lab 1.3 Source.cpp

← разместить еще код

Расшаренный код:

#include "Header.h"
#include <iostream>
#include <ctime>
// знаходження модуля числа
int abs(int argument) {
	if (argument > 0)
		return argument;
	return -argument;
}
// замiна елементiв модулями
void Matrix::Abs() {
	for (int i = 0; i < _rows; i++)
		for (int j = 0; j < _columns; j++)
			_matrix[i][j] = abs(_matrix[i][j]);
}
// створення обекта
void Matrix::AllocMemory(){
	_matrix = new int*[_rows];
	for (size_t i = 0; i < _rows; ++i)
		_matrix[i] = new int[_columns];
}
// випадкове заповнення
void Matrix::FillRandom() {
	srand(time(0));
	for (int i = 0; i < _rows; i++)
		for (int j = 0; j < _columns; j++)
			_matrix[i][j] = 1 + rand() % 10;
}

void Matrix::CopyElementsInRow(const Matrix &m, unsigned int i){
	for (unsigned int j = 0; j < _columns; ++j)
		_matrix[i][j] = m._matrix[i][j];
}
// копiювання матрицi
void Matrix::CopyMatrix(const Matrix &matrix){
	if (matrix._columns != _columns || matrix._rows != _rows)
		throw std::exception("Wrong sizes");
	for (size_t i = 0; i < _rows; ++i)
		CopyElementsInRow(matrix, i);
}

void Matrix::FillAllocatedMemory(){
	for (size_t i = 0; i < _rows; ++i)
		memset(_matrix[i], 0, _columns * sizeof(int));
}
// Блок сеттерiв и геттерiв
void Matrix::Set(size_t row, size_t columns, int value){
	_matrix[row][columns] = value;
}

int Matrix::Get(size_t row, size_t columns) const{
	return _matrix[row][columns];
}

size_t Matrix::GetRows() {
	return _rows;
}

size_t Matrix::GetColumns() {
	return _columns;
}
// Блок конструкторiв i деструктора
Matrix::Matrix(size_t rows, size_t columns){
	this->_rows = rows; this->_columns = columns;
	AllocMemory();
	FillAllocatedMemory();
}

Matrix::Matrix(const Matrix &matrix){
	_rows = matrix._rows;
	_columns = matrix._columns;
	AllocMemory();
	CopyMatrix(matrix);
}

Matrix::~Matrix(){
	for (size_t i = 0; i < _rows; ++i)
		delete[] _matrix[i];
	delete[] _matrix;
}

void Matrix::GetSumRows(const Matrix &firstMatrix, const Matrix &secondMatrix, size_t i){
	for (size_t j = 0; j < GetColumns(); ++j)
		Set(i, j, firstMatrix.Get(i, j) + secondMatrix.Get(i, j));
}
void Matrix::GetDifRows(const Matrix &firstMatrix, const Matrix &secondMatrix, size_t i) {
	for (size_t j = 0; j < GetColumns(); ++j)
		Set(i, j, firstMatrix.Get(i, j) - secondMatrix.Get(i, j));
}
// блок перевантаження операторiв
istream& operator>> (istream &in, Matrix& m) {
	for (int i = 0; i < m._rows; i++) {
		for (int j = 0; j < m._columns; j++) {
			in >> m._matrix[i][j];
		}
	}
	return in;
}

ostream& operator<< (ostream &out, Matrix& m) {
	for (int i = 0; i < m._rows; i++) {
		for (int j = 0; j < m._columns; j++) {
			out << m._matrix[i][j] << " ";
		}
		out << "\n";
	}
	return out;
}

Matrix operator+(const Matrix &firstMatrix, const Matrix &secondMatrix){
	if (firstMatrix._rows != secondMatrix._rows || firstMatrix._columns != secondMatrix._columns)
		throw MyException("Wrong sizes!",firstMatrix._rows,firstMatrix._columns,secondMatrix._rows,secondMatrix._columns);

	Matrix matrix(firstMatrix._rows, firstMatrix._columns);
	for (size_t i = 0; i < matrix._rows; ++i)
		matrix.GetSumRows(firstMatrix, secondMatrix, i);
	return matrix;
}

Matrix operator-(const Matrix &firstMatrix, const Matrix &secondMatrix) {
	if (firstMatrix._rows != secondMatrix._rows || firstMatrix._columns != secondMatrix._columns)
		throw MyException("Wrong sizes!", firstMatrix._rows, firstMatrix._columns, secondMatrix._rows, secondMatrix._columns);

	Matrix matrix(firstMatrix._rows, firstMatrix._columns);
	for (size_t i = 0; i < matrix._rows; ++i)
		matrix.GetDifRows(firstMatrix, secondMatrix, i);
	return matrix;
}

Matrix operator*(const Matrix &firstMatrix, const Matrix &secondMatrix) {
	if (firstMatrix._columns != secondMatrix._rows && firstMatrix._rows != secondMatrix._columns)
		throw MyException("Wrong sizes!", firstMatrix._rows, firstMatrix._columns, secondMatrix._rows, secondMatrix._columns);
	Matrix matrix(firstMatrix._rows, secondMatrix._columns);
	for (int i = 0; i < firstMatrix._rows; i++){
		for (int j = 0; j < secondMatrix._columns; j++)
		{
			matrix._matrix[i][j] = 0;
			for (int k = 0; k < firstMatrix._columns; k++)
				matrix._matrix[i][j] += firstMatrix._matrix[i][k] * secondMatrix._matrix[k][j];
		}
	}
	return matrix;
}

Matrix &Matrix::operator=(const Matrix &matrix){
	CopyMatrix(matrix);
	return *this;
}

int& Matrix::operator()(int i, int j) {
	return _matrix[i][j];
}