home *** CD-ROM | disk | FTP | other *** search
/ Global Amiga Experience / globalamigaexperience.iso / compressed / development / clusterdemo.dms / clusterdemo.adf / Modules.lha / modules / txt / VectorLongReal.def < prev    next >
Text File  |  1994-05-25  |  14KB  |  246 lines
  1. |##########|
  2. |#MAGIC   #|CLABLKKG
  3. |#PROJECT #|"ImportHelp"
  4. |#PATHS   #|"StdProject"
  5. |#FLAGS   #|xx---x--x---xxx--x--------------
  6. |#USERSW  #|--------------------------------
  7. |#USERMASK#|--------------------------------
  8. |#SWITCHES#|xx---xxxxx------
  9. |##########|
  10. DEFINITION MODULE VectorLongReal;
  11.  
  12. (*-----------------------------------------------------------------------------*
  13.  * Dieses Modul stellt zwei neue Typen zur Verfügung:                          *
  14.  *                                                                             *
  15.  * 1. Vektor:                                                                  *
  16.  * Ein Vektor besteht aus drei Komponenten. Man kann ihn als Punkt im drei-    *
  17.  * dimensionalen Raum oder als Pfeil vom Ursprung des Koordinatensystems       *
  18.  * zu einem Punkt auffassen.                                                   *
  19.  *                                                                             *
  20.  * 2. Matrix:                                                                  *
  21.  * Eine Matrix besteht aus drei Vektoren. Diese drei Vektoren können als       *
  22.  * Bilder der Einheitsvektoren entlang der Koordinatenachsen aufgefasst werden.*
  23.  * Damit legt die Matix eine Abbildung des Koordinatensystems in ein anderes   *
  24.  * Koordinatensystem fest. Das Bild eines Punktes (oder Vektors) läßt sich     *
  25.  * durch Multiplikation mit der Matix errechnen.                               *
  26.  *                                                                             *
  27.  * Außerdem enthält es Prozeduren und Funktionen für die grundlegende          *
  28.  * Arbeit mit Vektoren und Matrizen, die einzeln genauer erklärt sind.         *
  29.  *-----------------------------------------------------------------------------*)
  30.  
  31. FROM Exceptions IMPORT DivisionByZero;
  32.  
  33. EXCEPTION
  34.   DeterminanteZero : "Determinante is zero";
  35.   AxisZero         : "Axis is zero";
  36.  
  37.  
  38. TYPE
  39.   Vector = ARRAY [0..2] OF LONGREAL;
  40.  
  41.   Matrix = ARRAY [0..2] OF Vector;
  42.  
  43. (*-----------------------------------------------------------------------------*
  44.  * AUFGABE     :   Normiert einen Vektor auf Absolutbetrag 1.                  *
  45.  * PARAMETER   :   v  <= Vektor, der normiert werden soll.                     *
  46.  * BEMERKUNGEN :   Ist der Absolutbetrag von v = 0, so entsteht ein            *
  47.  *                 Laufzeitfehler.                                             *
  48.  *---------------------------------------------------------------------------- *)
  49.  
  50. PROCEDURE VNorm(VAR v IN 10 : Vector);
  51.  
  52. (*-----------------------------------------------------------------------------*
  53.  * AUFGABE     :   Negiert einen Vektor.                                       *
  54.  * PARAMETER   :   v  <= Vektor, der negiert werden soll.                      *
  55.  *                    => negierter Vektor.                                     *
  56.  * BEMERKUNGEN :   Jede Komponente wird mit einem Minus versehen.              *
  57.  *---------------------------------------------------------------------------- *)
  58.  
  59. PROCEDURE VNeg(v : Vector):Vector;
  60.  
  61. (*-----------------------------------------------------------------------------*
  62.  * AUFGABE     :   Berechnet den Absolutbetrag von v.                          *
  63.  * PARAMETER   :   v  <= Vektor, dessen Absolutbetrag berechnetwerden soll.    *
  64.  *                    => reelle Zahl.                                          *
  65.  * BEMERKUNGEN :   Der Absolutbetrag ist immer >=0.                            *
  66.  *---------------------------------------------------------------------------- *)
  67.  
  68. PROCEDURE VAbs(VAR v IN 10 : Vector):LONGREAL;
  69.  
  70. (*-----------------------------------------------------------------------------*
  71.  * AUFGABE     :   Erweitert einen Vektor um einen Faktor.                     *
  72.  * PARAMETER   :   v  <= Vektor, der erweitert werden soll.                    *
  73.  *                 a  <= Faktor, mit dem erweitert werden soll.                *
  74.  *                    => erweiterter Vektor                                    *
  75.  * BEMERKUNGEN :   Jede Komponente wird mit dem Faktor multipliziert.          *
  76.  *---------------------------------------------------------------------------- *)
  77.  
  78. PROCEDURE VExt(v : Vector;a : LONGREAL):Vector;
  79.  
  80. (*-----------------------------------------------------------------------------*
  81.  * AUFGABE     :   Addiert zwei Vektoren.                                      *
  82.  * PARAMETER   :   v1,v2  <= Vektoren, die addiert werden sollen.              *
  83.  *                        => Ergebnis der Addition.                            *
  84.  * BEMERKUNGEN :   Die Vektoren werden Komponentenweise addiert.               *
  85.  *---------------------------------------------------------------------------- *)
  86.  
  87. PROCEDURE VAdd(REF v : LIST OF Vector):Vector;
  88.  
  89. (*-----------------------------------------------------------------------------*
  90.  * AUFGABE     :   Subtrahiert zwei Vektoren.                                  *
  91.  * PARAMETER   :   v1,v2  <= Vektoren, die subtrahiert werden sollen.          *
  92.  *                        => Ergebnis der Subtraktion.                         *
  93.  * BEMERKUNGEN :   Die Vektoren werden Komponentenweise subtrahiert.           *
  94.  *---------------------------------------------------------------------------- *)
  95.  
  96. PROCEDURE VSub(v1,v2 : Vector):Vector;
  97.  
  98. (*-----------------------------------------------------------------------------*
  99.  * AUFGABE     :   Bildet das Skalarprodukt zweier Vektoren.                   *
  100.  * PARAMETER   :   v1,v2  <= Vektoren, die multipliziert werden sollen.        *
  101.  *                        => reelle Zahl (entspricht dem Produkt der           *
  102.  *                                        Absolutberäge der Eingabevektoren    *
  103.  *                                        mal dem cosinus des eingeschlossenen *
  104.  *                                        Winkels).                            *
  105.  * BEMERKUNGEN :   Das Skalarprodukt ist die Summe der einzelnen Produkte      *
  106.  *                 der Komponenten.                                            *
  107.  *                 (Es ist 0, wenn die Eingabevektoren senkrecht stehen.)      *
  108.  *---------------------------------------------------------------------------- *)
  109.  
  110. PROCEDURE VSMul(VAR v1 IN 10,v2 IN 11 : Vector):LONGREAL;
  111.  
  112. (*-----------------------------------------------------------------------------*
  113.  * AUFGABE     :   Bildet das Kreuzprodukt zweier Vektoren.                    *
  114.  * PARAMETER   :   v1,v2  <= Vektoren, die multipliziert werden sollen.        *
  115.  *                        => Kreuzproduktvektor.                               *
  116.  * BEMERKUNGEN :   Der Kreuzproduktvektor ist der Vektor, der senkrecht auf    *
  117.  *                 beiden Eingabevektoren steht und einen Absolutbetrag hat,   *
  118.  *                 der dem Produkt der Absolutbeträge der beiden               *
  119.  *                 Eingabevektoren mal dem sinus des von ihnen                 *
  120.  *                 eingeschlossenen Winkels entspricht.                        *
  121.  *                 ( Er ist 0|0|0, wenn v1 ein Vielfaches von v2 ist.)         *
  122.  *---------------------------------------------------------------------------- *)
  123.  
  124. PROCEDURE VCMul(v1,v2 : Vector):Vector;
  125.  
  126. (*-----------------------------------------------------------------------------*
  127.  * AUFGABE     :   Rotiert einen Vektor um eine vorgegebene Achse.             *
  128.  * PARAMETER   :   v     <=  Vektor, der rotiert werden soll.                  *
  129.  *                 axis  <=  Achse, um die gedreht werden soll.                *
  130.  * BEMERKUNGEN :   Der Winkel wird im Bogenmaß durch den Absolutbetrag         *
  131.  *                 der Achse angegeben.                                        *
  132.  *---------------------------------------------------------------------------- *)
  133.  
  134. PROCEDURE VRotate(VAR v : Vector;VAR axis : Vector);
  135.  
  136. (*-----------------------------------------------------------------------------*
  137.  * AUFGABE     :   Multipliziert einen Vektor mit einer Matrix.                *
  138.  * PARAMETER   :   v  <= Vektor, der multiplizeirt werden soll.                *
  139.  *                    => Ergebnis der Multiplikation.                          *
  140.  * BEMERKUNGEN :   Keine.                                                      *
  141.  *---------------------------------------------------------------------------- *)
  142.  
  143. PROCEDURE VMMul(m : Matrix;v : Vector):Vector;
  144.  
  145. (*-----------------------------------------------------------------------------*
  146.  * AUFGABE     :   Normiert eine Matrix auf Determinante = 1.                  *
  147.  * PARAMETER   :   m  <= Matrix, die normiert werden soll.                     *
  148.  * BEMERKUNGEN :   Ist die Determinante von m = 0, so entsteht ein             *
  149.  *                 Laufzeitfehler.                                             *
  150.  *---------------------------------------------------------------------------- *)
  151.  
  152. PROCEDURE MNorm(VAR m IN 10 : Matrix);
  153.  
  154. (*-----------------------------------------------------------------------------*
  155.  * AUFGABE     :   Negiert eine Matrix.                                        *
  156.  * PARAMETER   :   m  <= Matrix, die negiert werden soll.                      *
  157.  *                    => negierte Matrix.                                      *
  158.  * BEMERKUNGEN :   Jede Komponente wird mit einem Minus versehen.              *
  159.  *---------------------------------------------------------------------------- *)
  160.  
  161. PROCEDURE MNeg(m : Matrix):Matrix;
  162.  
  163. (*-----------------------------------------------------------------------------*
  164.  * AUFGABE     :   Berechnet die Determinante einer Matrix.                    *
  165.  * PARAMETER   :   m  <= Matrix, deren Determinante berechnet werden soll.     *
  166.  *                    => reelle Zahl.                                          *
  167.  * BEMERKUNGEN :   Die Determinante ist eine reelle Zahl, die die Volumens-    *
  168.  *                 vergrößerung der Abbildung angibt.                          *
  169.  *---------------------------------------------------------------------------- *)
  170.  
  171. PROCEDURE Det(VAR m IN 11 : Matrix):LONGREAL;
  172.  
  173. (*-----------------------------------------------------------------------------*
  174.  * AUFGABE     :   Erweitert eine Matrix um einen Faktor.                      *
  175.  * PARAMETER   :   m  <= Matrix, die erweitert werden soll.                    *
  176.  *                 a  <= Faktor, um den erweitert werden soll.                 *
  177.  *                    => erweiterte Matrix.                                    *
  178.  * BEMERKUNGEN :   Jede Komponente wird mit dem Faktor multipliziert.          *
  179.  *---------------------------------------------------------------------------- *)
  180.  
  181. PROCEDURE MExt(m : Matrix;a : LONGREAL):Matrix;
  182.  
  183. (*-----------------------------------------------------------------------------*
  184.  * AUFGABE     :   Addiert zwei Matrizen.                                      *
  185.  * PARAMETER   :   m1,m2  <= Matrizen, die addiert werden sollen.              *
  186.  *                        => Ergebnis der Addition.                            *
  187.  * BEMERKUNGEN :   Die Matrizen werden Komponentenweise addiert.               *
  188.  *---------------------------------------------------------------------------- *)
  189.  
  190. PROCEDURE MAdd(REF m : LIST OF Matrix):Matrix;
  191.  
  192. (*-----------------------------------------------------------------------------*
  193.  * AUFGABE     :   Subtrahiert zwei Matrizen.                                  *
  194.  * PARAMETER   :   m1,m2  <= Matrizen, die subtrahiert werden sollen.          *
  195.  *                        => Ergebnis der Subtraktion.                         *
  196.  * BEMERKUNGEN :   Die Matrizen werden Komponentenweise subtrahiert.           *
  197.  *---------------------------------------------------------------------------- *)
  198.  
  199. PROCEDURE MSub(m1,m2 : Matrix):Matrix;
  200.  
  201. (*-----------------------------------------------------------------------------*
  202.  * AUFGABE     :   Multipliziert zwei Matrizen.                                *
  203.  * PARAMETER   :   m1,m2  <= Matrizen, die multipliziert werden sollen.        *
  204.  *                        => Ergebnis der Mulitplikation.                      *
  205.  * BEMERKUNGEN :   Die Matrizen werden so multipliziert, daß für die           *
  206.  *                 Abbildungen gilt: m1 nach m2.                               *
  207.  *---------------------------------------------------------------------------- *)
  208.  
  209. PROCEDURE MMul(m1,m2 : Matrix):Matrix;
  210.  
  211. (*-----------------------------------------------------------------------------*
  212.  * AUFGABE     :   Transponiert eine Matrix.                                   *
  213.  * PARAMETER   :   m  <=  Matrix, die transponiert werden soll.                *
  214.  *                    =>  transponierte Matrix.                                *
  215.  * BEMERKUNGEN :   Transponieren bedeutet: Vertauschen von Zeile und Spalte.   *
  216.  *---------------------------------------------------------------------------- *)
  217.  
  218. PROCEDURE MTrans(m : Matrix):Matrix;
  219.  
  220. (*-----------------------------------------------------------------------------*
  221.  * AUFGABE     :   Bildet die inverse Matrix.                                  *
  222.  * PARAMETER   :   m  <= Matrix, die invertiert werden soll.                   *
  223.  *                    => invertierte Matrix.                                   *
  224.  * BEMERKUNGEN :   Hat m Determinante = 0, kann keine inverse Matrix gebildet  *
  225.  *                 werden und es entsteht ein Laufzeitfehler.                  *
  226.  *---------------------------------------------------------------------------- *)
  227.  
  228. PROCEDURE MInvert(m : Matrix):Matrix;
  229.  
  230. (*-----------------------------------------------------------------------------*
  231.  * AUFGABE     :   Berechnet die Abbildungsmatrix bezüglich einer Drehung      *
  232.  *                 um eine beliebige Achse.                                    *
  233.  * PARAMETER   :   m     <=  Matrix, die berechnet werden soll.                *
  234.  *                 axis  <=  Achse, um die gedreht werden soll.                *
  235.  * BEMERKUNGEN :   Ist die Achse der Nullvektor, so entsteht ein               *
  236.  *                 Laufzeitfehler.                                             *
  237.  *---------------------------------------------------------------------------- *)
  238.  
  239. PROCEDURE CalcRotM(VAR m : Matrix;VAR axis : Vector);
  240.  
  241. GROUP
  242.   All  = Vector,Matrix,VNorm,VNeg,VAbs,VExt,VAdd,VSub,VSMul,VCMul,VRotate,
  243.          VMMul,MNorm,MNeg,Det,MExt,MAdd,MSub,MMul,MTrans,MInvert,CalcRotM;
  244.  
  245. END VectorLongReal.
  246.