SimplexTASK/tools/matrix.cpp

#include "matrix.h"

Vector::Vector(int n)
{
  rows = n;
  columns = 1;
  vector.resize(n);
}

Vector::Vector(const Vector &other)
{
  rows = other.rows;
  columns = other.columns;
  vector = other.vector;
}

Vector::Vector(std::initializer_list<double> init)
{
  rows = init.size();
  columns = 1;
  vector = std::vector<double>(rows);

  auto it = init.begin();

  for (size_t i = 0; i < init.size(); ++i)
  {
    vector[i] = *it++;
  }
}

int Vector::size() const
{
  return rows;
}

double &Vector::operator[](int row)
{
  return vector[row];
}

Vector &Vector::operator=(const Vector &other)
{
  rows = other.rows;
  columns = other.columns;
  vector = other.vector;
  return *this;
}

Vector Vector::operator+(Vector &other)
{
  if (rows != other.rows)
  {
    throw std::runtime_error("Error: the dimensional problem occurred");
  }
  Vector result(rows);
  for (int i = 0; i < rows; ++i)
  {
    result[i] = vector[i] + other[i];
  }

  return result;
}

Vector Vector::operator-(Vector &other)
{
  if (rows != other.rows)
  {
    throw std::runtime_error("Error: the dimensional problem occurred");
  }
  Vector result(rows);
  for (int i = 0; i < rows; ++i)
  {
    result[i] = vector[i] - other[i];
  }

  return result;
}

std::istream &operator>>(std::istream &cin, Vector &vectorObj)
{
  for (int i = 0; i < vectorObj.rows; ++i)
  {
    cin >> vectorObj[i];
  }
  return cin;
}

std::ostream &operator<<(std::ostream &cout, Vector &vectorObj)
{
  for (int i = 0; i < vectorObj.rows; ++i)
  {
    if (i == vectorObj.rows - 1)
    {
      cout << vectorObj[i] << std::endl;
    }
    else
    {
      cout << vectorObj[i] << ' ';
    }
  }
  return cout;
}

Matrix::Matrix(int n, int m)
{
  rows = n;
  columns = m;
  matrix.resize(n, Vector(m));
  for (auto &row : matrix)
  {
    row = Vector(m);
  }
}

Matrix::Matrix(const Matrix &other)
{
  rows = other.rows;
  columns = other.columns;
  matrix = other.matrix;
}

Matrix::Matrix(std::initializer_list<std::vector<double>> init)
{
  rows = init.size();
  auto it = init.begin();
  columns = it->size();
  matrix = std::vector<Vector>(rows, Vector(columns));

  for (int i = 0; i < rows; ++i)
  {
    for (int j = 0; j < columns; ++j)
    {
      matrix[i][j] = it->operator[](j);
    }
    ++it;
  }
}

int Matrix::getRows() const
{
  return rows;
}

int Matrix::getColumns() const
{
  return columns;
}

Vector &Matrix::operator[](int row)
{
  return matrix[row];
}

Matrix &Matrix::operator=(const Matrix &other)
{
  rows = other.rows;
  columns = other.columns;
  matrix = other.matrix;
  return *this;
}

Matrix Matrix::operator+(Matrix &other) const
{
  if (rows != other.rows || columns != other.columns)
  {
    throw std::runtime_error("Error: the dimensional problem occurred");
  }
  Matrix result(rows, columns);
  for (int i = 0; i < rows; ++i)
  {
    for (int j = 0; j < columns; ++j)
    {
      auto x = matrix[i];
      auto y = other[i];
      result[i][j] = x[j] + y[j];
    }
  }

  return result;
}

Matrix Matrix::operator-(Matrix &other) const
{
  if (rows != other.rows || columns != other.columns)
  {
    throw std::runtime_error("Error: the dimensional problem occurred");
  }
  Matrix result(rows, columns);
  for (int i = 0; i < rows; ++i)
  {
    for (int j = 0; j < columns; ++j)
    {
      auto x = matrix[i];
      auto y = other[i];
      result[i][j] = x[j] - y[j];
    }
  }

  return result;
}

Matrix Matrix::operator*(Matrix &other) const
{
  if (columns != other.rows)
  {
    throw std::runtime_error("Error: the dimensional problem occurred");
  }

  Matrix result(rows, other.columns);
  for (int i = 0; i < rows; ++i)
  {
    for (int j = 0; j < other.columns; ++j)
    {
      result[i][j] = 0;
      for (int k = 0; k < columns; ++k)
      {
        auto x = matrix[i];
        auto y = other[k];
        result[i][j] += x[k] * y[j];
      }
    }
  }

  return result;
}

Vector Matrix::operator*(Vector other) const
{
  if (columns != other.size())
  {
    throw std::runtime_error("Error: the dimensional problem occurred");
  }

  Vector result(rows);
  for (int i = 0; i < rows; ++i)
  {
    result[i] = 0;
    for (int k = 0; k < columns; ++k)
    {
      auto x = matrix[i];
      result[i] += x[k] * other[k];
    }
  }

  return result;
}

Matrix Matrix::transpose() const
{
  Matrix result(columns, rows);
  for (int i = 0; i < rows; ++i)
  {
    for (int j = 0; j < columns; ++j)
    {
      auto x = matrix[i];
      result[j][i] = x[j];
    }
  }

  return result;
}

std::istream &operator>>(std::istream &cin, Matrix &matrixObj)
{
  for (int i = 0; i < matrixObj.rows; ++i)
  {
    for (int j = 0; j < matrixObj.columns; ++j)
    {
      cin >> matrixObj[i][j];
    }
  }
  return cin;
}

std::ostream &operator<<(std::ostream &cout, Matrix &matrixObj)
{
  size_t maxNumberLength = 1;
  for (int y = 0; y < matrixObj.getRows(); y++)
  {
    for (int x = 0; x < matrixObj.getColumns(); x++)
    {
      if (std::to_string(matrixObj[y][x]).length() > maxNumberLength)
      {
        maxNumberLength = std::to_string(matrixObj[y][x]).length();
      }
    }
  }
  // std::cout << maxNumberLength << std::endl;
  std::cout << std::endl;
  for (int y = 0; y < matrixObj.getRows(); y++)
  {
    std::string row = "";
    for (int x = 0; x < matrixObj.getColumns(); x++)
    {
      std::string strNumber = std::to_string(matrixObj[y][x]);
      bool spaceRight = true;
      while (strNumber.length() < maxNumberLength)
      {
        if (spaceRight)
        {
          strNumber += " ";
        }
        else
        {
          strNumber = " " + strNumber;
        }
        spaceRight = !spaceRight;
        strNumber = "" + strNumber;
      }
      if (matrixObj[y][x] == 0)
      {
        row += "[\033[0m" + strNumber + "\033[0m] ";
      }
      else if (matrixObj[y][x] > 0)
      {
        row += "[\033[32m" + strNumber + "\033[0m] ";
      }
      else
      {
        row += "[\033[31m" + strNumber + "\033[0m] ";
      }
    }
    std::cout << row << std::endl;
  }
  std::cout << std::endl;

  return cout;
}