//------------------------------//
//           MATRIX.H           //
//         Beloshenko(c)        //
//------------------------------//
// Beloshenko programers group

bool correct_add; // +
bool correct_sub; // -
bool correct_mul; // *

void init_flag()
{
     correct_add = true;
     correct_sub = true;
     correct_mul = true;
};

class Matrix
{
public:
      float M[100][100];
      int m,n;

      //Operators
      Matrix operator+ (const Matrix x) const;
      Matrix operator- (const Matrix x) const;
      Matrix operator* (const Matrix x) const;
};

Matrix
Matrix::operator+ (const Matrix x) const
{
       Matrix Result;
       int i,j;       

       //Correct?
       if((m==x.m)&&(n==x.n))
       {
          //Calculation
          for(i = 1; i <= m; i++)
          {
             for(j = 1; j <= n; j++)
             {
                 Result.M[i][j] = M[i][j] + x.M[i][j];
             };
          };
          Result.m = m;
          Result.n = n;
          correct_add = true;
       } else
       {
          correct_add = false;
       };
       
       return Result;
}

Matrix
Matrix::operator- (const Matrix x) const
{
       Matrix Result;
       int i,j;

       //Correct?
       if((m==x.m)&&(n==x.n))
       {
          //Calculation
          for(i = 1; i <= m; i++)
          {
             for(j = 1; j <= n; j++)
             {
                 Result.M[i][j] = M[i][j] - x.M[i][j];
             };
          };
          Result.m = m;
          Result.n = n;
          correct_sub = true;        
       } else 
       {
          correct_sub = false;
       };

       return Result;
}

Matrix
Matrix::operator* (const Matrix x) const
{
       Matrix Result;
       int i,j,k;
       //Correct?
       if(n==x.m)
       {
          //Calculation
          for(i = 1; i <= m; i++)
          {
              for(j = 1; j <= x.n; j++)
              {
                  Result.M[i][j] = 0;
                  for(k = 1; k <= n; k++)
                  {
                      Result.M[i][j] = Result.M[i][j] + M[i][k]*x.M[k][j];
                  };
              };
          };
	  Result.m = m;
	  Result.n = x.n;
          correct_mul = true;
       } else
       {
          correct_mul = false;
       };

       return Result;
}
   

//------------------------------//
//           MAIN.CPP           //
//         Beloshenko(c)        //
//------------------------------//
//Beloshenko programers group
//1). Beloshenko Nikita
//2). Ivanov Evgeniy

#include 
#include "matrix.h"

Matrix A;
Matrix B;
Matrix C;

void Out_C()
{
     int i,j;    
     // ==== Print matrix part ====
     // Print C.m
     printf("C.m %d \n",C.m);
     // Print C.n
     printf("C.n %d \n",C.n);
     for(i = 1; i <= C.m; i++)
     {
        for(j = 1; j <= C.n; j++)
        {
            // Print C.M[i][j]
            printf("C.M[%d][%d]: %f \n",i,j,C.M[i][j]);           
        };
     };
};

int main()
{
    int i,j;
    int error = 0;
    int d;
    float f;
    // ==== Input matrix part ====

    // Input matrix A
    // Input A.n
    printf("A.n? \n");
    scanf("%d",&d); A.n = d;      
    // Input A.m
    printf("A.m? \n");
    scanf("%d",&d); A.m = d;
    for(i = 1; i <= A.n; i++)
    {
       for(j = 1; j <= A.m; j++)
       {
          // Input A.M[i][j]
          printf("A.M[%d][%d]? \n",i,j);
          scanf("%f",&f); A.M[i][j] = f;
       };
    };

    // Input matrix B
    // Input B.n
    printf("B.n? \n");
    scanf("%d",&d); B.n = d;
    // Input B.m
    printf("B.m? \n");
    scanf("%d",&d); B.m = d;
    for(i = 1; i <= B.n; i++)
    {
       for(j = 1; j <= B.m; j++)
       {
          // Input B.M[i][j]
          printf("B.M[%d][%d]? \n",i,j);
          scanf("%f",&f); B.M[i][j] = f;
       };
    };

    // ==== Math CPU ====

    // C = A + B part 
    init_flag();
    C=A+B; 
    if(correct_add)
    {
       error = 0;    // ok result
       Out_C();      // print matrix C
    } else
    {
       error = 1;         // add error
       printf("error 1"); // Print error
    };
    // C = A - B part 
    init_flag();
    C=A-B;
    if(correct_sub)
    {
       error = 0;    // ok result
       Out_C();      // print matrix C
    } else
    {
       error = 2;         // sub error
       printf("error 2"); // Print error
    }; 
    // C = A * B part 
    init_flag();
    C=A*B;
    if(correct_mul)
    {
       error = 0;    // ok result
       Out_C();      // print matrix C 
    } else
    {
       error = 3;         // mul error
       printf("error 3"); // Print error
    };

    return 0;
}