OpenXM/src/ox_toolkit/ox.c - diff

Return to ox.c CVS log

Up to [local] / OpenXM / src / ox_toolkit

Diff for /OpenXM/src/ox_toolkit/ox.c between version 1.28 and 1.41

version 1.28, 2003/09/18 12:46:08

version 1.41, 2015/08/05 00:59:05

Line 1

/* -*- mode: C; coding: euc-japan -*- */

/* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.27 2003/09/15 09:31:41 ohara Exp $ */

/* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.40 2015/08/04 10:19:31 noro Exp $ */

This module includes functions for sending/receiveng CMO's.

Line 16

#include <sys/file.h>

#include <time.h>

#include <mpfr.h>

/* 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"

Line 35 static cmo_ring_by_name* receive_cmo_ring_by_name(OXFI

Line 51 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);

Line 43 static int send_cmo_string(OXFILE *oxfp, cmo_

Line 60 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);

Line 52 static cmo_zz* receive_cmo_zz(OXFILE *oxfp);

Line 70 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;

Line 116 int receive_int32(OXFILE *oxfp)

Line 136 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)

{

Line 194 static cmo_zz* receive_cmo_zz(OXFILE *oxfp)

Line 226 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();

Line 250 static cmo_polynomial_in_one_variable* receive_cmo_pol

Line 300 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);

return new_cmo_indeterminate(ob);

}

static cmo_tree* receive_cmo_tree(OXFILE *oxfp)

{

cmo_string* name = (cmo_string *)receive_cmo(oxfp);

Line 303 cmo *receive_cmo_tag(OXFILE *oxfp, int tag)

Line 365 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;

Line 321 cmo *receive_cmo_tag(OXFILE *oxfp, int tag)

Line 389 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;

case CMO_TREE:

m = (cmo *)receive_cmo_tree(oxfp);

break;

Line 331 cmo *receive_cmo_tag(OXFILE *oxfp, int tag)

Line 406 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);

Line 342 cmo *receive_cmo_tag(OXFILE *oxfp, int tag)

Line 416 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<len; i++) {

mpz->_mp_d[i] = receive_int32(oxfp);

ptr[i] = receive_int32(oxfp);

}

Line 537 static int send_cmo_polynomial_in_one_variable(OXFILE

Line 620 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;

Line 555 static int send_cmo_zz(OXFILE *oxfp, cmo_zz* c)

Line 643 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, (cmo *)c->ringdef);

Line 618 void send_cmo(OXFILE *oxfp, cmo* c)

Line 719 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;

Line 627 void send_cmo(OXFILE *oxfp, cmo* c)

Line 734 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;

Line 641 void send_cmo(OXFILE *oxfp, cmo* c)

Line 752 void send_cmo(OXFILE *oxfp, cmo* c)

static int send_mpz(OXFILE *oxfp, mpz_ptr mpz)

{

int i;

int len = abs(mpz->_mp_size);

int n = sizeof(mpz->_mp_d[0]) / sizeof(int);

send_int32(oxfp, mpz->_mp_size);

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<len; i++) {

send_int32(oxfp, mpz->_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,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;

}

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>