1.1 Was für Funktionen gibt es in der Unit Math?

mitp Seitenanzahl 13 Die Unit Math 1 Die Unit Math Die Unit Math stellt an die 100 Funktionen für mathematische Berechnungen zur Verfügung. Das schöne daran ist, das der Source verfügbar ist und zwar ist dieser unter \Borland\Delphi5\Source\Rtl\Sys\math.pas (Version 5) bzw. unter \Borland\Delphi7\Source\Rtl\Common\math.pas (Version 7) zu finden. Stellenweise ist der Code sehr ausführlich und gut kommentiert, so dass man die meisten Vorgänge gut nachvollziehen kann. 1.1 Was für Funktionen gibt es in der Unit Math? - Vergleiche - Trigonometrische Funktionen - Arkusfunktionen - Winkel-Einheiten konvertieren * - Hyberbolische Funktionen und deren Inverse * - Logarithmische Funktionen - Exponential Funktionen - Statistische Funktionen - Finanz-Mathematik * - FPU-Steuerung - und andere... * 1.2 Warum nicht selber machen oder: Was ist die FPU? Die meisten Funktionen aus der Unit Math lassen sich mit wenigen Grund- Funktionen selber schreiben. Beispielsweise läßt sich der Tangens von x durch sin(x)/cos(x) berechnen. Doch warum das Rad erneut erfinden und auf die Vorteile von getesteter und optimierter Software verzichten? Zumal die Unit Math sich der FPU bedient. 1

(Für uns) Interessantes über die FPU FPU steht für Floating Point Unit und ist für das Rechnen mit Fließkommazahlen zuständig. Da die FPU im Prinzip ein eigener Prozessor ist und parallel zur CPU läuft, wird die CPU durch die, im Prinzip langsamen Fließkomma-Operationen, extrem entlastet. Um in den Genuß dieses Vorteiles zu kommen, muss man die FPU allerdings mittels Assembler ansprechen. Aber auch das nimmt uns die Unit Math ab. Um zusätzlich an Geschwindigkeit zu gewinnen findet man im Source bei einigen Funktionen die Direktive Register, welche den Compiler explizit dazu veranlasst die Parameter in den CPU-Registern abzulegen und nicht auf dem Stack. ( Explizit deshalb, weil das eigentlich die Standard Aufruf-Konvention ist). 1.3 (Für uns) Interessantes über die FPU Da wir mit der FPU nicht direkt in Kontakt kommen, gibt es nur weniges, was wir über sie wissen müssen. Zum einen die Tatsache, dass wir die Art des Rundens von Zahlen mit ihr beeinflussen können und zum anderen die Genauigkeit der Fließkommazahlen. Doch dazu später mehr. 1.4 Von Unendlichkeiten, Zahlen und solche die es gerne wären 1.4.1 Die Unendlichkeit Die Unit Math stellt zwei Konstanten zur Verfügung, die die Unendlichkeit repräsentieren. Infinity stellt die positive Unendlichkeit dar und NegInfinity die negative. Da man keine unendlich große Zahl abspeichern kann, hat man zu einem Trick gegriffen und unendlich einfach als 1.0 / 0.0 respektive 1.0 / 0.0 definiert. 1.4.2 Zahlen Es stehen diverse Datentypen für Fließkommazahlen zur Verfügung, die jeweils einen unterschiedlich großen Wertebereich repräsentieren. Die minimal, bzw. maximal Werte dieser Wertebereiche sind als Konstanten in der Unit Math zu finden: Datentyp Minimum Maximum Single MinSingle = 1.5*10-45 MaxSingle = 3.4*10 38 Double MinDouble = 5.0*10-324 MaxDouble = 1.7*10 308 Comp MinComp = MaxComp = 2

Die Unit Math -9.223372036854775807*10 18 9.223372036854775807*10 18 Extended MinExtended = 3.4*10-4932 MaxExtended = 1.1*10 +4932 Genauigkeit Das bedeutet aber nicht, dass Ergebnisse von Berechnungen immer die Genauigkeit besitzen, die sie auch abspeichern könnten. Denn je genauer die Ergebnisse sein sollen, um so länger dauert ihre Berechnung. Und in den seltensten Fällen ist die Genauigkeit weit hinter dem Komma auch wirklich signifikant. Um die Präzision zu beeinflussen können wir der FPU mitteilen, wie genau sie wirklich arbeiten soll. Mit der Funktion SetPrecisonMode können wir einstellen, ob sie mit einfacher Genauigkeit (pmsingle), doppelter Genauigkeit (pmdouble) oder erweiterter Genauigkeit (pmextended) arbeiten soll. (Die Werte in den Klammern sind vom Typen TFPUPrecisionMode und sind als Parameter zu übergeben). Als Rückgabewert wird der alte Modus zurückgegeben. Um die aktuelle Einstellung zu ermitteln können wir die GetPrecisionMode- Funktion und jegliche Parameter aufrufen. Es wird entsprechend entweder pmsingle, pmdouble oder pmextended zurückgegeben. 1.4.3 NaN NaN steht für Not a number und ist: keine Zahl! Diese Konstante ist als 0.0 / 0.0 definiert und kann Fließkomma-Variablen zugewiesen werden, die noch nicht initialisiert wurden. 1.5 Eigenschaften von Werten Um Werte auf die eben genannten Eigenschaften zu testen, muss man sich nicht mit den technischen Details auseinander setzen, was intern passiert, denn die Unit Math stellt hier einige Funktionen zur Verfügung, die einem diese Arbeit abnehmen. 1.5.1 Ist Wert gleich NaN? Um eine Variable mit dem Wert NaN zu vergleichen, sollte man die Funktion IsNAN, der man den zu vergleichenden Wert als Parameter übergibt. Als Parameter werden Variablen vom Typen Single, Double und Extended akzeptiert. Der Rückgabewert ist vom Typen Boolean. 1.5.2 Ist Wert gleich unendlich? Ähnlich wie die IsNAN-Funktion verhält sich die Funktion IsInfinite. Ihr wird ein zu überprüfender Wert übergeben, der vom Datentyp Double sein muss und als 3

Eigenschaften von Werten Ergebnis wird ein boolescher Wert zurückgegeben. Um zwischen positiver und negativer Unendlichkeit unterscheiden zu können, benötigen wir eine weitere Funktion. 1.5.3 Vorzeichentest Um zu bestimmen, ob ein Wert positiv oder negativ ist, gibt es die Funktion Sign. Dabei ist diese Funktion nicht nur auf unendliche Werte beschränkt, sondern kann natürlich auf jeglichen Wert angewandt werden, soweit dieser vom Typen Integer, Int64 oder Double ist. Was für ein Vorzeichen besitzt dabei die 0? In der Regel wird die Null als positiver Wert gezählt, doch benutzt die Sign-Funktion einen eigenen Datentyp für die Rückgabe, so dass die 0 einfach 0 ist und somit kein Vorzeichen hat. Für negative Werte wird also 1 zurückgegeben, für den Wert 0 wird 0 zurückgegeben und für positive Werte (+)1. 1.5.4 Ist Wert gleich null? Auch wenn die Funktion Sign diese Frage beantworten könnte, gibt es eine eigene Funktion, um eine Variable auf den Wert 0 zu überprüfen respektive, ob dieser ziemlich nah dran ist. Die Funktion heißt IsZero und erwartet zwei Parameter! Als erster Parameter wird der zu überprüfende Wert (vom Typen Extended, Double oder Single) erwartet und als zweiter Parameter die maximale Abweichung. Überschreitet der zu überprüfende Wert die den zweiten Parameter nicht, wird der Wert immer noch als 0 interpretiert. Als Rückgabewert wird wieder ein Boolean zurückgegeben. 1.5.5 Weitere Vergleiche Uns stehen in der Unit Math noch weitere Vergleichsmöglichkeiten zur Verfügung, auf die hier nicht näher eingegangen werden soll. Diese Möglichkeiten schließen das Vergleichen zwischen zwei Zahlen ein, ob diese gleich sind, in welcher Beziehung diese zueinander stehen oder in welcher Spanne sich diese bewegen. Interessierte sollten sich folgende Funktionen anschauen: - CompareValue - SameValue - IfThen - InRange 4

Die Unit Math 1.6 Trigonometrische Funktionen Gehören Sinus und Kosinus zum festen Bestandteil der Unit System, so komplettiert die Unit Math das Angebot der trigonmetrischen Funktionen: Funktion Syntax cos 1 function ArcCos(const X: Extended): Extended; sin 1 function ArcSin(const X: Extended): Extended; tan 1 function ArcTan2(const Y, X: Extended): Extended; 1/sin(x) function Cosecant(const X: Extended): Extended; 1/tan(x) function Cotan(const X: Extended): Extended; sqrt(x 2 +y 2 ) 1/cos(x) sin(x)/cos(x) function Hypot(const X, Y: Extended): Extended; //berechnet die Länge der Hypotenuse function Secant(const X: Extended): Extended; function Tan(const X: Extended): Extended; Auf eine weitere Prozedur möchte ich hier aber noch genauer eingehen: SinCos 1.6.1 SinCos Sinus und Kosinus sind zwar schon in der Unit System implementiert, tauchen in der Unit Math aber nochmals auf. Und das aus gutem Grund. Schauen wir uns die Prozedur einmal an: procedure SinCos(const Theta: Extended; var Sin, Cos: Extended) register; Theta enthält den Winkel und die Parameter Sin und Cos die Variablen, in denen das entsprechende Ergebnis abgespeichert wird. Was ist nun so toll an dieser Prozedur? Schließlich können wir auch zwei seperate Berechnungen hintereinander durchführen, wenn wir sowohl Sinus als auch Kosinus benötigen. Das ist wohl wahr, allerdings ist diese Prozedur doppelt so schnell, als wenn man die Werte einzeln berechnen würde. Das liegt daran, dass die FPU einen extra Befehl dafür zur Verfügung stellt. 1.7 Logarithmische Funktionen Tja, was soll ich hier sagen? Es gibt vier verschiedene Funktionen, die den Logarithmus zu verschiedenen Basen berechnen: Logarithmus zur Basis Funktion 10 function Log10(const X: Extended): Extended; 5

Exponential Funktionen 2 function Log2(const X: Extended): Extended; n function LogN(const Base, X: Extended): Extended; Außerdem gibt es noch die Funktion function LnXP1(const X: Extended): Extended; die den natürlichen Logarithmus von x+1 bildet. Diese Funktion sollte benutzt werden, wenn x ziemlich nah an 0 ist. 1.8 Exponential Funktionen Es gibt zwei grundlegende Funktionen um Potenzen zu berechnen: IntPower und Power. Beide erwarten als ersten Parameter die Basis und als zweiten den Exponenten und beide liefern das Ergebniss als Extended zurück. Der einzige Unterschied ist, dass Power Fließkommazahlen als Exponenten zulässt und somit wesentlich langsamer ist, als IntPower, die nur Integer-Werte als Exponenten erlaubt. 1.9 Statistische Funktionen Allen statistischen Funktionen, die wir hier ansprechen wird als Parameter ein Double- oder Integer-Array übergeben, dass die Werte zur Verfügung stellt, auf die die Operation angewandt werden soll. 1.9.1 Den Durchschnitt berechnen Um den Durchschnitt zu ermitteln, übergeben wir der Funktion Mean ein Double- Array und erhalten als Rückgabewert einen Extended-Wert. 1.9.2 Summierung Für die Aufsummierung eines kompletten Arrays gibt es zwei Funktionen: Sum und SumInt. Ersteres erwartet ein Double-Array als Parameter und letzteres ein Integer-Array. Der Rückgabewert des Fließkomma-Arrays ist vom Typen Extended. Bei den ganzen Zahlen, bleibt der Rückgabewert ein Integer. 1.9.3 Maximum und Minimum Für Fließkommawerte stehen die Funktionen MaxValue respektive MinValue zur Verfügung. Entsprechend stehen für ganze Zahlen die Funktionen MaxIntValue und 6

Die Unit Math MinIntValue zur Verfügung. 1.10 Was woanders nicht passte: DivMod Es gibt noch eine Prozedur, die bisher nirgendwo so richtig reinpasste: DivMod. Ähnlich wie SinCos nimmt diese Prozedur auch 2 Berechnungen auf einmal vor und zwar eine ganzzahlige Division und eine Division mit Rest: procedure DivMod(Dividend: Integer; Divisor: Word; var Result, Remainder: Word); Die Parameter sprechen eigentlich für sich: den Parametern Dividend und Divisor werden entsprechende übergeben und die jeweiligen Ergebnisse werden in Result (ganzer Teil) und Remainder (Rest-Betrag) gespeichert. 1.11 Beispiel { Referat2 : Programm zu Demonstrationszwecken für das Referat in Programmierung 2 Autor: Joachim F. Rohde Datum: 08. April 2003 } program referat2; {$APPTYPE CONSOLE} uses SysUtils, Math; var Zahl : Single; Start, Stop : TDateTime; // Variablen für die // Zeitmessung // ermittelt eine Zeit-Differenz und gibt sie als String // zurück function F_Zeitbedarf (Start, Stop: TDateTime): string; 7

Beispiel F_Zeitbedarf := TimeToStr (Stop - Start) {CmpSinCos zeigt, dass SinCos tatsächlich doppelt so schnell ist, wie die getrennte Berechnung. Die Schleifen dienen dazu, dass meßbare Zeiten entstehen.} procedure CmpSinCos; var erg_cos, erg_sin : extended; i:integer; //Sinus und Cosinus getrennt berechnen start:=now; for i:=1 to 15000000 do erg_cos:=cos (45); erg_sin:=sin (45); writeln ('Cosinus: ', erg_cos:2:3); writeln ('Sinus: ', erg_sin:2:3); stop:=now; Writeln ('Benoetigte Zeit fuer die seperate Berechnung: ', F_Zeitbedarf (start, stop)); //SinCos benutzen start:=now; for i:=1 to 15000000 do SinCos (45, erg_sin, erg_cos); writeln ('Cosinus: ', erg_cos:2:3); writeln ('Sinus: ', erg_sin:2:3); stop:=now; 8

Die Unit Math Writeln ('Benoetigte Zeit fuer SinCos: ', F_Zeitbedarf (start, stop)); {Folgende Prozedur gibt den aktuellen Präzisions-Modus der FPU aus} procedure PraezisionAusgeben; var PraezisionsModus : TFPUPrecisionMode; write ('FPU laeuft zur Zeit mit '); PraezisionsModus:=GetPrecisionMode; case PraezisionsModus of pmsingle : writeln ('einfacher Genauigkeit.'); pmdouble : writeln ('doppelter Genauigkeit.'); pmextended : writeln ('erweiterter Genauigkeit.'); procedure Teste_NaN (Zahl : single); if IsNaN (Zahl) then writeln ('Zahl ist NaN') else writeln ('Zahl ist keine NaN'); procedure Teste_Infinity (zahl : single); if IsInfinite (Zahl) then writeln ('Zahl ist unendlich') else writeln ('Zahl ist nicht unendlich'); 9

Beispiel procedure Teste_Null (zahl : single); if IsZero (Zahl,0.01) then bei 0 writeln ('Zahl ist gleich 0') else writeln ('Zahl ist ungleich 0'); //beinahe procedure Teste_Sign (zahl : single); case Sign (Zahl) of //darf nicht nan sein 1 : writeln ('Zahl ist positiv'); 0 : writeln ('Zahl ist null'); -1 : writeln ('Zahl ist negativ'); //Vergleiche DivMod mit der separaten Berechnung procedure CmpDivMod; var erg_cos, erg_sin : extended; i:integer; // hier 2 Unterprozeduren, die für den Vergleich // aufgerufen werden //führt die Berechnung separat durch procedure Teste_DivMod (Divisor, Dividend : integer); var erg, rest : word; 10

Die Unit Math erg:=divisor div Divid rest:=divisor mod Divid //benutzt für die Berechnung DivMod procedure Teste_ProcDivMod (Divisor, Dividend : integer); var erg, rest : word; DivMod(Dividend, Divisor, erg, rest); //hier nt die eigentlich CmpDivMod Prozedur //Quotient und Rest getrennt berechnen start:=now; for i:=1 to 150000000 do Teste_DivMod (15,10); stop:=now; Writeln ('Benoetigte Zeit fuer die separate Berechnung: ', F_Zeitbedarf (start, stop)); //DivMod benutzen start:=now; for i:=1 to 150000000 do Teste_ProcDivMod (15,10); stop:=now; Writeln ('Benoetigte Zeit fuer DivMod: ', F_Zeitbedarf (start, stop)); 11

Beispiel writeln ('Bitte kleinen Moment warten...'); CmpSinCos; writeln ('Enter druecken um weiterzumachen'); readln; writeln ('Bitte kleinen Moment warten waehrend CmpDivMod ausgefuehrt wird...'); CmpDivMod; writeln ('Enter druecken um weiterzumachen'); readln; //gibt den aktuellen Präzisions-Modus aus PraezisionAusgeben; //NaN testen Writeln ('NaN testen'); Zahl:=NaN; Teste_NaN (zahl); write ('neue Zahl eingeben: '); readln (zahl); Teste_NaN (zahl); writeln ('Enter druecken um weiterzumachen'); readln; //auf unendlichkeit testen Writeln ('Auf Unendlichkeit testen'); zahl:=neginfinity; Teste_Infinity (zahl); write ('neue Zahl eingeben: '); readln (zahl); Teste_Infinity (zahl); writeln ('Enter druecken um weiterzumachen'); readln; 12

Die Unit Math //auf 0 testen Writeln ('Auf 0 testen'); zahl:=0; Teste_Null (zahl); write ('neue Zahl eingeben: '); readln (zahl); Teste_Null (zahl); writeln ('Enter druecken um weiterzumachen'); readln; //Vorzeichen testen Writeln ('Vorzeichen testen'); zahl:=0; Teste_Sign (zahl); write ('neue Zahl eingeben: '); readln (zahl); Teste_Sign (zahl); //Programm beenden writeln; writeln ('Enter zum beenden druecken.'); readln; end. 1.12 Quellen - Delphi-Hilfe - Source der Unit Math ( \Borland\Delphi7\Source\Rtl\Common\Math.pas ) - Übungsprogramm STATISTIK1 von Prof. Thomas Müller 13