├── README.md
└── matrix.h


/README.md:
--------------------------------------------------------------------------------
 1 | # Matrix
 2 | 
 3 | Matrix class in C++ with operators implemented.
 4 | 
 5 | # Usage
 6 | 
 7 | ```c++
 8 | #include "matrix.h"
 9 | ...
10 | 
11 | // Constructors :
12 | Matrix<type_of_variable> matrix(int height, int width);
13 | Matrix<type_of_variable> matrix(vector<vector<type_of_variable> > &array);
14 | Matrix<type_of_variable> matrix();
15 | ```
16 | 
17 | # Operators
18 | 
19 | ```c++
20 | Matrix<int> a,b,c;
21 | int z;
22 | 
23 | c = a + b;
24 | c = a - b;
25 | c = a * b;
26 | c = z * a;
27 | c = a / z;
28 | ```
29 | 
30 | # Example
31 | 
32 | ```c++
33 | Matrix<int> A(4,5);
34 | Matrix<int> B(4,5);
35 | Matrix<int> C(5,6);
36 | 
37 | Matrix<int> D = A + B;  // = A.add(B)
38 | Matrix<int> D = A - B;  // = A.subtract(B)
39 | Matrix<int> D = A * B;  // = A.multiply(B)
40 | Matrix<int> D = B.dot(C);
41 | Matrix<int> D = A.transpose();
42 | Matrix<int> D = A.subMatrix(0,0, 2,2); // get a sub matrix of size 2x2 from coordinates 0;0 in A
43 | 
44 | A += B;
45 | A -= B;
46 | A *= B;
47 | 
48 | int multiplyByTwo(int x){
49 |     return 2*x;
50 | }
51 | 
52 | Matrix<int> D = A.applyFunction(multiplyByTwo);
53 | 
54 | // you can combine operations :
55 | 
56 | Matrix<int> D = (A+B).dot(C).applyFunction(multiplyByTwo);
57 | 
58 | std::cout << D << std::endl;
59 | ```
60 | 


--------------------------------------------------------------------------------
/matrix.h:
--------------------------------------------------------------------------------
  1 | #ifndef DEF_MATRIX
  2 | #define DEF_MATRIX
  3 | 
  4 | #include <iostream>
  5 | #include <sstream>
  6 | #include <vector>
  7 | #include <stdexcept>
  8 | 
  9 | template <class T>
 10 | class Matrix{
 11 |     private:
 12 |         std::vector<std::vector<T> > array;
 13 |         int height;
 14 |         int width;
 15 | 
 16 |     public:
 17 |         Matrix<T>(int height, int width);
 18 |         Matrix<T>(std::vector<std::vector<T> > const &array);
 19 |         Matrix<T>();
 20 | 
 21 |         int getHeight() const;
 22 |         int getWidth() const;
 23 | 
 24 |         Matrix<T> add(const Matrix<T>& m) const;
 25 |         Matrix<T> subtract(const Matrix<T>& m) const;
 26 |         Matrix<T> multiply(const Matrix<T>& m) const;
 27 |         Matrix<T> dot(const Matrix<T>& m) const;
 28 |         Matrix<T> transpose() const;
 29 |         Matrix<T> multiply(const T& value) const;
 30 |         Matrix<T> divide(const T& value) const;
 31 | 
 32 |         Matrix<T> applyFunction(T (*function)(T)) const;
 33 |         Matrix<T> subMat(int startH, int startW, int h, int w) const;
 34 | 
 35 |         void fill(const T& value);
 36 |         void put(int h, int w, const T& value);
 37 |         T get(int h, int w) const;
 38 | 
 39 |         void print(std::ostream &flux) const;
 40 | 
 41 |         bool operator==(const Matrix<T>& m);
 42 |         bool operator!=(const Matrix<T>& m);
 43 |         Matrix<T> operator+=(const Matrix<T>& m);
 44 |         Matrix<T> operator-=(const Matrix<T>& m);
 45 |         Matrix<T> operator*=(const Matrix<T>& m);
 46 |         Matrix<T> operator*=(const T &m);
 47 |         Matrix<T> operator/=(const T &m);
 48 |         T& operator()(int y, int x);
 49 | };
 50 | 
 51 | template <class T> Matrix<T> operator+(const Matrix<T>& a, const Matrix<T>& b);
 52 | template <class T> Matrix<T> operator-(const Matrix<T>& a, const Matrix<T>& b);
 53 | template <class T> Matrix<T> operator*(const Matrix<T>& a, const Matrix<T>& b);
 54 | template <class T> Matrix<T> operator*(const T &b, const Matrix<T>& a);
 55 | template <class T> Matrix<T> operator/(const Matrix<T>& a, const T &b);
 56 | template <class T> std::ostream& operator<<(std::ostream &flux, const Matrix<T>& m);
 57 | 
 58 | #endif
 59 | 
 60 | 
 61 | template <class T>
 62 | Matrix<T>::Matrix(int height, int width){
 63 |     this->height = height;
 64 |     this->width = width;
 65 |     this->array = std::vector<std::vector<T> >(height, std::vector<T>(width));
 66 | }
 67 | 
 68 | template <class T>
 69 | Matrix<T>::Matrix(std::vector<std::vector<T> > const &array){
 70 |     if(array.size()==0)
 71 |         throw std::invalid_argument("Size of array must be greater than 0.");
 72 | 
 73 |     this->height = array.size();
 74 |     this->width = array[0].size();
 75 |     this->array = array;
 76 | }
 77 | 
 78 | template <class T>
 79 | Matrix<T>::Matrix(){
 80 |     height = 0;
 81 |     width = 0;
 82 | }
 83 | 
 84 | template <class T>
 85 | int Matrix<T>::getHeight() const{
 86 |     return height;
 87 | }
 88 | 
 89 | template <class T>
 90 | int Matrix<T>::getWidth() const{
 91 |     return width;
 92 | }
 93 | 
 94 | template <class T>
 95 | void Matrix<T>::fill(const T& value){
 96 |     for (int i=0 ; i<height ; i++){
 97 |         for (int j=0 ; j<width ; j++){
 98 |             array[i][j] = value;
 99 |         }
100 |     }
101 | }
102 | 
103 | template <class T>
104 | void Matrix<T>::put(int h, int w, const T& value){
105 |     if(!(h>=0 && h<height && w>=0 && w<width))
106 |         throw std::invalid_argument("Index out of bounds.");
107 | 
108 |     array[h][w] = value;
109 | }
110 | 
111 | template <class T>
112 | T Matrix<T>::get(int h, int w) const{
113 |     if(!(h>=0 && h<height && w>=0 && w<width))
114 |         throw std::invalid_argument("Index out of bounds.");
115 | 
116 |     return array[h][w];
117 | }
118 | 
119 | template <class T>
120 | Matrix<T> Matrix<T>::multiply(const T& value) const{
121 |     Matrix result(array);
122 |     for (int i=0 ; i<height ; i++){
123 |         for (int j=0 ; j<width ; j++){
124 |             result.array[i][j] *= value;
125 |         }
126 |     }
127 | 
128 |     return result;
129 | }
130 | 
131 | template <class T>
132 | Matrix<T> Matrix<T>::divide(const T& value) const{
133 |     Matrix result(array);
134 |     for (int i=0 ; i<height ; i++){
135 |         for (int j=0 ; j<width ; j++){
136 |             result.array[i][j] /= value;
137 |         }
138 |     }
139 | 
140 |     return result;
141 | }
142 | 
143 | template <class T>
144 | Matrix<T> Matrix<T>::add(const Matrix& m) const{
145 |     if(!(height==m.height && width==m.width))
146 |         throw std::invalid_argument("Matrix dimension must be the same.");
147 | 
148 |     Matrix result(height, width);
149 |     for (int i=0 ; i<height ; i++){
150 |         for (int j=0 ; j<width ; j++){
151 |             result.array[i][j] = array[i][j] + m.array[i][j];
152 |         }
153 |     }
154 | 
155 |     return result;
156 | }
157 | 
158 | template <class T>
159 | Matrix<T> Matrix<T>::subtract(const Matrix& m) const{
160 |     if(!(height==m.height && width==m.width))
161 |         throw std::invalid_argument("Matrix dimension must be the same.");
162 | 
163 |     Matrix result(height, width);
164 |     for (int i=0 ; i<height ; i++){
165 |         for (int j=0 ; j<width ; j++){
166 |             result.array[i][j] = array[i][j] - m.array[i][j];
167 |         }
168 |     }
169 |     return result;
170 | }
171 | 
172 | template <class T>
173 | Matrix<T> Matrix<T>::multiply(const Matrix& m) const{
174 |     if(!(height==m.height && width==m.width))
175 |         throw std::invalid_argument("Matrix dimension must be the same.");
176 | 
177 |     Matrix result(height, width);
178 | 
179 |     for (int i=0 ; i<height ; i++){
180 |         for (int j=0 ; j<width ; j++){
181 |             result.array[i][j] = array[i][j] * m.array[i][j];
182 |         }
183 |     }
184 |     return result;
185 | }
186 | 
187 | template <class T>
188 | Matrix<T> Matrix<T>::dot(const Matrix& m) const{
189 |     if(!(width==m.height))
190 |         throw std::invalid_argument("Dot product not compatible.");
191 | 
192 |     T w=0;
193 |     int mwidth = m.width;
194 | 
195 |     Matrix<T> result(height, mwidth);
196 |     for (int i=0 ; i<height ; i++){
197 |         for (int j=0 ; j<mwidth ; j++){
198 |             for (int h=0 ; h<width ; h++){
199 |                 w += array[i][h]*m.array[h][j];
200 |             }
201 |             result.array[i][j] = w;
202 |             w=0;
203 |         }
204 |     }
205 | 
206 |     return result;
207 | }
208 | 
209 | template <class T>
210 | Matrix<T> Matrix<T>::transpose() const{
211 |     Matrix<T> result(width, height);
212 | 
213 |     for (int i=0 ; i<width ; i++){
214 |         for (int j=0 ; j<height ; j++){
215 |             result.array[i][j] = array[j][i];
216 |         }
217 |     }
218 |     return result;
219 | }
220 | 
221 | template <class T>
222 | Matrix<T> Matrix<T>::applyFunction(T (*function)(T)) const{
223 |     Matrix<T> result(height, width);
224 | 
225 |     for (int i=0 ; i<height ; i++){
226 |         for (int j=0 ; j<width ; j++){
227 |             result.array[i][j] = (*function)(array[i][j]);
228 |         }
229 |     }
230 | 
231 |     return result;
232 | }
233 | 
234 | template <class T>
235 | Matrix<T> Matrix<T>::subMat(int startH, int startW, int h, int w) const{
236 |     if(!(startH>=0 && startH+h<=height && startW>=0 && startW+w<=width))
237 |         throw std::invalid_argument("Index out of bounds");
238 | 
239 |     Matrix<T> result(h,w);
240 |     for (int i=startH ; i<startH+h ; i++){
241 |         for (int j=startW ; j<startW+w ; j++){
242 |             result.array[i-startH][j-startW] = array[i][j];
243 |         }
244 |     }
245 |     return result;
246 | }
247 | 
248 | template <class T>
249 | void Matrix<T>::print(std::ostream &flux) const{
250 |     int maxLength[width] = {};
251 |     std::stringstream ss;
252 | 
253 |     for (int i=0 ; i<height ; i++){
254 |         for (int j=0 ; j<width ; j++){
255 |             ss << array[i][j];
256 |             if(maxLength[j] < ss.str().size()){
257 |                 maxLength[j] = ss.str().size();
258 |             }
259 |             ss.str(std::string());
260 |         }
261 |     }
262 | 
263 |     for (int i=0 ; i<height ; i++){
264 |         for (int j=0 ; j<width ; j++){
265 |             flux << array[i][j];
266 |             ss << array[i][j];
267 |             for (int k=0 ; k<maxLength[j]-ss.str().size()+1 ; k++){
268 |                 flux << " ";
269 |             }
270 |             ss.str(std::string());
271 |         }
272 |         flux << std::endl;
273 |     }
274 | }
275 | 
276 | template <class T>
277 | bool Matrix<T>::operator==(const Matrix& m){
278 |     if(height==m.height && width==m.width){
279 |         for (int i=0 ; i<height ; i++){
280 |             for (int j=0 ; j<width ; j++){
281 |                 if(array[i][j]!=m.array[i][j]){
282 |                     return false;
283 |                 }
284 |             }
285 |         }
286 |         return true;
287 |     }
288 |     return false;
289 | }
290 | 
291 | template <class T>
292 | bool Matrix<T>::operator!=(const Matrix& m){
293 |     return !operator==(m);
294 | }
295 | 
296 | template <class T>
297 | Matrix<T> Matrix<T>::operator+=(const Matrix& m){
298 |     this->array = add(m).array;
299 |     return *this;
300 | }
301 | 
302 | template <class T>
303 | Matrix<T> Matrix<T>::operator-=(const Matrix& m){
304 |     this->array = subtract(m).array;
305 |     return *this;
306 | }
307 | 
308 | template <class T>
309 | Matrix<T> Matrix<T>::operator*=(const Matrix& m){
310 |     this->array = multiply(m).array;
311 |     return *this;
312 | }
313 | 
314 | template <class T>
315 | Matrix<T> Matrix<T>::operator*=(const T &m){
316 |     *this = this->multiply(m);
317 |     return *this;
318 | }
319 | 
320 | template <class T>
321 | Matrix<T> Matrix<T>::operator/=(const T &m){
322 |     *this = this->divide(m);
323 |     return *this;
324 | }
325 | 
326 | template <class T>
327 | T& Matrix<T>::operator()(int y, int x){
328 |     if(!(y>=0 && y<height && x>=0 && x<width))
329 |         throw std::invalid_argument("Index out of bounds.");
330 |     return array[y][x];
331 | }
332 | 
333 | template <class T>
334 | Matrix<T> operator+(const Matrix<T>& a, const Matrix<T>& b){
335 |     return a.add(b);
336 | }
337 | 
338 | template <class T>
339 | Matrix<T> operator-(const Matrix<T>& a, const Matrix<T>& b){
340 |     return a.subtract(b);
341 | }
342 | 
343 | template <class T>
344 | Matrix<T> operator*(const Matrix<T>& a, const Matrix<T>& b){
345 |     return a.multiply(b);
346 | }
347 | 
348 | template <class T>
349 | Matrix<T> operator*(const T &b, const Matrix<T>& a){
350 |     return a.multiply(b);
351 | }
352 | template <class T>
353 | Matrix<T> operator/(const Matrix<T>& a, const T &b){
354 |     return a.divide(b);
355 | }
356 | 
357 | template <class T>
358 | std::ostream& operator<<(std::ostream &flux, const Matrix<T>& m){
359 |     m.print(flux);
360 |     return flux;
361 | }
362 | 


--------------------------------------------------------------------------------