SimplexTASK/tools/matrix.cpp

#include "matrix.h"

ColumnVector::ColumnVector(int n) {
	rows = n;
	columns = 1;
	columnVector.resize(n);
}

ColumnVector::ColumnVector(const ColumnVector& other) {
	rows = other.rows;
	columns = other.columns;
	columnVector = other.columnVector;
}

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

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

double& ColumnVector::operator[](int row) {
	return columnVector[row];
}

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

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

	return result;
}

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

	return result;
}

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

std::ostream& operator<<(std::ostream& cout, ColumnVector& 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, ColumnVector(m));
}

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

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

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

ColumnVector& 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;
}

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

	ColumnVector 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) {
	for (int i = 0; i < matrixObj.rows; ++i) {
		for (int j = 0; j < matrixObj.columns; ++j) {
			if (j == matrixObj.columns - 1) {
				cout << matrixObj[i][j] << std::endl;
			}
			else {
				cout << matrixObj[i][j] << ' ';
			}
		}
	}
	return cout;
}