| OptiVec Version 8
für C/C++ und für Pascal / Delphi
|
OptiCode
Dr. Martin Sander Software-Entwicklung
Brahmsstr. 6
D-32756 Detmold
http://www.optivec.de
e-mail: optivec@gmx.de
| Teil II: MatrixLib
|
Eine allgemeine Beschreibung von OptiVec finden Sie in HANDBUCH.HTM.
Kap. 1.2 dieser Datei enthält die Lizenzbedingungen der Shareware-Version, Kap. 1.3 diejenigen der registrierten Vollversion.
FUNKREF.HTM beschreibt die einzelnen VectorLib-Funktionen
und CMATHD.HTM die komplexen Funktionen von CMATH.
Inhaltsverzeichnis
1. Einführung
1.1 Matrix-Datentypen
1.2 Präfixe von MatrixLib-Funktionen
1.3 C/C++ -spezifisch
1.3.1 MatObj, das objekt-orientierte Interface für Matrix-Funktionen
1.3.2 Alternative Aufruf-Form von Matrix-Funktionen mit direkten Zeigern
1.4 Pascal/Delphi-spezifisch
2. Dynamische Allokation von Matrizen
3. Initialisierung von Matrizen
4. Datentyp-Umwandlungen
5. Symmetrie-Operationen (Transposition, Rotation, Spiegelung), Interpolation, Erweiterung, Verkleinerung, Extraktion sowie Initialisierung von Teilen von Matrizen
6. Arithmetische Operationen einer einzelnen Zeile, Spalte oder der Diagonalen
7. Operationen, die auf alle Zeilen oder alle Spalten gleichzeitig oder auf die Diagonale wirken; Berechnung des Schwerpunktes
8. Operationen von zwei Zeilen oder zwei Spalten
9. Arithmetik ganzer Matrizen: Addition und Multiplikation
10. Lineare Algebra
11. Eigenwerte und Eigenvektoren, Quadratwurzel
12. Fourier-Transform-Methoden
13. Datenanpassung (Fitting)
13.1 Polynome
13.2 Allgemeine lineare Modellfunktionen
13.3 Nicht-lineare Modelle
13.4 Anpassung von Mehrfach-Datensätzen
13.5 Hilfsfunktionen für nicht-lineare Anpassungen
13.6 Übersicht der Anpassungsfunktionen
14. Matrix-Eingabe und -Ausgabe
15. Graphische Darstellung von Matrizen
16. Alphabetische Referenz für MatrixLib
1. Einführung
Der MatrixLib-Teil von OptiVec baut auf den im VectorLib-Teil eingeführten Prinzipien auf. Sie sollten die Einführungskapitel von HANDBUCH.HTM gelesen haben, bevor Sie hier mit MatrixLib fortsetzen.
Zurück zum Inhaltsverzeichnis
1.1 Matrix-Datentypen
In Analogie zu den Vektor-Datentypen von VectorLib definiert MatrixLib die folgenden Matrix-Datentypen:
fMatrix | matrix of floats |
dMatrix | matrix of doubles |
eMatrix | matrix of extended (long double) |
cfMatrix | matrix of fComplex (complex<float>) |
cdMatrix | matrix of dComplex (complex<double>) |
ceMatrix | matrix of eComplex (complex<extended>) |
iMatrix | matrix of int |
uMatrix | matrix of unsigned int |
usw. | für alle weiteren Ganzzahl-Datentypen |
Die Speicher-Ordnung der Matrix-Elemente ist dieselbe wie in den zwei-dimensionalen Feldern des jeweiligen Compilers. Dies bedeutet, dass die MatrixLib-Versionen für C und C++ Matrizen zeilenweise speichern, während die Pascal/Delphi-Versionen mit spaltenweiser Ordnung arbeiten.
Wir empfehlen, in Ihren Programmen ausschließlich mit diesen dynamisch allozierten Matrizen zu arbeiten. Es ist aber möglich, statische Matrizen, die z.B. als
float MX[4][6]; (für C/C++), oder
MX: array[0..3][0..5] of Single; (für Pascal/Delphi)
definiert wurden, in allen MatrixLib-Funktionen zu verwenden. Die einzige Ausnahme stellen die multiLinfit-Funktionen und multiNonlinfit-Routionen dar.
Zurück zum Inhaltsverzeichnis
1.2 Präfixe von MatrixLib-Funktionen
Jede MatrixLib-Funktion besitzt ein Präfix, das den Datentyp anzeigt, den die betreffende Funktion verarbeitet:
Präfix: | Argumente: |
MF_ | fMatrix, float und fVector |
MD_ | dMatrix, double und dVector |
ME_ | eMatrix, extended (long double) und eVector |
MCF_ | cfMatrix, fComplex und cfVector |
MCD_ | cdMatrix, dComplex und cdVector |
MCE_ | ceMatrix, eComplex und ceVector |
MI_ | iMatrix, int und iVector |
MU_ | uMatrix, unsigned int und uVector |
| usw. für alle übrigen Ganzzahl-Datentypen |
In einigen Fällen wird das Präfix um einen Code aus drei Buchstaben erweitert, der spezielle Matrix-Eigenschaften anzeigt:
- MFdia_ bedeutet, dass die Funktion eine Diagonalmatrix erwartet, also eine quadratische Matrix mit Elementen ungleich 0 nur auf der Diagonalen. Da es für eine solche Matrix keinen Sinn macht, alle Nullen der Nicht-Diagonalelemente explizit zu speichern, wird eine Diagonalmatrix als Vektor gespeichert, der lediglich die Diagonalelemente enthält.
- MFsym_ zeigt eine Funktion an, die eine symmetrische Matrix als Argument erwartet. Zur Zeit machen nur MFsym_eigenvalues sowie MFsym_sqrt Gebrauch von dieser Annahme.
- MFtrd_ bedeutet eine Funktion einer Tridiagonalmatrix, also einer Quadratmatrix, die nicht-verschwindende Elemente nur auf der Diagonalen plus-minus einer Spalte besitzt. Eine tridiagonale Matrix wird als Matrix von drei Zeilen eingegeben. Diese drei Zeilen stellen die drei Vektoren dar, die tatsächlich Elemente ungleich Null besitzen. Die Original-Matrix
d0 | u0 | 0 | ··· | | |
l1 | d1 | u1 | 0 | ··· | |
0 | l2 | d2 | u2 | 0 | ··· |
| | | ··· | | |
| | | lN-2 | dN-2 | uN-2 |
| | | 0 | lN-1 | dN-1 |
wird also komprimiert in die Form
u0 | u1 | u2 | ··· | uN-2 | * |
d0 | d1 | d2 | ··· | dN-2 | dN-1 |
* | l1 | l2 | ··· | lN-2 | lN-1 |
Die mit einem Stern markierten Elemente l0 und uN-1, bleiben undefiniert und werden niemals benutzt.
Zurück zum Inhaltsverzeichnis
1.3 C/C++ -spezifisch:
1.3.1 MatObj, das objekt-orientierte Interface für Matrix-Funktionen
Analog zu den Vektor-Objekten von VecObj ist das objekt-orientierte Interface für die Matrix-Funktionen in den Include-Dateien <fMatObj.h>, <dMatObj.h> etc. implementiert, wobei jeder in OptiVec vorhandene Datentyp seine eigene Include-Datei erhält. Es sei aber daran erinnert, dass das gesamte Interface (für alle Vektor- und Matrix-Typen zusammen) durch Einschluß von <OptiVec.h> zur Verfügung gestellt wird.
Um irgendeine Vektor- oder Matrix-Graphikfunktion benutzen zu können, muss immer <OptiVec.h> eingeschlossen werden.
Ähnlich den Alias-Namen der Vektor-Objekte erhalten die Matrix-Objekte die Alternativ-Namen fMatObj, dMatObj usw., wobei wie immer der Datentyp durch die ersten ein oder zwei Buchstaben des Klassen-Namens angegeben wird.
Die Matrix-Konstruktoren sind:
matrix(); // kein Speicher zugewiesen; Dimensionen auf 0 gesetzt
matrix( ui ht, ui len ); // [ht * len] Matrix erzeugt
matrix( ui ht, ui len, T fill ); // desgleichen, aber mit "fill" initialisiert
matrix( matrix <T> init ); // erzeugt eine Kopie der Matrix "init"
Für die Matrix-Klassen sind die arithmetischen Operatoren
+ - * += -= *=
definiert.
Während der Vektor-Vektor-Operator * sich auf die Element-weise Multiplikation bezieht, bedeuten der Operator * für Matrix-Matrix, Matrix-Vektor und Vektor-Matrix die "echte" Matrizen-Multiplikation.
Sollten Sie einmal in die Lage kommen, ein MatObj-Matrixobjekt mit einer "klassischen" C-MatrixLib-Funktion verarbeiten zu wollen, benutzen Sie bitte die Member-Funktionen
getHt() und getLen(), um die Dimensionen auszulesen,
getMatrix für den Matrix-Zeiger vom Datentyp fMatrix usw., oder
getM0, um den Vektor M[0] vom Datentyp fVector usw. zu erhalten.
Die Syntax aller MatObj-Funktionen wird unten bei allen MatrixLib-Funktionen mit angegeben, so weit sie von tMatObj gekapselt werden.
Die strikte Kontrolle der Matrix-Dimensionen auf Konsistenz führt zu einigen Besonderheiten gegenüber den "normalen" MF_-Funktionen:
- Mit den MF_-Funktionen ist is möglich, eine große Matrix als Zwischenspeicher für kleinere Matrizen zu verwenden. Beispielsweise könnten eine [n * n]- und eine [m * n]-Matrix nacheinander denselben Speicherplatz nutzen, ohne dass eine Neu-Belegung von Speicher nötig wäre (m < n: eine oder mehrere Zeilen bleiben einfach ungenutzt). Dies ist nicht möglich mit MatObj, da hier die Matrix-Dimensionen gekapselt sind und daher keine Unterscheidung zwischen "tatsächlichen" und "genutzten" Dimensionen getroffen werden kann.
- Es ist nicht einmal möglich, beispielsweise eine nicht-quadratische Matrix mit ihrer Transponierten zu überschreiben (selbst wenn Sie bereit wären, auf die Integrität der Zeilenzeiger zu verzichten, und obwohl, die Größe der Matrix natürlich gleichbleibt).
- Alle MatObj-Funktionen mit dem Präfix Dia_... verlangen quadratische Matrizen (ht = len), während MF_Dia_...-Funktionen im Prinzip auch mit nicht-quadratischen Matrizen verwendet werden können, solange der Parameter "len" im Funktionsaufruf der jeweils kleineren Dimension entspricht.
- Die multifit-Funktionen sind nicht in den Klassen gekapselt, da die structs VF_EXPERIMENT und MF_EXPERIMENT ohnehin Zeiger anstatt Objekten enthalten müssen.
1.3.2 Alternative Aufruf-Form von Matrix-Funktionen mit direkten Zeigern
In der C/C++-Version von MatrixLib existieren alle Funktionen, die Matrizen als Argumente erwarten, in einer zweiten Form. In dieser sind alle Matrix-Argumente ersetzt durch Zeiger auf das Element [0,0] der jeweiligen Matrix. Man kann diese zweite Form explizit verwenden, indem der Unterstrich des Funktions-Präfixes fortgelassen wird. Ein Aufruf von
MF_mulM( MC, MA, MB, htA, lenA, lenB );
ist äquivalent zu
MFmulM(&(MC[0][0]),&(MA[0][0]),&(MB[0][0]),htA,lenA,lenB); oder
MFmulM( MC[0], MA[0], MB[0], htA, lenA, lenB );
Tatsächlich besteht die Laufzeitversion aller MatrixLib-Routinen aus dieser zweiten Form, in die die in <MFstd.h> usw. definierten Maktros alle Aufrufe der ersten Form umwandeln.
Zurück zum Inhaltsverzeichnis
1.4 Pascal/Delphi- spezifisch:
In der Pascal/Delphi-Version von MatrixLib werden die Matrizen aller Datentypen als Zeiger zu dem Element M[0][0] implementiert. Dies bedeutet, dass statische Matrizen (wie z.B. MX: array[0..5][0..5] of Single; ) an MatrixLib-Funktionen mit dem Adressen-Operator übergeben werden können:
MF_equ1( @(MX[0][0]), 6 );
Delphi 4 oder höher:
Ab Version 4 bietet Delphi dynamische Felder. Im eindimensionalen Fall werden diese als "array of Single", "array of Double", usw. deklariert. Die VecLib-unit enthält Kurzdefinizitionen für diese Felder als fArray,
dArray, usw. Durch einfaches type-casting von fArray in fVector können diese mit allen VectorLib-Funktionen verwendet werden.
Im zweidimensionalen Fall ist die Situation leider etwas komplizierter. Dynamische 2-D-Felder werden in Delphi als "array of fArray", "array of dArray" usw. deklariert. Auch hierfür bietet die VecLib-unit Kurzdefinitionen: f2DArray, d2DArray, usw. Aus der beschriebenen Implementation zweidimensionaler Felder in Delphi ergibt sich, dass jede Zeile einer Matrix als separater Vektor gespeichert wird. Dies hat zur Folge, dass die Matrix-Elemente nicht mehr innerhalb eines zusammenhängenden Speicherbereiches abgelegt werden, was sich wiederum sehr ungünstig auf die Performance von Matrix-Funktionen auswirkt und verhindert, dass Delphi-2DArrays direkt in MatrixLib-Funktionen eingesetzt werden können. Stattdessen müssen sie in "echte" Matrizen kopiert werden mittels MF_2DArrayToMatrix usw., bevor sie an MatrixLib-Funktionen übergeben werden können. Die Rück-Umwandlung wird durch MF_MatrixTo2DArray bewerkstelligt.
Die folgenden Kapitel bieten eine kurze Übersicht aller MatrixLib-Funktionen, geordnet nach ihrer Funktionalität. Am Schluß dieser Datei enthält Kap. 16 eine detaillierte Beschreibung der einzelnen Funktionen in alphabetischer Ordnung.
Zurück zum Inhaltsverzeichnis
2. Dynamische Allokation von Matrizen
MF_matrix | einer Matrix Speicherplatz zuweisen |
MF_matrix0 | Speicherplatz zuweisen und alle Elemente gleich 0 setzen |
M_free | Speicherplatz einer Matrix freigeben (unabhängig vom Datentyp) |
M_nfree | Speicherplatz mehrerer Matrizen freigeben (ebenfalls unabhängig vom Datentyp; nur C/C++) |
V_freeAll | Speicherplatz aller existierenden Vektoren und Matrizen freigeben |
Die dynamisch allozierten Matrizen von OptiVec sind an 64-ByteGrenzen ausgerichtet und dadurch optimal angepaßt an die Cache-Organisation moderner Prozessoren.
Nur C/C++-Version:
Die dynamisch allozierten Matrizen von OptiVec können genau wie zweidimensionale statische Felder von C/C++ adressiert werden. Angenommen, Sie deklarieren z.B. eine fMatrix X; und eine Variable float a;, dann können Sie eine Zuweisung schreiben der Art:
a = MX[3][5];
Sowohl C/C++- als auch Pascal/Delphi-Version:
Es gibt zwei Funktionen zur Adressierung einzelner Elemente. Diese Funktionen bieten die einzige Möglichkeit der Adressierung in Pascal/Delphi und werden außerdem benötigt, um die in der Zeigerarithmetik älterer Borland C++-Versionen enthaltenen Fehler zu umgehen:
Um einem spezifischen Matrix-Element einen Wert zuzuweisen, gebrauche man die Syntax
*(MF_Pelement( MX, ht, len, 3, 4 )) = 3.0; /* für C/C++*/
MF_Pelement( MX, ht, len, 3, 4 )^ := 3.0; (* für Pascal/Delphi *)
Zurück zum Inhaltsverzeichnis
3. Initialisierung von Matrizen
Um alle Matrix-Elemente mit ein- und demselben Wert zu initialisieren, oder um dieselbe arithmetische Operation auf alle Matrix-Elemente gleichzeitig anzuwenden, kann man die entsprechende VectorLib-Funktion aufrufen. Dies ist möglich, da alle Matrizen tatsächlich als Vektoren gespeichert sind und einen zusammenhängenden Speicherbereich belegen. Man muss lediglich die erste Zeile der Matrix (anstelle der Matrix selbst) an die gewünschte Vektor-Funktion übergeben. Um beispielsweise alle Matrix-Elemente mit einer Konstanten C zu initialisieren, rufe man:
VF_equC( MA[0], ht*len, C ); /* C/C++ */
VF_equC( MA, ht*len, C ); (* Pascal/Delphi *)
Die gebräuchlichsten Operationen dieser Art sind auch explizit als Matrix-Funktionen in MatrixLib definiert, wie die Initialisierung mit 0, MF_equ0, oder die Multiplikation mit einer Konstanten, MF_mulC (siehe Kap. 9). Die typischen Matrix-Initialisierungen sind:
MF_equ0 | alle Elemente gleich 0 setzen |
MCF_Reequ0 | die Realteile aller Matrix-Elemente gleich 0 setzen, wobei die Imaginärteile unverändert bleiben |
MCF_Imequ0 | die Imaginärteile aller Matrix-Elemente gleich 0 setzen, wobei die Realteile unverändert bleiben |
MF_equ1 | Einheitsmatrix: alle Diagonalelemente werden gleich 1.0 gesetzt, alle übrigen gleich 0 |
MF_equm1 | negative Einheitsmatrix: alle Diagonalelement sind gleich -1.0, alle übrigen gleich 0 |
MF_random | mit Zufallszahlen füllen |
MF_outerprod | Bildung einer Matrix als äußeres Produkt zweier Vektoren |
MF_Row_equ0 | alle Elemente einer Zeile gleich 0 setzen |
MF_Col_equ0 | alle Elemente einer Spalte gleich 0 setzen |
MF_Dia_equ0 | alle Diagonalelemente gleich 0 setzen |
MCF_Row_Reequ0 | den Realteil aller Elemente einer Zeile einer komplex-zahligen Matrix gleich 0 setzen |
MCF_Col_Reequ0 | den Realteil aller Elemente einer Spalte gleich 0 setzen |
MCF_Dia_Reequ0 | den Realteil aller Diagonalelemente gleich 0 setzen |
MCF_Row_Imequ0 | den Imaginärteil aller Elemente einer Zeile einer komplex-zahligen Matrix gleich 0 setzen |
MCF_Col_Imequ0 | den Imaginärteil aller Elemente einer Spalte gleich 0 setzen |
MCF_Dia_Imequ0 | den Imaginärteil aller Diagonalelemente gleich 0 setzen |
MF_Row_equC | alle Elemente einer Zeile gleich der Konstanten C setzen |
MF_Col_equC | alle Elemente einer Spalte gleich der Konstanten C setzen |
MF_Dia_equC | alle Diagonalelemente gleich der Konstanten C setzen |
MF_Row_equV | einen Vektor in eine bestimmte Zeile kopieren |
MF_Col_equV | einen Vektor in eine bestimmte Spalte kopieren |
MF_Dia_equV | einen Vektor in die Diagonale kopieren |
MF_Trd_equM | eine kompakt gespeicherte tridiagonale Matrix in eine allgemeine Matrix kopieren |
MF_equM | eine Matrix zur Kopie einer anderen machen |
MF_neg | eine Matrix zum Negativen einer anderen machen |
MCF_conj | komplex-konjugierte Matrix |
MCF_hermconj | Hermitesch konjugierte Matrix: MB = MAT* |
MF_UequL | Unterdiagonal- (engl. "lower-diagonal")Elemente durch Reflexion an der Diagonalen in die Überdiagonal- (engl. upper-diagonal) Elemente kopieren, um eine symmetrische Matrix zu erhalten |
MF_LequU | Überdiagonal- in Unterdiagonal-Elemente kopieren |
Zwei-dimensionale Fenster für räumliche Spektralanalyse werden geliefert durch:
Zurück zum Inhaltsverzeichnis
4. Datatyp-Umwandlungen
Matrizen jeden Datentyps können in jeden anderen Datentyp ungewandelt werden. Ein paar Beispiele hierfür sollten genügen. Der Rest ergibt sich wohl von selbst.
M_FtoD | fMatrix zu dMatrix |
M_EtoD | eMatrix zu dMatrix (mit Überlauf-Schutz) |
M_CDtoCF | cdMatrix zu cfMatrix (mit Überlauf-Schutz) |
M_DtoE | dMatrix zu eMatrix |
Zurück zum Inhaltsverzeichnis
5. Symmetrie-Operationen (Transposition, Rotation, , Spiegelung),
Interpolation, Erweiterung, Verkleinerung, Extraktion sowie Initialisierung von Teilen von Matrizen
MF_transpose | Matrix transponieren: MB = MAT |
MCF_hermconj | Hermitesch konjugierte Matrix: MB = MAT* |
MF_rotate90 | Matrix 90° im Uhrzeigersinn rotieren |
MF_rotate180 | Matrix 180° rotieren |
MF_rotate270 | Matrix 270° im Uhrzeigersinn (bzw. 90 ° entgegen dem Uhrzeigersinn) rotieren |
MF_Rows_rev | Umkehrung der Element-Reihenfolge innerhalb der Zeilen. Dies entspricht einer Spiegelung der Matrix an der Y-Achse |
MF_Cols_rev | Umkehrung der Element-Reihenfolge innerhalb der Spalten. Dies entspricht einer Spiegelung der Matrix an der X-Achse |
MF_Rows_reflect | obere Hälfte (d.h. höhere Indizes) aller Zeilen gleich der am Mittelpunkt reflektierten unteren Hälfte setzen |
MF_Cols_reflect | obere Hälfte (d.h. höhere Indizes) aller Spalten gleich der am Mittelpunkt reflektierten unteren Hälfte setzen |
MF_UequL | Unterdiagonal- (engl. "lower-diagonal")Elemente durch Reflexion an der Diagonalen in die Überdiagonal- (engl. upper-diagonal) Elemente kopieren, um eine symmetrische Matrix zu erhalten |
MF_LequU | Überdiagonal- in Unterdiagonal-Elemente kopieren |
MF_polyinterpol | Polynom-Interpolation |
MF_ratinterpol | rationale Interpolation |
MF_natCubSplineInterpol | "natürliche" kubische Spline-Interpolation |
MF_equMblock | einen Block, d.h. eine aus benachbarten Zeilen bzw. Spalten bestehende Teilmatrix, extrahieren |
MF_equMblockT | die Transponierte eines Blocks extrahieren |
MF_submatrix | Teilmatrix extrahieren, wobei die Abtast-Intervalle entlang der Zeilen bzw. Spalten von 1 verschieden sein dürfen |
MF_block_equM | Matrix in einen Block einer anderen (normalerweise größeren) Matrix kopieren |
MF_block_equMT | transponierte Matrix in einen Block einer anderen (normalerweise größeren) Matrix kopieren |
MF_submatrix_equM | Matrix in eine Teilmatrix einer (normalerweise größeren) Matrix kopieren |
MF_Row_extract | Einzelne Zeile extrahieren und in einen Vektor kopieren |
MF_Col_extract | Einzelne Spalte extrahieren und in einen Vektor kopieren |
MF_Dia_extract | Diagonale extrahieren und in einen Vektor kopieren |
MF_Trd_extract | tridiagonale Matrix aus allgemeiner Matrix extrahieren |
MF_Row_insert | Matrix durch Einfügen einer Zeile erweitern |
MF_Col_insert | Matrix durch Einfügen einer Spalte erweitern |
MF_Row_delete | Matrix durch Entfernen einer Zeile verkleinern |
MF_Col_delete | Matrix durch Entfernen einer Spalte verkleinern |
Man beachte, dass - im Gegensatz zu den VectorLib-Funktionen VF_insert und VF_delete - Einfügung und Entfernung von Zeilen oder Spalten nicht direkt auf die Eingabe-Matrix wirken. Stattdessen wird die mittels MF_Row_insert etc. erweiterte oder verkleinerte Eingabe-Matrix A als Ausgabe-Matrix B gespeichert. Beim Erweitern vergewissere man sich, dass MB groß genung ist, um die erweiterte Ausgabe-Matrix aufzunehmen! Im Normalfall bedeutet dies, dass man eine neue Matrix B zu allozieren hat, bevor man MF_???_insert aufrufen und eventuell anschließend MA mittels
M_free( MA );
verwerfen kann.
Wenn dieser Prozeß mehrfach wiederholt werden soll, ist es günstig, die Ineffizienz der wiederholten Allokation zu vermeiden. In diesem Fall kann MA gleich zu Beginn mit den Dimensionen alloziert werden, die schließlich erreicht werden sollen (oder, falls diese nicht von vornherein bekannt sind, mit willkürlich festgelegten Obergrenzen). Im Verlauf des Matrix-Aufbaus durch Zeilen- oder Spalten-Einfügung muss man dann die tatsächlich erreichten Dimensionen verfolgen und (anstelle der für die Allokation verwandten Obergrenzen!) in allen MatrixLib-Funktionsaufrufen angeben. Jetzt kann die Eingangsmatrix in jedem Aufruf von MF_???_insert durch die erweiterte Ausgabematrix überschrieben werden, wie z.B.:
MF_Row_insert( MA, MA, ++actualhtA, actuallenA, 0, X );
nur C++ mit dynamisch allozierten Matrizen:
Fall MA durch Spalten-Einfügung oder -Löschung von MB überschrieben wird, geht die Möglichkeit verloren, einzelne Matrix-Elemente als MB[i][j] anzusprechen. Der Grund hierfür ist, dass die Zeilen-Zeiger der Ausgabe-Matrix immer noch dieselben wie in der Eingabe-Matrix bleiben. Dann bieten nur noch MF_element und MF_Pelement Zugang zu den einzelnen Elementen. Falls auf der anderen Seite ausschließlich Zeilen eingefügt oder gelöscht werden, bleiben die Zeilen-Zeiger gültig.
Zurück zum Inhaltsverzeichnis
6. Arithmetische Operationen einer einzelnen Zeile, Spalte oder der Diagonalen
MF_Row_neg | Multiplikation aller Elemente einer bestimmten Zeile mit -1 |
MF_Col_neg | Multiplikation aller Elemente einer bestimmten Spalte mit -1 |
MF_Row_addC | eine Konstante zu allen Elementen einer bestimmten Zeile hinzuaddieren |
MF_Col_addC | eine Konstante zu allen Elementen einer bestimmten Spalte hinzuaddieren |
MF_Dia_addC | eine Konstante zu allen Elementen der Diagonalen hinzuaddieren |
MF_Row_addV | Vektor-Elemente zu den korrespondierenden Elementen einer bestimmten Zeile hinzuaddieren |
MF_Col_addV | Vektor-Elemente zu den korrespondierenden Elementen einer bestimmten Spalte hinzuaddieren |
MF_Dia_addV | Vektor-Elemente zu den korrespondierenden Elementen der Diagonalen hinzuaddieren |
Für die übrigen Funktionen dieser Familie sollten einige Beispiele genügen:
MF_Row_subC | eine Konstante von allen Elementen einer bestimmten Zeile subtrahieren |
MF_Col_subrC | umgekehrte Subtraktion: Differenz zwischen Spalten-Elementen und einer Konstanten |
MF_Dia_mulV | Diagonal-Elements mit korrespondierenden Vector-Elementen multiplizieren |
MF_Row_divV | Elemente einer bestimmten Zeile durch korrespondierende Vektor-Elemente dividieren |
MF_Col_divrC | umgekehrte Division: eine Konstante durch die einzelnen Elemente einer Spalte dividieren |
Zurück zum Inhaltsverzeichnis
7. Operationen, die auf alle Zeilen oder alle Spalten gleichzeitig oder auf die Diagonale wirken
Berechnung des Schwerpunktes
MF_Rows_max | Maxima der einzelnen Zeilen in einem Spaltenvektor speichern |
MF_Cols_max | Maxima der einzelnen Spalten in einem Zeilenvektor speichern |
MF_Dia_max | Maximum der Diagonalen als Skalar zurückgeben |
MF_Rows_absmax | Betrags-Maxima der einzelnen Zeilen in einem Spaltenvektor speichern |
MF_Cols_absmax | Betrags-Maxima der einzelnen Spalten in einem Zeilenvektor speichern |
MF_Dia_absmax | Betrags-Maximum der Diagonalen als Skalar zurückgeben |
MF_Rows_sum | Summen über die einzelnen Zeilen in einem Spaltenvektor speichern |
MF_Cols_sum | Summen über die einzelnen Spalen in einem Zeilenvektor speichern |
MF_Dia_sum | Summe der Diagonalelemente |
MF_Rows_prod | Produkte über die einzelnen Zeilen in einem Spaltenvektor speichern |
MF_Cols_prod | Producte über die einzelnen Spalen in einem Zeilenvektor speichern |
MF_Dia_prod | Produkt der Diagonal-Elemente |
MF_Rows_runsum | laufende Summe entlang der Zeilen |
MF_Cols_runsum | laufende Summe entlang der Spalten |
MF_Rows_runprod | laufendes Produkt entlang der Zeilen |
MF_Cols_runprod | laufendes Produkt entlang der Spalten |
MF_Rows_rotate | alle Zeilen um eine bestimmte Anzahl von Positionen rotieren |
MF_Cols_rotate | alle Spalten um eine bestimmte Anzahl von Positionen rotieren |
MF_Rows_rotate_buf | alle Zeilen um eine bestimmte Anzahl von Positionen rotieren (unter Verwendung eines als Argument übergebenen Puffer-Speichers) |
MF_Cols_rotate_buf | alle Spalten um eine bestimmte Anzahl von Positionen rotieren (unter Verwendung eines als Argument übergebenen Puffer-Speichers) |
MF_Rows_reflect | obere Hälfte (d.h. höhere Indizes) aller Zeilen gleich der am Mittelpunkt reflektierten unteren Hälfte setzen |
MF_Cols_reflect | obere Hälfte (d.h. höhere Indizes) aller Spalten gleich der am Mittelpunkt reflektierten unteren Hälfte setzen |
MF_Rows_rev | Element-Reihenfolge innerhalb der Zeilen umkehren. Dies entspricht einer Spiegelung der Matrix an der Y-Achse |
MF_Cols_rev | Element-Reihenfolge innerhalb der Spalten umkehren. Dies entspricht einer Spiegelung der Matrix an der X-Achse |
MF_Rows_FFT | Fourier-Transformation der Zeilen |
MF_Cols_FFT | Fourier-Transformation der Spalten |
MF_Rows_distribution | Histogramm (ein-dimensionale Verteilungsfunktion) der Zeilen |
MF_Cols_distribution | Histogramm (ein-dimensionale Verteilungsfunktion) der Spalten |
Man beachte, dass die Multiplikation aller Zeilen oder aller Spalten mit ein- und demselben Vektor äquivalent zur Multiplikation mit einer Diagonal-Matrix ist. Diese Operation wird durch MF_mulMdia und MF_TmulMdia bewerkstelligt.
Zu allen oben aufgeführten Maximum-Funktionen (...max, ...absmax) existieren die entsprechenden Minimum-Funktionen und sind als ...min bzw. ...absmin benannt.
Für komplexe Zahlen lassen sich verschiedene Kriterien zur Definition eines Maximums definieren. Die folgende Tabelle faßt die existierenden Maximum-Funktionen für komplexe Matrizen zusammen. Natürlich existieren auch hier die entsprechenden Minimum-Funktionen.
MCF_Rows_absmax | Betrags-Maxima der einzelnen Zeilen in einem (reellen) Spaltenvektor speichern |
MCF_Cols_absmax | Betrags-Maxima der einzelnen Spalten in einem (reellen) Zeilenvektor speichern |
MCF_Dia_absmax | Betrags-Maximum der Diagonale als (reellen) Skalarwert zurückgeben |
MCF_Rows_absmaxReIm | betragsmäßig größte Real- und Imaginärteile einzeln entlang der Zeilen suchen und als Real- bzw. Imaginärteile eines komplexen Spaltenvektors speichern |
MCF_Cols_absmaxReIm | betragsmäßig größte Real- und Imaginärteile einzeln entlang der Spalten suchen und als Real- bzw. Imaginärteile eines komplexen Zeilenvektors speichern |
MCF_Dia_absmaxReIm | betragsmäßig größten Real- und Imaginärteil einzeln entlang der Diagonale suchen und als Real- bzw. Imaginärteil einer komplexen Zahl zurückgeben |
MCF_Rows_cabsmax | bezüglich Absolutwert definierte Maxima der einzelnen Zeilen in einem Spaltenvektor speichern |
MCF_Cols_cabsmax | bezüglich Absolutwert definierte Maxima der einzelnen Spalten in einem Zeilenvektor speichern |
MCF_Dia_cabsmax | bezüglich Absolutwert definiertes Maximum entlang der Diagonale suchen und als Skalar zurückgeben |
MCF_Rows_maxReIm | größte Real- und Imaginärteile einzeln entlang der Zeilen suchen und als Real- bzw. Imaginärteile eines komplexen Spaltenvektors speichern |
MCF_Cols_maxReIm | größte Real- und Imaginärteile einzeln entlang der Spalten suchen und als Real- bzw. Imaginärteile eines komplexen Zeilenvektors speichern |
MCF_Dia_maxReIm | größten Real- und Imaginärteil einzeln entlang der Diagonale suchen und als Real- bzw. Imaginärteil einer komplexen Zahl zurückgeben |
MCF_Rows_sabsmax | bezüglich der Summe |Re|+|Im| definierte Maxima der einzelnen Zeilen in einem Spaltenvektor speichern |
MCF_Cols_sabsmax | bezüglich der Summe |Re|+|Im| definierte Maxima der einzelnen Spalten in einem Zeilenvektor speichern |
MCF_Dia_sabsmax | bezüglich der Summe |Re|+|Im| definiertes Maximum entlang der Diagonale suchen und als Skalar zurückgeben |
Zur Berechnung des Schwerpunktes einer Matrix stehen zwei Funktionen zur Verfügung:
Zurück zum Inhaltsverzeichnis
8. Operationen von zwei Zeilen oder zwei Spalten
Zurück zum Inhaltsverzeichnis
9. Arithmetik ganzer Matrizen: Addition und Multiplikation
a) Element-weise Operationen
MF_addM | zwei Matrizen addieren |
MF_addMT | eine Matrix und die Transponierte einer weiteren Matrix addieren
MC = MA + MBT |
MF_subM | eine Matrix von einer anderen subtrahieren |
MF_subMT | transponierte Matrix subtrahieren
MC = MA - MBT |
MF_subrMT | Matrix von der Transponierten einer anderen Matrix subtrahieren
MC = MBT - MA |
MF_mulC | alle Matrix-Elemente mit einer Konstanten multiplizieren |
MCF_mulReC | alle Elemente einer komplexen Matrix mit einer reellen Konstanten multiplizieren |
MF_divC | alle Matrix-Elemente durch eine Konstante dividieren |
MCF_divReC | alle Elemente einer komplexen Matrix durch eine reelle Konstante dividieren |
MFs_addM | skalierte Addition zweier Matrizen
MC = c * (MA + MB) |
MFs_addMT | skalierte Addition von einer Matrix und einer transponierten anderen MC = c * (MA + MBT) |
MFs_subM | skalierte Subtraktion zweier Matrizen
MC = c * (MA - MB) |
MFs_subMT | skalierte Subtraktion von einer Matrix minus der Transponierten einer anderen MC = c * (MA - MBT) |
MFs_subrMT | skalierte umgekehrte Subtraktion: transponierte Matrix minus eine andere MC = c * (MBT - MA) |
MF_lincomb | Linearkombination
MC = ca * MA + cb * MB |
b) Matrix-Multiplikation
MF_mulV | Matrix mit einem Spaltenvektor multiplizieren:
Y = MA * X |
MF_TmulV | transponierte Matrix mit einem Spaltenvektor multiplizieren:
Y = MAT * X |
VF_mulM | Zeilenvektor mit einer Matrix multiplizieren:
Y = X * MA |
VF_mulMT | Zeilenvektor mit transponierter Matrix multiplizieren:
Y = X * MAT |
MF_mulM | Multiplikation zweier Matrizen:
MC = MA * MB |
MF_mulMT | eine Matrix mit der Transponierten einer anderen multiplizieren:
MC = MA * MBT |
MF_TmulM | transponierte Matrix mit einer anderen Matrix multiplizieren:
MC = MAT * MB |
MF_TmulMT | transponierte Matrix mit einer anderen transponierten Matrix multiplizieren:
MC = MAT * MBT |
MCF_mulMH | eine Matrix mit der Hermitesch-konjugierten Form einer anderen multiplizieren:
MC = MA * MBT * |
MCF_HmulM | Hermitesch-konjugierte Form einer Matrix mit einer anderen Matrix multiplizieren:
MC = MAT * * MB |
MCF_TmulMH | transponierte Matrix mit Hermitesch-konjugierten Form einer anderen multiplizieren:
MC = MAT * MBT* |
c) Multiplikation von allgemeinen Matrizen mit Diagonalmatrizen und umgekehrt
Die Diagonalmatrix wird an die jeweilige Funktion als Vektor übergeben, der nur aus den Diagonalelementen besteht.
MF_mulMdia | allgemeine Matrix mit Diagonalmatrix multiplizieren:
MC = MA * MBDia |
MF_TmulMdia | transponierte allgemeine Matrix mit Diagonalmatrix multiplizieren:
MC = MAT * MBDia |
MFdia_mulM | Diagonalmatrix mit allgemeiner Matrix mutliplizieren:
MC = MADia * MB |
MFdia_mulMT | Diagonalmatrix mit transponierter allgemeiner Matrix mutliplizieren:
MC = MADia * MBT |
Zurück zum Inhaltsverzeichnis
10. Lineare Algebra
Es gibt vier Gruppen von Funktionen zur Linearen Algebra. Die erste besteht aus einfachen Funktionen, die benutzt werden können, ohne auf deren internen Ablauf Rücksicht zu nehmen. Die zweite Gruppe besteht aus spezifisch der LU-Faktorisierung (engl. LU decomposition, LUD) und ihren Anwendungen gewidmeten Funktionen. Die dritte Gruppe behandelt Cholesky-Faktorisierung und ihre Anwendungen. Die vierte Gruppe schließlich verwendet Singulärwert-Zerlegung (engl. Singular Value Decomposition, SVD). Die auf LUD basierenden Funktionen existieren auch für komplexe Matrizen, die übrigen nur für reelle.
Hier sind zunächst die einfachen Funktionen:
MF_solve |
Lösen eines linearen Gleichungs-Systems (unter Verwendung von LU-Faktorisierung) |
MF_inv | Matrix invertieren |
MF_det | Determinante einer Matrix |
MFsym_solve |
Lösen eines symmetrischen linearen Gleichungs-Systems, das als positiv-definit angenommen wird (unter Verwendung von Cholesky-Faktorisierung; falls das System sich dabei als nicht-positiv-definit herausstellt, wird LU-Faktorisierung angewandt) |
MFsym_inv | Symmetrische, als positiv-definit angenommene Matrix invertieren |
MFsym_det | Determinante einer symmetrischen, als positiv-definit angenommenen Matrix |
MF_solveBySVD | Lineares Gleichungssystem unter Verwendung von Singulärwert-Zerlegung (SVD) lösen |
MF_safeSolve | "sicheres" Lösen eines linearen Gleichungssystemes: zuerst wird Lösung über LUD versucht; schlägt diese fehl, wird SVD angewandt |
Es folgen einige Funktionen zur expliziten LU-Faktorisierung und zur Behandlung von LU-faktorisierten Matrizen:
MF_LUdecompose | Faktorisierung in die LU-Form |
MF_LUDresult | prüfen, ob MF_LUdecompose erfolgreich war |
MF_LUDsetEdit | Editier-Schwelle für MF_LUdecompose setzen; dies kann zur Umgehung von Singularitäten dienen |
MF_LUDgetEdit | aktuell eingestellte Editier-Schwelle lesen |
MF_LUsolve | Lösung eines linearen Gleichungssystems bei Vorliegen der Matrix in LU-Form |
MF_LUimprove | Genauigkeit der über LU-Faktorisierung erzielten Lösung eines linearen Gleichungssystems iterativ verbessern |
MF_LUinv | Bereits in LU-Form faktorisierte Matrix invertieren |
MF_LUdet | Determinante einer bereits in LU-Form vorliegenden Matrix |
Für positiv-definite Matrizen stehen folgende Funktionen zur Cholesky-Faktorisierung und zur Behandlung von Cholesky-faktorisierten Matrizen zur Verfügung:
MF_CholeskyLdecompose | Cholesky-Faktorisierung in linke Dreiecksmatrix |
MF_CholeskyRdecompose | Cholesky-Faktorisierung in rechte Dreiecksmatrix |
MF_CholeskyLsolve | Lösung eines positiv-definiten Gleichungssystems bei Vorliegen der Matrix in linker Dreiecks-Form |
MF_CholeskyRsolve | Lösung eines positiv-definiten Gleichungssystems bei Vorliegen der Matrix in rechter Dreiecks-Form |
MF_CholeskyLimprove | Genauigkeit der über Cholesky-Faktorisierung in L-Form erzielten Lösung eines linearen Gleichungssystems iterativ verbessern |
MF_CholeskyRimprove | Genauigkeit der über Cholesky-Faktorisierung in R-Form erzielten Lösung eines linearen Gleichungssystems iterativ verbessern |
MF_CholeskyLinv | Bereits durch Cholesky-Faktorisierung in L-Form vorliegende Matrix invertieren |
MF_CholeskyRinv | Bereits durch Cholesky-Faktorisierung in R-Form vorliegende Matrix invertieren |
MF_CholeskyDet | Determinante einer entweder in L- oder in R-Form vorliegenden Matrix |
Singulärwert-Zerlegung (SVD) und verwandte Funktionen:
MF_SVdecompose | Singulärwert-Zerlegung |
MF_SVsort | Sortierung von Singulärwerten in absteigender Reihenfolge unter entsprechender Um-Ordnung der linken und rechten Singulär-Vektoren |
MF_SVsolve | Singulärwert-zerlegtes Gleichungssystem lösen |
MF_SVDsetEdit | Editier-Schwelle für Dimensions-Reduktion bei SV-Lösung setzen |
MF_SVDgetEdit | aktuell eingestellte Editier-Schwelle für Dimensions-Reduktion bei SV-Lösung lesen |
Zurück zum Inhaltsverzeichnis
11. Eigenwerte und Eigenvektoren, Quadratwurzel
Zur Zeit wird nur der spezielle, aber häufigste Fall symmetrischer reeller Matrizen behandelt:
MFsym_eigenvalues |
Eigenwerte mit oder ohne Eigenvektoren einer symmetrischen reellen Matrix |
MFsym_sqrt |
Quadratwurzel einer symmetrischen Matrix mit ausschließlich positiven Eigenwerten |
Zurück zum Inhaltsverzeichnis
12. Fourier-Transform-Methoden
Analog zu den ein-dimensionalen Fourier-Transform-Methoden von VectorLib bietet MatrixLib die folgenden Funktionen für den zwei-dimensionalen Fall:
MF_FFTtoC | Schnelle Fourier-Transformation (engl.: Fast Fourier Transform, FFT) einer rellen Matrix in Vorwärts-Richtung; das Ergebnis ist eine komplexe Matrix |
MF_FFT | Vorwärts- und Rückwärts-FFT reeller Matrizen; unter Verwendung von Symmetrie-Eigenschaften wird das komplexe Ergebnis in eine reelle Matrix derselben Dimensionen wie die Eingabe-Matrix gepackt |
MCF_FFT | Vorwärts- und Rückwärts-FFT komplexer Matrizen |
MF_convolve | Faltung (engl.: convolution) mit einer räumlichen Impulsantwort-Funktion |
MF_deconvolve | Entfaltung (engl.: deconvolution) |
MF_filter | Räumliche Filterung |
MF_autocorr | Räumliche Autokorrelation |
MF_xcorr | Räumliche Kreuzkorrelation |
MF_spectrum | Raumfrequenz-Spektrum |
MF_xspectrum | Raumfrequenz-Kreuzspektrum (komplex) |
MF_xspectrumAbs | Raumfrequenz-Kreuzspektrum (Absolutwerte) |
MF_coherence | Räumliche Kohärenzfunktion |
Die ein-dimensionale Fourier-Transformation entlang der Zeilen oder diejenige entlang der Spalten ist mit folgenden Funktionen möglich:
MF_Rows_FFTtoC | Fourier-Transformation der Zeilen einer reellen Matrix; das Ergebnis ist eine komplexe Matrix |
MF_Cols_FFTtoC | Fourier-Transformation der Spalten einer reellen Matrix; das Ergebnis ist eine komplexe Matrix |
MF_Rows_FFT | Fourier-Transformation der Zeilen einer reellen Matrix |
MF_Cols_FFT | Fourier-Transformation der Spalten einer reellen Matrix |
MCF_Rows_FFT | Fourier-Transformation der Zeilen einer komplexen Matrix |
MCF_Cols_FFT | Fourier-Transformation der Spalten einer komplexen Matrix |
Zurück zum Inhaltsverzeichnis
13. Datenanpassung (Fitting)
MatrixLib bietet eine große Bandbreite von Datenanpassungs- ("Fit"-) Routinen für verschiedene Klassen von Modellfunktionen. Die folgende Tabelle bietet zunächst einen Überblick über die vorhandenen Routinen, bevor die einzelnen Klassen von Modellfunktionen und ihre Behandlung detaillierter besprochen werden:
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_polyfitOdd |
Koeffizienten eines nur aus ungeraden Potenzen bestehenden Polynoms an vorhandene X-Y-Daten anpassen |
VF_polyfitOddwW |
dasselbe mit ungleicher Wichtung der Datenpunkte |
VF_polyfitEven |
Koeffizienten eines nur aus geraden Potenzen bestehenden Polynoms an vorhandene X-Y-Daten anpassen |
VF_polyfitEvenwW |
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 |
MF_linfit |
Koeffizienten einer in ihren Parametern linearen Funktion an X-Y-Z-Daten anpassen |
MF_linfitwW |
dasselbe mit ungleicher Wichtung der Datenpunkte |
MF_nonlinfit |
Koeffizienten einer nicht-linearen Funktion an X-Y-Z-Daten anpassen |
MF_nonlinfitwW |
dasselbe mit ungleicher Wichtung der Datenpunkte |
MF_multiLinfit |
mehrere X-Y-Z-Datensätze gleichzeitig an eine gemeinsame lineare Funktion anpassen |
MF_multiLinfitwW |
dasselbe mit ungleicher Wichtung der Datenpunkte |
MF_multiNonlinfit |
mehrere X-Y-Z-Datensätze gleichzeitig an eine gemeinsame nicht-lineare Funktion anpassen |
MF_multiNonlinfitwW |
dasselbe mit ungleicher Wichtung der Datenpunkte |
Im folgenden werden die verschiedenen Klassen von Modellfunktionen einzeln besprochen. Das einfachste Modell besteht aus einer Geraden:
Yi = a * Xi + b;
Die Anpassung von Y = f(X)-Daten an eine Gerade heißt "lineare Regression" und wird durch VF_linregress durchgeführt.
Die nächst-höhere Stufe von Modellfunktionen stellen Polynome dar, die im folgenden Absatz besprochen werden:
13.1 Polynome
Polynome sind Funktionen der Form
Yi = a0 + a1Xi + a2Xi2 ... anXin
Ebenso wie lineare Regression ist auch die Anpassung an Polynome nur für Y-X-Daten (mittels VF_polyfit), nicht aber für MZ=f(X,Y)-Daten in OptiVec enthalten. Bei der Anpassung an Polynome möchte man die Koeffizienten ai bis zu einer bestimmten Grenze, dem Grad n des Polynoms bestimmen. In der einfachsten Form werden alle Koeffizienten als freie Parameter behandelt, also ohne die Möglichkeit, einzelne von vornherein bekannte Koeffizienten "einzufrieren."
Wenn man allerdings von vornherein weiß (oder jedenfalls vermutet), dass das Polynom nur aus ungeraden oder nur aus geraden Potenzen besteht, sollte man zur Anpassung VF_polyfitOdd bzw. VF_polyfitEven aufrufen.
Polynomial fitting is most useful for two to five free parameters (i.e., VF_polyfit: degrees of 2 to 4, VF_polyfitOdd: degrees 3 to 9, VF_polyfitEven: degrees 2 to 8).
Polynom-Anpassung ist sinnvoll für zwei oder drei bis 5 freie Parameter (also Grade zwischen 2 und 4 für VF_polyfit, Grade 3 bis 9 für VF_polyfitOdd oder 2 bis 8 für VF_polyfitEven. Mit mehr als fünf Termen kann man praktisch alle Eingabe-Daten irgendwie anpassen - die Aussagekraft der gewonnenen Koeffizienten wird aber immer niedriger, da bereits geringfügiges experimentelles Rauschen das Gleichgewicht der höheren Terme empfindlich stört. Falls Polynome höherer Grade tatsächlich benötigt werden, sollte man gründlich prüfen, welche Terme eliminiert werden können. Diese Aufgabe führt uns von den einfachen Polynomen zur nächsthöheren Klasse von Modellfunktionen, nämlich:
13.2 Allgemeine Lineare Modell-Funktionen
Im allgemeinen linearen Fall müssen Sie Ihre Modellfunktion selbst schreiben und als Argument an die Anpassungs-Routine übergeben. Das Wort "linear" bedeutet, dass die Modellfunktion aus einer linearen Kombination von Basisfunktionen besteht, deren jede linear von den anzupassenden Parametern abhängt:
y = a0f0(x) + a1f1(x) + a2f2(x)...
Die einzelnen Funktionen fi(x) können nicht-linear von x abhängen, aber nicht von den Koeffizienten ai. Beispielsweise ist
y = a0sin(x)+ a1cos(x)
eine korrekte lineare Modellfunktion, nicht aber
y = sin(a0x)+ cos(a1x)
da die Koeffizienten ai innerhalb der nicht-linearen Basisfunktionen auftreten.
Für allgemeine lineare Anpassungen muss die Modellfunktion in der Weise formuliert werden, dass sie die einzelnen Basisfunktionen für jeden x-Wert des Datensatzes ausrechnet. Das obige Beispiel mit sinus- und cosinus-Funktionen würde also in C/C++ geschrieben werden:
void LinModel( fVector BasFuncs, float x, unsigned nfuncs )
{
BasFuncs[0] = sin(x);
BasFuncs[1] = cos(x);
}
Man beachte, dass die Koeffizienten ai in der Modellfunktion gar nicht auftauchen. Das Argument nfuncs (das im obigen Beispiel ignoriert wird) ermöglicht es, eine variable Anzahl von Basisfunktionen zu verwenden. Man kann außerdem Anpassungsparameter "an" und "aus" schalten, d.h. zwischen "freien" und "eingefrorenen" Parametern wechseln. Hierfür übernimmt die Routine VF_linfit einen "Status"-Vektor als Argument. Für alle Elemente des Parameter-Vektors, die als frei behandelt werden sollen, muss der entsprechende "Status"-Eintrag auf 1 gesetzt werden. Setzt man Statusi gleich 0, so wird der entsprechende Parameter ai auf seinem Anfangswert eingefroren. Eingefrorene Werte müssen vor Aufruf von VF_linfit initialisiert werden.
Intern verwendet VF_linfit einen SVD-Algorithmus, um eine Lösung selbst für (nahezu) singuläre lineare Gleichungssysteme zu erhalten. Koeffizienten ai, deren Signifikanz unter einer bestimmten Schwelle Thresh liegt, werden dabei gleich 0 anstatt Unendlich gesetzt. Um diese Schwelle für jeden Aufruf einzeln zu definieren, verwende man VF_linfitwEdit anstelle von VF_linfit. Wenn man aber mit dem standardmäßig vorgegebenen Schwellenwert zufrieden ist, kann man auch das einfachere VF_linfit verwenden. Die standardmäßig eingestellte Schwelle kann allerdings auch durch Aufruf von VF_setLinfitNeglect modifiziert werden. Um den aktuell eingestellten Schwellenwert zu lesen, rufe man VF_getLinfitNeglect.
Nachdem bereits oben bemerkt wurde, dass Funktionen wie
y = sin(a0x)+ cos(a1x)
ihre eigene Behandlung erfordern, erreichen wir die letzte und allgemeinste Klasse von Modellfunktionen:
13.3 Nicht-lineare Modelle
Wie oben beschrieben wurde, verlaufen Anpassungen an lineare Modellfunktionen (einschließlich der einfachen Polynome) intern über die direkte Lösung eines Systems gekoppelter linearer Gleichungen. Diese wiederum besteht im wesentlichen aus einer einfachen Matrix-Inversion. Die Situation für nicht-lineare Modell-Funktionen stellt sich völlig anders dar: Es existiert keine geschlossene Lösung, und das Anpassungsproblem kann nur iterativ gelöst werden, also dadurch, dass die Routine in einem "trial-and-error"-Verfahren die Modellfunktion hunderte und tausende von Malen mit immer anderen Parameter-Sätzen aufruft, bis der am besten passende Parameter-Satz gefunden ist. Dadurch wird die Anpassung an nicht-lineare Modellfunktionen wesentlich rechenzeitaufwendiger (um 3-5 Größenordnungen!) als die Anpassung an lineare Modelle. Die OptiVec-Routinen zur Anpassung an nicht-lineare Modelle basieren auf zwei Algorithmen:
- Der Levenberg-Marquardt-Methode und der
- Downhill-Simplex-Methode nach Nelder und Mead.
Als Ausgangspunkt bietet sich normalerweise eine Kombination dieser beiden an (man wähle FitOptions.LevelOfMethod = 3, s.u.).
Alle nicht-linearen Datenanpassungs-Funktionen existieren in zwei Syntax-Varianten. Die eine erwartet je einen Zeiger auf die unten beschriebenen Strukturen des Typs VF_NONLINFITOPTIONS und VF_NONLINFITWORKSPACE als Argumente. Diese Form erlaubt es, einerseits verschiedene Anpassungen gleichzeitig mit unterschiedlichen Options-Sätzen durchzuführen, andererseits auf die ebenfalls unten einzeln aufgeführten Hilfsfunktionen zum Verfolgen des Anpassungs-Fortschritts zuzugreifen. Die zweite Syntax-Variante verzichtet auf diese beiden Parameter und verwendet die standardmäßig voreingestellten Optionen sowie einen intern angelegten Workspace. Bei dieser Variante ist aber kein Zugriff auf die Hilfsfunktionen möglich.
Die grundsätzliche Verschiedenheit zwischen linearer und nicht-linearer Datenanpassung spiegelt sich auch in der erforderlichen Formulierung der Modellfunktion wider. Im Unterschied zum linearen Fall werden hier nicht die einzelnen Basisfunktionen berechnet. Vielmehr wird die Modell-Funktion von VF_nonlinfit mit einem ganzen X-Vektor (samt dessen Größe size und dem aktuellen Parameter-Satz A) als Eingabe-Argument aufgerufen und hat den ganzen Y-Vektor zu berechnen. Für das obige nicht-lineare sinus- und cosinus-Beispiel könnte man die Modellfunktion in C/C++ schreiben:
void NonlinModel( fVector Y, fVector X, ui size, fVector A)
{
for( ui i=0; i<size; i++ )
Y[i] = sin( A[0]*X[i] ) + cos( A[1]*X[i] );
}
Aus der beschriebenen Arbeitsweise der Anpassungs-Routine wird klar, dass sie einen großen oder sogar den größten Teil der Rechenzeit in Ihrer Modellfunktion (und deren Ableitungen, siehe unten) verbringen wird. Daher sollte diese weitestmöglich mit Hilfe der in OptiVec bereitgestellten Vektor-Funktionen optimiert werden. Hierzu könnten Sie vor dem Aufruf von VF_nonlinfit einen fVector YHelp bereitstellen (entweder global mittels VF_vector alloziert oder bei kleineren Vektoren auch lokal auf dem Stack). Dann können Sie schreiben:
void OptNonlinModel( fVector Y, fVector X, ui size, fVector A)
{
VFx_sin( YHelp, X, size, A[0], 0.0, 1.0 );
VFx_cos( Y, X, size, A[1], 0.0, 1.0 );
VF_addV( Y, Y, YHelp, size );
}
Der Parameter-Vektor "A", den Sie als Argument an VF_nonlinfit übergeben, wird im Verlauf des Anpassungs-Prozesses immer weiter verbessert. Beim Aufruf von VF_nonlinfit muss "A" mit bereits möglichst "guten" Werten der Parameter initialisiert sein. Je besser Sie diese "raten", umso schneller wird VF_nonlinfit konvergieren. Raten Sie gar zu schlecht, kann die Konvergenz wesentlich langsamer oder im schlimmsten Fall auch überhaupt nicht erreicht werden.
Auf keinen Fall darf die Modell-Funktion irgendeine "Korrektur" der Parameter A vornehmen! VF_nonlinfit muss vielmehr das "Recht" haben, sich zu irren und aus den Konsequenzen (nämlich einer schlechten Anpassung) für die folgenden Annäherungs-Schritte zu lernen.
Alle nonlinfit-Funktionen geben den Anpassungstest-Wert (für Anpassung nach kleinsten Fehlerquadraten: c2, chi-Quadrat; für Anpassung nach kleinstem Absolut-Fehler: |c|, chiabs) des besten Parameter-Satzes "A" zurück.
Um die Anpassung durchführen zu können, benötigen diese Funktionen nicht nur die Modellfunktion selbst, sondern auch noch deren partielle Ableitungen nach den einzelnen Koeffizienten. Hierfür dient das Argument "Derivatives", das an alle nonlinfit-Funktionen übergeben werden muss. Falls Sie die partiellen Ableitungen in analytischer Form kennen, sollte Derivatives auf eine Funktion zeigen, die diese berechnet. Kennen Sie sie nicht, setzen Sie beim Funktionsaufruf Derivatives = NULL (nil in Pascal/Delphi). Im letzteren Fall werden alle Ableitungen numerisch innerhalb der Routinen bestimmt. In Fällen, wo Sie zwar einige, aber nicht alle der partiellen Ableitungen von Y nach den Koeffizienten ai kennen, können Sie dY / dai selbst berechnen, wo immer Sie die analytische Formel kennen, und VF_nonlinfit_autoDeriv für die übrigen Koeffizienten aufrufen. Um diese Möglichkeiten zu demonstrieren, sei hier erneut unser nicht-lineares sinus- und cosinus-Beispiel bemüht:
void DerivModel( fVector dYdAi, fVector X, ui size, unsigned iPar, fVector A, VF_NONLINFITWORKSPACE *ws )
{
switch( iPar )
{
case 0:
for( ui i=0; i<size; i++ )
dYdAi[i] = X[i] * cos( A[0]*X[i] );
break;
case 1: /* wir finden diese Ableitung zwar im Lehrbuch; aber nehmen wir einmal an, dies wäre nicht der Fall: */
VF_nonlinfit_autoDeriv( dYdAi, X, size:UIntSize; ipar, A, ws );
}
}
Bevor Sie allerdings VF_nonlinfit_autoDeriv tatsächlich einsetzen, sollten Sie alle Anstrengungen unternehmen, eine eventuell existierende analytische Lösung herauszufinden: Die für die numerische Ableitung notwendige Zahl von Funktionsaufrufen kann Ihre Anpassung leicht um einen Faktor von 3 bis 10 verlangsamen! Ohnehin sollten, ähnlich wie oben die Modellfunktion, auch deren Ableitungen möglichst mit Hilfe von Vektorfunktionen programmiert werden. Die optimierte Version von DerivModel lautet dann wie folgt:
void OptDerivModel( fVector dYdAi, fVector X, ui size, unsigned iPar, fVector A, VF_NONLINFITWORKSPACE *ws )
{
switch( iPar )
{
case 0:
VFx_cos( dYdAi, X, size, A[0], 0.0, 1.0 );
VF_mulV( dYdAi, dYdAi, X, size ); break;
case 1:
VFx_sin( dYdAi, X, size, A[1], 0.0, -1.0 );
VF_mulV( dYdAi, dYdAi, X, size );
}
}
Vollständige Beispiele für Anpassung an Polynome, allgemeine lineare und allgemeine nicht-lineare Modelle sind in den Dateien FITDEMO.CPP, FITDEMOW.CPP, FITDEMOB.BPR, FITDEMO.PAS und FITDEMO.DPR enthalten.
VF_NONLINFITOPTIONS
Die nichtlinearen Anpassungs-Routinen von OptiVecsind sehr vielseitig einstellbar mit Hilfe von Optionen, die in einer Struktur (struct in C/C++, record in Pascal/Delphi) namens VF_NONLINFITOPTIONS zusammengefasst sind. Diese besteht aus den folgenden Feldern:
int FigureOfMerit; | 0: kleinste Fehlerquadrate als Qualitätskriterium der Anpassung
1: "robuste" Anpassung, die auf betragsmäßig minimale Abweichung hin optimiert
(Standard: 0) |
float AbsTolChi; | absolute Änderung von c2 (Standard: EPSILON) |
float FracTolChi; | relative Änderung von c2 (Standard: SQRT_EPSILON) |
float AbsTolPar; | absolute Änderung aller Parameter (Standard: SQRT_MIN) |
float FracTolPar; | relative Änderung aller Parameter (Standard: SQRT_EPSILON)
Die vier xxxTolChi und xxxTolPar-Parameter beschreiben die Konvergenz-Kriterien: Wenn die in aufeinanderfolgenden Iterationen erreichten Verbesserungen kleiner als nach Maßgabe dieser Parameter verlangt ausfällt, signalisiert dies erreichte Konvergenz. Nicht-anwendbare Kriterien sollten auf 0.0 gesetzt werden. Mindestens ein Konvergenz-Kriterium muss aber ungleich 0 sein! |
unsigned HowOftenFulfill; | Wie oft hintereinander soll eine der obigen Begingungen erfüllt sein, bevor Konvergenz als erreicht betrachtet wird? (Standard: 3) |
unsigned LevelOfMethod; | 1: Levenberg-Marquardt-Methode,
2: Downhill Simplex-Methode nach Nelder und Mead,
3: beide Methoden abwechselnd;
man addiere hierzu 4, um auch einen "Ausbruch" aus lokalen Minima zu versuchen, in denen die Routine ansonsten "hängenbleiben" würde, ohne jemals das globale Minimum zu erreichen;
0: keine Anpassung, nur FOM (also c2 oder |c|) und ggf. Covar berechnen
(Standard: 1) |
unsigned LevMarIterations; | max. Anzahl erfolgreicher LevMar -Iterationen während eines Durchgangs (Standard: 100) |
unsigned LevMarStarts; | Anzahl von LevMar-Neustarts pro Durchgang (Standard: 2) |
float LambdaStart,
LambdaMin,
LambdaMax,
LambdaDiv,
LambdaMul; | Behandlung des LevMar-Parameters Lambda (nicht verändern, außer Sie kennen sich mit dem Algorithmus aus!) |
unsigned DownhillIterations; | max. Anzahl erfolgreicher Downhill-Simplex-Iterationen während eines Durchgangs (Standard: 200) |
float DownhillReflection,
DownhillContraction,
DownhillExpansion; | Behandlung der Form-Anpassung des Simplex in der Downhill-Simplex-Methode (nicht verändern, außer Sie kennen sich mit dem Algorithmus aus!) |
unsigned TotalStarts; | max. Anzahl von LevMar/Downhill-Paaren (Standard: 16) |
float FOMThreshForBreakout; | Schwellenwert für die Auslösung eines "Ausbruchs-Versuchs" aus eventuellen lokalen Optima. Dieser Parameter spielt natürlich nur dann eine Rolle, wenn bei LevelOfMethod 5, 6 oder 7 gesetzt wurde. Falls Sie wissen, in welcher Größenordnung Ihr c2 bzw. |c| bei einer erfolgreichen Anpassung zu erwarten ist, können Sie FOMThreshForBreakout etwas höher als diesen Erwartungswert setzen, um die meist recht langwierige "Ausbruchs-Routine" nicht unnötig in Gang zu setzen. (Standard: 0.0; der "Ausbruch" wird also immer versucht, wenn LevelOfMethod 5, 6 oder 7 ist) |
float BreakoutFenceHeightRel; | Um von einem lokalen Optimum einer Datenanpassung in ein anderes und schließlich in das gesuchte globale Optimum zu gelangen, oder auch nur, um sicherzustellen, dass ein gefundenes Optimum tatsächlich das globale ist, muss die Routine gewissermaßen über einen Wall oder einen Zaun zu klettern versuchen. Der Parameter BreakoutFenceHeightRel gibt an, bis zu welcher Höhe, gemessen als Vielfaches des besten erreichten Wertes von c2 bzw. |c|, sich die Routine an dem "Zaun" emportastet. Findet sie dabei einen Parameter-Satz auf der "anderen Seite" des Zaunes, der eine bessere Anpassung liefert, so wird das so gefundene neue lokale Optimum seinerseits auf gleiche Weise daraufhin überprüft, ob sich jenseits von ihm eventuell eine bessere Anpassung finden lässt. Die Suche endet, wenn die Routine den "Zaun" in allen Richtungen (also für jeden einzelnen angepassten Parameter) bis zum angegebenen Vielfachen von c2 bzw. |c| hochgeklettert ist, ohne eine bessere Lösung zu finden. Sie endet ebenfalls, wenn sie an die die Grenzen der angepassten Parameter stößt (siehe unten: UpperLimits, LowerLimits, Restrict). Ein zu niedriger Wert von BreakoutFenceHeightRel führt dazu, dass die Routine eventuell zu früh die Suche aufgibt; ein zu hoher Wert kann die Laufzeit u.U. stark verlängern. (Standardeinstellung: 2.0) |
float BreakoutFenceHeightAbs; | Anstatt die "Zaun-Höhe" beim Ausbruchsversuch relativ zum bislang besten Wert von c2 bzw. |c| anzugeben (siehe die vorige Option), kann mit Hilfe dieser Option auch ein Absolutwert festgelegt werden, um den die Routine den Zaun emporzuklettern hat, bevor das gefundene Optimum als globales Optimum anerkannt wird. (Standard: FLT_MAX; diese Option hat also standardmäßig keine Wirkung) |
fVector UpperLimits, LowerLimits; | obere und/oder untere Grenzen für die Parameter festlegen. Standard für beides: NULL or nil |
void (*Restrictions)(fVector A); | Zeiger zu einer benutzerdefinierten Funktion, die Beschränkungen der Parameter implementiert, die nicht als einfache Unter- und Obergrenzen formuliert werden können. Diese Funktion muss den ganzen Parameter-Vektor A prüfen und die Parameter nach Bedarf editieren. Standard: NULL or nil.
Ein Beispiel für den Einsatz von Restrictions wäre ein Modell, in dem die Parameter Ai in (auf- oder absteigender) Ordnung sein müssen. Ihre Restrictions-Funktion würde dann VF_sort aufrufen, um diese Ordnung durch eventuellen Austausch von Ai-Einträgen zu garantieren. Von solchen doch sehr speziellen Fällen abgesehen, ist es aber generell besser, Restrictions gar nicht zu nutzen, sondern die nonlinfit-Routine ihre Arbeit ohne "Einmischung" tun zu lassen. |
Diese Optionen können beim Aufruf jeder einzelnen nonlinfit-Funktion als Parameter FitOptions vom Typ VF_NONLINFITOPTIONS übergeben werden. Wie oben erwähnt, existieren alle nonlinfit-Funktionen auch in einer vereinfachten Syntax, die auf diesen Parameter verzichtet und stattdessen voreingestellte Standard-Werte verwendet. Diese wiederum lassen sie sich durch Aufruf der Funktion V_setNonlinfitOptions für alle künftigen Aufrufe ändern. Um die aktuell eingestellten Optionen zu lesen, rufe man V_getNonlinfitOptions. Um die "Fabrik-Einstellung" wiederherzustellen, rufe man V_setNonlinfitDefaultOptions. Um sie (z.B. als Startpunkt für eine eigene Zusammenstellung) zu lesen, rufe man V_getNonlinfitDefaultOptions.
Durch Aufruf von V_setNonlinfitOptions gesetzte Optionen gelten nur dann, wenn kein Optionen-Satz explizit an VF_nonlinfit usw. übergeben, sondern der entsprechende Parameter mit NULL / nil angegeben wird (oder wenn die vereinfachte Syntax angewandt wird, die diesen Parameter gar nicht erst enthält).
VF_NONLINFITWORKSPACE
Wie oben beschrieben, benötigen alle nicht-linearen Anpassungsfunktionen einen Satz von internen Variablen, der zusammengefasst als struct (Delphi: record) VF_NONLINFITWORKSPACE über seine Adresse an die jeweilige Funktion übergeben und wiederum von dieser verwendet wird, um alle benötigten Daten an Unter- und Hilfsfunktionen zu übergeben. Dieser Variablen-Satz muss nicht initialisiert werden; er enthält keine nutzbaren Informationen für den Anwender. Bei den Funktionen der MF_nonlinfit-Familie wird analog ein (von VF_NONLINFITWORKSPACE leicht verschiedener) Variablen-Satz als MF_NONLINFITWORKSPACE benötigt.
Man schreibe also in C/C++:
VF_NONLINFITWORKSPACE ws;
VF_NONLINFITOPTIONS fopt;
V_getNonlinfitOptions( &fopt );
// an dieser Stelle "fopt" nach Bedarf modifizieren...
VF_nonlinfit( ParValues, AStatus, nParameters, X, Y, sz, ModelFunc, DerivativeFuncs, &ws, &fopt );
oder in Delphi:
ws: VF_NONLINFITWORKSPACE;
fopt: V_NONLINFITOPTIONS;
V_getNonlinfitOptions( @fopt );
// an dieser Stelle "fopt" nach Bedarf modifizieren...
VF_nonlinfit( ParValues, AStatus, nParameters, X, Y, sz, @ModelFunc, @DerivativeFuncs, @ws, @fopt );
Wird beim Aufruf von VF_nonlinfit der entsprechende Paremeter gleich NULL / nil gesetzt, so erzeugt und verwendet die aufgerufene Funktion ihren eigenen Workspace.
13.4 Anpassung von Mehrfach-Datensätzen
Zusätzlich zu den Funktionen für einfache Datensätze gibt es Routinen für die simultane Anpassung mehrerer Datensätze an eine gemeinsame Modellfunktion. Angenommen, ein Physiker oder Chemiker misst eine Geschwindigkeitskonstante k. Er hat dieselbe kinetische Messung zehn Mal unter geringfügig variierenden Bedingungen durchgeführt. Alle diese Messungen haben natürlich dasselbe k, aber andere Parameter (wie z.B. Amplitude und Zeit-Nullpunkt) werden sich von Experiment zu Experiment unterscheiden. Nun ist der übliche Weg, eine Anpassung für jeden dieser zehn Datensätze durchzuführen und anschließend über die resultierenden k's zu mitteln.
Dieses Vorgehen ist aber problematisch: Man weiß nicht genau, welche Wichtung den einzelnen Messungen zukommen soll und wie die überlappenden Fehlerbreiten der einzelnen Anpassungen zu behandeln sind. Man könnte sich wünschen, stattdessen alle Datensätze gleichzeitig anzupassen und hierbei dasselbe k für alle Datensätze zu verlangen, jedem einzelnen aber seine eigene Amplitude, Zeit-Nullpunkt etc. zuzugestehen. Dies ist exakt, was die multiLinfit- und multiNonlinfit-Funktionen von MatrixLib leisten. Man kann Mehrfach-Datensätze sowohl an lineare als auch an nicht-lineare Modellfunktionen anpassen, und zwar für Y = f(X)- ebenso wie für MZ = f(X,Y)-Daten.
Die multiLinfit- und multiNonlinfit-Funktionen benötigen die Eingabe-Daten in Form von Strukturen VF_EXPERIMENT für X-Y-Daten und MF_EXPERIMENT für X-Y-ZDaten. In C/C++ hat VF_EXPERIMENT die folgenden Felder:
fVector X, Y; | X und Y-Vektoren: unabhängige Variable x und gemessene Daten y=f(x) |
fVector InvVar; | Kehrwert der Varianzen der einzelnen Meßwerte (wird nur für die "gewichteten" Varianten benötigt) |
ui size; | Zahl der x-y-Meßwerte |
float WeightOfExperiment; | Gewicht, das dem gesamten Experiment zugewiesen werden soll (wiederum nur für die "gewichteten" Varianten benötigt) |
MF_EXPERIMENT hat in C/C++ die folgenden Felder:
fVector X, Y; | X und Y-Vektoren (unabhängige Variablen x und y) |
fMatrix Z; | gemessene z=f(x,y)-Daten |
fMatrix InvVar; | Kehrwert der Varianzen der einzelnen Meßwerte (wird nur für die "gewichteten" Varianten benötigt) |
ui htZ, lenZ; | Matrix-Dimensionen |
float WeightOfExperiment; | Gewicht, das dem gesamten Experiment zugewiesen werden soll (wiederum nur für die "gewichteten" Varianten benötigt) |
In Pascal/Delphi sind VF_EXPERIMENT und MF_EXPERIMENT wie folgt definiert:
type VF_EXPERIMENT = record
X, Y, InvVar: fVector;
size: UIntSize;
WeightOfExperiment: Single;
end;
type PVF_EXPERIMENT = ^VF_EXPERIMENT;
type MF_EXPERIMENT = record
X, Y: fVector;
MZ, MInvVar: fMatrix;
htZ, lenZ:UIntSize;
WeightOfExperiment: Single;
end;
type PMF_EXPERIMENT = ^MF_EXPERIMENT;
Sowohl in VF_EXPERIMENT als auch in MF_EXPERIMENT sollten InvVar und WeightOfExperiment nur für die gewichteten Varianten der multifit-Funktionen gesetzt werden.
13.5 Hilfs-Funktionen für nichtlineare Anpassungen
Da nichtlineare Anpassungen - vor allem mit Mehrfach-Datensätzen - sich ziemlich langwierig gestalten und äußerst zeitaufwendig werden können (manchmal viele Stunden, selbst mit modernen Rechnern!), wurde eine Anzahl von Funktionen aufgenommen, die es erlauben, den Verlauf nichtlinearer Anpassungen zu verfolgen. Die Namen dieser Funktionen werden stets von der Anpassungs-Funktion abgeleitet, zu der sie gehören. Z.B. heißen die Hilfsfunktionen zu VF_nonlinfit:
Für die übrigen nicht-linearen Anpassungs-Funktion ergeben sich die Namen der Hilfsfunktionen durch Ersetzen des Präfixes "VF_nonlinfit_" durch den jeweiligen Fit-Funktions-Namen wie z.B. VF_nonlinfitwW_getBestValues, MF_multiNonlinfit_stop usw.
Es gibt zwei Möglichkeiten, diese Funktionen aufzurufen. Erstens können sie aus der ja vom Benutzer zu schreibenden Modellfunktion heraus angesprochen werden. Sie könnten hierfür beispielsweise einen Zähler in Ihrer Modellfunktion installieren, der alle 1000 Aufrufe das erreichte c2, den Parametersatz usw. ausliest. Der zweite Weg steht nur Multithread-Programmen offen: Ein Thread führt die Anpassung aus, und ein weiterer ist für den Aufruf der obigen Hilfs-Funktionen zuständig, um den Fortgang der Anpassung zu überprüfen.
Beide Wege verlangen, dass der verwendete VF_NONLINFITWORKSPACE global zugänglich ist. Wenn eine Nonlinfit-Funktion aus mehreren Threads gleichzeitig aufgerufen wird, gibt es natürlich ein Problem, vor allem, wenn der Aufruf der Hilfsfunktionen aus der Modellfunktion heraus erfolgen soll: Woher soll die Modellfunktion "wissen", von welchem Thread heraus sie aufgerufen wurde? Die Lösung: Man speichere einen Thread-Index in den einzelnen Parameter-Vektoren A. Dies könnte in Ihrem Hauptprogramm beispielsweise so ähnlich aussehen wie:
float A1[11], A2[11], ...;
int AStatus1[11], AStatus2[11], ...;
VF_NONLINFITWORKSPACE ws1, ws2, ...;
....
VF_random( A1, 10, 1, -1.0, +1.0 ); // Startwerte
VI_equC( AStatus1, 10, 1 ); // die ersten 10 Parameter sollen angepasst werden
A1[10] = 1; // Thread-Index = 1
AStatus1[10] = 0; // der Thread-Index bleibt natürlich eingefroren
... Thread #1 erzeugen mit VF_nonlinfit und A1, AStatus1, ws1 als Argumenten
VF_random( A2, 10, 1, -1.0, +1.0 ); // Startwerte des 2. Satzes
VI_equC( AStatus2, 10, 1 ); // wieder die ersten 10 Parameter anpassen
A2[10] = 2; // Thread-Index = 2
AStatus2[10] = 0; // Thread-Index wieder eingefroren
... Thread #2 erzeugen mit VF_nonlinfit und A2, AStatus2, ws2 als Argumenten
In Ihrer Modellfunktion hätten Sie dann etwas in der Art von:
void ModelFunc( fVector Y, fVector X, ui size, fVector A )
{
static unsigned counter1=0, counter2=0, ...;
float CurrentFOM;
....
switch( (unsigned)(A[10]) )
{
case 1: if( (++counter1 % 1024) == 0 )
{ CurrentFOM = VF_nonlinfit_getFOM( ws1 );
printf( "\nCount 1: %u, FOM: %f", counter1, CurrentFOM );
} break;
case 1: if( (++counter2 % 1024) == 0 )
{ CurrentFOM = VF_nonlinfit_getFOM( ws2 );
printf( "\nCount 2: %u, FOM: %f", counter2, CurrentFOM );
} break;
....
}
....
}
Zurück zum Inhaltsverzeichnis
14. Matrix-Eingabe und -Ausgabe
Die Ein- und Ausgabefunktionen für Matrizen sind analog den entsprechenden Vektor-Funktionen
MF_cprint |
Matrix auf dem Bildschirm ausgeben. Falls nötig, werden Zeilen am Bildschirmrand abgeschnitten. Falls mehr Zeilen auszugeben sind als auf einen Schirm passen, wird die Matrix auf mehrere Seiten aufgeteilt. (nur für Konsolen-Anwendungen) |
MF_print | Matrix auf dem Bildschirm ausgeben (ohne Abschneiden von Zeilen und ohne Aufteilung auf mehrere Seiten; nur für Konsolen-Anwendungen) |
MF_fprint | Matrix im ASCII-Format in einen Stream schreiben |
MF_store | im Binärformat speichern |
MF_recall | im Binärformat einlesen |
MF_write | im ASCII-Format in einen Stream schreiben |
MF_read | im ASCII-Format von einem Stream einlesen |
Zurück zum Inhaltsverzeichnis
15. Graphische Darstellung von Matrizen
Echte 3D-Darstellungs-Funktionen sind künftigen Versionen vorbehalten. Zur Zeit ist lediglich die Darstellung mittels Umsetzung von numerischen Werten in Farbtöne enthalten (engl.: color density plots). Hierbei wird ein Farbwert durch lineare Interpolation zwischen zwei als mincolor und maxcolor spezifizierten Farben gewonnen.
MF_xyzAutoDensityMap | Farbton-Plot für z=f(x,y) mit automatischer Skalierung der x und y-Achsen und der Farbton-Skala zwischen mincolor und maxcolor |
MF_xyzDataDensityMap | Farbton-Plot für z=f(x,y) in ein bereits existierendes Koordinatensystem unter Verwendung der durch einen früheren Aufruf einer AutoDensityMap-Funktion berechneten Farbton-Skala |
MF_zAutoDensityMap | Farbton-Plot für z=f(i,j) mit automatischer Skalierung der x und y-Achsen und der Farbton-Skala zwischen mincolor und maxcolor. i und j sind die Matrix-Indizes in x und y-Richtung |
MF_zDataDensityMap | Farbton-Plot für z=f(i,j) in ein bereits existierendes Koordinatensystem unter Verwendung der durch einen früheren Aufruf einer AutoDensityMap-Funktion berechneten Farbton-Skala |
M_setDensityBounds | Festsetzen einer Farbton-Skala |
M_setDensityMapBounds | Festsetzen einer Farbton-Skala und Zeichnung eines X-Y-Koordinatensystems |
M_findDensityMapBounds | Berechnung einer Farbton-Skala und Zeichnung eines X-Y-Koordinatensystems, wobei sichergestellt wird, dass die Rasterlinien des Koordinatensystems jeweils exakten (und nicht nur gerundeten) Zahlenwerten entsprechen |
Zurück zum Inhaltsverzeichnis
16. Alphabetische Referenz für MatrixLib
Ab hier werden alle MatrixLib-Funktionen in alphabetischer Reihenfolge detailliert beschrieben. Ähnlich der VectorLib-Referenz in FUNKREF.HTM wird das Präfix MF_ oder M_ bei der Einordnung ignoriert. Die Partikel "Row_", "Rows_", "Col_", "Cols_", "Dia_" und "Trd_" werden aber berücksichtigt. Z.B. werden "MF_Rows_"-Funktionen hinter allen "MF_Row_"-Funktionen eingeordnet. Obwohl die meisten MatrixLib-Funktionen mit "M" beginnende Präfixe besitzen (MF_, M_ usw.), besitzen einige – namentlich die X-Y-Datenanpassungs-Funktionen – das Präfix VF_ als eine Erinnerung daran, dass sie tatsächlich Vektoren verarbeiten, obwohl sie intern Matrix-Methoden anwenden und daher zu MatrixLib gehören. In Fällen, wo sowohl eine VF_ als auch eine MF_-Version existieren, wird entgegen der alphabetischen Reihenfolge die VF_-Version als erste beschrieben, da sie die einfachere ist.
MF_accElement | MD_accElement | ME_accElement |
MCF_accElement | MCD_accElement | MCE_accElement |
MCF_accElementRe | MCD_accElementRe | MCE_accElementRe |
MCF_accElementIm | MCD_accElementIm | MCE_accElementIm |
MI_accElement | MBI_accElement | MSI_accElement | MLI_accElement | MQI_accElement | |
MU_accElement | MUB_accElement | MUS_accElement | MUL_accElement | MUQ_accElement | MUI_accElement |
|
Funktion | Ein Matrix-Element um einen bestimmten Wert erhöhen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_accElement( fVector MA, ui ht, ui len, ui m, ui n, float C );
#include <MCFstd.h>
void MCF_accElement( cfMatrix MA, ui ht, ui len, ui m, ui n, fComplex C );
void MCF_accElementRe( fMatrix MA, ui ht, ui len, ui m, ui n, float C );
void MCF_accElementIm( fMatrix MA, ui ht, ui len, ui m, ui n, float C ); |
C++ VecObj | #include <OptiVec.h>
matrix<T>::accElement( ui ht, ui len, ui m, ui n, T C );
matrix<complex<T>>::accElement( ui ht, ui len, ui m, ui n, complex<T> C );
matrix<complex<T>>::accElementRe( ui ht, ui len, ui m, ui n, T C );
matrix<complex<T>>::accElementIm( ui ht, ui len, ui m, ui n, T C ); |
Pascal/Delphi | uses MFstd;
procedure MF_accElement( MA:fVector; ht, len, m, n:UIntSize; C:Single );
uses MCFstd;
procedure MCF_accElement( MA:cfMatrix; ht, len, m, n:UIntSize; C:fComplex );
procedure MCF_accElementRe( MA:cfMatrix; ht, len, m, n:UIntSize; C:Single );
procedure MCF_accElementIm( MA:cfMatrix; ht, len, m, n:UIntSize; C:Single );
|
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
void cudaMF_accElement( fMatrix d_MA, ui ht, ui len, ui m, ui n, float C );
void cusdMF_accElement( fMatrix d_MA, ui ht, ui len, ui m, ui n, float *d_C );
#include <cudaMCFstd.h>
void cudaMCF_accElement( cfMatrix d_MA, ui ht, ui len, ui m, ui n, fComplex C );
void cusdMCF_accElement( cfMatrix d_MA, ui ht, ui len, ui m, ui n, fComplex *d_C );
void cudaMCF_accElementRe( cfMatrix d_MA, ui ht, ui len, ui m, ui n, float C );
void cusdMCF_accElementRe( cfMatrix d_MA, ui ht, ui len, ui m, ui n, float *d_C );
void cudaMCF_accElementIm( cfMatrix d_MA, ui ht, ui len, ui m, ui n, float C );
void cusdMCF_accElementIm( cfMatrix d_MA, ui ht, ui len, ui m, ui n, float *d_C );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
procedure cudaMF_accElement( d_MA:fMatrix; ht, len, m, n:UIntSize; C:Single );
procedure cusdMF_accElement( d_MA:fMatrix; ht, len, m, n:UIntSize; d_C:PSingle );
uses MCFstd;
procedure cudaMCF_accElement( d_MA:cfMatrix; ht, len, m, n:UIntSize; C:fComplex );
procedure cusdMCF_accElement( d_MA:cfMatrix; ht, len, m, n:UIntSize; d_C:PfComplex );
procedure cudaMCF_accElementRe( d_MA:cfMatrix; ht, len, m, n:UIntSize; C:Single );
procedure cusdMCF_accElementRe( d_MA:cfMatrix; ht, len, m, n:UIntSize; d_C:PSingle );
procedure cudaMCF_accElementIm( d_MA:cfMatrix; ht, len, m, n:UIntSize; C:Single );
procedure cusdMCF_accElementIm( d_MA:cfMatrix; ht, len, m, n:UIntSize; d_C:PSingle );
|
|
Beschreibung | Reelle Versionen:
X[m][n] += C; Das Element an der Position m, n wird um den Wert C erhöht.
Komplexe Versionen MCF_accElement usw.:
X[m][n].Re += C.Re; X[m][n].Im += C.Im;
Komplexe Versionen MCF_accElementRe usw.:
X[m][n].Re += C.Re;
Der Imaginärteil X[m][n].Im bleibt unangetastet.
Komplexe Versionen MCF_accElementIm usw.:
X[m][n].Im += C.Im;
Der Realteil X[m][n].Re bleibt unangetastet.
|
|
|
|
|
MFs_addM |
MDs_addM |
MEs_addM |
MCF_addM |
MCD_addM |
MCE_addM |
|
Funktion | Element-weise Addition zweier Matrizen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_addM( fMatrix MC, fMatrix MA, fMatrix MB, ui ht, ui len );
void MFs_addM( fMatrix MC, fMatrix MA, fMatrix MB, ui ht, ui len, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::addM( const matrix<T>& MA, const matrix<T>& MB);
void matrix<T>::s_addM( const matrix<T>& MA, const matrix<T>& MB, const T& C); |
Pascal/Delphi | uses MFstd;
procedure MF_addM( MC, MA, MB:fMatrix; ht, len:UIntSize );
procedure MFs_addM( MC, MA, MB:fMatrix; ht, len:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_addM( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len );
int cudaMFs_addM( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len, float C );
int cusdMFs_addM( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len, float *d_C );
void MFcu_addM( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui ht, ui len );
void MFs_addM( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui ht, ui len, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_addM( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMFs_addM( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize; C:Single ): IntBool;
function cusdMFs_addM( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize; d_C:PSingle ): IntBool;
procedure MF_addM( h_MC, h_MA, h_MB:fMatrix; ht, len:UIntSize );
procedure MFs_addM( h_MC, h_MA, h_MB:fMatrix; ht, len:UIntSize; C:Single );
|
|
Beschreibung | Normalversion: MCij = MAij + MBij
Skalierte Version: MCij = C * (MAij + MBij) |
|
|
MF_addMT
| MD_addMT |
ME_addMT |
MFs_addMT |
MDs_addMT |
MEs_addMT |
MCF_addMT |
MCD_addMT |
MCE_addMT |
|
Funktion | Element-weise Addition einer Matrix und einer transponierten anderen Matrix |
|
Syntax C/C++ | #include <MFstd.h>
void MF_addMT( fMatrix MC, fMatrix MA, fMatrix MB, ui ht, ui len );
void MFs_addMT( fMatrix MC, fMatrix MA, fMatrix MB, ui ht, ui len, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::addMT( const matrix<T>& MA, const matrix<T>& MB);
void matrix<T>::s_addMT( const matrix<T>& MA, const matrix<T>& MB, const T& C); |
Pascal/Delphi | uses MFstd;
procedure MF_addMT( MC, MA, MB:fMatrix; ht, len:UIntSize );
procedure MFs_addMT( MC, MA, MB:fMatrix; ht, len:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_addMT( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len );
int cudaMFs_addMT( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len, float C );
int cusdMFs_addMT( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len, float *d_C );
void MFcu_addMT( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui ht, ui len );
void MFs_addMT( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui ht, ui len, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_addMT( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMFs_addMT( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize; C:Single ): IntBool;
function cusdMFs_addMT( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize; d_C:PSingle ): IntBool;
procedure MF_addMT( h_MC, h_MA, h_MB:fMatrix; ht, len:UIntSize );
procedure MFs_addMT( h_MC, h_MA, h_MB:fMatrix; ht, len:UIntSize; C:Single );
|
|
Beschreibung | Normalversion: MCij = MAij + MBTji
Skalierte Version: MCij = C * (MAij + MBTji) |
|
|
MF_autocorr
| MD_autocorr |
ME_autocorr |
MFb_autocorr
| MDb_autocorr |
MEb_autocorr |
|
Funktion | Räumliche Autokorrelations-Funktion |
|
Syntax C/C++ | #include <MFstd.h>
void MF_autocorr( fMatrix Y, fMatrix X, ui ht, ui len );
void MFb_autocorr( fMatrix Y, fMatrix X, ui ht, ui len, fVector Buf ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::autocorr( const matrix<T>& MX);
void matrix<T>::b_autocorr( const matrix<T>& MX, vector<T>& Buf); |
Pascal/Delphi | uses MFstd;
procedure MF_autocorr( MY, MX:fMatrix; ht, len:UIntSize );
procedure MFb_autocorr( MY, MX:fMatrix; ht, len:UIntSize; Buf:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_autocorr( fMatrix d_Y, fMatrix d_X, ui ht, ui len );
void MFcu_autocorr( fMatrix h_Y, fMatrix h_X, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_autocorr( d_MY, d_MX:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_autocorr( h_MY, h_MX:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Die räumliche Autokorrelations-Funktion (entl.: spatial autocorrelation function, SACF) von MX wird berechnet und in MY gespeichert. Dabei erhalten die Zeilen-Elemente MYi,0 bis MYi,len/2-1 die SACF für 0 und positive Verschiebungen in x-Richtung. Beginnend mit der größten negativen Verschiebung in MYi,len/2+1 enthalten die Elemente bis MYi,len-1 die SACF für negative Verschiebungen. Da diese Funktion MX als periodisch annimmt, ist die SACF für die größte positive Verschiebung gleich derjenigen für die größte negative Verschiebung. Dieses Element findet sich als Yi,len/2.
In ähnlicher Weise enthalten die Spalten-Elemente MY0,j bis MYlen/2-1,j die SACF für 0 und positive y-Verschiebungen. Beginnend mit der größten negativen Verschiebung in MYlen/2+1,j enthalten die Elemente bis MYlen-1,j die SACF für negative Verschiebungen.
Um die SACF in normale Reihenfolge zu bekommen, kann man die folgende Sequenz aufrufen:
MF_Rows_rotate( MY, ht, len, len/2 );
MF_Cols_rotate( MY, ht, len, ht/2 );
Danach befindet sich der Nullpunkt bei MYht/2,len/2.
Falls MX nicht-periodisch ist, sollten Randeffekte mit den bei MF_convolve beschriebenen Methoden vermieden werden.
Sowohl ht als auch len müssen ganzzahlige Potenzen von 2 sein.
Intern benötigt MF_autocorr zusätzlichen Pufferspeicher, der automatisch reserviert und wieder freigegeben wird. Bei wiederholten Aufrufen wäre dies ineffizient. Es wird empfohlen, für solche Fälle stattdessen MFb_autocorr zu verwenden. Die Größe von Buf muss dabei für C/C++ >= ht*(len+2) sein, fü Pascal/Delphi >= ht*len.Außerdem muss Buf 128-bit (P8) bzw. 256-bit( P9) ausgerichtet sein. Um dies zu garantieren, sollte man nur Vektoren als Buf verwenden, die mit der VF_vector-Familie alloziert wurden. |
|
Fehlerbehandlung | Falls entweder len oder ht nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf MF_autocorr basiert) mit der Fehlermeldung "Size must be an integer power of 2" und bricht das Programm ab. |
|
|
MF_block_equM
| MD_block_equM |
ME_block_equM |
MCF_block_equM |
MCD_block_equM |
MCE_block_equM |
MI_block_equM | MBI_block_equM | MSI_block_equM | MLI_block_equM | MQI_block_equM |
MU_block_equM | MUB_block_equM | MUS_block_equM | MUL_block_equM | MUQ_block_equM |
|
Funktion | Matrix in einen Block einer anderen Matrix kopieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_block_equM( fMatrix Dest,
unsigned destHt, unsigned destLen,
unsigned firstRow, ui firstCol,
fMatrix Srce, unsigned srceHt, unsigned srceLen ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::block_equM( const ui firstRow, const ui firstCol, const matrix<T>& MSrce); |
Pascal/Delphi | uses MFstd;
procedure MF_block_equM( MDest:fMatrix;
destHt, destLen, firstRow, firstCol:UIntSize;
MSrce:fMatrix; srceHt, srceLen:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_block_equM( fMatrix d_Dest,
unsigned destHt, unsigned destLen,
ui firstRow, ui firstCol,
fMatrix d_Srce, ui srceHt, ui srceLen );
void MFcu_block_equM( fMatrix h_Dest,
unsigned destHt, unsigned destLen,
ui firstRow, ui firstCol,
fMatrix h_Srce, ui srceHt, ui srceLen ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_block_equM( d_MDest:fMatrix;
destHt, destLen, firstRow, firstCol:UIntSize;
d_MSrce:fMatrix; srceHt, srceLen:UIntSize ): IntBool;
procedure MF_block_equM( h_MDest:fMatrix;
destHt, destLen, firstRow, firstCol:UIntSize;
h_MSrce:fMatrix; srceHt, srceLen:UIntSize );
|
|
Beschreibung | MDesti+firstRow, j+firstCol = MSrcei, j, i=0,...,srceHt-1; j=0,...,srceLen-1 |
|
|
MF_block_equMT
| MD_block_equMT |
ME_block_equMT |
MCF_block_equMT |
MCD_block_equMT |
MCE_block_equMT |
MI_block_equMT | MBI_block_equMT | MSI_block_equMT | MLI_block_equMT | MQI_block_equMT |
MU_block_equMT | MUB_block_equMT | MUS_block_equMT | MUL_block_equMT | MUQ_block_equMT |
|
Funktion | Transponierte Matrix in einen Block einer anderen Matrix kopieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_block_equMT( fMatrix Dest,
unsigned destHt, unsigned destLen,
unsigned firstRow, unsigned firstCol,
fMatrix Srce, ui srceHt, ui srceLen ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::block_equMT( const ui firstRow, const ui firstCol, const matrix<T>& MSrce); |
Pascal/Delphi | uses MFstd;
procedure MF_block_equMT( MDest:fMatrix;
destHt, destLen, firstRow, firstCol:UIntSize;
MSrce:fMatrix; srceHt, srceLen:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_block_equMT( fMatrix d_Dest,
unsigned destHt, unsigned destLen,
ui firstRow, ui firstCol,
fMatrix d_Srce, ui srceHt, ui srceLen );
void MFcu_block_equMT( fMatrix h_Dest,
unsigned destHt, unsigned destLen,
ui firstRow, ui firstCol,
fMatrix h_Srce, ui srceHt, ui srceLen ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_block_equMT( d_MDest:fMatrix;
destHt, destLen, firstRow, firstCol:UIntSize;
d_MSrce:fMatrix; srceHt, srceLen:UIntSize ): IntBool;
procedure MF_block_equMT( h_MDest:fMatrix;
destHt, destLen, firstRow, firstCol:UIntSize;
h_MSrce:fMatrix; srceHt, srceLen:UIntSize );
|
|
Beschreibung | MDesti+firstRow, j+firstCol = MSrcej, i, i=0,...,srceLen-1; j=0,...,srceHt-1 |
|
|
|
Funktion | Datentyp-Umwandlungen. Siehe M_FtoD.
|
|
MF_centerOfGravityInd | MD_centerOfGravityInd | ME_centerOfGravityInd |
|
Funktion | Schwerpunkt einer Matrix bezüglich der Element-Indizes |
|
Syntax C/C++ | #include <MFstd.h>
fComplex MF_centerOfGravityInd( fMatrix MA, ui ht, ui len ); |
C++ VecObj | #include <OptiVec.h>
complex<T> matrix<T>::centerOfGravityInd(); |
Pascal/Delphi | uses VFstd;
procedure MF_centerOfGravityInd( var COG:fComplex; MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_centerOfGravityInd( fComplex *h_RetVal, fMatrix d_MA, ui ht, ui len );
int cusdMF_centerOfGravityInd( fComplex *d_RetVal, fMatrix d_MA, ui ht, ui len );
fComplex MFcu_centerOfGravityInd( fMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_centerOfGravityInd( var h_RetVal:fComplex; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
function cusdMF_centerOfGravityInd( d_RetVal:PfComplex; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
function MFcu_centerOfGravityInd( h_MA:fMatrix; ht, len:UIntSize ): fComplex
Alternative Syntax:
procedure MFcu_centerOfGravityInd( var h_RetVal:fComplex; h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Der Schwerpunkt der Matrix MA wird berechnet. Dabei wird angenommen, dass die Werte von MA Punkt-Massen darstellen, die sich jeweils an der durch ihre Element-Indizes gegebenen Position befinden. Der Schwerpunkt wird als komplexe Zahl berechnet, deren Realteil die X-Koordinate und deren Imaginärteil die Y-Koordinate der Schwerpunkts-Position enthält. Man beachte, dass diese Reihenfolge der Koordinaten umgekehrt zu der Reihenfolge der Indizierung der Matrix-Elemente ist (hier gibt ja der zuerst stehende Index die i-te Zeile an, entspricht also einer Y-Koordinate). Falls alle Elemente von MA gleich 0 sind, so gibt es zwar keine Masse und strenggenommen auch keinen Schwerpunkt. Dieser wird dann jedoch als der Mittelpunkt von MA angenommen, also als ( (len-1) / 2; ( (ht-1) / 2; ).
Um den Schwerpunkt einer MZ-Matrix über explizit gegebenen X-Y-Koordinaten zu berechnen, rufe man MF_centerOfGravityV. |
|
|
Rückgabewert | (Interpolierte) Koordinaten des Schwerpunktes |
|
|
MF_chexprint
| MD_chexprint |
ME_chexprint |
MCF_chexprint |
MCD_chexprint |
MCE_chexprint |
MI_chexprint | MBI_chexprint | MSI_chexprint | MLI_chexprint | MQI_chexprint |
MU_chexprint | MUB_chexprint | MUS_chexprint | MUL_chexprint | MUQ_chexprint |
|
Funktion | Matrix auf dem Bildschirm ausgeben (nur für Konsolen-Anwendungen) |
|
Syntax C/C++ | #include <MFstd.h>
void MF_chexprint( fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::chexprint(); |
Pascal/Delphi | uses MFstd;
procedure MF_chexprint( MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_chexprint( fMatrix d_MA, ui ht, ui len );
int cudaMF_chexprint_buf( fMatrix d_MA, ui ht, ui len, fVector h_Wk );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_chexprint( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMF_chexprint_buf( d_MA:fMatrix; ht, len:UIntSize; h_Wk:fVector ): IntBool;
|
|
Beschreibung | Die Matrix A wird im Hexadezimal-Format auf dem Bildschirm ausgegeben. Jede Bildschirm-Zeile entspricht einer Zeile der Matrix. Die Zeilen werden von 0 and numeriert. Falls nötig, werden die Zeilen am Bildschirmrand abgeschnitten. Falls mehr Zeilen auszugeben sind, als auf den Bildschirm passen, wird die Matrix in mehrere Seiten aufgespalten.
Cartesisch-komplexe Zahlen werden in geschweiften Klammern mit einem Komma zwischen dem Real- und dem Imaginärteil geschrieben: {Re, Im}.
Diese Familie von Funktionen ist nur für Konsolenanwendungen verwendbar. |
nur CUDA-Versionen: | cudaM?_chexprint_buf übernimmt einen Host-Vektor h_Wk als zusätzliches Argument. Dieser dient als Pufferspeicher und muss (mindestens) dieselbe Größe haben wie X. Hierdurch wird die interne Bereitstellung von Pufferspeicher bei cudaM?_chexprint eingespart, so dass cudaM?_chexprint_buf etwas schneller ist. |
Andere Windows-Compiler sowie Linux: |
Da hier die Textfenster-Breite und Höhe nicht ohne weiteres verfügbar sind, werden Aufrufe von M?_chexprint nach MF_hexprint umgeleitet.
Dieselbe Umleitung erfolgt auch für Visual C++ mit statischer Laufzeitbibliothek, hier wegen Inkompatibilitäten zwischen den verschiedenen Visual C++-Versionen. |
|
Fehlerbehandlung | Wenn die Zahl der Spalten die maximal im derzeitigen Text-Modus mögliche Zahl der Einträge übersteigt, wird eine Fehlermeldung "Cannot use requested format (too many entries per line)!" ausgegeben; in diesem Fall, werden die Zeilen abgeschnitten und das Programm danach fortgesetzt.
|
|
|
MF_centerOfGravityInd | MD_centerOfGravityInd | ME_centerOfGravityInd |
|
Funktion | Schwerpunkt einer MZ-Matrix über gegebenen X- und Y-Achsen |
|
Syntax C/C++ | #include <MFstd.h>
fComplex MF_centerOfGravityV( fVector X, fVector Y, fMatrix MZ, ui ht, ui len ); |
C++ VecObj | #include <OptiVec.h>
complex<T> matrix<T>::centerOfGravityV( const vector<T>& X, const vector<T>& Y ); |
Pascal/Delphi | uses MFstd;
procedure MF_centerOfGravityV( var COG:fComplex; X, Y:fVector; MZ:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_centerOfGravityV( fComplex *h_RetVal, fVector d_X, fVector d_Y, fMatrix d_MZ, ui ht, ui len );
int cusdMF_centerOfGravityV( fComplex *d_RetVal, fVector d_X, fVector d_Y, fMatrix d_MZ, ui ht, ui len );
fComplex MFcu_centerOfGravityV( fVector h_X, fVector h_Y, fMatrix h_MZ, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_centerOfGravityV( var h_RetVal:fComplex; d_X, d_Y:fVector; d_MZ:fMatrix; ht, len:UIntSize ): IntBool;
function cusdMF_centerOfGravityV( d_RetVal:PfComplex; d_X, d_Y:fVector; d_MZ:fMatrix; ht, len:UIntSize ): IntBool;
function MFcu_centerOfGravityV( h_X, h_Y:fVector; h_MZ:fMatrix; ht, len:UIntSize ): fComplex
Alternative Syntax:
procedure MFcu_centerOfGravityV( var h_RetVal:fComplex; h_X, h_Y:fVector; h_MZ:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Der Schwerpunkt der Matrix MZ über dem durch X und Y aufgespannten Koordinatensystem wird berechnet. Dabei wird angenommen, dass die Werte von MZ Punkt-Massen darstellen, die sich an den durch X und Y bestimmten Positionen befinden. Falls alle Elemente von MZ gleich 0 sind, so gibt es zwar keine Masse und strenggenommen auch keinen Schwerpunkt. Dieser wird dann jedoch als geometrischer Mittelpunkt von MA angenommen, also als ( (X[size-1)] - X[0]) / 2; (X[size-1)] - X[0]) / 2; ).
Um den Schwerpunkt einer Matrix über den durch die Indizes gegebenen Achsen zu berechnen, rufe man MF_centerOfGravityInd. |
|
|
Rückgabewert | Koordinaten des Schwerpunkts |
|
|
MF_CholeskyLdecompose
| MD_CholeskyLdecompose |
ME_CholeskyLdecompose |
MF_CholeskyRdecompose |
MD_CholeskyRdecompose |
ME_CholeskyRdecompose |
|
Funktion | Cholesky-Faktorisierung einer symmetrischen, positiv-definiten Matrix |
|
Syntax C/C++ | #include <MFstd.h>
int MF_CholeskyLdecompose( fMatrix ML, fMatrix MA, ui len );
int MF_CholeskyRdecompose( fMatrix MR, fMatrix MA, ui len );
|
C++ MatObj | #include <OptiVec.h>
void matrix<T>::CholeskyLdecompose( const matrix<T>& MA );
void matrix<T>::CholeskyRdecompose( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
function MF_CholeskyLdecompose( ML:fMatrix; MA:fMatrix; len:UIntSize ):Integer;
function MF_CholeskyRdecompose( MR:fMatrix; MA:fMatrix; len:UIntSize ):Integer;
|
|
Beschreibung | Die symmetrische Eingabematrix MA wird in ein Produkt MA = ML * MR zerlegt, wobei ML eine linke (untere) Dreiecksmatrix ist, und MR ist eine rechte (obere) Dreiecks-Matrix, wobei MR = MLT. Da also MR die Transponierte von ML ist, ist die vollständige Information in jeder der beiden einzeln enthalten. Daher kann man wählen, entweder mittels MF_CholeskyLdecompose ML zu erhalten oder mittels MF_CholeskyLdecompose MR. Nicht alle symmetrischen Matrizen lassen sich in dieser Weise zerlegen, sondern nur die sogenannten positiv-definiten.
MA darf von ML bzw. MR überschrieben werden, falls gewünscht.
Der Rückgabewert von MF_CholeskyLdecompose und MF_CholeskyRdecompose zeigt an, ob die Zerlegung erfolgreich war (Rückgabewert 0) oder ob die Eingabe-Matrix nicht-positiv-definit ist (Rückgabewert 1).
|
|
Fehlerbehandlung | Im Falle einer nicht-positiv-definiten Matrix bleibt ML bzw. MR undefiniert, und der Rückgabewert wird auf 1 gesetzt. |
|
Rückgabewert | Bei Erfolg FALSE(0), andernfalls TRUE (1) |
|
|
MF_CholeskyDet
| MD_CholeskyDet |
ME_CholeskyDet |
|
Funktion | Determinante einer Cholesky-faktorisierten symmetrischen Matrix |
|
Syntax C/C++ | #include <MFstd.h>
float MF_CholeskyDet( fMatrix MLR, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::CholeskyDet( const matrix<T>& MLR, int permut ); |
Pascal/Delphi | uses MFstd;
function MF_CholeskyDet( MLR:fMatrix; len:UIntSize ): Single; |
|
Beschreibung | MF_CholeskyDet berechnet die Determinante einer nach Cholesky-Faktorisierung bereits als ML oder MR vorliegenden symmetrischen Matrix und gibt sie als Skalar zurück. Dabei ist es gleichgültig, ob man ML oder MR verwendet. |
|
|
|
MF_CholeskyLimprove
| MD_CholeskyLimprove |
ME_CholeskyLimprove |
MF_CholeskyRimprove |
MD_CholeskyRimprove |
ME_CholeskyRimprove |
|
Funktion | iterative Genauigkeits-Verbesserung der über Cholesky-Faktorisierung erzielten Lösung eines symmetrischen linearen Gleichungs-Systems |
|
Syntax C/C++ | #include <MFstd.h>
void MF_CholeskyLimprove( fVector X, fVector B, fMatrix MA, fMatrix ML, ui len );
void MF_CholeskyRimprove( fVector X, fVector B, fMatrix MA, fMatrix MR, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::CholeskyLimprove( const vector<T> B, const matrix<T>& MA, const matrix<T>& ML );
void vector<T>::CholeskyRimprove( const vector<T> B, const matrix<T>& MA, const matrix<T>& MR ); |
Pascal/Delphi | uses MFstd;
procedure MF_CholeskyLimprove( X, B:fVector; MA, ML:fMatrix; len:UIntSize );
procedure MFb_CholeskyRimprove( X, B:fVector; MA, MR:fMatrix; len:UIntSize ); |
|
Beschreibung | Vor allem für große Matrizen können die akkumulierten Rundungsfehler bei der Lösung eines Gleichungssystems recht erheblich werden. Führt man aber die Lösung eines linearen Gleichungs-Systems über Cholesky-Zerlegung mittels MF_CholeskyLdecompose durch und bewahrt dabei die Eingabe-Matrix auf, so eröffnet sich die Möglichkeit, die numerische Genauigkeit der von MF_CholeskyLsolve berechneten Lösung iterativ zu verbessern. Hierzu rufe man anschließend an MF_CholeskyLsolve noch MF_CholeskyLimprove. Diese Funktion benötigt als Argumente: den Ausgabe-Vektor X von MF_CholeskyLsolve, den Vektor B des linearen Gleichungssystemes und sowohl die originale Matrix MA als auch deren Cholesky-faktorisierte Form ML. Exakt analog nutze man MF_CholeskyRimprove zur Verbesserung einer via MF_CholeskyRdecompose und MF_CholeskyRsolve gewonnen Lösung.
|
|
|
MF_CholeskyLinv
| MD_CholeskyLinv |
ME_CholeskyLinv |
MF_CholeskyRinv |
MD_CholeskyRinv |
ME_CholeskyRinv |
|
Funktion | Invertierung einer bereits Cholesky-faktorisierten symmetrischen Matrix |
|
Syntax C/C++ | #include <MFstd.h>
void MF_CholeskyLinv( fMatrix Inv, fMatrix ML, ui len );
void MF_CholeskyRinv( fMatrix Inv, fMatrix MR, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::CholeskyLinv( const matrix<T>& ML );
void matrix<T>::CholeskyRinv( const matrix<T>& MR ); |
Pascal/Delphi | uses MFstd;
procedure MF_CholeskyLinv( MInv, ML:fMatrix; len:UIntSize );
procedure MF_CholeskyRinv( MInv, MR:fMatrix; len:UIntSize ); |
|
Beschreibung | MF_CholeskyLinv invertiert eine ursprüglich symmetrische Matrix, die nach Cholesky-Zerlegung bereits in ML-Form vorliegt. Analog invertiert MF_CholeskyRinv invertiert eine bereits als MR vorliegende symmetrische Matrix. |
|
|
MF_CholeskyLsolve
| MD_CholeskyLsolve |
ME_CholeskyLsolve |
MF_CholeskyRsolve |
MD_CholeskyRsolve |
ME_CholeskyRsolve |
|
Funktion | symmetrisches lineares Gleichungs-System MA * X = B lösen, für das MA nach Cholesky-Faktorisierung bereits als ML oder MR vorliegt |
|
Syntax C/C++ | #include <MFstd.h>
void MF_CholeskyLsolve( fVector X, fMatrix ML, fVector B, ui len );
void MF_CholeskyRsolve( fVector X, fMatrix MR, fVector B, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::CholeskyLsolve( const matrix<T>& ML, const vector<T>& B );
void vector<T>::CholeskyRsolve( const matrix<T>& MR, const vector<T>& B ); |
Pascal/Delphi | uses MFstd;
procedure MF_CholeskyLsolve( X:fVector; ML:fMatrix; B:fVector; len:UIntSize );
procedure MF_CholeskyRsolve( X:fVector; MR:fMatrix; B:fVector; len:UIntSize ); |
|
Beschreibung | Das symmetrische lineare Gleichungs-System MA * X = B wird nach dem Vektor X aufgelöst. Anstelle von MA selbst erwartet MF_CholeskyLsolve die aus Cholesky-Faktorisierung von MA resultierende ML-Form als Eingabe-Matrix ML. Analog erwartet MF_CholeskyRsolve die MR-Form.
|
|
|
MF_Col_addC
| MD_Col_addC |
ME_Col_addC |
MCF_Col_addC |
MCD_Col_addC |
MCE_Col_addC |
|
Funktion | eine Konstante zu allen Elementen einer Spalte addieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_addC( fMatrix MA, ui ht, ui len, ui iCol, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_addC( const ui iCol, const T& C); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_addC( MA:fMatrix; ht, len, iCol:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_addC( fMatrix d_MA, ui ht, ui len, ui iCol, float C );
int cusdMF_Col_addC( fMatrix d_MA, ui ht, ui len, ui iCol, float *d_C );
void MFcu_Col_addC( fMatrix h_MA, ui ht, ui len, ui iCol, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_addC( d_MA:fMatrix; ht, len, iCol:UIntSize; C:Single ): IntBool;
function cusdMF_Col_addC( d_MA:fMatrix; ht, len, iCol:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Col_addC( h_MA:fMatrix; ht, len, iCol:UIntSize; C:Single );
|
|
Beschreibung | MAi,iCol += C, i=0,...,ht-1 |
|
|
MF_Col_addV
| MD_Col_addV |
ME_Col_addV |
MCF_Col_addV |
MCD_Col_addV |
MCE_Col_addV |
|
Funktion | einen Vektor zu einer Spalte addieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_addV( fMatrix MA, ui ht, ui len, ui iCol, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_addV( const ui iCol, const vector<T>& X); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_addV( MA:fMatrix; ht, len, iCol:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_addV( fMatrix d_MA, ui ht, ui len, ui iCol, fVector d_X );
void MFcu_Col_addV( fMatrix h_MA, ui ht, ui len, ui iCol, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_addV( d_MA:fMatrix; ht, len, iCol:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Col_addV( h_MA:fMatrix; ht, len, iCol:UIntSize; h_X:fVector );
|
|
Beschreibung | MAi,iCol += Xi, i=0,...,ht-1 |
|
|
MCF_Col_conj |
MCD_Col_conj |
MCE_Col_conj |
|
Funktion | Komplex-conjugierte Form aller Elemente einer Zeile |
|
Syntax C/C++ | #include <MCFstd.h>
void MCF_Col_conj( cfMatrix MA, ui ht, ui len, ui iCol ); |
C++ MatObj | #include <OptiVec.h>
void matrix<complex<T>>::Col_conj( const ui iCol ); |
Pascal/Delphi | uses MFstd;
procedure MCF_Col_conj( MA:cfMatrix; ht, len, iCol:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Col_conj( cfMatrix d_MA, ui ht, ui len, ui iCol );
void MCFcu_Col_conj( cfMatrix h_MA, ui ht, ui len, ui iCol ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Col_conj( d_MA:cfMatrix; ht, len, iCol:UIntSize ): IntBool;
procedure MCFcu_Col_conj( h_MA:cfMatrix; ht, len, iCol:UIntSize );
|
|
Beschreibung | MAiCol,i = MA*i,iCol, i=0,...,ht-1 |
|
|
MF_Col_delete
| MD_Col_delete |
ME_Col_delete |
MCF_Col_delete |
MCD_Col_delete |
MCE_Col_delete |
MI_Col_delete | MBI_Col_delete | MSI_Col_delete | MLI_Col_delete | MQI_Col_delete |
MU_Col_delete | MUB_Col_delete | MUS_Col_delete | MUL_Col_delete | MUL_Col_delete |
|
Funktion | eine Spalte aus einer Matrix entfernen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_delete( fMatrix MB, fMatrix MA, ui htA, ui lenA, ui iCol ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_delete( const matrix<T>& MA, const ui iCol); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_delete( MB, MA:fMatrix; htA, lenA, iCol:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_delete( fMatrix d_MB, fMatrix d_MA, ui htA, ui lenA, ui iCol );
void MFcu_Col_delete( fMatrix h_MB, fMatrix h_MA, ui htA, ui lenA, ui iCol ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_delete( d_MB, d_MA:fMatrix; htA, lenA, iCol:UIntSize ): IntBool;
procedure MFcu_Col_delete( h_MB, h_MA:fMatrix; htA, lenA, iCol:UIntSize );
|
|
Beschreibung | Die Matrix B stellt die durch Entfernung einer Spalte verkleinerte Matrix A dar:
MBi,j = MAi,j, i=0,..htA-1, j=0,..iCol-1
MBi,j = MAi,j+1, i=0,...,htA-1, j=iCol,...,lenA-2
Die Parameter htA und lenA beziehen sich auf die Eingabe-Matrix |
|
|
MF_Col_divC
| MD_Col_divC |
ME_Col_divC |
MCF_Col_divC |
MCD_Col_divC |
MCE_Col_divC |
|
Funktion | alle Elemente einer Spalte durch eine Konstante dividieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_divC( fMatrix MA, ui ht, ui len, ui iCol, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_divC( const ui iCol, const T& C); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_divC( MA:fMatrix; ht, len, iCol:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_divC( fMatrix d_MA, ui ht, ui len, ui iCol, float C );
int cusdMF_Col_divC( fMatrix d_MA, ui ht, ui len, ui iCol, float *d_C );
void MFcu_Col_divC( fMatrix h_MA, ui ht, ui len, ui iCol, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_divC( d_MA:fMatrix; ht, len, iCol:UIntSize; C:Single ): IntBool;
function cusdMF_Col_divC( d_MA:fMatrix; ht, len, iCol:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Col_divC( h_MA:fMatrix; ht, len, iCol:UIntSize; C:Single );
|
|
Beschreibung | MAi,iCol /= C, i=0,...,ht-1 |
|
|
MF_Col_divrC
| MD_Col_divrC |
ME_Col_divrC |
MCF_Col_divrC |
MCD_Col_divrC |
MCE_Col_divrC |
|
Funktion | Umgekehrte Division: eine Konstante einzeln durch die Elemente einer Spalte teilen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_divrC( fMatrix MA, ui ht, ui len, ui iCol, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_divrC( const ui iCol, const T& C); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_divrC( MA:fMatrix; ht, len, iCol:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_divrC( fMatrix d_MA, ui ht, ui len, ui iCol, float C );
int cusdMF_Col_divrC( fMatrix d_MA, ui ht, ui len, ui iCol, float *d_C );
void MFcu_Col_divrC( fMatrix h_MA, ui ht, ui len, ui iCol, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_divrC( d_MA:fMatrix; ht, len, iCol:UIntSize; C:Single ): IntBool;
function cusdMF_Col_divrC( d_MA:fMatrix; ht, len, iCol:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Col_divrC( h_MA:fMatrix; ht, len, iCol:UIntSize; C:Single );
|
|
Beschreibung | MAi,iCol = C / MAi,iCol, i=0,...,ht-1 |
|
|
MF_Col_divrV
| MD_Col_divrV |
ME_Col_divrV |
MCF_Col_divrV |
MCD_Col_divrV |
MCE_Col_divrV |
|
Funktion | Umgekehrte Division: Vektor- durch Spalten-Elemente teilen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_divrV( fMatrix MA, ui ht, ui len, ui iCol, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_divrV( const ui iCol, const vector<T>& X); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_divrV( MA:fMatrix; ht, len, iCol:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_divrV( fMatrix d_MA, ui ht, ui len, ui iCol, fVector d_X );
void MFcu_Col_divrV( fMatrix h_MA, ui ht, ui len, ui iCol, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_divrV( d_MA:fMatrix; ht, len, iCol:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Col_divrV( h_MA:fMatrix; ht, len, iCol:UIntSize; h_X:fVector );
|
|
Beschreibung | MAi,iCol = Xi / MAi,iCol, i=0,...,ht-1 |
|
|
MF_Col_divV
| MD_Col_divV |
ME_Col_divV |
MCF_Col_divV |
MCD_Col_divV |
MCE_Col_divV |
|
Funktion | Element-weise Division einer Spalte durch einen Vektor |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_divV( fMatrix MA, ui ht, ui len, ui iCol, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_divV( const ui iCol, const vector<T>& X); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_divV( MA:fMatrix; ht, len, iCol:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_divV( fMatrix d_MA, ui ht, ui len, ui iCol, fVector d_X );
void MFcu_Col_divV( fMatrix h_MA, ui ht, ui len, ui iCol, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_divV( d_MA:fMatrix; ht, len, iCol:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Col_divV( h_MA:fMatrix; ht, len, iCol:UIntSize; h_X:fVector );
|
|
Beschreibung | MAi,iCol /= Xi, i=0,...,ht-1 |
|
|
MF_Col_equ0
| MD_Col_equ0 |
ME_Col_equ0 |
MCF_Col_equ0 |
MCD_Col_equ0 |
MCE_Col_equ0 |
MCF_Col_Reequ0 |
MCD_Col_Reequ0 |
MCE_Col_Reequ0 |
MCF_Col_Imequ0 |
MCD_Col_Imequ0 |
MCE_Col_Imequ0 |
MI_Col_equ0 | MBI_Col_equ0 | MSI_Col_equ0 | MLI_Col_equ0 | MQI_Col_equ0 |
MU_Col_equ0 | MUB_Col_equ0 | MUS_Col_equ0 | MUL_Col_equ0 | MUQ_Col_equ0 |
|
Funktion | alle Elemente einer Spalte gleich Null setzen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_equ0( fMatrix MA, ui ht, ui len, ui iCol );
void MCF_Col_Reequ0( cfMatrix MA, ui ht, ui len, ui iCol );
void MCF_Col_Imequ0( cfMatrix MA, ui ht, ui len, ui iCol ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_equ0( const ui iCol );
void matrix<complex<T>>::Col_Reequ0( const ui iCol );
void matrix<complex<T>>::Col_Imequ0( const ui iCol ); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_equ0( MA:fMatrix; ht, len, iCol:UIntSize );
procedure MCF_Col_Reequ0( MA:cfMatrix; ht, len, iCol:UIntSize );
procedure MCF_Col_Imequ0( MA:cfMatrix; ht, len, iCol:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_equ0( fMatrix d_MA, ui ht, ui len, ui iCol );
int cudaMCF_Col_Reequ0( cfMatrix d_MA, ui ht, ui len, ui iCol );
int cudaMCF_Col_Imequ0( cfMatrix d_MA, ui ht, ui len, ui iCol );
void MFcu_Col_equ0( fMatrix h_MA, ui ht, ui len, ui iCol ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_equ0( d_MA:fMatrix; ht, len, iCol:UIntSize ): IntBool;
function cudaMCF_Col_Reequ0( d_MA:cfMatrix; ht, len, iCol:UIntSize ): IntBool;
function cudaMCF_Col_Imequ0( d_MA:cfMatrix; ht, len, iCol:UIntSize ): IntBool;
procedure MFcu_Col_equ0( h_MA:fMatrix; ht, len, iCol:UIntSize );
|
|
Beschreibung | M?_Col_equ0: | MAi,iCol = 0, i=0,...,ht-1 |
MC?_Col_Reequ0: | MAi,iCol.Re = 0, i=0,...,ht-1 (MAi,iCol.Im bleibt unverändert) |
MC?_Col_Imequ0: | MAi,iCol.Im = 0, i=0,...,ht-1 (MAi,iCol.Re bleibt unverändert) |
|
|
|
MF_Col_equC
| MD_Col_equC |
ME_Col_equC |
MCF_Col_equC |
MCD_Col_equC |
MCE_Col_equC |
MI_Col_equC | MBI_Col_equC | MSI_Col_equC | MLI_Col_equC | MQI_Col_equC |
MU_Col_equC | MUB_Col_equC | MUS_Col_equC | MUL_Col_equC | MUQ_Col_equC |
|
Funktion | alle Elemente einer Spalte mit einer Konstanten initialisieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_equC( fMatrix MA, ui ht, ui len, ui iCol, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_equC( const ui iCol, const T& C ); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_equC( MA:fMatrix; ht, len, iCol:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_equC( fMatrix d_MA, ui ht, ui len, ui iCol, float C );
int cusdMF_Col_equC( fMatrix d_MA, ui ht, ui len, ui iCol, float *d_C );
void MFcu_Col_equC( fMatrix h_MA, ui ht, ui len, ui iCol, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_equC( d_MA:fMatrix; ht, len, iCol:UIntSize; C:Single ): IntBool;
function cusdMF_Col_equC( d_MA:fMatrix; ht, len, iCol:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Col_equC( h_MA:fMatrix; ht, len, iCol:UIntSize; C:Single );
|
|
Beschreibung | MAi,iCol = C, i=0,...,ht-1 |
|
|
MF_Col_equV
| MD_Col_equV |
ME_Col_equV |
MCF_Col_equV |
MCD_Col_equV |
MCE_Col_equV |
MI_Col_equV | MBI_Col_equV | MSI_Col_equV | MLI_Col_equV | MQI_Col_equV |
MU_Col_equV | MUB_Col_equV | MUS_Col_equV | MUL_Col_equV | MUQ_Col_equV |
|
Funktion | Vektor in Spalte kopieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_equV( fMatrix MA, ui ht, ui len, ui iCol, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_equV( const ui iCol, const vector<T>& X); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_equV( MA:fMatrix; ht, len, iCol:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_equV( fMatrix d_MA, ui ht, ui len, ui iCol, fVector d_X );
void MFcu_Col_equV( fMatrix h_MA, ui ht, ui len, ui iCol, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_equV( d_MA:fMatrix; ht, len, iCol:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Col_equV( h_MA:fMatrix; ht, len, iCol:UIntSize; h_X:fVector );
|
|
Beschreibung | MAi,iCol = Xi, i=0,...,ht-1 |
|
|
MF_Col_extract
| MD_Col_extract |
ME_Col_extract |
MCF_Col_extract |
MCD_Col_extract |
MCE_Col_extract |
MI_Col_extract | MBI_Col_extract | MSI_Col_extract | MLI_Col_extract | MQI_Col_extract |
MU_Col_extract | MUB_Col_extract | MUS_Col_extract | MUL_Col_extract | MUQ_Col_extract |
|
Funktion | Spalte in Vektor kopieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_extract( fVector Y, fMatrix MA, ui ht, ui len, ui iCol ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::Col_extract( const matrix<T>& MA, const ui iCol ); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_extract( Y:fVector; MA:fMatrix; ht, len, iCol:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_extract( fVector d_Y, fMatrix d_MA, ui ht, ui len, ui iCol );
void MFcu_Col_extract( fVector h_Y, fMatrix h_MA, ui ht, ui len, ui iCol ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_extract( d_Y:fVector; d_MA:fMatrix; ht, len, iCol:UIntSize ): IntBool;
procedure MFcu_Col_extract( h_Y:fVector; h_MA:fMatrix; ht, len, iCol:UIntSize );
|
|
Beschreibung | Yi = MAi,iCol, i=0,...,ht-1 |
|
|
MF_Col_insert
| MD_Col_insert |
ME_Col_insert |
MCF_Col_insert |
MCD_Col_insert |
MCE_Col_insert |
MI_Col_insert | MBI_Col_insert | MSI_Col_insert | MLI_Col_insert | MQI_Col_insert |
MU_Col_insert | MUB_Col_insert | MUS_Col_insert | MUL_Col_insert | MUQ_Col_insert |
|
Funktion | Matrix durch Einfügung einer Spalte erweitern |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_insert( fMatrix MB, fMatrix MA, ui htB, ui lenB, ui iCol, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_insert( const matrix<T>& MA, const ui iCol, const vector<T>& X); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_insert( MB, MA:fMatrix; htB, lenB, iCol:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_insert( fMatrix d_MB, fMatrix d_MA, ui htB, ui lenB, ui iCol, fVector d_X );
void MFcu_Col_insert( fMatrix h_MB, fMatrix h_MA, ui htB, ui lenB, ui iCol, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_insert( d_MB, d_MA:fMatrix; htB, lenB, iCol:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Col_insert( h_MB, h_MA:fMatrix; htB, lenB, iCol:UIntSize; h_X:fVector );
|
|
Beschreibung | MBi,j = MAi,j, i=0,...,htB-1, j=0,...,iCol-1
MBi,iCol = Xi, i=0,...,htB-1
MBi,j = MAi,j-1, i=0,...,htB-1, j=iCol,...,lenB-1
Die Parameter htB und lenB beziehen sich auf die Ausgabe-Matrix |
|
|
MF_Col_mulC
| MD_Col_mulC |
ME_Col_mulC |
MCF_Col_mulC |
MCD_Col_mulC |
MCE_Col_mulC |
|
Funktion | alle Elemente einer Spalte mit einer Konstanten multiplizieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_mulC( fMatrix MA, ui ht, ui len, ui iCol, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_mulC( const ui iCol, const T& C ); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_mulC( MA:fMatrix; ht, len, iCol:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_mulC( fMatrix d_MA, ui ht, ui len, ui iCol, float C );
int cusdMF_Col_mulC( fMatrix d_MA, ui ht, ui len, ui iCol, float *d_C );
void MFcu_Col_mulC( fMatrix h_MA, ui ht, ui len, ui iCol, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_mulC( d_MA:fMatrix; ht, len, iCol:UIntSize; C:Single ): IntBool;
function cusdMF_Col_mulC( d_MA:fMatrix; ht, len, iCol:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Col_mulC( h_MA:fMatrix; ht, len, iCol:UIntSize; C:Single );
|
|
Beschreibung | MAi,iCol *= C, i=0,...,ht-1 |
|
|
MF_Col_mulV
| MD_Col_mulV |
ME_Col_mulV |
MCF_Col_mulV |
MCD_Col_mulV |
MCE_Col_mulV |
|
Funktion | Element-weise Multiplikation einer Spalte mit einem Vektor |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_mulV( fMatrix MA, ui ht, ui len, ui iCol, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_mulV( const ui iCol, const vector<T>& X); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_mulV( MA:fMatrix; ht, len, iCol:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_mulV( fMatrix d_MA, ui ht, ui len, ui iCol, fVector d_X );
void MFcu_Col_mulV( fMatrix h_MA, ui ht, ui len, ui iCol, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_mulV( d_MA:fMatrix; ht, len, iCol:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Col_mulV( h_MA:fMatrix; ht, len, iCol:UIntSize; h_X:fVector );
|
|
Beschreibung | MAi,iCol *= Xi, i=0,..,ht-1 |
|
|
MF_Col_neg
| MD_Col_neg |
ME_Col_neg |
MCF_Col_neg |
MCD_Col_neg |
MCE_Col_neg |
|
Funktion | Multiplikation aller Elemente einer Spalte mit -1 |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_neg( fMatrix MA, ui ht, ui len, ui iCol ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_neg( const ui iCol ); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_neg( MA:fMatrix; ht, len, iCol:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_neg( fMatrix d_MA, ui ht, ui len, ui iCol );
void MFcu_Col_neg( fMatrix h_MA, ui ht, ui len, ui iCol ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_neg( d_MA:fMatrix; ht, len, iCol:UIntSize ): IntBool;
procedure MFcu_Col_neg( h_MA:fMatrix; ht, len, iCol:UIntSize );
|
|
Beschreibung | MAi,iCol *= -1, i=0,...,ht-1 |
|
|
MF_Col_subC
| MD_Col_subC |
ME_Col_subC |
MCF_Col_subC |
MCD_Col_subC |
MCE_Col_subC |
|
Funktion | eine Konstante von allen Elementen einer Spalte subtrahieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_subC( fMatrix MA, ui ht, ui len, ui iCol, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_subC( const ui iCol, const T& C ); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_subC( MA:fMatrix; ht, len, iCol:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_subC( fMatrix d_MA, ui ht, ui len, ui iCol, float C );
int cusdMF_Col_subC( fMatrix d_MA, ui ht, ui len, ui iCol, float *d_C );
void MFcu_Col_subC( fMatrix h_MA, ui ht, ui len, ui iCol, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_subC( d_MA:fMatrix; ht, len, iCol:UIntSize; C:Single ): IntBool;
function cusdMF_Col_subC( d_MA:fMatrix; ht, len, iCol:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Col_subC( h_MA:fMatrix; ht, len, iCol:UIntSize; C:Single );
|
|
Beschreibung | MAi,iCol -= C, i=0,..,ht-1 |
|
|
MF_Col_subrC
| MD_Col_subrC |
ME_Col_subrC |
MCF_Col_subrC |
MCD_Col_subrC |
MCE_Col_subrC |
|
Funktion | umgekehrte Subtraktion: eine Konstante minus eine Spalte |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_subrC( fMatrix MA, ui ht, ui len, ui iCol, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_subrC( const ui iCol, const T& C ); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_subrC( MA:fMatrix; ht, len, iCol:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_subrC( fMatrix d_MA, ui ht, ui len, ui iCol, float C );
int cusdMF_Col_subrC( fMatrix d_MA, ui ht, ui len, ui iCol, float *d_C );
void MFcu_Col_subrC( fMatrix h_MA, ui ht, ui len, ui iCol, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_subrC( d_MA:fMatrix; ht, len, iCol:UIntSize; C:Single ): IntBool;
function cusdMF_Col_subrC( d_MA:fMatrix; ht, len, iCol:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Col_subrC( h_MA:fMatrix; ht, len, iCol:UIntSize; C:Single );
|
|
Beschreibung | MAi,iCol = C - MAi,iCol, i=0,..,ht-1 |
|
|
MF_Col_subrV
| MD_Col_subrV |
ME_Col_subrV |
MCF_Col_subrV |
MCD_Col_subrV |
MCE_Col_subrV |
|
Funktion | Umgekehrte Subtraktion: Vektor minus eine Spalte (Element für Element) |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_subrV( fMatrix MA, ui ht, ui len, ui iCol, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_subrV( const ui iCol, const vector<T>& X); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_subrV( MA:fMatrix; ht, len, iCol:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_subrV( fMatrix d_MA, ui ht, ui len, ui iCol, fVector d_X );
void MFcu_Col_subrV( fMatrix h_MA, ui ht, ui len, ui iCol, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_subrV( d_MA:fMatrix; ht, len, iCol:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Col_subrV( h_MA:fMatrix; ht, len, iCol:UIntSize; h_X:fVector );
|
|
Beschreibung | MAi,iCol = Xi - MAi,iCol, i=0,..,ht-1 |
|
|
MF_Col_subV
| MD_Col_subV |
ME_Col_subV |
MCF_Col_subV |
MCD_Col_subV |
MCE_Col_subV |
|
Funktion | Vektor Element für Element von einer Spalte subtrahieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Col_subV( fMatrix MA, ui ht, ui len, ui iCol, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Col_subV( const ui iCol, const vector<T>& X); |
Pascal/Delphi | uses MFstd;
procedure MF_Col_subV( MA:fMatrix; ht, len, iCol:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Col_subV( fMatrix d_MA, ui ht, ui len, ui iCol, fVector d_X );
void MFcu_Col_subV( fMatrix h_MA, ui ht, ui len, ui iCol, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Col_subV( d_MA:fMatrix; ht, len, iCol:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Col_subV( h_MA:fMatrix; ht, len, iCol:UIntSize; h_X:fVector );
|
|
Beschreibung | MAi,iCol -= Xi, i=0,..,ht-1 |
|
|
MF_Cols_absmax
| MD_Cols_absmax |
ME_Cols_absmax |
MCF_Cols_absmax |
MCD_Cols_absmax |
MCE_Cols_absmax |
|
Funktion | Betrags-Maxima der einzelnen Spalten in einem Zeilen-Vektor speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_absmax( fVector Y, fMatrix MA, ui ht, ui len );
void MCF_Cols_absmax( fVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::Cols_absmax( const matrix<T>& MA );
void vector<T>::Cols_absmax( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_absmax( Y:fVector; MA:fMatrix; ht, len:UIntSize );
procedure MCF_Cols_absmax( Y:fVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_absmax( fVector d_Y, fMatrix d_MA, ui ht, ui len );
int cudaMCF_Cols_absmax( fVector d_Y, cfMatrix d_MA, ui ht, ui len )
void MFcu_Cols_absmax( fVector h_Y, fMatrix h_MA, ui ht, ui len );
void MCFcu_Cols_absmax( fVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_absmax( d_Y:fVector; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMCF_Cols_absmax( d_Y:fVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Cols_absmax( h_Y:fVector; h_MA:fMatrix; ht, len:UIntSize );
procedure MCFcu_Cols_absmax( h_Y:fVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Das Betrags-Maximum jeder Spalte j wird gespeichert als Element Yj für j=0,..,len-1 |
|
|
MCF_Cols_absmaxReIm
| MCD_Cols_absmaxReIm |
MCE_Cols_absmaxReIm |
|
Funktion | Betrags-Maxima der Real- und der Imaginärteile getrennt voneinander für die einzelnen Spalten bestimmen und als Real- bzw. Imaginärteile eines Zeilen-Vektors speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MCF_Cols_absmaxReIm( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> >::Cols_absmaxReIm( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MFstd;
procedure MCF_Cols_absmaxReIm( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Cols_absmaxReIm( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Cols_absmaxReIm( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Cols_absmaxReIm( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Cols_absmaxReIm( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Für j=0,..,len-1 wird das Betragsmaximum der Realteile jeder Spalte j als Element Yj.Re gespeichert und das Betragsmaximum der Imaginärteile jeder Spalte j als Element Yj.Im. |
|
|
MF_Cols_absmin
| MD_Cols_absmin |
ME_Cols_absmin |
MCF_Cols_absmin |
MCD_Cols_absmin |
MCE_Cols_absmin |
|
Funktion | Betrags-Minima der einzelnen Spalten in einem Zeilen-Vektor speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_absmin( fVector Y, fMatrix MA, ui ht, ui len );
void MCF_Cols_absmin( fVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::Cols_absmin( const matrix<T>& MA );
void vector<T>::Cols_absmin( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_absmin( Y:fVector; MA:fMatrix; ht, len:UIntSize );
procedure MCF_Cols_absmin( Y:fVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_absmin( fVector d_Y, fMatrix d_MA, ui ht, ui len );
int cudaMCF_Cols_absmin( fVector d_Y, cfMatrix d_MA, ui ht, ui len )
void MFcu_Cols_absmin( fVector h_Y, fMatrix h_MA, ui ht, ui len );
void MCFcu_Cols_absmin( fVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_absmin( d_Y:fVector; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMCF_Cols_absmin( d_Y:fVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Cols_absmin( h_Y:fVector; h_MA:fMatrix; ht, len:UIntSize );
procedure MCFcu_Cols_absmin( h_Y:fVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Das Betrags-Minimum jeder Spalte j wird gespeichert als Element Yj für j=0,..,len-1 |
|
|
MCF_Cols_absminReIm
| MCD_Cols_absminReIm |
MCE_Cols_absminReIm |
|
Funktion | Betrags-Minima der Real- und der Imaginärteile getrennt voneinander für die einzelnen Spalten bestimmen und als Real- bzw. Imaginärteile eines Zeilen-Vektors speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MCF_Cols_absminReIm( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> >::Cols_absminReIm( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MFstd;
procedure MCF_Cols_absminReIm( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Cols_absminReIm( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Cols_absminReIm( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Cols_absminReIm( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Cols_absminReIm( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Für j=0,..,len-1 wird das Betragsminimum der Realteile jeder Spalte j als Element Yj.Re gespeichert und das Betragsminimum der Imaginärteile jeder Spalte j als Element Yj.Im. |
|
|
MF_Cols_add
| MD_Cols_add |
ME_Cols_add |
MCF_Cols_add |
MCD_Cols_add |
MCE_Cols_add |
|
Funktion | eine Spalte ersetzen durch die Summe von ihr selbst und einer anderen Spalte |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_add( fMatrix MA, ui ht, ui len, unsigned destCol, unsigned sourceCol ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Cols_add( const unsigned destCol, const unsigned sourceCol ); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_add( MA:fMatrix; ht, len, destCol, sourceCol:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_add( fMatrix d_MA, ui ht, ui len, unsigned destCol, unsigned sourceCol );
void MFcu_Cols_add( fMatrix h_MA, ui ht, ui len, unsigned destCol, unsigned sourceCol ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_add( d_MA:fMatrix; ht, len, destCol, sourceCol:UIntSize ): IntBool;
procedure MFcu_Cols_add( h_MA:fMatrix; ht, len, destCol, sourceCol:UIntSize );
|
|
Beschreibung | MAi,destCol += MAi,sourceCol, i=0,..,ht-1 |
|
|
MCF_Cols_cabsmax
| MCD_Cols_cabsmax |
MCE_Cols_cabsmax |
|
Funktion | Denjenigen Wert jeder Spalte, der den größten Betrag aufweist, in einem Zeilen-Vektor speichern |
|
Syntax C/C++ | #include <MCFstd.h>
void MCF_Cols_cabsmax( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> T>::Cols_cabsmax( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
procedure MCF_Cols_cabsmax( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Cols_cabsmax( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Cols_cabsmax( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Cols_cabsmax( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Cols_cabsmax( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Dasjenige Element jeder Spalte j von MA, das den größten Betrag, sqrt(Re2+Im2), besitzt, wird gespeichert als Element Yj für j=0,..,len-1 |
|
|
MCF_Cols_cabsmin
| MCD_Cols_cabsmin |
MCE_Cols_cabsmin |
|
Funktion | Denjenigen Wert jeder Spalte, der den kleinsten Betrag aufweist, in einem Zeilen-Vektor speichern |
|
Syntax C/C++ | #include <MCFstd.h>
void MCF_Cols_cabsmin( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> T>::Cols_cabsmin( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
procedure MCF_Cols_cabsmin( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Cols_cabsmin( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Cols_cabsmin( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Cols_cabsmin( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Cols_cabsmin( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Dasjenige Element jeder Spalte j von MA, das den kleinsten Betrag, sqrt(Re2+Im2), besitzt, wird gespeichert als Element Yj für j=0,..,len-1 |
|
|
MF_Cols_Cadd
| MD_Cols_Cadd |
ME_Cols_Cadd |
MCF_Cols_Cadd |
MCD_Cols_Cadd |
MCE_Cols_Cadd |
|
Funktion | eine Spalte ersetzen durch die mit einer Konstanten skalierte Summe von ihr selbst und einer anderen Spalte |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_Cadd( fMatrix MA, ui ht, ui len, unsigned destCol, unsigned sourceCol, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Cols_Cadd( const unsigned destCol, const unsigned sourceCol, const T& C ); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_Cadd( MA:fMatrix; ht, len, destCol, sourceCol:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_Cadd( fMatrix d_MA, ui ht, ui len, unsigned destCol, unsigned sourceCol, float C );
int cusdMF_Cols_Cadd( fMatrix d_MA, ui ht, ui len, unsigned destCol, unsigned sourceCol, float *d_C );
void MFcu_Cols_Cadd( fMatrix h_MA, ui ht, ui len, unsigned destCol, unsigned sourceCol, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_Cadd( d_MA:fMatrix; ht, len, destCol, sourceCol:UIntSize; C:Single ): IntBool;
function cusdMF_Cols_Cadd( d_MA:fMatrix; ht, len, destCol, sourceCol:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Cols_Cadd( h_MA:fMatrix; ht, len, destCol, sourceCol:UIntSize; C:Single );
|
|
Beschreibung | MAi,destCol += C * MAi,sourceCol, i=0,..,ht-1 |
|
|
MF_Cols_distribution | MD_Cols_distribution | ME_Cols_distribution |
MI_Cols_distribution | MBI_Cols_distribution | MSI_Cols_distribution | MLI_Cols_distribution | MQI_Cols_distribution |
MU_Cols_distribution | MUB_Cols_distribution | MUS_Cols_distribution | MUL_Cols_distribution | MUQ_Cols_distribution |
|
Funktion | Histogramm: Verteilungsfunktion entlang der Spalten |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_distribution( uiMatrix MAbund, fVector Limits, ui nbins, fMatrix MA, ui ht, ui len, int mode ); |
C++ VecObj | #include <OptiVec.h>
void matrix<ui>::Cols_distribution( const vector<T>& Limits, const matrix<T>& MA, int mode=0 ); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_distribution( MAbund:uiMatrix; Limits:fVector; nbins:UIntSize; MA:fMatrix; ht, len:UIntSize; mode:Integer ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_distribution( uiMatrix d_MAbund, fVector d_Limits, ui nbins, fMatrix d_MA, ui ht, ui len, int mode );
void MFcu_Cols_distribution( uiMatrix h_MAbund, fVector h_Limits, ui nbins, fMatrix h_MA, ui ht, ui len, int mode ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_distribution( d_MAbund:uiMatrix; d_Limits:fVector; nbins:UIntSize; d_MA:fMatrix; ht, len:UIntSize; mode:Integer ): IntBool;
procedure MFcu_Cols_distribution( h_MAbund:uiMatrix; h_Limits:fVector; nbins:UIntSize; h_MA:fMatrix; ht, len:UIntSize; mode:Integer );
|
|
Beschreibung | Für jede Spalte wird gezählt, wieviele Elemente in jedes einzelne der in Limits definierten Intervalle fallen. Die gefundenen Häufigkeitswerte werden in der entsprechenden Spalte von MAbund gespeichert.
Es gibt nbins Intervalle (engl. bins). Die Größe von MAbund ist also nbins*len.
Limits muß in aufsteigender Folge sortiert sein. Die Abstände zwischen den einzelnen Werten von Limits müssen aber nicht unbedingt konstant sein.
Der Parameter mode entscheidet darüber, wie die in Limits angegebenen Werte interpretiert werden sollen.
mode > 0: Die Werte von Limits geben die Obergrenzen der Intervalle an.
mode < 0: Die Werte von Limits geben die Untergrenzen der Intervalle an.
mode = 0: Die Werte von Limits geben die Intervall-Mittelpunkte an. Ein X-Wert wird also demjenigen Intervall zugerechnet, zu dessen in Limits angegebenen Wert er den geringsten Abstand hat. Befindet sich ein X-Wert exakt in der Mitte zwischen zwei Limits-Werten, so wird er dem Intervall mit dem niedrigeren Index zugeschlagen. Das durch Limits0 angegebene Intervall ist nach unten hin offen, das durch Limitsnbins-1 angegebene reicht bis +HUGE_VAL.
Im Unterschied zu VF_distribution werden die außerhalb der spezifierten Intervalle liegenden Elemente nicht zurückgegeben, sondern ignoriert.
Die vorliegende Funktion eignet sich auch zur Stapelverarbeitung mehrerer Vektoren gleicher Größe, die zu diesem Zweck in die Spalten einer Matrix zu kopieren sind.
Derzeit stehen diese Funktionen nur für 64-bit zur Verfügung.
|
|
|
|
|
MF_Cols_exchange
| MD_Cols_exchange |
ME_Cols_exchange |
MCF_Cols_exchange |
MCD_Cols_exchange |
MCE_Cols_exchange |
MI_Cols_exchange | MBI_Cols_exchange | MSI_Cols_exchange | MLI_Cols_exchange | MQI_Cols_exchange |
MU_Cols_exchange | MUB_Cols_exchange | MUS_Cols_exchange | MUL_Cols_exchange | MUL_Cols_exchange |
|
Funktion | zwei Spalten vertauschen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_exchange( fMatrix MA, ui ht, ui len, unsigned i1, unsigned i2 ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Cols_exchange( const unsigned i1, const unsigned i2 ); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_exchange( MA:fMatrix; ht, len, i1, i2:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_exchange( fMatrix d_MA, ui ht, ui len, unsigned i1, unsigned i2 );
void MFcu_Cols_exchange( fMatrix MA, ui ht, ui len, unsigned i1, unsigned i2 ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_exchange( d_MA:fMatrix; ht, len, i1, i2:UIntSize ): IntBool;
procedure MFcu_Cols_exchange( h_MA:fMatrix; ht, len, i1, i2:UIntSize );
|
|
Beschreibung | Die Elemente der Spalten i1 und i2 werden vertauscht. |
|
|
MF_Cols_FFT |
MD_Cols_FFT |
ME_Cols_FFT |
MFb_Cols_FFT |
MDb_Cols_FFT |
MEb_Cols_FFT |
MF_Cols_FFTtoC
| MD_Cols_FFTtoC |
ME_Cols_FFTtoC |
MFb_Cols_FFTtoC
| MDb_Cols_FFTtoC |
MEb_Cols_FFTtoC |
MCF_Cols_FFT |
MCD_Cols_FFT |
MCE_Cols_FFT |
MCFb_Cols_FFT |
MCDb_Cols_FFT |
MCEb_Cols_FFT |
|
Funktion | Schnelle Fourier-Transformation (Fast Fourier Transformation) entlang der Spalten einer Matrix |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_FFT( fMatrix Y, fMatrix X, ui ht, ui len, int dir );
void MCF_Cols_FFT( cfMatrix Y, cfMatrix X, ui ht, ui len, int dir );
void MF_Cols_FFTtoC( cfMatrix Y, fMatrix X, ui ht, ui len );
void MFb_Cols_FFT( fMatrix Y, fMatrix X, ui ht, ui len, int dir, fVector Buf );
void MCFb_Cols_FFT( cfMatrix Y, cfMatrix X, ui ht, ui len, int dir, cfVector Buf );
void MFb_Cols_FFTtoC( cfMatrix Y, fMatrix X, ui ht, ui len, cfVector Buf ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Cols_FFT( const matrix<T>& MX, int dir );
void matrix<complex<T> >::FFT( const matrix<complex<T> >& MX, int dir );
void matrix<complex<T> >::FFTtoC( const matrix<T>& MX );
void matrix<T>::b_Cols_FFT( const matrix<T>& MX, int dir, vector<T>& Buf );
void matrix<complex<T> >::b_Cols_FFT( const matrix<complex<T> > MX, int dir, vector<complex<T> >&Buf );
void matrix<complex<T> >::b_Cols_FFTtoC( const matrix<T> MX, vector<complex<T>>& Buf ); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_FFT( MY, MX:fMatrix; ht, len:UIntSize; dir:Integer );
procedure MCF_Cols_FFT( MY, MX:cfMatrix; ht, len:UIntSize; dir:Integer );
procedure MF_Cols_FFTtoC( MY:cfMatrix; MX:fMatrix; ht, len:UIntSize );
procedure MFb_Cols_FFT( MY, MX:fMatrix; ht, len:UIntSize; dir:Integer; Buf:fVector );
procedure MCFb_Cols_FFT( MY, MX:cfMatrix; ht, len:UIntSize; dir:Integer; Buf:cfVector );
procedure MFb_Cols_FFTtoC( MY:cfMatrix; MX:fMatrix; ht, len:UIntSize; Buf:cfVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
#include <cudaMCFstd.h>
int cudaMF_Cols_FFT( fMatrix d_Y, fMatrix d_X, ui ht, ui len, int dir );
int cuda MCF_Cols_FFT( cfMatrix d_Y, cfMatrix d_X, ui ht, ui len, int dir );
int cudaMF_Cols_FFTtoC( cfMatrix d_Y, fMatrix d_X, ui ht, ui len );
void MFcu_Cols_FFT( fMatrix h_Y, fMatrix h_X, ui ht, ui len, int dir );
void MCFcu_Cols_FFT( cfMatrix h_Y, cfMatrix h_X, ui ht, ui len, int dir );
void MFcu_Cols_FFTtoC( cfMatrix h_Y, fMatrix h_X, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd, MCFstd;
function cudaMF_Cols_FFT( d_MY, d_MX:fMatrix; ht, len:UIntSize; dir:Integer ): IntBool;
function cudaMCF_Cols_FFT( d_MY, d_MX:cfMatrix; ht, len:UIntSize; dir:Integer ): IntBool;
function cudaMF_Cols_FFTtoC( d_MY:cfMatrix; d_MX:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Cols_FFT( h_MY, h_MX:fMatrix; ht, len:UIntSize; dir:Integer );
procedure MCFcu_Cols_FFT( h_MY, h_MX:cfMatrix; ht, len:UIntSize; dir:Integer );
procedure MFcu_Cols_FFTtoC( h_MY:cfMatrix; h_MX:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Die Fourier-Transformierten der Spalten von MX werden in den Spalten von MY zurückgegeben. Die Vorwärts-Transformation erhält man für dir = 1, die inverse (oder Rückwärts-) Transformation für dir = -1. Gemäß Konvention enthält die Rückwärts-Transformation eine Skalierung des Ergebnisses mit dem Faktor 1.0/ht (wodurch das Ergebnis von einmal Vorwärts- und einmal Rückwärts-Transformation wieder – von Rundungsfehlern abgesehen – die Ursprungs-Matrix ergibt). Für Situationen, in denen man diese implizite Skalierung umgehen möchte, spezifiziere man dir = -2.
Der verwendete FFT-Algorithmus erfordert es, dass ht eine ganzzahlige Potenz von 2 ist. len hingegen kann zwar beliebige Werte annehmen; die Funktion ist aber am effizientesten, wenn len ein Vielfaches von 4 ist.
Komplexe Version: Sowohl die Eingabe-Matrix X also auch die Ausgabe-Matrix Y sind komplex.
Reell-zu-Komplex-Version: Die Eingabe-Matrix X ist reell. Die Ausgabe-Matrix Y ist komplex. Da diese Funktion nur in Vorwärts-Richtung ausgeführt werden kann, ist kein Argument "dir" erforderlich.
Rein reelle Version: Für die Vorwärts-Transformation ist MX eine reelle Matrix. Die Ausgabe-Matrix Y ist ebenfalls als reelle Matrix definiert, obwohl sie aus komplexen Zahlen besteht. Diese sind auf spezielle Weise so gepackt, dass sie in den für eine gleich große reelle Matrix zur Verfügung stehenden Speicherplatz passen. Die Reihenfolge der Elemente der Spalten von MY ist in folgenden Tabelle angegeben. U ist die unkomprimierte Fourier-Transformierte, N ist ht.
Y0, i | U0, i.Re |
Y1, i | UN/2, i.Re |
Y2, i | U1, i.Re |
Y3, i | U1, i.Im |
..... | ..... |
YN-2, i | UN/2-1, i.Re |
YN-1, i | UN/2-1, i.Im |
Dieses Speicher-Schema bedeutet, dass in C/C++ (wo Matrizen zeilenweise gespeichert werden), Real- und Imaginärteil eines jeden Elements nicht an benachbarten Speicherplätzen abgelegt sind.
Für die inverse Cols_FFT reeller Matrizen muss die Eingabe-Matrix in diesem gepackt-komplexen Format vorliegen. und als Ergebnis erhält man eine "echte" reelle Matrix. Falls Sie es vorziehen, das Ergebnis der Vorwärts-Transformation ungepackt, also als "echten" komplexe Zahlen zu erhalten, benutzen Sie bitte MF_Cols_FFTtoC.
MFb_Cols_FFT, MFb_Cols_FFTtoC und MCFb_Cols_FFT verwenden den als Argument Buf übergebenen Puffer-Speicher, anstatt ihn selbst zu reservieren. Dadurch sind sie etwas effizienter als die ungepufferten Versionen. Buf muss (mindestens) so groß sein wie X und Y (d.h. Buf.size >= ht*len).
|
|
Fehlerbehandlung | Falls ht nicht eine Potenz von 2 ist, bricht das Programm mit der Fehlermeldung "Size must be an integer power of 2" ab. |
|
|
MF_Cols_lincomb
| MD_Cols_lincomb |
ME_Cols_lincomb |
MCF_Cols_lincomb |
MCD_Cols_lincomb |
MCE_Cols_lincomb |
|
Funktion | Linearkombination zweier Spalten |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_lincomb( fMatrix MA, ui ht, ui len, unsigned destCol, float destC, unsigned srceCol, float srceC ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Cols_lincomb( const unsigned destCol, const T& destC, const unsigned srceCol, const T& srceC ); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_lincomb( MA:fMatrix; ht, len:UIntSize; destCol:UIntSize; destC:Single; srceCol:UIntSize; srceC:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_lincomb( fMatrix d_MA, ui ht, ui len, unsigned destCol, float destC, unsigned srceCol, float srceC );
int cusdMF_Cols_lincomb( fMatrix d_MA, ui ht, ui len, unsigned destCol, float
d_destC, unsigned srceCol, float *d_srceC );
void MFcu_Cols_lincomb( fMatrix h_MA, ui ht, ui len, unsigned destCol, float destC, unsigned srceCol, float srceC );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_lincomb( d_MA:fMatrix; ht, len:UIntSize; destCol:UIntSize; destC:Single; srceCol:UIntSize; srceC:Single ): IntBool;
function cusdMF_Cols_lincomb( d_MA:fMatrix; ht, len:UIntSize; destCol:UIntSize; d_destC:PSingle; srceCol:UIntSize; d_srceC:PSingle ): IntBool;
procedure MFcu_Cols_lincomb( h_MA:fMatrix; ht, len:UIntSize; destCol:UIntSize; destC:Single; srceCol:UIntSize; srceC:Single );
|
|
Beschreibung | MAi,destCol = destC * MAi,destCol+ srceC * MAi,srceCol, i=0,..,ht-1 |
|
|
MF_Cols_max
| MD_Cols_max |
ME_Cols_max |
MI_Cols_max | MBI_Cols_max | MSI_Cols_max | MLI_Cols_max | MQI_Cols_max |
MU_Cols_max | MUB_Cols_max | MUS_Cols_max | MUL_Cols_max | MUQ_Cols_max |
|
Funktion | Maxima der einzelnen Spalten in einem Zeilen-Vektor speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_max( fVector Y, fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::Cols_max( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_max( Y:fVector; MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_max( fVector d_Y, fMatrix d_MA, ui ht, ui len );
void MFcu_Cols_max( fVector h_Y, fMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_max( d_Y:fVector; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Cols_max( h_Y:fVector; h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Das Maximum jeder Spalte j wird gespeichert als Element Yj für j=0,..,len-1 |
|
|
MCF_Cols_maxReIm
| MCD_Cols_maxReIm |
MCE_Cols_maxReIm |
|
Funktion | Maxima der Real- und der Imaginärteile getrennt voneinander für die einzelnen Spalten bestimmen und als Real- bzw. Imaginärteile eines Zeilen-Vektors speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MCF_Cols_maxReIm( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> >::Cols_maxReIm( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MFstd;
procedure MCF_Cols_maxReIm( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Cols_maxReIm( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Cols_maxReIm( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Cols_maxReIm( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Cols_maxReIm( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Für j=0,..,len-1 wird das Maximum der Realteile jeder Spalte j als Element Yj.Re gespeichert und das Maximum der Imaginärteile jeder Spalte j als Element Yj.Im. |
|
|
MF_Cols_min
| MD_Cols_min |
ME_Cols_min |
MI_Cols_min | MBI_Cols_min | MSI_Cols_min | MLI_Cols_min | MQI_Cols_min |
MU_Cols_min | MUB_Cols_min | MUS_Cols_min | MUL_Cols_min | MUQ_Cols_min |
|
Funktion | Minima der einzelnen Spalten in einem Zeilen-Vektor speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_min( fVector Y, fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::Cols_min( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_min( Y:fVector; MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_min( fVector d_Y, fMatrix d_MA, ui ht, ui len );
void MFcu_Cols_min( fVector h_Y, fMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_min( d_Y:fVector; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Cols_min( h_Y:fVector; h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Das Minimum jeder Spalte j wird gespeichert als Element Yj für j=0,..,len-1 |
|
|
MCF_Cols_minReIm
| MCD_Cols_minReIm |
MCE_Cols_minReIm |
|
Funktion | Minima der Real- und der Imaginärteile getrennt voneinander für die einzelnen Spalten bestimmen und als Real- bzw. Imaginärteile eines Zeilen-Vektors speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MCF_Cols_minReIm( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> >::Cols_minReIm( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MFstd;
procedure MCF_Cols_minReIm( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Cols_minReIm( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Cols_minReIm( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Cols_minReIm( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Cols_minReIm( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Für j=0,..,len-1 wird das Minimum der Realteile jeder Spalte j als Element Yj.Re gespeichert und das Minimum der Imaginärteile jeder Spalte j als Element Yj.Im. |
|
|
MF_Cols_prod
| MD_Cols_prod |
ME_Cols_prod |
MCF_Cols_prod |
MCD_Cols_prod |
MCE_Cols_prod |
|
Funktion | Produkte über alle Elemente jeder einzelnen Spalte in einem Zeilen-Vektor speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_prod(fVector Y, fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::Cols_prod( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_prod(Y:fVector; MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_prod( fVector d_Y, fMatrix d_MA, ui ht, ui len );
void MFcu_Cols_prod( fVector h_Y, fMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_prod( d_Y:fVector; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Cols_prod( h_Y:fVector; h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Yj = prod( MAi,j, i=0,..,ht-1), j=0,..,len-1 |
|
|
MF_Cols_reflect
| MD_Cols_reflect |
ME_Cols_reflect |
MCF_Cols_reflect
| MCD_Cols_reflect |
MCE_Cols_reflect |
MI_Cols_reflect | MBI_Cols_reflect | MSI_Cols_reflect | MLI_Cols_reflect | MQI_Cols_reflect |
MU_Cols_reflect | MUB_Cols_reflect | MUS_Cols_reflect | MUL_Cols_reflect | MUQ_Cols_reflect |
|
Funktion | Zweite Hälfte jeder Spalte von der ersten Hälfte durch Reflektion an der waagerechten Linie durch die Mitte der Matrix gewinnen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_reflect( fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Cols_reflect(); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_reflect( MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_reflect( fMatrix d_MA, ui ht, ui len );
void MFcu_Cols_reflect( fMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_reflect( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Cols_reflect( h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | MAht-i-1,j = MAi, j, i=0,..(ht-1)/2; j=0,..,len-1 |
|
|
MF_Cols_rev
| MD_Cols_rev |
ME_Cols_rev |
MCF_Cols_rev
| MCD_Cols_rev |
MCE_Cols_rev |
MI_Cols_rev | MBI_Cols_rev | MSI_Cols_rev | MLI_Cols_rev | MQI_Cols_rev |
MU_Cols_rev | MUB_Cols_rev | MUS_Cols_rev | MUL_Cols_rev | MUQ_Cols_rev |
|
Funktion | Umkehrung der Element-Reihenfolge entlang der Spalten. Dies entspricht einer Spiegelung der Matrix an der X-Achse (bzw. an der horizontalen Linie durch die Mitte der Matrix). |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_rev( fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Cols_rev(); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_rev( MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_rev( fMatrix d_MA, ui ht, ui len );
void MFcu_Cols_rev( fMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_rev( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Cols_rev( h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | MAi,j = MAht-i-1, j |
|
|
MF_Cols_rotate
| MD_Cols_rotate |
ME_Cols_rotate |
MCF_Cols_rotate |
MCD_Cols_rotate |
MCE_Cols_rotate |
MI_Cols_rotate | MBI_Cols_rotate | MSI_Cols_rotate | MLI_Cols_rotate | MQI_Cols_rotate |
MU_Cols_rotate | MUB_Cols_rotate | MUS_Cols_rotate | MUL_Cols_rotate | MUQ_Cols_rotate |
|
Funktion | alle Spalten um eine bestimmte Anzahl von Positionen rotieren; hierbei werden ganze Zeilen verschoben |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_rotate( fMatrix MA, ui ht, ui len, int pos ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Cols_rotate( const int pos ); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_rotate( MA:fMatrix; ht, len:UIntSize; pos:Integer ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_rotate( fMatrix d_MA, ui ht, ui len, int pos );
void MFcu_Cols_rotate( fMatrix h_MA, ui ht, ui len, int pos );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_rotate( d_MA:fMatrix; ht, len:UIntSize; pos:Integer ): IntBool;
procedure MFcu_Cols_rotate( h_MA:fMatrix; ht, len:UIntSize; pos:Integer );
|
|
Beschreibung | MAi,j = MAht-pos+i, j, i=0,..,pos-1
MAi,j = MAi-pos, j, i=pos,...,ht-1
Da diese Funktion jedes Mal intern Puffer-Speicher reservieren und wieder freigeben muss, ist sie nicht sonderlich effizient. Für Anwendungen, die häufiger Rotationen durchführen, empfehlen wir, einmal eine Puffermatrix zu allozieren und mit dieser MF_Cols_rotate_buf anstelle der vorliegenden Funktion aufzurufen. |
|
|
MF_Cols_rotate_buf
| MD_Cols_rotate_buf |
ME_Cols_rotate_buf |
MCF_Cols_rotate_buf |
MCD_Cols_rotate_buf |
MCE_Cols_rotate_buf |
MI_Cols_rotate_buf | MBI_Cols_rotate_buf | MSI_Cols_rotate_buf | MLI_Cols_rotate_buf | MQI_Cols_rotate_buf |
MU_Cols_rotate_buf | MUB_Cols_rotate_buf | MUS_Cols_rotate_buf | MUL_Cols_rotate_buf | MUQ_Cols_rotate_buf |
|
Funktion | effiziente Spalten-Rotation (Verschiebung ganzer Zeilen) unter Verwendung übergebenen Zwischenspeicher-Platzes |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_rotate_buf( fMatrix MA, ui ht, ui len, int pos, fMatrix MBuf ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Cols_rotate_buf( const int pos, const matrix<T> MBuf ); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_rotate_buf( MA:fMatrix; ht, len:UIntSize; pos:Integer; MBuf:fMatrix ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_rotate_buf( fMatrix d_MA, ui ht, ui len, int pos, fMatrix d_MBuf );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_rotate_buf( d_MA:fMatrix; ht, len:UIntSize; pos:Integer; d_MBuf:fMatrix ): IntBool;
|
|
Beschreibung | MAi,j = MAht-pos+i, j, i=0,..,pos-1
MAi,j = MAi-pos, j, i=pos,...,ht-1
Diese Funktion stellt eine effizientere Variante von MF_Cols_rotate dar: Anstatt den intern benötigten Pufferspeicher jedes Mal vom Betriebssystem anzufordern und wieder freizugeben, wird er in Form der Puffermatrix MBuf als Argument übernommen. MBuf muss eine mit Hilfe der OptiVec-Speicherroutinen MF_matrix etc. erzeugte Matrix mit mindestens ebenso vielen Elementen wie MA sein. |
|
|
MF_Cols_runprod
| MD_Cols_runprod |
ME_Cols_runprod |
MCF_Cols_runprod |
MCD_Cols_runprod |
MCE_Cols_runprod |
|
Funktion | laufendes Produkt über alle Spalten-Elemente |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_runprod( fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Cols_runprod(); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_runprod( MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_runprod( fMatrix d_MA, ui ht, ui len );
void MFcu_Cols_runprod( fMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_runprod( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Cols_runprod( h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Für alle Spalten einzeln wird jedes Element als Produkt seiner selbst und aller vorhergehender Elemente berechnet. Diese Funktion sollte mit Vorsicht eingesetzt werden: Überlauf wird leicht erreicht, und Unterlauf kann dazu führen, dass alle Elemente von einem bestimmten Punkt ab gleich 0 werden. |
|
|
MF_Cols_runsum
| MD_Cols_runsum |
ME_Cols_runsum |
MCF_Cols_runsum |
MCD_Cols_runsum |
MCE_Cols_runsum |
|
Funktion | laufende Summe über Spalten-Elemente |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_runsum( fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Cols_runsum(); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_runsum( MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_runsum( fMatrix d_MA, ui ht, ui len );
void MFcu_Cols_runsum( fMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_runsum( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Cols_runsum( h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Für alle Spalten einzeln wird jedes Element als Summe seiner selbst und aller vorhergehender Elemente berechnet. |
|
|
MCF_Cols_sabsmax
| MCD_Cols_sabsmax |
MCE_Cols_sabsmax |
|
Funktion | Denjenigen Wert jeder Spalte, der die größte Summe |Re| + |Im| aufweist, in einem Zeilen-Vektor speichern |
|
Syntax C/C++ | #include <MCFstd.h>
void MCF_Cols_sabsmax( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> T>::Cols_sabsmax( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
procedure MCF_Cols_sabsmax( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Cols_sabsmax( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Cols_sabsmax( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Cols_sabsmax( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Cols_sabsmax( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Das in bezug auf die Summe |Re| + |Im| größte Element jeder Spalte j von MA wird gespeichert als Element Yj für j=0,..,len-1 |
|
|
MCF_Cols_sabsmin
| MCD_Cols_sabsmin |
MCE_Cols_sabsmin |
|
Funktion | Denjenigen Wert jeder Spalte, der die kleinste Summe |Re| + |Im| aufweist, in einem Zeilen-Vektor speichern |
|
Syntax C/C++ | #include <MCFstd.h>
void MCF_Cols_sabsmin( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> T>::Cols_sabsmin( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
procedure MCF_Cols_sabsmin( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Cols_sabsmin( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Cols_sabsmin( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Cols_sabsmin( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Cols_sabsmin( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Das in bezug auf die Summe |Re| + |Im| kleinste Element jeder Spalte j von MA wird gespeichert als Element Yj für j=0,..,len-1 |
|
|
MF_Cols_sub
| MD_Cols_sub |
ME_Cols_sub |
MCF_Cols_sub |
MCD_Cols_sub |
MCE_Cols_sub |
|
Funktion | Eine Spalte von einer anderen abziehen und den Subtrahenden mit dem Ergebnis überschreiben |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_sub( fMatrix MA, ui ht, ui len, unsigned destCol, unsigned sourceCol ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Cols_sub( const unsigned destCol, const unsigned sourceCol ); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_sub( MA:fMatrix; ht, len, destCol, sourceCol:UIntSize; ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_sub( fMatrix d_MA, ui ht, ui len, unsigned destCol, unsigned sourceCol );
void MFcu_Cols_sub( fMatrix h_MA, ui ht, ui len, unsigned destCol, unsigned sourceCol ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_sub( d_MA:fMatrix; ht, len, destCol, sourceCol:UIntSize ): IntBool;
procedure MFcu_Cols_sub( h_MA:fMatrix; ht, len, destCol, sourceCol:UIntSize );
|
|
Beschreibung | MAi,destCol -= MAi,sourceCol, i=0,..,ht-1 |
|
|
MF_Cols_sum
| MD_Cols_sum |
ME_Cols_sum |
MCF_Cols_sum |
MCD_Cols_sum |
MCE_Cols_sum |
|
Funktion | Summen über alle Spalten in einem Zeilen-Vektor speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Cols_sum( fVector Y, fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::Cols_sum( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_Cols_sum( Y:fVector; MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Cols_sum( fVector d_Y, fMatrix d_MA, ui ht, ui len );
void MFcu_Cols_sum( fVector h_Y, fMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Cols_sum( d_Y:fVector; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Cols_sum( h_Y:fVector; h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Yj = sum( MAi,j, i=0,..,ht-1), j=0,..,len-1 |
|
|
MCF_conj
| MCD_conj |
MCE_conj |
|
Funktion | komplex-konjugierte Form |
|
Syntax C/C++ | #include <MFstd.h>
void MCF_conj( cfMatrix MB, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::conj(); |
Pascal/Delphi | uses MFstd;
procedure MCF_conj( MB, MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_conj( cfMatrix d_MB, cfMatrix d_MA, ui ht, ui len );
void MCFcu_conj( cfMatrix h_MB, cfMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_conj( d_MB, d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_conj( h_MB, h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | MBij.Re = MAij.Re
MBij.Im = -MAij.Im |
|
|
MF_coherence
| MD_coherence |
ME_coherence |
MFb_coherence
| MDb_coherence |
MEb_coherence |
MFb_coherence_sizeBuf
| MDb_coherence_sizeBuf |
MEb_coherence_sizeBuf |
|
Funktion | Räumliche Kohärenz-Funktion |
|
Syntax C/C++ | #include <MFstd.h>
void MF_coherence( fMatrix MCohr, ui htSpec, ui lenSpec, fMatrix MX, fMatrix MY, ui htX, ui lenX, fMatrix Win );
void MFb_coherence( fMatrix MCohr, ui htSpec, ui lenSpec, fMatrix MX, fMatrix MY, ui htX, ui lenX, fMatrix Win, fVector Buf );
ui MFb_coherence_sizeBuf( ui htSpec, ui lenSpec, ui htX, ui lenX ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::coherence( const matrix<T>& MX, const matrix<T>& MY, const matrix<T>& MWin );
void matrix<T>::b_coherence( const matrix<T>& MX, const matrix<T>& MY, const matrix<T>& MWin, vector<T> Buf ); |
Pascal/Delphi | uses MFstd;
procedure MF_coherence( MCohr:fMatrix; htSpec, lenSpec:UIntSize; MX, MY:fMatrix; htX, lenX:UIntSize; MWin:fMatrix );
procedure MFb_coherence( MCohr:fMatrix; htSpec, lenSpec:UIntSize; MX, MY:fMatrix; htX, lenX:UIntSize; MWin:fMatrix; Buf:fVector );
function MFb_coherence_sizeBuf( htSpec, lenSpec, htX, lenX:UIntSize ): UIntSize; |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_coherence( fMatrix d_MCohr, ui htSpec, ui lenSpec, fMatrix d_MX, fMatrix d_MY, ui htX, ui lenX, fMatrix d_MWin );
void MFcu_coherence( fMatrix h_MCohr, ui htSpec, ui lenSpec, fMatrix h_MX, fMatrix h_MY, ui htX, ui lenX, fMatrix h_MWin );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_coherence( d_MCohr:fMatrix; htSpec, lenSpec:UIntSize; d_MX, d_MY:fMatrix; htX, lenX:UIntSize; d_MWin:fMatrix ): IntBool;
procedure MFcu_coherence( h_MCohr:fMatrix; htSpec, lenSpec:UIntSize; h_MX, h_MY:fMatrix; htX, lenX:UIntSize; h_MWin:fMatrix );
|
|
Beschreibung | Die räumliche Kohärenzfunktion aus den in den Matrizen MX und MY enthaltenen Daten wird berechnet und in MCohr gespeichert. Der Algorithmus folgt der Welch-Methode der Unterteilung von MX und MY in überlappende Segmente, über deren Spektren und Kreuz-Spektren anschließend gemittelt wird. F¨r ein sinnvolles Ergebnis ist es erforderlich, den Algorithmus über mehrere Segmente mitteln zu lassen (htX und lenX müssen also Vielfache von htSpec, lenSpec sein). Bei nur einem einzigen Segment liefert dieser Algorithmus das sinnlose Ergebnis aller Elemente von MCohr = 1.0 (mit geringfügigen Rundungsfehlern). MWin ist ein Fenster, das auf die Datensegmente angewendet wird. OptiVec bietet drei Funktionen zur Erzeugung passender Fenster: MF_Welch, MF_Parzen und MF_Hann. Ein Rechteck-Fenster erhält man durch Setzen aller Matrix-Elemente auf den Wert 1.0 (MF_equC( MWin, htWin, lenWin, 1.0 ); ), dies wird aber nicht empfohlen.
htSpec und lenSpec müssen ganzzahlige Potenzen von 2 sein. Außerdem müssen folgende Bedingungen erfüllt sein:
htX >= n*htSpec, lenX >= n*lenSpec, htWin = htSpec, lenWin = lenSpec.
Intern benötigt MF_coherence zusätzlichen Pufferspeicher, der automatisch reserviert und wieder freigegeben wird. Bei wiederholten Aufrufen wäre dies ineffizient. Es wird empfohlen, für solche Fälle stattdessen MFb_coherence zu verwenden. Die notwendige Größe von Buf kann dabei durch Aufruf der Funktion MFb_coherence_sizeBuf ermittelt werden. Sie wird nie mehr als 11*htX*lenX betragen. Außerdem muss Buf 128-bit (P8) bzw. 256-bit( P9) ausgerichtet sein. Um dies zu garantieren, sollte man nur Vektoren als Buf verwenden, die mit der VF_vector-Familie alloziert wurden. |
|
Fehlerbehandlung | Falls entweder htSpec oder lenSpec keine ganzzahlige Potenz von 2 ist, meldet sich VF_FFT (worauf MF_coherence basiert) mit der Fehlermeldung "Size must be an integer power of 2" und bricht das Programm ab. |
|
|
MF_convolve
| MD_convolve |
ME_convolve |
MF_convolvewEdit
| MD_convolvewEdit |
ME_convolvewEdit |
MFb_convolve
| MDb_convolve |
MEb_convolve |
MFb_convolvewEdit
| MDb_convolvewEdit |
MEb_convolvewEdit |
|
Funktion | Faltung (Konvolution) mit einer räumlichen Response-Funktion |
|
Syntax C/C++ | #include <MFstd.h>
void MF_convolve( fMatrix Y, fMatrix Flt, fMatrix X, fMatrix Rsp, ui ht, ui len );
void MF_convolvewEdit( fMatrix Y, fMatrix Flt, fMatrix X, fMatrix Rsp, ui ht, ui len, fComplex thresh );
void MFb_convolve( fMatrix Y, fMatrix Flt, fMatrix X, fMatrix Rsp, ui ht, ui len, fVector Buf );
void MFb_convolvewEdit( fMatrix Y, fMatrix Flt, fMatrix X, fMatrix Rsp, ui ht, ui len, fComplex thresh, fVector Buf ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::convolve( matrix<T> Flt, const matrix<T>& MX, const matrix<T> Rsp);
void matrix<T>::convolve( matrix<T>* Flt, const matrix<T>& MX, const matrix<T> Rsp);
void matrix<T>::convolvewEdit( matrix<T> Flt, const matrix<T>& MX, const matrix<T> Rsp, complex<T> thresh);
void matrix<T>::convolvewEdit( matrix<T>* Flt, const matrix<T>& MX, const matrix<T> Rsp, complex<T> thresh);
void matrix<T>::b_convolve( matrix<T> Flt, const matrix<T>& MX, const matrix<T> Rsp, vector<T> Buf);
void matrix<T>::b_convolve( matrix<T>* Flt, const matrix<T>& MX, const matrix<T> Rsp, vector<T> Buf);
void matrix<T>::b_convolvewEdit( matrix<T> Flt, const matrix<T>& MX, const matrix<T> Rsp, complex<T> thresh, vector<T> Buf);
void matrix<T>::b_convolvewEdit( matrix<T>* Flt, const matrix<T>& MX, const matrix<T> Rsp, complex<T> thresh, vector<T> Buf); |
Pascal/Delphi | uses MFstd;
procedure MF_convolve( MY, MFlt, MX, MRsp:fMatrix; ht, len:UIntSize );
procedure MF_convolvewEdit( MY, MFlt, MX, MRsp:fMatrix; ht, len:UIntSize; thresh:fComplex );
procedure MFb_convolve( MY, MFlt, MX, MRsp:fMatrix; ht, len:UIntSize; Buf:fVector );
procedure MFb_convolvewEdit( MY, MFlt, MX, MRsp:fMatrix; ht, len:UIntSize; thresh:fComplex; Buf:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_convolve( fMatrix d_MY, fMatrix d_MFlt, fMatrix d_MX, fMatrix d_MRsp, ui ht, ui len );
void MFcu_convolve( fMatrix h_MY, fMatrix h_MFlt, fMatrix h_MX, fMatrix h_MRsp, ui ht, ui len );
int cudaMF_convolvewEdit( fMatrix d_MY, fMatrix d_MFlt, fMatrix d_MX, fMatrix d_MRsp, ui ht, ui len, fComplex thresh );
void MFcu_convolvewEdit( fMatrix h_MY, fMatrix h_MFlt, fMatrix h_MX, fMatrix h_MRsp, ui ht, ui len, fComplex thresh );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_convolve( d_MY, d_MFlt, d_MX, d_MRsp:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_convolve( h_MY, h_MFlt, h_MX, h_MRsp:fMatrix; ht, len:UIntSize );
function cudaMF_convolvewEdit( d_MY, d_MFlt, d_MX, d_MRsp:fMatrix; ht, len:UIntSize; thresh:fComplex ): IntBool;
procedure MFcu_convolvewEdit( h_MY, h_MFlt, h_MX, h_MRsp:fMatrix; ht, len:UIntSize; thresh:fComplex );
|
|
Beschreibung | Die Faltung von MX mit der räumlichen Antwort- (engl. response) Funktion MRsp wird in MY zurückgegeben. Ein Raum-Filter MFlt wird ebenfalls berechnet. Falls mehr als eine Matrix mit derselben MRsp gefaltet werden soll, benutze man MF_convolve nur einmal und verwende anschließend MF_filter für die übrigen Matrizen.
Die Response-Funktion muss so in MRsp übergeben werden, dass jede Zeile i von MRsp die Antwortfunktion für 0 und positive x-Werte als Elemente MRspi,0 bis MRspi,len/2 enthält sowie die Antwortfunktion für negative x-Werte (beginnend mit dem betragsmäßig größten negativen x) in MRspi,len/2+1 bis MRspi,len-1.
Analog muss jede Spalte von MRsp die Übertragunsfunktion für 0 und positive y-Werte als Elemente MRsp0,j bis MRsplen/2,j enthalten sowie die Übertragungsfunktion für negative y-Werte (beginnend mit dem betragsmäßig größten negativen y) in MRsplen/2+1,j bis MRsplen-1,j.
Am besten benutzte man MF_Rows_rotate und MF_Cols_rotate oder MF_Rows_reflect und MF_Cols_reflect, um diese Anordnung zu erhalten und die Matrix der Übertragungsfunktion zu konstruieren.
Das Ergebnis der Faltung erscheint mit der Summe aller Elemente von MRsp skaliert. Im Normalfall sollte MRsp daher auf 1.0 normalisiert werden.
MX, MY, MRsp und MFlt müssen alle dieselben Dimensionen besitzen. Sowohl len als auch ht müssen ganzzahlige Potenzen von 2 sein. MX darf durch MY überschrieben werden und MRsp durch MFlt, aber MX und MFlt sowie MY und MRsp müssen jeweils voneinander verschieden sein.
Eine Response-Funktion, bei der manche Raumfrequenzen so stark gedämpft werden, dass für sie jegliche Information verlorengeht (also z.B. die hohen Frequenzen bei einem Tiefpass-Filter), erkennt man an sehr kleinen Werten von MFlt für die betreffenden Frequenzen. Sehr klein" bedeutet dabei, dass sie relativ zu dem Spitzenwert im Bereich der Genauigkeit des jeweiligen Datentypes liegen. Zur Minimierung von Rundungsfehlern bei der Faltung ersetzt MF_convolve solche sehr kleinen Werte in MFlt durch 0.
Alle ein- und zweidimensionalen Faltungen und Entfaltungen verwenden denselben standardmäßig eingestellten Schwellenwert für diese implizite Filter-Editierung. Er kann durch VF_setRspEdit ausgelesen werden. Um für sämtliche Aufrufe von VF / MF_convolve und VF / MF_deconvolve einen anderen Schwellenwert einzustellen, kann die Funktion VF_setRspEdit aufgerufen werden. Diese Methode ist aber nicht fiber-sicher und daher nicht geeignet, um den Schwellenwert bei verschiedenen Aufrufen von VF / MF_convolve bzw. VF / MF_deconvolve unterschiedlich einzustellen. Hier muss die Variante MF_convolvewEdit verwendet werden, die den gewünschten Schwellenwert als Argument thresh übernimmt. Da MFlt aus komplexen Zahlen besteht und es gelegentlich wünschenswert ist, Real- und Imaginärteile unterschiedlich zu behandeln, ist thresh ebenfalls komplex.
Die Eingabe-Matrix wird als in beiden Dimensionen periodisch angenommen. Man vergleiche die Beschreibung von VF_convolve bezüglich der Vermeidung von Randeffekten bei nicht-periodischen Matrizen.
Intern benötigt MF_convolve / MF_convolvewEdit zusätzlichen Pufferspeicher, der automatisch reserviert und wieder freigegeben wird. Bei wiederholten Aufrufen wäre dies ineffizient. Es wird empfohlen, für solche Fälle stattdessen MFb_convolve / MFb_convolvewEdit zu verwenden. Für die Größe von Buf gilt dabei:
C/C++: | sizeof(Buf) >= ht*(len+4) |
Pascal/Delphi: | sizeof(Buf) >= ht*len |
|
Außerdem muss Buf 128-bit (P8) bzw. 256-bit( P9) ausgerichtet sein. Um dies zu garantieren, sollte man nur Vektoren als Buf verwenden, die mit der VF_vector-Familie alloziert wurden. |
Fehlerbehandlung | Falls entweder len oder ht nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf MF_convolve basiert) mit der Fehlermeldung "Size must be an integer power of 2" und bricht das Programm ab. |
|
|
MF_cprint
| MD_cprint |
ME_cprint |
MCF_cprint |
MCD_cprint |
MCE_cprint |
MI_cprint | MBI_cprint | MSI_cprint | MLI_cprint | MQI_cprint |
MU_cprint | MUB_cprint | MUS_cprint | MUL_cprint | MUQ_cprint |
|
Funktion | Matrix auf dem Bildschirm ausgeben (nur für Konsolen-Anwendungen) |
|
Syntax C/C++ | #include <MFstd.h>
void MF_cprint( fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::cprint(); |
Pascal/Delphi | uses MFstd;
procedure MF_cprint( MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_cprint( fMatrix d_MA, ui ht, ui len );
int cudaMF_cprint_buf( fMatrix d_MA, ui ht, ui len, fVector h_Wk );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_cprint( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMF_cprint_buf( d_MA:fMatrix; ht, len:UIntSize; h_Wk:fVector ): IntBool;
|
|
Beschreibung | Die Matrix A wird auf dem Bildschirm ausgegeben. Jede Bildschirm-Zeile entspricht einer Zeile der Matrix. Die Zeilen werden von 0 and numeriert. Falls nötig, werden die Zeilen am Bildschirmrand abgeschnitten. Falls mehr Zeilen auszugeben sind, als auf den Bildschirm passen, wird die Matrix in mehrere Seiten aufgespalten.
Cartesisch-komplexe Zahlen werden in geschweiften Klammern mit einem Komma zwischen dem Real- und dem Imaginärteil geschrieben: {Re, Im}.
Im Gegensatz zu MF_write kann die automatische Wahl des Ausgabeformats nicht verändert werden. Die Anzahl der pro Element ausgegebenen Stellen richtet sich nach dem zur Verfügung stehenden Platz, der wiederum durch die Spaltenzahl len und die Zeilenbreite des Bildschirms bestimmt wird.
Diese Familie von Funktionen ist nur für Konsolenanwendungen verwendbar. |
nur CUDA-Versionen: | cudaM?_cprint_buf übernimmt einen Host-Vektor h_Wk als zusätzliches Argument. Dieser dient als Pufferspeicher und muss (mindestens) dieselbe Größe haben wie X. Hierdurch wird die interne Bereitstellung von Pufferspeicher bei cudaM?_cprint eingespart, so dass cudaM?_cprint_buf etwas schneller ist. |
Andere Windows-Compiler sowie Linux: |
Da hier die Textfenster-Breite und Höhe nicht ohne weiteres verfügbar sind, werden Aufrufe von M?_cprint nach MF_print umgeleitet.
Dieselbe Umleitung erfolgt auch für Visual C++ mit statischer Laufzeitbibliothek, hier wegen Inkompatibilitäten zwischen den verschiedenen Visual C++-Versionen. |
GCC-Windows-spezifisch: | Zwar unterstützt GCC auch in der Windows-Portierung den 80-bit-Fließkomma-Typ long double. Die I/O-Routinen verwenden aber die Laufzeitbibliothek von Visual C++, wo 80-bit-long doubles schon seit langem nicht mehr vorkommen. Dies bedeutet, dass ME_cprint und MCE_cprint bei GCC nur mit double-Genauigkeit und innerhalb des für doubles möglichen Größenbereiches arbeiten (also Eingabewerte ggf. auf diesen abgeschnitten werden). Um wenigstens eine Ausgabe im Hexadezimal-Format in voller Genauigkeit zu erhalten, rufe man ME_chexprint etc. |
|
Fehlerbehandlung | Wenn die Zahl der Spalten die maximal im derzeitigen Text-Modus mögliche Zahl der Einträge übersteigt, wird eine Fehlermeldung "Cannot use requested format (too many entries per line)!" ausgegeben; in diesem Fall, werden die Zeilen abgeschnitten und das Programm danach fortgesetzt.
|
|
|
MF_decElement | MD_decElement | ME_decElement |
MCF_decElement | MCD_decElement | MCE_decElement |
MCF_decElementRe | MCD_decElementRe | MCE_decElementRe |
MCF_decElementIm | MCD_decElementIm | MCE_decElementIm |
MI_decElement | MBI_decElement | MSI_decElement | MLI_decElement | MQI_decElement | |
MU_decElement | MUB_decElement | MUS_decElement | MUL_decElement | MUQ_decElement | MUI_decElement |
|
Funktion | Ein Matrix-Element um einen bestimmten Wert erniedrigen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_decElement( fVector MA, ui ht, ui len, ui m, ui n, float C );
#include <MCFstd.h>
void MCF_decElement( cfMatrix MA, ui ht, ui len, ui m, ui n, fComplex C );
void MCF_decElementRe( fMatrix MA, ui ht, ui len, ui m, ui n, float C );
void MCF_decElementIm( fMatrix MA, ui ht, ui len, ui m, ui n, float C ); |
C++ VecObj | #include <OptiVec.h>
matrix<T>::decElement( ui ht, ui len, ui m, ui n, T C );
matrix<complex<T>>::decElement( ui ht, ui len, ui m, ui n, complex<T> C );
matrix<complex<T>>::decElementRe( ui ht, ui len, ui m, ui n, T C );
matrix<complex<T>>::decElementIm( ui ht, ui len, ui m, ui n, T C ); |
Pascal/Delphi | uses MFstd;
procedure MF_decElement( MA:fVector; ht, len, m, n:UIntSize; C:Single );
uses MCFstd;
procedure MCF_decElement( MA:cfMatrix; ht, len, m, n:UIntSize; C:fComplex );
procedure MCF_decElementRe( MA:cfMatrix; ht, len, m, n:UIntSize; C:Single );
procedure MCF_decElementIm( MA:cfMatrix; ht, len, m, n:UIntSize; C:Single );
|
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
void cudaMF_decElement( fMatrix d_MA, ui ht, ui len, ui m, ui n, float C );
void cusdMF_decElement( fMatrix d_MA, ui ht, ui len, ui m, ui n, float *d_C );
#include <cudaMCFstd.h>
void cudaMCF_decElement( cfMatrix d_MA, ui ht, ui len, ui m, ui n, fComplex C );
void cusdMCF_decElement( cfMatrix d_MA, ui ht, ui len, ui m, ui n, fComplex *d_C );
void cudaMCF_decElementRe( cfMatrix d_MA, ui ht, ui len, ui m, ui n, float C );
void cusdMCF_decElementRe( cfMatrix d_MA, ui ht, ui len, ui m, ui n, float *d_C );
void cudaMCF_decElementIm( cfMatrix d_MA, ui ht, ui len, ui m, ui n, float C );
void cusdMCF_decElementIm( cfMatrix d_MA, ui ht, ui len, ui m, ui n, float *d_C );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
procedure cudaMF_decElement( d_MA:fMatrix; ht, len, m, n:UIntSize; C:Single );
procedure cusdMF_decElement( d_MA:fMatrix; ht, len, m, n:UIntSize; d_C:PSingle );
uses MCFstd;
procedure cudaMCF_decElement( d_MA:cfMatrix; ht, len, m, n:UIntSize; C:fComplex );
procedure cusdMCF_decElement( d_MA:cfMatrix; ht, len, m, n:UIntSize; d_C:PfComplex );
procedure cudaMCF_decElementRe( d_MA:cfMatrix; ht, len, m, n:UIntSize; C:Single );
procedure cusdMCF_decElementRe( d_MA:cfMatrix; ht, len, m, n:UIntSize; d_C:PSingle );
procedure cudaMCF_decElementIm( d_MA:cfMatrix; ht, len, m, n:UIntSize; C:Single );
procedure cusdMCF_decElementIm( d_MA:cfMatrix; ht, len, m, n:UIntSize; d_C:PSingle );
|
|
Beschreibung | Reelle Versionen:
X[m][n] -= C; Das Element an der Position m, n wird um den Wert C erniedrigt.
Komplexe Versionen MCF_decElement usw.:
X[m][n].Re -= C.Re; X[m][n].Im -= C.Im;
Komplexe Versionen MCF_decElementRe usw.:
X[m][n].Re -= C.Re;
Der Imaginärteil X[m][n].Im bleibt unangetastet.
Komplexe Versionen MCF_decElementIm usw.:
X[m][n].Im -= C.Im;
Der Realteil X[m][n].Re bleibt unangetastet.
|
|
|
|
|
MF_deconvolve
| MD_deconvolve |
ME_deconvolve |
MF_deconvolvewEdit
| MD_deconvolvewEdit |
ME_deconvolvewEdit |
MFb_deconvolve
| MDb_deconvolve |
MEb_deconvolve |
MFb_deconvolvewEdit
| MDb_deconvolvewEdit |
MEb_deconvolvewEdit |
|
Funktion | Räumliche Entfaltung (Dekonvolution), Kanten-Schärfung |
|
Syntax C/C++ | #include <MFstd.h>
void MF_convolve( fMatrix Y, fMatrix Flt, fMatrix X, fMatrix Rsp, ui ht, ui len );
void MF_convolvewEdit( fMatrix Y, fMatrix Flt, fMatrix X, fMatrix Rsp, ui ht, ui len, fComplex thresh );
void MFb_convolve( fMatrix Y, fMatrix Flt, fMatrix X, fMatrix Rsp, ui ht, ui len, fVector Buf );
void MFb_convolvewEdit( fMatrix Y, fMatrix Flt, fMatrix X, fMatrix Rsp, ui ht, ui len, fComplex thresh, fVector Buf ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::convolve( matrix<T> Flt, const matrix<T>& MX, const matrix<T> Rsp);
void matrix<T>::convolve( matrix<T>* Flt, const matrix<T>& MX, const matrix<T> Rsp);
void matrix<T>::convolvewEdit( matrix<T> Flt, const matrix<T>& MX, const matrix<T> Rsp, complex<T> thresh);
void matrix<T>::convolvewEdit( matrix<T>* Flt, const matrix<T>& MX, const matrix<T> Rsp, complex<T> thresh);
void matrix<T>::b_convolve( matrix<T> Flt, const matrix<T>& MX, const matrix<T> Rsp, vector<T> Buf);
void matrix<T>::b_convolve( matrix<T>* Flt, const matrix<T>& MX, const matrix<T> Rsp, vector<T> Buf);
void matrix<T>::b_convolvewEdit( matrix<T> Flt, const matrix<T>& MX, const matrix<T> Rsp, complex<T> thresh, vector<T> Buf);
void matrix<T>::b_convolvewEdit( matrix<T>* Flt, const matrix<T>& MX, const matrix<T> Rsp, complex<T> thresh, vector<T> Buf); |
Pascal/Delphi | uses MFstd;
procedure MF_convolve( MY, MFlt, MX, MRsp:fMatrix; ht, len:UIntSize );
procedure MF_convolvewEdit( MY, MFlt, MX, MRsp:fMatrix; ht, len:UIntSize; thresh:fComplex );
procedure MFb_convolve( MY, MFlt, MX, MRsp:fMatrix; ht, len:UIntSize; Buf:fVector );
procedure MFb_convolvewEdit( MY, MFlt, MX, MRsp:fMatrix; ht, len:UIntSize; thresh:fComplex; Buf:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_deconvolve( fMatrix d_MY, fMatrix d_MFlt, fMatrix d_MX, fMatrix d_MRsp, ui ht, ui len );
void MFcu_deconvolve( fMatrix h_MY, fMatrix h_MFlt, fMatrix h_MX, fMatrix h_MRsp, ui ht, ui len );
int cudaMF_deconvolvewEdit( fMatrix d_MY, fMatrix d_MFlt, fMatrix d_MX, fMatrix d_MRsp, ui ht, ui len, fComplex thresh );
void MFcu_deconvolvewEdit( fMatrix h_MY, fMatrix h_MFlt, fMatrix h_MX, fMatrix h_MRsp, ui ht, ui len, fComplex thresh );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_deconvolve( d_MY, d_MFlt, d_MX, d_MRsp:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_deconvolve( h_MY, h_MFlt, h_MX, h_MRsp:fMatrix; ht, len:UIntSize );
function cudaMF_deconvolvewEdit( d_MY, d_MFlt, d_MX, d_MRsp:fMatrix; ht, len:UIntSize; thresh:fComplex ): IntBool;
procedure MFcu_deconvolvewEdit( h_MY, h_MFlt, h_MX, h_MRsp:fMatrix; ht, len:UIntSize; thresh:fComplex );
|
|
Beschreibung | MX wird als Ergebnis einer hypothetischen Faltung eines "wahren" Profils mit einer Response-Funktion MRsp angenommen. Eine Dekonvolution wird versucht und in MY gespeichert. Ein Filter MFlt wird ebenfalls berechnet. Falls mehr als eine Bild-Matrix mit derselben MRsp zu schärfen ist , benutze man MF_deconvolve nur einmal und verwende den so erhaltenen Filter MFlt, um weitere Matrizen durch Aufrufe von MF_filter zu entfalten. Die Response-Funktion muss in der für MF_convolve beschriebenen Weise in MRsp angeordnet werden.
Ebenso wie für MF_convolve müssen auch hier MX, MY, MRsp und MFlt alle dieselben Dimensionen aufweisen, die wiederum ganzzahlige Potenzen von 2 zu sein haben. MX darf durch MY überschrieben werden und MRsp durch MFlt, aber MX und MFlt sowie MY und MRsp müssen jeweils voneinander verschieden sein.
Mathematisch ist MFlt der Element für Element berechnete Kehrwert der Fourier-Transformierten von MRsp. Falls die Fourier-Transformierte von MRsp Elemente gleich Null enthält, bedeutet dies, dass jegliche Information für die betreffende Raum-Frequenz verloren und keine Rekonstruktion möglich ist. Das beste, was man in dieser Situation noch tun kann, ist, diesen Informationsverlust zu akzeptieren und nur bis zu denjenigen Raumfrequenzen zu schärfen, für die noch etwas übrig ist, um es zu rekonstruieren.
Es ist daher anzuraten, diese Funktion nicht "blind" zu gebrauchen, sondern die Fourier-Transformierte vonf MRsp zu inspizieren und auf der Basis des jeweiligen Anwendungs-Zweckes zu entscheiden, was zu tun ist. Wer diese Funktion trotzdem als solche anwenden möchte, der sollte die automatische Editierung des Filters ausnutzen, die in MF_deconvolve eingebaut ist. Hierdurch wird MFlt gleich Null (anstelle von Unendlich) gesetzt für diejenigen Frequenzen, an denen jegliche Information verloren ist.
Alle ein- und zweidimensionalen Faltungen und Entfaltungen verwenden denselben standardmäßig eingestellten Schwellenwert für diese implizite Filter-Editierung. Er kann durch VF_getRspEdit ausgelesen werden. Um für sämtliche Aufrufe von VF / MF_deconvolve und VF / MF_convolve einen anderen Schwellenwert einzustellen, kann die Funktion VF_setRspEdit aufgerufen werden. Diese Methode ist aber nicht fiber-sicher und daher nicht geeignet, um den Schwellenwert bei verschiedenen Aufrufen von VF / MF_deconvolve bzw. VF / MF_convolve unterschiedlich einzustellen. Hier muss die Variante MF_deconvolvewEdit verwendet werden, die den gewünschten Schwellenwert als Argument thresh übernimmt. Da MFlt aus komplexen Zahlen besteht und es gelegentlich wünschenswert ist, Real- und Imaginärteile unterschiedlich zu behandeln, ist thresh ebenfalls komplex.
Diese Dekonvolution basiert auf der stillschweigenden Annahme, dass MX in beiden Dimensionen periodisch ist; ist dies nicht der Fall, vergleiche man die Beschreibung von VF_convolve bezüglich der Vermeidung von Rand-Effekten.
Intern benötigt MF_deconvolve / MF_deconvolvewEdit zusätzlichen Pufferspeicher, der automatisch reserviert und wieder freigegeben wird. Bei wiederholten Aufrufen wäre dies ineffizient. Es wird empfohlen, für solche Fälle stattdessen MFb_deconvolve / MFb_deconvolvewEdit zu verwenden. Für die Größe von Buf gilt dabei:
C/C++: | sizeof(Buf) >= ht*(len+4) |
Pascal/Delphi: | sizeof(Buf) >= ht*len |
Außerdem muss Buf 128-bit (P8) bzw. 256-bit( P9) ausgerichtet sein. Um dies zu garantieren, sollte man nur Vektoren als Buf verwenden, die mit der VF_vector-Familie alloziert wurden. |
|
Fehlerbehandlung | Falls entweder len oder ht nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf MF_deconvolve basiert) mit der Fehlermeldung "Size must be an integer power of 2" und bricht das Programm ab.
Falls mittels VF_setRspEdit Trunc.Re = Trunc.Im = 0 spezifiziert wurde, können SING-Fehler auftreten, die durch Setzen von MFlt zu ±HUGE_VAL für die betreffende Raumfrequenz behandelt werden. Bei der Multiplikation mit der Fourier-Transformierten von MX kann dies aber zu unbehandeltem Fließkomma-Überlauf führen (dann nämlich, wenn die angenommene Übertragungsfunktion falsch war und doch noch Information vorhanden ist für Raumfrequenzen, wo keine mehr erwartet wurde).
|
|
|
MF_detwEdit
| MD_detwEdit |
ME_detwEdit |
MCF_detwEdit |
MCD_detwEdit |
MCE_detwEdit |
MCFb_det |
MCDb_det |
MCEb_det |
MFb_detwEdit
| MDb_detwEdit |
MEb_detwEdit |
MCFb_detwEdit |
MCDb_detwEdit |
MCEb_detwEdit |
MFb_det_sizeBuf
| MDb_det_sizeBuf |
MEb_det_sizeBuf |
MCFb_det_sizeBuf |
MCDb_det_sizeBuf |
MCEb_det_sizeBuf |
MFsym_det
| MDsym_det |
MEsym_det |
|
Funktion | Determinante einer Quadratmatrix |
|
Syntax C/C++ | #include <MFstd.h>
float MF_det( fMatrix MA, ui len );
float MFb_det( fMatrix MA, ui len, fVector Buf );
fComplex MCF_det( cfMatrix MA, ui len );
fComplex MCFb_det( cfMatrix MA, ui len, cfVector Buf );
ui MFb_det_sizeBuf( ui len );
float MFsym_det( fMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
T matrix<T>::det();
T matrix<T>::b_det( vector<T>& Buf );
complex<T> matrix<complex<T>>::det();
complex<T> matrix<complex<T>>::b_det( vector<complex<T>>& Buf );
ui matrix<T>::b_det_sizeBuf( const ui len );
T matrix<T>::sym_det();
|
Pascal/Delphi | uses MFstd;
function MF_det( MA:fMatrix; len:UIntSize ):Single;
function MFb_det( MA:fMatrix; len:UIntSize; Buf:fVector ):Single;
function MCF_det( MA:cfMatrix; len:UIntSize ):fComplex;
function MCFb_det( MA:cfMatrix; len:UIntSize; Buf:cfVector ):fComplex;
function MFb_det_sizeBuf( len:UIntSize ):UIntSize;
function MFsym_det( MA:fMatrix; len:UIntSize ):Single;
|
|
Beschreibung | Die Determinante von MA wird berechnet. Für große Matrizen geschieht dies im Normalfall durch MF_det über LU-Faktorisierung. Kleine Matrizen werden individuell behandelt. Im Spezialfall symmetrischer Matrizen kann die Determinante auch ungefähr doppelt so schnell durch MFsym_det berechnet werden.
MF_det benötigt Pufferspeicher. Die "Normal-Versionen" (Präfix MF_, MCF_ usw.) allozieren ihn selbst, während die Versionen mit den Präfixen MFb_, MCFb_ etc. als zusätzliches Aufruf-Argument einen Vektor Buf übernehmen. Die erforderliche Größe von Buf kann mittels Aufruf von MFb_det_sizeBuf() abgefragt werden (Angabe nicht in byte, sondern als Zahl der Elemente von Buf im jeweiligen Datentyp!).
Wie erwähnt kann die Determinante einer symmetrischen Matrix u.U. wesentlich schneller mittels MFsym_det berechnet werden. Die Syntax von MFsym_det ist identisch mit MF_inv. Diese Funktion versucht zunächst Cholesky-Faktorisierung. Nur falls diese nicht erfolgreich ist (sich die Eingabe-Matrix also als nicht-positiv-definit herausstellt), wird doch der Weg über LUD beschritten. |
|
Rückgabewert | Determinante der Matrix |
|
|
MF_Dia_absmax
| MD_Dia_absmax |
ME_Dia_absmax |
MCF_Dia_absmax |
MCD_Dia_absmax |
MCE_Dia_absmax |
|
Funktion | Betrags-Maximum der Diagonal-Elemente einer Quadratmatrix |
|
Syntax C/C++ | #include <MFstd.h>
float MF_Dia_absmax( fMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
T matrix<T>::Dia_absmax(); |
Pascal/Delphi | uses MFstd;
function MF_Dia_absmax( MA:fMatrix; len:UIntSize ):Single; |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_absmax( float *h_RetVal, fMatrix d_MA, ui len );
int cusdMF_Dia_absmax( float *d_RetVal, fMatrix d_MA, ui len );
float MFcu_Dia_absmax( fMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_absmax( var h_RetVal:Single; d_MA:fMatrix; len:UIntSize ): IntBool;
function cusdMF_Dia_absmax( d_RetVal:PSingle; d_MA:fMatrix; len:UIntSize ): IntBool;
procedure MFcu_Dia_absmax( h_MA:fMatrix; len:UIntSize ): Single;
|
|
Beschreibung | Das Betrags-Maximum der Elemente MAi,i wird als Skalar zurückgegeben. |
|
Rückgabewert | Betrags-Maximum der Diagonalen |
|
|
MCF_Dia_absmaxReIm
| MCD_Dia_absmaxReIm |
MCE_Dia_absmaxReIm |
|
Funktion | Getrennte Bestimmung des größten Absolutwertes von Real- und Imaginärteil der Diagonal-Elemente einer Quadratmatrix |
|
Syntax C/C++ | #include <MCFstd.h>
fComplex MCF_Dia_absmaxReIm( cfMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
complex<T> matrix<complex<T>>::Dia_absmaxReIm( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
function MCF_Dia_absmaxReIm( MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax:
procedure MCF_Dia_absmaxReIm( var RetVal:fComplex; MA:cfMatrix; len:UIntSize );
|
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Dia_absmaxReIm( fComplex *h_RetVal, cfMatrix d_MA, ui len );
int cusdMCF_Dia_absmaxReIm( fComplex *d_RetVal, cfMatrix d_MA, ui len );
fComplex MCFcu_Dia_absmaxReIm( cfMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Dia_absmaxReIm( var h_RetVal:fComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function cusdMCF_Dia_absmaxReIm( d_RetVal:PfComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function MCFcu_Dia_absmaxReIm( h_MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax:
procedure MCFcu_Dia_absmaxReIm( var h_RetVal:fComplex; h_MA:cfMatrix; len:UIntSize );
|
|
Beschreibung | Die getrennt voneinander bestimmten Betrags-Maxima der Real- und der Imaginärteile entlang der Diagonale von MA werden zu dem komplexen Rückgabewert (bzw. für Pascal/Delphi zu der komplexen Variablen Max) kombiniert. |
|
|
MF_Dia_absmin
| MD_Dia_absmin |
ME_Dia_absmin |
MCF_Dia_absmin |
MCD_Dia_absmin |
MCE_Dia_absmin |
|
Funktion | Betrags-Minimum der Diagonal-Elemente einer Quadratmatrix |
|
Syntax C/C++ | #include <MFstd.h>
float MF_Dia_absmin( fMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
T matrix<T>::Dia_absmin(); |
Pascal/Delphi | uses MFstd;
function MF_Dia_absmin( MA:fMatrix; len:UIntSize ):Single; |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_absmin( float *h_RetVal, fMatrix d_MA, ui len );
int cusdMF_Dia_absmin( float *d_RetVal, fMatrix d_MA, ui len );
float MFcu_Dia_absmin( fMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_absmin( var h_RetVal:Single; d_MA:fMatrix; len:UIntSize ): IntBool;
function cusdMF_Dia_absmin( d_RetVal:PSingle; d_MA:fMatrix; len:UIntSize ): IntBool;
procedure MFcu_Dia_absmin( h_MA:fMatrix; len:UIntSize ): Single;
|
|
Beschreibung | Das Betrags-Minimum der Elemente MAi,i wird als Skalar zurückgegeben. |
|
Rückgabewert | Betrags-Minimum der Diagonalen |
|
|
MCF_Dia_absminReIm
| MCD_Dia_absminReIm |
MCE_Dia_absminReIm |
|
Funktion | Getrennte Bestimmung des kleinsten Absolutwertes von Real- und Imaginärteil der Diagonal-Elemente einer Quadratmatrix |
|
Syntax C/C++ | #include <MCFstd.h>
fComplex MCF_Dia_absminReIm( cfMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
complex<T> matrix<complex<T>>::Dia_absminReIm( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
function MCF_Dia_absminReIm( MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax:
procedure MCF_Dia_absminReIm( var Min:fComplex; MA:cfMatrix; len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Dia_absminReIm( fComplex *h_RetVal, cfMatrix d_MA, ui len );
int cusdMCF_Dia_absminReIm( fComplex *d_RetVal, cfMatrix d_MA, ui len );
fComplex MCFcu_Dia_absminReIm( cfMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Dia_absminReIm( var h_RetVal:fComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function cusdMCF_Dia_absminReIm( d_RetVal:PfComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function MCFcu_Dia_absminReIm( h_MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax:
procedure MCFcu_Dia_absminReIm( var h_RetVal:fComplex; h_MA:cfMatrix; len:UIntSize );
|
|
Beschreibung | Die getrennt voneinander bestimmten Betrags-Minima der Real- und der Imaginärteile entlang der Diagonale von MA werden zu dem komplexen Rückgabewert (bzw. für Pascal/Delphi zu der komplexen Variablen Min) kombiniert. |
|
|
MF_Dia_addC
| MD_Dia_addC |
ME_Dia_addC |
MCF_Dia_addC |
MCD_Dia_addC |
MCE_Dia_addC |
|
Funktion | eine Konstante zu alle Elemente der Diagonalen einer Quadratmatrix hinzuaddieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_addC( fMatrix MA, ui len, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Dia_addC( const T& C ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_addC( MA:fMatrix; len:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_addC( fMatrix d_MA, ui len, float C );
int cusdMF_Dia_addC( fMatrix d_MA, ui len, float *d_C );
void MFcu_Dia_addC( fMatrix h_MA, ui len, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_addC( d_MA:fMatrix; len:UIntSize; C:Single ): IntBool;
function cusdMF_Dia_addC( d_MA:fMatrix; len:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Dia_addC( h_MA:fMatrix; len:UIntSize; C:Single );
|
|
Beschreibung | MAi,i += C, i=0,...,len-1 |
|
|
MF_Dia_addV
| MD_Dia_addV |
ME_Dia_addV |
MCF_Dia_addV |
MCD_Dia_addV |
MCE_Dia_addV |
|
Funktion | Element-weise Addition eines Vektors zur der Diagonalen einer Quadratmatrix |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_addV( fMatrix MA, ui len, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Dia_addV( const vector<T>& X ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_addV( MA:fMatrix; len:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_addV( fMatrix d_MA, ui len, fVector d_X );
void MFcu_Dia_addV( fMatrix h_MA, ui len, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_addV( d_MA:fMatrix; len:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Dia_addV( h_MA:fMatrix; len:UIntSize; h_X:fVector );
|
|
Beschreibung | MAi,i += Xi, i=0,...,len-1 |
|
|
MCF_Dia_cabsmax
| MCD_Dia_cabsmax |
MCE_Dia_cabsmax |
|
Funktion | Finden des Diagonalelements mit dem größten Betrag |
|
Syntax C/C++ | #include <MCFstd.h>
fComplex MCF_Dia_cabsmax( cfMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
complex<T> matrix<complex<T>>::Dia_cabsmax( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
function MCF_Dia_cabsmax( MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax:
procedure MCF_Dia_cabsmax( var Max:fComplex; MA:cfMatrix; len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Dia_cabsmax( fComplex *h_RetVal, cfMatrix d_MA, ui len );
int cusdMCF_Dia_cabsmax( fComplex *d_RetVal, cfMatrix d_MA, ui len );
fComplex MCFcu_Dia_cabsmax( cfMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Dia_cabsmax( var h_RetVal:fComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function cusdMCF_Dia_cabsmax( d_RetVal:PfComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function MCFcu_Dia_cabsmax( h_MA:cfMatrix; len:UIntSize ): fComplex;
Alternative syntax for the complex types:
procedure MCFcu_Dia_cabsmax( var h_RetVal:fComplex; h_MA:cfMatrix; len:UIntSize );
|
|
Beschreibung | Dasjenige Element der Diagonale von MA, das den größten Betrag, sqrt(Re2+Im2), besitzt, wird zurückgegeben (bzw. für Pascal/Delphi in der Variablen Max gespeichert). |
|
|
MCF_Dia_cabsmin
| MCD_Dia_cabsmin |
MCE_Dia_cabsmin |
|
Funktion | Finden des Diagonalelements mit dem kleinsten Betrag |
|
Syntax C/C++ | #include <MCFstd.h>
fComplex MCF_Dia_cabsmin( cfMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
complex<T> matrix<complex<T>>::Dia_cabsmin( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
function MCF_Dia_cabsmin( MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax:
procedure MCF_Dia_cabsmin( var Max:fComplex; MA:cfMatrix; len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Dia_cabsmin( fComplex *h_RetVal, cfMatrix d_MA, ui len );
int cusdMCF_Dia_cabsmin( fComplex *d_RetVal, cfMatrix d_MA, ui len );
fComplex MCFcu_Dia_cabsmin( cfMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Dia_cabsmin( var h_RetVal:fComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function cusdMCF_Dia_cabsmin( d_RetVal:PfComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function MCFcu_Dia_cabsmin( h_MA:cfMatrix; len:UIntSize ): fComplex;
Alternative syntax for the complex types:
procedure MCFcu_Dia_cabsmin( var h_RetVal:fComplex; h_MA:cfMatrix; len:UIntSize );
|
|
Beschreibung | Dasjenige Element der Diagonale von MA, das den kleinsten Betrag, sqrt(Re2+Im2), besitzt, wird zurückgegeben (bzw. für Pascal/Delphi in der Variablen Min gespeichert). |
|
|
MF_Dia_divC
| MD_Dia_divC |
ME_Dia_divC |
MCF_Dia_divC |
MCD_Dia_divC |
MCE_Dia_divC |
|
Funktion | alle Elemente der Diagonalen einer Quadratmatrix durch eine Konstante dividieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_divC( fMatrix MA, ui len, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Dia_divC( const T& C ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_divC( MA:fMatrix; len:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_divC( fMatrix d_MA, ui len, float C );
int cusdMF_Dia_divC( fMatrix d_MA, ui len, float *d_C );
void MFcu_Dia_divC( fMatrix h_MA, ui len, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_divC( d_MA:fMatrix; len:UIntSize; C:Single ): IntBool;
function cusdMF_Dia_divC( d_MA:fMatrix; len:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Dia_divC( h_MA:fMatrix; len:UIntSize; C:Single );
|
|
Beschreibung | MAi,i /= C, i=0,...,len-1 |
|
|
MF_Dia_divrC
| MD_Dia_divrC |
ME_Dia_divrC |
MCF_Dia_divrC |
MCD_Dia_divrC |
MCE_Dia_divrC |
|
Funktion | umgekehrte Division: eine Konstante durch die Diagonal-Elemente einer Quadratmatrix teilen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_divrC( fMatrix MA, ui len, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Dia_divrC( const T& C ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_divrC( MA:fMatrix; len:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_divrC( fMatrix d_MA, ui len, float C );
int cusdMF_Dia_divrC( fMatrix d_MA, ui len, float *d_C );
void MFcu_Dia_divrC( fMatrix h_MA, ui len, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_divrC( d_MA:fMatrix; len:UIntSize; C:Single ): IntBool;
function cusdMF_Dia_divrC( d_MA:fMatrix; len:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Dia_divrC( h_MA:fMatrix; len:UIntSize; C:Single );
|
|
Beschreibung | MAi,i = C / MAi,i, i=0,...,len-1 |
|
|
MF_Dia_divrV
| MD_Dia_divrV |
ME_Dia_divrV |
MCF_Dia_divrV |
MCD_Dia_divrV |
MCE_Dia_divrV |
|
Funktion | umgekehrte Division: Vektor durch die Diagonale einer Quadratmatrix teilen und die Diagonale mit dem Ergebnis überschreiben |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_divrV( fMatrix MA, ui len, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Dia_divrV( const vector<T>& X ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_divrV( MA:fMatrix; len:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_divrV( fMatrix d_MA, ui len, fVector d_X );
void MFcu_Dia_divrV( fMatrix h_MA, ui len, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_divrV( d_MA:fMatrix; len:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Dia_divrV( h_MA:fMatrix; len:UIntSize; h_X:fVector );
|
|
Beschreibung | MAi,i = Xi / MAi,i, i=0,...,len-1 |
|
|
MF_Dia_divV
| MD_Dia_divV |
ME_Dia_divV |
MCF_Dia_divV |
MCD_Dia_divV |
MCE_Dia_divV |
|
Funktion | Element-weise Division der Diagonalen einer Quadratmatrix durch einen Vektor |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_divV( fMatrix MA, ui len, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Dia_divV( const vector<T>& X ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_divV( MA:fMatrix; len:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_divV( fMatrix d_MA, ui len, fVector d_X );
void MFcu_Dia_divV( fMatrix h_MA, ui len, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_divV( d_MA:fMatrix; len:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Dia_divV( h_MA:fMatrix; len:UIntSize; h_X:fVector );
|
|
Beschreibung | MAi,i / Xi, i=0,...,len-1 |
|
|
MF_Dia_equ0
| MD_Dia_equ0 |
ME_Dia_equ0 |
MCF_Dia_equ0 |
MCD_Dia_equ0 |
MCE_Dia_equ0 |
MCF_Dia_Reequ0 |
MCD_Dia_Reequ0 |
MCE_Dia_Reequ0 |
MCF_Dia_Imequ0 |
MCD_Dia_Imequ0 |
MCE_Dia_Imequ0 |
MI_Dia_equ0 | MBI_Dia_equ0 | MSI_Dia_equ0 | MLI_Dia_equ0 | MQI_Dia_equ0 |
MU_Dia_equ0 | MUB_Dia_equ0 | MUS_Dia_equ0 | MUL_Dia_equ0 | MUQ_Dia_equ0 |
|
Funktion | alle Diagonal-Elemente einer Quadratmatrix mit Null initialisieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_equ0( fMatrix MA, ui len );
void MCF_Dia_Reequ0( cfMatrix MA, ui len );
void MCF_Dia_Imequ0( cfMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Dia_equ0();
void matrix<complex<T>>::Dia_Reequ0( );
void matrix<complex<T>>::Dia_Imequ0( ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_equ0( MA:fMatrix; len:UIntSize );
procedure MCF_Dia_Reequ0( MA:cfMatrix; len:UIntSize );
procedure MCF_Dia_Imequ0( MA:cfMatrix; len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_equ0( fMatrix d_MA, ui len );
int cudaMCF_Dia_Reequ0( cfMatrix d_MA, ui len );
int cudaMCF_Dia_Imequ0( cfMatrix d_MA, ui len );
void MFcu_Dia_equ0( fMatrix h_MA, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_equ0( d_MA:fMatrix; len:UIntSize ): IntBool;
function cudaMCF_Dia_Reequ0( d_MA:cfMatrix; len:UIntSize ): IntBool;
function cudaMCF_Dia_Imequ0( d_MA:cfMatrix; len:UIntSize ): IntBool;
procedure MFcu_Dia_equ0( h_MA:fMatrix; len:UIntSize );
|
|
Beschreibung | M?_Dia_equ0: | MAi,i = 0, i=0,...,len-1 |
MC?_Dia_Reequ0: | MAi,i.Re = 0, i=0,...,len-1 (MAi,i.Im bleibt unverändert) |
MC?_Dia_Imequ0: | MAi,i.Im = 0, i=0,...,len-1 (MAi,i.Re bleibt unverändert) |
|
|
|
MF_Dia_equC
| MD_Dia_equC |
ME_Dia_equC |
MCF_Dia_equC |
MCD_Dia_equC |
MCE_Dia_equC |
MI_Dia_equC | MBI_Dia_equC | MSI_Dia_equC | MLI_Dia_equC | MQI_Dia_equC |
MU_Dia_equC | MUB_Dia_equC | MUS_Dia_equC | MUL_Dia_equC | MUQ_Dia_equC |
|
Funktion | alle Diagonal-Elemente einer Quadratmatrix mit einer Konstanten initialisieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_equC( fMatrix MA, ui len, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Dia_equC( const T& C ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_equC( MA:fMatrix; len:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_equC( fMatrix d_MA, ui len, float C );
int cusdMF_Dia_equC( fMatrix d_MA, ui len, float *d_C );
void MFcu_Dia_equC( fMatrix h_MA, ui len, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_equC( d_MA:fMatrix; len:UIntSize; C:Single ): IntBool;
function cusdMF_Dia_equC( d_MA:fMatrix; len:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Dia_equC( h_MA:fMatrix; len:UIntSize; C:Single );
|
|
Beschreibung | MAi,i = C, i=0,...,len-1 |
|
|
MF_Dia_equV
| MD_Dia_equV |
ME_Dia_equV |
MCF_Dia_equV |
MCD_Dia_equV |
MCE_Dia_equV |
MI_Dia_equV | MBI_Dia_equV | MSI_Dia_equV | MLI_Dia_equV | MQI_Dia_equV |
MU_Dia_equV | MUB_Dia_equV | MUS_Dia_equV | MUL_Dia_equV | MUQ_Dia_equV |
|
Funktion | Vektor in die Diagonale einer Quadratmatrix kopieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_equV( fMatrix MA, ui len, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Dia_equV( const vector<T>& X ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_equV( MA:fMatrix; len:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_equV( fMatrix d_MA, ui len, fVector d_X );
void MFcu_Dia_equV( fMatrix h_MA, ui len, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_equV( d_MA:fMatrix; len:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Dia_equV( h_MA:fMatrix; len:UIntSize; h_X:fVector );
|
|
Beschreibung | MAi,i = Xi, i=0,...,len-1 |
|
|
MF_Dia_extract
| MD_Dia_extract |
ME_Dia_extract |
MCF_Dia_extract |
MCD_Dia_extract |
MCE_Dia_extract |
MI_Dia_extract | MBI_Dia_extract | MSI_Dia_extract | MLI_Dia_extract | MQI_Dia_extract |
MU_Dia_extract | MUB_Dia_extract | MUS_Dia_extract | MUL_Dia_extract | MUQ_Dia_extract |
|
Funktion | die Diagonale einer Quadratmatrix in einen Vektor kopieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_extract( fVector Y, fMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::Dia_extract( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_extract( Y:fVector; MA:fMatrix; len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_extract( fVector d_Y, fMatrix d_MA, ui len );
void MFcu_Dia_extract( fVector h_Y, fMatrix h_MA, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_extract( d_Y:fVector; d_MA:fMatrix; len:UIntSize ): IntBool;
procedure MFcu_Dia_extract( h_Y:fVector; h_MA:fMatrix; len:UIntSize );
|
|
Beschreibung | Yi = MAi,i, i=0,...,len-1 |
|
|
MF_Dia_max
| MD_Dia_max |
ME_Dia_max |
MI_Dia_max | MBI_Dia_max | MSI_Dia_max | MLI_Dia_max | MQI_Dia_max |
MU_Dia_max | MUB_Dia_max | MUS_Dia_max | MUL_Dia_max | MUQ_Dia_max |
|
Funktion | Maximum der Diagonal-Elemente einer Quadratmatrix |
|
Syntax C/C++ | #include <MFstd.h>
float MF_Dia_max( fMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
T matrix<T>::Dia_max(); |
Pascal/Delphi | uses MFstd;
function MF_Dia_max( MA:fMatrix; len:UIntSize ):Single; |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_max( float *h_RetVal, fMatrix d_MA, ui len );
int cusdMF_Dia_max( float *d_RetVal, fMatrix d_MA, ui len );
float MFcu_Dia_max( fMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_max( var h_RetVal:Single; d_MA:fMatrix; len:UIntSize ): IntBool;
function cusdMF_Dia_max( d_RetVal:PSingle; d_MA:fMatrix; len:UIntSize ): IntBool;
procedure MFcu_Dia_max( h_MA:fMatrix; len:UIntSize ): Single;
|
|
Beschreibung | Das größte Element der Diagonalen wird als Skalar zurückgegeben |
|
Rückgabewert | Maximum der Diagonalen |
|
|
MCF_Dia_maxReIm
| MCD_Dia_maxReIm |
MCE_Dia_maxReIm |
|
Funktion | Getrennte Bestimmung der Maxima von Real- und Imaginärteil der Diagonal-Elemente einer Quadratmatrix |
|
Syntax C/C++ | #include <MCFstd.h>
fComplex MCF_Dia_maxReIm( cfMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
complex<T> matrix<complex<T>>::Dia_maxReIm( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
function MCF_Dia_maxReIm( MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax:
procedure MCF_Dia_maxReIm( var Max:fComplex; MA:cfMatrix; len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Dia_maxReIm( fComplex *h_RetVal, cfMatrix d_MA, ui len );
int cusdMCF_Dia_maxReIm( fComplex *d_RetVal, cfMatrix d_MA, ui len );
fComplex MCFcu_Dia_maxReIm( cfMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Dia_maxReIm( var h_RetVal:fComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function cusdMCF_Dia_maxReIm( d_RetVal:PfComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function MCFcu_Dia_maxReIm( h_MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax:
procedure MCFcu_Dia_maxReIm( var h_RetVal:fComplex; h_MA:cfMatrix; len:UIntSize );
|
|
Beschreibung | Die getrennt voneinander bestimmten Maxima der Real- und der Imaginärteile entlang der Diagonale von MA werden zu dem komplexen Rückgabewert (bzw. für Pascal/Delphi zu der komplexen Variablen Max) kombiniert. |
|
|
MF_Dia_min
| MD_Dia_min |
ME_Dia_min |
MI_Dia_min | MBI_Dia_min | MSI_Dia_min | MLI_Dia_min | MQI_Dia_min |
MU_Dia_min | MUB_Dia_min | MUS_Dia_min | MUL_Dia_min | MUQ_Dia_min |
|
Funktion | Minimum der Diagonal-Elemente einer Quadratmatrix |
|
Syntax C/C++ | #include <MFstd.h>
float MF_Dia_min( fMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
T matrix<T>::Dia_min(); |
Pascal/Delphi | uses MFstd;
function MF_Dia_min( MA:fMatrix; len:UIntSize ):Single; |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_min( float *h_RetVal, fMatrix d_MA, ui len );
int cusdMF_Dia_min( float *d_RetVal, fMatrix d_MA, ui len );
float MFcu_Dia_min( fMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_min( var h_RetVal:Single; d_MA:fMatrix; len:UIntSize ): IntBool;
function cusdMF_Dia_min( d_RetVal:PSingle; d_MA:fMatrix; len:UIntSize ): IntBool;
procedure MFcu_Dia_min( h_MA:fMatrix; len:UIntSize ): Single;
|
|
Beschreibung | Das kleinste oder "negativste" Element der Diagonalen wird als Skalr zurückgegeben |
|
Rückgabewert | Minimum der Diagonalen |
|
|
MCF_Dia_minReIm
| MCD_Dia_minReIm |
MCE_Dia_minReIm |
|
Funktion | Getrennte Bestimmung des Minimums von Real- und Imaginärteil der Diagonal-Elemente einer Quadratmatrix |
|
Syntax C/C++ | #include <MCFstd.h>
fComplex MCF_Dia_minReIm( cfMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
complex<T> matrix<complex<T>>::Dia_minReIm( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
function MCF_Dia_minReIm( MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax:
procedure MCF_Dia_minReIm( var Min:fComplex; MA:cfMatrix; len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Dia_minReIm( fComplex *h_RetVal, cfMatrix d_MA, ui len );
int cusdMCF_Dia_minReIm( fComplex *d_RetVal, cfMatrix d_MA, ui len );
fComplex MCFcu_Dia_minReIm( cfMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Dia_minReIm( var h_RetVal:fComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function cusdMCF_Dia_minReIm( d_RetVal:PfComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function MCFcu_Dia_minReIm( h_MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax:
procedure MCFcu_Dia_minReIm( var h_RetVal:fComplex; h_MA:cfMatrix; len:UIntSize );
|
|
Beschreibung | Die getrennt voneinander bestimmten Minima der Real- und der Imaginärteile entlang der Diagonale von MA werden zu dem komplexen Rückgabewert (bzw. für Pascal/Delphi zu der komplexen Variablen Min) kombiniert. |
|
|
MF_Dia_mulC
| MD_Dia_mulC |
ME_Dia_mulC |
MCF_Dia_mulC |
MCD_Dia_mulC |
MCE_Dia_mulC |
|
Funktion | alle Diagonal-Elemente einer Quadratmatrix mit einer Konstanten multiplizieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_mulC( fMatrix MA, ui len, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Dia_mulC( const T& C ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_mulC( MA:fMatrix; len:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_mulC( fMatrix d_MA, ui len, float C );
int cusdMF_Dia_mulC( fMatrix d_MA, ui len, float *d_C );
void MFcu_Dia_mulC( fMatrix h_MA, ui len, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_mulC( d_MA:fMatrix; len:UIntSize; C:Single ): IntBool;
function cusdMF_Dia_mulC( d_MA:fMatrix; len:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Dia_mulC( h_MA:fMatrix; len:UIntSize; C:Single );
|
|
Beschreibung | MAi,i *= C, i=0,...,len-1 |
|
|
MF_Dia_mulV
| MD_Dia_mulV |
ME_Dia_mulV |
MCF_Dia_mulV |
MCD_Dia_mulV |
MCE_Dia_mulV |
|
Funktion | Element-weise Multiplikation der Diagonalen einer Quadratmatrix mit einem Vektor |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_mulV( fMatrix MA, ui len, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Dia_mulV( const vector<T>& X ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_mulV( MA:fMatrix; len:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_mulV( fMatrix d_MA, ui len, fVector d_X );
void MFcu_Dia_mulV( fMatrix h_MA, ui len, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_mulV( d_MA:fMatrix; len:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Dia_mulV( h_MA:fMatrix; len:UIntSize; h_X:fVector );
|
|
Beschreibung | MAi,i *= Xi, i=0,...,len-1 |
|
|
MF_Dia_prod
| MD_Dia_prod |
ME_Dia_prod |
MCF_Dia_prod |
MCD_Dia_prod |
MCE_Dia_prod |
|
Funktion | Produkt aller Diagonal-Elemente einer Quadratmatrix |
|
Syntax C/C++ | #include <MFstd.h>
float MF_Dia_prod( fMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
T matrix<T>::Dia_prod(); |
Pascal/Delphi | uses MFstd, MCFstd;
function MF_Dia_prod( MA:fMatrix; len:UIntSize ):Single; |
|
function MCF_Dia_prod( MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax für die komplexen Datentypen (veraltet, aber weiterhin unterstützt):
procedure MCF_Dia_prod( var RetVal:fComplex; MA:cfMatrix; len:UIntSize );
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_prod( float *h_RetVal, fMatrix d_MA, ui len );
int cusdMF_Dia_prod( float *d_RetVal, fMatrix d_MA, ui len );
float MFcu_Dia_prod( fMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd, MCFstd;
function cudaMF_Dia_prod( var h_RetVal:Single; d_MA:fMatrix; len:UIntSize ): IntBool;
function cusdMF_Dia_prod( d_RetVal:PSingle; d_MA:fMatrix; len:UIntSize ): IntBool;
procedure MFcu_Dia_prod( h_MA:fMatrix; len:UIntSize ): Single;
function MCFcu_Dia_prod( h_MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax für die komplexen Datentypen:
procedure MCFcu_Dia_prod( var h_RetVal:fComplex; h_MA:cfMatrix; len:UIntSize );
|
|
Beschreibung | Das Produkt der Diagonal-Elemente wird als Skalar zurückgegeben |
|
Rückgabewert | Produkt der Diagonal-Elemente |
|
|
MCF_Dia_sabsmax
| MCD_Dia_sabsmax |
MCE_Dia_sabsmax |
|
Funktion | Finden des Diagonalelements mit der größten Summe |Re| + |Im| |
|
Syntax C/C++ | #include <MCFstd.h>
fComplex MCF_Dia_sabsmax( cfMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
complex<T> matrix<complex<T>>::Dia_sabsmax( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
function MCF_Dia_sabsmax( MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax:
procedure MCF_Dia_sabsmax( var Max:fComplex; MA:cfMatrix; len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Dia_sabsmax( fComplex *h_RetVal, cfMatrix d_MA, ui len );
int cusdMCF_Dia_sabsmax( fComplex *d_RetVal, cfMatrix d_MA, ui len );
fComplex MCFcu_Dia_sabsmax( cfMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Dia_sabsmax( var h_RetVal:fComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function cusdMCF_Dia_sabsmax( d_RetVal:PfComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function MCFcu_Dia_sabsmax( h_MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax:
procedure MCFcu_Dia_sabsmax( var h_RetVal:fComplex; h_MA:cfMatrix; len:UIntSize );
|
|
Beschreibung | Dasjenige Element der Diagonale von MA, das die größte Summe |Re| + |Im| aufweist, wird zurückgegeben (bzw. für Pascal/Delphi in der Variablen Max gespeichert). |
|
|
MCF_Dia_sabsmin
| MCD_Dia_sabsmin |
MCE_Dia_sabsmin |
|
Funktion | Finden des Diagonalelements mit dem kleinsten Betrag |
|
Syntax C/C++ | #include <MCFstd.h>
fComplex MCF_Dia_sabsmin( cfMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
complex<T> matrix<complex<T>>::Dia_sabsmin( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
function MCF_Dia_sabsmin( MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax:
procedure MCF_Dia_sabsmin( var Max:fComplex; MA:cfMatrix; len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Dia_sabsmin( fComplex *h_RetVal, cfMatrix d_MA, ui len );
int cusdMCF_Dia_sabsmin( fComplex *d_RetVal, cfMatrix d_MA, ui len );
fComplex MCFcu_Dia_sabsmin( cfMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Dia_sabsmin( var h_RetVal:fComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function cusdMCF_Dia_sabsmin( d_RetVal:PfComplex; d_MA:cfMatrix; len:UIntSize ): IntBool;
function MCFcu_Dia_sabsmin( h_MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax:
procedure MCFcu_Dia_sabsmin( var h_RetVal:fComplex; h_MA:cfMatrix; len:UIntSize );
|
|
Beschreibung | Dasjenige Element der Diagonale von MA, das die kleinste Summe |Re| + |Im| aufweist, wird zurückgegeben (bzw. für Pascal/Delphi in der Variablen Min gespeichert). |
|
|
MF_Dia_subC
| MD_Dia_subC |
ME_Dia_subC |
MCF_Dia_subC |
MCD_Dia_subC |
MCE_Dia_subC |
|
Funktion | eine Konstante von allen Diagonal-Elementen einer Quadratmatrix subtrahieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_subC( fMatrix MA, ui len, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Dia_subC( const T& C ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_subC( MA:fMatrix; len:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_subC( fMatrix d_MA, ui len, float C );
int cusdMF_Dia_subC( fMatrix d_MA, ui len, float *d_C );
void MFcu_Dia_subC( fMatrix h_MA, ui len, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_subC( d_MA:fMatrix; len:UIntSize; C:Single ): IntBool;
function cusdMF_Dia_subC( d_MA:fMatrix; len:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Dia_subC( h_MA:fMatrix; len:UIntSize; C:Single );
|
|
Beschreibung | MAi,i -= C, i=0,...,len-1 |
|
|
MF_Dia_subrC
| MD_Dia_subrC |
ME_Dia_subrC |
MCF_Dia_subrC |
MCD_Dia_subrC |
MCE_Dia_subrC |
|
Funktion | umgekehrte Subtraktion: eine Konstante minus den Diagonal-Elementen einer Quadratmatrix; das Ergebnis überschreibt die Diagonale |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_subrC( fMatrix MA, ui len, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Dia_subrC( const T& C ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_subrC( MA:fMatrix; len:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_subrC( fMatrix d_MA, ui len, float C );
int cusdMF_Dia_subrC( fMatrix d_MA, ui len, float *d_C );
void MFcu_Dia_subrC( fMatrix h_MA, ui len, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_subrC( d_MA:fMatrix; len:UIntSize; C:Single ): IntBool;
function cusdMF_Dia_subrC( d_MA:fMatrix; len:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Dia_subrC( h_MA:fMatrix; len:UIntSize; C:Single );
|
|
Beschreibung | MAi,i = C - MAi,i, i=0,...,len-1 |
|
|
MF_Dia_subrV
| MD_Dia_subrV |
ME_Dia_subrV |
MCF_Dia_subrV |
MCD_Dia_subrV |
MCE_Dia_subrV |
|
Funktion | umgekehrte Subtraktion: Diagonal-Elemente einer Quadratmatrix von korrespondierenden Vektor-Elementen subtrahieren und die Diagonale mit dem Ergebnis überschreiben |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_subrV( fMatrix MA, ui len, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Dia_subrV( const vector<T>& X ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_subrV( MA:fMatrix; len:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_subrV( fMatrix d_MA, ui len, fVector d_X );
void MFcu_Dia_subrV( fMatrix h_MA, ui len, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_subrV( d_MA:fMatrix; len:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Dia_subrV( h_MA:fMatrix; len:UIntSize; h_X:fVector );
|
|
Beschreibung | MAi,i = Xi - MAi,i, i=0,...,len-1 |
|
|
MF_Dia_subV
| MD_Dia_subV |
ME_Dia_subV |
MCF_Dia_subV |
MCD_Dia_subV |
MCE_Dia_subV |
|
Funktion | Element-weise Subtraktion eines Vektors von der Diagonalen einer Quadratmatrix |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Dia_subV( fMatrix MA, ui len, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Dia_subV( const vector<T>& X ); |
Pascal/Delphi | uses MFstd;
procedure MF_Dia_subV( MA:fMatrix; len:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_subV( fMatrix d_MA, ui len, fVector d_X );
void MFcu_Dia_subV( fMatrix h_MA, ui len, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Dia_subV( d_MA:fMatrix; len:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Dia_subV( h_MA:fMatrix; len:UIntSize; h_X:fVector );
|
|
Beschreibung | MAi,i -= Xi, i=0,...,len-1 |
|
|
MF_Dia_sum
| MD_Dia_sum |
ME_Dia_sum |
MCF_Dia_sum |
MCD_Dia_sum |
MCE_Dia_sum |
|
Funktion | Summe über alle Diagonal-Elemente einer Quadratmatrix |
|
Syntax C/C++ | #include <MFstd.h>
float MF_Dia_sum( fMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
T matrix<T>::Dia_sum(); |
Pascal/Delphi | uses MFstd;
function MF_Dia_sum( MA:fMatrix; len:UIntSize ):Single;
function MCF_Dia_sum( MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax für die komplexen Datentypen:
procedure MCF_Dia_sum( var RetVal:fComplex; MA:cfMatrix; len:UIntSize );
|
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Dia_sum( float *h_RetVal, fMatrix d_MA, ui len );
int cusdMF_Dia_sum( float *d_RetVal, fMatrix d_MA, ui len );
float MFcu_Dia_sum( fMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd, MCFstd;
function cudaMF_Dia_sum( var h_RetVal:Single; d_MA:fMatrix; len:UIntSize ): IntBool;
function cusdMF_Dia_sum( d_RetVal:PSingle; d_MA:fMatrix; len:UIntSize ): IntBool;
procedure MFcu_Dia_sum( h_MA:fMatrix; len:UIntSize ): Single;
function MCFcu_Dia_sum( h_MA:cfMatrix; len:UIntSize ): fComplex;
Alternative Syntax für die komplexen Datentypen:
procedure MCFcu_Dia_sum( var h_RetVal:fComplex; h_MA:cfMatrix; len:UIntSize );
|
|
Beschreibung | Die Diagonal-Elemente werden aufsummiert und als Skalar zurückgegeben |
|
Rückgabewert | Summe über die Diagonal-Elemente |
|
|
MCF_divC |
MCD_divC |
MCE_divC |
MCF_divReC |
MCD_divReC |
MCE_divReC |
|
Funktion | alle Matrix Elemente durch eine Konstante dividieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_divC( fMatrix MB, fMatrix MA, ui ht, ui len, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::divC( const T& C ); |
Pascal/Delphi | uses MFstd;
procedure MF_divC( MB, MA:fMatrix; ht, len:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_divC( fMatrix d_MB, fMatrix d_MA, ui ht, ui len, float C );
int cusdMF_divC( fMatrix d_MB, fMatrix d_MA, ui ht, ui len, float *d_C );
void MFcu_divC( fMatrix h_MB, fMatrix h_MA, ui ht, ui len, float C );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_divC( d_MB, d_MA:fMatrix; ht, len:UIntSize; C:Single ): IntBool;
function cusdMF_divC( d_MB, d_MA:fMatrix; ht, len:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_divC( h_MB, h_MA:fMatrix; ht, len:UIntSize; C:Single );
|
|
Beschreibung | Mi,j /= C, i=0,...,ht-1; j=0,..,len-1 |
|
|
|
Funktion | Datentyp-Umwandlungen. Siehe M_FtoD. |
|
MFsym_eigenvalues
| MDsym_eigenvalues |
MEsym_eigenvalues |
|
Funktion | Eigenwerte und/oder Eigenvektoren einer reellen symmetrischen Matrix |
|
Syntax C/C++ | #include <MFstd.h>
int MFsym_eigenvalues( fVector EigVals, fMatrix EigVecs, fMatrix MA, ui len, int CalcEigenVec ); |
C++ MatObj | #include <OptiVec.h>
int matrix<T>::sym_eigenvalues( matrix<T> EigVecs, const matrix<T>& MA, int CalcEigenVec );
int matrix<T>::sym_eigenvalues( matrix<T>* EigVecs, const matrix<T>& MA, int CalcEigenVec ); |
Pascal/Delphi | uses MFstd;
function MFsym_eigenvalues( EigVals:fVector; EigVecs, MA:fMatrix; len:UIntSize; CalcEigenVec:IntBool ): IntBool; |
|
Beschreibung | Die Eigenwerte von MA werden mit oder ohne zugehörige Eigenvektoren berechnet. Diese Routine funktioniert nur für nicht-singuläre symmetrische reelle Matrizen! Sie erwartet die folgenden Argumente:
- EigVals: ein Vektor, in dem die Eigenwerte zurückgegeben werden
- EigVecs: eine Matrix der Größe len*len. Falls die Eigenvektoren gewünscht sind, werden die Spalten von EigVecs durch die Routine mit den Eigenvektoren gefüllt; andernfalls wird EigVecs als Arbeitsspeicher benötigt.
- MA: Die Eingabe-Matrix, die durch EigVecs überschrieben werden darf, falls gewünscht
- len: Die Zeilenlänge (die natürlich gleichzeitig die Spalten-Höhe ist, da MA eine symmetrische Quadrat-Matrix sein muss)
- CalcEigenVec: eine int oder IntBool, die angibt, ob nur die Eigenwerte benötigt werden (CalcEigenVec = FALSE oder 0) oder ob auch die Eigenvektoren gewünscht werden (CalcEigenVec = TRUE oder 1). Die Berechnung der Eigenwerte ohne Eigenvektoren beschleunigt die Rechengeschwindigkeit auf ungefähr das Doppelte.
Die Eigenwerte (und Eigenvektoren) werden in ungeordneter Reihenfolge ausgegeben. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (!= 0). Da Singularitäten meist nicht vor Aufruf dieser Funktion erkannt werden können, wird der Test des Rückgabewertes dringend empfohlen! |
|
|
MF_element
| MD_element |
ME_element |
MCF_element |
MCD_element |
MCE_element |
MI_element | MBI_element | MSI_element | MLI_element | MQI_element |
MU_element | MUB_element | MUS_element | MUL_element | MUQ_element |
|
Funktion | Lese-Zugriff auf ein einzelnes Matrix-Element |
|
Syntax C/C++ | #include <MFstd.h>
float MF_element( fMatrix X, ui ht, ui len, unsigned m, unsigned n );
fComplex MCF_element( cfMatrix X, ui ht, ui len, unsigned m, unsigned n ); |
C++ MatObj | #include <OptiVec.h>
T matrix<T>::element( const unsigned m, const unsigned n ); |
Pascal/Delphi | uses MFstd;
function MF_element( MA:fMatrix; ht, len, m, n:UIntSize ): Single;
function MCF_element( MA:cfMatrix; ht, len, m, n:UIntSize ): fComplex;
Alternative Syntax für die komplexen Datentypen (veraltet, aber weiterhin unterstützt):
procedure MCF_element( var RetVal:fComplex; MA:cfMatrix; ht, len, m, n:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
float cudaMF_element( fMatrix d_MA, ui ht, ui len, unsigned m, unsigned n );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_element( d_MA:fMatrix; ht, len, m, n:UIntSize ): Single;
function cudaMCF_element( d_MA:cfMatrix; ht, len, m, n:UIntSize ): fComplex;
Alternative Syntax für die komplexen Datentypen (veraltet, aber weiterhin unterstützt):
procedure cudaMCF_element( var RetVal:fComplex; MA:cfMatrix; ht, len, m, n:UIntSize );
|
|
Beschreibung | Das Element MAm,n wird zurückgegeben.
Nur Pascal/Delphi: Da Rückgabewerte der komplexen Datentypen hier nicht möglich sind, speichern die komplexen Versionen MAm,n in der Variablen RetVal.
Diese Funktion wird benötigt, um Elemente dynamisch allozierter Matrizen auszulesen. Pascal/Delphi bietet hierfür – anders als C – gar keinen eigenen Mechanismus, und ältere Versionen von Borland C++ hatten einen Fehler in der Zeiger-Arithmetik, der durch Verwendung von MF_element umgangen wird.
MF_element gestattet ausschließlich Lese-Zugriff. Es ist also nicht möglich, etwas in der Art
MF_element( MX, ht, len, 3, 4 ) := 5;
zu schreiben. Schreib-Zugriff auf einzelne Matrix-Elemente wird durch MF_Pelement geboten. |
|
Rückgabewert | Das Matrix-Element m,n (außer komplexe Version Pascal/Delphi) |
|
|
MCF_equ0 |
MCD_equ0 |
MCE_equ0 |
MCF_Reequ0 |
MCD_Reequ0 |
MCE_Reequ0 |
MCF_Imequ0 |
MCD_Imequ0 |
MCE_Imequ0 |
MI_equ0 | MBI_equ0 | MSI_equ0 | MLI_equ0 | MQI_equ0 |
MU_equ0 | MUB_equ0 | MUS_equ0 | MUL_equ0 | MUQ_equ0 |
|
Funktion | alle Matrixelemente gleich 0 setzen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_equ0( fMatrix MA, ui ht, ui len );
void MCF_Reequ0( cfMatrix MA, ui ht, ui len );
void MCF_Imequ0( cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::equ0( ); |
Pascal/Delphi | uses MFstd;
procedure MF_equ0( MA:fMatrix; ht, len:UIntSize );
procedure MCF_Reequ0( MA:cfMatrix; ht, len:UIntSize );
procedure MCF_Imequ0( MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_equ0( fMatrix d_MA, ui ht, ui len );
int cudaMCF_Reequ0( cfMatrix d_MA, ui ht, ui len );
int cudaMCF_Imequ0( cfMatrix d_MA, ui ht, ui len );
void MFcu_equ0( fMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_equ0( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMCF_Reequ0( d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
function cudaMCF_Imequ0( d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_equ0( h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | M?_equ0: MAi,j = 0, i=0,...,ht-1, j=0,...,len-1
MC?_Reequ0: MAi,j.Re = 0, i=0,...,ht-1, j=0,...,len-1 (MAi,j.Im bleibt unverändert)
MC?_Imequ0: MAi,j.Im = 0, i=0,...,ht-1, j=0,...,len-1 (MAi,i.Re bleibt unverändert) |
|
|
MCF_equ1 |
MCD_equ1 |
MCE_equ1 |
MI_equ1 | MBI_equ1 | MSI_equ1 | MLI_equ1 | MQI_equ1 |
MU_equ1 | MUB_equ1 | MUS_equ1 | MUL_equ1 | MUQ_equ1 |
|
|
Syntax C/C++ | #include <MFstd.h>
void MF_equ1( fMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::equ1( ); |
Pascal/Delphi | uses MFstd;
procedure MF_equ1( MA:fMatrix; len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_equ1( fMatrix d_MA, ui ht, ui len );
void MFcu_equ1( fMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_equ1( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_equ1( h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | MAi,i = 1
MAi,j = 0, i != j |
|
|
MCF_equM |
MCD_equM |
MCE_equM |
MI_equM | MBI_equM | MSI_equM | MLI_equM | MQI_equM |
MU_equM | MUB_equM | MUS_equM | MUL_equM | MUQ_equM |
|
|
Syntax C/C++ | #include <MFstd.h>
void MF_equM( fMatrix MB, fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::equM( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_equM( MB, MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_equM( fMatrix d_MB, fMatrix d_MA, ui ht, ui len );
void MFcu_equM( fMatrix h_MB, fMatrix h_MA, ui ht, ui len );
int cudaMF_equMhost( fMatrix d_MB, fMatrix h_NA, ui ht, ui len );
int MF_equMdevice( fMatrix h_MB, fMatrix d_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_equM( d_MB, d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MF_equM( h_MB, h_MA:fMatrix; ht, len:UIntSize );
function cudaMF_equMhost( d_MB, h_MA:fMatrix; ht, len:UIntSize ): IntBool;
function MF_equMdevice( h_MB, d_MA:fMatrix; ht, len:UIntSize ): IntBool;
|
|
Beschreibung | MBi,j = MAi,j
CUDA-Versionen: cudaMF_equMhost und MF_equMdevice kopieren Matrizen von Host- zu Device-Memory und umgekehrt. |
|
|
MF_equm1
| MD_equm1 |
ME_equm1 |
MCF_equm1 |
MCD_equm1 |
MCE_equm1 |
MI_equm1 | MBI_equm1 | MSI_equm1 | MLI_equm1 | MQI_equm1 |
|
Funktion | negative Einheits-Matrix |
|
Syntax C/C++ | #include <MFstd.h>
void MF_equm1( fMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::equm1( ); |
Pascal/Delphi | uses MFstd;
procedure MF_equm1( MA:fMatrix; len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_equm1( fMatrix d_MA, ui ht, ui len );
void MFcu_equm1( fMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_equm1( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_equm1( h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | MAi,i = -1
MAi,j = 0, i != j |
|
|
MF_equMblock
| MD_equMblock |
ME_equMblock |
MCF_equMblock |
MCD_equMblock |
MCE_equMblock |
MI_equMblock | MBI_equMblock | MSI_equMblock | MLI_equMblock | MQI_equMblock |
MU_equMblock | MUB_equMblock | MUS_equMblock | MUL_equMblock | MUQ_equMblock |
|
Funktion | Block extrahieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_equMblock( fMatrix Sub,
ui subHt, ui subLen,
fMatrix Srce, ui srceHt, ui srceLen,
unsigned firstRow, unsigned firstCol ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::equMblock( const matrix<T>& MSrce, const ui firstRow, const ui firstCol ); |
Pascal/Delphi | uses MFstd;
procedure MF_equMblock( MSub:fMatrix;
subHt, subLen: UIntSize;
MSrce:fMatrix;
srceHt, srceLen, firstRow, firstCol:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_equMblock( fMatrix d_MSub,
ui subHt, ui subLen,
fMatrix d_MSrce, ui srceHt, ui srceLen,
ui firstRow, ui firstCol );
void MFcu_equMblock( fMatrix h_MSub,
ui subHt, ui subLen,
fMatrix h_MSrce, ui srceHt, ui srceLen,
ui firstRow, ui firstCol );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_equMblock( d_MSub:fMatrix;
subHt, subLen: UIntSize;
d_MSrce:fMatrix;
srceHt, srceLen, firstRow, firstCol:UIntSize ): IntBool;
procedure MFcu_equMblock( h_MSub:fMatrix;
subHt, subLen: UIntSize;
h_MSrce:fMatrix;
srceHt, srceLen, firstRow, firstCol:UIntSize );
|
|
Beschreibung | MSubi, j = MSrcei+firstRow, j+firstCol, i=0,...,subHt-1; j=0,...,subLen-1 |
|
|
MF_equMblockT
| MD_equMblockT |
ME_equMblockT |
MCF_equMblockT |
MCD_equMblockT |
MCE_equMblockT |
MI_equMblockT | MBI_equMblockT | MSI_equMblockT | MLI_equMblockT | MQI_equMblockT |
MU_equMblockT | MUB_equMblockT | MUS_equMblockT | MUL_equMblockT | MUQ_equMblockT |
|
Funktion | Block extrahieren und transponieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_equMblockT( fMatrix Sub,
ui subHt, ui subLen,
fMatrix Srce, ui srceHt, ui srceLen,
unsigned firstRow, unsigned firstCol ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::equMblockT( const matrix<T>& MSrce, const ui firstRow, const ui firstCol ); |
Pascal/Delphi | uses MFstd;
procedure MF_equMblockT( MSub:fMatrix;
subHt, subLen: UIntSize;
MSrce:fMatrix;
srceHt, srceLen, firstRow, firstCol:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_equMblockT( fMatrix d_MSub,
ui subHt, ui subLen,
fMatrix d_MSrce, ui srceHt, ui srceLen,
ui firstRow, ui firstCol );
void MFcu_equMblockT( fMatrix h_MSub,
ui subHt, ui subLen,
fMatrix h_MSrce, ui srceHt, ui srceLen,
ui firstRow, ui firstCol );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_equMblockT( d_MSub:fMatrix;
subHt, subLen: UIntSize;
d_MSrce:fMatrix;
srceHt, srceLen, firstRow, firstCol:UIntSize ): IntBool;
procedure MFcu_equMblockT( h_MSub:fMatrix;
subHt, subLen: UIntSize;
h_MSrce:fMatrix;
srceHt, srceLen, firstRow, firstCol:UIntSize );
|
|
Beschreibung | MSubj, i = MSrcei+firstRow, j+firstCol, i=0,...,subLen-1; j=0,...,subHt-1 |
|
|
MF_FFT |
MD_FFT |
ME_FFT |
MFb_FFT |
MDb_FFT |
MEb_FFT |
MF_FFTtoC
| MD_FFTtoC |
ME_FFTtoC |
MFb_FFTtoC
| MDb_FFTtoC |
MEb_FFTtoC |
MCF_FFT |
MCD_FFT |
MCE_FFT |
MCFb_FFT |
MCDb_FFT |
MCEb_FFT |
|
Funktion | Zwei-dimensionale Schnelle Fourier-Transformation (Fast Fourier Transformation, FFT) |
|
Syntax C/C++ | #include <MFstd.h>
void MF_FFT( fMatrix Y, fMatrix X, ui ht, ui len, int dir );
void MCF_FFT( cfMatrix Y, cfMatrix X, ui ht, ui len, int dir );
void MF_FFTtoC( cfMatrix Y, fMatrix X, ui ht, ui len );
void MFb_FFT( fMatrix Y, fMatrix X, ui ht, ui len, int dir, fVector Buf );
void MCFb_FFT( cfMatrix Y, cfMatrix X, ui ht, ui len, int dir, cfVector Buf );
void MFb_FFTtoC( cfMatrix Y, fMatrix X, ui ht, ui len, cfVector Buf ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::FFT( const matrix<T>& MX, int dir );
void matrix<complex<T> >::FFT( const matrix<complex<T> >& MX, int dir );
void matrix<complex<T> >::FFTtoC( const matrix<T>& MX );
void matrix<T>::b_FFT( const matrix<T>& MX, int dir, vector<T>& Buf );
void matrix<complex<T> >::b_FFT( const matrix<complex<T> > MX, int dir, vector<complex<T> >&Buf );
void matrix<complex<T> >::b_FFTtoC( const matrix<T> MX, vector<complex<T>>& Buf ); |
Pascal/Delphi | uses MFstd;
procedure MF_FFT( MY, MX:fMatrix; ht, len:UIntSize; dir:Integer );
procedure MCF_FFT( MY, MX:cfMatrix; ht, len:UIntSize; dir:Integer );
procedure MF_FFTtoC( MY:cfMatrix; MX:fMatrix; ht, len:UIntSize );
procedure MFb_FFT( MY, MX:fMatrix; ht, len:UIntSize; dir:Integer; Buf:fVector );
procedure MCFb_FFT( MY, MX:cfMatrix; ht, len:UIntSize; dir:Integer; Buf:cfVector );
procedure MFb_FFTtoC( MY:cfMatrix; MX:fMatrix; ht, len:UIntSize; Buf:cfVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_FFT( fMatrix d_MY, fMatrix d_MX, ui ht, ui len, int dir );
int cudaMCF_FFT( cfMatrix d_MY, cfMatrix d_MX, ui ht, ui len, int dir );
int cudaMF_FFTtoC( cfMatrix d_MY, fMatrix d_MX, ui ht, ui len );
void MFcu_FFT( fMatrix h_MY, fMatrix h_MX, ui ht, ui len, int dir );
void MCFcu_FFT( cfMatrix h_MY, cfMatrix h_MX, ui ht, ui len, int dir );
void MFcu_FFTtoC( cfMatrix h_MY, fMatrix h_MX, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_FFT( d_MY, d_MX:fMatrix; ht, len:UIntSize; dir:Integer );
function cudaMCF_FFT( d_MY, d_MX:cfMatrix; ht, len:UIntSize; dir:Integer );
function cudaMF_FFTtoC( d_MY:cfMatrix; d_MX:fMatrix; ht, len:UIntSize );
procedure MFcu_FFT( h_MY, h_MX:fMatrix; ht, len:UIntSize; dir:Integer );
procedure MCFcu_FFT( h_MY, h_MX:cfMatrix; ht, len:UIntSize; dir:Integer );
procedure MFcu_FFTtoC( h_MY:cfMatrix; h_MX:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Die Fourier-Transformierte von MX wird in MY zurückgegeben. Die Vorwärts-Transformation erhält man für dir = 1, die inverse (oder Rückwärts-) Transformation für dir = -1. Gemäß Konvention enthält die Rückwärts-Transformation eine Skalierung des Ergebnisses mit dem Faktor 1.0/(ht*len) (wodurch das Ergebnis von einmal Vorwärts- und einmal Rückwärts-Transformation wieder - von Rundungsfehlern abgesehen - die Ausgangs-Matrix ergibt). Für Situationen, in denen man diese implizite Skalierung umgehen möchte, spezifiziere man dir = -2.
Der verwendete FFT-Algorithmus erfordert es, dass sowohl ht als auch len ganzzahlige Potenzen von 2 sind.
Komplexe Version: Sowohl die Eingabe-Matrix X also auch die Ausgabe-Matrix Y sind komplex.
Reell-zu-Komplex-Version: Die Eingabe-Matrix X ist reell. Die Ausgabe-Matrix Y ist komplex. Da diese Funktion nur in Vorwärts-Richtung ausgeführt werden kann, ist kein Argument "dir" erforderlich.
Rein reelle Version: Für die Vorwärts-Transformation ist MX eine reelle Matrix. Die Ausgabe-Matrix Y ist ebenfalls als reelle Matrix definiert, obwohl sie aus komplexen Zahlen besteht. Diese sind auf spezielle Weise so gepackt, dass sie in den für eine gleich große reelle Matrix zur Verfügung stehenden Speicherplatz passen. Die Reihenfolge der Elemente in MY ist von derjenigen im ein-dimensionalen Fall abgeleitet, wobei die Komprimierung zuerst auf alle Zeilen und danach auf die Spalten angewandt wird. Die folgende Tabelle faßt die sich so ergebende Anordnung zusammen. U ist die unkomprimierte Fourier-Transformierte von MX.
U0,0.Re | U0,len/2.Re | U0,1.Re | U0,1.Im | ··· | U0,len/2-1.Re | U0,len/2-1.Im |
Uht/2,0.Re | Uht/2,len/2.Re | U1,1.Re | U1,1.Im | ··· | U1,len/2-1.Re | U1,len/2-1.Im |
U1,0.Re | U1,len/2.Re | U2,1.Re | U2,1.Im | ··· | U2,len/2-1.Re | U2,len/2-1.Im |
U1,0.Im | U1,len/2.Im | U3,1.Re | U3,1.Im | ··· | U3,len/2-1.Re | U3,len/2-1.Im |
··· | ··· | ··· | ··· | ··· | ··· | ··· |
Uht/2-1,0.Re | Uht/2-1,len/2.Re | ··· | ··· | ··· | ··· | ··· |
Uht/2-1,0.Im | Uht/2-1,len/2.Im | Uht-1,1.Re | Uht-1,1.Im | ··· | Uht-1,len/2-1.Re | Uht-1,len/2-1.Im |
Für die inverse FFT reeller Matrizen muss die Eingabe-Matrix in diesem gepackt-komplexen Format vorliegen. und als Ergebnis erhält man eine "echte" reelle Matrix. Falls Sie es vorziehen, das Ergebnis der Vorwärts-Transformation einer rellen Matrix ungepackt, also als komplexe Matrix zu erhalten, benutzen Sie bitte MF_FFTtoC.
MFb_FFT, MFb_FFTtoC und MCFb_FFT verwenden den als Argument Buf übergebenen Puffer-Speicher, anstatt ihn selbst zu reservieren. Dadurch sind sie etwas effizienter als die ungepufferten Versionen. Buf muss (mindestens) so groß sein wie X und Y.Außerdem muss Buf 128-bit (P8) bzw. 256-bit( P9) ausgerichtet sein. Um dies zu garantieren, sollte man nur Vektoren als Buf verwenden, die mit der VF_vector-Familie alloziert wurden. |
|
Fehlerbehandlung | Falls entweder len oder ht nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf MF_FFT basiert) mit der Fehlermeldung "Size must be an integer power of 2" und bricht das Programm ab. |
|
|
MF_fhexprint
| MD_fhexprint |
ME_fhexprint |
MCF_fhexprint |
MCD_fhexprint |
MCE_fhexprint |
MI_fhexprint | MBI_fhexprint | MSI_fhexprint | MLI_fhexprint | MQI_fhexprint |
MU_fhexprint | MUB_fhexprint | MUS_fhexprint | MUL_fhexprint | MUQ_fhexprint |
|
Funktion | Matrix im Hexadezimal-Format in einen Stream schreiben |
|
Syntax C/C++ | #include <MFstd.h>
void MF_fhexprint( FILE *stream, fMatrix MA, ui ht, ui len, unsigned linewidth ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::fhexprint( FILE *stream, unsigned linewidth ); |
Pascal/Delphi | uses MFstd;
{Delphi-Version:}
procedure MF_fhexprint( var Stream:TextFile; MA:fMatrix; ht, len:UIntSize; linewidth:UInt );
{Turbo Pascal-Version:}
procedure MF_fhexprint( var Stream:Text; MA:fMatrix; ht, len:UIntSize; linewidth:UInt ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_fhexprint( FILE *stream, fMatrix d_MA, ui ht, ui len );
int cudaMF_fhexprint_buf( FILE *stream, fMatrix d_MA, ui ht, ui len, fVector h_Wk );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_fhexprint( var Stream:TextFile; d_MA:fMatrix; ht, len:UIntSize ): IntBool; function cudaMF_fhexprint_buf( var Stream:TextFile; d_MA:fMatrix; ht, len:UIntSize; h_Wk:fVector ): IntBool;
|
|
Beschreibung | Die Matrix A wird im Hexadezimal-Format in stream geschrieben. Jede Zeile entspricht einer Zeile der Matrix. Die Zeilen werden von 0 an durchnumeriert. Falls die spezifizierte Zeilenbreite linewidth zu klein für die Ausgabe aller Spalten ist, werden die Zeilen abgeschnitten.
Die Ausgabe beginnt stets mit einer neuen Zeile. Dies kann zu einer Leerzeile zu Beginn führen. Insbesondere die erste Zeile einer Datei ist für eine mögliche Überschrift reserviert.
Cartesisch-komplexe Zahlen werden in geschweiften Klammern geschrieben mit einem Komma zwischen den Real- und dem Imaginär-Teil: {Re, Im}.
Im Unterschied zu MF_write kann das automatisch eingestellte Ausgabe-Format nicht geändert werden. Die Anzahl ausgegebener Stellen pro Element richtet sich nach dem zur Verfügung stehenden Platz, der seinerseits von den Parametern len und linewidth abhängt.
nur CUDA-Versionen: cudaM?_fhexprint_buf übernimmt einen Host-Vektor h_Wk als zusätzliches Argument. Dieser dient als Pufferspeicher und muss (mindestens) dieselbe Größe haben wie X. Hierdurch wird die interne Bereitstellung von Pufferspeicher bei cudaM?_fhexprint eingespart, so dass cudaM?_fhexprint_buf etwas schneller ist.
|
|
Fehlerbehandlung | Falls len die maximal mögliche Zahl von Einträgen bei der gewählten Zeilenbreite übersteigt, wird eine Fehlermeldung "Cannot use requested Format (too many entries per line)!" ausgegeben; in diesem Fall schneidet das Programm alle Zeilen nach der maximal möglichen Spaltenzahl ab. |
|
|
MF_filter
| MD_filter |
ME_filter |
MCF_filter |
MCD_filter |
MCE_filter |
MFb_filter
| MDb_filter |
MEb_filter |
MCFb_filter |
MCDb_filter |
MCEb_filter |
|
Funktion | Raumfrequenz-Filterung |
|
Syntax C/C++ | #include <MFstd.h>
void MF_filter( fMatrix Y, fMatrix X, fMatrix Flt, ui ht, ui len );
void MFb_filter( fMatrix Y, fMatrix X, fMatrix Flt, ui ht, ui len, fVector Buf ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::filter( const matrix<T>& MX, const matrix<T>& MFlt );
void matrix<T>::b_filter( const matrix<T>& MX, const matrix<T>& MFlt, vector<T>& Buf ); |
Pascal/Delphi | uses MFstd;
procedure MF_filter( MY, MX, MFlt:fMatrix; ht, len:UIntSize );
procedure MFb_filter( MY, MX, MFlt:fMatrix; ht, len:UIntSize; Buf:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_filter( fMatrix d_MY, fMatrix d_MX, fMatrix d_MFlt, ui ht, ui len );
void MFcu_filter( fMatrix h_MY, fMatrix h_MX, fMatrix h_MFlt, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_filter( d_MY, d_MX, d_MFlt:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_filter( h_MY, h_MX, h_MFlt:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Der Raumfrequenz-Filer MFlt wird auf die Matrix X angewandt. Intern geschieht dies durch Multiplikation der Fourier-Transformierten von MX mit MFlt und Rücktransformation des Produktes.
Komplexe Versionen: MX, MY und der Filter MFlt sind komplexe Matrizen.
Reelle Versionen: MX und MY sind reell. MFlt muss in dem gepackt-komplexen Format vorliegen, das man durch Fourier-Transformation einer reellen Matrix mit MF_FFT oder durch Aufruf von MF_convolve erhält. Siehe MF_FFT bezüglich des gepackt-komplexen Formates.
Falls MX nicht-periodisch ist, kann das Filter-Ergebnis durch Randeffekte beeinträchtigt sein. Siehe VF_convolve bezüglich der Vermeidung von Randeffekten. Wie dort für Vektoren beschrieben, sollte auch die Matrix X eventuell in eine größere Matrix eingebettet oder mögliche lineare Trends in beiden Dimensionen beseitigt werden.
Intern benötigt MF_filter zusätzlichen Pufferspeicher, der automatisch reserviert und wieder freigegeben wird. Bei wiederholten Aufrufen wäre dies ineffizient. Es wird empfohlen, für solche Fälle stattdessen MFb_filter zu verwenden. Für die Größe von Buf gilt dabei:
C/C++, reell: | sizeof(Buf) >= ht*(len+4) |
C/C++, komplex: | sizeof(Buf) >= ht*len |
Pascal/Delphi, reell oder komplex: | sizeof(Buf) >= ht*len |
Außerdem muss Buf 128-bit (P8) bzw. 256-bit( P9) ausgerichtet sein. Um dies zu garantieren, sollte man nur Vektoren als Buf verwenden, die mit der VF_vector-Familie alloziert wurden.
|
|
Fehlerbehandlung | Falls entweder len oder ht nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf MF_filter basiert) mit der Fehlermeldung "Size must be an integer power of 2" und bricht das Programm ab. |
|
|
|
Funktion | Farbtonskala berechnen und X-Y-Koordinatensystem für Farbton-Plots zeichnen |
|
Syntax C/C++ | #include <Mgraph.h>
void M_findDensityMapBounds( extended xmin, extended xmax, extended ymin, extended ymax, extended zmin, extended zmax, COLORREF mincolor, COLORREF maxcolor ); |
Pascal/Delphi | uses Mgraph;
procedure M_findDensityMapBounds( xmin, xmax, ymin, ymax, zmin, zmax: Extended; mincolor, maxcolor: COLORREF ); |
|
Beschreibung | Ähnlich der Funktion V_findAxes für X-Y-Vektor-Plots berechnet diese Funktion eine Farbskala aus den Parametern mincolor, maxcolor, zmin und zmax und bereitet ein X-Y-Koordinatensystem für Farbton-Plots von Matrizen vor. Sofern nötig, werden die x und y-Bereiche geringfügig vergrößert, um sicherzustellen, dass alle Rasterlinien exakten (und nicht nur gerundeten) Werten entsprechen. Falls Null in dem einen oder anderen Bereich enthalten ist, fällt es auf eine Rasterlinie.
Als Anwender wird man diese Funktion nur selten selbst aufrufen. Sie wird intern von allen Funktionen der MF_xyzAutoDensityMap- und MF_zAutoDensityMap- Familien verwandt. |
|
|
MF_fprint
| MD_fprint |
ME_fprint |
MCF_fprint |
MCD_fprint |
MCE_fprint |
MI_fprint | MBI_fprint | MSI_fprint | MLI_fprint | MQI_fprint |
MU_fprint | MUB_fprint | MUS_fprint | MUL_fprint | MUQ_fprint |
|
Funktion | Matrix im ASCII-Format in einen Stream schreiben |
|
Syntax C/C++ | #include <MFstd.h>
void MF_fprint( FILE *stream, fMatrix MA, ui ht, ui len, unsigned linewidth ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::fprint( FILE *stream, unsigned linewidth ); |
Pascal/Delphi | uses MFstd;
{Delphi-Version:}
procedure MF_fprint( var Stream:TextFile; MA:fMatrix; ht, len:UIntSize; linewidth:UInt );
{Turbo Pascal-Version:}
procedure MF_fprint( var Stream:Text; MA:fMatrix; ht, len:UIntSize; linewidth:UInt ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_fprint( FILE *stream, fMatrix d_MA, ui ht, ui len );
int cudaMF_fprint_buf( FILE *stream, fMatrix d_MA, ui ht, ui len, fVector h_Wk );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_fprint( var Stream:TextFile; d_MA:fMatrix; ht, len:UIntSize ): IntBool; function cudaMF_fprint_buf( var Stream:TextFile; d_MA:fMatrix; ht, len:UIntSize; h_Wk:fVector ): IntBool;
|
|
Beschreibung | Die Matrix A wird in stream geschrieben. Jede Zeile entspricht einer Zeile der Matrix. Die Zeilen werden von 0 an durchnumeriert. Falls die spezifizierte Zeilenbreite linewidth zu klein für die Ausgabe aller Spalten ist, werden die Zeilen abgeschnitten.
Die Ausgabe beginnt stets mit einer neuen Zeile. Dies kann zu einer Leerzeile zu Beginn führen. Insbesondere die erste Zeile einer Datei ist für eine mögliche Überschrift reserviert.
Cartesisch-komplexe Zahlen werden in geschweiften Klammern geschrieben mit einem Komma zwischen den Real- und dem Imaginär-Teil: {Re, Im}.
Im Unterschied zu MF_write kann das automatisch eingestellte Ausgabe-Format nicht geändert werden. Die Anzahl ausgegebener Stellen pro Element richtet sich nach dem zur Verfügung stehenden Platz, der seinerseits von den Parametern len und linewidth abhängt.
nur CUDA-Versionen: cudaM?_fprint_buf übernimmt einen Host-Vektor h_Wk als zusätzliches Argument. Dieser dient als Pufferspeicher und muss (mindestens) dieselbe Größe haben wie X. Hierdurch wird die interne Bereitstellung von Pufferspeicher bei cudaM?_fprint eingespart, so dass cudaM?_fprint_buf etwas schneller ist.
|
|
Fehlerbehandlung | Falls len die maximal mögliche Zahl von Einträgen bei der gewählten Zeilenbreite übersteigt, wird eine Fehlermeldung "Cannot use requested Format (too many entries per line)!" ausgegeben; in diesem Fall schneidet das Programm alle Zeilen nach der maximal möglichen Spaltenzahl ab. |
|
|
|
Funktion | Speicherplatz einer Matrix freigeben |
|
Syntax C/C++ | #include <MFstd.h>
void M_free( void **M ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::free(); |
Pascal/Delphi | uses MFstd;
procedure M_free( M:Pointer ); |
|
CUDA-Funktion C/C++ | #include <cudaMatLib.h>
int cudaM_free( void **d_M );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaM_free( d_M:Pointer ): IntBool;
|
|
Beschreibung | Die Matrix wird gelöscht und ihr Speicherplatz freigegeben (de-alloziert). M_free sollte ausschließlich für Matrizen verwandt werden, die zuvor mit einer der Funktionen aus der MF_matrix- oder MF_matrix0-Familie alloziert wurden. Um mehrere Matrizen auf einmal freizugeben rufe man M_nfree (nur C/C++). Um alle Vektoren und Matrizen gleichzeitig freizugeben, benutze man V_freeAll.
|
|
Fehlerbehandlung | Der Versuch, eine Matrix freizugeben, die nicht oder nicht mehr existiert, führt zu einer Warnmeldung "Cannot free non-existent vector". Die Programmausführung wird dann fortgesetzt, ohne dass irgendetwas freigegeben wird. |
|
|
M_FtoD | M_FtoE | M_CFtoCD | M_CFtoCE |
M_DtoF | M_DtoE | M_CDtoCF | M_CDtoCE |
M_EtoF | M_EtoD | M_CEtoCF | M_CEtoCD |
|
Funktion | Datentyp-Umwandlungen |
|
Syntax C/C++ | #include <MDstd.h>
(stets die <M..std.h>-Datei des Ziel-Datentyps einschließen!)
void M_FtoD( dMatrix Y, fMatrix X, ui ht, ui len );
(analog alle übrigen Funktionen dieser Familie) |
C++ MatObj | #include <OptiVec.h>
void matrix<double>::FtoD( const matrix<float>& MX ); |
Pascal/Delphi | uses MDstd;
(stets die zum Ziel-Datentyp gehörende unit einschließen!)
procedure M_FtoD( MY:dMatrix; MX:fMatrix; ht, len:UIntSize );
(analog alle übrigen Funktionen dieser Familie) |
|
CUDA-Funktion C/C++ | #include <cudaMDstd.h>
int cudaM_FtoD( dMatrix d_MY, fMatrix d_MX, ui ht, ui len );
void Mcu_FtoD( dMatrix h_MY, fMatrix h_MX, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MDstd;
function cudaM_FtoD( d_MY:dMatrix; d_MX:fMatrix; ht, len:UIntSize ): IntBool;
procedure Mcu_FtoD( h_MY:dMatrix; h_MX:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Jedes Element von MX wird aus dem für MX spezifizierten Datentyp in denjenigen für MY umgewandelt und in MY gespeichert. |
|
Fehlerbehandlung | OVERFLOW-Fehler können bei den "Abwärts-Umwandlungen" (z.B. M_EtoF) auftreten. Standardmäßig wird in einem solchen Fall der größte im Ziel-Datentyp mögliche Wert mit dem korrekten Vorzeichen versehen und in MY gespeichert. |
|
|
MF_getElement
| MD_getElement |
ME_getElement |
MCF_getElement |
MCD_getElement |
MCE_getElement |
MI_getElement | MBI_getElement | MSI_getElement | MLI_getElement | MQI_getElement |
MU_getElement | MUB_getElement | MUS_getElement | MUL_getElement | MUQ_getElement |
|
Funktion | Lese-Zugriff auf ein Matrix-Element |
|
Syntax C/C++ | #include <MFstd.h>
void MF_getElement( float *RetVal, fMatrix MA, ui ht, ui len, unsigned m, unsigned n );
void MCF_getElement( fComplex *RetVal, cfMatrix MA, ui ht, ui len, unsigned m, unsigned n ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::getElement( T*RetVal, const unsigned m, const unsigned n ); |
Pascal/Delphi | uses MFstd;
procedure MF_getElement( var RetVal:Single; MA:fMatrix; ht, len, m, n:UIntSize );
procedure MCF_getElement( var RetVal:fComplex; MA:cfMatrix; ht, len, m, n:UIntSize );
|
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
void cudaMF_getElement( float *h_RetVal, fMatrix d_MA, ui ht, ui len, unsigned m, unsigned n );
void cusdMF_getElement( float *d_RetVal, fMatrix d_MA, ui ht, ui len, unsigned m, unsigned n );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
procedure cudaMF_getElement( var h_RetVal:Single; d_MA:fMatrix; ht, len, m, n:UIntSize );
procedure cusdMF_getElement( d_RetVal:PSingle; d_MA:fMatrix; ht, len, m, n:UIntSize );
|
|
Beschreibung | Das Element MAm,n wird in die durch RetVal spezifizierte Speicherstelle kopiert.
|
|
|
|
VF_getLinfitNeglect
| VD_getLinfitNeglect |
VE_getLinfitNeglect |
|
Funktion | aktuelle Signifikanz-Schwelle für Datenanpassungen mit linearen Modellfunktionen lesen |
|
Syntax C/C++ | #include <MFstd.h>
float VF_getLinfitNeglect( void ); |
C++ MatObj | #include <OptiVec.h>
T vector<T>::getLinfitNeglect();
T matrix<T>::getLinfitNeglect(); |
Pascal/Delphi | uses MFstd;
function VF_getLinfitNeglect:Single; |
|
Beschreibung | Intern verwenden die linearen Anpassungs-Routinen wie VF_linfit einen auf Singulärwert-Zerlegung (SVD) basierenden Algorithmus, um eine Lösung auch für (nahezu) singuläre Gleichungssysteme zu erhalten. Dabei werden Koeffizienten ai, deren Signifikanz unter einer Schwelle Thresh liegt, gleich 0 anstatt Unendlich gesetzt. Diese Schwelle kann durch Aufruf von VF_setLinfitNeglect modifiziert werden. VF_getLinfitNeglect liest die derzeit eingestellte Schwelle.
In der MatObj-Syntax benutzt diese Funktion die Matrix, als deren Member-Funktion sie aufgerufen wird, lediglich zur Bestimmung des gewünschten Datentypes, hat mit ihr aber ansonsten nichts zu tun. |
|
Rückgabewert | derzeit eingestellte Signifikanz-Schwelle für Datenanpassung an lineare Modelle |
|
|
VF_getNonlinfitOptions
| VD_getNonlinfitOptions |
VE_getNonlinfitOptions |
VF_getNonlinfitDefaultOptions
| VD_getNonlinfitDefaultOptions |
VE_getNonlinfitDefaultOptions |
|
Funktion | derzeit eingestellte Optionen oder Werkseinstellung für Datenanpassung an nicht-lineare Modelle lesen |
|
Syntax C/C++ | #include <MFstd.h>
void VF_getNonlinfitOptions( VF_NONLINFITOPTIONS *Options );
void VF_getNonlinfitDefaultOptions( VF_NONLINFITOPTIONS *Options ); |
Pascal/Delphi | uses MFstd;
procedure VF_getNonlinfitOptions( var Options: VF_NONLINFITOPTIONS );
procedure VF_getNonlinfitDefaultOptions( var Options: VF_NONLINFITOPTIONS ); |
|
Beschreibung | Die nicht-linearen Datenapassungs-Routinen wie VF_nonlinfit bieten eine große Zahl verschiedener Optionen, die in einer Struktur VF_NONLINFITOPTIONS (VD_NONLINFITOPTIONS und VE_NONLINFITOPTIONS für die Datentypen höherrer Genauigkeit) zusammengefaßt sind. Diese Optionen können durch die Funktion V_setNonlinfitOptions gesetzt werden. Um die derzeit eingestellten Optionen zu lesen, rufe man V_getNonlinfitOptions. Die "Werkseinstellung" ist durch V_getNonlinfitDefaultOptions erhältlich. |
|
|
|
Funktion | zwei-dimensionales Hann-Fenster für Raumfrequenz-Analyse |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Hann( fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Hann(); |
Pascal/Delphi | uses MFstd;
procedure MF_Hann( MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Hann( fMatrix d_MA, ui ht, ui len );
void MFcu_Hann( fMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Hann( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Hann( h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | MAi,j = 0.25 * (1 - cos( 2 p i / (ht-1) )) * (1 - cos( 2 p j / (len-1) )) |
|
|
MCF_hermconj
| MCD_hermconj |
MCE_hermconj |
|
Funktion | Hermitesch-konjugierte Form |
|
Syntax C/C++ | #include <MCFstd.h>
void MCF_hermconj( cfMatrix Tr, cfMatrix MA, ui htTr, ui lenTr ); |
C++ MatObj | #include <OptiVec.h>
void matrix<complex<T> >::hermconj( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
procedure MCF_hermconj( MTr, MA:cfMatrix; htTr, lenTr:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_hermconj( cfMatrix d_MTr, cfMatrix d_MA, ui htTr, ui lenTr );
void MCFcu_hermconj( cfMatrix h_MTr, cfMatrix h_MA, ui htTr, ui lenTr );
|
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_hermconj( d_MTr, d_MA:cfMatrix; htTr, lenTr:UIntSize ): IntBool;
procedure MCFcu_hermconj( h_MTr, h_MA:cfMatrix; htTr, lenTr:UIntSize );
|
|
Beschreibung | Die Hermitesch-konjugierte Form einer komplexen Matrix ist als komplex-konjugierte form ihrer Transponierten definiert:
MTri,j = MAj,i*
Die an diese Funktion übergebenen Dimensionen htTr und lenTr beziehen sich auf die transponierte Ausgabe-Matrix. |
|
|
MCF_HmulM |
MCD_HmulM |
MCE_HmulM |
|
Funktion | Hermitesch-konjugierte Form einer Matrix mit einer anderen Matrix multiplizieren |
|
Syntax C/C++ | #include <MCFstd.h>
void MCF_HmulM( cfMatrix MC, cfMatrix MA, cfMatrix MB, ui htA, ui lenA, ui lenB ); |
C++ MatObj | #include <OptiVec.h>
void matrix<complex<T> >::HmulM( const matrix<complex<T> >& MA, const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
procedure MCF_HmulM( MC, MA, MB:cfMatrix; htA, lenA, lenB:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_HmulM( cfMatrix d_MC, cfMatrix d_MA, cfMatrix d_MB, ui htA, ui lenA, ui lenB );
void MCFcu_HmulM( cfMatrix h_MC, cfMatrix h_MA, cfMatrix h_MB, ui htA, ui lenA, ui lenB );
|
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_HmulM( d_MC, d_MA, d_MB:cfMatrix; htA, lenA, lenB:UIntSize ): IntBool;
procedure MCFcu_HmulM( h_MC, h_MA, h_MB:cfMatrix; htA, lenA, lenB:UIntSize );
|
|
Beschreibung | MC = MAT* * MB
htA, lenA, und lenB müssen spezifiziert werden; die übrigen Dimensionen sind implizit gegeben als: htB = htA, lenC = lenB, htC = lenA. htA und lenA beziehen sich auf die originale, nicht-transponierte Eingabe-Matrix. |
|
|
MF_hexprint
| MD_hexprint |
ME_hexprint |
MCF_hexprint |
MCD_hexprint |
MCE_hexprint |
MI_hexprint | MBI_hexprint | MSI_hexprint | MLI_hexprint | MQI_hexprint |
MU_hexprint | MUB_hexprint | MUS_hexprint | MUL_hexprint | MUQ_hexprint |
|
Funktion | Matrix im Hexadezimal-Format in stdout ausgeben (nur Konsolenanwendungen) |
|
Syntax C/C++ | #include <MFstd.h>
void MF_hexprint( fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::hexprint(); |
Pascal/Delphi | uses MFstd;
procedure MF_hexprint( MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_hexprint( fMatrix d_MA, ui ht, ui len );
int cudaMF_hexprint_buf( fMatrix d_MA, ui ht, ui len, fVector h_Wk );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_hexprint( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMF_hexprint_buf( d_MA:fMatrix; ht, len:UIntSize; h_Wk:fVector ): IntBool;
|
|
Beschreibung | Die Matrix A wird im Hexadezimal-Format auf dem Bildschirm ausgegeben. Jede Bildschirm-Zeile entspricht einer Zeile der Matrix. Die Zeilen werden von 0 and numeriert. Falls nötig, werden die Zeilen am Bildschirmrand abgeschnitten.
C/C++: Die angenommene Zeilenlänge ist in <VecLib.h> als V_consoleWindowWidth definiert. Der Standardwert ist 150 Zeichen. Um eine andere Zeilenlänge zu verwenden, definiere man selbst V_consoleWindowWidth vor dem Einschluss von <VecLib.h>.
Pascal/Delphi: Die angenommene Zeilenlänge ist in der Unit VecLib als Variable V_consoleWindowWidth definiert. Der Standardwert ist 150 Zeichen. Um eine andere Zeilenlänge zu verwenden, weise man einfach den gewünschten Wert zu, z.B.: V_consoleWindowWidth := 80;
Komplexe Zahlen werden in geschweiften Klammern mit einem Komma zwischen dem Real- und dem Imaginärteil geschrieben: {Re, Im}.
Anders als bei MF_chexprint findet keine Aufteilung von Matrizen mit vielen Zeilen auf mehrere Bildschirmseiten statt.
Diese Familie von Funktionen existiert nur für Konsolen-Anwendungen.
nur CUDA-Versionen: cudaM?_hexprint_buf übernimmt einen Host-Vektor h_Wk als zusätzliches Argument. Dieser dient als Pufferspeicher und muss (mindestens) dieselbe Größe haben wie X. Hierdurch wird die interne Bereitstellung von Pufferspeicher bei cudaM?_hexprint eingespart, so dass cudaM?_hexprint_buf etwas schneller ist.
|
|
|
MF_invwEdit
| MD_invwEdit |
ME_invwEdit |
MCF_invwEdit |
MCD_invwEdit |
MCE_invwEdit |
MCFb_inv |
MCDb_inv |
MCEb_inv |
MFb_invwEdit
| MDb_invwEdit |
MEb_invwEdit |
MCFb_invwEdit |
MCDb_invwEdit |
MCEb_invwEdit |
MFb_inv_sizeBuf
| MDb_inv_sizeBuf |
MEb_inv_sizeBuf |
MCFb_inv_sizeBuf |
MCDb_inv_sizeBuf |
MCEb_inv_sizeBuf |
MFsym_inv
| MDsym_inv |
MEsym_inv |
|
|
Syntax C/C++ | #include <MFstd.h>
int MF_inv( fMatrix MInv, fMatrix MA, ui len );
int MF_invwEdit( fMatrix MInv, fMatrix MA, ui len, float thresh );
int MCF_invwEdit( cfMatrix MInv, cfMatrix MA, ui len, float thresh );
int MFb_inv( fMatrix MInv, fMatrix MA, ui len, fVector Buf );
int MFb_invwEdit( fMatrix MInv, fMatrix MA, ui len, float thresh, fVector Buf );
int MCFb_invwEdit( cfMatrix MInv, cfMatrix MA, ui len, float thresh, cfVector Buf );
ui MFb_inv_sizeBuf( ui len );
int MFsym_inv( fMatrix MInv, fMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::inv( const matrix<T>& MA );
void matrix<T>::invwEdit( const matrix<T>& MA, T thresh );
void matrix<complex<T>>::invwEdit( const matrix<complex<T>>& MA, T thresh );
void matrix<T>::b_inv( const matrix<T>& MA, vector<T>& Buf );
void matrix<T>::b_invwEdit( const matrix<T>& MA, T thresh, vector<T>& Buf );
void matrix<complex<T>>::invwEdit( const matrix<complex<T>>& MA, T thresh, vector<T>& Buf );
ui matrix<T>::b_inv_sizeBuf( const ui len );
void matrix<T>::sym_inv( const matrix<T>& MA );
|
Pascal/Delphi | uses MFstd;
function MF_inv( MInv, MA:fMatrix; len:UIntSize ):Integer;
function MF_invwEdit( MInv, MA:fMatrix; len:UIntSize; thresh:Single ):Integer;
function MCF_invwEdit( MInv, MA:cfMatrix; len:UIntSize; thresh:Single ):Integer;
function MFb_inv( MInv, MA:fMatrix; len:UIntSize; Buf:fVector ):Integer;
function MFb_invwEdit( MInv, MA:fMatrix; len:UIntSize; thresh:Single; Buf:fVector ):Integer;
function MCFb_invwEdit( MInv, MA:cfMatrix; len:UIntSize; thresh:Single; Buf:fVector ):Integer;
function MFb_inv_sizeBuf( len:UIntSize ):UIntSize;
function MFsym_inv( MInv, MA:fMatrix; len:UIntSize ):Integer; |
|
Beschreibung | Die Inverse der Matrix MA wird in MInv gespeichert. Falls MA nicht regulär ist, also nicht invertiert werden kann, gibt MF_inv einen Fehler-Code zurück. Im allgemeinen Fall, MF_inv, wird die Inversion über LU-Faktorisierung mit partieller Pivotisierung durchgeführt. Im speziellen Fall symmetrischer Matrizen bietet MFsym_inv einen im Erfolgsfall etwa doppelt so schnellen Weg der Invertierung.
Um bei MF_inv ein Scheitern der Invertierung zu verhindern, kann ein Minimalwert für die Pivotisierung festgelegt werden. Standardmäßig ist diese Pivot-Editierung ausgeschaltet. Um sie für alle Aufrufe von MF_LUdecompose sowie den auf LU-Zerlegung basierenden Funktionen MF_inv und MF_solve einzuschalten, kann MF_LUDsetEdit aufgerufen werden. Da diese Methode nicht fiber-sicher ist, sollte sie aber nicht angewandt werden, um bei verschiedenen Aufrufen von MF_LUdecompose, MF_inv oder MF_solve verschiedene Minimalwerte einzustellen. Zu diesem Zweck dient vielmehr die Funktion MF_invwEdit, die die gewünschte Editier-Schwelle als zusätzliches Argument thresh übernimmt.
Der Rückgabewert von MF_inv und MF_invwEdit zeigt an, ob die Invertierung erfolgreich war:
Rückgabewert | Bedeutung |
0 | Matrix MA ist regulär und konnte erfolgreich invertiert werden |
1 | Matrix MA ist singulär; Ergebnis MInv komplett unbrauchbar |
2 | Matrix MA (nahezu) singulär; konnte nur durch Pivot-Editierung invertiert werden; ob das Ergebnis brauchbar ist, hängt von der spezifischen Anwendung ab |
Um zu prüfen, ob MF_inv erfolgreich war, kann in Single-Thread-Programmen auch MF_LUDresult aufgerufen werden, deren Rückgabewert FALSE (0) sein wird, wenn MA fehlerfrei und ohne Pivot-Editierung invertiert werden konnte, und TRUE (1) für eine singuläre Eingabe-Matrix MA. Da in Multithread-Programmen ggf. nicht klar ist, auf welche Instanz von MF_inv sich MF_LUDresult bezieht, sollte hier nicht MF_LUDresult aufgerufen, sondern immer nur der Rückgabewert von MF_inv überprüft werden.
Diese Funktionen benötigen Pufferspeicher. Die "Normal-Versionen" (Präfix MF_, MCF_ usw.) allozieren ihn selbst, während die Versionen mit den Präfixen MFb_, MCFb_ etc. als zusätzliches Aufruf-Argument einen Vektor Buf übernehmen. Die erforderliche Größe von Buf kann mittels Aufruf von MFb_inv_sizeBuf() abgefragt werden (Angabe nicht in byte, sondern als Zahl der Elemente von Buf im jeweiligen Datentyp!).
Wie erwähnt können symmetrische Matrizen u.U. wesentlich schneller mittels MFsym_inv invertiert werden. Syntax und Bedeutung des Rückgabewerts sind identisch mit MF_inv. Diese Funktion versucht zunächst Cholesky-Faktorisierung. Nur falls diese nicht erfolgreich ist (sich die Eingabe-Matrix also als nicht-positiv-definit herausstellt), wird doch der Weg über LUD beschritten. |
|
Rückgabewert | Ein Code 0, 1 oder 2; siehe oben |
|
|
MF_LequU
| MD_LequU |
ME_LequU |
MCF_LequU |
MCD_LequU |
MCE_LequU |
MI_LequU | MBI_LequU | MSI_LequU | MLI_LequU | MQI_LequU |
MU_LequU | MUB_LequU | MUS_LequU | MUL_LequU | MUQ_LequU |
|
Funktion | Über-Diagonal-Elemente in Unter-Diagonal-Elemente durch Index-Reflektion kopieren, um eine symmetrische Matrix zu erhalten |
|
Syntax C/C++ | #include <MFstd.h>
void MF_LequU( fMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::LequU( ); |
Pascal/Delphi | uses MFstd;
procedure MF_LequU( MA:fMatrix; len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_LequU( fMatrix d_MA, ui len );
void MFcu_LequU( fMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_LequU( d_MA:fMatrix; len:UIntSize ): IntBool;
procedure MFcu_LequU( h_MA:fMatrix; len:UIntSize );
|
|
Beschreibung | MAi,j = MAj,i, i > j |
|
|
MF_lincomb
| MD_lincomb |
ME_lincomb |
MCF_lincomb |
MCD_lincomb |
MCE_lincomb |
|
Funktion | Linearkombination zweier Matrizen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_lincomb( fMatrix MC, fMatrix MA, fMatrix MB, ui ht, ui len, float CA, float CB ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::lincomb( const matrix<T>& MA, const matrix<T>& MB ); |
Pascal/Delphi | uses MFstd;
procedure MF_lincomb( MC, MA, MB:fMatrix; ht, len:UIntSize; CA, CB:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_lincomb( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len, float CA, float CB );
int cusdMF_lincomb( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len, float *d_CA, float *d_CB );
void MFcu_lincomb( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui ht, ui len, float CA, float CB );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_lincomb( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize; CA, CB:Single ): IntBool;
function cusdMF_lincomb( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize; d_CA, d_CB:PSingle ): IntBool;
procedure MFcu_lincomb( h_MC, h_MA, h_MB:fMatrix; ht, len:UIntSize; CA, CB:Single );
|
|
Beschreibung | MC = CA * MA + CB * MB |
|
|
VF_linfit
| VD_linfit |
VE_linfit |
VF_linfitwW |
VD_linfitwW |
VE_linfitwW |
|
Funktion | Datenanpassung für bezüglich ihrer Parameter lineare Modellfunktionen y=f(x) |
|
Syntax C/C++ | #include <MFstd.h>
int VF_linfit( fVector A, iVector AStatus, unsigned npars, fVector X, fVector Y, ui sizex,
void funcs(fVector BasFuncs, float x, unsigned nfuncs));
int VF_linfitwW( fVector A, fMatrix Covar, iVector AStatus, unsigned npars, fVector X, fVector Y, fVector InvVar, ui sizex,
void funcs(fVector BasFuncs, float x, unsigned nfuncs));
int VF_linfitwEdit( fVector A, iVector AStatus, unsigned npars, fVector X, fVector Y, ui sizex, float thresh,
void funcs(fVector BasFuncs, float x, unsigned nfuncs));
int VF_linfitwWwEdit( fVector A, fMatrix Covar, iVector AStatus, unsigned npars, fVector X, fVector Y, fVector InvVar, ui sizex, float thresh,
void funcs(fVector BasFuncs, float x, unsigned nfuncs)); |
C++ MatObj | #include <OptiVec.h>
int vector<T>::linfit( const vector<int>& AStatus, const vector<T>& X, const vector<T>& Y,
void funcs(fVector BasFuncs, float x, unsigned nfuncs));
int vector<T>::linfitwW( matrix<T> Covar, const vector<int>& AStatus, const vector<T>& X, const vector<T>& Y, const vector<T>& InvVar,
void funcs(fVector BasFuncs, float x, unsigned nfuncs));
int vector<T>::linfitwW( matrix<T>* Covar, const vector<int>& AStatus, const vector<T>& X, const vector<T>& Y, const vector<T>& InvVar,
void funcs(fVector BasFuncs, float x, unsigned nfuncs));
int vector<T>::linfitwEdit( const vector<int>& AStatus, const vector<T>& X, const vector<T>& Y, const T thresh,
void funcs(fVector BasFuncs, float x, unsigned nfuncs));
int vector<T>::linfitwWwEdit( matrix<T> Covar, const vector<int>& AStatus, const vector<T>& X, const vector<T>& Y, const vector<T>& InvVar, const T thresh,
void funcs(fVector BasFuncs, float x, unsigned nfuncs));
int vector<T>::linfitwWwEdit( matrix<T>* Covar, const vector<int>& AStatus, const vector<T>& X, const vector<T>& Y, const vector<T>& InvVar, const T thresh,
void funcs(fVector BasFuncs, float x, unsigned nfuncs)); |
Pascal/Delphi | uses MFstd;
function VF_linfit( A:fVector; AStatus:iVector; npars:UInt; X, Y:fVector; sizex:UIntSize; funcs:Pointer ): IntBool;
function VF_linfitwW( A:fVector; Covar:fMatrix; AStatus:iVector; npars:UInt; X, Y, InvVar:fVector; sizex:UIntSize; funcs:Pointer ): IntBool;
function VF_linfitwEdit( A:fVector; AStatus:iVector; npars:UInt; X, Y:fVector; sizex:UIntSize; thresh:Single; funcs:Pointer ): IntBool;
function VF_linfitwWwEdit( A:fVector; Covar:fMatrix; AStatus:iVector; npars:UInt; X, Y, InvVar:fVector; sizex:UIntSize; thresh:Single; funcs:Pointer ): IntBool; |
|
Beschreibung | Die Eingabe-Daten X, Y (und InvVar) werden benutzt, um die Parameter ai der allgemeinen linearen Funktion
y = a0f0(x) + a1f1(x) + a2f2(x)...
zu bestimmen. Die Parameter ai werden in dem Vektor A zurückgegeben.
Argumente:
A | Vektor der Länge npars; gibt die berechneten Koeffizienten zurück |
Covar | Matrix der Dimensionen [npars, npars]; gibt die Kovarianzen der Koeffizenten zurück Falls die Kovarianzen nicht benötigt werden, rufe man die Funktion mit Covar = (fMatrix)NULL / nil. |
AStatus | Vektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind |
npars | Gesamtzahl der Parameter |
X, Y, InvVar | Vektoren der Länge sizex mit den Eingabe-Daten |
funcs | Benutzer-definierte Modell-Funktion |
Die Modell-Funktion (und damit der Parameter-Vektor) kann mehr Parameter enthalten als tatsächlich angepaßt werden sollen. Daher muss ein zusätzlicher Vektor AStatus die Information darüber enthalten, welche Parameter bei ihren Eingabe-Werten eingefroren bleiben sollen (AStatus[i] = 0) und welche anzupassen sind (AStatus[i] = 1). Alle eingefrorenen Parameter müssen in A vor dem Aufruf von VF_linfit initialisiert sein. npars bezeichnet die Gesamtzahl der Parameter in A (also nicht nur die freien Parameter!).
Die Modell-Funktion "funcs" ist vom Anwender zu schreiben. Für jedes Argument x hat sie die einzelnen fi(x) zu berechnen und in dem Vektor BasFuncs zu speichern. In C/C++ muss sie als
void MyFunc( fVector BasFuncs, float x, unsigned nfuncs)
{
BasFuncs[0] = f0( x );
BasFuncs[1] = f1( x);
. . .
}
definiert und an VF_linfit durch Aufruf von
VF_linfit( A, AStatus, npars, X, Y, sizex, MyFunc );
übergeben werden.
In Pascal/Delphi muss die Modell-Funktion als
procedure MyFunc( BasFuncs:fVector; x:Single; nfuncs:UInt );
begin
VF_Pelement( BasFuncs, 0 )^ := f0( x );
VF_Pelement( BasFuncs, 1 )^ := f1( x );
. . .
end;
definiert und an VF_linfit durch Aufruf von
VF_linfit( A, AStatus, npars, X, Y, sizex, @MyFunc );
übergeben werden. Man beachte den Adress-Operator vor "MyFunc.".
Die Funktionen f0( x ) etc. dürfen die Parameter ai selbst nicht enthalten.
In der gewichteten Variante VF_linfitwW muss der Vektor InvVar den Kehrwert der Varianzen der einzelnen X-Y -Datenpunkte enthalten, und die Matrix MCovar gibt die Kovarianzen der Parameter ai zurück: MCovari,j = covariance( ai, aj ).
Intern verwendet VF_linfit einen auf Singulärwert-Zerlegung (SVD) basierenden Algorithmus, um eine Lösung auch für (nahezu) singuläre Gleichungssysteme zu erhalten. Dabei werden Koeffizienten ai, deren Signifikanz unter einer gewissen Schwelle liegt, gleich 0 anstatt Unendlich gesetzt. Die hierfür standardmäßig voreingestellte Schwelle kann mittels VF_setLinfitNeglect verändert werden. VF_getLinfitNeglect liest die derzeit eingestellte Schwelle. Da VF_setLinfitNeglect nicht fiber-sicher ist, sollte diese Funktion nicht verwendet werden, um verschiedene Schwellenwerte für verschiedene Aufrufe von VF_linfit usw. einzustellen. Anstatt wiederholt den Standard-Wert zu ändern, gebrauche man vielmehr die "wEdit"-Varianten von VF_linfit usw., also VF_linfitwEdit, VF_linfitwWwEdit usw.
In dem sehr seltenen Fall, dass diese Funktion keine Lösung finden kann, gibt sie 1 (TRUE) zurück und setzt alle A[i] = 0. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (!= 0). |
|
|
MF_linfit
| MD_linfit |
ME_linfit |
MF_linfitwW |
MD_linfitwW |
ME_linfitwW |
|
Funktion | Datenanpassung für bezüglich ihrer Parameter lineare Modellfunktionen z=f(x, y) |
|
Syntax C/C++ | #include <MFstd.h>
int MF_linfit( fVector A, iVector AStatus, unsigned npars, fVector X, fVector Y, fMatrix Z, ui htZ, ui lenZ,
void funcs(fVector BasFuncs, float x, float y, unsigned nfuncs));
int MF_linfitwW( fVector A, fMatrix Covar, iVector AStatus, unsigned npars, fVector X, fVector Y, fMatrix Z, fMatrix InvVar, ui htZ, ui lenZ,
void funcs(fVector BasFuncs, float x, float y, unsigned nfuncs));
int MF_linfitwEdit( fVector A, iVector AStatus, unsigned npars, fVector X, fVector Y, fMatrix Z, ui htZ, ui lenZ, float thresh,
void funcs(fVector BasFuncs, float x, float y, unsigned nfuncs));
int MF_linfitwWwEdit( fVector A, fMatrix Covar, iVector AStatus, unsigned npars, fVector X, fVector Y, fMatrix Z, fMatrix InvVar, ui htZ, ui lenZ, float thresh,
void funcs(fVector BasFuncs, float x, float y, unsigned nfuncs)); |
C++ MatObj | #include <OptiVec.h>
int vector<T>::linfit( const vector<int>& AStatus, const vector<T>& X, const vector<T>& Y, const matrix<T>& MZ,
void funcs(fVector BasFuncs, float x, float y, unsigned nfuncs));
int vector<T>::linfitwW( matrix<T> Covar, const vector<int>& AStatus, const vector<T>& X, const vector<T>& Y, const matrix<T>& MZ, const matrix<T>& MInvVar,
void funcs(fVector BasFuncs, float x, float y, unsigned nfuncs));
int vector<T>::linfitwW( matrix<T>* Covar, const vector<int>& AStatus, const vector<T>& X, const vector<T>& Y, const matrix<T>& MZ, const matrix<T>& MInvVar,
void funcs(fVector BasFuncs, float x, float y, unsigned nfuncs));
int vector<T>::linfitwEdit( const vector<int>& AStatus, const vector<T>& X, const vector<T>& Y, const matrix<T>& MZ, const T thresh,
void funcs(fVector BasFuncs, float x, float y, unsigned nfuncs));
int vector<T>::linfitwWwEdit( matrix<T> Covar, const vector<int>& AStatus, const vector<T>& X, const vector<T>& Y, const matrix<T>& MZ, const matrix<T>& MInvVar, const T thresh,
void funcs(fVector BasFuncs, float x, float y, unsigned nfuncs));
int vector<T>::linfitwWwEdit( matrix<T>* Covar, const vector<int>& AStatus, const vector<T>& X, const vector<T>& Y, const matrix<T>& MZ, const matrix<T>& MInvVar, const T thresh,
void funcs(fVector BasFuncs, float x, float y, unsigned nfuncs)); |
Pascal/Delphi | uses MFstd;
function MF_linfit( A:fVector; AStatus:iVector; npars:UInt; X, Y:fVector; MZ:fMatrix; htZ, lenZ:UIntSize; funcs:Pointer ): IntBool;
function MF_linfitwW( A:fVector; Covar:fMatrix; AStatus:iVector; npars:UInt; X, Y:fVector; MZ, MInvVar:fMatrix; htZ, lenZ:UIntSize; funcs:Pointer ): IntBool;
function MF_linfitwEdit( A:fVector; AStatus:iVector; npars:UInt; X, Y:fVector; MZ:fMatrix; htZ, lenZ:UIntSize; thresh:Single; funcs:Pointer ): IntBool;
function MF_linfitwWwEdit( A:fVector; Covar:fMatrix; AStatus:iVector; npars:UInt; X, Y:fVector; MZ, MInvVar:fMatrix; htZ, lenZ:UIntSize; thresh:Single; funcs:Pointer ): IntBool; |
|
Beschreibung | Die Eingabe-Daten X, Y, MZ (und MInvVar) werden benutzt, um die Parameter ai der allgemeinen linearen Funktion
z = a0f0(x, y) + a1f1(x, y) + a2f2(x, y)...
zu bestimmen. Die Parameter ai werden in dem Vektor A zurückgegeben.
Argumente:
A | Vektor der Länge npars; gibt die berechneten Koeffizienten zurück |
Covar | Matrix der Dimensionen [npars, npars]; gibt die Kovarianzen der Koeffizenten zurück. Falls die Kovarianzen nicht benötigt werden, rufe man die Funktion mit Covar = (fMatrix)NULL / nil. |
AStatus | Vektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind |
npars | Gesamtzahl der Parameter |
X, Y | Vektoren der Länge lenZbzw. htZ, die das X-Y-Koordinatensystem der Matrix Z aufspannen |
MZ, MInvVar | Matrizen der Dimensionen [htZ, lenZ] mit den Eingabedaten sowie, bei der gewichteten Variante, dem Kehrwert von deren Varianzen |
funcs | Benutzer-definierte Modell-Funktion |
Die Modell-Funktion (und damit der Parameter-Vektor) kann mehr Parameter enthalten als tatsächlich angepaßt werden sollen. Daher muss ein zusätzlicher Vektor AStatus die Information darüber enthalten, welche Parameter bei ihren Eingabe-Werten eingefroren bleiben sollen (AStatus[i] = 0) und welche anzupassen sind (AStatus[i] = 1). Alle eingefrorenen Parameter müssen in A vor dem Aufruf von MF_linfit initialisiert sein. npars bezeichnet die Gesamtzahl der Parameter in A (also nicht nur die freien Parameter!).
Die Modell-Funktion "funcs" ist vom Anwender zu schreiben. Für jedes Argumentenpaar x, y hat sie die einzelnen fi(x, y) zu berechnen und in dem Vektor BasFuncs zu speichern. In C/C++ muss sie als
void MyFunc( fVector BasFuncs, float x, float y, unsigned nfuncs);
{
BasFuncs[0] = f0( x, y );
BasFuncs[1] = f1( x, y);
. . .
}
definiert und an MF_linfit durch Aufruf von
MF_linfit( A, AStatus, npars, X, Y, MZ, htZ, lenZ, MyFunc );
übergeben werden.
In Pascal/Delphi muss die Modell-Funktion als
procedure MyFunc( BasFuncs:fVector; x, y:Single; nfuncs:UInt );
begin
VF_Pelement( BasFuncs, 0 )^ := f0( x, y );
VF_Pelement( BasFuncs, 1 )^ := f1( x, y );
. . .
end;
definiert und an MF_linfit durch Aufruf von
MF_linfit( A, AStatus, npars, X, Y, MZ, htZ, lenZ, @MyFunc );
übergeben werden. Man beachte den Adress-Operator vor "MyFunc.". In Turbo Pascal muss die Modellfunktion mit der Option "Force Far Calls" {$F+} compiliert werden.
Die Funktionen f0( x, y ) etc. dürfen die Parameter ai selbst nicht enthalten.
In der gewichteten Variante MF_linfitwW muss die Matrix MInvVar den Kehrwert der Varianzen der einzelnen X-Y-Z-Datenpunkte enthalten, und die Matrix MCovar gibt die Kovarianzen der Parameter ai zurück: MCovari,j = covariance( ai, aj ).
Intern verwendet MF_linfit einen auf Singulärwert-Zerlegung (SVD) basierenden Algorithmus, um eine Lösung auch für (nahezu) singuläre Gleichungssysteme zu erhalten. Dabei werden Koeffizienten ai, deren Signifikanz unter einer gewissen Schwelle liegt, gleich 0 anstatt Unendlich gesetzt. Die hierfür standardmäßig voreingestellte Schwelle kann mittels VF_setLinfitNeglect verändert werden. VF_getLinfitNeglect liest die derzeit eingestellte Schwelle. Da VF_setLinfitNeglect nicht fiber-sicher ist, sollte diese Funktion nicht verwendet werden, um verschiedene Schwellenwerte für verschiedene Aufrufe von VF / MF_linfit usw. einzustellen. Anstatt wiederholt den Standard-Wert zu ändern, gebrauche man vielmehr die "wEdit"-Varianten von VF / MF_linfit usw., also MF_linfitwEdit, MF_linfitwWwEdit usw.
In dem sehr seltenen Fall, dass diese Funktion keine Lösung finden kann, gibt sie 1 (TRUE) zurück und setzt alle A[i] = 0. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (!= 0). |
|
|
MF_LUdecompose
| MD_LUdecompose |
ME_LUdecompose |
MCF_LUdecompose |
MCD_LUdecompose |
MCE_LUdecompose |
MF_LUdecomposewEdit
| MD_LUdecomposewEdit |
ME_LUdecomposewEdit |
MCF_LUdecomposewEdit |
MCD_LUdecomposewEdit |
MCE_LUdecomposewEdit |
MFb_LUdecompose
| MDb_LUdecompose |
MEb_LUdecompose |
MCFb_LUdecompose |
MCDb_LUdecompose |
MCEb_LUdecompose |
MFb_LUdecomposewEdit
| MDb_LUdecomposewEdit |
MEb_LUdecomposewEdit |
MCFb_LUdecomposewEdit |
MCDb_LUdecomposewEdit |
MCEb_LUdecomposewEdit |
MFb_LUdecompose_sizeBuf
| MDb_LUdecompose_sizeBuf |
MEb_LUdecompose_sizeBuf |
MCFb_LUdecompose_sizeBuf |
MCDb_LUdecompose_sizeBuf |
MCEb_LUdecompose_sizeBuf |
|
Funktion | LU-Faktorisierung (engl. LU decomposition) |
|
Syntax C/C++ | #include <MFstd.h>
int MF_LUdecompose( fMatrix MLU, uiVector Ind, fMatrix MA, ui len );
int MF_LUdecomposewEdit( fMatrix MLU, uiVector Ind, fMatrix MA, ui len, float thresh ); int MCF_LUdecomposewEdit( cfMatrix MLU, uiVector Ind, cfMatrix MA, ui len, float thresh );
int MFb_LUdecompose( fMatrix MLU, uiVector Ind, fMatrix MA, ui len, fVector Buf );
int MFb_LUdecomposewEdit( fMatrix MLU, uiVector Ind, fMatrix MA, ui len, float thresh, fVector Buf );
int MCFb_LUdecomposewEdit( cfMatrix MLU, uiVector Ind, cfMatrix MA, ui len, float thresh, cfVector Buf );
ui MFb_LUdecompose_sizeBuf( ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::LUdecompose( vector<ui> Ind, const matrix<T>& MA );
void matrix<T>::LUdecompose( vector<ui>* Ind, const matrix<T>& MA );
void matrix<T>::LUdecomposewEdit( vector<ui> Ind, const matrix<T>& MA, const T& thresh );
void matrix<T>::LUdecomposewEdit( vector<ui>* Ind, const matrix<T>& MA, const T& thresh );
void matrix<complex<T>>::LUdecomposewEdit( vector<ui>* Ind, const matrix<complex<T>>& MA, const T& thresh );
void matrix<T>::b_LUdecompose( vector<ui> Ind, const matrix<T>& MA, vector<T> Buf );
void matrix<T>::b_LUdecompose( vector<ui>* Ind, const matrix<T>& MA, vector<T> Buf );
void matrix<T>::b_LUdecomposewEdit( vector<ui> Ind, const matrix<T>& MA, const T& thresh, vector<T> Buf );
void matrix<T>::b_LUdecomposewEdit( vector<ui>* Ind, const matrix<T>& MA, const T& thresh, vector<T> Buf );
void matrix<complex<T>>::b_LUdecomposewEdit( vector<ui>* Ind, const matrix<complex<T>>& MA, const T& thresh, vector<complex<T>> Buf );
ui matrix<T>::b_LUdecompose_sizeBuf(); |
Pascal/Delphi | uses MFstd;
function MF_LUdecompose( MLU:fMatrix; Ind:uiVector; MA:fMatrix; len:UIntSize ):Integer;
function MF_LUdecomposewEdit( MLU:fMatrix; Ind:uiVector; MA:fMatrix; len:UIntSize; thresh:Single ):Integer;
function MCF_LUdecomposewEdit( MLU:cfMatrix; Ind:uiVector; MA:cfMatrix; len:UIntSize; thresh:Single ):Integer;
function MFb_LUdecompose( MLU:fMatrix; Ind:uiVector; MA:fMatrix; len:UIntSize; Buf:fVector ):Integer;
function MFb_LUdecomposewEdit( MLU:fMatrix; Ind:uiVector; MA:fMatrix; len:UIntSize; thresh:Single; Buf:fVector ):Integer;
function MCFb_LUdecomposewEdit( MLU:cfMatrix; Ind:uiVector; MA:cfMatrix; len:UIntSize; thresh:Single; Buf:cfVector ):Integer;
function MFb_LUdecompose_sizeBuf( len:UIntSize ):UIntSize;
|
|
Beschreibung | MA wird in ein Produkt MA = L * U zerlegt, wobei L eine untere Dreiecksmatrix ist (engl. lower-triangular), deren Diagonal-Elemente alle gleich 1 sind, und U ist eine obere Dreiecks-Matrix (engl. upper-triangular). Da die Gesamtzahl der nicht-trivialen Elemente von L und U gerade in eine Matrix derselben Dimensionen wie MA paßt, wird das Ergebnis in einer einzelnen Matrix MLU anstelle von getrennten Matrizen L und U abgelegt. Tatsächlich sind es auch gar nicht die "wahren" Matrizen L und U, die zu MLU kombiniert werden, sondern eine Zeilen-Permutation, deren Indizes in dem Vektor Ind angegeben sind.
MA darf von MLU überschrieben werden, falls gewünscht.
Es gibt Anwendungen, wo es sinnvoll ist, (nahezu) singuläre Matrizen durch "Pivot-Editierung" zerlegbar zu machen, indem man für die bei der Zerlegung verwandte partielle Pivotisierung einen Minimalwert festlegt. Falls bei der Pivotisierung kein Diagonal-Element gefunden werden kann, das betragsmäßig größer als der Minimalwert ist, wird auf diesen anstelle des verschwindenden Diagonalelementes normalisiert. Auf diese Weise werden Divisionen durch Zahlen nahe oder gleich Null vermieden.
Standardmäßig ist Pivot-Editierung ausgeschaltet. Um sie für alle Aufrufe von MF_LUdecompose sowie den auf LU-Zerlegung basierenden Funktionen MF_inv und MF_solve einzuschalten, kann MF_LUDsetEdit aufgerufen werden. Da diese Methode nicht fiber-sicher ist, sollte sie aber nicht angewandt werden, um bei verschiedenen Aufrufen von MF_LUdecompose, MF_inv oder MF_solve verschiedene Minimalwerte einzustellen. Zu diesem Zweck dient vielmehr die Funktion MF_LUdecomposewEdit, die die gewünschte Editier-Schwelle als zusätzliches Argument thresh übernimmt.
Der Rückgabewert von MF_LUdecompose und MF_LUdecomposewEdit zeigt an, ob die Zerlegung erfolgreich war und ob die Anzahl der Permutationen gerade war oder ungerade:
Rückgabewert | Bedeutung |
0 | Matrix singulär, Ergebnis komplett unbrauchbar |
+1 | Matrix erfolgreich zerlegt; gerade Anzahl von Permutationen |
-1 | Matrix erfolgreich zerlegt; ungerade Anzahl von Permutationen |
+2 | Matrix nahezu singulär; konnte durch Pivot-Editierung zerlegt werden; Ergebnis nur teilweise brauchbar; gerade Anzahl von Permutationen |
+2 | Matrix nahezu singulär; konnte durch Pivot-Editierung zerlegt werden; Ergebnis nur teilweise brauchbar; ungerade Anzahl von Permutationen |
Um zu prüfen, ob MF_LUdecompose erfolgreich war, kann in Single-Thread-Programmen auch MF_LUDresult aufgerufen werden, deren Rückgabewert FALSE (0) sein wird, wenn MA fehlerfrei faktorisiert werden konnte, und TRUE (1) für eine singuläre Eingabe-Matrix A. Da in Multithread-Programmen ggf. nicht klar ist, auf welche Instanz von MF_LUdecompose sich MF_LUDresult bezieht, sollte hier nicht MF_LUDresult aufgerufen, sondern immer nur der Rückgabewert von MF_LUdecompose überprüft werden.
Diese Funktionen benötigen Pufferspeicher. Die "Normal-Versionen" (Präfix MF_, MCF_ usw.) allozieren ihn selbst, während die Versionen mit den Präfixen MFb_, MCFb_ etc. als zusätzliches Aufruf-Argument einen Vektor Buf übernehmen. Die erforderliche Größe von Buf kann mittels Aufruf von MFb_LUdecompose_sizeBuf() abgefragt werden (Angabe nicht in byte, sondern als Zahl der Elemente von Buf im jeweiligen Datentyp!). |
|
Fehlerbehandlung | Im Falle einer singulären Matrix bleibt MLU undefiniert, und der Rückgabewert wird auf 0 bzw. +-2 gesetzt. Zusätzlich wird ein internes Register gesetzt, das durch Aufruf von MF_LUDresult ausgelesen werden kann. |
|
Rückgabewert | Code 0, +-1 oder +-2, der Erfolg sowie gerade oder ungerade Anzahl von Zeilen-Permutationen anzeigt, s.o. |
|
|
MF_LUdet
| MD_LUdet |
ME_LUdet |
MCF_LUdet |
MCD_LUdet |
MCE_LUdet |
|
Funktion | Determinante einer LU-faktorisierten Matrix |
|
Syntax C/C++ | #include <MFstd.h>
float MF_LUdet( fMatrix LU, ui len, int permut ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::LUdet( const matrix<T>& MLU, int permut ); |
Pascal/Delphi | uses MFstd;
function MF_LUdet( MLU:fMatrix; len:UIntSize; permut:Integer ): Single; |
|
Beschreibung | MF_LUdet berechnet die Determinante einer bereits in LU-Form faktorisierten Matrix und gibt sie als Skalar zurück. Das Argument permut muss +1 or -1 sein, wie von MF_LUdecompose zurückgegeben.
|
|
|
|
MF_LUimprove
| MD_LUimprove |
ME_LUimprove |
MCF_LUimprove |
MCD_LUimprove |
MCE_LUimprove |
MFb_LUimprove
| MDb_LUimprove |
MEb_LUimprove |
MCFb_LUimprove |
MCDb_LUimprove |
MCEb_LUimprove |
|
Funktion | iterative Genauigkeits-Verbesserung der über LU-Faktorisierung erzielten Lösung eines linearen Gleichungs-Systems |
|
Syntax C/C++ | #include <MFstd.h>
void MF_LUimprove( fVector X, fVector B, fMatrix MA, fMatrix LU, uiVector Ind, ui len );
void MFb_LUimprove( fVector X, fVector B, fMatrix MA, fMatrix LU, uiVector Ind, ui len, fVector Buf ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::LUimprove( const vector<T> B, const matrix<T>& MA, const matrix<T>& MLU, const vector<ui>& Ind );
void vector<T>::LUbimprove( const vector<T> B, const matrix<T>& MA, const matrix<T>& MLU, const vector<ui>& Ind, vector<T> Buf ); |
Pascal/Delphi | uses MFstd;
procedure MF_LUimprove( X, B:fVector; MA, MLU:fMatrix; Ind:uiVector; len:UIntSize );
procedure MFb_LUimprove( X, B:fVector; MA, MLU:fMatrix; Ind:uiVector; len:UIntSize; Buf:fVector ); |
|
Beschreibung | Vor allem für große Matrizen können die akkumulierten Rundungsfehler bei der Matrix-Inversion recht groß werden. Führt man aber die Lösung eines linearen Gleichungs-Systems über LU-Zerlegung mittels MF_LUdecompose durch und bewahrt dabei die Eingabe-Matrix auf, so eröffnet sich die Möglichkeit, die numerische Genauigkeit der von MF_LUsolve berechneten Lösung iterativ zu verbessern. Hierzu rufe man anschließend an MF_LUsolve noch MF_LUimprove. Diese Funktion benötigt als Argumente: den Ausgabe-Vektor X von MF_LUsolve, den Vektor B des linearen Gleichungssystemes und sowohl die originale Matrix A als auch deren LU-faktorisierte Form MLU samt den Permutations-Indizes Ind.
Diese Funktionen benötigen Pufferspeicher. Die "Normal-Versionen" (Präfix MF_, MCF_ usw.) allozieren ihn selbst, während die Versionen mit den Präfixen MFb_, MCFb_ etc. als zusätzliches Aufruf-Argument einen Vektor Buf übernehmen. Die erforderliche Größe von Buf beträgt len Elemente des jeweiligen Datentyps. |
|
|
MF_LUinv
| MD_LUinv |
ME_LUinv |
MCF_LUinv |
MCD_LUinv |
MCE_LUinv |
MCF_LUinv |
MCD_LUinv |
MCE_LUinv |
MFb_LUinv
| MDb_LUinv |
MEb_LUinv |
MCFb_LUinv |
MCDb_LUinv |
MCEb_LUinv |
MFb_LUinv_sizeBuf
| MDb_LUinv_sizeBuf |
MEb_LUinv_sizeBuf |
MCFb_LUinv_sizeBuf |
MCDb_LUinv_sizeBuf |
MCEb_LUinv_sizeBuf |
|
Funktion | Invertierung einer bereits LU-faktorisierten Matrix |
|
Syntax C/C++ | #include <MFstd.h>
void MF_LUinv( fMatrix MInv, fMatrix MLU, uiVector Ind, ui len );
void MFb_LUinv( fMatrix MInv, fMatrix MLU, uiVector Ind, ui len, fVector Buf );
ui MFb_LUinv_sizeBuf( ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::LUinv( const matrix<T>& MLU, const vector<ui>& Ind );
void matrix<T>::b_LUinv( const matrix<T>& MLU, const vector<ui>& Ind );
ui matrix<T>::b_LUinv_sizeBuf(); |
Pascal/Delphi | uses MFstd;
procedure MF_LUinv( MInv, MLU:fMatrix; Ind:uiVector; len:UIntSize );
procedure MFb_LUinv( MInv, MLU:fMatrix; Ind:uiVector; len:UIntSize; Buf:fVector );
function MFb_LUinv_sizeBuf( len:UIntSize ):UIntSize; |
|
Beschreibung | MF_LUinv invertiert eine Matrix, die bereits in LU-Form vorliegt. Zusammen mit der Matrix LU müssen deren Zeilen-Permutationsindizes als Vektor Ind übergeben werden, so wie man sie als Ausgabe von MF_LUdecompose erhalten hat.
Diese Funktionen benötigen Pufferspeicher. Die "Normal-Versionen" (Präfix MF_, MCF_ usw.) allozieren ihn selbst, während die Versionen mit den Präfixen MFb_, MCFb_ etc. als zusätzliches Aufruf-Argument einen Vektor Buf übernehmen. Die erforderliche Größe von Buf kann mittels Aufruf von MFb_LUinv_sizeBuf() abgefragt werden (Angabe nicht in byte, sondern als Zahl der Elemente von Buf im jeweiligen Datentyp!). |
|
|
MF_LUDgetEdit
| MD_LUDgetEdit |
ME_LUDgetEdit |
MCF_LUgetEdit |
MCD_LUgetEdit |
MCE_LUgetEdit |
|
Funktion | Editierungs-Schwelle für Pivotisierung bei LU-Faktorisierung lesen |
|
Syntax C/C++ | #include <MFstd.h>
float MF_LUDgetEdit( void ); |
C++ MatObj | #include <OptiVec.h>
T matrix<T>::LUDgetEdit( ); |
Pascal/Delphi | uses MFstd;
function MF_LUDgetEdit: Single; |
|
|
|
MF_LUDresult
| MD_LUDresult |
ME_LUDresult |
MCF_LUDresult |
MCD_LUDresult |
MCE_LUDresult |
|
Funktion | prüfen, ob die letzte explizit oder implizit auf LU-Faktorisierung basierende Operation fehlerfrei durchgeführt werden konnte |
|
Syntax C/C++ | #include <MFstd.h>
int MF_LUDresult( void ); |
C++ MatObj | #include <OptiVec.h>
int matrix<T>::LUDresult( ); |
Pascal/Delphi | uses MFstd;
function MF_LUDresult: IntBool; |
|
Beschreibung | Nach einem Aufruf von MF_LUdecompose oder einer der intern auf LU-Faktorisierung basierenden Funktionen (wie MF_inv, MF_solve) sollte das Ergebnis mittels MF_LUDresult auf Fehlerfreiheit überprüft werden. Konnte die LU-Faktorisierung erfolgreich durchgeführt werden, gibt MF_LUDresult FALSE (0) zurück; war aber MA (nahezu) singulär, wird TRUE (1) zurückgegeben. |
|
|
|
MF_LUDsetEdit
| MD_LUDsetEdit |
ME_LUDsetEdit |
MCF_LUDsetEdit |
MCD_LUDsetEdit |
MCE_LUDsetEdit |
|
Funktion | Schwelle für Pivot-Editierung bei LU-Faktorisierung setzen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_LUDsetEdit( float Thresh );
void MCF_LUDsetEdit( float Thresh ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::LUDsetEdit( const T& Thresh ); |
Pascal/Delphi | uses MFstd;
procedure MF_LUDsetEdit( Thresh:Single );
procedure MCF_LUDsetEdit( Thresh:Single ); |
|
Beschreibung | Mit dieser Funktion wird die Schwelle für die Pivot-Editierung bei MF_LUdecompose, MF_inv und MF_solve festgelegt. Da diese Funktionen nicht fiber-sicher ist (wenn verschiedene Threads sie mit unterschiedlichen Werten aufrufen, ist der tatsächlich eingestellte Wert undefiniert), sollte man sie nur dann einsetzen, wenn alle Aufrufe der genannten Funktionen denselben Schwellenwert verwenden sollen. Andernfalls rufe man anstelle der Voreinstellung eines Standardwertes jeweils die "wEdit"-Varianten der genannten Funktionen, also MF_LUdecomposewEdit, MF_invwEdit bzw. MF_solvewEdit.
Komplexe Versionen: Der Schwellenwert ist immer reell Zahl. Real- und Imaginärteil in Frage kommender Pivots werden gleicherma&szlib;en mit ihm verglichen, und wenn beide kleiner sind, so erfolgt die Division durch die reelle Zahl thresh.
Um die derzeit eingestellte Standard-Schwelle zu lesen, rufe man MF_LUDgetEdit. |
|
|
MF_LUsolve
| MD_LUsolve |
ME_LUsolve |
MCF_LUsolve |
MCD_LUsolve |
MCE_LUsolve |
|
Funktion | lineares Gleichungs-System MA * X = B lösen, für das MA bereits in LU-faktorisierter Form vorliegt |
|
Syntax C/C++ | #include <MFstd.h>
void MF_LUsolve( fVector X, fMatrix LU, fVector B, uiVector Ind, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::LUsolve( const matrix<T>& MLU, const vector<T>& B, const vector<ui>& Ind ); |
Pascal/Delphi | uses MFstd;
procedure MF_LUsolve( X:fVector; MLU:fMatrix; B:fVector; Ind:uiVector;
len:UIntSize ); |
|
Beschreibung | Das lineare Gleichungs-System MA * X = B wird nach dem Vektor X aufgelöst. Anstelle von MA selbst erwartet diese Funktion die LU-faktorisierte Form von MA als Eingabe-Matrix LU samt deren Zeilen-Permutationsindizes in dem Vektor Ind, wie von MF_LUdecompose zurückgegeben.
Falls die originale Matrix A noch zur Verfügung steht, ist eine iterative Verbesserung der Lösung dringend anzuraten. Hierzu rufe man im Anschluß an MF_LUsolve noch MF_LUimprove. Im Vergleich zur bereits durchgeführten LU-Faktorisierung und Rück-Substitution kostet diese iterative Verbesserung nur sehr wenig Rechenzeit, kann aber zu einer deutlichen Verbesserung der Lösung führen und häufig sogar Lösungen "retten", die sonst aufgrund von zu großen Rundungsfehlern gänzlich unbrauchbar wären. |
|
|
MF_matrix
| MD_matrix |
ME_matrix |
MCF_matrix |
MCD_matrix |
MCE_matrix |
MI_matrix | MBI_matrix | MSI_matrix | MLI_matrix | MQI_matrix |
MU_matrix | MUB_matrix | MUS_matrix | MUL_matrix | MUQ_matrix |
|
Funktion | Speicherzuweisung für eine Matrix |
|
Syntax C/C++ | #include <MFstd.h>
fMatrix MF_matrix( ui ht, ui len ); |
Pascal/Delphi | uses MFstd;
function MF_matrix( ht, len:UIntSize ): fMatrix; |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
fMatrix cudaMF_matrix( ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_matrix( ht, len:UIntSize ): fMatrix;
|
|
Beschreibung | Je nach Umgebung und Speichermodell wird die am besten geeignete Methode der Speicherzuweisung gewählt. Schlägt die Allokation fehl, so wird eine Fehlermeldung ausgegeben und das Programm abgebrochen. Um hiermit zugewiesenen Speicher wieder freizugeben, rufe man M_free, M_nfree oder V_freeAll (M_nfree nur in C/C++).
Man beachte, dass die Deklaration einer Matrix (z.B. als fMatrix) nur einen Namen, aber keinen Speicherplatz reserviert!
Siehe Kap. 4.1 bezüglich Details der Implementierung.
|
|
Fehlerbehandlung | Falls nicht genügend Speicherplatz zur Verfügung steht oder falls entweder len oder ht gleich 0 sind, wird eine Fehlermeldung "Not enough memory" ausgegeben und das Programm abgebrochen.
16-bit-Modelle:
Falls mehr als 64 kB Speicher angefordert werden, wird eine Fehlermeldung "Vector > 64 kB not possible" ausgegeben und das Programm abgebrochen (außer im Modell HUGE). Falls eine oder beide Matrix-Dimensionen die 64 kB-Grenze überschreiten, wird eine Fehlermeldung "Invalid Matrix dimension(s)" ausgegeben und das Programm abgebrochen; dies gilt auch für das Modell HUGE.
32-bit:
Falls mehr als 4 GB Speicher angefordert werden, wird eine Fehlermeldung "Vector > 4 GB not possible" ausgegeben und das Programm abgebrochen. Falls bereits eine einzelne Matrix-Dimension diese Grenze übersteigt, wird eine Fehlermeldung "Invalid Matrix dimension(s)" ausgegeben und das Programm abgebrochen. |
|
Rückgabewert | C/C++: Zeiger auf das Feld von Zeilen-Zeigern
Pascal/Delphi: Zeiger auf den zugewiesenen Speicher |
|
|
MF_matrix0
| MD_matrix0 |
ME_matrix0 |
MCF_matrix0 |
MCD_matrix0 |
MCE_matrix0 |
MI_matrix0 | MBI_matrix0 | MSI_matrix0 | MLI_matrix0 | MQI_matrix0 |
MU_matrix0 | MUB_matrix0 | MUS_matrix0 | MUL_matrix0 | MUQ_matrix0 |
|
Funktion | Speicherzuweisung für eine Matrix und Initialisierung aller Elemente mit 0 |
|
Syntax C/C++ | #include <MFstd.h>
fMatrix F_matrix0( ui ht, ui len ); |
Pascal/Delphi | uses MFstd;
function MF_matrix0( ht, len:UIntSize ): fMatrix; |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
fMatrix cudaMF_matrix0( ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_matrix0( ht, len:UIntSize ): fMatrix;
|
|
Beschreibung | Die Funktionen dieser Familie sind denen der MF_matrix-Familie sehr ähnlich. Zusätzlich zur Speicherzuweisung initialisieren sie aber alle Elemente mit 0. Aufrufe von MF_matrix und MF_matrix0 können beliebig gemischt werden. Sie und die Vektor-Allokations-Funktionen VF_vector etc. benutzen dieselben Tabellen zur Buchführung über die zugewiesenen Handles und Zeiger. Bezüglich weiterer Einzelheiten siehe MF_matrix. |
|
Fehlerbehandlung | Falls nicht genügend Speicherplatz zur Verfügung steht oder falls entweder len oder ht gleich 0 sind, wird eine Fehlermeldung "Not enough memory" ausgegeben und das Programm abgebrochen.
16-bit-Modelle:
Falls mehr als 64 kB Speicher angefordert werden, wird eine Fehlermeldung "Vector > 64 kB not possible" ausgegeben und das Programm abgebrochen (außer im Modell HUGE). Falls eine oder beide Matrix-Dimensionen die 64 kB-Grenze überschreiten, wird eine Fehlermeldung "Invalid Matrix dimension(s)" ausgegeben und das Programm abgebrochen; dies gilt auch für das Modell HUGE.
32-bit:
Falls mehr als 4 GB Speicher angefordert werden, wird eine Fehlermeldung "Vector > 4 GB not possible" ausgegeben und das Programm abgebrochen. Falls bereits eine einzelne Matrix-Dimension diese Grenze übersteigt, wird eine Fehlermeldung "Invalid Matrix dimension(s)" ausgegeben und das Programm abgebrochen. |
|
Rückgabewert | C/C++: Zeiger auf das Feld von Zeilen-Zeigern
Pascal/Delphi: Zeiger auf den zugewiesenen Speicher |
|
|
MF_MatrixTo2DArray
| MD_MatrixTo2DArray |
ME_MatrixTo2DArray |
MCF_MatrixTo2DArray |
MCD_MatrixTo2DArray |
MCE_MatrixTo2DArray |
MI_MatrixTo2DArray | MBI_MatrixTo2DArray | MSI_MatrixTo2DArray | MLI_MatrixTo2DArray | MQI_MatrixTo2DArray |
MU_MatrixTo2DArray | MUB_MatrixTo2DArray | MUS_MatrixTo2DArray | MUL_MatrixTo2DArray | MUQ_MatrixTo2DArray |
|
Funktion | OptiVec-Matrix in 2D-Array von Delphi 4 oder höher konvertieren |
|
Syntax C/C++ | N.A. |
Pascal/Delphi | uses VecLib, MFstd;
type fArray = array of Single;
type f2DArray = array of fArray;
procedure MF_MatrixTo2DArray( DelphiArr:f2DArray; MF:fMatrix; ht,len:UIntSize); |
|
Beschreibung | Diese Funktion wird nur für Delphi 4 oder höher benötigt, da frühere Versionen von Borland Pascal/Delphi keine eigenen dynamisch allozierten Matrizen boten. MF_MatrixTo2DArray wandelt OptiVec-Matrizen in zwei-dimensionale Delphi-Arrays um. Man beachte, dass - im Unterschied zu statischen Pascal/Delphi-Matrizen - die dynamischen Matrizen von Delphi 4+ nicht direkt an OptiVec-Funktionen übergeben werden können, sondern zuvor durch Aufruf von MF_2DArrayToMatrix konvertiert werden müssen. Sollte es nötig werden, eine OptiVec-Matrix in das Delphi-Format zurückzuwandeln, dient dazu die vorliegende Funktion. |
|
|
MCF_mulC |
MCD_mulC |
MCE_mulC |
MCF_mulReC |
MCD_mulReC |
MCE_mulReC |
|
Funktion | alle Matrix-Elemente mit einer Konstante multiplizieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_mulC( fMatrix MB, fMatrix MA, ui ht, ui len, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::mulC( const T& C ); |
Pascal/Delphi | uses MFstd;
procedure MF_mulC( MB, MA:fMatrix; ht, len:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_mulC( fMatrix d_MB, fMatrix d_MA, ui ht, ui len, float C );
int cusdMF_mulC( fMatrix d_MB, fMatrix d_MA, ui ht, ui len, float *d_C );
int cudaMCF_mulC( cfMatrix d_MB, cfMatrix d_MA, ui ht, ui len, fComplex C );
int cusdMCF_mulC( cfMatrix d_MB, cfMatrix d_MA, ui ht, ui len, fComplex *d_C );
int cudaMCF_mulReC( cfMatrix d_MB, cfMatrix d_MA, ui ht, ui len, float CRe );
int cusdMCF_mulReC( cfMatrix d_MB, cfMatrix d_MA, ui ht, ui len, float *d_CRe );
void MFcu_mulC( fMatrix h_MB, fMatrix h_MA, ui ht, ui len, float C );
void MCFcu_mulC( cfMatrix h_MB, cfMatrix h_MA, ui ht, ui len, fComplex C );
void MCFcu_mulReC( cfMatrix h_MB, cfMatrix h_MA, ui ht, ui len, float CRe );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_mulC( d_MB, d_MA:fMatrix; ht, len:UIntSize; C:Single ): IntBool;
function cusdMF_mulC( d_MB, d_MA:fMatrix; ht, len:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_mulC( h_MB, h_MA:fMatrix; ht, len:UIntSize; C:Single );
|
|
Beschreibung | MBij = MAij + C |
|
|
|
Funktion | Zeilen-Vektor mit Matrix multiplizieren |
|
Syntax C/C++ | #include <MFstd.h>
void VF_mulM( fVector Y, fVector X, fMatrix MA, ui htA, ui lenA ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::mulM( const vector<T>& X, const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure VF_mulM( Y, X:fVector; MA:fMatrix; htA, lenA:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaVF_mulM( fVector d_Y, fVector d_X, fMatrix d_MA, ui htA, ui lenA );
void VFcu_mulM( fVector h_Y, fVector h_X, fMatrix h_MA, ui htA, ui lenA );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaVF_mulM( d_Y, d_X:fVector; d_MA:fMatrix; htA, lenA:UIntSize ): IntBool;
procedure VFcu_mulM( h_Y, h_X:fVector; h_MA:fMatrix; htA, lenA:UIntSize );
|
|
Beschreibung | Y = X * MA;
Die Dimensionen von X und Y sind implizit durch die Matrix-Dimensionen gegeben: sizX = htA, sizY = lenA. |
|
|
MCF_mulM |
MCD_mulM |
MCE_mulM |
|
Funktion | Matrix-Multiplikation |
|
Syntax C/C++ | #include <MFstd.h>
void MF_mulM( fMatrix MC, fMatrix MA, fMatrix MB, ui htA, ui lenA, ui lenB ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::mulM( const matrix<T>& MA, const matrix<T>& MB ); |
Pascal/Delphi | uses MFstd;
procedure MF_mulM( MC, MA, MB:fMatrix; htA, lenA, lenB:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_mulM( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui htA, ui lenA, ui lenB );
void MFcu_mulM( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui htA, ui lenA, ui lenB );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_mulM( d_MC, d_MA, d_MB:fMatrix; htA, lenA, lenB:UIntSize ): IntBool;
procedure MFcu_mulM( h_MC, h_MA, h_MB:fMatrix; htA, lenA, lenB:UIntSize );
|
|
Beschreibung | MC = MA * MB
htA, lenA und lenB müssen spezifiziert werden; die übrigen Dimensionen sind implizit gegeben als: htB = lenA, lenC = lenB, htC = htA. |
|
|
MFdia_mulM
| MDdia_mulM |
MEdia_mulM |
MCFdia_mulM |
MCDdia_mulM |
MCEdia_mulM |
|
Funktion | Multiplikation einer Diagonalmatrix und einer allgemeinen Matrix |
|
Syntax C/C++ | #include <MFstd.h>
void MFdia_mulM( fMatrix MC, fVector MADia, fMatrix MB, ui lenA, ui lenB ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::dia_mulM( const vector<T>& MADia, const matrix<T>& MB ); |
Pascal/Delphi | uses MFstd;
procedure MFdia_mulM( MC:fMatrix; MADia: fVector; MB:fMatrix; lenA, lenB:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMFdia_mulM( fMatrix d_MC, fVector d_MADia, fMatrix d_MB, ui lenA, ui lenB );
void MFdiacu_mulM( fMatrix h_MC, fVector h_MADia, fMatrix h_MB, ui lenA, ui lenB );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMFdia_mulM( d_MC:fMatrix; d_MADia:fVector; d_MB:fMatrix; lenA, lenB:UIntSize ): IntBool;
procedure MFdiacu_mulM( h_MC:fMatrix; h_MADia:fVector; h_MB:fMatrix; lenA, lenB:UIntSize );
|
|
Beschreibung | MC = MADia * MB
Der Vektor MAdia vertritt die Diagonalmatrix MA. (Eine Matrix wird Diagonalmatrix genannt, wenn alle außer den Diagonal-Elementen gleich 0 sind). lenA und lenB müssen spezifiziert werden; htB ist gleich lenA. |
|
|
MF_mulMdia
| MD_mulMdia |
ME_mulMdia |
MCF_mulMdia |
MCD_mulMdia |
MCE_mulMdia |
|
Funktion | allgemeine Matrix mit Diagonalmatrix multiplizieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_mulMdia( fMatrix MC, fMatrix MA, fVector MBDia, ui htA, ui lenA ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::mulMdia( const matrix<T>& MA, const vector<T>& MBDia, ); |
Pascal/Delphi | uses MFstd;
procedure MF_mulMdia( MC, MA:fMatrix; MBDia:fVector; htA, lenA:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_mulMdia( fMatrix d_MC, fMatrix d_MA, fVector d_MBDia, ui htA, ui lenA );
void MFcu_mulMdia( fMatrix h_MC, fMatrix h_MA, fVector h_MBDia, ui htA, ui lenA );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_mulMdia( d_MC, d_MA:fMatrix; d_MBDia:fVector; htA, lenA:UIntSize ): IntBool;
procedure MFcu_mulMdia( h_MC, h_MA:fMatrix; h_MBDia:fVector; htA, lenA:UIntSize );
|
|
Beschreibung | MC = MA * MBDia.
htA und lenA müssen spezifiziert werden; sizB = lenA. |
|
|
MCF_mulMH |
MCD_mulMH |
MCE_mulMH |
|
Funktion | eine Matrix mit der Hermitesch-konjugierten Form einer anderen Matrix multiplizieren |
|
Syntax C/C++ | #include <MCFstd.h>
void MCF_mulMH( cfMatrix MC, cfMatrix MA, cfMatrix MB, ui htA, ui lenA, ui htB ); |
C++ MatObj | #include <OptiVec.h>
void matrix<complex<T> >::mulMH( const matrix<complex<T> >& MA, const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
procedure MCF_mulMH( MC, MA, MB:cfMatrix; htA, lenA, htB:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_mulMH( cfMatrix d_MC, cfMatrix d_MA, cfMatrix d_MB, ui htA, ui lenA, ui htB );
void MCFcu_mulMH( cfMatrix h_MC, cfMatrix h_MA, cfMatrix h_MB, ui htA, ui lenA, ui htB );
|
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_mulMH( d_MC, d_MA, d_MB:cfMatrix; htA, lenA, htB:UIntSize ): IntBool;
procedure MCFcu_mulMH( h_MC, h_MA, h_MB:cfMatrix; htA, lenA, htB:UIntSize );
|
|
Beschreibung | MC = MA * MBT *.
htA, lenA und htB müssen spezifiziert werden; die übrigen Dimensionen sind implizit gegeben als: lenB = lenA, lenC = htB, htC = htA. |
|
|
MF_mulMT
| MD_mulMT |
ME_mulMT |
MCF_mulMT |
MCD_mulMT |
MCE_mulMT |
|
Funktion | eine Matrix mit der Transponierten einer anderen Matrix multiplizieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_mulMT( fMatrix MC, fMatrix MA, fMatrix MB, ui htA, ui lenA, ui htB ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::mulMT( const matrix<T>& MA, const matrix<T>& MB ); |
Pascal/Delphi | uses MFstd;
procedure MF_mulMT( MC, MA, MB:fMatrix; htA, lenA, htB:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_mulMT( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui htA, ui lenA, ui htB );
void MFcu_mulMT( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui htA, ui lenA, ui htB );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_mulMT( d_MC, d_MA, d_MB:fMatrix; htA, lenA, htB:UIntSize ): IntBool;
procedure MFcu_mulMT( h_MC, h_MA, h_MB:fMatrix; htA, lenA, htB:UIntSize );
|
|
Beschreibung | MC = MA * MBT.
htA, lenA und htB müssen spezifiziert werden; die übrigen Dimensionen sind implizit gegeben als: lenB = lenA, lenC = htB, htC = htA. |
|
|
MFdia_mulMT
| MDdia_mulMT |
MEdia_mulMT |
MCFdia_mulMT |
MCDdia_mulMT |
MCEdia_mulMT |
|
Funktion | Diagonalmatrix mit der Transponierten einer allgemeinen Matrix multiplizieren |
|
Syntax C/C++ | #include <MFstd.h>
void MFdia_mulMT( fMatrix MC, fVector MADia, fMatrix MB, ui htB, ui lenB ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::dia_mulMT( const vector<T>& MADia, const matrix<T>& MB ); |
Pascal/Delphi | uses MFstd;
procedure MFdia_mulMT( MC:fMatrix; MADia: fVector; MB:fMatrix; htB, lenB:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMFdia_mulMT( fMatrix d_MC, fVector d_MADia, fMatrix d_MB, ui htB, ui lenB );
void MFdiacu_mulMT( fMatrix h_MC, fVector h_MADia, fMatrix h_MB, ui htB, ui lenB );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMFdia_mulMT( d_MC:fMatrix; d_MADia:fVector; d_MB:fMatrix; htB, lenB:UIntSize ): IntBool;
procedure MFdiacu_mulMT( h_MC:fMatrix; h_MADia:fVector; h_MB:fMatrix; htB, lenB:UIntSize );
|
|
Beschreibung | MC = MADia * MBT
htB und lenB müssen spezifiziert werden; sizA = lenB. |
|
|
VF_mulMT
| VD_mulMT |
VE_mulMT |
|
Funktion | Zeilen-Vektor mit der Transponierten einer Matrix multiplizieren |
|
Syntax C/C++ | #include <MFstd.h>
void VF_mulMT( fVector Y, fVector X, fMatrix MA, ui htA, ui lenA ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::mulMT( const vector<T>& X, const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure VF_mulMT( Y, X:fVector; MA:fMatrix; htA, lenA:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaVF_mulMT( fVector d_Y, fVector d_X, fMatrix d_MA, ui htA, ui lenA );
void VFcu_mulMT( fVector h_Y, fVector h_X, fMatrix h_MA, ui htA, ui lenA );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaVF_mulMT( d_Y, d_X:fVector; d_MA:fMatrix; htA, lenA:UIntSize ): IntBool;
procedure VFcu_mulMT( h_Y, h_X:fVector; h_MA:fMatrix; htA, lenA:UIntSize );
|
|
Beschreibung | Y = X * MAT
The Dimensionen htA und lenA beziehen sich auf die originale Matrix A (nicht auf deren Transponierte); die Dimensionen von X und Y sind implizit gegeben durch die Matrix-Dimensionen: sizX = lenA, sizY = htA. |
|
|
VF_multiLinfit
| VD_multiLinfit |
VE_multiLinfit |
VF_multiLinfitwW |
VD_multiLinfitwW |
VE_multiLinfitwW |
|
Funktion | aus mehreren X-Y-Datensätzen gleichzeitig die Parameter einer gemeinsamen linearen Modell-Funktion bestimmen |
|
Syntax C/C++ | #include <MFstd.h>
int VF_multiLinfit( fVector A, iVector AStatus, unsigned npars, VF_EXPERIMENT *ListOfExperiments, unsigned nexperiments,
void (*funcs)(fVector BasFuncs, float x,unsigned nfuncs, unsigned iexperiment) );
int VF_multiLinfitwW( fVector A, fMatrix Covar, iVector AStatus, unsigned npars, VF_EXPERIMENT *ListOfExperiments, unsigned nexperiments,
void (*funcs)(fVector BasFuncs, float x, unsigned nfuncs, unsigned iexperiment) );
int VF_multiLinfitwEdit( fVector A, iVector AStatus, unsigned npars, VF_EXPERIMENT *ListOfExperiments, unsigned nexperiments, float thresh,
void (*funcs)(fVector BasFuncs, float x,unsigned nfuncs, unsigned iexperiment) );
int VF_multiLinfitwWwEdit( fVector A, fMatrix Covar, iVector AStatus, unsigned npars, VF_EXPERIMENT *ListOfExperiments, unsigned nexperiments, float thresh,
void (*funcs)(fVector BasFuncs, float x, unsigned nfuncs, unsigned iexperiment) ); |
Pascal/Delphi | uses MFstd;
function VF_multiLinfit( A:fVector; AStatus:iVector; nParameters:UInt; ListOfExperiments: PVF_EXPERIMENT; nexperiments:UInt; funcs: Pointer ): IntBool;
function VF_multiLinfitwW( A:fVector; Covar:fMatrix; AStatus:iVector; nParameters:UInt; ListOfExperiments:PVF_EXPERIMENT; nexperiments:UInt; funcs:Pointer ): IntBool;
function VF_multiLinfitwEdit( A:fVector; AStatus:iVector; nParameters:UInt; ListOfExperiments: PVF_EXPERIMENT; nexperiments:UInt; thresh:Single; funcs: Pointer ): IntBool;
function VF_multiLinfitwWwEdit( A:fVector; Covar:fMatrix; AStatus:iVector; nParameters:UInt; ListOfExperiments:PVF_EXPERIMENT; nexperiments:UInt; thresh:Single; funcs:Pointer ): IntBool; |
|
Beschreibung | Die in ListOfExperiments enthaltenen Eingabe-Daten werden benutzt, um die Parameter ai einer allgemeinen linearen Funktion
y = a0f0(x) + a1f1(x) + a2f2(x)...
zu bestimmen. Die Parameter ai werden in dem Vektor A zurückgegeben.
Argumente:
A | Vektor der Länge npars; gibt die berechneten Koeffizienten zurück |
Covar | Matrix der Dimensionen [npars, npars]; gibt die Kovarianzen der Koeffizenten zurück. Falls die Kovarianzen nicht benötigt werden, rufe man die Funktion mit Covar = (fMatrix)NULL / nil. |
AStatus | Vektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind |
npars | Gesamtzahl der Parameter |
ListOfExperiments | Eingabedaten, siehe Kap. 13.4 |
nexperiments | Anzahl der Datensätze in ListOfExperiments |
modelfunc | Benutzer-definierte Modell-Funktion |
Die Modell-Funktion (und damit der Parameter-Vektor) kann mehr Parameter enthalten als tatsächlich angepaßt werden sollen. Daher muss ein zusätzlicher Vektor AStatus die Information darüber enthalten, welche Parameter bei ihren Eingabe-Werten eingefroren bleiben sollen (AStatus[i] = 0) und welche anzupassen sind (AStatus[i] = 1). Alle eingefrorenen Parameter müssen in A vor dem Aufruf von VF_multiLinfit initialisiert sein. npars bezeichnet die Gesamtzahl der Parameter in A (also nicht nur die freien Parameter!).
Die Eingabe-Daten müssen in Sätzen des Typs VF_EXPERIMENT zusammengefaßt werden. Angenommen, man habe zwei X-Y-Datensätze, bestehend aus den Vektoren X1, Y1 (für VF_multiLinfitwW auch InvVar1) von je size1 Elementen, und X2, Y2 (und InvVar2) von je size2 Elementen. Hieraus hat man die Experimenten-Liste zusammenzustellen wie im folgenden Beispiel:
| Experimenten-Liste in C/C++ konstruieren |
VF_EXPERIMENT ExpList[2];
ExpList[0].X = X1; ExpList[0].Y = Y1; ExpList[0].size = size1;
ExpList[1].X = X2; ExpList[1].Y = Y2; ExpList[1].size = size2;
/* für die Variante mit Einzelpunkt-Wichtung außerdem: */
ExpList[0].InvVar = InvVar1; ExpList[0].WeightOfExperiment = wt1;
ExpList[1].InvVar = InvVar2; ExpList[1].WeightOfExperiment = wt2;
| Experimenten-Liste in Pascal/Delphi konstruieren |
var ExpList: array[0..1] of VF_EXPERIMENT;
begin
...
ExpList[0].X := X1; ExpList[0].Y := Y1;
ExpList[0].size := size1;
ExpList[1].X := X2; ExpList[1].Y := Y2;
ExpList[1].size := size2;
(* für die Variante mit Einzelpunkt-Wichtung außerdem: *)
ExpList[0].InvVar := InvVar1;
ExpList[0].WeightOfExperiment := wt1;
ExpList[1].InvVar := InvVar2;
ExpList[1].WeightOfExperiment := wt2;
...
end;
| Sowohl C/C++ als auch Pascal/Delphi |
Die Modell-Funktion "funcs" ist vom Anwender zu schreiben. Für jedes Argument x hat sie die einzelnen fi(x) zu berechnen und in dem Vektor BasFuncs zu speichern.
In C/C++ muss sie als
| Modell-Funktion für C/C++ |
void MyFunc( fVector BasFuncs, float x, unsigned nfuncs, unsigned iexperiment )
{
BasFuncs[0] = f0( x );
BasFuncs[1] = f1( x);
...
}
geschrieben und an VF_multiLinfit durch Aufruf von
VF_multiLinfit( A, AStatus, npars, ExpList, 2, MyFunc );
übergeben werden.
| Modell-Funktion für Pascal/Delphi |
procedure MyFunc( BasFuncs:fVector; x:Single; nfuncs, iexperiment:UInt );
begin
VF_Pelement( BasFuncs, 0 )^ := f0( x );
VF_Pelement( BasFuncs, 1 )^ := f1( x );
...
end;
Diese Modell-Funktion muss an VF_multiLinfit durch Aufruf von
VF_multiLinfit( A, AStatus, npars, @ExpList, 2, @MyFunc );
übergeben werden. Man beachte die Adress-Operatoren vor "ExpList" (statischer Pascal-Array, der an OptiVec-Funktion übergeben wird) und "MyFunc" (Zeiger auf die Funktion MyFunc). In Turbo Pascal muss die Modellfunktion mit der Option "Force Far Calls" {$F+} compiliert werden.
| Sowohl C/C++ als auch Pascal/Delphi |
Das Argument iexperiment, mit dem MyFunc intern von VF_multiLinfit aus aufgerufen werden wird, erlaubt die Unterscheidung zwischen Parametern, die allen Experimenten gemeinsam sind, und solchen, die individuell zu den einzelnen Experimenten gehören. Z.B. könnten die Y-Werte um einen für jedes Experiment verschiedenen Wert C verschoben sein. In diesem Falle muss A so viele Verschiebungen enthalten, wie es Experimente gibt. In MyFunc hätte man dies in der folgenden Weise zu berücksichtigen (Beispiel in C/C++; die Übersetzung in Pascal/Delphi dürfte leicht sein):
if( iexperiment == 0 ) { BasFuncs[2] = 1; BasFuncs[3] = 0; }
else {BasFuncs[2] = 0; BasFuncs[3] = 1; }
Die Funktionen f0( x ) etc. dürfen die Parameter ai selbst nicht enthalten.
In der gewichteten Variante VF_multiLinfitwW muss der Vektor ExpList[i].InvVar jedes Experimentes den Kehrwert der Varianzen der einzelnen X-Y -Datenpunkte enthalten, und die Matrix MCovar gibt die Kovarianzen der Parameter ai zurück: MCovari,j = covariance( ai, aj ).
Intern verwendet VF_multiLinfit einen auf Singulärwert-Zerlegung (SVD) basierenden Algorithmus, um eine Lösung auch für (nahezu) singuläre Gleichungssysteme zu erhalten. Dabei werden Koeffizienten ai, deren Signifikanz unter einer gewissen Schwelle liegt, gleich 0 anstatt Unendlich gesetzt. Die hierfür standardmäßig voreingestellte Schwelle kann mittels VF_setLinfitNeglect verändert werden. VF_getLinfitNeglect liest die derzeit eingestellte Schwelle. Da VF_setLinfitNeglect nicht fiber-sicher ist, sollte diese Funktion nicht verwendet werden, um verschiedene Schwellenwerte für verschiedene Aufrufe von VF_multiLinfit usw. einzustellen. Anstatt wiederholt den Standard-Wert zu ändern, gebrauche man vielmehr die "wEdit"-Varianten von VF_multiLinfit usw., also VF_multiLinfitwEdit, VF_multiLinfitwWwEdit usw.
In dem sehr seltenen Fall, dass diese Funktion keine Lösung finden kann, gibt sie 1 (TRUE) zurück und setzt alle A[i] = 0. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (!= 0). |
|
|
MF_multiLinfit
| MD_multiLinfit |
ME_multiLinfit |
MF_multiLinfitwW |
MD_multiLinfitwW |
ME_multiLinfitwW |
|
Funktion | aus mehreren X-Y-Z-Datensätzen gleichzeitig die Parameter einer gemeinsamen linearen Modell-Funktion bestimmen |
|
Syntax C/C++ | #include <MFstd.h>
int MF_multiLinfit( fVector A, iVector AStatus, unsigned npars, MF_EXPERIMENT *ListOfExperiments, unsigned nexperiments,
void (*funcs)(fVector BasFuncs, float x, float y, unsigned nfuncs, unsigned iexperiment) );
int MF_multiLinfitwW( fVector A, fMatrix Covar, iVector AStatus, unsigned npars, MF_EXPERIMENT *ListOfExperiments, unsigned nexperiments,
void (*funcs)(fVector BasFuncs, float x, float y, unsigned nfuncs, unsigned iexperiment) );
int MF_multiLinfitwEdit( fVector A, iVector AStatus, unsigned npars, MF_EXPERIMENT *ListOfExperiments, unsigned nexperiments, float thresh,
void (*funcs)(fVector BasFuncs, float x, float y, unsigned nfuncs, unsigned iexperiment) );
int MF_multiLinfitwWwEdit( fVector A, fMatrix Covar, iVector AStatus, unsigned npars, MF_EXPERIMENT *ListOfExperiments, unsigned nexperiments, float thresh,
void (*funcs)(fVector BasFuncs, float x, float y, unsigned nfuncs, unsigned iexperiment) ); |
Pascal/Delphi | uses MFstd;
function MF_multiLinfit( A:fVector; AStatus:iVector; nParameters:UInt; ListOfExperiments: PMF_EXPERIMENT; nexperiments:UInt; funcs: Pointer ): IntBool;
function MF_multiLinfitwW( A:fVector; Covar:fMatrix; AStatus:iVector; nParameters:UInt; ListOfExperiments: PMF_EXPERIMENT; nexperiments:UInt; funcs: Pointer ): IntBool;
function MF_multiLinfitwEdit( A:fVector; AStatus:iVector; nParameters:UInt; ListOfExperiments: PMF_EXPERIMENT; nexperiments:UInt; thresh:Single; funcs: Pointer ): IntBool;
function MF_multiLinfitwWwEdit( A:fVector; Covar:fMatrix; AStatus:iVector; nParameters:UInt; ListOfExperiments: PMF_EXPERIMENT; nexperiments:UInt; thresh:Single; funcs: Pointer ): IntBool; |
|
Beschreibung | Die in ListOfExperiments enthaltenen Eingabe-Daten werden benutzt, um die Parameter ai einer allgemeinen linearen Funktion
z = a0f0(x,y) + a1f1(x,y) + a2f2(x,y)...
zu bestimmen. Die Parameter ai werden in dem Vektor A zurückgegeben.
Argumente:
A | Vektor der Länge npars; gibt die berechneten Koeffizienten zurück |
Covar | Matrix der Dimensionen [npars, npars]; gibt die Kovarianzen der Koeffizenten zurück. Falls die Kovarianzen nicht benötigt werden, rufe man die Funktion mit Covar = (fMatrix)NULL / nil. |
AStatus | Vektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind |
npars | Gesamtzahl der Parameter |
ListOfExperiments | Eingabedaten, siehe Kap. 13.4 |
nexperiments | Anzahl der Datensätze in ListOfExperiments |
modelfunc | Benutzer-definierte Modell-Funktion |
Die Modell-Funktion (und damit der Parameter-Vektor) kann mehr Parameter enthalten als tatsächlich angepaßt werden sollen. Daher muss ein zusätzlicher Vektor AStatus die Information darüber enthalten, welche Parameter bei ihren Eingabe-Werten eingefroren bleiben sollen (AStatus[i] = 0) und welche anzupassen sind (AStatus[i] = 1). Alle eingefrorenen Parameter müssen in A vor dem Aufruf von MF_multiLinfit initialisiert sein. npars bezeichnet die Gesamtzahl der Parameter in A (also nicht nur die freien Parameter!).
Die Eingabe-Daten müssen in Sätzen des Typs MF_EXPERIMENT
zusammengefaßt werden. Angenommen, man habe zwei Sätze von X-Y-Z-Daten, deren jeder aus den Vektoren X und Y für die unabhängigen Variablen, der Matrix Z für die z=f(x,y)-Werte und, für MF_multiLinfitwW, den Einzelpunkt-Wichtungen in MInvVar besteht. Die Matrix-Dimensionen seinen htZ (= sizeY) und lenZ (= sizeX). Man hat dann eine Experimenten-Liste zu konstruieren wie in dem folgenden Beispiel:
| Experimenten-Liste in C/C++ konstruieren |
MF_EXPERIMENT ExpList[2];
ExpList[0].X = X1; ExpList[0].Y = Y1;
ExpList[0].MZ = MZ1;
ExpList[0].htZ = htZ1; ExpList[0].lenZ = lenZ1;
ExpList[1].X = X1; ExpList[1].Y = Y2;
ExpList[1].MZ = MZ2;
ExpList[1].htZ = htZ2; ExpList[1].lenZ = lenZ2;
/* für die Variante mit Einzelpunkt-Wichtung außerdem: */
ExpList[0].MInvVar = MInvVar1;
ExpList[0].WeightOfExperiment = wt1;
ExpList[1].MInvVar = MInvVar2;
ExpList[1].WeightOfExperiment = wt2;
| Experimenten-Liste in Pascal/Delphi konstruieren |
var ExpList: array[0..1] of MF_EXPERIMENT;
begin
...
ExpList[0].X := X1; ExpList[0].Y := Y1;
ExpList[0].MZ := MZ1;
ExpList[0].htZ := htZ1; ExpList[0].lenZ := lenZ1;
ExpList[1].X := X2; ExpList[1].Y := Y2;
ExpList[1].MZ := MZ2;
ExpList[1].htZ := htZ2; ExpList[1].lenZ := lenZ2;
(* für die Variante mit Einzelpunkt-Wichtung außerdem: *)
ExpList[0].MInvVar := MInvVar1;
ExpList[0].WeightOfExperiment := wt1;
ExpList[1].MInvVar := MInvVar2;
ExpList[1].WeightOfExperiment := wt2;
...
end;
| Sowohl C/C++ als auch Pascal/Delphi |
Die Modell-Funktion "funcs" ist vom Anwender zu schreiben. Für jedes Argumenten-Paar x, y hat sie die einzelnen fi(x, y) zu berechnen und in dem Vektor BasFuncs zu speichern.
In C/C++ muss sie als
| Modell-Funktion für C/C++ |
void MyFunc( fVector BasFuncs, float x, float y, unsigned nfuncs, unsigned iexperiment )
{
BasFuncs[0] = f0( x, y );
BasFuncs[1] = f1( x, y );
...
}
geschrieben und an MF_multiLinfit durch Aufruf von
MF_multiLinfit( A, AStatus, npars, ExpList, 2, MyFunc );
übergeben werden.
| Modell-Funktion für Pascal/Delphi |
procedure MyFunc( BasFuncs:fVector; x, y:Single; nfuncs, iexperiment:UInt );
begin
VF_Pelement( BasFuncs, 0 )^ := f0( x, y );
VF_Pelement( BasFuncs, 1 )^ := f1( x, y );
...
end;
Diese Modell-Funktion muss an MF_multiLinfit durch Aufruf von
MF_multiLinfit( A, AStatus, npars, @ExpList, 2, @MyFunc );
übergeben werden. Man beachte die Adress-Operatoren vor "ExpList" (statischer Pascal-Array, der an OptiVec-Funktion übergeben wird) und "MyFunc." (Zeiger auf die Funktion MyFunc). In Turbo Pascal muss die Modellfunktion mit der Option "Force Far Calls" {$F+} compiliert werden.
| Sowohl C/C++ als auch Pascal/Delphi |
Das Argument iexperiment, mit dem MyFunc intern von MF_multiLinfit aus aufgerufen werden wird, erlaubt die Unterscheidung zwischen Parametern, die allen Experimenten gemeinsam sind, und solchen, die individuell zu den einzelnen Experimenten gehören. Z.B. könnten die MZ-Werte um einen für jedes Experiment verschiedenen Wert C verschoben sein. In diesem Falle muss A so viele Verschiebungen enthalten, wie es Experimente gibt. In MyFunc hätte man dies in der folgenden Weise zu berücksichtigen (Beispiel in C/C++; die Übersetzung in Pascal/Delphi dürfte leicht sein):
if( iexperiment == 0 ) { BasFuncs[2] = 1; BasFuncs[3] = 0; }
else {BasFuncs[2] = 0; BasFuncs[3] = 1; }
Die Funktionen f0( x, y ) etc. dürfen die Parameter ai selbst nicht enthalten.
In der gewichteten Variante MF_multiLinfitwW muss die Matrix ExpList[i].MInvVar jedes Experimentes den Kehrwert der Varianzen der einzelnen X-Y-Z-Datenpunkte enthalten, und die Matrix MCovar gibt die Kovarianzen der Parameter ai zurück: MCovari,j = covariance( ai, aj ).
Intern verwendet MF_multiLinfit einen auf Singulärwert-Zerlegung (SVD) basierenden Algorithmus, um eine Lösung auch für (nahezu) singuläre Gleichungssysteme zu erhalten. Dabei werden Koeffizienten ai, deren Signifikanz unter einer gewissen Schwelle liegt, gleich 0 anstatt Unendlich gesetzt. Die hierfür standardmäßig voreingestellte Schwelle kann mittels VF_setLinfitNeglect verändert werden. VF_getLinfitNeglect liest die derzeit eingestellte Schwelle. Da VF_setLinfitNeglect nicht fiber-sicher ist, sollte diese Funktion nicht verwendet werden, um verschiedene Schwellenwerte für verschiedene Aufrufe von VF / MF_multiLinfit usw. einzustellen. Anstatt wiederholt den Standard-Wert zu ändern, gebrauche man vielmehr die "wEdit"-Varianten von VF / MF_multiLinfit usw., also MF_multiLinfitwEdit, MF_multiLinfitwWwEdit usw.
In dem sehr seltenen Fall, dass diese Funktion keine Lösung finden kann, gibt sie 1 (TRUE) zurück und setzt alle A[i] = 0. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (!= 0). |
|
|
VF_multiNonlinfit
| VD_multiNonlinfit |
VE_multiNonlinfit |
VF_multiNonlinfitwW |
VD_multiNonlinfitwW |
VE_multiNonlinfitwW |
|
Funktion | aus mehreren X-Y-Datensätzen gleichzeitig die Parameter einer gemeinsamen nicht-linearen Modell-Funktion anpassen |
|
Syntax C/C++ | #include <MFstd.h>
float VF_multiNonlinfit( fVector A, iVector AStatus, unsigned npars,
VF_EXPERIMENT *ListOfExperiments, unsigned nexperiments,
void (*modelfunc)(fVector YModel, fVector XModel, ui size, unsigned iexperiment, fVector A),
void (*derivatives)(fVector dYdAi,fVector X, ui size, unsigned ipar, unsigned iexperiment, fVector A, VF_NONLINFITWORKSPACE *ws),
VF_NONLINFITOPTIONS *FitOpts,
VF_NONLINFITWORKSPACE *WorkSpace );
float VF_multiNonlinfitwW( fVector A, fMatrix Covar, iVector AStatus, unsigned npars,
VF_EXPERIMENT *ListOfExperiments, unsigned nexperiments,
void (*modelfunc)(fVector YModel, fVector X, ui size, unsigned iexperiment, fVector A),
void (*derivatives)(fVector dYdAi, fVector X, ui size, unsigned ipar, unsigned iexperiment, fVector A, VF_NONLINFITWORKSPACE *ws),
VF_NONLINFITOPTIONS *FitOpts,
VF_NONLINFITWORKSPACE *WorkSpace ); |
Syntax C/C++ simplified | #include <MFstd.h>
float VF_multiNonlinfit( fVector A, iVector AStatus, unsigned npars,
VF_EXPERIMENT *ListOfExperiments, unsigned nexperiments,
void (*modelfunc)(fVector YModel, fVector XModel, ui size, unsigned iexperiment, fVector A),
void (*derivatives)(fVector dYdAi,fVector X, ui size, unsigned ipar, unsigned iexperiment, fVector A, VF_NONLINFITWORKSPACE *ws) );
float VF_multiNonlinfitwW( fVector A, fMatrix Covar, iVector AStatus, unsigned npars,
VF_EXPERIMENT *ListOfExperiments, unsigned nexperiments,
void (*modelfunc)(fVector YModel, fVector X, ui size, unsigned iexperiment, fVector A),
void (*derivatives)(fVector dYdAi, fVector X, ui size, unsigned ipar, unsigned iexperiment, fVector A, VF_NONLINFITWORKSPACE *ws) ); |
Pascal/Delphi | uses VFmnlfit;
function VF_multiNonlinfit( A: fVector; AStatus: iVector; nParameters: UInt;
ListOfExperiments: PVF_EXPERIMENT; nexperiments: UInt;
ModelFunc, Derivatives: Pointer;
FitOpts: PVF_NONLINFITOPTIONS; WorkSpace: PMF_NONLINFITWORKSPACE ): Single;
function VF_multiNonlinfitwW( A: fVector; Covar: fMatrix; AStatus: iVector; nParameters: UInt;
ListOfExperiments: PVF_EXPERIMENT; nexperiments: UInt;
ModelFunc, Derivatives: Pointer;
FitOpts: PVF_NONLINFITOPTIONS; WorkSpace: PMF_NONLINFITWORKSPACE ): Single;
Syntax der als Parameter übergebenen Funktionen ModelFunc und Derivatives:
procedure ModelFunc( YModel, X:fVector; size:UIntSize; iexperiment:UInt; A:fVector );
procedure Derivatives( dYdAi, X:fVector; size:UIntSize; ipar, iexperiment:UInt; A:fVector; ws:PVF_NONLINFITWORKSPACE );
|
Pascal/Delphi simplified | uses VFmnlfit;
function VF_multiNonlinfit( A: fVector; AStatus: iVector; nParameters: UInt;
ListOfExperiments: PVF_EXPERIMENT; nexperiments: UInt;
ModelFunc, Derivatives: Pointer ): Single;
function VF_multiNonlinfitwW( A: fVector; Covar: fMatrix; AStatus: iVector; nParameters: UInt;
ListOfExperiments: PVF_EXPERIMENT; nexperiments: UInt;
ModelFunc, Derivatives: Pointer ): Single; |
|
Beschreibung | Die in ListOfExperiments enthaltenen Eingabe-Daten werden benutzt, um die Parameter ai einer allgemeinen nicht-linearen Modell-Funktion y = f(x) zu bestimmen.
Argumente:
A | Vektor der Länge npars; gibt die berechneten Koeffizienten zurück |
Covar | Matrix der Dimensionen [npars, npars]; gibt die Kovarianzen der Koeffizenten zurück |
AStatus | Vektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind |
npars | Gesamtzahl der Parameter |
ListOfExperiments | Eingabedaten, siehe Kap. 13.4 |
nexperiments | Anzahl der Datensätze in ListOfExperiments |
modelfunc | Benutzer-definierte Modell-Funktion |
derivatives | Benutzer-definierte Funktion, die die partiellen Ableitungen der Modellfunktion nach den einzelnen Parametern berechnet. Durch Setzen dieses Arguments auf NULL / nil wird der Routine signalisiert, die partiellen Ableitungen numerisch zu bestimmen. |
FitOpts | Zeiger auf eine Struktur mit Fit-Optionen, siehe chap. 13.3 |
WorkSpace | Zeiger auf eine Struktur mit internen Variablen, siehe chap. 13.3 |
FitOpts und WorkSpace dürfen auf NULL / nil gesetzt werden. In der Variante mit vereinfachter Syntax gibt es diese beiden Argumente gar nicht erst.
Die Parameter ai werden in dem Vektor A zurückgegeben. Die Modell-Funktion (und damit der Parameter-Vektor) kann mehr Parameter enthalten als tatsächlich angepaßt werden sollen. Daher muss ein zusätzlicher Vektor AStatus die Information darüber enthalten, welche Parameter bei ihren Eingabe-Werten eingefroren bleiben sollen (AStatus[i] = 0) und welche anzupassen sind (AStatus[i] = 1). Alle Parameter (nicht nur die eingefrorenen!) müssen in A vor dem Aufruf von VF_multiNonlinfit initialisiert sein. Je besser Sie diese Startwerte "raten", umso schneller wird die Routine konvergieren. npars bezeichnet die Gesamtzahl der Parameter in A (also nicht nur die freien Parameter!).
Die Eingabe-Daten müssen in Sätzen des Typs VF_EXPERIMENT zusammengefaßt werden. Angenommen, man habe zwei X-Y-Datensätze, bestehend aus den Vektoren X1, Y1 (für VF_multiLinfitwW auch InvVar1) von je size1 Elementen, und X2, Y2 (und InvVar2) von je size2 Elementen. Hieraus hat man die Experimenten-Liste zusammenzustellen wie im folgenden Beispiel:
| Experimenten-Liste in C/C++ konstruieren |
VF_EXPERIMENT ExpList[2];
ExpList[0].X = X1; ExpList[0].Y = Y1; ExpList[0].size = size1;
ExpList[1].X = X2; ExpList[1].Y = Y2; ExpList[1].size = size2;
/* für die Variante mit Einzelpunkt-Wichtung außerdem: */
ExpList[0].InvVar = InvVar1; ExpList[0].WeightOfExperiment = wt1;
ExpList[1].InvVar = InvVar2; ExpList[1].WeightOfExperiment = wt2;
| Experimenten-Liste in Pascal/Delphi konstruieren |
var ExpList: array[0..1] of VF_EXPERIMENT;
begin
...
ExpList[0].X := X1; ExpList[0].Y := Y1;
ExpList[0].size := size1;
ExpList[1].X := X2; ExpList[1].Y := Y2;
ExpList[1].size := size2;
(* für die Variante mit Einzelpunkt-Wichtung außerdem: *)
ExpList[0].InvVar := InvVar1;
ExpList[0].WeightOfExperiment := wt1;
ExpList[1].InvVar := InvVar2;
ExpList[1].WeightOfExperiment := wt2;
...
end;
| Sowohl C/C++ als auch Pascal/Delphi |
Die Modell-Funktion "funcs" ist vom Anwender zu schreiben. Sie hat für einen gegebenen X-Vektor die entsprechenden Y-Werte zu berechnen.
In C/C++ muss sie wie folgt geschrieben werden:
| Modell-Funktion für C/C++ |
void _cdecl MyFunc( fVector Y, fVector X, ui size, unsigned iexperiment, fVector A )
{
for(ui i=0; i<size; i++ )
Y[i] = f( X[i] );
}
Dabei ist f( X[i] ) eine beliebige Funktion, die so kompliziert sein darf, wie es Ihre Anwendung erfordert. Sie darf aber keine Singularitäten besitzen, zumindest innerhalb der ggf. spezifizierten Unter- und Obergrenzen der Parameter (siehe NONLINFITOPTIONS).
Das Argument iexperiment, mit dem MyFunc intern von VF_multiNonlinfit aus aufgerufen werden wird, erlaubt die Unterscheidung zwischen Parametern, die allen Experimenten gemeinsam sind, und solchen, die individuell zu den einzelnen Experimenten gehören. Z.B. könnten die Y-Werte mit einen für jedes Experiment verschiedenen Wert C skaliert sein. In diesem Falle muss A so viele Skalierungs-Faktoren enthalten, wie es Experimente gibt. In MyFunc hätte man dies in der folgenden Weise zu berücksichtigen:
if( iexperiment == 0 ) Y[i] *= A[5]; else Y[i] *= A[6];
Zusätzlich zu der Modell-Funktion benötigt VF_multiNonlinfit die partiellen Ableitungen von Y nach allen Parametern A[ipar] entsprechend dem gewählten Modell. Falls sie zumindest zum Teil analytisch bekannt sind, solte man eine Funktion MyDerivs schreiben. Dabei können diejenigen partiellen Ableitungen, die man doch nicht kennt, durch Aufruf von VF_multiNonlinfit_autoDeriv numerisch berechnet werden.
| Partielle Ableitungen für C/C++ |
void _cdecl MyDerivs( fVector dYdAi, fVector X, ui size, unsigned ipar, unsigned iexperiment, fVector A, VF_NONLINFITWORKSPACE *ws )
{
ui i;
switch( ipar )
{
case 0: for(i=0; i<size; i++ )
dYdAi[i] = part_derv_of_Y_w_resp_zu_A0( X[i] );
break;
case 1: for(i=0; i<size; i++ )
dYdAi[i] = part_derv_of_Y_w_resp_zu_A1( X[i] );
break;
default: /* für alle unbekannten Ableitungen: */
VF_multiNonlinfit_autoDeriv(
dYdAi, X, size, ipar, iexperiment, A, ws );
}
}
Wiederum erlaubt es das Argument iexperiment, die für die einzelnen Experimente individuellen Parameter anders als die allen Experimenten gemeinsamen zu behandeln.
Ein Aufruf von VF_multiNonlinfit wird dann etwa so aussehen:
VF_multiNonlinfit( A, AStatus, npars, ExpList, 2, MyFunc, MyDerivs, &FitOpts, &WorkSpace );
oder vereinfacht
VF_multiNonlinfit( A, AStatus, npars, ExpList, 2, MyFunc, MyDerivs );
Falls überhaupt keine der partiellen Ableitungen analytisch bekannt sind, definiere man auch MyDerivs nicht, sondern setze derivatives = NULL im Aufruf von VF_multiNonlinfit:
VF_multiNonlinfit( A, AStatus, npars, ExpList, 2, MyFunc, NULL );
| Modell-Funktion für Pascal/Delphi |
In Pascal/Delphi muss die Modell-Funktion wie folgt geschrieben werden:
procedure MyFunc( Y, X:fVector; size:UIntSize; iexperiment:UInt; A:fVector );
var i:UIntSize;
begin
for i:=0 to size-1 do
VF_Pelement( Y, i )^ := f( VF_element( X, i ) );
end;
Dabei ist f( Xi ) eine beliebige Funktion, die so kompliziert sein darf, wie es Ihre Anwendung erfordert. Sie darf aber keine Singularitäten besitzen, zumindest innerhalb der ggf. spezifizierten Unter- und Obergrenzen der Parameter (siehe NONLINFITOPTIONS).
Das Argument iexperiment, mit dem MyFunc intern von VF_multiNonlinfit aus aufgerufen werden wird, erlaubt die Unterscheidung zwischen Parametern, die allen Experimenten gemeinsam sind, und solchen, die individuell zu den einzelnen Experimenten gehören. Z.B. könnten die Y-Werte mit einen für jedes Experiment verschiedenen Wert C skaliert sein. In diesem Falle muss A so viele Skalierungs-Faktoren enthalten, wie es Experimente gibt. In MyFunc hätte man dies in der folgenden Weise zu berücksichtigen:
if iexperiment = 0 then
VF_Pelement(Y,i)^ := VF_element(Y,i) * VF_element(A,5)
else VF_Pelement(Y,i)^ := VF_element(Y,i) * VF_element(A,6);
Zusätzlich zu der Modell-Funktion benötigt VF_multiNonlinfit die partiellen Ableitungen von Y nach allen Parametern A[ipar] entsprechend dem gewählten Modell. Falls sie zumindest zum Teil analytisch bekannt sind, solte man eine Funktion MyDerivs schreiben. Dabei können diejenigen partiellen Ableitungen, die man doch nicht kennt, durch Aufruf von VF_multiNonlinfit_autoDeriv numerisch berechnet werden.
| Partielle Ableitungen für Pascal/Delphi |
procedure MyDerivs( dYdAi, X:fVector; size:UIntSize; ipar, iexperiment:UInt; A:fVector; ws:PVF_NONLINFITWORKSPACE );
var i:UIntSize;
begin
case ipar of
0: begin
for i:=0 to size-1 do
VF_Pelement( dYdAi, i )^ := part_derv_of_Y_w_resp_zu_A0(VF_element( X, i )); end;
1: begin
for i:=0 to size-1 do
VF_Pelement( dYdAi, i )^ := part_derv_of_Y_w_resp_zu_A0(VF_element( X, i )); end;
else (* für alle unbekannten Ableitungen: *)
VF_multiNonlinfit_autoDeriv(
dYdAi, X, size:UIntSize; ipar, iexperiment, A, ws );
end;
end;
Wiederum erlaubt es das Argument iexperiment, die für die einzelnen Experimente individuellen Parameter anders als die allen Experimenten gemeinsamen zu behandeln.
Ein Aufruf von VF_multiNonlinfit wird dann etwa so aussehen:
VF_multiNonlinfit( A, AStatus, npars, @ExpList, 2, @MyFunc, @MyDerivs, @FitOpts, @WorkSpace );
oder vereinfacht
VF_multiNonlinfit( A, AStatus, npars, @ExpList, 2, @MyFunc, @MyDerivs );
Man beachte die Adress-Operatoren vor "ExpList", "MyFunc " und "MyDerivs".
Falls überhaupt keine der partiellen Ableitungen analytisch bekannt sind, definiere man auch MyDerivs nicht, sondern setze derivatives := nil im Aufruf von VF_multiNonlinfit:
VF_multiNonlinfit( A, AStatus, npars, @ExpList, 2, @MyFunc, nil );
In der gewichteten Variante VF_multiNonlinfitwW muss der Vektor ExpList[i].InvVar für jedes Experiment den Kehrwert der Varianzen der einzelnen X-Y -Datenpunkte enthalten, und die Matrix MCovar gibt die Kovarianzen der Parameter ai zurück: MCovari,j = covariance( ai, aj ).
| Sowohl C/C++ als auch Pascal/Delphi: |
Bezüglich der vielen verschieden Optionen zur Steuerung der nicht-linearen Datenapassungs-Routinen von OptiVec lese man Kap. 13.3. Hilfsfunktionen zum Abbruch überlang laufender Anpassungen und zur Überwachung des Fortganges dieser oft sehr zeitaufwendigen Prozeduren sind in Kap. 13.5 zusammengefasst und, im Spezialfall von VF_multiNonlinfit, hier beschrieben. |
|
Beschränkungen des Multi-threading | Die in den OptiVec-Versionen bis einschließlich 6.1 vorhandenen Multi-Threading-Einschränkungen sind mit Version 6.2 aufgehoben.
Diese Funktionen dürfen nicht aufgerufen werden, wenn die FPU auf reduzierte Genauigkeit geschaltet wurde. Andernfalls können sie in einer unendlichen Schleife hängenbleiben, siehe V_setFPAccuracy. |
|
Fehlerbehandlung | Übersteigt die Zahl der freien Parameter (also derjenigen mit AStatus[i] = 1) die Gesamtzahl der anzupassenden Datenpunkte, so wird eine Fehlermeldung "Invalid parameter(s)" ausgegeben und das Programm abgebrochen. |
|
Rückgabewert | Bei Erfolg: Anpassungstest-Wert c2 (chi-Quadrat) Wenn keine Verbesserung des Parametersatzes erzielt werden konnte: -1 |
|
|
VF_multiNonlinfit_...
| VD_multiNonlinfit_... |
VE_multiNonlinfit_... |
VF_multiNonlinfitwW_... |
VD_multiNonlinfitwW_... |
VE_multiNonlinfitwW_... |
|
|
Syntax C/C++ | #include <MFstd.h>
void VF_multiNonlinfit_autoDeriv( fVector dYdAi, fVector X, ui size, unsigned ipar, unsigned iexperiment, fVector A, VF_NONLINFITWORKSPACE *ws );
float VF_multiNonlinfit_getFOM( VF_NONLINFITWORKSPACE *ws );
void VF_multiNonlinfit_getFOMDetail( fVector FOMDetail, VF_NONLINFITWORKSPACE *ws );
void VF_multiNonlinfit_getBestValues( fVector ABest, VF_NONLINFITWORKSPACE *ws );
int VF_multiNonlinfit_getTestDir( VF_NONLINFITWORKSPACE *ws );
unsigned VF_multiNonlinfit_getTestPar( VF_NONLINFITWORKSPACE *ws );
unsigned VF_multiNonlinfit_getTestRun( VF_NONLINFITWORKSPACE *ws );
void VF_multiNonlinfit_stop( VF_NONLINFITWORKSPACE *ws );
(identische Syntax für die VF_multiNonlinfitwW_... Funktionen) |
Pascal/Delphi | uses VFmnlfit;
procedure VF_multiNonlinfit_autoDeriv( dYdAi, X:fVector; size:UIntSize; ipar, iex:UInt; ws:PVF_NONLINFITWORKSPACE );
function VF_multiNonlinfit_getFOM( ws:PVF_NONLINFITWORKSPACE ): Single;
procedure VF_multiNonlinfit_getFOMDetail( FOMDetail:fVector; ws:PVF_NONLINFITWORKSPACE );
procedure VF_multiNonlinfit_getBestValues( BestValues: fVector; ws:PVF_NONLINFITWORKSPACE );
function VF_multiNonlinfit_getTestDir( ws:PVF_NONLINFITWORKSPACE ): Integer;
function VF_multiNonlinfit_getTestPar( ws:PVF_NONLINFITWORKSPACE ): UInt;
function VF_multiNonlinfit_getTestRun( ws:PVF_NONLINFITWORKSPACE ): UInt;
procedure VF_multiNonlinfit_stop( ws:PVF_NONLINFITWORKSPACE );
(identische Syntax für die VF_multiNonlinfitwW_...-Funktionen) |
|
Beschreibung | VF_multiNonlinfit_autoDeriv differenziert eine benutzerdefinierte Modell-Funktion y=f(x) nach deren Parametern aipar. Sämtliche von VF_multiNonlinfit_autoDeriv benötigten Informationen (Modell-Funktion, Puffer-Speicher usw.) werden über den Zeiger auf den in der aktuellen VF_multiNonlinfit-Operation verwendeten VF_NONLINFITWORKSPACE mitgeteilt.
Die folgenden Funktionen gestatten es, den Fortgang nicht-linearer Anpassungs-Operationen zu verfolgen. Sie können entweder aus der benutzerdefinierten Modell-Funktion heraus oder - bei Multithread-Anwendungen - auch aus einem zweiten Thread heraus aufgerufen werden.
VF_multiNonlinfit_getFOM gibt den besten bislang erzielten Anpassungstest-Wert (c2 oder, für robuste Fits, |c|) zurück. Ruft man diese Funktion auf, bevor VF_multiNonlinfit die Chance hatte, c2 erstmalig zu berechnen, so wird -1.0 zurückgegeben.
VF_multiNonlinfit_getFOMDetail speichert die auf die einzelnen Experimente bezogenen Anpassungstest-Werte (c2iex oder, für robuste Fits, |ciex|) in dem als Argument übernommenen Vektor FOMDetail. Die Summe dieser einzelnen c2iex oder |ciex| -Werte ist das beste bislang erhaltene c2 (oder |c|), wie von VF_multiNonlinfit_getFOM zurückgegeben.
VF_multiNonlinfit_getBestValues speichert den besten bislang gefundenen Parametersatz A in dem als Argument angeforderten Vektor ABest.
VF_multiNonlinfit_getTestDir liefert die Test-Richtung (+1 für aufwärts, -1 für abwärts) während "Ausbruchsversuchen" aus eventuellen lokalen Optima, die andernfalls das Erreichen des globalen Optimums verhindern würden (LevelOfMethod > 3 in VF_setNonlinfitOptions spezifiziert).
VF_multiNonlinfit_getTestPar gibt den Index des gerade bezüglich "Ausbruchs" getesteten Parameters zurück.
VF_multiNonlinfit_getTestRun liefert den Index des aktuellen "Ausbruchstest"-Durchlaufes. Für jeden angepaßten Parameter wird ein Testdurchlauf durchgeführt. Die Reihenfolge, in der die Parameter geprüft werden, wird intern so festgelegt, dass die sensitivsten Parameter zuerst an die Reihe kommen.
VF_multiNonlinfit_stop sorgt dafür, dass VF_multiNonlinfit seinen aktuellen Levenberg-Marquardt- oder Downhill-Simplex-Zyklus beendet, die Ausgabe-Parameter auf den besten Stand bringt und zur aufrufenden Funktion zurückkehrt. Auf diese Weise können überlange Anpassungs-Sitzungen (insbesondere solche mit "Ausbruchs"-Versuchen) ohne Datenverlust abgebrochen werden. |
|
|
MF_multiNonlinfit
| MD_multiNonlinfit |
ME_multiNonlinfit |
MF_multiNonlinfitwW |
MD_multiNonlinfitwW |
ME_multiNonlinfitwW |
|
Funktion | aus mehreren X-Y-Z-Datensätzen gleichzeitig die Parameter einer gemeinsamen nicht-linearen Modell-Funktion anpassen |
|
Syntax C/C++ | #include <MFstd.h>
float MF_multiNonlinfit( fVector A, iVector AStatus, unsigned npars,
MF_EXPERIMENT *ListOfExperiments, unsigned nexperiments,
void (*modelfunc)(fMatrix ZModel, ui htZ, ui lenZ, fVector X, fVector Y, unsigned iexperiment, fVector A),
void (*derivatives)(fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, unsigned iexperiment, fVector A, MF_NONLINFITWORKSPACE *ws),
VF_NONLINFITOPTIONS *FitOpts,
MF_NONLINFITWORKSPACE *WorkSpace );
float MF_multiNonlinfitwW( fVector A, fMatrix Covar, iVector AStatus, unsigned npars,
MF_EXPERIMENT *ListOfExperiments, unsigned nexperiments,
void (*modelfunc)(fMatrix ZModel, ui htZ, ui lenZ, fVector X, fVector Y, unsigned iexperiment, fVector A),
void (*derivatives)(fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, unsigned iexperiment, fVector A, MF_NONLINFITWORKSPACE *ws),
VF_NONLINFITOPTIONS *FitOpts,
MF_NONLINFITWORKSPACE *WorkSpace ); |
Syntax C/C++ vereinfacht | #include <MFstd.h>
float MF_multiNonlinfit( fVector A, iVector AStatus, unsigned npars,
MF_EXPERIMENT *ListOfExperiments, unsigned nexperiments,
void (*modelfunc)(fMatrix ZModel, ui htZ, ui lenZ, fVector X, fVector Y, unsigned iexperiment, fVector A),
void (*derivatives)(fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, unsigned iexperiment, fVector A, MF_NONLINFITWORKSPACE *ws) );
float MF_multiNonlinfitwW( fVector A, fMatrix Covar, iVector AStatus, unsigned npars,
MF_EXPERIMENT *ListOfExperiments, unsigned nexperiments,
void (*modelfunc)(fMatrix ZModel, ui htZ, ui lenZ, fVector X, fVector Y, unsigned iexperiment, fVector A),
void (*derivatives)(fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, unsigned iexperiment, fVector A, MF_NONLINFITWORKSPACE *ws) ); |
Pascal/Delphi | uses MFmnlfit;
function MF_multiNonlinfit( A: fVector; AStatus: iVector; nParameters: UInt;
ListOfExperiments: PMF_EXPERIMENT; nexperiments: UInt;
ModelFunc, Derivatives: Pointer;
FitOpts: PVF_NONLINFITOPTIONS; WorkSpace: PMF_NONLINFITWORKSPACE ): Single;
function MF_multiNonlinfitwW( A: fVector; Covar: fMatrix; AStatus: iVector; nParameters: UInt;
ListOfExperiments: PMF_EXPERIMENT; nexperiments: UInt;
ModelFunc, Derivatives: Pointer;
FitOpts: PVF_NONLINFITOPTIONS; WorkSpace: PMF_NONLINFITWORKSPACE ): Single; Syntax der als Parameter übergebenen Funktionen ModelFunc und Derivatives:
procedure ModelFunc( ZModel:fMatrix; htZ, lenZ:UIntSize; X, Y:fVector; iexperiment:UInt; A:fVector );
procedure Derivatives( dZdAi:fMatrix; htZ, lenZ:UIntSize; X, Y:fVector; ipar, iexperiment:UInt; A:fVector; ws:PMF_NONLINFITWORKSPACE );
|
Pascal/Delphi vereinfacht | uses VFmnlfit;
function MF_multiNonlinfit( A: fVector; AStatus: iVector; nParameters: UInt;
ListOfExperiments: PMF_EXPERIMENT; nexperiments: UInt;
ModelFunc, Derivatives: Pointer ): Single;
function MF_multiNonlinfitwW( A: fVector; Covar: fMatrix; AStatus: iVector; nParameters: UInt;
ListOfExperiments: PMF_EXPERIMENT; nexperiments: UInt;
ModelFunc, Derivatives: Pointer ): Single; |
|
Beschreibung | Die in ListOfExperiments enthaltenen Eingabe-Daten werden benutzt, um die Parameter ai einer allgemeinen nicht-linearen Modell-Funktion z = f(x, y) zu bestimmen. Die Parameter ai werden in dem Vektor A zurückgegeben.
Argumente:
A | Vektor der Länge npars; gibt die berechneten Koeffizienten zurück |
Covar | Matrix der Dimensionen [npars, npars]; gibt die Kovarianzen der Koeffizenten zurück |
AStatus | Vektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind |
npars | Gesamtzahl der Parameter |
ListOfExperiments | Eingabedaten, siehe Kap. 13.4 |
nexperiments | Anzahl der Datensätze in ListOfExperiments |
modelfunc | Benutzer-definierte Modell-Funktion |
derivatives | Benutzer-definierte Funktion, die die partiellen Ableitungen der Modellfunktion nach den einzelnen Parametern berechnet |
FitOpts | Zeiger auf eine Struktur mit Fit-Optionen, siehe chap. 13.3 |
WorkSpace | Zeiger auf eine Struktur mit internen Variablen, siehe chap. 13.3 |
Die Modell-Funktion (und damit der Parameter-Vektor) kann mehr Parameter enthalten als tatsächlich angepasst werden sollen. Daher muss ein zusätzlicher Vektor AStatus die Information darüber enthalten, welche Parameter bei ihren Eingabe-Werten eingefroren bleiben sollen (AStatus[i] = 0) und welche anzupassen sind (AStatus[i] = 1). Alle Parameter (nicht nur die eingefrorenen!) müssen in A vor dem Aufruf von VF_multiNonlinfit initialisiert sein. npars bezeichnet die Gesamtzahl der Parameter in A (also nicht nur die freien Parameter!).
Die Eingabe-Daten müssen in Sätzen des Typs MF_EXPERIMENT zusammengefaßt werden. Angenommen, man habe zwei X-Y-Z-Datensätze, jeweils bestehend aus den Vektoren X und Y für die unabhängigen Variablen, die Matrix Z für die z=f(x, y)-Werte und, für MF_multiLinfitwW, die Einzelpunkt-Wichtungen in MInvVar. Hieraus hat man die Experimenten-Liste zusammenzustellen wie im folgenden Beispiel:
| Experimenten-Liste in C/C++ konstruieren |
MF_EXPERIMENT ExpList[2];
ExpList[0].X = X1; ExpList[0].Y = Y1;
ExpList[0].MZ = MZ1;
ExpList[0].htZ = htZ1; ExpList[0].lenZ = lenZ1;
ExpList[1].X = X1; ExpList[1].Y = Y2;
ExpList[1].MZ = MZ2;
ExpList[1].htZ = htZ2; ExpList[1].lenZ = lenZ2;
/* für die Variante mit Einzelpunkt-Wichtung außerdem: */
ExpList[0].MInvVar = MInvVar1;
ExpList[0].WeightOfExperiment = wt1;
ExpList[1].MInvVar = MInvVar2;
ExpList[1].WeightOfExperiment = wt2;
| Experimenten-Liste in Pascal/Delphi konstruieren |
var ExpList: array[0..1] of MF_EXPERIMENT;
begin
...
ExpList[0].X := X1; ExpList[0].Y := Y1;
ExpList[0].MZ := MZ1;
ExpList[0].htZ := htZ1; ExpList[0].lenZ := lenZ1;
ExpList[1].X := X2; ExpList[1].Y := Y2;
ExpList[1].MZ := MZ2;
ExpList[1].htZ := htZ2; ExpList[1].lenZ := lenZ2;
(* für die Variante mit Einzelpunkt-Wichtung außerdem: *)
ExpList[0].MInvVar := MInvVar1;
ExpList[0].WeightOfExperiment := wt1;
ExpList[1].MInvVar := MInvVar2;
ExpList[1].WeightOfExperiment := wt2;
...
end;
| Sowohl C/C++ als auch Pascal/Delphi |
Die Modell-Funktion "funcs" ist vom Anwender zu schreiben. Sie hat für gegebene X-Y-Vektorpaare die entsprechenden theoretischen MZ-Werte zu berechnen.
In C/C++ muss sie wie folgt geschrieben werden:
| Modell-Funktion für C/C++ |
void _cdecl MyFunc( fMatrix Z, ui htZ, ui lenZ, fVector X, fVector Y, unsigned iexperiment, fVector A )
{
for(ui i=0; i<htZ; i++ )
for(ui j=0; j<lenZ; j++ )
MZ[i][j] = f( X[j], Y[i] );
}
Dabei ist f( X[j], Y[i] ) eine beliebige Funktion, die so kompliziert sein darf, wie es Ihre Anwendung erfordert. Sie darf aber keine Singularitäten besitzen, zumindest innerhalb der ggf. spezifizierten Unter- und Obergrenzen der Parameter (siehe NONLINFITOPTIONS).
Das Argument iexperiment, mit dem MyFunc intern von MF_multiNonlinfit aus aufgerufen werden wird, erlaubt die Unterscheidung zwischen Parametern, die allen Experimenten gemeinsam sind, und solchen, die individuell zu den einzelnen Experimenten gehören. Z.B. könnten die MZ-Werte mit einen für jedes Experiment verschiedenen Wert C skaliert sein. In diesem Falle muss A so viele Skalierungs-Faktoren enthalten, wie es Experimente gibt. In MyFunc hätte man dies in der folgenden Weise zu berücksichtigen:
if( iexperiment == 0 ) MZ[i][j] *= A[5]; else MZ[i][j] *= A[6];
Zusätzlich zu der Modell-Funktion benötigt MF_multiNonlinfit die partiellen Ableitungen von MZ nach allen Parametern A[ipar] entsprechend dem gewählten Modell. Falls sie zumindest zum Teil analytisch bekannt sind, solte man eine Funktion MyDerivs schreiben. Dabei können diejenigen partiellen Ableitungen, die man doch nicht kennt, durch Aufruf von MF_multiNonlinfit_autoDeriv numerisch berechnet werden.
| Partielle Ableitungen für C/C++ |
void _cdecl MyDerivs( fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, unsigned iexperiment, fVector A, MF_NONLINFITWORKSPACE *ws )
{
ui i;
switch( ipar )
{
case 0:
for(i=0; i<htZ; i++ )
for( j=0; j<lenZ; j++ )
dZdAi[i][j] = part_Abl_MZ_nach_A0( X[j], Y[i] );
break;
case 1:
for(i=0; i<htZ; i++ )
for( j=0; j<lenZ; j++ )
dZdAi[i][j] = part_Abl_MZ_nach_A1( X[j], Y[i] );
break;
default: /* für alle unbekannten Ableitungen: */
MF_multiNonlinfit_autoDeriv(
dZdAi, htZ, lenZ, X, Y, ipar, iexperiment, A, ws );
}
}
Wiederum erlaubt es das Argument iexperiment, die für die einzelnen Experimente individuellen Parameter anders als die allen Experimenten gemeinsamen zu behandeln.
Ein Aufruf von MF_multiNonlinfit wird dann etwa so aussehen:
MF_multiNonlinfit( A, AStatus, npars, ExpList, 2, MyFunc, MyDerivs, &FitOpts, &WorkSpace );
oder in vereinfachter Syntax:
MF_multiNonlinfit( A, AStatus, npars, ExpList, 2, MyFunc, MyDerivs );
Falls überhaupt keine der partiellen Ableitungen analytisch bekannt sind, definiere man auch MyDerivs nicht, sondern setze derivatives = NULL im Aufruf von MF_multiNonlinfit:
MF_multiNonlinfit( A, AStatus, npars, ExpList, 2, MyFunc, NULL );
| Modell-Funktion für Pascal/Delphi |
In Pascal/Delphi muss die Modell-Funktion wie folgt geschrieben werden:
procedure MyFunc( MZ:fMatrix; htZ, lenZ:UIntSize; X, Y:fVector; iexperiment:UInt; A:fVector );
var i, j:UIntSize;
begin
for i:=0 to htZ-1 do
for j:=0 to lenZ-1 do
MF_Pelement( MZ, htZ, lenZ, i, j )^ :=
f( VF_element( X, j ), VF_element( Y, i ) );
end;
Dabei ist f( Xj, Yi ) eine beliebige Funktion, die so kompliziert sein darf, wie es Ihre Anwendung erfordert. Sie darf aber keine Singularitäten besitzen, zumindest innerhalb der ggf. spezifizierten Unter- und Obergrenzen der Parameter (siehe NONLINFITOPTIONS).
Das Argument iexperiment, mit dem MyFunc intern von MF_multiNonlinfit aus aufgerufen werden wird, erlaubt die Unterscheidung zwischen Parametern, die allen Experimenten gemeinsam sind, und solchen, die individuell zu den einzelnen Experimenten gehören. Z.B. könnten die MZ-Werte mit einen für jedes Experiment verschiedenen Wert C skaliert sein. In diesem Falle muss A so viele Skalierungs-Faktoren enthalten, wie es Experimente gibt. In MyFunc hätte man dies in der folgenden Weise zu berücksichtigen:
if iexperiment = 0 then
MF_Pelement(MZ, htZ, lenZ, i, j)^ :=
MF_element(MZ, htZ, lenZ, i, j) * VF_element(A,5)
else MF_Pelement(MZ, htZ, lenZ, i, j)^ :=
MF_element(MZ, htZ, lenZ, i, j) * VF_element(A,6);
Zusätzlich zu der Modell-Funktion benötigt MF_multiNonlinfit die partiellen Ableitungen von MZ nach allen Parametern A[ipar] entsprechend dem gewählten Modell. Falls sie zumindest zum Teil analytisch bekannt sind, solte man eine Funktion MyDerivs schreiben. Dabei können diejenigen partiellen Ableitungen, die man doch nicht kennt, durch Aufruf von MF_multiNonlinfit_autoDeriv numerisch berechnet werden.
| Partielle Ableitungen für Pascal/Delphi |
procedure MyDerivs( dZdAi:fMatrix; htZ, lenZ:UIntSize; X, Y:fVector; ipar, iexperiment:UInt; A:fVector; ws:PMF_NONLINFITWORKSPACE );
var i, j:UIntSize;
begin
case ipar of
0: begin
for i:=0 to ht-1 do
for j:=0 to len-1 do
MF_Pelement( dZdAi, htZ, lenZ, i, j )^ := part_Abl_MZ_nach_A0(VF_element( X, j ),
VF_element( Y, i ));
end;
1: begin
for i:=0 to ht-1 do
for j:=0 to len-1 do
MF_Pelement( dZdAi, htZ, lenZ, i, j )^ := part_Abl_MZ_nach_A1(VF_element( X, j ),
VF_element( Y, i ));
end;
else (* für alle unbekannten Ableitungen: *)
MF_multiNonlinfit_autoDeriv(
dZdAi, htZ, lenZ, X, Y, ipar, A, ws );
end;
end;
Wiederum erlaubt es das Argument iexperiment, die für die einzelnen Experimente individuellen Parameter anders als die allen Experimenten gemeinsamen zu behandeln.
Ein Aufruf von MF_multiNonlinfit wird dann etwa so aussehen:
MF_multiNonlinfit( A, AStatus, npars, @ExpList, 2, @MyFunc, @MyDerivs, @FitOpts, @WorkSpace );
oder in vereinfachter Syntax:
MF_multiNonlinfit( A, AStatus, npars, @ExpList, 2, @MyFunc, @MyDerivs );
Man beachte die Adress-Operatoren vor "ExpList", "MyFunc " und "MyDerivs". Falls überhaupt keine der partiellen Ableitungen analytisch bekannt sind, definiere man auch MyDerivs nicht, sondern setze derivatives := nil im Aufruf von MF_multiNonlinfit:
MF_multiNonlinfit( A, AStatus, npars, @ExpList, 2, @MyFunc, nil );
In der gewichteten Variante MF_multiNonlinfitwW muss die Matrix ExpList[i].MInvVar jedes Experimentes den Kehrwert der Varianzen der einzelnen X-Y-Z-Datenpunkte enthalten, und die Matrix MCovar gibt die Kovarianzen der Parameter ai zurück: MCovari,j = covariance( ai, aj ).
| Sowohl C/C++ als auch Pascal/Delphi: |
Bezüglich der vielen verschieden Optionen zur Steuerung der nicht-linearen Datenapassungs-Routinen von OptiVec lese man Kap. 13.3. Hilfsfunktionen zum Abbruch überlang laufender Anpassungen und zur Überwachung des Fortganges dieser oft sehr zeitaufwendigen Prozeduren sind in Kap. 13.5 zusammengefaßt und, im Spezialfall von MF_multiNonlinfit, hier beschrieben. |
|
Beschränkungen des Multi-threading | Die in den OptiVec-Versionen bis einschließlich 6.1 vorhandenen Multi-Threading-Einschränkungen sind mit Version 6.2 aufgehoben.
Diese Funktionen dürfen nicht aufgerufen werden, wenn die FPU auf reduzierte Genauigkeit geschaltet wurde. Andernfalls können sie in einer unendlichen Schleife hängenbleiben, siehe V_setFPAccuracy. |
|
Fehlerbehandlung | Übersteigt die Zahl der freien Parameter (also derjenigen mit AStatus[i] = 1) die Gesamtzahl der anzupassenden Datenpunkte, so wird eine Fehlermeldung "Invalid parameter(s)" ausgegeben und das Programm abgebrochen. |
|
Rückgabewert | Bei Erfolg: Anpassungstest-Wert c2 (chi-Quadrat) Wenn keine Verbesserung des Parametersatzes erzielt werden konnte: -1 |
|
|
MF_multiNonlinfit_...
| MD_multiNonlinfit_... |
ME_multiNonlinfit_... |
MF_multiNonlinfitwW_... |
MD_multiNonlinfitwW_... |
ME_multiNonlinfitwW_... |
|
|
Syntax C/C++ | #include <MFstd.h>
void MF_multiNonlinfit_autoDeriv( fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, unsigned iex, fVector A, MF_NONLINFITWORKSPACE *ws );
float MF_multiNonlinfit_getFOM( MF_NONLINFITWORKSPACE *ws );
void MF_multiNonlinfit_getFOMDetail( fVector FOMDetail, MF_NONLINFITWORKSPACE *ws );
void MF_multiNonlinfit_getBestValues( fVector ABest, MF_NONLINFITWORKSPACE *ws );
int MF_multiNonlinfit_getTestDir( MF_NONLINFITWORKSPACE *ws );
unsigned MF_multiNonlinfit_getTestPar( MF_NONLINFITWORKSPACE *ws );
unsigned MF_multiNonlinfit_getTestRun( MF_NONLINFITWORKSPACE *ws );
void MF_multiNonlinfit_stop( MF_NONLINFITWORKSPACE *ws );
(identische Syntax für die MF_nonlinfitwW_...-Funktionen) |
Pascal/Delphi | uses MFmnlfit;
procedure MF_multiNonlinfit_autoDeriv( dZdAi:fMatrix; htZ, lenZ:UIntSize; X, Y:fVector; ipar, iex: UInt; A:fVector; ws:PMF_NONLINFITWORKSPACE );
function MF_multiNonlinfit_getFOM( ws:PMF_NONLINFITWORKSPACE ): Single;
procedure MF_multiNonlinfit_getFOMDetail( FOMDetail:fVector; ws:PMF_NONLINFITWORKSPACE );
procedure MF_multiNonlinfit_getBestValues( BestValues: fVector; ws:PMF_NONLINFITWORKSPACE );
function MF_multiNonlinfit_getTestDir( ws:PMF_NONLINFITWORKSPACE ): Integer;
function MF_multiNonlinfit_getTestPar( ws:PMF_NONLINFITWORKSPACE ): UInt;
function MF_multiNonlinfit_getTestRun( ws:PMF_NONLINFITWORKSPACE ): UInt;
procedure MF_multiNonlinfit_stop( ws:PMF_NONLINFITWORKSPACE );
(identische Syntax für die MF_multiNonlinfitwW_...-Funktionen) |
|
Beschreibung | MF_multiNonlinfit_autoDeriv differenziert eine benutzerdefinierte Modell-Funktion z=f(x, y) nach deren Parametern aipar. Sämtliche von MF_multiNonlinfit_autoDeriv benötigten Informationen (Modell-Funktion, Pufferspeicher usw.) werden über den Zeiger auf den in der aktuellen MF_multiNonlinfit-Operation verwendeten MF_NONLINFITWORKSPACE mitgeteilt.
Die folgenden Funktionen gestatten es, den Fortgang nicht-linearer Anpassungs-Operationen zu verfolgen. Sie können entweder aus der benutzerdefinierten Modell-Funktion heraus oder - bei Multithread-Anwendungen - auch aus einem zweiten Thread heraus aufgerufen werden.
MF_multiNonlinfit_getFOM gibt den besten bislang erzielten Anpassungstest-Wert (c2 oder, für robuste Fits, |c|) zurück. Ruft man diese Funktion auf, bevor MF_multiNonlinfit die Chance hatte, c2 erstmalig zu berechnen, so wird -1.0 zurückgegeben.
MF_multiNonlinfit_getFOMDetail speichert die auf die einzelnen Experimente bezogenen Anpassungstest-Werte (c2iex oder, für robuste Fits, |ciex|) in dem als Argument übernommenen Vektor FOMDetail. Die Summe dieser einzelnen c2iex oder |ciex| -Werte ist das beste bislang erhaltene c2 (oder |c|), wie von MF_multiNonlinfit_getFOM zurückgegeben.
MF_multiNonlinfit_getBestValues speichert den besten bislang gefundenen Parametersatz A in dem als Argument angeforderten Vektor ABest.
MF_multiNonlinfit_getTestDir liefert die Test-Richtung (+1 für aufwärts, -1 für abwärts) während "Ausbruchsversuchen" aus eventuellen lokalen Optima, die andernfalls das Erreichen des globalen Optimums verhindern würden (LevelOfMethod > 3 in VF_setNonlinfitOptions spezifiziert).
MF_multiNonlinfit_getTestPar gibt den Index des gerade bezüglich "Ausbruchs" getesteten Parameters zurück.
MF_multiNonlinfit_getTestRun liefert den Index des aktuellen "Ausbruchstest"-Durchlaufes. Für jeden angepaßten Parameter wird ein Testdurchlauf durchgeführt. Die Reihenfolge, in der die Parameter geprüft werden, wird intern so festgelegt, dass die sensitivsten Parameter zuerst an die Reihe kommen.
MF_multiNonlinfit_stop sorgt dafür, dass MF_multiNonlinfit seinen aktuellen Levenberg-Marquardt- oder Downhill-Simplex-Zyklus beendet, die Ausgabe-Parameter auf den besten Stand bringt und zur aufrufenden Funktion zurückkehrt. Auf diese Weise können überlange Anpassungs-Sitzungen (insbesondere solche mit "Ausbruchs"-Versuchen) ohne Datenverlust abgebrochen werden. |
|
|
MCF_mulV |
MCD_mulV |
MCE_mulV |
|
Funktion | Matrix mit einem Spalten-Vektor multiplizieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_mulV( fVector Y, fMatrix MA, fVector X, ui htA, ui lenA ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::mulV( const matrix<T>& MA, const vector<T>& X ); |
Pascal/Delphi | uses MFstd;
procedure MF_mulV( Y:fVector; MA:fMatrix; X:fVector; htA, lenA:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_mulV( fVector d_Y, fMatrix d_MA, fVector d_X, ui htA, ui lenA );
void MFcu_mulV( fVector h_Y, fMatrix h_MA, fVector h_X, ui htA, ui lenA );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_mulV( d_Y:fVector; d_MA:fMatrix; d_X:fVector; htA, lenA:UIntSize ): IntBool;
procedure MFcu_mulV( h_Y:fVector; h_MA:fMatrix; h_X:fVector; htA, lenA:UIntSize );
|
|
Beschreibung | Y = MA * X
Die Dimensionen von X und Y sind implizit gegeben durch die Matrix-Dimensionen: sizX = lenA, sizY = htA.
|
|
|
MF_natCubSplineInterpol | MD_natCubSplineInterpol | ME_natCubSplineInterpol |
|
Funktion | natürliche kubische Spline-Interpolation von Matrix-Elementen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_natCubSplineInterpol( fMatrix MZ, fVector X, fVector Y, ui ht, ui len, fVector XTab, fVector YTab, fMatrix MZTab, ui httab, ui lentab ); |
C++ VecObj | #include <OptiVec.h>
void matrix<T>::natCubSplineInterpol( const vector<T>& X, const vector<T>& Y, const vector<T>& XTab, const vector<T>& YTab, const matrix<T>& MZTab ); |
Pascal/Delphi | uses MFstd;
procedure MF_natCubSplineInterpol( MZ:fMatrix; X, Y:fVector; ht, len:UIntSize; XTab, YTab:fVector; MZTab:fMatrix; httab, lentab:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_natCubSplineInterpol( fMatrix d_MZ, fVector d_X, fVector d_Y, ui ht, ui len, fVector d_XTab, fVector d_YTab, fMatrix d_MZTab, ui httab, ui lentab );
void MFcu_natCubSplineInterpol( fMatrix h_MZ, fVector h_X, fVector h_Y, ui ht, ui len, fVector h_XTab, fVector h_YTab, fMatrix h_MZTab, ui httab, ui lentab );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_natCubSplineInterpol( d_MZ:fMatrix; d_X, d_Y:fVector; ht, len:UIntSize; d_XTab, d_YTab:fVector; d_MZTab:fMatrix; httab, lentab:UIntSize ): IntBool;
procedure MFcu_natCubSplineInterpol( h_MZ:fMatrix; h_X, h_Y:fVector; ht, len:UIntSize; h_XTab, h_YTab:fVector; h_MZTab:fMatrix; httab, lentab:UIntSize );
|
|
Beschreibung | Für jedes der ht * len Elemente des durch X und Y aufgespannten Koordinatensystems wird ein MZ-Wert gewonnen durch kubische Spline-Interpolation einer Tabelle. Diese Tabelle muss in Form von XTab-YTab-MZTab-Werten vorliegen. XTab und YTab müssen geordnet sein (strikt aufsteigend oder abfallend). Außerdem müssen jeweils alle Werte von XTab und YTab verschieden sein (es können keine zwei MZTab-Werte zu ein- und demselben XTab- bzw. YTab- Wert gehören!). Andernfalls droht Programmabbruch durch eine Division durch 0.
httab und lentab müssen mindestens 3 betragen. |
|
Fehlerbehandlung | keine (Sie sind also selbst dafür verantwortlich, dass alle XTab- und YTab-Werte verschieden sind, dass die MZTab-Werte nicht schon nahe an der Überlaufgrenze sind und dass die Tabelle mindestens aus 3x3 Punkten besteht.) |
|
|
|
MI_neg | MBI_neg | MSI_neg | MLI_neg | MQI_neg |
|
|
Syntax C/C++ | #include <MFstd.h>
void MF_neg( fMatrix MB, fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::neg( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_neg( MB, MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_neg( fMatrix d_MB, fMatrix d_MA, ui ht, ui len );
void MFcu_neg( fMatrix h_MB, fMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_neg( d_MB, d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_neg( h_MB, h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | MBi,j = -MAi,j |
|
|
|
Funktion | Speicher mehrerer Matrizen freigeben (nur C/C++) |
|
Syntax C/C++ | #include <MFstd.h>
void M_nfree( unsigned numfree, ... ); |
Pascal/Delphi | Diese Funktion existiert nicht |
|
CUDA-Funktion C/C++ | #include <cudaMatLib.h>
int cudaM_nfree( unsigned numfree, ... );
|
|
Beschreibung | Der Parameter numfree teilt dieser Funktion mit, wie viele Matrizen freizugeben sind. Die Matrizen selbst folgen in der Parameterliste hinter numfree. De-Allokation von Matrizen, die nicht zuvor mit einer der Funktionen aus der MF_matrix- oder MF_matrix0- Familie erzeugt wurden, ist nicht möglich.
Pascal/Delphi: da der Sprach-Standard von Pascal/Delphi eine variable Parameterzahl nicht unterstützt, fehlt diese Funktion hier.
|
Beispiel C/C++ | M_nfree( 3, MX, MY, MZ ); |
|
|
VF_nonlinfit
| VD_nonlinfit |
VE_nonlinfit |
VF_nonlinfitwW |
VD_nonlinfitwW |
VE_nonlinfitwW |
|
Funktion | nicht-lineare Modellfunktion an y=f(x)-Daten anpassen |
|
Syntax C/C++ | #include <MFstd.h>
float VF_nonlinfit( fVector A, iVector AStatus, unsigned npars,
fVector X, fVector Y, ui sizex,
void modelfunc(fVector YModel, fVector XModel, ui size, fVector A),
void derivatives(fVector dYdAi, fVector X, ui size, unsigned iPar, fVector A, VF_NONLINFITWORKSPACE *ws),
VF_NONLINFITOPTIONS *FitOpts,
VF_NONLINFITWORKSPACE *WorkSpace );
float VF_nonlinfitwW( fVector A, fMatrix Covar, iVector AStatus, unsigned npars,
fVector X, fVector Y, fVector InvVar, ui sizex,
void modelfunc(fVector YModel, fVector X, ui size, fVector A),
void derivatives(fVector dYdAi, fVector X, ui size, unsigned iPar, fVector A, VF_NONLINFITWORKSPACE *ws),
VF_NONLINFITOPTIONS *FitOpts,
VF_NONLINFITWORKSPACE *WorkSpace ); |
Syntax C/C++ vereinfacht | #include <MFstd.h>
float VF_nonlinfit( fVector A, iVector AStatus, unsigned npars,
fVector X, fVector Y, ui sizex,
void modelfunc(fVector YModel, fVector XModel, ui size, fVector A),
void derivatives(fVector dYdAi, fVector X, ui size, unsigned iPar, fVector A, VF_NONLINFITWORKSPACE *ws) );
float VF_nonlinfitwW( fVector A, fMatrix Covar, iVector AStatus, unsigned npars,
fVector X, fVector Y, fVector InvVar, ui sizex,
void modelfunc(fVector YModel, fVector X, ui size, fVector A),
void derivatives(fVector dYdAi, fVector X, ui size, unsigned iPar, fVector A, VF_NONLINFITWORKSPACE *ws) ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::nonlinfit( const vector<int>& AStatus,
const vector<T>& X, const vector<T>& Y,
void modelfunc(fVector YModel, fVector XModel, ui size, fVector A),
void derivatives(fVector dYdAi, fVector X, ui size, unsigned iPar, fVector A, VF_NONLINFITWORKSPACE *ws),
VF_NONLINFITOPTIONS *FitOpts,
VF_NONLINFITWORKSPACE *WorkSpace );
void vector<T>::nonlinfitwW( matrix<T> Covar, const vector<int>& AStatus,
const vector<T>& X, const vector<T>& Y, const vector<T>& InvVar,
void modelfunc(fVector YModel, fVector XModel, ui size, fVector A),
void derivatives(fVector dYdAi, fVector X, ui size, unsigned iPar, fVector A, VF_NONLINFITWORKSPACE *ws),
VF_NONLINFITOPTIONS *FitOpts,
VF_NONLINFITWORKSPACE *WorkSpace );
void vector<T>::nonlinfitwW( matrix<T>* Covar, const vector<int>& AStatus,
const vector<T>& X, const vector<T>& Y, const vector<T>& InvVar,
void modelfunc(fVector YModel, fVector XModel, ui size, fVector A),
void derivatives(fVector dYdAi, fVector X, ui size, unsigned iPar, fVector A, VF_NONLINFITWORKSPACE *ws),
VF_NONLINFITOPTIONS *FitOpts,
VF_NONLINFITWORKSPACE *WorkSpace ); |
C++ MatObj vereinfacht | #include <OptiVec.h>
void vector<T>::nonlinfit( const vector<int>& AStatus,
const vector<T>& X, const vector<T>& Y,
void modelfunc(fVector YModel, fVector XModel, ui size, fVector A),
void derivatives(fVector dYdAi, fVector X, ui size, unsigned iPar, fVector A, VF_NONLINFITWORKSPACE *ws) );
void vector<T>::nonlinfitwW( matrix<T> Covar, const vector<int>& AStatus,
const vector<T>& X, const vector<T>& Y, const vector<T>& InvVar,
void modelfunc(fVector YModel, fVector XModel, ui size, fVector A),
void derivatives(fVector dYdAi, fVector X, ui size, unsigned iPar, fVector A, VF_NONLINFITWORKSPACE *ws) );
void vector<T>::nonlinfitwW( matrix<T>* Covar, const vector<int>& AStatus,
const vector<T>& X, const vector<T>& Y, const vector<T>& InvVar,
void modelfunc(fVector YModel, fVector XModel, ui size, fVector A),
void derivatives(fVector dYdAi, fVector X, ui size, unsigned iPar, fVector A, VF_NONLINFITWORKSPACE *ws) ); |
Pascal/Delphi | uses VFnlfit;
function VF_nonlinfit( A: fVector; AStatus: iVector; nParameters: UInt;
X, Y: fVector; sizex:UIntSize;
ModelFunc, Derivatives: Pointer;
FitOpts: PVF_NONLINFITOPTIONS;
WorkSpace: PVF_NONLINFITWORKSPACE ): Single;
function VF_nonlinfitwW( A: fVector; Covar: fMatrix;BR>
AStatus: iVector; nParameters: UInt;
X, Y, InvVar:fVector; sizex:UIntSize;
ModelFunc, Derivatives: Pointer;
FitOpts: PVF_NONLINFITOPTIONS;
WorkSpace: PVF_NONLINFITWORKSPACE ): Single;
Syntax der als Parameter übergebenen Funktionen ModelFunc und Derivatives:
procedure ModelFunc( YModel, XModel:fVector; size:UIntSize; A:fVector );
procedure Derivatives( dYdAi, X:fVector; size:UIntSize; ipar:UInt; A:fVector; ws:PVF_NONLINFITWORKSPACE );
|
Pascal/Delphi vereinfacht | uses VFnlfit;
function VF_nonlinfit( A: fVector; AStatus: iVector; nParameters: UInt;
X, Y: fVector; sizex:UIntSize;
ModelFunc, Derivatives: Pointer ): Single;
function VF_nonlinfitwW( A: fVector; Covar: fMatrix;
AStatus: iVector; nParameters: UInt;
X, Y, InvVar:fVector; sizex:UIntSize;
ModelFunc, Derivatives: Pointer ): Single; |
|
Beschreibung | Die X-Y-Eingabedaten werden benutzt, um den Parameter-Vektor A mit npars Elementen ai für eine beliebige Modell-Funktion y = f(x) zu bestimmen.
Argumente:
A | Vektor der Länge npars; gibt die berechneten Koeffizienten zurück |
Covar | Matrix der Dimensionen [npars, npars]; gibt die Kovarianzen der Koeffizenten zurück |
AStatus | Vektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind |
npars | Gesamtzahl der Parameter |
X, Y, InvVar | Vektoren der Länge sizex mit den Eingabe-Daten sowie, bei der gewichteten Variante, dem Kehrwert von deren Varianzen |
modelfunc | Benutzer-definierte Modell-Funktion |
derivatives | Benutzer-definierte Funktion, die die partiellen Ableitungen der Modellfunktion nach den einzelnen Parametern berechnet |
FitOpts | Zeiger auf eine Struktur mit Anpassungs-Optionen, siehe chap. 13.3 |
WorkSpace | Zeiger auf eine Struktur mit internen Variablen, siehe chap. 13.3 |
Die Modell-Funktion (und damit der Parameter-Vektor) kann mehr Parameter enthalten als tatsächlich angepaßt werden sollen. Daher muss ein zusätzlicher Vektor AStatus die Information darüber enthalten, welche Parameter bei ihren Eingabe-Werten eingefroren bleiben sollen (AStatus[i] = 0) und welche anzupassen sind (AStatus[i] = 1). Alle (also auch die freien!) Parameter müssen in A vor dem Aufruf von VF_nonlinfit initialisiert sein. Je besser man sie "errät", desto schneller konvergiert diese Routine. npars bezeichnet die Gesamtzahl der Parameter in A (also nicht nur die freien Parameter!).
Die Modell-Funktion "modelfunc" ist vom Anwender zu schreiben. Sie hat für einen gegebenen X-Vektor die entsprechenden Y-Werte zu berechnen. In C/C++ muss sie wie folgt geschrieben werden:
| Modell-Funktion für C/C++ |
void _cdecl MyFunc( fVector Y, fVector X, ui size, fVector A )
{
for(ui i=0; i<size; i++ )
Y[i] = f( X[i] );
}
Dabei ist f( X[i] ) eine beliebige Funktion, die so kompliziert sein darf, wie es Ihre Anwendung erfordert. Sie darf aber keine Singularitäten besitzen, zumindest innerhalb der ggf. spezifizierten Unter- und Obergrenzen der Parameter (siehe NONLINFITOPTIONS).
Zusätzlich zu der Modell-Funktion benötigt VF_nonlinfit die partiellen Ableitungen von Y nach allen Parametern A[ipar] entsprechend dem gewählten Modell. Falls sie zumindest zum Teil analytisch bekannt sind, solte man eine Funktion MyDerivs schreiben. Dabei können diejenigen partiellen Ableitungen, die man doch nicht kennt, durch Aufruf von VF_nonlinfit_autoDeriv numerisch berechnet werden.
| Partielle Ableitungen für C/C++ |
void _cdecl MyDerivs( fVector dYdAi, fVector X, ui size, unsigned ipar, fVector A, VF_NONLINFITWORKSPACE *ws )
{
ui i;
switch( ipar )
{
case 0: for(i=0; i<size; i++ )
dYdAi[i] = part_Abl_Y_nach_A0( X[i] );
break;
case 1: for(i=0; i<size; i++ )
dYdAi[i] = part_Abl_Y_nach_A1( X[i] );
break;
default: /* für alle unbekannten Ableitungen: */
VF_nonlinfit_autoDeriv( dYdAi, X, size:UIntSize; ipar, A, ws);
}
}
Ein Aufruf von VF_nonlinfit sieht dann so aus:
VF_nonlinfit( A, AStatus, npars, X, Y, sizex, MyFunc, MyDerivs, &FitOpts, &WorkSpace );
oder in vereinfachter Syntax:
VF_nonlinfit( A, AStatus, npars, X, Y, sizex, MyFunc, MyDerivs );
Falls überhaupt keine der partiellen Ableitungen analytisch bekannt sind, definiere man auch MyDerivs nicht, sondern setze derivatives = NULL im Aufruf von VF_nonlinfit:
VF_nonlinfit( A, AStatus, npars, X, Y, sizex, MyFunc, NULL );
| Modell-Funktion für Pascal/Delphi |
In Pascal/Delphi muss die Modell-Funktion wie folgt geschrieben werden:
procedure MyFunc( Y, X:fVector; size:UIntSize; A:fVector );
var i:UIntSize;
begin
for i:=0 to size-1 do
VF_Pelement( Y, i )^ := f( VF_element( X, i ) );
end;
Dabei ist f( Xi ) eine beliebige Funktion, die so kompliziert sein darf, wie es Ihre Anwendung erfordert. Sie darf aber keine Singularitäten besitzen, zumindest innerhalb der ggf. spezifizierten Unter- und Obergrenzen der Parameter (siehe NONLINFITOPTIONS).
Zusätzlich zu der Modell-Funktion benötigt VF_nonlinfit die partiellen Ableitungen von Y nach allen Parametern A[ipar] entsprechend dem gewählten Modell. Falls sie zumindest zum Teil analytisch bekannt sind, solte man eine Funktion MyDerivs schreiben. Dabei können diejenigen partiellen Ableitungen, die man doch nicht kennt, durch Aufruf von VF_nonlinfit_autoDeriv numerisch berechnet werden.
| Partielle Ableitungen für Pascal/Delphi |
procedure MyDerivs( dYdAi, X:fVector; size:UIntSize; ipar:UInt; A:fVector; ws:PVF_NONLINFITWORKSPACE );
var i:UIntSize;
begin
case ipar of
0: begin
for i:=0 to size-1 do
VF_Pelement( dYdAi, i )^ := part_Abl_Y_nach_A0(VF_element( X, i )); end;
1: begin
for i:=0 to size-1 do
VF_Pelement( dYdAi, i )^ := part_Abl_Y_nach_A0(VF_element( X, i )); end;
else (* für alle unbekannten Ableitungen: *)
VF_nonlinfit_autoDeriv( dYdAi, X, size:UIntSize; ipar, A, ws );
end;
end;
Ein Aufruf von VF_nonlinfit sieht dann folgendermaßen aus:
VF_nonlinfit( A, AStatus, npars, X, Y, sizex, @MyFunc, @MyDerivs, @FitOpts, @WorkSpace );
oder in vereinfachter Syntax (nur, wenn keine Hilfsfunktionen aufgerufen werden sollen):
VF_nonlinfit( A, AStatus, npars, X, Y, sizex, @MyFunc, @MyDerivs );
Man beachte die Adress-Operatoren vor "MyFunc " und "MyDerivs". Falls überhaupt keine der partiellen Ableitungen analytisch bekannt sind, definiere man auch MyDerivs nicht, sondern setze derivatives := nil im Aufruf von VF_nonlinfit:
VF_nonlinfit( A, AStatus, npars, X, Y, sizex, @MyFunc, nil );
In der gewichteten Variante VF_nonlinfitwW muss der Vektor InvVar den Kehrwert der Varianzen der einzelnen X-Y -Datenpunkte enthalten, und die Matrix MCovar gibt die Kovarianzen der Parameter ai zurück: MCovari,j = covariance( ai, aj ).
| Sowohl C/C++ als auch Pascal/Delphi: |
Bezüglich der vielen verschieden Optionen zur Steuerung der nicht-linearen Datenapassungs-Routinen von OptiVec lese man Kap. 13.3. Hilfsfunktionen zum Abbruch überlang laufender Anpassungen und zur Überwachung des Fortganges dieser oft sehr zeitaufwendigen Prozeduren sind in Kap. 13.5 zusammengefasst und, im Spezialfall von VF_nonlinfit, hier beschrieben. |
|
Beschränkungen des Multi-threading | Die in den OptiVec-Versionen bis einschließlich 6.1 vorhandenen Multi-Threading-Einschränkungen sind mit Version 6.2 aufgehoben.
Diese Funktionen dürfen nicht aufgerufen werden, wenn die FPU auf reduzierte Genauigkeit geschaltet wurde. Andernfalls können sie in einer unendlichen Schleife hängenbleiben, siehe V_setFPAccuracy. |
|
Fehlerbehandlung | Übersteigt die Zahl der freien Parameter (also derjenigen mit AStatus[i] = 1) die Gesamtzahl der anzupassenden Datenpunkte, so wird eine Fehlermeldung "Invalid parameter(s)" ausgegeben und das Programm abgebrochen. |
|
Rückgabewert | Bei Erfolg: Anpassungstest-Wert c2 (chi-Quadrat) Wenn keine Verbesserung des Parametersatzes erzielt werden konnte: -1 |
|
|
VF_nonlinfit_...
| VD_nonlinfit_... |
VE_nonlinfit_... |
VF_nonlinfitwW_... |
VD_nonlinfitwW_... |
VE_nonlinfitwW_... |
|
|
Syntax C/C++ | #include <MFstd.h>
void VF_nonlinfit_autoDeriv( fVector dYdAi, fVector X, ui size, unsigned ipar, fVector A, VF_NONLINFITWORKSPACE *ws );
float VF_nonlinfit_getFOM( VF_NONLINFITWORKSPACE *ws );
void VF_nonlinfit_getBestValues( fVector ABest, VF_NONLINFITWORKSPACE *ws );
int VF_nonlinfit_getTestDir( VF_NONLINFITWORKSPACE *ws );
unsigned VF_nonlinfit_getTestPar( VF_NONLINFITWORKSPACE *ws );
unsigned VF_nonlinfit_getTestRun( VF_NONLINFITWORKSPACE *ws );
void VF_nonlinfit_stop( VF_NONLINFITWORKSPACE *ws );
(identische Syntax für die VF_nonlinfitwW_...-Funktionen) |
C++ MatObj | #include <OptiVec.h>
void vector<T>::nonlinfit_getFOM( VF_NONLINFITWORKSPACE *ws );
void vector<T>::nonlinfit_getBestValues( VF_NONLINFITWORKSPACE *ws );
unsigned vector<T>::nonlinfit_getTestPar( VF_NONLINFITWORKSPACE *ws );
unsigned vector<T>::nonlinfit_getTestRun( VF_NONLINFITWORKSPACE *ws );
void vector<T>::nonlinfit_stop( VF_NONLINFITWORKSPACE *ws );
(identische Syntax für die nonlinfitwW_...-Funktionen) |
Pascal/Delphi | uses VFnlfit;
procedure VF_nonlinfit_autoDeriv( dYdAi, X: fVector; size:UIntSize; ipar:UInt; A:fVector; ws:PVF_NONLINFITWORKSPACE );
function VF_nonlinfit_getFOM( ws:PVF_NONLINFITWORKSPACE ): Single;
procedure VF_nonlinfit_getBestValues( BestValues: fVector; ws:PVF_NONLINFITWORKSPACE );
function VF_nonlinfit_getTestDir( ws:PVF_NONLINFITWORKSPACE ): Integer;
function VF_nonlinfit_getTestPar( ws:PVF_NONLINFITWORKSPACE ): UInt;
function VF_nonlinfit_getTestRun( ws:PVF_NONLINFITWORKSPACE ): UInt;
procedure VF_nonlinfit_stop( ws:PVF_NONLINFITWORKSPACE );
(identische Syntax für die VF_nonlinfitwW_...-Funktionen) |
|
Beschreibung | VF_nonlinfit_autoDeriv differenziert eine benutzerdefinierte Modell-Funktion y=f(x) nach deren Parametern aipar. Sämtliche von VF_nonlinfit_autoDeriv benötigten Informationen (Modell-Funktion, Pufferspeicher usw.) werden über den Zeiger auf den in der aktuellen VF_nonlinfit-Operation verwendeten VF_NONLINFITWORKSPACE mitgeteilt.
Die folgenden Funktionen gestatten es, den Fortgang nicht-linearer Anpassungs-Operationen zu verfolgen. Sie können entweder aus der benutzerdefinierten Modell-Funktion heraus oder - bei Multithread-Anwendungen - auch aus einem zweiten Thread heraus aufgerufen werden.
VF_nonlinfit_getFOM gibt den besten bislang erzielten Anpassungstest-Wert (c2 oder, für robuste Fits, |c|) zurück. Ruft man diese Funktion auf, bevor VF_nonlinfit die Chance hatte, c2 erstmalig zu berechnen, so wird -1.0 zurückgegeben.
VF_nonlinfit_getBestValues speichert den besten bislang gefundenen Parametersatz A in dem als Argument angeforderten Vektor ABest.
VF_nonlinfit_getTestDir liefert die Test-Richtung (+1 für aufwärts, -1 für abwärts) während "Ausbruchsversuchen" aus eventuellen lokalen Optima, die andernfalls das Erreichen des globalen Optimums verhindern würden (LevelOfMethod > 3 in VF_setNonlinfitOptions spezifiziert).
VF_nonlinfit_getTestPar gibt den Index des gerade bezüglich "Ausbruchs" getesteten Parameters zurück.
VF_nonlinfit_getTestRun liefert den Index des aktuellen "Ausbruchstest"-Durchlaufes. Für jeden angepaßten Parameter wird ein Testdurchlauf durchgeführt. Die Reihenfolge, in der die Parameter geprüft werden, wird intern so festgelegt, dass die sensitivsten Parameter zuerst an die Reihe kommen.
VF_nonlinfit_stop sorgt dafür, dass VF_nonlinfit seinen aktuellen Levenberg-Marquardt- oder Downhill-Simplex-Zyklus beendet, die Ausgabe-Parameter auf den besten Stand bringt und zur aufrufenden Funktion zurückkehrt. Auf diese Weise können überlange Anpassungs-Sitzungen (insbesondere solche mit "Ausbruchs"-Versuchen) ohne Datenverluste abgebrochen werden. |
|
|
MF_nonlinfit
| MD_nonlinfit |
ME_nonlinfit |
MF_nonlinfitwW |
MD_nonlinfitwW |
ME_nonlinfitwW |
|
Funktion | nicht-lineare Modellfunktion an z=f(x,y)-Daten anpassen |
|
Syntax C/C++ | #include <MFstd.h>
float MF_nonlinfit( fVector A, iVector AStatus, unsigned npars,
fVector X, fVector Y, fMatrix Z, ui htZ, ui lenZ,
void modelfunc(fMatrix ZModel, ui htZ, ui lenZ, fVector X, fVector Y, fVector A ),
void derivatives(fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, fVector A, MF_NONLINFITWORKSPACE *ws),
VF_NONLINFITOPTIONS *FitOpts,
MF_NONLINFITWORKSPACE *WorkSpace );
float MF_nonlinfitwW( fVector A, fMatrix Covar, iVector AStatus, unsigned npars,
fVector X, fVector Y, fMatrix Z, fMatrix InvVar, ui htZ, ui lenZ,
void modelfunc(fMatrix ZModel, ui htZ, ui lenZ, fVector X, fVector Y, fVector A ),
void derivatives(fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, fVector A, MF_NONLINFITWORKSPACE *ws),
VF_NONLINFITOPTIONS *FitOpts,
MF_NONLINFITWORKSPACE *WorkSpace ); |
Syntax C/C++ vereinfacht | #include <MFstd.h>
float MF_nonlinfit( fVector A, iVector AStatus, unsigned npars,
fVector X, fVector Y, fMatrix Z, ui htZ, ui lenZ,
void modelfunc(fMatrix ZModel, ui htZ, ui lenZ, fVector X, fVector Y, fVector A ),
void derivatives(fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, fVector A, MF_NONLINFITWORKSPACE *ws) );
float MF_nonlinfitwW( fVector A, fMatrix Covar, iVector AStatus, unsigned npars,
fVector X, fVector Y, fMatrix Z, fMatrix InvVar, ui htZ, ui lenZ,
void modelfunc(fMatrix ZModel, ui htZ, ui lenZ, fVector X, fVector Y, fVector A ),
void derivatives(fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, fVector A, MF_NONLINFITWORKSPACE *ws) ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::nonlinfit( const vector<int>& AStatus,
const vector<T>& X, const vector<T>& Y, const matrix<T>& MZ,
void modelfunc(fMatrix ZModel, ui htZ, ui lenZ, fVector X, fVector Y, fVector A ),
void derivatives(fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, fVector A, MF_NONLINFITWORKSPACE *ws),
VF_NONLINFITOPTIONS *FitOpts,
MF_NONLINFITWORKSPACE *WorkSpace );
void vector<T>::nonlinfitwW( matrix<T> Covar, const vector<int>& AStatus,
const vector<T>& X, const vector<T>& Y, const matrix<T>& MZ, const matrix<T>& MInvVar,
void modelfunc(fMatrix ZModel, ui htZ, ui lenZ, fVector X, fVector Y, fVector A ),
void derivatives(fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, fVector A, MF_NONLINFITWORKSPACE *ws),
VF_NONLINFITOPTIONS *FitOpts,
MF_NONLINFITWORKSPACE *WorkSpace );
void vector<T>::nonlinfitwW( matrix<T>* Covar, const vector<int>& AStatus,
const vector<T>& X, const vector<T>& Y, const matrix<T>& MZ, const matrix<T>& MInvVar,
void modelfunc(fMatrix ZModel, ui htZ, ui lenZ, fVector X, fVector Y, fVector A ),
void derivatives(fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, fVector A, MF_NONLINFITWORKSPACE *ws),
VF_NONLINFITOPTIONS *FitOpts,
MF_NONLINFITWORKSPACE *WorkSpace ); |
C++ MatObj vereinfacht | #include <OptiVec.h>
void vector<T>::nonlinfit( const vector<int>& AStatus,
const vector<T>& X, const vector<T>& Y, const matrix<T>& MZ,
void modelfunc(fMatrix ZModel, ui htZ, ui lenZ, fVector X, fVector Y, fVector A ),
void derivatives(fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, fVector A, MF_NONLINFITWORKSPACE *ws) );
void vector<T>::nonlinfitwW( matrix<T> Covar, const vector<int>& AStatus,
const vector<T>& X, const vector<T>& Y, const matrix<T>& MZ, const matrix<T>& MInvVar,
void modelfunc(fMatrix ZModel, ui htZ, ui lenZ, fVector X, fVector Y, fVector A ),
void derivatives(fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, fVector A, MF_NONLINFITWORKSPACE *ws) );
void vector<T>::nonlinfitwW( matrix<T>* Covar, const vector<int>& AStatus,
const vector<T>& X, const vector<T>& Y, const matrix<T>& MZ, const matrix<T>& MInvVar,
void modelfunc(fMatrix ZModel, ui htZ, ui lenZ, fVector X, fVector Y, fVector A ),
void derivatives(fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, fVector A, MF_NONLINFITWORKSPACE *ws) ); |
Pascal/Delphi | uses MFnlfit;
function MF_nonlinfit( A: fVector; AStatus: iVector; nParameters: UInt;
X, Y: fVector; MZ: fMatrix; htZ, lenZ:UIntSize;
ModelFunc, Derivatives: Pointer;
FitOpts: PVF_NONLINFITOPTIONS;
WorkSpace: PMF_NONLINFITWORKSPACE ): Single;
function MF_nonlinfitwW( A: fVector; Covar: fMatrix; AStatus: iVector; nParameters: UInt;
X, Y: fVector; MZ, MInvVar: fMatrix; htZ, lenZ:UIntSize;
ModelFunc, Derivatives: Pointer;
FitOpts: PVF_NONLINFITOPTIONS;
WorkSpace: PMF_NONLINFITWORKSPACE ): Single;
Syntax der als Parameter übergebenen Funktionen ModelFunc und Derivatives:
procedure ModelFunc( ZModel:fMatrix; htZ, lenZ:UIntSize; X, Y:fVector; A:fVector );
procedure Derivatives( dZdAi:fMatrix; htZ, lenZ:UIntSize; X, Y:fVector; ipar:UInt; A:fVector; ws:PMF_NONLINFITWORKSPACE );
|
Pascal/Delphi vereinfacht | uses MFnlfit;
function MF_nonlinfit( A: fVector; AStatus: iVector; nParameters: UInt;
X, Y: fVector; MZ: fMatrix; htZ, lenZ:UIntSize;
ModelFunc, Derivatives: Pointer ): Single;
function MF_nonlinfitwW( A: fVector; Covar: fMatrix; AStatus: iVector; nParameters: UInt;
X, Y: fVector; MZ, MInvVar: fMatrix; htZ, lenZ:UIntSize;
ModelFunc, Derivatives: Pointer ): Single; | |
Beschreibung | Die X-Y-Z-Eingabedaten werden benutzt, um den Parameter-Vektor A mit npars Elementen ai für eine beliebige Modell-Funktion z = f(x, y) zu bestimmen.
Argumente:
A | Vektor der Länge npars; gibt die berechneten Koeffizienten zurück |
Covar | Matrix der Dimensionen [npars, npars]; gibt die Kovarianzen der Koeffizenten zurück |
AStatus | Vektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind |
npars | Gesamtzahl der Parameter |
X, Y | Vektoren der Länge lenZbzw. htZ, die das X-Y-Koordinatensystem der Matrix Z aufspannen |
MZ, MInvVar | Matrizen der Dimensionen [htZ, lenZ] mit den Eingabedaten sowie, bei der gewichteten Variante, dem Kehrwert von deren Varianzen |
modelfunc | Benutzer-definierte Modell-Funktion |
derivatives | Benutzer-definierte Funktion, die die partiellen Ableitungen der Modellfunktion nach den einzelnen Parametern berechnet |
FitOpts | Zeiger auf eine Struktur mit Anpassungs-Optionen, siehe chap. 13.3 |
WorkSpace | Zeiger auf eine Struktur mit internen Variablen, siehe chap. 13.3 |
Die Modell-Funktion (und damit der Parameter-Vektor) kann mehr Parameter enthalten als tatsächlich angepaßt werden sollen. Daher muss ein zusätzlicher Vektor AStatus die Information darüber enthalten, welche Parameter bei ihren Eingabe-Werten eingefroren bleiben sollen (AStatus[i] = 0) und welche anzupassen sind (AStatus[i] = 1). Alle (also auch die freien!) Parameter müssen in A vor dem Aufruf von MF_nonlinfit initialisiert sein. Je besser man sie "errät", desto schneller konvergiert diese Routine. npars bezeichnet die Gesamtzahl der Parameter in A (also nicht nur die freien Parameter!).
Die Modell-Funktion "modelfunc" ist vom Anwender zu schreiben. Sie hat für eine gegebene X-Y-Vektorpaare die entsprechenden theoretischen MZ-Werte zu berechnen. In C/C++ muss sie wie folgt geschrieben werden:
| Modell-Funktion für C/C++ |
void _cdecl MyFunc( fMatrix Z, ui htZ, ui lenZ, fVector X, fVector Y, fVector A )
{
for(ui i=0; i<htZ; i++ )
for(ui j=0; j<lenZ; j++ )
MZ[i][j] = f( X[j], Y[i] );
}
Dabei ist f( X[j], Y[i] ) eine beliebige Funktion, die so kompliziert sein darf, wie es Ihre Anwendung erfordert. Sie darf aber keine Singularitäten besitzen, zumindest innerhalb der ggf. spezifizierten Unter- und Obergrenzen der Parameter (siehe NONLINFITOPTIONS).
Zusätzlich zu der Modell-Funktion benötigt MF_nonlinfit die partiellen Ableitungen von MZ nach allen Parametern A[ipar] entsprechend dem gewählten Modell. Falls sie zumindest zum Teil analytisch bekannt sind, solte man eine Funktion MyDerivs schreiben. Dabei können diejenigen partiellen Ableitungen, die man doch nicht kennt, durch Aufruf von MF_nonlinfit_autoDeriv numerisch berechnet werden.
| Partielle Ableitungen für C/C++ |
void _cdecl MyDerivs( fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, fVector A, MF_NONLINFITWORKSPACE *ws )
{
ui i;
switch( ipar )
{
case 0:
for(i=0; i<htZ; i++ )
for( j=0; j<lenZ; j++ )
dZdAi[i][j] = part_Abl_MZ_nach_A0( X[j], Y[i] );
break;
case 1:
for(i=0; i<htZ; i++ )
for( j=0; j<lenZ; j++ )
dZdAi[i][j] = part_Abl_MZ_nach_A1( X[j], Y[i] );
break;
default: /* für alle unbekannten Ableitungen: */
MF_nonlinfit_autoDeriv( dZdAi, htZ, lenZ, X, Y, ipar, A, ws );
}
}
Ein Aufruf von MF_nonlinfit wird wie folgt aussehen:
MF_nonlinfit( A, AStatus, npars, X, Y, MZ, htZ, lenZ, MyFunc, MyDerivs, &FitOpts, &WorkSpace );
oder in vereinfachter Syntax (nur, wenn kein expliziter Aufruf von MF_nonlinfit_autoDeriv erforderlich ist):
MF_nonlinfit( A, AStatus, npars, X, Y, MZ, htZ, lenZ, MyFunc, MyDerivs );
Falls überhaupt keine der partiellen Ableitungen analytisch bekannt sind, definiere man auch MyDerivs nicht, sondern setze derivatives = NULL im Aufruf von MF_nonlinfit.
MF_nonlinfit( A, AStatus, npars, X, Y, MZ, htZ, lenZ, MyFunc, NULL );
| Modell-Funktion für Pascal/Delphi |
In Pascal/Delphi muss die Modell-Funktion wie folgt geschrieben werden:
procedure MyFunc( MZ:fMatrix; htZ, lenZ:UIntSize; X, Y, A:fVector );
var i, j:UIntSize;
begin
for i:=0 to htZ-1 do
for j:=0 to lenZ-1 do
MF_Pelement( MZ, htZ, lenZ, i, j )^ :=
f( VF_element( X, j ), VF_element( Y, i ) );
end;
Dabei ist f( Xj, Yi ) eine beliebige Funktion, die so kompliziert sein darf, wie es Ihre Anwendung erfordert. Sie darf aber keine Singularitäten besitzen, zumindest innerhalb der ggf. spezifizierten Unter- und Obergrenzen der Parameter (siehe NONLINFITOPTIONS).
Zusätzlich zu der Modell-Funktion benötigt MF_nonlinfit die partiellen Ableitungen von MZ nach allen Parametern A[ipar] entsprechend dem gewählten Modell. Falls sie zumindest zum Teil analytisch bekannt sind, solte man eine Funktion MyDerivs schreiben. Dabei können diejenigen partiellen Ableitungen, die man doch nicht kennt, durch Aufruf von MF_nonlinfit_autoDeriv numerisch berechnet werden.
| Partielle Ableitungen für Pascal/Delphi |
procedure MyDerivs( dZdAi:fMatrix; htZ, lenZ:UIntSize; X, Y:fVector; ipar:UInt; A:fVector; ws:PMF_NONLINFITWORKSPACE );
var i, j:UIntSize;
begin
case ipar of
0: begin
for i:=0 to ht-1 do
for j:=0 to len-1 do
MF_Pelement( dZdAi, htZ, lenZ, i, j )^ := part_Abl_MZ_nach_A0(VF_element( X, j ),
VF_element( Y, i ));
end;
1: begin
for i:=0 to ht-1 do
for j:=0 to len-1 do
MF_Pelement( dZdAi, htZ, lenZ, i, j )^ := part_Abl_MZ_nach_A1(VF_element( X, j ),
VF_element( Y, i ));
end;
else (* für alle unbekannten Ableitungen: *)
MF_nonlinfit_autoDeriv( dZdAi, htZ, lenZ, X, Y, ipar, A, ws );
end;
end;
Ein Aufruf von MF_nonlinfit sieht dann so aus:
MF_nonlinfit( A, AStatus, npars, MZ, htZ, lenZ, X, Y, @MyFunc, @MyDerivs );
oder in vereinfachter Syntax (nur, wenn kein expliziter Aufruf von MF_nonlinfit_autoDeriv erforderlich ist:
MF_nonlinfit( A, AStatus, npars, MZ, htZ, lenZ, X, Y, @MyFunc, @MyDerivs );
Man beachte die Adress-Operatoren vor "MyFunc " und "MyDerivs". Falls überhaupt keine der partiellen Ableitungen analytisch bekannt sind, definiere man auch MyDerivs nicht, sondern setze derivatives := nil im Aufruf von MF_nonlinfit:
MF_nonlinfit( A, AStatus, npars, MZ, htZ, lenZ, X, Y, @MyFunc, nil );
In der gewichteten Variante MF_nonlinfitwW muss die Matrix MInvVar den Kehrwert der Varianzen der einzelnen X-Y-Z-Datenpunkte enthalten, und die Matrix MCovar gibt die Kovarianzen der Parameter ai zurück: MCovari,j = covariance( ai, aj ). Theoretisch gilt covariance(ai, aj) = covariance(aj, ai); durch Rundungsfehler kann es aber zu geringfügigen Abweichungen kommen.
| Sowohl C/C++ als auch Pascal/Delphi: |
Bezüglich der vielen verschieden Optionen zur Steuerung der nicht-linearen Datenapassungs-Routinen von OptiVec lese man Kap. 13.3. Hilfsfunktionen zum Abbruch überlang laufender Anpassungen und zur Überwachung des Fortganges dieser oft sehr zeitaufwendigen Prozeduren sind in Kap. 13.5 zusammengefaßt und, im Spezialfall von MF_nonlinfit, hier beschrieben. |
|
Beschränkungen des Multi-threading | Die in den OptiVec-Versionen bis einschließlich 6.1 vorhandenen Multi-Threading-Einschränkungen sind mit Version 6.2 aufgehoben.
Diese Funktionen dürfen nicht aufgerufen werden, wenn die FPU auf reduzierte Genauigkeit geschaltet wurde. Andernfalls können sie in einer unendlichen Schleife hängenbleiben, siehe V_setFPAccuracy. |
|
Fehlerbehandlung | Übersteigt die Zahl der freien Parameter (also derjenigen mit AStatus[i] = 1) die Gesamtzahl der anzupassenden Datenpunkte, so wird eine Fehlermeldung "Invalid parameter(s)" ausgegeben und das Programm abgebrochen. |
|
Rückgabewert | Bei Erfolg: Anpassungstest-Wert c2 (chi-Quadrat) Wenn keine Verbesserung des Parametersatzes erzielt werden konnte: -1 |
|
|
MF_nonlinfit_...
| MD_nonlinfit_... |
ME_nonlinfit_... |
MF_nonlinfitwW_... |
MD_nonlinfitwW_... |
ME_nonlinfitwW_... |
|
|
Syntax C/C++ | #include <MFstd.h>
void MF_nonlinfit_autoDeriv( fMatrix dZdAi, ui htZ, ui lenZ, fVector X, fVector Y, unsigned ipar, fVector A, MF_NONLINFITWORKSPACE *ws );
float MF_nonlinfit_getFOM( MF_NONLINFITWORKSPACE *ws );
void MF_nonlinfit_getBestValues( fVector ABest, MF_NONLINFITWORKSPACE *ws );
unsigned MF_nonlinfit_getTestRun( MF_NONLINFITWORKSPACE *ws );
unsigned MF_nonlinfit_getTestPar( MF_NONLINFITWORKSPACE *ws );
int MF_nonlinfit_getTestDir( MF_NONLINFITWORKSPACE *ws );
void MF_nonlinfit_stop( MF_NONLINFITWORKSPACE *ws );
(identidsche Syntax für die MF_nonlinfitwW_...-Funktionen) |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::nonlinfit_getFOM( MF_NONLINFITWORKSPACE *ws );
void vector<T>::Mnonlinfit_getBestValues( MF_NONLINFITWORKSPACE *ws );
unsigned matrix<T>::nonlinfit_getTestPar( MF_NONLINFITWORKSPACE *ws );
unsigned matrix<T>::nonlinfit_getTestRun( MF_NONLINFITWORKSPACE *ws );
void matrix<T>::nonlinfit_stop( MF_NONLINFITWORKSPACE *ws );
(identische Syntax für die nonlinfitwW_...-Funktionen) |
Pascal/Delphi | uses MFnlfit;
procedure MF_nonlinfit_autoDeriv( dZdAi:fMatrix; htZ, lenZ:UIntSize; X, Y:fVector; ipar:UInt; A:fVector; ws:PMF_NONLINFITWORKSPACE );
function MF_nonlinfit_getFOM( ws: PMF_NONLINFITWORKSPACE ): Single;
procedure MF_nonlinfit_getBestValues( BestValues: fVector; ws: PMF_NONLINFITWORKSPACE );
function MF_nonlinfit_getTestRun( ws: PMF_NONLINFITWORKSPACE ): UInt;
function MF_nonlinfit_getTestPar( ws: PMF_NONLINFITWORKSPACE ): UInt;
function MF_nonlinfit_getTestDir( ws: PMF_NONLINFITWORKSPACE ): Integer;
procedure MF_nonlinfit_stop( ws: PMF_NONLINFITWORKSPACE );
(identidsche Syntax für die MF_nonlinfitwW_...-Funktionen) |
|
Beschreibung | MF_nonlinfit_autoDeriv differenziert eine benutzerdefinierte Modell-Funktion z=f(x, y) nach deren Parametern aipar. Die Modell-Funktion, die differenziert werden soll, ist diejenige, die in demselben Aufruf an MF_nonlinfit übergeben wurde.
Die folgenden Funktionen gestatten es, den Fortgang nicht-linearer Anpassungs-Operationen zu verfolgen. Sie können entweder aus der benutzerdefinierten Modell-Funktion heraus oder - bei Multithread-Anwendungen - auch aus einem zweiten Thread heraus aufgerufen werden.
MF_nonlinfit_getFOM gibt den besten bislang erzielten Anpassungstest-Wert (c2 oder, für robuste Fits, |c|) zurück. Ruft man diese Funktion auf, bevor MF_nonlinfit die Chance hatte, c2 erstmalig zu berechnen, so wird -1.0 zurückgegeben.
MF_nonlinfit_getBestValues speichert den besten bislang gefundenen Parametersatz A in dem als Argument angeforderten Vektor ABest.
MF_nonlinfit_getTestDir liefert die Test-Richtung (+1 für aufwärts, -1 für abwärts) während "Ausbruchsversuchen" aus eventuellen lokalen Optima, die andernfalls das Erreichen des globalen Optimums verhindern würden (LevelOfMethod > 3 in VF_setNonlinfitOptions spezifiziert).
MF_nonlinfit_getTestPar gibt den Index des gerade bezüglich "Ausbruchs" getesteten Parameters zurück.
MF_nonlinfit_getTestRun liefert den Index des aktuellen "Ausbruchstest"-Durchlaufes. Für jeden angepaßten Parameter wird ein Testdurchlauf durchgeführt. Die Reihenfolge, in der die Parameter geprüft werden, wird intern so festgelegt, dass die sensitivsten Parameter zuerst an die Reihe kommen.
MF_nonlinfit_stop sorgt dafür, dass MF_nonlinfit seinen aktuellen Levenberg-Marquardt- oder Downhill-Simplex-Zyklus beendet, die Ausgabe-Parameter auf den besten Stand bringt und zur aufrufenden Funktion zurückkehrt. Auf diese Weise können überlange Anpassungs-Sitzungen (insbesondere solche mit "Ausbruchs"-Versuchen) ohne Datenverluste abgebrochen werden. |
|
|
MF_outerprod
| MD_outerprod |
ME_outerprod |
MCF_outerprod |
MCD_outerprod |
MCE_outerprod |
MI_outerprod | MBI_outerprod | MSI_outerprod | MLI_outerprod | MQI_outerprod |
MU_outerprod | MUB_outerprod | MUS_outerprod | MUL_outerprod | MUQ_outerprod |
|
Funktion | Bildung einer Matrix als äußeres Produkt zweier Vektoren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_outerprod( fMatrix MA, fVector X, fVector Y, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::outerprod( const vector<T>& X, const vector<T>& Y ); |
Pascal/Delphi | uses MFstd;
procedure MF_outerprod( MA:fMatrix; X, Y:fVector; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_outerprod( fMatrix d_MA, fVector d_X, fVector d_Y, ui ht, ui len );
void MFcu_outerprod( fMatrix h_MA, fVector h_X, fVector h_Y, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_outerprod( d_MA:fMatrix; d_X, d_Y:fVector; ht, len:UIntSize ): IntBool;
procedure MF_outerprod( h_MA:fMatrix; h_X, h_Y:fVector; ht, len:UIntSize );
|
|
Beschreibung | MAi,j = Xi * Yj |
|
|
MF_Parzen
| MD_Parzen |
ME_Parzen |
|
Funktion | zwei-dimensionales Parzen-Fenster für Raumfrequenz-Analyse |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Parzen( fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Parzen( ); |
Pascal/Delphi | uses MFstd;
procedure MF_Parzen( MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Parzen( fMatrix d_MA, ui ht, ui len );
void MFcu_Parzen( fMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Parzen( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Parzen( h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | MAi,j = (1 - |(i - 0.5*(ht - 1)) / 0.5*(ht + 1)|) * (1 - |(j - 0.5*(len - 1)) / 0.5*(len + 1)|) |
|
|
MF_Pelement
| MD_Pelement |
ME_Pelement |
MCF_Pelement |
MCD_Pelement |
MCE_Pelement |
MI_Pelement | MBI_Pelement | MSI_Pelement | MLI_Pelement | MQI_Pelement |
MU_Pelement | MUB_Pelement | MUS_Pelement | MUL_Pelement | MUQ_Pelement |
|
Funktion | Zeiger auf ein Matrix-Element |
|
Syntax C/C++ | #include <MFstd.h>
float * MF_Pelement( fMatrix X, ui ht, ui len, unsigned m, unsigned n ); |
C++ MatObj | #include <OptiVec.h>
T * matrix<T>::Pelement( const unsigned m, const unsigned n ); |
Pascal/Delphi | uses MFstd;
function MF_Pelement( MA:fMatrix; ht, len, m, n:UIntSize ): PSingle; |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
float * cudaMF_Pelement( fMatrix MA, ui ht, ui len, unsigned m, unsigned n );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Pelement( d_MA:fMatrix; ht, len, m, n:UIntSize ): PSingle;
|
|
Beschreibung | Ein Zeiger auf das Element MAm,n wird zurückgegeben.
Diese Funktion gestattet den Zugriff auf einzelne Elemente dynamisch allozierter Matrizen. Um mit dieser Funktion ein Matrix-Element zu setzen, dereferenziere man den erhaltenen Zeiger: |
C/C++ | *MF_Pelement( MA, ht, len, m, n ) = 3.5; |
Pascal/Delphi | MF_Pelement( MA, ht, len, m, n )^ := 3.5;
Der bessere Weg, einzelne Elemente zu setzen, ist allerdings die Funktion MF_setElement. Sie stellt auch die einzige Möglichkeit fü Schreib-Zugriff auf einzelne Elemente bei CUDA-Matrizen dar.
Ausschließlicher Lese-Zugriff auf Matrix-Elemente wird auch durch die verwandten Funktionen MF_element und MF_getElement geboten. |
|
Rückgabewert | Zeiger auf das Matrix-Element MAm,n |
|
|
|
Funktion | Nur cudaOptiVec: Eine einzelne Matriz im "pinned" Host-Memory freigeben |
|
CUDA-Funktion C/C++ | #include <cudaMatLib.h>
int cudaM_pinnedFree( void **h_MA );
|
CUDA-Funktion Pascal/Delphi | uses VecLib;
function cudaM_pinnedFree( h_X:Pointer ): IntBool;
|
|
Beschreibung | Die "pinned" Host-Memory-Matrix MA wird freigegeben (also de-alloziert). Diese Funktion benötigt die Host-Adresse (nicht die Device-Adresse!) der "pinned" Matrix als Argument. Um mehrere "pinned" Matrizen gleichzeitig freizugeben, rufe man cudaM_pinnedNfree (C/C++ only). |
|
Fehlerbehandlung | Der Versuch, eine "pinned" Matrix freizugeben, die
bereits freigegeben oder der gar nicht erst alloziert wurde, führt zu einer Warnung "Cannot free non-existent vector". Das Programm wird in diesem Fall fortgesetzt, ohne dass etwas freigegeben wird. |
|
Rückgabewert | FALSE (0) bei Erfolg, sonst TRUE (nicht-Null) |
|
|
cudaMF_pinnedMatrix
| cudaMD_pinnedMatrix |
cudaME_pinnedMatrix |
cudaMCF_pinnedMatrix |
cudaMCD_pinnedMatrix |
cudaMCE_pinnedMatrix |
cudaMI_pinnedMatrix | cudaMBI_pinnedMatrix | cudaMSI_pinnedMatrix |
cudaMLI_pinnedMatrix | cudaMQI_pinnedMatrix | |
cudaMU_pinnedMatrix | cudaMUB_pinnedMatrix | cudaMUS_pinnedMatrix |
cudaMUL_pinnedMatrix | cudaMUQ_pinnedMatrix | cudaMUI_pinnedMatrix |
|
Funktion | Erzeugung einer "pinned" Host-Memory-Matrix |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
fMatrix cudaMF_pinnedMatrix( fMatrix *h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses VecLib;
function cudaMF_pinnedMatrix( var h_MA:fMatrix; ht, len:UIntSize ): fMatrix;
|
|
Beschreibung | Host-Speicher für eine Matrix wird reserviert und in den "pinned"-Zustand überführt. Der Device-Zeige wird zurückgegeben; der Host-Zeiger wird als h_MA gespeichert. Um den so reservierten Speicher wieder freizugeben, benutze man cudaM_pinnedFree, cudaM_pinnedFreeAll, or cudaM_pinnedNfree (letztere Funktion nur in C/C++).
Eine Beschreibung der verschiedenen in cudaOptiVec verwendeten Speichertypen findet sich in CudaOptiVecD.htm, Kap. 3. |
|
Fehlerbehandlung | Falls nicht genug Speicher vorhanden ist, oder im Falle von size=0, wird eine Fehlermeldung "Not enough memory" ausgegeben und das Programm abgebrochen.
|
|
Rückgabewert | Device-Zeiger auf den reservierten Speicherbereich |
|
|
cudaMF_pinnedMatrix0
| cudaMD_pinnedMatrix0 |
cudaME_pinnedMatrix0 |
cudaMCF_pinnedMatrix0 |
cudaMCD_pinnedMatrix0 |
cudaMCE_pinnedMatrix0 |
cudaMI_pinnedMatrix0 | cudaMBI_pinnedMatrix0 | cudaMSI_pinnedMatrix0 |
cudaMLI_pinnedMatrix0 | cudaMQI_pinnedMatrix0 | |
cudaMU_pinnedMatrix0 | cudaMUB_pinnedMatrix0 | cudaMUS_pinnedMatrix0 |
cudaMUL_pinnedMatrix0 | cudaMUQ_pinnedMatrix0 | cudaMUI_pinnedMatrix0 |
|
Funktion | Reservierung von "pinned" Host-Memory für eine Matrix und Initilisierung mit 0 |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
fMatrix0 cudaMF_pinnedMatrix0( fMatrix0 *h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses VecLib;
function cudaMF_pinnedMatrix0( var h_MA:fMatrix0; ht, len:UIntSize ): fMatrix0;
|
|
Beschreibung | Host-Speicher für eine Matrix wird reserviert, in den "pinned"-Zustand überführt und mit 0 initialisiert. Der Device-Zeige wird zurückgegeben; der Host-Zeiger wird als h_MA gespeichert. Um den so reservierten Speicher wieder freizugeben, benutze man cudaM_pinnedFree, cudaM_pinnedFreeAll, or cudaM_pinnedNfree (letztere Funktion nur in C/C++).
Eine Beschreibung der verschiedenen in cudaOptiVec verwendeten Speichertypen findet sich in CudaOptiVecD.htm, Kap. 3. |
|
Fehlerbehandlung | Falls nicht genug Speicher vorhanden ist, oder im Falle von size=0, wird eine Fehlermeldung "Not enough memory" ausgegeben und das Programm abgebrochen.
|
|
Rückgabewert | Device-Zeiger auf den reservierten Speicherbereich |
|
|
|
Funktion | De-Allocation mehrerer "pinned" Host-Memory Matrizen |
|
CUDA-Funktion C/C++ | #include <cudaMatLib.h>
int cudaV_pinnedNfree( unsigned numfree, ... );
|
|
Beschreibung | Der Parameter numfree teilt der Funktion mit, wie viele Matrizen freizugeben sind. Die Host-Zeiger (also nicht die Device-Zeiger!) dieser Matrizen folgen in der Parameterliste nach numfree. Nur Matrizen, die durch eine Funktion aus der cudaMF_pinnedMatrix- oder cudaMF_pinnedMatrix0-Familie alloziert wurden, können durch cudaM_pinnedNfree freigegeben werden.
Falls versehentlich Device-Zeiger anstelle der Host-Zeiger angegeben werden, gibt diese Funktion eine Fehlermeldung aus.
Pascal/Delphi: Da eine variable Anzahl von Parametern in Pascal/Delphi nicht unterstützt wird, existiert diese Funktion hier nicht. |
Beispiel C/C++ | cudaM_pinnedNfree( 3, h_MX, h_MY, h_MZ ); |
|
Rückgabewert | FALSE (0) bei Erfolg, sonst TRUE (nicht-Null) |
|
|
VF_polyfit
| VD_polyfit |
VE_polyfit |
VF_polyfitwW |
VD_polyfitwW |
VE_polyfitwW |
VF_polyfitEven
| VD_polyfitEven |
VE_polyfitEven |
VF_polyfitEvenwW |
VD_polyfitEvenwW |
VE_polyfitEvenwW |
VF_polyfitOdd
| VD_polyfitOdd |
VE_polyfitOdd |
VF_polyfitOddwW |
VD_polyfitOddwW |
VE_polyfitOddwW |
|
Funktion | Polynom-Koeffizienten an X-Y-Datensatz anpassen |
|
Syntax C/C++ | #include <MFstd.h>
int VF_polyfit( fVector A, unsigned deg, fVector X, fVector Y, ui sizex );
int VF_polyfitwW( fVector A, fMatrix Covar, unsigned deg, fVector X, fVector Y, fVector InvVar, ui sizex );
identische Syntax für VF_polyfitEven, VF_polyfitEvenwW, VF_polyfitOdd, VF_polyfitOddwW |
C++ MatObj | #include <OptiVec.h>
int vector<T>::polyfit( const vector<T>& X, const vector<T>& Y );
int vector<T>::polyfitwW( matrix<T> Covar, const vector<T>& X, const vector<T>& Y, const vector<T>& InvVar );
int vector<T>::polyfitwW( matrix<T>* Covar, const vector<T>& X, const vector<T>& Y, const vector<T>& InvVar );
identische Syntax für polyfitEven, polyfitEvenwW, polyfitOdd, polyfitOddwW |
Pascal/Delphi | uses MFstd;
function VF_polyfit( A:fVector; deg:UInt; X, Y:fVector; sizex:UIntSize ): IntBool;
function VF_polyfitwW( A:fVector; Covar:fMatrix; deg:UInt, X, Y, InvVar:fVector; sizex:UIntSize ): IntBool;
identische Syntax für VF_polyfitEven, VF_polyfitEvenwW, VF_polyfitOdd, VF_polyfitOddwW |
|
Beschreibung | Die Eingabe-Daten werden zur Bestimmung der Koeffizienten ai eines Polynoms deg-ten Grades verwendet.
VF_polyfit, VF_polyfitwW:
Pi = a0 + a1Xi + a2Xi2 ... anXin
A enthät deg+1 Elemente.
VF_polyfitEven, VF_polyfitEvenwW:
Das Polynom besteht ausschließlich aus geraden Termen,
Pi = a0 + a2Xi2 ... a2nXi2n
A enthät deg/2+1 Elemente. Die Koeffizienten der ungeraden Terme (alle = 0) werden nicht gespeichert.
VF_polyfitOdd, VF_polyfitOddwW:
Das Polynom besteht ausschließlich aus ungeraden Termen,
Pi = a1Xi + a3Xi3 ... a2n+1Xi2n+1
A enthät (deg+1)/2 Elemente. Die Koeffizienten der geraden Terme (alle = 0) werden nicht gespeichert.
Die Koeffizienten werden so berechnet, dass die Abweichung zwischen den "theoretischen" (durch Auswertung des Polynoms berechneten) Pi-Werten einerseits und den tatsächlichen Yi-Werten minimiert wird. Genauer gesagt, wird die Anpassungstestfunktion chi-Quadrat,
c2 = Summe( 1/si2 * (Pi - Yi)2 );
minimiert. In den Einzelpunkt-gewichteten Varianten VF_polyfitwW etc. müssen die Werte 1/si2 als Vektor InvVar bekannt sein. In den nicht-gewichteten Varianten werden alle si willkürlich als 1.0 angenommen.
Argumente:
A | Vektor der Länge deg+1; gibt die berechneten Koeffizienten zurück |
Covar | Matrix der Dimensionen [deg+1, deg+1]; gibt die Kovarianzen der Koeffizenten zurück Falls die Kovarianzen nicht benötigt werden, rufe man die Funktion mit Covar= (fMatrix)NULL / nil. |
deg | Grad des Fit-Polynoms |
X, Y, InvVar | Vektoren der Länge sizex mit den Eingabe-Daten |
Es empfiehlt sich, die X-Achse so zu wählen, dass sie den Nullpunkt einschließt. Weit entfernt vom Nullpunkt wird die Anpassung nämlich immer schlechter. Dies liegt an der Form der für die Anpassung verwendeten Polynome, die nur maximal deg-1 Maxima bzw. Minima haben können. Falls Ihre X-Achse beispielsweise von 9 bis 10 reicht, sollten Sie sie lieber um den Betrag -9,5 verschieben, so dass x' = 0 in der Mitte des Bereiches liegt. Eine Verschiebung um -9,0 mit x' =0 am Beginn des Bereiches wäre ebenfalls gut.
In dem sehr seltenen Fall, dass diese Funktion keine Lösung finden kann, gibt sie 1 (TRUE) zurück und setzt alle A[i] = 0. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (!= 0). |
|
|
MF_polyinterpol | MD_polyinterpol | ME_polyinterpol |
|
Funktion | Polynom-Interpolation von Matrix-Elementen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_polyinterpol(
fMatrix MZ, fVector X, fVector Y, ui ht, ui len, fVector XTab, fVector YTab, fMatrix MZTab, ui httab, ui lentab, unsigned degX, unsigned degY ); |
C++ VecObj | #include <OptiVec.h>
void matrix<T>::polyinterpol( const vector<T>& X, const vector<T>& Y, const vector<T>& XTab, const vector<T>& YTab, const matrix<T>& MZTab, unsigned degX, unsigned degY ); |
Pascal/Delphi | uses MFstd;
procedure MF_polyinterpol( MZ:fMatrix; X, Y:fVector; ht, len:UIntSize; XTab, YTab:fVector; MZTab:fMatrix; httab, lentab:UIntSize; degX, degY:UInt ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_polyinterpol( fMatrix d_MZ, fVector d_X, fVector d_Y, ui ht, ui len, fVector d_XTab, fVector d_YTab, fMatrix d_MZTab, ui httab, ui lentab, unsigned degX, unsigned degY );
void MFcu_polyinterpol( fMatrix h_MZ, fVector h_X, fVector h_Y, ui ht, ui len, fVector h_XTab, fVector h_YTab, fMatrix h_MZTab, ui httab, ui lentab, unsigned degX, unsigned degY );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_polyinterpol( d_MZ:fMatrix; d_X, d_Y:fVector; ht, len:UIntSize; d_XTab, d_YTab:fVector; d_MZTab:fMatrix; httab, lentab:UIntSize; degX, degY:UInt ): IntBool;
procedure MFcu_polyinterpol( h_MZ:fMatrix; h_X, h_Y:fVector; ht, len:UIntSize; h_XTab, h_YTab:fVector; h_MZTab:fMatrix; httab, lentab:UIntSize; degX, degY:UInt );
|
|
Beschreibung | Für jedes der ht * len Elemente des durch X und Y aufgespannten Koordinatensystems wird ein MZ-Wert gewonnen durch polynomische Interpolation einer Tabelle. Diese Tabelle muss in Form von XTab-YTab-MZTab-Werten vorliegen. XTab und YTab müssen geordnet sein (strikt aufsteigend oder abfallend). Außerdem müssen jeweils alle Werte von XTab und YTab verschieden sein (es können keine zwei MZTab-Werte zu ein- und demselben XTab- bzw. YTab- Wert gehören!). Andernfalls droht Programmabbruch durch eine Division durch 0.
Der Parameter degX bezeichnet die Anzahl von in die Interpolation in X-Richtung einbezogenen Punkten (also nicht den Grad des interpolierenden Polynoms!). Entsprechend bezeichnet degY die Anzahl von in die Interpolation in Y-Richtung einbezogenen Punkten. Jeder Wert zwischen 0 und 2 wird als lineare Interpolation ausgeführt. Maximal ist eine 10-Punkt-Interpolation möglich. Außerdem muss lentab mindestens degX+1 betragen und httab mindestens degY+1. |
|
Fehlerbehandlung | Werte von degX oder degY > 10 führen zu einer Fehlermeldung "Not possible with more than 10 elements" und zum Programmabbruch. Wenn degX größer ist als lentab-1 oder degY größer als httab-1, wird die Meldung "Invalid parameter(s)" ausgegeben und das Programm ebenfalls abgebrochen.
Andere Fehler werden nicht abgefangen (Sie sind also selbst dafür verantwortlich, dass alle XTab- und YTab-Werte verschieden sind, dass die MZTab-Werte nicht schon nahe an der Überlaufgrenze sind.) |
|
|
|
MF_print
| MD_print |
ME_print |
MCF_print |
MCD_print |
MCE_print |
MI_print | MBI_print | MSI_print | MLI_print | MQI_print |
MU_print | MUB_print | MUS_print | MUL_print | MUQ_print |
|
Funktion | Matrix im ASCII Format in stdout ausgeben (nur Konsolenanwendungen) |
|
Syntax C/C++ | #include <MFstd.h>
void MF_print( fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::print(); |
Pascal/Delphi | uses MFstd;
procedure MF_print( MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_print( fMatrix d_MA, ui ht, ui len );
int cudaMF_print_buf( fMatrix d_MA, ui ht, ui len, fVector h_Wk );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_print( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMF_print_buf( d_MA:fMatrix; ht, len:UIntSize; h_Wk:fVector ): IntBool;
|
|
Beschreibung | Die Matrix A wird auf dem Bildschirm ausgegeben. Jede Bildschirm-Zeile entspricht einer Zeile der Matrix. Die Zeilen werden von 0 and numeriert. Falls nötig, werden die Zeilen am Bildschirmrand abgeschnitten.
C/C++: Die angenommene Zeilenlänge ist in <VecLib.h> als V_consoleWindowWidth definiert. Der Standardwert ist 150 Zeichen. Um eine andere Zeilenlänge zu verwenden, definiere man selbst V_consoleWindowWidth vor dem Einschluss von <VecLib.h>.
Pascal/Delphi: Die angenommene Zeilenlänge ist in der Unit VecLib als Variable V_consoleWindowWidth definiert. Der Standardwert ist 150 Zeichen. Um eine andere Zeilenlänge zu verwenden, weise man einfach den gewünschten Wert zu, z.B.: V_consoleWindowWidth := 80;
Komplexe Zahlen werden in geschweiften Klammern mit einem Komma zwischen dem Real- und dem Imaginärteil geschrieben: {Re, Im}.
Im Gegensatz zu MF_write kann die automatische Wahl des Ausgabeformats nicht verändert werden. Die Anzahl der pro Element ausgegebenen Stellen richtet sich nach dem zur Verfügung stehenden Platz, der wiederum durch die Spaltenzahl len bestimmt wird.
Anders als bei MF_cprint findet keine Aufteilung von Matrizen mit vielen Zeilen auf mehrere Bildschirmseiten statt.
Diese Familie von Funktionen existiert nur für Konsolen-Anwendungen.
nur CUDA-Versionen: cudaM?_print_buf übernimmt einen Host-Vektor h_Wk als zusätzliches Argument. Dieser dient als Pufferspeicher und muss (mindestens) dieselbe Größe haben wie X. Hierdurch wird die interne Bereitstellung von Pufferspeicher bei cudaM?_print eingespart, so dass cudaM?_print_buf etwas schneller ist.
|
|
|
MF_random
| MD_random |
ME_random |
MCF_random |
MCD_random |
MCE_random |
MI_random | MBI_random | MSI_random | MLI_random | MQI_random |
MU_random | MUB_random | MUS_random | MUL_random | MUQ_random |
|
Funktion | Matrix mit gleichverteilten Zufallszahlen hoher Qualität füllen |
|
Syntax C/C++ | #include <MFstd.h>
long MF_random( fMatrix MA, ui ht, ui len, long seed, float MinVal, float MaxVal ); |
C++ MatObj | #include <OptiVec.h>
long matrix<T>::random( const long& seed, const T& MinVal, const T& MaxVal ); |
Pascal/Delphi | uses MFstd;
function MF_random( MA:fMatrix; ht, len:UIntSize; seed:LongInt; MinVal, MaxVal:Single ): LongInt; |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_random( fMatrix d_MA, ui ht, ui len, long seed, float MinVal, float MaxVal );
int cusdMF_random( fMatrix d_MA, ui ht, ui len, long seed, float *d_MinVal, float *d_MaxVal );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_random( d_MA:fMatrix; ht, len:UIntSize; seed:LongInt; MinVal, MaxVal:Single ): IntBool;
function cusdMF_random( d_MA:fMatrix; ht, len:UIntSize; seed:LongInt; d_MinVal, d_MaxVal:PSingle ): IntBool;
|
|
Beschreibung | Die Matrix A wird mit einer Sequenz von Pseudo-Zufallszahlen gefüllt. Innerhalb des durch MinVal und MaxVal begrenzten Bereiches (die Extremwerte eingeschlossen) sind alle Zahlen prinzipiell gleich wahrscheinlich. Lediglich durch die beschränkte Anzahl von Nachkomma-Stellen entstehen größenabhängige Rundungseffekte, die aber praktisch meist keine Bedeutung haben. Der Start- Parameter seed kann völlig beliebig gewählt werden. Aufeinander folgende Aufrufe mit demselben Wert von seed führen zu identischen Sequenzen. Für unterschiedliche Werte von seed sind die erzeugten Sequenzen miteinander unkorreliert.
Intern gebrauchen diese Funktionen einen 32-bit-Zufallszahlengenerator nach H.W.Lewis, wobei zusätzliche Schritte (sog. "Bays-Durham shuffle") der vollständigen Vermeidung sequentieller Korrelationen dienen. So wird eine hohe Qualität der Zufallszahlen erzielt, die diejenige von einfacheren Generatoren wie der C/C++-Funktion rand oder der Pascal-Funktion Random bei weitem übertrifft.
Ein long-Wert wird zurückgegeben, der als neuer seed-Wert für spätere Aufrufe verwendet werden kann.
Es gibt keine MFcu_-Version dieser Funktion, da die Zufallszahlen ohnehin auf der CPU generiert werden. |
|
|
Rückgabewert | letzte intern generierte 32-bit-Zufallszahl; kann als neuer Startwert für spätere Aufrufe verwandt werden |
|
|
MF_randomLC
| MD_randomLC |
ME_randomLC |
MCF_randomLC |
MCD_randomLC |
MCE_randomLC |
MI_randomLC | MBI_randomLC | MSI_randomLC | MLI_randomLC | MQI_randomLC |
MU_randomLC | MUB_randomLC | MUS_randomLC | MUL_randomLC | MUQ_randomLC; |
|
Function | Matrix mit gleichverteilten Zufallszahlen hoher Qualität initialisieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_randomLC( fMatrix MA, ui ht, ui len, long seed, float MinVal, float MaxValV_RANDOMLCSTATE *state ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::randomLC( const long& seed, const T& MinVal, const T& MaxVal, V_RANDOMLCSTATE *h_state ); |
Pascal/Delphi | uses MFstd;
procedure MF_randomLC( MA:fMatrix; ht, len:UIntSize; seed:LongInt; MinVal, MaxVal:Single; state:PV_RANDOMLCSTATE ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_randomLC( fMatrix d_MA, ui ht, ui len, long seed, float MinVal, float MaxVal, V_RANDOMLCSTATE *h_state );
int cusdMF_randomLC( fMatrix d_MA, ui ht, ui len, long seed, float *d_MinVal, float *d_MaxVal, V_RANDOMLCSTATE *h_state );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_randomLC( d_MA:fMatrix; ht, len:UIntSize; seed:LongInt; MinVal, MaxVal:Single; h_state:PV_RANDOMLCSTATE ): IntBool;
function cusdMF_randomLC( d_MA:fMatrix; ht, len:UIntSize; seed:LongInt; d_MinVal, d_MaxVal:PSingle; h_state:PV_RANDOMLCSTATE ): IntBool;
|
|
Beschreibung | Die Matrix MA wird mit einer Sequenz von Pseudo-Zufallszahlen gefüllt. Innerhalb des durch MinVal und MaxVal begrenzten Bereiches (die Extremwerte eingeschlossen) sind alle Zahlen prinzipiell gleich wahrscheinlich. Lediglich durch die beschränkte Anzahl von Nachkomma-Stellen in den Fließkomma-Versionen entstehen größenabhängige Rundungseffekte, die aber praktisch meist keine Bedeutung haben.
Der Start-Parameter seed kann willkürlich gewählt werden, wobei ein Wert ungleich 0 Initialisierung des Generators und Start einer neuen Serie bewirkt, während ein Aufruf mit seed=0 und demselben state zur Fortsetzung der zuletzt generierten Serie führt. Aufrufe mit demselben Wert von seed ergeben identische Resultate; für verschiedene Werte von seed sind die Resultate unkorreliert.
Intern gebrauchen diese Funktionen für die kleineren Datentypen einen linear-kongruenten (daher der Namensteil "LC") 32-bit-Zufallszahlengenerator nach H.W. Lewis und für die größeren eine 64-bit-Variante, wobei zusätzliche Schritte (sog. "Bays-Durham shuffle") der vollständigen Vermeidung sequentieller Korrelationen dienen. So wird eine hohe statistische Qualität der Zufallszahlen erzielt. Da dieser Algorithmus aber allgemein bekannt ist und aus einem gegebenen Abschnitt der generierten Serie von gewisser Länge der Zustand des Generators erschlossen werden kann (und damit die folgenden Zahlen vorhergesagt werden können), besitzen diese Funktionen keine kryptographische Eignung!
Als vereinfachte Form dieser Funktion steht MF_random zur Verfügung.
Es gibt keine MFcu_-Version dieser Funktion, da die Zufallszahlen ohnehin auf der CPU generiert werden. |
|
|
|
|
MF_ratinterpol | MD_ratinterpol | ME_ratinterpol |
|
Funktion | diagonal-rationale Interpolation von Matrix-Elementen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_ratinterpol( fMatrix MZ, fVector X, fVector Y, ui ht, ui len, fVector XTab, fVector YTab, fMatrix MZTab, ui httab, ui lentab, unsigned degX, unsigned degY ); |
C++ VecObj | #include <OptiVec.h>
void matrix<T>::ratinterpol( const vector<T>& X, const vector<T>& Y, const vector<T>& XTab, const vector<T>& YTab, const matrix<T>& MZTab, unsigned degX, unsigned degY ); |
Pascal/Delphi | uses MFstd;
procedure MF_ratinterpol( MZ:fMatrix; X, Y:fVector; ht, len:UIntSize; XTab, YTab:fVector; MZTab:fMatrix; httab, lentab:UIntSize; degX, degY:UInt ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_ratinterpol( fMatrix d_MZ, fVector d_X, fVector d_Y, ui ht, ui len, fVector d_XTab, fVector d_YTab, fMatrix d_MZTab, ui httab, ui lentab, unsigned degX, unsigned degY );
void MFcu_ratinterpol( fMatrix h_MZ, fVector h_X, fVector h_Y, ui ht, ui len, fVector h_XTab, fVector h_YTab, fMatrix h_MZTab, ui httab, ui lentab, unsigned degX, unsigned degY );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_ratinterpol( d_MZ:fMatrix; d_X, d_Y:fVector; ht, len:UIntSize; d_XTab, d_YTab:fVector; d_MZTab:fMatrix; httab, lentab:UIntSize; degX, degY:UInt ): IntBool;
procedure MFcu_ratinterpol( h_MZ:fMatrix; h_X, h_Y:fVector; ht, len:UIntSize; h_XTab, h_YTab:fVector; h_MZTab:fMatrix; httab, lentab:UIntSize; degX, degY:UInt );
|
|
Beschreibung | Für jedes der ht * len Elemente des durch X und Y aufgespannten Koordinatensystems wird ein MZ-Wert gewonnen durch diagonal-rationale Interpolation einer Tabelle. Diese Tabelle muss in Form von XTab-YTab-MZTab-Werten vorliegen. XTab und YTab müssen geordnet sein (strikt aufsteigend oder abfallend). Außerdem müssen jeweils alle Werte von XTab und YTab verschieden sein (es können keine zwei MZTab-Werte zu ein- und demselben XTab- bzw. YTab- Wert gehören!). Andernfalls droht Programmabbruch durch eine Division durch 0.
Der Parameter degX bezeichnet die Anzahl von in die Interpolation in X-Richtung einbezogenen Punkten. Entsprechend bezeichnet degY die Anzahl von in die Interpolation in Y-Richtung einbezogenen Punkten. Als Interpolationsfunktion wird der Quotient zweier Polynome verwendet, wobei das Polynom im Nenner von demselben Grad (bei geradem deg) oder um einen Grad höher ist (bei ungeradem deg) als das Polynom im Zähler. Diese Art der Interpolation ist insbesondere dann, wenn Polstellen vorhanden sind, der Polynom-Interpolation überlegen, allerdings deutlich langsamer als diese.
degX und degY müssen zwischen 3 und 20 liegen. Außerdem muss lentab mindestens degX+1 betragen und httab mindestens degY+1. |
|
Fehlerbehandlung | Eine Polstelle (d.h. ein Wert von Unendlich) in der Interpolationsfunktion wird als SING-Fehler behandelt mit dem Ergebnis ±HUGE_VAL. (Der in C/C++ an _matherr übergebene x-Wert ist dabei das erste Element von XTab, falls die Polstelle bei der Interpolation in X-Richtung auftritt, oder das erste Element von YTab, falls die Polstelle bei der Interpolation in Y-Richtung auftritt). Werte von degX oder degY > 20 führen zu einer Fehlermeldung "Not possible with more than 20 elements" und zum Programmabbruch. Wenn degX oder degY < 3 sind, wenn degX größer ist als lentab-1 oder degY größer als httab-1, wird die Meldung "Invalid parameter(s)" ausgegeben und das Programm ebenfalls abgebrochen.
Andere Fehler werden nicht abgefangen (Sie sind also selbst dafür verantwortlich, dass alle XTab- und YTab-Werte verschieden sind.) |
|
|
|
MCF_read |
MCD_read |
MCE_read |
MI_read | MBI_read | MSI_read | MLI_read | MQI_read |
MU_read | MUB_read | MUS_read | MUL_read | MUQ_read |
|
Funktion | eine Matrix im ASCII-Format aus einem Stream einlesen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_read( fMatrix MA, ui ht, ui len, FILE *stream ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::read( FILE *stream ); |
Pascal/Delphi | uses MFstd;
{Delphi-Version:}
procedure MF_read( MA:fMatrix; ht, len:UIntSize; var Stream:TextFile );
{Turbo Pascal-Version:}
procedure MF_read( MA:fMatrix; ht, len:UIntSize; var Stream:Text ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_read( fMatrix d_MA, ui ht, ui len, FILE *stream );
int cudaMF_read_buf( fMatrix d_MA, ui ht, ui len, FILE *stream, fVector h_Wk );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_read( d_MA:fMatrix; ht, len:UIntSize; var Stream:TextFile ): IntBool;
function cudaMF_read_buf( d_MA:fMatrix; ht, len:UIntSize; var Stream:TextFile; h_Wk:fVector ): IntBool;
|
|
Beschreibung | Die Matrix A mit ht*len Elementen wird im ASCII-Format aus stream eingelesen. Normalerweise wird man diese Funktion verwenden, um Matrizen aus anderen Programmen zu importieren, die Zahlen nicht im PC-Maschinenformat speichern können. Man kann sie auch benutzen, um Matrizen wiederherzustellen, die zuvor mittels MF_write gespeichert wurden. Um Zwischenergebnisse zu speichern und wiederherzustellen, sollte man allerdings das Funktionenpaar MF_store / MF_recall unbedingt gegenüber MF_write / MF_read vorziehen (über die Gründe siehe MF_write).
Komplexe Versionen:
Real- und Imaginär-Teil dürfen (müssen aber nicht) in geschweifte { } oder runde Klammern ( ) eingeschlossen sein. Man muss allerdings konsequent sein: Entweder müssen alle oder gar kein Element eingeklammert sein.
Ein Komma darf (muss aber nicht) zwischen Real- und Imaginärteil stehen. Der Imaginärteil muss stets explizit angegeben werden, auch wenn er gleich 0 sein sollte.
Beispiele für gültige Formate sind:
0.3 0.5 (weder Klammern noch trennendes Komma)
0.3, 0.5 (keine Klammern; Komma zwischen Re und Im)
{0.3 0.5} (geschweifte Klammern; kein Komma)
(0.3, 0.5) (runde Klammern und Komma)
|
C/C++-spezifisch: | Die zu lesenden Elemente müssen durch Whitespace (' ', '\n' oder '\t') voneinander getrennt sein. Zusätzlich ist ein (!) "Nicht-Whitespace"-Zeichen nach jedem Eintrag erlaubt, sofern es direkt auf die letzte Ziffer folgt. Nach ihm muss wiederum mindestens ein Whitespace-Zeichen folgen.
|
Pascal/Delphi-spezifisch: | Die zu lesenden Elemente müssen durch Whitespace (' ', #13, or #9) voneinander getrennt sein.
Während die C/C++-Version dieser Funktionen den Konventionen der C-Funktionen strtod, strtol usw. folgt, hat sich die Pascal/Delphi-Version nach den Regeln der Pascal/Delphi Funktion Read zu richten. Hierdurch wird die Pascal/Delphi-Version wesentlich weniger flexibel als die C/C++-Version:
- es sind keine Trennzeichen außer dem Leerzeichen (' ') und #9 erlaubt,
- überlaufende Eingabe-Zahlen werden nicht automatisch abgeschnitten.
nur CUDA-Versionen: cudaM?_read_buf übernimmt einen Host-Vektor h_Wk als zusätzliches Argument. Dieser dient als Pufferspeicher und muss (mindestens) dieselbe Größe haben wie X. Hierdurch wird die interne Bereitstellung von Pufferspeicher bei cudaM?_read eingespart, so dass cudaM?_read_buf etwas schneller ist.
|
|
Fehlerbehandlung | C/C++:
Überlaufende Eingabezahlen werden stillschweigend auf ±HUGE_VAL gesetzt.
Pascal/Delphi:
Überlaufende oder anderweitig nicht den Format-Bestimmungen entsprechende Eingabezahlen führen zu einem I/O-Fehler. |
|
Rückgabewert | keiner, außCUDA-Variante; dort: 0, wenn fehlerfrei, sonst ungleich 0 |
|
Querverweis | MF_write, VF_nread, MF_store, MF_recall, Kap. 14 |
MF_recall
| MD_recall |
ME_recall |
MCF_recall |
MCD_recall |
MCE_recall |
MI_recall | MBI_recall | MSI_recall | MLI_recall | MQI_recall |
MU_recall | MUB_recall | MUS_recall | MUL_recall | MUQ_recall |
|
Funktion | Matrix im Binär-Format aus einem Stream einlesen |
|
Syntax C/C++ | #include <MFstd.h>
int MF_recall( fMatrix MA, ui ht, ui len, FILE *stream); |
C++ MatObj | #include <OptiVec.h>
int matrix<T>::recall( FILE *stream ); |
Pascal/Delphi | uses MFstd;
function MF_recall( MA:fMatrix; ht, len:UIntSize; var Stream:FILE ): Integer; |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_recall( fMatrix d_MA, ui ht, ui len, FILE *stream );
int cudaMF_recall_buf( fMatrix d_MA, ui ht, ui len, FILE *stream, fVector h_Wk );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_recall( d_MA:fMatrix; ht, len:UIntSize; var Stream:File ): IntBool;
function cudaMF_recall_buf( d_MA:fMatrix; ht, len:UIntSize; var Stream:File; h_Wk:fVector ): IntBool;
|
|
Beschreibung | Die Matrix A mit ht*len Elementen wird im Binärformat aus stream gelesen. Normalerweise wird diese Funktion verwendet, um Matrizen zu importieren, die zuvor durch die entsprechende Funktion der MF_store-Familie gespeichert wurden.
In C/C++ werden Matrizen zeilenweise gespeichert, während Pascal/Delphi und Fortran mit Spalten-Matrizen arbeiten. Falls eine durch ein C/C++-Programm gespeicherte Matrix von einem Pascal/Delphi-Programm gelesen wird (oder umgekehrt), erhält man daher die Transponierte. In diesem Fall rufe man einfach
MF_transpose( MA, MA, ht, len );.
nur CUDA-Versionen: cudaM?_recall_buf übernimmt einen Host-Vektor h_Wk als zusätzliches Argument. Dieser dient als Pufferspeicher und muss (mindestens) dieselbe Größe (ht*len) haben wie d_MA. Hierdurch wird die interne Bereitstellung von Pufferspeicher bei cudaM?_recall eingespart, so dass cudaM?_recall_buf etwas schneller ist.
Nur GCC, CLang: GCC und CLang (einschließlich BCC32C) erweitern den 10-byte Datentyp long double zu 12 oder 16 bytes im Speicher (12 byte in 32-bit, 16 byte in 64 bit). Um für Kompatibilität zwischen den mit den verschiedenen Compilern erzeugten Dateien zu sorgen, schreiben und lesen die Funktionspaare ME_store / ME_recall und MCE_store / MCE_recall stets im 10-byte-Format. |
|
Thread-Sicherheit | Verschiedene Threads können gefahrlos mehrere Funktionen der VF_ / MF_store- und VF_ / MF_recall-Familien gleichzeitig aufrufen, solange sie auf verschiedene Streams zugreifen. Falls sie allerdings auf ein- und denselben Stream zugreifen, müssen unbedingt durch geeignete Maßnahmen (Critical Sections, Mutexes) Race-Conditions verhindert werden. |
|
Fehlerbehandlung | wird durch die C-Funktion fread bzw. die Delphi-Funktion BlockRead durchgeführt, auf der MF_recall etc. basieren |
|
Rückgabewert | 0, wenn fehlerfrei; ansonsten 1. Um mehr Information im Falle eines Fehlers zu erhalten, inspiziere man errno (C/C++) oder IOResult (Delphi). |
|
MF_rotate90
| MD_rotate90 |
ME_rotate90 |
MCF_rotate90 |
MCD_rotate90 |
MCE_rotate90 |
MI_rotate90 | MBI_rotate90 | MSI_rotate90 | MLI_rotate90 | MQI_rotate90 |
MU_rotate90 | MUB_rotate90 | MUS_rotate90 | MUL_rotate90 | MUQ_rotate90 |
|
Funktion | Rotation um 90° im Uhrzeigersinn |
|
Syntax C/C++ | #include <MFstd.h>
void MF_rotate90( fMatrix MRot, fMatrix MA, ui htRot, ui lenRot ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::rotate90( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_rotate90( MRot, MA:fMatrix; htRot, lenRot:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_rotate90( fMatrix d_MRot, fMatrix d_MA, ui htRot, ui lenRot );
void MFcu_rotate90( fMatrix h_MRot, fMatrix h_MA, ui htRot, ui lenRot );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_rotate90( d_MRot, MA:fMatrix; htRot, lenRot:UIntSize ): IntBool;
procedure MFcu_rotate90( h_MRot, h_MA:fMatrix; htRot, lenRot:UIntSize );
|
|
Beschreibung | MRoti,j = MAlenRot-j-1, i
Die Dimensionen htRot und lenRot beziehen sich auf die Ausgabe-Matrix, nicht auf die Eingabe-Matrix. |
|
|
MF_rotate180
| MD_rotate180 |
ME_rotate180 |
MCF_rotate180 |
MCD_rotate180 |
MCE_rotate180 |
MI_rotate180 | MBI_rotate180 | MSI_rotate180 | MLI_rotate180 | MQI_rotate180 |
MU_rotate180 | MUB_rotate180 | MUS_rotate180 | MUL_rotate180 | MUQ_rotate180 |
|
Funktion | Rotation einer Matrix um 180° |
|
Syntax C/C++ | #include <MFstd.h>
void MF_rotate180( fMatrix MRot, fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::rotate180( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_rotate180( MRot, MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_rotate180( fMatrix d_MRot, fMatrix d_MA, ui htRot, ui lenRot );
void MFcu_rotate180( fMatrix h_MRot, fMatrix h_MA, ui htRot, ui lenRot );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_rotate180( d_MRot, MA:fMatrix; htRot, lenRot:UIntSize ): IntBool;
procedure MFcu_rotate180( h_MRot, h_MA:fMatrix; htRot, lenRot:UIntSize );
|
|
Beschreibung | MRoti,j = MAht-i-1, len-j-1 |
|
|
MF_rotate270
| MD_rotate270 |
ME_rotate270 |
MCF_rotate270 |
MCD_rotate270 |
MCE_rotate270 |
MI_rotate270 | MBI_rotate270 | MSI_rotate270 | MLI_rotate270 | MQI_rotate270 |
MU_rotate270 | MUB_rotate270 | MUS_rotate270 | MUL_rotate270 | MUQ_rotate270 |
|
Funktion | Rotation einer Matrix um 270° im Uhrzeigersinn (bzw. um 90° entgegen dem Uhrzeigersinn) |
|
Syntax C/C++ | #include <MFstd.h>
void MF_rotate270( fMatrix MRot, fMatrix MA, ui htRot, ui lenRot ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::rotate270( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_rotate270( MRot, MA:fMatrix; htRot, lenRot:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_rotate270( fMatrix d_MRot, fMatrix d_MA, ui htRot, ui lenRot );
void MFcu_rotate270( fMatrix h_MRot, fMatrix h_MA, ui htRot, ui lenRot );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_rotate270( d_MRot, MA:fMatrix; htRot, lenRot:UIntSize ): IntBool;
procedure MFcu_rotate270( h_MRot, h_MA:fMatrix; htRot, lenRot:UIntSize );
|
|
Beschreibung | MRoti,j = MAj, htRot-i-1
Die Dimensionen htRot und lenRot beziehen sich auf die Ausgabe-Matrix, nicht auf die Eingabe-Matrix. |
|
|
MF_Row_addC
| MD_Row_addC |
ME_Row_addC |
MCF_Row_addC |
MCD_Row_addC |
MCE_Row_addC |
|
Funktion | Konstante zu allen Elemente einer Zeile hinzuaddieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_addC( fMatrix MA, ui ht, ui len, ui iRow, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_addC( const ui iRow, const T& C); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_addC( MA:fMatrix; ht, len, iRow:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_addC( fMatrix d_MA, ui ht, ui len, ui iRow, float C );
int cusdMF_Row_addC( fMatrix d_MA, ui ht, ui len, ui iRow, float *d_C );
void MFcu_Row_addC( fMatrix h_MA, ui ht, ui len, ui iRow, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_addC( d_MA:fMatrix; ht, len, iRow:UIntSize; C:Single ): IntBool;
function cusdMF_Row_addC( d_MA:fMatrix; ht, len, iRow:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Row_addC( h_MA:fMatrix; ht, len, iRow:UIntSize; C:Single );
|
|
Beschreibung | MAiRow,i += C, i=0,...,len-1 |
|
|
MF_Row_addV
| MD_Row_addV |
ME_Row_addV |
MCF_Row_addV |
MCD_Row_addV |
MCE_Row_addV |
|
Funktion | Element-weise Addition einer Zeile und eines Vektors |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_addV( fMatrix MA, ui ht, ui len, ui iRow, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_addV( const ui iRow, const vector<T>& X); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_addV( MA:fMatrix; ht, len, iRow:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_addV( fMatrix d_MA, ui ht, ui len, ui iRow, fVector d_X );
void MFcu_Row_addV( fMatrix h_MA, ui ht, ui len, ui iRow, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_addV( d_MA:fMatrix; ht, len, iRow:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Row_addV( h_MA:fMatrix; ht, len, iRow:UIntSize; h_X:fVector );
|
|
Beschreibung | MAiRow,i += Xi, i=0,...,len-1 |
|
|
MCF_Row_conj |
MCD_Row_conj |
MCE_Row_conj |
|
Funktion | Komplex-conjugierte Form aller Elemente einer Spalte |
|
Syntax C/C++ | #include <MFstd.h>
void MCF_Row_conj( cfMatrix MA, ui ht, ui len, ui iRow ); |
C++ MatObj | #include <OptiVec.h>
void matrix<complex<T>>::Row_conj( const ui iRow ); |
Pascal/Delphi | uses MFstd;
procedure MCF_Row_conj( MA:cfMatrix; ht, len, iRow:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Row_conj( cfMatrix d_MA, ui ht, ui len, ui iRow );
void MCFcu_Row_conj( cfMatrix h_MA, ui ht, ui len, ui iRow ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Row_conj( d_MA:cfMatrix; ht, len, iRow:UIntSize ): IntBool;
procedure MCFcu_Row_conj( h_MA:cfMatrix; ht, len, iRow:UIntSize );
|
|
Beschreibung | MAiRow,i = MA*iRow,i, i=0,...,len-1 |
|
|
MF_Row_delete
| MD_Row_delete |
ME_Row_delete |
MCF_Row_delete |
MCD_Row_delete |
MCE_Row_delete |
MI_Row_delete | MBI_Row_delete | MSI_Row_delete | MLI_Row_delete | MQI_Row_delete |
MU_Row_delete | MUB_Row_delete | MUS_Row_delete | MUL_Row_delete | MUQ_Row_delete |
|
Funktion | eine Zeile aus einer Matrix entfernen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_delete( fMatrix MB, fMatrix MA, ui htA, ui lenA, ui iRow ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_delete( const matrix<T>& MA, const ui iRow ); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_delete( MB, MA:fMatrix; htA, lenA, iRow:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_delete( fMatrix d_MB, fMatrix d_MA, ui htA, ui lenA, ui iRow );
void MFcu_Row_delete( fMatrix h_MB, fMatrix h_MA, ui htA, ui lenA, ui iRow ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_delete( d_MB, d_MA:fMatrix; htA, lenA, iRow:UIntSize ): IntBool;
procedure MFcu_Row_delete( h_MB, h_MA:fMatrix; htA, lenA, iRow:UIntSize );
|
|
Beschreibung | MBi,j = MAi,j, i=0,...,iRow-1, j=0,...,len-1
MBi,j = MAi+1,j, i=iRow,...,htA-2, j=0,...,lenA-1
Die Parameter htA und lenA beziehen sich auf die Eingabe- Matrix |
|
|
MF_Row_divC
| MD_Row_divC |
ME_Row_divC |
MCF_Row_divC |
MCD_Row_divC |
MCE_Row_divC |
|
Funktion | alle Elemente einer Zeile durch eine Konstante dividieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_divC( fMatrix MA, ui ht, ui len, ui iRow, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_divC( const ui iRow, const T& C); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_divC( MA:fMatrix; ht, len, iRow:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_divC( fMatrix d_MA, ui ht, ui len, ui iRow, float C );
int cusdMF_Row_divC( fMatrix d_MA, ui ht, ui len, ui iRow, float *d_C );
void MFcu_Row_divC( fMatrix h_MA, ui ht, ui len, ui iRow, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_divC( d_MA:fMatrix; ht, len, iRow:UIntSize; C:Single ): IntBool;
function cusdMF_Row_divC( d_MA:fMatrix; ht, len, iRow:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Row_divC( h_MA:fMatrix; ht, len, iRow:UIntSize; C:Single );
|
|
Beschreibung | MAiRow,i /= C, i=0,...,len-1 |
|
|
MF_Row_divrC
| MD_Row_divrC |
ME_Row_divrC |
MCF_Row_divrC |
MCD_Row_divrC |
MCE_Row_divrC |
|
Funktion | umgekehrte Division: eine Konstante durch alle Elemente einer Zeile dividieren und die Zeile mit dem Ergebnis überschreiben |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_divrC( fMatrix MA, ui ht, ui len, ui iRow, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_divrC( const ui iRow, const T& C); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_divrC( MA:fMatrix; ht, len, iRow:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_divrC( fMatrix d_MA, ui ht, ui len, ui iRow, float C );
int cusdMF_Row_divrC( fMatrix d_MA, ui ht, ui len, ui iRow, float *d_C );
void MFcu_Row_divrC( fMatrix h_MA, ui ht, ui len, ui iRow, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_divrC( d_MA:fMatrix; ht, len, iRow:UIntSize; C:Single ): IntBool;
function cusdMF_Row_divrC( d_MA:fMatrix; ht, len, iRow:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Row_divrC( h_MA:fMatrix; ht, len, iRow:UIntSize; C:Single );
|
|
Beschreibung | MAiRow,i = C / MAiRow,i, i=0,...,len-1 |
|
|
MF_Row_divrV
| MD_Row_divrV |
ME_Row_divrV |
MCF_Row_divrV |
MCD_Row_divrV |
MCE_Row_divrV |
|
Funktion | Element-weise umgekehrte Division: Vektor durch eine Zeile einer Matrix teilen und die Zeile mit dem Ergebnis überschreiben |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_divrV( fMatrix MA, ui ht, ui len, ui iRow, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_divrV( const ui iRow, const vector<T>& X); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_divrV( MA:fMatrix; ht, len, iRow:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_divrV( fMatrix d_MA, ui ht, ui len, ui iRow, fVector d_X );
void MFcu_Row_divrV( fMatrix h_MA, ui ht, ui len, ui iRow, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_divrV( d_MA:fMatrix; ht, len, iRow:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Row_divrV( h_MA:fMatrix; ht, len, iRow:UIntSize; h_X:fVector );
|
|
Beschreibung | MAiRow,i = Xi / MAiRow,i, i=0,...,len-1 |
|
|
MF_Row_divV
| MD_Row_divV |
ME_Row_divV |
MCF_Row_divV |
MCD_Row_divV |
MCE_Row_divV |
|
Funktion | Element-weise Division einer Zeile einer Matrix durch einen Vektor |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_divV( fMatrix MA, ui ht, ui len, ui iRow, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_divV( const ui iRow, const vector<T>& X); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_divV( MA:fMatrix; ht, len, iRow:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_divV( fMatrix d_MA, ui ht, ui len, ui iRow, fVector d_X );
void MFcu_Row_divV( fMatrix h_MA, ui ht, ui len, ui iRow, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_divV( d_MA:fMatrix; ht, len, iRow:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Row_divV( h_MA:fMatrix; ht, len, iRow:UIntSize; h_X:fVector );
|
|
Beschreibung | MAiRow,i /= Xi, i=0,...,len-1 |
|
|
MF_Row_equ0
| MD_Row_equ0 |
ME_Row_equ0 |
MCF_Row_equ0 |
MCD_Row_equ0 |
MCE_Row_equ0 |
MCF_Row_Reequ0 |
MCD_Row_Reequ0 |
MCE_Row_Reequ0 |
MCF_Row_Imequ0 |
MCD_Row_Imequ0 |
MCE_Row_Imequ0 |
MI_Row_equ0 | MBI_Row_equ0 | MSI_Row_equ0 | MLI_Row_equ0 | MQI_Row_equ0 |
MU_Row_equ0 | MUB_Row_equ0 | MUS_Row_equ0 | MUL_Row_equ0 | MUQ_Row_equ0 |
|
Funktion | alle Elemente einer Zeile mit Null initialisieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_equ0( fMatrix MA, ui ht, ui len, ui iRow );
void MCF_Row_Reequ0( cfMatrix MA, ui ht, ui len, ui iRow );
void MCF_Row_Imequ0( cfMatrix MA, ui ht, ui len, ui iRow ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_equ0( const ui iRow );
void matrix<complex<T>>::Row_Reequ0( const ui iRow );
void matrix<complex<T>>::Row_Imequ0( const ui iRow ); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_equ0( MA:fMatrix; ht, len, iRow:UIntSize );
procedure MCF_Row_Reequ0( MA:cfMatrix; ht, len, iRow:UIntSize );
procedure MCF_Row_Imequ0( MA:cfMatrix; ht, len, iRow:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_equ0( fMatrix d_MA, ui ht, ui len, ui iRow );
int cudaMCF_Row_Reequ0( cfMatrix d_MA, ui ht, ui len, ui iRow );
int cudaMCF_Row_Imequ0( cfMatrix d_MA, ui ht, ui len, ui iRow );
void MFcu_Row_equ0( fMatrix h_MA, ui ht, ui len, ui iRow ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_equ0( d_MA:fMatrix; ht, len, iRow:UIntSize ): IntBool;
function cudaMCF_Row_Reequ0( d_MA:cfMatrix; ht, len, iRow:UIntSize ): IntBool;
function cudaMCF_Row_Imequ0( d_MA:cfMatrix; ht, len, iRow:UIntSize ): IntBool;
procedure MFcu_Row_equ0( h_MA:fMatrix; ht, len, iRow:UIntSize );
|
|
Beschreibung | M?_Row_equ0: | MAiRow,i = 0, i=0,...,len-1 |
MC?_Row_Reequ0: | MAiRow,i.Re = 0, i=0,...,len-1 (MAiRow,i.Im bleibt unverändert) |
MC?_Row_Imequ0: | MAiRow,i.Im = 0, i=0,...,len-1 (MAiRow,i.Re bleibt unverändert) |
|
|
|
MF_Row_equC
| MD_Row_equC |
ME_Row_equC |
MCF_Row_equC |
MCD_Row_equC |
MCE_Row_equC |
MI_Row_equC | MBI_Row_equC | MSI_Row_equC | MLI_Row_equC | MQI_Row_equC |
MU_Row_equC | MUB_Row_equC | MUS_Row_equC | MUL_Row_equC | MUQ_Row_equC |
|
Funktion | alle Elemente einer Zeile mit einer Konstanten initialisieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_equC( fMatrix MA, ui ht, ui len, ui iRow, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_equC( const ui iRow, const T& C); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_equC( MA:fMatrix; ht, len, iRow:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_equC( fMatrix d_MA, ui ht, ui len, ui iRow, float C );
int cusdMF_Row_equC( fMatrix d_MA, ui ht, ui len, ui iRow, float *d_C );
void MFcu_Row_equC( fMatrix h_MA, ui ht, ui len, ui iRow, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_equC( d_MA:fMatrix; ht, len, iRow:UIntSize; C:Single ): IntBool;
function cusdMF_Row_equC( d_MA:fMatrix; ht, len, iRow:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Row_equC( h_MA:fMatrix; ht, len, iRow:UIntSize; C:Single );
|
|
Beschreibung | MAiRow,i = C, i=0,...,len-1 |
|
|
MF_Row_equV
| MD_Row_equV |
ME_Row_equV |
MCF_Row_equV |
MCD_Row_equV |
MCE_Row_equV |
MI_Row_equV | MBI_Row_equV | MSI_Row_equV | MLI_Row_equV | MQI_Row_equV |
MU_Row_equV | MUB_Row_equV | MUS_Row_equV | MUL_Row_equV | MUQ_Row_equV |
|
Funktion | Vektor in eine Zeile kopieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_equV( fMatrix MA, ui ht, ui len, ui iRow, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_equV( const ui iRow, const vector<T>& X); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_equV( MA:fMatrix; ht, len, iRow:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_equV( fMatrix d_MA, ui ht, ui len, ui iRow, fVector d_X );
void MFcu_Row_equV( fMatrix h_MA, ui ht, ui len, ui iRow, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_equV( d_MA:fMatrix; ht, len, iRow:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Row_equV( h_MA:fMatrix; ht, len, iRow:UIntSize; h_X:fVector );
|
|
Beschreibung | MAiRow,i = Xi, i=0,...,len-1 |
|
|
MF_Row_extract
| MD_Row_extract |
ME_Row_extract |
MCF_Row_extract |
MCD_Row_extract |
MCE_Row_extract |
MI_Row_extract | MBI_Row_extract | MSI_Row_extract | MLI_Row_extract | MQI_Row_extract |
MU_Row_extract | MUB_Row_extract | MUS_Row_extract | MUL_Row_extract | MUQ_Row_extract |
|
Funktion | eine Zeile in einen Vektor kopieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_extract( fVector Y, fMatrix MA, ui ht, ui len, ui iRow ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::Row_extract( const matrix<T>& MA, const ui iRow ); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_extract( Y:fVector; MA:fMatrix; ht, len, iRow:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_extract( fVector d_Y, fMatrix d_MA, ui ht, ui len, ui iRow );
void MFcu_Row_extract( fVector h_Y, fMatrix h_MA, ui ht, ui len, ui iRow ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_extract( d_Y:fVector; d_MA:fMatrix; ht, len, iRow:UIntSize ): IntBool;
procedure MFcu_Row_extract( h_Y:fVector; h_MA:fMatrix; ht, len, iRow:UIntSize );
|
|
Beschreibung | Xi = MAiRow,i, i=0,...,len-1 |
|
|
MF_Row_insert
| MD_Row_insert |
ME_Row_insert |
MCF_Row_insert |
MCD_Row_insert |
MCE_Row_insert |
MI_Row_insert | MBI_Row_insert | MSI_Row_insert | MLI_Row_insert | MQI_Row_insert |
MU_Row_insert | MUB_Row_insert | MUS_Row_insert | MUL_Row_insert | MUQ_Row_insert |
|
Funktion | Matrix durch Einfühgen einer Zeile erweitern |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_insert( fMatrix MB, fMatrix MA, ui htB, ui lenB, ui iRow, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_insert( const matrix<T>& MA, const ui iRow, const vector<T>& X ); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_insert( MB, MA:fMatrix; htB, lenB, iRow:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_insert( fMatrix d_MB, fMatrix d_MA, ui htB, ui lenB, ui iRow, fVector d_X );
void MFcu_Row_insert( fMatrix h_MB, fMatrix h_MA, ui htB, ui lenB, ui iRow, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_insert( d_MB, d_MA:fMatrix; htB, lenB, iRow:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Row_insert( h_MB, h_MA:fMatrix; htB, lenB, iRow:UIntSize; h_X:fVector );
|
|
Beschreibung | MBi,j = MAi,j, i=0,...,iRow-1, j=0,...,len-1
MBiRow,j = Xj, j=0,...,lenB-1
MBi,j = MAi-1,j, i=iRow,...,htB-1, j=0,...,lenB-1
Die Parameter htB und lenB beziehen sich auf the Ausgabe-Matrix |
|
|
MF_Row_mulC
| MD_Row_mulC |
ME_Row_mulC |
MCF_Row_mulC |
MCD_Row_mulC |
MCE_Row_mulC |
|
Funktion | alle Elemente einer Zeile mit einer Konstanten multiplizieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_mulC( fMatrix MA, ui ht, ui len, ui iRow, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_mulC( const ui iRow, const T& C); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_mulC( MA:fMatrix; ht, len, iRow:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_mulC( fMatrix d_MA, ui ht, ui len, ui iRow, float C );
int cusdMF_Row_mulC( fMatrix d_MA, ui ht, ui len, ui iRow, float *d_C );
void MFcu_Row_mulC( fMatrix h_MA, ui ht, ui len, ui iRow, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_mulC( d_MA:fMatrix; ht, len, iRow:UIntSize; C:Single ): IntBool;
function cusdMF_Row_mulC( d_MA:fMatrix; ht, len, iRow:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Row_mulC( h_MA:fMatrix; ht, len, iRow:UIntSize; C:Single );
|
|
Beschreibung | MAiRow,i *= C, i=0,...,len-1 |
|
|
MF_Row_mulV
| MD_Row_mulV |
ME_Row_mulV |
MCF_Row_mulV |
MCD_Row_mulV |
MCE_Row_mulV |
|
Funktion | Element-weise Multiplikation einer Zeile mit einem Vektor |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_mulV( fMatrix MA, ui ht, ui len, ui iRow, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_mulV( const ui iRow, const vector<T>& X); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_mulV( MA:fMatrix; ht, len, iRow:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_mulV( fMatrix d_MA, ui ht, ui len, ui iRow, fVector d_X );
void MFcu_Row_mulV( fMatrix h_MA, ui ht, ui len, ui iRow, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_mulV( d_MA:fMatrix; ht, len, iRow:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Row_mulV( h_MA:fMatrix; ht, len, iRow:UIntSize; h_X:fVector );
|
|
Beschreibung | MAiRow,i *= Xi, i=0,...,len-1 |
|
|
MF_Row_neg
| MD_Row_neg |
ME_Row_neg |
MCF_Row_neg |
MCD_Row_neg |
MCE_Row_neg |
|
Funktion | Multiplikation aller Elemente einer Spalte mit -1 |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_neg( fMatrix MA, ui ht, ui len, ui iRow ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_neg( const ui iRow ); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_neg( MA:fMatrix; ht, len, iRow:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_neg( fMatrix d_MA, ui ht, ui len, ui iRow );
void MFcu_Row_neg( fMatrix h_MA, ui ht, ui len, ui iRow ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_neg( d_MA:fMatrix; ht, len, iRow:UIntSize ): IntBool;
procedure MFcu_Row_neg( h_MA:fMatrix; ht, len, iRow:UIntSize );
|
|
Beschreibung | MAiRow,i *= -1, i=0,...,len-1 |
|
|
MF_Row_subC
| MD_Row_subC |
ME_Row_subC |
MCF_Row_subC |
MCD_Row_subC |
MCE_Row_subC |
|
Funktion | eine Konstante von allen Elementen einer Zeile subtrahieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_subC( fMatrix MA, ui ht, ui len, ui iRow, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_subC( const ui iRow, const T& C); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_subC( MA:fMatrix; ht, len, iRow:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_subC( fMatrix d_MA, ui ht, ui len, ui iRow, float C );
int cusdMF_Row_subC( fMatrix d_MA, ui ht, ui len, ui iRow, float *d_C );
void MFcu_Row_subC( fMatrix h_MA, ui ht, ui len, ui iRow, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_subC( d_MA:fMatrix; ht, len, iRow:UIntSize; C:Single ): IntBool;
function cusdMF_Row_subC( d_MA:fMatrix; ht, len, iRow:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Row_subC( h_MA:fMatrix; ht, len, iRow:UIntSize; C:Single );
|
|
Beschreibung | MAiRow,i -= C, i=0,...,len-1 |
|
|
MF_Row_subrC
| MD_Row_subrC |
ME_Row_subrC |
MCF_Row_subrC |
MCD_Row_subrC |
MCE_Row_subrC |
|
Funktion | umgekehrte Subtraktion: eine Konstante minus eine Zeile |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_subrC( fMatrix MA, ui ht, ui len, ui iRow, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_subrC( const ui iRow, const T& C); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_subrC( MA:fMatrix; ht, len, iRow:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_subrC( fMatrix d_MA, ui ht, ui len, ui iRow, float C );
int cusdMF_Row_subrC( fMatrix d_MA, ui ht, ui len, ui iRow, float *d_C );
void MFcu_Row_subrC( fMatrix h_MA, ui ht, ui len, ui iRow, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_subrC( d_MA:fMatrix; ht, len, iRow:UIntSize; C:Single ): IntBool;
function cusdMF_Row_subrC( d_MA:fMatrix; ht, len, iRow:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Row_subrC( h_MA:fMatrix; ht, len, iRow:UIntSize; C:Single );
|
|
Beschreibung | MAiRow,i = C - MAiRow,i, i=0,...,len-1 |
|
|
MF_Row_subrV
| MD_Row_subrV |
ME_Row_subrV |
MCF_Row_subrV |
MCD_Row_subrV |
MCE_Row_subrV |
|
Funktion | Element-weise umgekehrte Subtraktion: ein Vektor minus eine Zeile einer Matrix; die Zeile wird mit dem Ergebnis überschrieben |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_subrV( fMatrix MA, ui ht, ui len, ui iRow, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_subrV( const ui iRow, const vector<T>& X); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_subrV( MA:fMatrix; ht, len, iRow:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_subrV( fMatrix d_MA, ui ht, ui len, ui iRow, fVector d_X );
void MFcu_Row_subrV( fMatrix h_MA, ui ht, ui len, ui iRow, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_subrV( d_MA:fMatrix; ht, len, iRow:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Row_subrV( h_MA:fMatrix; ht, len, iRow:UIntSize; h_X:fVector );
|
|
Beschreibung | MAiRow,i = Xi - MAiRow,i, i=0,...,len-1 |
|
|
MF_Row_subV
| MD_Row_subV |
ME_Row_subV |
MCF_Row_subV |
MCD_Row_subV |
MCE_Row_subV |
|
Funktion | Element-weise Subtraktion eines Vektors von einer Zeile |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Row_subV( fMatrix MA, ui ht, ui len, ui iRow, fVector X ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Row_subV( const ui iRow, const vector<T>& X); |
Pascal/Delphi | uses MFstd;
procedure MF_Row_subV( MA:fMatrix; ht, len, iRow:UIntSize; X:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Row_subV( fMatrix d_MA, ui ht, ui len, ui iRow, fVector d_X );
void MFcu_Row_subV( fMatrix h_MA, ui ht, ui len, ui iRow, fVector h_X ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Row_subV( d_MA:fMatrix; ht, len, iRow:UIntSize; d_X:fVector ): IntBool;
procedure MFcu_Row_subV( h_MA:fMatrix; ht, len, iRow:UIntSize; h_X:fVector );
|
|
Beschreibung | MAiRow,i -= Xi, i=0,...,len-1 |
|
|
MF_Rows_absmax
| MD_Rows_absmax |
ME_Rows_absmax |
MCF_Rows_absmax |
MCD_Rows_absmax |
MCE_Rows_absmax |
|
Funktion | Betrags-Maxima der einzelnen Zeilen in einem Spalten-Vektor speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_absmax( fVector Y, fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::Rows_absmax( const matrix<T>& MA );
void vector<T>::Rows_absmax( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_absmax( Y:fVector; MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_absmax( fVector d_Y, fMatrix d_MA, ui ht, ui len );
int cudaMCF_Rows_absmax( fVector d_Y, cfMatrix d_MA, ui ht, ui len )
void MFcu_Rows_absmax( fVector h_Y, fMatrix h_MA, ui ht, ui len );
void MCFcu_Rows_absmax( fVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_absmax( d_Y:fVector; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMCF_Rows_absmax( d_Y:fVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_absmax( h_Y:fVector; h_MA:fMatrix; ht, len:UIntSize );
procedure MCFcu_Rows_absmax( h_Y:fVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | The Betrags-Maximum jeder Zeile i wird gespeichert als Element Yi für i=0,...,ht-1 |
|
|
MCF_Rows_absmaxReIm
| MCD_Rows_absmaxReIm |
MCE_Rows_absmaxReIm |
|
Funktion | Betrags-Maxima der Real- und der Imaginärteile getrennt voneinander für die einzelnen Zeilen bestimmen und als Real- bzw. Imaginärteile eines Spalten-Vektors speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MCF_Rows_absmaxReIm( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> >::Rows_absmaxReIm( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MFstd;
procedure MCF_Rows_absmaxReIm( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Rows_absmaxReIm( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Rows_absmaxReIm( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Rows_absmaxReIm( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Rows_absmaxReIm( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Für i=0,..,ht-1 wird das Betragsmaximum der Realteile jeder Zeile i als Element Yi.Re gespeichert und das Betragsmaximum der Imaginärteile jeder Zeile i als Element Yi.Im. |
|
|
MF_Rows_absmin
| MD_Rows_absmin |
ME_Rows_absmin |
MCF_Rows_absmin |
MCD_Rows_absmin |
MCE_Rows_absmin |
|
Funktion | Betrags-Minima der einzelnen Zeilen in einem Spalten-Vektor speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_absmin( fVector Y, fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::Rows_absmin( const matrix<T>& MA );
void vector<T>::Rows_absmin( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_absmin( Y:fVector; MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_absmin( fVector d_Y, fMatrix d_MA, ui ht, ui len );
int cudaMCF_Rows_absmin( fVector d_Y, cfMatrix d_MA, ui ht, ui len )
void MFcu_Rows_absmin( fVector h_Y, fMatrix h_MA, ui ht, ui len );
void MCFcu_Rows_absmin( fVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_absmin( d_Y:fVector; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMCF_Rows_absmin( d_Y:fVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_absmin( h_Y:fVector; h_MA:fMatrix; ht, len:UIntSize );
procedure MCFcu_Rows_absmin( h_Y:fVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | The Betrags-Minimum jeder Zeile i wird gespeichert als Element Yi für i=0,...,ht-1 |
|
|
MCF_Rows_absminReIm
| MCD_Rows_absminReIm |
MCE_Rows_absminReIm |
|
Funktion | Betrags-Maxima der Real- und der Imaginärteile getrennt voneinander für die einzelnen Zeilen bestimmen und als Real- bzw. Imaginärteile eines Spalten-Vektors speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MCF_Rows_absminReIm( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> >::Rows_absminReIm( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MFstd;
procedure MCF_Rows_absminReIm( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Rows_absminReIm( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Rows_absminReIm( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Rows_absminReIm( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Rows_absminReIm( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Für j=0,..,ht-1 wird das Betragsmaximum der Realteile jeder Zeile i als Element Yi.Re gespeichert und das Betragsmaximum der Imaginärteile jeder Zeile i als Element Yi.Im. |
|
|
MF_Rows_add
| MD_Rows_add |
ME_Rows_add |
MCF_Rows_add |
MCD_Rows_add |
MCE_Rows_add |
|
Funktion | eine Zeile zu einer anderen hinzuaddieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_add( fMatrix MA, ui ht, ui len, unsigned destRow, unsigned sourceRow ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Rows_add( const unsigned destRow, const unsigned sourceRow ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_add( MA:fMatrix; ht, len, destRow, sourceRow:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_add( fMatrix d_MA, ui ht, ui len, unsigned destRow, unsigned sourceRow );
void MFcu_Rows_add( fMatrix h_MA, ui ht, ui len, unsigned destRow, unsigned sourceRow ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_add( d_MA:fMatrix; ht, len, destRow, sourceRow:UIntSize ): IntBool;
procedure MFcu_Rows_add( h_MA:fMatrix; ht, len, destRow, sourceRow:UIntSize );
|
|
Beschreibung | MAdestRow, j += MAsourceRow, j, i=0,...,len-1 |
|
|
MCF_Rows_cabsmax
| MCD_Rows_cabsmax |
MCE_Rows_cabsmax |
|
Funktion | Denjenigen Wert jeder Zeile, der den größten Betrag aufweist, in einem Spalten-Vektor speichern |
|
Syntax C/C++ | #include <MCFstd.h>
void MCF_Rows_cabsmax( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> T>::Rows_cabsmax( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
procedure MCF_Rows_cabsmax( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Rows_cabsmax( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Rows_cabsmax( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Rows_cabsmax( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Rows_cabsmax( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Dasjenige Element jeder Zeile i von MA, das den größten Betrag, sqrt(Re2+Im2), besitzt, wird gespeichert als Element Yi für i=0,..,ht-1 |
|
|
MCF_Rows_cabsmin
| MCD_Rows_cabsmin |
MCE_Rows_cabsmin |
|
Funktion | Denjenigen Wert jeder Zeile, der den größten Betrag aufweist, in einem Spalten-Vektor speichern |
|
Syntax C/C++ | #include <MCFstd.h>
void MCF_Rows_cabsmin( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> T>::Rows_cabsmin( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
procedure MCF_Rows_cabsmin( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Rows_cabsmin( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Rows_cabsmin( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Rows_cabsmin( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Rows_cabsmin( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Dasjenige Element jeder Zeile i von MA, das den größten Betrag, sqrt(Re2+Im2), besitzt, wird gespeichert als Element Yi für i=0,..,ht-1 |
|
|
MF_Rows_Cadd
| MD_Rows_Cadd |
ME_Rows_Cadd |
MCF_Rows_Cadd |
MCD_Rows_Cadd |
MCE_Rows_Cadd |
|
Funktion | eine Zeile ersetzen durch die mit einer Konstanten skalierte Summe von ihr selbst und einer anderen Zeile |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_Cadd( fMatrix MA, ui ht, ui len, unsigned destRow, unsigned sourceRow, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Rows_Cadd( const unsigned destRow, const unsigned sourceRow, const T& C ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_Cadd( MA:fMatrix; ht, len, destRow, sourceRow:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_Cadd( fMatrix d_MA, ui ht, ui len, unsigned destRow, unsigned sourceRow, float C );
int cusdMF_Rows_Cadd( fMatrix d_MA, ui ht, ui len, unsigned destRow, unsigned sourceRow, float *d_C );
void MFcu_Rows_Cadd( fMatrix h_MA, ui ht, ui len, unsigned destRow, unsigned sourceRow, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_Cadd( d_MA:fMatrix; ht, len, destRow, sourceRow:UIntSize; C:Single ): IntBool;
function cusdMF_Rows_Cadd( d_MA:fMatrix; ht, len, destRow, sourceRow:UIntSize; d_C:PSingle ): IntBool;
procedure MFcu_Rows_Cadd( h_MA:fMatrix; ht, len, destRow, sourceRow:UIntSize; C:Single );
|
|
Beschreibung | MAdestRow, j += C * MAsourceRow, j, i=0,...,len-1 |
|
|
MF_Rows_distribution | MD_Rows_distribution | ME_Rows_distribution |
MI_Rows_distribution | MBI_Rows_distribution | MSI_Rows_distribution | MLI_Rows_distribution | MQI_Rows_distribution |
MU_Rows_distribution | MUB_Rows_distribution | MUS_Rows_distribution | MUL_Rows_distribution | MUQ_Rows_distribution |
|
Funktion | Histogramm: Verteilungsfunktion entlang der Zeilen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_distribution( uiMatrix MAbund, fVector Limits, ui nbins, fMatrix MA, ui ht, ui len, int mode ); |
C++ VecObj | #include <OptiVec.h>
void matrix<ui>::Rows_distribution( const vector<T>& Limits, const matrix<T>& MA, int mode=0 ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_distribution( MAbund:uiMatrix; Limits:fVector; nbins:UIntSize; MA:fMatrix; ht, len:UIntSize; mode:Integer ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_distribution( uiMatrix d_MAbund, fVector d_Limits, ui nbins, fMatrix d_MA, ui ht, ui len, int mode );
void MFcu_Rows_distribution( uiMatrix h_MAbund, fVector h_Limits, ui nbins, fMatrix h_MA, ui ht, ui len, int mode ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_distribution( d_MAbund:uiMatrix; d_Limits:fVector; nbins:UIntSize; d_MA:fMatrix; ht, len:UIntSize; mode:Integer ): IntBool;
procedure MFcu_Rows_distribution( h_MAbund:uiMatrix; h_Limits:fVector; nbins:UIntSize; h_MA:fMatrix; ht, len:UIntSize; mode:Integer );
|
|
Beschreibung | Für jede Zeile wird gezählt, wieviele Elemente in jedes einzelne der in Limits definierten Intervalle fallen. Die gefundenen Häufigkeitswerte werden in der entsprechenden Zeile von MAbund gespeichert.
Es gibt nbins Intervalle (engl. bins). Die Größe von MAbund ist also ht*nbins.
Limits muß in aufsteigender Folge sortiert sein. Die Abstände zwischen den einzelnen Werten von Limits müssen aber nicht unbedingt konstant sein.
Der Parameter mode entscheidet darüber, wie die in Limits angegebenen Werte interpretiert werden sollen.
mode > 0: Die Werte von Limits geben die Obergrenzen der Intervalle an.
mode < 0: Die Werte von Limits geben die Untergrenzen der Intervalle an.
mode = 0: Die Werte von Limits geben die Intervall-Mittelpunkte an. Ein X-Wert wird also demjenigen Intervall zugerechnet, zu dessen in Limits angegebenen Wert er den geringsten Abstand hat. Befindet sich ein X-Wert exakt in der Mitte zwischen zwei Limits-Werten, so wird er dem Intervall mit dem niedrigeren Index zugeschlagen. Das durch Limits0 angegebene Intervall ist nach unten hin offen, das durch Limitsnbins-1 angegebene reicht bis +HUGE_VAL.
Im Unterschied zu VF_distribution werden die außerhalb der spezifierten Intervalle liegenden Elemente nicht zurückgegeben, sondern ignoriert.
Die vorliegende Funktion eignet sich auch zur Stapelverarbeitung mehrerer Vektoren gleicher Größe, die zu diesem Zweck in die Zeilen einer Matrix zu kopieren sind.
Derzeit stehen diese Funktionen nur für 64-bit zur Verfügung.
|
|
|
|
|
MF_Rows_exchange
| MD_Rows_exchange |
ME_Rows_exchange |
MCF_Rows_exchange |
MCD_Rows_exchange |
MCE_Rows_exchange |
MI_Rows_exchange | MBI_Rows_exchange | MSI_Rows_exchange | MLI_Rows_exchange | MQI_Rows_exchange |
MU_Rows_exchange | MUB_Rows_exchange | MUS_Rows_exchange | MUL_Rows_exchange | MUQ_Rows_exchange |
|
Funktion | zwei Zeilen vertauschen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_exchange( fMatrix MA, ui ht, ui len, unsigned i1, unsigned i2 ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Rows_exchange( const unsigned i1, const unsigned i2 ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_exchange( MA:fMatrix; ht, len, i1, i2:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_exchange( fMatrix d_MA, ui ht, ui len, unsigned i1, unsigned i2 );
void MFcu_Rows_exchange( fMatrix MA, ui ht, ui len, unsigned i1, unsigned i2 ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_exchange( d_MA:fMatrix; ht, len, i1, i2:UIntSize ): IntBool;
procedure MFcu_Rows_exchange( h_MA:fMatrix; ht, len, i1, i2:UIntSize );
|
|
Beschreibung | Die Elemente der Zeilen i1 und i2 werden miteinander vertauscht. |
|
|
MF_Rows_FFT |
MD_Rows_FFT |
ME_Rows_FFT |
MFb_Rows_FFT |
MDb_Rows_FFT |
MEb_Rows_FFT |
MF_Rows_FFTtoC
| MD_Rows_FFTtoC |
ME_Rows_FFTtoC |
MFb_Rows_FFTtoC
| MDb_Rows_FFTtoC |
MEb_Rows_FFTtoC |
MCF_Rows_FFT |
MCD_Rows_FFT |
MCE_Rows_FFT |
MCFb_Rows_FFT |
MCDb_Rows_FFT |
MCEb_Rows_FFT |
|
Funktion | Schnelle Fourier-Transformation (Fast Fourier Transformation) entlang der Zeilen einer Matrix |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_FFT( fMatrix Y, fMatrix X, ui ht, ui len, int dir );
void MCF_Rows_FFT( cfMatrix Y, cfMatrix X, ui ht, ui len, int dir );
void MF_Rows_FFTtoC( cfMatrix Y, fMatrix X, ui ht, ui len );
void MFb_Rows_FFT( fMatrix Y, fMatrix X, ui ht, ui len, int dir, fVector Buf );
void MCFb_Rows_FFT( cfMatrix Y, cfMatrix X, ui ht, ui len, int dir, cfVector Buf );
void MFb_Rows_FFTtoC( cfMatrix Y, fMatrix X, ui ht, ui len, cfVector Buf ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Rows_FFT( const matrix<T>& MX, int dir );
void matrix<complex<T> >::FFT( const matrix<complex<T> >& MX, int dir );
void matrix<complex<T> >::FFTtoC( const matrix<T>& MX );
void matrix<T>::b_Rows_FFT( const matrix<T>& MX, int dir, vector<T>& Buf );
void matrix<complex<T> >::b_Rows_FFT( const matrix<complex<T> > MX, int dir, vector<complex<T> >&Buf );
void matrix<complex<T> >::b_Rows_FFTtoC( const matrix<T> MX, vector<complex<T>>& Buf ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_FFT( MY, MX:fMatrix; ht, len:UIntSize; dir:Integer );
procedure MCF_Rows_FFT( MY, MX:cfMatrix; ht, len:UIntSize; dir:Integer );
procedure MF_Rows_FFTtoC( MY:cfMatrix; MX:fMatrix; ht, len:UIntSize );
procedure MFb_Rows_FFT( MY, MX:fMatrix; ht, len:UIntSize; dir:Integer; Buf:fVector );
procedure MCFb_Rows_FFT( MY, MX:cfMatrix; ht, len:UIntSize; dir:Integer; Buf:cfVector );
procedure MFb_Rows_FFTtoC( MY:cfMatrix; MX:fMatrix; ht, len:UIntSize; Buf:cfVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
#include <cudaMCFstd.h>
int cudaMF_Rows_FFT( fMatrix d_Y, fMatrix d_X, ui ht, ui len, int dir );
int cuda MCF_Rows_FFT( cfMatrix d_Y, cfMatrix d_X, ui ht, ui len, int dir );
int cudaMF_Rows_FFTtoC( cfMatrix d_Y, fMatrix d_X, ui ht, ui len );
void MFcu_Rows_FFT( fMatrix h_Y, fMatrix h_X, ui ht, ui len, int dir );
void MCFcu_Rows_FFT( cfMatrix h_Y, cfMatrix h_X, ui ht, ui len, int dir );
void MFcu_Rows_FFTtoC( cfMatrix h_Y, fMatrix h_X, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd, MCFstd;
function cudaMF_Rows_FFT( d_MY, d_MX:fMatrix; ht, len:UIntSize; dir:Integer ): IntBool;
function cudaMCF_Rows_FFT( d_MY, d_MX:cfMatrix; ht, len:UIntSize; dir:Integer ): IntBool;
function cudaMF_Rows_FFTtoC( d_MY:cfMatrix; d_MX:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_FFT( h_MY, h_MX:fMatrix; ht, len:UIntSize; dir:Integer );
procedure MCFcu_Rows_FFT( h_MY, h_MX:cfMatrix; ht, len:UIntSize; dir:Integer );
procedure MFcu_Rows_FFTtoC( h_MY:cfMatrix; h_MX:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Die Fourier-Transformierten der Zeilen von MX werden in den Zeilen von MY zurückgegeben. Die Vorwärts-Transformation erhält man für dir = 1, die inverse (oder Rückwärts-) Transformation für dir = -1. Gemäß Konvention enthält die Rückwärts-Transformation eine Skalierung des Ergebnisses mit dem Faktor 1.0/len (wodurch das Ergebnis von einmal Vorwärts- und einmal Rückwärts-Transformation wieder – von Rundungsfehlern abgesehen – die Ursprungs-Matrix ergibt). Für Situationen, in denen man diese implizite Skalierung umgehen möchte, spezifiziere man dir = -2.
Der verwendete FFT-Algorithmus erfordert es, dass len eine ganzzahlige Potenz von 2 ist. ht hingegen kann zwar beliebige Werte annehmen; die Funktion ist aber am effizientesten, wenn ht ein Vielfaches von 4 ist.
Komplexe Version: Sowohl die Eingabe-Matrix X also auch die Ausgabe-Matrix Y sind komplex.
Reell-zu-Komplex-Version: Die Eingabe-Matrix X ist reell. Die Ausgabe-Matrix Y ist komplex. Da diese Funktion nur in Vorwärts-Richtung ausgeführt werden kann, ist kein Argument "dir" erforderlich.
Rein reelle Version: Für die Vorwärts-Transformation ist MX eine reelle Matrix. Die Ausgabe-Matrix Y ist ebenfalls als reelle Matrix definiert, obwohl sie aus komplexen Zahlen besteht. Diese sind auf spezielle Weise so gepackt, dass sie in den für eine gleich große reelle Matrix zur Verfügung stehenden Speicherplatz passen. Die Reihenfolge der Elemente der Zeilen von MY ist in folgenden Tabelle angegeben. U ist die unkomprimierte Fourier-Transformierte, N ist ht.
MYi,0 | MYi,1 | MYi,2
| MYi,3 | .....
| MYi,N-2 | MYi,N-1 |
Ui,0.Re | Ui,N/2.Re | Ui,1.Re
| Ui,1.Im | .....
| Ui,N/2-1.Re | Ui,N/2-1.Im |
Dieses Speicher-Schema bedeutet, dass in Pascal/Delphi (wo Matrizen spaltenweise gespeichert werden), Real- und Imaginärteil eines jeden Elements nicht an benachbarten Speicherplätzen abgelegt sind.
Für die inverse Rows_FFT reeller Matrizen muss die Eingabe-Matrix in diesem gepackt-komplexen Format vorliegen. und als Ergebnis erhält man eine "echte" reelle Matrix. Falls Sie es vorziehen, das Ergebnis der Vorwärts-Transformation ungepackt, also als "echte" komplexe Zahlen zu erhalten, benutzen Sie bitte MF_Rows_FFTtoC.
MFb_Rows_FFT, MFb_Rows_FFTtoC und MCFb_Rows_FFT verwenden den als Argument Buf übergebenen Puffer-Speicher, anstatt ihn selbst zu reservieren. Dadurch sind sie etwas effizienter als die ungepufferten Versionen. Buf muss (mindestens) so groß sein wie X und Y (d.h. Buf.size >= ht*len).
|
|
Fehlerbehandlung | Falls len nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf MF_Rows_FFT basiert) mit der Fehlermeldung "Size must be an integer power of 2" und bricht das Programm ab. |
|
|
MF_Rows_lincomb
| MD_Rows_lincomb |
ME_Rows_lincomb |
MCF_Rows_lincomb |
MCD_Rows_lincomb |
MCE_Rows_lincomb |
|
Funktion | Linearkombination zweier Zeilen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_lincomb( fMatrix MA, ui ht, ui len, unsigned destRow, float destC, unsigned srceRow, float srceC ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Rows_lincomb( const unsigned destRow, const T& destC, const unsigned sourceRow, const T& srceC ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_lincomb( MA:fMatrix; ht, len:UIntSize; destRow:UIntSize; destC:Single;
srceRow:UIntSize; srceC:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_lincomb( fMatrix d_MA, ui ht, ui len, unsigned destRow, float destC, unsigned srceRow, float srceC );
int cusdMF_Rows_lincomb( fMatrix d_MA, ui ht, ui len, unsigned destRow, float
d_destC, unsigned srceRow, float *d_srceC );
void MFcu_Rows_lincomb( fMatrix h_MA, ui ht, ui len, unsigned destRow, float destC, unsigned srceRow, float srceC );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_lincomb( d_MA:fMatrix; ht, len:UIntSize; destRow:UIntSize; destC:Single; srceRow:UIntSize; srceC:Single ): IntBool;
function cusdMF_Rows_lincomb( d_MA:fMatrix; ht, len:UIntSize; destRow:UIntSize; d_destC:PSingle; srceRow:UIntSize; d_srceC:PSingle ): IntBool;
procedure MFcu_Rows_lincomb( h_MA:fMatrix; ht, len:UIntSize; destRow:UIntSize; destC:Single; srceRow:UIntSize; srceC:Single );
|
|
Beschreibung | MAdestRow, j = destC * MAdestRow, j+ srceC * MAsrceRow, j, j=0,...,len-1 |
|
|
MF_Rows_max
| MD_Rows_max |
ME_Rows_max |
MI_Rows_max | MBI_Rows_max | MSI_Rows_max | MLI_Rows_max | MQI_Rows_max |
MU_Rows_max | MUB_Rows_max | MUS_Rows_max | MUL_Rows_max | MUQ_Rows_max |
|
Funktion | Maxima der einzelnen Zeilen in einem Spalten-Vektor speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_max( fVector Y, fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::Rows_max( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_max( Y:fVector; MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_max( fVector d_Y, fMatrix d_MA, ui ht, ui len );
void MFcu_Rows_max( fVector h_Y, fMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_max( d_Y:fVector; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_max( h_Y:fVector; h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Das Maximum jeder Zeile i wird gespeichert als Element Yi für i=0,...,ht-1 |
|
|
MCF_Rows_maxReIm
| MCD_Rows_maxReIm |
MCE_Rows_maxReIm |
|
Funktion | Maxima der Real- und der Imaginärteile getrennt voneinander für die einzelnen Zeilen bestimmen und als Real- bzw. Imaginärteile eines Spalten-Vektors speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MCF_Rows_maxReIm( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> >::Rows_maxReIm( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MFstd;
procedure MCF_Rows_maxReIm( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Rows_maxReIm( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Rows_maxReIm( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Rows_maxReIm( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Rows_maxReIm( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Für i=0,..,ht-1 wird das Maximum der Realteile jeder Zeile i als Element Yi.Re gespeichert und das Maximum der Imaginärteile jeder Zeile i als Element Yi.Im. |
|
|
MF_Rows_min
| MD_Rows_min |
ME_Rows_min |
MI_Rows_min | MBI_Rows_min | MSI_Rows_min | MLI_Rows_min | MQI_Rows_min |
MU_Rows_min | MUB_Rows_min | MUS_Rows_min | MUL_Rows_min | MUQ_Rows_min |
|
Funktion | Minima der einzelnen Zeilen in einem Spalten-Vektor speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_min( fVector Y, fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::Rows_min( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_min( Y:fVector; MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_min( fVector d_Y, fMatrix d_MA, ui ht, ui len );
void MFcu_Rows_min( fVector h_Y, fMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_min( d_Y:fVector; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_min( h_Y:fVector; h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Das kleinste oder "negativste" Element jeder Zeile i wird gespeichert als Element Yi für i=0,...,ht-1 |
|
|
MCF_Rows_minReIm
| MCD_Rows_minReIm |
MCE_Rows_minReIm |
|
Funktion | Minima der Real- und der Imaginärteile getrennt voneinander für die einzelnen Zeilen bestimmen und als Real- bzw. Imaginärteile eines Spalten-Vektors speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MCF_Rows_minReIm( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> >::Rows_minReIm( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MFstd;
procedure MCF_Rows_minReIm( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Rows_minReIm( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Rows_minReIm( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Rows_minReIm( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Rows_minReIm( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Für i=0,..,ht-1 wird das Minimum der Realteile jeder Zeile i als Element Yi.Re gespeichert und das Maximum der Imaginärteile jeder Zeile i als Element Yi.Im. |
|
|
MF_Rows_prod
| MD_Rows_prod |
ME_Rows_prod |
MCF_Rows_prod |
MCD_Rows_prod |
MCE_Rows_prod |
|
Funktion | Produkte über alle Elemente jeder einzelnen Zeile in einem Spalten-Vektor speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_prod(fVector Y, fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::Rows_prod( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_prod(Y:fVector; MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_prod( fVector d_Y, fMatrix d_MA, ui ht, ui len );
void MFcu_Rows_prod( fVector h_Y, fMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_prod( d_Y:fVector; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_prod( h_Y:fVector; h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Yi = prod( MAi,j, j=0,...,len-1), i=0,...,ht-1 |
|
|
MF_Rows_reflect
| MD_Rows_reflect |
ME_Rows_reflect |
MCF_Rows_reflect |
MCD_Rows_reflect |
MCE_Rows_reflect |
MI_Rows_reflect | MBI_Rows_reflect | MSI_Rows_reflect | MLI_Rows_reflect | MQI_Rows_reflect |
MU_Rows_reflect | MUB_Rows_reflect | MUS_Rows_reflect | MUL_Rows_reflect | MUQ_Rows_reflect |
|
Funktion | Zweite Hälfte jeder Zeile von der ersten Hälfte durch Reflektion an der senkrechten Linie durch die Mitte der Matrix gewinnen. |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_reflect( fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Rows_reflect( ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_reflect( MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_reflect( fMatrix d_MA, ui ht, ui len );
void MFcu_Rows_reflect( fMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_reflect( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_reflect( h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | MAi, len-j-1 = MAi, j, i=0,...,ht-1; j=0,...,(len-1)/2; |
|
|
MF_Rows_rev
| MD_Rows_rev |
ME_Rows_rev |
MCF_Rows_rev |
MCD_Rows_rev |
MCE_Rows_rev |
MI_Rows_rev | MBI_Rows_rev | MSI_Rows_rev | MLI_Rows_rev | MQI_Rows_rev |
MU_Rows_rev | MUB_Rows_rev | MUS_Rows_rev | MUL_Rows_rev | MUQ_Rows_rev |
|
Funktion | Umkehrung der Element-Reihenfolge entlang der Zeilen. Dies entspricht einer Spiegelung der Matrix an der Y-Achse (bzw. an der senkrechten Linie durch die Mitte der Matrix). |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_rev( fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Rows_rev( ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_rev( MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_rev( fMatrix d_MA, ui ht, ui len );
void MFcu_Rows_rev( fMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_rev( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_rev( h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | MAi,j = MAi, len-j-1 |
|
|
MF_Rows_rotate
| MD_Rows_rotate |
ME_Rows_rotate |
MCF_Rows_rotate |
MCD_Rows_rotate |
MCE_Rows_rotate |
MI_Rows_rotate | MBI_Rows_rotate | MSI_Rows_rotate | MLI_Rows_rotate | MQI_Rows_rotate |
MU_Rows_rotate | MUB_Rows_rotate | MUS_Rows_rotate | MUL_Rows_rotate | MUQ_Rows_rotate |
|
Funktion | alle Zeilen um eine bestimmte Anzahl von Positionen rotieren; hierdurch werden ganze Spalten verschoben |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_rotate( fMatrix MA, ui ht, ui len, int pos ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Rows_rotate( const int pos ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_rotate( MA:fMatrix; ht, len:UIntSize; pos:Integer ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_rotate( fMatrix d_MA, ui ht, ui len, int pos );
void MFcu_Rows_rotate( fMatrix h_MA, ui ht, ui len, int pos );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_rotate( d_MA:fMatrix; ht, len:UIntSize; pos:Integer ): IntBool;
procedure MFcu_Rows_rotate( h_MA:fMatrix; ht, len:UIntSize; pos:Integer );
|
|
Beschreibung | MAi,j = MAi, len-pos+j, j=0,..,pos-1
MAi,j = MAi, j-pos, j=pos,...,len-1
Da diese Funktion jedes Mal intern Puffer-Speicher reservieren und wieder freigeben muss, ist sie nicht sonderlich effizient. Für Anwendungen, die häufiger Rotationen durchführen, empfehlen wir, einmal eine Puffermatrix zu allozieren und mit dieser MF_Rows_rotate_buf anstelle der vorliegenden Funktion aufzurufen. |
|
|
MF_Rows_rotate_buf
| MD_Rows_rotate_buf |
ME_Rows_rotate_buf |
MCF_Rows_rotate_buf |
MCD_Rows_rotate_buf |
MCE_Rows_rotate_buf |
MI_Rows_rotate_buf | MBI_Rows_rotate_buf | MSI_Rows_rotate_buf | MLI_Rows_rotate_buf | MQI_Rows_rotate_buf |
MU_Rows_rotate_buf | MUB_Rows_rotate_buf | MUS_Rows_rotate_buf | MUL_Rows_rotate_buf | MUQ_Rows_rotate_buf |
|
Funktion | alle Zeilen um eine bestimmte Anzahl von Positionen rotieren; hierdurch werden ganze Spalten verschoben |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_rotate_buf( fMatrix MA, ui ht, ui len, int pos, fMatrix MBuf ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Rows_rotate_buf( const int pos, const matrix<T> MBuf ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_rotate_buf( MA:fMatrix; ht, len:UIntSize; pos:Integer; MBuf:fMatrix ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_rotate_buf( fMatrix d_MA, ui ht, ui len, int pos, fMatrix d_MBuf );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_rotate_buf( d_MA:fMatrix; ht, len:UIntSize; pos:Integer; d_MBuf:fMatrix ): IntBool;
|
|
Beschreibung | MAi,j = MAi, len-pos+j, j=0,..,pos-1
MAi,j = MAi, j-pos, j=pos,...,len-1
Diese Funktion stellt eine effizientere Variante von MF_Rows_rotate dar: Anstatt den intern benötigten Pufferspeicher jedes Mal vom Betriebssystem anzufordern und wieder freizugeben, wird er in Form der Puffermatrix MBuf als Argument übernommen. MBuf muss eine mit Hilfe der OptiVec-Speicherroutinen MF_matrix etc. erzeugte Matrix mit mindestens ebenso vielen Elementen wie MA sein. |
|
|
MF_Rows_runprod
| MD_Rows_runprod |
ME_Rows_runprod |
MCF_Rows_runprod |
MCD_Rows_runprod |
MCE_Rows_runprod |
|
Funktion | laufendes Produkt über die Zeilen-Elemente |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_runprod( fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Rows_runprod( ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_runprod( MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_runprod( fMatrix d_MA, ui ht, ui len );
void MFcu_Rows_runprod( fMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_runprod( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_runprod( h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Für alle Zeilen einzeln wird jedes Element als Produkt seiner selbst und aller vorhergehenden Elemente berechnet. Man gebrauche diese Funktion mit Vorsicht: Überlauf wird leicht erreicht, und Unterlauf kann dazu führen, dass alle Elemente von einem bestimmten Punkt ab gleich 0 werden. |
|
|
MF_Rows_runsum
| MD_Rows_runsum |
ME_Rows_runsum |
MCF_Rows_runsum |
MCD_Rows_runsum |
MCE_Rows_runsum |
|
Funktion | laufende Summe über Zeilen-Elemente |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_runsum( fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Rows_runsum( ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_runsum( MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_runsum( fMatrix d_MA, ui ht, ui len );
void MFcu_Rows_runsum( fMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_runsum( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_runsum( h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Für alle Zeilen einzeln wird jedes Element als Summe seiner selbst und aller vorhergehender Elemente berechnet. |
|
|
MCF_Rows_sabsmax
| MCD_Rows_sabsmax |
MCE_Rows_sabsmax |
|
Funktion | Denjenigen Wert jeder Zeile, der die größte Summe |Re| + |Im| aufweist, in einem Spalten-Vektor speichern |
|
Syntax C/C++ | #include <MCFstd.h>
void MCF_Rows_sabsmax( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> T>::Rows_sabsmax( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
procedure MCF_Rows_sabsmax( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Rows_sabsmax( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Rows_sabsmax( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Rows_sabsmax( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Rows_sabsmax( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Das in bezug auf die Summe |Re| + |Im| größte Element jeder Zeile i von MA wird gespeichert als Element Yi für i=0,..,ht-1 |
|
|
MCF_Rows_sabsmin
| MCD_Rows_sabsmin |
MCE_Rows_sabsmin |
|
Funktion | Denjenigen Wert jeder Zeile, der die kleinste Summe |Re| + |Im| aufweist, in einem Spalten-Vektor speichern |
|
Syntax C/C++ | #include <MCFstd.h>
void MCF_Rows_sabsmin( cfVector Y, cfMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<complex<T> T>::Rows_sabsmin( const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MCFstd;
procedure MCF_Rows_sabsmin( Y:cfVector; MA:cfMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_Rows_sabsmin( cfVector d_Y, cfMatrix d_MA, ui ht, ui len );
void MCFcu_Rows_sabsmin( cfVector h_Y, cfMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_Rows_sabsmin( d_Y:cfVector; d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_Rows_sabsmin( h_Y:cfVector; h_MA:cfMatrix; ht, len:UIntSize );
|
|
Beschreibung | Das in bezug auf die Summe |Re| + |Im| kleinste Element jeder Zeile i von MA wird gespeichert als Element Yi für i=0,..,ht-1 |
|
|
MF_Rows_sub
| MD_Rows_sub |
ME_Rows_sub |
MCF_Rows_sub |
MCD_Rows_sub |
MCE_Rows_sub |
|
Funktion | eine Zeile durch die Differenz ihrer selbst und einer anderen Zeile ersetzen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_sub( fMatrix MA, ui ht, ui len, unsigned destRow, unsigned sourceRow ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Rows_sub( const unsigned destRow, const unsigned sourceRow ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_sub( MA:fMatrix; ht, len, destRow, sourceRow:UIntSize; ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_sub( fMatrix d_MA, ui ht, ui len, unsigned destRow, unsigned sourceRow );
void MFcu_Rows_sub( fMatrix h_MA, ui ht, ui len, unsigned destRow, unsigned sourceRow ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_sub( d_MA:fMatrix; ht, len, destRow, sourceRow:UIntSize ): IntBool;
procedure MFcu_Rows_sub( h_MA:fMatrix; ht, len, destRow, sourceRow:UIntSize );
|
|
Beschreibung | MAdestRow, j -= MAsourceRow, j, i=0,...,len-1 |
|
|
MF_Rows_sum
| MD_Rows_sum |
ME_Rows_sum |
MCF_Rows_sum |
MCD_Rows_sum |
MCE_Rows_sum |
|
Funktion | Summen über alle Elemente jeder einzelnen Zeile in einem Spalten-Vektor speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Rows_sum( fVector Y, fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::Rows_sum( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_Rows_sum( Y:fVector; MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Rows_sum( fVector d_Y, fMatrix d_MA, ui ht, ui len );
void MFcu_Rows_sum( fVector h_Y, fMatrix h_MA, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Rows_sum( d_Y:fVector; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_sum( h_Y:fVector; h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Yi = Summe( MAi,j, j=0,...,len-1), i=0,...,ht-1 |
|
|
MF_safeSolve
| MD_safeSolve |
ME_safeSolve |
MFb_safeSolve
| MDb_safeSolve |
MEb_safeSolve |
MFb_safeSolve_sizeBuf
| MDb_safeSolve_sizeBuf |
MEb_safeSolve_sizeBuf |
|
Funktion | "sicheres" Lösen eines linearen Gleichungs-Systems MA * X = B; im Falle singulärer Systeme wird eine einzige Lösung aus dem unendlichen Lösungsraum ausgewählt |
|
Syntax C/C++ | #include <MFstd.h>
int MF_safeSolve( fVector X, fMatrix MA, fVector B, ui len );
int MF_safeSolvewEdit( fVector X, fMatrix MA, fVector B, ui len, float thresh );
int MFb_safeSolve( fVector X, fMatrix MA, fVector B, ui len, fVector Buf );
int MFb_safeSolvewEdit( fVector X, fMatrix MA, fVector B, ui len, float thresh, fVector Buf );
ui MFb_safeSolve_sizeBuf( ui len ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::safeSolve( const matrix<T>& MA, const vector<T>& B );
void vector<T>::safeSolvewEdit( const matrix<T>& MA, const vector<T>& B, T thresh ); |
Pascal/Delphi | uses MFstd;
function MF_safeSolve( X:fVector; MA:fMatrix; B:fVector; len:UIntSize ):Integer;
function MF_safeSolvewEdit( X:fVector; MA:fMatrix; B:fVector; len:UIntSize; thresh:Single ):Integer;
function MFb_safeSolve( X:fVector; MA:fMatrix; B:fVector; len:UIntSize; Buf:fVector ):Integer;
function MFb_safeSolvewEdit( X:fVector; MA:fMatrix; B:fVector; len:UIntSize; thresh:Single; Buf:fVector ):Integer;
function MFb_safeSolve_sizeBuf( len:UIntSize ):UIntSize; |
|
Beschreibung | MF_safeSolve ist ähnlich MF_solve mit dem Unterschied, dass, falls es keine eindeutige Lösung des linearen Gleichungssystems gibt (also die LU-Faktorisierung fehlschlägt), mittels Singulärwert-Zerlegung (SVD) wenigstens eine Lösung aus dem unendlichen Lösungsraum gefunden wird. Man beachte, dass das Problem singulärer linearer Gleichungssysteme nicht etwa darin besteht, dass es keine Lösung gäbe, sondern dass diese Systeme im Gegenteil unter-determiniert sind und eine unendliche Zahl von Lösungen besitzen. Mit anderen Worten, es können ein oder mehrere Elemente des Lösungsvektors willkürlich gewählt werden. Genau dies tut MF_safeSolve, und zwar in der Weise, dass der Lösungsvektor mit der kleinsten Euclid-schen Norm (s. VF_Euclid) bestimmt wird.
Ein Rückgabewert von 0 zeigt an, dass eine eindeutige Lösung gefunden wurde (d.h. Erfolg über LUD); 1 zeigt eine Lösung über SVD, und -1 wird in dem sehr seltenen Fall zurückgegeben, dass auch SVD fehlschlägt.
Die Entscheidung zwischen LUD und SVD ebenso wie die Singulärwert-Editierung im Falle der Wahl des SVD-Zweigs wird dabei aufgrund der Standard-Schwelle für die Dimensions-Reduktion durch SV-Editierung getroffen. Diese kann mittels MF_SVDsetEdit verändert werden. Da allerdings MF_SVDsetEdit nicht fiber-sicher ist, sollte diese Funktion nicht verwendet werden, um verschiedene Schwellenwerte für verschiedene Aufrufe von MF_safeSolve usw. einzustellen. Anstatt wiederholt den Standard-Wert zu ändern, gebrauche man vielmehr die "wEdit"-Varianten von MF_safeSolve usw., also MF_safeSolvewEdit, MF_SVsolvewEdit und MF_solveBySVDwEdit.
Diese Funktionen benötigen Pufferspeicher. Die "Normal-Versionen" (Präfix MF_, MD_ usw.) allozieren ihn selbst, während die Versionen mit den Präfixen MFb_, MDb_ etc. als zusätzliches Aufruf-Argument einen Vektor Buf übernehmen. Die erforderliche Größe von Buf kann mittels Aufruf von MFb_safeSolve_sizeBuf(len) abgefragt werden (Angabe nicht in byte, sondern als Zahl der Elemente von Buf im jeweiligen Datentyp!).
|
|
|
|
Funktion | Farbskala für Farbton-Plots berechnen |
|
Syntax C/C++ | #include <Mgraph.h>
void M_setDensityBounds( extended zmin, extended zmax, COLORREF mincolor, COLORREF maxcolor ); |
Pascal/Delphi | uses Mgraph;
procedure M_setDensityBounds( zmin, zmax: Extended; mincolor, maxcolor: COLORREF ); |
|
Beschreibung | Eine Farbtonskala wird zwischen den Farben mincolor und maxcolor entsprechend den zugehörigen zmin und zmax berechnet. Bei allen folgenden Aufrufen von MF_xyzDataDensityMap oder MF_zDataDensityMap werden die z-Werte durch lineare Interpolation zwischen den so gesetzten Extremen in Farbtöne übersetzt. Man wird diese Funktion selten direkt aufrufen. Sie wird vor allem intern von allen Funktionen der MF_xyzAutoDensityMap- und MF_zAutoDensityMap-Familien gebraucht. |
|
|
|
Funktion | z-Wert-Farbskala für Farbton-Plots berechnen und und X-Y-Koordinatensystem zeichnen |
|
Syntax C/C++ | #include <Mgraph.h>
void M_setDensityMapBounds( extended xmin, extended xmax, extended ymin, extended ymax, extended zmin, extended zmax, COLORREF mincolor, COLORREF maxcolor ); |
Pascal/Delphi | uses Mgraph;
procedure M_setDensityMapBounds( xmin, xmax, ymin, ymax, zmin, zmax: Extended; mincolor, maxcolor: COLORREF ); |
|
Beschreibung | Ähnlich der Funktion V_drawAxes für X-Y Vektor-Plots berechnet diese Funktion eine Farbtonskala aus den Parametern mincolor, maxcolor, zmin und zmax und bereitet ein X-Y-Koordinatensystem gemäß der durch xmin, xmax, ymin und ymax spezifizierten x- und y-Bereiche für Farbton-Plots von Matrizen vor. Im Unterschied zu M_findDensityMapBounds wird keine Anpassung der x- und y-Achsen an "runde Werte" auf den Rasterlinien vorgenommen. |
|
|
MF_setElement
| MD_setElement |
ME_setElement |
MCF_setElement |
MCD_setElement |
MCE_setElement |
MI_setElement | MBI_setElement | MSI_setElement | MLI_setElement | MQI_setElement |
MU_setElement | MUB_setElement | MUS_setElement | MUL_setElement | MUQ_setElement |
|
Funktion | Schreib-Zugriff auf ein einzelnes Matrix-Element |
|
Syntax C/C++ | #include <MFstd.h>
void MF_setElement( fMatrix MA, ui ht, ui len, unsigned m, unsigned n, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::setElement( const unsigned m, const unsigned n, const T C ); |
Pascal/Delphi | uses MFstd;
procedure MF_setElement( MA:fMatrix; ht, len, m, n:UIntSize; C:Single );
|
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
void cudaMF_setElement( fMatrix d_MA, ui ht, ui len, unsigned m, unsigned n, float C );
void cusdMF_setElement( fMatrix d_MA, ui ht, ui len, unsigned m, unsigned n, float *d_C );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
procedure cudaMF_setElement( d_MA:fMatrix; ht, len, m, n:UIntSize; C:Single );
procedure cusdMF_setElement( d_MA:fMatrix; ht, len, m, n:UIntSize; d_C:PSingle );
|
|
Beschreibung | Das Element MAm,n wird mit dem Wert C überschrieben.
|
|
|
|
VF_setLinfitNeglect
| VD_setLinfitNeglect |
VE_setLinfitNeglect |
|
Funktion | Signifikanz-Schwelle für lineare Datenanpassung festlegen |
|
Syntax C/C++ | #include <MFstd.h>
void VF_setLinfitNeglect( float Thresh ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::setLinfitNeglect( const T& Thresh );
void matrix<T>::setLinfitNeglect( const T& Thresh ); |
Pascal/Delphi | uses MFstd;
procedure VF_setLinfitNeglect( Thresh:Single ); |
|
Beschreibung | Wie für VF_linfit beschrieben, erlaubt diese Funktion die Definition einer Signifikanz-Schwelle, unterhalb derer Parameter ai ignoriert werden. Standardmäßig ist diese Schwelle auf 4*FLT_EPSILON, 8*DLB_EPSILON, oder 16*LDBL_EPSILON eingestellt. Die aktuelle Schwelle kann mittels VF_getLinfitNeglect gelesen werden. |
|
|
VF_setNonlinfitOptions
| VD_setNonlinfitOptions |
VE_setNonlinfitOptions |
VF_setNonlinfitDefaultOptions
| VD_setNonlinfitDefaultOptions |
VE_setNonlinfitDefaultOptions |
|
Funktion | Optionen für nicht-lineare Datenanpassungs-Routinen setzen |
|
Syntax C/C++ | #include <MFstd.h>
void VF_setNonlinfitOptions( VF_NONLINFITOPTIONS *Options );
void VF_setNonlinfitDefaultOptions( void ); |
Pascal/Delphi | uses MFstd;
procedure VF_setNonlinfitOptions( Options: VF_NONLINFITOPTIONS );
procedure VF_setNonlinfitDefaultOptions( ); |
|
Beschreibung | Die nicht-linearen Datenanpassungs-Routinen wie VF_nonlinfit bieten dem Anwender eine Vielzahl verschiedener Optionen, die in der Struktur VF_NONLINFITOPTIONS (VD_NONLINFITOPTIONS und VE_NONLINFITOPTIONS für die höheren Datentypen) zusammengefaßt sind. Diese Optionen werden durch die Funktion V_setNonlinfitOptions gesetzt. Um die derzeit eingestellten Optionen zu lesen, rufe man V_getNonlinfitOptions. Um ggf. zu den "Fabrik-Einstellungen" zurückzukehren, rufe man V_setNonlinfitDefaultOptions.
Die mit dieser Funktion gesetzten Optionen gelten für alle Datenanpassungs-Funktionen derselben Genauigkeits-Stufe. Das heißt, dass beispielsweise VD_setNonlinfitOptions die für VD_nonlinfit, VD_multiNonlinfit, MD_nonlinfit, MD_multiNonlinfit und deren Geschwister mit Einzelpunkt-Wichtung ("wW"-Versionen) setzt.
Diese Funktion ist nicht geeignet, um verschiedene Sätze von Optionen an verschiedene Aufrufe von nonlinfit-Funktionen zu übergeben, die von unterschiedlichen Arbeits-Threads aus getätigt werden. Stattdessen verwende man die vollständige Syntax der nonlinfit-Funktionen, um jeder Instanz ihren Eigenen Optionen-Satz als Argument zu übergeben. |
Beispiel C/C++ | VF_NONLINFITOPTIONS Opt;
VF_getNonlinfitDefaultOptions( &Opt ); // Ausgangspunkt: Fabrikeinstellungen
Opt.FigureOfMerit = 0; // kleinste Fehlerquadrate wählen
Opt.AbsTolChi = 1.e-6;
Opt.FracTolChi = 1.e-3; // schneller, aber nicht sehr genauer Fit
Opt.LevelOfMethod = 1; // nur Levenberg-Marquardt
VF_setNonlinfitOptions( &Opt ); |
Beispiel Pascal/Delphi | Opt: VD_NONLINFITOPTIONS;
VD_getNonlinfitDefaultOptions(Opt );
Opt.FigureOfMerit := 1; (* "robuster Fit: kleinste Absolut-Fehler *)
Opt.AbsTolChi := 1.e-10;
Opt.FracTolChi := 1.e-8; (* langsamerer, aber genauerer Fit *)
Opt.LevelOfMethod := 3; (* abwechselnde Levenberg-Marquardt- und Downhill-Simplex-Durchgänge *)
VD_setNonlinfitOptions(Opt ); |
|
|
MF_setWriteFormat
| MD_setWriteFormat |
ME_setWriteFormat |
MCF_setWriteFormat |
MCD_setWriteFormat |
MCE_setWriteFormat |
|
Funktion | Definition des Ausgabeformats für M?_write: nur C/C++ ! |
|
Syntax C/C++ | #include <MFstd.h>
void MF_setWriteFormat( char *FormatString ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::setWriteFormat( char *FormatString ); |
Pascal/Delphi | Diese Funktionen existieren nicht. |
|
Beschreibung | Diese Funktionen sind identisch mit der VF_setWriteFormat-Familie.
Das Zahlenformat der von M?_write geschriebenen Matrix-Elemente kann mit deser Funktion modifiziert werden. Sollen von M?_write geschriebene Zahlen irgendwann wieder eingelesen werden, dann sei man sich der Beschränkungen der M?_read-Funktionen bewußt: Nicht alle Formate, die man für die Ausgabe wählen kann, können hinterher korrekt gelesen werden.
MF_setWriteFormat sollte nicht für die Definition von Whitespace zwischen den Spalten eingesetzt werden. Dies ist vielmehr die Aufgabe von MF_setWriteSeparate.
Die folgende Tabelle faßt die für die verschiedenen Datentypen verwendeten Formate zusammen. Die letzte Spalte gibt die maximale Länge des Format-Strings an.
Version | Standard-Format | Alternativ-Beispiel | max. Länge |
MF_ | "% 11.8e" | "% 8.4f" | 16 |
MD_ | "% 19.16le" | "% 16.8lf" | 16 |
ME_ | "% 22.19Le" | "% 22.19LG" | 16 |
MCF_ | "% 11.8e, % 11.8e" | "{% 8.4f, % 8.4f}" | 32 |
MCD_ | "% 19.16le, % 19.16le" | "{% 19.16lE % 19.16lE}" | 32 |
MCE_ | "% 22.19Le, % 22.19Le" | "{% 22.19Lg % 22.19Lg}" | 32 |
|
|
Fehlerbehandlung | Format-Strings, deren Länge das in der obigen Tabelle angegebene Maximum übersteigt, führen zu einem Programm-Abbruch mit der Fehlermeldung "Invalid Parameter(s)".
Der eigentliche Inhalt des Format-Strings wird dagegen nicht überprüft. Man muss sich also vorsehen, nur für den jeweiligen Datentyp zulässige Formate zu spezifizieren. |
|
|
MF_setWriteSeparate
| MD_setWriteSeparate |
ME_setWriteSeparate |
MCF_setWriteSeparate |
MCD_setWriteSeparate |
MCE_setWriteSeparate |
|
Funktion | Zeichenkette zwischen den durch M?_write ausgegebenen Matrix-Spalten definieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_setWriteSeparate( char *SepString ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::setWriteSeparate( char *SepString ); |
Pascal/Delphi | uses MFstd;
procedure MF_setWriteSeparate( SepString:PChar ); |
|
Beschreibung | Diese Funktionen sind identisch mit denen der VF_setNWriteSeparate-Familie. Sie erlauben es, die Zeichenkette zu bestimmen, die zwischen den Spalten einer durch MF_write geschriebenen Tabelle stehen soll. MF_setWriteSeparate hat keinen Einfluß auf die Zeilenenden, die stets aus einem Zeilenumbruch ('\n' für C/C++ und #13 für Pascal/Delphi) bestehen.
SepString darf bis zu 12 Zeichen umfassen. Die Standard-Einstellung besteht aus einem einfachen Tabulator-Zeichen ("\t" für C/C++ und #9 für Pascal/Delphi).
|
|
Fehlerbehandlung | Falls SepString mehr als 12 Zeichen umfaßt, wird das Programm mit der Fehlermeldung "Invalid Parameter(s)" abgebrochen.
Der eigentliche Inhalt von SepString wird dagegen nicht überprüft. |
|
|
MF_solve
| MD_solve |
ME_solve |
MCF_solve |
MCD_solve |
MCE_solve |
MCF_solve |
MCD_solve |
MCE_solve |
MF_solvewEdit
| MD_solvewEdit |
ME_solvewEdit |
MCF_solvewEdit |
MCD_solvewEdit |
MCE_solvewEdit |
MFb_solve
| MDb_solve |
MEb_solve |
MCFb_solve |
MCDb_solve |
MCEb_solve |
MFb_solvewEdit
| MDb_solvewEdit |
MEb_solvewEdit |
MCFb_solvewEdit |
MCDb_solvewEdit |
MCEb_solvewEdit |
MFb_solve_sizeBuf
| MDb_solve_sizeBuf |
MEb_solve_sizeBuf |
MCFb_solve_sizeBuf |
MCDb_solve_sizeBuf |
MCEb_solve_sizeBuf |
MFsym_solve
| MDsym_solve |
MEsym_solve |
|
Funktion | lineares Gleichungssystem lösen |
|
Syntax C/C++ | #include <MFstd.h>
int MF_solve( fVector X, fMatrix MA, fVector B, ui len );
int MF_solvewEdit( fVector X, fMatrix MA, fVector B, ui len, float thresh );
int MCF_solvewEdit( cfVector X, cfMatrix MA, cfVector B, ui len, float thresh );
int MFsym_solve( fVector X, fMatrix MA, fVector B, ui len );
|
C++ MatObj | #include <OptiVec.h>
void vector<T>::solve( const matrix<T>& MA, const vector<T>& B );
void vector<T>::solvewEdit( const matrix<T>& MA, const vector<T>& B, T thresh );
void vector<T>::sym_solve( const matrix<T>& MA, const vector<T>& B );
|
Pascal/Delphi | uses MFstd;
function MF_solve( X:fVector; MA:fMatrix; B:fVector; len:UIntSize ): Integer;
function MF_solvewEdit( X:fVector; MA:fMatrix; B:fVector; len:UIntSize; thresh:Single ): Integer;
function MCF_solvewEdit( X:cfVector; MA:cfMatrix; B:cfVector; len:UIntSize; thresh:Single ): Integer;
function MFsym_solve( X:fVector; MA:fMatrix; B:fVector; len:UIntSize ): Integer; |
|
Beschreibung | Diesen Funktionen lösen das lineare Gleichungs-System MA * X = B. Im allgemeinen Fall, MF_solve, wird hierfür eine LU-Faktorisierung durchgeführt. Für den Spezialfall symmetrischer Matrizen bietet MFsym_solve einen etwa doppelt so schnellen Weg mittels Cholesky-Faktorisierung.
Zuerst wird MF_solve beschrieben. MFsym_solve folgt am Schluss.
MF_solve hat immer dann Erfolg, wenn das Gleichungssystem eine eindeutige Lösung besitzt. In diesem Fall wird FALSE (0) zurückgegeben.
Wenn sich das Gleichungs-System aber als unter-determiniert herausstellt, was immer dann geschieht, wenn eine oder mehrere der Gleichungen tatsächlich Linearkombinationen anderer Gleichungen desselben Systems darstellen, wird die Matrix singulär, und die Lösung schlägt fehl mit einem Rückgabewert von TRUE (1).
Um in Situationen, wo man mit unter-determinierten Matrizen zu rechnen hat, Singularitäten zu umgehen, kann man einen Minimalwertes für die Pivotisierung bei der LU-Faktorisierung definieren. Standardmäßig ist diese Pivot-Editierung ausgeschaltet. Um sie für alle Aufrufe von MF_LUdecompose sowie den auf LU-Zerlegung basierenden Funktionen MF_inv und MF_solve einzuschalten, kann MF_LUDsetEdit aufgerufen werden. Da diese Methode nicht fiber-sicher ist, sollte sie aber nicht angewandt werden, um bei verschiedenen Aufrufen von MF_LUdecompose, MF_inv oder MF_solve verschiedene Minimalwerte einzustellen. Zu diesem Zweck dient vielmehr die Funktion MF_solvewEdit, die die gewünschte Editier-Schwelle als zusätzliches Argument thresh übernimmt.
Der Rückgabewert von MF_solve und MF_solvewEdit zeigt an, ob die Lösung des Gleichungssystems erfolgreich war:
Rückgabewert | Bedeutung |
0 | Matrix MA ist regulär; Gleichungssystem konnte erfolgreich gelöst werden |
1 | Matrix MA ist singulär; Ergebnis X komplett unbrauchbar |
2 | Matrix MA (nahezu) singulär; durch Pivot-Editierung konnte eine der unendlich vielen Lösungen gefunden werden; ob dieses Ergebnis brauchbar ist, hängt von der spezifischen Anwendung ab |
Um zu prüfen, ob MF_solve erfolgreich war, kann in Single-Thread-Programmen auch MF_LUDresult aufgerufen werden, deren Rückgabewert FALSE (0) sein wird, wenn das Gleichungssystem eindeutig und ohne Pivot-Editierung gelöst werden konnte, und TRUE (1) für eine singuläre Eingabe-Matrix MA. Da in Multithread-Programmen ggf. nicht klar ist, auf welche Instanz von MF_solve sich MF_LUDresult bezieht, sollte hier nicht MF_LUDresult aufgerufen, sondern immer nur der Rückgabewert von MF_solve überprüft werden.
Alternativ zur Pivot-Editierung kann man auch MF_safeSolve oder MF_solveBySVD anstelle des einfachen MF_solve verwenden.
Für symmetrische Matrizen bietet MFsym_solve wie erwähnt einen schnelleren Weg zur Lösung. Diese Routine führt zunächst eine Cholesky-Faktorisierung durch. Nur in dem Fall, dass sich die Eingabe-Matrix dabei als nicht-positiv-definit herausstellt, wird doch wieder LUD angewandt. Der Rückgabewert von MFsym_solve zeigt an, ob das lineare Gleichungssystem erfolgreich gelöst werden konnte:
Rückgabewert | Bedeutung |
0 | Matrix MA ist regulär; Gleichungssystem konnte erfolgreich entweder über Cholesky oder über LUD gelöst werden |
1 | Matrix MA ist singulär; sowohl Cholesky als auch LUD scheiterten; Ergebnis X komplett unbrauchbar |
2 | Matrix MA (nahezu) singulär; über LUD konnte durch Pivot-Editierung eine der unendlich vielen Lösungen gefunden werden; ob dieses Ergebnis teilweise brauchbar ist, hängt von der spezifischen Anwendung ab |
|
|
Rückgabewert | Ein Code 0, 1 oder 2, siehe oben |
|
|
MF_solveBySVD
| MD_solveBySVD |
ME_solveBySVD |
MFb_solveBySVD
| MDb_solveBySVD |
MEb_solveBySVD |
MFb_solveBySVD_sizeBuf
| MDb_solveBySVD_sizeBuf |
MEb_solveBySVD_sizeBuf |
|
Funktion | möglicherweise über- oder unter-determiniertes lineares Gleichungssystem über Singular-Value-Decomposition lösen |
|
Syntax C/C++ | #include <MFstd.h>
int MF_solveBySVD( fVector X, fMatrix MA, fVector B, ui htA, ui lenA );
int MF_solveBySVDwEdit( fVector X, fMatrix MA, fVector B, ui htA, ui lenA, float thresh );
int MFb_solveBySVD( fVector X, fMatrix MA, fVector B, ui htA, ui lenA, fVector Buf );
int MFb_solveBySVDwEdit( fVector X, fMatrix MA, fVector B, ui htA, ui lenA, float thresh, fVector Buf );
ui MFb_solveBySVD_sizeBuf( ui htA, ui lenA );
|
C++ MatObj | #include <OptiVec.h>
void vector<T>::solveBySVD( const matrix<T>& MA, const vector<T>& B );
void vector<T>::solveBySVDwEdit( const matrix<T>& MA, const vector<T>& B, T thresh ); |
Pascal/Delphi | uses MFstd;
function MF_solveBySVD( X:fVector; MA:fMatrix; B:fVector; htA, lenA:UIntSize ): IntBool;
function MF_solveBySVDwEdit( X:fVector; MA:fMatrix; B:fVector; htA, lenA:UIntSize; thresh:Single ): IntBool;
function MFb_solveBySVD( X:fVector; MA:fMatrix; B:fVector; htA, lenA:UIntSize; Buf:fVector ): IntBool;
function MFb_solveBySVDwEdit( X:fVector; MA:fMatrix; B:fVector; htA, lenA:UIntSize; thresh:Single; Buf:fVector ): IntBool;
function MFb_solveBySVD( htA, lenA:UIntSize ): UIntSize; |
|
Beschreibung | Das lineare Gleichungssystem MA * X = B wird unter Verwendung von Singulärwert-Zerlegung (Singular Value Decomposition, SVD) gelöst . Hier führen unterdeterminierte Systems nicht zu Fehlern. Vielmehr erhält man durch Dimensions-Reduktion eine einzelne Lösung aus dem unendlichen Lösungsraum. Hat man aber mehr Gleichungen als Unbekannte, handelt es sich also um ein überdeterminiertes System, enthält der Lösungs-Vektor X einen "Kompromiß" zwischen den Gleichungen unter Minimierung der Euclid'schen Norm des Lösungsvektors.
Diese Funktion sollte immer FALSE (0) zurückgeben. Nur in dem sehr unwahrscheinlichen Fall, dass der SVD-Algorithmus nicht konvergiert, wird TRUE (1) zurückgegeben. Die Länge des Lösungs-Vektors, sizX, muss gleich der Breite der Eingabe-Matrix, lenA, sein, während die Länge des Vektors B, sizB, gleich htA sein muss.
Die standardmäßig voreingestellte Schwelle für die Dimensions-Reduktion durch SV-Editierung kann mittels MF_SVDsetEdit verändert werden. Da allerdings MF_SVDsetEdit nicht fiber-sicher ist, sollte diese Funktion nicht verwendet werden, um verschiedene Schwellenwerte für verschiedene Aufrufe von MF_solveBySVD usw. einzustellen. Anstatt wiederholt den Standard-Wert zu ändern, gebrauche man vielmehr die "wEdit"-Varianten von MF_solveBySVD usw., also MF_solveBySVDwEdit, MF_SVsolvewEdit und MF_safeSolvewEdit.
Diese Funktionen benötigen Pufferspeicher. Die "Normal-Versionen" (Präfix MF_, MD_ usw.) allozieren ihn selbst, während die Versionen mit den Präfixen MFb_, MDb_ etc. als zusätzliches Aufruf-Argument einen Vektor Buf übernehmen. Die erforderliche Größe von Buf kann mittels Aufruf von MFb_solveBySVD_sizeBuf(ht,len) abgefragt werden (Angabe nicht in byte, sondern als Zahl der Elemente von Buf im jeweiligen Datentyp!).
|
|
Rückgabewert | normalerweise FALSE (0); nur in dem sehr unwahrscheinlichen Fall eines Scheiterns von SVD wird TRUE (1) zurückgegeben. |
|
|
MF_spectrum
| MD_spectrum |
ME_spectrum |
MFb_spectrum
| MDb_spectrum |
MEb_spectrum |
MFb_spectrum_sizeBuf
| MDb_spectrum_sizeBuf |
MEb_spectrum_sizeBuf |
|
Funktion | Raumfrequenz-Spektrum |
|
Syntax C/C++ | #include <MFstd.h>
void MF_spectrum( fMatrix MSpec, ui htSpec, ui lenSpec, fMatrix MX, ui htX, ui lenX, fMatrix Win );
void MFb_spectrum( fMatrix MSpec, ui htSpec, ui lenSpec, fMatrix MX, ui htX, ui lenX, fMatrix Win, fVector Buf );
ui MFb_spectrum_sizeBuf( ui htSpec, ui lenSpec, ui htX, ui lenX ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::spectrum( const matrix<T>& MX, const matrix<T>& MWin );
void matrix<T>::b_spectrum( const matrix<T>& MX, const matrix<T>& MWin, vector<T> Buf ); |
Pascal/Delphi | uses MFstd;
procedure MF_spectrum( MSpec:fMatrix; htSpec, lenSpec:UIntSize; MX:fMatrix; htX, lenX:UIntSize; MWin:fMatrix );
procedure MFb_spectrum( MSpec:fMatrix; htSpec, lenSpec:UIntSize; MX:fMatrix; htX, lenX:UIntSize; MWin:fMatrix; Buf:fVector );
function MFb_spectrum_sizeBuf( htSpec, lenSpec, htX, lenX:UIntSize ): UIntSize; |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_spectrum( fMatrix d_Spec, ui htSpec, ui lenSpec, fMatrix d_X, ui htX, ui lenX, fMatrix d_Win );
void MFcu_spectrum( fMatrix h_Spec, ui htSpec, ui lenSpec, fMatrix h_X, ui htX, ui lenX, fMatrix h_Win );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_spectrum( d_MSpec:fMatrix; htSpec, lenSpec:UIntSize; d_MX:fMatrix; htX, lenX:UIntSize; d_MWin:fMatrix ): IntBool;
procedure MFcu_spectrum( h_MSpec:fMatrix; htSpec, lenSpec:UIntSize; h_MX:fMatrix; htX, lenX:UIntSize; h_MWin:fMatrix );
|
|
Beschreibung | Das mittlere Amplitudenquadrat des Raumfrequenz-Spektrums der in MX enthaltenen Daten wird berechnet und in MSpc gespeichert.
Intern wird MX in überlappende Segmente unterteilt, ähnlich wie für den eindimensionalen Fall bei VF_spectrum beschrieben. MWin ist ein Fenster, das auf die Datensegmente angewendet wird. OptiVec bietet drei Funktionen zur Erzeugung passender Fenster: MF_Welch, MF_Parzen und MF_Hann. Ein Rechteck-Fenster erhält man durch Setzen aller Matrix-Elemente auf den Wert 1.0 (MF_equC( MWin, htWin, lenWin, 1.0 ); ), dies wird aber nicht empfohlen.
htSpec und lenSpec müssen ganzzahlige Potenzen von 2 sein. Außerdem müssen folgende Bedingungen erfüllt sein:
htX >= n*htSpec, lenX >= n*lenSpec, htWin = htSpec, lenWin = lenSpec.
Intern benötigt MF_spectrum zusätzlichen Pufferspeicher, der automatisch reserviert und wieder freigegeben wird. Bei wiederholten Aufrufen wäre dies ineffizient. Es wird empfohlen, für solche Fälle stattdessen MFb_spectrum zu verwenden. Die notwendige Größe von Buf kann dabei durch Aufruf der Funktion MFb_spectrum_sizeBuf ermittelt werden. Sie wird nie mehr als 4*htX*lenX betragen. Außerdem muss Buf 128-bit (P8) bzw. 256-bit( P9) ausgerichtet sein. Um dies zu garantieren, sollte man nur Vektoren als Buf verwenden, die mit der VF_vector-Familie alloziert wurden. |
|
Fehlerbehandlung | Falls entweder htSpec oder lenSpec keine ganzzahlige Potenz von 2 ist, meldet sich VF_FFT (worauf MF_spectrum basiert) mit der Fehlermeldung "Size must be an integer power of 2" und bricht das Programm ab. |
|
|
MFsym_sqrt
| MDsym_sqrt |
MEsym_sqrt |
|
Funktion | Quadratwurzel einer symmetrischen Matrix mit ausschließlich positiven Eigenwerten |
|
Syntax C/C++ | #include <MFstd.h>
int MFsym_sqrt( fMatrix MB, fMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::sqrt( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
function MFsym_sqrt( MB, MA:fMatrix; len:UIntSize ):IntBool; |
|
Beschreibung | Die Quadratwurzel der symmetrischen Matrix A wird berechnet, so dass die Matrix B die Gleichung MB * MB = MA erfüllt. Man beachte, dass außer der Symmetriebedingung noch die zweite Bedingung erfüllt sein muss, dass alle Eigenwerte von MA positiv oder gleich 0 sein müssen. Zwar können auch nicht-symmetrische Matrizen oder solche mit negativen Eigenwerten u.U. eine Quadratwurzel besitzen. Der hier verwendete Algorithmus ist aber auf den einfachsten Fall derjenigen Matrizen beschränkt, die immer eine Quadratwurzel besitzen. Die Berechnung erfolgt über die Eigenwerte und Eigenvektoren. Beim Auftreten eines negativen Eigenwertes erfolgt eine Fehlermeldung, und das Ergebnis wird unter Ersetzung des negativen Eigenwertes durch 0 berechnet. War der beanstandete negative Eigenwert sehr klein, so kann das Ergebnis u.U. noch brauchbar sein.
Ein Rückgabewert FALSE oder 0 signalisiert Erfolg; TRUE oder nicht-Null stehen für Mißerfolg. |
|
Rückgabewert | im Erfolgsfall FALSE (0); sonst TRUE (1) |
|
|
MF_store
| MD_store |
ME_store |
MCF_store |
MCD_store |
MCE_store |
MI_store | MBI_store | MSI_store | MLI_store | MQI_store |
MU_store | MUB_store | MUS_store | MUL_store | MUQ_store |
|
Funktion | Matrix im Binärformat in einem Stream speichern |
|
Syntax C/C++ | #include <MFstd.h>
int MF_store( FILE *stream, fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
int matrix<T>::store( FILE *stream ); |
Pascal/Delphi | uses MFstd;
function MF_store( var Stream:FILE; MA:fMatrix; ht, len:UIntSize ): Integer; |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_store( FILE *stream, fMatrix d_MA, ui ht, ui len );
int cudaMF_store_buf( FILE *stream, fMatrix d_MA, ui ht, ui len, fVector h_Wk ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_store( var Stream:File; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMF_store_buf( var Stream:File; d_MA:fMatrix; ht, len:UIntSize; h_Wk:fVector ): IntBool;
|
|
Beschreibung | Die Matrix A mit ht*len Elementen wird im Binärformat in stream gespeichert. stream muss bereits für binäre Schreib-Operationen geöffnet sein.
nur CUDA-Versionen: cudaM?_store_buf übernimmt einen Host-Vektor h_Wk als zusätzliches Argument. Dieser dient als Pufferspeicher und muss (mindestens) dieselbe Größe (ht*len) haben wie d_MA. Hierdurch wird die interne Bereitstellung von Pufferspeicher bei cudaM?_store eingespart, so dass cudaM?_store_buf etwas schneller ist.
Nur GCC und CLang: GCC und CLang (einschließlich BCC32C) erweitern den 10-byte Datentyp long double zu 12 oder 16 bytes im Speicher (12 byte in 32-bit, 16 byte in 64 bit). Um für Kompatibilität zwischen den mit den verschiedenen Compilern erzeugten Dateien zu sorgen, schreiben und lesen die Funktionspaare ME_store / ME_recall und MCE_store / MCE_recall stets im 10-byte-Format. |
|
Thread-Sicherheit | Verschiedene Threads können gefahrlos mehrere Funktionen der VF_ / MF_store- und VF_ / MF_recall-Familien gleichzeitig aufrufen, solange sie auf verschiedene Streams zugreifen. Falls sie allerdings auf ein- und denselben Stream zugreifen, müssen unbedingt durch geeignete Maßnahmen (Critical Sections, Mutexes) Race-Conditions verhindert werden. |
|
Fehlerbehandlung | wird durch die C-Funktion fwrite bzw. die Delphi-Funktion BlockWrite durchgeführt, auf der MF_store etc. basieren |
|
Rückgabewert | 0, wenn fehlerfrei; ansonsten 1. Um mehr Information im Falle eines Fehlers zu erhalten, inspiziere man errno (C/C++) oder IOResult (Delphi). |
|
|
MFs_subM |
MDs_subM |
MEs_subM |
MCF_subM |
MCD_subM |
MCE_subM |
|
Funktion | Element-weise Subtraktion zweier Matrizen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_subM( fMatrix MC, fMatrix MA, fMatrix MB, ui ht, ui len );
void MFs_subM( fMatrix MC, fMatrix MA, fMatrix MB, ui ht, ui len, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::subM( const matrix<T>& MA, const matrix<T>& MB);
void matrix<T>::s_subM( const matrix<T>& MA, const matrix<T>& MB, const T& C); |
Pascal/Delphi | uses MFstd;
procedure MF_subM( MC, MA, MB:fMatrix; ht, len:UIntSize );
procedure MFs_subM( MC, MA, MB:fMatrix; ht, len:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_subM( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len );
int cudaMFs_subM( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len, float C );
int cusdMFs_subM( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len, float *d_C );
void MFcu_subM( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui ht, ui len );
void MFs_subM( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui ht, ui len, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_subM( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMFs_subM( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize; C:Single ): IntBool;
function cusdMFs_subM( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize; d_C:PSingle ): IntBool;
procedure MF_subM( h_MC, h_MA, h_MB:fMatrix; ht, len:UIntSize );
procedure MFs_subM( h_MC, h_MA, h_MB:fMatrix; ht, len:UIntSize; C:Single );
|
|
Beschreibung | Normalversion: MCij = MAij - MBij
Skalierte Version: MCij = C * (MAij - MBij) |
|
|
MF_subMT
| MD_subMT |
ME_subMT |
MFs_subMT |
MDs_subMT |
MEs_subMT |
MCF_subMT |
MCD_subMT |
MCE_subMT |
|
Funktion | Transponierte einer Matrix von einer anderen Matrix subtrahieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_subMT( fMatrix MC, fMatrix MA, fMatrix MB, ui ht, ui len );
void MFs_subMT( fMatrix MC, fMatrix MA, fMatrix MB, ui ht, ui len, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::subMT( const matrix<T>& MA, const matrix<T>& MB);
void matrix<T>::s_subMT( const matrix<T>& MA, const matrix<T>& MB, const T& C); |
Pascal/Delphi | uses MFstd;
procedure MF_subMT( MC, MA, MB:fMatrix; ht, len:UIntSize );
procedure MFs_subMT( MC, MA, MB:fMatrix; ht, len:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_subMT( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len );
int cudaMFs_subMT( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len, float C );
int cusdMFs_subMT( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len, float *d_C );
void MFcu_subMT( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui ht, ui len );
void MFs_subMT( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui ht, ui len, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_subMT( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMFs_subMT( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize; C:Single ): IntBool;
function cusdMFs_subMT( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize; d_C:PSingle ): IntBool;
procedure MF_subMT( h_MC, h_MA, h_MB:fMatrix; ht, len:UIntSize );
procedure MFs_subMT( h_MC, h_MA, h_MB:fMatrix; ht, len:UIntSize; C:Single );
|
|
Beschreibung | Normalversion: MCi,j = MAi,j - MBTj,i
Skalierte Version: MCi,j = C * (MAi,j - MBTj,i) |
|
|
MF_subrMT
| MD_subrMT |
ME_subrMT |
MFs_subrMT |
MDs_subrMT |
MEs_subrMT |
MCF_subrMT |
MCD_subrMT |
MCE_subrMT |
|
Funktion | umgekehrte Subtraktion: eine Matrix von der Transponierten einer anderen subtrahieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_subrMT( fMatrix MC, fMatrix MA, fMatrix MB, ui ht, ui len );
void MFs_subrMT( fMatrix MC, fMatrix MA, fMatrix MB, ui ht, ui len, float C ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::subrMT( const matrix<T>& MA, const matrix<T>& MB);
void matrix<T>::s_subrMT( const matrix<T>& MA, const matrix<T>& MB, const T& C); |
Pascal/Delphi | uses MFstd;
procedure MF_subrMT( MC, MA, MB:fMatrix; ht, len:UIntSize );
procedure MFs_subrMT( MC, MA, MB:fMatrix; ht, len:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_subrMT( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len );
int cudaMFs_subrMT( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len, float C );
int cusdMFs_subrMT( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len, float *d_C );
void MFcu_subrMT( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui ht, ui len );
void MFs_subrMT( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui ht, ui len, float C ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_subrMT( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMFs_subrMT( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize; C:Single ): IntBool;
function cusdMFs_subrMT( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize; d_C:PSingle ): IntBool;
procedure MF_subrMT( h_MC, h_MA, h_MB:fMatrix; ht, len:UIntSize );
procedure MFs_subrMT( h_MC, h_MA, h_MB:fMatrix; ht, len:UIntSize; C:Single );
|
|
Beschreibung | Normalversion: MCi,j = MBTj,i - MAi,j
Skalierte Version: MCi,j = C * (MBTj,i - MAi,j) |
|
|
MF_submatrix
| MD_submatrix |
ME_submatrix |
MCF_submatrix |
MCD_submatrix |
MCE_submatrix |
MI_submatrix | MBI_submatrix | MSI_submatrix | MLI_submatrix | MQI_submatrix |
MU_submatrix | MUB_submatrix | MUS_submatrix | MUL_submatrix | MUQ_submatrix |
|
Funktion | Teilmatrix extrahieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_submatrix( fMatrix Sub, ui subHt, ui subLen, fMatrix Srce, ui srceHt, ui srceLen, unsigned firstRowInCol, ui sampInCol, unsigned firstColInRow, ui sampInRow ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::submatrix( const matrix<T>& MSrce, const ui firstRowInCol, const ui sampInCol, const ui firstColInRow, const ui sampInRow ); |
Pascal/Delphi | uses MFstd;
procedure MF_submatrix( MSub:fMatrix; subHt, subLen:UIntSize; MSrce:fMatrix; srceHt, srceLen:UIntSize; firstRowInCol, sampInCol, firstColInRow, sampInRow:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_submatrix( fMatrix d_MSub, ui subHt, ui subLen, fMatrix d_MSrce, ui srceHt, ui srceLen, ui firstRowInCol, ui sampInCol, ui firstColInRow, ui sampInRow );
void MFcu_submatrix( fMatrix h_MSub, ui subHt, ui subLen, fMatrix h_MSrce, ui srceHt, ui srceLen, ui firstRowInCol, ui sampInCol, ui firstColInRow, ui sampInRow ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_submatrix( d_MSub:fMatrix; subHt, subLen:UIntSize; d_MSrce:fMatrix; srceHt, srceLen:UIntSize; firstRowInCol, sampInCol, firstColInRow, sampInRow:UIntSize ): IntBool;
procedure MFcu_submatrix( h_MSub:fMatrix; subHt, subLen:UIntSize; h_MSrce:fMatrix; srceHt, srceLen:UIntSize; firstRowInCol, sampInCol firstColInRow, sampInRow:UIntSize );
|
|
Beschreibung | MSubi, j = MSrcei*sampInCol+firstRowInCol, j*sampInRow+firstColInRow |
|
|
MF_submatrix_equM
| MD_submatrix_equM |
ME_submatrix_equM |
MCF_submatrix_equM |
MCD_submatrix_equM |
MCE_submatrix_equM |
MI_submatrix_equM | MBI_submatrix_equM | MSI_submatrix_equM | MLI_submatrix_equM | MQI_submatrix_equM |
MU_submatrix_equM | MUB_submatrix_equM | MUS_submatrix_equM | MUL_submatrix_equM | MUQ_submatrix_equM |
|
Funktion | Matrix in eine Teilmatrix einer (normalerweise größere) Matrix kopieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_submatrix_equM( fMatrix Dest, unsigned destHt, unsigned destLen, unsigned firstRowInCol, ui sampInCol, unsigned firstColInRow, ui sampInRow, fMatrix Srce, ui srceHt, ui srceLen ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::submatrix_equM( const ui firstRowInCol, const ui sampInCol, const ui firstColInRow, const ui sampInRow, const matrix<T>& MSrce ); |
Pascal/Delphi | uses MFstd;
procedure MF_submatrix_equM( MDest:fMatrix; destHt, destLen, firstRowInCol, sampInCol, firstColInRow, sampInRow:UIntSize;
MSrce:fMatrix; srceHt, srceLen:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_submatrix_equM( fMatrix d_MDest, unsigned destHt, unsigned destLen, ui firstRowInCol, ui sampInCol, ui firstColInRow, ui sampInRow, fMatrix d_MSrce, ui srceHt, ui srceLen );
void MFcu_submatrix_equM( fMatrix h_MDest, unsigned destHt, unsigned destLen, ui firstRowInCol, ui sampInCol, ui firstColInRow, ui sampInRow, fMatrix h_MSrce, ui srceHt, ui srceLen ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_submatrix_equM( d_MDest:fMatrix; destHt, destLen, firstRowInCol, sampInCol, firstColInRow, sampInRow:UIntSize; d_MSrce:fMatrix; srceHt, srceLen:UIntSize ): IntBool;
procedure MFcu_submatrix_equM( h_MDest:fMatrix; destHt, destLen, firstRowInCol, sampInCol, firstColInRow, sampInRow:UIntSize; h_MSrce:fMatrix; srceHt, srceLen:UIntSize );
|
|
Beschreibung | MDesti*sampInCol+firstRowInCol, j*sampInRow+firstColInRow = MSrcei, j
Diese Funktion stellt die Umkehrung von MF_submatrix dar. |
|
|
MF_SVdecompose
| MD_SVdecompose |
ME_SVdecompose |
MFb_SVdecompose
| MDb_SVdecompose |
MEb_SVdecompose |
MFb_SVdecompose_sizeBuf
| MDb_SVdecompose_sizeBuf |
MEb_SVdecompose_sizeBuf |
|
Funktion | Singulärwert-Zerlegung (engl. Singular Value Decomposition, SVD) |
|
Syntax C/C++ | #include <MFstd.h>
int MF_SVdecompose( fMatrix U, fMatrix V, fVector W, fMatrix MA, ui htA, ui lenA );
int MFb_SVdecompose( fMatrix U, fMatrix V, fVector W, fMatrix MA, ui htA, ui lenA, fVector Buf );
ui MFb_SVdecompose_sizeBuf( ui htA, ui lenA ); |
C++ MatObj | #include <OptiVec.h>
int matrix<T>::SVdecompose( matrix<T> MV, vector<T> W, const matrix<T>& MA );
int matrix<T>::SVdecompose( matrix<T>* MV, vector<T>* W, const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
function MF_SVdecompose( MU, MV:fMatrix; W:fVector; MA:fMatrix; htA, lenA:UIntSize ): IntBool;
function MFb_SVdecompose( MU, MV:fMatrix; W:fVector; MA:fMatrix; htA, lenA:UIntSize; Buf:fVector ): IntBool;
function MFb_SVdecompose_sizeBuf( htA, lenA:UIntSize ): UIntSize; |
|
Beschreibung | Die Matrix A mit den Dimensionen [ht, len] wird in ein Produkt
MA = MU * MW * MVT,
faktorisiert, wobei MU die Dimensionen [max(ht,len), len] hat. MW ist eine Diagonalmatrix, deren Elemente alle positiv oder 0 sind. Tatsächlich wird nur die Diagonale dieser Matrix in dem Vektor W der Größe [len] gespeichert. MV schließlich ist eine Quadratmatrix [len, len]. Sowohl MU als auch MV sind orthogonal:
MUT * MU = MVT * MV = (1).
Aufgrund dieser Orthogonalitäts-Beziehungen ist die Lösung eines linearen Gleichungssystem MA * X = B sehr einfach, hat man die beschriebene Faktorisierung erst einmal durchgeführt, da lediglich MW explizit invertiert werden muss:
X = MV * W-1 * MUT
(Diese Gleichung ist von rechts nach links zu berechnen.) Die Invertierung von MW ist auch wiederum einfach, da MW eine Diagonalmatrix ist und ihre Inverse aus den Kehrwerten der Diagonalelemente besteht. Diese Eigenschaft ist es, die SVD so nützlich macht, da sie sowohl eine Diagnose als auch eine Möglichkeit zur Behebung von Singularitäten bereitstellt. Falls eine Element von W sehr klein im Vergleich zu dem größten Element ist, entspricht dies einer Singularität (zumindest im Sinne numerischer Berechnungen, wo die Division durch extrem kleine Zahlen praktisch genauso schlecht ist wie eine Division durch 0). Eine Singularität bedeutet, dass das zugrundeliegende lineare Gleichungssystem unterdeterminiert ist. Dieses wiederum heißt, dass man willkürlich eine bestimmte Lösung aus dem unendlichen Lösungsraum herausgreifen kann. Insbesondere kann man W-1ii = 0 für sehr kleine Wii wählen - eine der seltenen Gelegenheiten, wo das Ergebnis einer Division durch (fast) 0 am besten gleich 0 anstelle von Unendlich zu setzen ist. Durch diese Editierung der isolierte Singulärwerte wird eine Dimensions-Reduktion des zugrundeliegenden Problems erreicht. Sie steht an zentraler Stelle bei allen auf SVD basierenden Routinen, wie z.B. MF_SVsolve, MF_safeSolve) und VF_linfit.
Die voreingestellte Schwelle für die Dimensions-Reduktion kann durch MF_SVDsetEdit verändert werden. Da MF_SVDsetEdit allerdings nicht fiber-sicher ist, sollte diese Funktion nicht verwendet werden, um verschiedene Schwellenwerte für verschiedene Aufrufe von MF_SVsolve usw. einzustellen. Anstatt wiederholt den Standard-Wert zu ändern, gebrauche man vielmehr die "wEdit"-Varianten von MF_SVsolve usw., also MF_SVsolvewEdit, MF_solveBySVDwEdit und MF_safeSolvewEdit.
Die Singulärwerte sind in W in willkürlicher Reihenfolge gespeichert. Für manche Anwendungen (manuelle Inspektion der Singulärwerte, Dimensions-Reduktion usw.) ist es wünschenswert, die Singulärwerte in absteigender Reihenfolge zu sortieren. Hierbei müssen die Matrizen MU und MV entsprechend mit um-geordnet werden. Diese Aufgabe übernimmt die Funktion MF_SVsort.
Diese Funktionen benötigen Pufferspeicher. Die "Normal-Versionen" (Präfix MF_, MD_ usw.) allozieren ihn selbst, während die Versionen mit den Präfixen MFb_, MDb_ etc. als zusätzliches Aufruf-Argument einen Vektor Buf übernehmen. Die erforderliche Größe von Buf kann mittels Aufruf von MFb_SVdecompose_sizeBuf(ht,len) abgefragt werden (Angabe nicht in byte, sondern als Zahl der Elemente von Buf im jeweiligen Datentyp!).
Wenn Sie mittels MF_SVdecompose berechnete Ergebnisse mit SVD-Routinen anderer Anbieter vergleichen, beachten Sie bitte folgende Punkte:
- MF_SVdecompose nimmt selbst keine Dimensions-Reduktion (also keinen Ersatz sehr kleiner Singulärwerte durch 0) vor, sondern überlässt diesen Schritt nachfolgenden Funktionen oder ggf. manueller Inspektion durch den Anwender.
- Singulärwerte können vertauscht werden, wenn gleichzeitig auch die entsprechenden Spalten sowohl von MU als auch von MV vertauscht werden. Gelegentlich wird diese Eigenschaft genutzt, um die Singulärwerte in eine bestimmte (meist fallende) Reihenfolge zu bringen. Da der Vorzug geordneter Singulärwerte aber durch erhöhten Rechenaufwand erkauft wird, verzichtet MF_SVdecompose selbst auf diese Ordnung. Nur, wenn wirklich benötigt, sollte daher nach MF_SVdecompose noch die eben erwähnte Funktion MF_SVsort aufgerufen werden.
- Das Vorzeichen eines Singulärwertes kann vertauscht werden, wenn gleichzeitig die entsprechende Spalte von MV mit -1 multipliziert wird. MF_SVdecompose nutzt diese Eigenschaft, um alle nicht-verschwindenden Singulärwerte positiv zu machen.
|
|
SVD überprüfen | Die folgende Routine demonstriert SVD und Überprüfung ihres Ergebnisses.
#include <VDstd.h>
#include <MDstd.h>
#include <conio.h>
void SVDtest( void )
{
unsigned ht=386, len=52, // beliebige Werte
maxhtlen, sizeA, sizeV;
dMatrix MA, MU, MV, MOne, MA2, MUV2, MDiffA, MDiffOne;
dVector W;
double err;
maxhtlen = (ht >= len ? ht : len);
sizeA = ht*len;
sizeV = len*len;
MA = MD_matrix( ht, len ); // Eingabe-Matrix
MU = MD_matrix( maxhtlen, len );
MV = MD_matrix( len, len );
W = VD_vector( len );
MOne = MD_matrix( len, len ); // Einheits-Matrix zum Vergleich
MD_equ1( MOne, len );
MA2 = MD_matrix( maxhtlen, len );
// wird MU*W*MVT erhalten zum Vergleich mit der Eingabe-Matrix
// führende Dimension maxhtlen ist für unter-determinierte Matrizen nötig
MUV2 = MD_matrix( len, len );
// wird MUT*MU, MVT*MV, MV*MVT erhalten zum Vergleich mit MOne
MDiffA = MD_matrix( ht, len ); // für Zwischenergebnisse
MDiffOne = MD_matrix( len, len ); // für Zwischenergebnisse
MD_random( MA, ht, len, 1, -1., +1. );
// MA mit Zufallszahlen zwischen -1 und +1 füllen
// alternativ auf irgendeinem anderen Weg eine Test-Matrix erzeugen oder einlesen
MD_SVdecompose( MU, MV, W, MA, ht, len );
/* prüfen, ob MA = MU*W*MVT; Auswertung von rechts nach links: */
MDdia_mulMT( MUV2, W, MV, len, len ); // MUV2 speichert W * MVT
MD_mulM( MA2, MU, MUV2, maxhtlen, len, len );
MD_subM( MDiffA, MA, MA2, ht, len );
// für unter-determinierte Matrizen werden die Zeilen von ht bis maxhtlen-1 ignoriert
err = VD_absmax( MDiffA[0], sizeA );
printf( "SVDtest: Test für die SVD-Routine von OptiVec\n\n"
"In den folgenden Tests in Double-Genauigkeit\n"
"sind Fehler bis zu einigen Malen 1.e-14 in Ordnung\n"
"bei Matrizen der Größenordnung 100x100 bis 1000x1000 Elemente:\n\n"
"max. Fehler der Matrix-Rekonstruktion MA = MU*W*MVT: %lg", err );
/* prüfe, ob MU orthogonal, also MUT*MU = (1): */
MD_TmulM( MUV2, MU, MU, maxhtlen, len, len );
MD_subM( MDiffOne, MUV2, MOne, len, len );
err = VD_absmax( MDiffOne[0], sizeV );
printf( "\nmax. Fehler von MUT*MU = (1): %lg", err );
/* prüfe, ob MV orthogonal, also MVT*MV = (1): */
MD_TmulM( MUV2, MV, MV, len, len, len );
MD_subM( MDiffOne, MUV2, MOne, len, len );
err = VD_absmax( MDiffOne[0], sizeV );
printf( "\nmax. Fehler von MVT*MV = (1): %lg", err );
/* prüfe, ob MV auch orthonormal, also MV*MVT = (1): */
MD_mulMT( MUV2, MV, MV, len, len, len );
MD_subM( MDiffOne, MUV2, MOne, len, len );
err = VD_absmax( MDiffOne[0], sizeV );
printf( "\nmax. Fehler von MV*MVT = (1): %lg", err );
printf( "\n\nZum Beenden des Tests beliebige Taste drücken!" ); _getch();
M_nfree( 8, MA, MU, MV, MOne, MA2, MUV2, MDiffA, MDiffOne );
V_free( W );
} |
|
|
MF_SVDgetEdit
| MD_SVDgetEdit |
ME_SVDgetEdit |
|
Funktion | aktuelle Schwelle für Dimensions-Reduktion durch Singulärwert-Editierung lesen |
|
Syntax C/C++ | #include <MFstd.h>
float MF_SVDgetEdit( void ); |
C++ MatObj | #include <OptiVec.h>
T matrix<T>::SVDgetEdit( ); |
Pascal/Delphi | uses MFstd;
function MF_SVDgetEdit: Single; |
|
Beschreibung | Diese Funktion gibt die aktuell eingestellte Standard-Schwelle für die Dimensions-Reduktion durch Editierung der mittels SVD isolierten Singulärwerte zurück. Diese Standard-Schwelle kann mittels MF_SVDsetEdit modifiziert werden. |
|
Rückgabewert | aktuelle Schwelle für Dimensions-Reduktion |
|
|
MF_SVDsetEdit
| MD_SVDsetEdit |
ME_SVDsetEdit |
|
Funktion | Schwelle für Dimensions-Reduktion durch Singulärwert-Editierung setzen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_SVDsetEdit( float Thresh ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::SVDsetEdit( const T& Thresh ); |
Pascal/Delphi | uses MFstd;
procedure MF_SVDsetEdit( Thresh:Single ); |
|
Beschreibung | Wie bei MF_SVdecompose und MF_SVsolve beschrieben, ist der springende Punkt bei der Anwendung von auf Singulärwert-Zerlegung (SVD) besierenden Funktionen die Dimensions-Reduktion durch Editierung der isolierten Singulärwerte. Standardmäßig beträgt die Editier-Schwelle 4*FLT_EPSILON, 8*DBL_EPSILON oder 16*LDBL_EPSILON.
Zur Änderung dieser Standard-Werte rufe man MF_SVDsetEdit. Um die aktuelle Einstellung zu erfahren, rufe man MF_SVDgetEdit.
Da MF_SVDsetEdit nicht fiber-sicher ist, sollte diese Funktion nicht verwendet werden, um verschiedene Schwellenwerte für verschiedene Aufrufe von MF_SVsolve usw. einzustellen. Anstatt wiederholt den Standard-Wert zu ändern, gebrauche man vielmehr die "wEdit"-Varianten von MF_SVsolve usw., also MF_SVsolvewEdit, MF_solveBySVDwEdit und MF_safeSolvewEdit. |
|
|
MF_SVsolve
| MD_SVsolve |
ME_SVsolve |
MFb_SVsolve
| MDb_SVsolve |
MEb_SVsolve |
MFb_SVsolve_sizeBuf
| MDb_SVsolve_sizeBuf |
MEb_SVsolve_sizeBuf |
|
Funktion | lineares Gleichungssystem bei Vorliegen der Singulärwert-zerlegten Form lösen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_SVsolve( fVector X, fMatrix MU, fMatrix MV, fVector W, fVector B, ui htA, ui lenA );
void MF_SVsolvewEdit( fVector X, fMatrix MU, fMatrix MV, fVector W, fVector B, ui htA, ui lenA, float thresh );
void MFb_SVsolve( fVector X, fMatrix MU, fMatrix MV, fVector W, fVector B, ui htA, ui lenA, fVector Buf );
void MFb_SVsolvewEdit( fVector X, fMatrix MU, fMatrix MV, fVector W, fVector B, ui htA, ui lenA, float thresh, fVector Buf );
ui MFb_SVsolve_sizeBuf( ui htA, ui lenA );
|
C++ MatObj | #include <OptiVec.h>
void vector<T>::SVsolve( const matrix<T>& MU, const matrix<T>& MV, const vector<T>& W, const vector<T>& B );
void vector<T>::SVsolvewEdit( const matrix<T>& MU, const matrix<T>& MV, const vector<T>& W, const vector<T>& B, T thresh ); |
Pascal/Delphi | uses MFstd;
procedure MF_SVsolve( X:fVector; MU, MV:fMatrix; W, B:fVector; htA, lenA:UIntSize );
procedure MF_SVsolvewEdit( X:fVector; MU, MV:fMatrix; W, B:fVector; htA, lenA:UIntSize; thresh:Single );
procedure MFb_SVsolve( X:fVector; MU, MV:fMatrix; W, B:fVector; htA, lenA:UIntSize; Buf:fVector );
procedure MFb_SVsolvewEdit( X:fVector; MU, MV:fMatrix; W, B:fVector; htA, lenA:UIntSize; thresh:Single; Buf:fVector );
function MFb_SVsolve_sizeBuf( htA, lenA:UIntSize ): UIntSize; |
|
Beschreibung | MF_SVsolve löst ein lineares Gleichungssystem, das zuvor mittels MF_SVdecompose faktorisiert wurde. Dieser Prozeß wird auch als Singulärwert-Rücksubstitution bezeichnet. In dieser Funktion wird zunächst W in der Weise editiert, dass alle Elemente unter einer gewissen Schwelle gleich 0 gesetzt werden. Bei der anschließenden Rücksubstitution, die Divisionen durch die Elemente of W vornimmt, werden die Ergebnisse aller Divisionen durch Wi = 0 gleich 0 (anstelle von Unendlich) gesetzt und hierdurch die Dimension des zugrundeliegenden Gleichungssystems reduziert. Die voreingestellte Standard-Editierschwelle kann mittels MF_SVDsetEdit geändert werden. Falls man es vorzieht, W selbst zu inspizieren und zu editieren, bevor man MF_SVsolve aufruft, sollte MF_SVDsetEdit mit dem Argument 0.0 aufgerufen werden, um die automatische Dimensions-Reduktion auszuschalten. Da MF_SVDsetEdit nicht fiber-sicher ist, sollte diese Funktion nicht verwendet werden, um verschiedene Schwellenwerte für verschiedene Aufrufe von MF_SVsolve usw. einzustellen. Anstatt wiederholt den Standard-Wert zu ändern, gebrauche man vielmehr die "wEdit"-Varianten von MF_SVsolve usw., also MF_SVsolvewEdit, MF_solveBySVDwEdit und MF_safeSolvewEdit.
Die Parameter htA und lenA beziehen sich auf die ursprüngliche, an MF_SVdecompose übergebene Matrix MA. Die Dimensionen der an MF_SVsolve übergebenen Matrizen und Vektoren ergeben sich wie folgt:
sizeB = htA;
sizeX = htU = max( lenA, htA );
sizeW = lenU = htV = lenV = lenA;
Diese Funktionen benötigen Pufferspeicher. Die "Normal-Versionen" (Präfix MF_, MD_ usw.) allozieren ihn selbst, während die Versionen mit den Präfixen MFb_, MDb_ etc. als zusätzliches Aufruf-Argument einen Vektor Buf übernehmen. Die erforderliche Größe von Buf kann mittels Aufruf von MFb_SVsolve_sizeBuf(ht,len) abgefragt werden (Angabe nicht in byte, sondern als Zahl der Elemente von Buf im jeweiligen Datentyp!).
|
|
|
MF_SVsort
| MD_SVsort |
ME_SVsort |
|
Funktion | Sortierung von Singulärwerten |
|
Syntax C/C++ | #include <MFstd.h>
void MF_SVsort( fMatrix MUout, fMatrix MVout, fVector Wout, fMatrix MUraw, fMatrix MVraw, fVector Wraw, ui htU, ui lenU ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::SVsort( matrix<T> MVout, vector<T> Wout, const matrix<T>& MUraw, const matrix<T>& MVraw, const vector<T>& Wraw ); |
Pascal/Delphi | uses MFstd;
procedure MF_SVsort( MUraw, MVraw:fMatrix; Wraw:fVector; MUraw, MVraw:fMatrix; Wraw:fVector; htU, lenU:UIntSize ); |
|
Beschreibung | MF_SVsort bringt die über MF_SVdecompose in dem Vektor W erhaltenen Singulärwerte in absteigende Ordnung. Gleichzeitig werden durch Spaltenvertauschung die Matrizen MU und MV entsprechend umgeordnet.
Die Parameter htU und lenU beziehen sich auf die Matrix MU. Sie ergeben sich aus den Dimensionen der ursprünglichen, an MF_SVdecompose übergebene Matrix MA wie folgt::
htU = max( lenA, htA );
lenU = lenA; |
|
|
MF_TmulM
| MD_TmulM |
ME_TmulM |
MCF_TmulM |
MCD_TmulM |
MCE_TmulM |
|
Funktion | Transponierte einer Matrix mit einer anderen Matrix multiplizieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_TmulM( fMatrix MC, fMatrix MA, fMatrix MB, ui htA, ui lenA, ui lenB ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::TmulM( const matrix<T>& MA, const matrix<T>& MB ); |
Pascal/Delphi | uses MFstd;
procedure MF_TmulM( MC, MA, MB:fMatrix; htA, lenA, lenB:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_TmulM( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui htA, ui lenA, ui lenB );
void MFcu_TmulM( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui htA, ui lenA, ui lenB ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_TmulM( d_MC, d_MA, d_MB:fMatrix; htA, lenA, lenB:UIntSize ): IntBool;
procedure MFcu_TmulM( h_MC, h_MA, h_MB:fMatrix; htA, lenA, lenB:UIntSize );
|
|
Beschreibung | MC = MAT * MB
htA, lenA, und lenB müssen spezifiziert werden; die übrigen Dimensionen sind implizit gegeben als: htB = htA, lenC = lenB, htC = lenA. htA und lenA beziehen sich auf die originale, nicht-transponierte Eingabe-Matrix. |
|
|
MF_TmulMdia
| MD_TmulMdia |
ME_TmulMdia |
MCF_TmulMdia |
MCD_TmulMdia |
MCE_TmulMdia |
|
Funktion | Transponierte einer allgemeinen Matrix mit einer Diagonalmatrix multiplizieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_TmulMdia( fMatrix MC, fMatrix MA, fVector MBDia, ui htA, ui lenA ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::mulMdia( const matrix<T>& MA, const vector<T>& MBDia, ); |
Pascal/Delphi | uses MFstd;
procedure MF_TmulMdia( MC, MA:fMatrix; MBDia:fVector; htA, lenA:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_TmulMdia( fMatrix d_MC, fMatrix d_MA, fVector d_MBDia, ui htA, ui lenA );
void MFcu_TmulMdia( fMatrix h_MC, fMatrix h_MA, fVector h_MBDia, ui htA, ui lenA ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_TmulMdia( d_MC, d_MA:fMatrix; d_MBDia:fVector; htA, lenA:UIntSize ): IntBool;
procedure MFcu_TmulMdia( h_MC, h_MA:fMatrix; h_MBDia:fVector; htA, lenA:UIntSize );
|
|
Beschreibung | MC = MAT * MBDia
htA und lenA müssen spezifiziert werden. Sie beziehen sich auf die originale, nicht-transponierte Eingabe-Matrix. Implizit ist sizB = htA. |
|
|
MCF_TmulMH |
MCD_TmulMH |
MCE_TmulMH |
|
Funktion | Transponierte einer Matrix mit der Hermitesch-konjugierten Form einer anderen multiplizieren |
|
Syntax C/C++ | #include <MCFstd.h>
void MCF_TmulMT( cfMatrix MC, cfMatrix MA, cfMatrix MB, ui htA, ui lenA, ui htB ); |
C++ MatObj | #include <OptiVec.h>
void matrix<complex<T> >::TmulMH( const matrix<complex<T> >& MA, const matrix<complex<T> >& MA ); |
Pascal/Delphi | uses MFstd;
procedure MCF_TmulMH( MC, MA, MB:cfMatrix; htA, lenA, htB:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMCFstd.h>
int cudaMCF_TmulMH( cfMatrix d_MC, cfMatrix d_MA, cfMatrix d_MB, ui htA, ui lenA, ui htB );
void MCFcu_TmulMH( cfMatrix h_MC, cfMatrix h_MA, cfMatrix h_MB, ui htA, ui lenA, ui htB ); |
CUDA-Funktion Pascal/Delphi | uses MCFstd;
function cudaMCF_TmulMH( d_MC, d_MA, d_MB:cfMatrix; htA, lenA, htB:UIntSize ): IntBool;
procedure MCF_TmulMH( h_MC, h_MA, h_MB:cfMatrix; htA, lenA, htB:UIntSize );
|
|
Beschreibung | MC = MAT * MBT*
htA, lenA, und htB müssen spezifiziert werden; die übrigen Dimensionen sind implizit gegeben als: lenB = htA, lenC = htB, htC = lenA. Alle Dimensionen beziehen sich auf die originalen, nicht-transponierten Eingabe-Matrizen. |
|
|
MF_TmulMT
| MD_TmulMT |
ME_TmulMT |
MCF_TmulMT |
MCD_TmulMT |
MCE_TmulMT |
|
Funktion | Transponierte einer Matrix mit der Transponierten einer anderen multiplizieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_TmulMT( fMatrix MC, fMatrix MA, fMatrix MB, ui htA, ui lenA, ui htB ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::TmulMT( const matrix<T>& MA, const matrix<T>& MB ); |
Pascal/Delphi | uses MFstd;
procedure MF_TmulMT( MC, MA, MB:fMatrix; htA, lenA, htB:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_TmulMT( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui htA, ui lenA, ui htB );
void MFcu_TmulMT( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui htA, ui lenA, ui htB ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_TmulMT( d_MC, d_MA, d_MB:fMatrix; htA, lenA, htB:UIntSize ): IntBool;
procedure MFcu_TmulMT( h_MC, h_MA, h_MB:fMatrix; htA, lenA, htB:UIntSize );
|
|
Beschreibung | MC = MAT * MBT
htA, lenA, und htB müssen spezifiziert werden; die übrigen Dimensionen sind implizit gegeben als: lenB = htA, lenC = htB, htC = lenA. Alle Dimensionen beziehen sich auf die originalen, nicht-transponierten Eingabe-Matrizen. |
|
|
MF_TmulV
| MD_TmulV |
ME_TmulV |
MCF_TmulV |
MCD_TmulV |
MCE_TmulV |
|
Funktion | Transponierte einer Matrix mit einem Spalten-Vektor multiplizieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_TmulV( fVector Y, fMatrix MA, fVector X, ui htA, ui lenA ); |
C++ MatObj | #include <OptiVec.h>
void vector<T>::TmulV( const matrix<T>& MA, const vector<T>& X ); |
Pascal/Delphi | uses MFstd;
procedure MF_TmulV( Y:fVector; MA:fMatrix; X:fVector; htA, lenA:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_TmulV( fVector d_Y, fMatrix d_MA, fVector d_X, ui htA, ui lenA );
void MFcu_TmulV( fVector h_Y, fMatrix h_MA, fVector h_X, ui htA, ui lenA ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_TmulV( d_Y:fVector; d_MA:fMatrix; d_X:fVector; htA, lenA:UIntSize ): IntBool;
procedure MFcu_TmulV( h_Y:fVector; h_MA:fMatrix; h_X:fVector; htA, lenA:UIntSize );
|
|
Beschreibung | Y = MAT * X
Die Dimensionen htA und lenA beziehen sich auf the originale (und nicht die intermediäre transponierte) Matrix A; die Dimensionen von X und Y sind implizit gegeben durch die Matrix-Dimensionen: sizX = htA, sizY = lenA. |
|
|
MF_transpose
| MD_transpose |
ME_transpose |
MCF_transpose |
MCD_transpose |
MCE_transpose |
MI_transpose | MBI_transpose | MSI_transpose | MLI_transpose | MQI_transpose |
MU_transpose | MUB_transpose | MUS_transpose | MUL_transpose | MUQ_transpose |
|
Funktion | Transponierte einer Matrix |
|
Syntax C/C++ | #include <MFstd.h>
void MF_transpose( fMatrix Tr, fMatrix MA, ui htTr, ui lenTr ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::transpose( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_transpose( MTr, MA:fMatrix; htTr, lenTr:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_transpose( fMatrix d_MTr, fMatrix d_MA, ui htTr, ui lenTr );
void MFcu_transpose( fMatrix h_MTr, fMatrix h_MA, ui htTr, ui lenTr ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_transpose( d_MTr, d_MA:fMatrix; htTr, lenTr:UIntSize ): IntBool;
procedure MFcu_transpose( h_MTr, h_MA:fMatrix; htTr, lenTr:UIntSize );
|
|
Beschreibung | MTri,j = MAj,i
Die an diese Funktion übergebenen Dimensionen htTr und lenTr beziehen sich auf die transponierte Ausgabe-Matrix. |
|
|
MF_Trd_equM
| MD_Trd_equM |
ME_Trd_equM |
MCF_Trd_equM |
MCD_Trd_equM |
MCE_Trd_equM |
MI_Trd_equM | MBI_Trd_equM | MSI_Trd_equM | MLI_Trd_equM | MQI_Trd_equM |
MU_Trd_equM | MUB_Trd_equM | MUS_Trd_equM | MUL_Trd_equM | MUQ_Trd_equM |
|
Funktion | Tridiagonal-Teil einer Matrix mit den drei in einer gepackten Tridiagonalmatrix gespeicherten Vektoren initialisieren |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Trd_equM( fMatrix MA, fMatrix Trd, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Trd_equM( const matrix<T>& MTrd ); |
Pascal/Delphi | uses MFstd;
procedure MF_Trd_equM( MA, MTrd:fMatrix; len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Trd_equM( fMatrix d_MA, fMatrix Trd, ui len );
void MFcu_Trd_equM( fMatrix h_MA, fMatrix Trd, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Trd_equM( d_MA, d_MTrd:fMatrix; len:UIntSize ): IntBool;
procedure MFcu_Trd_equM( h_MA, h_MTrd:fMatrix; len:UIntSize );
|
|
Beschreibung | Zeile 0 von MTrd wird in die erste Nebendiagonale oberhalb der Hauptdiagonalen der Quadratmatrix MA kopiert. Zeile 1 von MTrd geht nach der Hauptdiagonalen von MA, und Zeile 2 von MTrd nach der ersten Nebendiagonalen unterhalb der Hauptdiagonalen von MA. Die Speicherung von Tridiagonalmatrizen wird in Kap. 1.2 beschrieben. |
|
|
MF_Trd_extract
| MD_Trd_extract |
ME_Trd_extract |
MCF_Trd_extract |
MCD_Trd_extract |
MCE_Trd_extract |
MI_Trd_extract | MBI_Trd_extract | MSI_Trd_extract | MLI_Trd_extract | MQI_Trd_extract |
MU_Trd_extract | MUB_Trd_extract | MUS_Trd_extract | MUL_Trd_extract | MUQ_Trd_extract |
|
Funktion | Tridiagonal-Teil einer allgemeinen Matrix als gepackte Tridiagonalmatrix speichern |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Trd_extract( fMatrix Trd, fMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Trd_estract( const matrix<T>& MA ); |
Pascal/Delphi | uses MFstd;
procedure MF_Trd_extract( MTrd, MA:fMatrix; len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Trd_extract( fMatrix d_MTrd, fMatrix d_MA, ui len );
void MFcu_Trd_extract( fMatrix h_MTrd, fMatrix h_MA, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Trd_extract( d_MTrd, d_MA:fMatrix; len:UIntSize ): IntBool;
procedure MFcu_Trd_extract( h_MTrd, h_MA:fMatrix; len:UIntSize );
|
|
Beschreibung | Die erste Nebendiagonale oberhalb der Hauptdiagonalen von MA wird in Zeile 0 von MTrd kopiert. Die Hauptdiagonale von MA geht in Zeile 1 von MTrd, und die erste Nebendiagonale unterhalb der Hauptdiagonalen von MA kommt in Zeile 2 von MTrd. |
|
|
MF_UequL
| MD_UequL |
ME_UequL |
MCF_UequL |
MCD_UequL |
MCE_UequL |
MI_UequL | MBI_UequL | MSI_UequL | MLI_UequL | MQI_UequL |
MU_UequL | MUB_UequL | MUS_UequL | MUL_UequL | MUQ_UequL |
|
Funktion | Unterdiagonalelemente durch Indexreflektion in Überdiagonalelemente kopieren, um eine symmetrische Matrix zu erhalten |
|
Syntax C/C++ | #include <MFstd.h>
void MF_UequL( fMatrix MA, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::UequL( ); |
Pascal/Delphi | uses MFstd;
procedure MF_UequL( MA:fMatrix; len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_UequL( fMatrix d_MA, ui len );
void MFcu_UequL( fMatrix h_MA, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_UequL( d_MA:fMatrix; len:UIntSize ): IntBool;
procedure MFcu_UequL( h_MA:fMatrix; len:UIntSize );
|
|
Beschreibung | MAi,j = MAj,i, i < j |
|
|
MF_Welch
| MD_Welch |
ME_Welch |
|
Funktion | zwei-dimensionales Welch-Fenster für Raumfrequenz-Analysen |
|
Syntax C/C++ | #include <MFstd.h>
void MF_Welch( fMatrix MA, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::Welch( ); |
Pascal/Delphi | uses MFstd;
procedure MF_Welch( MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_Welch( fMatrix d_MA, ui ht, ui len );
void MFcu_Welch( fMatrix h_MA, ui ht, ui len );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_Welch( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Welch( h_MA:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | MAi,j = (1 - ( (i - 0.5*(ht - 1)) / (0.5*(ht + 1)) )2) * (1 - ( (j - 0.5*(len - 1)) / (0.5*(len + 1)) )2) |
|
|
MF_write
| MD_write |
ME_write |
MCF_write |
MCD_write |
MCE_write |
MI_write | MBI_write | MSI_write | MLI_write | MQI_write |
MU_write | MUB_write | MUS_write | MUL_write | MUQ_write |
|
Funktion | Matrix im ASCII-Format in einen Stream schreiben |
|
Syntax C/C++ | #include <MFstd.h>
void MF_write( FILE *stream, fMatrix X, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::write( FILE *stream ); |
Pascal/Delphi | uses MFstd;
{Delphi-Version:}
procedure MF_write( var Stream:TextFile; MA:fMatrix; ht, len:UIntSize );
{Turbo Pascal-Version:}
procedure MF_write( var Stream:Text; MA:fMatrix; ht, len:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_write( FILE *stream, fMatrix d_MA, ui ht, ui len );
int cudaMF_write_buf( FILE *stream, fMatrix d_MA, ui ht, ui len, fVector h_Wk ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_write( var Stream:TextFile; d_MA:fMatrix; ht, len:UIntSize ): IntBool;
function cudaMF_write_buf( var Stream:TextFile; d_MA:fMatrix; ht, len:UIntSize; h_Wk:fVector ): IntBool;
|
|
Beschreibung | Die Matrix A mit len Spalten und ht Zeilen wird im ASCII Format in stream geschrieben. stream muss bereits für Schreiboperationen im Text-Format geöffnet sein.
Das Zahlenformat und die Trennzeichen zwischen den einzelnen Spalten können über MF_setWriteFormat (nur C/C++) bzw. MF_setWriteSeparate modifiziert werden.
Daten im ASCII-Format zu speichern ist sinnvoll, wenn die Daten für menschliche Augen lesbar werden sollen oder wenn sie in andere Programme zu exportieren sind, die Zahlen nicht im Maschinen-Format lesen können. Zur Zwischenspeicherung von Daten, die später einmal wieder eingelesen werden sollen, vermeide man diese Funktionen aber so weit wie möglich. Die Funktionen-Paare der MF_store / MF_recall-Familie sind hier aus den folgenden Gründen überlegen: Umwandlung in das ASCII-Format ist zeitaufwendig, führt zu Rundungsfehlern und benötigt viel mehr Speicherplatz als Zahlen im Binär-Format.
nur CUDA-Versionen: cudaM?_write_buf übernimmt einen Host-Vektor h_Wk als zusätzliches Argument. Dieser dient als Pufferspeicher und muss (mindestens) dieselbe Größe haben wie X. Hierdurch wird die interne Bereitstellung von Pufferspeicher bei cudaM?_write eingespart, so dass cudaM?_write_buf etwas schneller ist.
|
|
|
MF_xcorr
| MD_xcorr |
ME_xcorr |
MFb_xcorr
| MDb_xcorr |
MEb_xcorr |
|
Funktion | Räumliche Kreuzkorrelationsfunktion |
|
Syntax C/C++ | #include <MFstd.h>
void MF_xcorr( fMatrix MC, fMatrix MA, fMatrix MB, ui ht, ui len );
void MFb_xcorr( fMatrix MC, fMatrix MA, fMatrix MB, ui ht, ui len, fVector Buf ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::xcorr( const matrix<T>& MA, const matrix<T>& MB );
void matrix<T>::b_xcorr( const matrix<T>& MA, const matrix<T>& MB, vector<T>& Buf ); |
Pascal/Delphi | uses MFstd;
procedure MF_xcorr( MC, MA, MB:fMatrix; ht, len:UIntSize );
procedure MFb_xcorr( MC, MA, MB:fMatrix; ht, len:UIntSize; Buf:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_xcorr( fMatrix d_MC, fMatrix d_MA, fMatrix d_MB, ui ht, ui len );
void MFcu_xcorr( fMatrix h_MC, fMatrix h_MA, fMatrix h_MB, ui ht, ui len ); |
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_xcorr( d_MC, d_MA, d_MB:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_xcorr( h_MC, h_MA, h_MB:fMatrix; ht, len:UIntSize );
|
|
Beschreibung | Die räumliche Kreuzkorrelationsfunktion (engl.: spatial cross-correlation function, SCCF) von MA und MB wird in MC in der folgenden Weise gespeichert: Die Zeilenelemente MCi,0 bis MCi,len/2-1 enthalten die SCCF für 0 und für positive x-Verschiebungen. Beginnend mit der größten negativen Verschiebung in MCi,len/2+1 enthalten die Elemente bis zu MCi,len-1 die SCCF für negative Verschiebungen. Da diese Funktion MA und MB als periodisch annimmt, ist die SCCF für die größte positive Verschiebung gleich der SCCF für die größte negative Verschiebung und wird als MCi,len/2 gespeichert.
In ähnlicher Weise enthalten die Spaltenelemente MC0,j bis MClen/2-1,j die SCCF für 0 und für positive y-Verschiebungen. Beginnend mit der größten negativen Verschiebung in MClen/2+1,j enthalten die Elemente bis zu MClen-1,j die SCCF für negative Verschiebungen.
Um die SCCF in normale Reihenfolge zu bringen, rufe man
MF_Rows_rotate( MC, ht, len, len/2 );
MF_Cols_rotate( MC, ht, len, ht/2 );
Hiernach befindet sich der Nullpunkt an der Stelle MCht/2,len/2.
Falls MA oder MB nicht-periodisch sind, sollten Randeffekte mit den bei MF_convolve beschriebenen Methoden vermieden werden.
Die Dimensionen aller drei beteiligter Matrizen sind gleich. Dabei müssen sowohl ht als auch len ganzzahlige Potenzen von 2 sein.
Intern benötigt MF_xcorr zusätzlichen Pufferspeicher, der automatisch reserviert und wieder freigegeben wird. Bei wiederholten Aufrufen wäre dies ineffizient. Es wird empfohlen, für solche Fälle stattdessen MFb_xcorr zu verwenden. Die Größe von Buf muss dabei für C/C++ >= 2*ht*(len+2) sein, fü Pascal/Delphi >= 2*ht*len.Außerdem muss Buf 128-bit (P8) bzw. 256-bit( P9) ausgerichtet sein. Um dies zu garantieren, sollte man nur Vektoren als Buf verwenden, die mit der VF_vector-Familie alloziert wurden. |
|
Fehlerbehandlung | Falls entweder len oder ht nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf MF_xcorr basiert) mit der Fehlermeldung "Size must be an integer power of 2" und bricht das Programm ab. |
|
|
MF_xspectrum
| MD_xspectrum |
ME_xspectrum |
MF_xspectrumAbs
| MD_xspectrumAbs |
ME_xspectrumAbs |
MFb_xspectrum
| MDb_xspectrum |
MEb_xspectrum |
MFb_xspectrumAbs
| MDb_xspectrumAbs |
MEb_xspectrumAbs |
MFb_xspectrum_sizeBuf
| MDb_xspectrum_sizeBuf |
MEb_xspectrum_sizeBuf |
MFb_xspectrumAbs_sizeBuf
| MDb_xspectrumAbs_sizeBuf |
MEb_xspectrumAbs_sizeBuf |
|
Funktion | Raumfrequenz-Spektrum |
|
Syntax C/C++ | #include <MFstd.h>
void MF_xspectrum( cfMatrix MSpec, ui htSpec, ui lenSpec, fMatrix MX, fMatrix MY, ui htX, ui lenX, fMatrix Win );
void MFb_xspectrum( cfMatrix MSpec, ui htSpec, ui lenSpec, fMatrix MX, fMatrix MY, ui htX, ui lenX, fMatrix Win, fVector Buf );
ui MFb_xspectrum_sizeBuf( ui htSpec, ui lenSpec, ui htX, ui lenX );
void MF_xspectrumAbs( fMatrix MSpec, ui htSpec, ui lenSpec, fMatrix MX, fMatrix MY, ui htX, ui lenX, fMatrix Win );
void MFb_xspectrumAbs( fMatrix MSpec, ui htSpec, ui lenSpec, fMatrix MX, ui htX, fMatrix MY, ui lenX, fMatrix Win, fVector Buf );
ui MFb_xspectrumAbs_sizeBuf( ui htSpec, ui lenSpec, ui htX, ui lenX ); |
C++ MatObj | #include <OptiVec.h>
void matrix<complex<T>>::xspectrum( const matrix<T>& MX, const matrix<T>& MY, const matrix<T>& MWin );
void matrix<complex<T>>::b_xspectrum( const matrix<T>& MX, const matrix<T>& MY, const matrix<T>& MWin, vector<T> Buf );
void matrix<T>::xspectrumAbs( const matrix<T>& MX, const matrix<T>& MY, const matrix<T>& MWin );
void matrix<T>::b_xspectrumAbs( const matrix<T>& MX, const matrix<T>& MY, const matrix<T>& MWin, vector<T> Buf ); |
Pascal/Delphi | uses MFstd;
procedure MF_xspectrum( MSpec:cfMatrix; htSpec, lenSpec:UIntSize; MX, MY:fMatrix; htX, lenX:UIntSize; MWin:fMatrix );
procedure MFb_xspectrum( MSpec:cfMatrix; htSpec, lenSpec:UIntSize; MX, MY:fMatrix; htX, lenX:UIntSize; MWin:fMatrix; Buf:fVector );
function MFb_xspectrum_sizeBuf( htSpec, lenSpec, htX, lenX:UIntSize ): UIntSize;
procedure MF_xspectrumAbs( MSpec:fMatrix; htSpec, lenSpec:UIntSize; MX, MY:fMatrix; htX, lenX:UIntSize; MWin:fMatrix );
procedure MFb_xspectrumAbs( MSpec:fMatrix; htSpec, lenSpec:UIntSize; MX, MY:fMatrix; htX, lenX:UIntSize; MWin:fMatrix; Buf:fVector );
function MFb_xspectrumAbs_sizeBuf( htSpec, lenSpec, htX, lenX:UIntSize ): UIntSize; |
|
CUDA-Funktion C/C++ | #include <cudaMFstd.h>
int cudaMF_xspectrum( cfMatrix d_Spec, ui htSpec, ui lenSpec, fMatrix d_X, fMatrix d_Y, ui htX, ui lenX, fMatrix d_Win );
void MFcu_xspectrum( cfMatrix h_Spec, ui htSpec, ui lenSpec, fMatrix h_X, fMatrix h_Y, ui htX, ui lenX, fMatrix h_Win );
int cudaMF_xspectrumAbs( fMatrix d_Spec, ui htSpec, ui lenSpec, fMatrix d_X, fMatrix d_Y, ui htX, ui lenX, fMatrix d_Win );
void MFcu_xspectrumAbs( fMatrix h_Spec, ui htSpec, ui lenSpec, fMatrix h_X, fMatrix h_Y, ui htX, ui lenX, fMatrix h_Win );
|
CUDA-Funktion Pascal/Delphi | uses MFstd;
function cudaMF_xspectrum( d_MSpec:cfMatrix; htSpec, lenSpec:UIntSize; d_MX, d_MY:fMatrix; htX, lenX:UIntSize; d_MWin:fMatrix ): IntBool;
procedure MFcu_xspectrum( h_MSpec:cfMatrix; htSpec, lenSpec:UIntSize; h_MX, h_MY:fMatrix; htX, lenX:UIntSize; h_MWin:fMatrix );
function cudaMF_xspectrumAbs( d_MSpec:fMatrix; htSpec, lenSpec:UIntSize; d_MX, d_MY:fMatrix; htX, lenX:UIntSize; d_MWin:fMatrix ): IntBool;
procedure MFcu_xspectrumAbs( h_MSpec:fMatrix; htSpec, lenSpec:UIntSize; h_MX, h_MY:fMatrix; htX, lenX:UIntSize; h_MWin:fMatrix );
|
|
Beschreibung | Das Raumfrequenz-Kreuz-Spektrum der beiden Matrizen MX und MY wird berechnet und in MSpc gespeichert. Dabei ist das Resultat für MF_xspectrum eine komplexe Matrix, die auch Phasen-Informationen enthält, während MF_xspectrumAbs den häufigeren Fall abdeckt, dass nur die Absolutwerte von Interesse sind.
Intern wird MX in überlappende Segmente unterteilt, ähnlich wie für den eindimensionalen Fall bei VF_xspectrum beschrieben. MWin ist ein Fenster, das auf die Datensegmente angewendet wird. OptiVec bietet drei Funktionen zur Erzeugung passender Fenster: MF_Welch, MF_Parzen und MF_Hann. Ein Rechteck-Fenster erhält man durch Setzen aller Matrix-Elemente auf den Wert 1.0 (MF_equC( MWin, htWin, lenWin, 1.0 ); ), dies wird aber nicht empfohlen.
htSpec und lenSpec müssen ganzzahlige Potenzen von 2 sein. Außerdem müssen folgende Bedingungen erfüllt sein:
htX >= n*htSpec, lenX >= n*lenSpec, htWin = htSpec, lenWin = lenSpec.
Intern benötigt MF_xspectrum / MF_xspectrumAbs zusätzlichen Pufferspeicher, der automatisch reserviert und wieder freigegeben wird. Bei wiederholten Aufrufen wäre dies ineffizient. Es wird empfohlen, für solche Fälle stattdessen MFb_xspectrum / MFb_xspectrumAbs zu verwenden. Die notwendige Größe von Buf kann dabei durch Aufruf der Funktion MFb_xspectrum_sizeBuf / MFb_xspectrumAbs_sizeBuf ermittelt werden. Sie wird für MFb_xspectrum nie mehr als 7*htX*lenX betragen, für MFb_xspectrumAbs nie mehr als 8*htX*lenX. Außerdem muss Buf 128-bit (P8) bzw. 256-bit( P9) ausgerichtet sein. Um dies zu garantieren, sollte man nur Vektoren als Buf verwenden, die mit der VF_vector-Familie alloziert wurden. |
|
Fehlerbehandlung | Falls entweder htSpec oder lenSpec keine ganzzahlige Potenz von 2 ist, meldet sich VF_FFT (worauf MF_xspectrum / MF_xspectrumAbs basiert) mit der Fehlermeldung "Size must be an integer power of 2" und bricht das Programm ab. |
|
|
MF_xyzAutoDensityMap
| MD_xyzAutoDensityMap |
ME_xyzAutoDensityMap |
MI_xyzAutoDensityMap | MBI_xyzAutoDensityMap | MSI_xyzAutoDensityMap | MLI_xyzAutoDensityMap | MQI_xyzAutoDensityMap |
MU_xyzAutoDensityMap | MUB_xyzAutoDensityMap | MUS_xyzAutoDensityMap | MUL_xyzAutoDensityMap | MUQ_xyzAutoDensityMap |
|
Funktion | Automatisch skalierter Farbton-Plot für z = f( x, y ) |
|
Syntax C/C++ | #include <Mgraph.h>
void MF_xyzAutoDensityMap( fVector X, fVector Y, fMatrix Z, ui ht, ui len, COLORREF mincolor, COLORREF maxcolor ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::xyzAutoDensityMap( const vector<T>& X, const vector<T>& Y, COLORREF mincolor, COLORREF maxcolor ); |
Pascal/Delphi | uses Mgraph;
procedure MF_xyzAutoDensityMap( X, Y:fVector; MZ:fMatrix; ht, len: UIntSize; mincolor, maxcolor: COLORREF ); |
|
Beschreibung | Ein Cartesisches Koordinatensystem wird mit automatisch skalierten Achsen gezeichnet und die Matrix Z als Farbton-Plot gegen die Vektoren X und Y aufgetragen. Bevor MF_xyzAutoDensityMap aufgerufen werden kann, müssen die OptiVec-Grafikfunktionen mittels V_initPlot initialisiert werden.
Die Achsenbeschriftung erfolgt im aktuellen Text-Font. Es wird der Schriftsatz des aktuellen Device Contexts verwandt.
Alle MZ-Werte werden durch lineare Interpolation zwischen den Parametern mincolor und maxcolor gewonnen. (Der Datentyp COLORREF ist unsigned long).
Die Farben BLACK, BLUE, GREEN, CYAN, RED, MAGENTA, BROWN, LIGHTGRAY, DARKGRAY, LIGHTBLUE, LIGHTGREEN, LIGHTCYAN, LIGHTRED, LIGHTMAGENTA, YELLOW und WHITE sind in <Vgraph.h> (oder der unit Vgraph) analog zu den COLORS aus alten DOS-Zeiten definiert. Wer feinere Abstufungen wünscht, sollte anstelle dieser vordefinierten die durch das RGB-Makro gesetzten Farben zu verwenden.
Falls die Achsen des Koordinatensystems "per Hand" anstatt automatisch skaliert werden sollen, rufe man zuerst M_setDensityMapBounds oder (für zwar automatische Skalierung, aber mit beliebigen x- und y- Wertebereichen) MF_findDensityMapBounds. Danach verwende man MF_xyzDataDensityMap anstelle von MF_xyzAutoDensityMap. |
|
|
MF_xyzDataDensityMap
| MD_xyzDataDensityMap |
ME_xyzDataDensityMap |
MI_xyzDataDensityMap | MBI_xyzDataDensityMap | MSI_xyzDataDensityMap | MLI_xyzDataDensityMap | MQI_xyzDataDensityMap |
MU_xyzDataDensityMap | MUB_xyzDataDensityMap | MUS_xyzDataDensityMap | MUL_xyzDataDensityMap | MUQ_xyzDataDensityMap |
|
Funktion | Farbtonplot z = f( x, y ) in ein bereits existierendes Koordinatensystem mit einer bereits definierten Farbtonskala |
|
Syntax C/C++ | #include <Mgraph.h>
void MF_xyzDataDensityMap( fVector X, fVector Y, fMatrix Z, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::xyzDataDensityMap( const vector<T>& X, const vector<T>& Y ); |
Pascal/Delphi | uses Mgraph;
procedure MF_xyzDataDensityMap( X, Y:fVector; MZ:fMatrix; ht, len: UIntSize ); |
|
Beschreibung | Die Matrix Z wird als Farbton-Plot gegen die Vektoren X und Y in ein Koordinatensystem aufgetragen, das durch einen vorherigen Aufruf von MF_setDensityMapBounds oder (für automatische Skalierung) MF_findDensityMapBounds erzeugt werden muss. Um den Plot mit automatischer Bereichsüberprüfung und Achsenskalierung durchzuführen, rufe man MF_xyzAutoDensityMap anstelle der vorliegenden Funktion. |
|
|
MF_zAutoDensityMap
| MD_zAutoDensityMap |
ME_zAutoDensityMap |
MI_zAutoDensityMap | MBI_zAutoDensityMap | MSI_zAutoDensityMap | MLI_zAutoDensityMap | MQI_zAutoDensityMap |
MU_zAutoDensityMap | MUB_zAutoDensityMap | MUS_zAutoDensityMap | MUL_zAutoDensityMap | MUQ_zAutoDensityMap
Funktion | automatisch skalierter Farbton-Plot einer Matrix gegen die Indizes ihrer beiden Dimensionen |
|
Syntax C/C++ | #include <Mgraph.h>
void MF_zAutoDensityMap( fMatrix Z, ui ht, ui len, COLORREF mincolor, COLORREF maxcolor ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::zAutoDensityMap( COLORREF mincolor, COLORREF maxcolor ); |
Pascal/Delphi | uses Mgraph;
procedure MF_xyzDataDensityMap( X, Y:fVector; MZ:fMatrix; ht, len: UIntSize ); |
|
Beschreibung | Diese Funktion ähnelt MF_xyzAutoDensityMap, aber hier wird MZ gegen die Indizes beider Matrix-Dimensionen anstelle expliziter X -und Y-Werte aufgetragen. |
|
|
|
MF_zDataDensityMap
| MD_zDataDensityMap |
ME_zDataDensityMap |
MI_zDataDensityMap | MBI_zDataDensityMap | MSI_zDataDensityMap | MLI_zDataDensityMap | MQI_zDataDensityMap |
MU_zDataDensityMap | MUB_zDataDensityMap | MUS_zDataDensityMap | MUL_zDataDensityMap | MUQ_zDataDensityMap |
|
Funktion | Farbton-Plot einer Matrix gegen die Indizes in x- und y-Richtung in ein existierendes Koordinatensystem |
|
Syntax C/C++ | #include <Mgraph.h>
void MF_zDataDensityMap( fMatrix Z, ui ht, ui len ); |
C++ MatObj | #include <OptiVec.h>
void matrix<T>::zDataDensityMap( ); |
Pascal/Delphi | uses Mgraph;
procedure MF_zDataDensityMap( MZ:fMatrix; ht, len: UIntSize ); |
|
Beschreibung | Diese Funktion ähnelt MF_xyzDataDensityMap, mit dem Unterschied, dass MZ hier gegen die Indizes der beiden Matrix-Dimensionen anstelle expliziter X- und Y-Werte aufgetragen wird. |
|
|
MF_2DArrayToMatrix
| MD_2DArrayToMatrix |
ME_2DArrayToMatrix |
MCF_2DArrayToMatrix |
MCD_2DArrayToMatrix |
MCE_2DArrayToMatrix |
MI_2DArrayToMatrix | MBI_2DArrayToMatrix | MSI_2DArrayToMatrix | MLI_2DArrayToMatrix | MQI_2DArrayToMatrix |
MU_2DArrayToMatrix | MUB_2DArrayToMatrix | MUS_2DArrayToMatrix | MUL_2DArrayToMatrix | MUQ_2DArrayToMatrix |
|
Funktion | 2D-Array von Delphi 4 oder höher in OptiVec-Matrix konvertieren |
|
Syntax C/C++ | N.A. |
Pascal/Delphi | uses MFstd, VecLib;
type fArray = array of Single;
type f2DArray = array of fArray;
procedure MF_2DArrayToMatrix( MF:fMatrix; DelphiArr:f2DArray; ht,len:UIntSize); |
|
Beschreibung | Diese Funktion wandelt zwei-dimensionale Delphi-Arrays in OptiVec-Matrizen um. Man beachte, dass - im Unterschied zu statischen Pascal/Delphi-Matrizen - die dynamischen Matrizen von Delphi 4+ nicht direkt an OptiVec-Funktionen übergeben werden können, sondern zuvor konvertiert werden müssen. Sollte es nötig werden, eine OptiVec-Matrix in das Delphi-Format zurückzuwandeln, dient dazu MF_MatrixTo2DArray. |
|
|
Zurück zum Inhaltsverzeichnis
E N D E
Copyright für OptiVec Software und Dokumentation
© 1996-2024 OptiCode - Dr. Martin Sander Software Dev.
Alle Rechte vorbehalten!
|