OpenXM_contrib2/asir2018/engine/dist.c - diff

Return to dist.c CVS log

Up to [local] / OpenXM_contrib2 / asir2018 / engine

Diff for /OpenXM_contrib2/asir2018/engine/dist.c between version 1.4 and 1.8

version 1.4, 2019/09/04 01:12:02

version 1.8, 2019/09/13 02:04:42

Line 45

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

* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.

* $OpenXM: OpenXM_contrib2/asir2018/engine/dist.c,v 1.3 2019/08/21 00:37:47 noro Exp $

* $OpenXM: OpenXM_contrib2/asir2018/engine/dist.c,v 1.7 2019/09/06 00:11:59 noro Exp $

#include "ca.h"

Line 2635 NBP harmonic_mul_nbm(NBM a,NBM b)

/* DPM functions */

DMMstack dmm_stack;

extern LIST schreyer_obj;

void push_schreyer_order(LIST data)

{

DMMstack t;

int len,i;

NODE in;

NODE in,t1;

/* data = [DPM,...,DPM] */

in = BDY(data);

Line 2655 void push_schreyer_order(LIST data)

Line 2656 void push_schreyer_order(LIST data)

t->next = dmm_stack;

dmm_stack = t;

dpm_ordtype = 2;

MKNODE(t1,data,schreyer_obj?BDY(schreyer_obj):0);

MKLIST(schreyer_obj,t1);

}

// data=[Ink,...,In0]

// Ini = a list of module monomials

Line 2714 NODE dpm_reduceall(NODE in)

Line 2716 NODE dpm_reduceall(NODE in)

for ( i = 0, t = in; i < n; i++, t = NEXT(t) ) ps[i] = BDY(t);

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

g = ps[i]; ps[i] = 0;

dpm_nf_z(0,g,psv,1,DP_Multiple,&r);

// dpm_nf_z(0,g,psv,1,DP_Multiple,&ps[i]);

ps[i] = r;

dpm_nf_z(0,g,psv,1,0,&ps[i]);

}

t = 0;

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

Line 2725 NODE dpm_reduceall(NODE in)

Line 2727 NODE dpm_reduceall(NODE in)

return t;

}

struct oEGT egra;

void dpm_schreyer_base(LIST g,LIST *s)

{

NODE nd,t,b0,b;

Line 2738 void dpm_schreyer_base(LIST g,LIST *s)

Line 2742 void dpm_schreyer_base(LIST g,LIST *s)

DPM *ps;

VECT psv;

DP **m,*quo;

struct oEGT eg_nf,eg0,eg1;

struct oEGT eg0,eg1;

extern struct oEGT egc,egcomp;

extern struct oEGT egred;

// init_eg(&eg_nf);

init_eg(&egra);

// init_eg(&egcomp);

nd = BDY(g);

n = length(nd);

MKVECT(psv,n);

Line 2751 void dpm_schreyer_base(LIST g,LIST *s)

Line 2754 void dpm_schreyer_base(LIST g,LIST *s)

nv = ps[0]->nv;

m = (DP **)almat_pointer(n,n);

b0 = 0;

// init_eg(&egc);

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

// sp(ps[i],ps[j]) = ti*ps[i]-tj*ps[j] => m[i][j] = ti

for ( j = i+1; j < n; j++ ) m[i][j] = dpm_sp_hm(ps[i],ps[j]);

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

// for ( j = n-1; j > i; j-- ) {

if ( !m[i][j] ) continue;

for ( h = m[i][j], k = i+1; k < n; k++ )

if ( k != j && m[i][k] && dp_redble(m[i][k],h) ) m[i][k] = 0;

Line 2764 void dpm_schreyer_base(LIST g,LIST *s)

Line 2765 void dpm_schreyer_base(LIST g,LIST *s)

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

if ( m[i][j] ) {

dpm_sp(ps[i],ps[j],&sp,&t1,&t2);

// get_eg(&eg0);

quo = dpm_nf_and_quotient(0,sp,psv,&nf,&dn);

// get_eg(&eg1); add_eg(&eg_nf,&eg0,&eg1);

if ( nf )

error("dpm_schreyer_base : cannot happen");

NEWDMM(r0); r = r0;

Line 2795 void dpm_schreyer_base(LIST g,LIST *s)

Line 2794 void dpm_schreyer_base(LIST g,LIST *s)

BDY(t) = (pointer)dpm;

}

b0 = dpm_sort_list(b0);

// b0 = dpm_reduceall(b0);

// get_eg(&eg0);

b0 = dpm_reduceall(b0);

// get_eg(&eg1); add_eg(&egra,&eg0,&eg1); print_eg("RA",&egra);

MKLIST(*s,b0);

// print_eg("nf",&eg_nf); printf("\n");

// print_eg("red",&egred); printf("\n");

// print_eg("coef",&egc); printf("\n");

}

int compdmm_schreyer(int n,DMM m1,DMM m2)

Line 2965 void chsgndpm(DPM p,DPM *pr)

}

void mulcmp(Obj c,MP m)

{

MP t;

Obj c1;

for ( t = m; t; t = NEXT(t) ) {

arf_mul(CO,c,C(t),&c1); C(t) = c1;

}

void mulcdmm(Obj c,DMM m)

{

DMM t;

Obj c1;

for ( t = m; t; t = NEXT(t) ) {

arf_mul(CO,c,C(t),&c1); C(t) = c1;

}

void mulcdpm(VL vl,Obj c,DPM p,DPM *pr)

{

DMM m,mr=0,mr0;

Line 3119 int compdpm(VL vl,DPM p1,DPM p2)

Line 3139 int compdpm(VL vl,DPM p1,DPM p2)

}

// p = ...+c*<<0,...0:pos>>+...

DPM dpm_eliminate_term(DPM a,DPM p,Obj c,int pos)

{

MP d0,d;

DMM m;

DP f;

DPM a1,p1,r;

if ( !a ) return 0;

d0 = 0;

for ( m = BDY(a); m; m = NEXT(m) )

if ( m->pos == pos ) {

NEXTMP(d0,d); d->dl = m->dl; arf_chsgn(m->c,&d->c);

}

if ( d0 ) {

NEXT(d) = 0; MKDP(NV(a),d0,f);

mulcdpm(CO,c,a,&a1);

mulobjdpm(CO,(Obj)f,p,&p1);

adddpm(CO,a1,p1,&r);

return r;

} else

return a;

}

// <<...:i>> -> <<...:tab[i]>>

DPM dpm_compress(DPM p,int *tab)

{

DMM m,mr0,mr;

DPM t;

if ( !p ) return 0;

else {

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

NEXTDMM(mr0,mr);

mr->dl = m->dl; mr->c = m->c; mr->pos = tab[m->pos];

if ( mr->pos <= 0 )

error("dpm_compress : invalid position");

}

NEXT(mr) = 0;

MKDPM(p->nv,mr0,t); t->sugar = p->sugar;

return t;

}

// input : s, s = syz(m) output simplified s, m

void dpm_simplify_syz(LIST s,LIST m,LIST *s1,LIST *m1)

{

int lm,ls,i,j,pos;

DPM *am,*as;

DPM p;

DMM d;

Obj c;

int *tab;

NODE t,t1;

lm = length(BDY(m));

am = (DPM *)MALLOC((lm+1)*sizeof(DPM));

ls = length(BDY(s));

as = (DPM *)MALLOC(ls*sizeof(DPM));

for ( i = 1, t = BDY(m); i <= lm; i++, t = NEXT(t) ) am[i] = (DPM)BDY(t);

for ( i = 0, t = BDY(s); i < ls; i++, t = NEXT(t) ) as[i] = (DPM)BDY(t);

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

p = as[i];

if ( p == 0 ) continue;

for ( d = BDY(p); d; d = NEXT(d) ) if ( d->dl->td == 0 ) break;

if ( d ) {

c = d->c; pos = d->pos;

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

if ( j != i ) {

as[j] = dpm_eliminate_term(as[j],p,c,pos);

}

// remove m[i]

am[pos] = 0;

as[i] = 0;

}

// compress s

// create index table from am[]

// (0 0 * 0 * ...) -> (0 0 1 0 2 ... ) which means 2->1, 4->2, ...

tab = (int *)MALLOC((lm+1)*sizeof(int));

for ( j = 0, i = 1; i <= lm; i++ ) {

if ( am[i] ) { j++; tab[i] = j; }

else tab[i] = 0;

}

t = 0;

for ( i = ls-1; i >= 0; i-- )

if ( as[i] ) {

p = dpm_compress(as[i],tab);

MKNODE(t1,(pointer)p,t); t = t1;

}

MKLIST(*s1,t);

t = 0;

for ( i = lm; i >= 1; i-- )

if ( am[i] ) {

MKNODE(t1,(pointer)am[i],t); t = t1;

}

MKLIST(*m1,t);

}

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