myMatrix.cpp

#include "myMatrix.h"

// constructor and destructor
MyMatrix::MyMatrix() noexcept
    : rows_(DEFAULT_MATRIX_SIZE), cols_(DEFAULT_MATRIX_SIZE),
      matrix_(new double[DEFAULT_MATRIX_SIZE * DEFAULT_MATRIX_SIZE]{}) {}

MyMatrix::MyMatrix(int r, int c)
    : rows_(r), cols_(c), matrix_(new double[r * c]{}) {
  if (r < 1 || c < 1)
    throw std::out_of_range("Rows and columns should be positive");
}

MyMatrix::MyMatrix(const MyMatrix &other)
    : rows_{other.rows_}, cols_{other.cols_},
      matrix_(new double[rows_ * cols_]) {
  std::copy(other.matrix_, other.matrix_ + rows_ * cols_, matrix_);
}

MyMatrix::MyMatrix(MyMatrix &&other) noexcept
    : rows_{other.rows_}, cols_{other.cols_}, matrix_(other.matrix_) {
  other.matrix_ = nullptr;
  other.rows_ = 0;
  other.cols_ = 0;
}

MyMatrix::~MyMatrix() noexcept { delete[] matrix_; }

MyMatrix &MyMatrix::operator=(const MyMatrix &other) {
  MyMatrix tmp(other);
  *this = std::move(tmp);
  return *this;
}

MyMatrix &MyMatrix::operator=(MyMatrix &&other) noexcept {
  if (this != &other) {
    delete[] matrix_;
    rows_ = 0;
    cols_ = 0;
    matrix_ = nullptr;
    std::swap(rows_, other.rows_);
    std::swap(cols_, other.cols_);
    std::swap(matrix_, other.matrix_);
  }
  return *this;
}

double &MyMatrix::operator()(int row, int col) & {
  return const_cast<double &>(getElement(row, col));
}

const double &MyMatrix::operator()(int row, int col) const & {
  return getElement(row, col);
}

bool MyMatrix::operator==(const MyMatrix &other) { return EqMatrix(other); }

MyMatrix MyMatrix::operator+(const MyMatrix &other) const {
  MyMatrix res(*this);
  res.SumMatrix(other);
  return res;
}

MyMatrix MyMatrix::operator+=(const MyMatrix &other) {
  SumMatrix(other);
  return *this;
}

MyMatrix MyMatrix::operator-(const MyMatrix &other) const {
  MyMatrix res(*this);
  res.SubMatrix(other);
  return res;
}

MyMatrix MyMatrix::operator-=(const MyMatrix &other) {
  SubMatrix(other);
  return *this;
}

MyMatrix MyMatrix::operator*(const double num) const noexcept {
  MyMatrix res(*this);
  res.MulNumber(num);
  return res;
}

MyMatrix MyMatrix::operator*=(const double num) {
  MulNumber(num);
  return *this;
}

MyMatrix MyMatrix::operator*(const MyMatrix &other) const {
  MyMatrix res(*this);
  res.MulMatrix(other);
  return res;
}

MyMatrix MyMatrix::operator*=(const MyMatrix &other) {
  MulMatrix(other);
  return *this;
}

bool MyMatrix::EqMatrix(const MyMatrix &other) {
  bool result = true;
  if (rows_ != other.rows_ || cols_ != other.cols_) {
    result = false;
  } else {
    for (int i = 0; i < rows_; ++i) {
      for (int j = 0; j < cols_; ++j) {
        if (std::abs(other(i, j) - (*this)(i, j)) > precision)
          result = false;
      }
    }
  }
  return result;
}

/*void MyMatrix::SumMatrix(const MyMatrix &other)
{
    if(rows_ == other.GetRows() && cols_ == other.GetColumns())
    {
        for(int i = 0; i < rows_; i++){
            for(int j = 0; j < cols_; j++){
                (*this)(i, j) += other(i, j);
            }
        }
    } else {
        throw std::out_of_range("Incorrect input, matrix should have the same
size");
    }
}*/

void MyMatrix::SumMatrix(const MyMatrix &other) {
  if (rows_ == other.GetRows() && cols_ == other.GetColumns()) {
    for (int i = 0; i < rows_; i++) {
      for (int j = 0; j < cols_; j++) {
        (*this)(i, j) += other(i, j);
      }
    }
  } else {
    throw std::out_of_range(
        "Incorrect input, matrix should have the same size");
  }
}

void MyMatrix::MulNumber(const double num) noexcept {
  for (int i = 0; i < rows_; i++) {
    for (int j = 0; j < cols_; j++) {
      (*this)(i, j) *= num;
    }
  }
}

void MyMatrix::MulMatrix(const MyMatrix &other) {
  if (cols_ == other.GetRows()) {
    MyMatrix resultMatrix(rows_, other.GetColumns());
    for (int i = 0; i < resultMatrix.GetRows(); i++) {
      for (int j = 0; j < resultMatrix.GetColumns(); j++) {
        for (int k = 0; k < cols_; k++) {
          resultMatrix(i, j) += ((*this)(i, k) * other(k, j));
        }
      }
    }
    *this = std::move(resultMatrix);
  } else {
    throw std::logic_error(
        "Incorrect input: number of columns in the first matrix should be"
        "equal to number of rows in the second matrix");
  }
}

MyMatrix MyMatrix::Transpose() const {
  MyMatrix newMatrix(cols_, rows_);
  for (int i = 0; i < rows_; i++) {
    for (int j = 0; j < cols_; j++) {
      newMatrix(j, i) = (*this)(i, j);
    }
  }
  return newMatrix;
}

MyMatrix MyMatrix::getMinorMatrix(int rows, int columns) const {
  if (this->rows_ == 1 && this->cols_ == 1)
    return *this;
  MyMatrix tmp(this->rows_ - 1, this->cols_ - 1);
  int shift_row = 0;
  int shift_col = 0;
  for (int i = 0; i < this->rows_ - 1; i++) {
    if (i == rows) {
      shift_row = 1;
    }
    shift_col = 0;
    for (int j = 0; j < this->cols_ - 1; j++) {
      if (j == columns) {
        shift_col = 1;
      }
      tmp(i, j) = (*this)(i + shift_row, j + shift_col);
    }
  }
  return tmp;
}

//!
double MyMatrix::Determinant() const {
  if (this->rows_ != this->cols_)
    throw std::out_of_range("The matrix is not squared");
  double result = 0;
  if (this->rows_ == 1)
    result = (*this)(0, 0);
  else if (this->rows_ == 2)
    result = (*this)(0, 0) * (*this)(1, 1) - (*this)(0, 1) * (*this)(1, 0);
  else {
    for (int j = 0; j < this->cols_; j++)
      result += ((j << 31) >> 31 == 0 ? 1 : -1) *
                getMinorMatrix(0, j).Determinant() * (*this)(0, j);
  }
  return result;
}

MyMatrix MyMatrix::CalcComplements() {
  if (rows_ != cols_)
    throw std::logic_error("Incorrect input, matrix should be squared");
  MyMatrix result(rows_, cols_);
  for (int i = 0; i < rows_; ++i) {
    for (int j = 0; j < cols_; ++j) {
      result(i, j) = (((i + j) << 31) >> 31 == 0 ? 1 : -1) *
                     getMinorMatrix(i, j).Determinant();
    }
  }
  return result;
}

MyMatrix MyMatrix::InverseMatrix() const {
  if (rows_ != cols_) {
    throw std::logic_error("Incorrect input, matrix should be squared");
  }

  double det = Determinant();

  if (det == 0.0 || abs(det) < precision) {
    throw std::logic_error(
        "Incorrect input, matrix is not invertible, determinant should be "
        "non-zero");
  }
  return Transpose().CalcComplements() * (1.0 / det);
}

int MyMatrix::GetRows() const noexcept { return rows_; }
int MyMatrix::GetColumns() const noexcept { return cols_; }

const double &MyMatrix::getElement(int row, int col) const {
  if (row >= rows_ || col >= cols_ || row < 0 || col < 0)
    throw std::out_of_range("Incorrect input, index out of bounds");

  return matrix_[row * cols_ + col];
}

void MyMatrix::SetRows(int new_rows) {
  if (new_rows < 1)
    throw std::length_error("Rows must be > 0");
  if (new_rows == rows_)
    return;

  MyMatrix tmp(new_rows, cols_);
  int min_rows = std::min(rows_, new_rows);
  std::copy(matrix_, matrix_ + min_rows * cols_, tmp.matrix_);
  *this = std::move(tmp);
}

void MyMatrix::SetColumns(int new_columns) {
  if (new_columns < 1)
    throw std::length_error("Column out of range; must be > 0");
  if (new_columns == cols_)
    return;

  MyMatrix tmp(rows_, new_columns);
  int min_cols = std::min(cols_, new_columns);

  for (int i = 0; i < rows_; ++i) {
    std::copy(matrix_ + i * cols_, matrix_ + i * cols_ + min_cols,
              tmp.matrix_ + i * new_columns);
  }
  *this = std::move(tmp);
}

// adiitional methods
void MyMatrix::set(int row, int col, double value) {
  if (row < 0 || row >= rows_ || col < 0 || col >= cols_)
    throw std::out_of_range("Index out of bounds");
  matrix_[row * cols_ + col] = value;
}

double MyMatrix::get(int row, int col) const {
  if (row < 0 || row >= rows_ || col < 0 || col >= cols_)
    throw std::out_of_range("Index out of bounds");
  return matrix_[row * cols_ + col];
}

void MyMatrix::printMatrix() const {
  for (int i = 0; i < rows_; i++) {
    for (int j = 0; j < cols_; j++) {
      std::cout << get(i, j) << " ";
    }
    std::cout << std::endl;
  }
}

void MyMatrix::SubMatrix(const MyMatrix &other) {
  if (rows_ != other.rows_ || cols_ != other.cols_) {
    throw std::invalid_argument("Matrix dimensions must match for subtraction");
  }

  for (int i = 0; i < rows_; i++) {
    for (int j = 0; j < cols_; j++) {
      set(i, j, get(i, j) - other.get(i, j));
    }
  }
}