Implementierungsdatei der Matrix-Klasse


  // Definition der Klasse "matrix"

  #include <iostream.h>  // Einbinden der Standard-I/O-Routinen
  #include <fstream.h>   // Einbinden der Datei-I/O-Routinen
  #include <iomanip.h>   // Einbinden der headerdatei für Manipulatoren mit Parametern.

  #include "matrix.h"    // Einbinden der Definition der Matrix-Klasse
  #include "vektor.h"    // Einbinden der Definition der Vektor-Klasse

  // +-----------------------------------------+
  // | Konstruktor (inkl. Default-Konstruktor) |
  // +-----------------------------------------+

  matrix::matrix(vektor v1, vektor v2, vektor v3)
  {
    elem[0] = v1;    // Spalte 1 der Matrix ^= Vektor v1
    elem[1] = v2;    // Spalte 2 der Matrix ^= Vektor v2
    elem[2] = v3;    // Spalte 3 der Matrix ^= Vektor v3
  };

  // +-------------------+
  // | Copy-Konstruktor: |
  // +-------------------+

  matrix::matrix(matrix& M)
  {
    for (int i = 0; i < 3; i++)
      elem[i] = M.elem[i];       // Übernahme der Elemente der Matrix M
  };

  // +-------------+
  // | Destruktor: |
  // +-------------+


  matrix::~matrix()
  {
  };

  // +----------------------------------------------------------------------+
  // | Funktion zum Überprüfen, ob x,y Indizes des zulässigen Bereichs sind |
  // +----------------------------------------------------------------------+

  int matrix::zulaessig(int x, int y)
  {
    if ( (0<=x) && (x<3) && (0<=y) && (y<3) )
      return 1;
    else return 0;
  };

  // +-------------------------------------------------------+
  // | Funktion zum Setzen eines bestimmten Matrix-Elementes |
  // +-------------------------------------------------------+

  void matrix::setze(int x,int y, double d)
  {
    // beachte: x - Zeilenindex; y - Spaltenindex
    if ( zulaessig(x,y) == 1)
      elem[y].elem[x] = d;
    else
      cout << "Setzen nicht moeglich (ausserhalb des Bereiches) !" << endl;
  };

  // +---------------------------------------------------------+
  // | Funktion zum Auslesen eines bestimmten Matrix-Elementes |
  // +---------------------------------------------------------+

  double matrix::liefer(int x, int y)
  {
    if (zulaessig(x,y) == 1)
      return elem[x].elem[y];
    else
    {
      cout << "Lesen nicht moeglich (ausserhalb des Bereiches) !" << endl;
      return 0;
    };
  };

  // +---------------------------------------------+
  // | Funktion zum Setzen einer Matrix "von Hand" |
  // +---------------------------------------------+

  void matrix::eingabe()
  {
    double D;
    int x = 0;
    int y = 0;

    while ( x < 3)
    {
      cout << "Bitte Komponente (" << x+1 << "," << y+1 << ") eingeben: ";
      cin >> D;
      setze(x,y,D);  // Setzen des Matrixelements mit dem eingegebenen Wert
      y++;
      if (y == 3)
      {
        y = 0;       // erste Spalte wählen
        x++;         // nächste Zeile wählen
      }
    }
  }

  // +--------------------------------------------------+
  // | Funktion zum Fllen einer Matrix aus einer Datei |
  // +--------------------------------------------------+

  void matrix::eingabe(fstream& datei)
  {
    double D;
    int x = 0;
    int y = 0;

    datei.seekg(0, ios::beg);  // am Dateianfang positionieren
    while ( datei >> D)
    {
      setze(x,y,D);
      y++;
      if (y==3)
      {
        y = 0;       // erste Spalte wählen
        x++;         // nächste Zeile wählen
      }
    }
  }

  // +------------------------------------------------+
  // | Funktion zur formatierten Ausgabe einer Matrix |
  // +------------------------------------------------+

  void matrix::ausgabe()
  {
    // Festlegung der Ausgabenotation:
    cout.setf(ios::scientific, ios::floatfield);   // scientific-Notation
    cout.setf(ios::adjustfield, ios::right);       // rechtsbndig
    cout.setf(ios::showpoint);                     // Dezimalpunkt und abschlie˜ende Nullen ausgeben
    cout.precision(2);                             // Genauigkeit der Gleitkommawerte = 2

    cout << "Matrix: " << endl;
    for (int i = 0; i < 3; i++)                    // zeilenweises Ausgeben der Matrix
    {
      cout << " ( " << setw(9) << elem[0].elem[i] << " " << setw(9) <<
           elem[1].elem[i] << " " << setw(9) << elem[2].elem[i] << " )" << endl;
    };
  };

  /*
  --------------------------------------------------------------------------
    Überladen der OPERATOREN:
  --------------------------------------------------------------------------
  */

  // +--------------+
  // | Un„res Minus |
  // +--------------+

  matrix& matrix::operator-()
  {
    return (*this * (-1));
  };

  // +------------------------------------------------------------------+
  // | Multiplikationsoperator ( Matrix * Matrix )                      |
  // |                                                                  |
  // |  Implementierung der Matrizen-Multiplikation unter Verwendung    |
  // |  der Matrix-Vektor-Multiplikation                                |
  // +------------------------------------------------------------------+

  matrix matrix::operator*(const matrix& M)
  {
    matrix H;

    for (int i = 0; i < 3; i++)
      H.elem[i] = *this * M.elem[i];

    return H;
  };

  // +---------------------------------------------+
  // | Multiplikationsoperator ( Matrix * Skalar ) |
  // +---------------------------------------------+

  matrix matrix::operator*(const double d)
  {
    matrix H(*this);                // Aufruf des Copy-Konstruktors mit dem this-Zeiger

    for (int i = 0; i < 3; i++)     // Schleife ber die Spalten
      for (int j = 0; j < 3; j++)   // Schleife ber die Zeilen
        H.elem[i].elem[j] *= d;

    return H;
  };

  // +---------------------------------------------+
  // | Multiplikationsoperator ( Matrix * Vektor ) |
  // +---------------------------------------------+

  vektor matrix::operator*(const vektor& v)
  {
    vektor h;

    for (int i = 0; i < 3; i++)
    {
      h.elem[i] = 0;
      for (int j = 0; j < 3; j++)
        h.elem[i] += elem[j].elem[i] * v.elem[j];
    }

    return h;
  };

  // +---------------------------------------------------------+
  // | Multiplikations-/Zuweisungsoperator ( Matrix * Matrix ) |
  // +---------------------------------------------------------+

  matrix& matrix::operator*=(const matrix& M)
  {
    // Aufruf des Multiplikationsoperators für Matrizen und
    // unmittelbare Rückgabe des Ergebnisses
    return (*this * M);
  };

  // +---------------------------------------------------------+
  // | Multiplikations-/Zuweisungsoperator ( Matrix * Skalar ) |
  // +---------------------------------------------------------+

  matrix& matrix::operator*=(const double d)
  {
    return (*this * d);
  };

  // +---------------------------------------+
  // | Additionsoperator ( Matrix + Matrix ) |
  // +---------------------------------------+

  matrix matrix::operator+(const matrix& M)
  {
    matrix H;

    for (int i = 0; i < 3; i++)
      H.elem[i] = elem[i] + M.elem[i];   // Addieren der Spaltenvektoren

    return H;
  };

  // +---------------------------------------------------+
  // | Additions-/Zuweisungsoperator ( Matrix + Matrix ) |
  // +---------------------------------------------------+

  matrix& matrix::operator+=(const matrix& M)
  {
    for (int i = 0; i < 3; i++)
      elem[i] += M.elem[i];              // Addieren der Spaltenvektoren

    return *this;
  };

  // +------------------------------------------+
  // | Subtraktionsoperator ( Matrix - Matrix ) |
  // +------------------------------------------+

  matrix matrix::operator-(const matrix& M)
  {
    matrix H;
    for (int i = 0; i < 3; i++)
      H.elem[i] = elem[i] - M.elem[i];   // Subtrahieren der Spaltenvektoren

    return H;
  };

  // +------------------------------------------------------+
  // | Subtraktions-/Zuweisungsoperator ( Matrix - Matrix ) |
  // +------------------------------------------------------+

  matrix& matrix::operator-=(const matrix& M)
  {
    for (int i = 0; i < 3; i++)
      elem[i] -= M.elem[i];              // Subtrahieren der Spaltenvektoren

  return *this;
  };

  /*
    FRIEND-Funktionen
  */

  // +---------------------------------------------+
  // | Multiplikationsoperator ( Skalar + Matrix ) |
  // +---------------------------------------------+

  matrix operator*(double d, const matrix& M)
  {
    matrix H;

    for (int i = 0; i < 3; i++)
      for (int j = 0; j < 3; j++)
        H.elem[i].setze(j, M.elem[i].liefer(j) * d);

    return H;
  };