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.209 and 1.216

version 1.209, 2013/09/25 02:36:24

version 1.216, 2013/12/20 04:35:34

Line 1

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.208 2013/09/15 04:30:28 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.215 2013/12/20 02:02:24 noro Exp $ */

#include "nd.h"

Line 37 static UINT nd_mask[32];

static UINT nd_mask0,nd_mask1;

static NDV *nd_ps;

static NDV *nd_ps_gz;

static NDV *nd_ps_trace;

static NDV *nd_ps_sym;

static NDV *nd_ps_trace_sym;

static RHist *nd_psh;

static int nd_psn,nd_pslen;

static RHist *nd_red;

Line 77 void parse_nd_option(NODE opt);

Line 80 void parse_nd_option(NODE opt);

void dltondl(int n,DL dl,UINT *r);

DP ndvtodp(int mod,NDV p);

DP ndtodp(int mod,ND p);

NDV ndvtondvgz(NDV p);

NDV ndvgztondv(NDV p);

ND ndtondgz(ND p);

ND ndgztond(ND p);

extern int Denominator,DP_Multiple;

Line 1969 again:

Line 1976 again:

}

nfv = ndtondv(m,nf); nd_free(nf);

nh = ndv_newps(m,nfv,0);

nh = ndv_newps(m,nfv,0,0);

if ( !m && (ishomo && ++diag_count == diag_period) ) {

diag_count = 0;

stat = do_diagonalize(sugar,m);

Line 2038 again:

Line 2045 again:

return 1;

}

int check_splist_f4(int m,NODE splist)

{

UINT *s0vect;

PGeoBucket bucket;

NODE p,rp0,t;

ND_pairs d,r,l,ll;

int col,stat;

for ( d = 0, t = splist; t; t = NEXT(t) ) {

p = BDY((LIST)BDY(t));

NEXTND_pairs(d,r);

r->i1 = QTOS((Q)ARG0(p)); r->i2 = QTOS((Q)ARG1(p));

ndl_lcm(DL(nd_psh[r->i1]),DL(nd_psh[r->i2]),r->lcm);

SG(r) = TD(LCM(r)); /* XXX */

}

if ( d ) NEXT(r) = 0;

while ( d ) {

l = nd_minsugarp(d,&d);

bucket = create_pbucket();

stat = nd_sp_f4(m,0,l,bucket);

if ( !stat ) {

for ( ll = l; NEXT(ll); ll = NEXT(ll) );

NEXT(ll) = d; d = l;

d = nd_reconstruct(0,d);

continue;

}

if ( bucket->m < 0 ) continue;

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

if ( !col ) {

for ( ll = l; NEXT(ll); ll = NEXT(ll) );

NEXT(ll) = d; d = l;

d = nd_reconstruct(0,d);

continue;

}

if ( nd_f4_red(m,l,0,s0vect,col,rp0,0) ) return 0;

}

return 1;

}

int do_diagonalize_trace(int sugar,int m)

{

int i,nh,stat;

Line 2209 again:

Line 2256 again:

nd_tracelist = t;

}

nh = ndv_newps(0,nfv,nfqv);

nh = ndv_newps(0,nfv,nfqv,0);

if ( ishomo && ++diag_count == diag_period ) {

diag_count = 0;

if ( DP_Print > 2 ) fprintf(asir_out,"|");

Line 2632 ND_pairs nd_minsugarp( ND_pairs d, ND_pairs *prest )

Line 2679 ND_pairs nd_minsugarp( ND_pairs d, ND_pairs *prest )

return dm0;

}

int ndv_newps(int m,NDV a,NDV aq)

int ndv_newps(int m,NDV a,NDV aq,int f4)

{

int len;

RHist r;

Line 2644 int ndv_newps(int m,NDV a,NDV aq)

Line 2691 int ndv_newps(int m,NDV a,NDV aq)

if ( nd_psn == nd_pslen ) {

nd_pslen *= 2;

nd_ps = (NDV *)REALLOC((char *)nd_ps,nd_pslen*sizeof(NDV));

nd_ps_gz = (NDV *)REALLOC((char *)nd_ps_gz,nd_pslen*sizeof(NDV));

nd_ps_trace = (NDV *)REALLOC((char *)nd_ps_trace,nd_pslen*sizeof(NDV));

nd_psh = (RHist *)REALLOC((char *)nd_psh,nd_pslen*sizeof(RHist));

nd_bound = (UINT **)

REALLOC((char *)nd_bound,nd_pslen*sizeof(UINT *));

nd_ps_sym = (NDV *)REALLOC((char *)nd_ps_sym,nd_pslen*sizeof(NDV));

nd_ps_trace_sym = (NDV *)REALLOC((char *)nd_ps_trace_sym,nd_pslen*sizeof(NDV));

}

NEWRHist(r); nd_psh[nd_psn] = r;

nd_ps[nd_psn] = a;

if ( aq ) {

nd_ps_trace[nd_psn] = aq;

nd_ps_gz[nd_psn] = ndvtondvgz(aq);

register_hcf(aq);

nd_bound[nd_psn] = ndv_compute_bound(aq);

SG(r) = SG(aq); ndl_copy(HDL(aq),DL(r));

Line 2660 int ndv_newps(int m,NDV a,NDV aq)

Line 2711 int ndv_newps(int m,NDV a,NDV aq)

if ( !m ) register_hcf(a);

nd_bound[nd_psn] = ndv_compute_bound(a);

SG(r) = SG(a); ndl_copy(HDL(a),DL(r));

if ( !m ) nd_ps_gz[nd_psn] = ndvtondvgz(a);

}

if ( nd_demand ) {

if ( aq ) {

ndv_save(nd_ps_trace[nd_psn],nd_psn);

nd_ps_trace_sym[nd_psn] = ndv_symbolic(m,nd_ps_trace[nd_psn]);

nd_ps_trace[nd_psn] = 0;

} else {

ndv_save(nd_ps[nd_psn],nd_psn);

nd_ps_sym[nd_psn] = ndv_symbolic(m,nd_ps[nd_psn]);

nd_ps[nd_psn] = 0;

}

Line 2715 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i

Line 2769 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i

}

nd_pslen = 2*nd_psn;

nd_ps = (NDV *)MALLOC(nd_pslen*sizeof(NDV));

nd_ps_gz = (NDV *)MALLOC(nd_pslen*sizeof(NDV));

nd_ps_trace = (NDV *)MALLOC(nd_pslen*sizeof(NDV));

nd_ps_sym = (NDV *)MALLOC(nd_pslen*sizeof(NDV));

nd_ps_trace_sym = (NDV *)MALLOC(nd_pslen*sizeof(NDV));

nd_psh = (RHist *)MALLOC(nd_pslen*sizeof(RHist));

nd_bound = (UINT **)MALLOC(nd_pslen*sizeof(UINT *));

nd_hcf = 0;

Line 2732 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i

Line 2789 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i

hc = HCU(w[i].p);

if ( trace ) {

a = nd_ps_trace[i] = ndv_dup(0,w[i].p);

nd_ps_gz[i] = ndvtondvgz(a);

if ( !dont_removecont) ndv_removecont(0,a);

register_hcf(a);

am = nd_ps[i] = ndv_dup(mod,a);

ndv_mod(mod,am);

if ( DL_COMPARE(HDL(am),HDL(a)) )

return 0;

ndv_removecont(mod,am);

} else {

a = nd_ps[i] = ndv_dup(mod,w[i].p);

if ( !mod ) nd_ps_gz[i] = ndvtondvgz(a);

if ( mod || !dont_removecont ) ndv_removecont(mod,a);

if ( !mod ) register_hcf(a);

}

Line 2756 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i

Line 2815 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i

if ( nd_demand ) {

if ( trace ) {

ndv_save(nd_ps_trace[i],i);

nd_ps_trace_sym[i] = ndv_symbolic(mod,nd_ps_trace[i]);

nd_ps_trace[i] = 0;

} else {

ndv_save(nd_ps[i],i);

nd_ps_sym[i] = ndv_symbolic(mod,nd_ps[i]);

nd_ps[i] = 0;

}

Line 2980 void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int

Line 3041 void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int

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

}

ndv_setup(m,0,fd0,(nd_gbblock||nd_splist)?1:0,0);

ndv_setup(m,0,fd0,(nd_gbblock||nd_splist||nd_check_splist)?1:0,0);

if ( nd_gentrace ) {

MKLIST(l1,nd_tracelist); MKNODE(nd_alltracelist,l1,0);

}

Line 2989 void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int

Line 3050 void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int

return;

}

if ( nd_check_splist ) {

if ( check_splist(m,nd_check_splist) ) *rp = (LIST)ONE;

if ( f4 ) {

else *rp = 0;

if ( check_splist_f4(m,nd_check_splist) ) *rp = (LIST)ONE;

else *rp = 0;

} else {

if ( check_splist(m,nd_check_splist) ) *rp = (LIST)ONE;

else *rp = 0;

}

return;

}

x = f4?nd_f4(m,&perm):nd_gb(m,ishomo || homo,0,0,&perm);

Line 4117 ND_pairs nd_reconstruct(int trace,ND_pairs d)

Line 4183 ND_pairs nd_reconstruct(int trace,ND_pairs d)

prev_ndp_free_list = _ndp_free_list;

_nm_free_list = 0;

_ndp_free_list = 0;

for ( i = nd_psn-1; i >= 0; i-- ) ndv_realloc(nd_ps[i],obpe,oadv,oepos);

for ( i = nd_psn-1; i >= 0; i-- ) {

ndv_realloc(nd_ps[i],obpe,oadv,oepos);

ndv_realloc(nd_ps_sym[i],obpe,oadv,oepos);

ndv_realloc(nd_ps_gz[i],obpe,oadv,oepos);

}

if ( trace )

for ( i = nd_psn-1; i >= 0; i-- )

for ( i = nd_psn-1; i >= 0; i-- ) {

ndv_realloc(nd_ps_trace[i],obpe,oadv,oepos);

ndv_realloc(nd_ps_trace_sym[i],obpe,oadv,oepos);

}

s0 = 0;

for ( t = d; t; t = NEXT(t) ) {

NEXTND_pairs(s0,s);

Line 4641 NDV ndv_dup(int mod,NDV p)

Line 4713 NDV ndv_dup(int mod,NDV p)

return d;

}

NDV ndvtondvgz(NDV p)

{

NDV r;

int len,i;

NMV t;

r = ndv_dup(0,p);

len = LEN(p);

for ( t = BDY(r), i = 0; i < len; i++, NMV_ADV(t) ) CZ(t) = ztogz(CQ(t));

return r;

}

NDV ndvgztondv(NDV p)

{

NDV r;

int len,i;

NMV t;

r = ndv_dup(0,p);

len = LEN(p);

for ( t = BDY(r), i = 0; i < len; i++, NMV_ADV(t) ) CQ(t) = gztoz(CZ(t));

return r;

}

NDV ndv_symbolic(int mod,NDV p)

{

NDV d;

NMV t,m,m0;

int i,len;

if ( !p ) return 0;

len = LEN(p);

m0 = m = (NMV)(mod?MALLOC_ATOMIC(len*nmv_adv):MALLOC(len*nmv_adv));

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

ndl_copy(DL(t),DL(m));

CQ(m) = ONE;

}

MKNDV(NV(p),m0,len,d);

SG(d) = SG(p);

return d;

}

ND nd_dup(ND p)

{

ND d;

Line 4658 ND nd_dup(ND p)

Line 4772 ND nd_dup(ND p)

return d;

}

ND ndtondgz(ND p)

{

ND r;

NM t;

r = nd_dup(p);

for ( t = BDY(r); t; t = NEXT(t) ) CZ(t) = ztogz(CQ(t));

return r;

}

ND ndgztond(ND p)

{

ND r;

NM t;

r = nd_dup(p);

for ( t = BDY(r); t; t = NEXT(t) ) CQ(t) = gztoz(CZ(t));

return r;

}

/* XXX if p->len == 0 then it represents 0 */

void ndv_mod(int mod,NDV p)

Line 5363 Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_p

Line 5499 Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_p

return r;

}

IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0,int n,NM_ind_pair pair)

IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0,int n,int *s0hash,NM_ind_pair pair)

{

NM m;

NMV mr;

Line 5372 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

Line 5508 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0

unsigned char *ivc;

unsigned short *ivs;

UINT *v,*ivi,*s0v;

int i,j,len,prev,diff,cdiff;

int i,j,len,prev,diff,cdiff,h;

IndArray r;

struct oEGT eg0,eg1;

m = pair->mul;

d = DL(m);

p = nd_ps[pair->index];

p = nd_demand?nd_ps_sym[pair->index]:nd_ps[pair->index];

len = LEN(p);

t = (UINT *)ALLOCA(nd_wpd*sizeof(UINT));

v = (unsigned int *)ALLOCA(len*sizeof(unsigned int));

get_eg(&eg0);

for ( i = j = 0, s = s0, mr = BDY(p); j < len; j++, NMV_ADV(mr) ) {

ndl_add(d,DL(mr),t);

for ( ; !ndl_equal(t,s); s += nd_wpd, i++ );

h = ndl_hash_value(t);

for ( ; h != s0hash[i] || !ndl_equal(t,s); s += nd_wpd, i++ );

v[j] = i;

}

get_eg(&eg1); add_eg(&eg_search,&eg0,&eg1);

Line 5456 int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr

Line 5593 int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr

k = ivect->head;

if ( svect[k] ) {

maxrs = MAX(maxrs,rp0[i]->sugar);

redv = trace?nd_ps_trace[rp0[i]->index]:nd_ps[rp0[i]->index];

redv = nd_demand?ndv_load(rp0[i]->index)

:(trace?nd_ps_trace[rp0[i]->index]:nd_ps[rp0[i]->index]);

len = LEN(redv); mr = BDY(redv);

igcd_cofactor(svect[k],CQ(mr),&gcd,&cs,&cr);

chsgnq(cs,&mcs);

Line 5508 int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr

Line 5646 int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr

return maxrs;

}

int ndv_reduce_vect_gz(GZ *gvect,int trace,int col,IndArray *imat,NM_ind_pair *rp0,int nred)

{

int i,j,k,l,len,pos,prev,nz;

GZ cs,mcs,c1,c2,cr,gcd,t;

IndArray ivect;

unsigned char *ivc;

unsigned short *ivs;

unsigned int *ivi;

NDV redv;

NMV mr;

NODE rp;

int maxrs;

double hmag;

struct oVECT v;

maxrs = 0;

for ( i = 0; i < col && !gvect[i]; i++ );

if ( i == col ) return maxrs;

hmag = (double)n_bits_gz(gvect[i])*nd_scale;

for ( i = 0; i < nred; i++ ) {

ivect = imat[i];

k = ivect->head;

if ( gvect[k] ) {

maxrs = MAX(maxrs,rp0[i]->sugar);

redv = nd_ps_gz[rp0[i]->index];

len = LEN(redv); mr = BDY(redv);

gcdgz(gvect[k],CZ(mr),&gcd);

divsgz(gvect[k],gcd,&cs);

divsgz(CZ(mr),gcd,&cr);

chsgngz(cs,&mcs);

if ( !UNIGZ(cr) ) {

for ( j = 0; j < col; j++ ) {

mulgz(gvect[j],cr,&c1); gvect[j] = c1;

}

gvect[k] = 0; prev = k;

switch ( ivect->width ) {

case 1:

ivc = ivect->index.c;

for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {

pos = prev+ivc[j]; prev = pos;

mulgz(CZ(mr),mcs,&c2); addgz(gvect[pos],c2,&t); gvect[pos] = t;

}

break;

case 2:

ivs = ivect->index.s;

for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {

pos = prev+ivs[j]; prev = pos;

mulgz(CZ(mr),mcs,&c2); addgz(gvect[pos],c2,&t); gvect[pos] = t;

}

break;

case 4:

ivi = ivect->index.i;

for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {

pos = prev+ivi[j]; prev = pos;

mulgz(CZ(mr),mcs,&c2); addgz(gvect[pos],c2,&t); gvect[pos] = t;

}

break;

}

for ( j = k+1; j < col && !gvect[j]; j++ );

if ( j == col ) break;

if ( hmag && ((double)n_bits_gz(gvect[j]) > hmag) ) {

v.len = col; v.body = (pointer)gvect; gcdvgz(&v,&gcd);

#if 1

for ( l = 0; l < col; l++ ) { divsgz(gvect[l],gcd,&t); gvect[l] = t; }

#endif

hmag = (double)n_bits_gz(gvect[j])*nd_scale;

}

for ( j = 0; j < col && !gvect[j]; j++ );

if ( j < col ) {

v.len = col; v.body = (pointer)gvect; gcdvgz(&v,&gcd);

for ( l = 0; l < col; l++ ) { divsgz(gvect[l],gcd,&t); gvect[l] = t; }

}

if ( DP_Print ) {

fprintf(asir_out,"-"); fflush(asir_out);

}

return maxrs;

}

int ndv_reduce_vect(int m,UINT *svect,int col,IndArray *imat,NM_ind_pair *rp0,int nred)

{

int i,j,k,len,pos,prev;

Line 5534 int ndv_reduce_vect(int m,UINT *svect,int col,IndArray

Line 5754 int ndv_reduce_vect(int m,UINT *svect,int col,IndArray

case 1:

ivc = ivect->index.c;

for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {

pos = prev+ivc[j]; c1 = CM(mr); c2 = svect[pos];

pos = prev+ivc[j]; c1 = CM(mr); prev = pos;

prev = pos;

if ( c1 ) {

DMA(c1,c,c2,up,lo);

c2 = svect[pos];

if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;

DMA(c1,c,c2,up,lo);

} else svect[pos] = lo;

if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;

} else svect[pos] = lo;

}

break;

case 2:

ivs = ivect->index.s;

for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {

pos = prev+ivs[j]; c1 = CM(mr); c2 = svect[pos];

pos = prev+ivs[j]; c1 = CM(mr);

prev = pos;

DMA(c1,c,c2,up,lo);

if ( c1 ) {

if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;

c2 = svect[pos];

} else svect[pos] = lo;

DMA(c1,c,c2,up,lo);

if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;

} else svect[pos] = lo;

}

break;

case 4:

ivi = ivect->index.i;

for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) {

pos = prev+ivi[j]; c1 = CM(mr); c2 = svect[pos];

pos = prev+ivi[j]; c1 = CM(mr);

prev = pos;

DMA(c1,c,c2,up,lo);

if ( c1 ) {

if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;

c2 = svect[pos];

} else svect[pos] = lo;

DMA(c1,c,c2,up,lo);

if ( up ) { DSAB(m,up,lo,dmy,c3); svect[pos] = c3;

} else svect[pos] = lo;

}

break;

}

Line 5679 NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead

Line 5907 NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead

}

NDV vect_to_ndv_gz(GZ *vect,int spcol,int col,int *rhead,UINT *s0vect)

{

int j,k,len;

UINT *p;

Q c;

NDV r;

NMV mr0,mr;

for ( j = 0, len = 0; j < spcol; j++ ) if ( vect[j] ) len++;

if ( !len ) return 0;

else {

mr0 = (NMV)MALLOC(nmv_adv*len);

#if 0

ndv_alloc += nmv_adv*len;

#endif

mr = mr0;

p = s0vect;

for ( j = k = 0; j < col; j++, p += nd_wpd )

if ( !rhead[j] ) {

if ( c = vect[k++] ) {

ndl_copy(p,DL(mr)); CZ(mr) = c; NMV_ADV(mr);

}

MKNDV(nd_nvar,mr0,len,r);

return r;

}

/* for plain vector */

NDV plain_vect_to_ndv_q(Q *vect,int col,UINT *s0vect)

Line 5738 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI

Line 5994 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI

NDV *ps;

s0 = 0; rp0 = 0; col = 0;

ps = trace?nd_ps_trace:nd_ps;

if ( nd_demand )

ps = trace?nd_ps_trace_sym:nd_ps_sym;

else

ps = trace?nd_ps_trace:nd_ps;

while ( 1 ) {

head = remove_head_pbucket_symbolic(bucket);

if ( !head ) break;

Line 5845 NODE nd_f4(int m,int **indp)

Line 6104 NODE nd_f4(int m,int **indp)

if ( DP_Print )

fprintf(asir_out,"sugar=%d,symb=%fsec,",

sugar,eg_f4.exectime+eg_f4.gctime);

if ( 1 )

nflist = nd_f4_red(m,l,0,s0vect,col,rp0,nd_gentrace?&ll:0);

else

nflist = nd_f4_red_dist(m,l,s0vect,col,rp0,nd_gentrace?&ll:0);

/* adding new bases */

for ( r = nflist; r; r = NEXT(r) ) {

nf = (NDV)BDY(r);

Line 5861 NODE nd_f4(int m,int **indp)

Line 6117 NODE nd_f4(int m,int **indp)

nd_removecont(m,nf1);

nf = ndtondv(m,nf1);

}

nh = ndv_newps(m,nf,0);

nh = ndv_newps(m,nf,0,1);

d = update_pairs(d,g,nh,0);

g = update_base(g,nh);

}

Line 5884 NODE nd_f4(int m,int **indp)

Line 6140 NODE nd_f4(int m,int **indp)

#if 0

fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc);

#endif

conv_ilist(0,0,g,indp);

conv_ilist(nd_demand,0,g,indp);

return g;

}

Line 5976 NODE nd_f4_trace(int m,int **indp)

Line 6232 NODE nd_f4_trace(int m,int **indp)

nfv = ndv_dup(0,nfqv);

ndv_mod(m,nfv);

ndv_removecont(m,nfv);

nh = ndv_newps(0,nfv,nfqv);

nh = ndv_newps(0,nfv,nfqv,1);

d = update_pairs(d,g,nh,0);

g = update_base(g,nh);

}

Line 5984 NODE nd_f4_trace(int m,int **indp)

Line 6240 NODE nd_f4_trace(int m,int **indp)

#if 0

fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc);

#endif

conv_ilist(0,1,g,indp);

conv_ilist(nd_demand,1,g,indp);

return g;

}

Line 6079 NODE nd_f4_pseudo_trace(int m,int **indp)

Line 6335 NODE nd_f4_pseudo_trace(int m,int **indp)

nfv = ndv_dup(0,nfqv);

ndv_mod(m,nfv);

ndv_removecont(m,nfv);

nh = ndv_newps(0,nfv,nfqv);

nh = ndv_newps(0,nfv,nfqv,1);

d = update_pairs(d,g,nh,0);

g = update_base(g,nh);

}

Line 6099 NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve

Line 6355 NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve

NODE r0,rp;

ND_pairs sp;

NM_ind_pair *rvect;

UINT *s;

int *s0hash;

init_eg(&eg_search);

for ( sp = sp0, nsp = 0; sp; sp = NEXT(sp), nsp++ );

nred = length(rp0);

Line 6107 init_eg(&eg_search);

Line 6366 init_eg(&eg_search);

for ( i = 0; i < col; i++ ) rhead[i] = 0;

/* construction of index arrays */

fprintf(stderr,"%dx%d,",nsp+nred,col);

rvect = (NM_ind_pair *)ALLOCA(nred*sizeof(NM_ind_pair));

s0hash = (int *)ALLOCA(col*sizeof(int));

for ( i = 0, s = s0vect; i < col; i++, s += nd_wpd )

s0hash[i] = ndl_hash_value(s);

for ( rp = rp0, i = 0; rp; i++, rp = NEXT(rp) ) {

rvect[i] = (NM_ind_pair)BDY(rp);

imat[i] = nm_ind_pair_to_vect_compress(m,s0vect,col,rvect[i]);

imat[i] = nm_ind_pair_to_vect_compress(m,s0vect,col,s0hash,rvect[i]);

rhead[imat[i]->head] = 1;

}

if ( m )

r0 = nd_f4_red_main(m,sp0,nsp,s0vect,col,rvect,rhead,imat,nred,nz);

else

r0 = nd_f4_red_q_main(sp0,nsp,trace,s0vect,col,rvect,rhead,imat,nred);

r0 = nd_f4_red_gz_main(sp0,nsp,trace,s0vect,col,rvect,rhead,imat,nred);

print_eg("search",&eg_search);

return r0;

}

Line 6258 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U

Line 6521 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U

rank = nd_gauss_elim_q(spmat,spsugar,sprow,spcol,colstat);

w = (pointer *)ALLOCA(rank*sizeof(pointer));

for ( i = 0; i < rank; i++ ) {

#if 0

w[rank-i-1] = (pointer)vect_to_ndv_q(spmat[i],spcol,col,rhead,s0vect);

SG((NDV)w[rank-i-1]) = spsugar[i];

#else

w[i] = (pointer)vect_to_ndv_q(spmat[i],spcol,col,rhead,s0vect);

SG((NDV)w[i]) = spsugar[i];

#endif

/* GCFREE(spmat[i]); */

}

#if 0

Line 6283 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U

Line 6551 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U

}

return r0;

}

NODE nd_f4_red_gz_main(ND_pairs sp0,int nsp,int trace,UINT *s0vect,int col,

NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred)

{

int spcol,sprow,a;

int i,j,k,l,rank;

NODE r0,r;

ND_pairs sp;

ND spol;

GZ **spmat;

GZ *svect,*v;

int *colstat;

struct oEGT eg0,eg1,eg2,eg_f4,eg_f4_1,eg_f4_2;

int maxrs;

int *spsugar;

pointer *w;

spcol = col-nred;

get_eg(&eg0);

/* elimination (1st step) */

spmat = (GZ **)ALLOCA(nsp*sizeof(GZ *));

svect = (GZ *)ALLOCA(col*sizeof(GZ));

spsugar = (int *)ALLOCA(nsp*sizeof(Q));

for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) {

nd_sp(0,trace,sp,&spol);

if ( !spol ) continue;

spol = ndtondgz(spol);

nd_to_vect_q(s0vect,col,spol,(Q *)svect);

maxrs = ndv_reduce_vect_gz(svect,trace,col,imat,rvect,nred);

for ( i = 0; i < col; i++ ) if ( svect[i] ) break;

if ( i < col ) {

spmat[sprow] = v = (GZ *)MALLOC(spcol*sizeof(GZ));

for ( j = k = 0; j < col; j++ )

if ( !rhead[j] ) v[k++] = svect[j];

spsugar[sprow] = MAX(maxrs,SG(spol));

sprow++;

}

/* nd_free(spol); */

}

get_eg(&eg1); init_eg(&eg_f4_1); add_eg(&eg_f4_1,&eg0,&eg1);

if ( DP_Print ) {

fprintf(asir_out,"elim1=%fsec,",eg_f4_1.exectime+eg_f4_1.gctime);

fflush(asir_out);

}

/* free index arrays */

/* for ( i = 0; i < nred; i++ ) GCFREE(imat[i]->index.c); */

/* elimination (2nd step) */

colstat = (int *)ALLOCA(spcol*sizeof(int));

rank = nd_gauss_elim_gz(spmat,spsugar,sprow,spcol,colstat);

w = (pointer *)ALLOCA(rank*sizeof(pointer));

for ( i = 0; i < rank; i++ ) {

#if 0

w[rank-i-1] = (pointer)vect_to_ndv_gz(spmat[i],spcol,col,rhead,s0vect);

w[rank-i-1] = ndvgztondv(w[rank-i-1]);

SG((NDV)w[rank-i-1]) = spsugar[i];

#else

w[i] = (pointer)vect_to_ndv_gz((Q *)spmat[i],spcol,col,rhead,s0vect);

w[i] = ndvgztondv(w[i]);

SG((NDV)w[i]) = spsugar[i];

#endif

/* GCFREE(spmat[i]); */

}

#if 0

qsort(w,rank,sizeof(NDV),

(int (*)(const void *,const void *))ndv_compare);

#endif

r0 = 0;

for ( i = 0; i < rank; i++ ) {

NEXTNODE(r0,r); BDY(r) = w[i];

}

if ( r0 ) NEXT(r) = 0;

/* for ( ; i < sprow; i++ ) GCFREE(spmat[i]); */

get_eg(&eg2); init_eg(&eg_f4_2); add_eg(&eg_f4_2,&eg1,&eg2);

init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg2);

if ( DP_Print ) {

fprintf(asir_out,"elim2=%fsec\n",eg_f4_2.exectime+eg_f4_2.gctime);

fprintf(asir_out,"nsp=%d,nred=%d,spmat=(%d,%d),rank=%d ",

nsp,nred,sprow,spcol,rank);

fprintf(asir_out,"%fsec\n",eg_f4.exectime+eg_f4.gctime);

}

return r0;

}

#else

void printm(Q **mat,int row,int col)

{

int i,j;

Line 6435 int ox_exec_f4_red(Q proc)

Line 6788 int ox_exec_f4_red(Q proc)

return s;

}

#if 0

NODE nd_f4_red_dist(int m,ND_pairs sp0,UINT *s0vect,int col,NODE rp0,ND_pairs *nz)

{

int nsp,nred;

Line 6597 void nd_exec_f4_red_dist()

Line 6951 void nd_exec_f4_red_dist()

}

fflush(nd_write);

}

#endif

int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int col,int *colstat)

{

Line 6615 int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int co

Line 6970 int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int co

mat0[i][ri[i]] = dn;

for ( j = 0; j < c; j++ )

mat0[i][ci[j]] = (Q)BDY(nm)[i][j];

}

return rank;

}

int nd_gauss_elim_gz(GZ **mat0,int *sugar,int row,int col,int *colstat)

{

int i,j,t,c,rank,inv;

int *ci,*ri;

GZ dn;

MAT m,nm;

NEWMAT(m); m->row = row; m->col = col; m->body = (pointer **)mat0;

rank = gz_generic_gauss_elim(m,&nm,&dn,&ri,&ci);

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

for ( j = 0; j < col; j++ )

mat0[i][j] = 0;

c = col-rank;

for ( i = 0; i < rank; i++ ) {

mat0[i][ri[i]] = dn;

for ( j = 0; j < c; j++ )

mat0[i][ci[j]] = (GZ)BDY(nm)[i][j];

}

return rank;

}

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