SquareMat.cpp

// ronavraham1999@gmail.com

#include <stdexcept>
#include <iostream>
#include "SquareMat.hpp"
#include <cmath>

namespace mat{

// Constructor
    SquareMat::SquareMat(int size) : n(size) { 
    if (size <= 0) {
        throw std::invalid_argument("Matrix size must be positive.");
    }
    matrix = new double*[size];
    for (int i = 0; i < size; ++i) {
        matrix[i] = new double[size];
        for (int j = 0; j < size; ++j) {
            matrix[i][j] = 0.0; // Initialize elements to zero
        }
    }
}   

 // Destructor 
    SquareMat::~SquareMat() {  
        for (int i = 0; i < n; ++i) {
            delete[] matrix[i];
        }
        delete[] matrix;
    }
    SquareMat::SquareMat(const SquareMat& other) : n(other.n) {
        matrix = new double*[n];
        for (int i = 0; i < n; ++i) {
            matrix[i] = new double[n];
            for (int j = 0; j < n; ++j) {
                matrix[i][j] = other.matrix[i][j];
            }
        }
    }

    SquareMat& SquareMat::operator=(const SquareMat& other) { //
        if (this == &other) { 
            return *this;
        }

        for (int i = 0; i < n; ++i) {
            delete[] matrix[i];
        }
        delete[] matrix;

        n = other.n;
        matrix = new double*[n];
        for (int i = 0; i < n; ++i) {
            matrix[i] = new double[n];
            for (int j = 0; j < n; ++j) {
                matrix[i][j] = other.matrix[i][j];
            }
        }

        return *this;
    }
// matrix + matrix
    SquareMat SquareMat::operator+(const SquareMat& other) const {
        if (n != other.n) {
            throw std::invalid_argument("Matrix sizes must match for addition");
        }

        SquareMat result(n);
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                result.matrix[i][j] = matrix[i][j] + other.matrix[i][j];
            }
        }
        return result;
    }

// matrix - matrix
    SquareMat SquareMat::operator-(const SquareMat& other) const {
        if (n != other.n) {
            throw std::invalid_argument("Matrix sizes must match for subtraction");
        }

        SquareMat result(n);
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                result.matrix[i][j] = matrix[i][j] - other.matrix[i][j];
            }
        }
        return result;
    }
// unary minus
    SquareMat SquareMat::operator-() const {
        SquareMat result(n);
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                result.matrix[i][j] = -matrix[i][j];
            }
        }
        return result;
    }
// matrix * matrix
    SquareMat SquareMat::operator*(const SquareMat& other) const {
        if (n != other.n) {
            throw std::invalid_argument("Matrix sizes must match for multiplication");
        }

        SquareMat result(n);
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                double sum = 0.0;
                for (int k = 0; k < n; ++k) {
                    sum += matrix[i][k] * other.matrix[k][j];
                }
                result.matrix[i][j] = sum;
            }
        }
        return result;
    }

// matrix * scalar
    SquareMat SquareMat::operator*(double scalar) const {
        SquareMat result(n);
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                result.matrix[i][j] = matrix[i][j] * scalar;
            }
        }
        return result;
    }

// scalar * matrix 
    SquareMat operator*(double scalar, const SquareMat& mat) {
        SquareMat result(mat.n);
        for (int i = 0; i < mat.n; ++i) {
            for (int j = 0; j < mat.n; ++j) {
                result.matrix[i][j] = scalar * mat.matrix[i][j];
            }
        }
        return result;
    }

//matrix * matrix (element-wise multiplication)
    SquareMat SquareMat::operator%(const SquareMat& other) const {
        if (n != other.n) {
            throw std::invalid_argument("Matrix sizes must match for element-wise multiplication");
        }

        SquareMat result(n);
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                result.matrix[i][j] = matrix[i][j] * other.matrix[i][j];
            }
        }
        return result;
    }

//matrix % scalar (element-wise modulo)
    SquareMat SquareMat::operator%(int scalar) const {
        if (scalar == 0) {
            throw std::invalid_argument("Modulo by zero is not allowed");
        }

    SquareMat result(n);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            result.matrix[i][j] = std::fmod(matrix[i][j], static_cast<double>(scalar));
        }
    }
    return result;
}
    
//matrix / scalar (element-wise division)
    SquareMat SquareMat::operator/(double scalar) const {
        if (scalar == 0.0) {
            throw std::invalid_argument("Division by zero is not allowed");
        }

        SquareMat result(n);
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                result.matrix[i][j] = matrix[i][j] / scalar;
            }
        }
        return result;
    }

// matrix ^ power (matrix exponentiation)
    SquareMat SquareMat::operator^(int power) const {
        if (power < 0) {
            throw std::invalid_argument("Negative exponents are not supported");
        }

        SquareMat result(n);

    
        if (power == 0) {
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n; ++j) {
                    result.matrix[i][j] = (i == j) ? 1.0 : 0.0; // Identity matrix
                }
            }
            return result;
        }

        // Copy original
        if (power == 1) {
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < n; ++j) {
                    result.matrix[i][j] = matrix[i][j];
                }
            }
            return result;
        }

        // Exponentiation by squaring (efficient)
        if (power % 2 == 0) {
            SquareMat half = (*this) ^ (power / 2);
            return half * half;
        } 
        else {
            return (*this) * ((*this) ^ (power - 1));
        }
}

// Pre-increment
    SquareMat& SquareMat::operator++() {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                matrix[i][j] += 1.0;
            }
        }
        return *this;
    }

// Pre-decrement
    SquareMat& SquareMat::operator--() {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                matrix[i][j] -= 1.0;
            }
        }
        return *this;
    }

// Post-increment
    SquareMat SquareMat::operator++(int) {
        SquareMat temp(*this); 
        ++(*this); 
        return temp;
    }

// Post-decrement
    SquareMat SquareMat::operator--(int) {
        SquareMat temp(*this); 
        --(*this); 
        return temp;
    }


// Transpose of the matrix
    SquareMat SquareMat::operator~() const {
    SquareMat result(n);
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            result.matrix[i][j] = matrix[j][i];
        }
    }
    return result;
}

// Access operator for non-const objects
    double* SquareMat::operator[](int row) {
    if (row < 0 || row >= n) {
        throw std::out_of_range("Row index out of range");
    }
    return matrix[row];
}
// Access operator for const objects (read-only)
    const double* SquareMat::operator[](int row) const {
        if (row < 0 || row >= n) {
            throw std::out_of_range("Row index out of range");
        }
        return matrix[row];
    }

// Helper function for the next functions, to calculate the sum of all elements.
      double SquareMat::sum() const {
        double total = 0.0;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                total += matrix[i][j];
            }
        }
        return total;
    }
// Comparison operators based on the sum of elements
    bool SquareMat::operator==(const SquareMat& other) const {
        return this->sum() == other.sum();
    }
// "Not equal" operator
    bool SquareMat::operator!=(const SquareMat& other) const {
        return !(*this == other);
    }
// "Less than" operator
    bool SquareMat::operator<(const SquareMat& other) const {
        return this->sum() < other.sum();
    }
// "Greater than" operator
    bool SquareMat::operator>(const SquareMat& other) const {
        return this->sum() > other.sum();
    }
// "Less than or equal to" operator
    bool SquareMat::operator<=(const SquareMat& other) const {
        return this->sum() <= other.sum();
    }
// "Greater than or equal to" operator
    bool SquareMat::operator>=(const SquareMat& other) const {
        return this->sum() >= other.sum();
    }


// Helper function to get the minor matrix for the next function
    SquareMat SquareMat::minorMatrix(int row, int col) const {
        SquareMat result(n - 1);
        int r = 0;
        for (int i = 0; i < n; ++i) {
            if (i == row) continue;
            int c = 0;
            for (int j = 0; j < n; ++j) {
                if (j == col) continue;
                result[r][c] = matrix[i][j];
                ++c;
            }
            ++r;
        }
        return result;
    }

// Determinant of the matrix
    double SquareMat::operator!() const {
    if (n == 1) {
        return matrix[0][0];
    }
    if (n == 2) {
        return matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
    }

    double det = 0.0;
    for (int col = 0; col < n; ++col) {
        double sign = (col % 2 == 0) ? 1.0 : -1.0;
        SquareMat minorMat = this->minorMatrix(0, col);
        det += sign * matrix[0][col] * !minorMat;
    }
    return det;
}

// Adds another matrix to this matrix (element-wise)
  SquareMat& SquareMat::operator+=(const SquareMat& other) {
    if (n != other.n) {
        throw std::invalid_argument("Matrix sizes must match for addition");
    }
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < n; ++j) {
            matrix[i][j] += other.matrix[i][j];
        }
    }
    return *this;
    }

// Subtracts another matrix from this matrix (element-wise)
    SquareMat& SquareMat::operator-=(const SquareMat& other) {
        if (n != other.n) {
            throw std::invalid_argument("Matrix sizes must match for subtraction");
        }
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                matrix[i][j] -= other.matrix[i][j];
            }
        }
        return *this;
    }

// Multiplies this matrix by a scalar (element-wise)
    SquareMat& SquareMat::operator*=(double scalar) {
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                matrix[i][j] *= scalar;
            }
        }
        return *this;
    }

// Multiplies this matrix by another matrix
    SquareMat& SquareMat::operator*=(const SquareMat& other) {
        if (n != other.n) {
            throw std::invalid_argument("Matrix sizes must match for multiplication");
        }
        SquareMat temp = (*this) * other;
        *this = temp;
        return *this;
    }

// Divides this matrix by a scalar (element-wise)
    SquareMat& SquareMat::operator/=(double scalar) {
        if (scalar == 0.0) {
            throw std::invalid_argument("Division by zero is not allowed");
        }
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                matrix[i][j] /= scalar;
            }
        }
        return *this;
    }

// Applies modulo operation with a scalar on each element
    SquareMat& SquareMat::operator%=(int scalar) {
        if (scalar == 0) {
            throw std::invalid_argument("Modulo by zero is not allowed");
        }
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                matrix[i][j] = std::fmod(matrix[i][j], static_cast<double>(scalar));
            }
        }
        return *this;
    }


//Applies element-wise modulo operation with another matrix
    SquareMat& SquareMat::operator%=(const SquareMat& other) {
        if (n != other.n) {
            throw std::invalid_argument("Matrix sizes must match for element-wise modulo");
        }
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                if (other.matrix[i][j] == 0.0) {
                    throw std::invalid_argument("Modulo by zero element is not allowed");
                }
                matrix[i][j] = std::fmod(matrix[i][j], other.matrix[i][j]);
            }
        }
        return *this;
    }

// Print the matrix
    std::ostream& operator<<(std::ostream& os, const SquareMat& mat) {
        for (int i = 0; i < mat.n; ++i) {
            for (int j = 0; j < mat.n; ++j) {
                os << mat.matrix[i][j];
                if (j < mat.n - 1) {
                    os << " ";
                }
            }
            os << "\n";
        }
        return os;
    }



}