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.43 and 1.49

version 1.43, 2015/08/17 05:18:35

version 1.49, 2022/03/28 09:12:38

Line 1

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

/* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.42 2015/08/13 00:49:57 noro Exp $ */

/* $OpenXM: OpenXM/src/ox_toolkit/ox.c,v 1.48 2016/06/30 01:14:00 ohara Exp $ */

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

Some commnets is written in Japanese by the EUC-JP coded

character set.

#include <stdio.h>

#include <stdlib.h>

#include <stdarg.h>

#include <string.h>

#include <unistd.h>

#include <fcntl.h>

#include <sys/file.h>

#include <time.h>

#include <limits.h>

#if !defined(_MSC_VER)

#include <unistd.h>

#include <sys/file.h>

#endif

#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 RAT_CEIL(nm,dn) (((nm)+(dn)-1)/((dn)))

#define MPFR_LIMB_SIZE(x) (MPFR_LAST_LIMB (x) + 1)

#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;

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

Line 72 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) */

Line 177 static cmo_int32* receive_cmo_int32(OXFILE *oxfp)

Line 181 static cmo_int32* receive_cmo_int32(OXFILE *oxfp)

static cmo_string* receive_cmo_string(OXFILE *oxfp)

{

int i,n;

int len = receive_int32(oxfp);

char* s = MALLOC(len+1);

memset(s, '\0', len+1);

if (len > 0) {

for(i=0; i<len; i+=n) {

oxf_read(s, 1, len, oxfp);

n=oxf_read(s+i, 1, len-i, oxfp);

}

return new_cmo_string(s);

}

Line 244 static cmo_bf* receive_cmo_bf(OXFILE *oxfp)

Line 249 static cmo_bf* receive_cmo_bf(OXFILE *oxfp)

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

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

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

case CMO_QQ:

m = (cmo *)receive_cmo_qq(oxfp);

break;

case CMO_BIGFLOAT:

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;

Line 656 static int send_cmo_bf(OXFILE *oxfp, cmo_bf* c)

Line 674 static int send_cmo_bf(OXFILE *oxfp, cmo_bf* c)

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

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

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

case CMO_QQ:

send_cmo_qq(oxfp, (cmo_qq *)c);

break;

case CMO_BIGFLOAT:

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;

Line 775 int send_int64(OXFILE *oxfp,UL64 a)

Line 803 int send_int64(OXFILE *oxfp,UL64 a)

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;

int sgn,prec,exp,len_r,len,i;

unsigned int hi,lo;

unsigned int *ptr;

unsigned long *ptr;

L64 exp;

sgn = receive_int32(oxfp);

prec = receive_int32(oxfp);

sgn = receive_int32(oxfp);

exp = receive_int64(oxfp);

exp = receive_int32(oxfp);

/* len = length as an int array (int = 4bytes) */

len = receive_int32(oxfp);

mpfr_init2(mpfr,prec); /* initialized by NaN */

MPFR_SIGN(mpfr) = sgn;

mpfr_init2(mpfr,prec);

MPFR_EXP(mpfr) = exp;

MPFR_SIGN(mpfr) = sgn;

*(MPFR_MANT(mpfr))=0; /* initialized by 0 */

ptr = mpfr->_mpfr_d;

ptr = (unsigned int *)MPFR_MANT(mpfr);

mpfr->_mpfr_exp = exp;

len_r = MPFR_LIMB_SIZE_REAL(mpfr);

#if SIZEOF_LONG==4

for(i=(len_r-len); i<len_r; i++) {

for ( i = 0; i < len; i++ )

ptr[i] = receive_int32(oxfp);

}

#else

if ( len%2 ) {

hi = receive_int32(oxfp);

ptr[0] = (((UL64)hi)<<32);

i = 1;

} else

i = 0;

len = (len+1)/2;

for ( ; i < len; i ++ ) {

lo = (unsigned int)receive_int32(oxfp);

hi = (unsigned int)receive_int32(oxfp);

ptr[i] = (((UL64)hi)<<32)|((UL64)lo);

}

#endif

}

static int send_mpfr(OXFILE *oxfp, mpfr_ptr mpfr)

{

int i,len_r,len;

unsigned int *ptr;

int i,len,t;

send_int32(oxfp, MPFR_PREC(mpfr));

unsigned long *ptr;

send_int32(oxfp, MPFR_SIGN(mpfr));

UL64 uexp;

send_int32(oxfp, MPFR_EXP(mpfr));

len_r = MPFR_LIMB_SIZE_REAL(mpfr);

send_int32(oxfp, MPFR_SIGN(mpfr));

len = MPFR_LIMB_SIZE_BODY(mpfr);

send_int32(oxfp, MPFR_PREC(mpfr));

ptr = (unsigned int *)MPFR_MANT(mpfr);

send_int64(oxfp, MPFR_EXP(mpfr));

send_int32(oxfp, len);

len = MPFR_LIMB_SIZE(mpfr);

for(i=(len_r-len); i<len_r; i++) {

ptr = MPFR_MANT(mpfr);

send_int32(oxfp, ptr[i]);

#if SIZEOF_LONG==4

}

send_int32(oxfp, len);

for ( i = 0; i < len; i++ )

send_int32(oxfp,ptr[i]);

#else /* SIZEOF_LONG==8 */

t = (MPFR_PREC(mpfr)+31)/32;

send_int32(oxfp, t);

if ( t%2 ) {

send_int32(oxfp,(unsigned int)(ptr[0]>>32));

i = 1;

} else

i = 0;

t = (t+1)/2;

for ( ; i < len; i++ ) {

send_int32(oxfp,(unsigned int)(ptr[i]&0xffffffff));

send_int32(oxfp,(unsigned int)(ptr[i]>>32));

}

#endif

return 0;

}

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