Matrix_Template_Cpp/matrix_temp.h at master · faivan95/Matrix_Template_Cpp · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
#pragma once

#include <iostream>
#include <vector>
#include <type_traits>

//bool checkForString(const std::string& str);

template <typename T>
class Matrix {
private:
    std::vector<std::vector<T>> data;
    size_t rows, cols;

public:
    // Matrix(T tData) {
    //     //data.resize(tData.size());
    //     data.resize(1, 1);
    //     data[0][0] = "Empty";
    // }

    Matrix(size_t rows, size_t cols) {
        this->rows = rows;
        this->cols = cols;
        data.resize(rows, std::vector<T>(cols));
    }

    T& operator()(size_t row, size_t col) {
        return data[row][col];
    }

    const T& operator()(size_t row, size_t col) const {
        return data[row][col];
    }

    size_t getRows() const { return rows; }
    size_t getCols() const { return cols; }

    //Display matrix data
    void displayData() {
        for (size_t i = 0; i < rows; ++i) {
            for (size_t j = 0; j < cols; ++j) {
                std::cout << "Data at (" << i << ", " << j << ") is " << data[i][j] << std::endl;
            }
        }
    }

    // Addition Operation
    Matrix<T> operator+(const Matrix<T>& second) const {
        Matrix<T> result(rows, cols);
        for (size_t i = 0; i < rows; ++i) {
            for (size_t j = 0; j < cols; ++j) {
                result(i, j) = data[i][j] + second(i, j);
            }
        }
        return result;
    }

    // Subtraction operation
    Matrix<T> operator-(const Matrix<T>& second) const {
        Matrix<T> result(rows, cols);
        if constexpr (std::is_same<T, std::string>::value) {
            std::cout << "Subtraction operation is not possible with string types in matrices!" << std::endl;
        }
        else {
            for (size_t i = 0; i < rows; ++i) {
                for (size_t j = 0; j < cols; ++j) {
                    result(i, j) = data[i][j] - second(i, j);
                }
            }
        }

        return result;
    }

    // Multiplication operation
    Matrix<T> operator*(const Matrix<T>& second) const {
        Matrix<T> result(rows, second.getCols());
        if constexpr (std::is_same<T, std::string>::value) {
            std::cout << "Multiplication operation is not possible with string types in matrices!" << std::endl;
            // Matrix<T> result(0, 0);
            // // result.data("Empty");
            // result(0, 0) = "Empty";
            // return result;

            // Matrix<T> result(rows, second.getCols());
            // for (size_t i = 0; i < rows; ++i) {
            //     for (size_t j = 0; j < second.getCols(); ++j) {
            //         //result(i, j) = 0;
            //         for (size_t k = 0; k < cols; ++k) {
            //             result(i, j) = "Empty ";
            //         }
            //     }
            // }
        }
        else {
            //Matrix<T> result(rows, second.getCols());
            for (size_t i = 0; i < rows; ++i) {
                for (size_t j = 0; j < second.getCols(); ++j) {
                    result(i, j) = 0;
                    for (size_t k = 0; k < cols; ++k) {
                        result(i, j) += data[i][k] * second(k, j);
                        std::cout << data[i][k] << " * " << second(k,j) << " = " << result(i,j) << std::endl;
                    }
                }
            }
        }
        return result;
    }
};