matrix.c

00001 #include "matrix.h"
00002 
00003 int CreateMatrix(matrix *m)
00004 {
00005     int i;
00006     int k ;
00007 
00008     m->element = (float**) malloc(m->row * (sizeof (float*)));
00009     if(m->element == NULL)
00010     {
00011         return 1;
00012     }
00013     else
00014     {
00015         for(i = 0; i < m->row; i++)
00016         {
00017             m->element[i]= (float*) malloc(m->col * (sizeof (float)));
00018             if(m->element[i] == NULL)
00019             {
00020                 return 1;
00021             }
00022         }
00023     }
00024     for(i = 0; i < m->row; i++)
00025     {
00026         for(k = 0; k < m->col; k++)
00027         {
00028             m->element[i][k] = 0;
00029         }
00030     }
00031     return 0;
00032 }
00033 
00034 void DeleteMatrix(matrix *m)
00035 {
00036     int i;
00037     for(i = 0; i< m->row; i ++)
00038     {
00039         if (m->element[i]!= NULL)
00040         {
00041             free(m->element[i]);
00042             m->element[i] = NULL;
00043         }
00044     }
00045     if (m->element[i]!= NULL)
00046     {
00047         free(m->element);
00048         m->element = NULL;
00049     }
00050 }
00051 
00052 int InitMatrix(matrix* m, int row, int col)
00053 {
00054     m->row = row;
00055     m->col = col;
00056     return CreateMatrix(m);
00057 }
00058 
00059 int MxM (matrix* a, matrix* b, matrix* r)
00060 {
00061     int i;
00062     int z;
00063     int j;
00064     matrix temp;
00065     InitMatrix(&temp, a->row, b->col);
00066 
00067 
00068     if (a->col != b->row)
00069     {
00070         DeleteMatrix(&temp);
00071         return 1;
00072     }
00073     else if(a->row!=r->row)
00074     {
00075         DeleteMatrix(&temp);
00076         return 2;
00077     }
00078     else if(b->col!=r->col)
00079     {
00080                 DeleteMatrix(&temp);
00081         return 3;
00082     }
00083     else
00084     {
00085 
00086         for(i = 0; i < a->row; i++)
00087         {
00088             for(j = 0; j < b->col; j++)
00089             {
00090                 for(z = 0; z < a->col; z++)
00091                 {
00092                     temp.element[i][j]+= a->element[i][z] * b->element[z][j];
00093                 }
00094             }
00095         }
00096 
00097         for(i = 0; i < temp.row; i++)
00098         {
00099             for(j = 0; j < temp.col; j++)
00100             {
00101                 r->element[i][j]=temp.element[i][j];
00102             }
00103         }
00104         DeleteMatrix(&temp);
00105         return 0;
00106     }
00107 }
00108 
00109 int axM(matrix *m,float a, matrix* r)
00110 {
00111     int i = 0;
00112     int j = 0;
00113     matrix temp;
00114     
00115     InitMatrix(&temp,m->row,m->col);
00116     
00117     if(m->row!=r->row)
00118     {
00119                 DeleteMatrix(&temp);
00120         return 1;
00121     }
00122     else if(m->col!=r->col)
00123     {
00124                 DeleteMatrix(&temp);
00125         return 2;
00126     }
00127     else
00128     {
00129         
00130 
00131         for(i = 0; i < m->row; i++)
00132         {
00133             for(j = 0; j < m->col; j++)
00134             {
00135                 temp.element[i][j] =  (m->element[i][j]) * a;
00136             }
00137         }
00138         for(i = 0; i < temp.row; i++)
00139         {
00140             for(j = 0; j < temp.col; j++)
00141             {
00142                 r->element[i][j]=temp.element[i][j];
00143             }
00144         }
00145         DeleteMatrix(&temp);
00146 
00147         return 0;
00148     }
00149 }
00150 
00151 int Sum(matrix *a, matrix *b, matrix* r)
00152 {
00153     int i = 0;
00154     int j = 0;
00155 
00156     if(a->col != b->col)
00157     {
00158         return 1;
00159     }
00160     else if(a->row != b->row)
00161     {
00162         return 2;
00163     }
00164     else if(a->row != r->row)
00165     {
00166         return 3;
00167     }
00168     else if(a->col != r->col)
00169     {
00170         return 4;
00171     }
00172     else
00173     {
00174         for(i = 0; i < r->row; i++)
00175         {
00176             for(j = 0; j < r->col; j++)
00177             {
00178                 r->element[i][j] =  (a->element[i][j]) + (b->element[i][j]);
00179             }
00180         }
00181 
00182         return 0;
00183     }
00184 }
00185 
00186 int Sub(matrix *a, matrix *b, matrix* r)
00187 {
00188     int i = 0;
00189     int j = 0;
00190 
00191     if(a->col != b->col)
00192     {
00193         return 1;
00194     }
00195     else if(a->row != b->row)
00196     {
00197         return 2;
00198     }
00199     else if(a->row != r->row)
00200     {
00201         return 3;
00202     }
00203     else if(a->col != r->col)
00204     {
00205         return 4;
00206     }
00207     else
00208     {
00209         for(i = 0; i < r->row; i++)
00210         {
00211             for(j = 0; j < r->col; j++)
00212             {
00213                 r->element[i][j] =  (a->element[i][j]) - (b->element[i][j]);
00214             }
00215         }
00216 
00217         return 0;
00218     }
00219 }
00220 
00221 int Traspost(matrix *m, matrix *r)
00222 {
00223     int i;
00224     int j;
00225 
00226     matrix temp;
00227     InitMatrix(&temp,m->row,m->col);
00228     
00229     if (m->row!=r->col)
00230     {
00231         DeleteMatrix(&temp);
00232         return 1;
00233     }
00234     else if (m->col!=r->row)
00235     {
00236         DeleteMatrix(&temp);
00237         return 2;
00238     }
00239     else
00240     {
00241         for(i = 0; i < m->row; i++)
00242         {
00243             for(j = 0; j < m->col; j++)
00244             {
00245                 temp.element[j][i] = m->element[i][j];
00246             }
00247         }
00248 
00249         for(i = 0; i < r->row; i++)
00250         {
00251             for(j = 0; j < r->col; j++)
00252             {
00253                 r->element[i][j] = temp.element[i][j];
00254             }
00255         }
00256 
00257         DeleteMatrix(&temp);
00258         return 0;
00259     }
00260 }
00261 
00262 int Inv(matrix *m, matrix *inv_m)
00263 {
00264     int i = 0;
00265     int j = 0;
00266     int k = 0;
00267     float regTemp = 0;
00268     
00269     matrix temp;
00270     temp.row = m->row;
00271     temp.col = (m->col) * 2;
00272     CreateMatrix(&temp);
00273 
00274     if (m->col != m->row)
00275     {   DeleteMatrix(&temp);
00276         return 1;
00277     }
00278     else if (m->row != inv_m->row)
00279     {   DeleteMatrix(&temp);
00280         return 2;
00281     }
00282     else if (m->col != inv_m->col)
00283     {   DeleteMatrix(&temp);
00284         return 3;
00285     }
00286     else
00287     {
00288 
00289         for(i = 0; i < m->row; i++)
00290         {
00291             for(j = 0 ; j < m->col; j++)
00292             {
00293                 temp.element[i][j] = m->element[i][j];
00294                 if(j == 0)
00295                 {
00296                     temp.element[i][i + m->col] = 1;
00297                 }
00298             }
00299         }
00300 
00301         /*start gauss algorithm*/
00302         for(k = 0; k < temp.row; k++)
00303         {
00304             /*check if element [k][k] != 0*/
00305             if(temp.element[k][k] == 0)
00306             {
00307                 /*find an element [j][k] != 0*/
00308                 for(i = k; i < temp.row; i++)
00309                 {
00310                     if(temp.element[i][k] != 0)
00311                     {
00312                         break;
00313                     }
00314                 }
00315                 /*if not the matrix has no inverse*/
00316                 if(i == temp.row)
00317                 {
00318                     DeleteMatrix(&temp);
00319                     return 4;
00320                 }
00321                 /*else exchange row*/
00322                 for(j = 0; j < temp.col; j++)
00323                 {
00324                     regTemp = temp.element[k][j];
00325                     temp.element[k][j] = temp.element[i][j];
00326                     temp.element[i][j] = regTemp;
00327                 }
00328             }
00329             /*row k divided by element[k][k]*/
00330             regTemp = temp.element[k][k];
00331             for(j = 0; j<temp.col; j++)
00332             {
00333                 temp.element[k][j] = temp.element[k][j]/regTemp;
00334             }
00335             /*compute the other value of matrix*/
00336             for (i = 0; i < temp.row; i++)
00337             {
00338                 if (i != k)
00339                 {
00340                     regTemp = temp.element[i][k];
00341                     for(j = 0; j < temp.col; j++)
00342                     {
00343                         temp.element[i][j] = temp.element[i][j] - temp.element[k][j] * regTemp;
00344                     }
00345                 }
00346             }
00347         }
00348         for(i = 0; i < inv_m->row; i++)
00349         {
00350             for(j = 0; j < inv_m->col; j++)
00351             {
00352                 inv_m->element[i][j] = temp.element[i][inv_m->col + j];
00353             }
00354         }
00355         DeleteMatrix(&temp);
00356         return 0;
00357     }
00358 }
00359 
00360 void CrossProd(matrix* v, matrix* w, matrix* r)
00361 {
00362     matrix s;
00363 
00364     InitMatrix(&s, 3,3);
00365 
00366     //Sv = [0,-v(3),v(2);v(3),0,-v(1);-v(2),v(1),0];
00367     s.element[0][0] = 0;
00368     s.element[0][1] = -(v->element[2][0]);
00369     s.element[0][2] = v->element[1][0];
00370     s.element[1][0] = v->element[2][0];
00371     s.element[1][1] = 0;
00372     s.element[1][2] = -v->element[0][0];
00373     s.element[2][0] = -v->element[1][0];
00374     s.element[2][1] = v->element[0][0];
00375     s.element[2][2] = 0;
00376 
00377     //k = Sv*w;
00378     MxM(&s, w, r);
00379 
00380     DeleteMatrix(&s);
00381 
00382     return;
00383 }
00384 
00385 void Print_Matrix(matrix* m)
00386 {
00387     int i;
00388     int j;
00389     for (i = 0; i<m->row;i++)
00390     {
00391         for( j = 0; j < m->col;j++)
00392         {
00393             printf("%f  ",m->element[i][j]);
00394         }
00395             printf("\n");
00396 
00397     }
00398     printf("\n");
00399     return;
00400 }
00401 
00402