=================================================================== RCS file: /home/cvs/OpenXM/src/ox_toolkit/ox.c,v retrieving revision 1.31 retrieving revision 1.47 diff -u -p -r1.31 -r1.47 --- OpenXM/src/ox_toolkit/ox.c 2003/11/12 15:24:06 1.31 +++ OpenXM/src/ox_toolkit/ox.c 2016/06/29 05:07:23 1.47 @@ -1,5 +1,5 @@ /* -*- mode: C; coding: euc-japan -*- */ -/* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.30 2003/11/09 01:48:01 iwane Exp $ */ +/* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.46 2016/06/28 11:59:15 ohara Exp $ */ /* This module includes functions for sending/receiveng CMO's. @@ -11,11 +11,31 @@ #include #include #include -#include #include -#include #include +#include +#if !defined(_MSC_VER) +#include +#include +#endif +#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 RAT_CEIL(nm,dn) (((nm)+(dn)-1)/((dn))) +#define MPFR_LIMB_SIZE_REAL(x) (RAT_CEIL(MPFR_PREC((x)),sizeof(mp_limb_t)*CHAR_BIT) * (sizeof(mp_limb_t)/sizeof(int)) ) +#define MPFR_LIMB_SIZE_BODY(x) (RAT_CEIL(MPFR_PREC((x)),sizeof(unsigned int)*CHAR_BIT)) + +#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 +55,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 +64,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 +74,10 @@ 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 cmo_bf* receive_cmo_bf(OXFILE *oxfp); +static void receive_mpfr(OXFILE *oxfp, mpfr_ptr mpfr); +static int send_cmo_bf(OXFILE *oxfp, cmo_bf* c); +static int send_mpfr(OXFILE *oxfp, mpfr_ptr mpfr); /* hook functions. (yet not implemented) */ static hook_t hook_before_send_cmo = NULL; @@ -116,6 +142,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 +232,34 @@ 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_complex* receive_cmo_complex(OXFILE *oxfp) +{ + cmo *re, *im; + + re = receive_cmo(oxfp); + im = receive_cmo(oxfp); + return new_cmo_complex_set_re_im(re,im); +} + + static cmo_zero* receive_cmo_zero(OXFILE *oxfp) { return new_cmo_zero(); @@ -250,6 +316,12 @@ static cmo_polynomial_in_one_variable* receive_cmo_pol 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); @@ -309,6 +381,15 @@ 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_BIGFLOAT32: + m = (cmo *)receive_cmo_bf(oxfp); + break; + case CMO_COMPLEX: + m = (cmo *)receive_cmo_complex(oxfp); + break; case CMO_ZERO: m = (cmo *)receive_cmo_zero(oxfp); break; @@ -327,6 +408,10 @@ cmo *receive_cmo_tag(OXFILE *oxfp, int tag) 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; @@ -340,7 +425,6 @@ cmo *receive_cmo_tag(OXFILE *oxfp, int tag) 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); @@ -351,12 +435,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); } } @@ -546,6 +639,11 @@ static int send_cmo_polynomial_in_one_variable(OXFILE 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; @@ -564,6 +662,26 @@ 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_complex(OXFILE *oxfp, cmo_complex* c) +{ + send_cmo(oxfp, c->re); + send_cmo(oxfp, c->im); + return 0; +} + static int send_cmo_recursive_polynomial(OXFILE *oxfp, cmo_recursive_polynomial* c) { send_cmo(oxfp, (cmo *)c->ringdef); @@ -627,6 +745,15 @@ 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_BIGFLOAT32: + send_cmo_bf(oxfp, (cmo_bf *)c); + break; + case CMO_COMPLEX: + send_cmo_complex(oxfp, (cmo_complex *)c); + break; case CMO_DISTRIBUTED_POLYNOMIAL: send_cmo_distributed_polynomial(oxfp, (cmo_distributed_polynomial *)c); break; @@ -636,6 +763,10 @@ 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; @@ -650,10 +781,66 @@ 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; +} + +int send_int64(OXFILE *oxfp,UL64 a) +{ + return oxfp->send_double(oxfp,((double *)&a)[0]); +} + +UL64 receive_int64(OXFILE *oxfp) +{ + double d = receive_double(oxfp); + return ((UL64 *)&d)[0]; +} + +static void receive_mpfr(OXFILE *oxfp, mpfr_ptr mpfr) +{ + int sgn,prec,exp,len_r,len,i; + unsigned int *ptr; + + prec = receive_int32(oxfp); + sgn = receive_int32(oxfp); + exp = receive_int32(oxfp); + len = receive_int32(oxfp); + mpfr_init2(mpfr,prec); /* initialized by NaN */ + MPFR_SIGN(mpfr) = sgn; + MPFR_EXP(mpfr) = exp; + *(MPFR_MANT(mpfr))=0; /* initialized by 0 */ + ptr = (unsigned int *)MPFR_MANT(mpfr); + len_r = MPFR_LIMB_SIZE_REAL(mpfr); + for(i=(len_r-len); i