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.5 and 1.21

version 1.5, 2000/06/05 02:26:47

version 1.21, 2001/09/17 07:16:58

Line 1

/* $OpenXM: OpenXM_contrib2/asir2000/builtin/array.c,v 1.4 2000/05/29 08:54:44 noro Exp $ */

* FUJITSU LABORATORIES LIMITED ("FLL") hereby grants you a limited,

* non-exclusive and royalty-free license to use, copy, modify and

* redistribute, solely for non-commercial and non-profit purposes, the

* computer program, "Risa/Asir" ("SOFTWARE"), subject to the terms and

* conditions of this Agreement. For the avoidance of doubt, you acquire

* only a limited right to use the SOFTWARE hereunder, and FLL or any

* third party developer retains all rights, including but not limited to

* copyrights, in and to the SOFTWARE.

* (1) FLL does not grant you a license in any way for commercial

* purposes. You may use the SOFTWARE only for non-commercial and

* non-profit purposes only, such as academic, research and internal

* business use.

* (2) The SOFTWARE is protected by the Copyright Law of Japan and

* international copyright treaties. If you make copies of the SOFTWARE,

* with or without modification, as permitted hereunder, you shall affix

* to all such copies of the SOFTWARE the above copyright notice.

* (3) An explicit reference to this SOFTWARE and its copyright owner

* shall be made on your publication or presentation in any form of the

* results obtained by use of the SOFTWARE.

* (4) In the event that you modify the SOFTWARE, you shall notify FLL by

* e-mail at risa-admin@sec.flab.fujitsu.co.jp of the detailed specification

* for such modification or the source code of the modified part of the

* SOFTWARE.

* THE SOFTWARE IS PROVIDED AS IS WITHOUT ANY WARRANTY OF ANY KIND. FLL

* MAKES ABSOLUTELY NO WARRANTIES, EXPRESSED, IMPLIED OR STATUTORY, AND

* EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS

* FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT OF THIRD PARTIES'

* RIGHTS. NO FLL DEALER, AGENT, EMPLOYEES IS AUTHORIZED TO MAKE ANY

* MODIFICATIONS, EXTENSIONS, OR ADDITIONS TO THIS WARRANTY.

* UNDER NO CIRCUMSTANCES AND UNDER NO LEGAL THEORY, TORT, CONTRACT,

* OR OTHERWISE, SHALL FLL BE LIABLE TO YOU OR ANY OTHER PERSON FOR ANY

* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, PUNITIVE OR CONSEQUENTIAL

* DAMAGES OF ANY CHARACTER, INCLUDING, WITHOUT LIMITATION, DAMAGES

* ARISING OUT OF OR RELATING TO THE SOFTWARE OR THIS AGREEMENT, DAMAGES

* FOR LOSS OF GOODWILL, WORK STOPPAGE, OR LOSS OF DATA, OR FOR ANY

* DAMAGES, EVEN IF FLL SHALL HAVE BEEN INFORMED OF THE POSSIBILITY OF

* SUCH DAMAGES, OR FOR ANY CLAIM BY ANY OTHER PARTY. EVEN IF A PART

* OF THE SOFTWARE HAS BEEN DEVELOPED BY A THIRD PARTY, THE THIRD PARTY

* 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.20 2001/09/17 03:33:57 noro Exp $

#include "ca.h"

#include "base.h"

#include "parse.h"

Line 9

Line 57

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

#endif

extern int Print; /* XXX */

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

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

Line 67 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 **);

void reduce_sp_by_red_mod_compress (int *,CDP *,int *,int,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 Pnewbytearray();

void Pgeneric_gauss_elim_mod();

Line 41 void Px962_irredpoly_up2();

Line 91 void Px962_irredpoly_up2();

void Pirredpoly_up2();

void Pnbpoly_up2();

void Pqsort();

void Pexponent_vector();

struct ftab array_tab[] = {

{"solve_by_lu_gfmmat",Psolve_by_lu_gfmmat,4},

Line 48 struct ftab array_tab[] = {

Line 99 struct ftab array_tab[] = {

{"mat_to_gfmmat",Pmat_to_gfmmat,2},

{"generic_gauss_elim_mod",Pgeneric_gauss_elim_mod,2},

{"newvect",Pnewvect,-2},

{"vector",Pnewvect,-2},

{"exponent_vector",Pexponent_vector,-99999999},

{"newmat",Pnewmat,-3},

{"matrix",Pnewmat,-3},

{"newbytearray",Pnewbytearray,-2},

{"sepmat_destructive",Psepmat_destructive,2},

{"sepvect",Psepvect,2},

{"qsort",Pqsort,-2},

Line 326 VECT *rp;

Line 381 VECT *rp;

*rp = vect;

}

void Pexponent_vector(arg,rp)

NODE arg;

DP *rp;

{

nodetod(arg,rp);

}

void Pnewbytearray(arg,rp)

NODE arg;

BYTEARRAY *rp;

{

int len,i,r;

BYTEARRAY array;

unsigned char *vb;

char *str;

LIST list;

NODE tn;

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

len = QTOS((Q)ARG0(arg));

if ( len < 0 )

error("newbytearray : invalid size");

MKBYTEARRAY(array,len);

if ( argc(arg) == 2 ) {

if ( !ARG1(arg) )

error("newbytearray : invalid initialization");

switch ( OID((Obj)ARG1(arg)) ) {

case O_LIST:

list = (LIST)ARG1(arg);

asir_assert(list,O_LIST,"newbytearray");

for ( r = 0, tn = BDY(list); tn; r++, tn = NEXT(tn) );

if ( r <= len ) {

for ( i = 0, tn = BDY(list), vb = BDY(array); tn;

i++, tn = NEXT(tn) )

vb[i] = (unsigned char)QTOS((Q)BDY(tn));

}

break;

case O_STR:

str = BDY((STRING)ARG1(arg));

r = strlen(str);

if ( r <= len )

bcopy(str,BDY(array),r);

break;

default:

if ( !ARG1(arg) )

error("newbytearray : invalid initialization");

}

*rp = array;

}

void Pnewmat(arg,rp)

NODE arg;

MAT *rp;

Line 664 int row,col,md;

Line 770 int row,col,md;

t = mat[i];

if ( i != j && (a = t[j]) )

for ( k = j, a = md - a; k <= n; k++ ) {

unsigned int tk;

/* t[k] = dmar(pivot[k],a,t[k],md); */

DMAR(pivot[k],a,t[k],md,t[k])

DMAR(pivot[k],a,t[k],md,tk)

t[k] = tk;

}

Line 709 int **rindp,**cindp;

Line 817 int **rindp,**cindp;

colstat = (int *)MALLOC_ATOMIC(col*sizeof(int));

wcolstat = (int *)MALLOC_ATOMIC(col*sizeof(int));

for ( ind = 0; ; ind++ ) {

if ( Print ) {

if ( DP_Print ) {

fprintf(asir_out,"."); fflush(asir_out);

}

md = lprime[ind];

md = get_lprime(ind);

get_eg(&tmp0);

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

for ( j = 0, bmi = bmat[i], wmi = wmat[i]; j < col; j++ )

Line 746 RESET:

Line 854 RESET:

}

} else {

if ( rank < rank0 ) {

if ( Print ) {

if ( DP_Print ) {

fprintf(asir_out,"lower rank matrix; continuing...\n");

fflush(asir_out);

}

continue;

} else if ( rank > rank0 ) {

if ( Print ) {

if ( DP_Print ) {

fprintf(asir_out,"higher rank matrix; resetting...\n");

fflush(asir_out);

}

Line 760 RESET:

Line 868 RESET:

} else {

for ( j = 0; (j<col) && (colstat[j]==wcolstat[j]); j++ );

if ( j < col ) {

if ( Print ) {

if ( DP_Print ) {

fprintf(asir_out,"inconsitent colstat; resetting...\n");

fflush(asir_out);

}

Line 799 RESET:

Line 907 RESET:

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

get_eg(&tmp0);

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

if ( ind % 16 )

ret = 0;

else

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

get_eg(&tmp1);

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

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

Line 816 RESET:

Line 927 RESET:

get_eg(&tmp1);

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

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

if ( Print ) {

if ( DP_Print ) {

print_eg("Mod",&eg_mod_split);

print_eg("Elim",&eg_elim_split);

print_eg("ChRem",&eg_chrem_split);

Line 857 int **rindp,**cindp;

Line 968 int **rindp,**cindp;

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

w = (int **)almat(row,col);

for ( ind = 0; ; ind++ ) {

md = lprime[ind];

md = get_lprime(ind);

STOQ(md,mdq);

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

for ( j = 0, ai = a0[i], wi = w[i]; j < col; j++ )

Line 939 int **rindp,**cindp;

Line 1050 int **rindp,**cindp;

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

/* q = q*md */

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

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

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

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

if ( cinfo[j] )

rind[k++] = j;

Line 1193 int md;

Line 1304 int md;

ONE_STEP1 ONE_STEP1 ONE_STEP1 ONE_STEP1

}

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

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

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

}

Line 1280 int md;

Line 1391 int md;

hc = md-hc;

s = redmat[i]+j;

tj = sp+j;

for ( k = col-j; k >= 0; k-- ) {

for ( k = col-j; k > 0; k-- ) {

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

}

mat[i] : compressed reducers (i=0,...,nred-1)

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

int red_by_compress(m,p,r,ri,hc,len)

int m;

unsigned int *p;

unsigned int hc;

{

unsigned int up,lo;

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 */

int red_by_vect(m,p,r,hc,len)

int m;

unsigned int *p,*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 (sp,redmat,ind,nred,col,md)

int *sp;

CDP *redmat;

int *ind;

int nred,col;

int md;

{

int i,j,k,len;

unsigned int *tj;

CDP ri;

unsigned int hc,up,lo,up1,lo1,c;

unsigned int *usp;

usp = (unsigned int *)sp;

/* reduce the spolys by redmat */

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

/* reduce sp by redmat[i] */

usp[ind[i]] %= md;

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

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

hc = md-hc;

ri = redmat[i];

len = ri->len;

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

}

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

if ( usp[i] >= 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(mat0,row,col,md,colstat)

int **mat;

int **mat0;

int row,col,md;

int *colstat;

{

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

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

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

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 1311 int *colstat;

Line 1511 int *colstat;

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

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

if ( *pk ) {

if ( *pk >= 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 1348 int *colstat;

Line 1527 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] >= md )

t[k] %= md;

l++;

}

return rank;

}

Line 1414 int *perm;

Line 1579 int *perm;

DMAR(inv,m,0,md,t[k])

for ( j = k+1, m = md - t[k]; j < col; j++ )

if ( pivot[j] ) {

DMAR(m,pivot[j],t[j],md,t[j])

unsigned int tj;

DMAR(m,pivot[j],t[j],md,tj)

t[j] = tj;

}

Line 1469 int **rinfo,**cinfo;

Line 1637 int **rinfo,**cinfo;

DMAR(inv,m,0,md,t[k])

for ( j = k+1, m = md - t[k]; j < col; j++ )

if ( pivot[j] ) {

DMAR(m,pivot[j],t[j],md,t[j])

unsigned int tj;

DMAR(m,pivot[j],t[j],md,tj)

t[j] = tj;

}

Line 2418 int row,col;

Line 2588 int row,col;

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

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

printnum(mat[i][j]); printf(" ");

printnum((Num)mat[i][j]); printf(" ");

}

printf("\n");

}

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