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.24

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

version 1.24, 2001/10/09 01:36:05

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.23 2001/10/01 01:58:01 noro Exp $

#include "ca.h"

#include "base.h"

Line 59

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

Line 109 struct ftab array_tab[] = {

Line 98 struct ftab array_tab[] = {

{"vtol",Pvtol,1},

{"size",Psize,1},

{"det",Pdet,-2},

{"invmat",Pinvmat,-2},

{"leqm",Pleqm,2},

{"leqm1",Pleqm1,2},

{"geninvm",Pgeninvm,2},

Line 126 struct ftab array_tab[] = {

Line 116 struct ftab array_tab[] = {

{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 124 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 138 Obj *a,*b;

}

void Pqsort(arg,rp)

void Pqsort(NODE arg,VECT *rp)

NODE arg;

VECT *rp;

{

VECT vect;

char buf[BUFSIZ];

char *fname;

NODE n;

P p;

V v;

Line 179 VECT *rp;

Line 163 VECT *rp;

*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 200 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 231 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 251 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 260 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 291 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 320 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 347 VECT *rp;

*rp = vect;

}

void Pexponent_vector(arg,rp)

void Pexponent_vector(NODE arg,DP *rp)

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 394 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 429 MAT *rp;

*rp = m;

}

void Pvtol(arg,rp)

void Pvtol(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

NODE n,n1;

VECT v;

Line 485 LIST *rp;

Line 444 LIST *rp;

MKLIST(*rp,n);

}

void Premainder(arg,rp)

void Premainder(NODE arg,Obj *rp)

NODE arg;

Obj *rp;

{

Obj a;

VECT v,w;

Line 535 Obj *rp;

Line 492 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 541 Obj *rp;

}

void Psize(arg,rp)

void Psize(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

int n,m;

Line 614 LIST *rp;

Line 567 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 591 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 635 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_mod(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

NODE n0;

MAT m,mat;

Line 663 LIST *rp;

Line 645 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 685 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 724 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 785 int row,col,md;

Line 763 int row,col,md;

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

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 941 RESET:

Line 915 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 1069 int **rindp,**cindp;

Line 1039 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 1087 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 1109 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 1162 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 1217 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 1272 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 1322 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 1348 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;

}

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 1439 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 ) {

ONE_STEP2 ONE_STEP2 ONE_STEP2 ONE_STEP2

}

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

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

}

rank++;

}

Line 1496 int *colstat;

Line 1455 int *colstat;

pivot = mat[l];

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

t = mat[i];

if ( a = t[j] ) {

t[j] %= md;

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

if ( a = t[j] )

k = col-j;

red_by_vect(md,t+j,pivot+j,md-a,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--;

}

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;

}

/* 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 1529 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 1580 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 **a;

int n;

int md;

int **b;

int l;

{

unsigned int *y,*c;

int i,j,k;

Line 1683 int l;

Line 1618 int l;

}

void Pleqm1(arg,rp)

void Pleqm1(NODE arg,VECT *rp)

NODE arg;

VECT *rp;

{

MAT m;

VECT vect;

Line 1724 VECT *rp;

Line 1657 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 1694 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 1728 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 1772 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 1793 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 1830 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 1860 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 1871 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 1979 GFMMAT *rp;

Line 1894 GFMMAT *rp;

TOGFMMAT(row,col,wmat,*rp);

}

void Pgeninvm_swap(arg,rp)

void Pgeninvm_swap(NODE arg,LIST *rp)

NODE arg;

LIST *rp;

{

MAT m;

pointer **mat;

Line 2027 LIST *rp;

Line 1940 LIST *rp;

}

gauss_elim_geninv_mod_swap(mat,row,col,md,invmatp,indexp)

int gauss_elim_geninv_mod_swap(unsigned int **mat,int row,int col,

unsigned int **mat;

unsigned int md,unsigned int ***invmatp,int **indexp)

int row,col;

unsigned int md;

unsigned int ***invmatp;

int **indexp;

{

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

unsigned int *t,*pivot,*s;

Line 2086 void _addn(N,N,N);

Line 1995 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 2048 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 2104 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 2115 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 2135 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 2153 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 2178 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

Line 2563 PENTA:

Line 2458 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 2470 int row,col;

}

printimat(mat,row,col)

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

int **mat;

int row,col;

{

int i,j;

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