# Matrix enought to get started in C

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