OpenXM_contrib2/asir2000/engine/nd.c - diff

Return to nd.c CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / engine

Diff for /OpenXM_contrib2/asir2000/engine/nd.c between version 1.83 and 1.93

version 1.83, 2003/10/17 05:15:20

version 1.93, 2004/03/13 07:48:30

Line 1

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.82 2003/10/15 03:21:44 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.92 2004/03/13 07:43:24 noro Exp $ */

#include "ca.h"

#include "parse.h"

#include "ox.h"

#include "base.h"

#include "inline.h"

#include <time.h>

Line 117 typedef struct oIndArray

Line 118 typedef struct oIndArray

int (*ndl_compare_function)(UINT *a1,UINT *a2);

static int ndv_alloc;

#if 1

static int nd_f4_nsp=0x7fffffff;

#else

static int nd_f4_nsp=50;

#endif

static double nd_scale=2;

static UINT **nd_bound;

static struct order_spec *nd_ord;

Line 141 static int nd_psn,nd_pslen;

Line 146 static int nd_psn,nd_pslen;

static RHist *nd_red;

static int nd_found,nd_create,nd_notfirst;

static int nm_adv;

static int nmv_adv;

static int nd_dcomp;

static int nd_demand;

extern struct order_spec dp_current_spec;

extern struct order_spec *dp_current_spec;

extern char *Demand;

extern VL CO;

extern int Top,Reverse,DP_Print,dp_nelim,do_weyl,NoSugar;

Line 174 extern int *current_weyl_weight_vector;

Line 178 extern int *current_weyl_weight_vector;

#define GET_EXP_OLD(d,a) (((d)[oepos[a].i]>>oepos[a].s)&omask0)

#define PUT_EXP_OLD(r,a,e) ((r)[oepos[a].i] |= ((e)<<oepos[a].s))

#define ROUND_FOR_ALIGN(s) ((((s)+sizeof(void *)-1)/sizeof(void *))*sizeof(void *))

/* macros for term comparison */

#define TD_DL_COMPARE(d1,d2)\

(TD(d1)>TD(d2)?1:(TD(d1)<TD(d2)?-1:ndl_lex_compare(d1,d2)))

Line 1758 ND normalize_pbucket(int mod,PGeoBucket g)

Line 1764 ND normalize_pbucket(int mod,PGeoBucket g)

return r;

}

void do_diagonalize(int sugar,int m)

{

int i,nh,stat;

NODE r,g,t;

ND h,nf,s,head;

NDV nfv;

Q q,num,den;

union oNDC dn;

for ( i = nd_psn-1; i >= 0 && SG(nd_psh[i]) == sugar; i-- ) {

if ( nd_demand )

nfv = ndv_load(i);

else

nfv = nd_ps[i];

s = ndvtond(m,nfv);

s = nd_separate_head(s,&head);

nd_nf(m,s,nd_ps,1,&dn,&nf);

if ( !m ) {

NTOQ(NM(dn.z),SGN(dn.z),num);

mulq(HCQ(head),num,&q); HCQ(head) = q;

if ( DN(dn.z) ) {

NTOQ(DN(dn.z),1,den);

nd_mul_c_q(nf,den);

}

nf = nd_add(m,head,nf);

ndv_free(nfv);

nd_removecont(m,nf);

nfv = ndtondv(m,nf);

nd_free(nf);

nd_bound[i] = ndv_compute_bound(nfv);

if ( nd_demand ) {

ndv_save(nfv,i);

ndv_free(nfv);

} else

nd_ps[i] = nfv;

}

/* return value = 0 => input is not a GB */

NODE nd_gb(int m,int ishomo,int checkonly)

Line 1768 NODE nd_gb(int m,int ishomo,int checkonly)

Line 1813 NODE nd_gb(int m,int ishomo,int checkonly)

ND_pairs l;

ND h,nf,s,head;

NDV nfv;

Q q;

Q q,num,den;

union oNDC dn;

g = 0; d = 0;

Line 1781 NODE nd_gb(int m,int ishomo,int checkonly)

Line 1826 NODE nd_gb(int m,int ishomo,int checkonly)

again:

l = nd_minp(d,&d);

if ( SG(l) != sugar ) {

if ( ishomo ) {

if ( ishomo ) do_diagonalize(sugar,m);

for ( i = nd_psn-1; SG(nd_psh[i]) == sugar; i-- ) {

if ( nd_demand )

nfv = ndv_load(i);

else

nfv = nd_ps[i];

s = ndvtond(m,nfv);

s = nd_separate_head(s,&head);

nd_nf(m,s,nd_ps,1,&dn,&nf);

if ( !m ) { mulq(HCQ(head),dn.z,&q); HCQ(head) = q; }

nf = nd_add(m,head,nf);

ndv_free(nfv);

nd_removecont(m,nf);

nfv = ndtondv(m,nf);

nd_free(nf);

nd_bound[i] = ndv_compute_bound(nfv);

if ( nd_demand ) {

ndv_save(nfv,i);

ndv_free(nfv);

} else

nd_ps[i] = nfv;

}

sugar = SG(l);

if ( DP_Print ) fprintf(asir_out,"%d",sugar);

}

Line 1845 again:

Line 1869 again:

return g;

}

void do_diagonalize_trace(int sugar,int m)

{

int i,nh,stat;

NODE r,g,t;

ND h,nf,nfq,s,head;

NDV nfv,nfqv;

Q q,den,num;

union oNDC dn;

for ( i = nd_psn-1; i >= 0 && SG(nd_psh[i]) == sugar; i-- ) {

/* for nd_ps */

s = ndvtond(m,nd_ps[i]);

s = nd_separate_head(s,&head);

nd_nf_pbucket(m,s,nd_ps,1,&nf);

nf = nd_add(m,head,nf);

ndv_free(nd_ps[i]);

nd_ps[i] = ndtondv(m,nf);

nd_free(nf);

/* for nd_ps_trace */

if ( nd_demand )

nfv = ndv_load(i);

else

nfv = nd_ps_trace[i];

s = ndvtond(0,nfv);

s = nd_separate_head(s,&head);

nd_nf(0,s,nd_ps_trace,1,&dn,&nf);

NTOQ(NM(dn.z),SGN(dn.z),num);

mulq(HCQ(head),num,&q); HCQ(head) = q;

if ( DN(dn.z) ) {

NTOQ(DN(dn.z),1,den);

nd_mul_c_q(nf,den);

}

nf = nd_add(0,head,nf);

ndv_free(nfv);

nd_removecont(0,nf);

nfv = ndtondv(0,nf);

nd_free(nf);

nd_bound[i] = ndv_compute_bound(nfv);

if ( nd_demand ) {

ndv_save(nfv,i);

ndv_free(nfv);

} else

nd_ps_trace[i] = nfv;

}

NODE nd_gb_trace(int m,int ishomo)

{

int i,nh,sugar,stat;

Line 1853 NODE nd_gb_trace(int m,int ishomo)

Line 1924 NODE nd_gb_trace(int m,int ishomo)

ND_pairs l;

ND h,nf,nfq,s,head;

NDV nfv,nfqv;

Q q;

Q q,den,num;

union oNDC dn;

g = 0; d = 0;

Line 1866 NODE nd_gb_trace(int m,int ishomo)

Line 1937 NODE nd_gb_trace(int m,int ishomo)

again:

l = nd_minp(d,&d);

if ( SG(l) != sugar ) {

if ( ishomo ) {

if ( ishomo ) do_diagonalize_trace(sugar,m);

for ( i = nd_psn-1; SG(nd_psh[i]) == sugar; i-- ) {

/* for nd_ps */

s = ndvtond(m,nd_ps[i]);

s = nd_separate_head(s,&head);

nd_nf_pbucket(m,s,nd_ps,1,&nf);

nf = nd_add(m,head,nf);

ndv_free(nd_ps[i]);

nd_ps[i] = ndtondv(m,nf);

nd_free(nf);

/* for nd_ps_trace */

if ( nd_demand )

nfv = ndv_load(i);

else

nfv = nd_ps_trace[i];

s = ndvtond(0,nfv);

s = nd_separate_head(s,&head);

nd_nf(0,s,nd_ps_trace,1,&dn,&nf);

mulq(HCQ(head),dn.z,&q); HCQ(head) = q;

nf = nd_add(0,head,nf);

ndv_free(nfv);

nd_removecont(0,nf);

nfv = ndtondv(0,nf);

nd_free(nf);

nd_bound[i] = ndv_compute_bound(nfv);

if ( nd_demand ) {

ndv_save(nfv,i);

ndv_free(nfv);

} else

nd_ps_trace[i] = nfv;

}

sugar = SG(l);

if ( DP_Print ) fprintf(asir_out,"%d",sugar);

}

Line 1974 NODE ndv_reduceall(int m,NODE f)

Line 2013 NODE ndv_reduceall(int m,NODE f)

NODE t,a0,a;

union oNDC dn;

NDV *w;

Q q;

Q q,num,den;

n = length(f);

#if 0

Line 1993 NODE ndv_reduceall(int m,NODE f)

Line 2032 NODE ndv_reduceall(int m,NODE f)

nd_reconstruct(m,0,0);

else {

if ( DP_Print ) { printf("."); fflush(stdout); }

if ( !m ) { mulq(HCQ(head),dn.z,&q); HCQ(head) = q; }

if ( !m ) {

NTOQ(NM(dn.z),SGN(dn.z),num);

mulq(HCQ(head),num,&q); HCQ(head) = q;

if ( DN(dn.z) ) {

NTOQ(DN(dn.z),1,den);

nd_mul_c_q(nf,den);

}

nf = nd_add(m,head,nf);

ndv_free(nd_ps[i]);

nd_removecont(m,nf);

Line 2382 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

Line 2428 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

ndv_alloc = 0;

get_vars((Obj)f,&fv); pltovl(v,&vv);

for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ );

switch ( ord->id ) {

case 1:

if ( ord->nv != nvar )

error("nd_{gr,f4} : invalid order specification");

break;

default:

break;

}

nd_init_ord(ord);

for ( t = BDY(f), max = 0; t; t = NEXT(t) )

for ( tv = vv; tv; tv = NEXT(tv) ) {

Line 2414 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

Line 2468 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe

void nd_gr_trace(LIST f,LIST v,int trace,int homo,struct order_spec *ord,LIST *rp)

{

struct order_spec ord1;

struct order_spec *ord1;

VL tv,fv,vv,vc;

NODE fd,fd0,in0,in,r,r0,t,s,cand;

int m,nocheck,nvar,mindex,e,max;

Line 2426 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

Line 2480 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

get_vars((Obj)f,&fv); pltovl(v,&vv);

for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ );

switch ( ord->id ) {

case 1:

if ( ord->nv != nvar )

error("nd_gr_trace : invalid order specification");

break;

default:

break;

}

nocheck = 0;

mindex = 0;

Line 2465 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

Line 2527 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

wmax = MAX(TD(DL(a)),wmax);

}

homogenize_order(ord,nvar,&ord1);

nd_init_ord(&ord1);

nd_init_ord(ord1);

nd_setup_parameters(nvar+1,wmax);

for ( t = fd0; t; t = NEXT(t) )

ndv_homogenize((NDV)BDY(t),obpe,oadv,oepos);

Line 2504 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

Line 2566 void nd_gr_trace(LIST f,LIST v,int trace,int homo,stru

m = get_lprime(++mindex);

/* reset the parameters */

if ( !ishomo && homo ) {

nd_init_ord(&ord1);

nd_init_ord(ord1);

nd_setup_parameters(nvar+1,wmax);

} else {

nd_init_ord(ord);

Line 2735 void ndv_dehomogenize(NDV p,struct order_spec *ord)

Line 2797 void ndv_dehomogenize(NDV p,struct order_spec *ord)

for ( m = BDY(p), i = 0; i < len; NMV_ADV(m), i++ )

ndl_dehomogenize(DL(m));

if ( newwpd != nd_wpd ) {

newadv = sizeof(struct oNMV)+(newwpd-1)*sizeof(UINT);

newadv = ROUND_FOR_ALIGN(sizeof(struct oNMV)+(newwpd-1)*sizeof(UINT));

for ( m = r = BDY(p), i = 0; i < len; NMV_ADV(m), NDV_NADV(r), i++ ) {

CQ(r) = CQ(m);

for ( j = 0; j < newexporigin; j++ ) DL(r)[j] = DL(m)[j];

Line 2931 void nd_setup_parameters(int nvar,int max) {

Line 2993 void nd_setup_parameters(int nvar,int max) {

nd_mask[nd_epw-i-1] = (nd_mask0<<(i*nd_bpe));

nd_mask1 |= (1<<(nd_bpe-1))<<(i*nd_bpe);

}

nm_adv = sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT);

nmv_adv = ROUND_FOR_ALIGN(sizeof(struct oNMV)+(nd_wpd-1)*sizeof(UINT));

nmv_adv = sizeof(struct oNMV)+(nd_wpd-1)*sizeof(UINT);

nd_epos = nd_create_epos(nd_ord);

nd_blockmask = nd_create_blockmask(nd_ord);

}

Line 4131 NODE nd_f4(int m)

Line 4192 NODE nd_f4(int m)

ND spol,red;

NDV nf,redv;

NM s0,s;

NODE rp0,sp0,srp0,nflist;

NODE rp0,srp0,nflist;

int nsp,nred,col,rank,len,k,j,a;

UINT c;

UINT **spmat;

Line 4164 NODE nd_f4(int m)

Line 4225 NODE nd_f4(int m)

d = nd_reconstruct(m,0,d);

continue;

}

if ( !sp0 ) continue;

if ( bucket->m < 0 ) continue;

col = nd_symbolic_preproc(bucket,&s0vect,&rp0);

if ( !col ) {

for ( t = l; NEXT(t); t = NEXT(t) );

Line 4393 NODE nd_f4_red_dist(int m,ND_pairs sp0,UINT *s0vect,in

Line 4454 NODE nd_f4_red_dist(int m,ND_pairs sp0,UINT *s0vect,in

nd_send_int(nd_wpd);

nd_send_int(nmv_adv);

saveobj(nd_write,dp_current_spec.obj); fflush(nd_write);

saveobj(nd_write,dp_current_spec->obj); fflush(nd_write);

nd_send_int(nd_psn);

for ( i = 0; i < nd_psn; i++ ) nd_send_ndv(nd_ps[i]);

Line 4439 void nd_exec_f4_red_dist()

Line 4500 void nd_exec_f4_red_dist()

ND_pairs *sp0;

int *colstat;

int a,sprow,rank;

struct order_spec ord;

struct order_spec *ord;

Obj ordspec;

ND spol;

int maxrs;

Line 4454 void nd_exec_f4_red_dist()

Line 4515 void nd_exec_f4_red_dist()

nmv_adv = nd_recv_int();

loadobj(nd_read,&ordspec);

create_order_spec(ordspec,&ord);

create_order_spec(0,ordspec,&ord);

nd_init_ord(&ord);

nd_init_ord(ord);

nd_setup_parameters(nd_nvar,0);

nd_psn = nd_recv_int();

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