Advertisement
Guest User

Untitled

a guest
Nov 13th, 2022
99
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 3.78 KB | None | 0 0
  1. #include <iostream>
  2. #include <random>
  3. #include <cfloat>
  4. using namespace std;
  5. const inline size_t M = 1000000;
  6. const inline size_t N = 4;
  7.  
  8. void CopyMatrix(const float* from, float* to) {
  9.   for (size_t i = 0; i < N; i++) {
  10.     for (size_t j = 0; j < N; j++) {
  11.       to[i * N + j] = from[i * N + j];
  12.     }
  13.   }
  14.  
  15. }
  16.  
  17. void SumMatrix(const float *M1, const float *M2, float *result) {
  18.   for (size_t i = 0; i < N; i++) {
  19.     for (size_t j = 0; j < N; j++) {
  20.       result[i * N + j] = M1[i * N + j] + M2[i * N + j];
  21.     }
  22.   }
  23. }
  24.  
  25. void showMatrix(float *matrix, size_t size) {
  26.   size_t i, j;
  27.   for (i = 0; i < size; ++i) {
  28.     for (j = 0; j < size; ++j) {
  29.       cout << matrix[i * size + j] << " ";
  30.     }
  31.     cout << endl;
  32.   }
  33.   cout << "\n\n\n";
  34. }
  35.  
  36. inline float generateRandomInRange(float a, float b) {
  37.   random_device rd;
  38.   uniform_real_distribution gen(a, b);
  39.   return gen(rd);
  40. }
  41.  
  42. float *GenerateMatrixI() {
  43.   auto *I = new float[N * N];
  44.   for (size_t i = 0; i < N; i++) {
  45.     for (size_t j = 0; j < N; j++) {
  46.       if (i == j) I[i * N + j] = 1.0;
  47.       else I[i * N + j] = 0.0;
  48.     }
  49.   }
  50.   return I;
  51. }
  52.  
  53. float *GenerateMatrix() {
  54.   auto *A = new float[N * N];
  55.   for (size_t i = 0; i < N; i++) {
  56.     for (size_t j = 0; j < N; j++) {
  57.       A[i * N + j] = generateRandomInRange(1, 100000);
  58.     }
  59.   }
  60.   return A;
  61. }
  62.  
  63. void TransposeMatrix(float *B, const float *A) {
  64.   for (size_t i = 0; i < N; i++)
  65.     for (size_t j = 0; j < N; j++) {
  66.       B[i * N + j] = A[j * N + i];
  67.     }
  68. }
  69.  
  70. float MaxLineCount(const float *matrix) {
  71.   float maximum = FLT_MIN;
  72.   for (size_t i = 0; i < N; i++) {
  73.     float temp = 0;
  74.  
  75.     for (size_t j = 0; j < N; j++) {
  76.       temp += matrix[i * N + j];
  77.     }
  78.  
  79.     if (temp > maximum) {
  80.       maximum = temp;
  81.     }
  82.   }
  83.   return maximum;
  84. }
  85.  
  86. float *GenerateMatrixB(float *A) {
  87.   auto *B = new float[N * N];
  88.   auto *transposedA = new float[N * N];
  89.   TransposeMatrix(transposedA, A);
  90.   float maxRowCount = MaxLineCount(A);
  91.   float maxColumnCount = MaxLineCount(transposedA);
  92.   float divider = 1 / (maxRowCount * maxColumnCount);
  93.   for (size_t i = 0; i < N; i++) {
  94.     for (size_t j = 0; j < N; j++) {
  95.       B[i * N + j] = transposedA[i * N + j] * divider;
  96.     }
  97.   }
  98.   delete[] transposedA;
  99.   return B;
  100. }
  101.  
  102. float *MultiplyMatrices(const float *M1, const float *M2) {
  103.   auto* M3 = new float[N * N];
  104.   for (size_t i = 0; i < N; ++i) {
  105.     float* c = M3 + i * N;
  106.     for (size_t j = 0; j < N; ++j) c[j] = 0;
  107.     for (size_t k = 0; k < N; ++k) {
  108.       const float* b = M2 + k * N;
  109.       float a = M1[i * N + k];
  110.       for (size_t j = 0; j < N; ++j) c[j] += a * b[j];
  111.     }
  112.   }
  113.   return M3;
  114. }
  115.  
  116. void SubtractMatrix(float *I, const float *multed, const float *R) {
  117.   for (size_t i = 0; i < N; i++)
  118.     for (size_t j = 0; j < N; j++)
  119.       I[i * N + j] = R[i * N + j] - multed[i * N + j];
  120. }
  121.  
  122. float *GenerateMatrixR(const float *A, float *I, const float *B) {
  123.   auto *R = new float[N * N];
  124.   auto *multed = MultiplyMatrices(B, A);
  125.   // R - BA
  126.   SubtractMatrix(I, multed, R);
  127.   delete[] multed;
  128.   return R;
  129. }
  130.  
  131. float *GetInversedMatrix(float *A) {
  132.   float *I = GenerateMatrixI();
  133.   auto *copyI = new float[N*N];
  134.   CopyMatrix(I, copyI);
  135.  
  136.   float *B = GenerateMatrixB(A);
  137.   float *R = GenerateMatrixR(A, copyI, B);
  138.  
  139.  
  140.   float *Rn = R;
  141.   float *t;
  142.  
  143.   SumMatrix(I, Rn, I);
  144.   for (size_t i = 0; i < M; i++) {
  145.     t = MultiplyMatrices(Rn, R);
  146.     if (i != 0) delete[] Rn;
  147.     Rn = t;
  148.     SumMatrix(I, Rn, I);
  149.   }
  150.  
  151.   auto new_I = MultiplyMatrices(I, B);
  152.  
  153.   delete[] I;
  154.   delete[] B;
  155.   delete[] R;
  156.   delete[] t;
  157.   delete [] copyI;
  158.   return new_I;
  159. }
  160.  
  161. int main() {
  162.   float *A = GenerateMatrix();
  163.   float *InversedA = GetInversedMatrix(A);
  164.   showMatrix(InversedA, N);
  165.  
  166.   delete[] A;
  167.   delete[] InversedA;
  168.   return 0;
  169. }
  170.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement