OpenXM_contrib2/asir2000/builtin/dp.c - diff

Return to dp.c CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / builtin

Diff for /OpenXM_contrib2/asir2000/builtin/dp.c between version 1.96 and 1.105

version 1.96, 2015/09/24 04:43:12

version 1.105, 2017/08/31 02:36:20

Line 44

* DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,

* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.

* $OpenXM: OpenXM_contrib2/asir2000/builtin/dp.c,v 1.95 2015/01/26 13:48:31 noro Exp $

* $OpenXM: OpenXM_contrib2/asir2000/builtin/dp.c,v 1.104 2017/03/27 09:35:13 noro Exp $

#include "ca.h"

#include "base.h"

Line 69 void Pdp_set_sugar();

void Pdp_cri1(),Pdp_cri2(),Pdp_subd(),Pdp_mod(),Pdp_red_mod(),Pdp_tdiv();

void Pdp_prim(),Pdp_red_coef(),Pdp_mag(),Pdp_set_kara(),Pdp_rat();

void Pdp_nf(),Pdp_true_nf(),Pdp_true_nf_marked(),Pdp_true_nf_marked_mod();

void Pdp_true_nf_and_quotient(),Pdp_true_nf_and_quotient_mod();

void Pdp_true_nf_and_quotient_marked(),Pdp_true_nf_and_quotient_marked_mod();

void Pdp_nf_mod(),Pdp_true_nf_mod();

void Pdp_criB(),Pdp_nelim();

void Pdp_minp(),Pdp_sp_mod();

Line 84 void Pdp_vtoe(), Pdp_etov(), Pdp_dtov(), Pdp_idiv(), P

Line 87 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 Pdp_weyl_red();

void Pdp_weyl_sp();

void Pdp_weyl_nf(),Pdp_weyl_nf_mod();

void Pdp_weyl_true_nf_and_quotient(),Pdp_weyl_true_nf_and_quotient_mod();

void Pdp_weyl_true_nf_and_quotient_marked(),Pdp_weyl_true_nf_and_quotient_marked_mod();

void Pdp_weyl_gr_main(),Pdp_weyl_gr_mod_main(),Pdp_weyl_gr_f_main();

void Pdp_weyl_f4_main(),Pdp_weyl_f4_mod_main(),Pdp_weyl_f4_f_main();

void Pdp_weyl_mul(),Pdp_weyl_mul_mod(),Pdp_weyl_act();

void Pdp_weyl_set_weight();

void Pdp_set_weight(),Pdp_set_top_weight(),Pdp_set_module_weight();

void Pdp_nf_f(),Pdp_weyl_nf_f();

void Pdpm_nf_f(),Pdpm_weyl_nf_f();

void Pdp_lnf_f();

void Pnd_gr(),Pnd_gr_trace(),Pnd_f4(),Pnd_f4_trace();

void Pnd_gr_postproc(), Pnd_weyl_gr_postproc();

Line 143 struct ftab dp_tab[] = {

Line 153 struct ftab dp_tab[] = {

/* normal form */

{"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_sp",Pdpm_sp,2},

{"dpm_weyl_sp",Pdpm_weyl_sp,2},

{"dp_true_nf",Pdp_true_nf,4},

{"dp_true_nf_mod",Pdp_true_nf_mod,5},

{"dp_true_nf_marked",Pdp_true_nf_marked,4},

{"dp_true_nf_marked_mod",Pdp_true_nf_marked_mod,5},

{"dp_true_nf_and_quotient",Pdp_true_nf_and_quotient,3},

{"dp_true_nf_and_quotient_mod",Pdp_true_nf_and_quotient_mod,4},

{"dp_true_nf_and_quotient_marked",Pdp_true_nf_and_quotient_marked,4},

{"dp_true_nf_and_quotient_marked_mod",Pdp_true_nf_and_quotient_marked_mod,5},

{"dp_true_nf_marked_mod",Pdp_true_nf_marked_mod,5},

{"dp_nf_mod",Pdp_nf_mod,5},

{"dp_true_nf_mod",Pdp_true_nf_mod,5},

{"dp_lnf_mod",Pdp_lnf_mod,3},

{"dp_nf_tab_f",Pdp_nf_tab_f,2},

{"dp_nf_tab_mod",Pdp_nf_tab_mod,3},

Line 162 struct ftab dp_tab[] = {

Line 182 struct ftab dp_tab[] = {

{"dp_gr_mod_main",Pdp_gr_mod_main,5},

{"dp_gr_f_main",Pdp_gr_f_main,4},

{"dp_gr_checklist",Pdp_gr_checklist,2},

{"nd_f4",Pnd_f4,4},

{"nd_f4",Pnd_f4,-4},

{"nd_gr",Pnd_gr,4},

{"nd_gr",Pnd_gr,-4},

{"nd_gr_trace",Pnd_gr_trace,5},

{"nd_gr_trace",Pnd_gr_trace,-5},

{"nd_f4_trace",Pnd_f4_trace,5},

{"nd_f4_trace",Pnd_f4_trace,-5},

{"nd_gr_postproc",Pnd_gr_postproc,5},

{"nd_gr_recompute_trace",Pnd_gr_recompute_trace,5},

{"nd_btog",Pnd_btog,-6},

{"nd_weyl_gr_postproc",Pnd_weyl_gr_postproc,5},

{"nd_weyl_gr",Pnd_weyl_gr,4},

{"nd_weyl_gr",Pnd_weyl_gr,-4},

{"nd_weyl_gr_trace",Pnd_weyl_gr_trace,5},

{"nd_weyl_gr_trace",Pnd_weyl_gr_trace,-5},

{"nd_nf",Pnd_nf,5},

{"nd_weyl_nf",Pnd_weyl_nf,5},

Line 193 struct ftab dp_tab[] = {

Line 213 struct ftab dp_tab[] = {

/* normal form */

{"dp_weyl_nf",Pdp_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},

{"dp_weyl_true_nf_and_quotient",Pdp_weyl_true_nf_and_quotient,3},

{"dp_weyl_true_nf_and_quotient_mod",Pdp_weyl_true_nf_and_quotient_mod,4},

{"dp_weyl_true_nf_and_quotient_marked",Pdp_weyl_true_nf_and_quotient_marked,4},

{"dp_weyl_true_nf_and_quotient_marked_mod",Pdp_weyl_true_nf_and_quotient_marked_mod,5},

/* Buchberger algorithm */

{"dp_weyl_gr_main",Pdp_weyl_gr_main,-5},

{"dp_weyl_gr_mod_main",Pdp_weyl_gr_mod_main,5},

Line 220 struct ftab dp_supp_tab[] = {

Line 247 struct ftab dp_supp_tab[] = {

/* setting flags */

{"dp_sort",Pdp_sort,1},

{"dp_ord",Pdp_ord,-1},

{"dpm_ord",Pdpm_ord,-1},

{"dpv_ord",Pdpv_ord,-2},

{"dp_set_kara",Pdp_set_kara,-1},

{"dp_nelim",Pdp_nelim,-1},

Line 240 struct ftab dp_supp_tab[] = {

Line 268 struct ftab dp_supp_tab[] = {

{"dp_rat",Pdp_rat,1},

{"dp_ltod",Pdp_ltod,-2},

{"dpm_ltod",Pdpm_ltod,2},

{"dpm_dtol",Pdpm_dtol,3},

/* criteria */

{"dp_cri1",Pdp_cri1,2},

{"dp_cri2",Pdp_cri2,2},

Line 254 struct ftab dp_supp_tab[] = {

Line 285 struct ftab dp_supp_tab[] = {

{"dpv_hm",Pdpv_hm,1},

{"dpv_ht",Pdpv_ht,1},

{"dpv_hc",Pdpv_hc,1},

{"dpm_hm",Pdpm_hm,1},

{"dpm_ht",Pdpm_ht,1},

{"dpm_hc",Pdpm_hc,1},

{"dp_rest",Pdp_rest,1},

{"dp_initial_term",Pdp_initial_term,1},

{"dp_order",Pdp_order,1},

Line 361 void Pdp_compute_essential_df(NODE arg,LIST *rp)

Line 395 void Pdp_compute_essential_df(NODE arg,LIST *rp)

MKLIST(*rp,r);

}

void Pdp_inv_or_split(arg,rp)

void Pdp_inv_or_split(NODE arg,Obj *rp)

NODE arg;

Obj *rp;

{

NODE gb,newgb;

DP f,inv;

Line 387 Obj *rp;

Line 419 Obj *rp;

}

void Pdp_sort(arg,rp)

void Pdp_sort(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

dp_sort((DP)ARG0(arg),rp);

}

void Pdp_mdtod(arg,rp)

void Pdp_mdtod(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

MP m,mr,mr0;

DP p;

Line 407 DP *rp;

Line 435 DP *rp;

*rp = 0;

else {

for ( mr0 = 0, m = BDY(p); m; m = NEXT(m) ) {

mptop(m->c,&t); NEXTMP(mr0,mr); mr->c = t; mr->dl = m->dl;

mptop((P)m->c,&t); NEXTMP(mr0,mr); mr->c = (Obj)t; mr->dl = m->dl;

}

NEXT(mr) = 0; MKDP(p->nv,mr0,*rp); (*rp)->sugar = p->sugar;

}

void Pdp_sep(arg,rp)

void Pdp_sep(NODE arg,VECT *rp)

NODE arg;

VECT *rp;

{

DP p,r;

MP m,t;

Line 442 VECT *rp;

Line 468 VECT *rp;

}

void Pdp_idiv(arg,rp)

void Pdp_idiv(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

dp_idiv((DP)ARG0(arg),(Q)ARG1(arg),rp);

}

void Pdp_cont(arg,rp)

void Pdp_cont(NODE arg,Q *rp)

NODE arg;

Q *rp;

{

dp_cont((DP)ARG0(arg),rp);

}

void Pdp_dtov(arg,rp)

void Pdp_dtov(NODE arg,VECT *rp)

NODE arg;

VECT *rp;

{

dp_dtov((DP)ARG0(arg),rp);

}

void Pdp_mbase(arg,rp)

void Pdp_mbase(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

NODE mb;

Line 474 LIST *rp;

Line 492 LIST *rp;

MKLIST(*rp,mb);

}

void Pdp_etov(arg,rp)

void Pdp_etov(NODE arg,VECT *rp)

NODE arg;

VECT *rp;

{

DP dp;

int n,i;

Line 494 VECT *rp;

Line 510 VECT *rp;

*rp = v;

}

void Pdp_vtoe(arg,rp)

void Pdp_vtoe(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

DP dp;

DL dl;

Line 513 DP *rp;

Line 527 DP *rp;

d[i] = QTOS((Q)(v->body[i])); td += MUL_WEIGHT(d[i],i);

}

dl->td = td;

NEWMP(m); m->dl = dl; m->c = (P)ONE; NEXT(m) = 0;

NEWMP(m); m->dl = dl; m->c = (Obj)ONE; NEXT(m) = 0;

MKDP(n,m,dp); dp->sugar = td;

*rp = dp;

}

void Pdp_lnf_mod(arg,rp)

void Pdp_lnf_mod(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

DP r1,r2;

NODE b,g,n;

Line 537 LIST *rp;

Line 549 LIST *rp;

NEXT(NEXT(n)) = 0; MKLIST(*rp,n);

}

void Pdp_lnf_f(arg,rp)

void Pdp_lnf_f(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

DP r1,r2;

NODE b,g,n;

Line 553 LIST *rp;

Line 563 LIST *rp;

NEXT(NEXT(n)) = 0; MKLIST(*rp,n);

}

void Pdp_nf_tab_mod(arg,rp)

void Pdp_nf_tab_mod(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

asir_assert(ARG0(arg),O_DP,"dp_nf_tab_mod");

asir_assert(ARG1(arg),O_VECT,"dp_nf_tab_mod");

Line 564 DP *rp;

Line 572 DP *rp;

QTOS((Q)ARG2(arg)),rp);

}

void Pdp_nf_tab_f(arg,rp)

void Pdp_nf_tab_f(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

asir_assert(ARG0(arg),O_DP,"dp_nf_tab_f");

asir_assert(ARG1(arg),O_VECT,"dp_nf_tab_f");

dp_nf_tab_f((DP)ARG0(arg),(LIST *)BDY((VECT)ARG1(arg)),rp);

}

void Pdp_ord(arg,rp)

void Pdp_ord(NODE arg,Obj *rp)

NODE arg;

Obj *rp;

{

struct order_spec *spec;

LIST v;

Line 595 Obj *rp;

Line 599 Obj *rp;

}

void Pdp_ptod(arg,rp)

void Pdp_ptod(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

P p;

NODE n;

Line 636 DP *rp;

Line 638 DP *rp;

ptod(CO,vl,p,rp);

}

void Phomogenize(arg,rp)

void Phomogenize(NODE arg,Obj *rp)

NODE arg;

P *rp;

{

P p;

DP d,h;

Line 673 P *rp;

dtop(CO,vl,h,rp);

}

void Pdp_ltod(arg,rp)

void Pdp_ltod(NODE arg,DPV *rp)

NODE arg;

DPV *rp;

{

NODE n;

VL vl,tvl;

Line 722 DPV *rp;

Line 720 DPV *rp;

MKDPV(len,e,*rp);

}

void Pdp_dtop(arg,rp)

void Pdpm_ltod(NODE arg,DPM *rp)

NODE arg;

P *rp;

{

NODE n;

VL vl,tvl;

LIST f,v;

int i,len;

NODE nd;

NODE t;

DP d;

DPM s,u,w;

f = (LIST)ARG0(arg);

v = (LIST)ARG1(arg);

for ( vl = 0, n = BDY(v); n; n = NEXT(n) ) {

if ( !vl ) {

NEWVL(vl); tvl = vl;

} else {

NEWVL(NEXT(tvl)); tvl = NEXT(tvl);

}

VR(tvl) = VR((P)BDY(n));

}

if ( vl )

NEXT(tvl) = 0;

nd = BDY(f);

len = length(nd);

for ( i = 0, 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;

}

*rp = s;

}

void Pdpm_dtol(NODE arg,LIST *rp)

{

DPM a;

NODE nd,nd1;

VL vl,tvl;

int n,len,i,pos,nv;

MP *w;

DMM t;

DMM *wa;

MP m;

DP u;

Obj s;

a = (DPM)ARG0(arg);

for ( vl = 0, nd = BDY((LIST)ARG1(arg)), nv = 0; nd; nd = NEXT(nd), nv++ ) {

if ( !vl ) {

NEWVL(vl); tvl = vl;

} else {

NEWVL(NEXT(tvl)); tvl = NEXT(tvl);

}

VR(tvl) = VR((P)BDY(nd));

}

if ( vl )

NEXT(tvl) = 0;

n = QTOS((Q)ARG2(arg));

w = (MP *)CALLOC(n,sizeof(MP));

for ( t = BDY(a), len = 0; t; t = NEXT(t) ) len++;

wa = (DMM *)MALLOC(len*sizeof(DMM));

for ( t = BDY(a), i = 0; t; t = NEXT(t), i++ ) wa[i] = t;

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;

}

nd = 0;

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

MKDP(nv,w[i],u); u->sugar = a->sugar; /* XXX */

dtop(CO,vl,u,&s);

MKNODE(nd1,s,nd); nd = nd1;

}

MKLIST(*rp,nd);

}

void Pdp_dtop(NODE arg,Obj *rp)

{

NODE n;

VL vl,tvl;

asir_assert(ARG0(arg),O_DP,"dp_dtop");

asir_assert(ARG1(arg),O_LIST,"dp_dtop");

for ( vl = 0, n = BDY((LIST)ARG1(arg)); n; n = NEXT(n) ) {

Line 746 P *rp;

Line 820 P *rp;

extern LIST Dist;

void Pdp_ptozp(arg,rp)

void Pdp_ptozp(NODE arg,Obj *rp)

NODE arg;

Obj *rp;

{

Q t;

NODE tt,p;

Line 786 Obj *rp;

Line 858 Obj *rp;

*rp = (Obj)pp;

}

void Pdp_ptozp2(arg,rp)

void Pdp_ptozp2(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

DP p0,p1,h,r;

NODE n0;

Line 803 LIST *rp;

Line 873 LIST *rp;

MKLIST(*rp,n0);

}

void Pdp_prim(arg,rp)

void Pdp_prim(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

DP t;

Line 813 DP *rp;

Line 881 DP *rp;

dp_prim((DP)ARG0(arg),&t); dp_ptozp(t,rp);

}

void Pdp_mod(arg,rp)

void Pdp_mod(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

DP p;

int mod;

Line 829 DP *rp;

Line 895 DP *rp;

dp_mod(p,mod,subst,rp);

}

void Pdp_rat(arg,rp)

void Pdp_rat(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

asir_assert(ARG0(arg),O_DP,"dp_rat");

dp_rat((DP)ARG0(arg),rp);

Line 839 DP *rp;

Line 903 DP *rp;

extern int DP_Multiple;

void Pdp_nf(arg,rp)

void Pdp_nf(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

NODE b;

DP *ps;

Line 861 DP *rp;

Line 923 DP *rp;

dp_nf_z(b,g,ps,full,DP_Multiple,rp);

}

void Pdp_weyl_nf(arg,rp)

void Pdp_weyl_nf(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

NODE b;

DP *ps;

Line 884 DP *rp;

Line 944 DP *rp;

do_weyl = 0;

}

void Pdpm_nf(NODE arg,DP *rp)

{

NODE b;

DPM *ps;

DPM g;

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

dpm_nf_z(b,g,ps,full,DP_Multiple,rp);

}

void Pdpm_weyl_nf(NODE arg,DPM *rp)

{

NODE b;

DPM *ps;

DPM g;

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

dpm_nf_z(b,g,ps,full,DP_Multiple,rp);

do_weyl = 0;

}

/* nf computation using field operations */

void Pdp_nf_f(arg,rp)

void Pdp_nf_f(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

NODE b;

DP *ps;

Line 908 DP *rp;

Line 1007 DP *rp;

dp_nf_f(b,g,ps,full,rp);

}

void Pdp_weyl_nf_f(arg,rp)

void Pdp_weyl_nf_f(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

NODE b;

DP *ps;

Line 931 DP *rp;

Line 1028 DP *rp;

do_weyl = 0;

}

void Pdp_nf_mod(arg,rp)

void Pdpm_nf_f(NODE arg,DPM *rp)

NODE arg;

DP *rp;

{

NODE b;

DPM *ps;

DPM g;

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

dpm_nf_f(b,g,ps,full,rp);

}

void Pdpm_weyl_nf_f(NODE arg,DPM *rp)

{

NODE b;

DPM *ps;

DPM g;

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

do_weyl = 1;

dpm_nf_f(b,g,ps,full,rp);

do_weyl = 0;

}

void Pdp_nf_mod(NODE arg,DP *rp)

{

NODE b;

DP g;

DP *ps;

int mod,full,ac;

Line 962 DP *rp;

Line 1098 DP *rp;

dp_nf_mod(n0,g,ps,mod,full,rp);

}

void Pdp_true_nf(arg,rp)

void Pdp_true_nf(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

NODE b,n;

DP *ps;

Line 990 LIST *rp;

Line 1124 LIST *rp;

NEXT(NEXT(n)) = 0; MKLIST(*rp,n);

}

void Pdp_true_nf_marked(arg,rp)

DP *dp_true_nf_and_quotient_marked(NODE b,DP g,DP *ps,DP *hps,DP *rp,P *dnp);

NODE arg;

LIST *rp;

void Pdp_true_nf_and_quotient_marked(NODE arg,LIST *rp)

{

NODE b,n;

DP *ps,*hps;

DP g;

DP nm;

Q cont;

VECT quo;

P dn;

int full;

do_weyl = 0; dp_fcoeffs = 0;

asir_assert(ARG0(arg),O_LIST,"dp_true_nf_marked");

asir_assert(ARG0(arg),O_LIST,"dp_true_nf_and_quotient_marked");

asir_assert(ARG1(arg),O_DP,"dp_true_nf_marked");

asir_assert(ARG1(arg),O_DP,"dp_true_nf_and_quotient_marked");

asir_assert(ARG2(arg),O_VECT,"dp_true_nf_marked");

asir_assert(ARG2(arg),O_VECT,"dp_true_nf_and_quotient_marked");

asir_assert(ARG3(arg),O_VECT,"dp_true_nf_marked");

asir_assert(ARG3(arg),O_VECT,"dp_true_nf_and_quotient_marked");

if ( !(g = (DP)ARG1(arg)) ) {

nm = 0; dn = (P)ONE;

} else {

b = BDY((LIST)ARG0(arg));

ps = (DP *)BDY((VECT)ARG2(arg));

hps = (DP *)BDY((VECT)ARG3(arg));

dp_true_nf_marked(b,g,ps,hps,&nm,&cont,&dn);

NEWVECT(quo); quo->len = ((VECT)ARG2(arg))->len;

quo->body = (pointer *)dp_true_nf_and_quotient_marked(b,g,ps,hps,&nm,&dn);

}

n = mknode(3,nm,cont,dn);

n = mknode(3,nm,dn,quo);

MKLIST(*rp,n);

}

DP *dp_true_nf_and_quotient_marked (NODE b,DP g,DP *ps,DP *hps,DP *rp,P *dnp);

void Pdp_true_nf_and_quotient(NODE arg,LIST *rp)

{

NODE narg = mknode(4,ARG0(arg),ARG1(arg),ARG2(arg),ARG2(arg));

Pdp_true_nf_and_quotient_marked(narg,rp);

}

void Pdp_true_nf_and_quotient_marked(arg,rp)

NODE arg;

DP *dp_true_nf_and_quotient_marked_mod (NODE b,DP g,DP *ps,DP *hps,int mod,DP *rp,P *dnp);

LIST *rp;

void Pdp_true_nf_and_quotient_marked_mod(NODE arg,LIST *rp)

{

NODE b,n;

DP *ps,*hps;

Line 1031 LIST *rp;

Line 1171 LIST *rp;

DP nm;

VECT quo;

P dn;

int full;

int full,mod;

do_weyl = 0; dp_fcoeffs = 0;

asir_assert(ARG0(arg),O_LIST,"dp_true_nf_and_quotient_marked");

asir_assert(ARG0(arg),O_LIST,"dp_true_nf_and_quotient_marked_mod");

asir_assert(ARG1(arg),O_DP,"dp_true_nf_and_quotient_marked");

asir_assert(ARG1(arg),O_DP,"dp_true_nf_and_quotient_marked_mod");

asir_assert(ARG2(arg),O_VECT,"dp_true_nf_and_quotient_marked");

asir_assert(ARG2(arg),O_VECT,"dp_true_nf_and_quotient_marked_mod");

asir_assert(ARG3(arg),O_VECT,"dp_true_nf_and_quotient_marked");

asir_assert(ARG3(arg),O_VECT,"dp_true_nf_and_quotient_marked_mod");

asir_assert(ARG4(arg),O_N,"dp_true_nf_and_quotient_marked_mod");

if ( !(g = (DP)ARG1(arg)) ) {

nm = 0; dn = (P)ONE;

} else {

b = BDY((LIST)ARG0(arg));

ps = (DP *)BDY((VECT)ARG2(arg));

hps = (DP *)BDY((VECT)ARG3(arg));

mod = QTOS((Q)ARG4(arg));

NEWVECT(quo); quo->len = ((VECT)ARG2(arg))->len;

quo->body = (pointer *)dp_true_nf_and_quotient_marked(b,g,ps,hps,&nm,&dn);

quo->body = (pointer *)dp_true_nf_and_quotient_marked_mod(b,g,ps,hps,mod,&nm,&dn);

}

n = mknode(3,nm,dn,quo);

MKLIST(*rp,n);

}

DP *dp_true_nf_and_quotient_marked_mod (NODE b,DP g,DP *ps,DP *hps,int mod,DP *rp,P *dnp);

void Pdp_true_nf_and_quotient_mod(NODE arg,LIST *rp)

{

NODE narg = mknode(5,ARG0(arg),ARG1(arg),ARG2(arg),ARG2(arg),ARG3(arg));

Pdp_true_nf_and_quotient_marked_mod(narg,rp);

}

void Pdp_true_nf_and_quotient_marked_mod(arg,rp)

void Pdp_true_nf_marked(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

NODE b,n;

DP *ps,*hps;

DP g;

DP nm;

VECT quo;

Q cont;

P dn;

int full,mod;

int full;

do_weyl = 0; dp_fcoeffs = 0;

asir_assert(ARG0(arg),O_LIST,"dp_true_nf_and_quotient_marked_mod");

asir_assert(ARG0(arg),O_LIST,"dp_true_nf_marked");

asir_assert(ARG1(arg),O_DP,"dp_true_nf_and_quotient_marked_mod");

asir_assert(ARG1(arg),O_DP,"dp_true_nf_marked");

asir_assert(ARG2(arg),O_VECT,"dp_true_nf_and_quotient_marked_mod");

asir_assert(ARG2(arg),O_VECT,"dp_true_nf_marked");

asir_assert(ARG3(arg),O_VECT,"dp_true_nf_and_quotient_marked_mod");

asir_assert(ARG3(arg),O_VECT,"dp_true_nf_marked");

asir_assert(ARG4(arg),O_N,"dp_true_nf_and_quotient_marked_mod");

if ( !(g = (DP)ARG1(arg)) ) {

nm = 0; dn = (P)ONE;

} else {

b = BDY((LIST)ARG0(arg));

ps = (DP *)BDY((VECT)ARG2(arg));

hps = (DP *)BDY((VECT)ARG3(arg));

mod = QTOS((Q)ARG4(arg));

dp_true_nf_marked(b,g,ps,hps,&nm,(P *)&cont,(P *)&dn);

NEWVECT(quo); quo->len = ((VECT)ARG2(arg))->len;

quo->body = (pointer *)dp_true_nf_and_quotient_marked_mod(b,g,ps,hps,mod,&nm,&dn);

}

n = mknode(3,nm,dn,quo);

n = mknode(3,nm,cont,dn);

MKLIST(*rp,n);

}

void Pdp_true_nf_marked_mod(arg,rp)

void Pdp_true_nf_marked_mod(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

NODE b,n;

DP *ps,*hps;

Line 1115 LIST *rp;

Line 1254 LIST *rp;

MKLIST(*rp,n);

}

void Pdp_weyl_nf_mod(arg,rp)

void Pdp_weyl_nf_mod(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

NODE b;

DP g;

Line 1147 DP *rp;

Line 1284 DP *rp;

do_weyl = 0;

}

void Pdp_true_nf_mod(arg,rp)

void Pdp_true_nf_mod(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

NODE b;

DP g,nm;

Line 1176 LIST *rp;

Line 1311 LIST *rp;

NEXT(NEXT(n)) = 0; MKLIST(*rp,n);

}

void Pdp_tdiv(arg,rp)

void Pdp_weyl_true_nf_and_quotient_marked(NODE arg,LIST *rp)

NODE arg;

DP *rp;

{

NODE b,n;

DP *ps,*hps;

DP g;

DP nm;

VECT quo;

P dn;

int full;

do_weyl = 1; dp_fcoeffs = 0;

asir_assert(ARG0(arg),O_LIST,"dp_weyl_true_nf_and_quotient_marked");

asir_assert(ARG1(arg),O_DP,"dp_weyl_true_nf_and_quotient_marked");

asir_assert(ARG2(arg),O_VECT,"dp_weyl_true_nf_and_quotient_marked");

asir_assert(ARG3(arg),O_VECT,"dp_weyl_true_nf_and_quotient_marked");

if ( !(g = (DP)ARG1(arg)) ) {

nm = 0; dn = (P)ONE;

} else {

b = BDY((LIST)ARG0(arg));

ps = (DP *)BDY((VECT)ARG2(arg));

hps = (DP *)BDY((VECT)ARG3(arg));

NEWVECT(quo); quo->len = ((VECT)ARG2(arg))->len;

quo->body = (pointer *)dp_true_nf_and_quotient_marked(b,g,ps,hps,&nm,&dn);

}

n = mknode(3,nm,dn,quo);

MKLIST(*rp,n);

}

void Pdp_weyl_true_nf_and_quotient(NODE arg,LIST *rp)

{

NODE narg = mknode(4,ARG0(arg),ARG1(arg),ARG2(arg),ARG2(arg));

Pdp_weyl_true_nf_and_quotient_marked(narg,rp);

}

void Pdp_weyl_true_nf_and_quotient_marked_mod(NODE arg,LIST *rp)

{

NODE b,n;

DP *ps,*hps;

DP g;

DP nm;

VECT quo;

P dn;

int full,mod;

do_weyl = 1; dp_fcoeffs = 0;

asir_assert(ARG0(arg),O_LIST,"dp_weyl_true_nf_and_quotient_marked_mod");

asir_assert(ARG1(arg),O_DP,"dp_weyl_true_nf_and_quotient_marked_mod");

asir_assert(ARG2(arg),O_VECT,"dp_weyl_true_nf_and_quotient_marked_mod");

asir_assert(ARG3(arg),O_VECT,"dp_weyl_true_nf_and_quotient_marked_mod");

asir_assert(ARG4(arg),O_N,"dp_weyl_true_nf_and_quotient_marked_mod");

if ( !(g = (DP)ARG1(arg)) ) {

nm = 0; dn = (P)ONE;

} else {

b = BDY((LIST)ARG0(arg));

ps = (DP *)BDY((VECT)ARG2(arg));

hps = (DP *)BDY((VECT)ARG3(arg));

mod = QTOS((Q)ARG4(arg));

NEWVECT(quo); quo->len = ((VECT)ARG2(arg))->len;

quo->body = (pointer *)dp_true_nf_and_quotient_marked_mod(b,g,ps,hps,mod,&nm,&dn);

}

n = mknode(3,nm,dn,quo);

MKLIST(*rp,n);

}

void Pdp_weyl_true_nf_and_quotient_mod(NODE arg,LIST *rp)

{

NODE narg = mknode(5,ARG0(arg),ARG1(arg),ARG2(arg),ARG2(arg),ARG3(arg));

Pdp_weyl_true_nf_and_quotient_marked_mod(narg,rp);

}

void Pdp_tdiv(NODE arg,DP *rp)

{

MP m,mr,mr0;

DP p;

Q c;

Line 1198 DP *rp;

Line 1403 DP *rp;

*rp = 0; return;

} else {

NEXTMP(mr0,mr); NTOQ(q,SGN((Q)m->c)*sgn,c);

mr->c = (P)c; mr->dl = m->dl;

mr->c = (Obj)c; mr->dl = m->dl;

}

NEXT(mr) = 0; MKDP(p->nv,mr0,*rp); (*rp)->sugar = p->sugar;

}

void Pdp_red_coef(arg,rp)

void Pdp_red_coef(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

MP m,mr,mr0;

P q,r;

Line 1221 DP *rp;

Line 1424 DP *rp;

*rp = 0;

else {

for ( mr0 = 0, m = BDY(p); m; m = NEXT(m) ) {

divsrp(CO,m->c,mod,&q,&r);

divsrp(CO,(P)m->c,mod,&q,&r);

if ( r ) {

NEXTMP(mr0,mr); mr->c = r; mr->dl = m->dl;

NEXTMP(mr0,mr); mr->c = (Obj)r; mr->dl = m->dl;

}

if ( mr0 ) {

Line 1233 DP *rp;

Line 1436 DP *rp;

}

void Pdp_redble(arg,rp)

void Pdp_redble(NODE arg,Q *rp)

NODE arg;

Q *rp;

{

asir_assert(ARG0(arg),O_DP,"dp_redble");

asir_assert(ARG1(arg),O_DP,"dp_redble");

Line 1245 Q *rp;

Line 1446 Q *rp;

*rp = 0;

}

void Pdp_red_mod(arg,rp)

void Pdp_red_mod(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

DP h,r;

P dmy;

Line 1265 LIST *rp;

Line 1464 LIST *rp;

NEXT(NEXT(n)) = 0; MKLIST(*rp,n);

}

void Pdp_subd(arg,rp)

void Pdp_subd(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

DP p1,p2;

Line 1277 DP *rp;

Line 1474 DP *rp;

dp_subd(p1,p2,rp);

}

void Pdp_symb_add(arg,rp)

void Pdp_symb_add(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

DP p1,p2,r;

NODE s0;

Line 1296 DP *rp;

Line 1491 DP *rp;

nv = p1->nv;

s0 = symb_merge(dp_dllist(p1),dp_dllist(p2),nv);

for ( mp0 = 0; s0; s0 = NEXT(s0) ) {

NEXTMP(mp0,mp); mp->dl = (DL)BDY(s0); mp->c = (P)ONE;

NEXTMP(mp0,mp); mp->dl = (DL)BDY(s0); mp->c = (Obj)ONE;

}

NEXT(mp) = 0;

MKDP(nv,mp0,r); r->sugar = MAX(p1->sugar,p2->sugar);

*rp = r;

}

void Pdp_mul_trunc(arg,rp)

void Pdp_mul_trunc(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

DP p1,p2,p;

Line 1316 DP *rp;

Line 1509 DP *rp;

comm_muld_trunc(CO,p1,p2,BDY(p)->dl,rp);

}

void Pdp_quo(arg,rp)

void Pdp_quo(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

DP p1,p2;

Line 1328 DP *rp;

Line 1519 DP *rp;

comm_quod(CO,p1,p2,rp);

}

void Pdp_weyl_mul(arg,rp)

void Pdp_weyl_mul(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

DP p1,p2;

Line 1341 DP *rp;

Line 1530 DP *rp;

do_weyl = 0;

}

void Pdp_weyl_act(arg,rp)

void Pdp_weyl_act(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

DP p1,p2;

Line 1353 DP *rp;

Line 1540 DP *rp;

}

void Pdp_weyl_mul_mod(arg,rp)

void Pdp_weyl_mul_mod(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

DP p1,p2;

Q m;

Line 1369 DP *rp;

Line 1554 DP *rp;

do_weyl = 0;

}

void Pdp_red(arg,rp)

void Pdp_red(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

NODE n;

DP head,rest,dmy1;

Line 1387 LIST *rp;

Line 1570 LIST *rp;

NEXT(NEXT(n)) = 0; MKLIST(*rp,n);

}

void Pdp_weyl_red(arg,rp)

void Pdp_weyl_red(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

NODE n;

DP head,rest,dmy1;

Line 1406 LIST *rp;

Line 1587 LIST *rp;

NEXT(NEXT(n)) = 0; MKLIST(*rp,n);

}

void Pdp_sp(arg,rp)

void Pdp_sp(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

DP p1,p2;

Line 1418 DP *rp;

Line 1597 DP *rp;

dp_sp(p1,p2,rp);

}

void Pdp_weyl_sp(arg,rp)

void Pdp_weyl_sp(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

DP p1,p2;

p1 = (DP)ARG0(arg); p2 = (DP)ARG1(arg);

asir_assert(p1,O_DP,"dp_weyl_sp"); asir_assert(p2,O_DP,"dp_sp");

asir_assert(p1,O_DP,"dp_weyl_sp"); asir_assert(p2,O_DP,"dp_weyl_sp");

do_weyl = 1;

dp_sp(p1,p2,rp);

do_weyl = 0;

}

void Pdp_sp_mod(arg,rp)

void Pdpm_sp(NODE arg,DPM *rp)

NODE arg;

DP *rp;

{

DPM p1,p2;

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

}

void Pdpm_weyl_sp(NODE arg,DPM *rp)

{

DPM p1,p2;

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

do_weyl = 0;

}

void Pdp_sp_mod(NODE arg,DP *rp)

{

DP p1,p2;

int mod;

Line 1446 DP *rp;

Line 1642 DP *rp;

dp_sp_mod(p1,p2,mod,rp);

}

void Pdp_lcm(arg,rp)

void Pdp_lcm(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

int i,n,td;

DL d1,d2,d;

Line 1463 DP *rp;

Line 1657 DP *rp;

d->d[i] = MAX(d1->d[i],d2->d[i]); td += MUL_WEIGHT(d->d[i],i);

}

d->td = td;

NEWMP(m); m->dl = d; m->c = (P)ONE; NEXT(m) = 0;

NEWMP(m); m->dl = d; m->c = (Obj)ONE; NEXT(m) = 0;

MKDP(n,m,*rp); (*rp)->sugar = td; /* XXX */

}

void Pdp_hm(arg,rp)

void Pdp_hm(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

DP p;

Line 1477 DP *rp;

Line 1669 DP *rp;

dp_hm(p,rp);

}

void Pdp_ht(arg,rp)

void Pdp_ht(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

DP p;

MP m,mr;

Line 1488 DP *rp;

Line 1678 DP *rp;

dp_ht(p,rp);

}

void Pdp_hc(arg,rp)

void Pdp_hc(NODE arg,Obj *rp)

NODE arg;

P *rp;

{

asir_assert(ARG0(arg),O_DP,"dp_hc");

if ( !ARG0(arg) )

Line 1499 P *rp;

Line 1687 P *rp;

*rp = BDY((DP)ARG0(arg))->c;

}

void Pdp_rest(arg,rp)

void Pdp_rest(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

asir_assert(ARG0(arg),O_DP,"dp_rest");

if ( !ARG0(arg) )

Line 1510 DP *rp;

Line 1696 DP *rp;

dp_rest((DP)ARG0(arg),rp);

}

void Pdp_td(arg,rp)

void Pdp_td(NODE arg,Q *rp)

NODE arg;

Q *rp;

{

DP p;

Line 1523 Q *rp;

Line 1707 Q *rp;

STOQ(BDY(p)->dl->td,*rp);

}

void Pdp_sugar(arg,rp)

void Pdp_sugar(NODE arg,Q *rp)

NODE arg;

Q *rp;

{

DP p;

Line 1536 Q *rp;

Line 1718 Q *rp;

STOQ(p->sugar,*rp);

}

void Pdp_initial_term(arg,rp)

void Pdp_initial_term(NODE arg,Obj *rp)

NODE arg;

Obj *rp;

{

struct order_spec *ord;

Num homo;

Line 1565 Obj *rp;

Line 1745 Obj *rp;

*rp = (Obj)initiallist;

}

void Pdp_order(arg,rp)

void Pdp_order(NODE arg,Obj *rp)

NODE arg;

Obj *rp;

{

struct order_spec *ord;

Num homo;

Line 1594 Obj *rp;

Line 1772 Obj *rp;

*rp = (Obj)ordlist;

}

void Pdp_set_sugar(arg,rp)

void Pdp_set_sugar(NODE arg,Q *rp)

NODE arg;

Q *rp;

{

DP p;

Q q;

Line 1615 Q *rp;

Line 1791 Q *rp;

*rp = 0;

}

void Pdp_cri1(arg,rp)

void Pdp_cri1(NODE arg,Q *rp)

NODE arg;

Q *rp;

{

DP p1,p2;

int *d1,*d2;

Line 1632 Q *rp;

Line 1806 Q *rp;

*rp = i == n ? ONE : 0;

}

void Pdp_cri2(arg,rp)

void Pdp_cri2(NODE arg,Q *rp)

NODE arg;

Q *rp;

{

DP p1,p2;

int *d1,*d2;

Line 1649 Q *rp;

Line 1821 Q *rp;

*rp = i == n ? ONE : 0;

}

void Pdp_minp(arg,rp)

void Pdp_minp(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

NODE tn,tn1,d,dd,dd0,p,tp;

LIST l,minp;

Line 1696 LIST *rp;

Line 1866 LIST *rp;

MKLIST(l,dd0); MKNODE(tn,l,0); MKNODE(tn1,minp,tn); MKLIST(*rp,tn1);

}

void Pdp_criB(arg,rp)

void Pdp_criB(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

NODE d,ij,dd,ddd;

int i,j,s,n;

Line 1734 LIST *rp;

Line 1902 LIST *rp;

}

void Pdp_nelim(arg,rp)

void Pdp_nelim(NODE arg,Q *rp)

NODE arg;

Q *rp;

{

if ( arg ) {

asir_assert(ARG0(arg),O_N,"dp_nelim");

Line 1745 Q *rp;

Line 1911 Q *rp;

STOQ(dp_nelim,*rp);

}

void Pdp_mag(arg,rp)

void Pdp_mag(NODE arg,Q *rp)

NODE arg;

Q *rp;

{

DP p;

int s;

Line 1759 Q *rp;

Line 1923 Q *rp;

*rp = 0;

else {

for ( s = 0, m = BDY(p); m; m = NEXT(m) )

s += p_mag(m->c);

s += p_mag((P)m->c);

STOQ(s,*rp);

}

extern int kara_mag;

void Pdp_set_kara(arg,rp)

void Pdp_set_kara(NODE arg,Q *rp)

NODE arg;

Q *rp;

{

if ( arg ) {

asir_assert(ARG0(arg),O_N,"dp_set_kara");

Line 1777 Q *rp;

Line 1939 Q *rp;

STOQ(kara_mag,*rp);

}

void Pdp_homo(arg,rp)

void Pdp_homo(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

asir_assert(ARG0(arg),O_DP,"dp_homo");

dp_homo((DP)ARG0(arg),rp);

}

void Pdp_dehomo(arg,rp)

void Pdp_dehomo(NODE arg,DP *rp)

NODE arg;

DP *rp;

{

asir_assert(ARG0(arg),O_DP,"dp_dehomo");

dp_dehomo((DP)ARG0(arg),rp);

}

void Pdp_gr_flags(arg,rp)

void Pdp_gr_flags(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

Obj name,value;

NODE n;

Line 1818 LIST *rp;

Line 1974 LIST *rp;

extern int DP_Print, DP_PrintShort;

void Pdp_gr_print(arg,rp)

void Pdp_gr_print(NODE arg,Q *rp)

NODE arg;

Q *rp;

{

Q q;

int s;

Line 1949 void parse_gr_option(LIST f,NODE opt,LIST *v,Num *homo

Line 2103 void parse_gr_option(LIST f,NODE opt,LIST *v,Num *homo

else

*modular = QTOS(m);

modular_is_set = 1;

} else if ( !strcmp(key,"dp") ) {

/* XXX : ignore */

} else

error("parse_gr_option : not implemented");

}

Line 1957 void parse_gr_option(LIST f,NODE opt,LIST *v,Num *homo

Line 2113 void parse_gr_option(LIST f,NODE opt,LIST *v,Num *homo

if ( !homo_is_set ) *homo = 0;

}

void Pdp_gr_main(arg,rp)

void Pdp_gr_main(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

VL vl;

Line 1998 LIST *rp;

Line 2152 LIST *rp;

dp_gr_main(f,v,homo,modular,0,ord,rp);

}

void Pdp_interreduce(arg,rp)

void Pdp_interreduce(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

VL vl;

Line 2022 LIST *rp;

Line 2174 LIST *rp;

dp_interreduce(f,v,0,ord,rp);

}

void Pdp_gr_f_main(arg,rp)

void Pdp_gr_f_main(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

Num homo;

Line 2067 LIST *rp;

Line 2217 LIST *rp;

dp_gr_main(f,v,homo,m?1:0,field,ord,rp);

}

void Pdp_f4_main(arg,rp)

void Pdp_f4_main(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

struct order_spec *ord;

Line 2088 LIST *rp;

Line 2236 LIST *rp;

/* dp_gr_checklist(list of dp) */

void Pdp_gr_checklist(arg,rp)

void Pdp_gr_checklist(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

VECT g;

LIST dp;

Line 2106 LIST *rp;

Line 2252 LIST *rp;

MKLIST(*rp,r);

}

void Pdp_f4_mod_main(arg,rp)

void Pdp_f4_mod_main(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

int m;

Line 2129 LIST *rp;

Line 2273 LIST *rp;

dp_f4_mod_main(f,v,m,ord,rp);

}

void Pdp_gr_mod_main(arg,rp)

void Pdp_gr_mod_main(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

Num homo;

Line 2155 LIST *rp;

Line 2297 LIST *rp;

dp_gr_mod_main(f,v,homo,m,ord,rp);

}

void Pnd_f4(arg,rp)

void Pnd_f4(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

int m,homo,retdp;

int m,homo,retdp,ac;

Obj val;

Q mq;

Num nhomo;

NODE node;

struct order_spec *ord;

do_weyl = 0;

nd_rref2 = 0;

asir_assert(ARG0(arg),O_LIST,"nd_f4");

retdp = 0;

asir_assert(ARG1(arg),O_LIST,"nd_f4");

if ( (ac = argc(arg)) == 4 ) {

asir_assert(ARG2(arg),O_N,"nd_f4");

asir_assert(ARG0(arg),O_LIST,"nd_f4");

f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);

asir_assert(ARG1(arg),O_LIST,"nd_f4");

f = remove_zero_from_list(f);

asir_assert(ARG2(arg),O_N,"nd_f4");

if ( !BDY(f) ) {

f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);

*rp = f; return;

f = remove_zero_from_list(f);

}

if ( !BDY(f) ) {

m = QTOS((Q)ARG2(arg));

*rp = f; return;

create_order_spec(0,ARG3(arg),&ord);

}

homo = retdp = 0;

mq = (Q)ARG2(arg);

if ( get_opt("homo",&val) && val ) homo = 1;

if ( mq && (PL(NM(mq)) > 1 || BD(NM(mq))[0] >= (1<<30)) ) {

if ( get_opt("dp",&val) && val ) retdp = 1;

node = mknode(1,mq);

if ( get_opt("rref2",&val) && val ) nd_rref2 = 1;

Psetmod_ff(node,&val);

m = -2;

} else

m = QTOS(mq);

create_order_spec(0,ARG3(arg),&ord);

homo = 0;

if ( get_opt("homo",&val) && val ) homo = 1;

if ( get_opt("dp",&val) && val ) retdp = 1;

if ( get_opt("rref2",&val) && val ) nd_rref2 = 1;

} else if ( ac == 1 ) {

f = (LIST)ARG0(arg);

parse_gr_option(f,current_option,&v,&nhomo,&m,&ord);

homo = QTOS((Q)nhomo);

if ( get_opt("dp",&val) && val ) retdp = 1;

if ( get_opt("rref2",&val) && val ) nd_rref2 = 1;

} else

error("nd_f4 : invalid argument");

nd_gr(f,v,m,homo,retdp,1,ord,rp);

}

void Pnd_gr(arg,rp)

void Pnd_gr(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

int m,homo,retdp;

int m,homo,retdp,ac;

Obj val;

Q mq;

Num nhomo;

NODE node;

struct order_spec *ord;

do_weyl = 0;

asir_assert(ARG0(arg),O_LIST,"nd_gr");

retdp = 0;

asir_assert(ARG1(arg),O_LIST,"nd_gr");

if ( (ac=argc(arg)) == 4 ) {

asir_assert(ARG2(arg),O_N,"nd_gr");

asir_assert(ARG0(arg),O_LIST,"nd_gr");

f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);

asir_assert(ARG1(arg),O_LIST,"nd_gr");

f = remove_zero_from_list(f);

asir_assert(ARG2(arg),O_N,"nd_gr");

if ( !BDY(f) ) {

f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);

*rp = f; return;

f = remove_zero_from_list(f);

}

if ( !BDY(f) ) {

m = QTOS((Q)ARG2(arg));

*rp = f; return;

create_order_spec(0,ARG3(arg),&ord);

}

homo = retdp = 0;

mq = (Q)ARG2(arg);

if ( get_opt("homo",&val) && val ) homo = 1;

if ( mq && (PL(NM(mq)) > 1 || BD(NM(mq))[0] >= (1<<30)) ) {

if ( get_opt("dp",&val) && val ) retdp = 1;

node = mknode(1,mq);

Psetmod_ff(node,&val);

m = -2;

} else

m = QTOS(mq);

create_order_spec(0,ARG3(arg),&ord);

homo = 0;

if ( get_opt("homo",&val) && val ) homo = 1;

if ( get_opt("dp",&val) && val ) retdp = 1;

} else if ( ac == 1 ) {

f = (LIST)ARG0(arg);

parse_gr_option(f,current_option,&v,&nhomo,&m,&ord);

homo = QTOS((Q)nhomo);

if ( get_opt("dp",&val) && val ) retdp = 1;

} else

error("nd_gr : invalid argument");

nd_gr(f,v,m,homo,retdp,0,ord,rp);

}

void Pnd_gr_postproc(arg,rp)

void Pnd_gr_postproc(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

int m,do_check;

Q mq;

Obj val;

NODE node;

struct order_spec *ord;

do_weyl = 0;

Line 2226 LIST *rp;

Line 2402 LIST *rp;

if ( !BDY(f) ) {

*rp = f; return;

}

m = QTOS((Q)ARG2(arg));

mq = (Q)ARG2(arg);

if ( mq && (PL(NM(mq)) > 1 || BD(NM(mq))[0] >= (1<<30)) ) {

node = mknode(1,mq);

Psetmod_ff(node,&val);

m = -2;

} else

m = QTOS(mq);

create_order_spec(0,ARG3(arg),&ord);

do_check = ARG4(arg) ? 1 : 0;

nd_gr_postproc(f,v,m,ord,do_check,rp);

}

void Pnd_gr_recompute_trace(arg,rp)

void Pnd_gr_recompute_trace(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v,tlist;

int m;

Line 2254 LIST *rp;

Line 2434 LIST *rp;

Obj nd_btog_one(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist,int pos);

Obj nd_btog(LIST f,LIST v,int m,struct order_spec *ord,LIST tlist);

void Pnd_btog(arg,rp)

void Pnd_btog(NODE arg,Obj *rp)

NODE arg;

Obj *rp;

{

LIST f,v,tlist;

int m,ac,pos;

Line 2280 Obj *rp;

Line 2458 Obj *rp;

error("nd_btog : argument mismatch");

}

void Pnd_weyl_gr_postproc(arg,rp)

void Pnd_weyl_gr_postproc(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

int m,do_check;

Line 2304 LIST *rp;

Line 2480 LIST *rp;

do_weyl = 0;

}

void Pnd_gr_trace(arg,rp)

void Pnd_gr_trace(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

int m,homo;

int m,homo,ac;

Num nhomo;

struct order_spec *ord;

do_weyl = 0;

asir_assert(ARG0(arg),O_LIST,"nd_gr_trace");

if ( (ac = argc(arg)) == 5 ) {

asir_assert(ARG1(arg),O_LIST,"nd_gr_trace");

asir_assert(ARG0(arg),O_LIST,"nd_gr_trace");

asir_assert(ARG2(arg),O_N,"nd_gr_trace");

asir_assert(ARG1(arg),O_LIST,"nd_gr_trace");

asir_assert(ARG3(arg),O_N,"nd_gr_trace");

asir_assert(ARG2(arg),O_N,"nd_gr_trace");

f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);

asir_assert(ARG3(arg),O_N,"nd_gr_trace");

f = remove_zero_from_list(f);

f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);

if ( !BDY(f) ) {

f = remove_zero_from_list(f);

*rp = f; return;

if ( !BDY(f) ) {

}

*rp = f; return;

homo = QTOS((Q)ARG2(arg));

}

m = QTOS((Q)ARG3(arg));

homo = QTOS((Q)ARG2(arg));

create_order_spec(0,ARG4(arg),&ord);

m = QTOS((Q)ARG3(arg));

create_order_spec(0,ARG4(arg),&ord);

} else if ( ac == 1 ) {

f = (LIST)ARG0(arg);

parse_gr_option(f,current_option,&v,&nhomo,&m,&ord);

homo = QTOS((Q)nhomo);

} else

error("nd_gr_trace : invalid argument");

nd_gr_trace(f,v,m,homo,0,ord,rp);

}

void Pnd_f4_trace(arg,rp)

void Pnd_f4_trace(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

int m,homo;

int m,homo,ac;

Num nhomo;

struct order_spec *ord;

do_weyl = 0;

asir_assert(ARG0(arg),O_LIST,"nd_gr_trace");

if ( (ac = argc(arg))==5 ) {

asir_assert(ARG1(arg),O_LIST,"nd_gr_trace");

asir_assert(ARG0(arg),O_LIST,"nd_f4_trace");

asir_assert(ARG2(arg),O_N,"nd_gr_trace");

asir_assert(ARG1(arg),O_LIST,"nd_f4_trace");

asir_assert(ARG3(arg),O_N,"nd_gr_trace");

asir_assert(ARG2(arg),O_N,"nd_f4_trace");

f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);

asir_assert(ARG3(arg),O_N,"nd_f4_trace");

f = remove_zero_from_list(f);

f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);

if ( !BDY(f) ) {

f = remove_zero_from_list(f);

*rp = f; return;

if ( !BDY(f) ) {

}

*rp = f; return;

homo = QTOS((Q)ARG2(arg));

}

m = QTOS((Q)ARG3(arg));

homo = QTOS((Q)ARG2(arg));

create_order_spec(0,ARG4(arg),&ord);

m = QTOS((Q)ARG3(arg));

create_order_spec(0,ARG4(arg),&ord);

} else if ( ac == 1 ) {

f = (LIST)ARG0(arg);

parse_gr_option(f,current_option,&v,&nhomo,&m,&ord);

homo = QTOS((Q)nhomo);

} else

error("nd_gr_trace : invalid argument");

nd_gr_trace(f,v,m,homo,1,ord,rp);

}

void Pnd_weyl_gr(arg,rp)

void Pnd_weyl_gr(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

int m,homo,retdp;

int m,homo,retdp,ac;

Obj val;

Num nhomo;

struct order_spec *ord;

do_weyl = 1;

asir_assert(ARG0(arg),O_LIST,"nd_weyl_gr");

retdp = 0;

asir_assert(ARG1(arg),O_LIST,"nd_weyl_gr");

if ( (ac = argc(arg)) == 4 ) {

asir_assert(ARG2(arg),O_N,"nd_weyl_gr");

asir_assert(ARG0(arg),O_LIST,"nd_weyl_gr");

f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);

asir_assert(ARG1(arg),O_LIST,"nd_weyl_gr");

f = remove_zero_from_list(f);

asir_assert(ARG2(arg),O_N,"nd_weyl_gr");

if ( !BDY(f) ) {

f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);

*rp = f; do_weyl = 0; return;

f = remove_zero_from_list(f);

}

if ( !BDY(f) ) {

m = QTOS((Q)ARG2(arg));

*rp = f; do_weyl = 0; return;

create_order_spec(0,ARG3(arg),&ord);

}

homo = retdp = 0;

m = QTOS((Q)ARG2(arg));

if ( get_opt("homo",&val) && val ) homo = 1;

create_order_spec(0,ARG3(arg),&ord);

if ( get_opt("dp",&val) && val ) retdp = 1;

homo = 0;

if ( get_opt("homo",&val) && val ) homo = 1;

if ( get_opt("dp",&val) && val ) retdp = 1;

} else if ( ac == 1 ) {

f = (LIST)ARG0(arg);

parse_gr_option(f,current_option,&v,&nhomo,&m,&ord);

homo = QTOS((Q)nhomo);

if ( get_opt("dp",&val) && val ) retdp = 1;

} else

error("nd_weyl_gr : invalid argument");

nd_gr(f,v,m,homo,retdp,0,ord,rp);

do_weyl = 0;

}

void Pnd_weyl_gr_trace(arg,rp)

void Pnd_weyl_gr_trace(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

int m,homo;

int m,homo,ac;

Num nhomo;

struct order_spec *ord;

do_weyl = 1;

asir_assert(ARG0(arg),O_LIST,"nd_weyl_gr_trace");

if ( (ac = argc(arg)) == 5 ) {

asir_assert(ARG1(arg),O_LIST,"nd_weyl_gr_trace");

asir_assert(ARG0(arg),O_LIST,"nd_weyl_gr_trace");

asir_assert(ARG2(arg),O_N,"nd_weyl_gr_trace");

asir_assert(ARG1(arg),O_LIST,"nd_weyl_gr_trace");

asir_assert(ARG3(arg),O_N,"nd_weyl_gr_trace");

asir_assert(ARG2(arg),O_N,"nd_weyl_gr_trace");

f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);

asir_assert(ARG3(arg),O_N,"nd_weyl_gr_trace");

f = remove_zero_from_list(f);

f = (LIST)ARG0(arg); v = (LIST)ARG1(arg);

if ( !BDY(f) ) {

f = remove_zero_from_list(f);

*rp = f; do_weyl = 0; return;

if ( !BDY(f) ) {

}

*rp = f; do_weyl = 0; return;

homo = QTOS((Q)ARG2(arg));

}

m = QTOS((Q)ARG3(arg));

homo = QTOS((Q)ARG2(arg));

create_order_spec(0,ARG4(arg),&ord);

m = QTOS((Q)ARG3(arg));

create_order_spec(0,ARG4(arg),&ord);

} else if ( ac == 1 ) {

f = (LIST)ARG0(arg);

parse_gr_option(f,current_option,&v,&nhomo,&m,&ord);

homo = QTOS((Q)nhomo);

} else

error("nd_weyl_gr_trace : invalid argument");

nd_gr_trace(f,v,m,homo,0,ord,rp);

do_weyl = 0;

}

Line 2446 void Pnd_weyl_nf(NODE arg,Obj *rp)

Line 2648 void Pnd_weyl_nf(NODE arg,Obj *rp)

/* for Weyl algebra */

void Pdp_weyl_gr_main(arg,rp)

void Pdp_weyl_gr_main(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

Num homo;

Line 2488 LIST *rp;

Line 2688 LIST *rp;

do_weyl = 0;

}

void Pdp_weyl_gr_f_main(arg,rp)

void Pdp_weyl_gr_f_main(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

Num homo;

Line 2512 LIST *rp;

Line 2710 LIST *rp;

do_weyl = 0;

}

void Pdp_weyl_f4_main(arg,rp)

void Pdp_weyl_f4_main(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

struct order_spec *ord;

Line 2532 LIST *rp;

Line 2728 LIST *rp;

do_weyl = 0;

}

void Pdp_weyl_f4_mod_main(arg,rp)

void Pdp_weyl_f4_mod_main(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

int m;

Line 2556 LIST *rp;

Line 2750 LIST *rp;

do_weyl = 0;

}

void Pdp_weyl_gr_mod_main(arg,rp)

void Pdp_weyl_gr_mod_main(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

LIST f,v;

Num homo;

Line 2585 LIST *rp;

Line 2777 LIST *rp;

VECT current_dl_weight_vector_obj;

int *current_dl_weight_vector;

int dp_negative_weight;

void Pdp_set_weight(arg,rp)

void Pdp_set_weight(NODE arg,VECT *rp)

NODE arg;

VECT *rp;

{

VECT v;

int i,n;

Line 2599 VECT *rp;

Line 2790 VECT *rp;

else if ( !ARG0(arg) ) {

current_dl_weight_vector_obj = 0;

current_dl_weight_vector = 0;

dp_negative_weight = 0;

*rp = 0;

} else {

if ( OID(ARG0(arg)) != O_VECT && OID(ARG0(arg)) != O_LIST )

Line 2617 VECT *rp;

Line 2809 VECT *rp;

current_dl_weight_vector = (int *)CALLOC(n,sizeof(int));

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

current_dl_weight_vector[i] = QTOS((Q)v->body[i]);

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

if ( current_dl_weight_vector[i] < 0 ) break;

if ( i < n )

dp_negative_weight = 1;

else

dp_negative_weight = 0;

*rp = v;

}

Line 2624 VECT *rp;

Line 2822 VECT *rp;

VECT current_module_weight_vector_obj;

int *current_module_weight_vector;

void Pdp_set_module_weight(arg,rp)

void Pdp_set_module_weight(NODE arg,VECT *rp)

NODE arg;

VECT *rp;

{

VECT v;

int i,n;

Line 2686 void Pdp_set_top_weight(NODE arg,Obj *rp)

Line 2882 void Pdp_set_top_weight(NODE arg,Obj *rp)

MKVECT(v,n);

for ( i = 0; i < n; i++, node = NEXT(node) )

BDY(v)[i] = BDY(node);

obj = v;

obj = (Obj)v;

} else

obj = ARG0(arg);

if ( OID(obj) == O_VECT ) {

Line 2717 void Pdp_get_denomlist(LIST *rp)

Line 2913 void Pdp_get_denomlist(LIST *rp)

static VECT current_weyl_weight_vector_obj;

int *current_weyl_weight_vector;

void Pdp_weyl_set_weight(arg,rp)

void Pdp_weyl_set_weight(NODE arg,VECT *rp)

NODE arg;

VECT *rp;

{

VECT v;

NODE node;

Line 2769 void Pdp_mono_raddec(NODE arg,LIST *rp)

Line 2963 void Pdp_mono_raddec(NODE arg,LIST *rp)

else {

t = BDY((LIST)ARG1(arg));

nv = length(t);

v = (P)MALLOC(nv*sizeof(P));

v = (P *)MALLOC(nv*sizeof(P));

for ( vl0 = 0, i = 0; t; t = NEXT(t), i++ ) {

NEXTVL(vl0,vl); VR(vl) = VR((P)BDY(t));

MKV(VR(vl),v[i]);

Line 2911 void Pdp_rref2(NODE arg,VECT *rp)

Line 3105 void Pdp_rref2(NODE arg,VECT *rp)

if ( v[j/BLEN] & (1L<<(j%BLEN)) ) {

NEXTMP(m0,m);

m->dl = t[j];

m->c = (P)ONE;

m->c = (Obj)ONE;

td = MAX(td,m->dl->td);

}

Line 2982 NODE sumi_criFMD(int nv,DP *f,int m)

Line 3176 NODE sumi_criFMD(int nv,DP *f,int m)

for ( k2 = 0; k2 < nv; k2++ )

if ( dl1->d[k2] && dl2->d[k2] ) break;

if ( k2 < nv ) {

NEWMP(mp); mp->dl = l1; C(mp) = (P)ONE;

NEWMP(mp); mp->dl = l1; C(mp) = (Obj)ONE;

NEXT(mp) = 0; MKDP(nv,mp,u); u->sugar = l1->td;

STOQ(i,iq); STOQ(m,mq);

nd = mknode(3,iq,mq,u);

Line 3045 DP dltodp(int nv,DL d)

Line 3239 DP dltodp(int nv,DL d)

MP mp;

DP dp;

NEWMP(mp); mp->dl = d; C(mp) = (P)ONE;

NEWMP(mp); mp->dl = d; C(mp) = (Obj)ONE;

NEXT(mp) = 0; MKDP(nv,mp,dp); dp->sugar = d->td;

return dp;

}

Line 3226 void Pdpv_ord(NODE arg,Obj *rp)

Line 3420 void Pdpv_ord(NODE arg,Obj *rp)

*rp = dp_current_modspec->obj;

}

extern int dpm_ispot;

void Pdpm_ord(NODE arg,LIST *rp)

{

Q 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,QTOS((Q)ARG0(nd)));

}

STOQ(dpm_ispot,q);

nd = mknode(2,q,dp_current_spec->obj);

MKLIST(*rp,nd);

}

void Pdpm_hm(NODE arg,DPM *rp)

{

DPM p;

p = (DPM)ARG0(arg); asir_assert(p,O_DPM,"dpm_hm");

dpm_hm(p,rp);

}

void Pdpm_ht(NODE arg,DPM *rp)

{

DPM p;

p = (DPM)ARG0(arg); asir_assert(p,O_DPM,"dp_ht");

dpm_ht(p,rp);

}

void Pdpm_hc(NODE arg,Obj *rp)

{

asir_assert(ARG0(arg),O_DPM,"dpm_hc");

if ( !ARG0(arg) )

*rp = 0;

else

*rp = BDY((DPM)ARG0(arg))->c;

}

void Pdpv_ht(NODE arg,LIST *rp)

{

NODE n;

Line 3280 void Pdpv_hc(NODE arg,LIST *rp)

Line 3519 void Pdpv_hc(NODE arg,LIST *rp)

if ( pos < 0 )

hc = 0;

else

hc = BDY(BDY(p)[pos])->c;

hc = (P)BDY(BDY(p)[pos])->c;

STOQ(pos,q);

n = mknode(2,q,hc);

MKLIST(*rp,n);

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