Return to matrix.c CVS log

Up to [local] / OpenXM / src / kan96xx / Kan

Annotation of OpenXM/src/kan96xx/Kan/matrix.c, Revision 1.1

1.1     ! maekawa     1: /* matrix.c */
        !             2: #include <stdio.h>
        !             3: #include "datatype.h"
        !             4: #include "stackm.h"
        !             5: #include "extern.h"
        !             6: #include "extern2.h"
        !             7:
        !             8: #include "matrix.h"   /* ind() and ind2() are defined. */
        !             9:                       /* You must use n and n2. */
        !            10:
        !            11: struct arrayOfPOLY *aaAdd(aa,bb)
        !            12: struct arrayOfPOLY *aa,*bb;
        !            13: /* this function has not been tested yet. */
        !            14: {
        !            15:   int i;
        !            16:   POLY *r;
        !            17:   POLY *a;
        !            18:   POLY *b;
        !            19:   int size;
        !            20:   struct arrayOfPOLY *ra;
        !            21:   size = aa->n;
        !            22:   a = aa->array; b = bb->array;
        !            23:   r = (POLY *)sGC_malloc(sizeof(POLY)*size);
        !            24:   if (r == (POLY *)NULL) errorMatrix("aaAdd(): no more memory");
        !            25:   for (i=0; i<size; i++) {
        !            26:     r[i] = ppAdd(a[i],b[i]);
        !            27:   }
        !            28:   ra = (struct arrayOfPOLY *)sGC_malloc(sizeof(struct arrayOfPOLY));
        !            29:   if (ra == (struct arrayOfPOLY *)NULL) errorMatrix("No more memory.");
        !            30:   ra->n = size; ra->array = r;
        !            31:   return(ra);
        !            32: }
        !            33:
        !            34: struct matrixOfPOLY *aaMult(aa,bb)
        !            35: struct matrixOfPOLY *aa,*bb;
        !            36: {
        !            37:   POLY *a;
        !            38:   POLY *b;
        !            39:   int m,n,m2,n2; /* c.f. matrix.h */
        !            40:   /*  (m,n) * (m2,n2) */
        !            41:   int i,j,k;
        !            42:   POLY *r;
        !            43:   POLY tmp;
        !            44:   struct matrixOfPOLY *rmat;
        !            45:
        !            46:   m = aa->m; n = aa->n;
        !            47:   m2 = bb->m; n2 = bb->n;
        !            48:   a = aa->mat; b = bb->mat;
        !            49:   r = (POLY *)sGC_malloc(sizeof(POLY)*m*n2);
        !            50:   if (r == (POLY *)NULL) errorMatrix("aaMult(): no more memory");
        !            51:   /* we do not check n == m2. */
        !            52:   for (i=0; i<m; i++) {
        !            53:     for (j=0; j<n2; j++) {
        !            54:       tmp = ZERO;
        !            55:       for (k=0; k<n; k++) {
        !            56:        tmp = ppAddv(tmp, ppMult( a[ind(i,k)], b[ind2(k,j)]));
        !            57:       }
        !            58:       r[ind2(i,j)] = tmp;
        !            59:     }
        !            60:   }
        !            61:   rmat = (struct matrixOfPOLY *)sGC_malloc(sizeof(struct matrixOfPOLY));
        !            62:   if (rmat == (struct matrixOfPOLY *)NULL) errorMatrix("No more memory.");
        !            63:   rmat->m = m; rmat->n = n2;
        !            64:   rmat->mat = r;
        !            65:   return(rmat);
        !            66: }
        !            67:
        !            68:
        !            69: /****************  error handler ************************/
        !            70: void errorMatrix(str)
        !            71: char *str;
        !            72: {
        !            73:   fprintf(stderr,"matrix.c: %s\n",str);
        !            74:   exit(10);
        !            75: }
        !            76:
        !            77: /********************************************************/
        !            78:
        !            79: struct arrayOfPOLY *newArrayOfPOLY(size)
        !            80: int size;
        !            81: /* if size<=0, it returns [0,null]. */
        !            82: {
        !            83:   struct arrayOfPOLY *ap;
        !            84:   ap = (struct arrayOfPOLY *)sGC_malloc(sizeof(struct arrayOfPOLY));
        !            85:   if (ap == (struct arrayOfPOLY *)NULL) errorMatrix("No more memory.");
        !            86:   if (size <=0) {
        !            87:     ap->n = 0; ap->array = (POLY *)NULL;
        !            88:     return(ap);
        !            89:   }
        !            90:   ap->n = size;
        !            91:   ap->array = (POLY *)sGC_malloc(size*sizeof(POLY));
        !            92:   if (ap->array == (POLY *)NULL) errorMatrix("No more memory.");
        !            93:   return(ap);
        !            94: }
        !            95:
        !            96: struct matrixOfPOLY *newMatrixOfPOLY(m,n)
        !            97: int m,n;
        !            98: /* if size<=0, it returns [0,null]. */
        !            99: {
        !           100:   struct matrixOfPOLY *ap;
        !           101:   ap = (struct matrixOfPOLY *)sGC_malloc(sizeof(struct matrixOfPOLY));
        !           102:   if (ap == (struct matrixOfPOLY *)NULL) errorMatrix("No more memory.");
        !           103:   if ((m <=0) || (n <= 0)) {
        !           104:     ap->m = ap->n = 0; ap->mat = (POLY *)NULL;
        !           105:     return(ap);
        !           106:   }
        !           107:   ap->m = m; ap->n = n;
        !           108:   ap->mat = (POLY *)sGC_malloc(m*n*sizeof(POLY));
        !           109:   if (ap->mat == (POLY *)NULL) errorMatrix("No more memory.");
        !           110:   return(ap);
        !           111: }
        !           112:
        !           113:
        !           114: struct arrayOfPOLY *carrayToArrayOfPOLY(a,size)
        !           115: POLY a[];
        !           116: int size;
        !           117: /* a[] is read only. */
        !           118: {
        !           119:   struct arrayOfPOLY *ans;
        !           120:   int i;
        !           121:   ans = newArrayOfPOLY(size);
        !           122:   for (i=0; i<size; i++) {
        !           123:     ans->array[i] = a[i];
        !           124:   }
        !           125:   return(ans);
        !           126: }
        !           127:
        !           128:
        !           129:
        !           130:
        !           131:
        !           132: