=================================================================== RCS file: /home/cvs/OpenXM/src/ox_toolkit/ox.c,v retrieving revision 1.26 retrieving revision 1.39 diff -u -p -r1.26 -r1.39 --- OpenXM/src/ox_toolkit/ox.c 2003/08/21 12:44:06 1.26 +++ OpenXM/src/ox_toolkit/ox.c 2015/08/04 07:41:49 1.39 @@ -1,5 +1,5 @@ /* -*- mode: C; coding: euc-japan -*- */ -/* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.25 2003/06/02 10:25:56 ohara Exp $ */ +/* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.38 2015/08/04 05:24:44 noro Exp $ */ /* This module includes functions for sending/receiveng CMO's. @@ -16,6 +16,22 @@ #include #include +#include +/* XXX : defined in mpfr-impl.h */ +#define MPFR_PREC(x) ((x)->_mpfr_prec) +#define MPFR_EXP(x) ((x)->_mpfr_exp) +#define MPFR_MANT(x) ((x)->_mpfr_d) +#define MPFR_LAST_LIMB(x) ((MPFR_PREC (x) - 1) / GMP_NUMB_BITS) +#define MPFR_LIMB_SIZE(x) (MPFR_LAST_LIMB (x) + 1) + +#if SIZEOF_LONG==4 +typedef long long L64; +typedef unsigned long long UL64; +#else +typedef long L64; +typedef unsigned long UL64; +#endif + #include "mysocket.h" #include "ox_toolkit.h" #include "parse.h" @@ -35,6 +51,7 @@ static cmo_ring_by_name* receive_cmo_ring_by_name(OXFI static cmo_distributed_polynomial* receive_cmo_distributed_polynomial(OXFILE *oxfp); static cmo_recursive_polynomial* receive_cmo_recursive_polynomial(OXFILE *oxfp); static cmo_polynomial_in_one_variable* receive_cmo_polynomial_in_one_variable(OXFILE *oxfp); +static cmo_double* receive_cmo_double(OXFILE *oxfp); static cmo_error2* receive_cmo_error2(OXFILE *oxfp); static int send_cmo_null(OXFILE *oxfp, cmo_null* c); @@ -43,6 +60,7 @@ static int send_cmo_string(OXFILE *oxfp, cmo_ static int send_cmo_mathcap(OXFILE *oxfp, cmo_mathcap* c); static int send_cmo_list(OXFILE *oxfp, cmo_list* c); static int send_cmo_monomial32(OXFILE *oxfp, cmo_monomial32* c); +static int send_cmo_double(OXFILE *oxfp, cmo_double* c); static int send_cmo_error2(OXFILE *oxfp, cmo_error2* c); static int send_cmo_distributed_polynomial(OXFILE *oxfp, cmo_distributed_polynomial* c); static int send_cmo_polynomial_in_one_variable(OXFILE *oxfp, cmo_polynomial_in_one_variable* c); @@ -52,6 +70,8 @@ static cmo_zz* receive_cmo_zz(OXFILE *oxfp); static void receive_mpz(OXFILE *oxfp, mpz_ptr mpz); static int send_cmo_zz(OXFILE *oxfp, cmo_zz* c); static int send_mpz(OXFILE *oxfp, mpz_ptr mpz); +static void receive_mpfr(OXFILE *oxfp, mpfr_ptr mpfr); +static int send_mpfr(OXFILE *oxfp, mpfr_ptr mpfr); /* hook functions. (yet not implemented) */ static hook_t hook_before_send_cmo = NULL; @@ -116,6 +136,18 @@ int receive_int32(OXFILE *oxfp) return oxfp->receive_int32(oxfp); } +/* sending an object of int32 type. (not equal to cmo_int32 type) */ +int send_double(OXFILE *oxfp, double d) +{ + return oxfp->send_double(oxfp, d); +} + +/* receiving an object of int32 type. (not equal to cmo_int32 type) */ +double receive_double(OXFILE *oxfp) +{ + return oxfp->receive_double(oxfp); +} + /* receiving an (OX_tag, serial number) */ int receive_ox_tag(OXFILE *oxfp) { @@ -194,6 +226,24 @@ static cmo_zz* receive_cmo_zz(OXFILE *oxfp) return c; } +static cmo_qq* receive_cmo_qq(OXFILE *oxfp) +{ + mpz_t num, den; + mpz_init(num); + mpz_init(den); + receive_mpz(oxfp, num); + receive_mpz(oxfp, den); + return new_cmo_qq_set_mpz(num, den); +} + +static cmo_bf* receive_cmo_bf(OXFILE *oxfp) +{ + mpfr_t num; + mpfr_init(num); + receive_mpfr(oxfp, num); + return new_cmo_bf_set_mpfr(num); +} + static cmo_zero* receive_cmo_zero(OXFILE *oxfp) { return new_cmo_zero(); @@ -213,8 +263,8 @@ static cmo_ring_by_name* receive_cmo_ring_by_name(OXFI static cmo_recursive_polynomial* receive_cmo_recursive_polynomial(OXFILE *oxfp) { - cmo* ringdef = receive_cmo(oxfp); - cmo* coef = receive_cmo(oxfp); + cmo_list* ringdef = (cmo_list *)receive_cmo(oxfp); + cmo* coef = receive_cmo(oxfp); return new_cmo_recursive_polynomial(ringdef, coef); } @@ -244,12 +294,39 @@ static cmo_polynomial_in_one_variable* receive_cmo_pol while (len>0) { exp = receive_int32(oxfp); coef = receive_cmo(oxfp); - list_append_monomial(c, coef, exp); + list_append_monomial((cmo_list *)c, coef, exp); len--; } return c; } +static cmo_double* receive_cmo_double(OXFILE *oxfp) +{ + double d = receive_double(oxfp); + return new_cmo_double(d); +} + +static cmo_indeterminate* receive_cmo_indeterminate(OXFILE *oxfp) +{ + cmo* ob = receive_cmo(oxfp); + return new_cmo_indeterminate(ob); +} + +static cmo_tree* receive_cmo_tree(OXFILE *oxfp) +{ + cmo_string* name = (cmo_string *)receive_cmo(oxfp); + cmo_list* attrib = (cmo_list *)receive_cmo(oxfp); + cmo_list* leaves = (cmo_list *)receive_cmo(oxfp); + return new_cmo_tree(name, attrib, leaves); +} + +static cmo_lambda* receive_cmo_lambda(OXFILE *oxfp) +{ + cmo_list* args = (cmo_list *)receive_cmo(oxfp); + cmo_tree* body = (cmo_tree *)receive_cmo(oxfp); + return new_cmo_lambda(args, body); +} + static cmo_error2* receive_cmo_error2(OXFILE *oxfp) { cmo* ob = receive_cmo(oxfp); @@ -288,6 +365,12 @@ cmo *receive_cmo_tag(OXFILE *oxfp, int tag) case CMO_ZZ: m = (cmo *)receive_cmo_zz(oxfp); break; + case CMO_QQ: + m = (cmo *)receive_cmo_qq(oxfp); + break; + case CMO_BIGFLOAT: + m = (cmo *)receive_cmo_bf(oxfp); + break; case CMO_ZERO: m = (cmo *)receive_cmo_zero(oxfp); break; @@ -305,11 +388,24 @@ cmo *receive_cmo_tag(OXFILE *oxfp, int tag) break; case CMO_POLYNOMIAL_IN_ONE_VARIABLE: m = (cmo *)receive_cmo_polynomial_in_one_variable(oxfp); + break; + case CMO_64BIT_MACHINE_DOUBLE: + case CMO_IEEE_DOUBLE_FLOAT: + m = (cmo *)receive_cmo_double(oxfp); + break; + case CMO_INDETERMINATE: + m = (cmo *)receive_cmo_indeterminate(oxfp); + break; + case CMO_TREE: + m = (cmo *)receive_cmo_tree(oxfp); + break; + case CMO_LAMBDA: + m = (cmo *)receive_cmo_lambda(oxfp); + break; case CMO_ERROR2: m = (cmo *)receive_cmo_error2(oxfp); break; case CMO_DATUM: - case CMO_QQ: default: m = NULL; ox_printf("the CMO (%d) is not implemented.\n", tag); @@ -320,12 +416,21 @@ cmo *receive_cmo_tag(OXFILE *oxfp, int tag) static void receive_mpz(OXFILE *oxfp, mpz_ptr mpz) { int i; + int n = sizeof(mpz->_mp_d[0]) / sizeof(int); int size = receive_int32(oxfp); int len = abs(size); - resize_mpz(mpz, size); + int *ptr; + if (n == 1) { + resize_mpz(mpz, size); + } else if (size >= 0) { + resize_mpz(mpz, (size+1) / n); + } else { + resize_mpz(mpz, (size-1) / n); + } + ptr = (int *)mpz->_mp_d; for(i=0; i_mp_d[i] = receive_int32(oxfp); + ptr[i] = receive_int32(oxfp); } } @@ -502,19 +607,24 @@ static int send_cmo_distributed_polynomial(OXFILE *oxf static int send_cmo_polynomial_in_one_variable(OXFILE *oxfp, cmo_polynomial_in_one_variable* c) { - cell* el = list_first(c); - int len = list_length(c); + cell* el = list_first((cmo_list *)c); + int len = list_length((cmo_list *)c); send_int32(oxfp, len); send_int32(oxfp, c->var); - while(!list_endof(c, el)) { - send_cmo(oxfp, el->exp); + while(!list_endof((cmo_list *)c, el)) { + send_int32(oxfp, el->exp); send_cmo(oxfp, el->cmo); el = list_next(el); } return 0; } +static int send_cmo_double(OXFILE *oxfp, cmo_double* c) +{ + return send_double(oxfp, c->d); +} + static int send_cmo_monomial32(OXFILE *oxfp, cmo_monomial32* c) { int i; @@ -533,13 +643,41 @@ static int send_cmo_zz(OXFILE *oxfp, cmo_zz* c) return 0; } +static int send_cmo_qq(OXFILE *oxfp, cmo_qq* c) +{ + send_mpz(oxfp, mpq_numref(c->mpq)); + send_mpz(oxfp, mpq_denref(c->mpq)); + return 0; +} + +static int send_cmo_bf(OXFILE *oxfp, cmo_bf* c) +{ + send_mpfr(oxfp, c->mpfr); + return 0; +} + static int send_cmo_recursive_polynomial(OXFILE *oxfp, cmo_recursive_polynomial* c) { - send_cmo(oxfp, c->ringdef); + send_cmo(oxfp, (cmo *)c->ringdef); send_cmo(oxfp, c->coef); return 0; } +static int send_cmo_tree(OXFILE *oxfp, cmo_tree *c) +{ + send_cmo(oxfp, (cmo *)c->name); + send_cmo(oxfp, (cmo *)c->attributes); + send_cmo(oxfp, (cmo *)c->leaves); + return 0; +} + +static int send_cmo_lambda(OXFILE *oxfp, cmo_lambda *c) +{ + send_cmo(oxfp, (cmo *)c->args); + send_cmo(oxfp, (cmo *)c->body); + return 0; +} + static int send_cmo_error2(OXFILE *oxfp, cmo_error2* c) { send_cmo(oxfp, c->ob); @@ -581,6 +719,12 @@ void send_cmo(OXFILE *oxfp, cmo* c) case CMO_ZZ: send_cmo_zz(oxfp, (cmo_zz *)c); break; + case CMO_QQ: + send_cmo_qq(oxfp, (cmo_qq *)c); + break; + case CMO_BIGFLOAT: + send_cmo_bf(oxfp, (cmo_bf *)c); + break; case CMO_DISTRIBUTED_POLYNOMIAL: send_cmo_distributed_polynomial(oxfp, (cmo_distributed_polynomial *)c); break; @@ -590,6 +734,16 @@ void send_cmo(OXFILE *oxfp, cmo* c) case CMO_POLYNOMIAL_IN_ONE_VARIABLE: send_cmo_polynomial_in_one_variable(oxfp, (cmo_polynomial_in_one_variable *)c); break; + case CMO_64BIT_MACHINE_DOUBLE: + case CMO_IEEE_DOUBLE_FLOAT: + send_cmo_double(oxfp, (cmo_double *)c); + break; + case CMO_TREE: + send_cmo_tree(oxfp, (cmo_tree *)c); + break; + case CMO_LAMBDA: + send_cmo_lambda(oxfp, (cmo_lambda *)c); + break; default: call_hook_after_send_cmo(oxfp, c); } @@ -598,14 +752,85 @@ void send_cmo(OXFILE *oxfp, cmo* c) static int send_mpz(OXFILE *oxfp, mpz_ptr mpz) { int i; - int len = abs(mpz->_mp_size); - send_int32(oxfp, mpz->_mp_size); + int n = sizeof(mpz->_mp_d[0]) / sizeof(int); + int len = abs(mpz->_mp_size) * n; + int *ptr = (int *)mpz->_mp_d; + int size; + if (len > 0 && ptr[len-1] == 0) { + len--; + } + size = mpz->_mp_size < 0 ? -len : len; + send_int32(oxfp, size); for(i=0; i_mp_d[i]); + send_int32(oxfp, ptr[i]); } return 0; } +void send_int64(OXFILE *oxfp,UL64 a) +{ + send_int32(oxfp, a>>32); + send_int32(oxfp, a&0xffffffff); +} + +UL64 receive_int64(OXFILE *oxfp) +{ + UL64 u,l; + + u = receive_int32(oxfp); + l = receive_int32(oxfp); + return (u<<32)|l; +} + +static void receive_mpfr(OXFILE *oxfp, mpfr_ptr mpfr) +{ + int sgn,prec,len,i; + long *ptr; + L64 exp; + + sgn = receive_int32(oxfp); + prec = receive_int32(oxfp); + exp = receive_int64(oxfp); + /* len = length as an int array (int = 4bytes) */ + len = receive_int32(oxfp); + + mpfr_init2(mpfr,prec); + MPFR_SIGN(mpfr) = sgn; + ptr = mpfr->_mpfr_d; + mpfr->_mpfr_exp = exp; +#if SIZEOF_LONG==4 + for ( i = 0; i < len; i++ ) + ptr[i] = receive_int32(oxfp); +#else + len >>= 1; + for ( i = 0; i < len; i++ ) + ptr[i] = receive_int64(oxfp); +#endif +} + +static int send_mpfr(OXFILE *oxfp, mpfr_ptr mpfr) +{ + + int i,len; + long *ptr; + + send_int32(oxfp, MPFR_SIGN(mpfr)); + send_int32(oxfp, MPFR_PREC(mpfr)); + send_int64(oxfp, MPFR_EXP(mpfr)); + len = MPFR_LIMB_SIZE(mpfr); + ptr = MPFR_MANT(mpfr); +#if SIZEOF_LONG==4 + send_int32(oxfp, len); + for ( i = 0; i < len; i++ ) + send_int32(oxfp,ptr[i]); +#else /* SIZEOF_LONG==8 */ + send_int32(oxfp, 2*len); + for ( i = 0; i < len; i++ ) + send_int64(oxfp,ptr[i]); +#endif + return 0; +} + ox_data* new_ox_data(cmo* c) { ox_data* m = MALLOC(sizeof(ox_data)); @@ -635,6 +860,7 @@ int ox_stderr_init(FILE *fp) if (ox_stderr != NULL) { setbuf(ox_stderr, NULL); } + return 0; } int ox_printf(char *format, ...) @@ -644,4 +870,5 @@ int ox_printf(char *format, ...) va_start(ap, format); vfprintf(ox_stderr, format, ap); } + return 0; }