481 lines
11 KiB
C++
481 lines
11 KiB
C++
#include <iostream>
|
|
#include <fstream>
|
|
#include <string.h>
|
|
#include <cstdlib>
|
|
#include <ctime>
|
|
#include <tuple>
|
|
using namespace std;
|
|
|
|
/*class Exception: public exception
|
|
{
|
|
protected:
|
|
//????????? ?? ??????
|
|
char* str;
|
|
public:
|
|
Exception(const char* s)
|
|
{
|
|
str = new char[strlen(s) + 1];
|
|
strcpy_s(str, strlen(s) + 1, s);
|
|
}
|
|
Exception(const Exception& e)
|
|
{
|
|
str = new char[strlen(e.str) + 1];
|
|
strcpy_s(str, strlen(e.str) + 1, e.str);
|
|
}
|
|
~Exception()
|
|
{
|
|
delete[] str;
|
|
}
|
|
|
|
virtual void print()
|
|
{
|
|
cout << "Exception: " << str<< "; "<<what();
|
|
}
|
|
};*/
|
|
|
|
class Exception : public exception
|
|
{
|
|
protected:
|
|
char* str;
|
|
public:
|
|
Exception(const char* s)
|
|
{
|
|
str = new char[strlen(s) + 1];
|
|
strcpy_s(str, strlen(s) + 1, s);
|
|
}
|
|
Exception(const Exception& e)
|
|
{
|
|
str = new char[strlen(e.str) + 1];
|
|
strcpy_s(str, strlen(e.str) + 1, e.str);
|
|
}
|
|
~Exception()
|
|
{
|
|
delete[] str;
|
|
}
|
|
|
|
virtual void print()
|
|
{
|
|
cout << "Exception: " << str << "; " << what();
|
|
}
|
|
};
|
|
|
|
class InvalidOperationException : public Exception {
|
|
public:
|
|
InvalidOperationException(const char* s) : Exception(s) {}
|
|
virtual void print()
|
|
{
|
|
cout << "InvalidOperationException: " << str << "; " << what();
|
|
}
|
|
};
|
|
|
|
|
|
class WrongSizeException : public Exception
|
|
{
|
|
protected:
|
|
int Row1, Col1, Row2, Col2;
|
|
public:
|
|
WrongSizeException(const char* s, int row1, int col1, int row2, int col2) : Exception(s) { Row1 = row1; Col1 = col1; Row2 = row2; Col2 = col2; }
|
|
virtual void print()
|
|
{
|
|
cout << "WrongSizeException: " << str << "; " << Row1 << ", " << Col1 << ", " << Row2 << ", " << Col2 << "; " << what();
|
|
}
|
|
};
|
|
|
|
class IndexOutOfBoundsException : public Exception
|
|
{
|
|
protected:
|
|
int Row, Col;
|
|
public:
|
|
IndexOutOfBoundsException(const char* s, int row, int col) : Exception(s) { Row = row; Col = col; }
|
|
virtual void print()
|
|
{
|
|
cout << "IndexOutOfBoundsException: " << str << "; " << Row << ", " << Col << "; " << what();
|
|
}
|
|
};
|
|
class NonPositiveSizeException : public WrongSizeException
|
|
{
|
|
public:
|
|
NonPositiveSizeException(const char* s, int row1, int col1, int row2, int col2) : WrongSizeException(s, row1, col1, row2, col2) {}
|
|
|
|
virtual void print()
|
|
{
|
|
cout << "NonPositiveSizeException: " << str << "; " << Row1 << ", " << Col1 << ", " << Row2 << ", " << Col2 << "; " << what();
|
|
}
|
|
};
|
|
|
|
class TooLargeSizeException : public WrongSizeException
|
|
{
|
|
public:
|
|
TooLargeSizeException(const char* s, int row1, int col1, int row2, int col2) : WrongSizeException(s, row1, col1, row2, col2) {}
|
|
|
|
virtual void print()
|
|
{
|
|
cout << "TooLargeSizeException: " << str << "; " << Row1 << ", " << Col1 << ", " << Row2 << ", " << Col2 << "; " << what();
|
|
}
|
|
};
|
|
|
|
//My exception
|
|
class CenterOfMassCalculationException : public Exception {
|
|
public:
|
|
CenterOfMassCalculationException(const char* s) : Exception(s) {}
|
|
virtual void print() {
|
|
cout << "CenterOfMassCalculationException: " << str << "; " << what();
|
|
}
|
|
};
|
|
|
|
template<class T>
|
|
class BaseMatrix
|
|
{
|
|
protected:
|
|
T** ptr;
|
|
int height;
|
|
int width;
|
|
public:
|
|
BaseMatrix(int Height = 2, int Width = 2)
|
|
{
|
|
if (Height <= 0 || Width <= 0)
|
|
{
|
|
throw NonPositiveSizeException("Attempt to create a matrix of negative or zero size", Height, Width, -1, -1);
|
|
}
|
|
height = Height;
|
|
width = Width;
|
|
ptr = new T* [height];
|
|
for (int i = 0; i < height; i++)
|
|
ptr[i] = new T[width];
|
|
}
|
|
|
|
BaseMatrix(const BaseMatrix& M)
|
|
{
|
|
height = M.height;
|
|
width = M.width;
|
|
ptr = new T* [height];
|
|
for (int i = 0; i < height; i++)
|
|
{
|
|
ptr[i] = new T[width];
|
|
for (int j = 0; j < width; j++)
|
|
ptr[i][j] = M.ptr[i][j];
|
|
}
|
|
}
|
|
|
|
BaseMatrix operator=(BaseMatrix& V)
|
|
{
|
|
if (height != V.height && width != V.width)
|
|
{
|
|
if (ptr != NULL)
|
|
{
|
|
for (int i = 0; i < height; i++)
|
|
delete[] ptr[i];
|
|
delete[] ptr;
|
|
ptr = NULL;
|
|
}
|
|
height = V.height;
|
|
width = V.width;
|
|
ptr = new double* [height];
|
|
for (int i = 0; i < height; i++)
|
|
ptr[i] = new double[width];
|
|
}
|
|
for (int i = 0; i < height; i++)
|
|
for (int j = 0; j < width; j++)
|
|
ptr[i][j] = V.ptr[i][j];
|
|
return *this;
|
|
}
|
|
|
|
~BaseMatrix()
|
|
{
|
|
if (ptr != NULL)
|
|
{
|
|
for (int i = 0; i < height; i++)
|
|
delete[] ptr[i];
|
|
delete[] ptr;
|
|
ptr = NULL;
|
|
}
|
|
}
|
|
|
|
void print()
|
|
{
|
|
for (int i = 0; i < height; i++)
|
|
{
|
|
for (int j = 0; j < width; j++)
|
|
cout << ptr[i][j] << " ";
|
|
cout << "\n";
|
|
}
|
|
}
|
|
|
|
double& operator()(int row, int col)
|
|
{
|
|
if (row < 0 || col < 0 || row >= height || col >= width)
|
|
throw IndexOutOfBoundsException("IndexOutOfBoundsException in operator()", row, col);
|
|
return ptr[row][col];
|
|
}
|
|
};
|
|
template <class T>
|
|
class Matrix : public BaseMatrix<T>
|
|
{
|
|
public:
|
|
using BaseMatrix<T>::ptr;
|
|
using BaseMatrix<T>::height;
|
|
using BaseMatrix<T>::width;
|
|
|
|
Matrix(int Height = 2, int Width = 2) : BaseMatrix<T>(Height, Width) { cout << "\nMatrix constructor\n"; }
|
|
~Matrix() { cout << "\nMatrix destructor\n"; }
|
|
Matrix(T** array, int Height, int Width) : BaseMatrix<T>(Height, Width)
|
|
{
|
|
ptr = new T* [height];
|
|
for (int i = 0; i < height; ++i)
|
|
{
|
|
ptr[i] = new T[width];
|
|
for (int j = 0; j < width; ++j)
|
|
{
|
|
ptr[i][j] = array[i][j];
|
|
}
|
|
}
|
|
}
|
|
// Filling a matrix element by the sum of its indices
|
|
void fillRandom(int a)
|
|
{
|
|
// Initialization of random number generator with current time
|
|
srand(time(nullptr));
|
|
|
|
for (int i = 0; i < height; ++i)
|
|
{
|
|
for (int j = 0; j < width; ++j)
|
|
{
|
|
// Random number generation
|
|
ptr[i][j] = (rand() * (a + 1))%100;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
pair<double, double> calculateCenterOfMass()
|
|
{
|
|
double totalMass = 0;
|
|
double centerX = 0;
|
|
double centerY = 0;
|
|
|
|
for (int i = 0; i < this->height; ++i)
|
|
{
|
|
for (int j = 0; j < this->width; ++j)
|
|
{
|
|
totalMass += this->ptr[i][j];
|
|
centerX += i * this->ptr[i][j];
|
|
centerY += j * this->ptr[i][j];
|
|
}
|
|
}
|
|
/*if (totalMass != 0)
|
|
{
|
|
centerX /= totalMass;
|
|
centerY /= totalMass;
|
|
}*/
|
|
if (totalMass == 0)
|
|
{
|
|
throw CenterOfMassCalculationException("Total mass is zero, cannot calculate center of mass.");
|
|
}
|
|
|
|
centerX /= totalMass;
|
|
centerY /= totalMass;
|
|
|
|
return make_pair(centerX, centerY);
|
|
}
|
|
|
|
|
|
double Trace()
|
|
{
|
|
if (height != width)
|
|
{
|
|
throw InvalidOperationException("The operation of finding the trace is not defined for a non-square matrix");
|
|
}
|
|
double summ = 0;
|
|
for (int i = 0; i < height; i++)
|
|
summ += ptr[i][i];
|
|
return summ;
|
|
}
|
|
|
|
Matrix operator+(Matrix M)
|
|
{
|
|
if (height != M.height || width != M.width)
|
|
throw WrongSizeException("Unequal size of matrices to add in operator+()", height, width, M.height, M.width);
|
|
Matrix res(height, width);
|
|
for (int i = 0; i < height; i++)
|
|
for (int j = 0; j < width; j++)
|
|
res(i, j) = ptr[i][j] + M.ptr[i][j];
|
|
return res;
|
|
}
|
|
// Перегрузка оператора присваивания
|
|
Matrix& operator=(const Matrix& other)
|
|
{
|
|
if (this != &other)
|
|
{
|
|
this->~Matrix();
|
|
|
|
height = other.height;
|
|
width = other.width;
|
|
|
|
ptr = new double* [height];
|
|
for (int i = 0; i < height; ++i)
|
|
{
|
|
ptr[i] = new double[width];
|
|
for (int j = 0; j < width; ++j)
|
|
{
|
|
ptr[i][j] = other.ptr[i][j];
|
|
}
|
|
}
|
|
}
|
|
return *this;
|
|
}
|
|
template<class T>
|
|
friend ostream& operator<<(ostream& s, Matrix<T> M);
|
|
template<class T>
|
|
friend istream& operator>>(istream& s, Matrix<T>& M);
|
|
};
|
|
|
|
template<class T>
|
|
ostream& operator<<(ostream& s, Matrix<T> M)
|
|
{
|
|
if (typeid(s) == typeid(ofstream))
|
|
{
|
|
s << M.height << " " << M.width << " ";
|
|
for (int i = 0; i < M.height; i++)
|
|
for (int j = 0; j < M.width; j++)
|
|
s << M.ptr[i][j] << " ";
|
|
return s;
|
|
}
|
|
for (int i = 0; i < M.height; i++)
|
|
{
|
|
for (int j = 0; j < M.width; j++)
|
|
s << M.ptr[i][j] << " ";
|
|
s << "\n";
|
|
}
|
|
return s;
|
|
}
|
|
|
|
template<class T>
|
|
istream& operator>>(istream& s, Matrix<T>& M)
|
|
{
|
|
if (typeid(s) == typeid(ifstream))
|
|
{
|
|
int w, h; s >> h >> w;
|
|
if (h != M.height || w != M.width)
|
|
{
|
|
throw InvalidOperationException("The dimensions of the read matrix are different from those of the original matrix.");
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < M.height; i++)
|
|
for (int j = 0; j < M.width; j++)
|
|
s >> M.ptr[i][j];
|
|
return s;
|
|
}
|
|
|
|
int main() {
|
|
try {
|
|
Matrix<double> M[10];
|
|
// Matrix filling and output
|
|
for (int i = 0; i < 3; i++) {
|
|
cout << "Matrix " << i + 1 << ":" << endl;
|
|
M[i].fillRandom(i);
|
|
cout << M[i] << endl;
|
|
}
|
|
|
|
// Saving a matrix array to a file
|
|
ofstream fout("1.txt");
|
|
if (fout) {
|
|
fout << "3\n";
|
|
for (int i = 0; i < 3; i++)
|
|
fout << M[i] << "\n";
|
|
fout.close();
|
|
}
|
|
|
|
// To test wrong matrix size input
|
|
// Saving a matrix array to a file with one matrix having different dimensions
|
|
// (uncomment this for testing)
|
|
|
|
//ofstream fout("1.txt");
|
|
//if (fout) {
|
|
// fout << "3\n";
|
|
// for (int i = 0; i < 2; i++) // Save the first two matrices normally
|
|
// fout << M[i] << "\n";
|
|
// fout << "3 3 "; // Write incorrect dimensions for the third matrix
|
|
// for (int i = 0; i < 3; i++) {
|
|
// for (int j = 0; j < 3; j++) {
|
|
// fout << (rand() % 100) << " "; // Fill the incorrect matrix with random values
|
|
// }
|
|
// }
|
|
// fout.close();
|
|
//}
|
|
|
|
|
|
// reading a matrix array from a file
|
|
Matrix<double>* M1;
|
|
ifstream fin("1.txt");
|
|
|
|
if (fin) {
|
|
int n;
|
|
fin >> n;
|
|
M1 = new Matrix<double>[n];
|
|
for (int i = 0; i < 3; i++) {
|
|
fin >> M1[i];
|
|
cout << "Matrix from file " << i + 1 << ":" << endl;
|
|
cout << M1[i] << endl;
|
|
}
|
|
delete[] M1;
|
|
}
|
|
Matrix<double> A(2, 2);
|
|
A.fillRandom(4);
|
|
A.print();
|
|
Matrix<double> B(2, 2);
|
|
B.fillRandom(3);
|
|
B.print();
|
|
Matrix<double> C = A + B; // matrix1+matrix2
|
|
cout << "A + B:" << endl << C << endl;
|
|
|
|
Matrix<double> D;
|
|
D = A; //Assignment of matrix
|
|
cout << "D (assigned from A):" << endl << D << endl;
|
|
double a, b;
|
|
A.print();
|
|
tie(a,b)=A.calculateCenterOfMass(); //calculate Center Of Mass
|
|
cout << "Center of Mass of A:" << endl;
|
|
cout << a << ", " << b << "\n";
|
|
double traceA = A.Trace(); // calculate trace
|
|
cout << "Trace of A: " << traceA << endl;
|
|
|
|
|
|
// Test CenterOfMassCalculationException
|
|
Matrix<double> ZeroMatrix(2, 2);
|
|
for (int i = 0; i < 2; ++i) {
|
|
for (int j = 0; j < 2; ++j) {
|
|
ZeroMatrix(i, j) = 0;
|
|
}
|
|
}
|
|
cout << "ZeroMatrix:" << endl;
|
|
ZeroMatrix.print();
|
|
tie(a, b) = ZeroMatrix.calculateCenterOfMass();
|
|
cout << "Center of Mass of ZeroMatrix:" << endl;
|
|
cout << a << ", " << b << "\n";
|
|
}
|
|
|
|
catch (IndexOutOfBoundsException& ex)
|
|
{
|
|
cout << "IndexOutOfBoundsException has been caught: ";
|
|
ex.print();
|
|
}
|
|
catch (CenterOfMassCalculationException& ex)
|
|
{
|
|
cout << "CenterOfMassCalculationException has been caught: ";
|
|
ex.print();
|
|
}
|
|
catch (Exception& ex)
|
|
{
|
|
cout << "Exception has been caught: ";
|
|
ex.print();
|
|
}
|
|
catch (exception& ex)
|
|
{
|
|
cout << "Standard exception has been caught: " << ex.what();
|
|
}
|
|
|
|
|
|
return 0;
|
|
}
|