#include<stdio.h>
#include<stdlib.h>
 
// ********************
 
// Definition einer Klasse fuer Matrizen beliebiger Groesse.
 
class Matrix
{
public:  // Von aussen sichtbar.
 
  // Methoden.
 
  // Konstruktor: Reserviert entsprechend Speicher fuer die Matrixelemente,
  // initialisiert die Attribute (eine m_ x m_ Matrix, alle Eintraege 0.0). 
  Matrix(int m_);
 
  // Konstruktor: Reserviert entsprechend Speicher fuer die Matrixelemente,
  // initialisiert die Attribute (eine m_ x n_ Matrix, alle Eintraege 0.0). 
  Matrix(int m_, int n_);
 
  // Konstruktor: Kopiert eine bestehende Matrix.
  Matrix(const Matrix &A);
 
  // Destruktor: Gibt den fuer die Matrixelemente reservierten Speicher wieder
  // frei.
  ~Matrix();
 
  // Liefert den Wert des (i,j)-ten Matrixelements.
  double Get(int i, int j);
 
  // Liefert den Wert des (i,j)-ten Matrixelements.
  void Set(int i, int j, double a);
 
  // Gibt die Matrix am Bildschirm aus.
  void Print();
 
  int Get_m(void) { return m; }
  int Get_n(void) { return n; }
 
  // *****
 
private:  // Von aussen nicht sichtbar.
 
  // Wandelt Zeilenindex i und Spaltenindex j in den Index des Arrays
  // elements um; eine Hilfsfunktion fuer Get und Set, daher private.
  int Index(int i, int j);
 
  // Attribute.
  int m, n;  // Eine Matrix mit m Zeilen und n Spalten.
  double *elements;  // Die Matrixeintraege.
};
 
// Im Folgenden werden die in
//   class Matrix { ... }
// deklarierten Methoden definiert.
 
Matrix::Matrix(int m_)
{
  int i1;
 
  m = m_;
  n = m_;
 
  if((elements = (double *)malloc(m*n*sizeof(double))) == NULL)
    {
      fprintf(stderr, "Fehler in Matrix::Matrix(...\n");
      exit(0);
    }
 
  for(i1 = 0; i1 < m*n; i1++)
    elements[i1] = 0.0;
}
 
Matrix::Matrix(int m_, int n_)
{
  int i1;
 
  m = m_;
  n = n_;
 
  if((elements = (double *)malloc(m*n*sizeof(double))) == NULL)
    {
      fprintf(stderr, "Fehler in Matrix::Matrix(...\n");
      exit(0);
    }
 
  for(i1 = 0; i1 < m*n; i1++)
    elements[i1] = 0.0;
}
 
Matrix::Matrix(const Matrix &A)
{
  int i1;
 
  m = A.m;
  n = A.n;
 
  if((elements = (double *)malloc(m*n*sizeof(double))) == NULL)
    {
      fprintf(stderr, "Fehler in Matrix::Matrix(...\n");
      exit(0);
    }
 
  for(i1 = 0; i1 < m*n; i1++)
    elements[i1] = A.elements[i1];
}
 
Matrix::~Matrix()
{
  if(elements != NULL)
    free(elements);
}
 
int Matrix::Index(int i, int j)
{
  if(i < 0 || i >= m || j < 0 || j >= n)
    {
      fprintf(stderr, "Fehler in int Matrix::Index(...\n");
      exit(0);
    }
 
 return i*n + j;
}
 
double Matrix::Get(int i, int j)
{
  return elements[Index(i, j)];
}
 
void Matrix::Set(int i, int j, double a)
{
  elements[Index(i, j)] = a;
}
 
void Matrix::Print()
{
  int i1, i2;
 
  for(i1 = 0; i1 < m; i1++)
    {
      printf("| ");
 
      for(i2 = 0; i2 < n; i2++)
        {
          printf("%+.3e ", Get(i1, i2));
        }
 
      printf("|\n");
    }
}
 
// ********************
 
// Reelle Zahl * Matrix, d.h. d * A.
const Matrix operator*(const double &d, Matrix &A)
{
  int i1, i2;
 
  int m = A.Get_m();
  int n = A.Get_n();
 
  Matrix B(m, n);
 
  for(i1 = 0; i1 < m; i1++)
    {
      for(i2 = 0; i2 < n; i2++)
      	B.Set(i1, i2, d * A.Get(i1, i2));
    }
 
  return B;
}
 
// Matrix * Matrix, d.h. A * B.
const Matrix operator*(Matrix &A, Matrix &B)
{
  double d1;
  int i1, i2, i3;
 
  if(A.Get_n() != B.Get_m())
    {
      fprintf(stderr, "Fehler in const Matrix operator*(...\n");
      exit(0);
    }
 
  int mA = A.Get_m();
  int nA = A.Get_n();
  int nB = B.Get_n();
 
  Matrix C(mA, nB);
 
  for(i1 = 0; i1 < mA; i1++)
    {
      for(i2 = 0; i2 < nB; i2++)
	      {
	        d1 = 0.0;
 
      	  for(i3 = 0; i3 < nA; i3++)
	          d1 += A.Get(i1, i3) * B.Get(i3, i2);
 
	        C.Set(i1, i2, d1);
	      }
    }
 
  return C;
}
 
// ********************
 
int main(void)
{
  Matrix A(2);
  A.Set(0, 0, 1.0);
  A.Set(1, 1, 1.0);
  printf("A =\n");
  A.Print();
 
  printf("********************\n");
 
  Matrix B(5.0 * A);  // !!! Jetzt kann man einfach 5.0 * A schreiben. !!!
  printf("B =\n");
  B.Print();
 
  printf("********************\n");
 
  Matrix C(2, 1);
  C.Set(0, 0, 1.5);
  C.Set(1, 0, 0.5);
  printf("C =\n");
  C.Print();
 
  printf("********************\n");
 
  Matrix D(B * C);  // !!! Jetzt kann man einfach B * C schreiben. !!!
  printf("D =\n");
  D.Print();
}

