[BACK]Return to array.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / builtin

Diff for /OpenXM_contrib2/asir2000/builtin/array.c between version 1.57 and 1.64

version 1.57, 2009/02/03 00:39:23 version 1.64, 2013/11/05 02:55:02
Line 45 
Line 45 
  * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,   * DEVELOPER SHALL HAVE NO LIABILITY IN CONNECTION WITH THE USE,
  * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.   * PERFORMANCE OR NON-PERFORMANCE OF THE SOFTWARE.
  *   *
  * $OpenXM: OpenXM_contrib2/asir2000/builtin/array.c,v 1.56 2007/11/23 05:43:23 ohara Exp $   * $OpenXM: OpenXM_contrib2/asir2000/builtin/array.c,v 1.63 2013/09/09 07:29:25 noro Exp $
 */  */
 #include "ca.h"  #include "ca.h"
 #include "base.h"  #include "base.h"
Line 54 
Line 54 
   
 #include <sys/types.h>  #include <sys/types.h>
 #include <sys/stat.h>  #include <sys/stat.h>
   #if !defined(_MSC_VER)
 #include <unistd.h>  #include <unistd.h>
   #endif
   
 #define F4_INTRAT_PERIOD 8  #define F4_INTRAT_PERIOD 8
   
Line 95  void Pmat();
Line 97  void Pmat();
 void Pmatc();  void Pmatc();
 void Pnd_det();  void Pnd_det();
 void Plu_mat();  void Plu_mat();
   void Pmat_col();
   void Plusolve_prep();
   void Plusolve_main();
   
 struct ftab array_tab[] = {  struct ftab array_tab[] = {
         {"lu_mat",Plu_mat,1},          {"lu_mat",Plu_mat,1},
Line 140  struct ftab array_tab[] = {
Line 145  struct ftab array_tab[] = {
         {"nbpoly_up2",Pnbpoly_up2,2},          {"nbpoly_up2",Pnbpoly_up2,2},
         {"mat_swap_row_destructive",Pmat_swap_row_destructive,3},          {"mat_swap_row_destructive",Pmat_swap_row_destructive,3},
         {"mat_swap_col_destructive",Pmat_swap_col_destructive,3},          {"mat_swap_col_destructive",Pmat_swap_col_destructive,3},
           {"mat_col",Pmat_col,2},
           {"lusolve_prep",Plusolve_prep,1},
           {"lusolve_main",Plusolve_main,1},
         {0,0,0},          {0,0,0},
 };  };
   
   typedef struct _ent { int j; unsigned int e; } ent;
   
   ent *get_row(FILE *,int *l);
   void put_row(FILE *out,int l,ent *a);
   int lu_elim(int *l,ent **a,int k,int i,int mul,int mod);
   
   static int *ul,*ll;
   static ent **u,**l;
   static int modulus;
   
   void Plusolve_prep(NODE arg,Q *rp)
   {
           char *fname;
           FILE *in;
           int len,i,rank;
           int *rhs;
   
           fname = BDY((STRING)ARG0(arg));
           in = fopen(fname,"r");
           modulus = getw(in);
           len = getw(in);
           ul = (int *)MALLOC_ATOMIC(len*sizeof(int));
           u = (ent **)MALLOC(len*sizeof(ent *));
           ll = (int *)MALLOC_ATOMIC(len*sizeof(int));
           l = (ent **)MALLOC(len*sizeof(ent *));
           for ( i = 0; i < len; i++ ) {
                   u[i] = get_row(in,&ul[i]);
           }
           for ( i = 0; i < len; i++ ) {
                   l[i] = get_row(in,&ll[i]);
           }
           fclose(in);
           *rp = ONE;
   }
   
   void Plusolve_main(NODE arg,VECT *rp)
   {
           Q *d,*p;
           VECT v,r;
           int len,i;
           int *rhs;
   
           v = (VECT)ARG0(arg); len = v->len;
           d = (Q *)BDY(v);
           rhs = (int *)MALLOC_ATOMIC(len*sizeof(int));
           for ( i = 0; i < len; i++ ) rhs[i] = QTOS(d[i]);
           solve_l(ll,l,len,rhs,modulus);
           solve_u(ul,u,len,rhs,modulus);
           NEWVECT(r); r->len = len;
           r->body = (pointer *)MALLOC(len*sizeof(pointer));
           p = (Q *)r->body;
           for ( i = 0; i < len; i++ )
                   STOQ(rhs[i],p[i]);
           *rp = r;
   }
   
   ent *get_row(FILE *in,int *l)
   {
           int len,i;
           ent *a;
   
           *l = len = getw(in);
           a = (ent *)MALLOC_ATOMIC(len*sizeof(ent));
           for ( i = 0; i < len; i++ ) {
                   a[i].j = getw(in);
                   a[i].e = getw(in);
           }
           return a;
   }
   
   int lu_gauss(int *ul,ent **u,int *ll,ent **l,int n,int mod)
   {
           int i,j,k,s,mul;
           unsigned int inv;
           int *ll2;
   
           ll2 = (int *)MALLOC_ATOMIC(n*sizeof(int));
           for ( i = 0; i < n; i++ ) ll2[i] = 0;
           for ( i = 0; i < n; i++ ) {
                   fprintf(stderr,"i=%d\n",i);
                   inv = invm(u[i][0].e,mod);
                   for ( k = i+1; k < n; k++ )
                           if ( u[k][0].j == n-i ) {
                                   s = u[k][0].e;
                                   DMAR(s,inv,0,mod,mul);
                                   lu_elim(ul,u,k,i,mul,mod);
                                   lu_append(ll,l,ll2,k,i,mul);
                           }
           }
   }
   
   #define INITLEN 10
   
   lu_append(int *l,ent **a,int *l2,int k,int i,int mul)
   {
           int len;
           ent *p;
   
           len = l[k];
           if ( !len ) {
                   a[k] = p = (ent *)MALLOC_ATOMIC(INITLEN*sizeof(ent));
                   p[0].j = i; p[0].e = mul;
                   l[k] = 1; l2[k] = INITLEN;
           } else {
                   if ( l2[k] == l[k] ) {
                           l2[k] *= 2;
                           a[k] = REALLOC(a[k],l2[k]*sizeof(ent));
                   }
                   p =a[k];
                   p[l[k]].j = i; p[l[k]].e = mul;
                   l[k]++;
           }
   }
   
   /* a[k] = a[k]-mul*a[i] */
   
   int lu_elim(int *l,ent **a,int k,int i,int mul,int mod)
   {
           ent *ak,*ai,*w;
           int lk,li,j,m,p,q,r,s,t,j0;
   
           ak = a[k]; ai = a[i]; lk = l[k]; li = l[i];
           w = (ent *)alloca((lk+li)*sizeof(ent));
           p = 0; q = 0; j = 0;
           mul = mod-mul;
           while ( p < lk && q < li ) {
                   if ( ak[p].j > ai[q].j ) {
                           w[j] = ak[p]; j++; p++;
                   } else if ( ak[p].j < ai[q].j ) {
                           w[j].j = ai[q].j;
                           t = ai[q].e;
                           DMAR(t,mul,0,mod,r);
                           w[j].e = r;
                           j++; q++;
                   } else {
                           t = ai[q].e; s = ak[p].e;
                           DMAR(t,mul,s,mod,r);
                           if ( r ) {
                                   w[j].j = ai[q].j; w[j].e = r; j++;
                           }
                           p++; q++;
                   }
           }
           if ( q == li )
                   while ( p < lk ) {
                           w[j] = ak[p]; j++; p++;
                   }
           else if ( p == lk )
                   while ( q < li ) {
                           w[j].j = ai[q].j;
                           t = ai[q].e;
                           DMAR(t,mul,0,mod,r);
                           w[j].e = r;
                           j++; q++;
                   }
           if ( j <= lk ) {
                   for ( m = 0; m < j; m++ ) ak[m] = w[m];
           } else {
                   a[k] = ak = (ent *)MALLOC_ATOMIC(j*sizeof(ent));
                   for ( m = 0; m < j; m++ ) ak[m] = w[m];
           }
           l[k] = j;
   }
   
   int solve_l(int *ll,ent **l,int n,int *rhs,int mod)
   {
           int j,k,s,len;
           ent *p;
   
           for ( j = 0; j < n; j++ ) {
                   len = ll[j]; p = l[j];
                   for ( k = 0, s = 0; k < len; k++ )
                           s = dmar(p[k].e,rhs[p[k].j],s,mod);
                   rhs[j] -=  s;
                   if ( rhs[j] < 0 ) rhs[j] += mod;
           }
   }
   
   int solve_u(int *ul,ent **u,int n,int *rhs,int mod)
   {
           int j,k,s,len,inv;
           ent *p;
   
           for ( j = n-1; j >= 0; j-- ) {
                   len = ul[j]; p = u[j];
                   for ( k = 1, s = 0; k < len; k++ )
                           s = dmar(p[k].e,rhs[p[k].j],s,mod);
                   rhs[j] -=  s;
                   if ( rhs[j] < 0 ) rhs[j] += mod;
                   inv = invm((unsigned int)p[0].e,mod);
                   rhs[j] = dmar(rhs[j],inv,0,mod);
           }
   }
   
 int comp_obj(Obj *a,Obj *b)  int comp_obj(Obj *a,Obj *b)
 {  {
         return arf_comp(CO,*a,*b);          return arf_comp(CO,*a,*b);
Line 150  int comp_obj(Obj *a,Obj *b)
Line 352  int comp_obj(Obj *a,Obj *b)
   
 static FUNC generic_comp_obj_func;  static FUNC generic_comp_obj_func;
 static NODE generic_comp_obj_arg;  static NODE generic_comp_obj_arg;
   static NODE generic_comp_obj_option;
   
 int generic_comp_obj(Obj *a,Obj *b)  int generic_comp_obj(Obj *a,Obj *b)
 {  {
Line 157  int generic_comp_obj(Obj *a,Obj *b)
Line 360  int generic_comp_obj(Obj *a,Obj *b)
   
         BDY(generic_comp_obj_arg)=(pointer)(*a);          BDY(generic_comp_obj_arg)=(pointer)(*a);
         BDY(NEXT(generic_comp_obj_arg))=(pointer)(*b);          BDY(NEXT(generic_comp_obj_arg))=(pointer)(*b);
         r = (Q)bevalf(generic_comp_obj_func,generic_comp_obj_arg);          r = (Q)bevalf_with_opts(generic_comp_obj_func,generic_comp_obj_arg,generic_comp_obj_option);
         if ( !r )          if ( !r )
                 return 0;                  return 0;
         else          else
Line 204  void Pqsort(NODE arg,LIST *rp)
Line 407  void Pqsort(NODE arg,LIST *rp)
                         func = (FUNC)v->priv;                          func = (FUNC)v->priv;
                 }                  }
                 generic_comp_obj_func = func;                  generic_comp_obj_func = func;
                 MKNODE(n,0,0); MKNODE(generic_comp_obj_arg,0,n);                  MKNODE(n,0,0); MKNODE(generic_comp_obj_arg,0,n);
                   generic_comp_obj_option = current_option;
                 qsort(BDY(vect),vect->len,sizeof(Obj),(int (*)(const void *,const void *))generic_comp_obj);                  qsort(BDY(vect),vect->len,sizeof(Obj),(int (*)(const void *,const void *))generic_comp_obj);
         }          }
     if (OID(t) == O_LIST) {      if (OID(t) == O_LIST) {
Line 338  void Psepmat_destructive(NODE arg,LIST *rp)
Line 542  void Psepmat_destructive(NODE arg,LIST *rp)
                         sgn = SGN(ent);                          sgn = SGN(ent);
                         divn(nm,mod,&quo,&rem);                          divn(nm,mod,&quo,&rem);
 /*                      if ( quo != nm && rem != nm ) */  /*                      if ( quo != nm && rem != nm ) */
 /*                              GC_free(nm); */  /*                              GCFREE(nm); */
 /*                      GC_free(ent); */  /*                      GCFREE(ent); */
                         NTOQ(rem,sgn,a[i][j]); NTOQ(quo,sgn,a1[i][j]);                          NTOQ(rem,sgn,a[i][j]); NTOQ(quo,sgn,a1[i][j]);
                 }                  }
         MKNODE(n1,mat1,0); MKNODE(n0,mat,n1);          MKNODE(n1,mat1,0); MKNODE(n0,mat,n1);
Line 405  void Pnewvect(NODE arg,VECT *rp)
Line 609  void Pnewvect(NODE arg,VECT *rp)
 }  }
   
 void Pvect(NODE arg,VECT *rp) {  void Pvect(NODE arg,VECT *rp) {
         int len,i,r;          int len,i;
         VECT vect;          VECT vect;
         pointer *vb;          pointer *vb;
         NODE tn;          NODE tn;
Line 917  void Pgeneric_gauss_elim(NODE arg,LIST *rp)
Line 1121  void Pgeneric_gauss_elim(NODE arg,LIST *rp)
         int *ri,*ci;          int *ri,*ci;
         VECT rind,cind;          VECT rind,cind;
         Q dn,q;          Q dn,q;
         int i,j,k,l,row,col,t,rank;          int i,row,col,t,rank;
         int is_hensel = 0;          int is_hensel = 0;
         char *key;          char *key;
         Obj value;          Obj value;
Line 1260  RESET:
Line 1464  RESET:
         }          }
 }  }
   
   void lu_dec_cr(MAT mat,MAT lu,Q *dn,int **perm);
   
 /* XXX broken */  /* XXX broken */
 int lu_dec_cr(MAT mat,MAT lu,Q *dn,int **perm)  void lu_dec_cr(MAT mat,MAT lu,Q *dn,int **perm)
 {  {
         Q **a0,**b;          Q **a0,**b;
         Q *aiq;          Q *aiq;
Line 1363  int lu_dec_cr(MAT mat,MAT lu,Q *dn,int **perm)
Line 1569  int lu_dec_cr(MAT mat,MAT lu,Q *dn,int **perm)
         }          }
 }  }
   
 int nmat(N **m,int n)  void nmat(N **m,int n)
 {  {
         int i,j;          int i,j;
   
Line 2076  void red_by_compress(int m,unsigned int *p,unsigned in
Line 2282  void red_by_compress(int m,unsigned int *p,unsigned in
   
 void red_by_vect(int m,unsigned int *p,unsigned int *r,unsigned int hc,int len)  void red_by_vect(int m,unsigned int *p,unsigned int *r,unsigned int hc,int len)
 {  {
         register unsigned int up,lo;          unsigned int up,lo,dmy;
         unsigned int dmy;  
   
         *p++ = 0; r++; len--;          *p++ = 0; r++; len--;
         for ( ; len; len--, r++, p++ )          for ( ; len; len--, r++, p++ )
Line 2958  void inner_product_int(Q *a,Q *b,int n,Q *r)
Line 3163  void inner_product_int(Q *a,Q *b,int n,Q *r)
                         t = wma; wma = sum; sum = t;                          t = wma; wma = sum; sum = t;
                 }                  }
         }          }
         GC_free(wm);          GCFREE(wm);
         GC_free(wma);          GCFREE(wma);
         if ( !sgn ) {          if ( !sgn ) {
                 GC_free(sum);                  GCFREE(sum);
                 *r = 0;                  *r = 0;
         } else          } else
                 NTOQ(sum,sgn,*r);                  NTOQ(sum,sgn,*r);
Line 3016  void inner_product_mat_int_mod(Q **a,int **b,int n,int
Line 3221  void inner_product_mat_int_mod(Q **a,int **b,int n,int
                         t = wma; wma = sum; sum = t;                          t = wma; wma = sum; sum = t;
                 }                  }
         }          }
         GC_free(wm);          GCFREE(wm);
         GC_free(wma);          GCFREE(wma);
         if ( !sgn ) {          if ( !sgn ) {
                 GC_free(sum);                  GCFREE(sum);
                 *r = 0;                  *r = 0;
         } else          } else
                 NTOQ(sum,sgn,*r);                  NTOQ(sum,sgn,*r);
Line 3451  void Pnd_det(NODE arg,P *rp)
Line 3656  void Pnd_det(NODE arg,P *rp)
                 nd_det(0,ARG0(arg),rp);                  nd_det(0,ARG0(arg),rp);
         else          else
                 nd_det(QTOS((Q)ARG1(arg)),ARG0(arg),rp);                  nd_det(QTOS((Q)ARG1(arg)),ARG0(arg),rp);
   }
   
   void Pmat_col(NODE arg,VECT *rp)
   {
           int i,j,n;
           MAT mat;
           VECT vect;
   
           asir_assert(ARG0(arg),O_MAT,"mat_col");
           asir_assert(ARG1(arg),O_N,"mat_col");
           mat = (MAT)ARG0(arg);
           j = QTOS((Q)ARG1(arg));
           if ( j < 0 || j >= mat->col) {
                   error("mat_col : Out of range");
           }
           n = mat->row;
           MKVECT(vect,n);
           for(i=0; i<n; i++) {
                   BDY(vect)[i] = BDY(mat)[i][j];
           }
           *rp = vect;
 }  }
Legend:
Removed from v.1.57  
changed lines
  Added in v.1.64
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>