j0h

Matrix enought to get started in C

j0h
Jul 27th, 2021
986
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1.  
  2. ------------------mmult.c-----------------------------
  3. //A program to multiply matrices
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <unistd.h>
  7. #include <errno.h>
  8. #include <math.h>
  9. #include "matrix.h"
  10.  
  11.  
  12. int main(int argc, char * argv[])
  13. {
  14.     // Three matrices to work with
  15.     struct matrix *m1=NULL;
  16.     struct matrix *m2=NULL;
  17.     struct matrix *m3=NULL;
  18.  
  19.     // Create a random 3x3 matrix
  20.     m1=mrand(3,3);
  21.     if (m1==NULL) {
  22.         printf("Malloc error\n");
  23.         return 1;
  24.     }
  25.     // Create a random 3x3 matrix
  26.     m2=mrand(3,3);
  27.     if (m2==NULL) {
  28.         printf("Malloc error\n");
  29.         return 1;
  30.     }
  31.  
  32.     // Multiply the two
  33.     m3=mmult(m1,m2);
  34.     if (m3==NULL) {
  35.         mfree(m1);
  36.         mfree(m2);
  37.         return 1;
  38.     }
  39.  
  40.     // Print them all
  41.     mprint(m1);
  42.     mprint(m2);
  43.     mprint(m3);
  44.  
  45.     // Clean up
  46.     mfree(m1);
  47.     mfree(m2);
  48.     mfree(m3);
  49.  
  50.     return 0;
  51. }
  52.  
  53.  
  54. --------------------matrix.c------------------------
  55. //  - Matrix routines
  56. #include <stdio.h>
  57. #include <stdlib.h>
  58. #include <unistd.h>
  59. #include <errno.h>
  60. #include "matrix.h"
  61.  
  62. // Create random matrix of size i by j
  63. struct matrix *mrand(int i, int j)
  64. {
  65.     int a, b;           // Counters
  66.     struct matrix *m;   // The matrix pointer
  67.    
  68.     // Allocate the matrix structure
  69.     m=(struct matrix *)malloc(sizeof(struct matrix));
  70.     if (m==NULL) {
  71.         perror("Malloc");
  72.         return NULL;
  73.     }
  74.  
  75.     // Set the size
  76.     m->r=i;
  77.     m->c=j;
  78.  
  79.     // Alocate the rows & Handle errors
  80.     m->d=(float **)malloc(sizeof(float *)*m->r);
  81.     if (m->d==NULL) {
  82.         perror("Malloc");
  83.         free(m);
  84.         return NULL;
  85.     }
  86.     // Allocate the columns & Handle errors
  87.     for (b=0; b<j; b++) {
  88.         m->d[b]=(float *)malloc(sizeof(float)*m->c);
  89.         if (m->d[b]==NULL) {
  90.             perror("Malloc");
  91.             for (a=0;a<b;a++) {
  92.                 free(m->d[a]);
  93.             }
  94.             free(m->d);
  95.             free(m);
  96.             return NULL;
  97.         }
  98.     }
  99.     // Fill the matrix
  100.     for (a=0;a<i;a++) {
  101.         for (b=0;b<j;b++) {
  102.             m->d[a][b]=drand48();
  103.         }
  104.     }
  105.     return m;
  106. }
  107.  
  108. // Multiply m1 by m2 result is allocated and returned
  109. struct matrix *mmult(struct matrix *m1, struct matrix *m2)
  110. {
  111.     struct matrix *m;
  112.     int a, b, c;
  113.  
  114.     // Sanity
  115.     if (m1==NULL) {
  116.         printf("Null matrix!\n");
  117.         return NULL;
  118.     }
  119.     if (m2==NULL) {
  120.         printf("Null matrix!\n");
  121.         return NULL;
  122.     }
  123.     // Inner dimensions must agree
  124.     if (m1->c!=m2->r) {
  125.         printf("Matrix inner dimensions must agree\n");
  126.         return NULL;
  127.     }
  128.  
  129.     // As in mrand(), allocate space for the new matrix
  130.     m=(struct matrix *)malloc(sizeof(struct matrix));
  131.     if (m==NULL) {
  132.         perror("Malloc");
  133.         return NULL;
  134.     }
  135.  
  136.     m->r=m1->r;
  137.     m->c=m2->c;
  138.  
  139.     m->d=(float **)malloc(sizeof(float *)*m->r);
  140.     if (m->d==NULL) {
  141.         perror("Malloc");
  142.         free(m);
  143.         return NULL;
  144.     }
  145.     for (b=0; b<m->r; b++) {
  146.         m->d[b]=(float *)malloc(sizeof(float)*m->c);
  147.         if (m->d[b]==NULL) {
  148.             perror("Malloc");
  149.             for (a=0;a<b;a++) {
  150.                 free(m->d[a]);
  151.             }
  152.             free(m->d);
  153.             free(m);
  154.             return NULL;
  155.         }
  156.     }
  157.     // Multiply
  158.     for (a=0;a<m1->r;a++) {
  159.         for (b=0;b<m2->c;b++) {
  160.             m->d[a][b]=0;
  161.             for (c=0;c<m1->c;c++) {
  162.                 m->d[a][b]+=m1->d[a][c]*m2->d[c][b];
  163.             }
  164.         }
  165.     }
  166.     return m;
  167. }
  168.  
  169. // Print a matrix
  170. void mprint(struct matrix *m)
  171. {
  172.     int a, b;   // Counters
  173.  
  174.     // Sanity
  175.     if (m==NULL) {
  176.         printf("Null Matrix!\n");
  177.         return;
  178.     }
  179.     // MATLAB format
  180.     printf("[");
  181.     for (a=0;a<m->r;a++) {
  182.         for (b=0;b<m->c;b++) {
  183.             printf("%.9f ",m->d[a][b]);
  184.         }
  185.         printf(";\n");
  186.     }
  187.     printf("]\n");
  188.  
  189.     return;
  190. }
  191.  
  192. // Free a matrix
  193. void mfree(struct matrix *m)
  194. {
  195.     int a;  // Counter
  196.  
  197.     // Sanity
  198.     if (m==NULL) {
  199.         printf("Null Matrix!\n");
  200.         return;
  201.     }
  202.     // Free in reverse order
  203.     for (a=0;a<m->r;a++) {
  204.         free(m->d[a]);
  205.     }
  206.     free(m->d);
  207.     free(m);
  208.     m=NULL;
  209.     return;
  210. }
  211.  
  212.  
  213.  
  214. ------------matrix.h-------------
  215. /***Matrix routine protos***/
  216. #ifndef __MATRIX_H__
  217. #define __MATRIX_H__
  218.  
  219. // Organize the matrix data
  220. struct matrix {
  221.     int r;
  222.     int c;
  223.     float **d;
  224. };
  225.  
  226. // Create a random matrix
  227. struct matrix * mrand(int i, int j);
  228. // Multiply matrices
  229. struct matrix * mmult(struct matrix *m1, struct matrix *m2);
  230. // Free a matrix
  231. void mfree(struct matrix *m);
  232. // Print a matrix
  233. void mprint(struct matrix *m);
  234.  
  235. #endif // __MATRIX_H__
  236.  
  237. -------------------Makefile---------------------------------
  238.  
  239. TARGET=mmult
  240. OBJS=mmult.o matrix.o
  241. CFLAGS=-g -Wall
  242. .PHONY: clean all
  243.  
  244. all: ${TARGET}
  245.  
  246. ${TARGET}: ${OBJS}
  247.     ${CC} -o ${TARGET} ${OBJS}
  248.  
  249. clean:
  250.     rm -f ${OBJS} ${TARGET}
  251.  
  252. matrix.o: matrix.h
RAW Paste Data