184 lines
4.0 KiB
C++
184 lines
4.0 KiB
C++
#include "matrix.h"
|
|
|
|
void Matrix::delete_data() {
|
|
for (int i = 0; i < m; i++) {
|
|
delete [] this->data[i];
|
|
}
|
|
delete [] this->data;
|
|
|
|
this->m = 0;
|
|
this->n = 0;
|
|
}
|
|
|
|
void Matrix::insert_matrix(const Matrix& m) {
|
|
this->m = m.m;
|
|
this->n = m.n;
|
|
|
|
this->data = new int* [this->m];
|
|
for (int i = 0; i < this->m; i++) {
|
|
this->data[i] = new int [this->n];
|
|
for (int j = 0; j < this->n; j++) {
|
|
this->data[i][j] = m.data[i][j];
|
|
}
|
|
}
|
|
}
|
|
|
|
Matrix::Matrix(int m, int n, int value) {
|
|
this->m = m;
|
|
this->n = n;
|
|
this->data = new int* [this->m];
|
|
|
|
for (int i = 0; i < this->m; i++) {
|
|
this->data[i] = new int [this->n];
|
|
for (int j = 0; j < this->n; j++) {
|
|
this->data[i][j] = value;
|
|
}
|
|
}
|
|
}
|
|
|
|
Matrix::Matrix(const Matrix& m) {
|
|
this->insert_matrix(m);
|
|
}
|
|
|
|
Matrix::~Matrix() {
|
|
this->delete_data();
|
|
}
|
|
|
|
Matrix& Matrix::operator= (const Matrix& m) {
|
|
if (this == &m) {
|
|
return *this;
|
|
}
|
|
|
|
this->delete_data();
|
|
|
|
this->insert_matrix(m);
|
|
|
|
return *this;
|
|
}
|
|
|
|
int Matrix::det() {
|
|
if (this->m != this->n) {
|
|
throw logic_error("Determinant of matrix that is not square is undefined!");
|
|
}
|
|
|
|
if (this->m == 1) {
|
|
return this->data[0][0];
|
|
} else {
|
|
int res = 0;
|
|
for (int j = 0; j < this->n; j++) {
|
|
// ! alg_add causes recursion
|
|
res += this->data[0][j] * this->alg_add(1, j + 1);
|
|
}
|
|
return res;
|
|
}
|
|
}
|
|
|
|
int Matrix::rank() {
|
|
}
|
|
|
|
Matrix Matrix::get_transposed_matrix() {
|
|
Matrix tmat(this->n, this->m);
|
|
for (int i = 0; i < this->m; i++) {
|
|
for (int j = 0; j < this->n; j++) {
|
|
tmat[j][i] = (*this)[i][j];
|
|
}
|
|
}
|
|
|
|
return tmat;
|
|
}
|
|
|
|
Matrix Matrix::get_minor_matrix(int im, int jn) {
|
|
// out arrays begin from 0 and user expects matrix to begin from 1
|
|
im--; jn--;
|
|
|
|
if (this->m != this->n) {
|
|
throw logic_error("This function can find only minor of square matrix.");
|
|
}
|
|
if (im > this->m || jn > this->n) {
|
|
throw out_of_range("Minor indexes are out of range.");
|
|
}
|
|
|
|
Matrix res(this->m - 1, this->n - 1);
|
|
|
|
int ni = 0, nj = 0;
|
|
for (int i = 0; i < this->m; i++) {
|
|
if (i != im) {
|
|
nj = 0;
|
|
for (int j = 0; j < this->n; j++) {
|
|
if (j != jn) {
|
|
res.data[ni][nj] = this->data[i][j];
|
|
nj++;
|
|
}
|
|
}
|
|
ni++;
|
|
}
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
int Matrix::alg_add(int m, int n) {
|
|
Matrix minor = this->get_minor_matrix(m, n);
|
|
return (((m + n) % 2 == 0)? 1: -1) * minor.det();
|
|
}
|
|
|
|
int* Matrix::operator[] (int i) {
|
|
if (i > this->m) {
|
|
throw out_of_range("");
|
|
}
|
|
return this->data[i];
|
|
}
|
|
|
|
Matrix operator* (const int& k, const Matrix& m) {
|
|
Matrix res(m);
|
|
for (int i = 0; i < res.m; i++) {
|
|
for (int j = 0; j < res.n; j++) {
|
|
res.data[i][j] *= k;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
bool Matrix::operator== (const Matrix& m) {
|
|
if (this->m != m.m || this->n != m.n) {
|
|
return false;
|
|
}
|
|
for (int i = 0; i < m.m; i++) {
|
|
for (int j = 0; j < m.n; j++) {
|
|
if (this->data[i][j] != m.data[i][j]) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
Matrix operator+ (const Matrix& m1, const Matrix& m2) {
|
|
if (m1.m == m2.m && m1.n == m2.n) {
|
|
Matrix res(m1.m, m2.n);
|
|
for (int i = 0; i < m1.m; i++) {
|
|
for (int j = 0; j < m1.n; j++) {
|
|
res.data[i][j] = m1.data[i][j] + m2.data[i][j];
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
else {
|
|
throw invalid_argument("Matrixes must have the same size!");
|
|
}
|
|
}
|
|
|
|
ostream& operator<< (ostream& out, const Matrix& m) {
|
|
cout << "--" << endl;
|
|
for (int i = 0; i < m.m; i++) {
|
|
out << "| ";
|
|
for (int j = 0; j < m.n; j++) {
|
|
out << m.data[i][j] << " ";
|
|
}
|
|
out << endl;
|
|
}
|
|
cout << "--";
|
|
return out;
|
|
}
|