OpenXM_contrib2/asir2000/builtin/array.c - diff

Return to array.c CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / builtin

Diff for /OpenXM_contrib2/asir2000/builtin/array.c between version 1.16 and 1.44

version 1.16, 2001/09/10 02:45:25

version 1.44, 2005/01/12 10:38:07

Line 45

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

* PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.

* $OpenXM: OpenXM_contrib2/asir2000/builtin/array.c,v 1.15 2001/09/07 08:54:57 noro Exp $

* $OpenXM: OpenXM_contrib2/asir2000/builtin/array.c,v 1.43 2004/12/18 16:50:10 saito Exp $

#include "ca.h"

#include "base.h"

#include "parse.h"

#include "inline.h"

#define F4_INTRAT_PERIOD 8

#if 0

#undef DMAR

#define DMAR(a1,a2,a3,d,r) (r)=dmar(a1,a2,a3,d);

Line 59

Line 61

extern int DP_Print; /* XXX */

void inner_product_mat_int_mod(Q **,int **,int,int,int,Q *);

void solve_by_lu_mod(int **,int,int,int **,int);

void solve_by_lu_gfmmat(GFMMAT,unsigned int,unsigned int *,unsigned int *);

int lu_gfmmat(GFMMAT,unsigned int,int *);

void mat_to_gfmmat(MAT,unsigned int,GFMMAT *);

int generic_gauss_elim_mod(int **,int,int,int,int *);

int generic_gauss_elim(MAT ,MAT *,Q *,int **,int **);

int gauss_elim_mod(int **,int,int,int);

int gauss_elim_mod1(int **,int,int,int);

int gauss_elim_geninv_mod(unsigned int **,int,int,int);

int gauss_elim_geninv_mod_swap(unsigned int **,int,int,unsigned int,unsigned int ***,int **);

void Pnewvect(), Pnewmat(), Psepvect(), Psize(), Pdet(), Pleqm(), Pleqm1(), Pgeninvm();

void Pinvmat();

void Pnewbytearray();

void Pgeneric_gauss_elim();

void Pgeneric_gauss_elim_mod();

void Pmat_to_gfmmat(),Plu_gfmmat(),Psolve_by_lu_gfmmat();

void Pgeninvm_swap(), Premainder(), Psremainder(), Pvtol();

void Pgeninvm_swap(), Premainder(), Psremainder(), Pvtol(), Pltov();

void Pgeninv_sf_swap();

void sepvect();

void Pmulmat_gf2n();

void Pbconvmat_gf2n();

Line 91 void Pirredpoly_up2();

Line 84 void Pirredpoly_up2();

void Pnbpoly_up2();

void Pqsort();

void Pexponent_vector();

void Pmat_swap_row_destructive();

void Pmat_swap_col_destructive();

void Pvect();

void Pmat();

void Pmatc();

void Pnd_det();

struct ftab array_tab[] = {

{"solve_by_lu_gfmmat",Psolve_by_lu_gfmmat,4},

{"lu_gfmmat",Plu_gfmmat,2},

{"mat_to_gfmmat",Pmat_to_gfmmat,2},

{"generic_gauss_elim",Pgeneric_gauss_elim,1},

{"generic_gauss_elim_mod",Pgeneric_gauss_elim_mod,2},

{"newvect",Pnewvect,-2},

{"vect",Pvect,-99999999},

{"vector",Pnewvect,-2},

{"exponent_vector",Pexponent_vector,-99999999},

{"newmat",Pnewmat,-3},

{"matrix",Pnewmat,-3},

{"mat",Pmat,-99999999},

{"matr",Pmat,-99999999},

{"matc",Pmatc,-99999999},

{"newbytearray",Pnewbytearray,-2},

{"sepmat_destructive",Psepmat_destructive,2},

{"sepvect",Psepvect,2},

{"qsort",Pqsort,-2},

{"vtol",Pvtol,1},

{"ltov",Pltov,1},

{"size",Psize,1},

{"det",Pdet,-2},

{"nd_det",Pnd_det,-2},

{"invmat",Pinvmat,-2},

{"leqm",Pleqm,2},

{"leqm1",Pleqm1,2},

{"geninvm",Pgeninvm,2},

{"geninvm_swap",Pgeninvm_swap,2},

{"geninv_sf_swap",Pgeninv_sf_swap,1},

{"remainder",Premainder,2},

{"sremainder",Psremainder,2},

{"mulmat_gf2n",Pmulmat_gf2n,1},

Line 123 struct ftab array_tab[] = {

Line 131 struct ftab array_tab[] = {

{"x962_irredpoly_up2",Px962_irredpoly_up2,2},

{"irredpoly_up2",Pirredpoly_up2,2},

{"nbpoly_up2",Pnbpoly_up2,2},

{"mat_swap_row_destructive",Pmat_swap_row_destructive,3},

{"mat_swap_col_destructive",Pmat_swap_col_destructive,3},

{0,0,0},

};

int comp_obj(a,b)

int comp_obj(Obj *a,Obj *b)

Obj *a,*b;

{

return arf_comp(CO,*a,*b);

}

Line 135 Obj *a,*b;

Line 144 Obj *a,*b;

static FUNC generic_comp_obj_func;

static NODE generic_comp_obj_arg;

int generic_comp_obj(a,b)

int generic_comp_obj(Obj *a,Obj *b)

Obj *a,*b;

{

Q r;

Line 150 Obj *a,*b;

Line 158 Obj *a,*b;

}

void Pqsort(arg,rp)

void Pqsort(NODE arg,VECT *rp)

NODE arg;

VECT *rp;

{

VECT vect;

char buf[BUFSIZ];

NODE n,n1;

char *fname;

NODE n;

P p;

V v;

FUNC func;

int len,i;

pointer *a;

Obj t;

asir_assert(ARG0(arg),O_VECT,"qsort");

t = ARG0(arg);

vect = (VECT)ARG0(arg);

if (OID(t) == O_LIST) {

n = (NODE)BDY((LIST)t);

len = length(n);

MKVECT(vect,len);

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

BDY(vect)[i] = BDY(n);

}

}else if (OID(t) != O_VECT) {

error("qsort : invalid argument");

}else {

vect = (VECT)t;

}

if ( argc(arg) == 1 )

qsort(BDY(vect),vect->len,sizeof(Obj),(int (*)(const void *,const void *))comp_obj);

else {

Line 170 VECT *rp;

Line 190 VECT *rp;

if ( !p || OID(p)!=2 )

error("qsort : invalid argument");

v = VR(p);

if ( (int)v->attr != V_SR )

gen_searchf(NAME(v),&func);

error("qsort : no such function");

if ( !func ) {

generic_comp_obj_func = (FUNC)v->priv;

if ( (int)v->attr != V_SR )

error("qsort : no such function");

func = (FUNC)v->priv;

}

generic_comp_obj_func = func;

MKNODE(n,0,0); MKNODE(generic_comp_obj_arg,0,n);

qsort(BDY(vect),vect->len,sizeof(Obj),(int (*)(const void *,const void *))generic_comp_obj);

}

*rp = vect;

if (OID(t) == O_LIST) {

a = BDY(vect);

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

MKNODE(n1,a[i],n); n = n1;

}

MKLIST((LIST)*rp,n);

}else {

*rp = vect;

}

void PNBmul_gf2n(arg,rp)

void PNBmul_gf2n(NODE arg,GF2N *rp)

NODE arg;

GF2N *rp;

{

GF2N a,b;

GF2MAT mat;

Line 218 GF2N *rp;

Line 248 GF2N *rp;

}

void Pmul_vect_mat_gf2n(arg,rp)

void Pmul_vect_mat_gf2n(NODE arg,GF2N *rp)

NODE arg;

GF2N *rp;

{

GF2N a;

GF2MAT mat;

Line 251 GF2N *rp;

Line 279 GF2N *rp;

}

void Pbconvmat_gf2n(arg,rp)

void Pbconvmat_gf2n(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

P p0,p1;

int to;

Line 273 LIST *rp;

Line 299 LIST *rp;

MKLIST(*rp,n0);

}

void Pmulmat_gf2n(arg,rp)

void Pmulmat_gf2n(NODE arg,GF2MAT *rp)

NODE arg;

GF2MAT *rp;

{

GF2MAT m;

Line 284 GF2MAT *rp;

Line 308 GF2MAT *rp;

*rp = m;

}

void Psepmat_destructive(arg,rp)

void Psepmat_destructive(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

MAT mat,mat1;

int i,j,row,col;

Line 317 LIST *rp;

Line 339 LIST *rp;

MKLIST(*rp,n0);

}

void Psepvect(arg,rp)

void Psepvect(NODE arg,VECT *rp)

NODE arg;

VECT *rp;

{

sepvect((VECT)ARG0(arg),QTOS((Q)ARG1(arg)),rp);

}

void sepvect(v,d,rp)

void sepvect(VECT v,int d,VECT *rp)

VECT v;

int d;

VECT *rp;

{

int i,j,k,n,q,q1,r;

pointer *pv,*pw,*pu;

Line 351 VECT *rp;

Line 368 VECT *rp;

}

void Pnewvect(arg,rp)

void Pnewvect(NODE arg,VECT *rp)

NODE arg;

VECT *rp;

{

int len,i,r;

VECT vect;

Line 380 VECT *rp;

Line 395 VECT *rp;

*rp = vect;

}

void Pexponent_vector(arg,rp)

void Pvect(NODE arg,VECT *rp) {

NODE arg;

int len,i,r;

DP *rp;

VECT vect;

pointer *vb;

NODE tn;

if ( !arg ) {

*rp =0;

return;

}

for (len = 0, tn = arg; tn; tn = NEXT(tn), len++);

if ( len == 1 ) {

if ( ARG0(arg) != 0 ) {

switch ( OID(ARG0(arg)) ) {

case O_VECT:

*rp = ARG0(arg);

return;

case O_LIST:

for ( len = 0, tn = ARG0(arg); tn; tn = NEXT(tn), len++ );

MKVECT(vect,len-1);

for ( i = 0, tn = BDY((LIST)ARG0(arg)), vb =BDY(vect);

tn; i++, tn = NEXT(tn) )

vb[i] = (pointer)BDY(tn);

*rp=vect;

return;

}

MKVECT(vect,len);

for ( i = 0, tn = arg, vb = BDY(vect); tn; i++, tn = NEXT(tn) )

vb[i] = (pointer)BDY(tn);

*rp = vect;

}

void Pexponent_vector(NODE arg,DP *rp)

{

nodetod(arg,rp);

}

void Pnewbytearray(arg,rp)

void Pnewbytearray(NODE arg,BYTEARRAY *rp)

NODE arg;

BYTEARRAY *rp;

{

int len,i,r;

BYTEARRAY array;

Line 431 BYTEARRAY *rp;

Line 477 BYTEARRAY *rp;

*rp = array;

}

void Pnewmat(arg,rp)

void Pnewmat(NODE arg,MAT *rp)

NODE arg;

MAT *rp;

{

int row,col;

int i,j,r,c;

Line 468 MAT *rp;

Line 512 MAT *rp;

*rp = m;

}

void Pvtol(arg,rp)

void Pmat(NODE arg, MAT *rp)

NODE arg;

LIST *rp;

{

int row,col;

int i;

MAT m;

pointer **mb;

pointer *ent;

NODE tn, sn;

VECT v;

if ( !arg ) {

*rp =0;

return;

}

for (row = 0, tn = arg; tn; tn = NEXT(tn), row++);

if ( row == 1 ) {

if ( OID(ARG0(arg)) == O_MAT ) {

*rp=ARG0(arg);

return;

} else if ( !(OID(ARG0(arg)) == O_LIST || OID(ARG0(arg)) == O_VECT)) {

error("mat : invalid argument");

}

if ( OID(ARG0(arg)) == O_VECT ) {

v = ARG0(arg);

col = v->len;

} else if ( OID(ARG0(arg)) == O_LIST ) {

for (col = 0, tn = BDY((LIST)ARG0(arg)); tn ; tn = NEXT(tn), col++);

} else {

error("mat : invalid argument");

}

MKMAT(m,row,col);

for (row = 0, tn = arg, mb = BDY(m); tn; tn = NEXT(tn), row++) {

if ( BDY(tn) == 0 ) {

error("mat : invalid argument");

} else if ( OID(BDY(tn)) == O_VECT ) {

v = tn->body;

ent = BDY(v);

for (i = 0; i < v->len; i++ ) mb[row][i] = (Obj)ent[i];

} else if ( OID(BDY(tn)) == O_LIST ) {

for (col = 0, sn = BDY((LIST)BDY(tn)); sn; col++, sn = NEXT(sn) )

mb[row][col] = (pointer)BDY(sn);

} else {

error("mat : invalid argument");

}

*rp = m;

}

void Pmatc(NODE arg, MAT *rp)

{

int row,col;

int i;

MAT m;

pointer **mb;

pointer *ent;

NODE tn, sn;

VECT v;

if ( !arg ) {

*rp =0;

return;

}

for (col = 0, tn = arg; tn; tn = NEXT(tn), col++);

if ( col == 1 ) {

if ( OID(ARG0(arg)) == O_MAT ) {

*rp=ARG0(arg);

return;

} else if ( !(OID(ARG0(arg)) == O_LIST || OID(ARG0(arg)) == O_VECT)) {

error("matc : invalid argument");

}

if ( OID(ARG0(arg)) == O_VECT ) {

v = ARG0(arg);

row = v->len;

} else if ( OID(ARG0(arg)) == O_LIST ) {

for (row = 0, tn = BDY((LIST)ARG0(arg)); tn ; tn = NEXT(tn), row++);

} else {

error("matc : invalid argument");

}

MKMAT(m,row,col);

for (col = 0, tn = arg, mb = BDY(m); tn; tn = NEXT(tn), col++) {

if ( BDY(tn) == 0 ) {

error("matc : invalid argument");

} else if ( OID(BDY(tn)) == O_VECT ) {

v = tn->body;

ent = BDY(v);

for (i = 0; i < v->len; i++ ) mb[i][col] = (Obj)ent[i];

} else if ( OID(BDY(tn)) == O_LIST ) {

for (row = 0, sn = BDY((LIST)BDY(tn)); sn; row++, sn = NEXT(sn) )

mb[row][col] = (pointer)BDY(sn);

} else {

error("matc : invalid argument");

}

*rp = m;

}

void Pvtol(NODE arg,LIST *rp)

{

NODE n,n1;

VECT v;

pointer *a;

Line 485 LIST *rp;

Line 629 LIST *rp;

MKLIST(*rp,n);

}

void Premainder(arg,rp)

void Pltov(NODE arg,VECT *rp)

NODE arg;

Obj *rp;

{

NODE n;

VECT v;

int len,i;

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

n = (NODE)BDY((LIST)ARG0(arg));

len = length(n);

MKVECT(v,len);

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

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

*rp = v;

}

void Premainder(NODE arg,Obj *rp)

{

Obj a;

VECT v,w;

MAT m,l;

Line 535 Obj *rp;

Line 692 Obj *rp;

}

void Psremainder(arg,rp)

void Psremainder(NODE arg,Obj *rp)

NODE arg;

Obj *rp;

{

Obj a;

VECT v,w;

Line 586 Obj *rp;

Line 741 Obj *rp;

}

void Psize(arg,rp)

void Psize(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

int n,m;

Line 607 LIST *rp;

Line 760 LIST *rp;

n = ((MAT)ARG0(arg))->row; m = ((MAT)ARG0(arg))->col;

STOQ(m,q); MKNODE(s,q,0); STOQ(n,q); MKNODE(t,q,s);

break;

case O_IMAT:

n = ((IMAT)ARG0(arg))->row; m = ((IMAT)ARG0(arg))->col;

STOQ(m,q); MKNODE(s,q,0); STOQ(n,q); MKNODE(t,q,s);

break;

default:

error("size : invalid argument"); break;

}

Line 614 LIST *rp;

Line 771 LIST *rp;

MKLIST(*rp,t);

}

void Pdet(arg,rp)

void Pdet(NODE arg,P *rp)

NODE arg;

P *rp;

{

MAT m;

int n,i,j,mod;

Line 640 P *rp;

Line 795 P *rp;

}

void Pinvmat(NODE arg,LIST *rp)

{

MAT m,r;

int n,i,j,mod;

P dn;

P **mat,**imat,**w;

NODE nd;

m = (MAT)ARG0(arg);

asir_assert(m,O_MAT,"invmat");

if ( m->row != m->col )

error("invmat : non-square matrix");

else if ( argc(arg) == 1 ) {

n = m->row;

invmatp(CO,(P **)BDY(m),n,&imat,&dn);

NEWMAT(r); r->row = n; r->col = n; r->body = (pointer **)imat;

nd = mknode(2,r,dn);

MKLIST(*rp,nd);

} else {

n = m->row; mod = QTOS((Q)ARG1(arg)); mat = (P **)BDY(m);

w = (P **)almat_pointer(n,n);

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

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

ptomp(mod,mat[i][j],&w[i][j]);

#if 0

detmp(CO,mod,w,n,&d);

mptop(d,rp);

#else

error("not implemented yet");

#endif

}

input : a row x col matrix A

A[I] <-> A[I][0]*x_0+A[I][1]*x_1+...

Line 651 P *rp;

Line 839 P *rp;

B[I] <-> x_{R[I]}+B[I][0]x_{C[0]}+B[I][1]x_{C[1]}+...

void Pgeneric_gauss_elim_mod(arg,rp)

void Pgeneric_gauss_elim(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

NODE n0;

MAT m,nm;

int *ri,*ci;

VECT rind,cind;

Q dn,q;

int i,j,k,l,row,col,t,rank;

asir_assert(ARG0(arg),O_MAT,"generic_gauss_elim");

m = (MAT)ARG0(arg);

row = m->row; col = m->col;

rank = generic_gauss_elim(m,&nm,&dn,&ri,&ci);

t = col-rank;

MKVECT(rind,rank);

MKVECT(cind,t);

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

STOQ(ri[i],q);

BDY(rind)[i] = (pointer)q;

}

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

STOQ(ci[i],q);

BDY(cind)[i] = (pointer)q;

}

n0 = mknode(4,nm,dn,rind,cind);

MKLIST(*rp,n0);

}

input : a row x col matrix A

A[I] <-> A[I][0]*x_0+A[I][1]*x_1+...

output : [B,R,C]

B : a rank(A) x col-rank(A) matrix

R : a vector of length rank(A)

C : a vector of length col-rank(A)

B[I] <-> x_{R[I]}+B[I][0]x_{C[0]}+B[I][1]x_{C[1]}+...

void Pgeneric_gauss_elim_mod(NODE arg,LIST *rp)

{

NODE n0;

MAT m,mat;

VECT rind,cind;

Q **tmat;

Line 663 LIST *rp;

Line 888 LIST *rp;

Q *rib,*cib;

int *colstat;

Q q;

int md,i,j,k,l,row,col,t,n,rank;

int md,i,j,k,l,row,col,t,rank;

asir_assert(ARG0(arg),O_MAT,"generic_gauss_elim_mod");

asir_assert(ARG1(arg),O_N,"generic_gauss_elim_mod");

Line 703 LIST *rp;

Line 928 LIST *rp;

MKLIST(*rp,n0);

}

void Pleqm(arg,rp)

void Pleqm(NODE arg,VECT *rp)

NODE arg;

VECT *rp;

{

MAT m;

VECT vect;

Line 744 VECT *rp;

Line 967 VECT *rp;

}

int gauss_elim_mod(mat,row,col,md)

int gauss_elim_mod(int **mat,int row,int col,int md)

int **mat;

int row,col,md;

{

int i,j,k,inv,a,n;

int *t,*pivot;

Line 784 int row,col,md;

Line 1005 int row,col,md;

}

struct oEGT eg_mod,eg_elim,eg_elim1,eg_elim2,eg_chrem,eg_gschk,eg_intrat,eg_symb;

struct oEGT eg_conv;

int generic_gauss_elim(mat,nm,dn,rindp,cindp)

int generic_gauss_elim(MAT mat,MAT *nm,Q *dn,int **rindp,int **cindp)

MAT mat;

MAT *nm;

Q *dn;

int **rindp,**cindp;

{

int **wmat;

Q **bmat;

Line 906 RESET:

Line 1124 RESET:

add_eg(&eg_chrem_split,&tmp0,&tmp1);

get_eg(&tmp0);

if ( ind % 16 )

if ( ind % F4_INTRAT_PERIOD )

ret = 0;

else

ret = intmtoratm(crmat,m1,*nm,dn);

Line 941 RESET:

Line 1159 RESET:

}

int generic_gauss_elim_hensel(mat,nmmat,dn,rindp,cindp)

int generic_gauss_elim_hensel(MAT mat,MAT *nmmat,Q *dn,int **rindp,int **cindp)

MAT mat;

MAT *nmmat;

Q *dn;

int **rindp,**cindp;

{

MAT bmat,xmat;

Q **a0,**a,**b,**x,**nm;

Line 961 int **rindp,**cindp;

Line 1175 int **rindp,**cindp;

int *cinfo,*rinfo;

int *rind,*cind;

int count;

struct oEGT eg_mul,eg_inv,tmp0,tmp1;

int ret;

struct oEGT eg_mul,eg_inv,eg_intrat,eg_check,tmp0,tmp1;

int period;

int *wx,*ptr;

int wxsize,nsize;

N wn;

Q wq;

a0 = (Q **)mat->body;

row = mat->row; col = mat->col;

Line 979 int **rindp,**cindp;

Line 1199 int **rindp,**cindp;

} else

wi[j] = 0;

rank = find_lhs_and_lu_mod(w,row,col,md,&rinfo,&cinfo);

rank = find_lhs_and_lu_mod((unsigned int **)w,row,col,md,&rinfo,&cinfo);

a = (Q **)almat_pointer(rank,rank); /* lhs mat */

MKMAT(bmat,rank,col-rank); b = (Q **)bmat->body; /* lhs mat */

for ( j = li = ri = 0; j < col; j++ )

Line 1009 int **rindp,**cindp;

Line 1229 int **rindp,**cindp;

*cindp = cind = (int *)MALLOC_ATOMIC((ri)*sizeof(int));

init_eg(&eg_mul); init_eg(&eg_inv);

for ( q = ONE, count = 0; ; count++ ) {

init_eg(&eg_check); init_eg(&eg_intrat);

fprintf(stderr,".");

period = F4_INTRAT_PERIOD;

nsize = period;

wxsize = rank*ri*nsize;

wx = (int *)MALLOC_ATOMIC(wxsize*sizeof(int));

for ( i = 0; i < wxsize; i++ ) wx[i] = 0;

for ( q = ONE, count = 0; ; ) {

if ( DP_Print > 3 )

fprintf(stderr,"o");

/* wc = -b mod md */

get_eg(&tmp0);

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

for ( j = 0, bi = b[i], wi = wc[i]; j < ri; j++ )

if ( u = (Q)bi[j] ) {

Line 1021 int **rindp,**cindp;

Line 1249 int **rindp,**cindp;

wi[j] = t;

} else

wi[j] = 0;

/* wc = A^(-1)wc; wc is normalized */

/* wc = A^(-1)wc; wc is not normalized */

get_eg(&tmp0);

solve_by_lu_mod(w,rank,md,wc,ri,0);

solve_by_lu_mod(w,rank,md,wc,ri);

/* wx += q*wc */

get_eg(&tmp1);

ptr = wx;

add_eg(&eg_inv,&tmp0,&tmp1);

/* x = x-q*wc */

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

for ( j = 0, xi = x[i], wi = wc[i]; j < ri; j++ ) {

for ( j = 0, wi = wc[i]; j < ri; j++ ) {

STOQ(wi[j],u); mulq(q,u,&s);

if ( wi[j] )

subq(xi[j],s,&u); xi[j] = u;

muln_1(BD(NM(q)),PL(NM(q)),wi[j],ptr);

ptr += nsize;

}

count++;

get_eg(&tmp1);

add_eg(&eg_inv,&tmp0,&tmp1);

get_eg(&tmp0);

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

for ( j = 0; j < ri; j++ ) {

Line 1049 int **rindp,**cindp;

Line 1279 int **rindp,**cindp;

add_eg(&eg_mul,&tmp0,&tmp1);

/* q = q*md */

mulq(q,mdq,&u); q = u;

if ( !(count % 16) && intmtoratm_q(xmat,NM(q),*nmmat,dn) ) {

if ( count == period ) {

for ( j = k = l = 0; j < col; j++ )

get_eg(&tmp0);

if ( cinfo[j] )

ptr = wx;

rind[k++] = j;

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

else

for ( j = 0, xi = x[i]; j < ri;

cind[l++] = j;

j++, ptr += nsize ) {

if ( gensolve_check(mat,*nmmat,*dn,rind,cind) ) {

for ( k = nsize-1; k >= 0 && !ptr[k]; k-- );

fprintf(stderr,"\n");

if ( k >= 0 ) {

print_eg("INV",&eg_inv);

wn = NALLOC(k+1);

print_eg("MUL",&eg_mul);

PL(wn) = k+1;

fflush(asir_out);

for ( l = 0; l <= k; l++ ) BD(wn)[l] = (unsigned int)ptr[l];

return rank;

NTOQ(wn,1,wq);

subq(xi[j],wq,&u); xi[j] = u;

}

ret = intmtoratm_q(xmat,NM(q),*nmmat,dn);

get_eg(&tmp1); add_eg(&eg_intrat,&tmp0,&tmp1);

if ( ret ) {

for ( j = k = l = 0; j < col; j++ )

if ( cinfo[j] )

rind[k++] = j;

else

cind[l++] = j;

get_eg(&tmp0);

ret = gensolve_check(mat,*nmmat,*dn,rind,cind);

get_eg(&tmp1); add_eg(&eg_check,&tmp0,&tmp1);

if ( ret ) {

if ( DP_Print > 3 ) {

fprintf(stderr,"\n");

print_eg("INV",&eg_inv);

print_eg("MUL",&eg_mul);

print_eg("INTRAT",&eg_intrat);

print_eg("CHECK",&eg_check);

fflush(asir_out);

}

return rank;

}

} else {

period = period*3/2;

count = 0;

nsize += period;

wxsize += rank*ri*nsize;

wx = (int *)REALLOC(wx,wxsize*sizeof(int));

for ( i = 0; i < wxsize; i++ ) wx[i] = 0;

}

Line 1069 int **rindp,**cindp;

Line 1331 int **rindp,**cindp;

int f4_nocheck;

int gensolve_check(mat,nm,dn,rind,cind)

int gensolve_check(MAT mat,MAT nm,Q dn,int *rind,int *cind)

MAT mat,nm;

Q dn;

int *rind,*cind;

{

int row,col,rank,clen,i,j,k,l;

Q s,t,u;

Q s,t;

Q *w;

Q *mati,*nmk;

Line 1120 int *rind,*cind;

Line 1379 int *rind,*cind;

/* assuming 0 < c < m */

int inttorat(c,m,b,sgnp,nmp,dnp)

int inttorat(N c,N m,N b,int *sgnp,N *nmp,N *dnp)

N c,m,b;

int *sgnp;

N *nmp,*dnp;

{

Q qq,t,u1,v1,r1,nm;

Q qq,t,u1,v1,r1;

N q,r,u2,v2,r2;

N q,u2,v2,r2;

u1 = 0; v1 = ONE; u2 = m; v2 = c;

while ( cmpn(v2,b) >= 0 ) {

Line 1145 N *nmp,*dnp;

Line 1401 N *nmp,*dnp;

/* mat->body = N ** */

int intmtoratm(mat,md,nm,dn)

int intmtoratm(MAT mat,N md,MAT nm,Q *dn)

MAT mat;

N md;

MAT nm;

Q *dn;

{

N t,s,b;

Q bound,dn0,dn1,nm1,q,tq;

Q dn0,dn1,nm1,q;

int i,j,k,l,row,col;

Q **rmat;

N **tmat;

Line 1202 Q *dn;

Line 1454 Q *dn;

/* mat->body = Q ** */

int intmtoratm_q(mat,md,nm,dn)

int intmtoratm_q(MAT mat,N md,MAT nm,Q *dn)

MAT mat;

N md;

MAT nm;

Q *dn;

{

N t,s,b;

Q bound,dn0,dn1,nm1,q,tq;

Q dn0,dn1,nm1,q;

int i,j,k,l,row,col;

Q **rmat;

Q **tmat;

Line 1261 Q *dn;

Line 1509 Q *dn;

#define ONE_STEP1 if ( zzz = *s ) { DMAR(zzz,hc,*tj,md,*tj) } tj++; s++;

void reduce_reducers_mod(mat,row,col,md)

void reduce_reducers_mod(int **mat,int row,int col,int md)

int **mat;

int row,col;

int md;

{

int i,j,k,l,hc,zzz;

int *t,*s,*tj,*ind;

Line 1319 int md;

Line 1564 int md;

2. reduce spolys by the reduced reducers

void pre_reduce_mod(mat,row,col,nred,md)

void pre_reduce_mod(int **mat,int row,int col,int nred,int md)

int **mat;

int row,col,nred;

int md;

{

int i,j,k,l,hc,inv;

int *t,*s,*tk,*ind;

Line 1372 int md;

Line 1614 int md;

mat[0] < mat[1] < ... < mat[nred-1] w.r.t the term order

void reduce_sp_by_red_mod(sp,redmat,ind,nred,col,md)

void reduce_sp_by_red_mod(int *sp,int **redmat,int *ind,int nred,int col,int md)

int *sp,**redmat;

int *ind;

int nred,col;

int md;

{

int i,j,k,hc,zzz;

int *t,*s,*tj;

int *s,*tj;

/* reduce the spolys by redmat */

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

Line 1402 int md;

Line 1640 int md;

mat[0] < mat[1] < ... < mat[nred-1] w.r.t the term order

void reduce_sp_by_red_mod_compress (sp,redmat,ind,nred,col,md)

void red_by_compress(int m,unsigned int *p,unsigned int *r,

int *sp;

unsigned int *ri,unsigned int hc,int len)

CDP *redmat;

int *ind;

int nred,col;

int md;

{

int i,j,k,hc,c,len;

unsigned int up,lo;

int *tj;

unsigned int dmy;

unsigned int *pj;

p[*ri] = 0; r++; ri++;

for ( len--; len; len--, r++, ri++ ) {

pj = p+ *ri;

DMA(*r,hc,*pj,up,lo);

if ( up ) {

DSAB(m,up,lo,dmy,*pj);

} else

*pj = lo;

}

/* p -= hc*r */

void red_by_vect(int m,unsigned int *p,unsigned int *r,unsigned int hc,int len)

{

unsigned int dmy;

*p++ = 0; r++; len--;

for ( ; len; len--, r++, p++ )

if ( *r ) {

DMA(*r,hc,*p,up,lo);

if ( up ) {

DSAB(m,up,lo,dmy,*p);

} else

*p = lo;

}

void red_by_vect_sf(int m,unsigned int *p,unsigned int *r,unsigned int hc,int len)

{

*p++ = 0; r++; len--;

for ( ; len; len--, r++, p++ )

if ( *r )

*p = _addsf(_mulsf(*r,hc),*p);

}

extern unsigned int **psca;

void reduce_sp_by_red_mod_compress (int *sp,CDP *redmat,int *ind,

int nred,int col,int md)

{

int i,len;

CDP ri;

unsigned int hc;

unsigned int *usp;

usp = (unsigned int *)sp;

/* reduce the spolys by redmat */

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

/* reduce sp by redmat[i] */

if ( hc = sp[ind[i]] ) {

usp[ind[i]] %= md;

if ( hc = usp[ind[i]] ) {

/* sp = sp-hc*redmat[i] */

hc = md-hc;

ri = redmat[i];

len = ri->len;

for ( k = 0; k < len; k++ ) {

red_by_compress(md,usp,psca[ri->psindex],ri->body,hc,len);

j = ri->body[k].index;

c = ri->body[k].c;

tj = sp+j;

#if 1

DMAR(c,hc,*tj,md,*tj);

#else

*tj = ((hc*c)+(*tj))%md;

#endif

}

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

if ( usp[i] >= (unsigned int)md )

usp[i] %= md;

}

#define ONE_STEP2 if ( zzz = *pk ) { DMAR(zzz,a,*tk,md,*tk) } pk++; tk++;

int generic_gauss_elim_mod(mat,row,col,md,colstat)

int generic_gauss_elim_mod(int **mat0,int row,int col,int md,int *colstat)

int **mat;

int row,col,md;

int *colstat;

{

int i,j,k,l,inv,a,rank,zzz;

int i,j,k,l,inv,a,rank;

int *t,*pivot,*pk,*tk;

unsigned int *t,*pivot,*pk;

unsigned int **mat;

mat = (unsigned int **)mat0;

for ( rank = 0, j = 0; j < col; j++ ) {

for ( i = rank; i < row && !mat[i][j]; i++ );

for ( i = rank; i < row; i++ )

mat[i][j] %= md;

for ( i = rank; i < row; i++ )

if ( mat[i][j] )

break;

if ( i == row ) {

colstat[j] = 0;

continue;

Line 1459 int *colstat;

Line 1739 int *colstat;

inv = invm(pivot[j],md);

for ( k = j, pk = pivot+k; k < col; k++, pk++ )

if ( *pk ) {

if ( *pk >= (unsigned int)md )

*pk %= md;

DMAR(*pk,inv,0,md,*pk)

}

for ( i = rank+1; i < row; i++ ) {

t = mat[i];

if ( a = t[j] ) {

if ( a = t[j] )

a = md - a; pk = pivot+j; tk = t+j;

red_by_vect(md,t+j,pivot+j,md-a,col-j);

k = col-j;

}

for ( ; k >= 64; k -= 64 ) {

rank++;

ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2

}

ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2

for ( j = col-1, l = rank-1; j >= 0; j-- )

ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2

if ( colstat[j] ) {

ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2

pivot = mat[l];

ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2

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

ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2

t = mat[i];

ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2

t[j] %= md;

ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2

if ( a = t[j] )

ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2

red_by_vect(md,t+j,pivot+j,md-a,col-j);

ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2

}

for ( ; k > 0; k -- ) {

if ( zzz = *pk ) { DMAR(zzz,a,*tk,md,*tk) } pk++; tk++;

}

l--;

}

for ( j = 0, l = 0; l < rank; j++ )

if ( colstat[j] ) {

t = mat[l];

for ( k = j; k < col; k++ )

if ( t[k] >= (unsigned int)md )

t[k] %= md;

l++;

}

return rank;

}

int generic_gauss_elim_sf(int **mat0,int row,int col,int md,int *colstat)

{

int i,j,k,l,inv,a,rank;

unsigned int *t,*pivot,*pk;

unsigned int **mat;

mat = (unsigned int **)mat0;

for ( rank = 0, j = 0; j < col; j++ ) {

for ( i = rank; i < row; i++ )

if ( 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;

}

pivot = mat[rank];

inv = _invsf(pivot[j]);

for ( k = j, pk = pivot+k; k < col; k++, pk++ )

if ( *pk )

*pk = _mulsf(*pk,inv);

for ( i = rank+1; i < row; i++ ) {

t = mat[i];

if ( a = t[j] )

red_by_vect_sf(md,t+j,pivot+j,_chsgnsf(a),col-j);

}

rank++;

}

for ( j = col-1, l = rank-1; j >= 0; j-- )

Line 1496 int *colstat;

Line 1808 int *colstat;

pivot = mat[l];

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

t = mat[i];

if ( a = t[j] ) {

if ( a = t[j] )

a = md-a; pk = pivot+j; tk = t+j;

red_by_vect_sf(md,t+j,pivot+j,_chsgnsf(a),col-j);

k = col-j;

for ( ; k >= 64; k -= 64 ) {

ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2

}

for ( ; k > 0; k -- ) {

if ( zzz = *pk ) { DMAR(zzz,a,*tk,md,*tk) } pk++; tk++;

}

l--;

}

Line 1529 int *colstat;

Line 1818 int *colstat;

/* LU decomposition; a[i][i] = 1/U[i][i] */

int lu_gfmmat(mat,md,perm)

int lu_gfmmat(GFMMAT mat,unsigned int md,int *perm)

GFMMAT mat;

unsigned int md;

int *perm;

{

int row,col;

int i,j,k,l;

int i,j,k;

unsigned int *t,*pivot;

unsigned int **a;

unsigned int inv,m;

Line 1587 int *perm;

Line 1873 int *perm;

cinfo[j]=1 <=> j-th column is contained in the LU decomp.

int find_lhs_and_lu_mod(a,row,col,md,rinfo,cinfo)

int find_lhs_and_lu_mod(unsigned int **a,int row,int col,

unsigned int **a;

unsigned int md,int **rinfo,int **cinfo)

unsigned int md;

int **rinfo,**cinfo;

{

int i,j,k,l,d;

int i,j,k,d;

int *rp,*cp;

unsigned int *t,*pivot;

unsigned int inv,m;

Line 1640 int **rinfo,**cinfo;

Line 1924 int **rinfo,**cinfo;

b = a^(-1)b

void solve_by_lu_mod(a,n,md,b,l)

void solve_by_lu_mod(int **a,int n,int md,int **b,int l,int normalize)

int **a;

int n;

int md;

int **b;

int l;

{

unsigned int *y,*c;

int i,j,k;

Line 1678 int l;

Line 1957 int l;

DMAR(t,a[i][i],0,md,c[i])

}

/* copy c to b[.][k] with normalization */

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

if ( normalize )

b[i][k] = (int)(c[i]>m2 ? c[i]-md : c[i]);

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

b[i][k] = (int)(c[i]>m2 ? c[i]-md : c[i]);

else

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

b[i][k] = c[i];

}

void Pleqm1(arg,rp)

void Pleqm1(NODE arg,VECT *rp)

NODE arg;

VECT *rp;

{

MAT m;

VECT vect;

Line 1724 VECT *rp;

Line 2005 VECT *rp;

}

gauss_elim_mod1(mat,row,col,md)

int gauss_elim_mod1(int **mat,int row,int col,int md)

int **mat;

int row,col,md;

{

int i,j,k,inv,a,n;

int *t,*pivot;

Line 1763 int row,col,md;

Line 2042 int row,col,md;

return -1;

}

void Pgeninvm(arg,rp)

void Pgeninvm(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

MAT m;

pointer **mat;

Line 1799 LIST *rp;

Line 2076 LIST *rp;

MKMAT(mat1,col,row); MKMAT(mat2,row-col,row);

for ( i = 0, tmat = (Q **)mat1->body; i < col; i++ )

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

STOQ(wmat[i][j+col],tmat[i][j]);

UTOQ(wmat[i][j+col],tmat[i][j]);

for ( tmat = (Q **)mat2->body; i < row; i++ )

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

STOQ(wmat[i][j+col],tmat[i-col][j]);

UTOQ(wmat[i][j+col],tmat[i-col][j]);

MKNODE(node2,mat2,0); MKNODE(node1,mat1,node2); MKLIST(*rp,node1);

}

int gauss_elim_geninv_mod(mat,row,col,md)

int gauss_elim_geninv_mod(unsigned int **mat,int row,int col,int md)

unsigned int **mat;

int row,col,md;

{

int i,j,k,inv,a,n,m;

unsigned int *t,*pivot;

Line 1845 int row,col,md;

Line 2120 int row,col,md;

return 0;

}

void Psolve_by_lu_gfmmat(arg,rp)

void Psolve_by_lu_gfmmat(NODE arg,VECT *rp)

NODE arg;

VECT *rp;

{

GFMMAT lu;

Q *perm,*rhs,*v;

Line 1868 VECT *rp;

Line 2141 VECT *rp;

solve_by_lu_gfmmat(lu,md,b,sol);

MKVECT(r,n);

for ( i = 0, v = (Q *)r->body; i < n; i++ )

STOQ(sol[i],v[i]);

UTOQ(sol[i],v[i]);

*rp = r;

}

void solve_by_lu_gfmmat(lu,md,b,x)

void solve_by_lu_gfmmat(GFMMAT lu,unsigned int md,

GFMMAT lu;

unsigned int *b,unsigned int *x)

unsigned int md;

unsigned int *b;

unsigned int *x;

{

int n;

unsigned int **a;

Line 1908 unsigned int *x;

Line 2178 unsigned int *x;

}

void Plu_gfmmat(arg,rp)

void Plu_gfmmat(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

MAT m;

GFMMAT mm;

Line 1940 LIST *rp;

Line 2208 LIST *rp;

MKLIST(*rp,n0);

}

void Pmat_to_gfmmat(arg,rp)

void Pmat_to_gfmmat(NODE arg,GFMMAT *rp)

NODE arg;

GFMMAT *rp;

{

MAT m;

unsigned int md;

Line 1953 GFMMAT *rp;

Line 2219 GFMMAT *rp;

mat_to_gfmmat(m,md,rp);

}

void mat_to_gfmmat(m,md,rp)

void mat_to_gfmmat(MAT m,unsigned int md,GFMMAT *rp)

MAT m;

unsigned int md;

GFMMAT *rp;

{

unsigned int **wmat;

unsigned int t;

Line 2082 int **indexp;

Line 2345 int **indexp;

return 0;

}

void Pgeninv_sf_swap(NODE arg,LIST *rp)

{

MAT m;

GFS **mat,**tmat;

Q *tvect;

GFS q;

int **wmat,**invmat;

int *index;

unsigned int t;

int i,j,row,col,status;

MAT mat1;

VECT vect1;

NODE node1,node2;

asir_assert(ARG0(arg),O_MAT,"geninv_sf_swap");

m = (MAT)ARG0(arg);

row = m->row; col = m->col; mat = (GFS **)m->body;

wmat = (int **)almat(row,col+row);

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

bzero((char *)wmat[i],(col+row)*sizeof(int));

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

if ( q = (GFS)mat[i][j] )

wmat[i][j] = FTOIF(CONT(q));

wmat[i][col+i] = _onesf();

}

status = gauss_elim_geninv_sf_swap(wmat,row,col,&invmat,&index);

if ( status > 0 )

*rp = 0;

else {

MKMAT(mat1,col,col);

for ( i = 0, tmat = (GFS **)mat1->body; i < col; i++ )

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

if ( t = invmat[i][j] ) {

MKGFS(IFTOF(t),tmat[i][j]);

}

MKVECT(vect1,row);

for ( i = 0, tvect = (Q *)vect1->body; i < row; i++ )

STOQ(index[i],tvect[i]);

MKNODE(node2,vect1,0); MKNODE(node1,mat1,node2); MKLIST(*rp,node1);

}

int gauss_elim_geninv_sf_swap(int **mat,int row,int col,

int ***invmatp,int **indexp)

{

int i,j,k,inv,a,n,m,u;

int *t,*pivot,*s;

int *index;

int **invmat;

n = col; m = row+col;

*indexp = index = (int *)MALLOC_ATOMIC(row*sizeof(int));

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

index[i] = i;

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

for ( i = j; i < row && !mat[i][j]; i++ );

if ( i == row ) {

*indexp = 0; *invmatp = 0; return 1;

}

if ( i != j ) {

t = mat[i]; mat[i] = mat[j]; mat[j] = t;

k = index[i]; index[i] = index[j]; index[j] = k;

}

pivot = mat[j];

inv = _invsf(pivot[j]);

for ( k = j; k < m; k++ )

if ( pivot[k] )

pivot[k] = _mulsf(pivot[k],inv);

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

t = mat[i];

if ( a = t[j] )

for ( k = j, a = _chsgnsf(a); k < m; k++ )

if ( pivot[k] ) {

u = _mulsf(pivot[k],a);

t[k] = _addsf(u,t[k]);

}

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

pivot = mat[j];

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

t = mat[i];

if ( a = t[j] )

for ( k = j, a = _chsgnsf(a); k < m; k++ )

if ( pivot[k] ) {

u = _mulsf(pivot[k],a);

t[k] = _addsf(u,t[k]);

}

*invmatp = invmat = (int **)almat(col,col);

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

for ( j = 0, s = invmat[i], t = mat[i]; j < col; j++ )

s[j] = t[col+index[j]];

return 0;

}

void _addn(N,N,N);

int _subn(N,N,N);

void _muln(N,N,N);

void inner_product_int(a,b,n,r)

void inner_product_int(Q *a,Q *b,int n,Q *r)

Q *a,*b;

int n;

Q *r;

{

int la,lb,i;

int sgn,sgn1;

Line 2142 Q *r;

Line 2499 Q *r;

/* (k,l) element of a*b where a: .x n matrix, b: n x . integer matrix */

void inner_product_mat_int_mod(a,b,n,k,l,r)

void inner_product_mat_int_mod(Q **a,int **b,int n,int k,int l,Q *r)

Q **a;

int **b;

int n,k,l;

Q *r;

{

int la,lb,i;

int sgn,sgn1;

Line 2202 Q *r;

Line 2555 Q *r;

NTOQ(sum,sgn,*r);

}

void Pmul_mat_vect_int(arg,rp)

void Pmul_mat_vect_int(NODE arg,VECT *rp)

NODE arg;

VECT *rp;

{

MAT mat;

VECT vect,r;

Line 2215 VECT *rp;

Line 2566 VECT *rp;

row = mat->row;

col = mat->col;

MKVECT(r,row);

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

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

inner_product_int(mat->body[i],vect->body,col,&r->body[i]);

inner_product_int((Q *)mat->body[i],(Q *)vect->body,col,(Q *)&r->body[i]);

}

*rp = r;

}

void Pnbpoly_up2(arg,rp)

void Pnbpoly_up2(NODE arg,GF2N *rp)

NODE arg;

GF2N *rp;

{

int m,type,ret;

UP2 r;

Line 2236 GF2N *rp;

Line 2586 GF2N *rp;

*rp = 0;

}

void Px962_irredpoly_up2(arg,rp)

void Px962_irredpoly_up2(NODE arg,GF2N *rp)

NODE arg;

GF2N *rp;

{

int m,type,ret,w;

int m,ret,w;

GF2N prev;

UP2 r;

Line 2256 GF2N *rp;

Line 2604 GF2N *rp;

bzero((char *)r->b,w*sizeof(unsigned int));

}

ret = _generate_irreducible_polynomial(r,m,type);

ret = _generate_irreducible_polynomial(r,m);

if ( ret == 0 )

MKGF2N(r,*rp);

else

*rp = 0;

}

void Pirredpoly_up2(arg,rp)

void Pirredpoly_up2(NODE arg,GF2N *rp)

NODE arg;

GF2N *rp;

{

int m,type,ret,w;

int m,ret,w;

GF2N prev;

UP2 r;

Line 2283 GF2N *rp;

Line 2629 GF2N *rp;

bzero((char *)r->b,w*sizeof(unsigned int));

}

ret = _generate_good_irreducible_polynomial(r,m,type);

ret = _generate_good_irreducible_polynomial(r,m);

if ( ret == 0 )

MKGF2N(r,*rp);

else

*rp = 0;

}

void Pmat_swap_row_destructive(NODE arg, MAT *m)

{

int i1,i2;

pointer *t;

MAT mat;

asir_assert(ARG0(arg),O_MAT,"mat_swap_row_destructive");

asir_assert(ARG1(arg),O_N,"mat_swap_row_destructive");

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

mat = (MAT)ARG0(arg);

i1 = QTOS((Q)ARG1(arg));

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

if ( i1 < 0 || i2 < 0 || i1 >= mat->row || i2 >= mat->row )

error("mat_swap_row_destructive : Out of range");

t = mat->body[i1];

mat->body[i1] = mat->body[i2];

mat->body[i2] = t;

*m = mat;

}

void Pmat_swap_col_destructive(NODE arg, MAT *m)

{

int j1,j2,i,n;

pointer *mi;

pointer t;

MAT mat;

asir_assert(ARG0(arg),O_MAT,"mat_swap_col_destructive");

asir_assert(ARG1(arg),O_N,"mat_swap_col_destructive");

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

mat = (MAT)ARG0(arg);

j1 = QTOS((Q)ARG1(arg));

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

if ( j1 < 0 || j2 < 0 || j1 >= mat->col || j2 >= mat->col )

error("mat_swap_col_destructive : Out of range");

n = mat->row;

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

mi = mat->body[i];

t = mi[j1]; mi[j1] = mi[j2]; mi[j2] = t;

}

*m = mat;

}

* f = type 'type' normal polynomial of degree m if exists

* IEEE P1363 A.7.2

Line 2563 PENTA:

Line 2951 PENTA:

return 1;

}

printqmat(mat,row,col)

void printqmat(Q **mat,int row,int col)

Q **mat;

int row,col;

{

int i,j;

Line 2577 int row,col;

Line 2963 int row,col;

}

printimat(mat,row,col)

void printimat(int **mat,int row,int col)

int **mat;

int row,col;

{

int i,j;

Line 2589 int row,col;

Line 2973 int row,col;

}

printf("\n");

}

void Pnd_det(NODE arg,P *rp)

{

if ( argc(arg) == 1 )

nd_det(0,ARG0(arg),rp);

else

nd_det(QTOS((Q)ARG1(arg)),ARG0(arg),rp);

}

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