OptiVec logo 

VectorLib



Index:

OptiVec Home
MatrixLib
CMATH
Download
Bestellung / Registrierung
Update
Support

VectorLib

4. VectorLib-Funktionen: Ein kurzer Überblick

4.1 Erzeugung, Initialisierung und Freigabe von Vektoren
4.2 Index-orientierte Manipulationen
4.3 Datentyp-Umwandlungen
4.4 Nähere Informationen zur Ganzzahl-Arithmetik
4.5 Grundfunktionen komplexer Vektoren
4.6 Mathematische Funktionen
4.6.1 Rundung
4.6.2 Vergleiche
4.6.3 Direkte Bit-Manipulationen
4.6.4 Arithmetische Grundfunktionen, Akkumulation
4.6.5 Geometrische Vektor-Arithmetik
4.6.6 Potenzen
4.6.7 Exponential- und Hyperbel-Funktionen
4.6.8 Logarithmen
4.6.9 Trigonometrische Funktionen
4.7 Analysis
4.8 Signalverarbeitung: Fourier-Transformations-Techniken
4.9 Statistische Funktionen und Bausteine
4.10 Daten-Anpassung
4.11 Input und Output
4.12 Graphik

4.1 Erzeugung, Initialisierung und Freigabe von Vektoren

VectorLib erlaubt die gleichzeitige Verwendung von statisch (wie z.B. "float a[100];" ) und dynamisch mit Speicherplatz versehenen Vektoren (siehe Kap. 2.3). Wir empfehlen allerdings die Verwendung der flexibleren in VectorLib definierten Vektoren mit dynamischer Speicherzuweisung. Die hierzu verwendeten Funktionen werden in der folgenden Tabelle zusammengefaßt.
VF_vectorSpeicherzuweisung für einen Vektor
VF_vector0Speicherzuweisung in Initialisierung aller elemente mit 0
V_freeeinen Vektor freigeben
V_nfreemehrere Vektoren freigeben (nur C/C++)
V_freeAllelle existierenden Vektoren freigeben
 
Man sollte stets darauf achten, Vektoren freizugeben, wenn sie nicht länger benötigt werden. Intern werden alle Vektoren in eine Tabelle eingetragen, die über den zugewiesenen Speicher Buch führt. Der Versuch, einen nicht (mehr) existierenden Vektor freizugeben, führt zu einer Warnung, nach der der Programmablauf fortgesetzt wird, ohne etwas freizugeben.

Daß den bereits in C und C++ reichlich vorhandenen Operatoren und Funktionen für diese Zwecke (malloc, calloc, free, new, LocalAlloc, GlobalAlloc usw.) hier noch mehr hinzugefügt werden, hat seinen Grund darin, daß für jedes Speichermodell und jede Umgebung automatisch die optimale Methode gewählt werden soll. Die Implementation von VF_vector usw. paßt sich also der jeweiligen Umgebung an, was der Portabilität der Programme zugute kommt.

Performance-Tips:

  • Die mittels VF_vector usw. erzeugten Vektoren sind an 64-Byte-Grenzen ausgerichtet zur optimalen Anpassung an die Cache-Zeilengröße der Prozessoren. Im Gegensatz hierzu sind statische Arrays ebenso wie die über den Operator new oder die Standard-Allokationsfunktionen malloc, calloc, GetMem, LocalAlloc, GlobalAlloc etc. erzeugten dynamischen Arrays nur an 4-Byte-Grenzen ausgerichtet. Für optimale Performance sollten Sie daher über VF_vector etc. erzeugte Vektoren verwenden.
  • Die in der P6-Version verwendeten SIMD-Befehle verlangen an 16-Byte-Grenzen ausgerichtete Daten. Wiederum gilt: Benutzen Sie die dynamischen Vektoren von OptiVec, um die verlangte Ausrichtung zu garantieren. Die Geschwindigkeits-Einbuße bei Verwendung nicht korrekt ausgerichteter Daten beträgt bis zu 25%.
  • Anstatt vieler kleiner Vektoren sollten Sie besser einen großen Vektor allozieren und die kleinen Vektoren als Teile des großen definieren, also z.B.:
    C/C++:
    X = VF_vector( 3*size);
    Z = (Y = X+size) + size;
    Pascal/Delphi:
    X := VF_vector( 3*size );
    Y := VF_Pelement( X, size );
    Z := VF_Pelement( Y, size );
    Runden Sie aber gegebenenfalls size so auf, dass size*sizeof( data type ) ein Vielfaches von 32 oder besser 64 wird.
  • Vermeiden Sie zu häufige Allokation und Deallokation. Versuchen Sie lieber, Vektoren wiederzuverwenden.

Zur Initialisierung ganzer Vektoren (nach der Zuweisung von Speicherplatz!) mit bestimmten Werten stehen die folgenden Funktionen zur Verfügung:

VF_equ0setzt alle Elemente gleich 0
VF_equ1setzt alle Elemente gleich 1
VF_equm1setzt alle Elemente gleich -1
VF_equCsetzt alle Elemente gleich C
VF_equVmacht einen Vektor zur Kopie eines anderen
VFx_equVerweiterte Version des Gleichheitsoperators: Yi = a * Xi + b
VF_ramp"Rampe": Xi = a * i + b.
VF_randomZufallszahlen hoher Qualität
VF_noiseweißes Rauschen
VF_comb"Kamm", der an äquidistanten Punkten gleich einer Konstanten C und ansonsten 0 ist.
 
Die folgenden Funktionen generieren Fenster zur Verwendung in der Spektrenanalyse (siehe VF_spectrum):
VF_HannHann-Fenster
VF_ParzenParzen-Fenster
VF_WelchWelch-Fenster
 
Komplexe Vektoren können mittels der folgenden Funktionen initialisiert werden:
VF_ReImtoCzwei reelle Vektoren, Re und Im, zu einem cartesisch-komplexen Vektor zusammenfassen
VF_RetoCRealteil eines cartesisch-komplexen Vektors überschreiben
VF_ImtoCImaginärteil eines cartesisch-komplexen Vektors überschreiben
VF_PolartoCCartesisch-komplexen Vektor aus Polarkoordinaten konstruieren, die als getrennte Vektoren Mag und Arg vorliegen
VF_MagArgtoPzwei reelle Vektoren, Mag und Arg, zu einem polar-komplexen Vektor zusammenfassen
VF_MagArgtoPrincipalzwei reelle Vektoren, Mag und Arg, zu einem polar-komplexen Vektor zusammenfassen und die Zeigerwinkel auf den Hauptwert normieren: -p < Arg <= +p
VF_MagtoPMag-Teil eines polar-komplexen Vektors überschreiben
VF_ArgtoPArg-Teil eines polar-komplexen Vektors überschreiben
VF_ReImtoPPolar-komplexen Vektor aus cartesischen Koordinaten konstruieren, die als getrennte Vektoren Re und Im vorliegen

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home

4.2 Index-orientierte Manipulationen

VF_revkehrt die Reihenfolge aller Elemente eines Vektor um (engl. to reverse = umkehren)
VF_reflectreflektiert einen Vektor an seinem Mittelpunkt, so daß die obere Hälfte gleich der umgekehrten unteren Hälfte wird
VF_rotaterotiert einen Vektor um eine als Parameter übergebene Anzahl von Positionen (wobei auf einer Seite hinausgeschobene Elemente an der anderen wieder hineingeschoben werden)
VF_rotate_bufEffiziente Rotation eines Vektors unter Verwendung von benutzerspezifiziertem Pufferspeicher
VF_insertElement einfügen
VF_deleteElement entfernen
VF_sortSortieren (aufsteigende oder abfallende Folge)
VF_sortindmit einem Vektor assoziierten Index-Array sortieren
VF_subvectorUnter-Vektor aus einem (meist größeren) Vektor extrahieren mit konstantem Abtastintervall
VF_indpickfüllt einen Vektor mit Elementen eines anderen, wobei diese entsprechend ihren Indizes "herausgepickt" werden.
VF_indputverteilt die Elemente eines Vektors auf die durch ihre Indizes spezifizierten Plätze eines anderen Vektors.
 

Operationen, die nur auf eine Untermenge von Elementen (z.B. auf jedes vierte, zehnte o.ä.) angewandt werden sollen, werden durch die Funktionsfamilie VF_subvector_... zur Verfügung gestellt, wobei die drei Punkte für ein Suffix stehen, daß die jeweilige Operation bezeichnet:

VF_subvector_equC Xi*samp = C,   i=0,...subsize-1
VF_subvector_addC Xi*samp += C,   i=0,...subsize-1
VF_subvector_subC Xi*samp -= C,   i=0,...subsize-1
VF_subvector_subrC Xi*samp = C - Xi*samp,   i=0,...subsize-1
VF_subvector_mulC Xi*samp *= C,   i=0,...subsize-1
VF_subvector_divC Xi*samp /= C,   i=0,...subsize-1
VF_subvector_divrC Xi*samp = C / Xi*samp,   i=0,...subsize-1
VF_subvector_equV Yi*samp = Yi,   i=0,...subsize-1
VF_subvector_addV Xi*samp += Yi,   i=0,...subsize-1
VF_subvector_subV Xi*samp -= Yi,   i=0,...subsize-1
VF_subvector_subrV Xi*samp = Yi - Xi*samp,   i=0,...subsize-1
VF_subvector_mulV Xi*samp *= Yi,   i=0,...subsize-1
VF_subvector_divV Xi*samp /= Yi,   i=0,...subsize-1
VF_subvector_divrV Xi*samp = Yi / Xi*samp,   i=0,...subsize-1
 

Dem Durchsuchen von Tabellen nach bestimmten Werten dienen:

VF_searchC sucht das einem Wert C am nächsten kommende Element eines Vektors, wobei ein Parameter mode darüber entscheidet, ob das absolut nächste, das nächste "größere-oder-gleiche" oder das nächste "kleinere-oder-gleiche" gewählt werden
VF_searchVdasselbe für ein ganzes Feld von Suchwerten
 
An Interpolations-Routinen stellt OptiVec zur Verfügung:
VF_polyinterpolPolynom-Interpolation
VF_ratinterpolrationale Interpolation
VF_natCubSplineInterpol"natürliche" kubische Spline-Interpolation
VF_splineinterpolgeneralisierte kubische Spline-Interpolation
 

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home

4.3 Datentyp-Umwandlungen

Das erste, was über die nun folgenden Umwandlungsroutinen zu sagen wäre, ist, daß man sie möglichst selten anwenden sollte. Man überlege vorher, welche Genauigkeit und welchen Zahlenbereich man benötigt, und bleibe dann innerhalb dieser Genauigkeit. Da es aber doch immer wieder Gelegenheiten gibt, wo eine Umwandlung sich nicht umgehen läßt, ist für jeden Zweck die passende VectorLib-Funktion gegeben. Die folgende Tabelle faßt einige Beispiele zusammen. Die übrigen Funktionen dürfte sich von selbst ergeben:
V_FtoDfloat in double
V_CDtoCFcomplex<double> in complex<float> (mit Überlauf-Abfang)
V_PFtoPEpolar<float> in polar<extended>
VF_PtoCpolar<float> in complex<float>
V_ItoLIint in long int
V_ULtoUSunsigned long in unsigned short
V_ItoUsigned int in unsigned int. Die Umwandlungen zwischen vorzeichenbehafteten und vorzeichenlosen Typen beschränken sich allerdings auf Umwandlungen innerhalb der jeweils selben Genauigkeitsstufe. Funktionen wie "V_UStoLI" existieren naher nicht.
V_ItoFint to float
 
Die Umwandlung von Fließkomma- in ganze Zahlen wird durch die folgenden Funktionen bewerkstelligt, die sich in der Behandlung des Rundungsrestes unterscheiden:
VF_roundtoIround to the closest integer
VF_choptoIround by neglecting ("chopping off") the fractional part
VF_trunctoIthe same as VF_choptoI
VF_ceiltoIround to the next greater-or-equal integer
VF_floortoIround to the next smaller-or-equal integer
 
Diese Operationen werden als mathematische Funktionen behandelt und in Kap. 4.6.1 beschrieben.

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home

4.4 Nähere Informationen zur Ganzzahl-Arithmetik

Im Zusammenhang mit der Arithmetik ganzer Zahlen (engl.: Integers) sollte man sich klar machen, daß alle Integer-Operationen implizit modulo 2n durchgeführt werden, wobei n die den jeweiligen Datentyp darstellende Anzahl von Bits ist. Jedes Ergebnis, das außerhalb des mit dem jeweiligen Typ darstellbaren Zahlenbereiches liegen würde, wird durch Verlust des oder der höchsten Bits auf den darstellbaren Bereich abgebildet. Im Ergebnis sieht das so aus, als wäre das Ergebnis durch Addition oder Subtraktion von soviel mal 2n wie nötig erhalten worden.

So wird man im Datentyp short / SmallInt als Ergebnis der Multiplikation 5 * 20000 die vielleicht unerwartete Zahl -31072 erhalten. Das "korrekte" Resultat, 100000, übersteigt den darstellbaren Bereich von short/SmallInt-Zahlen, -32768 <= x <= +32767. short / SmallInt sind 16-bit-Zahlen, also ist n = 16 und 2n = 65536. Man kann sich das Zustandekommen des erhaltenen Resultates also so vorstellen, als ob der Prozessor 2 * 65536 = 131072 von 100000 abgezogen hätte, was -31072 ergibt.

Überlaufende Zwischenergebnisse werden nicht durch nachfolgende Operationen "geheilt". Das Ergebnis der Berechnung von (5 * 20000) / 4 ist nicht – wie man vielleicht hoffen könnte – +25000, sondern -7768.

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home

4.5 Grundfunktionen komplexer Vektoren

Für die Behandlung cartesisch-komplexer Vektoren existieren die folgenden Grundfunktionen:
VF_ReImtoCBildung eines cartesisch-komplexen Vektors aus Real- und Imaginärteil
VF_RetoCÜberschreiben des Realteils
VF_ImtoCÜberschreiben des Imaginärteils
VF_CtoReImExtraktion von Real- und Imaginärteil
VF_CtoReExtraktion des Realteils
VF_CtoImExtraktion des Imaginärteils
VF_PolartoCBildung eines cartesisch-komplexen Vektors aus Polarkoordinaten, die als separate reelle Vektoren Mag und Arg vorliegen
VF_CtoPolarUmwandlung eines cartesisch-komplexen Vektors in Polarkoordinaten, die in separaten reellen Vektoren Mag und Arg abgelegt werden
VF_CtoAbsAbsolutwert (Zeigergröße in der komplexen Ebene)
VF_CtoArgArgument (Zeigerwinkel in der komplexen Ebene)
VF_CtoNormNorm (hier als Quadrat des Absolutwertes definiert)
VCF_normtoCNorm, gespeichert als komplexer Vektor (mit allen Imaginärteilen gleich 0)
 
Die entsprechenden Funktionen für Polarkoordinaten sind:
VF_MagArgtoPzwei reelle Vektoren, Mag und Arg, zu einem polar-komplexen Vektor zusammenfassen
VF_MagArgtoPrincipaldasselbe, mit Normierung der Zeigerwinkel auf den Hauptwert, -p < Arg <= +p
VF_MagtoPMag-Teil überschreiben
VF_ArgtoPArg-Teil überschreiben
VF_PtoMagArgMag- und Arg-Teile extrahieren
VF_PtoMagMag-Teil extrahieren
VF_PtoArgArg-Teil extrahieren
VF_PtoNormNorm (hier als Quadrat der Zeigerlänge definiert)
VF_ReImtoPpolar-komplexen Vektor aus cartesischen Koordinaten konstruieren, die als separate reelle Vektoren Re und Im vorliegen
VF_PtoReImpolar-komplexen-Vektor in cartesische Koordinaten umwandeln, die als zwei reelle Vektoren Re und Im gespeichert werden
VF_PtoReRealteil berechnen
VF_PtoImImaginärteil berechnen
VPF_principalHauptwert. Man erinnere sich, daß eine komplexe Zahl unendlich viele Darstellungen in Polarkoordinaten besitzt, deren Zeigerwinkel sich um ganzzahlige Vielfache von 2 p unterschieden. Die Darstellung mit -p < Arg <= +p wird Hauptwert genannt.
 

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home

4.6 Mathematische Funktionen

In Ermangelung einer besser begründeten Definition werden hier als "mathematisch" alle diejenigen Funktionen verstanden, bei denen jedes einzelne Element eines Vektors aus genau einem korrespondierenden Element eines anderen Vektors berechnet wird mit Hilfe einer mehr oder weniger einfachen Formel: Yi = f( Xi ) (im Unterschied also zu Funktionen wie der Fourier-Transformation, wo jedes Element des Ergebnis-Vektors von prinzipiell jedem Element des Eingabe-Vektors abhängt).

Mit Ausnahme der einfachen arithmetischen Funktionen (Addition, Subtraktion etc.), existieren die mathematischen Funktionen nur für die Fließkomma-Datentypen. Die meisten mathematischen Funktionen von VectorLib sind als vektorisierte Versionen der entsprechenden Funktionen von ANSI-C oder Pascal zu verstehen oder von diesen abgeleitet. In C/C++ werden Fehler grundsätzlich über die vom Compiler zur Verfügung gestellten (oder vom Anwender selbst geschriebenen) Funktionen _matherr und (bei Borland C++) _matherrl behandelt. In Pascal/Delphi bietet OptiVec dem Anwender die Möglichkeit, das Verhalten im Fehlerfall über die Funktion V_setFPErrorHandling festzulegen.
Zusätzlich zu dieser Fehlerbehandlung "pro Element" wird noch durch den Rückgabewert der Vektor-Funktion angegeben, ob die Berechnung für alle Elemente erfolgreich war oder ob irgendein Fehler auftrat. Im Falle fehlerfreier Verarbeitung ist der Rückgabewert FALSE (0), sonst TRUE (irgendeine Zahl ungleich 0).

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home

4.6.1 Rundung

Wie schon im Zusammenhang mit den Datentyp-Umwandlungsroutinen erwähnt, ist die Umwandlung von Fließkomma- in Ganzzahl-Typen nicht von vornherein eindeutig möglich. Man hat vielmehr die Behandlung der Stellen nach dem Komma näher zu spezifizieren. Das Resultat der Rundung wiederum kann entweder in dem ursprünglichen Fließkomma-Format belassen oder in einen der Ganzzahl-Typen umgewandelt werden. Die folgenden Funktionen belassen das Resultat als Fließkomma-Zahl:
VF_roundauf die nächstliegende ganze Zahl auf- oder abrunden
VF_chopNachkommastellen abschneiden (Rundung Richtung 0)
VF_truncidentisch mit VF_chop
VF_ceilaufrunden
VF_floorabrunden
 
Die folgenden Funktionen wandeln das Ergebnis in Ganzzahlen um (die Tabelle nennt die Funktionen für Umwandlung in den Typ int / Integer):
VF_roundtoIauf die nächstliegende ganze Zahl auf- oder abrunden
VF_choptoINachkommastellen abschneiden (Rundung Richtung 0)
VF_trunctoIidentisch mit VF_choptoI
VF_ceiltoIaufrunden
VF_floortoIabrunden
 
Selbstverständlich kann der Ziel-Datentyp auch jeder andere Ganzzahl-Typ sein. Einige wenige Beispiele sollten genügen:
VF_choptoSINachkommastellen abschneiden und als short / SmallInt speichern
VF_ceiltoLIaufrunden und als long / LongInt speichern
VF_floortoQIabrunden und als quad / QuadInt speichern
VF_roundtoUauf die nächstliegende ganze Zahl runden und als unsigned / UInt speichern
VF_ceiltoUSaufrunden und als unsigned short / USMall speichern
VD_choptoULNachkommastellen abschneiden und als unsigned long / ULong speichern

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home

4.6.2 Vergleiche

Die Namen aller Vergleichs-Funktionen werden aufgebaut, indem dem Datentyp-Präfix die Buchstaben quot;cmp" folgen und danach die nähere Angabe der durchzuführenden Vergleichsoperation. Jedes Element eines Vektors kann entweder mit 0 oder mit einem Sollwert C oder auch mit dem korrespondierenden Element eines anderen Vektors verglichen werden. Es gibt hierbei zwei Möglichkeiten. Die erste besteht in der Unterscheidung der Fälle "kleiner als", "gleich" und "größer als". Das Ergebnis des Vergleiches wird als Fließkomma-Zahlen -1.0 (für "kleiner als"), 0.0 (für "gleich") und +1.0 (für "größer als") angegeben. Beispiele sind die Funktionen
 
VF_cmp0Vergleich mit 0
VD_cmpCVergleich mit einem Sollwert C
VE_cmpVVergleich korrespondierender Vektorelemente

Die zweite Möglichkeit ist, daß –durch einen Unterstrich abgesetzt –die zu testende Bedingung angegeben wird. Diese kann Gleichheit, Ungleichheit, "größer als", "größer oder gleich", "kleiner als" oder "kleiner oder gleich" sein. Das Resultat ist TRUE oder FALSE und wird als 1.0 oder 0.0 gespeichert. Beispiele sind:
 

VF_cmp_eq0Test, ob Xi = 0
VD_cmp_gtCTest, ob Xi > C
VE_cmp_leVTest, ob Xi <= Yi

Alternativ können auch die Indizes derjenigen Elemente in einem Index-Array abgelegt werden, für die die Bedingung als TRUE gefunden wurde:
 

VF_cmp_neCindIndizes der Elemente Xi != C
VD_cmp_lt0indIndizes der Elemente Xi < 0
VE_cmp_geVindIndizes der Elemente Xi >= Yi

Während die eben beschriebenen einfachen Vergleichsfunktionen nur bezüglich einer einzigen Grenze testen, existieren einige Funktionen, die feststellen, ob Vektorelemente in einen bestimmten Bereich fallen:
 

VF_cmp_inclrange0C TRUE für 0 <= x <= C (C positiv),
0 >= x >= C (C negativ)
VF_cmp_exclrange0C TRUE für 0 < x < C (C positiv),
0 > x > C (C negativ)
VF_cmp_inclrangeCC TRUE für CLo <= x <= CHi
VF_cmp_exclrangeCC TRUE für CLo < x < CHi
VF_cmp_inclrange0Cind Indizes der Elemente 0 <= Xi <= C  (C positiv)
oder  0 >= Xi > C  (C negativ)
VF_cmp_exclrange0Cind Indizes der Elemente 0 < Xi < C  (C positiv)
oder  0 > Xi > C  (C negativ)
VF_cmp_inclrangeCCind Indizes der Elemente CLo <= Xi <= CHi
VF_cmp_exclrangeCCind Indizes der Elemente CLo < Xi < CHi

Um zu testen, ob sich in einer Tabelle bestimmte Werte finden, können die folgenden Funktionen benutzt werden:

VF_iselementC TRUE, wenn C ein Element der als Eingabevektor übergebenen Tabelle ist
VF_iselementV prüft für jedes Element von X, ob es in der Tabelle Tab enthalten ist

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home 

4.6.3 Direkte Bit-Manipulationen

Für die Ganzzahl-Datentypen steht eine Reihe von Bit-weisen Operationen zur Verfügung, die beispielsweise für schnelle Multiplikationen und Divisionen durch ganzzahlige Potenzen von 2 eingesetzt werden können:
VI_shlBits nach links schieben
VI_shrBits nach rechts schieben
VI_orOR-Operation mit Bit-Maske
VI_xorXOR-Operation mit Bit-Maske
VI_notalle Bits invertieren

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home

4.6.4 Arithmetische Grundfunktionen, Akkumulation

VectorLib stellt die im folgenden aufgeführten Arithmetik-Funktionen in vektorisierter Form zur Verfügung, wobei hier nur die VF_-Version explizit genannt wird. Die VD_- und VE_- Versionen existieren natürlich ebenfalls und – wo immer dies sinnvoll ist – auch komplexe und Ganzzahl-Versionen.
VF_negYi = - Xi
VF_absYi = | Xi |
VCF_conjYi.Re = Xi.Re; Yi.Im = -(Xi.Re)
VF_invYi = 1.0 / Xi
 
VF_equCXi = C
VF_addCYi = Xi + C
VF_subCYi = Xi - C
VF_subrCYi = C - Xi
VF_mulCYi = Xi * C
VF_divCYi = Xi / C
VF_divrCYi = C / Xi
VF_modCYi = Xi mod C
VF_equVYi = Xi
VF_addVZi = Xi + Yi
VF_subVZi = Xi - Yi
VF_subrVZi = Yi - Xi
VF_mulVZi = Xi * Yi
VF_divVZi = Xi / Yi
VF_divrVZi = Yi / Xi
VF_modVZi = Xi mod Yi
VF_add2VZi = Xi + Y1i + Y2i
VF_sub2VZi = Xi - Y1i - Y2i

Neben diesen Grundfunktionen sind auch häufig gebrauchte Kombinationen von Addition und Division sowie die Pythagoras-Formel aufgenommen:
 

VF_hypCYi = Xi / (Xi + C)
VF_redCYi = (Xi * C) / (Xi + C)
VF_visCYi = (Xi - C) / (Xi + C)
VF_hypotCYi = sqrt( Xi² + C² )
VF_hypVZi = Xi / (Xi + Yi)
VF_redVZi = (Xi * Yi) / (Xi + Yi)
VF_visVZi = (Xi - Yi) / (Xi + Yi)
VF_hypotVZi = sqrt( Xi² + Yi²)

Alle Funktionen in der rechten Kolumne der obigen beiden Abschnitte existieren zusätzlich noch in erweiterter Form. Diese wird durch durch das Präfix "VFx_" angegeben (das "x" stammt aus der englischen Bezeichnung "expanded"). Hier wird die jeweilige Funktion nicht für Xi selbst, sondern für (a * Xi + b) berechnet, z.B.
 

VFx_addV Zi = (a * Xi + b) + Yi
VFx_divrV Zi = Yi / (a * Xi + b)

Für die vier Grundrechenarten existiert noch eine weitere Spezialform, bei der das Ergebnis mit einem konstanten Faktor multipliziert wird. Diese "skalierte" Version wird durch den zusätzlichen Buchstaben "s" im Präfix angegeben:
 

VFs_addV Zi = C * (Xi + Yi)
VFs_subV Zi = C * (Xi - Yi)
VFs_mulV Zi = C * (Xi * Yi)
VFs_divV Zi = C * (Xi / Yi)

Unter den weiteren einfachen arithmetischen Operationen seien genannt:
 

VF_maxCsetzt Yi gleich Xi oder C, je nachdem, welcher von beiden Werten der größere ist
VF_minCwählt den kleineren Wert aus Xi und C
VF_maxVwählt den größeren Wert aus Xi und Yi und speichert ihn als Zi
VF_minVwählt den kleineren Wert aus Xi und Yi und speichert ihn als Zi
VF_limitführt eine Begrenzung des Zahlenbereiches durch
VF_flush0setzt alle Werte unterhalb eines als Parameter übergebenen Absolut-Schwellenwertes gleich 0
VF_intfracspaltet Zahlen in ihre Ganzzahl- und Bruchzahl-Anteile auf
VF_mantexptrennt Zahlen in Mantisse und Exponent

Während allgemein alle OptiVec-Funktionen Ein- und Ausgabe-Vektoren desselben Datentyps verarbeiten, existieren die arithmetischen Funktionen auch für "gemischte" Operationen zwischen Fließkomma- und Ganzzahltypen, wobei das Ergenis stets in dem Fließkomma-Typ gespeichert wird, z.B.:
 

VF_addVIfVector Z = fVector X + iVector Y
VD_mulVULdVector Z = dVector X * ulVector Y
VE_divrVBIeVector Z = biVector Y / eVector X

In ähnlicher Weise existieren Funktionen für die Akkumulation von Daten in entweder demselben oder in höher-genauen Datentypen. Diese Funktionen entsprechen der Operation Y += X. Beispiele sind:
 

VF_accVfVector Y += fVector X
VD_accVFdVector Y += fVector X
VF_accVIfVector Y += iVector X
VQI_accVLIqiVector Y += liVector X

Innerhalb der Fließkomma-Datentypen besteht zusätzlich die Möglichkeit, gleich zwei Vektoren auf einmal zu akkumulieren:

VF_acc2VfVector Y += fVector X1 + fVector X2
VD_acc2VFdVector Y += fVector X1 + fVector X2

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home 

4.6.5 Geometrische Vektor-Arithmetik

Im geometrischen Sinne ist ein Vektor ein Zeiger auf einen Punkt im n-dimensionalen Raum, wobei die Elemente des Vektors die Koordinaten dieses Punktes angeben. VectorLib enthält einige Funktionen, die sich auf diese Interpretation von Vektoren beziehen:
 
VF_scalprod Skalarprodukt zweier Vektoren
VF_xprod Vektor- oder Kreuzprodukt zweier Vektoren
VF_Euclid Euclid'sche Norm eines Vectors

Werden andererseits die Koordinaten mehrerer Punkte in einer Ebene entweder in zwei getrennten Vektoren X und Y oder in einem komplexen Vektor gespeichert, so existiert eine Funktion zur Rotation dieser Koordinaten:

VF_rotateCoordinates Rotation der durch zwei Vektoren X und Y angegebenen Koordinaten mehrer Punkte in einer Ebene gegen den Uhrzeigersinn; die neuen Koordinaten werden als Xrot und Yrot gespeichert.
VCF_rotateCoordinates Rotation der durch Real- und Imaginärteil des komplexen Vektors XY angegebenen Koordinaten mehrer Punkte in einer Ebene gegen den Uhrzeigersinn; die neuen Koordinaten werden als Real- und Imaginärteil des komplexen Vektors XYrot gespeichert.

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home 

4.6.6 Potenzen

Die folgenden Funktionen erheben Vektoren von Eingabedaten in bestimmte Potenzen. Während die "normalen" Versionen eine volle Fehlerbehandlung für optimale Sicherheit durchführen, können die schnellen "ungeschützten" Versionen in Situationen eingesetzt werden, wo man absolut sicher ist, daß alle Eingabe-Elemente gültige Ergebnisse liefern. Da die Abwesenheit von Fehlerprüfungen hier eine viel effizientere Vektorisierung erlaubt, sind diese Funktionen bis zu 1,8 mal so schnell wie die geschützten Versionen (dies gilt allerdings nur ab der Pentium-CPU, während auf älteren Computern praktisch kein Geschwindigkeitsvorteil erzielt wird). Man sei sich allerdings des Risikos bewußt: Ein eventueller Überlauf wird zum Absturz ohne Vorwarnung führen.
 
Normalversionungeschützte VersionOperation
VF_squareVFu_squareQuadrat
VF_cubicVFu_cubicKubik
VF_quarticVFu_quarticvierte Potenz
VF_ipowVFu_ipowbeliebige ganzzahlige Potenzen
VF_pown.a.beliebige reelle Potenzen
VF_powexpn.a.reelle Potenzen, multipliziert mit Exponentialfunktion: xrexp(x)
VF_polyVFu_polyPolynom
 

Während bei allen eben genannten Funktionen spezifizierte Potenzen beliebiger Zahlen erhalten werden, ist es bei der nun folgenden Gruppe von Funktionen umgekehrt:
 

VF_pow10 reelle Potenzen von 10
VF_ipow10 ganzzahlige Potenzen von 10 (als Fließkomma-Zahlen gespeichert)
VF_pow2 reelle Potenzen von 2
VF_ipow2 ganzzahlige Potenzen von 2 (als Fließkomma-Zahlen gespeichert)
VF_exp Exponentialfunktion
VF_exp10 Exponentialfunktion zur Basis 10 (identisch mit VF_pow10)
VF_exp2 Exponentialfunktion zur Basis 10 (identisch mit VF_pow2)
VF_expArbBase Exponentialfunktion zu beliebiger Basis
VF_sqrt Quadratwurzel (entspricht Potenz 0.5)
 
Alle diese Funktionen existieren auch in der erweiterten "VFx_"-Form, wie z.B.
VFx_square: Yi = (a * Xi + b)² 
Die erweiterte Form der ungeschützten Funktionen hat das Präfix VFux_.

Die äquivalenten Funktionen für komplex-zahlige Vektoren sind ebenfalls vorhanden, sowohl für cartesische als auch in Polarkoordinaten. Zusätzlich werden zwei Spezialfälle behandelt:
 

VCF_powReExpo reelle Potenzen komplexer Zahlen
VCF_exptoP übernimmt einen cartesischen Eingabevektor und gibt dessen Exponentialfunktion in Polarkoordinaten zurück

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home 

4.6.7 Exponential- und Hyperbel-Funktionen

Eine ganze Gruppe von Funktionen läßt sich auf die Exponentialfunktion zurückführen, aus der sie durch verschiedene einfache Operationen gewonnen wird.
 
VF_exp Exponentialfunktion
VF_expc komplementäre Exponentialfunktion Yi = 1 - exp[ Xi ]
VF_expmx2 Exponentialfunktion des negativen Quadrates des Arguments: Yi = exp[ - X2i ].
Dies ist eine glockenförmige Funktion ähnlich der Gauss-Funktion
VF_Gauss Gauss'sche Verteilungsfunktion
VF_erf Gauss'sches Fehlerintegral
VF_erfc Komplement des Gauss'schen Fehlerintegrals, 1 - erf( Xi )
VF_powexpn.a.reelle Potenzen, multipliziert mit Exponentialfunktion, Xirexp(Xi)
 
Die vektorisierten Formen der Hyperbel-Funktionen werden zur Verfügung gestellt durch:
VF_sinh Hyperbel-Sinus
VF_cosh Hyperbel-Cosinus
VF_tanh Hyperbel-Tangens
VF_coth Hyperbel-Cotangens
VF_sech Hyperbel-Secans
VF_cosech Hyperbel-Cosecans
VF_sech2 Quadrat des Hyperbel-Secans

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home 

4.6.8 Logarithmen

VF_log10 dekadischer Logarithmus (zur Basis 10)
VF_log natürlicher Logarithmus (zur Basis e)
VF_ln Synonym für VF_log
VF_log2 binärer Logarithmus (zur Basis 2)
 
Auch hier existieren die cartesisch-komplexen Versionen. Die polar-komplexen Versionen stellen aber insofern eine Besonderheit dar, als sie das Ergebnis stets in cartesischen Koordinaten zurückgeben:
VPF_log10toC dekadischer Logarithmus (zur Basis 10)
VPF_logtoC natürlicher Logarithmus (zur Basis e)
VPF_lntoC Synonym für VPF_logtoC
VPF_log2toC binärer Logarithmus (zur Basis 2)

Als Sonderform des Zehner-Logarithmus ist die Formel für die Optische Dichte, OD = log10( X0/X ) anzusehen. Aufgrund ihrer Bedeutung in der experimentellen naturwissenschaftlichen Arbeit ist sie hier in mehreren Varianten aufgenommen, von denen einige Beispiele in der folgenden Tabelle zusammengefaßt sind: 

VF_ODOD = log10( X0/X ) für fVector als Eingabe und als Ausgabe
VF_ODwDarkOptische Dichte mit Dunkelstrom-Korrektur:
OD = log10( (X0-X0Dark) / (X-XDark) ) für fVector als Eingabe und als Ausgabe
VUS_ODtoFOD in float / Single-Genauigkeit für usVector als Eingabe
VUL_ODtoDOD in double-Genauigkeit für ulVector als Eingabe
VQI_ODtoEwDarkOD mit Dunkelstrom-Korrektur in extended-Genauigkeit für qiVector als Eingabe

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home 

4.6.9 Trigonometrische Funktionen

Einige der trigonometrischen Funktionen existieren in zwei Varianten. Die erste Variante folgt den üblichen Regeln der Fehlerbehandlung mathematischer Funktionen. Die zweite Variante ist für Situationen, in denen man mit Sicherheit weiß, daß alle Eingabewerte in den Bereich -2p <= Xi <= +2p fallen. Diese "Funktionen mit reduziertem Eingabe-Bereich" arbeiten deutlich schneller als die Normalvariante. Sie werden allerdings ohne Vorwarnung abstürzen, falls sich doch ein Eingabewert außerhalb des genannten Bereiches befindet. Da alle übrigen trigonometrischen Funktionen selbst für Argumente innerhalb dieses Bereiches ohnehin eine Bereichsprüfung und Fehlerbehandlung durchführen müssen, existieren die Varianten mit reduziertem Eingabe-Bereich derzeit nur für den Sinus und den Cosinus.
 
VF_sinSinus
VFr_sinschnelle Sinus-Funktion für den reduzierten Eingabe-Bereich -2p <= Xi <= +2p
VF_cosCosinus
VFr_cosschnelle Cosinus-Funktion für -2p <= Xi <= +2p
VF_sincosgleichzeitige Berechnung von Sinus und Cosinus
VFr_sincosSinus und Cosinus für -2p <= Xi <= +2p
VF_tanTangens
VF_cotCotangens
VF_secSecans
VF_cosecCosecans

Die Quadrate der trigonometrischen Funktionen werden gebildet durch:
 

VF_sin2Sinus²
VFr_sin2Sinus² für -2p <= Xi <= +2p
VF_cos2Cosinus²
VFr_cos2Cosinus² für -2p <= Xi <= +2p
VF_sincos2Sinus² und Cosinus² gleichzeitig
VFr_sincos2Sinus² und Cosinus² für -2p <= Xi <= +2p
VF_tan2Tangens²
VF_cot2Cotangens²
VF_sec2Secans²
VF_cosec2Cosecans²
 
Ein sehr effizienter Weg zur Berechnung trigonometrischer Funktionen für Argumente, die sich als gebrochenzahlige Vielfache von p (PI) darstellen lassen, wird durch die Funktionen mit dem Suffix "rpi" (für "rationale Vielfache von p") bereitgestellt. Hier ist r = p / q, wobei q konstant und p durch die Eingabevektor-Elemente gegeben ist:
 
VF_sinrpiSinus von p/q * p
VF_cosrpiCosinus von p/q * p
VF_sincosrpiSinus und Cosinus von p/q * p at once
VF_tanrpiTangens von p/q * p
VF_cotrpiCotangens von p/q * p
VF_secrpiSecans von p/q * p
VF_cosecrpiCosecans von p/q * p

Spezialisierte Versionen gebrauchen Tabellen, um häufig vorkommende Werte direkt zu lesen, anstatt sie berechnen zu müssen. Die werden durch die Suffixe "rpi2" (Vielfache von p dividiert durch eine ganzzahlige Potenz von 2) und "rpi3" (Vielfache von p dividiert durch ein ganzzahliges Vielfaches von 3) bezeichnet. Beispiele sind:
 

VF_sinrpi2 Sinus von p / 2n * p
VF_tanrpi3 Tangens von p / (3*n) * p

Zwei spezielle trigonometrische Funktionen sind: 

VF_sinc Sinc-Funktion, Yi = sin( Xi ) / Xi
VF_Kepler Kepler-Funktion (zeitabhängige Winkelposition eines Himmelskörpers nach dem Zweiten Keplerschen Gesetz bei gegebener Umlaufzeit und Exzentrizität)

Vektorisierte inverse trigonometrische Funktionen (die "Arcus"-Funktionen) stehen zur Verfügung als: 

VF_asinArcus-Sinus
VF_acosArcus-Cosinus
VF_atanArcus-Tangens
VF_atan2 Arcus-Tangens von Quotienten, Zi = atan( Yi / Xi )

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home 

4.7 Analysis

Es gibt eine ganze Reihe von Funktionen zur Bestimmung analytischer Eigenschaften von Datensätzen:
 
VF_derivV Ableitung eines Y-Arrays nach einem X-Array
VF_derivC desgleichen für konstante Intervalle zwischen den X-Werten
VF_integralV Wert des Integrals eines Y-Arrays über einem X-Array
VF_runintegralV Punkt-für-Punkt-Integral ("laufendes" Integral)
VF_integralC Integral über einer X-Achse mit konstantem Punktabstand
VF_runintegralC Punkt-für-Punkt-Integral über einer X-Achse mit konstantem Punktabstand
VF_ismonoton Test, ob sich die Elemente eines Vektors in monoton steigender oder fallender Anordnung befinden
VF_iselementC Test, ob ein gegebener Wert in einem Vektor auftaucht
VF_searchC Bestimmung des einem vorgegebenen Wert C am nächsten kommenden Eintrages in einer Tabelle
VF_localmaxima Detektion lokaler Maxima (Punkte, deren rechter und linker Nachbar kleiner sind)
VF_localminima Detektion lokaler Minima (Punkte, deren rechter und linker Nachbar größer sind)
VF_max globales Maximum
VF_min globales Minimum
VF_maxind globales Maximum und sein Index
VF_minind globales Minimum und sein Index
VF_absmax globales Absolutwert-Maximum
VF_absmin globales Absolutwert-Minimum
VF_absmaxind global größter Absolutwert und sein Index
VF_absminind global kleinster Absolutwert und sein Index
VF_maxexp global größter Exponent
VF_minexp global kleinster Exponent
VF_runmax "laufendes" Maximum
VF_runmin "laufendes" Minimum

Die komplexen Äquivalente der zuletzt genannten Gruppe von Funktionen sind:
 

VCF_maxReIm größter Real- und größter Imaginärteil einzeln
VCF_minReIm kleinster Real- und kleinster Imaginärteil einzeln
VCF_absmaxReIm betragsmäßig größter Real- und Imaginärteil einzeln
VCF_absminReIm betragsmäßig kleinster Real- und Imaginärteil einzeln
VCF_absmax größter Absolutwert (Zeigerlänge; dies ist eine reelle Zahl)
VCF_absmin kleinster Absolutwert (Zeigerlänge)
VCF_cabsmax komplexe Zahl mit dem größten Absolutwert
VCF_cabsmin komplexe Zahl mit dem kleinsten Absolutwert
VCF_sabsmax komplexe Zahl mit der größten Summe |Re| + |Im|
VCF_sabsmin komplexe Zahl mit der kleinsten Summe |Re| + |Im|
VCF_absmaxind größter Absolutwert und sein Index
VCF_absminind kleinster Absolutwert und sein Index

Summen, Produkte usw. werden durch die in chapter 4.9 als Statistik-Funktionen zusammengefaßten Routinen gebildet.

Zur Berechnung des Schwerpunktes eines Vektors stehen zwei Funktionen zur Verfügung:
 

VF_centerOfGravityIndSchwerpunkt eines Vektors in Form eines interpolierten Element-Indexes
VF_centerOfGravityVSchwerpunkt eines Y-Vektors bei explizit gegebener X-Achse

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home 

4.8 Signalverarbeitung:
Fourier-Transformations-Techniken

Die folgenden Funktionen dienen der Signalverarbeitung mittels Fourier-Transformation:
 
VF_FFTtoC Schnelle Fourier-Transformation (FFT) eines reellen Vektors; das Ergebnis ist ein cartesisch-komplexer Vektor
VF_FFT Vorwärts- und Rückwärts-FFT reeller Vektoren; das Ergebnis der Vorwärts-Transformation ist ein gepackt-komplexer Vektor derselben Speicher-Größe wie der Eingabevektor.
VCF_FFT Vorwärts- und Rückwärts-FFT komplexer Vektoren
VF_convolve Faltung mit einer gegebenen Impulsantwortfunktion
VF_deconvolve Entfaltung unter Annahme einer gegebenen Impulsantwortfunktion
VF_filter spektrale Filterung
VF_spectrum spektrale Analyse
VF_autocorr Autokorrelationsfunktion eines Datensatzes
VF_xcorr Kreuzkorrelationsfunktion zweier Datensätze
VF_setRspEdit Editierschwelle für den intermediär bei Faltungen und Entfaltungen berechneten Filter setzen (entscheidet über die Behandlung "verlorener" Frequenzen)
VF_getRspEdit derzeit eingestellte Editierschwelle lesen

Bei der hier gewählten Implementation handelt es sich um einen Radix-2-Cooley-Tukey-Algorithmus. Obwohl theoretisch effizienter, lassen sich Radix-4- und Radix-8-Algorithmen aufgrund der beschränkten Anzahl von Fließkomma-Registern auf PC-Systemen nicht so effizient implementieren wie der gewählte Algorithmus.
Aus historischen Gründen existieren drei Versionen aller auf FFT basierenden Funktionen. Die jeweils effizienteste wird automatisch gewählt. Man kann die gewünschte Version aber auch spezifizieren.

  • Bei der ersten Version wird die im Zusammenhang mit trigonometrischen Funktionen erwähnte Tabelle der Sinus-Werte verwandt, um die benötigten Fourier-Koeffizienten zu bestimmen. Diese Tabelle nimmt bis zu 40 kByte Speicherplatz in Anspruch. Um sie explizit zu spezifizieren, benutze man die Präfixe VFl_,  VDl_,  VEl_.
  • Die zweite Variante verwendet zur Bestimmung der Koeffizienten Rekursionsformeln und ist etwas langsamer. Sie wird durch den zusätzlichen Buchstaben "s" im Präfix explizit spezifiziert: VFs_FFT,   VDs_convolve,   VEs_spectrum. Wenn sie diese Variante wählen wollen, müssen Sie das Präfix VFs_ für alle(!) auf FFT zugreifenden Funktionen verwenden. Andernfalls laden Sie nicht nur eine zusätzliche Funktion, sondern auch noch die gesamte Tabelle unnötigerweise in den Speicher.
  • Die "parallelisierte" Variante mit dem Präfix VFp_ schließlich benutzt zusätzlichen Speicherplatz, um den Eingangsvektor so umzuordnen, daß sowohl Cache-Ausnutzung als auch (in den Pentium III-Bibliotheken) der Einsatz von SIMD-Befehlen optimiert werden können. Die Mindestgröße des Eingangsvektors ist 16. Darunter geben die VFp_-Funktionen den Aufruf augomatisch an die VFs_ Funktionen weiter. Für Vektoren mittlerer Größe ist die VFp_-Version ca. 20% schneller als die anderen beiden Varianten. Für große Vektoren (d.h. größer als der L2-Cache) steigt der Gewinn ungefähr auf einen Faktor von 1,8. Die analoge 2D-FFT für Matrizen – wo die zu erzielende Parallelität logischerweise noch größer ist – ergiebt sich ein Geschwindigkeitsvorteil von ungefähr einem Faktor 2.5 (alle Angaben für die Pentium III-Bibliotheken gemessen; mit den 486DX-Bibliotheken beträgt der Gewinn noch 10% für mittelgroße Vektoren, bis zu einem Faktor 1.6 für große Vektoren und ca. 30% für Matrizen). Für extrem große Vektoren nahe oder oberhalb des zur Verfügung stehenden RAM-Speichers bremst die Notwendigkeit des zusätzlichen (dann virtuellen!) Speicherplatzes die VFp_-Version allerdings wieder auf das Niveau der VFs_-Version ab. Ab einer Datentyp-abhängigen Mindestgröße der verarbeiteten Vektoren wird automatisch diese VFp_-Version gewählt.

Da alle auf FFT basierenden Matrix-Funktionen intern VF_FFT aufrufen, existieren sie alle ebenfalls in drei Varianten. Die Präfixe sind hier MFs_, MFl_ und MFp_ im Falle reeller Matrizen sowie MCFs_, MCFl_ und MCFp_ für komplexe Matrizen. Ähnlich wie im eindimensionalen Fall leiten die Funktionen mit dem "normalen" Präfix (MF_,  MCF_) den Aufruf automatisch je nach Speichermodell an die jeweils bestgeeignete Variante weiter.

Obwohl sie keine Fourier-Transformation benutzen, sollen in diesem Zusammenhang die Funktionen VF_biquad für bi-quadratische Audio-Filterung sowie VF_smooth (engl. to smooth = glätten) als einer etwas groben Form der Frequenzfilterung genannt werden.

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home 

4.9 Statistische Funktionen und Bausteine

OptiVec bietet die folgende Kollektion von Statistik-Funktionen:
 
VF_sum Summe aller Elemente
VI_fsum Summe aller Elemente eines Ganzzahl-Vektors, die als Fließkommazahl in double- oder extended- Genauigkeit akkumuliert wird
VF_prod Produkt aller Elemente
VF_ssq Quadratsumme aller Elemente
VF_sumabs Summe der Absolutwerte aller Elemente
VF_rms Wurzel des mittleren Quadrats aller Elemente
VF_runsum laufende Summe
VF_runprod laufendes Produkt
VF_sumdevC Summe der Abweichungen von einem Sollwert, Summe( |Xi-C| )
VF_sumdevV Summe der Abweichungen von einem anderen Vektor, Summe( |Xi-Yi| )
VF_avdevC mittlere Abweichung von einem Sollwert, 1/N * Summe( |Xi-C| )
VF_avdevV mittlere Abweichung von einem anderen Vektor, 1/N * Summe( |Xi-Yi| )
VF_ssqdevC Quadratsumme der Abweichungen von einem Sollwert,
Summe( (Xi - C)² )
VF_ssqdevV Quadratsumme der Abweichungen von einem anderen Vektor,
Summe( (Xi - Yi)² )
VF_chi2 Chi-Quadrat-Testwert
VF_chiabs "robuster" Testwert ähnlich VF_chi2, aber auf absoluten statt auf quadratischen Abweichungen basierend
VF_mean gleichgewichtetes Mittel (Durchschnitt) aller Elemente
VF_meanwW gewichtetes Mittel
VF_meanabs gleichgewichtetes Mittel aller Absolutwerte
VF_selected_mean Mittel über diejenigen Vektorelemente, die in einen bestimmten Wertebereich fallen; hierdurch lassen sich Ausreißerpunkte von der Mittelwertbildung ausschließen
VF_varianceC Varianz einer Verteilung bezüglich eines Sollwertes
VF_varianceCwW desgl. mit Einzelpunkt-Wichtung
VF_varianceV Varianz einer Verteilung bezüglich einer zweiten
VF_varianceVwW desgl. mit Einzelpunkt-Wichtung
VF_meanvar Mittelwert und Varianz einer Verteilung
VF_meanvarwW desgl. mit Einzelpunkt-Wichtung
VF_median Median einer Verteilung
VF_corrcoeff linearer Korrelationskoeffizient zweier Verteilungen
VF_distribution diskrete eindimensionale Verteilungsfunktion einer eindimensionalen Verteilung
VF_min_max_mean_stddev gleichzeitige Berechnung von Minimum, Maximum, Mittelwert und Standardabweichung einer eindimensionalen Verteilung

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home 

4.10 Datenanpassung

Von linearer Regression bis hin zu komplexen Anpassungsproblemen mit mehreren Datensätzen und nichtlinearen Modellfunktionen mit vielen freien Parametern bietet OptiVec eine breite Palette von Routinen für fast alle praktisch vorkommenden Datenanpassungs-Aufgaben. Da sie alle, mit Ausnahme der einfachen linearen Regression, auf Matrix-Methoden basieren, gehören sie zu MatrixLib. Dies bedeutet, daß man die Include-Dateien <MFstd.h> (<MDstd.h>< MEstd.h>) oder die Units MFstd, (MDstd, MEstd) einschließen muß, um sie benutzen zu können.

Eine detaillierte Beschreibung der verschiedenen Konzepte zur Datenanpassung an die unterschiedlichen Klassen von Modellfunktionen wird in Kap. 13 von http://www.optivec.de/matfuncs/M gegeben. Daher genüge an dieser Stelle eine tabellarische Zusammenfassung der vorhandenen X-Y-Anpassungsroutinen:
 

VF_linregress lineare Regression von X-Y-Daten mit gleicher Wichtung aller Datenpunkte
VF_linregresswW dasselbe mit ungleicher Wichtung
VF_polyfit Koeffizienten eines Polynoms an vorhandene X-Y-Daten anpassen
VF_polyfitwW dasselbe mit ungleicher Wichtung der Datenpunkte
VF_linfit Koeffizienten einer beliebigen, in ihren Parametern linearen Funktion an vorhandene X-Y-Daten anpassen
VF_linfitwW dasselbe mit ungleicher Wichtung der Datenpunkte
VF_nonlinfit Koeffizienten einer beliebigen, möglicherweise nicht-linearen Funktion an vorhandene X-Y-Daten anpassen
VF_nonlinfitwW dasselbe mit ungleicher Wichtung der Datenpunkte
VF_multiLinfit mehrere X-Y-Datensätze gleichzeitig an eine gemeinsame lineare Funktion anpassen
VF_multiLinfitwW dasselbe mit ungleicher Wichtung der Datenpunkte
VF_multiNonlinfit mehrere X-Y-Datensätze gleichzeitig an eine gemeinsame nicht-lineare Funktion anpassen
VF_multiNonlinfitwW dasselbe mit ungleicher Wichtung der Datenpunkte

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home 

4.11 Input und Output

VF_cprint Ausdruck der Elemente eines Vektors auf dem Bildschirm (der "Konsole"; daher das "c" im Namen) im aktuellen Textfenster, wobei Höhe und Breite dieses Fensters automatisch detektiert und die Seiten umgebrochen werden (nur für DOS)
VF_print ähnlich VF_cprint; auch hier erfolgt die Ausgabe auf dem Bildschirm, aber ohne automatische Detektion der Bildschirmdaten. Es wird eine Standardbreite von 80 Zeichen angenommen. Ein Seitenumbruch findet nicht statt (d.h. alle Seiten laufen durch, bis die letzte schließlich stehenbleibt). (Nur DOS und EasyWin)
VF_fprint Ausgabe eines Vektors in einen Stream
VF_write Ablage von Daten im ASCII-Format auf Festplatte
VF_read liest einen Vektor aus einer ASCII-Datei ein
VF_nwrite schreibt n gleichartige Vektoren als Spalten einer Tabelle in eine ASCII-Datei
VF_nread liest die Spalten einer Tabelle in n gleichartige Vektoren ein
VF_store Speichern im Binärformat
VF_recall Einlesen im Binärformat

Die folgenden Funktionen modifizieren die Standardeinstellung für VF_write,   VF_nwrite und VI_read:
 

VF_setWriteFormat bestimmtes Ausgabeformat vorgeben
VF_setWriteSeparate Trennzeichen zwischen aufeinander folgenden Element für VF_write vorgeben
VF_setNWriteSeparate Trennzeichen zwischen den durch VF_nwrite geschriebenen Spalten definieren
V_setRadix für die ganzzahligen V.._read-Funktionen eine andere als die als Standard angenommene Basis 10 einstellen.

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home 

4.12 Graphik

VectorLib bietet eine Reihe von Funktionen zum Plotten von in Arrays vorliegenden Daten. Bevor eine der eigentlichen Plot-Funktionen aufgerufen werden kann, müssen die Graphik-Funktionen von VectorLib initialisiert werden:
 
V_initPlot Graphikfunktionen von VectorLib initialisieren (Windows und DOS). Es ist unter Windows nicht nötig, nach Gebrauch einen Abschluß durchzuführen, da V_initPlot nur Zahlenwerte initialisiert, aber keine Speicherreservierungen o.ä. durchführt und die Windows-Graphikfunktionen stets vorhanden bleiben. V_initPlot reserviert automatisch einen Bildschirmausschnitt für Plot-Operationen, der etwa die rechten 2/3 des Bildschirms umfaßt und oben noch Raum für eine Überschrift sowie unten ein paar Zeilen für eine Unterschrift freiläßt. Am unteren Rand bleiben einige Zeilen frei. Um die Standard-Einstellung zu ändern, rufe man V_setPlotRegion nach V_initPlot.
V_initGraph gleichzeitige Initialisierung des Borland-Graphik-Interface BGI und der VectorLib-Plotfunktionen (nur DOS). Dabei erfolgt automatisch der Aufruf der BGI-Initialisierungsroutine "initgraph" und sollte daher nicht wiederholt werden. Ist initgraph bereits aufgerufen worden, so verwende man statt V_initGraph die Funktion V_initPlot. Nach Abschluß der Arbeit mit den Graphik-Funktionen muß in den Textmodus zurückgeschaltet und Pufferspeicher freigegeben werden durch den Aufruf der BGI-Funktion closegraph.
V_initPrint Graphikfunktionen von VectorLib initialisieren und die Ausgabe auf einen Drucker umleiten (nur Windows). Standardmäßig wird eine ganze Seite zum Druck verwandt. Auch diese Einstellung läßt sich mit Hilfe von V_setPlotRegion nach V_initPrint ändern.
V_setPlotRegion Definition eines von der automatischen Wahl abweichenden Fensterausschnitts

VectorLib unterscheidet zwei Arten von Plot-Funktionen: AutoPlot und DataPlot. Alle AutoPlot-Funktionen (z.B. VF_xyAutoPlot) führen die folgenden Schritte durch:

  1. Definition eines geeigneten Viewports innerhalb des standardmäßig eingestellten oder mittels V_setPlotRegion gewählten Fensterausschnitts
  2. Löschen des vorhandenen Viewport-Inhalts
  3. Erzeugung eines cartesischen Koordinatensystems mit geeigneter Achsenskalierung und -beschriftung
  4. Auftragung der Daten gemäß den an die jeweilige Funktion übergebenen Parametern
Alle DataPlot-Funktionen führen lediglich den letzten dieser Schritte durch, d.h. sie gehen davon aus, daß ein Koordinatensystem bereits existiert, und zwar von einem Aufruf einer AutoPlot-Funktion, von V_findAxes, oder von V_drawAxes. In dieses Koordinatensystem erfolgt die gewünschte Auftragung. Alle Einstellungen des Koordinatensystems müssen hierfür noch gültig sein. Es darf also nicht inzwischen ein anderer Viewport definiert worden sein, und die Skalierung der Achsen muß auch für die hinzukommende Auftragung "passen".
To add text and lables, a new viewport must be defined. Use SetViewportOrgEx (32-bit Windows), SetViewportOrg (16-bit Windows), or setviewport (DOS).

If you wish to switch back into text mode in DOS, use restorecrtmode. After that, a new call to V_initPlot (not V_initGraph!) brings you back into graphics mode.

Um Text und Beschriftungen hinzuzufügen, sollte ein neuer Viewport definiert werden. Hierzu verwende man SetViewportOrgEx (32-bit Windows), SetViewportOrg (16-bit Windows) oder setviewport (DOS). Andernfalls werden alle Positionsangaben von der linken oberen Ecke des gezeichneten Koordinatensystems aus gerechnet.

Um unter DOS in den Textmodus zurückzuschalten, gebrauche man restorecrtmode. Erneuter Aufruf von V_initPlot (nicht V_initGraph!) führt danach wieder in den Graphik-Modus.
Die verschiedenen Darstellungs-Optionen (Symbole, Linien und Farben) werden als Parameter beim Aufruf der jeweiligen Funktion spezifiziert, siehe VF_xyAutoPlot. Hier folgt eine Liste der vorhandenen AutoPlot- und DataPlot-Routinen:
 

VF_xyAutoPlot automatisch skalierter Plot eines X-Y-Vektor-Paares
VF_yAutoPlot automatisch skalierter Plot eines Y-Vektors gegen den als X-Achse verwendeten Element-Index
VF_xy2AutoPlot gleichzeitige Auftragung zweier X-Y-Paare, wobei die Achsenskalierung sicherstellt, daß beide in dasselbe Koordinatensystem passen
VF_y2AutoPlot desgl. für zwei gegen ihre Indizes aufgetragene Y-Vektoren
VF_xyDataPlot zusätzlichen X-Y-Datensatz auftragen
VF_yDataPlot zusätzlichen Y-Vektor gegen seinen Index auftragen

Vektoren aus cartesisch-komplexen Zahlen werden in der komplexen Ebene dargestellt, d.h. die Imaginärteile gegen die Realteile aufgetragen. Hierzu dienen
 

VCF_autoPlot Auftragung eines cartesisch-komplexen Vektors
VCF_2AutoPlot gleichzeitige Auftragung zweier komplexer Vektoren
VCF_dataPlot Hinzufügung eines weiteren komplexen Vektors zu einer bestehenden Auftragung

Funktionen zur Auftragung polar-komplexer Vektoren sind derzeit nicht enthalten.
Es ist möglich, mehrere Koordinatensysteme in ein-und-dasselbe Fenster zu zeichnen. Die Position jedes Koordinatensystems muß über die oben erwähnte Funktion V_setPlotRegion spezifiziert werden. Dem Umschalten zwischen ver- schiedenen Koordinatensystemen (z.B. um neue DataPlots hinzuzufügen) dienen die folgenden Funktionen:
 

V_continuePlot Wiederherstellung des zuletzt für einen Plot verwendeten Viewports und der zugehörigen Achsen-Skalierungen
V_getCoordSystem Speichern der Position und Skalierungen eines Koordinatensystems
V_setCoordSystem Wiederherstellung von Position und Skalierungen eines Koordinatensystems. Diese müssen zuvor mittels V_getCoordSystem gespeichert worden sein.

nur DOS:
Wenn mehrere Koordinatensysteme gleichzeitig auf dem Bildschirm dargestellt werden, ist meistens der für die Achsenbeschriftung verwendete Standard-Schriftsatz zu groß, so daß es zum Überlappen benachbarter Zahlen kommt. In diesem Fall verwenden Sie bitte die BGI-Funktion settextstyle, um auf einen anderen Schriftsatz umzuschalten, bevor Sie eine AutoPlot-Funktion aufrufen.

Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home 

Fortsetzung: Kap. 5. Fehlerbehandlung
Zurück zum VectorLib-Inhaltsverzeichnis     OptiVec Home 

Copyright © 1998-2016 OptiCode – Dr. Martin Sander Software Development

Letzte Aktualisierung: 18. Oktober 2016