|##########|
|#MAGIC   #|CLABLKJP
|#PROJECT #|"ImportHelp"
|#PATHS   #|"StdProject"
|#FLAGS   #|xx---x--x----xx-----------------
|#USERSW  #|--------------------------------
|#USERMASK#|--------------------------------
|#SWITCHES#|xx---xxxxx------
|##########|
DEFINITION MODULE VectorReal;

(*-----------------------------------------------------------------------------*
 * Dieses Modul stellt zwei neue Typen zur Verfügung:                          *
 *                                                                             *
 * 1. Vektor:                                                                  *
 * Ein Vektor besteht aus drei Komponenten. Man kann ihn als Punkt im drei-    *
 * dimensionalen Raum oder als Pfeil vom Ursprung des Koordinatensystems       *
 * zu einem Punkt auffassen.                                                   *
 *                                                                             *
 * 2. Matrix:                                                                  *
 * Eine Matrix besteht aus drei Vektoren. Diese drei Vektoren können als       *
 * Bilder der Einheitsvektoren entlang der Koordinatenachsen aufgefasst werden.*
 * Damit legt die Matix eine Abbildung des Koordinatensystems in ein anderes   *
 * Koordinatensystem fest. Das Bild eines Punktes (oder Vektors) läßt sich     *
 * durch Multiplikation mit der Matix errechnen.                               *
 *                                                                             *
 * Außerdem enthält es Prozeduren und Funktionen für die grundlegende          *
 * Arbeit mit Vektoren und Matrizen, die einzeln genauer erklärt sind.         *
 *-----------------------------------------------------------------------------*)

FROM Exceptions IMPORT DivisionByZero;

EXCEPTION
  DeterminanteZero : "Determinante is zero";
  AxisZero         : "Axis is zero";

TYPE
  Vector = ARRAY [0..2] OF REAL;

  Matrix = ARRAY [0..2] OF Vector;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Normiert einen Vektor auf Absolutbetrag 1.                  *
 * PARAMETER   :   v  <= Vektor, der normiert werden soll.                     *
 * BEMERKUNGEN :   Ist der Absolutbetrag von v = 0, so entsteht ein            *
 *                 Laufzeitfehler.                                             *
 *---------------------------------------------------------------------------- *)

PROCEDURE VNorm(VAR v IN 10 : Vector);

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Negiert einen Vektor.                                       *
 * PARAMETER   :   v  <= Vektor, der negiert werden soll.                      *
 *                    => negierter Vektor.                                     *
 * BEMERKUNGEN :   Jede Komponente wird mit einem Minus versehen.              *
 *---------------------------------------------------------------------------- *)

PROCEDURE VNeg(v : Vector):Vector;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Berechnet den Absolutbetrag von v.                          *
 * PARAMETER   :   v  <= Vektor, dessen Absolutbetrag berechnetwerden soll.    *
 *                    => reelle Zahl.                                          *
 * BEMERKUNGEN :   Der Absolutbetrag ist immer >=0.                            *
 *---------------------------------------------------------------------------- *)

PROCEDURE VAbs(VAR v IN 10 : Vector):REAL;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Erweitert einen Vektor um einen Faktor.                     *
 * PARAMETER   :   v  <= Vektor, der erweitert werden soll.                    *
 *                 a  <= Faktor, mit dem erweitert werden soll.                *
 *                    => erweiterter Vektor                                    *
 * BEMERKUNGEN :   Jede Komponente wird mit dem Faktor multipliziert.          *
 *---------------------------------------------------------------------------- *)

PROCEDURE VExt(v : Vector;a : REAL):Vector;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Addiert zwei Vektoren.                                      *
 * PARAMETER   :   v1,v2  <= Vektoren, die addiert werden sollen.              *
 *                        => Ergebnis der Addition.                            *
 * BEMERKUNGEN :   Die Vektoren werden Komponentenweise addiert.               *
 *---------------------------------------------------------------------------- *)

PROCEDURE VAdd(REF v : LIST OF Vector):Vector;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Subtrahiert zwei Vektoren.                                  *
 * PARAMETER   :   v1,v2  <= Vektoren, die subtrahiert werden sollen.          *
 *                        => Ergebnis der Subtraktion.                         *
 * BEMERKUNGEN :   Die Vektoren werden Komponentenweise subtrahiert.           *
 *---------------------------------------------------------------------------- *)

PROCEDURE VSub(v1,v2 : Vector):Vector;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Bildet das Skalarprodukt zweier Vektoren.                   *
 * PARAMETER   :   v1,v2  <= Vektoren, die multipliziert werden sollen.        *
 *                        => reelle Zahl (entspricht dem Produkt der           *
 *                                        Absolutberäge der Eingabevektoren    *
 *                                        mal dem cosinus des eingeschlossenen *
 *                                        Winkels).                            *
 * BEMERKUNGEN :   Das Skalarprodukt ist die Summe der einzelnen Produkte      *
 *                 der Komponenten.                                            *
 *                 (Es ist 0, wenn die Eingabevektoren senkrecht stehen.)      *
 *---------------------------------------------------------------------------- *)

PROCEDURE VSMul(VAR v1 IN 10,v2 IN 11 : Vector):REAL;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Bildet das Kreuzprodukt zweier Vektoren.                    *
 * PARAMETER   :   v1,v2  <= Vektoren, die multipliziert werden sollen.        *
 *                        => Kreuzproduktvektor.                               *
 * BEMERKUNGEN :   Der Kreuzproduktvektor ist der Vektor, der senkrecht auf    *
 *                 beiden Eingabevektoren steht und einen Absolutbetrag hat,   *
 *                 der dem Produkt der Absolutbeträge der beiden               *
 *                 Eingabevektoren mal dem sinus des von ihnen                 *
 *                 eingeschlossenen Winkels entspricht.                        *
 *                 ( Er ist 0|0|0, wenn v1 ein Vielfaches von v2 ist.)         *
 *---------------------------------------------------------------------------- *)

PROCEDURE VCMul(v1,v2 : Vector):Vector;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Rotiert einen Vektor um eine vorgegebene Achse.             *
 * PARAMETER   :   v     <=  Vektor, der rotiert werden soll.                  *
 *                 axis  <=  Achse, um die gedreht werden soll.                *
 * BEMERKUNGEN :   Der Winkel wird im Bogenmaß durch den Absolutbetrag         *
 *                 der Achse angegeben.                                        *
 *---------------------------------------------------------------------------- *)

PROCEDURE VRotate(VAR v : Vector;VAR axis : Vector);

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Multipliziert einen Vektor mit einer Matrix.                *
 * PARAMETER   :   v  <= Vektor, der multiplizeirt werden soll.                *
 *                    => Ergebnis der Multiplikation.                          *
 * BEMERKUNGEN :   Keine.                                                      *
 *---------------------------------------------------------------------------- *)

PROCEDURE VMMul(m : Matrix;v : Vector):Vector;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Normiert eine Matrix auf Determinante = 1.                  *
 * PARAMETER   :   m  <= Matrix, die normiert werden soll.                     *
 * BEMERKUNGEN :   Ist die Determinante von m = 0, so entsteht ein             *
 *                 Laufzeitfehler.                                             *
 *---------------------------------------------------------------------------- *)

PROCEDURE MNorm(VAR m IN 10 : Matrix);

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Negiert eine Matrix.                                        *
 * PARAMETER   :   m  <= Matrix, die negiert werden soll.                      *
 *                    => negierte Matrix.                                      *
 * BEMERKUNGEN :   Jede Komponente wird mit einem Minus versehen.              *
 *---------------------------------------------------------------------------- *)

PROCEDURE MNeg(m : Matrix):Matrix;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Berechnet die Determinante einer Matrix.                    *
 * PARAMETER   :   m  <= Matrix, deren Determinante berechnet werden soll.     *
 *                    => reelle Zahl.                                          *
 * BEMERKUNGEN :   Die Determinante ist eine reelle Zahl, die die Volumens-    *
 *                 vergrößerung der Abbildung angibt.                          *
 *---------------------------------------------------------------------------- *)

PROCEDURE Det(VAR m IN 11 : Matrix):REAL;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Erweitert eine Matrix um einen Faktor.                      *
 * PARAMETER   :   m  <= Matrix, die erweitert werden soll.                    *
 *                 a  <= Faktor, um den erweitert werden soll.                 *
 *                    => erweiterte Matrix.                                    *
 * BEMERKUNGEN :   Jede Komponente wird mit dem Faktor multipliziert.          *
 *---------------------------------------------------------------------------- *)

PROCEDURE MExt(m : Matrix;a : REAL):Matrix;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Addiert zwei Matrizen.                                      *
 * PARAMETER   :   m1,m2  <= Matrizen, die addiert werden sollen.              *
 *                        => Ergebnis der Addition.                            *
 * BEMERKUNGEN :   Die Matrizen werden Komponentenweise addiert.               *
 *---------------------------------------------------------------------------- *)

PROCEDURE MAdd(REF m : LIST OF Matrix):Matrix;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Subtrahiert zwei Matrizen.                                  *
 * PARAMETER   :   m1,m2  <= Matrizen, die subtrahiert werden sollen.          *
 *                        => Ergebnis der Subtraktion.                         *
 * BEMERKUNGEN :   Die Matrizen werden Komponentenweise subtrahiert.           *
 *---------------------------------------------------------------------------- *)

PROCEDURE MSub(m1,m2 : Matrix):Matrix;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Multipliziert zwei Matrizen.                                *
 * PARAMETER   :   m1,m2  <= Matrizen, die multipliziert werden sollen.        *
 *                        => Ergebnis der Mulitplikation.                      *
 * BEMERKUNGEN :   Die Matrizen werden so multipliziert, daß für die           *
 *                 Abbildungen gilt: m1 nach m2.                               *
 *---------------------------------------------------------------------------- *)

PROCEDURE MMul(m1,m2 : Matrix):Matrix;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Transponiert eine Matrix.                                   *
 * PARAMETER   :   m  <=  Matrix, die transponiert werden soll.                *
 *                    =>  transponierte Matrix.                                *
 * BEMERKUNGEN :   Transponieren bedeutet: Vertauschen von Zeile und Spalte.   *
 *---------------------------------------------------------------------------- *)

PROCEDURE MTrans(m : Matrix):Matrix;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Bildet die inverse Matrix.                                  *
 * PARAMETER   :   m  <= Matrix, die invertiert werden soll.                   *
 *                    => invertierte Matrix.                                   *
 * BEMERKUNGEN :   Hat m Determinante = 0, kann keine inverse Matrix gebildet  *
 *                 werden und es entsteht ein Laufzeitfehler.                  *
 *---------------------------------------------------------------------------- *)

PROCEDURE MInvert(m : Matrix):Matrix;

(*-----------------------------------------------------------------------------*
 * AUFGABE     :   Berechnet die Abbildungsmatrix bezüglich einer Drehung      *
 *                 um eine beliebige Achse.                                    *
 * PARAMETER   :   m     <=  Matrix, die berechnet werden soll.                *
 *                 axis  <=  Achse, um die gedreht werden soll.                *
 * BEMERKUNGEN :   Ist die Achse der Nullvektor, so entsteht ein               *
 *                 Laufzeitfehler.                                             *
 *---------------------------------------------------------------------------- *)

PROCEDURE CalcRotM(VAR m : Matrix;VAR axis : Vector);


GROUP
  All  = Vector,Matrix,VNorm,VNeg,VAbs,VExt,VAdd,VSub,VSMul,VCMul,VRotate,
         VMMul,MNorm,MNeg,Det,MExt,MAdd,MSub,MMul,MTrans,MInvert,CalcRotM;


END VectorReal.