Ada Tour - Dokumentation

vor

11.7.1.1 Generic_Complex_Types

Dieses Paket enthält eine Typdeklaration der komplexen Zahlen samt einer Vielzahl von Operatoren, um komplexe Zahlen zu addieren oder zu subtrahieren, wie auch Operatoren, um Gleitpunktzahlen mit komplexen Zahlen zu verknüpfen.

Das generische Kindpaket "Ada.Numerics.Generic_Complex_Elementary_Functions" wird wie folgt deklariert:

with Ada.Numerics.Generic_Complex_Types;
generic
   with package Complex_Types is new Ada.Numerics.Generic_Complex_Types (<>);
   use Complex_Types;
package Ada.Numerics.Generic_Complex_Elementary_Functions is

   pragma Pure(Generic_Complex_Elementary_Functions);

   function Sqrt (X : Complex) return Complex;
   function Log (X : Complex) return Complex;
   function Exp (X : Complex) return Complex;
   function Exp (X : Imaginary) return Complex;

   function "**" (Left : Complex; Right : Complex) return Complex;
   function "**" (Left : Complex; Right : Real'Base) return Complex;
   function "**" (Left : Real'Base; Right : Complex) return Complex;

   function Sin (X : Complex) return Complex;
   function Cos (X : Complex) return Complex;
   function Tan (X : Complex) return Complex;
   function Cot (X : Complex) return Complex;

   function Arcsin (X : Complex) return Complex;
   function Arccos (X : Complex) return Complex;
   function Arctan (X : Complex) return Complex;
   function Arccot (X : Complex) return Complex;

   function Sinh (X : Complex) return Complex;
   function Cosh (X : Complex) return Complex;
   function Tanh (X : Complex) return Complex;
   function Coth (X : Complex) return Complex;

   function Arcsinh (X : Complex) return Complex;
   function Arccosh (X : Complex) return Complex;
   function Arctanh (X : Complex) return Complex;
   function Arccoth (X : Complex) return Complex;

end Ada.Numerics.Generic_Complex_Elementary_Functions;

Diese Paket akzeptiert als generischen Parameter eine Instantiierung des generischen Pakets "Complex_Types".

Beispiel:

type real_type is new float;
package complex_types is new ada.numerics.generic_complex_types( real_type );
package complex_functions is new ada.numerics.generic_complex_elementary_functions( complex_types );

Neben diesem generischen Paket können zusätzlich analoge, nicht generische Bibliothekspakete mit elementaren Funktionen zu komplexen Zahlen zu vordefinierten Zahlentypen, wie "Float", "Short_Float" oder "Long_Float", angeboten werden, die an Stelle des Basistyps "Real’Base" im generischen Paket mit den jeweiligen vordefinierten Typen operieren.

Definition der komplexen Zahlen mittels des Typs "Short_Float"

Anmerkung:
Das folgende generische Paket ist mit dem Pragma "Pure" ausgestattet, um anzuzeigen, daß keine Objekte bzw. Zeiger bei der Instantiierung angelegt werden. Diese Eigenschaft wird für verteilte Programme bzw. bei Programmen mit mehr als einem Prozeß wichtig.

with Ada.Numerics.Generic_Complex_Types;
package Ada.Numerics.Short_Complex_Types is new Ada.Numerics.Generic_Complex_Types (Short_Float);
pragma Pure (Short_Complex_Types);

Das Refenzhandbuch schreibt dem Übersetzerhersteller nicht vor, ob die nicht generischen Bibliothekspakete der komplexen Zahlen, wenn sie denn angeboten werden, als Instantiierungen des generischen Pakets vorzuliegen haben oder nicht.

Der Typ "Complex" ist so deklariert, daß auf die Komponenten direkt ohne Verwendung von Unterprogrammen aus dem Paket zugegriffen werden kann. Von dieser Möglichkeit sollte aber kein Gebrauch gemacht werden. Es sollten immer die zugehörigen Komponentenfunktionen und -prozeduren verwendet werden.

Beispiel:

   -- ...
   type a_Float is new float;
   package Complex_types is new ada.numerics.generic_complex_types( a_Float );
   w : Complex_Types.Complex;
   x, y : a_Float;
begin
   x := w.re; -- Möglich aber nicht zu empfehlen
   y := w.im; --- ebenso
   x := Complex_Types.Re( w ); -- Die empfohlene Form
   y := Complex_Types.Im( w ); -- ebenso

   w.re := x; --- Möglich aber nicht zu empfehlen
   w.im := y; --- ebenso
   Complex_Types.Set_Re( x => w, re => x ); -- Die empfohlene Form
   Complex_Types.Set_Im( x => w, im => x ); -- ebenso

Der Typ "Imaginary" ist dagegen als privater Typ deklariert, so daß der Zugriff nur über Unterprogramme erfolgen kann, die vom Paket bereitgestellt werden.

Die Operatoren "+", "-", "*", "/" sind für jede Kombination der Typen "Real’Base", "Complex" und "Imaginary" definiert, um komplexe Zahlen mit rein imaginären oder Gleitpunktzahlen zu verknüpfen.
Für den Typ "Imaginary" sind Vergleichsoperatoren definiert. Für komplexe Zahlen machen diese keinen Sinn, da z. B. eine komplexe Zahl auch als zweidimensionaler Vektor interpretiert werden kann und bei Vektoren nur Vergleiche bezüglich der Länge auf kleiner und größer aber nicht bezüglich der Richtung sinnvoll sind.

-- P = Pi oder noch besser den grieschischen Buchstaben pi

Neben der Interpretation der komplexen Zahlen als Vektoren ist auch noch die mittels Polarkoordinaten üblich. Bei Polarkoordinaten sind die zwei unabhängigen Größen der Winkel und der Radius. Der Winkel wird durch zwei Halbstrahlen eingeschlossen, die vom Ursprung des Koordinatensystems ausgehen, wobei der eine der beiden Halbstrahlen die positive reelle Achse ist. Der Schnittpunkt eines Kreises mit dem vorgegebenen Radius um den Ursprung mit dem anderen
der beiden Halbstrahlen definiert dann die komplexe Zahl in Polarkoordinaten. Winkel werden, wie mathematisch üblich, in Radianten angegeben, d. h. in Vielfachen der Zahl p; z. B. hat der rechte Winkel die Größe p/2 und der Vollkreis die Größe 2*p. Der Radius ist gleich der Länge des zugehörigen Vektors. Ist der Winkel größer als 2*p, so heißt das geometrisch, daß der Ursprung entsprechend häufig umrundet wird. Der Ort der komplexen Zahl ist allerdings derselbe, ob der Ursprung nicht oder mehrfach umrundet wird, d. h. der Winkel wird modulo 2*p betrachtet.

Die beiden zugehörigen Funktionen für die Umrechnung aus Polarkoordinaten in komplexe Zahlen heißen "Compose_From_Polar" mit und ohne Angabe der Kreiszahl (englisch Cycle), die aus einer Angabe mittels Radius (englisch Modulus) und Winkel (englisch Argument) eine komplexe Zahl formen. Die erste der beiden Funktionen berechnet die komplexe Zahl unter der Annahme, daß der Vollwinkel eines Kreises 2*p ist, die zweite Funktion erlaubt über einen dritten Parameter die
Variation dieser Annahme. Die Umkehrfunktionen heißen "Modulus", die den Radius (also die Länge des Vektors) berechnet, und "Argument", die den Winkel bestimmt. Die letzte gibt es in zwei Ausprägungen, einmal unter der Annahme, daß der Vollwinkel eines Kreises 2*p ist, und die andere mit einem zweiten Parameter namens "Cycle", mittels dessen diese Annahme variiert werden kann.
Der Bereich der Funktion "Argument" ist -p bis +p.

Das Kindpaket "Generic_Complex_Types" definiert keine eigenen Ausnahmen. Es wird die Ausnahme "Argument_Error" aus dem Vaterpaket "Ada.Numerics" verwendet, wenn der Wert des Parameters "Cycle" der Funktionen "Argument" oder "Compose_From_Polar" null oder negativ ist.
Die Standardausnahme "Constraint_Error" wird ausgelöst, wenn bei Division der Divisor null ist.
Ebenso wird "Constraint_Error" ausgelöst, wenn bei der Exponentialfunktion der linke Operand null und der rechte negativ ist. "Constraint_Error" kann auch ausgelöst werden (muß aber nicht), wenn das Ergebnis einer Operation zu einem Überlauf führt.

zurück

vor

Index

nach oben