SaveText.Ru

Без имени
  1. //Header
  2. #pragma once
  3. #include <iostream>
  4. #include <vector>
  5. #include <ctime>
  6. #include <cmath>
  7. #include <clocale>
  8. using namespace std;
  9.  
  10. class matrix
  11. {
  12. public:
  13.         int n;
  14.         int m;
  15.         vector <vector<float>> a;
  16.         matrix();
  17.         matrix(int n);
  18.         matrix(int n, int m);
  19.         matrix(matrix& mat);
  20.         void FillRandomMatrix();
  21.         void PrintMatrix();
  22.         void setElement(int j, int i, float a);
  23.         matrix Transposition();
  24.         float max(const vector <float> value);
  25.         virtual float SumNormsMatrix();
  26.         void operator= (matrix& mat);
  27.         bool operator== (matrix& mat);
  28.         bool operator> (matrix& mat);
  29.         bool operator< (matrix& mat);
  30.         bool operator!= (matrix& mat);
  31.         bool operator>= (matrix& mat);
  32.         bool operator<= (matrix& mat);
  33.         ~matrix();
  34. };
  35.  
  36. class square : public matrix
  37. {
  38. public:
  39.         square() : matrix() {}
  40.         square(int n) : matrix(n) {}
  41.         square(square& mat);
  42. };
  43.  
  44. class symmetric : public square
  45. {
  46. public:
  47.         symmetric() : square() {}
  48.         symmetric(int n);
  49.         symmetric(symmetric& mat);
  50.         void FillRandomMatrix();
  51.         ~symmetric();
  52.         void PrintMatrix();
  53.         float SumNormsMatrix();
  54.         void Transposition();
  55.         void operator= (symmetric& mat);
  56. };
  57.  
  58. class kit : public symmetric
  59. {
  60. public:
  61.         short size;
  62.         matrix* mats;
  63.         kit();
  64.         ~kit();
  65.         void Add(matrix *mat);
  66.         void Print();
  67. };
  68.  
  69. //kit.cpp
  70. #include "Header.h"
  71.  
  72. int main()
  73. {
  74.         setlocale(LC_ALL, "ru");
  75.         matrix* pmat;
  76.         matrix mat(2);
  77.         pmat = &mat;
  78.         square mat2(3);
  79.         matrix *pmat2;
  80.         pmat2 = &mat2;
  81.         kit a;
  82.         a.Add(pmat);
  83.         a.Add(pmat2);
  84.         a.Print();
  85.         return 0;
  86. }
  87.  
  88. //matrix
  89. #include "Header.h"
  90.  
  91. matrix::matrix() {
  92.         n = 0;
  93.         m = 0;
  94.         a.resize(0);
  95. }
  96. matrix::matrix(int n)
  97. {
  98.         this->n = n;
  99.         this->m = n;
  100.         a.resize(n);
  101.         for (int i = 0; i < n; i++) {
  102.                 a[i].resize(m);
  103.                 for (int j = 0; j < m; j++)
  104.                         a[i][j] = 0;
  105.         }
  106. }
  107. matrix::matrix(int n, int m)
  108. {
  109.         this->n = n;
  110.         this->m = m;
  111.         a.resize(n);
  112.         for (int i = 0; i < n; i++) {
  113.                 a[i].resize(m);
  114.                 for (int j = 0; j < m; j++)
  115.                         a[i][j] = 0;
  116.         }
  117. }
  118. matrix::matrix(matrix& mat) {
  119.         this->n = mat.n;
  120.         this->m = mat.m;
  121.         a.resize(n);
  122.         for (int i = 0; i < n; i++) {
  123.                 a[i].resize(m);
  124.                 for (int j = 0; j < m; j++)
  125.                         a[i][j] = mat.a[i][j];
  126.         }
  127. }
  128. void matrix::FillRandomMatrix() {
  129.         for (int i = 0; i < n; i++) {
  130.                 for (int j = 0; j < m; j++)
  131.                         a[i][j] = (rand() + time(0)) % 10;
  132.         }
  133. }
  134. void matrix::PrintMatrix() {
  135.         for (int i = 0; i < n; i++) {
  136.                 for (int j = 0; j < m; j++)
  137.                         cout << a[i][j] << "t";
  138.                 cout << endl;
  139.         }
  140.         cout << endl;
  141. }
  142. void matrix::setElement(int j, int i, float a) {
  143.         this->a[j][i] = a;
  144. }
  145. matrix matrix::Transposition() {
  146.         matrix b(m, n);
  147.         for (int i = 0; i < n; i++) {
  148.                 for (int j = 0; j < m; j++) {
  149.                         b.setElement(j, i, a[i][j]);
  150.                 }
  151.         }
  152.         return b;
  153. }
  154. float matrix::max(const vector <float> value)
  155. {
  156.         float max;
  157.         max = value[0];
  158.         for (int i = 0; i < value.size() - 1; i++)
  159.         {
  160.                 if (value[i + 1] > value[i])
  161.                         max = value[i + 1];
  162.         }
  163.         return max;
  164. }
  165. float matrix::SumNormsMatrix() {
  166.         vector <float> Norms = { 0,0,0 };
  167.         vector <float> Sum;
  168.         //Первая норма
  169.         Sum.resize(m);
  170.         for (int i = 0; i < m; i++)
  171.                 Sum[i] = 0;
  172.         for (int i = 0; i < n; i++)
  173.                 for (int j = 0; j < m; j++)
  174.                         Sum[i] += a[j][i];
  175.         //Вторая норма
  176.         for (int i = 0; i < n; i++)
  177.                 for (int j = 0; j < m; j++)
  178.                         Norms[1] += a[i][j] * a[i][j];
  179.         Norms[1] = sqrt(Norms[1]);
  180.         //Третья норма
  181.         Sum.clear();
  182.         Sum.resize(n);
  183.         for (int i = 0; i < n; i++)
  184.                 Sum[i] = 0;
  185.         for (int i = 0; i < n; i++)
  186.                 for (int j = 0; j < m; j++)
  187.                         Sum[i] += a[i][j];
  188.         Norms[2] = max(Sum);
  189.         return Norms[0] + Norms[1] + Norms[2];
  190. }
  191. void matrix::operator= (matrix& mat) {
  192.         if (!a.empty())
  193.                 a.clear();
  194.         this->n = mat.n;
  195.         this->m = mat.m;
  196.         a.resize(n);
  197.         for (int i = 0; i < n; i++) {
  198.                 a[i].resize(m);
  199.                 for (int j = 0; j < m; j++)
  200.                         a[i][j] = mat.a[i][j];
  201.         }
  202. }
  203. bool matrix::operator== (matrix& mat)
  204. {
  205.         float subtraction = this->SumNormsMatrix() - mat.SumNormsMatrix();
  206.         cout << this->SumNormsMatrix() << " " << mat.SumNormsMatrix() << " " << subtraction << endl;
  207.         if (subtraction == 0)
  208.                 return 1;
  209.         else return 0;
  210. }
  211. bool matrix::operator> (matrix& mat)
  212. {
  213.         float subtraction = this->SumNormsMatrix() - mat.SumNormsMatrix();
  214.         if (subtraction > 0)
  215.                 return 1;
  216.         else return 0;
  217. }
  218. bool matrix::operator< (matrix& mat)
  219. {
  220.         cout << "Оператор меньше " << endl;
  221.         float subtraction = this->SumNormsMatrix() - mat.SumNormsMatrix();
  222.         if (subtraction < 0)
  223.                 return 1;
  224.         else return 0;
  225. }
  226. bool matrix::operator!= (matrix& mat)
  227. {
  228.         float subtraction = this->SumNormsMatrix() - mat.SumNormsMatrix();
  229.         if (subtraction != 0)
  230.                 return 1;
  231.         else return 0;
  232. }
  233. bool matrix::operator>= (matrix& mat)
  234. {
  235.         float subtraction = this->SumNormsMatrix() - mat.SumNormsMatrix();
  236.         if (subtraction >= 0)
  237.                 return 1;
  238.         else return 0;
  239. }
  240. bool matrix::operator<= (matrix& mat)
  241. {
  242.         float subtraction = this->SumNormsMatrix() - mat.SumNormsMatrix();
  243.         if (subtraction <= 0)
  244.                 return 1;
  245.         else return 0;
  246. }
  247. matrix::~matrix() {
  248.         a.clear();
  249. }
  250.  
  251. //square
  252. #include "Header.h"
  253.  
  254. square::square(square& mat)
  255. {
  256.         this->n = mat.n;
  257.         this->m = mat.n;
  258.         a.resize(n);
  259.         for (int i = 0; i < n; i++) {
  260.                 a.resize(n);
  261.                 for (int j = 0; j < n; j++)
  262.                         a[i][j] = mat.a[i][j];
  263.         }
  264. }
  265.  
  266. //symmetric
  267. #include "Header.h"
  268.  
  269. symmetric::symmetric(int n)
  270. {
  271.         this->n = n;
  272.         this->m = n;
  273.         bool temp = 0;
  274.         a.resize(n);
  275.         for (int i = 0; i < n; i++)
  276.         {
  277.                 a.resize(i + 1);
  278.                 for (int j = 0; j < n; j++)
  279.                         if (j <= i)
  280.                                 a[i][j] = 0;
  281.         }
  282. }
  283. symmetric::symmetric(symmetric& mat)
  284. {
  285.         this->n = mat.n;
  286.         this->m = mat.m;
  287.         a.resize(n);
  288.         for (int i = 0; i < n; i++) {
  289.                 a.resize(i + 1);
  290.                 for (int j = 0; j < m; j++)
  291.                         a[i][j] = mat.a[i][j];
  292.         }
  293. }
  294. void symmetric::FillRandomMatrix()
  295. {
  296.         for (int i = 0; i < n; i++)
  297.                 for (int j = 0; j < m; j++)
  298.                         if (j <= i)
  299.                                 a[i][j] = (rand()+time(NULL)) % 10;
  300. }
  301. symmetric::~symmetric()
  302. {
  303.         a.clear();
  304. }
  305. void symmetric::PrintMatrix()
  306. {
  307.         for (int i = 0; i < n; i++) {
  308.                 for (int j = 0; j < m; j++)
  309.                 {
  310.                         if (j <= i)
  311.                                 cout << a[i][j] << "t";
  312.                         else cout << a[j][i] << "t";
  313.                 }
  314.                 cout << endl;
  315.         }
  316. }
  317. float symmetric::SumNormsMatrix() {
  318.         vector <float> Norms = { 0,0,0 };
  319.         vector <float> Sum;
  320.         //Первая норма
  321.         Sum.resize(m);
  322.         for (int i = 0; i < m; i++)
  323.                 Sum[i] = 0;
  324.         for (int i = 0; i < n; i++)
  325.                 for (int j = 0; j < m; j++)
  326.                         if (j <= i)
  327.                                 Sum[i] += a[j][i];
  328.         //Вторая норма
  329.         for (int i = 0; i < n; i++)
  330.                 for (int j = 0; j < m; j++)
  331.                         if (j <= i)
  332.                                 Norms[1] += a[i][j] * a[i][j];
  333.         Norms[1] = sqrt(Norms[1]);
  334.         //Третья норма
  335.         Sum.clear();
  336.         Sum.resize(n);
  337.         for (int i = 0; i < n; i++)
  338.                 Sum[i] = 0;
  339.         for (int i = 0; i < n; i++)
  340.                 for (int j = 0; j < m; j++)
  341.                         if (j <= i)
  342.                                 Sum[i] += a[i][j];
  343.         Norms[2] = max(Sum);
  344.         return Norms[0] + Norms[1] + Norms[2];
  345. }
  346. void symmetric::Transposition()
  347. {
  348.         cout << "Матрица не транспонируется..." << endl;
  349. }
  350. void symmetric::operator= (symmetric& mat) {
  351.         if (this == &mat)
  352.                 return;
  353.         a.clear();
  354.         this->n = mat.n;
  355.         this->m = mat.m;
  356.         a.resize(n);
  357.         for (int i = 0; i < n; i++) {
  358.                 a[i].resize(i + 1);
  359.                 for (int j = 0; j < m; j++)
  360.                         if (j <= i)
  361.                                 a[i][j] = mat.a[i][j];
  362.         }
  363. }
  364.  
  365. //mats
  366. #include "Header.h"
  367.  
  368. kit::kit()
  369. {
  370.         mats = NULL;
  371.         size = 0;
  372. }
  373.  
  374. kit::~kit()
  375. {
  376.         if (mats!=NULL)
  377.                 delete[] mats;
  378.         mats = NULL;
  379.         size = 0;
  380. }
  381.  
  382.  
  383. void kit::Add(matrix *mat)
  384. {
  385.         if (size == 0)
  386.         {
  387.                 mats = new matrix[1];
  388.                 mats[size] = *mat;
  389.         }
  390.         else
  391.         {
  392.                 matrix* temp = new matrix[size+1];
  393.                 for (int i = 0; i < size; i++)
  394.                         temp[i] = mats[i];
  395.                 temp[size] = *mat;
  396.                 delete[] mats;
  397.                 mats = NULL;
  398.                 mats = new matrix[size + 1];
  399.                 for (int i = 0; i < size+1; i++)
  400.                         mats[i] = temp[i];
  401.                 delete[] temp;
  402.         }
  403.         size++;
  404. }
  405.  
  406. void kit::Print()
  407. {
  408.         for (int i = 0; i < size; i++)
  409.         {
  410.                 mats[i].PrintMatrix();
  411.         }
  412. }

Share with your friends:

Print