Add 3D matrices operations

README.md

@@ -89,6 +89,6 @@ result_matrix.show();
 
 ## ToDo
 
-- [ ] Add arithmetic operations for 3-Dimensional matrices
-  - [ ] Add multiplication of 3D-matrices
-  - [ ] Add addition/subtraction of 3D-matrices
+- [x] Add arithmetic operations for 3-Dimensional matrices
+  - [x] Add multiplication of 3D-matrices
+  - [x] Add addition/subtraction of 3D-matrices

src/headers/three_dimensional_matrix.hh

@@ -1,16 +1,101 @@
 #ifndef THREE_DIMENSIONAL_MATRIX_HH
 #define THREE_DIMENSIONAL_MATRIX_HH
-#include "two_dimensional_matrix.hh"
+#include <vector>
+#include <cstddef>
+#include <stdexcept>
+#include <iomanip>
 
-template <typename T, typename = std::enable_if_t<is_numeric<T>::value>>
+template <typename T>
 class ThreeDimensionalMatrix {
-
 public:
-    ThreeDimensionalMatrix(); // Constructor
-    ~ThreeDimensionalMatrix(); // Desctructor
+    ThreeDimensionalMatrix(std::size_t x, std::size_t y, std::size_t z) 
+        : dimX(x), dimY(y), dimZ(z), matrix(x, std::vector<std::vector<T>>(y, std::vector<T>(z, 0))) {}
+
+    void set_value(std::size_t x, std::size_t y, std::size_t z, T value) {
+        if (x >= dimX || y >= dimY || z >= dimZ) {
+            throw std::out_of_range("Index out of bounds");
+        }
+        matrix[x][y][z] = value;
+    }
+
+    T get_value(std::size_t x, std::size_t y, std::size_t z) const {
+        if (x >= dimX || y >= dimY || z >= dimZ) {
+            throw std::out_of_range("Index out of bounds");
+        }
+        return matrix[x][y][z];
+    }
+
+    void show() const {
+        for (size_t i = 0; i < dimX; ++i) {
+            for (size_t j = 0; j < dimY; ++j) {
+                for (size_t k = 0; k < dimZ; ++k) {
+                    std::cout << matrix[i][j][k] << " ";
+                }
+                std::cout << std::endl;
+            }
+            std::cout << "-----" << std::endl;
+        }
+    }
 
+    ThreeDimensionalMatrix<T> operator+(const ThreeDimensionalMatrix<T>& rhs) {
+        if (dimX != rhs.dimX || dimY != rhs.dimY || dimZ != rhs.dimZ) {
+            throw std::invalid_argument("Matrices dimensions do not match");
+        }
+
+        ThreeDimensionalMatrix<T> result(dimX, dimY, dimZ);
+        for (size_t i = 0; i < dimX; ++i) {
+            for (size_t j = 0; j < dimY; ++j) {
+                for (size_t k = 0; k < dimZ; ++k) {
+                    result.set_value(i, j, k, this->get_value(i, j, k) + rhs.get_value(i, j, k));
+                }
+            }
+        }
+        return result;
+    }
+
+    ThreeDimensionalMatrix<T> operator-(const ThreeDimensionalMatrix<T>& rhs) {
+        if (dimX != rhs.dimX || dimY != rhs.dimY || dimZ != rhs.dimZ) {
+            throw std::invalid_argument("Matrices dimensions do not match");
+        }
+
+        ThreeDimensionalMatrix<T> result(dimX, dimY, dimZ);
+        for (size_t i = 0; i < dimX; ++i) {
+            for (size_t j = 0; j < dimY; ++j) {
+                for (size_t k = 0; k < dimZ; ++k) {
+                    result.set_value(i, j, k, this->get_value(i, j, k) - rhs.get_value(i, j, k));
+                }
+            }
+        }
+        return result;
+    }
+
+    ThreeDimensionalMatrix<T> operator*(const ThreeDimensionalMatrix<T>& rhs) {
+        // Simplified multiplication for demonstration purposes
+        if (dimY != rhs.dimX || dimZ != rhs.dimY) {
+            throw std::invalid_argument("Matrices dimensions do not allow multiplication");
+        }
+
+        ThreeDimensionalMatrix<T> result(dimX, rhs.dimY, rhs.dimZ);
+        for (size_t i = 0; i < dimX; ++i) {
+            for (size_t j = 0; j < rhs.dimY; ++j) {
+                for (size_t k = 0; k < rhs.dimZ; ++k) {
+                    T sum = 0;
+                    for (size_t l = 0; l < dimY; ++l) {
+                        for (size_t m = 0; m < dimZ; ++m) {
+                            sum += this->get_value(i, l, m) * rhs.get_value(l, j, m);
+                        }
+                    }
+                    result.set_value(i, j, k, sum);
+                }
+            }
+        }
+        return result;
+    }
 
 
+private:
+    std::vector<std::vector<std::vector<T>>> matrix;
+    std::size_t dimX, dimY, dimZ;
 };
 
-#endif // THREE_DIMENSIONAL_MATRIX_HH
+#endif // THREE_DIMENSIONAL_MATRIX_HH

src/main.cpp

@@ -21,5 +21,47 @@ int main(int argc, const char** argv) {
     auto runtime_microseconds = std::chrono::duration_cast<std::chrono::microseconds>(delta).count();
     std::cout << "Runtime=" << runtime_microseconds << " microseconds" << std::endl;
 
+    // Creating two 3D matrices of size 2x2x2 for demonstration
+    ThreeDimensionalMatrix<int> matrix1(2, 2, 2);
+    ThreeDimensionalMatrix<int> matrix2(2, 2, 2);
+
+    // Initializing matrix1 with some values
+    matrix1.set_value(0, 0, 0, 1);
+    matrix1.set_value(0, 0, 1, 2);
+    matrix1.set_value(0, 1, 0, 3);
+    matrix1.set_value(0, 1, 1, 4);
+    matrix1.set_value(1, 0, 0, 5);
+    matrix1.set_value(1, 0, 1, 6);
+    matrix1.set_value(1, 1, 0, 7);
+    matrix1.set_value(1, 1, 1, 8);
+
+    // Initializing matrix2 with some values
+    matrix2.set_value(0, 0, 0, 8);
+    matrix2.set_value(0, 0, 1, 7);
+    matrix2.set_value(0, 1, 0, 6);
+    matrix2.set_value(0, 1, 1, 5);
+    matrix2.set_value(1, 0, 0, 4);
+    matrix2.set_value(1, 0, 1, 3);
+    matrix2.set_value(1, 1, 0, 2);
+    matrix2.set_value(1, 1, 1, 1);
+
+    // Performing arithmetic operations
+    ThreeDimensionalMatrix<int> sumMatrix = matrix1 + matrix2;
+    ThreeDimensionalMatrix<int> diffMatrix = matrix1 - matrix2;
+    ThreeDimensionalMatrix<int> prodMatrix = matrix1 * matrix2;
+
+    // Displaying results
+    std::cout << "Sum of Matrix 1 and Matrix 2:" << std::endl;
+    // Display sumMatrix
+    sumMatrix.show();
+
+    std::cout << "\nDifference between Matrix 1 and Matrix 2:" << std::endl;
+    // Display diffMatrix
+    diffMatrix.show();
+
+    std::cout << "\nProduct of Matrix 1 and Matrix 2:" << std::endl;
+    // Display prodMatrix
+    prodMatrix.show();
+
     return 0;
-}
+}