| version 1.211, 2013/09/26 08:55:11 |
version 1.236, 2017/03/27 09:05:46 |
|
|
| /* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.210 2013/09/26 00:38:47 noro Exp $ */ |
/* $OpenXM: OpenXM_contrib2/asir2000/engine/nd.c,v 1.235 2017/02/28 07:06:28 noro Exp $ */ |
| |
|
| #include "nd.h" |
#include "nd.h" |
| |
|
| Line 8 int diag_period = 6; |
|
| Line 8 int diag_period = 6; |
|
| int weight_check = 1; |
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 37 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 50 static int nd_found,nd_create,nd_notfirst; |
|
| Line 56 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,nd_pot_nelim; |
static int nd_module,nd_ispot,nd_mpos,nd_pot_nelim; |
| |
static int nd_module_rank,nd_poly_weight_len; |
| |
static int *nd_poly_weight,*nd_module_weight; |
| 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_gentrace,nd_gensyz,nd_nora,nd_newelim,nd_intersect,nd_lf; |
| static int *nd_gbblock; |
static int *nd_gbblock; |
| static NODE nd_nzlist,nd_check_splist; |
static NODE nd_nzlist,nd_check_splist; |
| static int nd_splist; |
static int nd_splist; |
| |
static int *nd_sugarweight; |
| |
static int nd_f4red,nd_rank0; |
| |
|
| 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 77 void parse_nd_option(NODE opt); |
|
| Line 87 void parse_nd_option(NODE opt); |
|
| void dltondl(int n,DL dl,UINT *r); |
void dltondl(int n,DL dl,UINT *r); |
| DP ndvtodp(int mod,NDV p); |
DP ndvtodp(int mod,NDV p); |
| DP ndtodp(int mod,ND p); |
DP ndtodp(int mod,ND p); |
| |
NDV ndvtondvgz(NDV p); |
| |
NDV ndvgztondv(NDV p); |
| |
ND ndtondgz(ND p); |
| |
ND ndgztond(ND p); |
| |
|
| extern int Denominator,DP_Multiple; |
void Pdp_set_weight(NODE,VECT *); |
| |
void Pox_cmo_rpc(NODE,Obj *); |
| |
|
| |
ND nd_add_lf(ND p1,ND p2); |
| |
void nd_mul_c_lf(ND p,GZ mul); |
| |
void ndv_mul_c_lf(NDV p,GZ mul); |
| |
NODE nd_f4_red_lf_main(int m,ND_pairs sp0,int nsp,int trace,UINT *s0vect,int col, |
| |
NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred); |
| |
int nd_gauss_elim_lf(mpz_t **mat0,int *sugar,int row,int col,int *colstat); |
| |
NODE nd_f4_lf_trace_main(int m,int **indp); |
| |
void nd_f4_lf_trace(LIST f,LIST v,int trace,int homo,struct order_spec *ord,LIST *rp); |
| |
|
| |
extern int lf_lazy; |
| |
extern GZ current_mod_lf; |
| |
|
| |
extern int Denominator,DP_Multiple,MaxDeg; |
| |
|
| |
#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 100 void _NM_alloc() |
|
| Line 137 void _NM_alloc() |
|
| } |
} |
| } |
} |
| |
|
| |
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; |
| Line 136 INLINE int nd_length(ND p) |
|
| Line 187 INLINE int nd_length(ND p) |
|
| } |
} |
| } |
} |
| |
|
| |
extern int dp_negative_weight; |
| |
|
| INLINE int ndl_reducible(UINT *d1,UINT *d2) |
INLINE int ndl_reducible(UINT *d1,UINT *d2) |
| { |
{ |
| UINT u1,u2; |
UINT u1,u2; |
| Line 143 INLINE int ndl_reducible(UINT *d1,UINT *d2) |
|
| Line 196 INLINE int ndl_reducible(UINT *d1,UINT *d2) |
|
| |
|
| if ( nd_module && (MPOS(d1) != MPOS(d2)) ) return 0; |
if ( nd_module && (MPOS(d1) != MPOS(d2)) ) return 0; |
| |
|
| if ( TD(d1) < TD(d2) ) return 0; |
if ( !dp_negative_weight && TD(d1) < TD(d2) ) return 0; |
| #if USE_UNROLL |
#if USE_UNROLL |
| switch ( nd_bpe ) { |
switch ( nd_bpe ) { |
| case 3: |
case 3: |
| Line 422 int ndl_weight(UINT *d) |
|
| Line 475 int ndl_weight(UINT *d) |
|
| return t; |
return t; |
| } |
} |
| |
|
| |
/* for sugarweight */ |
| |
|
| |
int ndl_weight2(UINT *d) |
| |
{ |
| |
int t,u; |
| |
int i,j; |
| |
|
| |
for ( i = 0, t = 0; i < nd_nvar; i++ ) { |
| |
u = GET_EXP(d,i); |
| |
t += nd_sugarweight[i]*u; |
| |
} |
| |
if ( nd_module && current_module_weight_vector && MPOS(d) ) |
| |
t += current_module_weight_vector[MPOS(d)]; |
| |
return t; |
| |
} |
| |
|
| void ndl_weight_mask(UINT *d) |
void ndl_weight_mask(UINT *d) |
| { |
{ |
| UINT t,u; |
UINT t,u; |
| Line 490 int ndl_block_compare(UINT *d1,UINT *d2) |
|
| Line 559 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 502 int ndl_matrix_compare(UINT *d1,UINT *d2) |
|
| Line 597 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 555 int ndl_composite_compare(UINT *d1,UINT *d2) |
|
| Line 652 int ndl_composite_compare(UINT *d1,UINT *d2) |
|
| else if ( nd_work_vector[j] < 0 ) return -1; |
else if ( nd_work_vector[j] < 0 ) return -1; |
| break; |
break; |
| case 2: |
case 2: |
| |
end = start+len; |
| for ( j = start; j < end; j++ ) |
for ( j = start; j < end; j++ ) |
| if ( nd_work_vector[j] > 0 ) return 1; |
if ( nd_work_vector[j] > 0 ) return 1; |
| else if ( nd_work_vector[j] < 0 ) return -1; |
else if ( nd_work_vector[j] < 0 ) return -1; |
| Line 584 int ndl_ww_lex_compare(UINT *d1,UINT *d2) |
|
| Line 682 int ndl_ww_lex_compare(UINT *d1,UINT *d2) |
|
| return ndl_lex_compare(d1,d2); |
return ndl_lex_compare(d1,d2); |
| } |
} |
| |
|
| |
int ndl_module_weight_compare(UINT *d1,UINT *d2) |
| |
{ |
| |
int s,j; |
| |
|
| |
if ( nd_nvar != nd_poly_weight_len ) |
| |
error("invalid module weight : the length of polynomial weight != the number of variables"); |
| |
s = 0; |
| |
for ( j = 0; j < nd_nvar; j++ ) |
| |
s += (GET_EXP(d1,j)-GET_EXP(d2,j))*nd_poly_weight[j]; |
| |
if ( MPOS(d1) >= 1 && MPOS(d2) >= 1 ) { |
| |
s += nd_module_weight[MPOS(d1)-1]-nd_module_weight[MPOS(d2)-1]; |
| |
} |
| |
if ( s > 0 ) return 1; |
| |
else if ( s < 0 ) return -1; |
| |
else return 0; |
| |
} |
| |
|
| int ndl_module_grlex_compare(UINT *d1,UINT *d2) |
int ndl_module_grlex_compare(UINT *d1,UINT *d2) |
| { |
{ |
| int i,c; |
int i,c; |
| |
|
| |
if ( nd_module_rank && (c = ndl_module_weight_compare(d1,d2)) ) return c; |
| if ( nd_ispot ) { |
if ( nd_ispot ) { |
| if ( nd_pot_nelim && MPOS(d1)>=nd_pot_nelim+1 && MPOS(d2) >= nd_pot_nelim+1 ) { |
if ( nd_pot_nelim && MPOS(d1)>=nd_pot_nelim+1 && MPOS(d2) >= nd_pot_nelim+1 ) { |
| if ( TD(d1) > TD(d2) ) return 1; |
if ( TD(d1) > TD(d2) ) return 1; |
| Line 614 int ndl_module_glex_compare(UINT *d1,UINT *d2) |
|
| Line 730 int ndl_module_glex_compare(UINT *d1,UINT *d2) |
|
| { |
{ |
| int i,c; |
int i,c; |
| |
|
| |
if ( nd_module_rank && (c = ndl_module_weight_compare(d1,d2)) ) return c; |
| if ( nd_ispot ) { |
if ( nd_ispot ) { |
| 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 632 int ndl_module_lex_compare(UINT *d1,UINT *d2) |
|
| Line 749 int ndl_module_lex_compare(UINT *d1,UINT *d2) |
|
| { |
{ |
| int i,c; |
int i,c; |
| |
|
| |
if ( nd_module_rank && (c = ndl_module_weight_compare(d1,d2)) ) return c; |
| if ( nd_ispot ) { |
if ( nd_ispot ) { |
| 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 648 int ndl_module_block_compare(UINT *d1,UINT *d2) |
|
| Line 766 int ndl_module_block_compare(UINT *d1,UINT *d2) |
|
| { |
{ |
| int i,c; |
int i,c; |
| |
|
| |
if ( nd_module_rank && (c = ndl_module_weight_compare(d1,d2)) ) return c; |
| if ( nd_ispot ) { |
if ( nd_ispot ) { |
| 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 664 int ndl_module_matrix_compare(UINT *d1,UINT *d2) |
|
| Line 783 int ndl_module_matrix_compare(UINT *d1,UINT *d2) |
|
| { |
{ |
| int i,c; |
int i,c; |
| |
|
| |
if ( nd_module_rank && (c = ndl_module_weight_compare(d1,d2)) ) return c; |
| if ( nd_ispot ) { |
if ( nd_ispot ) { |
| 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 680 int ndl_module_composite_compare(UINT *d1,UINT *d2) |
|
| Line 800 int ndl_module_composite_compare(UINT *d1,UINT *d2) |
|
| { |
{ |
| int i,c; |
int i,c; |
| |
|
| |
if ( nd_module_rank && (c = ndl_module_weight_compare(d1,d2)) ) return c; |
| if ( nd_ispot ) { |
if ( nd_ispot ) { |
| 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 1097 ND nd_add(int mod,ND p1,ND p2) |
|
| Line 1218 ND nd_add(int mod,ND p1,ND p2) |
|
| if ( !p1 ) return p2; |
if ( !p1 ) return p2; |
| else if ( !p2 ) return p1; |
else if ( !p2 ) return p1; |
| else if ( mod == -1 ) return nd_add_sf(p1,p2); |
else if ( mod == -1 ) return nd_add_sf(p1,p2); |
| |
else if ( mod == -2 ) return nd_add_lf(p1,p2); |
| else if ( !mod ) return nd_add_q(p1,p2); |
else if ( !mod ) return nd_add_q(p1,p2); |
| else { |
else { |
| can = 0; |
can = 0; |
| Line 1257 ND nd_add_sf(ND p1,ND p2) |
|
| Line 1379 ND nd_add_sf(ND p1,ND p2) |
|
| } |
} |
| } |
} |
| |
|
| |
|
| ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn,Obj *divp) |
ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn,Obj *divp) |
| { |
{ |
| int c,c1,c2; |
int c,c1,c2; |
| Line 1267 ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn,Ob |
|
| Line 1390 ND nd_reduce2(int mod,ND d,ND g,NDV p,NM mul,NDC dn,Ob |
|
| if ( mod == -1 ) { |
if ( mod == -1 ) { |
| CM(mul) = _mulsf(_invsf(HCM(p)),_chsgnsf(HCM(g))); |
CM(mul) = _mulsf(_invsf(HCM(p)),_chsgnsf(HCM(g))); |
| *divp = (Obj)ONE; |
*divp = (Obj)ONE; |
| |
} else if ( mod == -2 ) { |
| |
GZ inv,t; |
| |
divlf(ONEGZ,HCZ(p),&inv); |
| |
chsgnlf(HCZ(g),&t); |
| |
mullf(inv,t,&CZ(mul)); |
| |
*divp = (Obj)ONE; |
| } else if ( mod ) { |
} else if ( mod ) { |
| c1 = invm(HCM(p),mod); c2 = mod-HCM(g); |
c1 = invm(HCM(p),mod); c2 = mod-HCM(g); |
| DMAR(c1,c2,0,mod,c); CM(mul) = c; |
DMAR(c1,c2,0,mod,c); CM(mul) = c; |
| Line 1328 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND |
|
| Line 1457 int nd_nf(int mod,ND d,ND g,NDV *ps,int full,NDC dn,ND |
|
| |
|
| sugar0 = sugar = SG(g); |
sugar0 = sugar = SG(g); |
| n = NV(g); |
n = NV(g); |
| mul = (NM)ALLOCA(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT)); |
mul = (NM)MALLOC(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT)); |
| if ( d ) |
if ( d ) |
| for ( tail = BDY(d); NEXT(tail); tail = NEXT(tail) ); |
for ( tail = BDY(d); NEXT(tail); tail = NEXT(tail) ); |
| for ( ; g; ) { |
for ( ; g; ) { |
| Line 1416 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp |
|
| Line 1545 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp |
|
| bucket = create_pbucket(); |
bucket = create_pbucket(); |
| add_pbucket(mod,bucket,g); |
add_pbucket(mod,bucket,g); |
| d = 0; |
d = 0; |
| mul = (NM)ALLOCA(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT)); |
mul = (NM)MALLOC(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT)); |
| while ( 1 ) { |
while ( 1 ) { |
| hindex = mod?head_pbucket(mod,bucket):head_pbucket_q(bucket); |
if ( mod > 0 || mod == -1 ) |
| |
hindex = head_pbucket(mod,bucket); |
| |
else if ( mod == -2 ) |
| |
hindex = head_pbucket_lf(bucket); |
| |
else |
| |
hindex = head_pbucket_q(bucket); |
| if ( hindex < 0 ) { |
if ( hindex < 0 ) { |
| if ( DP_Print > 3 ) printf("(%d %d)",count,hcount); |
if ( DP_Print > 3 ) printf("(%d %d)",count,hcount); |
| if ( d ) SG(d) = sugar; |
if ( d ) SG(d) = sugar; |
| Line 1441 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp |
|
| Line 1575 int nd_nf_pbucket(int mod,ND g,NDV *ps,int full,ND *rp |
|
| p = ps[index]; |
p = ps[index]; |
| if ( mod == -1 ) |
if ( mod == -1 ) |
| CM(mul) = _mulsf(_invsf(HCM(p)),_chsgnsf(HCM(g))); |
CM(mul) = _mulsf(_invsf(HCM(p)),_chsgnsf(HCM(g))); |
| else if ( mod ) { |
else if ( mod == -2 ) { |
| |
GZ inv,t; |
| |
divlf(ONEGZ,HCZ(p),&inv); |
| |
chsgnlf(HCZ(g),&t); |
| |
mullf(inv,t,&CZ(mul)); |
| |
} else if ( mod ) { |
| c1 = invm(HCM(p),mod); c2 = mod-HCM(g); |
c1 = invm(HCM(p),mod); c2 = mod-HCM(g); |
| DMAR(c1,c2,0,mod,c); CM(mul) = c; |
DMAR(c1,c2,0,mod,c); CM(mul) = c; |
| } else { |
} else { |
|
|
| 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); |
| |
if ( m ) ndv_mod(m,r); |
| d = ndvtond(m,r); |
d = ndvtond(m,r); |
| stat = nd_nf(m,0,d,nd_ps,0,0,&nf); |
stat = nd_nf(m,0,d,nd_ps,0,0,&nf); |
| if ( !stat ) { |
if ( !stat ) { |
| Line 1749 int head_pbucket_q(PGeoBucket g) |
|
| Line 1889 int head_pbucket_q(PGeoBucket g) |
|
| } |
} |
| } |
} |
| |
|
| |
int head_pbucket_lf(PGeoBucket g) |
| |
{ |
| |
int j,i,c,k,nv; |
| |
GZ sum,t; |
| |
ND gi,gj; |
| |
|
| |
k = g->m; |
| |
while ( 1 ) { |
| |
j = -1; |
| |
for ( i = 0; i <= k; i++ ) { |
| |
if ( !(gi = g->body[i]) ) continue; |
| |
if ( j < 0 ) { |
| |
j = i; |
| |
gj = g->body[j]; |
| |
sum = HCZ(gj); |
| |
} else { |
| |
nv = NV(gi); |
| |
c = DL_COMPARE(HDL(gi),HDL(gj)); |
| |
if ( c > 0 ) { |
| |
if ( sum ) HCZ(gj) = sum; |
| |
else g->body[j] = nd_remove_head(gj); |
| |
j = i; |
| |
gj = g->body[j]; |
| |
sum = HCZ(gj); |
| |
} else if ( c == 0 ) { |
| |
addlf(sum,HCZ(gi),&t); |
| |
sum = t; |
| |
g->body[i] = nd_remove_head(gi); |
| |
} |
| |
} |
| |
} |
| |
if ( j < 0 ) return -1; |
| |
else if ( sum ) { |
| |
HCZ(gj) = sum; |
| |
return j; |
| |
} else |
| |
g->body[j] = nd_remove_head(gj); |
| |
} |
| |
} |
| |
|
| ND normalize_pbucket(int mod,PGeoBucket g) |
ND normalize_pbucket(int mod,PGeoBucket g) |
| { |
{ |
| int i; |
int i; |
| Line 1917 NODE nd_gb(int m,int ishomo,int checkonly,int gensyz,i |
|
| Line 2097 NODE nd_gb(int m,int ishomo,int checkonly,int gensyz,i |
|
| while ( d ) { |
while ( d ) { |
| again: |
again: |
| l = nd_minp(d,&d); |
l = nd_minp(d,&d); |
| |
if ( MaxDeg > 0 && SG(l) > MaxDeg ) break; |
| if ( SG(l) != sugar ) { |
if ( SG(l) != sugar ) { |
| if ( ishomo ) { |
if ( ishomo ) { |
| diag_count = 0; |
diag_count = 0; |
|
|
| } |
} |
| } |
} |
| 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); |
|
|
| return 1; |
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 2135 NODE nd_gb_trace(int m,int ishomo,int **indp) |
|
| Line 2356 NODE nd_gb_trace(int m,int ishomo,int **indp) |
|
| while ( d ) { |
while ( d ) { |
| again: |
again: |
| l = nd_minp(d,&d); |
l = nd_minp(d,&d); |
| |
if ( MaxDeg > 0 && SG(l) > MaxDeg ) break; |
| if ( SG(l) != sugar ) { |
if ( SG(l) != sugar ) { |
| #if 1 |
#if 1 |
| if ( ishomo ) { |
if ( ishomo ) { |
|
|
| 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,"|"); |
|
|
| FREENDP(l); |
FREENDP(l); |
| } |
} |
| if ( nd_nalg ) { |
if ( nd_nalg ) { |
| print_eg("monic",&eg_monic); |
if ( DP_Print ) { |
| print_eg("invdalg",&eg_invdalg); |
print_eg("monic",&eg_monic); |
| print_eg("le",&eg_le); |
print_eg("invdalg",&eg_invdalg); |
| |
print_eg("le",&eg_le); |
| |
} |
| } |
} |
| conv_ilist(nd_demand,1,g,indp); |
conv_ilist(nd_demand,1,g,indp); |
| if ( DP_Print ) { printf("nd_gb_trace done.\n"); fflush(stdout); } |
if ( DP_Print ) { printf("nd_gb_trace done.\n"); fflush(stdout); } |
| Line 2400 ND_pairs nd_newpairs( NODE g, int t ) |
|
| Line 2624 ND_pairs nd_newpairs( NODE g, int t ) |
|
| ndl_lcm(DL(nd_psh[r->i1]),dl,r->lcm); |
ndl_lcm(DL(nd_psh[r->i1]),dl,r->lcm); |
| s = SG(nd_psh[r->i1])-TD(DL(nd_psh[r->i1])); |
s = SG(nd_psh[r->i1])-TD(DL(nd_psh[r->i1])); |
| SG(r) = MAX(s,ts) + TD(LCM(r)); |
SG(r) = MAX(s,ts) + TD(LCM(r)); |
| |
/* experimental */ |
| |
if ( nd_sugarweight ) |
| |
r->sugar2 = ndl_weight2(r->lcm); |
| } |
} |
| if ( r0 ) NEXT(r) = 0; |
if ( r0 ) NEXT(r) = 0; |
| return r0; |
return r0; |
| } |
} |
| |
|
| |
/* ipair = [i1,i2],[i1,i2],... */ |
| |
ND_pairs nd_ipairtospair(NODE ipair) |
| |
{ |
| |
int s1,s2; |
| |
NODE tn,t; |
| |
ND_pairs r,r0; |
| |
|
| |
for ( r0 = 0, t = ipair; t; t = NEXT(t) ) { |
| |
NEXTND_pairs(r0,r); |
| |
tn = BDY((LIST)BDY(t)); |
| |
r->i1 = QTOS((Q)ARG0(tn)); |
| |
r->i2 = QTOS((Q)ARG1(tn)); |
| |
ndl_lcm(DL(nd_psh[r->i1]),DL(nd_psh[r->i2]),r->lcm); |
| |
s1 = SG(nd_psh[r->i1])-TD(DL(nd_psh[r->i1])); |
| |
s2 = SG(nd_psh[r->i2])-TD(DL(nd_psh[r->i2])); |
| |
SG(r) = MAX(s1,s2) + TD(LCM(r)); |
| |
/* experimental */ |
| |
if ( nd_sugarweight ) |
| |
r->sugar2 = ndl_weight2(r->lcm); |
| |
} |
| |
if ( r0 ) NEXT(r) = 0; |
| |
return r0; |
| |
} |
| |
|
| /* kokokara */ |
/* kokokara */ |
| |
|
| ND_pairs crit_B( ND_pairs d, int s ) |
ND_pairs crit_B( ND_pairs d, int s ) |
| Line 2417 ND_pairs crit_B( ND_pairs d, int s ) |
|
| Line 2668 ND_pairs crit_B( ND_pairs d, int s ) |
|
| t = DL(nd_psh[s]); |
t = DL(nd_psh[s]); |
| prev = 0; |
prev = 0; |
| head = cur = d; |
head = cur = d; |
| lcm = (UINT *)ALLOCA(nd_wpd*sizeof(UINT)); |
lcm = (UINT *)MALLOC(nd_wpd*sizeof(UINT)); |
| while ( cur ) { |
while ( cur ) { |
| tl = cur->lcm; |
tl = cur->lcm; |
| if ( ndl_reducible(tl,t) ) { |
if ( ndl_reducible(tl,t) ) { |
| Line 2585 ND_pairs nd_minp( ND_pairs d, ND_pairs *prest ) |
|
| Line 2836 ND_pairs nd_minp( ND_pairs d, ND_pairs *prest ) |
|
| NEXT(m) = 0; |
NEXT(m) = 0; |
| return m; |
return m; |
| } |
} |
| s = SG(m); |
|
| if ( !NoSugar ) { |
if ( !NoSugar ) { |
| for ( ml = 0, l = m; p; p = NEXT(l = p) ) |
if ( nd_sugarweight ) { |
| if ( (SG(p) < s) |
s = m->sugar2; |
| || ((SG(p) == s) && (DL_COMPARE(LCM(p),LCM(m)) < 0)) ) { |
for ( ml = 0, l = m; p; p = NEXT(l = p) ) |
| ml = l; m = p; s = SG(m); |
if ( (p->sugar2 < s) |
| } |
|| ((p->sugar2 == s) && (DL_COMPARE(LCM(p),LCM(m)) < 0)) ) { |
| |
ml = l; m = p; s = m->sugar2; |
| |
} |
| |
} else { |
| |
s = SG(m); |
| |
for ( ml = 0, l = m; p; p = NEXT(l = p) ) |
| |
if ( (SG(p) < s) |
| |
|| ((SG(p) == s) && (DL_COMPARE(LCM(p),LCM(m)) < 0)) ) { |
| |
ml = l; m = p; s = SG(m); |
| |
} |
| |
} |
| } else { |
} else { |
| for ( ml = 0, l = m; p; p = NEXT(l = p) ) |
for ( ml = 0, l = m; p; p = NEXT(l = p) ) |
| if ( DL_COMPARE(LCM(p),LCM(m)) < 0 ) { |
if ( DL_COMPARE(LCM(p),LCM(m)) < 0 ) { |
| Line 2612 ND_pairs nd_minsugarp( ND_pairs d, ND_pairs *prest ) |
|
| Line 2872 ND_pairs nd_minsugarp( ND_pairs d, ND_pairs *prest ) |
|
| int msugar,i; |
int msugar,i; |
| ND_pairs t,dm0,dm,dr0,dr; |
ND_pairs t,dm0,dm,dr0,dr; |
| |
|
| for ( msugar = SG(d), t = NEXT(d); t; t = NEXT(t) ) |
if ( nd_sugarweight ) { |
| if ( SG(t) < msugar ) msugar = SG(t); |
for ( msugar = d->sugar2, t = NEXT(d); t; t = NEXT(t) ) |
| dm0 = 0; dr0 = 0; |
if ( t->sugar2 < msugar ) msugar = t->sugar2; |
| for ( i = 0, t = d; t; t = NEXT(t) ) |
dm0 = 0; dr0 = 0; |
| if ( i < nd_f4_nsp && SG(t) == msugar ) { |
for ( i = 0, t = d; t; t = NEXT(t) ) |
| if ( dm0 ) NEXT(dm) = t; |
if ( i < nd_f4_nsp && t->sugar2 == msugar ) { |
| else dm0 = t; |
if ( dm0 ) NEXT(dm) = t; |
| dm = t; |
else dm0 = t; |
| i++; |
dm = t; |
| } else { |
i++; |
| if ( dr0 ) NEXT(dr) = t; |
} else { |
| else dr0 = t; |
if ( dr0 ) NEXT(dr) = t; |
| dr = t; |
else dr0 = t; |
| } |
dr = t; |
| |
} |
| |
} else { |
| |
for ( msugar = SG(d), t = NEXT(d); t; t = NEXT(t) ) |
| |
if ( SG(t) < msugar ) msugar = SG(t); |
| |
dm0 = 0; dr0 = 0; |
| |
for ( i = 0, t = d; t; t = NEXT(t) ) |
| |
if ( i < nd_f4_nsp && SG(t) == msugar ) { |
| |
if ( dm0 ) NEXT(dm) = t; |
| |
else dm0 = t; |
| |
dm = t; |
| |
i++; |
| |
} else { |
| |
if ( dr0 ) NEXT(dr) = t; |
| |
else dr0 = t; |
| |
dr = t; |
| |
} |
| |
} |
| NEXT(dm) = 0; |
NEXT(dm) = 0; |
| if ( dr0 ) NEXT(dr) = 0; |
if ( dr0 ) NEXT(dr) = 0; |
| *prest = dr0; |
*prest = dr0; |
| 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 2644 int ndv_newps(int m,NDV a,NDV aq) |
|
| Line 2921 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; |
| register_hcf(aq); |
if ( !m ) { |
| |
if ( !nd_vc ) nd_ps_gz[nd_psn] = ndvtondvgz(aq); |
| |
register_hcf(aq); |
| |
} else if ( m == -2 ) { |
| |
/* do nothing */ |
| |
} else |
| |
error("ndv_newps : invalud modulus"); |
| 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)); |
| } else { |
} else { |
| 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_sym[nd_psn] = ndv_symbolic(m,nd_ps_trace[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; |
| } |
} |
| } |
} |
| Line 2701 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i |
|
| Line 2991 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i |
|
| nd_tracelist = 0; |
nd_tracelist = 0; |
| |
|
| for ( nd_psn = 0, s = f; s; s = NEXT(s) ) if ( BDY(s) ) nd_psn++; |
for ( nd_psn = 0, s = f; s; s = NEXT(s) ) if ( BDY(s) ) nd_psn++; |
| w = (NDVI)ALLOCA(nd_psn*sizeof(struct oNDVI)); |
w = (NDVI)MALLOC(nd_psn*sizeof(struct oNDVI)); |
| for ( i = j = 0, s = f; s; s = NEXT(s), j++ ) |
for ( i = j = 0, s = f; s; s = NEXT(s), j++ ) |
| if ( BDY(s) ) { w[i].p = BDY(s); w[i].i = j; i++; } |
if ( BDY(s) ) { w[i].p = BDY(s); w[i].i = j; i++; } |
| if ( !dont_sort ) { |
if ( !dont_sort ) { |
| Line 2715 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i |
|
| Line 3005 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i |
|
| } |
} |
| 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 2731 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i |
|
| Line 3024 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i |
|
| for ( i = 0; i < nd_psn; i++ ) { |
for ( i = 0; i < nd_psn; i++ ) { |
| 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); |
if ( mod == -2 ) { |
| if ( !dont_removecont) ndv_removecont(0,a); |
/* over a large finite field */ |
| register_hcf(a); |
/* trace = small modulus */ |
| am = nd_ps[i] = ndv_dup(mod,a); |
a = nd_ps_trace[i] = ndv_dup(-2,w[i].p); |
| ndv_mod(mod,am); |
ndv_mod(-2,a); |
| if ( DL_COMPARE(HDL(am),HDL(a)) ) |
if ( !dont_removecont) ndv_removecont(-2,a); |
| return 0; |
am = nd_ps[i] = ndv_dup(trace,w[i].p); |
| ndv_removecont(mod,am); |
ndv_mod(trace,am); |
| |
if ( DL_COMPARE(HDL(am),HDL(a)) ) |
| |
return 0; |
| |
ndv_removecont(trace,am); |
| |
} else { |
| |
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); |
| |
register_hcf(a); |
| |
am = nd_ps[i] = ndv_dup(mod,a); |
| |
ndv_mod(mod,am); |
| |
if ( DL_COMPARE(HDL(am),HDL(a)) ) |
| |
return 0; |
| |
ndv_removecont(mod,am); |
| |
} |
| } else { |
} 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); |
| } |
} |
| Line 2756 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i |
|
| Line 3064 int ndv_setup(int mod,int trace,NODE f,int dont_sort,i |
|
| 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_sym[i] = ndv_symbolic(mod,nd_ps_trace[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; |
| } |
} |
| } |
} |
| Line 2788 void preprocess_algcoef(VL vv,VL av,struct order_spec |
|
| Line 3099 void preprocess_algcoef(VL vv,VL av,struct order_spec |
|
| LIST f1,f2; |
LIST f1,f2; |
| struct order_spec *current_spec; |
struct order_spec *current_spec; |
| VECT obj,obj0; |
VECT obj,obj0; |
| Obj tmp; |
VECT tmp; |
| |
|
| for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++); |
for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++); |
| for ( nalg = 0, tv = av; tv; tv = NEXT(tv), nalg++); |
for ( nalg = 0, tv = av; tv; tv = NEXT(tv), nalg++); |
| Line 2802 void preprocess_algcoef(VL vv,VL av,struct order_spec |
|
| Line 3113 void preprocess_algcoef(VL vv,VL av,struct order_spec |
|
| |
|
| /* simplification, making polynomials monic */ |
/* simplification, making polynomials monic */ |
| setfield_dalg(alist); |
setfield_dalg(alist); |
| obj_algtodalg(f,&f1); |
obj_algtodalg((Obj)f,(Obj *)&f1); |
| for ( t = BDY(f); t; t = NEXT(t) ) { |
for ( t = BDY(f); t; t = NEXT(t) ) { |
| initd(ord); ptod(vv,vv,(P)BDY(t),&d); |
initd(ord); ptod(vv,vv,(P)BDY(t),&d); |
| hc = (DAlg)BDY(d)->c; |
hc = (DAlg)BDY(d)->c; |
| Line 2814 void preprocess_algcoef(VL vv,VL av,struct order_spec |
|
| Line 3125 void preprocess_algcoef(VL vv,VL av,struct order_spec |
|
| } |
} |
| initd(ord); dtop(vv,vv,d,&poly); BDY(f) = (pointer)poly; |
initd(ord); dtop(vv,vv,d,&poly); BDY(f) = (pointer)poly; |
| } |
} |
| obj_dalgtoalg(f1,&f); |
obj_dalgtoalg((Obj)f1,(Obj *)&f); |
| |
|
| /* append alg vars to the var list */ |
/* append alg vars to the var list */ |
| for ( tv = vv; NEXT(tv); tv = NEXT(tv) ); |
for ( tv = vv; NEXT(tv); tv = NEXT(tv) ); |
| Line 2831 void preprocess_algcoef(VL vv,VL av,struct order_spec |
|
| Line 3142 void preprocess_algcoef(VL vv,VL av,struct order_spec |
|
| } |
} |
| MKLIST(f1,t); |
MKLIST(f1,t); |
| *alistp = alist; |
*alistp = alist; |
| algobjtorat(f1,f1p); |
algobjtorat((Obj)f1,(Obj *)f1p); |
| |
|
| /* creating a new weight vector */ |
/* creating a new weight vector */ |
| prev_weight_vector_obj = obj0 = current_dl_weight_vector_obj; |
prev_weight_vector_obj = obj0 = current_dl_weight_vector_obj; |
| Line 2852 NODE postprocess_algcoef(VL av,NODE alist,NODE r) |
|
| Line 3163 NODE postprocess_algcoef(VL av,NODE alist,NODE r) |
|
| NODE s,t,u0,u; |
NODE s,t,u0,u; |
| P p; |
P p; |
| VL tv; |
VL tv; |
| Obj obj,tmp; |
Obj obj; |
| |
VECT tmp; |
| NODE arg; |
NODE arg; |
| |
|
| u0 = 0; |
u0 = 0; |
| Line 2906 void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int |
|
| Line 3218 void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int |
|
| ndv_alloc = 0; |
ndv_alloc = 0; |
| #endif |
#endif |
| 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); |
| |
if ( m && nd_vc ) |
| |
error("nd_{gr,f4} : computation over Fp(X) is unsupported. Use dp_gr_mod_main()."); |
| 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 ) { |
| case 1: |
case 1: |
| Line 2989 void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int |
|
| Line 3303 void nd_gr(LIST f,LIST v,int m,int homo,int retdp,int |
|
| return; |
return; |
| } |
} |
| if ( nd_check_splist ) { |
if ( nd_check_splist ) { |
| if ( check_splist(m,nd_check_splist) ) *rp = (LIST)ONE; |
if ( f4 ) { |
| else *rp = 0; |
if ( check_splist_f4(m,nd_check_splist) ) *rp = (LIST)ONE; |
| |
else *rp = 0; |
| |
} else { |
| |
if ( check_splist(m,nd_check_splist) ) *rp = (LIST)ONE; |
| |
else *rp = 0; |
| |
} |
| return; |
return; |
| } |
} |
| x = f4?nd_f4(m,&perm):nd_gb(m,ishomo || homo,0,0,&perm); |
x = f4?nd_f4(m,0,&perm):nd_gb(m,ishomo || homo,0,0,&perm); |
| if ( !x ) { |
if ( !x ) { |
| *rp = 0; return; |
*rp = 0; return; |
| } |
} |
| Line 3173 NDV recompute_trace(NODE ti,NDV *p,int mod) |
|
| Line 3492 NDV recompute_trace(NODE ti,NDV *p,int mod) |
|
| static int afo=0; |
static int afo=0; |
| |
|
| afo++; |
afo++; |
| mul = (NM)ALLOCA(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT)); |
mul = (NM)MALLOC(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT)); |
| CM(mul) = 1; |
CM(mul) = 1; |
| tail = 0; |
tail = 0; |
| for ( i = 0, d = r = 0; ti; ti = NEXT(ti), i++ ) { |
for ( i = 0, d = r = 0; ti; ti = NEXT(ti), i++ ) { |
| Line 3194 NDV recompute_trace(NODE ti,NDV *p,int mod) |
|
| Line 3513 NDV recompute_trace(NODE ti,NDV *p,int mod) |
|
| } |
} |
| } |
} |
| if ( !m ) return 0; /* failure */ |
if ( !m ) return 0; /* failure */ |
| else { |
else { |
| BDY(r) = m; |
BDY(r) = m; |
| c1 = invm(HCM(rm),mod); c2 = mod-HCM(r); |
if ( mod > 0 || mod == -1 ) { |
| DMAR(c1,c2,0,mod,c); |
c1 = invm(HCM(rm),mod); c2 = mod-HCM(r); |
| nd_mul_c(mod,rm,c); |
DMAR(c1,c2,0,mod,c); |
| |
nd_mul_c(mod,rm,c); |
| |
} else { |
| |
GZ t,u; |
| |
|
| |
chsgnlf(HCZ(r),&t); |
| |
divlf(t,HCZ(rm),&u); |
| |
nd_mul_c_lf(rm,u); |
| |
} |
| r = nd_add(mod,r,rm); |
r = nd_add(mod,r,rm); |
| } |
} |
| } |
} |
| } |
} |
| } |
} |
| if ( tail ) NEXT(tail) = 0; |
if ( tail ) NEXT(tail) = 0; |
| d = nd_add(mod,d,r); |
d = nd_add(mod,d,r); |
| Line 3325 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| Line 3652 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| Q jq,bpe; |
Q jq,bpe; |
| |
|
| nd_module = 0; |
nd_module = 0; |
| |
nd_lf = 0; |
| parse_nd_option(current_option); |
parse_nd_option(current_option); |
| |
if ( nd_lf ) { |
| |
if ( f4 ) |
| |
nd_f4_lf_trace(f,v,trace,homo,ord,rp); |
| |
else |
| |
error("nd_gr_trace is not implemented yet over a large finite field"); |
| |
return; |
| |
} |
| 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 3415 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| Line 3750 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| for ( t = fd0; t; t = NEXT(t) ) |
for ( t = fd0; t; t = NEXT(t) ) |
| ndv_homogenize((NDV)BDY(t),obpe,oadv,oepos,ompos); |
ndv_homogenize((NDV)BDY(t),obpe,oadv,oepos,ompos); |
| } |
} |
| |
if ( MaxDeg > 0 ) nocheck = 1; |
| while ( 1 ) { |
while ( 1 ) { |
| tl1 = tl2 = tl3 = tl4 = 0; |
tl1 = tl2 = tl3 = tl4 = 0; |
| if ( Demand ) |
if ( Demand ) |
| Line 3451 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| Line 3787 void nd_gr_trace(LIST f,LIST v,int trace,int homo,int |
|
| tl3 = nd_alltracelist; nd_alltracelist = 0; |
tl3 = nd_alltracelist; nd_alltracelist = 0; |
| } else tl3 = 0; |
} else tl3 = 0; |
| /* gbcheck : cand is a GB of Id(cand) ? */ |
/* gbcheck : cand is a GB of Id(cand) ? */ |
| ret = nd_gb(0,0,1,nd_gensyz?1:0,0)!=0; |
if ( nd_vc || nd_gentrace || nd_gensyz ) |
| |
ret = nd_gb(0,0,1,nd_gensyz?1:0,0)!=0; |
| |
else |
| |
ret = nd_f4(0,1,0)!=0; |
| if ( nd_gentrace && nd_gensyz ) { |
if ( nd_gentrace && nd_gensyz ) { |
| tl4 = nd_alltracelist; nd_alltracelist = 0; |
tl4 = nd_alltracelist; nd_alltracelist = 0; |
| } else tl4 = 0; |
} else tl4 = 0; |
| Line 3589 void ndl_print(UINT *dl) |
|
| Line 3928 void ndl_print(UINT *dl) |
|
| for ( i = 0; i < n; i++ ) printf(i==n-1?"%d":"%d,",GET_EXP(dl,i)); |
for ( i = 0; i < n; i++ ) printf(i==n-1?"%d":"%d,",GET_EXP(dl,i)); |
| } |
} |
| printf(">>"); |
printf(">>"); |
| if ( MPOS(dl) ) |
if ( nd_module && MPOS(dl) ) |
| printf("*e%d",MPOS(dl)); |
printf("*e%d",MPOS(dl)); |
| } |
} |
| |
|
| Line 3644 void nd_removecont(int mod,ND p) |
|
| Line 3983 void nd_removecont(int mod,ND p) |
|
| N q,r; |
N q,r; |
| |
|
| if ( mod == -1 ) nd_mul_c(mod,p,_invsf(HCM(p))); |
if ( mod == -1 ) nd_mul_c(mod,p,_invsf(HCM(p))); |
| else if ( mod ) nd_mul_c(mod,p,invm(HCM(p),mod)); |
else if ( mod == -2 ) { |
| |
GZ inv; |
| |
divlf(ONEGZ,HCZ(p),&inv); |
| |
nd_mul_c_lf(p,inv); |
| |
} else if ( mod ) nd_mul_c(mod,p,invm(HCM(p),mod)); |
| else { |
else { |
| for ( m = BDY(p), n = 0; m; m = NEXT(m), n++ ); |
for ( m = BDY(p), n = 0; m; m = NEXT(m), n++ ); |
| w = (Q *)ALLOCA(n*sizeof(Q)); |
w = (Q *)MALLOC(n*sizeof(Q)); |
| v.len = n; |
v.len = n; |
| v.body = (pointer *)w; |
v.body = (pointer *)w; |
| for ( m = BDY(p), i = 0; i < n; m = NEXT(m), i++ ) w[i] = CQ(m); |
for ( m = BDY(p), i = 0; i < n; m = NEXT(m), i++ ) w[i] = CQ(m); |
| Line 3668 void nd_removecont2(ND p1,ND p2) |
|
| Line 4011 void nd_removecont2(ND p1,ND p2) |
|
| n1 = nd_length(p1); |
n1 = nd_length(p1); |
| n2 = nd_length(p2); |
n2 = nd_length(p2); |
| n = n1+n2; |
n = n1+n2; |
| w = (Q *)ALLOCA(n*sizeof(Q)); |
w = (Q *)MALLOC(n*sizeof(Q)); |
| v.len = n; |
v.len = n; |
| v.body = (pointer *)w; |
v.body = (pointer *)w; |
| i = 0; |
i = 0; |
| Line 3695 void ndv_removecont(int mod,NDV p) |
|
| Line 4038 void ndv_removecont(int mod,NDV p) |
|
| |
|
| if ( mod == -1 ) |
if ( mod == -1 ) |
| ndv_mul_c(mod,p,_invsf(HCM(p))); |
ndv_mul_c(mod,p,_invsf(HCM(p))); |
| else if ( mod ) |
else if ( mod == -2 ) { |
| |
GZ inv; |
| |
divlf(ONEGZ,HCZ(p),&inv); |
| |
ndv_mul_c_lf(p,inv); |
| |
} else if ( mod ) |
| ndv_mul_c(mod,p,invm(HCM(p),mod)); |
ndv_mul_c(mod,p,invm(HCM(p),mod)); |
| else { |
else { |
| len = p->len; |
len = p->len; |
| w = (P *)ALLOCA(len*sizeof(P)); |
w = (P *)MALLOC(len*sizeof(P)); |
| c = (Q *)ALLOCA(len*sizeof(Q)); |
c = (Q *)MALLOC(len*sizeof(Q)); |
| for ( m = BDY(p), all_p = 1, i = 0; i < len; NMV_ADV(m), i++ ) { |
for ( m = BDY(p), all_p = 1, i = 0; i < len; NMV_ADV(m), i++ ) { |
| ptozp(CP(m),1,&c[i],&w[i]); |
ptozp(CP(m),1,&c[i],&w[i]); |
| all_p = all_p && !NUM(w[i]); |
all_p = all_p && !NUM(w[i]); |
| Line 3734 void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos |
|
| Line 4081 void ndv_homogenize(NDV p,int obpe,int oadv,EPOS oepos |
|
| 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); |
| mr = (NMV)((char *)mr0+(len-1)*nmv_adv); |
mr = (NMV)((char *)mr0+(len-1)*nmv_adv); |
| t = (NMV)ALLOCA(nmv_adv); |
t = (NMV)MALLOC(nmv_adv); |
| for ( i = 0; i < len; i++, NMV_OPREV(m), NMV_PREV(mr) ) { |
for ( i = 0; i < len; i++, NMV_OPREV(m), NMV_PREV(mr) ) { |
| ndl_homogenize(DL(m),DL(t),obpe,oepos,ompos,max); |
ndl_homogenize(DL(m),DL(t),obpe,oepos,ompos,max); |
| CQ(mr) = CQ(m); |
CQ(mr) = CQ(m); |
| Line 3782 void nd_heu_nezgcdnpz(VL vl,P *pl,int m,int full,P *pr |
|
| Line 4129 void nd_heu_nezgcdnpz(VL vl,P *pl,int m,int full,P *pr |
|
| NODE l; |
NODE l; |
| P h,gcd,t; |
P h,gcd,t; |
| |
|
| tpl = (P *)ALLOCA(m*sizeof(P)); |
tpl = (P *)MALLOC(m*sizeof(P)); |
| tpl1 = (P *)ALLOCA(m*sizeof(P)); |
tpl1 = (P *)MALLOC(m*sizeof(P)); |
| bcopy(pl,tpl,m*sizeof(P)); |
bcopy(pl,tpl,m*sizeof(P)); |
| gcd = (P)ONE; |
gcd = (P)ONE; |
| for ( l = nd_hcf; l; l = NEXT(l) ) { |
for ( l = nd_hcf; l; l = NEXT(l) ) { |
| Line 3819 void removecont_array(P *p,int n,int full) |
|
| Line 4166 void removecont_array(P *p,int n,int full) |
|
| if ( all_q ) { |
if ( all_q ) { |
| removecont_array_q((Q *)p,n); |
removecont_array_q((Q *)p,n); |
| } else { |
} else { |
| c = (Q *)ALLOCA(n*sizeof(Q)); |
c = (Q *)MALLOC(n*sizeof(Q)); |
| w = (P *)ALLOCA(n*sizeof(P)); |
w = (P *)MALLOC(n*sizeof(P)); |
| for ( i = 0; i < n; i++ ) { |
for ( i = 0; i < n; i++ ) { |
| ptozp(p[i],1,&c[i],&w[i]); |
ptozp(p[i],1,&c[i],&w[i]); |
| } |
} |
| Line 3840 void removecont_array_q(Q *c,int n) |
|
| Line 4187 void removecont_array_q(Q *c,int n) |
|
| N qn,rn,gn; |
N qn,rn,gn; |
| Q *q,*r; |
Q *q,*r; |
| |
|
| q = (Q *)ALLOCA(n*sizeof(Q)); |
q = (Q *)MALLOC(n*sizeof(Q)); |
| r = (Q *)ALLOCA(n*sizeof(Q)); |
r = (Q *)MALLOC(n*sizeof(Q)); |
| v.id = O_VECT; v.len = n; v.body = (pointer *)c; |
v.id = O_VECT; v.len = n; v.body = (pointer *)c; |
| igcdv_estimate(&v,&d0); |
igcdv_estimate(&v,&d0); |
| for ( i = 0; i < n; i++ ) { |
for ( i = 0; i < n; i++ ) { |
| Line 3883 void nd_mul_c(int mod,ND p,int mul) |
|
| Line 4230 void nd_mul_c(int mod,ND p,int mul) |
|
| } |
} |
| } |
} |
| |
|
| |
void nd_mul_c_lf(ND p,GZ mul) |
| |
{ |
| |
NM m; |
| |
GZ c; |
| |
|
| |
if ( !p ) return; |
| |
if ( UNIGZ(mul) ) return; |
| |
for ( m = BDY(p); m; m = NEXT(m) ) { |
| |
mullf(CZ(m),mul,&c); CZ(m) = c; |
| |
} |
| |
} |
| |
|
| void nd_mul_c_q(ND p,P mul) |
void nd_mul_c_q(ND p,P mul) |
| { |
{ |
| NM m; |
NM m; |
| Line 3947 UINT *ndv_compute_bound(NDV p) |
|
| Line 4306 UINT *ndv_compute_bound(NDV p) |
|
| |
|
| if ( !p ) |
if ( !p ) |
| return 0; |
return 0; |
| d1 = (UINT *)ALLOCA(nd_wpd*sizeof(UINT)); |
d1 = (UINT *)MALLOC(nd_wpd*sizeof(UINT)); |
| d2 = (UINT *)ALLOCA(nd_wpd*sizeof(UINT)); |
d2 = (UINT *)MALLOC(nd_wpd*sizeof(UINT)); |
| len = LEN(p); |
len = LEN(p); |
| m = BDY(p); ndl_copy(DL(m),d1); NMV_ADV(m); |
m = BDY(p); ndl_copy(DL(m),d1); NMV_ADV(m); |
| for ( i = 1; i < len; i++, NMV_ADV(m) ) { |
for ( i = 1; i < len; i++, NMV_ADV(m) ) { |
| Line 3976 UINT *nd_compute_bound(ND p) |
|
| Line 4335 UINT *nd_compute_bound(ND p) |
|
| |
|
| if ( !p ) |
if ( !p ) |
| return 0; |
return 0; |
| d1 = (UINT *)ALLOCA(nd_wpd*sizeof(UINT)); |
d1 = (UINT *)MALLOC(nd_wpd*sizeof(UINT)); |
| d2 = (UINT *)ALLOCA(nd_wpd*sizeof(UINT)); |
d2 = (UINT *)MALLOC(nd_wpd*sizeof(UINT)); |
| len = LEN(p); |
len = LEN(p); |
| m = BDY(p); ndl_copy(DL(m),d1); m = NEXT(m); |
m = BDY(p); ndl_copy(DL(m),d1); m = NEXT(m); |
| for ( m = NEXT(m); m; m = NEXT(m) ) { |
for ( m = NEXT(m); m; m = NEXT(m) ) { |
| Line 4010 int nd_get_exporigin(struct order_spec *ord) |
|
| Line 4369 int nd_get_exporigin(struct order_spec *ord) |
|
| /* module d[0]:weight d[1]:w0,...,d[nd_exporigin-2]:w(n-1) */ |
/* module d[0]:weight d[1]:w0,...,d[nd_exporigin-2]:w(n-1) */ |
| return ord->ord.block.length+1+nd_module; |
return ord->ord.block.length+1+nd_module; |
| case 3: case 259: |
case 3: case 259: |
| |
#if 0 |
| error("nd_get_exporigin : composite order is not supported yet."); |
error("nd_get_exporigin : composite order is not supported yet."); |
| |
#else |
| |
return 1+nd_module; |
| |
#endif |
| } |
} |
| } |
} |
| |
|
| Line 4117 ND_pairs nd_reconstruct(int trace,ND_pairs d) |
|
| Line 4480 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 4130 ND_pairs nd_reconstruct(int trace,ND_pairs d) |
|
| Line 4499 ND_pairs nd_reconstruct(int trace,ND_pairs d) |
|
| ndl_reconstruct(LCM(t),LCM(s),obpe,oepos); |
ndl_reconstruct(LCM(t),LCM(s),obpe,oepos); |
| } |
} |
| |
|
| old_red = (RHist *)ALLOCA(REDTAB_LEN*sizeof(RHist)); |
old_red = (RHist *)MALLOC(REDTAB_LEN*sizeof(RHist)); |
| for ( i = 0; i < REDTAB_LEN; i++ ) { |
for ( i = 0; i < REDTAB_LEN; i++ ) { |
| old_red[i] = nd_red[i]; |
old_red[i] = nd_red[i]; |
| nd_red[i] = 0; |
nd_red[i] = 0; |
| Line 4247 int nd_sp(int mod,int trace,ND_pairs p,ND *rp) |
|
| Line 4616 int nd_sp(int mod,int trace,ND_pairs p,ND *rp) |
|
| |
|
| if ( mod == -1 ) { |
if ( mod == -1 ) { |
| CM(m1) = HCM(p2); CM(m2) = _chsgnsf(HCM(p1)); |
CM(m1) = HCM(p2); CM(m2) = _chsgnsf(HCM(p1)); |
| } else if ( mod ) { |
} else if ( mod > 0 ) { |
| CM(m1) = HCM(p2); CM(m2) = mod-HCM(p1); |
CM(m1) = HCM(p2); CM(m2) = mod-HCM(p1); |
| |
} else if ( mod == -2 ) { |
| |
CZ(m1) = HCZ(p2); chsgnlf(HCZ(p1),&CZ(m2)); |
| } else if ( nd_vc ) { |
} else if ( nd_vc ) { |
| ezgcdpz(nd_vc,HCP(p1),HCP(p2),&gp); |
ezgcdpz(nd_vc,HCP(p1),HCP(p2),&gp); |
| divsp(nd_vc,HCP(p2),gp,&CP(m1)); |
divsp(nd_vc,HCP(p2),gp,&CP(m1)); |
| Line 4286 void ndv_mul_c(int mod,NDV p,int mul) |
|
| Line 4657 void ndv_mul_c(int mod,NDV p,int mul) |
|
| } |
} |
| } |
} |
| |
|
| |
void ndv_mul_c_lf(NDV p,GZ mul) |
| |
{ |
| |
NMV m; |
| |
GZ c; |
| |
int len,i; |
| |
|
| |
if ( !p ) return; |
| |
len = LEN(p); |
| |
for ( m = BDY(p), i = 0; i < len; i++, NMV_ADV(m) ) { |
| |
mullf(CZ(m),mul,&c); CZ(m) = c; |
| |
} |
| |
} |
| |
|
| void ndv_mul_c_q(NDV p,Q mul) |
void ndv_mul_c_q(NDV p,Q mul) |
| { |
{ |
| NMV m; |
NMV m; |
| Line 4312 ND weyl_ndv_mul_nm(int mod,NM m0,NDV p) { |
|
| Line 4696 ND weyl_ndv_mul_nm(int mod,NM m0,NDV p) { |
|
| d0 = DL(m0); |
d0 = DL(m0); |
| l = LEN(p); |
l = LEN(p); |
| for ( i = 0, tlen = 1; i < n2; i++ ) tlen *= (GET_EXP(d0,n2+i)+1); |
for ( i = 0, tlen = 1; i < n2; i++ ) tlen *= (GET_EXP(d0,n2+i)+1); |
| tab = (NM *)ALLOCA(tlen*sizeof(NM)); |
tab = (NM *)MALLOC(tlen*sizeof(NM)); |
| psum = (NM *)ALLOCA(tlen*sizeof(NM)); |
psum = (NM *)MALLOC(tlen*sizeof(NM)); |
| for ( i = 0; i < tlen; i++ ) psum[i] = 0; |
for ( i = 0; i < tlen; i++ ) psum[i] = 0; |
| m1 = (NMV)(((char *)BDY(p))+nmv_adv*(l-1)); |
m1 = (NMV)(((char *)BDY(p))+nmv_adv*(l-1)); |
| for ( i = l-1; i >= 0; i--, NMV_PREV(m1) ) { |
for ( i = l-1; i >= 0; i--, NMV_PREV(m1) ) { |
| Line 4391 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta |
|
| Line 4775 void weyl_mul_nm_nmv(int n,int mod,NM m0,NMV m1,NM *ta |
|
| } |
} |
| min = MIN(k,l); |
min = MIN(k,l); |
| if ( mod ) { |
if ( mod ) { |
| ctab = (UINT *)ALLOCA((min+1)*sizeof(UINT)); |
ctab = (UINT *)MALLOC((min+1)*sizeof(UINT)); |
| mkwcm(k,l,mod,ctab); |
mkwcm(k,l,mod,ctab); |
| } else { |
} else { |
| ctab_q = (Q *)ALLOCA((min+1)*sizeof(Q)); |
ctab_q = (Q *)MALLOC((min+1)*sizeof(Q)); |
| mkwc(k,l,ctab_q); |
mkwc(k,l,ctab_q); |
| } |
} |
| for ( j = min; j >= 0; j-- ) { |
for ( j = min; j >= 0; j-- ) { |
| Line 4492 ND ndv_mul_nm(int mod,NM m0,NDV p) |
|
| Line 4876 ND ndv_mul_nm(int mod,NM m0,NDV p) |
|
| |
|
| if ( !p ) return 0; |
if ( !p ) return 0; |
| else if ( do_weyl ) |
else if ( do_weyl ) |
| if ( mod == -1 ) |
if ( mod < 0 ) |
| error("ndv_mul_nm : not implemented (weyl)"); |
error("ndv_mul_nm : not implemented (weyl)"); |
| else |
else |
| return weyl_ndv_mul_nm(mod,m0,p); |
return weyl_ndv_mul_nm(mod,m0,p); |
| Line 4509 ND ndv_mul_nm(int mod,NM m0,NDV p) |
|
| Line 4893 ND ndv_mul_nm(int mod,NM m0,NDV p) |
|
| CM(mr) = _mulsf(CM(m),c); |
CM(mr) = _mulsf(CM(m),c); |
| ndl_add(DL(m),d,DL(mr)); |
ndl_add(DL(m),d,DL(mr)); |
| } |
} |
| |
} else if ( mod == -2 ) { |
| |
GZ cl; |
| |
cl = CZ(m0); |
| |
for ( i = 0; i < len; i++, NMV_ADV(m) ) { |
| |
NEXTNM(mr0,mr); |
| |
mullf(CZ(m),cl,&CZ(mr)); |
| |
ndl_add(DL(m),d,DL(mr)); |
| |
} |
| } else if ( mod ) { |
} else if ( mod ) { |
| c = CM(m0); |
c = CM(m0); |
| for ( i = 0; i < len; i++, NMV_ADV(m) ) { |
for ( i = 0; i < len; i++, NMV_ADV(m) ) { |
| Line 4546 ND nd_quo(int mod,PGeoBucket bucket,NDV d) |
|
| Line 4938 ND nd_quo(int mod,PGeoBucket bucket,NDV d) |
|
| else { |
else { |
| nv = NV(d); |
nv = NV(d); |
| mq0 = 0; |
mq0 = 0; |
| tm = (NMV)ALLOCA(nmv_adv); |
tm = (NMV)MALLOC(nmv_adv); |
| while ( 1 ) { |
while ( 1 ) { |
| hindex = mod?head_pbucket(mod,bucket):head_pbucket_q(bucket); |
if ( mod > 0 || mod == -1 ) |
| |
hindex = head_pbucket(mod,bucket); |
| |
else if ( mod == -2 ) |
| |
hindex = head_pbucket_lf(bucket); |
| |
else |
| |
hindex = head_pbucket_q(bucket); |
| if ( hindex < 0 ) break; |
if ( hindex < 0 ) break; |
| p = bucket->body[hindex]; |
p = bucket->body[hindex]; |
| NEXTNM(mq0,mq); |
NEXTNM(mq0,mq); |
| Line 4591 void ndv_realloc(NDV p,int obpe,int oadv,EPOS oepos) |
|
| Line 4988 void ndv_realloc(NDV p,int obpe,int oadv,EPOS oepos) |
|
| 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); |
| mr = (NMV)((char *)mr0+(len-1)*nmv_adv); |
mr = (NMV)((char *)mr0+(len-1)*nmv_adv); |
| t = (NMV)ALLOCA(nmv_adv); |
t = (NMV)MALLOC(nmv_adv); |
| for ( i = 0; i < len; i++, NMV_OPREV(m), NMV_PREV(mr) ) { |
for ( i = 0; i < len; i++, NMV_OPREV(m), NMV_PREV(mr) ) { |
| CQ(t) = CQ(m); |
CQ(t) = CQ(m); |
| for ( k = 0; k < nd_wpd; k++ ) DL(t)[k] = 0; |
for ( k = 0; k < nd_wpd; k++ ) DL(t)[k] = 0; |
| Line 4631 NDV ndv_dup(int mod,NDV p) |
|
| Line 5028 NDV ndv_dup(int mod,NDV p) |
|
| |
|
| if ( !p ) return 0; |
if ( !p ) return 0; |
| len = LEN(p); |
len = LEN(p); |
| m0 = m = (NMV)(mod?MALLOC_ATOMIC(len*nmv_adv):MALLOC(len*nmv_adv)); |
m0 = m = (NMV)((mod>0 || mod==-1)?MALLOC_ATOMIC(len*nmv_adv):MALLOC(len*nmv_adv)); |
| for ( t = BDY(p), i = 0; i < len; i++, NMV_ADV(t), NMV_ADV(m) ) { |
for ( t = BDY(p), i = 0; i < len; i++, NMV_ADV(t), NMV_ADV(m) ) { |
| ndl_copy(DL(t),DL(m)); |
ndl_copy(DL(t),DL(m)); |
| CQ(m) = CQ(t); |
CQ(m) = CQ(t); |
| Line 4641 NDV ndv_dup(int mod,NDV p) |
|
| Line 5038 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>0||mod==-1)?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 4658 ND nd_dup(ND p) |
|
| Line 5097 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 4675 void ndv_mod(int mod,NDV p) |
|
| Line 5136 void ndv_mod(int mod,NDV p) |
|
| if ( mod == -1 ) |
if ( mod == -1 ) |
| for ( t = d = BDY(p), i = 0; i < len; i++, NMV_ADV(t) ) { |
for ( t = d = BDY(p), i = 0; i < len; i++, NMV_ADV(t) ) { |
| simp_ff((Obj)CP(t),&gfs); |
simp_ff((Obj)CP(t),&gfs); |
| r = FTOIF(CONT((GFS)gfs)); |
if ( gfs ) { |
| CM(d) = r; |
r = FTOIF(CONT((GFS)gfs)); |
| ndl_copy(DL(t),DL(d)); |
CM(d) = r; |
| NMV_ADV(d); |
ndl_copy(DL(t),DL(d)); |
| dlen++; |
NMV_ADV(d); |
| |
dlen++; |
| |
} |
| } |
} |
| |
else if ( mod == -2 ) |
| |
for ( t = d = BDY(p), i = 0; i < len; i++, NMV_ADV(t) ) { |
| |
simp_ff((Obj)CP(t),&gfs); |
| |
if ( gfs ) { |
| |
lmtolf(gfs,&CZ(d)); |
| |
ndl_copy(DL(t),DL(d)); |
| |
NMV_ADV(d); |
| |
dlen++; |
| |
} |
| |
} |
| else |
else |
| for ( t = d = BDY(p), i = 0; i < len; i++, NMV_ADV(t) ) { |
for ( t = d = BDY(p), i = 0; i < len; i++, NMV_ADV(t) ) { |
| if ( nd_vc ) { |
if ( nd_vc ) { |
| Line 4728 void pltozpl(LIST l,Q *cont,LIST *pp) |
|
| Line 5201 void pltozpl(LIST l,Q *cont,LIST *pp) |
|
| LIST r; |
LIST r; |
| |
|
| nd = BDY(l); n = length(nd); |
nd = BDY(l); n = length(nd); |
| pl = (P *)ALLOCA(n*sizeof(P)); |
pl = (P *)MALLOC(n*sizeof(P)); |
| cl = (Q *)ALLOCA(n*sizeof(P)); |
cl = (Q *)MALLOC(n*sizeof(P)); |
| for ( i = 0; i < n; i++, nd = NEXT(nd) ) |
for ( i = 0; i < n; i++, nd = NEXT(nd) ) |
| ptozp((P)BDY(nd),1,&cl[i],&dmy); |
ptozp((P)BDY(nd),1,&cl[i],&dmy); |
| qltozl(cl,n,&dvr); |
qltozl(cl,n,&dvr); |
| Line 4794 ND ptond(VL vl,VL dvl,P p) |
|
| Line 5267 ND ptond(VL vl,VL dvl,P p) |
|
| return r; |
return r; |
| } else { |
} else { |
| for ( dc = DC(p), k = 0; dc; dc = NEXT(dc), k++ ); |
for ( dc = DC(p), k = 0; dc; dc = NEXT(dc), k++ ); |
| w = (DCP *)ALLOCA(k*sizeof(DCP)); |
w = (DCP *)MALLOC(k*sizeof(DCP)); |
| for ( dc = DC(p), j = 0; j < k; dc = NEXT(dc), j++ ) w[j] = dc; |
for ( dc = DC(p), j = 0; j < k; dc = NEXT(dc), j++ ) w[j] = dc; |
| for ( i = 0, tvl = dvl, v = VR(p); |
for ( i = 0, tvl = dvl, v = VR(p); |
| tvl && tvl->v != v; tvl = NEXT(tvl), i++ ); |
tvl && tvl->v != v; tvl = NEXT(tvl), i++ ); |
| Line 4842 P ndvtop(int mod,VL vl,VL dvl,NDV p) |
|
| Line 5315 P ndvtop(int mod,VL vl,VL dvl,NDV p) |
|
| m = (NMV)(((char *)BDY(p))+nmv_adv*(len-1)); |
m = (NMV)(((char *)BDY(p))+nmv_adv*(len-1)); |
| for ( j = len-1, s = 0; j >= 0; j--, NMV_PREV(m) ) { |
for ( j = len-1, s = 0; j >= 0; j--, NMV_PREV(m) ) { |
| if ( mod == -1 ) { |
if ( mod == -1 ) { |
| e = IFTOF(CM(m)); MKGFS(e,gfs); c = (P)gfs; |
e = IFTOF(CM(m)); MKGFS(e,gfs); c = (P)gfs; |
| } else if ( mod ) { |
} else if ( mod == -2 ) { |
| |
c = gztoz(CZ(m)); |
| |
} else if ( mod > 0 ) { |
| STOQ(CM(m),q); c = (P)q; |
STOQ(CM(m),q); c = (P)q; |
| } else |
} else |
| c = CP(m); |
c = CP(m); |
| Line 4874 LIST ndvtopl(int mod,VL vl,VL dvl,NDV p,int rank) |
|
| Line 5349 LIST ndvtopl(int mod,VL vl,VL dvl,NDV p,int rank) |
|
| |
|
| if ( !p ) return 0; |
if ( !p ) return 0; |
| else { |
else { |
| a = (P *)ALLOCA((rank+1)*sizeof(P)); |
a = (P *)MALLOC((rank+1)*sizeof(P)); |
| for ( i = 0; i <= rank; i++ ) a[i] = 0; |
for ( i = 0; i <= rank; i++ ) a[i] = 0; |
| len = LEN(p); |
len = LEN(p); |
| n = NV(p); |
n = NV(p); |
| Line 4911 NDV ndtondv(int mod,ND p) |
|
| Line 5386 NDV ndtondv(int mod,ND p) |
|
| |
|
| if ( !p ) return 0; |
if ( !p ) return 0; |
| len = LEN(p); |
len = LEN(p); |
| if ( mod ) |
if ( mod > 0 || mod == -1 ) |
| m0 = m = (NMV)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); |
| Line 5032 NODE ndv_reducebase(NODE x,int *perm) |
|
| Line 5507 NODE ndv_reducebase(NODE x,int *perm) |
|
| NODE t,t0; |
NODE t,t0; |
| |
|
| len = length(x); |
len = length(x); |
| w = (NDVI)ALLOCA(len*sizeof(struct oNDVI)); |
w = (NDVI)MALLOC(len*sizeof(struct oNDVI)); |
| for ( i = 0, t = x; i < len; i++, t = NEXT(t) ) { |
for ( i = 0, t = x; i < len; i++, t = NEXT(t) ) { |
| w[i].p = BDY(t); w[i].i = perm[i]; |
w[i].p = BDY(t); w[i].i = perm[i]; |
| } |
} |
| Line 5057 NODE ndv_reducebase(NODE x,int *perm) |
|
| Line 5532 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); |
| |
if ( nd_module ) { |
| |
nd_dcomp = -1; |
| |
nd_ispot = ord->ispot; |
| |
nd_pot_nelim = ord->pot_nelim; |
| |
nd_poly_weight_len = ord->nv; |
| |
nd_poly_weight = ord->top_weight; |
| |
nd_module_rank = ord->module_rank; |
| |
nd_module_weight = ord->module_top_weight; |
| |
} |
| nd_matrix = 0; |
nd_matrix = 0; |
| nd_matrix_len = 0; |
nd_matrix_len = 0; |
| switch ( ord->id ) { |
switch ( ord->id ) { |
| Line 5113 void nd_init_ord(struct order_spec *ord) |
|
| Line 5597 void nd_init_ord(struct order_spec *ord) |
|
| |
|
| /* module order */ |
/* module order */ |
| case 256: |
case 256: |
| nd_ispot = ord->ispot; |
|
| nd_pot_nelim = ord->pot_nelim; |
|
| nd_dcomp = -1; |
|
| switch ( ord->ord.simple ) { |
switch ( ord->ord.simple ) { |
| case 0: |
case 0: |
| nd_isrlex = 1; |
nd_isrlex = 1; |
| Line 5135 void nd_init_ord(struct order_spec *ord) |
|
| Line 5616 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; |
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_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; |
| Line 5153 void nd_init_ord(struct order_spec *ord) |
|
| Line 5628 void nd_init_ord(struct order_spec *ord) |
|
| 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_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; |
| Line 5340 int nd_to_vect_q(UINT *s0,int n,ND d,Q *r) |
|
| Line 5812 int nd_to_vect_q(UINT *s0,int n,ND d,Q *r) |
|
| return i; |
return i; |
| } |
} |
| |
|
| |
int nd_to_vect_lf(UINT *s0,int n,ND d,mpz_t *r) |
| |
{ |
| |
NM m; |
| |
UINT *t,*s; |
| |
int i; |
| |
|
| |
for ( i = 0; i < n; i++ ) { mpz_init(r[i]); mpz_set_ui(r[i],0); } |
| |
for ( i = 0, s = s0, m = BDY(d); m; m = NEXT(m) ) { |
| |
t = DL(m); |
| |
for ( ; !ndl_equal(t,s); s += nd_wpd, i++ ); |
| |
mpz_set(r[i],BDY(CZ(m))); |
| |
} |
| |
for ( i = 0; !mpz_sgn(r[i]); 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 *)MALLOC(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 5354 Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_p |
|
| Line 5880 Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_p |
|
| p = nd_ps[pair->index]; |
p = nd_ps[pair->index]; |
| len = LEN(p); |
len = LEN(p); |
| r = (Q *)CALLOC(n,sizeof(Q)); |
r = (Q *)CALLOC(n,sizeof(Q)); |
| t = (UINT *)ALLOCA(nd_wpd*sizeof(UINT)); |
t = (UINT *)MALLOC(nd_wpd*sizeof(UINT)); |
| 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++ ); |
for ( ; !ndl_equal(t,s); s += nd_wpd, i++ ); |
| Line 5363 Q *nm_ind_pair_to_vect(int mod,UINT *s0,int n,NM_ind_p |
|
| Line 5889 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,int *s0hash,NM_ind_pair pair) |
IndArray nm_ind_pair_to_vect_compress(int trace,UINT *s0,int n,int *s0hash,NM_ind_pair pair) |
| { |
{ |
| NM m; |
NM m; |
| NMV mr; |
NMV mr; |
| Line 5378 struct oEGT eg0,eg1; |
|
| Line 5904 struct oEGT eg0,eg1; |
|
| |
|
| m = pair->mul; |
m = pair->mul; |
| d = DL(m); |
d = DL(m); |
| p = nd_ps[pair->index]; |
if ( trace ) |
| |
p = nd_demand?nd_ps_trace_sym[pair->index]:nd_ps_trace[pair->index]; |
| |
else |
| |
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 *)MALLOC(nd_wpd*sizeof(UINT)); |
| v = (unsigned int *)ALLOCA(len*sizeof(unsigned int)); |
v = (unsigned int *)MALLOC(len*sizeof(unsigned int)); |
| get_eg(&eg0); |
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); |
| Line 5451 int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr |
|
| Line 5981 int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr |
|
| for ( i = 0; i < col && !svect[i]; i++ ); |
for ( i = 0; i < col && !svect[i]; i++ ); |
| if ( i == col ) return maxrs; |
if ( i == col ) return maxrs; |
| hmag = p_mag((P)svect[i])*nd_scale; |
hmag = p_mag((P)svect[i])*nd_scale; |
| cvect = (Q *)ALLOCA(col*sizeof(Q)); |
cvect = (Q *)MALLOC(col*sizeof(Q)); |
| for ( i = 0; i < nred; i++ ) { |
for ( i = 0; i < nred; i++ ) { |
| ivect = imat[i]; |
ivect = imat[i]; |
| 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 5509 int ndv_reduce_vect_q(Q *svect,int trace,int col,IndAr |
|
| Line 6040 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 5535 int ndv_reduce_vect(int m,UINT *svect,int col,IndArray |
|
| Line 6148 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 5586 int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndAr |
|
| Line 6207 int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndAr |
|
| maxrs = 0; |
maxrs = 0; |
| for ( i = 0; i < nred; i++ ) { |
for ( i = 0; i < nred; i++ ) { |
| ivect = imat[i]; |
ivect = imat[i]; |
| k = ivect->head; svect[k] %= m; |
k = ivect->head; |
| if ( c = svect[k] ) { |
if ( c = svect[k] ) { |
| maxrs = MAX(maxrs,rp0[i]->sugar); |
maxrs = MAX(maxrs,rp0[i]->sugar); |
| c = _chsgnsf(c); redv = nd_ps[rp0[i]->index]; |
c = _chsgnsf(c); redv = nd_ps[rp0[i]->index]; |
| Line 5620 int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndAr |
|
| Line 6241 int ndv_reduce_vect_sf(int m,UINT *svect,int col,IndAr |
|
| return maxrs; |
return maxrs; |
| } |
} |
| |
|
| |
ND nd_add_lf(ND p1,ND p2) |
| |
{ |
| |
int n,c,can; |
| |
ND r; |
| |
NM m1,m2,mr0,mr,s; |
| |
GZ t; |
| |
|
| |
if ( !p1 ) return p2; |
| |
else if ( !p2 ) return p1; |
| |
else { |
| |
can = 0; |
| |
for ( n = NV(p1), m1 = BDY(p1), m2 = BDY(p2), mr0 = 0; m1 && m2; ) { |
| |
c = DL_COMPARE(DL(m1),DL(m2)); |
| |
switch ( c ) { |
| |
case 0: |
| |
addlf(CZ(m1),CZ(m2),&t); |
| |
s = m1; m1 = NEXT(m1); |
| |
if ( t ) { |
| |
can++; NEXTNM2(mr0,mr,s); CZ(mr) = (t); |
| |
} else { |
| |
can += 2; FREENM(s); |
| |
} |
| |
s = m2; m2 = NEXT(m2); FREENM(s); |
| |
break; |
| |
case 1: |
| |
s = m1; m1 = NEXT(m1); NEXTNM2(mr0,mr,s); |
| |
break; |
| |
case -1: |
| |
s = m2; m2 = NEXT(m2); NEXTNM2(mr0,mr,s); |
| |
break; |
| |
} |
| |
} |
| |
if ( !mr0 ) |
| |
if ( m1 ) mr0 = m1; |
| |
else if ( m2 ) mr0 = m2; |
| |
else return 0; |
| |
else if ( m1 ) NEXT(mr) = m1; |
| |
else if ( m2 ) NEXT(mr) = m2; |
| |
else NEXT(mr) = 0; |
| |
BDY(p1) = mr0; |
| |
SG(p1) = MAX(SG(p1),SG(p2)); |
| |
LEN(p1) = LEN(p1)+LEN(p2)-can; |
| |
FREEND(p2); |
| |
return p1; |
| |
} |
| |
} |
| |
|
| |
int ndv_reduce_vect_lf(mpz_t *svect,int trace,int col,IndArray *imat,NM_ind_pair *rp0,int nred) |
| |
{ |
| |
int i,j,k,len,pos,prev; |
| |
mpz_t c,mc,c1; |
| |
IndArray ivect; |
| |
unsigned char *ivc; |
| |
unsigned short *ivs; |
| |
unsigned int *ivi; |
| |
NDV redv; |
| |
NMV mr; |
| |
NODE rp; |
| |
int maxrs; |
| |
|
| |
maxrs = 0; |
| |
lf_lazy = 1; |
| |
for ( i = 0; i < nred; i++ ) { |
| |
ivect = imat[i]; |
| |
k = ivect->head; |
| |
mpz_mod(svect[k],svect[k],BDY(current_mod_lf)); |
| |
if ( mpz_sgn(svect[k]) ) { |
| |
maxrs = MAX(maxrs,rp0[i]->sugar); |
| |
mpz_neg(svect[k],svect[k]); |
| |
redv = trace?nd_ps_trace[rp0[i]->index]:nd_ps[rp0[i]->index]; |
| |
len = LEN(redv); mr = BDY(redv); |
| |
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; |
| |
mpz_addmul(svect[pos],svect[k],BDY(CZ(mr))); |
| |
} |
| |
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; |
| |
mpz_addmul(svect[pos],svect[k],BDY(CZ(mr))); |
| |
} |
| |
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; |
| |
mpz_addmul(svect[pos],svect[k],BDY(CZ(mr))); |
| |
} |
| |
break; |
| |
} |
| |
mpz_set_ui(svect[k],0); |
| |
} |
| |
} |
| |
lf_lazy=0; |
| |
for ( i = 0; i < col; i++ ) { |
| |
mpz_mod(svect[i],svect[i],BDY(current_mod_lf)); |
| |
} |
| |
return maxrs; |
| |
} |
| |
|
| |
int nd_gauss_elim_lf(mpz_t **mat0,int *sugar,int row,int col,int *colstat) |
| |
{ |
| |
int i,j,k,l,rank,s; |
| |
mpz_t a,a1,inv; |
| |
mpz_t *t,*pivot,*pk; |
| |
mpz_t **mat; |
| |
struct oEGT eg0,eg1,eg_forward,eg_mod,eg_back; |
| |
int size,size1; |
| |
|
| |
mpz_init(inv); |
| |
mpz_init(a); |
| |
mat = (mpz_t **)mat0; |
| |
size = 0; |
| |
for ( rank = 0, j = 0; j < col; j++ ) { |
| |
for ( i = rank; i < row; i++ ) { |
| |
mpz_mod(mat[i][j],mat[i][j],BDY(current_mod_lf)); |
| |
} |
| |
for ( i = rank; i < row; i++ ) |
| |
if ( mpz_sgn(mat[i][j]) ) |
| |
break; |
| |
if ( i == row ) { |
| |
colstat[j] = 0; |
| |
continue; |
| |
} else |
| |
colstat[j] = 1; |
| |
if ( i != rank ) { |
| |
t = mat[i]; mat[i] = mat[rank]; mat[rank] = t; |
| |
s = sugar[i]; sugar[i] = sugar[rank]; sugar[rank] = s; |
| |
} |
| |
pivot = mat[rank]; |
| |
s = sugar[rank]; |
| |
mpz_invert(inv,pivot[j],BDY(current_mod_lf)); |
| |
for ( k = j, pk = pivot+k; k < col; k++, pk++ ) |
| |
if ( mpz_sgn(*pk) ) { |
| |
mpz_mul(a,*pk,inv); mpz_mod(*pk,a,BDY(current_mod_lf)); |
| |
} |
| |
for ( i = rank+1; i < row; i++ ) { |
| |
t = mat[i]; |
| |
if ( mpz_sgn(t[j]) ) { |
| |
sugar[i] = MAX(sugar[i],s); |
| |
mpz_neg(a,t[j]); |
| |
red_by_vect_lf(t+j,pivot+j,a,col-j); |
| |
} |
| |
} |
| |
rank++; |
| |
} |
| |
for ( j = col-1, l = rank-1; j >= 0; j-- ) |
| |
if ( colstat[j] ) { |
| |
pivot = mat[l]; |
| |
s = sugar[l]; |
| |
for ( k = j; k < col; k++ ) |
| |
mpz_mod(pivot[k],pivot[k],BDY(current_mod_lf)); |
| |
for ( i = 0; i < l; i++ ) { |
| |
t = mat[i]; |
| |
if ( mpz_sgn(t[j]) ) { |
| |
sugar[i] = MAX(sugar[i],s); |
| |
mpz_neg(a,t[j]); |
| |
red_by_vect_lf(t+j,pivot+j,a,col-j); |
| |
} |
| |
} |
| |
l--; |
| |
} |
| |
for ( j = 0, l = 0; l < rank; j++ ) |
| |
if ( colstat[j] ) { |
| |
t = mat[l]; |
| |
for ( k = j; k < col; k++ ) { |
| |
mpz_mod(t[k],t[k],BDY(current_mod_lf)); |
| |
} |
| |
l++; |
| |
} |
| |
return rank; |
| |
} |
| |
|
| |
|
| NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhead,UINT *s0vect) |
NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhead,UINT *s0vect) |
| { |
{ |
| int j,k,len; |
int j,k,len; |
| Line 5648 NDV vect_to_ndv(UINT *vect,int spcol,int col,int *rhea |
|
| Line 6448 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 5680 NDV vect_to_ndv_q(Q *vect,int spcol,int col,int *rhead |
|
| Line 6502 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; |
| |
GZ 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; |
| |
} |
| |
} |
| |
|
| |
NDV vect_to_ndv_lf(mpz_t *vect,int spcol,int col,int *rhead,UINT *s0vect) |
| |
{ |
| |
int j,k,len; |
| |
UINT *p; |
| |
mpz_t c; |
| |
NDV r; |
| |
NMV mr0,mr; |
| |
|
| |
for ( j = 0, len = 0; j < spcol; j++ ) if ( mpz_sgn(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] ) { |
| |
c[0] = vect[k++][0]; |
| |
if ( mpz_sgn(c) ) { |
| |
ndl_copy(p,DL(mr)); MPZTOGZ(c,CZ(mr)); 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 5737 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI |
|
| Line 6616 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI |
|
| NM_ind_pair pair; |
NM_ind_pair pair; |
| ND red; |
ND red; |
| NDV *ps; |
NDV *ps; |
| |
static int afo; |
| |
|
| 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 5751 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI |
|
| Line 6634 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI |
|
| h = nd_psh[index]; |
h = nd_psh[index]; |
| NEWNM(mul); |
NEWNM(mul); |
| ndl_sub(DL(head),DL(h),DL(mul)); |
ndl_sub(DL(head),DL(h),DL(mul)); |
| if ( ndl_check_bound2(index,DL(mul)) ) return 0; |
if ( ndl_check_bound2(index,DL(mul)) ) |
| |
return 0; |
| sugar = TD(DL(mul))+SG(ps[index]); |
sugar = TD(DL(mul))+SG(ps[index]); |
| MKNM_ind_pair(pair,mul,index,sugar); |
MKNM_ind_pair(pair,mul,index,sugar); |
| red = ndv_mul_nm_symbolic(mul,ps[index]); |
red = ndv_mul_nm_symbolic(mul,ps[index]); |
| Line 5770 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI |
|
| Line 6654 int nd_symbolic_preproc(PGeoBucket bucket,int trace,UI |
|
| return col; |
return col; |
| } |
} |
| |
|
| NODE nd_f4(int m,int **indp) |
NODE nd_f4(int m,int checkonly,int **indp) |
| { |
{ |
| int i,nh,stat,index; |
int i,nh,stat,index,f4red; |
| NODE r,g,tn0,tn,node; |
NODE r,g,tn0,tn,node; |
| ND_pairs d,l,t,ll0,ll; |
ND_pairs d,l,t,ll0,ll; |
| LIST l0,l1; |
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,nzlist; |
NODE rp0,srp0,nflist,nzlist,nzlist_t; |
| int nsp,nred,col,rank,len,k,j,a,i1s,i2s; |
int nsp,nred,col,rank,len,k,j,a,i1s,i2s; |
| UINT c; |
UINT c; |
| UINT **spmat; |
UINT **spmat; |
| Line 5797 NODE nd_f4(int m,int **indp) |
|
| Line 6681 NODE nd_f4(int m,int **indp) |
|
| #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,0); |
if ( !nd_nzlist ) d = update_pairs(d,g,i,0); |
| g = update_base(g,i); |
g = update_base(g,i); |
| } |
} |
| nzlist = 0; |
nzlist = 0; |
| while ( d ) { |
nzlist_t = nd_nzlist; |
| |
f4red = 0; |
| |
while ( d || nzlist_t ) { |
| get_eg(&eg0); |
get_eg(&eg0); |
| l = nd_minsugarp(d,&d); |
|
| sugar = SG(l); |
|
| if ( nd_nzlist ) { |
if ( nd_nzlist ) { |
| for ( tn = nd_nzlist; tn; tn = NEXT(tn) ) { |
node = BDY((LIST)BDY(nzlist_t)); |
| node = BDY((LIST)BDY(tn)); |
sugar = (int)ARG0(node); |
| if ( QTOS((Q)ARG0(node)) == sugar ) break; |
tn = BDY((LIST)ARG1(node)); |
| |
if ( !tn ) { |
| |
nzlist_t = NEXT(nzlist_t); |
| |
continue; |
| } |
} |
| if ( !tn ) error("nd_f4 : inconsistent non-zero list"); |
/* tn = [[i1,i2],...] */ |
| for ( t = l, ll0 = 0; t; t = NEXT(t) ) { |
l = nd_ipairtospair(tn); |
| for ( tn = BDY((LIST)ARG1(node)); tn; tn = NEXT(tn) ) { |
} else { |
| i1s = QTOS((Q)ARG0(BDY((LIST)BDY(tn)))); |
l = nd_minsugarp(d,&d); |
| i2s = QTOS((Q)ARG1(BDY((LIST)BDY(tn)))); |
sugar = nd_sugarweight?l->sugar2:SG(l); |
| if ( t->i1 == i1s && t->i2 == i2s ) break; |
if ( MaxDeg > 0 && sugar > MaxDeg ) break; |
| } |
|
| if ( tn ) { |
|
| if ( !ll0 ) ll0 = t; |
|
| else NEXT(ll) = t; |
|
| ll = t; |
|
| } |
|
| } |
|
| if ( ll0 ) NEXT(ll) = 0; |
|
| l = ll0; |
|
| } |
} |
| 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 ) { |
| for ( t = l; NEXT(t); t = NEXT(t) ); |
if ( !nd_nzlist ) { |
| NEXT(t) = d; d = l; |
for ( t = l; NEXT(t); t = NEXT(t) ); |
| d = nd_reconstruct(0,d); |
NEXT(t) = d; d = l; |
| |
d = nd_reconstruct(0,d); |
| |
} |
| continue; |
continue; |
| } |
} |
| if ( bucket->m < 0 ) continue; |
if ( bucket->m < 0 ) continue; |
| Line 5847 NODE nd_f4(int m,int **indp) |
|
| Line 6727 NODE nd_f4(int m,int **indp) |
|
| 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); |
| nflist = nd_f4_red(m,l,0,s0vect,col,rp0,nd_gentrace?&ll:0); |
nflist = nd_f4_red(m,l,0,s0vect,col,rp0,nd_gentrace?&ll:0); |
| |
if ( checkonly && nflist ) return 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 5859 NODE nd_f4(int m,int **indp) |
|
| Line 6740 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,0); |
if ( !nd_nzlist ) d = update_pairs(d,g,nh,0); |
| g = update_base(g,nh); |
g = update_base(g,nh); |
| } |
} |
| |
if ( DP_Print ) { |
| |
fprintf(asir_out,"f4red=%d,gblen=%d,",f4red,length(g)); fflush(asir_out); |
| |
} |
| if ( nd_gentrace ) { |
if ( nd_gentrace ) { |
| for ( t = ll, tn0 = 0; t; t = NEXT(t) ) { |
for ( t = ll, tn0 = 0; t; t = NEXT(t) ) { |
| NEXTNODE(tn0,tn); |
NEXTNODE(tn0,tn); |
| Line 5874 NODE nd_f4(int m,int **indp) |
|
| Line 6758 NODE nd_f4(int m,int **indp) |
|
| STOQ(sugar,sugarq); node = mknode(2,sugarq,l0); MKLIST(l1,node); |
STOQ(sugar,sugarq); node = mknode(2,sugarq,l0); MKLIST(l1,node); |
| MKNODE(node,l1,nzlist); nzlist = node; |
MKNODE(node,l1,nzlist); nzlist = node; |
| } |
} |
| |
if ( nd_nzlist ) nzlist_t = NEXT(nzlist_t); |
| |
f4red++; |
| |
if ( nd_f4red && f4red >= nd_f4red ) break; |
| |
if ( nd_rank0 && !nflist ) break; |
| } |
} |
| if ( nd_gentrace ) { |
if ( nd_gentrace ) { |
| MKLIST(l0,reverse_node(nzlist)); |
MKLIST(l0,reverse_node(nzlist)); |
| Line 5882 NODE nd_f4(int m,int **indp) |
|
| Line 6770 NODE nd_f4(int m,int **indp) |
|
| #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 5916 NODE nd_f4_trace(int m,int **indp) |
|
| Line 6804 NODE nd_f4_trace(int m,int **indp) |
|
| get_eg(&eg0); |
get_eg(&eg0); |
| l = nd_minsugarp(d,&d); |
l = nd_minsugarp(d,&d); |
| sugar = SG(l); |
sugar = SG(l); |
| |
if ( MaxDeg > 0 && sugar > MaxDeg ) break; |
| 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 5974 NODE nd_f4_trace(int m,int **indp) |
|
| Line 6863 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,0); |
d = update_pairs(d,g,nh,0); |
| g = update_base(g,nh); |
g = update_base(g,nh); |
| } |
} |
| Line 5982 NODE nd_f4_trace(int m,int **indp) |
|
| Line 6871 NODE nd_f4_trace(int m,int **indp) |
|
| #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,1,g,indp); |
conv_ilist(nd_demand,1,g,indp); |
| return g; |
return g; |
| } |
} |
| |
|
| NODE nd_f4_pseudo_trace(int m,int **indp) |
int rref(matrix mat,int *sugar) |
| { |
{ |
| int i,nh,stat,index; |
int row,col,i,j,k,l,s,wcol,wj; |
| NODE r,g; |
unsigned long bj; |
| ND_pairs d,l,l0,t; |
unsigned long **a; |
| ND spol,red; |
unsigned long *ai,*ak,*as,*t; |
| NDV nf,redv,nfqv,nfv; |
int *pivot; |
| 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; |
row = mat->row; |
| for ( i = 0; i < nd_psn; i++ ) { |
col = mat->col; |
| d = update_pairs(d,g,i,0); |
a = mat->a; |
| g = update_base(g,i); |
wcol = (col+BLEN-1)/BLEN; |
| } |
pivot = (int *)MALLOC_ATOMIC(row*sizeof(int)); |
| while ( d ) { |
i = 0; |
| get_eg(&eg0); |
for ( j = 0; j < col; j++ ) { |
| l = nd_minsugarp(d,&d); |
wj = j/BLEN; bj = 1L<<(j%BLEN); |
| sugar = SG(l); |
for ( k = i; k < row; k++ ) |
| bucket = create_pbucket(); |
if ( a[k][wj] & bj ) break; |
| stat = nd_sp_f4(m,0,l,bucket); |
if ( k == row ) continue; |
| if ( !stat ) { |
pivot[i] = j; |
| for ( t = l; NEXT(t); t = NEXT(t) ); |
if ( k != i ) { |
| NEXT(t) = d; d = l; |
t = a[i]; a[i] = a[k]; a[k] = t; |
| d = nd_reconstruct(1,d); |
s = sugar[i]; sugar[i] = sugar[k]; sugar[k] = s; |
| continue; |
} |
| } |
ai = a[i]; |
| if ( bucket->m < 0 ) continue; |
for ( k = i+1; k < row; k++ ) { |
| col = nd_symbolic_preproc(bucket,0,&s0vect,&rp0); |
ak = a[k]; |
| if ( !col ) { |
if ( ak[wj] & bj ) { |
| for ( t = l; NEXT(t); t = NEXT(t) ); |
for ( l = wj; l < wcol; l++ ) |
| NEXT(t) = d; d = l; |
ak[l] ^= ai[l]; |
| d = nd_reconstruct(1,d); |
sugar[k] = MAX(sugar[k],sugar[i]); |
| continue; |
} |
| } |
} |
| get_eg(&eg1); init_eg(&eg_f4); add_eg(&eg_f4,&eg0,&eg1); |
i++; |
| if ( DP_Print ) |
} |
| fprintf(asir_out,"sugar=%d,symb=%fsec,", |
for ( k = i-1; k >= 0; k-- ) { |
| sugar,eg_f4.exectime+eg_f4.gctime); |
j = pivot[k]; wj = j/BLEN; bj = 1L<<(j%BLEN); |
| nflist = nd_f4_red(m,l,0,s0vect,col,rp0,&l0); |
ak = a[k]; |
| if ( !l0 ) continue; |
for ( s = 0; s < k; s++ ) { |
| l = l0; |
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; |
| |
} |
| |
|
| /* over Q */ |
void print_matrix(matrix mat) |
| while ( 1 ) { |
{ |
| bucket = create_pbucket(); |
int row,col,i,j; |
| stat = nd_sp_f4(0,1,l,bucket); |
unsigned long *ai; |
| if ( !stat ) { |
|
| for ( t = l; NEXT(t); t = NEXT(t) ); |
row = mat->row; |
| NEXT(t) = d; d = l; |
col = mat->col; |
| d = nd_reconstruct(1,d); |
printf("%d x %d\n",row,col); |
| continue; |
for ( i = 0; i < row; i++ ) { |
| } |
ai = mat->a[i]; |
| if ( bucket->m < 0 ) continue; |
for ( j = 0; j < col; j++ ) { |
| col = nd_symbolic_preproc(bucket,1,&s0vect,&rp0); |
if ( ai[j/BLEN] & (1L<<(j%BLEN)) ) putchar('1'); |
| if ( !col ) { |
else putchar('0'); |
| for ( t = l; NEXT(t); t = NEXT(t) ); |
} |
| NEXT(t) = d; d = l; |
putchar('\n'); |
| d = nd_reconstruct(1,d); |
} |
| continue; |
} |
| } |
|
| nflist = nd_f4_red(0,l,1,s0vect,col,rp0,0); |
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 *)MALLOC(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 *)MALLOC(col*sizeof(int)); |
| |
for ( i = 0, s = s0vect; i < col; i++, s += nd_wpd ) |
| |
s0hash[i] = ndl_hash_value(s); |
| |
|
| |
sugar = (int *)MALLOC(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; |
| |
if ( DP_Print ) { |
| |
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); |
| |
} |
| |
|
| /* adding new bases */ |
get_eg(&eg1); |
| for ( r = nflist; r; r = NEXT(r) ) { |
init_eg(&eg_elim1); add_eg(&eg_elim1,&eg0,&eg1); |
| nfqv = (NDV)BDY(r); |
rank = rref(mat,sugar); |
| ndv_removecont(0,nfqv); |
|
| if ( !rem(NM(HCQ(nfqv)),m) ) return 0; |
|
| if ( nd_nalg ) { |
|
| ND nf1; |
|
| |
|
| nf1 = ndvtond(m,nfqv); |
for ( i = 0, r0 = 0; i < rank; i++ ) { |
| nd_monic(0,&nf1); |
NEXTNODE(r0,r); |
| nd_removecont(0,nf1); |
BDY(r) = (pointer)vect_to_ndv_2(mat->a[i],col,s0vect); |
| nfqv = ndtondv(0,nf1); nd_free(nf1); |
SG((NDV)BDY(r)) = sugar[i]; |
| } |
|
| nfv = ndv_dup(0,nfqv); |
|
| ndv_mod(m,nfv); |
|
| ndv_removecont(m,nfv); |
|
| nh = ndv_newps(0,nfv,nfqv); |
|
| d = update_pairs(d,g,nh,0); |
|
| g = update_base(g,nh); |
|
| } |
|
| } |
} |
| #if 0 |
if ( r0 ) NEXT(r) = 0; |
| fprintf(asir_out,"ndv_alloc=%d\n",ndv_alloc); |
get_eg(&eg2); |
| #endif |
init_eg(&eg_elim2); add_eg(&eg_elim2,&eg1,&eg2); |
| conv_ilist(0,1,g,indp); |
if ( DP_Print ) { |
| return g; |
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 6100 NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve |
|
| Line 7056 NODE nd_f4_red(int m,ND_pairs sp0,int trace,UINT *s0ve |
|
| UINT *s; |
UINT *s; |
| int *s0hash; |
int *s0hash; |
| |
|
| |
if ( m == 2 && nd_rref2 ) |
| |
return nd_f4_red_2(sp0,s0vect,col,rp0,nz); |
| |
|
| init_eg(&eg_search); |
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 *)MALLOC(nred*sizeof(IndArray)); |
| rhead = (int *)ALLOCA(col*sizeof(int)); |
rhead = (int *)MALLOC(col*sizeof(int)); |
| 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 */ |
| rvect = (NM_ind_pair *)ALLOCA(nred*sizeof(NM_ind_pair)); |
if ( DP_Print ) { |
| s0hash = (int *)ALLOCA(col*sizeof(int)); |
fprintf(stderr,"%dx%d,",nsp+nred,col); |
| |
} |
| |
rvect = (NM_ind_pair *)MALLOC(nred*sizeof(NM_ind_pair)); |
| |
s0hash = (int *)MALLOC(col*sizeof(int)); |
| for ( i = 0, s = s0vect; i < col; i++, s += nd_wpd ) |
for ( i = 0, s = s0vect; i < col; i++, s += nd_wpd ) |
| s0hash[i] = ndl_hash_value(s); |
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,s0hash,rvect[i]); |
imat[i] = nm_ind_pair_to_vect_compress(trace,s0vect,col,s0hash,rvect[i]); |
| rhead[imat[i]->head] = 1; |
rhead[imat[i]->head] = 1; |
| } |
} |
| if ( m ) |
if ( m > 0 || m == -1 ) |
| 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 if ( m == -2 ) |
| |
r0 = nd_f4_red_lf_main(m,sp0,nsp,trace,s0vect,col,rvect,rhead,imat,nred); |
| 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); |
if ( DP_Print ) print_eg("search",&eg_search); |
| return r0; |
return r0; |
| } |
} |
| |
|
| |
/* for small finite fields */ |
| NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s0vect,int col, |
NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s0vect,int col, |
| NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred,ND_pairs *nz) |
NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred,ND_pairs *nz) |
| { |
{ |
| Line 6144 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s |
|
| Line 7109 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s |
|
| spcol = col-nred; |
spcol = col-nred; |
| get_eg(&eg0); |
get_eg(&eg0); |
| /* elimination (1st step) */ |
/* elimination (1st step) */ |
| spmat = (int **)ALLOCA(nsp*sizeof(UINT *)); |
spmat = (int **)MALLOC(nsp*sizeof(UINT *)); |
| svect = (UINT *)ALLOCA(col*sizeof(UINT)); |
svect = (UINT *)MALLOC(col*sizeof(UINT)); |
| spsugar = (int *)ALLOCA(nsp*sizeof(UINT)); |
spsugar = (int *)MALLOC(nsp*sizeof(int)); |
| spactive = !nz?0:(ND_pairs *)ALLOCA(nsp*sizeof(ND_pairs)); |
spactive = !nz?0:(ND_pairs *)MALLOC(nsp*sizeof(ND_pairs)); |
| for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) { |
for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) { |
| nd_sp(m,0,sp,&spol); |
nd_sp(m,0,sp,&spol); |
| if ( !spol ) continue; |
if ( !spol ) continue; |
| Line 6177 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s |
|
| Line 7142 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s |
|
| for ( i = 0; i < nred; i++ ) GCFREE(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 *)MALLOC(spcol*sizeof(int)); |
| if ( m == -1 ) |
if ( m == -1 ) |
| rank = nd_gauss_elim_sf(spmat,spsugar,sprow,spcol,m,colstat); |
rank = nd_gauss_elim_sf(spmat,spsugar,sprow,spcol,m,colstat); |
| else |
else |
| Line 6211 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s |
|
| Line 7176 NODE nd_f4_red_main(int m,ND_pairs sp0,int nsp,UINT *s |
|
| return r0; |
return r0; |
| } |
} |
| |
|
| |
NODE nd_f4_red_lf_main(int m,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; |
| |
mpz_t **spmat; |
| |
mpz_t *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 = (mpz_t **)MALLOC(nsp*sizeof(mpz_t *)); |
| |
svect = (mpz_t *)MALLOC(col*sizeof(mpz_t)); |
| |
spsugar = (int *)MALLOC(nsp*sizeof(int)); |
| |
for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) { |
| |
nd_sp(m,trace,sp,&spol); |
| |
if ( !spol ) continue; |
| |
nd_to_vect_lf(s0vect,col,spol,svect); |
| |
maxrs = ndv_reduce_vect_lf(svect,trace,col,imat,rvect,nred); |
| |
for ( i = 0; i < col; i++ ) if ( mpz_sgn(svect[i]) ) break; |
| |
if ( i < col ) { |
| |
spmat[sprow] = v = (mpz_t *)MALLOC(spcol*sizeof(mpz_t)); |
| |
for ( j = k = 0; j < col; j++ ) |
| |
if ( !rhead[j] ) v[k++][0] = svect[j][0]; |
| |
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 *)MALLOC(spcol*sizeof(int)); |
| |
rank = nd_gauss_elim_lf(spmat,spsugar,sprow,spcol,colstat); |
| |
w = (pointer *)MALLOC(rank*sizeof(pointer)); |
| |
for ( i = 0; i < rank; i++ ) { |
| |
#if 0 |
| |
w[rank-i-1] = (pointer)vect_to_ndv_lf(spmat[i],spcol,col,rhead,s0vect); |
| |
SG((NDV)w[rank-i-1]) = spsugar[i]; |
| |
#else |
| |
w[i] = (pointer)vect_to_ndv_lf(spmat[i],spcol,col,rhead,s0vect); |
| |
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; |
| |
} |
| |
|
| #if 1 |
#if 1 |
| NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,UINT *s0vect,int col, |
NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,UINT *s0vect,int col, |
| NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred) |
NM_ind_pair *rvect,int *rhead,IndArray *imat,int nred) |
| Line 6231 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U |
|
| Line 7278 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U |
|
| spcol = col-nred; |
spcol = col-nred; |
| get_eg(&eg0); |
get_eg(&eg0); |
| /* elimination (1st step) */ |
/* elimination (1st step) */ |
| spmat = (Q **)ALLOCA(nsp*sizeof(Q *)); |
spmat = (Q **)MALLOC(nsp*sizeof(Q *)); |
| svect = (Q *)ALLOCA(col*sizeof(Q)); |
svect = (Q *)MALLOC(col*sizeof(Q)); |
| spsugar = (int *)ALLOCA(nsp*sizeof(Q)); |
spsugar = (int *)MALLOC(nsp*sizeof(int)); |
| for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) { |
for ( a = sprow = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) { |
| nd_sp(0,trace,sp,&spol); |
nd_sp(0,trace,sp,&spol); |
| if ( !spol ) continue; |
if ( !spol ) continue; |
| Line 6258 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U |
|
| Line 7305 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U |
|
| /* for ( i = 0; i < nred; i++ ) GCFREE(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 *)MALLOC(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 *)MALLOC(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]; |
| |
#else |
| |
w[i] = (pointer)vect_to_ndv_q(spmat[i],spcol,col,rhead,s0vect); |
| |
SG((NDV)w[i]) = spsugar[i]; |
| |
#endif |
| /* GCFREE(spmat[i]); */ |
/* GCFREE(spmat[i]); */ |
| } |
} |
| #if 0 |
#if 0 |
| Line 6287 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,int trace,U |
|
| Line 7339 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 **)MALLOC(nsp*sizeof(GZ *)); |
| |
svect = (GZ *)MALLOC(col*sizeof(GZ)); |
| |
spsugar = (int *)MALLOC(nsp*sizeof(int)); |
| |
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 *)MALLOC(spcol*sizeof(int)); |
| |
rank = nd_gauss_elim_gz(spmat,spsugar,sprow,spcol,colstat); |
| |
w = (pointer *)MALLOC(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(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 6314 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,UINT *s0vec |
|
| Line 7451 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,UINT *s0vec |
|
| |
|
| row = nsp+nred; |
row = nsp+nred; |
| /* make the matrix */ |
/* make the matrix */ |
| mat = (Q **)ALLOCA(row*sizeof(Q *)); |
mat = (Q **)MALLOC(row*sizeof(Q *)); |
| sugar = (int *)ALLOCA(row*sizeof(int)); |
sugar = (int *)MALLOC(row*sizeof(int)); |
| for ( row = a = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) { |
for ( row = a = 0, sp = sp0; a < nsp; a++, sp = NEXT(sp) ) { |
| nd_sp(0,0,sp,&spol); |
nd_sp(0,0,sp,&spol); |
| if ( !spol ) continue; |
if ( !spol ) continue; |
| Line 6329 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,UINT *s0vec |
|
| Line 7466 NODE nd_f4_red_q_main(ND_pairs sp0,int nsp,UINT *s0vec |
|
| sugar[row] = rvect[i]->sugar; |
sugar[row] = rvect[i]->sugar; |
| } |
} |
| /* elimination */ |
/* elimination */ |
| colstat = (int *)ALLOCA(col*sizeof(int)); |
colstat = (int *)MALLOC(col*sizeof(int)); |
| rank = nd_gauss_elim_q(mat,sugar,row,col,colstat); |
rank = nd_gauss_elim_q(mat,sugar,row,col,colstat); |
| r0 = 0; |
r0 = 0; |
| for ( i = 0; i < rank; i++ ) { |
for ( i = 0; i < rank; i++ ) { |
| Line 6421 NDV nd_recv_ndv() |
|
| Line 7558 NDV nd_recv_ndv() |
|
| } |
} |
| } |
} |
| |
|
| int ox_exec_f4_red(Q proc) |
int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int col,int *colstat) |
| { |
{ |
| Obj obj; |
int i,j,t,c,rank,inv; |
| STRING fname; |
int *ci,*ri; |
| NODE arg; |
Q dn; |
| int s; |
MAT m,nm; |
| extern int ox_need_conv,ox_file_io; |
|
| |
|
| MKSTR(fname,"nd_exec_f4_red"); |
NEWMAT(m); m->row = row; m->col = col; m->body = (pointer **)mat0; |
| arg = mknode(2,proc,fname); |
rank = generic_gauss_elim(m,&nm,&dn,&ri,&ci); |
| Pox_cmo_rpc(arg,&obj); |
for ( i = 0; i < row; i++ ) |
| s = get_ox_server_id(QTOS(proc)); |
for ( j = 0; j < col; j++ ) |
| nd_write = iofp[s].out; |
mat0[i][j] = 0; |
| nd_read = iofp[s].in; |
c = col-rank; |
| ox_need_conv = ox_file_io = 0; |
|
| return s; |
|
| } |
|
| |
|
| #if 0 |
|
| NODE nd_f4_red_dist(int m,ND_pairs sp0,UINT *s0vect,int col,NODE rp0,ND_pairs *nz) |
|
| { |
|
| int nsp,nred; |
|
| int i,rank,s; |
|
| NODE rp,r0,r; |
|
| ND_pairs sp; |
|
| NM_ind_pair pair; |
|
| NMV nmv; |
|
| NM nm; |
|
| NDV nf; |
|
| Obj proc,dmy; |
|
| |
|
| ox_launch_main(0,0,&proc); |
|
| s = ox_exec_f4_red((Q)proc); |
|
| |
|
| nd_send_int(m); |
|
| nd_send_int(nd_nvar); |
|
| nd_send_int(nd_bpe); |
|
| nd_send_int(nd_wpd); |
|
| nd_send_int(nmv_adv); |
|
| |
|
| saveobj(nd_write,dp_current_spec->obj); fflush(nd_write); |
|
| |
|
| nd_send_int(nd_psn); |
|
| for ( i = 0; i < nd_psn; i++ ) nd_send_ndv(nd_ps[i]); |
|
| |
|
| for ( sp = sp0, nsp = 0; sp; sp = NEXT(sp), nsp++ ); |
|
| nd_send_int(nsp); |
|
| for ( i = 0, sp = sp0; i < nsp; i++, sp = NEXT(sp) ) { |
|
| nd_send_int(sp->i1); nd_send_int(sp->i2); |
|
| } |
|
| |
|
| nd_send_int(col); nd_send_intarray(s0vect,col*nd_wpd); |
|
| |
|
| nred = length(rp0); nd_send_int(nred); |
|
| for ( i = 0, rp = rp0; i < nred; i++, rp = NEXT(rp) ) { |
|
| pair = (NM_ind_pair)BDY(rp); |
|
| nd_send_int(pair->index); |
|
| nd_send_intarray(pair->mul->dl,nd_wpd); |
|
| } |
|
| fflush(nd_write); |
|
| rank = nd_recv_int(); |
|
| fprintf(asir_out,"rank=%d\n",rank); |
|
| r0 = 0; |
|
| for ( i = 0; i < rank; i++ ) { |
for ( i = 0; i < rank; i++ ) { |
| nf = nd_recv_ndv(); |
mat0[i][ri[i]] = dn; |
| NEXTNODE(r0,r); BDY(r) = (pointer)nf; |
for ( j = 0; j < c; j++ ) |
| |
mat0[i][ci[j]] = (Q)BDY(nm)[i][j]; |
| } |
} |
| Pox_shutdown(mknode(1,proc),&dmy); |
return rank; |
| return r0; |
|
| } |
} |
| |
|
| /* server side */ |
int nd_gauss_elim_gz(GZ **mat0,int *sugar,int row,int col,int *colstat) |
| |
|
| void nd_exec_f4_red_dist() |
|
| { |
{ |
| int m,i,nsp,col,s0size,nred,spcol,j,k; |
|
| NM_ind_pair *rp0; |
|
| NDV nf; |
|
| UINT *s0vect; |
|
| IndArray *imat; |
|
| int *rhead; |
|
| int **spmat; |
|
| UINT *svect,*v; |
|
| ND_pairs *sp0; |
|
| int *colstat; |
|
| int a,sprow,rank; |
|
| struct order_spec *ord; |
|
| Obj ordspec; |
|
| ND spol; |
|
| int maxrs; |
|
| int *spsugar; |
|
| |
|
| nd_read = iofp[0].in; |
|
| nd_write = iofp[0].out; |
|
| m = nd_recv_int(); |
|
| nd_nvar = nd_recv_int(); |
|
| nd_bpe = nd_recv_int(); |
|
| nd_wpd = nd_recv_int(); |
|
| nmv_adv = nd_recv_int(); |
|
| |
|
| loadobj(nd_read,&ordspec); |
|
| create_order_spec(0,ordspec,&ord); |
|
| nd_init_ord(ord); |
|
| nd_setup_parameters(nd_nvar,0); |
|
| |
|
| nd_psn = nd_recv_int(); |
|
| nd_ps = (NDV *)MALLOC(nd_psn*sizeof(NDV)); |
|
| nd_bound = (UINT **)MALLOC(nd_psn*sizeof(UINT *)); |
|
| for ( i = 0; i < nd_psn; i++ ) { |
|
| nd_ps[i] = nd_recv_ndv(); |
|
| nd_bound[i] = ndv_compute_bound(nd_ps[i]); |
|
| } |
|
| |
|
| nsp = nd_recv_int(); |
|
| sp0 = (ND_pairs *)MALLOC(nsp*sizeof(ND_pairs)); |
|
| for ( i = 0; i < nsp; i++ ) { |
|
| NEWND_pairs(sp0[i]); |
|
| sp0[i]->i1 = nd_recv_int(); sp0[i]->i2 = nd_recv_int(); |
|
| ndl_lcm(HDL(nd_ps[sp0[i]->i1]),HDL(nd_ps[sp0[i]->i2]),LCM(sp0[i])); |
|
| } |
|
| |
|
| col = nd_recv_int(); |
|
| s0size = col*nd_wpd; |
|
| s0vect = (UINT *)MALLOC(s0size*sizeof(UINT)); |
|
| nd_recv_intarray(s0vect,s0size); |
|
| |
|
| nred = nd_recv_int(); |
|
| rp0 = (NM_ind_pair *)MALLOC(nred*sizeof(NM_ind_pair)); |
|
| for ( i = 0; i < nred; i++ ) { |
|
| rp0[i] = (NM_ind_pair)MALLOC(sizeof(struct oNM_ind_pair)); |
|
| rp0[i]->index = nd_recv_int(); |
|
| rp0[i]->mul = (NM)MALLOC(sizeof(struct oNM)+(nd_wpd-1)*sizeof(UINT)); |
|
| nd_recv_intarray(rp0[i]->mul->dl,nd_wpd); |
|
| } |
|
| |
|
| spcol = col-nred; |
|
| imat = (IndArray *)MALLOC(nred*sizeof(IndArray)); |
|
| rhead = (int *)MALLOC(col*sizeof(int)); |
|
| for ( i = 0; i < col; i++ ) rhead[i] = 0; |
|
| |
|
| /* construction of index arrays */ |
|
| for ( i = 0; i < nred; i++ ) { |
|
| imat[i] = nm_ind_pair_to_vect_compress(m,s0vect,col,rp0[i]); |
|
| rhead[imat[i]->head] = 1; |
|
| } |
|
| |
|
| /* elimination (1st step) */ |
|
| spmat = (int **)MALLOC(nsp*sizeof(UINT *)); |
|
| svect = (UINT *)MALLOC(col*sizeof(UINT)); |
|
| spsugar = (int *)ALLOCA(nsp*sizeof(UINT)); |
|
| for ( a = sprow = 0; a < nsp; a++ ) { |
|
| nd_sp(m,0,sp0[a],&spol); |
|
| if ( !spol ) continue; |
|
| nd_to_vect(m,s0vect,col,spol,svect); |
|
| if ( m == -1 ) |
|
| maxrs = ndv_reduce_vect_sf(m,svect,col,imat,rp0,nred); |
|
| else |
|
| maxrs = ndv_reduce_vect(m,svect,col,imat,rp0,nred); |
|
| for ( i = 0; i < col; i++ ) if ( svect[i] ) break; |
|
| if ( i < col ) { |
|
| spmat[sprow] = v = (UINT *)MALLOC(spcol*sizeof(UINT)); |
|
| for ( j = k = 0; j < col; j++ ) |
|
| if ( !rhead[j] ) v[k++] = svect[j]; |
|
| spsugar[sprow] = MAX(maxrs,SG(spol)); |
|
| sprow++; |
|
| } |
|
| nd_free(spol); |
|
| } |
|
| /* elimination (2nd step) */ |
|
| colstat = (int *)ALLOCA(spcol*sizeof(int)); |
|
| if ( m == -1 ) |
|
| rank = nd_gauss_elim_sf(spmat,spsugar,sprow,spcol,m,colstat); |
|
| else |
|
| rank = nd_gauss_elim_mod(spmat,spsugar,0,sprow,spcol,m,colstat); |
|
| nd_send_int(rank); |
|
| for ( i = 0; i < rank; i++ ) { |
|
| nf = vect_to_ndv(spmat[i],spcol,col,rhead,s0vect); |
|
| nd_send_ndv(nf); |
|
| } |
|
| fflush(nd_write); |
|
| } |
|
| #endif |
|
| |
|
| int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int col,int *colstat) |
|
| { |
|
| int i,j,t,c,rank,inv; |
int i,j,t,c,rank,inv; |
| int *ci,*ri; |
int *ci,*ri; |
| Q dn; |
GZ dn; |
| MAT m,nm; |
MAT m,nm; |
| |
|
| 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 = 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++ ) |
| mat0[i][j] = 0; |
mat0[i][j] = 0; |
| Line 6620 int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int co |
|
| Line 7595 int nd_gauss_elim_q(Q **mat0,int *sugar,int row,int co |
|
| for ( i = 0; i < rank; i++ ) { |
for ( i = 0; i < rank; i++ ) { |
| mat0[i][ri[i]] = dn; |
mat0[i][ri[i]] = dn; |
| 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]] = (GZ)BDY(nm)[i][j]; |
| } |
} |
| return rank; |
return rank; |
| } |
} |
| Line 6983 void nd_det(int mod,MAT f,P *rp) |
|
| Line 7958 void nd_det(int mod,MAT f,P *rp) |
|
| if ( mod ) ndv_mod(mod,d); |
if ( mod ) ndv_mod(mod,d); |
| chsgnq(ONE,&mone); |
chsgnq(ONE,&mone); |
| for ( j = 0, sgn = 1; j < n; j++ ) { |
for ( j = 0, sgn = 1; j < n; j++ ) { |
| if ( DP_Print ) fprintf(stderr,".",j); |
if ( DP_Print ) { |
| |
fprintf(stderr,".",j); |
| |
} |
| for ( i = j; i < n && !dm[i][j]; i++ ); |
for ( i = j; i < n && !dm[i][j]; i++ ); |
| if ( i == n ) { |
if ( i == n ) { |
| *rp = 0; |
*rp = 0; |
| Line 7042 void nd_det(int mod,MAT f,P *rp) |
|
| Line 8019 void nd_det(int mod,MAT f,P *rp) |
|
| } |
} |
| d = mjj; |
d = mjj; |
| } |
} |
| if ( DP_Print ) fprintf(stderr,"\n",k); |
if ( DP_Print ) { |
| |
fprintf(stderr,"\n",k); |
| |
} |
| if ( sgn < 0 ) |
if ( sgn < 0 ) |
| if ( mod ) |
if ( mod ) |
| ndv_mul_c(mod,d,mod-1); |
ndv_mul_c(mod,d,mod-1); |
| Line 7300 P ndc_div(int mod,union oNDC a,union oNDC b) |
|
| Line 8279 P ndc_div(int mod,union oNDC a,union oNDC b) |
|
| int inv,t; |
int inv,t; |
| |
|
| if ( mod == -1 ) c.m = _mulsf(a.m,_invsf(b.m)); |
if ( mod == -1 ) c.m = _mulsf(a.m,_invsf(b.m)); |
| |
else if ( mod == -2 ) divlf(a.z,b.z,&c.z); |
| else if ( mod ) { |
else if ( mod ) { |
| inv = invm(b.m,mod); |
inv = invm(b.m,mod); |
| DMAR(a.m,inv,0,mod,t); c.m = t; |
DMAR(a.m,inv,0,mod,t); c.m = t; |
| Line 7318 P ndctop(int mod,union oNDC c) |
|
| Line 8298 P ndctop(int mod,union oNDC c) |
|
| |
|
| if ( mod == -1 ) { |
if ( mod == -1 ) { |
| e = IFTOF(c.m); MKGFS(e,gfs); return (P)gfs; |
e = IFTOF(c.m); MKGFS(e,gfs); return (P)gfs; |
| } else if ( mod ) { |
} else if ( mod > 0 ) { |
| STOQ(c.m,q); return (P)q; |
STOQ(c.m,q); return (P)q; |
| } else |
} else |
| return (P)c.p; |
return (P)c.p; |
| Line 7363 void conv_ilist(int demand,int trace,NODE g,int **indp |
|
| Line 8343 void conv_ilist(int demand,int trace,NODE g,int **indp |
|
| void parse_nd_option(NODE opt) |
void parse_nd_option(NODE opt) |
| { |
{ |
| NODE t,p,u; |
NODE t,p,u; |
| int i,s; |
int i,s,n; |
| char *key; |
char *key; |
| Obj value; |
Obj value; |
| |
|
| nd_gentrace = 0; nd_gensyz = 0; nd_nora = 0; nd_gbblock = 0; |
nd_gentrace = 0; nd_gensyz = 0; nd_nora = 0; nd_gbblock = 0; |
| nd_newelim = 0; nd_intersect = 0; nd_nzlist = 0; |
nd_newelim = 0; nd_intersect = 0; nd_nzlist = 0; |
| nd_splist = 0; nd_check_splist = 0; |
nd_splist = 0; nd_check_splist = 0; |
| |
nd_sugarweight = 0; |
| |
nd_f4red =0; |
| |
nd_rank0 = 0; |
| for ( t = opt; t; t = NEXT(t) ) { |
for ( t = opt; t; t = NEXT(t) ) { |
| p = BDY((LIST)BDY(t)); |
p = BDY((LIST)BDY(t)); |
| key = BDY((STRING)BDY(p)); |
key = BDY((STRING)BDY(p)); |
| Line 7381 void parse_nd_option(NODE opt) |
|
| Line 8364 void parse_nd_option(NODE opt) |
|
| else if ( !strcmp(key,"nora") ) |
else if ( !strcmp(key,"nora") ) |
| nd_nora = value?1:0; |
nd_nora = value?1:0; |
| else if ( !strcmp(key,"gbblock") ) { |
else if ( !strcmp(key,"gbblock") ) { |
| if ( !value || OID(value) != O_LIST ) |
if ( value && OID(value) == O_LIST ) { |
| error("nd_* : invalid value for gbblock option"); |
u = BDY((LIST)value); |
| u = BDY((LIST)value); |
nd_gbblock = MALLOC((2*length(u)+1)*sizeof(int)); |
| nd_gbblock = MALLOC((2*length(u)+1)*sizeof(int)); |
for ( i = 0; u; u = NEXT(u) ) { |
| for ( i = 0; u; u = NEXT(u) ) { |
p = BDY((LIST)BDY(u)); |
| p = BDY((LIST)BDY(u)); |
s = nd_gbblock[i++] = QTOS((Q)BDY(p)); |
| s = nd_gbblock[i++] = QTOS((Q)BDY(p)); |
nd_gbblock[i++] = s+QTOS((Q)BDY(NEXT(p)))-1; |
| nd_gbblock[i++] = s+QTOS((Q)BDY(NEXT(p)))-1; |
} |
| } |
nd_gbblock[i] = -1; |
| nd_gbblock[i] = -1; |
} else |
| |
nd_gbblock = 0; |
| } else if ( !strcmp(key,"newelim") ) |
} else if ( !strcmp(key,"newelim") ) |
| nd_newelim = value?1:0; |
nd_newelim = value?1:0; |
| else if ( !strcmp(key,"intersect") ) |
else if ( !strcmp(key,"intersect") ) |
| nd_intersect = value?1:0; |
nd_intersect = value?1:0; |
| |
else if ( !strcmp(key,"lf") ) |
| |
nd_lf = value?1:0; |
| else if ( !strcmp(key,"trace") ) { |
else if ( !strcmp(key,"trace") ) { |
| u = BDY((LIST)value); |
u = BDY((LIST)value); |
| nd_nzlist = BDY((LIST)ARG2(u)); |
nd_nzlist = BDY((LIST)ARG2(u)); |
| nd_bpe = QTOS((Q)ARG3(u)); |
nd_bpe = QTOS((Q)ARG3(u)); |
| } else if ( !strcmp(key,"splist") ) |
} else if ( !strcmp(key,"f4red") ) { |
| |
nd_f4red = QTOS((Q)value); |
| |
} else if ( !strcmp(key,"rank0") ) { |
| |
nd_rank0 = value?1:0; |
| |
} else if ( !strcmp(key,"splist") ) { |
| nd_splist = value?1:0; |
nd_splist = value?1:0; |
| else if ( !strcmp(key,"check_splist") ) { |
} else if ( !strcmp(key,"check_splist") ) { |
| nd_check_splist = BDY((LIST)value); |
nd_check_splist = BDY((LIST)value); |
| |
} else if ( !strcmp(key,"sugarweight") ) { |
| |
u = BDY((LIST)value); |
| |
n = length(u); |
| |
nd_sugarweight = MALLOC(n*sizeof(int)); |
| |
for ( i = 0; i < n; i++, u = NEXT(u) ) |
| |
nd_sugarweight[i] = QTOS((Q)BDY(u)); |
| } |
} |
| } |
} |
| } |
} |
| Line 7577 MAT nd_btog(LIST f,LIST v,int mod,struct order_spec *o |
|
| Line 8573 MAT nd_btog(LIST f,LIST v,int mod,struct order_spec *o |
|
| pi0 = QTOS((Q)ARG0(pi)); pi1 = QTOS((Q)ARG1(pi)); |
pi0 = QTOS((Q)ARG0(pi)); pi1 = QTOS((Q)ARG1(pi)); |
| p[pi0] = c = (ND *)MALLOC(nb*sizeof(ND)); |
p[pi0] = c = (ND *)MALLOC(nb*sizeof(ND)); |
| ptomp(mod,(P)ARG2(pi),&inv); |
ptomp(mod,(P)ARG2(pi),&inv); |
| |
((MQ)inv)->cont = invm(((MQ)inv)->cont,mod); |
| u = ptond(CO,vv,(P)ONE); |
u = ptond(CO,vv,(P)ONE); |
| HCM(u) = ((MQ)inv)->cont; |
HCM(u) = ((MQ)inv)->cont; |
| c[pi1] = u; |
c[pi1] = u; |
| Line 7585 MAT nd_btog(LIST f,LIST v,int mod,struct order_spec *o |
|
| Line 8582 MAT nd_btog(LIST f,LIST v,int mod,struct order_spec *o |
|
| printf("%d ",i); fflush(stdout); |
printf("%d ",i); fflush(stdout); |
| ti = BDY((LIST)BDY(t)); |
ti = BDY((LIST)BDY(t)); |
| p[j=QTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod); |
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++ ) { |
for ( t = intred, i=0; t; t = NEXT(t), i++ ) { |
| printf("%d ",i); fflush(stdout); |
printf("%d ",i); fflush(stdout); |
| ti = BDY((LIST)BDY(t)); |
ti = BDY((LIST)BDY(t)); |
| p[j=QTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod); |
p[j=QTOS((Q)ARG0(ti))] = btog(BDY((LIST)ARG1(ti)),p,nb,mod); |
| if ( j == 441 ) |
|
| printf("afo"); |
|
| } |
} |
| m = length(ind); |
m = length(ind); |
| MKMAT(mat,nb,m); |
MKMAT(mat,nb,m); |
| Line 7648 VECT nd_btog_one(LIST f,LIST v,int mod,struct order_sp |
|
| Line 8641 VECT nd_btog_one(LIST f,LIST v,int mod,struct order_sp |
|
| pi = BDY((LIST)BDY(t)); |
pi = BDY((LIST)BDY(t)); |
| pi0 = QTOS((Q)ARG0(pi)); pi1 = QTOS((Q)ARG1(pi)); |
pi0 = QTOS((Q)ARG0(pi)); pi1 = QTOS((Q)ARG1(pi)); |
| if ( pi1 == pos ) { |
if ( pi1 == pos ) { |
| ptomp(mod,(P)ARG2(pi),&inv); |
ptomp(mod,(P)ARG2(pi),&inv); |
| |
((MQ)inv)->cont = invm(((MQ)inv)->cont,mod); |
| u = ptond(CO,vv,(P)ONE); |
u = ptond(CO,vv,(P)ONE); |
| HCM(u) = ((MQ)inv)->cont; |
HCM(u) = ((MQ)inv)->cont; |
| p[pi0] = u; |
p[pi0] = u; |
| Line 7683 VECT nd_btog_one(LIST f,LIST v,int mod,struct order_sp |
|
| Line 8677 VECT nd_btog_one(LIST f,LIST v,int mod,struct order_sp |
|
| } |
} |
| return vect; |
return vect; |
| } |
} |
| |
|
| |
void ndv_print_lf(NDV p) |
| |
{ |
| |
NMV m; |
| |
int i,len; |
| |
|
| |
if ( !p ) printf("0\n"); |
| |
else { |
| |
len = LEN(p); |
| |
for ( m = BDY(p), i = 0; i < len; i++, NMV_ADV(m) ) { |
| |
printf("+"); |
| |
mpz_out_str(asir_out,10,BDY(CZ(m))); |
| |
printf("*"); |
| |
ndl_print(DL(m)); |
| |
} |
| |
printf("\n"); |
| |
} |
| |
} |
| |
|
| |
void nd_f4_lf_trace(LIST f,LIST v,int trace,int homo,struct order_spec *ord,LIST *rp) |
| |
{ |
| |
VL tv,fv,vv,vc,av; |
| |
NODE fd,fd0,in0,in,r,r0,t,s,cand,alist; |
| |
int m,nocheck,nvar,mindex,e,max; |
| |
NDV c; |
| |
NMV a; |
| |
P p,zp; |
| |
Q dmy; |
| |
EPOS oepos; |
| |
int obpe,oadv,wmax,i,len,cbpe,ishomo,nalg,mrank,trank,ompos; |
| |
Alg alpha,dp; |
| |
P poly; |
| |
LIST f1,f2,zpl; |
| |
Obj obj; |
| |
NumberField nf; |
| |
struct order_spec *ord1; |
| |
struct oEGT eg_check,eg0,eg1; |
| |
NODE tr,tl1,tl2,tl3,tl4; |
| |
LIST l1,l2,l3,l4,l5; |
| |
int *perm; |
| |
int j,ret; |
| |
Q jq,bpe; |
| |
|
| |
nd_module = 0; |
| |
parse_nd_option(current_option); |
| |
get_vars((Obj)f,&fv); pltovl(v,&vv); vlminus(fv,vv,&nd_vc); |
| |
if ( nd_vc ) |
| |
error("nd_f4_lf_trace : computation over a rational function field is not implemented"); |
| |
for ( nvar = 0, tv = vv; tv; tv = NEXT(tv), nvar++ ); |
| |
switch ( ord->id ) { |
| |
case 1: |
| |
if ( ord->nv != nvar ) |
| |
error("nd_f4_lf_trace : invalid order specification"); |
| |
break; |
| |
default: |
| |
break; |
| |
} |
| |
|
| |
nd_ntrans = nvar; |
| |
nd_nalg = 0; |
| |
|
| |
nocheck = 0; |
| |
mindex = 0; |
| |
|
| |
/* do not use on-demand load/save */ |
| |
nd_demand = 0; |
| |
m = trace > 1 ? trace : get_lprime(mindex); |
| |
nd_init_ord(ord); |
| |
mrank = 0; |
| |
for ( t = BDY(f), max = 1; t; t = NEXT(t) ) |
| |
for ( tv = vv; tv; tv = NEXT(tv) ) { |
| |
if ( nd_module ) { |
| |
s = BDY((LIST)BDY(t)); |
| |
trank = length(s); |
| |
mrank = MAX(mrank,trank); |
| |
for ( ; s; s = NEXT(s) ) { |
| |
e = getdeg(tv->v,(P)BDY(s)); |
| |
max = MAX(e,max); |
| |
} |
| |
} else { |
| |
e = getdeg(tv->v,(P)BDY(t)); |
| |
max = MAX(e,max); |
| |
} |
| |
} |
| |
nd_setup_parameters(nvar,max); |
| |
obpe = nd_bpe; oadv = nmv_adv; oepos = nd_epos; ompos = nd_mpos; |
| |
ishomo = 1; |
| |
/* XXX */ |
| |
for ( in0 = 0, fd0 = 0, t = BDY(f); t; t = NEXT(t) ) { |
| |
if ( nd_module ) { |
| |
c = (pointer)pltondv(CO,vv,(LIST)BDY(t)); |
| |
} else { |
| |
c = (pointer)ptondv(CO,vv,(P)BDY(t)); |
| |
} |
| |
if ( ishomo ) |
| |
ishomo = ishomo && ndv_ishomo(c); |
| |
if ( c ) { |
| |
NEXTNODE(in0,in); BDY(in) = (pointer)c; |
| |
NEXTNODE(fd0,fd); BDY(fd) = (pointer)ndv_dup(0,c); |
| |
} |
| |
} |
| |
if ( in0 ) NEXT(in) = 0; |
| |
if ( fd0 ) NEXT(fd) = 0; |
| |
if ( !ishomo && homo ) { |
| |
for ( t = in0, wmax = max; t; t = NEXT(t) ) { |
| |
c = (NDV)BDY(t); len = LEN(c); |
| |
for ( a = BDY(c), 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); |
| |
} |
| |
if ( MaxDeg > 0 ) nocheck = 1; |
| |
ret = ndv_setup(-2,m,fd0,nd_gbblock?1:0,0); |
| |
if ( ret ) |
| |
cand = nd_f4_lf_trace_main(m,&perm); |
| |
if ( !ret || !cand ) { |
| |
*rp = 0; return; |
| |
} |
| |
if ( !ishomo && homo ) { |
| |
/* dehomogenization */ |
| |
for ( t = cand; t; t = NEXT(t) ) ndv_dehomogenize((NDV)BDY(t),ord); |
| |
nd_init_ord(ord); |
| |
nd_setup_parameters(nvar,0); |
| |
} |
| |
cand = ndv_reducebase(cand,perm); |
| |
cand = ndv_reduceall(-2,cand); |
| |
cbpe = nd_bpe; |
| |
get_eg(&eg0); |
| |
if ( ret = ndv_check_membership(-2,in0,obpe,oadv,oepos,cand) ) { |
| |
/* gbcheck : cand is a GB of Id(cand) ? */ |
| |
ret = nd_f4(-2,0,0); |
| |
} |
| |
if ( !ret ) { |
| |
/* failure */ |
| |
*rp = 0; return; |
| |
} |
| |
get_eg(&eg1); init_eg(&eg_check); add_eg(&eg_check,&eg0,&eg1); |
| |
if ( DP_Print ) |
| |
fprintf(asir_out,"check=%fsec\n",eg_check.exectime+eg_check.gctime); |
| |
/* dp->p */ |
| |
nd_bpe = cbpe; |
| |
nd_setup_parameters(nd_nvar,0); |
| |
for ( r = cand; r; r = NEXT(r) ) { |
| |
if ( nd_module ) BDY(r) = ndvtopl(-2,CO,vv,BDY(r),mrank); |
| |
else BDY(r) = (pointer)ndvtop(-2,CO,vv,BDY(r)); |
| |
} |
| |
MKLIST(*rp,cand); |
| |
} |
| |
|
| |
NODE nd_f4_lf_trace_main(int m,int **indp) |
| |
{ |
| |
int i,nh,stat,index; |
| |
NODE r,rm,g; |
| |
ND_pairs d,l,l0,t; |
| |
ND spol,red; |
| |
NDV nf,redv,nfqv,nfv; |
| |
NM s0,s; |
| |
NODE rp0,srp0,nflist,nflist_lf; |
| |
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); |
| |
if ( MaxDeg > 0 && sugar > MaxDeg ) break; |
| |
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 LF */ |
| |
bucket = create_pbucket(); |
| |
stat = nd_sp_f4(-2,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_lf = nd_f4_red(-2,l,1,s0vect,col,rp0,0); |
| |
/* adding new bases */ |
| |
for ( rm = nflist, r = nflist_lf; r && rm; rm = NEXT(rm), r = NEXT(r) ) { |
| |
nfv = (NDV)BDY(rm); |
| |
nfqv = (NDV)BDY(r); |
| |
if ( DL_COMPARE(HDL(nfv),HDL(nfqv)) ) return 0; |
| |
ndv_removecont(m,nfv); |
| |
ndv_removecont(-2,nfqv); |
| |
nh = ndv_newps(-2,nfv,nfqv,1); |
| |
d = update_pairs(d,g,nh,0); |
| |
g = update_base(g,nh); |
| |
} |
| |
if ( r || rm ) return 0; |
| |
} |
| |
conv_ilist(nd_demand,1,g,indp); |
| |
return g; |
| |
} |
| |
|
![[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