=================================================================== RCS file: /home/cvs/OpenXM_contrib2/asir2018/builtin/dp.c,v retrieving revision 1.8 retrieving revision 1.16 diff -u -p -r1.8 -r1.16 --- OpenXM_contrib2/asir2018/builtin/dp.c 2019/03/18 10:30:41 1.8 +++ OpenXM_contrib2/asir2018/builtin/dp.c 2019/10/11 03:45:56 1.16 @@ -45,7 +45,7 @@ * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE, * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE. * - * $OpenXM: OpenXM_contrib2/asir2018/builtin/dp.c,v 1.7 2019/03/18 07:09:58 noro Exp $ + * $OpenXM: OpenXM_contrib2/asir2018/builtin/dp.c,v 1.15 2019/09/19 06:29:47 noro Exp $ */ #include "ca.h" #include "base.h" @@ -79,6 +79,7 @@ void Pdp_nf_mod(),Pdp_true_nf_mod(); void Pdp_criB(),Pdp_nelim(); void Pdp_minp(),Pdp_sp_mod(); void Pdp_homo(),Pdp_dehomo(); +void Pdpm_homo(),Pdpm_dehomo(); void Pdp_gr_mod_main(),Pdp_gr_f_main(); void Pdp_gr_main(),Pdp_gr_hm_main(),Pdp_gr_d_main(),Pdp_gr_flags(); void Pdp_interreduce(); @@ -89,8 +90,9 @@ void Pdp_vtoe(), Pdp_etov(), Pdp_dtov(), Pdp_idiv(), P void Pdp_cont(); void Pdp_gr_checklist(); void Pdp_ltod(),Pdpv_ord(),Pdpv_ht(),Pdpv_hm(),Pdpv_hc(); -void Pdpm_ltod(),Pdpm_dtol(),Pdpm_ord(),Pdpm_nf(),Pdpm_weyl_nf(),Pdpm_sp(),Pdpm_weyl_sp(); -void Pdpm_hm(),Pdpm_ht(),Pdpm_hc(); +void Pdpm_ltod(),Pdpm_dtol(),Pdpm_set_schreyer(),Pdpm_nf(),Pdpm_weyl_nf(),Pdpm_sp(),Pdpm_weyl_sp(),Pdpm_nf_and_quotient(); +void Pdpm_hm(),Pdpm_ht(),Pdpm_hc(),Pdpm_hp(),Pdpm_rest(),Pdpm_shift(),Pdpm_split(),Pdpm_sort(),Pdpm_dptodpm(),Pdpm_redble(); +void Pdpm_schreyer_base(),Pdpm_simplify_syz(),Pdpm_td(); void Pdp_weyl_red(); void Pdp_weyl_sp(); @@ -157,9 +159,10 @@ struct ftab dp_tab[] = { {"dp_nf",Pdp_nf,4}, {"dp_nf_mod",Pdp_nf_mod,5}, {"dp_nf_f",Pdp_nf_f,4}, - {"dpm_nf_f",Pdpm_nf_f,4}, - {"dpm_weyl_nf_f",Pdpm_weyl_nf_f,4}, - {"dpm_nf",Pdpm_nf,4}, + {"dpm_nf_and_quotient",Pdpm_nf_and_quotient,-3}, + {"dpm_nf_f",Pdpm_nf_f,-4}, + {"dpm_weyl_nf_f",Pdpm_weyl_nf_f,-4}, + {"dpm_nf",Pdpm_nf,-4}, {"dpm_sp",Pdpm_sp,2}, {"dpm_weyl_sp",Pdpm_weyl_sp,2}, @@ -215,7 +218,7 @@ struct ftab dp_tab[] = { /* normal form */ {"dp_weyl_nf",Pdp_weyl_nf,4}, - {"dpm_weyl_nf",Pdpm_weyl_nf,4}, + {"dpm_weyl_nf",Pdpm_weyl_nf,-4}, {"dp_weyl_nf_mod",Pdp_weyl_nf_mod,5}, {"dp_weyl_nf_f",Pdp_weyl_nf_f,4}, @@ -252,7 +255,7 @@ struct ftab dp_supp_tab[] = { /* setting flags */ {"dp_sort",Pdp_sort,1}, {"dp_ord",Pdp_ord,-1}, - {"dpm_ord",Pdpm_ord,-1}, + {"dpm_set_schreyer",Pdpm_set_schreyer,-1}, {"dpv_ord",Pdpv_ord,-2}, {"dp_set_kara",Pdp_set_kara,-1}, {"dp_nelim",Pdp_nelim,-1}, @@ -274,7 +277,10 @@ struct ftab dp_supp_tab[] = { {"dp_ltod",Pdp_ltod,-2}, {"dpm_ltod",Pdpm_ltod,2}, - {"dpm_dtol",Pdpm_dtol,3}, + {"dpm_dptodpm",Pdpm_dptodpm,2}, + {"dpm_dtol",Pdpm_dtol,2}, + {"dpm_homo",Pdpm_homo,1}, + {"dpm_dehomo",Pdpm_dehomo,1}, /* criteria */ {"dp_cri1",Pdp_cri1,2}, @@ -293,6 +299,11 @@ struct ftab dp_supp_tab[] = { {"dpm_hm",Pdpm_hm,1}, {"dpm_ht",Pdpm_ht,1}, {"dpm_hc",Pdpm_hc,1}, + {"dpm_hp",Pdpm_hp,1}, + {"dpm_rest",Pdpm_rest,1}, + {"dpm_shift",Pdpm_shift,2}, + {"dpm_split",Pdpm_split,2}, + {"dpm_sort",Pdpm_sort,1}, {"dp_rest",Pdp_rest,1}, {"dp_initial_term",Pdp_initial_term,1}, {"dp_order",Pdp_order,1}, @@ -303,10 +314,12 @@ struct ftab dp_supp_tab[] = { {"dp_mag",Pdp_mag,1}, {"dp_sugar",Pdp_sugar,1}, {"dp_set_sugar",Pdp_set_sugar,2}, + {"dpm_td",Pdpm_td,1}, /* misc */ {"dp_mbase",Pdp_mbase,1}, {"dp_redble",Pdp_redble,2}, + {"dpm_redble",Pdpm_redble,2}, {"dp_sep",Pdp_sep,2}, {"dp_idiv",Pdp_idiv,2}, {"dp_tdiv",Pdp_tdiv,2}, @@ -316,6 +329,8 @@ struct ftab dp_supp_tab[] = { {"dp_compute_essential_df",Pdp_compute_essential_df,2}, {"dp_mono_raddec",Pdp_mono_raddec,2}, {"dp_mono_reduce",Pdp_mono_reduce,2}, + {"dpm_schreyer_base",Pdpm_schreyer_base,1}, + {"dpm_simplify_syz",Pdpm_simplify_syz,2}, {"dp_rref2",Pdp_rref2,2}, {"sumi_updatepairs",Psumi_updatepairs,3}, @@ -503,6 +518,8 @@ P binpoly(P n,int a,int b) return r; } +void ibin(unsigned long int n,unsigned long int k,Z *r); + void mhp_to_hf(VL vl,P hp,int n,P *plist,VECT *head,P *hf) { P tv,gcd,q,h,hphead,tt,ai,hpoly,nv,bp,w; @@ -538,7 +555,7 @@ void mhp_to_hf(VL vl,P hp,int n,P *plist,VECT *head,P topdc = 0; for ( i = 0; i < qd; i++ ) { NEWDC(dc); NEXT(dc) = topdc; - ibin(i+s-1,s-1,&COEF(dc)); + ibin(i+s-1,s-1,(Z *)&COEF(dc)); STOZ(i,d); DEG(dc) = d; topdc = dc; } @@ -897,6 +914,8 @@ void Pdp_nf_tab_f(NODE arg,DP *rp) dp_nf_tab_f((DP)ARG0(arg),(LIST *)BDY((VECT)ARG1(arg)),rp); } +extern int dpm_ordtype; + void Pdp_ord(NODE arg,Obj *rp) { struct order_spec *spec; @@ -914,6 +933,7 @@ void Pdp_ord(NODE arg,Obj *rp) else if ( !create_order_spec(0,(Obj)ARG0(arg),&spec) ) error("dp_ord : invalid order specification"); initd(spec); *rp = spec->obj; + if ( spec->id >= 256 ) dpm_ordtype = spec->module_ordtype; } } @@ -1064,7 +1084,7 @@ void Pdpm_ltod(NODE arg,DPM *rp) nd = BDY(f); len = length(nd); - for ( i = 0, t = nd, s = 0; i < len; i++, t = NEXT(t) ) { + for ( i = 1, t = nd, s = 0; i <= len; i++, t = NEXT(t) ) { ptod(CO,vl,(P)BDY(t),&d); dtodpm(d,i,&u); adddpm(CO,s,u,&w); s = w; @@ -1072,6 +1092,36 @@ void Pdpm_ltod(NODE arg,DPM *rp) *rp = s; } +// c*[monomial,i]+... -> c*<>+... + +void Pdpm_dptodpm(NODE arg,DPM *rp) +{ + DP p; + MP mp; + int pos,shift; + DMM m0,m; + + p = (DP)ARG0(arg); + pos = ZTOS((Z)ARG1(arg)); + if ( pos <= 0 ) + error("dpm_mtod : position must be positive"); + if ( !p ) *rp = 0; + else { + for ( m0 = 0, mp = BDY(p); mp; mp = NEXT(mp) ) { + NEXTDMM(m0,m); m->dl = mp->dl; m->c = mp->c; m->pos = pos; + } + if ( dp_current_spec->module_rank ) { + if ( pos > dp_current_spec->module_rank ) + error("dpm_dptodpm : inconsistent order spec"); + shift = dp_current_spec->module_top_weight[pos-1]; + m->dl->td += shift; + } else + shift = 0; + + MKDPM(p->nv,m0,*rp); (*rp)->sugar = p->sugar+shift; + } +} + void Pdpm_dtol(NODE arg,LIST *rp) { DPM a; @@ -1086,6 +1136,10 @@ void Pdpm_dtol(NODE arg,LIST *rp) Obj s; a = (DPM)ARG0(arg); + if ( !a ) { + MKLIST(*rp,0); + return; + } for ( vl = 0, nd = BDY((LIST)ARG1(arg)), nv = 0; nd; nd = NEXT(nd), nv++ ) { if ( !vl ) { NEWVL(vl); tvl = vl; @@ -1096,7 +1150,8 @@ void Pdpm_dtol(NODE arg,LIST *rp) } if ( vl ) NEXT(tvl) = 0; - n = ZTOS((Q)ARG2(arg)); + for ( t = BDY(a), n = 0; t; t = NEXT(t) ) + if ( t->pos > n ) n = t->pos; w = (MP *)CALLOC(n,sizeof(MP)); for ( t = BDY(a), len = 0; t; t = NEXT(t) ) len++; wa = (DMM *)MALLOC(len*sizeof(DMM)); @@ -1104,8 +1159,8 @@ void Pdpm_dtol(NODE arg,LIST *rp) for ( i = len-1; i >= 0; i-- ) { NEWMP(m); m->dl = wa[i]->dl; C(m) = C(wa[i]); pos = wa[i]->pos; - NEXT(m) = w[pos]; - w[pos] = m; + NEXT(m) = w[pos-1]; + w[pos-1] = m; } nd = 0; for ( i = n-1; i >= 0; i-- ) { @@ -1265,40 +1320,87 @@ void Pdp_weyl_nf(NODE arg,DP *rp) void Pdpm_nf(NODE arg,DPM *rp) { NODE b; - DPM *ps; + VECT ps; DPM g; - int full; + int ac,full; if ( !(g = (DPM)ARG1(arg)) ) { *rp = 0; return; } do_weyl = 0; dp_fcoeffs = 0; - asir_assert(ARG0(arg),O_LIST,"dpm_nf"); - asir_assert(ARG1(arg),O_DPM,"dpm_nf"); - asir_assert(ARG2(arg),O_VECT,"dpm_nf"); - asir_assert(ARG3(arg),O_N,"dpm_nf"); - b = BDY((LIST)ARG0(arg)); ps = (DPM *)BDY((VECT)ARG2(arg)); - full = (Q)ARG3(arg) ? 1 : 0; + ac = argc(arg); + if ( ac < 3 ) + error("dpm_nf: invalid arguments"); + else if ( ac == 3 ) { + asir_assert(ARG1(arg),O_VECT,"dpm_nf"); + b = 0; g = (DPM)ARG0(arg); ps = (VECT)ARG1(arg); + } else if ( ac == 4 ) { + asir_assert(ARG0(arg),O_LIST,"dpm_nf"); + asir_assert(ARG2(arg),O_VECT,"dpm_nf"); + b = BDY((LIST)ARG0(arg)); g = (DPM)ARG1(arg); ps = (VECT)ARG2(arg); + full = (Q)ARG3(arg) ? 1 : 0; + } dpm_nf_z(b,g,ps,full,DP_Multiple,rp); } +DP *dpm_nf_and_quotient(NODE b,DPM g,VECT ps,DPM *rp,P *dnp); + +void Pdpm_nf_and_quotient(NODE arg,LIST *rp) +{ + NODE b; + VECT ps; + DPM g,nm; + P dn; + VECT quo; + NODE n; + int ac; + + do_weyl = 0; dp_fcoeffs = 0; + ac = argc(arg); + if ( ac < 2 ) + error("dpm_nf_and_quotient : invalid arguments"); + else if ( ac == 2 ) { + asir_assert(ARG1(arg),O_VECT,"dpm_nf_and_quotient"); + b = 0; g = (DPM)ARG0(arg); ps = (VECT)ARG1(arg); + } else if ( ac == 3 ) { + asir_assert(ARG0(arg),O_LIST,"dpm_nf_and_quotient"); + asir_assert(ARG2(arg),O_VECT,"dpm_nf_and_quotient"); + b = BDY((LIST)ARG0(arg)); g = (DPM)ARG1(arg); ps = (VECT)ARG2(arg); + } + NEWVECT(quo); quo->len = ps->len; + if ( g ) { + quo->body = (pointer *)dpm_nf_and_quotient(b,g,ps,&nm,&dn); + } else { + quo->body = (pointer *)MALLOC(quo->len*sizeof(pointer)); + nm = 0; dn = (P)ONE; + } + n = mknode(3,nm,dn,quo); + MKLIST(*rp,n); +} + void Pdpm_weyl_nf(NODE arg,DPM *rp) { NODE b; - DPM *ps; + VECT ps; DPM g; - int full; + int ac,full; if ( !(g = (DPM)ARG1(arg)) ) { *rp = 0; return; } - asir_assert(ARG0(arg),O_LIST,"dpm_weyl_nf"); - asir_assert(ARG1(arg),O_DPM,"dpm_weyl_nf"); - asir_assert(ARG2(arg),O_VECT,"dpm_weyl_nf"); - asir_assert(ARG3(arg),O_N,"dpm_weyl_nf"); - b = BDY((LIST)ARG0(arg)); ps = (DPM *)BDY((VECT)ARG2(arg)); - full = (Q)ARG3(arg) ? 1 : 0; - do_weyl = 1; + do_weyl = 1; dp_fcoeffs = 0; + ac = argc(arg); + if ( ac < 3 ) + error("dpm_weyl_nf: invalid arguments"); + else if ( ac == 3 ) { + asir_assert(ARG1(arg),O_VECT,"dpm_nf"); + b = 0; g = (DPM)ARG0(arg); ps = (VECT)ARG1(arg); + } else if ( ac == 4 ) { + asir_assert(ARG0(arg),O_LIST,"dpm_weyl_nf"); + asir_assert(ARG2(arg),O_VECT,"dpm_weyl_nf"); + b = BDY((LIST)ARG0(arg)); g = (DPM)ARG1(arg); ps = (VECT)ARG2(arg); + full = (Q)ARG3(arg) ? 1 : 0; + } dpm_nf_z(b,g,ps,full,DP_Multiple,rp); do_weyl = 0; } @@ -1349,38 +1451,51 @@ void Pdp_weyl_nf_f(NODE arg,DP *rp) void Pdpm_nf_f(NODE arg,DPM *rp) { NODE b; - DPM *ps; + VECT ps; DPM g; - int full; + int ac,full; if ( !(g = (DPM)ARG1(arg)) ) { *rp = 0; return; } - asir_assert(ARG0(arg),O_LIST,"dpm_nf_f"); - asir_assert(ARG1(arg),O_DPM,"dpm_nf_f"); - asir_assert(ARG2(arg),O_VECT,"dpm_nf_f"); - asir_assert(ARG3(arg),O_N,"dpm_nf_f"); - b = BDY((LIST)ARG0(arg)); ps = (DPM *)BDY((VECT)ARG2(arg)); - full = (Q)ARG3(arg) ? 1 : 0; + ac = argc(arg); + if ( ac < 3 ) + error("dpm_nf_f: invalid arguments"); + else if ( ac == 3 ) { + asir_assert(ARG1(arg),O_VECT,"dpm_nf_f"); + b = 0; g = (DPM)ARG0(arg); ps = (VECT)ARG1(arg); + } else if ( ac == 4 ) { + asir_assert(ARG0(arg),O_LIST,"dpm_nf_f"); + asir_assert(ARG2(arg),O_VECT,"dpm_nf_f"); + b = BDY((LIST)ARG0(arg)); g = (DPM)ARG1(arg); ps = (VECT)ARG2(arg); + full = (Q)ARG3(arg) ? 1 : 0; + } + do_weyl = 0; dpm_nf_f(b,g,ps,full,rp); } void Pdpm_weyl_nf_f(NODE arg,DPM *rp) { NODE b; - DPM *ps; + VECT ps; DPM g; - int full; + int ac,full; if ( !(g = (DPM)ARG1(arg)) ) { *rp = 0; return; } - asir_assert(ARG0(arg),O_LIST,"dpm_weyl_nf_f"); - asir_assert(ARG1(arg),O_DP,"dpm_weyl_nf_f"); - asir_assert(ARG2(arg),O_VECT,"dpm_weyl_nf_f"); - asir_assert(ARG3(arg),O_N,"dpm_weyl_nf_f"); - b = BDY((LIST)ARG0(arg)); ps = (DPM *)BDY((VECT)ARG2(arg)); - full = (Q)ARG3(arg) ? 1 : 0; + ac = argc(arg); + if ( ac < 3 ) + error("dpm_weyl_nf_f: invalid arguments"); + else if ( ac == 3 ) { + asir_assert(ARG1(arg),O_VECT,"dpm_weyl_nf_f"); + b = 0; g = (DPM)ARG0(arg); ps = (VECT)ARG1(arg); + } else if ( ac == 4 ) { + asir_assert(ARG0(arg),O_LIST,"dpm_weyl_nf_f"); + asir_assert(ARG2(arg),O_VECT,"dpm_weyl_nf_f"); + b = BDY((LIST)ARG0(arg)); g = (DPM)ARG1(arg); ps = (VECT)ARG2(arg); + full = (Q)ARG3(arg) ? 1 : 0; + } do_weyl = 1; dpm_nf_f(b,g,ps,full,rp); do_weyl = 0; @@ -1763,6 +1878,39 @@ void Pdp_redble(NODE arg,Z *rp) *rp = 0; } +void Pdpm_redble(NODE arg,Z *rp) +{ + asir_assert(ARG0(arg),O_DPM,"dpm_redble"); + asir_assert(ARG1(arg),O_DPM,"dpm_redble"); + if ( dpm_redble((DPM)ARG0(arg),(DPM)ARG1(arg)) ) + *rp = ONE; + else + *rp = 0; +} + +void dpm_schreyer_base(LIST g,LIST *s); + +void Pdpm_schreyer_base(NODE arg,LIST *rp) +{ + asir_assert(ARG0(arg),O_LIST,"dpm_schreyer_base"); + dpm_schreyer_base((LIST)ARG0(arg),rp); +} + +void dpm_simplify_syz(LIST m,LIST s,LIST *m1,LIST *s1,LIST *w1); + +void Pdpm_simplify_syz(NODE arg,LIST *rp) +{ + LIST s1,m1,w1; + NODE t; + + asir_assert(ARG0(arg),O_LIST,"dpm_simplify_syz"); + asir_assert(ARG1(arg),O_LIST,"dpm_simplify_syz"); + dpm_simplify_syz((LIST)ARG0(arg),(LIST)ARG1(arg),&s1,&m1,&w1); + t = mknode(3,s1,m1,w1); + MKLIST(*rp,t); +} + + void Pdp_red_mod(NODE arg,LIST *rp) { DP h,r; @@ -1925,25 +2073,47 @@ void Pdp_weyl_sp(NODE arg,DP *rp) do_weyl = 0; } -void Pdpm_sp(NODE arg,DPM *rp) +void Pdpm_sp(NODE arg,Obj *rp) { - DPM p1,p2; + DPM p1,p2,sp; + DP mul1,mul2; + Obj val; + NODE nd; + LIST l; do_weyl = 0; p1 = (DPM)ARG0(arg); p2 = (DPM)ARG1(arg); asir_assert(p1,O_DPM,"dpm_sp"); asir_assert(p2,O_DPM,"dpm_sp"); - dpm_sp(p1,p2,rp); + dpm_sp(p1,p2,&sp,&mul1,&mul2); + if ( get_opt("coef",&val) && val ) { + nd = mknode(3,sp,mul1,mul2); + MKLIST(l,nd); + *rp = (Obj)l; + } else { + *rp = (Obj)sp; + } } -void Pdpm_weyl_sp(NODE arg,DPM *rp) +void Pdpm_weyl_sp(NODE arg,Obj *rp) { - DPM p1,p2; + DPM p1,p2,sp; + DP mul1,mul2; + Obj val; + NODE nd; + LIST l; p1 = (DPM)ARG0(arg); p2 = (DPM)ARG1(arg); asir_assert(p1,O_DPM,"dpm_weyl_sp"); asir_assert(p2,O_DPM,"dpm_weyl_sp"); do_weyl = 1; - dpm_sp(p1,p2,rp); + dpm_sp(p1,p2,&sp,&mul1,&mul2); do_weyl = 0; + if ( get_opt("coef",&val) && val ) { + nd = mknode(3,sp,mul1,mul2); + MKLIST(l,nd); + *rp = (Obj)l; + } else { + *rp = (Obj)sp; + } } void Pdp_sp_mod(NODE arg,DP *rp) @@ -2024,6 +2194,17 @@ void Pdp_td(NODE arg,Z *rp) STOZ(BDY(p)->dl->td,*rp); } +void Pdpm_td(NODE arg,Z *rp) +{ + DPM p; + + p = (DPM)ARG0(arg); asir_assert(p,O_DPM,"dpm_td"); + if ( !p ) + *rp = 0; + else + STOZ(BDY(p)->dl->td,*rp); +} + void Pdp_sugar(NODE arg,Z *rp) { DP p; @@ -2264,6 +2445,22 @@ void Pdp_dehomo(NODE arg,DP *rp) dp_dehomo((DP)ARG0(arg),rp); } +void dpm_homo(DPM a,DPM *b); +void dpm_dehomo(DPM a,DPM *b); + +void Pdpm_homo(NODE arg,DPM *rp) +{ + asir_assert(ARG0(arg),O_DPM,"dpm_homo"); + dpm_homo((DPM)ARG0(arg),rp); +} + +void Pdpm_dehomo(NODE arg,DPM *rp) +{ + asir_assert(ARG0(arg),O_DPM,"dpm_dehomo"); + dpm_dehomo((DPM)ARG0(arg),rp); +} + + void Pdp_gr_flags(NODE arg,LIST *rp) { Obj name,value; @@ -2813,6 +3010,8 @@ void Pnd_gr_trace(NODE arg,LIST *rp) { LIST f,v; int m,homo,ac; + Obj val; + int retdp; Num nhomo; struct order_spec *ord; @@ -2836,13 +3035,17 @@ void Pnd_gr_trace(NODE arg,LIST *rp) homo = ZTOS((Q)nhomo); } else error("nd_gr_trace : invalid argument"); - nd_gr_trace(f,v,m,homo,0,ord,rp); + retdp = 0; + if ( get_opt("dp",&val) && val ) retdp = 1; + nd_gr_trace(f,v,m,homo,retdp,0,ord,rp); } void Pnd_f4_trace(NODE arg,LIST *rp) { LIST f,v; int m,homo,ac; + int retdp; + Obj val; Num nhomo; struct order_spec *ord; @@ -2866,7 +3069,9 @@ void Pnd_f4_trace(NODE arg,LIST *rp) homo = ZTOS((Q)nhomo); } else error("nd_gr_trace : invalid argument"); - nd_gr_trace(f,v,m,homo,1,ord,rp); + retdp = 0; + if ( get_opt("dp",&val) && val ) retdp = 1; + nd_gr_trace(f,v,m,homo,retdp,1,ord,rp); } void Pnd_weyl_gr(NODE arg,LIST *rp) @@ -2907,7 +3112,8 @@ void Pnd_weyl_gr(NODE arg,LIST *rp) void Pnd_weyl_gr_trace(NODE arg,LIST *rp) { LIST f,v; - int m,homo,ac; + int m,homo,ac,retdp; + Obj val; Num nhomo; struct order_spec *ord; @@ -2931,7 +3137,9 @@ void Pnd_weyl_gr_trace(NODE arg,LIST *rp) homo = ZTOS((Q)nhomo); } else error("nd_weyl_gr_trace : invalid argument"); - nd_gr_trace(f,v,m,homo,0,ord,rp); + retdp = 0; + if ( get_opt("dp",&val) && val ) retdp = 1; + nd_gr_trace(f,v,m,homo,retdp,0,ord,rp); do_weyl = 0; } @@ -3750,23 +3958,17 @@ void Pdpv_ord(NODE arg,Obj *rp) *rp = dp_current_modspec->obj; } -extern int dpm_ispot; +extern int dpm_ordtype; +extern DMMstack dmm_stack; -void Pdpm_ord(NODE arg,LIST *rp) +void set_schreyer_order(LIST n); + +void Pdpm_set_schreyer(NODE arg,LIST *rp) { - Z q; - NODE nd; - struct order_spec *spec; - - if ( arg ) { - nd = BDY((LIST)ARG0(arg)); - if ( !create_order_spec(0,(Obj)ARG1(nd),&spec) ) - error("dpm_ord : invalid order specification"); - initdpm(spec,ZTOS((Q)ARG0(nd))); + if ( argc(arg) ) { + set_schreyer_order((LIST)ARG0(arg)); } - STOZ(dpm_ispot,q); - nd = mknode(2,q,dp_current_spec->obj); - MKLIST(*rp,nd); + *rp = dmm_stack->obj; } void Pdpm_hm(NODE arg,DPM *rp) @@ -3781,20 +3983,91 @@ void Pdpm_ht(NODE arg,DPM *rp) { DPM p; - p = (DPM)ARG0(arg); asir_assert(p,O_DPM,"dp_ht"); + p = (DPM)ARG0(arg); asir_assert(p,O_DPM,"dpm_ht"); dpm_ht(p,rp); } -void Pdpm_hc(NODE arg,Obj *rp) +void dpm_rest(DPM p,DPM *r); + +void Pdpm_rest(NODE arg,DPM *rp) { + DPM p; + + p = (DPM)ARG0(arg); asir_assert(p,O_DPM,"dpm_ht"); + dpm_rest(p,rp); +} + + +void Pdpm_hp(NODE arg,Z *rp) +{ + DPM p; + int pos; + + p = (DPM)ARG0(arg); asir_assert(p,O_DPM,"dpm_ht"); + pos = BDY(p)->pos; + STOZ(pos,*rp); +} + +void dpm_shift(DPM p,int s,DPM *rp); + +void Pdpm_shift(NODE arg,DPM *rp) +{ + DPM p; + int s; + + p = (DPM)ARG0(arg); asir_assert(p,O_DPM,"dpm_shift"); + s = ZTOS((Z)ARG1(arg)); + dpm_shift(p,s,rp); +} + +void dpm_sort(DPM p,DPM *rp); + +void Pdpm_sort(NODE arg,DPM *rp) +{ + DPM p; + int s; + + p = (DPM)ARG0(arg); + if ( !p ) *rp = 0; + dpm_sort(p,rp); +} + +void dpm_split(DPM p,int s,DPM *up,DPM *lo); + +void Pdpm_split(NODE arg,LIST *rp) +{ + DPM p,up,lo; + int s; + NODE nd; + + p = (DPM)ARG0(arg); + s = ZTOS((Z)ARG1(arg)); + dpm_split(p,s,&up,&lo); + nd = mknode(2,up,lo); + MKLIST(*rp,nd); +} + + +void Pdpm_hc(NODE arg,DP *rp) +{ + DPM p; + DP d; + MP m; + asir_assert(ARG0(arg),O_DPM,"dpm_hc"); if ( !ARG0(arg) ) *rp = 0; - else - *rp = BDY((DPM)ARG0(arg))->c; + else { + p = (DPM)ARG0(arg); + NEWMP(m); + m->dl = BDY(p)->dl; + m->c = BDY(p)->c; + NEXT(m) = 0; + MKDP(NV(p),m,d); d->sugar = p->sugar; + *rp = d; + } } - void Pdpv_ht(NODE arg,LIST *rp) { NODE n; @@ -3894,6 +4167,10 @@ int dpv_hp(DPV p) case ORD_LEX: for ( i = 0; i < len; i++ ) if ( e[i] ) return i; + return -1; + break; + default: + error("dpv_hp : unsupported term ordering"); return -1; break; }