OpenXM_contrib2/asir2018/engine/nd.c - diff

Return to nd.c CVS log

Up to [local] / OpenXM_contrib2 / asir2018 / engine

Diff for /OpenXM_contrib2/asir2018/engine/nd.c between version 1.29 and 1.32

version 1.29, 2020/07/02 09:24:17

version 1.32, 2020/07/07 08:08:26

Line 1

/* $OpenXM: OpenXM_contrib2/asir2018/engine/nd.c,v 1.28 2020/06/30 01:52:17 noro Exp $ */

/* $OpenXM: OpenXM_contrib2/asir2018/engine/nd.c,v 1.31 2020/07/07 08:04:30 noro Exp $ */

#include "nd.h"

Line 50 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 int nd_psn,nd_pslen,nd_nbase;

static RHist *nd_red;

static int *nd_work_vector;

static int **nd_matrix;

Line 786 int ndl_module_compare(UINT *d1,UINT *d2)

extern DMMstack dmm_stack;

void _addtodl(int n,DL d1,DL d2);

void _adddl(int n,DL d1,DL d2,DL d3);

int _eqdl(int n,DL d1,DL d2);

int ndl_module_schreyer_compare(UINT *m1,UINT *m2)

Line 2484 print_eg("update",&eg_update);

Line 2485 print_eg("update",&eg_update);

return g;

}

ND_pairs update_pairs_s(ND_pairs d,NODE g,int t,NODE *syz);

ND_pairs update_pairs_s(ND_pairs d,int t,NODE *syz);

ND_pairs nd_newpairs_s( NODE g, int t ,NODE *syz);

ND_pairs nd_newpairs_s(int t ,NODE *syz);

int nd_nf_pbucket_s(int mod,ND g,NDV *ps,int full,ND *nf);

int nd_nf_s(int mod,ND d,ND g,NDV *ps,int full,ND *nf);

Line 2606 ND_pairs remove_large_lcm(ND_pairs d)

Line 2607 ND_pairs remove_large_lcm(ND_pairs d)

struct oEGT eg_create,eg_newpairs,eg_merge;

NODE conv_ilist_s(int demand,int trace,int **indp);

NODE nd_sba_buch(int m,int ishomo,int **indp)

{

int i,j,nh,sugar,stat;

NODE r,g,t;

NODE r,t,g;

ND_pairs d;

ND_pairs l;

ND h,nf,s,head,nf1;

Line 2622 NODE nd_sba_buch(int m,int ishomo,int **indp)

Line 2625 NODE nd_sba_buch(int m,int ishomo,int **indp)

NODE *syzlist;

int Nredundant;

DL lcm,quo,mul;

struct oEGT eg1,eg2,eg_update,eg_remove,eg_large;

struct oEGT eg1,eg2,eg_update,eg_remove,eg_large,eg_nf,eg_nfzero;

init_eg(&eg_remove);

syzlist = (NODE *)MALLOC(nd_psn*sizeof(NODE));

Nsyz = 0;

Nnd_add = 0;

Nredundant = 0;

g = 0; d = 0;

d = 0;

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

d = update_pairs_s(d,g,i,syzlist);

d = update_pairs_s(d,i,syzlist);

g = append_one(g,i);

}

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

for ( j = i+1; j < nd_psn; j++ ) {

Line 2645 init_eg(&eg_remove);

Line 2647 init_eg(&eg_remove);

init_eg(&eg_create);

init_eg(&eg_merge);

init_eg(&eg_large);

init_eg(&eg_nf);

init_eg(&eg_nfzero);

while ( d ) {

again:

if ( DP_Print ) {

Line 2671 again:

Line 2675 again:

d = nd_reconstruct(0,d);

goto again;

}

get_eg(&eg1);

#if USE_GEOBUCKET

stat = m?nd_nf_pbucket_s(m,h,nd_ps,!Top,&nf):nd_nf_s(m,0,h,nd_ps,!Top,&nf);

#else

stat = nd_nf_s(m,0,h,nd_ps,!Top,&nf);

#endif

get_eg(&eg2);

if ( !stat ) {

NEXT(l) = d; d = l;

d = nd_reconstruct(0,d);

Line 2685 again:

Line 2691 again:

FREENDP(l);

} else if ( nf ) {

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

add_eg(&eg_nf,&eg1,&eg2);

hc = HCU(nf);

nd_removecont(m,nf);

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

nh = ndv_newps(m,nfv,0);

d = update_pairs_s(d,g,nh,syzlist);

d = update_pairs_s(d,nh,syzlist);

g = append_one(g,nh);

nd_sba_pos[sig->pos] = append_one(nd_sba_pos[sig->pos],nh);

FREENDP(l);

} else {

add_eg(&eg_nfzero,&eg1,&eg2);

// syzygy

get_eg(&eg1);

d = remove_spair_s(d,sig);

Line 2704 get_eg(&eg2); add_eg(&eg_remove,&eg1,&eg2);

Line 2711 get_eg(&eg2); add_eg(&eg_remove,&eg1,&eg2);

FREENDP(l);

}

conv_ilist(nd_demand,0,g,indp);

g = conv_ilist_s(nd_demand,0,indp);

if ( DP_Print ) {

printf("\nnd_sba done. nd_add=%d,Nsyz=%d,Nredundant=%d\n",Nnd_add,Nsyz,Nredundant);

fflush(stdout);

print_eg("create",&eg_create);

print_eg("merge",&eg_merge);

print_eg("remove",&eg_remove);

print_eg("nf",&eg_nf);

print_eg("nfzero",&eg_nfzero);

printf("\n");

}

return g;

Line 3135 ND_pairs update_pairs( ND_pairs d, NODE /* of index */

Line 3144 ND_pairs update_pairs( ND_pairs d, NODE /* of index */

ND_pairs merge_pairs_s(ND_pairs d,ND_pairs d1);

ND_pairs update_pairs_s( ND_pairs d, NODE /* of index */ g, int t,NODE *syz)

ND_pairs update_pairs_s( ND_pairs d, int t,NODE *syz)

{

ND_pairs d1;

struct oEGT eg1,eg2,eg3;

if ( !g ) return d;

if ( !t ) return d;

get_eg(&eg1);

d1 = nd_newpairs_s(g,t,syz);

d1 = nd_newpairs_s(t,syz);

get_eg(&eg2); add_eg(&eg_create,&eg1,&eg2);

d = merge_pairs_s(d,d1);

get_eg(&eg3); add_eg(&eg_merge,&eg2,&eg3);

Line 3186 ND_pairs nd_newpairs( NODE g, int t )

Line 3195 ND_pairs nd_newpairs( NODE g, int t )

return r0;

}

int comp_sig(SIG s1,SIG s2)

{

#if 0

Line 3201 int comp_sig(SIG s1,SIG s2)

Line 3209 int comp_sig(SIG s1,SIG s2)

if ( nvar != nd_nvar ) {

nvar = nd_nvar; NEWDL(m1,nvar); NEWDL(m2,nvar);

}

// _ndltodl(DL(nd_psh[s1->pos]),m1);

#if 0

// _ndltodl(DL(nd_psh[s2->pos]),m2);

_copydl(nd_nvar,nd_sba_hm[s1->pos],m1);

_copydl(nd_nvar,nd_sba_hm[s2->pos],m2);

_addtodl(nd_nvar,s1->dl,m1);

_addtodl(nd_nvar,s2->dl,m2);

#else

_adddl(nd_nvar,s1->dl,nd_sba_hm[s1->pos],m1);

_adddl(nd_nvar,s2->dl,nd_sba_hm[s2->pos],m2);

#endif

ret = (*cmpdl)(nd_nvar,m1,m2);

if ( ret != 0 ) return ret;

else if ( s1->pos > s2->pos ) return 1;

Line 3362 INLINE int __dl_redble(DL d1,DL d2,int nvar)

Line 3373 INLINE int __dl_redble(DL d1,DL d2,int nvar)

return 1;

}

ND_pairs nd_newpairs_s( NODE g, int t, NODE *syz)

ND_pairs nd_newpairs_s(int t, NODE *syz)

{

NODE h,s;

UINT *dl;

Line 3380 ND_pairs nd_newpairs_s( NODE g, int t, NODE *syz)

Line 3391 ND_pairs nd_newpairs_s( NODE g, int t, NODE *syz)

r0 = 0;

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

ret = _create_spair_s(i,t,_sp,_sig1,_sig2);

// for ( h = g; h; h = NEXT(h) ) {

// ret = _create_spair_s((long)BDY(h),t,_sp,_sig1,_sig2);

if ( ret ) {

spsig = _sp->sig;

for ( s = syz[spsig->pos]; s; s = s->next ) {

Line 3682 ND_pairs nd_minsugarp_s( ND_pairs d, ND_pairs *prest )

Line 3691 ND_pairs nd_minsugarp_s( ND_pairs d, ND_pairs *prest )

int msugar;

ND_pairs t,last;

#if 0

#if 1

for ( msugar = SG(d), t = d; t; t = NEXT(t) )

if ( SG(t) == msugar ) last = t;

#else

Line 5582 ND_pairs nd_reconstruct(int trace,ND_pairs d)

Line 5591 ND_pairs nd_reconstruct(int trace,ND_pairs d)

return s0;

}

void nd_reconstruct_s(int trace,ND_pairs *d)

{

int i,obpe,oadv,h;

static NM prev_nm_free_list;

static ND_pairs prev_ndp_free_list;

RHist mr0,mr;

RHist r;

RHist *old_red;

ND_pairs s0,s,t;

EPOS oepos;

obpe = nd_bpe;

oadv = nmv_adv;

oepos = nd_epos;

if ( obpe < 2 ) nd_bpe = 2;

else if ( obpe < 3 ) nd_bpe = 3;

else if ( obpe < 4 ) nd_bpe = 4;

else if ( obpe < 5 ) nd_bpe = 5;

else if ( obpe < 6 ) nd_bpe = 6;

else if ( obpe < 8 ) nd_bpe = 8;

else if ( obpe < 10 ) nd_bpe = 10;

else if ( obpe < 16 ) nd_bpe = 16;

else if ( obpe < 32 ) nd_bpe = 32;

else error("nd_reconstruct_s : exponent too large");

nd_setup_parameters(nd_nvar,0);

prev_nm_free_list = _nm_free_list;

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

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

}

if ( trace )

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

}

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

s0 = 0;

for ( t = d[i]; t; t = NEXT(t) ) {

NEXTND_pairs(s0,s);

s->i1 = t->i1;

s->i2 = t->i2;

s->sig = t->sig;

SG(s) = SG(t);

ndl_reconstruct(LCM(t),LCM(s),obpe,oepos);

}

d[i] = s0;

}

old_red = (RHist *)MALLOC(REDTAB_LEN*sizeof(RHist));

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

old_red[i] = nd_red[i];

nd_red[i] = 0;

}

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

for ( r = old_red[i]; r; r = NEXT(r) ) {

NEWRHist(mr);

mr->index = r->index;

SG(mr) = SG(r);

ndl_reconstruct(DL(r),DL(mr),obpe,oepos);

h = ndl_hash_value(DL(mr));

NEXT(mr) = nd_red[h];

nd_red[h] = mr;

mr->sig = r->sig;

}

for ( i = 0; i < REDTAB_LEN; i++ ) old_red[i] = 0;

old_red = 0;

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

NEWRHist(r); SG(r) = SG(nd_psh[i]);

ndl_reconstruct(DL(nd_psh[i]),DL(r),obpe,oepos);

r->sig = nd_psh[i]->sig;

nd_psh[i] = r;

}

if ( s0 ) NEXT(s) = 0;

prev_nm_free_list = 0;

prev_ndp_free_list = 0;

#if 0

GC_gcollect();

#endif

}

void ndl_reconstruct(UINT *d,UINT *r,int obpe,EPOS oepos)

{

int n,i,ei,oepw,omask0,j,s,ord_l,l;

Line 9452 void conv_ilist(int demand,int trace,NODE g,int **indp

Line 9546 void conv_ilist(int demand,int trace,NODE g,int **indp

if ( indp ) *indp = ind;

}

NODE conv_ilist_s(int demand,int trace,int **indp)

{

int n,i,j;

int *ind;

NODE g0,g;

n = nd_psn;

ind = (int *)MALLOC(n*sizeof(int));

g0 = 0;

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

ind[i] = i;

NEXTNODE(g0,g);

BDY(g) = (pointer)(demand?ndv_load(i):(trace?nd_ps_trace[i]:nd_ps[i]));

}

if ( g0 ) NEXT(g) = 0;

if ( indp ) *indp = ind;

return g0;

}

void parse_nd_option(NODE opt)

{

NODE t,p,u;

Line 10495 int nd_gauss_elim_mod64_s(mp_limb_t **mat,int *sugar,N

Line 10608 int nd_gauss_elim_mod64_s(mp_limb_t **mat,int *sugar,N

UINT *ct;

ND_pairs pair;

SIG sg;

int *used;

used = (int *)MALLOC(row*sizeof(int));

cmat = (UINT **)MALLOC(row*sizeof(UINT *));

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

cmat[i] = MALLOC_ATOMIC(col*sizeof(UINT));

bzero(cmat[i],col*sizeof(UINT));

}

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

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

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

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

a = mat[i][j]; c = cmat[i][j];

MOD128(a,c,md);

mat[i][j] = a; cmat[i][j] = 0;

}

imin = -1;

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

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

if ( !used[i] && mat[i][j] ) break;

if ( mat[i][j] && (imin < 0 || comp_sig(sig[imin],sig[i]) > 0) ) imin = i;

if ( i == row ) {

if ( imin == -1 ) {

colstat[j] = 0;

continue;

} else

} else {

colstat[j] = 1;

if ( imin != rank ) {

used[i] = 1;

t = mat[imin]; mat[imin] = mat[rank]; mat[rank] = t;

ct = cmat[imin]; cmat[imin] = cmat[rank]; cmat[rank] = ct;

s = sugar[imin]; sugar[imin] = sugar[rank]; sugar[rank] = s;

sg = sig[imin]; sig[imin] = sig[rank]; sig[rank] = sg;

if ( spactive ) {

pair = spactive[imin]; spactive[imin] = spactive[rank];

spactive[rank] = pair;

}

/* column j is normalized */

s = sugar[rank];

s = sugar[i];

inv = invm((UINT)mat[rank][j],md);

inv = invm((UINT)mat[i][j],md);

/* normalize pivot row */

for ( k = j, pk = mat[rank]+j, ck = cmat[rank]+j; k < col; k++, pk++, ck++ ) {

for ( k = j, pk = mat[i]+j, ck = cmat[i]+j; k < col; k++, pk++, ck++ ) {

a = *pk; c = *ck; MOD128(a,c,md); *pk = (a*inv)%md; *ck = 0;

}

for ( i = rank+1; i < row; i++ ) {

for ( k = i+1; k < row; k++ ) {

if ( (a = mat[i][j]) != 0 ) {

if ( (a = mat[k][j]) != 0 ) {

sugar[i] = MAX(sugar[i],s);

sugar[k] = MAX(sugar[k],s);

red_by_vect64(md,mat[i]+j,cmat[i]+j,mat[rank]+j,(int)(md-a),col-j);

red_by_vect64(md,mat[k]+j,cmat[k]+j,mat[i]+j,(int)(md-a),col-j);

Nf4_red++;

}

rank++;

}

#if 1

rank = 0;

for ( j = col-1, l = rank-1; j >= 0; j-- )

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

if ( colstat[j] ) {

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

for ( k = j, pk = mat[l]+j, ck = cmat[l]+j; k < col; k++, pk++, ck++ ) {

if ( mat[i][j] ) break;

a = *pk; c = *ck; MOD128(a,c,md); *pk = a; *ck = 0;

if ( j == col ) sugar[i] = -1;

}

else rank++;

s = sugar[l];

}

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

a = mat[i][j]; c = cmat[i][j]; MOD128(a,c,md); mat[i][j] = a; cmat[i][j] = 0;

if ( a && comp_sig(sig[i],sig[l]) > 0 ) {

sugar[i] = MAX(sugar[i],s);

red_by_vect64(md,mat[i]+j,cmat[i]+j,mat[l]+j,(int)(md-a),col-j);

Nf4_red++;

}

l--;

}

#endif

for ( i = 0; i < row; i++ ) GCFREE(cmat[i]);

GCFREE(cmat);

return rank;

Line 10621 NODE nd_f4_red_mod64_main_s(int m,ND_pairs sp0,int nsp

Line 10715 NODE nd_f4_red_mod64_main_s(int m,ND_pairs sp0,int nsp

colstat = (int *)MALLOC(col*sizeof(int));

rank = nd_gauss_elim_mod64_s(spmat,spsugar,0,sprow,col,m,colstat,spsig);

r0 = 0;

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

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

NEXTNODE(r0,r);

if ( spsugar[i] >= 0 ) {

BDY(r) = vect64_to_ndv_s(spmat[i],col,s0vect);

NEXTNODE(r0,r);

SG((NDV)BDY(r)) = spsugar[i];

BDY(r) = vect64_to_ndv_s(spmat[i],col,s0vect);

((NDV)BDY(r))->sig = spsig[i];

SG((NDV)BDY(r)) = spsugar[i];

((NDV)BDY(r))->sig = spsig[i];

} else

syzlistp[spsig[i]->pos] = insert_sig(syzlistp[spsig[i]->pos],spsig[i]);

GCFREE(spmat[i]);

}

if ( r0 ) NEXT(r) = 0;

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

GCFREE(spmat[i]);

syzlistp[spsig[i]->pos] = insert_sig(syzlistp[spsig[i]->pos],spsig[i]);

}

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

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

if ( DP_Print ) {

Line 10806 NODE nd_sba_f4(int m,int **indp)

Line 10898 NODE nd_sba_f4(int m,int **indp)

int *rhead;

int spcol,sprow;

int sugar,sugarh;

int nbase;

PGeoBucket bucket;

struct oEGT eg0,eg1,eg_f4;

Z i1,i2,sugarq;

NODE *syzlist;

Nf4_red=0;

g = 0; d = 0;

d = 0;

syzlist = (NODE *)MALLOC(nd_psn*sizeof(NODE));

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

d = update_pairs_s(d,g,i,syzlist);

d = update_pairs_s(d,i,syzlist);

g = append_one(g,i);

}

nd_nbase = nd_psn;

f4red = 1;

while ( d ) {

l = nd_minsugarp_s(d,&d);

Line 10845 NODE nd_sba_f4(int m,int **indp)

Line 10938 NODE nd_sba_f4(int m,int **indp)

nflist = nd_f4_red_s(m,l,0,s0vect,col,rp0,syzlist);

/* adding new bases */

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

#if 0

ND tmp,tmpred;

SIG sig;

Line 10852 NODE nd_sba_f4(int m,int **indp)

Line 10946 NODE nd_sba_f4(int m,int **indp)

sig = nf->sig;

tmp = ndvtond(m,nf);

stat = nd_nf_s(m,0,tmp,nd_ps,!Top,&tmpred);

#if 0

if ( stat < 0 ) {

// top reducible

if ( DP_Print ) { fprintf(asir_out,"S"); fflush(asir_out); }

} else if ( tmpred ) {

#else

if ( tmpred ) {

#endif

nf = ndtondv(m,tmpred);

ndv_removecont(m,nf);

nh = ndv_newps(m,nf,0);

d = update_pairs_s(d,g,nh,syzlist);

d = update_pairs_s(d,nh,syzlist);

g = append_one(g,nh);

nd_sba_pos[sig->pos] = append_one(nd_sba_pos[sig->pos],nh);

} else {

syzlist[sig->pos] = insert_sig(syzlist[sig->pos],sig);

}

#else

nf = (NDV)BDY(r);

ndv_removecont(m,nf);

nh = ndv_newps(m,nf,0);

d = update_pairs_s(d,nh,syzlist);

nd_sba_pos[nf->sig->pos] = append_one(nd_sba_pos[nf->sig->pos],nh);

#endif

}

// YYY

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

// for ( r = syzlist; r; r = NEXT(r) )

for ( r = syzlist[i]; r; r = NEXT(r) )

// d = remove_spair_s(d,(SIG)BDY(r));

d = remove_spair_s(d,(SIG)BDY(r));

if ( DP_Print ) {

fprintf(asir_out,"f4red=%d,gblen=%d\n",f4red,length(g)); fflush(asir_out);

fprintf(asir_out,"f4red=%d,gblen=%d\n",f4red,nd_psn); fflush(asir_out);

}

f4red++;

if ( nd_f4red && f4red > nd_f4red ) break;

Line 10878 NODE nd_sba_f4(int m,int **indp)

Line 10983 NODE nd_sba_f4(int m,int **indp)

if ( DP_Print ) {

fprintf(asir_out,"number of red=%d,",Nf4_red);

}

conv_ilist(nd_demand,0,g,indp);

g = conv_ilist_s(nd_demand,0,indp);

return g;

}

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