| version 1.167, 2009/02/08 02:47:09 |
version 1.221, 2015/03/15 19:31:30 |
|
|
| /* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.166 2009/02/03 08:08:01 noro Exp $ */ |
/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.220 2015/01/13 00:54:54 noro Exp $ */ |
| |
|
| #include "nd.h" |
#include "nd.h" |
| |
|
| |
struct oEGT eg_search; |
| |
|
| int diag_period = 6; |
int diag_period = 6; |
| |
int weight_check = 1; |
| int (*ndl_compare_function)(UINT *a1,UINT *a2); |
int (*ndl_compare_function)(UINT *a1,UINT *a2); |
| int nd_dcomp; |
int nd_dcomp; |
| |
int nd_rref2; |
| NM _nm_free_list; |
NM _nm_free_list; |
| ND _nd_free_list; |
ND _nd_free_list; |
| ND_pairs _ndp_free_list; |
ND_pairs _ndp_free_list; |
| NODE nd_hcf; |
NODE nd_hcf; |
| |
|
| |
Obj nd_top_weight; |
| |
|
| static NODE nd_subst; |
static NODE nd_subst; |
| static VL nd_vc; |
static VL nd_vc; |
| static int nd_ntrans; |
static int nd_ntrans; |
| Line 34 static UINT nd_mask[32]; |
|
| Line 40 static UINT nd_mask[32]; |
|
| static UINT nd_mask0,nd_mask1; |
static UINT nd_mask0,nd_mask1; |
| |
|
| static NDV *nd_ps; |
static NDV *nd_ps; |
| |
static NDV *nd_ps_gz; |
| static NDV *nd_ps_trace; |
static NDV *nd_ps_trace; |
| |
static NDV *nd_ps_sym; |
| |
static NDV *nd_ps_trace_sym; |
| static RHist *nd_psh; |
static RHist *nd_psh; |
| static int nd_psn,nd_pslen; |
static int nd_psn,nd_pslen; |
| static RHist *nd_red; |
static RHist *nd_red; |
| Line 46 static int nd_worb_len; |
|
| Line 55 static int nd_worb_len; |
|
| static int nd_found,nd_create,nd_notfirst; |
static int nd_found,nd_create,nd_notfirst; |
| static int nmv_adv; |
static int nmv_adv; |
| static int nd_demand; |
static int nd_demand; |
| static int nd_module,nd_ispot,nd_mpos; |
static int nd_module,nd_ispot,nd_mpos,nd_pot_nelim; |
| static NODE nd_tracelist; |
static NODE nd_tracelist; |
| static NODE nd_alltracelist; |
static NODE nd_alltracelist; |
| |
static int nd_gentrace,nd_gensyz,nd_nora,nd_newelim,nd_intersect; |
| |
static int *nd_gbblock; |
| |
static NODE nd_nzlist,nd_check_splist; |
| |
static int nd_splist; |
| |
|
| NumberField get_numberfield(); |
NumberField get_numberfield(); |
| UINT *nd_det_compute_bound(NDV **dm,int n,int j); |
UINT *nd_det_compute_bound(NDV **dm,int n,int j); |
| Line 60 LIST ndvtopl(int mod,VL vl,VL dvl,NDV p,int rank); |
|
| Line 73 LIST ndvtopl(int mod,VL vl,VL dvl,NDV p,int rank); |
|
| NDV pltondv(VL vl,VL dvl,LIST p); |
NDV pltondv(VL vl,VL dvl,LIST p); |
| void pltozpl(LIST l,Q *cont,LIST *pp); |
void pltozpl(LIST l,Q *cont,LIST *pp); |
| void ndl_max(UINT *d1,unsigned *d2,UINT *d); |
void ndl_max(UINT *d1,unsigned *d2,UINT *d); |
| pointer GC_malloc_atomic_ignore_off_page(int); |
|
| void nmtodp(int mod,NM m,DP *r); |
void nmtodp(int mod,NM m,DP *r); |
| NODE reverse_node(NODE n); |
NODE reverse_node(NODE n); |
| P ndc_div(int mod,union oNDC a,union oNDC b); |
P ndc_div(int mod,union oNDC a,union oNDC b); |
| P ndctop(int mod,union oNDC c); |
P ndctop(int mod,union oNDC c); |
| void finalize_tracelist(int i,P cont); |
void finalize_tracelist(int i,P cont); |
| void conv_ilist(int demand,int trace,NODE g,int **indp); |
void conv_ilist(int demand,int trace,NODE g,int **indp); |
| |
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); |
| |
|
| |
void Pdp_set_weight(NODE,VECT *); |
| |
void Pox_cmo_rpc(NODE,Obj *); |
| |
|
| extern int Denominator,DP_Multiple; |
extern int Denominator,DP_Multiple; |
| |
|
| |
#define BLEN (8*sizeof(unsigned long)) |
| |
|
| |
typedef struct matrix { |
| |
int row,col; |
| |
unsigned long **a; |
| |
} *matrix; |
| |
|
| |
|
| void nd_free_private_storage() |
void nd_free_private_storage() |
| { |
{ |
| _nm_free_list = 0; |
_nm_free_list = 0; |
|
| Line 116 void _NM_alloc() |
|
| int i; |
int i; |
| |
|
| for ( i = 0; i < 1024; i++ ) { |
for ( i = 0; i < 1024; i++ ) { |
| p = (NM)GC_malloc(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT)); |
p = (NM)MALLOC(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT)); |
| p->next = _nm_free_list; _nm_free_list = p; |
p->next = _nm_free_list; _nm_free_list = p; |
| } |
} |
| } |
} |
| |
|
| |
matrix alloc_matrix(int row,int col) |
| |
{ |
| |
unsigned long **a; |
| |
int i,len,blen; |
| |
matrix mat; |
| |
|
| |
mat = (matrix)MALLOC(sizeof(struct matrix)); |
| |
mat->row = row; |
| |
mat->col = col; |
| |
mat->a = a = (unsigned long **)MALLOC(row*sizeof(unsigned long *)); |
| |
return mat; |
| |
} |
| |
|
| |
|
| void _ND_alloc() |
void _ND_alloc() |
| { |
{ |
| ND p; |
ND p; |
| int i; |
int i; |
| |
|
| for ( i = 0; i < 1024; i++ ) { |
for ( i = 0; i < 1024; i++ ) { |
| p = (ND)GC_malloc(sizeof(struct oND)); |
p = (ND)MALLOC(sizeof(struct oND)); |
| p->body = (NM)_nd_free_list; _nd_free_list = p; |
p->body = (NM)_nd_free_list; _nd_free_list = p; |
| } |
} |
| } |
} |
| Line 107 void _NDP_alloc() |
|
| Line 152 void _NDP_alloc() |
|
| int i; |
int i; |
| |
|
| for ( i = 0; i < 1024; i++ ) { |
for ( i = 0; i < 1024; i++ ) { |
| p = (ND_pairs)GC_malloc(sizeof(struct oND_pairs) |
p = (ND_pairs)MALLOC(sizeof(struct oND_pairs) |
| +(nd_wpd-1)*sizeof(UINT)); |
+(nd_wpd-1)*sizeof(UINT)); |
| p->next = _ndp_free_list; _ndp_free_list = p; |
p->next = _ndp_free_list; _ndp_free_list = p; |
| } |
} |
| Line 480 int ndl_block_compare(UINT *d1,UINT *d2) |
|
| Line 525 int ndl_block_compare(UINT *d1,UINT *d2) |
|
| |
|
| int ndl_matrix_compare(UINT *d1,UINT *d2) |
int ndl_matrix_compare(UINT *d1,UINT *d2) |
| { |
{ |
| int i,j,s; |
int i,j,s,row; |
| int *v; |
int *v; |
| |
Q **mat; |
| |
Q *w; |
| |
Q t,t1,t2; |
| |
|
| for ( j = 0; j < nd_nvar; j++ ) |
for ( j = 0; j < nd_nvar; j++ ) |
| nd_work_vector[j] = GET_EXP(d1,j)-GET_EXP(d2,j); |
nd_work_vector[j] = GET_EXP(d1,j)-GET_EXP(d2,j); |
| |
if ( nd_top_weight ) { |
| |
if ( OID(nd_top_weight) == O_VECT ) { |
| |
mat = (Q **)&BDY((VECT)nd_top_weight); |
| |
row = 1; |
| |
} else { |
| |
mat = (Q **)BDY((MAT)nd_top_weight); |
| |
row = ((MAT)nd_top_weight)->row; |
| |
} |
| |
for ( i = 0; i < row; i++ ) { |
| |
w = (Q *)mat[i]; |
| |
for ( j = 0, t = 0; j < nd_nvar; j++ ) { |
| |
STOQ(nd_work_vector[j],t1); |
| |
mulq(w[j],t1,&t2); |
| |
addq(t,t2,&t1); |
| |
t = t1; |
| |
} |
| |
if ( t ) { |
| |
s = SGN(t); |
| |
if ( s > 0 ) return 1; |
| |
else if ( s < 0 ) return -1; |
| |
} |
| |
} |
| |
} |
| for ( i = 0; i < nd_matrix_len; i++ ) { |
for ( i = 0; i < nd_matrix_len; i++ ) { |
| v = nd_matrix[i]; |
v = nd_matrix[i]; |
| for ( j = 0, s = 0; j < nd_nvar; j++ ) |
for ( j = 0, s = 0; j < nd_nvar; j++ ) |
| Line 492 int ndl_matrix_compare(UINT *d1,UINT *d2) |
|
| Line 563 int ndl_matrix_compare(UINT *d1,UINT *d2) |
|
| if ( s > 0 ) return 1; |
if ( s > 0 ) return 1; |
| else if ( s < 0 ) return -1; |
else if ( s < 0 ) return -1; |
| } |
} |
| |
if ( !ndl_equal(d1,d2) ) |
| |
error("afo"); |
| return 0; |
return 0; |
| } |
} |
| |
|
| Line 579 int ndl_module_grlex_compare(UINT *d1,UINT *d2) |
|
| Line 652 int ndl_module_grlex_compare(UINT *d1,UINT *d2) |
|
| int i,c; |
int i,c; |
| |
|
| if ( nd_ispot ) { |
if ( nd_ispot ) { |
| |
if ( nd_pot_nelim && MPOS(d1)>=nd_pot_nelim+1 && MPOS(d2) >= nd_pot_nelim+1 ) { |
| |
if ( TD(d1) > TD(d2) ) return 1; |
| |
else if ( TD(d1) < TD(d2) ) return -1; |
| |
if ( c = ndl_lex_compare(d1,d2) ) return c; |
| |
if ( MPOS(d1) < MPOS(d2) ) return 1; |
| |
else if ( MPOS(d1) > MPOS(d2) ) return -1; |
| |
return 0; |
| |
} |
| if ( MPOS(d1) < MPOS(d2) ) return 1; |
if ( MPOS(d1) < MPOS(d2) ) return 1; |
| else if ( MPOS(d1) > MPOS(d2) ) return -1; |
else if ( MPOS(d1) > MPOS(d2) ) return -1; |
| } |
} |
| Line 1325 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND |
|
| Line 1406 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND |
|
| p = nd_demand ? ndv_load(index) : ps[index]; |
p = nd_demand ? ndv_load(index) : ps[index]; |
| /* d+g -> div*(d+g)+mul*p */ |
/* d+g -> div*(d+g)+mul*p */ |
| g = nd_reduce2(mod,d,g,p,mul,dn,&div); |
g = nd_reduce2(mod,d,g,p,mul,dn,&div); |
| if ( GenTrace ) { |
if ( nd_gentrace ) { |
| /* Trace=[div,index,mul,ONE] */ |
/* Trace=[div,index,mul,ONE] */ |
| STOQ(index,iq); |
STOQ(index,iq); |
| nmtodp(mod,mul,&dmul); |
nmtodp(mod,mul,&dmul); |
| node = mknode(4,div,iq,dmul,ONE); |
node = mknode(4,div,iq,dmul,ONE); |
| } |
} |
| sugar = MAX(sugar,SG(p)+TD(DL(mul))); |
sugar = MAX(sugar,SG(p)+TD(DL(mul))); |
| if ( !mod && g && ((double)(p_mag(HCP(g))) > hmag) ) { |
if ( !mod && g && !nd_vc && ((double)(p_mag(HCP(g))) > hmag) ) { |
| hg = HCU(g); |
hg = HCU(g); |
| nd_removecont2(d,g); |
nd_removecont2(d,g); |
| if ( dn || GenTrace ) { |
if ( dn || nd_gentrace ) { |
| /* overwrite cont : Trace=[div,index,mul,cont] */ |
/* overwrite cont : Trace=[div,index,mul,cont] */ |
| cont = ndc_div(mod,hg,HCU(g)); |
cont = ndc_div(mod,hg,HCU(g)); |
| if ( dn ) { |
if ( dn ) { |
| Line 1344 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND |
|
| Line 1425 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND |
|
| reductr(nd_vc,(Obj)tr,&tr1); dn->r = (R)tr1; |
reductr(nd_vc,(Obj)tr,&tr1); dn->r = (R)tr1; |
| } else divq(dn->z,(Q)cont,&dn->z); |
} else divq(dn->z,(Q)cont,&dn->z); |
| } |
} |
| if ( GenTrace && !UNIQ(cont) ) ARG3(node) = (pointer)cont; |
if ( nd_gentrace && !UNIQ(cont) ) ARG3(node) = (pointer)cont; |
| } |
} |
| hmag = ((double)p_mag(HCP(g)))*nd_scale; |
hmag = ((double)p_mag(HCP(g)))*nd_scale; |
| } |
} |
| Line 1476 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp |
|
| Line 1557 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp |
|
| |
|
| /* input : list of NDV, cand : list of NDV */ |
/* input : list of NDV, cand : list of NDV */ |
| |
|
| int ndv_check_candidate(NODE input,int obpe,int oadv,EPOS oepos,NODE cand) |
int ndv_check_membership(int m,NODE input,int obpe,int oadv,EPOS oepos,NODE cand) |
| { |
{ |
| int n,i,stat; |
int n,i,stat; |
| ND nf,d; |
ND nf,d; |
| NDV r; |
NDV r; |
| NODE t,s; |
NODE t,s; |
| union oNDC dn; |
union oNDC dn; |
| |
Q q; |
| |
LIST list; |
| |
|
| ndv_setup(0,0,cand,0,1); |
ndv_setup(m,0,cand,nd_gentrace?1:0,1); |
| n = length(cand); |
n = length(cand); |
| |
|
| |
if ( nd_gentrace ) { nd_alltracelist = 0; nd_tracelist = 0; } |
| /* membercheck : list is a subset of Id(cand) ? */ |
/* membercheck : list is a subset of Id(cand) ? */ |
| for ( t = input; t; t = NEXT(t) ) { |
for ( t = input, i = 0; t; t = NEXT(t), i++ ) { |
| again: |
again: |
| |
nd_tracelist = 0; |
| if ( nd_bpe > obpe ) |
if ( nd_bpe > obpe ) |
| r = ndv_dup_realloc((NDV)BDY(t),obpe,oadv,oepos); |
r = ndv_dup_realloc((NDV)BDY(t),obpe,oadv,oepos); |
| else |
else |
| r = (NDV)BDY(t); |
r = (NDV)BDY(t); |
| d = ndvtond(0,r); |
d = ndvtond(m,r); |
| stat = nd_nf(0,0,d,nd_ps,0,0,&nf); |
stat = nd_nf(m,0,d,nd_ps,0,0,&nf); |
| if ( !stat ) { |
if ( !stat ) { |
| nd_reconstruct(0,0); |
nd_reconstruct(0,0); |
| goto again; |
goto again; |
| } else if ( nf ) return 0; |
} else if ( nf ) return 0; |
| |
if ( nd_gentrace ) { |
| |
nd_tracelist = reverse_node(nd_tracelist); |
| |
MKLIST(list,nd_tracelist); |
| |
STOQ(i,q); s = mknode(2,q,list); MKLIST(list,s); |
| |
MKNODE(s,list,nd_alltracelist); |
| |
nd_alltracelist = s; nd_tracelist = 0; |
| |
} |
| if ( DP_Print ) { printf("."); fflush(stdout); } |
if ( DP_Print ) { printf("."); fflush(stdout); } |
| } |
} |
| if ( DP_Print ) { printf("\n"); } |
if ( DP_Print ) { printf("\n"); } |
| /* gbcheck : cand is a GB of Id(cand) ? */ |
|
| if ( !nd_gb(0,0,1,0) ) return 0; |
|
| /* XXX */ |
|
| return 1; |
return 1; |
| } |
} |
| |
|
| Line 1558 void free_pbucket(PGeoBucket b) { |
|
| Line 1647 void free_pbucket(PGeoBucket b) { |
|
| nd_free(b->body[i]); |
nd_free(b->body[i]); |
| b->body[i] = 0; |
b->body[i] = 0; |
| } |
} |
| GC_free(b); |
GCFREE(b); |
| } |
} |
| |
|
| void add_pbucket_symbolic(PGeoBucket g,ND d) |
void add_pbucket_symbolic(PGeoBucket g,ND d) |
| Line 1813 int do_diagonalize(int sugar,int m) |
|
| Line 1902 int do_diagonalize(int sugar,int m) |
|
| Q iq; |
Q iq; |
| |
|
| for ( i = nd_psn-1; i >= 0 && SG(nd_psh[i]) == sugar; i-- ) { |
for ( i = nd_psn-1; i >= 0 && SG(nd_psh[i]) == sugar; i-- ) { |
| if ( GenTrace ) { |
if ( nd_gentrace ) { |
| /* Trace = [1,index,1,1] */ |
/* Trace = [1,index,1,1] */ |
| STOQ(i,iq); node = mknode(4,ONE,iq,ONE,ONE); |
STOQ(i,iq); node = mknode(4,ONE,iq,ONE,ONE); |
| MKLIST(l,node); MKNODE(nd_tracelist,l,0); |
MKLIST(l,node); MKNODE(nd_tracelist,l,0); |
| Line 1829 int do_diagonalize(int sugar,int m) |
|
| Line 1918 int do_diagonalize(int sugar,int m) |
|
| ndv_free(nfv); |
ndv_free(nfv); |
| hc = HCU(nf); nd_removecont(m,nf); |
hc = HCU(nf); nd_removecont(m,nf); |
| cont = ndc_div(m,hc,HCU(nf)); |
cont = ndc_div(m,hc,HCU(nf)); |
| if ( GenTrace ) finalize_tracelist(i,cont); |
if ( nd_gentrace ) finalize_tracelist(i,cont); |
| nfv = ndtondv(m,nf); |
nfv = ndtondv(m,nf); |
| nd_free(nf); |
nd_free(nf); |
| nd_bound[i] = ndv_compute_bound(nfv); |
nd_bound[i] = ndv_compute_bound(nfv); |
| Line 1843 int do_diagonalize(int sugar,int m) |
|
| Line 1932 int do_diagonalize(int sugar,int m) |
|
| return 1; |
return 1; |
| } |
} |
| |
|
| |
LIST compute_splist() |
| |
{ |
| |
NODE g,tn0,tn,node; |
| |
LIST l0; |
| |
ND_pairs d,t; |
| |
int i; |
| |
Q i1,i2; |
| |
|
| |
g = 0; d = 0; |
| |
for ( i = 0; i < nd_psn; i++ ) { |
| |
d = update_pairs(d,g,i,0); |
| |
g = update_base(g,i); |
| |
} |
| |
for ( t = d, tn0 = 0; t; t = NEXT(t) ) { |
| |
NEXTNODE(tn0,tn); |
| |
STOQ(t->i1,i1); STOQ(t->i2,i2); |
| |
node = mknode(2,i1,i2); MKLIST(l0,node); |
| |
BDY(tn) = l0; |
| |
} |
| |
if ( tn0 ) NEXT(tn) = 0; MKLIST(l0,tn0); |
| |
return l0; |
| |
} |
| |
|
| /* return value = 0 => input is not a GB */ |
/* return value = 0 => input is not a GB */ |
| |
|
| NODE nd_gb(int m,int ishomo,int checkonly,int **indp) |
NODE nd_gb(int m,int ishomo,int checkonly,int gensyz,int **indp) |
| { |
{ |
| int i,nh,sugar,stat; |
int i,nh,sugar,stat; |
| NODE r,g,t; |
NODE r,g,t; |
| Line 1861 NODE nd_gb(int m,int ishomo,int checkonly,int **indp) |
|
| Line 1973 NODE nd_gb(int m,int ishomo,int checkonly,int **indp) |
|
| |
|
| g = 0; d = 0; |
g = 0; d = 0; |
| for ( i = 0; i < nd_psn; i++ ) { |
for ( i = 0; i < nd_psn; i++ ) { |
| d = update_pairs(d,g,i); |
d = update_pairs(d,g,i,gensyz); |
| g = update_base(g,i); |
g = update_base(g,i); |
| } |
} |
| sugar = 0; |
sugar = 0; |
|
|
| goto again; |
goto again; |
| } |
} |
| #if USE_GEOBUCKET |
#if USE_GEOBUCKET |
| stat = (m&&!GenTrace)?nd_nf_pbucket(m,h,nd_ps,!Top,&nf) |
stat = (m&&!nd_gentrace)?nd_nf_pbucket(m,h,nd_ps,!Top,&nf) |
| :nd_nf(m,0,h,nd_ps,!Top,0,&nf); |
:nd_nf(m,0,h,nd_ps,!Top,0,&nf); |
| #else |
#else |
| stat = nd_nf(m,0,h,nd_ps,!Top,0,&nf); |
stat = nd_nf(m,0,h,nd_ps,!Top,0,&nf); |
|
|
| d = nd_reconstruct(0,d); |
d = nd_reconstruct(0,d); |
| goto again; |
goto again; |
| } else if ( nf ) { |
} else if ( nf ) { |
| if ( checkonly ) return 0; |
if ( checkonly || gensyz ) return 0; |
| |
if ( nd_newelim ) { |
| |
if ( nd_module ) { |
| |
if ( MPOS(HDL(nf)) > 1 ) return 0; |
| |
} else if ( !(HDL(nf)[nd_exporigin] & nd_mask[0]) ) return 0; |
| |
} |
| if ( DP_Print ) { printf("+"); fflush(stdout); } |
if ( DP_Print ) { printf("+"); fflush(stdout); } |
| hc = HCU(nf); |
hc = HCU(nf); |
| nd_removecont(m,nf); |
nd_removecont(m,nf); |
|
|
| nd_monic(0,&nf); |
nd_monic(0,&nf); |
| nd_removecont(m,nf); |
nd_removecont(m,nf); |
| } |
} |
| if ( GenTrace ) { |
if ( nd_gentrace ) { |
| cont = ndc_div(m,hc,HCU(nf)); |
cont = ndc_div(m,hc,HCU(nf)); |
| if ( m || !UNIQ(cont) ) { |
if ( m || !UNIQ(cont) ) { |
| t = mknode(4,0,0,0,cont); |
t = mknode(4,NULLP,NULLP,NULLP,cont); |
| MKLIST(list,t); MKNODE(t,list,nd_tracelist); |
MKLIST(list,t); MKNODE(t,list,nd_tracelist); |
| nd_tracelist = t; |
nd_tracelist = t; |
| } |
} |
| } |
} |
| nfv = ndtondv(m,nf); nd_free(nf); |
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) ) { |
if ( !m && (ishomo && ++diag_count == diag_period) ) { |
| diag_count = 0; |
diag_count = 0; |
| stat = do_diagonalize(sugar,m); |
stat = do_diagonalize(sugar,m); |
|
|
| goto again; |
goto again; |
| } |
} |
| } |
} |
| d = update_pairs(d,g,nh); |
d = update_pairs(d,g,nh,0); |
| g = update_base(g,nh); |
g = update_base(g,nh); |
| FREENDP(l); |
FREENDP(l); |
| } else { |
} else { |
| |
if ( nd_gentrace && gensyz ) { |
| |
nd_tracelist = reverse_node(nd_tracelist); |
| |
MKLIST(list,nd_tracelist); |
| |
STOQ(-1,q); t = mknode(2,q,list); MKLIST(list,t); |
| |
MKNODE(t,list,nd_alltracelist); |
| |
nd_alltracelist = t; nd_tracelist = 0; |
| |
} |
| if ( DP_Print ) { printf("."); fflush(stdout); } |
if ( DP_Print ) { printf("."); fflush(stdout); } |
| FREENDP(l); |
FREENDP(l); |
| } |
} |
|
|
| return g; |
return g; |
| } |
} |
| |
|
| |
/* splist = [[i1,i2],...] */ |
| |
|
| |
int check_splist(int m,NODE splist) |
| |
{ |
| |
NODE t,p; |
| |
ND_pairs d,r,l; |
| |
int stat; |
| |
ND h,nf; |
| |
|
| |
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 ) { |
| |
again: |
| |
l = nd_minp(d,&d); |
| |
stat = nd_sp(m,0,l,&h); |
| |
if ( !stat ) { |
| |
NEXT(l) = d; d = l; |
| |
d = nd_reconstruct(0,d); |
| |
goto again; |
| |
} |
| |
stat = nd_nf(m,0,h,nd_ps,!Top,0,&nf); |
| |
if ( !stat ) { |
| |
NEXT(l) = d; d = l; |
| |
d = nd_reconstruct(0,d); |
| |
goto again; |
| |
} else if ( nf ) return 0; |
| |
if ( DP_Print) { printf("."); fflush(stdout); } |
| |
} |
| |
if ( DP_Print) { printf("done.\n"); fflush(stdout); } |
| |
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 do_diagonalize_trace(int sugar,int m) |
| { |
{ |
| int i,nh,stat; |
int i,nh,stat; |
| Line 1952 int do_diagonalize_trace(int sugar,int m) |
|
| Line 2155 int do_diagonalize_trace(int sugar,int m) |
|
| P cont,cont1; |
P cont,cont1; |
| |
|
| for ( i = nd_psn-1; i >= 0 && SG(nd_psh[i]) == sugar; i-- ) { |
for ( i = nd_psn-1; i >= 0 && SG(nd_psh[i]) == sugar; i-- ) { |
| if ( GenTrace ) { |
if ( nd_gentrace ) { |
| /* Trace = [1,index,1,1] */ |
/* Trace = [1,index,1,1] */ |
| STOQ(i,iq); node = mknode(4,ONE,iq,ONE,ONE); |
STOQ(i,iq); node = mknode(4,ONE,iq,ONE,ONE); |
| MKLIST(l,node); MKNODE(nd_tracelist,l,0); |
MKLIST(l,node); MKNODE(nd_tracelist,l,0); |
| Line 1979 int do_diagonalize_trace(int sugar,int m) |
|
| Line 2182 int do_diagonalize_trace(int sugar,int m) |
|
| ndv_free(nfv); |
ndv_free(nfv); |
| hc = HCU(nf); nd_removecont(0,nf); |
hc = HCU(nf); nd_removecont(0,nf); |
| cont = ndc_div(0,hc,HCU(nf)); |
cont = ndc_div(0,hc,HCU(nf)); |
| if ( GenTrace ) finalize_tracelist(i,cont); |
if ( nd_gentrace ) finalize_tracelist(i,cont); |
| nfv = ndtondv(0,nf); |
nfv = ndtondv(0,nf); |
| nd_free(nf); |
nd_free(nf); |
| nd_bound[i] = ndv_compute_bound(nfv); |
nd_bound[i] = ndv_compute_bound(nfv); |
| Line 2028 NODE nd_gb_trace(int m,int ishomo,int **indp) |
|
| Line 2231 NODE nd_gb_trace(int m,int ishomo,int **indp) |
|
| init_eg(&eg_le); |
init_eg(&eg_le); |
| g = 0; d = 0; |
g = 0; d = 0; |
| for ( i = 0; i < nd_psn; i++ ) { |
for ( i = 0; i < nd_psn; i++ ) { |
| d = update_pairs(d,g,i); |
d = update_pairs(d,g,i,0); |
| g = update_base(g,i); |
g = update_base(g,i); |
| } |
} |
| sugar = 0; |
sugar = 0; |
|
|
| nd_removecont(0,nfq); nfqv = ndtondv(0,nfq); nd_free(nfq); |
nd_removecont(0,nfq); nfqv = ndtondv(0,nfq); nd_free(nfq); |
| nd_removecont(m,nf); nfv = ndtondv(m,nf); nd_free(nf); |
nd_removecont(m,nf); nfv = ndtondv(m,nf); nd_free(nf); |
| } |
} |
| if ( GenTrace ) { |
if ( nd_gentrace ) { |
| cont = ndc_div(0,hnfq,HCU(nfqv)); |
cont = ndc_div(0,hnfq,HCU(nfqv)); |
| if ( !UNIQ(cont) ) { |
if ( !UNIQ(cont) ) { |
| t = mknode(4,0,0,0,cont); |
t = mknode(4,NULLP,NULLP,NULLP,cont); |
| MKLIST(list,t); MKNODE(t,list,nd_tracelist); |
MKLIST(list,t); MKNODE(t,list,nd_tracelist); |
| nd_tracelist = t; |
nd_tracelist = t; |
| } |
} |
| } |
} |
| nh = ndv_newps(0,nfv,nfqv); |
nh = ndv_newps(0,nfv,nfqv,0); |
| if ( ishomo && ++diag_count == diag_period ) { |
if ( ishomo && ++diag_count == diag_period ) { |
| diag_count = 0; |
diag_count = 0; |
| if ( DP_Print > 2 ) fprintf(asir_out,"|"); |
if ( DP_Print > 2 ) fprintf(asir_out,"|"); |
|
|
| goto again; |
goto again; |
| } |
} |
| } |
} |
| d = update_pairs(d,g,nh); |
d = update_pairs(d,g,nh,0); |
| g = update_base(g,nh); |
g = update_base(g,nh); |
| } else { |
} else { |
| if ( DP_Print ) { printf("*"); fflush(stdout); } |
if ( DP_Print ) { printf("*"); fflush(stdout); } |
| Line 2175 NODE ndv_reduceall(int m,NODE f) |
|
| Line 2378 NODE ndv_reduceall(int m,NODE f) |
|
| union oNDC hc; |
union oNDC hc; |
| P cont,cont1; |
P cont,cont1; |
| |
|
| |
if ( nd_nora ) return f; |
| n = length(f); |
n = length(f); |
| ndv_setup(m,0,f,0,1); |
ndv_setup(m,0,f,0,1); |
| perm = (int *)MALLOC(n*sizeof(int)); |
perm = (int *)MALLOC(n*sizeof(int)); |
| if ( GenTrace ) { |
if ( nd_gentrace ) { |
| for ( t = nd_tracelist, i = 0; i < n; i++, t = NEXT(t) ) |
for ( t = nd_tracelist, i = 0; i < n; i++, t = NEXT(t) ) |
| perm[i] = QTOS((Q)ARG1(BDY((LIST)BDY(t)))); |
perm[i] = QTOS((Q)ARG1(BDY((LIST)BDY(t)))); |
| } |
} |
| for ( i = 0; i < n; ) { |
for ( i = 0; i < n; ) { |
| if ( GenTrace ) { |
if ( nd_gentrace ) { |
| /* Trace = [1,index,1,1] */ |
/* Trace = [1,index,1,1] */ |
| STOQ(i,iq); node = mknode(4,ONE,iq,ONE,ONE); |
STOQ(i,iq); node = mknode(4,ONE,iq,ONE,ONE); |
| MKLIST(l,node); MKNODE(nd_tracelist,l,0); |
MKLIST(l,node); MKNODE(nd_tracelist,l,0); |
| Line 2197 NODE ndv_reduceall(int m,NODE f) |
|
| Line 2401 NODE ndv_reduceall(int m,NODE f) |
|
| if ( DP_Print ) { printf("."); fflush(stdout); } |
if ( DP_Print ) { printf("."); fflush(stdout); } |
| ndv_free(nd_ps[i]); |
ndv_free(nd_ps[i]); |
| hc = HCU(nf); nd_removecont(m,nf); |
hc = HCU(nf); nd_removecont(m,nf); |
| if ( GenTrace ) { |
if ( nd_gentrace ) { |
| for ( t = nd_tracelist; t; t = NEXT(t) ) { |
for ( t = nd_tracelist; t; t = NEXT(t) ) { |
| jq = ARG1(BDY((LIST)BDY(t))); j = QTOS(jq); |
jq = ARG1(BDY((LIST)BDY(t))); j = QTOS(jq); |
| STOQ(perm[j],jq); ARG1(BDY((LIST)BDY(t))) = jq; |
STOQ(perm[j],jq); ARG1(BDY((LIST)BDY(t))) = jq; |
| Line 2213 NODE ndv_reduceall(int m,NODE f) |
|
| Line 2417 NODE ndv_reduceall(int m,NODE f) |
|
| if ( DP_Print ) { printf("\n"); } |
if ( DP_Print ) { printf("\n"); } |
| for ( a0 = 0, i = 0; i < n; i++ ) { |
for ( a0 = 0, i = 0; i < n; i++ ) { |
| NEXTNODE(a0,a); |
NEXTNODE(a0,a); |
| if ( !GenTrace ) BDY(a) = (pointer)nd_ps[i]; |
if ( !nd_gentrace ) BDY(a) = (pointer)nd_ps[i]; |
| else { |
else { |
| for ( j = 0; j < n; j++ ) if ( perm[j] == i ) break; |
for ( j = 0; j < n; j++ ) if ( perm[j] == i ) break; |
| BDY(a) = (pointer)nd_ps[j]; |
BDY(a) = (pointer)nd_ps[j]; |
| Line 2223 NODE ndv_reduceall(int m,NODE f) |
|
| Line 2427 NODE ndv_reduceall(int m,NODE f) |
|
| return a0; |
return a0; |
| } |
} |
| |
|
| ND_pairs update_pairs( ND_pairs d, NODE /* of index */ g, int t) |
ND_pairs update_pairs( ND_pairs d, NODE /* of index */ g, int t, int gensyz) |
| { |
{ |
| ND_pairs d1,nd,cur,head,prev,remove; |
ND_pairs d1,nd,cur,head,prev,remove; |
| |
|
| if ( !g ) return d; |
if ( !g ) return d; |
| |
/* for testing */ |
| |
if ( gensyz && nd_gensyz == 2 ) { |
| |
d1 = nd_newpairs(g,t); |
| |
if ( !d ) |
| |
return d1; |
| |
else { |
| |
nd = d; |
| |
while ( NEXT(nd) ) nd = NEXT(nd); |
| |
NEXT(nd) = d1; |
| |
return d; |
| |
} |
| |
} |
| d = crit_B(d,t); |
d = crit_B(d,t); |
| d1 = nd_newpairs(g,t); |
d1 = nd_newpairs(g,t); |
| d1 = crit_M(d1); |
d1 = crit_M(d1); |
| d1 = crit_F(d1); |
d1 = crit_F(d1); |
| if ( do_weyl ) |
if ( gensyz || do_weyl ) |
| head = d1; |
head = d1; |
| else { |
else { |
| prev = 0; cur = head = d1; |
prev = 0; cur = head = d1; |
| Line 2262 ND_pairs nd_newpairs( NODE g, int t ) |
|
| Line 2478 ND_pairs nd_newpairs( NODE g, int t ) |
|
| { |
{ |
| NODE h; |
NODE h; |
| UINT *dl; |
UINT *dl; |
| int ts,s; |
int ts,s,i,t0,min,max; |
| ND_pairs r,r0; |
ND_pairs r,r0; |
| |
|
| dl = DL(nd_psh[t]); |
dl = DL(nd_psh[t]); |
| ts = SG(nd_psh[t]) - TD(dl); |
ts = SG(nd_psh[t]) - TD(dl); |
| |
if ( nd_module && nd_intersect && (MPOS(dl) > 1) ) return 0; |
| for ( r0 = 0, h = g; h; h = NEXT(h) ) { |
for ( r0 = 0, h = g; h; h = NEXT(h) ) { |
| if ( nd_module && (MPOS(DL(nd_psh[(long)BDY(h)])) != MPOS(dl)) ) |
if ( nd_module && (MPOS(DL(nd_psh[(long)BDY(h)])) != MPOS(dl)) ) |
| continue; |
continue; |
| |
if ( nd_gbblock ) { |
| |
t0 = (long)BDY(h); |
| |
for ( i = 0; nd_gbblock[i] >= 0; i += 2 ) { |
| |
min = nd_gbblock[i]; max = nd_gbblock[i+1]; |
| |
if ( t0 >= min && t0 <= max && t >= min && t <= max ) |
| |
break; |
| |
} |
| |
if ( nd_gbblock[i] >= 0 ) |
| |
continue; |
| |
} |
| NEXTND_pairs(r0,r); |
NEXTND_pairs(r0,r); |
| r->i1 = (long)BDY(h); |
r->i1 = (long)BDY(h); |
| r->i2 = t; |
r->i2 = t; |
| Line 2508 ND_pairs nd_minsugarp( ND_pairs d, ND_pairs *prest ) |
|
| Line 2735 ND_pairs nd_minsugarp( ND_pairs d, ND_pairs *prest ) |
|
| return dm0; |
return dm0; |
| } |
} |
| |
|
| int ndv_newps(int m,NDV a,NDV aq) |
int ndv_newps(int m,NDV a,NDV aq,int f4) |
| { |
{ |
| int len; |
int len; |
| RHist r; |
RHist r; |
| Line 2520 int ndv_newps(int m,NDV a,NDV aq) |
|
| Line 2747 int ndv_newps(int m,NDV a,NDV aq) |
|
| if ( nd_psn == nd_pslen ) { |
if ( nd_psn == nd_pslen ) { |
| nd_pslen *= 2; |
nd_pslen *= 2; |
| nd_ps = (NDV *)REALLOC((char *)nd_ps,nd_pslen*sizeof(NDV)); |
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_ps_trace = (NDV *)REALLOC((char *)nd_ps_trace,nd_pslen*sizeof(NDV)); |
| nd_psh = (RHist *)REALLOC((char *)nd_psh,nd_pslen*sizeof(RHist)); |
nd_psh = (RHist *)REALLOC((char *)nd_psh,nd_pslen*sizeof(RHist)); |
| nd_bound = (UINT **) |
nd_bound = (UINT **) |
| REALLOC((char *)nd_bound,nd_pslen*sizeof(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; |
NEWRHist(r); nd_psh[nd_psn] = r; |
| nd_ps[nd_psn] = a; |
nd_ps[nd_psn] = a; |
| if ( aq ) { |
if ( aq ) { |
| nd_ps_trace[nd_psn] = aq; |
nd_ps_trace[nd_psn] = aq; |
| |
if ( !nd_vc ) nd_ps_gz[nd_psn] = ndvtondvgz(aq); |
| register_hcf(aq); |
register_hcf(aq); |
| nd_bound[nd_psn] = ndv_compute_bound(aq); |
nd_bound[nd_psn] = ndv_compute_bound(aq); |
| SG(r) = SG(aq); ndl_copy(HDL(aq),DL(r)); |
SG(r) = SG(aq); ndl_copy(HDL(aq),DL(r)); |
| Line 2536 int ndv_newps(int m,NDV a,NDV aq) |
|
| Line 2767 int ndv_newps(int m,NDV a,NDV aq) |
|
| if ( !m ) register_hcf(a); |
if ( !m ) register_hcf(a); |
| nd_bound[nd_psn] = ndv_compute_bound(a); |
nd_bound[nd_psn] = ndv_compute_bound(a); |
| SG(r) = SG(a); ndl_copy(HDL(a),DL(r)); |
SG(r) = SG(a); ndl_copy(HDL(a),DL(r)); |
| |
if ( !m && !nd_vc ) nd_ps_gz[nd_psn] = ndvtondvgz(a); |
| } |
} |
| if ( nd_demand ) { |
if ( nd_demand ) { |
| if ( aq ) { |
if ( aq ) { |
| ndv_save(nd_ps_trace[nd_psn],nd_psn); |
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; |
nd_ps_trace[nd_psn] = 0; |
| } else { |
} else { |
| ndv_save(nd_ps[nd_psn],nd_psn); |
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; |
nd_ps[nd_psn] = 0; |
| } |
} |
| } |
} |
| if ( GenTrace ) { |
if ( nd_gentrace ) { |
| /* reverse the tracelist and append it to alltracelist */ |
/* reverse the tracelist and append it to alltracelist */ |
| nd_tracelist = reverse_node(nd_tracelist); MKLIST(l,nd_tracelist); |
nd_tracelist = reverse_node(nd_tracelist); MKLIST(l,nd_tracelist); |
| STOQ(nd_psn,iq); tn = mknode(2,iq,l); MKLIST(l,tn); |
STOQ(nd_psn,iq); tn = mknode(2,iq,l); MKLIST(l,tn); |
| Line 2556 int ndv_newps(int m,NDV a,NDV aq) |
|
| Line 2790 int ndv_newps(int m,NDV a,NDV aq) |
|
| } |
} |
| |
|
| /* nd_tracelist = [[0,index,div],...,[nd_psn-1,index,div]] */ |
/* nd_tracelist = [[0,index,div],...,[nd_psn-1,index,div]] */ |
| |
/* return 1 if success, 0 if failure (HC(a mod p)) */ |
| |
|
| void ndv_setup(int mod,int trace,NODE f,int dont_sort,int dont_removecont) |
int ndv_setup(int mod,int trace,NODE f,int dont_sort,int dont_removecont) |
| { |
{ |
| int i,j,td,len,max; |
int i,j,td,len,max; |
| NODE s,s0,f0,tn; |
NODE s,s0,f0,tn; |
| Line 2590 void ndv_setup(int mod,int trace,NODE f,int dont_sort, |
|
| Line 2825 void ndv_setup(int mod,int trace,NODE f,int dont_sort, |
|
| } |
} |
| nd_pslen = 2*nd_psn; |
nd_pslen = 2*nd_psn; |
| nd_ps = (NDV *)MALLOC(nd_pslen*sizeof(NDV)); |
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_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_psh = (RHist *)MALLOC(nd_pslen*sizeof(RHist)); |
| nd_bound = (UINT **)MALLOC(nd_pslen*sizeof(UINT *)); |
nd_bound = (UINT **)MALLOC(nd_pslen*sizeof(UINT *)); |
| nd_hcf = 0; |
nd_hcf = 0; |
| Line 2607 void ndv_setup(int mod,int trace,NODE f,int dont_sort, |
|
| Line 2845 void ndv_setup(int mod,int trace,NODE f,int dont_sort, |
|
| hc = HCU(w[i].p); |
hc = HCU(w[i].p); |
| if ( trace ) { |
if ( trace ) { |
| a = nd_ps_trace[i] = ndv_dup(0,w[i].p); |
a = nd_ps_trace[i] = ndv_dup(0,w[i].p); |
| |
if ( !nd_vc ) nd_ps_gz[i] = ndvtondvgz(a); |
| if ( !dont_removecont) ndv_removecont(0,a); |
if ( !dont_removecont) ndv_removecont(0,a); |
| register_hcf(a); |
register_hcf(a); |
| am = nd_ps[i] = ndv_dup(mod,a); |
am = nd_ps[i] = ndv_dup(mod,a); |
| ndv_mod(mod,am); |
ndv_mod(mod,am); |
| |
if ( DL_COMPARE(HDL(am),HDL(a)) ) |
| |
return 0; |
| ndv_removecont(mod,am); |
ndv_removecont(mod,am); |
| } else { |
} else { |
| a = nd_ps[i] = ndv_dup(mod,w[i].p); |
a = nd_ps[i] = ndv_dup(mod,w[i].p); |
| |
if ( !mod && !nd_vc ) nd_ps_gz[i] = ndvtondvgz(a); |
| if ( mod || !dont_removecont ) ndv_removecont(mod,a); |
if ( mod || !dont_removecont ) ndv_removecont(mod,a); |
| if ( !mod ) register_hcf(a); |
if ( !mod ) register_hcf(a); |
| } |
} |
| if ( GenTrace ) { |
if ( nd_gentrace ) { |
| STOQ(i,iq); STOQ(w[i].i,jq); node = mknode(3,iq,jq,ONE); |
STOQ(i,iq); STOQ(w[i].i,jq); node = mknode(3,iq,jq,ONE); |
| ARG2(node) = (pointer) |
if ( !dont_removecont ) |
| ndc_div(trace?0:mod,hc,HCU(a)); |
ARG2(node) = (pointer)ndc_div(trace?0:mod,hc,HCU(a)); |
| MKLIST(l,node); NEXTNODE(nd_tracelist,tn); BDY(tn) = l; |
MKLIST(l,node); NEXTNODE(nd_tracelist,tn); BDY(tn) = l; |
| } |
} |
| NEWRHist(r); SG(r) = HTD(a); ndl_copy(HDL(a),DL(r)); |
NEWRHist(r); SG(r) = HTD(a); ndl_copy(HDL(a),DL(r)); |
| Line 2629 void ndv_setup(int mod,int trace,NODE f,int dont_sort, |
|
| Line 2871 void ndv_setup(int mod,int trace,NODE f,int dont_sort, |
|
| if ( nd_demand ) { |
if ( nd_demand ) { |
| if ( trace ) { |
if ( trace ) { |
| ndv_save(nd_ps_trace[i],i); |
ndv_save(nd_ps_trace[i],i); |
| |
nd_ps_trace_sym[i] = ndv_symbolic(mod,nd_ps_trace[i]); |
| nd_ps_trace[i] = 0; |
nd_ps_trace[i] = 0; |
| } else { |
} else { |
| ndv_save(nd_ps[i],i); |
ndv_save(nd_ps[i],i); |
| |
nd_ps_sym[i] = ndv_symbolic(mod,nd_ps[i]); |
| nd_ps[i] = 0; |
nd_ps[i] = 0; |
| } |
} |
| } |
} |
| } |
} |
| if ( GenTrace && nd_tracelist ) NEXT(tn) = 0; |
if ( nd_gentrace && nd_tracelist ) NEXT(tn) = 0; |
| |
return 1; |
| } |
} |
| |
|
| struct order_spec *append_block(struct order_spec *spec, |
struct order_spec *append_block(struct order_spec *spec, |
| Line 2744 NODE postprocess_algcoef(VL av,NODE alist,NODE r) |
|
| Line 2989 NODE postprocess_algcoef(VL av,NODE alist,NODE r) |
|
| return u0; |
return u0; |
| } |
} |
| |
|
| void nd_gr(LIST f,LIST v,int m,int f4,struct order_spec *ord,LIST *rp) |
void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int f4,struct order_spec *ord,LIST *rp) |
| { |
{ |
| VL tv,fv,vv,vc,av; |
VL tv,fv,vv,vc,av; |
| NODE fd,fd0,r,r0,t,x,s,xx,alist; |
NODE fd,fd0,r,r0,t,x,s,xx,alist; |
| int e,max,nvar,i; |
int e,max,nvar,i; |
| NDV b; |
NDV b; |
| int ishomo,nalg,mrank,trank; |
int ishomo,nalg,mrank,trank,wmax,len; |
| |
NMV a; |
| Alg alpha,dp; |
Alg alpha,dp; |
| P p,zp; |
P p,zp; |
| Q dmy; |
Q dmy; |
| Line 2758 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe |
|
| Line 3004 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe |
|
| Obj obj; |
Obj obj; |
| NumberField nf; |
NumberField nf; |
| struct order_spec *ord1; |
struct order_spec *ord1; |
| NODE tr,tl1,tl2; |
NODE tr,tl1,tl2,tl3,tl4,nzlist; |
| LIST l1,l2,l3; |
LIST l1,l2,l3,l4,l5; |
| int j; |
int j; |
| Q jq; |
Q jq,bpe; |
| int *perm; |
int *perm; |
| |
EPOS oepos; |
| |
int obpe,oadv,ompos,cbpe; |
| |
|
| nd_module = 0; |
nd_module = 0; |
| if ( !m && Demand ) nd_demand = 1; |
if ( !m && Demand ) nd_demand = 1; |
| else nd_demand = 0; |
else nd_demand = 0; |
| |
parse_nd_option(current_option); |
| |
|
| if ( DP_Multiple ) |
if ( DP_Multiple ) |
| nd_scale = ((double)DP_Multiple)/(double)(Denominator?Denominator:1); |
nd_scale = ((double)DP_Multiple)/(double)(Denominator?Denominator:1); |
| Line 2800 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe |
|
| Line 3049 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe |
|
| } |
} |
| nd_init_ord(ord); |
nd_init_ord(ord); |
| mrank = 0; |
mrank = 0; |
| for ( t = BDY(f), max = 0; t; t = NEXT(t) ) |
for ( t = BDY(f), max = 1; t; t = NEXT(t) ) |
| for ( tv = vv; tv; tv = NEXT(tv) ) { |
for ( tv = vv; tv; tv = NEXT(tv) ) { |
| if ( nd_module ) { |
if ( nd_module ) { |
| s = BDY((LIST)BDY(t)); |
s = BDY((LIST)BDY(t)); |
| Line 2815 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe |
|
| Line 3064 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe |
|
| max = MAX(e,max); |
max = MAX(e,max); |
| } |
} |
| } |
} |
| nd_setup_parameters(nvar,max); |
nd_setup_parameters(nvar,nd_nzlist?0:max); |
| |
obpe = nd_bpe; oadv = nmv_adv; oepos = nd_epos; ompos = nd_mpos; |
| ishomo = 1; |
ishomo = 1; |
| for ( fd0 = 0, t = BDY(f); t; t = NEXT(t) ) { |
for ( fd0 = 0, t = BDY(f); t; t = NEXT(t) ) { |
| if ( nd_module ) { |
if ( nd_module ) { |
| if ( !m && !GenTrace ) pltozpl((LIST)BDY(t),&dmy,&zpl); |
if ( !m && !nd_gentrace ) pltozpl((LIST)BDY(t),&dmy,&zpl); |
| else zpl = (LIST)BDY(t); |
else zpl = (LIST)BDY(t); |
| b = (pointer)pltondv(CO,vv,zpl); |
b = (pointer)pltondv(CO,vv,zpl); |
| } else { |
} else { |
| if ( !m && !GenTrace ) ptozp((P)BDY(t),1,&dmy,&zp); |
if ( !m && !nd_gentrace ) ptozp((P)BDY(t),1,&dmy,&zp); |
| else zp = (P)BDY(t); |
else zp = (P)BDY(t); |
| b = (pointer)ptondv(CO,vv,zp); |
b = (pointer)ptondv(CO,vv,zp); |
| } |
} |
| Line 2833 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe |
|
| Line 3083 void nd_gr(LIST f,LIST v,int m,int f4,struct order_spe |
|
| if ( b ) { NEXTNODE(fd0,fd); BDY(fd) = (pointer)b; } |
if ( b ) { NEXTNODE(fd0,fd); BDY(fd) = (pointer)b; } |
| } |
} |
| if ( fd0 ) NEXT(fd) = 0; |
if ( fd0 ) NEXT(fd) = 0; |
| ndv_setup(m,0,fd0,0,0); |
|
| if ( GenTrace ) { |
if ( !ishomo && homo ) { |
| |
for ( t = fd0, wmax = max; t; t = NEXT(t) ) { |
| |
b = (NDV)BDY(t); len = LEN(b); |
| |
for ( a = BDY(b), i = 0; i < len; i++, NMV_ADV(a) ) |
| |
wmax = MAX(TD(DL(a)),wmax); |
| |
} |
| |
homogenize_order(ord,nvar,&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,ompos); |
| |
} |
| |
|
| |
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); |
MKLIST(l1,nd_tracelist); MKNODE(nd_alltracelist,l1,0); |
| } |
} |
| x = f4?nd_f4(m,&perm):nd_gb(m,ishomo,0,&perm); |
if ( nd_splist ) { |
| |
*rp = compute_splist(); |
| |
return; |
| |
} |
| |
if ( nd_check_splist ) { |
| |
if ( f4 ) { |
| |
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); |
| |
if ( !x ) { |
| |
*rp = 0; return; |
| |
} |
| |
if ( !ishomo && homo ) { |
| |
/* dehomogenization */ |
| |
for ( t = x; t; t = NEXT(t) ) ndv_dehomogenize((NDV)BDY(t),ord); |
| |
nd_init_ord(ord); |
| |
nd_setup_parameters(nvar,0); |
| |
} |
| nd_demand = 0; |
nd_demand = 0; |
| |
if ( nd_module && nd_intersect ) { |
| |
for ( j = nd_psn-1, x = 0; j >= 0; j-- ) |
| |
if ( MPOS(DL(nd_psh[j])) > 1 ) { |
| |
MKNODE(xx,(pointer)j,x); x = xx; |
| |
} |
| |
conv_ilist(nd_demand,0,x,0); |
| |
goto FINAL; |
| |
} |
| |
if ( nd_gentrace && f4 ) { nzlist = nd_alltracelist; } |
| x = ndv_reducebase(x,perm); |
x = ndv_reducebase(x,perm); |
| if ( GenTrace ) { tl1 = nd_alltracelist; nd_alltracelist = 0; } |
if ( nd_gentrace && !f4 ) { tl1 = nd_alltracelist; nd_alltracelist = 0; } |
| x = ndv_reduceall(m,x); |
x = ndv_reduceall(m,x); |
| |
cbpe = nd_bpe; |
| |
if ( nd_gentrace && !f4 ) { |
| |
tl2 = nd_alltracelist; nd_alltracelist = 0; |
| |
ndv_check_membership(m,fd0,obpe,oadv,oepos,x); |
| |
tl3 = nd_alltracelist; nd_alltracelist = 0; |
| |
if ( nd_gensyz ) { |
| |
nd_gb(m,0,1,1,0); |
| |
tl4 = nd_alltracelist; nd_alltracelist = 0; |
| |
} else tl4 = 0; |
| |
} |
| |
nd_bpe = cbpe; |
| |
nd_setup_parameters(nd_nvar,0); |
| |
FINAL: |
| for ( r0 = 0, t = x; t; t = NEXT(t) ) { |
for ( r0 = 0, t = x; t; t = NEXT(t) ) { |
| NEXTNODE(r0,r); |
NEXTNODE(r0,r); |
| if ( nd_module ) BDY(r) = ndvtopl(m,CO,vv,BDY(t),mrank); |
if ( nd_module ) BDY(r) = ndvtopl(m,CO,vv,BDY(t),mrank); |
| else BDY(r) = ndvtop(m,CO,vv,BDY(t)); |
else if ( retdp ) BDY(r) = ndvtodp(m,BDY(t)); |
| |
else BDY(r) = ndvtop(m,CO,vv,BDY(t)); |
| } |
} |
| if ( r0 ) NEXT(r) = 0; |
if ( r0 ) NEXT(r) = 0; |
| if ( nalg ) |
if ( !m && nd_nalg ) |
| r0 = postprocess_algcoef(av,alist,r0); |
r0 = postprocess_algcoef(av,alist,r0); |
| MKLIST(*rp,r0); |
MKLIST(*rp,r0); |
| if ( GenTrace ) { |
if ( nd_gentrace ) { |
| tl2 = nd_alltracelist; nd_alltracelist = 0; |
if ( f4 ) { |
| tl1 = reverse_node(tl1); tl2 = reverse_node(tl2); |
STOQ(16,bpe); |
| /* tl2 = [[i,[[*,j,*,*],...]],...] */ |
tr = mknode(4,*rp,(!ishomo&&homo)?ONE:0,BDY(nzlist),bpe); MKLIST(*rp,tr); |
| for ( t = tl2; t; t = NEXT(t) ) { |
} else { |
| /* s = [i,[*,j,*,*],...] */ |
tl1 = reverse_node(tl1); tl2 = reverse_node(tl2); |
| s = BDY((LIST)BDY(t)); |
tl3 = reverse_node(tl3); |
| j = perm[QTOS((Q)ARG0(s))]; STOQ(j,jq); ARG0(s) = (pointer)jq; |
/* tl2 = [[i,[[*,j,*,*],...]],...] */ |
| for ( s = BDY((LIST)ARG1(s)); s; s = NEXT(s) ) { |
for ( t = tl2; t; t = NEXT(t) ) { |
| j = perm[QTOS((Q)ARG1(BDY((LIST)BDY(s))))]; STOQ(j,jq); |
/* s = [i,[*,j,*,*],...] */ |
| ARG1(BDY((LIST)BDY(s))) = (pointer)jq; |
s = BDY((LIST)BDY(t)); |
| |
j = perm[QTOS((Q)ARG0(s))]; STOQ(j,jq); ARG0(s) = (pointer)jq; |
| |
for ( s = BDY((LIST)ARG1(s)); s; s = NEXT(s) ) { |
| |
j = perm[QTOS((Q)ARG1(BDY((LIST)BDY(s))))]; STOQ(j,jq); |
| |
ARG1(BDY((LIST)BDY(s))) = (pointer)jq; |
| |
} |
| } |
} |
| } |
for ( j = length(x)-1, t = 0; j >= 0; j-- ) { |
| for ( j = length(x)-1, t = 0; j >= 0; j-- ) { |
STOQ(perm[j],jq); MKNODE(s,jq,t); t = s; |
| STOQ(perm[j],jq); MKNODE(s,jq,t); t = s; |
} |
| } |
MKLIST(l1,tl1); MKLIST(l2,tl2); MKLIST(l3,t); MKLIST(l4,tl3); |
| MKLIST(l1,tl1); MKLIST(l2,tl2); MKLIST(l3,t); |
MKLIST(l5,tl4); |
| tr = mknode(5,*rp,0,l1,l2,l3); MKLIST(*rp,tr); |
STOQ(nd_bpe,bpe); |
| |
tr = mknode(8,*rp,(!ishomo&&homo)?ONE:0,l1,l2,l3,l4,l5,bpe); MKLIST(*rp,tr); |
| |
} |
| } |
} |
| #if 0 |
#if 0 |
| fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc); |
fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc); |
| Line 2891 void nd_gr_postproc(LIST f,LIST v,int m,struct order_s |
|
| Line 3208 void nd_gr_postproc(LIST f,LIST v,int m,struct order_s |
|
| struct order_spec *ord1; |
struct order_spec *ord1; |
| int *perm; |
int *perm; |
| |
|
| |
parse_nd_option(current_option); |
| get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&nd_vc); |
get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&nd_vc); |
| for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ ); |
for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ ); |
| switch ( ord->id ) { |
switch ( ord->id ) { |
| Line 2917 void nd_gr_postproc(LIST f,LIST v,int m,struct order_s |
|
| Line 3235 void nd_gr_postproc(LIST f,LIST v,int m,struct order_s |
|
| nvar += nalg; |
nvar += nalg; |
| } |
} |
| nd_init_ord(ord); |
nd_init_ord(ord); |
| for ( t = BDY(f), max = 0; t; t = NEXT(t) ) |
for ( t = BDY(f), max = 1; t; t = NEXT(t) ) |
| for ( tv = vv; tv; tv = NEXT(tv) ) { |
for ( tv = vv; tv; tv = NEXT(tv) ) { |
| e = getdeg(tv->v,(P)BDY(t)); |
e = getdeg(tv->v,(P)BDY(t)); |
| max = MAX(e,max); |
max = MAX(e,max); |
| Line 2937 void nd_gr_postproc(LIST f,LIST v,int m,struct order_s |
|
| Line 3255 void nd_gr_postproc(LIST f,LIST v,int m,struct order_s |
|
| for ( x = 0, i = 0; i < nd_psn; i++ ) |
for ( x = 0, i = 0; i < nd_psn; i++ ) |
| x = update_base(x,i); |
x = update_base(x,i); |
| if ( do_check ) { |
if ( do_check ) { |
| x = nd_gb(m,ishomo,1,&perm); |
x = nd_gb(m,ishomo,1,0,&perm); |
| if ( !x ) { |
if ( !x ) { |
| *rp = 0; |
*rp = 0; |
| return; |
return; |
| } |
} |
| } else { |
} else { |
| |
#if 0 |
| |
/* bug ? */ |
| for ( t = x; t; t = NEXT(t) ) |
for ( t = x; t; t = NEXT(t) ) |
| BDY(t) = (pointer)nd_ps[(long)BDY(t)]; |
BDY(t) = (pointer)nd_ps[(long)BDY(t)]; |
| |
#else |
| |
conv_ilist(0,0,x,&perm); |
| |
#endif |
| } |
} |
| x = ndv_reducebase(x,perm); |
x = ndv_reducebase(x,perm); |
| x = ndv_reduceall(m,x); |
x = ndv_reduceall(m,x); |
| Line 2953 void nd_gr_postproc(LIST f,LIST v,int m,struct order_s |
|
| Line 3276 void nd_gr_postproc(LIST f,LIST v,int m,struct order_s |
|
| BDY(r) = ndvtop(m,CO,vv,BDY(t)); |
BDY(r) = ndvtop(m,CO,vv,BDY(t)); |
| } |
} |
| if ( r0 ) NEXT(r) = 0; |
if ( r0 ) NEXT(r) = 0; |
| if ( nalg ) |
if ( !m && nd_nalg ) |
| r0 = postprocess_algcoef(av,alist,r0); |
r0 = postprocess_algcoef(av,alist,r0); |
| MKLIST(*rp,r0); |
MKLIST(*rp,r0); |
| } |
} |
| |
|
| |
NDV recompute_trace(NODE trace,NDV *p,int m); |
| |
void nd_gr_recompute_trace(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist,LIST *rp); |
| |
|
| |
NDV recompute_trace(NODE ti,NDV *p,int mod) |
| |
{ |
| |
int c,c1,c2,i; |
| |
NM mul,m,tail; |
| |
ND d,r,rm; |
| |
NODE sj; |
| |
NDV red; |
| |
Obj mj; |
| |
static int afo=0; |
| |
|
| |
afo++; |
| |
mul = (NM)ALLOCA(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT)); |
| |
CM(mul) = 1; |
| |
tail = 0; |
| |
for ( i = 0, d = r = 0; ti; ti = NEXT(ti), i++ ) { |
| |
sj = BDY((LIST)BDY(ti)); |
| |
if ( ARG0(sj) ) { |
| |
red = p[QTOS((Q)ARG1(sj))]; |
| |
mj = (Obj)ARG2(sj); |
| |
if ( OID(mj) != O_DP ) ndl_zero(DL(mul)); |
| |
else dltondl(nd_nvar,BDY((DP)mj)->dl,DL(mul)); |
| |
rm = ndv_mul_nm(mod,mul,red); |
| |
if ( !r ) r = rm; |
| |
else { |
| |
for ( m = BDY(r); m && !ndl_equal(m->dl,BDY(rm)->dl); m = NEXT(m), LEN(r)-- ) { |
| |
if ( d ) { |
| |
NEXT(tail) = m; tail = m; LEN(d)++; |
| |
} else { |
| |
MKND(nd_nvar,m,1,d); tail = BDY(d); |
| |
} |
| |
} |
| |
if ( !m ) return 0; /* failure */ |
| |
else { |
| |
BDY(r) = m; |
| |
c1 = invm(HCM(rm),mod); c2 = mod-HCM(r); |
| |
DMAR(c1,c2,0,mod,c); |
| |
nd_mul_c(mod,rm,c); |
| |
r = nd_add(mod,r,rm); |
| |
} |
| |
} |
| |
} |
| |
} |
| |
if ( tail ) NEXT(tail) = 0; |
| |
d = nd_add(mod,d,r); |
| |
nd_mul_c(mod,d,invm(HCM(d),mod)); |
| |
return ndtondv(mod,d); |
| |
} |
| |
|
| |
void nd_gr_recompute_trace(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist,LIST *rp) |
| |
{ |
| |
VL tv,fv,vv,vc,av; |
| |
NODE fd,fd0,r,r0,t,x,s,xx,alist; |
| |
int e,max,nvar,i; |
| |
NDV b; |
| |
int ishomo,nalg; |
| |
Alg alpha,dp; |
| |
P p,zp; |
| |
Q dmy; |
| |
LIST f1,f2; |
| |
Obj obj; |
| |
NumberField nf; |
| |
struct order_spec *ord1; |
| |
NODE permtrace,intred,ind,perm,trace,ti; |
| |
int len,n,j; |
| |
NDV *db,*pb; |
| |
|
| |
parse_nd_option(current_option); |
| |
get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&nd_vc); |
| |
for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ ); |
| |
switch ( ord->id ) { |
| |
case 1: |
| |
if ( ord->nv != nvar ) |
| |
error("nd_check : invalid order specification"); |
| |
break; |
| |
default: |
| |
break; |
| |
} |
| |
nd_init_ord(ord); |
| |
nd_bpe = QTOS((Q)ARG7(BDY(tlist))); |
| |
nd_setup_parameters(nvar,0); |
| |
|
| |
len = length(BDY(f)); |
| |
db = (NDV *)MALLOC(len*sizeof(NDV *)); |
| |
for ( i = 0, t = BDY(f); t; i++, t = NEXT(t) ) { |
| |
ptozp((P)BDY(t),1,&dmy,&zp); |
| |
b = ptondv(CO,vv,zp); |
| |
ndv_mod(m,b); |
| |
ndv_mul_c(m,b,invm(HCM(b),m)); |
| |
db[i] = b; |
| |
} |
| |
|
| |
permtrace = BDY((LIST)ARG2(BDY(tlist))); |
| |
intred = BDY((LIST)ARG3(BDY(tlist))); |
| |
ind = BDY((LIST)ARG4(BDY(tlist))); |
| |
perm = BDY((LIST)ARG0(permtrace)); |
| |
trace = NEXT(permtrace); |
| |
|
| |
for ( i = length(perm)-1, t = trace; t; t = NEXT(t) ) { |
| |
j = QTOS((Q)ARG0(BDY((LIST)BDY(t)))); |
| |
if ( j > i ) i = j; |
| |
} |
| |
n = i+1; |
| |
pb = (NDV *)MALLOC(n*sizeof(NDV *)); |
| |
for ( t = perm, i = 0; t; t = NEXT(t), i++ ) { |
| |
ti = BDY((LIST)BDY(t)); |
| |
pb[QTOS((Q)ARG0(ti))] = db[QTOS((Q)ARG1(ti))]; |
| |
} |
| |
for ( t = trace; t; t = NEXT(t) ) { |
| |
ti = BDY((LIST)BDY(t)); |
| |
pb[QTOS((Q)ARG0(ti))] = recompute_trace(BDY((LIST)ARG1(ti)),pb,m); |
| |
if ( !pb[QTOS((Q)ARG0(ti))] ) { *rp = 0; return; } |
| |
if ( DP_Print ) { |
| |
fprintf(asir_out,"."); fflush(asir_out); |
| |
} |
| |
} |
| |
for ( t = intred; t; t = NEXT(t) ) { |
| |
ti = BDY((LIST)BDY(t)); |
| |
pb[QTOS((Q)ARG0(ti))] = recompute_trace(BDY((LIST)ARG1(ti)),pb,m); |
| |
if ( !pb[QTOS((Q)ARG0(ti))] ) { *rp = 0; return; } |
| |
if ( DP_Print ) { |
| |
fprintf(asir_out,"*"); fflush(asir_out); |
| |
} |
| |
} |
| |
for ( r0 = 0, t = ind; t; t = NEXT(t) ) { |
| |
NEXTNODE(r0,r); |
| |
b = pb[QTOS((Q)BDY(t))]; |
| |
ndv_mul_c(m,b,invm(HCM(b),m)); |
| |
#if 0 |
| |
BDY(r) = ndvtop(m,CO,vv,pb[QTOS((Q)BDY(t))]); |
| |
#else |
| |
BDY(r) = ndvtodp(m,pb[QTOS((Q)BDY(t))]); |
| |
#endif |
| |
} |
| |
if ( r0 ) NEXT(r) = 0; |
| |
MKLIST(*rp,r0); |
| |
if ( DP_Print ) fprintf(asir_out,"\n"); |
| |
} |
| |
|
| void nd_gr_trace(LIST f,LIST v,int trace,int homo,int f4,struct order_spec *ord,LIST *rp) |
void nd_gr_trace(LIST f,LIST v,int trace,int homo,int f4,struct order_spec *ord,LIST *rp) |
| { |
{ |
| VL tv,fv,vv,vc,av; |
VL tv,fv,vv,vc,av; |
| Line 2976 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| Line 3440 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| NumberField nf; |
NumberField nf; |
| struct order_spec *ord1; |
struct order_spec *ord1; |
| struct oEGT eg_check,eg0,eg1; |
struct oEGT eg_check,eg0,eg1; |
| NODE tr,tl1,tl2; |
NODE tr,tl1,tl2,tl3,tl4; |
| LIST l1,l2,l3; |
LIST l1,l2,l3,l4,l5; |
| int *perm; |
int *perm; |
| int j; |
int j,ret; |
| Q jq; |
Q jq,bpe; |
| |
|
| nd_module = 0; |
nd_module = 0; |
| |
parse_nd_option(current_option); |
| if ( DP_Multiple ) |
if ( DP_Multiple ) |
| nd_scale = ((double)DP_Multiple)/(double)(Denominator?Denominator:1); |
nd_scale = ((double)DP_Multiple)/(double)(Denominator?Denominator:1); |
| |
|
| Line 3023 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| Line 3488 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| m = trace > 1 ? trace : get_lprime(mindex); |
m = trace > 1 ? trace : get_lprime(mindex); |
| nd_init_ord(ord); |
nd_init_ord(ord); |
| mrank = 0; |
mrank = 0; |
| for ( t = BDY(f), max = 0; t; t = NEXT(t) ) |
for ( t = BDY(f), max = 1; t; t = NEXT(t) ) |
| for ( tv = vv; tv; tv = NEXT(tv) ) { |
for ( tv = vv; tv; tv = NEXT(tv) ) { |
| if ( nd_module ) { |
if ( nd_module ) { |
| s = BDY((LIST)BDY(t)); |
s = BDY((LIST)BDY(t)); |
| Line 3043 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| Line 3508 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| ishomo = 1; |
ishomo = 1; |
| for ( in0 = 0, fd0 = 0, t = BDY(f); t; t = NEXT(t) ) { |
for ( in0 = 0, fd0 = 0, t = BDY(f); t; t = NEXT(t) ) { |
| if ( nd_module ) { |
if ( nd_module ) { |
| if ( !GenTrace ) pltozpl((LIST)BDY(t),&dmy,&zpl); |
if ( !nd_gentrace ) pltozpl((LIST)BDY(t),&dmy,&zpl); |
| else zpl = (LIST)BDY(t); |
else zpl = (LIST)BDY(t); |
| c = (pointer)pltondv(CO,vv,zpl); |
c = (pointer)pltondv(CO,vv,zpl); |
| } else { |
} else { |
| if ( !GenTrace ) ptozp((P)BDY(t),1,&dmy,&zp); |
if ( !nd_gentrace ) ptozp((P)BDY(t),1,&dmy,&zp); |
| else zp = (P)BDY(t); |
else zp = (P)BDY(t); |
| c = (pointer)ptondv(CO,vv,zp); |
c = (pointer)ptondv(CO,vv,zp); |
| } |
} |
| Line 3073 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| Line 3538 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| ndv_homogenize((NDV)BDY(t),obpe,oadv,oepos,ompos); |
ndv_homogenize((NDV)BDY(t),obpe,oadv,oepos,ompos); |
| } |
} |
| while ( 1 ) { |
while ( 1 ) { |
| |
tl1 = tl2 = tl3 = tl4 = 0; |
| if ( Demand ) |
if ( Demand ) |
| nd_demand = 1; |
nd_demand = 1; |
| ndv_setup(m,1,fd0,0,0); |
ret = ndv_setup(m,1,fd0,nd_gbblock?1:0,0); |
| if ( GenTrace ) { |
if ( nd_gentrace ) { |
| MKLIST(l1,nd_tracelist); MKNODE(nd_alltracelist,l1,0); |
MKLIST(l1,nd_tracelist); MKNODE(nd_alltracelist,l1,0); |
| } |
} |
| cand = f4?nd_f4_trace(m,&perm):nd_gb_trace(m,ishomo || homo,&perm); |
if ( ret ) |
| if ( !cand ) { |
cand = f4?nd_f4_trace(m,&perm):nd_gb_trace(m,ishomo || homo,&perm); |
| |
if ( !ret || !cand ) { |
| /* failure */ |
/* failure */ |
| if ( trace > 1 ) { *rp = 0; return; } |
if ( trace > 1 ) { *rp = 0; return; } |
| else m = get_lprime(++mindex); |
else m = get_lprime(++mindex); |
| Line 3094 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| Line 3561 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| } |
} |
| nd_demand = 0; |
nd_demand = 0; |
| cand = ndv_reducebase(cand,perm); |
cand = ndv_reducebase(cand,perm); |
| if ( GenTrace ) { tl1 = nd_alltracelist; nd_alltracelist = 0; } |
if ( nd_gentrace ) { tl1 = nd_alltracelist; nd_alltracelist = 0; } |
| cand = ndv_reduceall(0,cand); |
cand = ndv_reduceall(0,cand); |
| cbpe = nd_bpe; |
cbpe = nd_bpe; |
| if ( GenTrace ) { tl2 = nd_alltracelist; nd_alltracelist = 0; } |
if ( nd_gentrace ) { tl2 = nd_alltracelist; nd_alltracelist = 0; } |
| |
get_eg(&eg0); |
| if ( nocheck ) |
if ( nocheck ) |
| break; |
break; |
| get_eg(&eg0); |
if ( ret = ndv_check_membership(0,in0,obpe,oadv,oepos,cand) ) { |
| if ( ndv_check_candidate(in0,obpe,oadv,oepos,cand) ) |
if ( nd_gentrace ) { |
| /* success */ |
tl3 = nd_alltracelist; nd_alltracelist = 0; |
| break; |
} else tl3 = 0; |
| |
/* gbcheck : cand is a GB of Id(cand) ? */ |
| |
ret = nd_gb(0,0,1,nd_gensyz?1:0,0)!=0; |
| |
if ( nd_gentrace && nd_gensyz ) { |
| |
tl4 = nd_alltracelist; nd_alltracelist = 0; |
| |
} else tl4 = 0; |
| |
} |
| |
if ( ret ) break; |
| else if ( trace > 1 ) { |
else if ( trace > 1 ) { |
| /* failure */ |
/* failure */ |
| *rp = 0; return; |
*rp = 0; return; |
| Line 3130 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| Line 3605 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| if ( nd_module ) BDY(r) = ndvtopl(0,CO,vv,BDY(r),mrank); |
if ( nd_module ) BDY(r) = ndvtopl(0,CO,vv,BDY(r),mrank); |
| else BDY(r) = (pointer)ndvtop(0,CO,vv,BDY(r)); |
else BDY(r) = (pointer)ndvtop(0,CO,vv,BDY(r)); |
| } |
} |
| if ( nalg ) |
if ( nd_nalg ) |
| cand = postprocess_algcoef(av,alist,cand); |
cand = postprocess_algcoef(av,alist,cand); |
| MKLIST(*rp,cand); |
MKLIST(*rp,cand); |
| if ( GenTrace ) { |
if ( nd_gentrace ) { |
| tl1 = reverse_node(tl1); tl2 = reverse_node(tl2); |
tl1 = reverse_node(tl1); tl2 = reverse_node(tl2); |
| |
tl3 = reverse_node(tl3); |
| /* tl2 = [[i,[[*,j,*,*],...]],...] */ |
/* tl2 = [[i,[[*,j,*,*],...]],...] */ |
| for ( t = tl2; t; t = NEXT(t) ) { |
for ( t = tl2; t; t = NEXT(t) ) { |
| /* s = [i,[*,j,*,*],...] */ |
/* s = [i,[*,j,*,*],...] */ |
| Line 3148 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| Line 3624 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| for ( j = length(cand)-1, t = 0; j >= 0; j-- ) { |
for ( j = length(cand)-1, t = 0; j >= 0; j-- ) { |
| STOQ(perm[j],jq); MKNODE(s,jq,t); t = s; |
STOQ(perm[j],jq); MKNODE(s,jq,t); t = s; |
| } |
} |
| MKLIST(l1,tl1); MKLIST(l2,tl2); MKLIST(l3,t); |
MKLIST(l1,tl1); MKLIST(l2,tl2); MKLIST(l3,t); MKLIST(l4,tl3); |
| tr = mknode(5,*rp,homo?ONE:0,l1,l2,l3); MKLIST(*rp,tr); |
MKLIST(l5,tl4); |
| |
STOQ(nd_bpe,bpe); |
| |
tr = mknode(8,*rp,(!ishomo&&homo)?ONE:0,l1,l2,l3,l4,l5,bpe); MKLIST(*rp,tr); |
| } |
} |
| } |
} |
| |
|
| Line 3373 void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos |
|
| Line 3851 void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos |
|
| NMV m,mr0,mr,t; |
NMV m,mr0,mr,t; |
| |
|
| len = p->len; |
len = p->len; |
| for ( m = BDY(p), i = 0, max = 0; i < len; NMV_OADV(m), i++ ) |
for ( m = BDY(p), i = 0, max = 1; i < len; NMV_OADV(m), i++ ) |
| max = MAX(max,TD(DL(m))); |
max = MAX(max,TD(DL(m))); |
| mr0 = nmv_adv>oadv?(NMV)REALLOC(BDY(p),len*nmv_adv):BDY(p); |
mr0 = nmv_adv>oadv?(NMV)REALLOC(BDY(p),len*nmv_adv):BDY(p); |
| m = (NMV)((char *)mr0+(len-1)*oadv); |
m = (NMV)((char *)mr0+(len-1)*oadv); |
| Line 3566 void nd_free(ND p) |
|
| Line 4044 void nd_free(ND p) |
|
| |
|
| void ndv_free(NDV p) |
void ndv_free(NDV p) |
| { |
{ |
| GC_free(BDY(p)); |
GCFREE(BDY(p)); |
| } |
} |
| |
|
| void nd_append_red(UINT *d,int i) |
void nd_append_red(UINT *d,int i) |
| Line 3677 void nd_setup_parameters(int nvar,int max) { |
|
| Line 4155 void nd_setup_parameters(int nvar,int max) { |
|
| else if ( max < 65536 ) nd_bpe = 16; |
else if ( max < 65536 ) nd_bpe = 16; |
| else nd_bpe = 32; |
else nd_bpe = 32; |
| } |
} |
| |
if ( !do_weyl && weight_check && (current_dl_weight_vector || nd_matrix) ) { |
| |
UINT t; |
| |
int st; |
| |
int *v; |
| |
/* t = max(weights) */ |
| |
t = 0; |
| |
if ( current_dl_weight_vector ) |
| |
for ( i = 0, t = 0; i < nd_nvar; i++ ) { |
| |
if ( (st=current_dl_weight_vector[i]) < 0 ) st = -st; |
| |
if ( t < st ) t = st; |
| |
} |
| |
if ( nd_matrix ) |
| |
for ( i = 0; i < nd_matrix_len; i++ ) |
| |
for ( j = 0, v = nd_matrix[i]; j < nd_nvar; j++ ) { |
| |
if ( (st=v[j]) < 0 ) st = -st; |
| |
if ( t < st ) t = st; |
| |
} |
| |
/* i = bitsize of t */ |
| |
for ( i = 0; t; t >>=1, i++ ); |
| |
/* i += bitsize of nd_nvar */ |
| |
for ( t = nd_nvar; t; t >>=1, i++); |
| |
/* nd_bpe+i = bitsize of max(weights)*max(exp)*nd_nvar */ |
| |
if ( (nd_bpe+i) >= 31 ) |
| |
error("nd_setup_parameters : too large weight"); |
| |
} |
| nd_epw = (sizeof(UINT)*8)/nd_bpe; |
nd_epw = (sizeof(UINT)*8)/nd_bpe; |
| elen = nd_nvar/nd_epw+(nd_nvar%nd_epw?1:0); |
elen = nd_nvar/nd_epw+(nd_nvar%nd_epw?1:0); |
| nd_exporigin = nd_get_exporigin(nd_ord); |
nd_exporigin = nd_get_exporigin(nd_ord); |
| Line 3736 ND_pairs nd_reconstruct(int trace,ND_pairs d) |
|
| Line 4239 ND_pairs nd_reconstruct(int trace,ND_pairs d) |
|
| prev_ndp_free_list = _ndp_free_list; |
prev_ndp_free_list = _ndp_free_list; |
| _nm_free_list = 0; |
_nm_free_list = 0; |
| _ndp_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 ) |
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[i],obpe,oadv,oepos); |
| |
ndv_realloc(nd_ps_trace_sym[i],obpe,oadv,oepos); |
| |
} |
| s0 = 0; |
s0 = 0; |
| for ( t = d; t; t = NEXT(t) ) { |
for ( t = d; t; t = NEXT(t) ) { |
| NEXTND_pairs(s0,s); |
NEXTND_pairs(s0,s); |
| Line 3877 int nd_sp(int mod,int trace,ND_pairs p,ND *rp) |
|
| Line 4386 int nd_sp(int mod,int trace,ND_pairs p,ND *rp) |
|
| } |
} |
| t1 = ndv_mul_nm(mod,m1,p1); t2 = ndv_mul_nm(mod,m2,p2); |
t1 = ndv_mul_nm(mod,m1,p1); t2 = ndv_mul_nm(mod,m2,p2); |
| *rp = nd_add(mod,t1,t2); |
*rp = nd_add(mod,t1,t2); |
| if ( GenTrace ) { |
if ( nd_gentrace ) { |
| /* nd_tracelist is initialized */ |
/* nd_tracelist is initialized */ |
| STOQ(p->i1,iq); nmtodp(mod,m1,&d); node = mknode(4,ONE,iq,d,ONE); |
STOQ(p->i1,iq); nmtodp(mod,m1,&d); node = mknode(4,ONE,iq,d,ONE); |
| MKLIST(hist,node); MKNODE(nd_tracelist,hist,0); |
MKLIST(hist,node); MKNODE(nd_tracelist,hist,0); |
| Line 3977 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta |
|
| Line 4486 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta |
|
| NEWNM(m); d = DL(m); |
NEWNM(m); d = DL(m); |
| if ( mod ) { |
if ( mod ) { |
| c0 = CM(m0); c1 = CM(m1); DMAR(c0,c1,0,mod,c); CM(m) = c; |
c0 = CM(m0); c1 = CM(m1); DMAR(c0,c1,0,mod,c); CM(m) = c; |
| } else |
} else if ( nd_vc ) |
| |
mulp(nd_vc,CP(m0),CP(m1),&CP(m)); |
| |
else |
| mulq(CQ(m0),CQ(m1),&CQ(m)); |
mulq(CQ(m0),CQ(m1),&CQ(m)); |
| for ( i = 0; i < nd_wpd; i++ ) d[i] = 0; |
for ( i = 0; i < nd_wpd; i++ ) d[i] = 0; |
| homo = n&1 ? 1 : 0; |
homo = n&1 ? 1 : 0; |
| Line 4032 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta |
|
| Line 4543 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta |
|
| ndl_addto(DL(tab[u]),d); |
ndl_addto(DL(tab[u]),d); |
| if ( mod ) { |
if ( mod ) { |
| c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(tab[u]) = c1; |
c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(tab[u]) = c1; |
| } else { |
} else if ( nd_vc ) |
| |
mulp(nd_vc,CP(tab[u]),(P)q,&CP(tab[u])); |
| |
else { |
| mulq(CQ(tab[u]),q,&q1); CQ(tab[u]) = q1; |
mulq(CQ(tab[u]),q,&q1); CQ(tab[u]) = q1; |
| } |
} |
| } |
} |
| Line 4044 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta |
|
| Line 4557 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta |
|
| ndl_add(DL(tab[u]),d,DL(t)); |
ndl_add(DL(tab[u]),d,DL(t)); |
| if ( mod ) { |
if ( mod ) { |
| c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(t) = c1; |
c0 = CM(tab[u]); DMAR(c0,c,0,mod,c1); CM(t) = c1; |
| } else |
} else if ( nd_vc ) |
| |
mulp(nd_vc,CP(tab[u]),(P)q,&CP(t)); |
| |
else |
| mulq(CQ(tab[u]),q,&CQ(t)); |
mulq(CQ(tab[u]),q,&CQ(t)); |
| *p = t; |
*p = t; |
| } |
} |
| Line 4254 NDV ndv_dup(int mod,NDV p) |
|
| Line 4769 NDV ndv_dup(int mod,NDV p) |
|
| return d; |
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 nd_dup(ND p) |
| { |
{ |
| ND d; |
ND d; |
| Line 4271 ND nd_dup(ND p) |
|
| Line 4828 ND nd_dup(ND p) |
|
| return d; |
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 */ |
/* XXX if p->len == 0 then it represents 0 */ |
| |
|
| void ndv_mod(int mod,NDV p) |
void ndv_mod(int mod,NDV p) |
| Line 4525 NDV ndtondv(int mod,ND p) |
|
| Line 5104 NDV ndtondv(int mod,ND p) |
|
| if ( !p ) return 0; |
if ( !p ) return 0; |
| len = LEN(p); |
len = LEN(p); |
| if ( mod ) |
if ( mod ) |
| m0 = m = (NMV)GC_malloc_atomic_ignore_off_page(len*nmv_adv); |
m0 = m = (NMV)MALLOC_ATOMIC_IGNORE_OFF_PAGE(len*nmv_adv); |
| else |
else |
| m0 = m = MALLOC(len*nmv_adv); |
m0 = m = MALLOC(len*nmv_adv); |
| #if 0 |
#if 0 |
| Line 4561 ND ndvtond(int mod,NDV p) |
|
| Line 5140 ND ndvtond(int mod,NDV p) |
|
| return d; |
return d; |
| } |
} |
| |
|
| |
DP ndvtodp(int mod,NDV p) |
| |
{ |
| |
MP m,m0; |
| |
DP d; |
| |
NMV t; |
| |
int i,len; |
| |
|
| |
if ( !p ) return 0; |
| |
m0 = 0; |
| |
len = p->len; |
| |
for ( t = BDY(p), i = 0; i < len; NMV_ADV(t), i++ ) { |
| |
NEXTMP(m0,m); |
| |
m->dl = ndltodl(nd_nvar,DL(t)); |
| |
m->c = ndctop(mod,t->c); |
| |
} |
| |
NEXT(m) = 0; |
| |
MKDP(nd_nvar,m0,d); |
| |
SG(d) = SG(p); |
| |
return d; |
| |
} |
| |
|
| |
DP ndtodp(int mod,ND p) |
| |
{ |
| |
MP m,m0; |
| |
DP d; |
| |
NM t; |
| |
int i,len; |
| |
|
| |
if ( !p ) return 0; |
| |
m0 = 0; |
| |
len = p->len; |
| |
for ( t = BDY(p); t; t = NEXT(t) ) { |
| |
NEXTMP(m0,m); |
| |
m->dl = ndltodl(nd_nvar,DL(t)); |
| |
m->c = ndctop(mod,t->c); |
| |
} |
| |
NEXT(m) = 0; |
| |
MKDP(nd_nvar,m0,d); |
| |
SG(d) = SG(p); |
| |
return d; |
| |
} |
| |
|
| void ndv_print(NDV p) |
void ndv_print(NDV p) |
| { |
{ |
| NMV m; |
NMV m; |
| Line 4629 NODE ndv_reducebase(NODE x,int *perm) |
|
| Line 5250 NODE ndv_reducebase(NODE x,int *perm) |
|
| void nd_init_ord(struct order_spec *ord) |
void nd_init_ord(struct order_spec *ord) |
| { |
{ |
| nd_module = (ord->id >= 256); |
nd_module = (ord->id >= 256); |
| |
nd_matrix = 0; |
| |
nd_matrix_len = 0; |
| switch ( ord->id ) { |
switch ( ord->id ) { |
| case 0: |
case 0: |
| switch ( ord->ord.simple ) { |
switch ( ord->ord.simple ) { |
| Line 4683 void nd_init_ord(struct order_spec *ord) |
|
| Line 5306 void nd_init_ord(struct order_spec *ord) |
|
| /* module order */ |
/* module order */ |
| case 256: |
case 256: |
| nd_ispot = ord->ispot; |
nd_ispot = ord->ispot; |
| |
nd_pot_nelim = ord->pot_nelim; |
| nd_dcomp = -1; |
nd_dcomp = -1; |
| switch ( ord->ord.simple ) { |
switch ( ord->ord.simple ) { |
| case 0: |
case 0: |
| Line 4703 void nd_init_ord(struct order_spec *ord) |
|
| Line 5327 void nd_init_ord(struct order_spec *ord) |
|
| break; |
break; |
| case 257: |
case 257: |
| /* block order */ |
/* block order */ |
| |
nd_ispot = ord->ispot; |
| |
nd_pot_nelim = ord->pot_nelim; |
| |
nd_dcomp = -1; |
| |
nd_isrlex = 0; |
| ndl_compare_function = ndl_module_block_compare; |
ndl_compare_function = ndl_module_block_compare; |
| break; |
break; |
| case 258: |
case 258: |
| /* matrix order */ |
/* matrix order */ |
| |
nd_ispot = ord->ispot; |
| |
nd_pot_nelim = ord->pot_nelim; |
| |
nd_dcomp = -1; |
| |
nd_isrlex = 0; |
| nd_matrix_len = ord->ord.matrix.row; |
nd_matrix_len = ord->ord.matrix.row; |
| nd_matrix = ord->ord.matrix.matrix; |
nd_matrix = ord->ord.matrix.matrix; |
| ndl_compare_function = ndl_module_matrix_compare; |
ndl_compare_function = ndl_module_matrix_compare; |
| break; |
break; |
| case 259: |
case 259: |
| /* composite order */ |
/* composite order */ |
| |
nd_ispot = ord->ispot; |
| |
nd_pot_nelim = ord->pot_nelim; |
| |
nd_dcomp = -1; |
| |
nd_isrlex = 0; |
| nd_worb_len = ord->ord.composite.length; |
nd_worb_len = ord->ord.composite.length; |
| nd_worb = ord->ord.composite.w_or_b; |
nd_worb = ord->ord.composite.w_or_b; |
| ndl_compare_function = ndl_module_composite_compare; |
ndl_compare_function = ndl_module_composite_compare; |
| Line 4801 EPOS nd_create_epos(struct order_spec *ord) |
|
| Line 5437 EPOS nd_create_epos(struct order_spec *ord) |
|
| |
|
| /* external interface */ |
/* external interface */ |
| |
|
| void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec *ord,P *rp) |
void nd_nf_p(Obj f,LIST g,LIST v,int m,struct order_spec *ord,Obj *rp) |
| { |
{ |
| NODE t,in0,in; |
NODE t,in0,in; |
| ND nd,nf; |
ND ndf,nf; |
| NDV ndv; |
NDV ndvf; |
| VL vv,tv; |
VL vv,tv; |
| int stat,nvar,max,e; |
int stat,nvar,max,mrank; |
| union oNDC dn; |
union oNDC dn; |
| Q cont; |
Q cont; |
| P pp; |
P pp; |
| |
LIST ppl; |
| |
|
| if ( !f ) { |
if ( !f ) { |
| *rp = 0; |
*rp = 0; |
| Line 4819 void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec |
|
| Line 5456 void nd_nf_p(P f,LIST g,LIST v,int m,struct order_spec |
|
| pltovl(v,&vv); |
pltovl(v,&vv); |
| for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ ); |
for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ ); |
| |
|
| /* get the degree bound */ |
/* max=65536 implies nd_bpe=32 */ |
| for ( t = BDY(g), max = 0; t; t = NEXT(t) ) |
max = 65536; |
| for ( tv = vv; tv; tv = NEXT(tv) ) { |
|
| e = getdeg(tv->v,(P)BDY(t)); |
|
| max = MAX(e,max); |
|
| } |
|
| for ( tv = vv; tv; tv = NEXT(tv) ) { |
|
| e = getdeg(tv->v,f); |
|
| max = MAX(e,max); |
|
| } |
|
| |
|
| |
nd_module = 0; |
| |
/* nd_module will be set if ord is a module ordering */ |
| nd_init_ord(ord); |
nd_init_ord(ord); |
| nd_setup_parameters(nvar,max); |
nd_setup_parameters(nvar,max); |
| |
if ( nd_module && OID(f) != O_LIST ) |
| |
error("nd_nf_p : the first argument must be a list"); |
| |
if ( nd_module ) mrank = length(BDY((LIST)f)); |
| /* conversion to ndv */ |
/* conversion to ndv */ |
| for ( in0 = 0, t = BDY(g); t; t = NEXT(t) ) { |
for ( in0 = 0, t = BDY(g); t; t = NEXT(t) ) { |
| NEXTNODE(in0,in); |
NEXTNODE(in0,in); |
| ptozp((P)BDY(t),1,&cont,&pp); |
if ( nd_module ) { |
| BDY(in) = (pointer)ptondv(CO,vv,pp); |
if ( !BDY(t) || OID(BDY(t)) != O_LIST |
| |
|| length(BDY((LIST)BDY(t))) != mrank ) |
| |
error("nd_nf_p : inconsistent basis element"); |
| |
if ( !m ) pltozpl((LIST)BDY(t),&cont,&ppl); |
| |
else ppl = (LIST)BDY(t); |
| |
BDY(in) = (pointer)pltondv(CO,vv,ppl); |
| |
} else { |
| |
if ( !m ) ptozp((P)BDY(t),1,&cont,&pp); |
| |
else pp = (P)BDY(t); |
| |
BDY(in) = (pointer)ptondv(CO,vv,pp); |
| |
} |
| if ( m ) ndv_mod(m,(NDV)BDY(in)); |
if ( m ) ndv_mod(m,(NDV)BDY(in)); |
| } |
} |
| NEXTNODE(in0,in); |
if ( in0 ) NEXT(in) = 0; |
| BDY(in) = (pointer)ptondv(CO,vv,f); |
|
| if ( m ) ndv_mod(m,(NDV)BDY(in)); |
|
| NEXT(in) = 0; |
|
| |
|
| |
if ( nd_module ) ndvf = pltondv(CO,vv,(LIST)f); |
| |
else ndvf = ptondv(CO,vv,(P)f); |
| |
if ( m ) ndv_mod(m,ndvf); |
| |
ndf = (pointer)ndvtond(m,ndvf); |
| |
|
| /* dont sort, dont removecont */ |
/* dont sort, dont removecont */ |
| ndv_setup(m,0,in0,1,1); |
ndv_setup(m,0,in0,1,1); |
| nd_psn--; |
|
| nd_scale=2; |
nd_scale=2; |
| while ( 1 ) { |
stat = nd_nf(m,0,ndf,nd_ps,1,0,&nf); |
| nd = (pointer)ndvtond(m,nd_ps[nd_psn]); |
if ( !stat ) |
| stat = nd_nf(m,0,nd,nd_ps,1,0,&nf); |
error("nd_nf_p : exponent too large"); |
| if ( !stat ) { |
if ( nd_module ) *rp = (Obj)ndvtopl(m,CO,vv,ndtondv(m,nf),mrank); |
| nd_psn++; |
else *rp = (Obj)ndvtop(m,CO,vv,ndtondv(m,nf)); |
| nd_reconstruct(0,0); |
|
| nd_psn--; |
|
| } else |
|
| break; |
|
| } |
|
| *rp = ndvtop(m,CO,vv,ndtondv(m,nf)); |
|
| } |
} |
| |
|
| int nd_to_vect(int mod,UINT *s0,int n,ND d,UINT *r) |
int nd_to_vect(int mod,UINT *s0,int n,ND d,UINT *r) |
| Line 4894 int nd_to_vect_q(UINT *s0,int n,ND d,Q *r) |
|
| Line 5532 int nd_to_vect_q(UINT *s0,int n,ND d,Q *r) |
|
| return i; |
return i; |
| } |
} |
| |
|
| |
unsigned long *nd_to_vect_2(UINT *s0,int n,int *s0hash,ND p) |
| |
{ |
| |
NM m; |
| |
unsigned long *v; |
| |
int i,j,h,size; |
| |
UINT *s,*t; |
| |
|
| |
size = sizeof(unsigned long)*(n+BLEN-1)/BLEN; |
| |
v = (unsigned long *)MALLOC_ATOMIC_IGNORE_OFF_PAGE(size); |
| |
bzero(v,size); |
| |
for ( i = j = 0, s = s0, m = BDY(p); m; j++, m = NEXT(m) ) { |
| |
t = DL(m); |
| |
h = ndl_hash_value(t); |
| |
for ( ; h != s0hash[i] || !ndl_equal(t,s); s += nd_wpd, i++ ); |
| |
v[i/BLEN] |= 1L <<(i%BLEN); |
| |
} |
| |
return v; |
| |
} |
| |
|
| |
int nd_nm_to_vect_2(UINT *s0,int n,int *s0hash,NDV p,NM m,unsigned long *v) |
| |
{ |
| |
NMV mr; |
| |
UINT *d,*t,*s; |
| |
int i,j,len,h,head; |
| |
|
| |
d = DL(m); |
| |
len = LEN(p); |
| |
t = (UINT *)ALLOCA(nd_wpd*sizeof(UINT)); |
| |
for ( i = j = 0, s = s0, mr = BDY(p); j < len; j++, NMV_ADV(mr) ) { |
| |
ndl_add(d,DL(mr),t); |
| |
h = ndl_hash_value(t); |
| |
for ( ; h != s0hash[i] || !ndl_equal(t,s); s += nd_wpd, i++ ); |
| |
if ( j == 0 ) head = i; |
| |
v[i/BLEN] |= 1L <<(i%BLEN); |
| |
} |
| |
return head; |
| |
} |
| |
|
| Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_pair pair) |
Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_pair pair) |
| { |
{ |
| NM m; |
NM m; |
| Line 4917 Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_p |
|
| Line 5593 Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_p |
|
| return r; |
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; |
NM m; |
| NMV mr; |
NMV mr; |
| Line 4926 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0 |
|
| Line 5602 IndArray nm_ind_pair_to_vect_compress(int mod,UINT *s0 |
|
| unsigned char *ivc; |
unsigned char *ivc; |
| unsigned short *ivs; |
unsigned short *ivs; |
| UINT *v,*ivi,*s0v; |
UINT *v,*ivi,*s0v; |
| int i,j,len,prev,diff,cdiff; |
int i,j,len,prev,diff,cdiff,h; |
| IndArray r; |
IndArray r; |
| |
struct oEGT eg0,eg1; |
| |
|
| m = pair->mul; |
m = pair->mul; |
| d = DL(m); |
d = DL(m); |
| p = nd_ps[pair->index]; |
p = nd_demand?nd_ps_sym[pair->index]:nd_ps[pair->index]; |
| len = LEN(p); |
len = LEN(p); |
| t = (UINT *)ALLOCA(nd_wpd*sizeof(UINT)); |
t = (UINT *)ALLOCA(nd_wpd*sizeof(UINT)); |
| v = (unsigned int *)ALLOCA(len*sizeof(unsigned int)); |
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) ) { |
for ( i = j = 0, s = s0, mr = BDY(p); j < len; j++, NMV_ADV(mr) ) { |
| ndl_add(d,DL(mr),t); |
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; |
v[j] = i; |
| } |
} |
| |
get_eg(&eg1); add_eg(&eg_search,&eg0,&eg1); |
| r = (IndArray)MALLOC(sizeof(struct oIndArray)); |
r = (IndArray)MALLOC(sizeof(struct oIndArray)); |
| r->head = v[0]; |
r->head = v[0]; |
| diff = 0; |
diff = 0; |
| Line 5007 int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr |
|
| Line 5687 int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr |
|
| k = ivect->head; |
k = ivect->head; |
| if ( svect[k] ) { |
if ( svect[k] ) { |
| maxrs = MAX(maxrs,rp0[i]->sugar); |
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); |
len = LEN(redv); mr = BDY(redv); |
| igcd_cofactor(svect[k],CQ(mr),&gcd,&cs,&cr); |
igcd_cofactor(svect[k],CQ(mr),&gcd,&cs,&cr); |
| chsgnq(cs,&mcs); |
chsgnq(cs,&mcs); |
| Line 5059 int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr |
|
| Line 5740 int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr |
|
| return maxrs; |
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 ndv_reduce_vect(int m,UINT *svect,int col,IndArray *imat,NM_ind_pair *rp0,int nred) |
| { |
{ |
| int i,j,k,len,pos,prev; |
int i,j,k,len,pos,prev; |
| Line 5085 int ndv_reduce_vect(int m,UINT *svect,int col,IndArray |
|
| Line 5848 int ndv_reduce_vect(int m,UINT *svect,int col,IndArray |
|
| case 1: |
case 1: |
| ivc = ivect->index.c; |
ivc = ivect->index.c; |
| for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) { |
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; |
break; |
| case 2: |
case 2: |
| ivs = ivect->index.s; |
ivs = ivect->index.s; |
| for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) { |
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; |
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; |
break; |
| case 4: |
case 4: |
| ivi = ivect->index.i; |
ivi = ivect->index.i; |
| for ( j = 1, NMV_ADV(mr); j < len; j++, NMV_ADV(mr) ) { |
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; |
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; |
break; |
| } |
} |
| Line 5181 NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhea |
|
| Line 5952 NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhea |
|
| for ( j = 0, len = 0; j < spcol; j++ ) if ( vect[j] ) len++; |
for ( j = 0, len = 0; j < spcol; j++ ) if ( vect[j] ) len++; |
| if ( !len ) return 0; |
if ( !len ) return 0; |
| else { |
else { |
| mr0 = (NMV)GC_malloc_atomic_ignore_off_page(nmv_adv*len); |
mr0 = (NMV)MALLOC_ATOMIC_IGNORE_OFF_PAGE(nmv_adv*len); |
| #if 0 |
#if 0 |
| ndv_alloc += nmv_adv*len; |
ndv_alloc += nmv_adv*len; |
| #endif |
#endif |
| Line 5198 NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhea |
|
| Line 5969 NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhea |
|
| } |
} |
| } |
} |
| |
|
| |
NDV vect_to_ndv_2(unsigned long *vect,int col,UINT *s0vect) |
| |
{ |
| |
int j,k,len; |
| |
UINT *p; |
| |
NDV r; |
| |
NMV mr0,mr; |
| |
|
| |
for ( j = 0, len = 0; j < col; j++ ) if ( vect[j/BLEN] & (1L<<(j%BLEN)) ) len++; |
| |
if ( !len ) return 0; |
| |
else { |
| |
mr0 = (NMV)MALLOC_ATOMIC_IGNORE_OFF_PAGE(nmv_adv*len); |
| |
mr = mr0; |
| |
p = s0vect; |
| |
for ( j = 0; j < col; j++, p += nd_wpd ) |
| |
if ( vect[j/BLEN] & (1L<<(j%BLEN)) ) { |
| |
ndl_copy(p,DL(mr)); CM(mr) = 1; NMV_ADV(mr); |
| |
} |
| |
MKNDV(nd_nvar,mr0,len,r); |
| |
return r; |
| |
} |
| |
} |
| |
|
| /* for preprocessed vector */ |
/* for preprocessed vector */ |
| |
|
| NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead,UINT *s0vect) |
NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead,UINT *s0vect) |
| Line 5211 NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead |
|
| Line 6004 NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead |
|
| for ( j = 0, len = 0; j < spcol; j++ ) if ( vect[j] ) len++; |
for ( j = 0, len = 0; j < spcol; j++ ) if ( vect[j] ) len++; |
| if ( !len ) return 0; |
if ( !len ) return 0; |
| else { |
else { |
| mr0 = (NMV)GC_malloc(nmv_adv*len); |
mr0 = (NMV)MALLOC(nmv_adv*len); |
| #if 0 |
#if 0 |
| ndv_alloc += nmv_adv*len; |
ndv_alloc += nmv_adv*len; |
| #endif |
#endif |
| Line 5230 NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead |
|
| Line 6023 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 */ |
/* for plain vector */ |
| |
|
| NDV plain_vect_to_ndv_q(Q *vect,int col,UINT *s0vect) |
NDV plain_vect_to_ndv_q(Q *vect,int col,UINT *s0vect) |
| Line 5243 NDV plain_vect_to_ndv_q(Q *vect,int col,UINT *s0vect) |
|
| Line 6064 NDV plain_vect_to_ndv_q(Q *vect,int col,UINT *s0vect) |
|
| for ( j = 0, len = 0; j < col; j++ ) if ( vect[j] ) len++; |
for ( j = 0, len = 0; j < col; j++ ) if ( vect[j] ) len++; |
| if ( !len ) return 0; |
if ( !len ) return 0; |
| else { |
else { |
| mr0 = (NMV)GC_malloc(nmv_adv*len); |
mr0 = (NMV)MALLOC(nmv_adv*len); |
| #if 0 |
#if 0 |
| ndv_alloc += nmv_adv*len; |
ndv_alloc += nmv_adv*len; |
| #endif |
#endif |
| Line 5289 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI |
|
| Line 6110 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI |
|
| NDV *ps; |
NDV *ps; |
| |
|
| s0 = 0; rp0 = 0; col = 0; |
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 ) { |
while ( 1 ) { |
| head = remove_head_pbucket_symbolic(bucket); |
head = remove_head_pbucket_symbolic(bucket); |
| if ( !head ) break; |
if ( !head ) break; |
| Line 5323 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI |
|
| Line 6147 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI |
|
| NODE nd_f4(int m,int **indp) |
NODE nd_f4(int m,int **indp) |
| { |
{ |
| int i,nh,stat,index; |
int i,nh,stat,index; |
| NODE r,g; |
NODE r,g,tn0,tn,node; |
| ND_pairs d,l,t; |
ND_pairs d,l,t,ll0,ll; |
| |
LIST l0,l1; |
| ND spol,red; |
ND spol,red; |
| NDV nf,redv; |
NDV nf,redv; |
| NM s0,s; |
NM s0,s; |
| NODE rp0,srp0,nflist; |
NODE rp0,srp0,nflist,nzlist; |
| int nsp,nred,col,rank,len,k,j,a; |
int nsp,nred,col,rank,len,k,j,a,i1s,i2s; |
| UINT c; |
UINT c; |
| UINT **spmat; |
UINT **spmat; |
| UINT *s0vect,*svect,*p,*v; |
UINT *s0vect,*svect,*p,*v; |
| Line 5340 NODE nd_f4(int m,int **indp) |
|
| Line 6165 NODE nd_f4(int m,int **indp) |
|
| int sugar; |
int sugar; |
| PGeoBucket bucket; |
PGeoBucket bucket; |
| struct oEGT eg0,eg1,eg_f4; |
struct oEGT eg0,eg1,eg_f4; |
| |
Q i1,i2,sugarq; |
| #if 0 |
#if 0 |
| ndv_alloc = 0; |
ndv_alloc = 0; |
| #endif |
#endif |
| g = 0; d = 0; |
g = 0; d = 0; |
| for ( i = 0; i < nd_psn; i++ ) { |
for ( i = 0; i < nd_psn; i++ ) { |
| d = update_pairs(d,g,i); |
d = update_pairs(d,g,i,0); |
| g = update_base(g,i); |
g = update_base(g,i); |
| } |
} |
| |
nzlist = 0; |
| while ( d ) { |
while ( d ) { |
| get_eg(&eg0); |
get_eg(&eg0); |
| l = nd_minsugarp(d,&d); |
l = nd_minsugarp(d,&d); |
| sugar = SG(l); |
sugar = SG(l); |
| |
if ( nd_nzlist ) { |
| |
for ( tn = nd_nzlist; tn; tn = NEXT(tn) ) { |
| |
node = BDY((LIST)BDY(tn)); |
| |
if ( QTOS((Q)ARG0(node)) == sugar ) break; |
| |
} |
| |
if ( tn ) { |
| |
for ( t = l, ll0 = 0; t; t = NEXT(t) ) { |
| |
for ( tn = BDY((LIST)ARG1(node)); tn; tn = NEXT(tn) ) { |
| |
i1s = QTOS((Q)ARG0(BDY((LIST)BDY(tn)))); |
| |
i2s = QTOS((Q)ARG1(BDY((LIST)BDY(tn)))); |
| |
if ( t->i1 == i1s && t->i2 == i2s ) break; |
| |
} |
| |
if ( tn ) { |
| |
if ( !ll0 ) ll0 = t; |
| |
else NEXT(ll) = t; |
| |
ll = t; |
| |
} |
| |
} |
| |
if ( ll0 ) NEXT(ll) = 0; |
| |
l = ll0; |
| |
} else l = 0; |
| |
} |
| bucket = create_pbucket(); |
bucket = create_pbucket(); |
| stat = nd_sp_f4(m,0,l,bucket); |
stat = nd_sp_f4(m,0,l,bucket); |
| if ( !stat ) { |
if ( !stat ) { |
| Line 5373 NODE nd_f4(int m,int **indp) |
|
| Line 6221 NODE nd_f4(int m,int **indp) |
|
| if ( DP_Print ) |
if ( DP_Print ) |
| fprintf(asir_out,"sugar=%d,symb=%fsec,", |
fprintf(asir_out,"sugar=%d,symb=%fsec,", |
| sugar,eg_f4.exectime+eg_f4.gctime); |
sugar,eg_f4.exectime+eg_f4.gctime); |
| if ( 1 ) |
nflist = nd_f4_red(m,l,0,s0vect,col,rp0,nd_gentrace?&ll:0); |
| nflist = nd_f4_red(m,l,0,s0vect,col,rp0,0); |
|
| else |
|
| nflist = nd_f4_red_dist(m,l,s0vect,col,rp0,0); |
|
| /* adding new bases */ |
/* adding new bases */ |
| for ( r = nflist; r; r = NEXT(r) ) { |
for ( r = nflist; r; r = NEXT(r) ) { |
| nf = (NDV)BDY(r); |
nf = (NDV)BDY(r); |
| Line 5389 NODE nd_f4(int m,int **indp) |
|
| Line 6234 NODE nd_f4(int m,int **indp) |
|
| nd_removecont(m,nf1); |
nd_removecont(m,nf1); |
| nf = ndtondv(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); |
d = update_pairs(d,g,nh,0); |
| g = update_base(g,nh); |
g = update_base(g,nh); |
| } |
} |
| |
if ( nd_gentrace ) { |
| |
for ( t = ll, tn0 = 0; t; t = NEXT(t) ) { |
| |
NEXTNODE(tn0,tn); |
| |
STOQ(t->i1,i1); STOQ(t->i2,i2); |
| |
node = mknode(2,i1,i2); MKLIST(l0,node); |
| |
BDY(tn) = l0; |
| |
} |
| |
if ( tn0 ) NEXT(tn) = 0; MKLIST(l0,tn0); |
| |
STOQ(sugar,sugarq); node = mknode(2,sugarq,l0); MKLIST(l1,node); |
| |
MKNODE(node,l1,nzlist); nzlist = node; |
| |
} |
| } |
} |
| |
if ( nd_gentrace ) { |
| |
MKLIST(l0,reverse_node(nzlist)); |
| |
MKNODE(nd_alltracelist,l0,0); |
| |
} |
| #if 0 |
#if 0 |
| fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc); |
fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc); |
| #endif |
#endif |
| conv_ilist(0,0,g,indp); |
conv_ilist(nd_demand,0,g,indp); |
| return g; |
return g; |
| } |
} |
| |
|
| Line 5424 NODE nd_f4_trace(int m,int **indp) |
|
| Line 6284 NODE nd_f4_trace(int m,int **indp) |
|
| |
|
| g = 0; d = 0; |
g = 0; d = 0; |
| for ( i = 0; i < nd_psn; i++ ) { |
for ( i = 0; i < nd_psn; i++ ) { |
| d = update_pairs(d,g,i); |
d = update_pairs(d,g,i,0); |
| g = update_base(g,i); |
g = update_base(g,i); |
| } |
} |
| while ( d ) { |
while ( d ) { |
| Line 5489 NODE nd_f4_trace(int m,int **indp) |
|
| Line 6349 NODE nd_f4_trace(int m,int **indp) |
|
| nfv = ndv_dup(0,nfqv); |
nfv = ndv_dup(0,nfqv); |
| ndv_mod(m,nfv); |
ndv_mod(m,nfv); |
| ndv_removecont(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); |
d = update_pairs(d,g,nh,0); |
| g = update_base(g,nh); |
g = update_base(g,nh); |
| } |
} |
| } |
} |
| #if 0 |
#if 0 |
| fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc); |
fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc); |
| #endif |
#endif |
| |
conv_ilist(nd_demand,1,g,indp); |
| |
return g; |
| |
} |
| |
|
| |
NODE nd_f4_pseudo_trace(int m,int **indp) |
| |
{ |
| |
int i,nh,stat,index; |
| |
NODE r,g; |
| |
ND_pairs d,l,l0,t; |
| |
ND spol,red; |
| |
NDV nf,redv,nfqv,nfv; |
| |
NM s0,s; |
| |
NODE rp0,srp0,nflist; |
| |
int nsp,nred,col,rank,len,k,j,a; |
| |
UINT c; |
| |
UINT **spmat; |
| |
UINT *s0vect,*svect,*p,*v; |
| |
int *colstat; |
| |
IndArray *imat; |
| |
int *rhead; |
| |
int spcol,sprow; |
| |
int sugar; |
| |
PGeoBucket bucket; |
| |
struct oEGT eg0,eg1,eg_f4; |
| |
|
| |
g = 0; d = 0; |
| |
for ( i = 0; i < nd_psn; i++ ) { |
| |
d = update_pairs(d,g,i,0); |
| |
g = update_base(g,i); |
| |
} |
| |
while ( d ) { |
| |
get_eg(&eg0); |
| |
l = nd_minsugarp(d,&d); |
| |
sugar = SG(l); |
| |
bucket = create_pbucket(); |
| |
stat = nd_sp_f4(m,0,l,bucket); |
| |
if ( !stat ) { |
| |
for ( t = l; NEXT(t); t = NEXT(t) ); |
| |
NEXT(t) = d; d = l; |
| |
d = nd_reconstruct(1,d); |
| |
continue; |
| |
} |
| |
if ( bucket->m < 0 ) continue; |
| |
col = nd_symbolic_preproc(bucket,0,&s0vect,&rp0); |
| |
if ( !col ) { |
| |
for ( t = l; NEXT(t); t = NEXT(t) ); |
| |
NEXT(t) = d; d = l; |
| |
d = nd_reconstruct(1,d); |
| |
continue; |
| |
} |
| |
get_eg(&eg1); init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg1); |
| |
if ( DP_Print ) |
| |
fprintf(asir_out,"sugar=%d,symb=%fsec,", |
| |
sugar,eg_f4.exectime+eg_f4.gctime); |
| |
nflist = nd_f4_red(m,l,0,s0vect,col,rp0,&l0); |
| |
if ( !l0 ) continue; |
| |
l = l0; |
| |
|
| |
/* over Q */ |
| |
while ( 1 ) { |
| |
bucket = create_pbucket(); |
| |
stat = nd_sp_f4(0,1,l,bucket); |
| |
if ( !stat ) { |
| |
for ( t = l; NEXT(t); t = NEXT(t) ); |
| |
NEXT(t) = d; d = l; |
| |
d = nd_reconstruct(1,d); |
| |
continue; |
| |
} |
| |
if ( bucket->m < 0 ) continue; |
| |
col = nd_symbolic_preproc(bucket,1,&s0vect,&rp0); |
| |
if ( !col ) { |
| |
for ( t = l; NEXT(t); t = NEXT(t) ); |
| |
NEXT(t) = d; d = l; |
| |
d = nd_reconstruct(1,d); |
| |
continue; |
| |
} |
| |
nflist = nd_f4_red(0,l,1,s0vect,col,rp0,0); |
| |
} |
| |
|
| |
/* adding new bases */ |
| |
for ( r = nflist; r; r = NEXT(r) ) { |
| |
nfqv = (NDV)BDY(r); |
| |
ndv_removecont(0,nfqv); |
| |
if ( !rem(NM(HCQ(nfqv)),m) ) return 0; |
| |
if ( nd_nalg ) { |
| |
ND nf1; |
| |
|
| |
nf1 = ndvtond(m,nfqv); |
| |
nd_monic(0,&nf1); |
| |
nd_removecont(0,nf1); |
| |
nfqv = ndtondv(0,nf1); nd_free(nf1); |
| |
} |
| |
nfv = ndv_dup(0,nfqv); |
| |
ndv_mod(m,nfv); |
| |
ndv_removecont(m,nfv); |
| |
nh = ndv_newps(0,nfv,nfqv,1); |
| |
d = update_pairs(d,g,nh,0); |
| |
g = update_base(g,nh); |
| |
} |
| |
} |
| |
#if 0 |
| |
fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc); |
| |
#endif |
| conv_ilist(0,1,g,indp); |
conv_ilist(0,1,g,indp); |
| return g; |
return g; |
| } |
} |
| |
|
| |
int rref(matrix mat,int *sugar) |
| |
{ |
| |
int row,col,i,j,k,l,s,wcol,wj; |
| |
unsigned long bj; |
| |
unsigned long **a; |
| |
unsigned long *ai,*ak,*as,*t; |
| |
int *pivot; |
| |
|
| |
row = mat->row; |
| |
col = mat->col; |
| |
a = mat->a; |
| |
wcol = (col+BLEN-1)/BLEN; |
| |
pivot = (int *)MALLOC_ATOMIC(row*sizeof(int)); |
| |
i = 0; |
| |
for ( j = 0; j < col; j++ ) { |
| |
wj = j/BLEN; bj = 1L<<(j%BLEN); |
| |
for ( k = i; k < row; k++ ) |
| |
if ( a[k][wj] & bj ) break; |
| |
if ( k == row ) continue; |
| |
pivot[i] = j; |
| |
if ( k != i ) { |
| |
t = a[i]; a[i] = a[k]; a[k] = t; |
| |
s = sugar[i]; sugar[i] = sugar[k]; sugar[k] = s; |
| |
} |
| |
ai = a[i]; |
| |
for ( k = i+1; k < row; k++ ) { |
| |
ak = a[k]; |
| |
if ( ak[wj] & bj ) { |
| |
for ( l = wj; l < wcol; l++ ) |
| |
ak[l] ^= ai[l]; |
| |
sugar[k] = MAX(sugar[k],sugar[i]); |
| |
} |
| |
} |
| |
i++; |
| |
} |
| |
for ( k = i-1; k >= 0; k-- ) { |
| |
j = pivot[k]; wj = j/BLEN; bj = 1L<<(j%BLEN); |
| |
ak = a[k]; |
| |
for ( s = 0; s < k; s++ ) { |
| |
as = a[s]; |
| |
if ( as[wj] & bj ) { |
| |
for ( l = wj; l < wcol; l++ ) |
| |
as[l] ^= ak[l]; |
| |
sugar[s] = MAX(sugar[s],sugar[k]); |
| |
} |
| |
} |
| |
} |
| |
return i; |
| |
} |
| |
|
| |
void print_matrix(matrix mat) |
| |
{ |
| |
int row,col,i,j; |
| |
unsigned long *ai; |
| |
|
| |
row = mat->row; |
| |
col = mat->col; |
| |
printf("%d x %d\n",row,col); |
| |
for ( i = 0; i < row; i++ ) { |
| |
ai = mat->a[i]; |
| |
for ( j = 0; j < col; j++ ) { |
| |
if ( ai[j/BLEN] & (1L<<(j%BLEN)) ) putchar('1'); |
| |
else putchar('0'); |
| |
} |
| |
putchar('\n'); |
| |
} |
| |
} |
| |
|
| |
NDV vect_to_ndv_2(unsigned long *vect,int col,UINT *s0vect); |
| |
|
| |
void red_by_vect_2(matrix mat,int *sugar,unsigned long *v,int rhead,int rsugar) |
| |
{ |
| |
int row,col,wcol,wj,i,j; |
| |
unsigned long bj; |
| |
unsigned long *ai; |
| |
unsigned long **a; |
| |
int len; |
| |
int *pos; |
| |
|
| |
row = mat->row; |
| |
col = mat->col; |
| |
wcol = (col+BLEN-1)/BLEN; |
| |
pos = (int *)ALLOCA(wcol*sizeof(int)); |
| |
bzero(pos,wcol*sizeof(int)); |
| |
for ( i = j = 0; i < wcol; i++ ) |
| |
if ( v[i] ) pos[j++] = i;; |
| |
len = j; |
| |
wj = rhead/BLEN; |
| |
bj = 1L<<rhead%BLEN; |
| |
a = mat->a; |
| |
for ( i = 0; i < row; i++ ) { |
| |
ai = a[i]; |
| |
if ( ai[wj]&bj ) { |
| |
for ( j = 0; j < len; j++ ) |
| |
ai[pos[j]] ^= v[pos[j]]; |
| |
sugar[i] = MAX(sugar[i],rsugar); |
| |
} |
| |
} |
| |
} |
| |
|
| |
NODE nd_f4_red_2(ND_pairs sp0,UINT *s0vect,int col,NODE rp0,ND_pairs *nz) |
| |
{ |
| |
int nsp,nred,i,i0,k,rank,row; |
| |
NODE r0,rp; |
| |
ND_pairs sp; |
| |
ND spol; |
| |
NM_ind_pair rt; |
| |
int *s0hash; |
| |
UINT *s; |
| |
int *pivot,*sugar,*head; |
| |
matrix mat; |
| |
NM m; |
| |
NODE r; |
| |
struct oEGT eg0,eg1,eg2,eg_elim1,eg_elim2; |
| |
int rhead,rsugar,size; |
| |
unsigned long *v; |
| |
|
| |
get_eg(&eg0); |
| |
init_eg(&eg_search); |
| |
for ( sp = sp0, nsp = 0; sp; sp = NEXT(sp), nsp++ ); |
| |
nred = length(rp0); |
| |
mat = alloc_matrix(nsp,col); |
| |
s0hash = (int *)ALLOCA(col*sizeof(int)); |
| |
for ( i = 0, s = s0vect; i < col; i++, s += nd_wpd ) |
| |
s0hash[i] = ndl_hash_value(s); |
| |
|
| |
sugar = (int *)ALLOCA(nsp*sizeof(int)); |
| |
for ( i = 0, sp = sp0; sp; sp = NEXT(sp) ) { |
| |
nd_sp(2,0,sp,&spol); |
| |
if ( spol ) { |
| |
mat->a[i] = nd_to_vect_2(s0vect,col,s0hash,spol); |
| |
sugar[i] = SG(spol); |
| |
i++; |
| |
} |
| |
} |
| |
mat->row = i; |
| |
fprintf(asir_out,"%dx%d,",mat->row,mat->col); fflush(asir_out); |
| |
size = ((col+BLEN-1)/BLEN)*sizeof(unsigned long); |
| |
v = CALLOC((col+BLEN-1)/BLEN,sizeof(unsigned long)); |
| |
for ( rp = rp0, i = 0; rp; rp = NEXT(rp), i++ ) { |
| |
rt = (NM_ind_pair)BDY(rp); |
| |
bzero(v,size); |
| |
rhead = nd_nm_to_vect_2(s0vect,col,s0hash,nd_ps[rt->index],rt->mul,v); |
| |
rsugar = SG(nd_ps[rt->index])+TD(DL(rt->mul)); |
| |
red_by_vect_2(mat,sugar,v,rhead,rsugar); |
| |
} |
| |
|
| |
get_eg(&eg1); |
| |
init_eg(&eg_elim1); add_eg(&eg_elim1,&eg0,&eg1); |
| |
rank = rref(mat,sugar); |
| |
|
| |
for ( i = 0, r0 = 0; i < rank; i++ ) { |
| |
NEXTNODE(r0,r); |
| |
BDY(r) = (pointer)vect_to_ndv_2(mat->a[i],col,s0vect); |
| |
SG((NDV)BDY(r)) = sugar[i]; |
| |
} |
| |
if ( r0 ) NEXT(r) = 0; |
| |
get_eg(&eg2); |
| |
init_eg(&eg_elim2); add_eg(&eg_elim2,&eg1,&eg2); |
| |
if ( DP_Print ) { |
| |
fprintf(asir_out,"elim1=%fsec,elim2=%fsec\n", |
| |
eg_elim1.exectime+eg_elim1.gctime,eg_elim2.exectime+eg_elim2.gctime); |
| |
fflush(asir_out); |
| |
} |
| |
return r0; |
| |
} |
| |
|
| |
|
| NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0vect,int col,NODE rp0,ND_pairs *nz) |
NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0vect,int col,NODE rp0,ND_pairs *nz) |
| { |
{ |
| IndArray *imat; |
IndArray *imat; |
| Line 5509 NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve |
|
| Line 6640 NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve |
|
| NODE r0,rp; |
NODE r0,rp; |
| ND_pairs sp; |
ND_pairs sp; |
| NM_ind_pair *rvect; |
NM_ind_pair *rvect; |
| |
UINT *s; |
| |
int *s0hash; |
| |
|
| |
if ( m == 2 && nd_rref2 ) |
| |
return nd_f4_red_2(sp0,s0vect,col,rp0,nz); |
| |
|
| |
init_eg(&eg_search); |
| for ( sp = sp0, nsp = 0; sp; sp = NEXT(sp), nsp++ ); |
for ( sp = sp0, nsp = 0; sp; sp = NEXT(sp), nsp++ ); |
| nred = length(rp0); |
nred = length(rp0); |
| imat = (IndArray *)ALLOCA(nred*sizeof(IndArray)); |
imat = (IndArray *)ALLOCA(nred*sizeof(IndArray)); |
| Line 5517 NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve |
|
| Line 6654 NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve |
|
| for ( i = 0; i < col; i++ ) rhead[i] = 0; |
for ( i = 0; i < col; i++ ) rhead[i] = 0; |
| |
|
| /* construction of index arrays */ |
/* construction of index arrays */ |
| |
fprintf(stderr,"%dx%d,",nsp+nred,col); |
| rvect = (NM_ind_pair *)ALLOCA(nred*sizeof(NM_ind_pair)); |
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) ) { |
for ( rp = rp0, i = 0; rp; i++, rp = NEXT(rp) ) { |
| rvect[i] = (NM_ind_pair)BDY(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; |
rhead[imat[i]->head] = 1; |
| } |
} |
| if ( m ) |
if ( m ) |
| r0 = nd_f4_red_main(m,sp0,nsp,s0vect,col,rvect,rhead,imat,nred,nz); |
r0 = nd_f4_red_main(m,sp0,nsp,s0vect,col,rvect,rhead,imat,nred,nz); |
| else |
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; |
return r0; |
| } |
} |
| |
|
| Line 5579 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s |
|
| Line 6721 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s |
|
| fflush(asir_out); |
fflush(asir_out); |
| } |
} |
| /* free index arrays */ |
/* free index arrays */ |
| for ( i = 0; i < nred; i++ ) GC_free(imat[i]->index.c); |
for ( i = 0; i < nred; i++ ) GCFREE(imat[i]->index.c); |
| |
|
| /* elimination (2nd step) */ |
/* elimination (2nd step) */ |
| colstat = (int *)ALLOCA(spcol*sizeof(int)); |
colstat = (int *)ALLOCA(spcol*sizeof(int)); |
| Line 5592 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s |
|
| Line 6734 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s |
|
| NEXTNODE(r0,r); BDY(r) = |
NEXTNODE(r0,r); BDY(r) = |
| (pointer)vect_to_ndv(spmat[i],spcol,col,rhead,s0vect); |
(pointer)vect_to_ndv(spmat[i],spcol,col,rhead,s0vect); |
| SG((NDV)BDY(r)) = spsugar[i]; |
SG((NDV)BDY(r)) = spsugar[i]; |
| GC_free(spmat[i]); |
GCFREE(spmat[i]); |
| } |
} |
| if ( r0 ) NEXT(r) = 0; |
if ( r0 ) NEXT(r) = 0; |
| |
|
| for ( ; i < sprow; i++ ) GC_free(spmat[i]); |
for ( ; i < sprow; i++ ) GCFREE(spmat[i]); |
| get_eg(&eg2); init_eg(&eg_f4_2); add_eg(&eg_f4_2,&eg1,&eg2); |
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); |
init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg2); |
| if ( DP_Print ) { |
if ( DP_Print ) { |
| Line 5660 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U |
|
| Line 6802 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U |
|
| fflush(asir_out); |
fflush(asir_out); |
| } |
} |
| /* free index arrays */ |
/* free index arrays */ |
| /* for ( i = 0; i < nred; i++ ) GC_free(imat[i]->index.c); */ |
/* for ( i = 0; i < nred; i++ ) GCFREE(imat[i]->index.c); */ |
| |
|
| /* elimination (2nd step) */ |
/* elimination (2nd step) */ |
| colstat = (int *)ALLOCA(spcol*sizeof(int)); |
colstat = (int *)ALLOCA(spcol*sizeof(int)); |
| rank = nd_gauss_elim_q(spmat,spsugar,sprow,spcol,colstat); |
rank = nd_gauss_elim_q(spmat,spsugar,sprow,spcol,colstat); |
| w = (pointer *)ALLOCA(rank*sizeof(pointer)); |
w = (pointer *)ALLOCA(rank*sizeof(pointer)); |
| for ( i = 0; i < rank; i++ ) { |
for ( i = 0; i < rank; i++ ) { |
| |
#if 0 |
| w[rank-i-1] = (pointer)vect_to_ndv_q(spmat[i],spcol,col,rhead,s0vect); |
w[rank-i-1] = (pointer)vect_to_ndv_q(spmat[i],spcol,col,rhead,s0vect); |
| SG((NDV)w[rank-i-1]) = spsugar[i]; |
SG((NDV)w[rank-i-1]) = spsugar[i]; |
| /* GC_free(spmat[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 |
#if 0 |
| qsort(w,rank,sizeof(NDV), |
qsort(w,rank,sizeof(NDV), |
| Line 5681 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U |
|
| Line 6828 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U |
|
| } |
} |
| if ( r0 ) NEXT(r) = 0; |
if ( r0 ) NEXT(r) = 0; |
| |
|
| /* for ( ; i < sprow; i++ ) GC_free(spmat[i]); */ |
/* for ( ; i < sprow; i++ ) GCFREE(spmat[i]); */ |
| get_eg(&eg2); init_eg(&eg_f4_2); add_eg(&eg_f4_2,&eg1,&eg2); |
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); |
init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg2); |
| if ( DP_Print ) { |
if ( DP_Print ) { |
| Line 5692 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U |
|
| Line 6839 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U |
|
| } |
} |
| return r0; |
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 |
#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) |
void printm(Q **mat,int row,int col) |
| { |
{ |
| int i,j; |
int i,j; |
| Line 5813 NDV nd_recv_ndv() |
|
| Line 7045 NDV nd_recv_ndv() |
|
| len = nd_recv_int(); |
len = nd_recv_int(); |
| if ( !len ) return 0; |
if ( !len ) return 0; |
| else { |
else { |
| m0 = m = (NMV)GC_malloc_atomic_ignore_off_page(nmv_adv*len); |
m0 = m = (NMV)MALLOC_ATOMIC_IGNORE_OFF_PAGE(nmv_adv*len); |
| #if 0 |
#if 0 |
| ndv_alloc += len*nmv_adv; |
ndv_alloc += len*nmv_adv; |
| #endif |
#endif |
| Line 5844 int ox_exec_f4_red(Q proc) |
|
| Line 7076 int ox_exec_f4_red(Q proc) |
|
| return s; |
return s; |
| } |
} |
| |
|
| |
#if 0 |
| NODE nd_f4_red_dist(int m,ND_pairs sp0,UINT *s0vect,int col,NODE rp0,ND_pairs *nz) |
NODE nd_f4_red_dist(int m,ND_pairs sp0,UINT *s0vect,int col,NODE rp0,ND_pairs *nz) |
| { |
{ |
| int nsp,nred; |
int nsp,nred; |
| Line 6006 void nd_exec_f4_red_dist() |
|
| Line 7239 void nd_exec_f4_red_dist() |
|
| } |
} |
| fflush(nd_write); |
fflush(nd_write); |
| } |
} |
| |
#endif |
| |
|
| int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int col,int *colstat) |
int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int col,int *colstat) |
| { |
{ |
| int mod,i,j,t,c,rank,rank0,inv; |
int i,j,t,c,rank,inv; |
| int *ci,*ri; |
int *ci,*ri; |
| Q dn; |
Q dn; |
| MAT m,nm; |
MAT m,nm; |
| int **wmat; |
|
| |
|
| /* XXX */ |
|
| mod = 99999989; |
|
| wmat = (int **)ALLOCA(row*sizeof(int *)); |
|
| for ( i = 0; i < row; i++ ) { |
|
| wmat[i] = (int *)ALLOCA(col*sizeof(int)); |
|
| for ( j = 0; j < col; j++ ) { |
|
| if ( mat0[i][j] ) { |
|
| t = rem(NM(mat0[i][j]),mod); |
|
| if ( SGN(mat0[i][j]) < 0 ) t = mod-t; |
|
| wmat[i][j] = t; |
|
| } else |
|
| wmat[i][j] = 0; |
|
| } |
|
| } |
|
| rank0 = nd_gauss_elim_mod(wmat,sugar,0,row,col,mod,colstat); |
|
| NEWMAT(m); m->row = row; m->col = col; m->body = (pointer **)mat0; |
NEWMAT(m); m->row = row; m->col = col; m->body = (pointer **)mat0; |
| rank = generic_gauss_elim(m,&nm,&dn,&ri,&ci); |
rank = generic_gauss_elim(m,&nm,&dn,&ri,&ci); |
| if ( rank != rank0 ) |
|
| error("afo"); |
|
| for ( i = 0; i < row; i++ ) |
for ( i = 0; i < row; i++ ) |
| for ( j = 0; j < col; j++ ) |
for ( j = 0; j < col; j++ ) |
| mat0[i][j] = 0; |
mat0[i][j] = 0; |
| Line 6043 int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int co |
|
| Line 7259 int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int co |
|
| for ( j = 0; j < c; j++ ) |
for ( j = 0; j < c; j++ ) |
| mat0[i][ci[j]] = (Q)BDY(nm)[i][j]; |
mat0[i][ci[j]] = (Q)BDY(nm)[i][j]; |
| } |
} |
| inv = invm(rem(NM(dn),mod),mod); |
return rank; |
| if ( SGN(dn) < 0 ) inv = mod-inv; |
} |
| |
|
| |
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 ( i = 0; i < row; i++ ) |
| for ( j = 0; j < col; j++ ) { |
for ( j = 0; j < col; j++ ) |
| if ( mat0[i][j] ) { |
mat0[i][j] = 0; |
| t = rem(NM(mat0[i][j]),mod); |
c = col-rank; |
| if ( SGN(mat0[i][j]) < 0 ) t = mod-t; |
for ( i = 0; i < rank; i++ ) { |
| } else |
mat0[i][ri[i]] = dn; |
| t = 0; |
for ( j = 0; j < c; j++ ) |
| c = dmar(t,inv,0,mod); |
mat0[i][ci[j]] = (GZ)BDY(nm)[i][j]; |
| if ( wmat[i][j] != c ) |
} |
| error("afo"); |
|
| } |
|
| return rank; |
return rank; |
| } |
} |
| |
|
| Line 6235 void ndv_save(NDV p,int index) |
|
| Line 7459 void ndv_save(NDV p,int index) |
|
| fclose(s); |
fclose(s); |
| } |
} |
| |
|
| |
void nd_save_mod(ND p,int index) |
| |
{ |
| |
FILE *s; |
| |
char name[BUFSIZ]; |
| |
int nv,sugar,len,c; |
| |
NM m; |
| |
|
| |
sprintf(name,"%s/%d",Demand,index); |
| |
s = fopen(name,"w"); |
| |
if ( !p ) { |
| |
len = 0; |
| |
write_int(s,&len); |
| |
fclose(s); |
| |
return; |
| |
} |
| |
nv = NV(p); |
| |
sugar = SG(p); |
| |
len = LEN(p); |
| |
write_int(s,&nv); write_int(s,&sugar); write_int(s,&len); |
| |
for ( m = BDY(p); m; m = NEXT(m) ) { |
| |
c = CM(m); write_int(s,&c); |
| |
write_intarray(s,DL(m),nd_wpd); |
| |
} |
| |
fclose(s); |
| |
} |
| |
|
| NDV ndv_load(int index) |
NDV ndv_load(int index) |
| { |
{ |
| FILE *s; |
FILE *s; |
| Line 6279 NDV ndv_load(int index) |
|
| Line 7529 NDV ndv_load(int index) |
|
| return d; |
return d; |
| } |
} |
| |
|
| |
ND nd_load_mod(int index) |
| |
{ |
| |
FILE *s; |
| |
char name[BUFSIZ]; |
| |
int nv,sugar,len,i,c; |
| |
ND d; |
| |
NM m0,m; |
| |
|
| |
sprintf(name,"%s/%d",Demand,index); |
| |
s = fopen(name,"r"); |
| |
/* if the file does not exist, it means p[index]=0 */ |
| |
if ( !s ) return 0; |
| |
|
| |
read_int(s,&nv); |
| |
if ( !nv ) { fclose(s); return 0; } |
| |
|
| |
read_int(s,&sugar); |
| |
read_int(s,&len); |
| |
for ( m0 = 0, i = 0; i < len; i++ ) { |
| |
NEXTNM(m0,m); |
| |
read_int(s,&c); CM(m) = c; |
| |
read_intarray(s,DL(m),nd_wpd); |
| |
} |
| |
NEXT(m) = 0; |
| |
MKND(nv,m0,len,d); |
| |
SG(d) = sugar; |
| |
fclose(s); |
| |
return d; |
| |
} |
| |
|
| void nd_det(int mod,MAT f,P *rp) |
void nd_det(int mod,MAT f,P *rp) |
| { |
{ |
| VL fv,tv; |
VL fv,tv; |
| Line 6343 void nd_det(int mod,MAT f,P *rp) |
|
| Line 7623 void nd_det(int mod,MAT f,P *rp) |
|
| m = (pointer **)w; |
m = (pointer **)w; |
| } |
} |
| |
|
| for ( i = 0, max = 0; i < n; i++ ) |
for ( i = 0, max = 1; i < n; i++ ) |
| for ( j = 0; j < n; j++ ) |
for ( j = 0; j < n; j++ ) |
| for ( tv = fv; tv; tv = NEXT(tv) ) { |
for ( tv = fv; tv; tv = NEXT(tv) ) { |
| e = getdeg(tv->v,(P)m[i][j]); |
e = getdeg(tv->v,(P)m[i][j]); |
| Line 6351 void nd_det(int mod,MAT f,P *rp) |
|
| Line 7631 void nd_det(int mod,MAT f,P *rp) |
|
| } |
} |
| nd_setup_parameters(nvar,max); |
nd_setup_parameters(nvar,max); |
| dm = (NDV **)almat_pointer(n,n); |
dm = (NDV **)almat_pointer(n,n); |
| for ( i = 0, max = 0; i < n; i++ ) |
for ( i = 0, max = 1; i < n; i++ ) |
| for ( j = 0; j < n; j++ ) { |
for ( j = 0; j < n; j++ ) { |
| dm[i][j] = ptondv(CO,fv,m[i][j]); |
dm[i][j] = ptondv(CO,fv,m[i][j]); |
| if ( mod ) ndv_mod(mod,dm[i][j]); |
if ( mod ) ndv_mod(mod,dm[i][j]); |
| Line 6711 void finalize_tracelist(int i,P cont) |
|
| Line 7991 void finalize_tracelist(int i,P cont) |
|
| Q iq; |
Q iq; |
| |
|
| if ( !UNIQ(cont) ) { |
if ( !UNIQ(cont) ) { |
| node = mknode(4,0,0,0,cont); |
node = mknode(4,NULLP,NULLP,NULLP,cont); |
| MKLIST(l,node); MKNODE(node,l,nd_tracelist); |
MKLIST(l,node); MKNODE(node,l,nd_tracelist); |
| nd_tracelist = node; |
nd_tracelist = node; |
| } |
} |
| Line 6736 void conv_ilist(int demand,int trace,NODE g,int **indp |
|
| Line 8016 void conv_ilist(int demand,int trace,NODE g,int **indp |
|
| BDY(t) = (pointer)(demand?ndv_load(j):(trace?nd_ps_trace[j]:nd_ps[j])); |
BDY(t) = (pointer)(demand?ndv_load(j):(trace?nd_ps_trace[j]:nd_ps[j])); |
| } |
} |
| if ( indp ) *indp = ind; |
if ( indp ) *indp = ind; |
| |
} |
| |
|
| |
void parse_nd_option(NODE opt) |
| |
{ |
| |
NODE t,p,u; |
| |
int i,s; |
| |
char *key; |
| |
Obj value; |
| |
|
| |
nd_gentrace = 0; nd_gensyz = 0; nd_nora = 0; nd_gbblock = 0; |
| |
nd_newelim = 0; nd_intersect = 0; nd_nzlist = 0; |
| |
nd_splist = 0; nd_check_splist = 0; |
| |
for ( t = opt; t; t = NEXT(t) ) { |
| |
p = BDY((LIST)BDY(t)); |
| |
key = BDY((STRING)BDY(p)); |
| |
value = (Obj)BDY(NEXT(p)); |
| |
if ( !strcmp(key,"gentrace") ) |
| |
nd_gentrace = value?1:0; |
| |
else if ( !strcmp(key,"gensyz") ) |
| |
nd_gensyz = value?1:0; |
| |
else if ( !strcmp(key,"nora") ) |
| |
nd_nora = value?1:0; |
| |
else if ( !strcmp(key,"gbblock") ) { |
| |
if ( !value || OID(value) != O_LIST ) |
| |
error("nd_* : invalid value for gbblock option"); |
| |
u = BDY((LIST)value); |
| |
nd_gbblock = MALLOC((2*length(u)+1)*sizeof(int)); |
| |
for ( i = 0; u; u = NEXT(u) ) { |
| |
p = BDY((LIST)BDY(u)); |
| |
s = nd_gbblock[i++] = QTOS((Q)BDY(p)); |
| |
nd_gbblock[i++] = s+QTOS((Q)BDY(NEXT(p)))-1; |
| |
} |
| |
nd_gbblock[i] = -1; |
| |
} else if ( !strcmp(key,"newelim") ) |
| |
nd_newelim = value?1:0; |
| |
else if ( !strcmp(key,"intersect") ) |
| |
nd_intersect = value?1:0; |
| |
else if ( !strcmp(key,"trace") ) { |
| |
u = BDY((LIST)value); |
| |
nd_nzlist = BDY((LIST)ARG2(u)); |
| |
nd_bpe = QTOS((Q)ARG3(u)); |
| |
} else if ( !strcmp(key,"splist") ) |
| |
nd_splist = value?1:0; |
| |
else if ( !strcmp(key,"check_splist") ) { |
| |
nd_check_splist = BDY((LIST)value); |
| |
} |
| |
} |
| |
} |
| |
|
| |
ND mdptond(DP d); |
| |
ND nd_mul_nm(int mod,NM m0,ND p); |
| |
ND *btog(NODE ti,ND **p,int nb,int mod); |
| |
ND btog_one(NODE ti,ND *p,int nb,int mod); |
| |
MAT nd_btog(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist,MAT *rp); |
| |
VECT nd_btog_one(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist,int pos,MAT *rp); |
| |
|
| |
/* d:monomial */ |
| |
ND mdptond(DP d) |
| |
{ |
| |
NM m; |
| |
ND r; |
| |
|
| |
if ( OID(d) == 1 ) |
| |
r = ptond(CO,CO,(P)d); |
| |
else { |
| |
NEWNM(m); |
| |
dltondl(NV(d),BDY(d)->dl,DL(m)); |
| |
CQ(m) = (Q)BDY(d)->c; |
| |
NEXT(m) = 0; |
| |
MKND(NV(d),m,1,r); |
| |
} |
| |
return r; |
| |
} |
| |
|
| |
ND nd_mul_nm(int mod,NM m0,ND p) |
| |
{ |
| |
UINT *d0; |
| |
int c0,c1,c; |
| |
NM tm,mr,mr0; |
| |
ND r; |
| |
|
| |
if ( !p ) return 0; |
| |
d0 = DL(m0); |
| |
c0 = CM(m0); |
| |
mr0 = 0; |
| |
for ( tm = BDY(p); tm; tm = NEXT(tm) ) { |
| |
NEXTNM(mr0,mr); |
| |
c = CM(tm); DMAR(c0,c,0,mod,c1); CM(mr) = c1; |
| |
ndl_add(d0,DL(tm),DL(mr)); |
| |
} |
| |
NEXT(mr) = 0; |
| |
MKND(NV(p),mr0,LEN(p),r); |
| |
return r; |
| |
} |
| |
|
| |
ND *btog(NODE ti,ND **p,int nb,int mod) |
| |
{ |
| |
PGeoBucket *r; |
| |
int i,ci; |
| |
NODE t,s; |
| |
ND m,tp; |
| |
ND *pi,*rd; |
| |
P c; |
| |
|
| |
r = (PGeoBucket *)MALLOC(nb*sizeof(PGeoBucket)); |
| |
for ( i = 0; i < nb; i++ ) |
| |
r[i] = create_pbucket(); |
| |
for ( t = ti; t; t = NEXT(t) ) { |
| |
s = BDY((LIST)BDY(t)); |
| |
if ( ARG0(s) ) { |
| |
m = mdptond((DP)ARG2(s)); |
| |
ptomp(mod,(P)HCQ(m),&c); |
| |
if ( ci = ((MQ)c)->cont ) { |
| |
HCM(m) = ci; |
| |
pi = p[QTOS((Q)ARG1(s))]; |
| |
for ( i = 0; i < nb; i++ ) { |
| |
tp = nd_mul_nm(mod,BDY(m),pi[i]); |
| |
add_pbucket(mod,r[i],tp); |
| |
} |
| |
} |
| |
ci = 1; |
| |
} else { |
| |
ptomp(mod,(P)ARG3(s),&c); ci = ((MQ)c)->cont; |
| |
ci = invm(ci,mod); |
| |
} |
| |
} |
| |
rd = (ND *)MALLOC(nb*sizeof(ND)); |
| |
for ( i = 0; i < nb; i++ ) |
| |
rd[i] = normalize_pbucket(mod,r[i]); |
| |
if ( ci != 1 ) |
| |
for ( i = 0; i < nb; i++ ) nd_mul_c(mod,rd[i],ci); |
| |
return rd; |
| |
} |
| |
|
| |
ND btog_one(NODE ti,ND *p,int nb,int mod) |
| |
{ |
| |
PGeoBucket r; |
| |
int i,ci,j; |
| |
NODE t,s; |
| |
ND m,tp; |
| |
ND pi,rd; |
| |
P c; |
| |
|
| |
r = create_pbucket(); |
| |
for ( t = ti; t; t = NEXT(t) ) { |
| |
s = BDY((LIST)BDY(t)); |
| |
if ( ARG0(s) ) { |
| |
m = mdptond((DP)ARG2(s)); |
| |
ptomp(mod,(P)HCQ(m),&c); |
| |
if ( ci = ((MQ)c)->cont ) { |
| |
HCM(m) = ci; |
| |
pi = p[j=QTOS((Q)ARG1(s))]; |
| |
if ( !pi ) { |
| |
pi = nd_load_mod(j); |
| |
tp = nd_mul_nm(mod,BDY(m),pi); |
| |
nd_free(pi); |
| |
add_pbucket(mod,r,tp); |
| |
} else { |
| |
tp = nd_mul_nm(mod,BDY(m),pi); |
| |
add_pbucket(mod,r,tp); |
| |
} |
| |
} |
| |
ci = 1; |
| |
} else { |
| |
ptomp(mod,(P)ARG3(s),&c); ci = ((MQ)c)->cont; |
| |
ci = invm(ci,mod); |
| |
} |
| |
} |
| |
rd = normalize_pbucket(mod,r); |
| |
free_pbucket(r); |
| |
if ( ci != 1 ) nd_mul_c(mod,rd,ci); |
| |
return rd; |
| |
} |
| |
|
| |
MAT nd_btog(LIST f,LIST v,int mod,struct order_spec *ord,LIST tlist,MAT *rp) |
| |
{ |
| |
int i,j,n,m,nb,pi0,pi1,nvar; |
| |
VL fv,tv,vv; |
| |
NODE permtrace,perm,trace,intred,ind,t,pi,ti; |
| |
ND **p; |
| |
ND *c; |
| |
ND u; |
| |
P inv; |
| |
MAT mat; |
| |
|
| |
parse_nd_option(current_option); |
| |
get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&nd_vc); |
| |
for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ ); |
| |
switch ( ord->id ) { |
| |
case 1: |
| |
if ( ord->nv != nvar ) |
| |
error("nd_check : invalid order specification"); |
| |
break; |
| |
default: |
| |
break; |
| |
} |
| |
nd_init_ord(ord); |
| |
#if 0 |
| |
nd_bpe = QTOS((Q)ARG7(BDY(tlist))); |
| |
#else |
| |
nd_bpe = 32; |
| |
#endif |
| |
nd_setup_parameters(nvar,0); |
| |
permtrace = BDY((LIST)ARG2(BDY(tlist))); |
| |
intred = BDY((LIST)ARG3(BDY(tlist))); |
| |
ind = BDY((LIST)ARG4(BDY(tlist))); |
| |
perm = BDY((LIST)BDY(permtrace)); trace =NEXT(permtrace); |
| |
for ( i = length(perm)-1, t = trace; t; t = NEXT(t) ) { |
| |
j = QTOS((Q)BDY(BDY((LIST)BDY(t)))); |
| |
if ( j > i ) i = j; |
| |
} |
| |
n = i+1; |
| |
nb = length(BDY(f)); |
| |
p = (ND **)MALLOC(n*sizeof(ND *)); |
| |
for ( t = perm, i = 0; t; t = NEXT(t), i++ ) { |
| |
pi = BDY((LIST)BDY(t)); |
| |
pi0 = QTOS((Q)ARG0(pi)); pi1 = QTOS((Q)ARG1(pi)); |
| |
p[pi0] = c = (ND *)MALLOC(nb*sizeof(ND)); |
| |
ptomp(mod,(P)ARG2(pi),&inv); |
| |
((MQ)inv)->cont = invm(((MQ)inv)->cont,mod); |
| |
u = ptond(CO,vv,(P)ONE); |
| |
HCM(u) = ((MQ)inv)->cont; |
| |
c[pi1] = u; |
| |
} |
| |
for ( t = trace,i=0; t; t = NEXT(t), i++ ) { |
| |
printf("%d ",i); fflush(stdout); |
| |
ti = BDY((LIST)BDY(t)); |
| |
p[j=QTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod); |
| |
if ( j == 441 ) |
| |
printf("afo"); |
| |
} |
| |
for ( t = intred, i=0; t; t = NEXT(t), i++ ) { |
| |
printf("%d ",i); fflush(stdout); |
| |
ti = BDY((LIST)BDY(t)); |
| |
p[j=QTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod); |
| |
if ( j == 441 ) |
| |
printf("afo"); |
| |
} |
| |
m = length(ind); |
| |
MKMAT(mat,nb,m); |
| |
for ( j = 0, t = ind; j < m; j++, t = NEXT(t) ) |
| |
for ( i = 0, c = p[QTOS((Q)BDY(t))]; i < nb; i++ ) |
| |
BDY(mat)[i][j] = ndtodp(mod,c[i]); |
| |
return mat; |
| |
} |
| |
|
| |
VECT nd_btog_one(LIST f,LIST v,int mod,struct order_spec *ord, |
| |
LIST tlist,int pos,MAT *rp) |
| |
{ |
| |
int i,j,n,m,nb,pi0,pi1,nvar; |
| |
VL fv,tv,vv; |
| |
NODE permtrace,perm,trace,intred,ind,t,pi,ti; |
| |
ND *p; |
| |
ND *c; |
| |
ND u; |
| |
P inv; |
| |
VECT vect; |
| |
|
| |
parse_nd_option(current_option); |
| |
get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&nd_vc); |
| |
for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ ); |
| |
switch ( ord->id ) { |
| |
case 1: |
| |
if ( ord->nv != nvar ) |
| |
error("nd_check : invalid order specification"); |
| |
break; |
| |
default: |
| |
break; |
| |
} |
| |
nd_init_ord(ord); |
| |
#if 0 |
| |
nd_bpe = QTOS((Q)ARG7(BDY(tlist))); |
| |
#else |
| |
nd_bpe = 32; |
| |
#endif |
| |
nd_setup_parameters(nvar,0); |
| |
permtrace = BDY((LIST)ARG2(BDY(tlist))); |
| |
intred = BDY((LIST)ARG3(BDY(tlist))); |
| |
ind = BDY((LIST)ARG4(BDY(tlist))); |
| |
perm = BDY((LIST)BDY(permtrace)); trace =NEXT(permtrace); |
| |
for ( i = length(perm)-1, t = trace; t; t = NEXT(t) ) { |
| |
j = QTOS((Q)BDY(BDY((LIST)BDY(t)))); |
| |
if ( j > i ) i = j; |
| |
} |
| |
n = i+1; |
| |
nb = length(BDY(f)); |
| |
p = (ND *)MALLOC(n*sizeof(ND *)); |
| |
for ( t = perm, i = 0; t; t = NEXT(t), i++ ) { |
| |
pi = BDY((LIST)BDY(t)); |
| |
pi0 = QTOS((Q)ARG0(pi)); pi1 = QTOS((Q)ARG1(pi)); |
| |
if ( pi1 == pos ) { |
| |
ptomp(mod,(P)ARG2(pi),&inv); |
| |
((MQ)inv)->cont = invm(((MQ)inv)->cont,mod); |
| |
u = ptond(CO,vv,(P)ONE); |
| |
HCM(u) = ((MQ)inv)->cont; |
| |
p[pi0] = u; |
| |
} |
| |
} |
| |
for ( t = trace,i=0; t; t = NEXT(t), i++ ) { |
| |
printf("%d ",i); fflush(stdout); |
| |
ti = BDY((LIST)BDY(t)); |
| |
p[j=QTOS((Q)ARG0(ti))] = btog_one(BDY((LIST)ARG1(ti)),p,nb,mod); |
| |
if ( Demand ) { |
| |
nd_save_mod(p[j],j); nd_free(p[j]); p[j] = 0; |
| |
} |
| |
} |
| |
for ( t = intred, i=0; t; t = NEXT(t), i++ ) { |
| |
printf("%d ",i); fflush(stdout); |
| |
ti = BDY((LIST)BDY(t)); |
| |
p[j=QTOS((Q)ARG0(ti))] = btog_one(BDY((LIST)ARG1(ti)),p,nb,mod); |
| |
if ( Demand ) { |
| |
nd_save_mod(p[j],j); nd_free(p[j]); p[j] = 0; |
| |
} |
| |
} |
| |
m = length(ind); |
| |
MKVECT(vect,m); |
| |
for ( j = 0, t = ind; j < m; j++, t = NEXT(t) ) { |
| |
u = p[QTOS((Q)BDY(t))]; |
| |
if ( !u ) { |
| |
u = nd_load_mod(QTOS((Q)BDY(t))); |
| |
BDY(vect)[j] = ndtodp(mod,u); |
| |
nd_free(u); |
| |
} else |
| |
BDY(vect)[j] = ndtodp(mod,u); |
| |
} |
| |
return vect; |
| } |
} |
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to nd.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib2 / asir2000 / engine