OpenXM_contrib2/asir2000/engine/init.c - diff

Return to init.c CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / engine

Diff for /OpenXM_contrib2/asir2000/engine/init.c between version 1.7 and 1.27

version 1.7, 2000/12/22 10:03:28

version 1.27, 2007/01/25 16:19:41

Line 45

* DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,

* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.

* $OpenXM: OpenXM_contrib2/asir2000/engine/init.c,v 1.6 2000/12/11 02:00:41 noro Exp $

* $OpenXM: OpenXM_contrib2/asir2000/engine/init.c,v 1.26 2006/02/25 06:33:31 noro Exp $

#include "ca.h"

#include "version.h"

#include "prime.h"

struct oN oUNIN,oTWON,oTHREEN,oFOURN,oFIVEN,oSIXN,oSEVENN,oEIGHTN;

struct oQ oUNIQ,oTWOQ,oTHREEQ,oFOURQ,oFIVEQ,oSIXQ,oSEVENQ,oEIGHTQ;

Line 82 USINT VOIDobj = &oVOID;

Line 83 USINT VOIDobj = &oVOID;

int bigfloat;

int nez = 1;

int current_mod = 0;

int StrassenSize = 0;

int outputstyle = 0;

int Itvplot = 33;

#if PARI

static int *lprime;

static int lprime_size;

#if defined(PARI)

int paristack = 1<<16;

#define ADDBF addbf

#define SUBBF subbf

#define MULBF mulbf

#define DIVBF divbf

#define PWRBF pwrbf

#define CHSGNBF chsgnbf

#define CMPBF cmpbf

# else

#define ADDBF 0

#define SUBBF 0

#define MULBF 0

#define DIVBF 0

#define PWRBF 0

#define CHSGNBF 0

#define CMPBF 0

#endif

#if defined(INTERVAL)

int zerorewrite = 0;

void (*addnumt[])() = { addq, addreal, addalg, addbf, additvp, additvd, 0, additvf, addcplx, addmi, addlm, addgf2n, addgfpn };

void (*addnumt[])() = { addq, addreal, addalg, ADDBF, 0, additvp, additvd, 0, additvf, addcplx, addmi, addlm, addgf2n, addgfpn, addgfs, addgfsn, adddalg };

void (*subnumt[])() = { subq, subreal, subalg, subbf, subitvp, subitvd, 0, subitvf, subcplx, submi, sublm, subgf2n, subgfpn };

void (*subnumt[])() = { subq, subreal, subalg, SUBBF, 0, subitvp, subitvd, 0, subitvf, subcplx, submi, sublm, subgf2n, subgfpn, subgfs, subgfsn, subdalg };

void (*mulnumt[])() = { mulq, mulreal, mulalg, mulbf, mulitvp, mulitvd, 0, mulitvf, mulcplx, mulmi, mullm, mulgf2n, mulgfpn };

void (*mulnumt[])() = { mulq, mulreal, mulalg, MULBF, 0, mulitvp, mulitvd, 0, mulitvf, mulcplx, mulmi, mullm, mulgf2n, mulgfpn, mulgfs, mulgfsn, muldalg };

void (*divnumt[])() = { divq, divreal, divalg, divbf, divitvp, divitvd, 0, divitvf, divcplx, divmi, divlm, divgf2n, divgfpn };

void (*divnumt[])() = { divq, divreal, divalg, DIVBF, 0, divitvp, divitvd, 0, divitvf, divcplx, divmi, divlm, divgf2n, divgfpn, divgfs, divgfsn, divdalg };

void (*pwrnumt[])() = { pwrq, pwrreal, pwralg, pwrbf, pwritvp, pwritvd, 0, pwritvf, pwrcplx, pwrmi, pwrlm, pwrgf2n, pwrgfpn };

void (*pwrnumt[])() = { pwrq, pwrreal, pwralg, PWRBF, 0, pwritvp, pwritvd, 0, pwritvf, pwrcplx, pwrmi, pwrlm, pwrgf2n, pwrgfpn, pwrgfs, pwrgfsn, pwrdalg };

void (*chsgnnumt[])() = { chsgnq, chsgnreal, chsgnalg, chsgnbf, chsgnitvp, chsgnitvd, 0, chsgnitvf, chsgncplx, chsgnmi, chsgnlm, chsgngf2n, chsgngfpn };

void (*chsgnnumt[])() = { chsgnq, chsgnreal, chsgnalg, CHSGNBF, 0, chsgnitvp, chsgnitvd, 0, chsgnitvf, chsgncplx, chsgnmi, chsgnlm, chsgngf2n, chsgngfpn, chsgngfs , chsgngfsn, chsgndalg};

int (*cmpnumt[])() = { cmpq, cmpreal, cmpalg, cmpbf, cmpitvp, cmpitvd, 0, cmpitvf, cmpcplx, cmpmi, cmplm, cmpgf2n, cmpgfpn };

int (*cmpnumt[])() = { cmpq, cmpreal, cmpalg, CMPBF, 0, cmpitvp, cmpitvd, 0, cmpitvf, cmpcplx, cmpmi, cmplm, cmpgf2n, cmpgfpn, cmpgfs, cmpgfsn, cmpdalg };

#else

void (*addnumt[])() = { addq, addreal, addalg, addbf, addcplx, addmi, addlm, addgf2n, addgfpn };

void (*addnumt[])() = { addq, addreal, addalg, ADDBF, addcplx, addmi, addlm, addgf2n, addgfpn, addgfs, addgfsn, adddalg };

void (*subnumt[])() = { subq, subreal, subalg, subbf, subcplx, submi, sublm, subgf2n, subgfpn };

void (*subnumt[])() = { subq, subreal, subalg, SUBBF, subcplx, submi, sublm, subgf2n, subgfpn, subgfs, subgfsn, subdalg };

void (*mulnumt[])() = { mulq, mulreal, mulalg, mulbf, mulcplx, mulmi, mullm, mulgf2n, mulgfpn };

void (*mulnumt[])() = { mulq, mulreal, mulalg, MULBF, mulcplx, mulmi, mullm, mulgf2n, mulgfpn, mulgfs, mulgfsn, muldalg };

void (*divnumt[])() = { divq, divreal, divalg, divbf, divcplx, divmi, divlm, divgf2n, divgfpn };

void (*divnumt[])() = { divq, divreal, divalg, DIVBF, divcplx, divmi, divlm, divgf2n, divgfpn, divgfs, divgfsn, divdalg };

void (*pwrnumt[])() = { pwrq, pwrreal, pwralg, pwrbf, pwrcplx, pwrmi, pwrlm, pwrgf2n, pwrgfpn };

void (*pwrnumt[])() = { pwrq, pwrreal, pwralg, PWRBF, pwrcplx, pwrmi, pwrlm, pwrgf2n, pwrgfpn, pwrgfs, pwrgfsn, pwrdalg };

void (*chsgnnumt[])() = { chsgnq, chsgnreal, chsgnalg, chsgnbf, chsgncplx, chsgnmi, chsgnlm, chsgngf2n, chsgngfpn };

void (*chsgnnumt[])() = { chsgnq, chsgnreal, chsgnalg, CHSGNBF, chsgncplx, chsgnmi, chsgnlm, chsgngf2n, chsgngfpn, chsgngfs, chsgngfsn, chsgndalg };

int (*cmpnumt[])() = { cmpq, cmpreal, cmpalg, cmpbf, cmpcplx, cmpmi, cmplm, cmpgf2n, cmpgfpn };

int (*cmpnumt[])() = { cmpq, cmpreal, cmpalg, CMPBF, cmpcplx, cmpmi, cmplm, cmpgf2n, cmpgfpn, cmpgfs, cmpgfsn, cmpdalg };

#endif

#else

#if defined(INTERVAL)

void (*addnumt[])() = { addq, addreal, addalg, 0, additvp, additvd, 0, additvf, addcplx, addmi, addlm, addgf2n, addgfpn };

void (*subnumt[])() = { subq, subreal, subalg, 0, subitvp, subitvd, 0, subitvf, subcplx, submi, sublm, subgf2n, subgfpn };

void (*mulnumt[])() = { mulq, mulreal, mulalg, 0, mulitvp, mulitvd, 0, mulitvf, mulcplx, mulmi, mullm, mulgf2n, mulgfpn };

void (*divnumt[])() = { divq, divreal, divalg, 0, divitvp, divitvd, 0, divitvf, divcplx, divmi, divlm, divgf2n, divgfpn };

void (*pwrnumt[])() = { pwrq, pwrreal, pwralg, 0, pwritvp, pwritvd, 0, pwritvf, pwrcplx, pwrmi, pwrlm, pwrgf2n, pwrgfpn };

void (*chsgnnumt[])() = { chsgnq, chsgnreal, chsgnalg, 0, chsgnitvp, chsgnitvd, 0, chsgnitvf, chsgncplx, chsgnmi, chsgnlm, chsgngf2n, chsgngfpn };

int (*cmpnumt[])() = { cmpq, cmpreal, cmpalg, 0, cmpitvp, cmpitvd, 0, cmpitvf, cmpcplx, cmpmi, cmplm, cmpgf2n, cmpgfpn };

#else

void (*addnumt[])() = { addq, addreal, addalg, 0, addcplx, addmi, addlm, addgf2n, addgfpn };

void (*subnumt[])() = { subq, subreal, subalg, 0, subcplx, submi, sublm, subgf2n, subgfpn };

void (*mulnumt[])() = { mulq, mulreal, mulalg, 0, mulcplx, mulmi, mullm, mulgf2n, mulgfpn };

void (*divnumt[])() = { divq, divreal, divalg, 0, divcplx, divmi, divlm, divgf2n,divgfpn };

void (*pwrnumt[])() = { pwrq, pwrreal, pwralg, 0, pwrcplx, pwrmi, pwrlm, pwrgf2n, pwrgfpn };

void (*chsgnnumt[])() = { chsgnq, chsgnreal, chsgnalg, 0, chsgncplx, chsgnmi, chsgnlm, chsgngf2n, chsgngfpn };

int (*cmpnumt[])() = { cmpq, cmpreal, cmpalg, 0, cmpcplx, cmpmi, cmplm, cmpgf2n, cmpgfpn };

#endif

double get_current_time();

void init_lprime();

void nglob_init() {

PL(&oUNIN) = 1; BD(&oUNIN)[0] = 1;

Line 175 void nglob_init() {

Line 180 void nglob_init() {

/* moved to parse/main.c */

#if 0

#if PARI

#if defined(PARI)

risa_pari_init();

#endif

srandom((int)get_current_time());

#endif

init_up2_tab();

init_lprime();

}

extern double gctime;

double suspend_start;

double suspended_time=0;

void get_eg(p)

void get_eg(struct oEGT *p)

struct oEGT *p;

{

p->exectime = get_clock() - gctime - suspended_time; p->gctime = gctime;

}

void init_eg(eg)

void init_eg(struct oEGT *eg)

struct oEGT *eg;

{

bzero((char *)eg,sizeof(struct oEGT));

}

void add_eg(base,start,end)

void add_eg(struct oEGT *base,struct oEGT *start,struct oEGT *end)

struct oEGT *base,*start,*end;

{

base->exectime += end->exectime - start->exectime;

base->gctime += end->gctime - start->gctime;

}

void print_eg(item,eg)

void print_eg(char *item,struct oEGT *eg)

char *item;

struct oEGT *eg;

{

printf("%s=(%.4g,%.4g)",item,eg->exectime,eg->gctime);

}

void print_split_eg(start,end)

void print_split_eg(struct oEGT *start,struct oEGT *end)

struct oEGT *start,*end;

{

struct oEGT base;

Line 222 struct oEGT *start,*end;

Line 223 struct oEGT *start,*end;

printf("(%.4g,%.4g)",base.exectime,base.gctime);

}

void print_split_e(start,end)

void print_split_e(struct oEGT *start,struct oEGT *end)

struct oEGT *start,*end;

{

struct oEGT base;

Line 242 void resume_timer() {

extern int lm_lazy, up_lazy;

extern int GC_dont_gc;

extern int do_weyl;

extern int dp_fcoeffs;

void reset_engine() {

lm_lazy = 0; up_lazy = 0;

lm_lazy = 0;

up_lazy = 0;

do_weyl = 0;

dp_fcoeffs = 0;

GC_dont_gc = 0;

}

Line 253 unsigned int get_asir_version() {

Line 256 unsigned int get_asir_version() {

return ASIR_VERSION;

}

void create_error(ERR *err,unsigned int serial,char *msg)

char *get_asir_distribution() {

return ASIR_DISTRIBUTION;

}

void create_error(ERR *err,unsigned int serial,char *msg,LIST trace)

{

int len;

USINT ui;

USINT ui,notsupp;

NODE n,n1;

LIST list;

char *msg1;

STRING errmsg;

MKUSINT(ui,serial);

MKUSINT(notsupp,-1);

len = strlen(msg);

msg1 = (char *)MALLOC(len+1);

strcpy(msg1,msg);

MKSTR(errmsg,msg1);

MKNODE(n1,errmsg,0); MKNODE(n,ui,n1); MKLIST(list,n);

if ( !trace )

MKLIST(trace,0);

n = mknode(4,ui,notsupp,errmsg,trace); MKLIST(list,n);

MKERR(*err,list);

}

void init_lprime()

{

int s,i;

s = sizeof(lprime_init);

lprime = (int *)GC_malloc_atomic(s);

lprime_size = s/sizeof(int);

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

lprime[i] = lprime_init[lprime_size-i-1];

}

void create_new_lprimes(int);

int get_lprime(index)

{

if ( index >= lprime_size )

create_new_lprimes(index);

return lprime[index];

}

void create_new_lprimes(int index)

{

int count,p,i,j,d;

if ( index < lprime_size )

return;

count = index-lprime_size+1;

if ( count < 256 )

count = 256;

lprime = (int *)GC_realloc(lprime,(lprime_size+count)*sizeof(int));

p = lprime[lprime_size-1]+2;

for ( i = 0; i < count; p += 2 ) {

for ( j = 0; d = sprime[j]; j++ ) {

if ( d*d > p ) {

lprime[i+lprime_size] = p;

i++;

break;

}

if ( !(p%d) )

break;

}

lprime_size += count;

}

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