OptiVec logo 

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:
fMatrixmatrix of floats
dMatrixmatrix of doubles
eMatrixmatrix of extended (long double)
cfMatrixmatrix of fComplex (complex<float>)
cdMatrixmatrix of dComplex (complex<double>)
ceMatrixmatrix of eComplex (complex<extended>)
iMatrixmatrix of int
uMatrixmatrix 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:

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:

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_matrixeiner Matrix Speicherplatz zuweisen
MF_matrix0Speicherplatz zuweisen und alle Elemente gleich 0 setzen
M_freeSpeicherplatz einer Matrix freigeben (unabhängig vom Datentyp)
M_nfreeSpeicherplatz mehrerer Matrizen freigeben (ebenfalls unabhängig vom Datentyp; nur C/C++)
V_freeAllSpeicherplatz 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:
MF_PelementZeiger auf ein spezifisches Matrix-Element
MF_elementWert eines spezifischen Matrix-Elementes

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_equ0alle Elemente gleich 0 setzen
MCF_Reequ0die Realteile aller Matrix-Elemente gleich 0 setzen, wobei die Imaginärteile unverändert bleiben
MCF_Imequ0die Imaginärteile aller Matrix-Elemente gleich 0 setzen, wobei die Realteile unverändert bleiben
MF_equ1Einheitsmatrix: alle Diagonalelemente werden gleich 1.0 gesetzt, alle übrigen gleich 0
MF_equm1negative Einheitsmatrix: alle Diagonalelement sind gleich -1.0, alle übrigen gleich 0
MF_randommit Zufallszahlen füllen
MF_outerprodBildung einer Matrix als äußeres Produkt zweier Vektoren
MF_Row_equ0alle Elemente einer Zeile gleich 0 setzen
MF_Col_equ0alle Elemente einer Spalte gleich 0 setzen
MF_Dia_equ0alle Diagonalelemente gleich 0 setzen
MCF_Row_Reequ0den Realteil aller Elemente einer Zeile einer komplex-zahligen Matrix gleich 0 setzen
MCF_Col_Reequ0den Realteil aller Elemente einer Spalte gleich 0 setzen
MCF_Dia_Reequ0den Realteil aller Diagonalelemente gleich 0 setzen
MCF_Row_Imequ0den Imaginärteil aller Elemente einer Zeile einer komplex-zahligen Matrix gleich 0 setzen
MCF_Col_Imequ0den Imaginärteil aller Elemente einer Spalte gleich 0 setzen
MCF_Dia_Imequ0den Imaginärteil aller Diagonalelemente gleich 0 setzen
MF_Row_equCalle Elemente einer Zeile gleich der Konstanten C setzen
MF_Col_equCalle Elemente einer Spalte gleich der Konstanten C setzen
MF_Dia_equCalle Diagonalelemente gleich der Konstanten C setzen
MF_Row_equVeinen Vektor in eine bestimmte Zeile kopieren
MF_Col_equVeinen Vektor in eine bestimmte Spalte kopieren
MF_Dia_equVeinen Vektor in die Diagonale kopieren
MF_Trd_equMeine kompakt gespeicherte tridiagonale Matrix in eine allgemeine Matrix kopieren
MF_equMeine Matrix zur Kopie einer anderen machen
MF_negeine Matrix zum Negativen einer anderen machen
MCF_conjkomplex-konjugierte Matrix
MCF_hermconjHermitesch konjugierte Matrix: MB = MAT*
MF_UequLUnterdiagonal- (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:
MF_HannHann-Fenster
MF_ParzenParzen-Fenster
MF_WelchWelch-Fenster

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_FtoDfMatrix zu dMatrix
M_EtoDeMatrix zu dMatrix (mit Überlauf-Schutz)
M_CDtoCFcdMatrix zu cfMatrix (mit Überlauf-Schutz)
M_DtoEdMatrix zu eMatrix

Zurück zum Inhaltsverzeichnis


5. Symmetrie-Operationen (Transposition, Rotation, , Spiegelung),
Interpolation, Erweiterung, Verkleinerung, Extraktion sowie Initialisierung von Teilen von Matrizen

MF_transposeMatrix transponieren: MB = MAT
MCF_hermconjHermitesch konjugierte Matrix: MB = MAT*
MF_rotate90Matrix 90° im Uhrzeigersinn rotieren
MF_rotate180Matrix 180° rotieren
MF_rotate270Matrix 270° im Uhrzeigersinn (bzw. 90 ° entgegen dem Uhrzeigersinn) rotieren
MF_Rows_revUmkehrung der Element-Reihenfolge innerhalb der Zeilen. Dies entspricht einer Spiegelung der Matrix an der Y-Achse
MF_Cols_revUmkehrung der Element-Reihenfolge innerhalb der Spalten. Dies entspricht einer Spiegelung der Matrix an der X-Achse
MF_Rows_reflectobere Hälfte (d.h. höhere Indizes) aller Zeilen gleich der am Mittelpunkt reflektierten unteren Hälfte setzen
MF_Cols_reflectobere Hälfte (d.h. höhere Indizes) aller Spalten gleich der am Mittelpunkt reflektierten unteren Hälfte setzen
MF_UequLUnterdiagonal- (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_polyinterpolPolynom-Interpolation
MF_ratinterpolrationale Interpolation
MF_natCubSplineInterpol"natürliche" kubische Spline-Interpolation
MF_equMblockeinen Block, d.h. eine aus benachbarten Zeilen bzw. Spalten bestehende Teilmatrix, extrahieren
MF_equMblockTdie Transponierte eines Blocks extrahieren
MF_submatrixTeilmatrix extrahieren, wobei die Abtast-Intervalle entlang der Zeilen bzw. Spalten von 1 verschieden sein dürfen
MF_block_equMMatrix in einen Block einer anderen (normalerweise größeren) Matrix kopieren
MF_block_equMTtransponierte Matrix in einen Block einer anderen (normalerweise größeren) Matrix kopieren
MF_submatrix_equMMatrix in eine Teilmatrix einer (normalerweise größeren) Matrix kopieren
MF_Row_extractEinzelne Zeile extrahieren und in einen Vektor kopieren
MF_Col_extractEinzelne Spalte extrahieren und in einen Vektor kopieren
MF_Dia_extractDiagonale extrahieren und in einen Vektor kopieren
MF_Trd_extracttridiagonale Matrix aus allgemeiner Matrix extrahieren
MF_Row_insertMatrix durch Einfügen einer Zeile erweitern
MF_Col_insertMatrix durch Einfügen einer Spalte erweitern
MF_Row_deleteMatrix durch Entfernen einer Zeile verkleinern
MF_Col_deleteMatrix 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_negMultiplikation aller Elemente einer bestimmten Zeile mit -1
MF_Col_negMultiplikation aller Elemente einer bestimmten Spalte mit -1
MF_Row_addCeine Konstante zu allen Elementen einer bestimmten Zeile hinzuaddieren
MF_Col_addCeine Konstante zu allen Elementen einer bestimmten Spalte hinzuaddieren
MF_Dia_addCeine Konstante zu allen Elementen der Diagonalen hinzuaddieren
MF_Row_addVVektor-Elemente zu den korrespondierenden Elementen einer bestimmten Zeile hinzuaddieren
MF_Col_addVVektor-Elemente zu den korrespondierenden Elementen einer bestimmten Spalte hinzuaddieren
MF_Dia_addVVektor-Elemente zu den korrespondierenden Elementen der Diagonalen hinzuaddieren
 
Für die übrigen Funktionen dieser Familie sollten einige Beispiele genügen:
MF_Row_subCeine Konstante von allen Elementen einer bestimmten Zeile subtrahieren
MF_Col_subrCumgekehrte Subtraktion: Differenz zwischen Spalten-Elementen und einer Konstanten
MF_Dia_mulVDiagonal-Elements mit korrespondierenden Vector-Elementen multiplizieren
MF_Row_divVElemente einer bestimmten Zeile durch korrespondierende Vektor-Elemente dividieren
MF_Col_divrCumgekehrte 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_maxMaxima der einzelnen Zeilen in einem Spaltenvektor speichern
MF_Cols_maxMaxima der einzelnen Spalten in einem Zeilenvektor speichern
MF_Dia_maxMaximum der Diagonalen als Skalar zurückgeben
MF_Rows_absmaxBetrags-Maxima der einzelnen Zeilen in einem Spaltenvektor speichern
MF_Cols_absmaxBetrags-Maxima der einzelnen Spalten in einem Zeilenvektor speichern
MF_Dia_absmaxBetrags-Maximum der Diagonalen als Skalar zurückgeben
MF_Rows_sumSummen über die einzelnen Zeilen in einem Spaltenvektor speichern
MF_Cols_sumSummen über die einzelnen Spalen in einem Zeilenvektor speichern
MF_Dia_sumSumme der Diagonalelemente
MF_Rows_prodProdukte über die einzelnen Zeilen in einem Spaltenvektor speichern
MF_Cols_prodProducte über die einzelnen Spalen in einem Zeilenvektor speichern
MF_Dia_prodProdukt der Diagonal-Elemente
MF_Rows_runsumlaufende Summe entlang der Zeilen
MF_Cols_runsumlaufende Summe entlang der Spalten
MF_Rows_runprod  laufendes Produkt entlang der Zeilen
MF_Cols_runprodlaufendes Produkt entlang der Spalten
MF_Rows_rotatealle Zeilen um eine bestimmte Anzahl von Positionen rotieren
MF_Cols_rotatealle Spalten um eine bestimmte Anzahl von Positionen rotieren
MF_Rows_rotate_bufalle Zeilen um eine bestimmte Anzahl von Positionen rotieren (unter Verwendung eines als Argument übergebenen Puffer-Speichers)
MF_Cols_rotate_bufalle Spalten um eine bestimmte Anzahl von Positionen rotieren (unter Verwendung eines als Argument übergebenen Puffer-Speichers)
MF_Rows_reflectobere Hälfte (d.h. höhere Indizes) aller Zeilen gleich der am Mittelpunkt reflektierten unteren Hälfte setzen
MF_Cols_reflectobere Hälfte (d.h. höhere Indizes) aller Spalten gleich der am Mittelpunkt reflektierten unteren Hälfte setzen
MF_Rows_revElement-Reihenfolge innerhalb der Zeilen umkehren. Dies entspricht einer Spiegelung der Matrix an der Y-Achse
MF_Cols_revElement-Reihenfolge innerhalb der Spalten umkehren. Dies entspricht einer Spiegelung der Matrix an der X-Achse
MF_Rows_FFTFourier-Transformation der Zeilen
MF_Cols_FFTFourier-Transformation der Spalten
MF_Rows_distributionHistogramm (ein-dimensionale Verteilungsfunktion) der Zeilen
MF_Cols_distributionHistogramm (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_absmaxBetrags-Maxima der einzelnen Zeilen in einem (reellen) Spaltenvektor speichern
MCF_Cols_absmaxBetrags-Maxima der einzelnen Spalten in einem (reellen) Zeilenvektor speichern
MCF_Dia_absmaxBetrags-Maximum der Diagonale als (reellen) Skalarwert zurückgeben
MCF_Rows_absmaxReImbetragsmäßig größte Real- und Imaginärteile einzeln entlang der Zeilen suchen und als Real- bzw. Imaginärteile eines komplexen Spaltenvektors speichern
MCF_Cols_absmaxReImbetragsmäßig größte Real- und Imaginärteile einzeln entlang der Spalten suchen und als Real- bzw. Imaginärteile eines komplexen Zeilenvektors speichern
MCF_Dia_absmaxReImbetragsmäß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_cabsmaxbezüglich Absolutwert definierte Maxima der einzelnen Zeilen in einem Spaltenvektor speichern
MCF_Cols_cabsmaxbezüglich Absolutwert definierte Maxima der einzelnen Spalten in einem Zeilenvektor speichern
MCF_Dia_cabsmaxbezüglich Absolutwert definiertes Maximum entlang der Diagonale suchen und als Skalar zurückgeben
MCF_Rows_maxReImgrößte Real- und Imaginärteile einzeln entlang der Zeilen suchen und als Real- bzw. Imaginärteile eines komplexen Spaltenvektors speichern
MCF_Cols_maxReImgrößte Real- und Imaginärteile einzeln entlang der Spalten suchen und als Real- bzw. Imaginärteile eines komplexen Zeilenvektors speichern
MCF_Dia_maxReImgrößten Real- und Imaginärteil einzeln entlang der Diagonale suchen und als Real- bzw. Imaginärteil einer komplexen Zahl zurückgeben
MCF_Rows_sabsmaxbezüglich der Summe |Re|+|Im| definierte Maxima der einzelnen Zeilen in einem Spaltenvektor speichern
MCF_Cols_sabsmaxbezüglich der Summe |Re|+|Im| definierte Maxima der einzelnen Spalten in einem Zeilenvektor speichern
MCF_Dia_sabsmaxbezü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:
 
MF_centerOfGravityIndSchwerpunkt einer Matrix in Form interpolierter Element-Indizes
MF_centerOfGravityVSchwerpunkt einer MZ-Matrix bei explizit gegebener X- und Y-Achse

Zurück zum Inhaltsverzeichnis


8. Operationen von zwei Zeilen oder zwei Spalten

MF_Rows_exchange zwei Zeilen vertauschen
MF_Cols_exchangezwei Spalten vertauschen
MF_Rows_addeine Zeile zu einer anderen hinzuaddieren (Ziel += Quelle)
MF_Cols_addeine Spalte zu einer anderen hinzuaddieren
MF_Rows_subeine Zeile von einer anderen abziehen (Ziel -= Quelle)
MF_Cols_subeine Spalte von einer anderen abziehen
MF_Rows_Caddeine mit einem konstanten Faktor skalierte Zeile zu einer anderen Zeile hinzuaddieren (Ziel += C * Quelle)
MF_Cols_Caddeine mit einem konstanten Faktor skalierte Spalte zu einer anderen Spalte hinzuaddieren
MF_Rows_lincombLinearkombination zweier Zeilen
MF_Cols_lincombLinearkombination zweier Spalten

Zurück zum Inhaltsverzeichnis


9. Arithmetik ganzer Matrizen: Addition und Multiplikation

a) Element-weise Operationen
MF_addMzwei Matrizen addieren
MF_addMTeine Matrix und die Transponierte einer weiteren Matrix addieren
MC = MA + MBT
MF_subMeine Matrix von einer anderen subtrahieren
MF_subMTtransponierte Matrix subtrahieren
MC = MA - MBT
MF_subrMTMatrix von der Transponierten einer anderen Matrix subtrahieren
MC = MBT - MA
MF_mulCalle Matrix-Elemente mit einer Konstanten multiplizieren
MCF_mulReCalle Elemente einer komplexen Matrix mit einer reellen Konstanten multiplizieren
MF_divCalle Matrix-Elemente durch eine Konstante dividieren
MCF_divReCalle Elemente einer komplexen Matrix durch eine reelle Konstante dividieren
MFs_addMskalierte Addition zweier Matrizen
MC = c * (MA + MB)
MFs_addMTskalierte Addition von einer Matrix und einer transponierten anderen
MC = c * (MA + MBT)
MFs_subMskalierte Subtraktion zweier Matrizen
MC = c * (MA - MB)
MFs_subMTskalierte Subtraktion von einer Matrix minus der Transponierten einer anderen
MC = c * (MA - MBT)
MFs_subrMTskalierte umgekehrte Subtraktion: transponierte Matrix minus eine andere
MC = c * (MBT - MA)
MF_lincombLinearkombination
MC = ca * MA + cb * MB

b) Matrix-Multiplikation
MF_mulVMatrix mit einem Spaltenvektor multiplizieren:
Y = MA * X
MF_TmulVtransponierte Matrix mit einem Spaltenvektor multiplizieren:
Y = MAT * X
VF_mulMZeilenvektor mit einer Matrix multiplizieren:
Y = X * MA
VF_mulMTZeilenvektor mit transponierter Matrix multiplizieren:
Y = X * MAT
MF_mulMMultiplikation zweier Matrizen:
MC = MA * MB
MF_mulMTeine Matrix mit der Transponierten einer anderen multiplizieren:
MC = MA * MBT
MF_TmulMtransponierte Matrix mit einer anderen Matrix multiplizieren:
MC = MAT * MB
MF_TmulMTtransponierte Matrix mit einer anderen transponierten Matrix multiplizieren:
MC = MAT * MBT
MCF_mulMHeine Matrix mit der Hermitesch-konjugierten Form einer anderen multiplizieren:
MC = MA * MBT *
MCF_HmulMHermitesch-konjugierte Form einer Matrix mit einer anderen Matrix multiplizieren:
MC = MAT * * MB
MCF_TmulMHtransponierte 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_mulMdiaallgemeine Matrix mit Diagonalmatrix multiplizieren:
MC = MA * MBDia
MF_TmulMdiatransponierte allgemeine Matrix mit Diagonalmatrix multiplizieren:
MC = MAT * MBDia
MFdia_mulMDiagonalmatrix mit allgemeiner Matrix mutliplizieren:
MC = MADia * MB
MFdia_mulMTDiagonalmatrix 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_invMatrix invertieren
MF_detDeterminante 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_invSymmetrische, als positiv-definit angenommene Matrix invertieren
MFsym_detDeterminante einer symmetrischen, als positiv-definit angenommenen Matrix
MF_solveBySVDLineares 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_LUDresultprüfen, ob MF_LUdecompose erfolgreich war
MF_LUDsetEditEditier-Schwelle für MF_LUdecompose setzen; dies kann zur Umgehung von Singularitäten dienen
MF_LUDgetEditaktuell eingestellte Editier-Schwelle lesen
MF_LUsolveLösung eines linearen Gleichungssystems bei Vorliegen der Matrix in LU-Form
MF_LUimproveGenauigkeit der über LU-Faktorisierung erzielten Lösung eines linearen Gleichungssystems iterativ verbessern
MF_LUinvBereits in LU-Form faktorisierte Matrix invertieren
MF_LUdetDeterminante 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_CholeskyLsolveLösung eines positiv-definiten Gleichungssystems bei Vorliegen der Matrix in linker Dreiecks-Form
MF_CholeskyRsolveLösung eines positiv-definiten Gleichungssystems bei Vorliegen der Matrix in rechter Dreiecks-Form
MF_CholeskyLimproveGenauigkeit der über Cholesky-Faktorisierung in L-Form erzielten Lösung eines linearen Gleichungssystems iterativ verbessern
MF_CholeskyRimproveGenauigkeit der über Cholesky-Faktorisierung in R-Form erzielten Lösung eines linearen Gleichungssystems iterativ verbessern
MF_CholeskyLinvBereits durch Cholesky-Faktorisierung in L-Form vorliegende Matrix invertieren
MF_CholeskyRinvBereits durch Cholesky-Faktorisierung in R-Form vorliegende Matrix invertieren
MF_CholeskyDetDeterminante 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_SVsolveSingulärwert-zerlegtes Gleichungssystem lösen
MF_SVDsetEditEditier-Schwelle für Dimensions-Reduktion bei SV-Lösung setzen
MF_SVDgetEditaktuell 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_FFTtoCSchnelle Fourier-Transformation (engl.: Fast Fourier Transform, FFT) einer rellen Matrix in Vorwärts-Richtung; das Ergebnis ist eine komplexe Matrix
MF_FFTVorwä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_FFTVorwärts- und Rückwärts-FFT komplexer Matrizen
MF_convolveFaltung (engl.: convolution) mit einer räumlichen Impulsantwort-Funktion
MF_deconvolveEntfaltung (engl.: deconvolution)
MF_filterRäumliche Filterung
MF_autocorrRäumliche Autokorrelation
MF_xcorrRäumliche Kreuzkorrelation
MF_spectrumRaumfrequenz-Spektrum
MF_xspectrumRaumfrequenz-Kreuzspektrum (komplex)
MF_xspectrumAbsRaumfrequenz-Kreuzspektrum (Absolutwerte)
MF_coherenceRäumliche Kohärenzfunktion

Die ein-dimensionale Fourier-Transformation entlang der Zeilen oder diejenige entlang der Spalten ist mit folgenden Funktionen möglich:
MF_Rows_FFTtoCFourier-Transformation der Zeilen einer reellen Matrix; das Ergebnis ist eine komplexe Matrix
MF_Cols_FFTtoCFourier-Transformation der Spalten einer reellen Matrix; das Ergebnis ist eine komplexe Matrix
MF_Rows_FFTFourier-Transformation der Zeilen einer reellen Matrix
MF_Cols_FFTFourier-Transformation der Spalten einer reellen Matrix
MCF_Rows_FFTFourier-Transformation der Zeilen einer komplexen Matrix
MCF_Cols_FFTFourier-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: 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:
 
VF_nonlinfit_getBestValuesbislang bester Parameter-Satz
VF_nonlinfit_getFOMbislang bester Anpassungstest-Wert (c2, chi-Quadrat oder |c|, chiabs, je nach Einstellung des VF_NONLINFITOPTIONS-Members "FigureOfMerit")
VF_nonlinfit_getTestDiraktuelle Test-Richtung (+1 für aufwärts, -1 für abwärts) während "Ausbruchs"-Versuchen (LevelOfMethod größer als 3, siehe die obige Beschreibung von VF_NONLINFITOPTIONS)
VF_nonlinfit_getTestParIndex des derzeit bezüglich "Ausbruchs" geprüften Parameters
VF_nonlinfit_getTestRunIndes des aktuellen "Ausbruchs"-Durchlaufs (für jeden Fit-Parameter wird ein Testdurchlauf durchgeführt)
VF_nonlinfit_stopAnpassung nach Vervollständigung des laufenden Levenberg-Marquardt- oder Downhill-Simplex-Zyklus beenden
 
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_printMatrix auf dem Bildschirm ausgeben (ohne Abschneiden von Zeilen und ohne Aufteilung auf mehrere Seiten; nur für Konsolen-Anwendungen)
MF_fprintMatrix im ASCII-Format in einen Stream schreiben
MF_storeim Binärformat speichern
MF_recallim Binärformat einlesen
MF_writeim ASCII-Format in einen Stream schreiben
MF_readim 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_zAutoDensityMapFarbton-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_zDataDensityMapFarbton-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_setDensityBoundsFestsetzen einer Farbton-Skala
M_setDensityMapBoundsFestsetzen einer Farbton-Skala und Zeichnung eines X-Y-Koordinatensystems
M_findDensityMapBoundsBerechnung 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_accElementMD_accElementME_accElement
MCF_accElementMCD_accElementMCE_accElement
MCF_accElementReMCD_accElementReMCE_accElementRe
MCF_accElementImMCD_accElementImMCE_accElementIm
MI_accElementMBI_accElementMSI_accElementMLI_accElementMQI_accElement 
MU_accElementMUB_accElementMUS_accElementMUL_accElementMUQ_accElementMUI_accElement
FunktionEin 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/Delphiuses 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/Delphiuses 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 );
BeschreibungReelle 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.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisMF_Pelement,   MF_element,   MF_getElement,   MF_setElement,   MF_decElement

 
MF_addM MD_addM ME_addM
MFs_addM MDs_addM MEs_addM
MCF_addM MCD_addM MCE_addM
FunktionElement-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/Delphiuses 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/Delphiuses 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 );
BeschreibungNormalversion: MCij = MAij + MBij
Skalierte Version: MCij = C * (MAij + MBij)
QuerverweisMF_addMT,   MF_subM,   MF_subrM,   Kap. 9

 
MF_addMT MD_addMT ME_addMT
MFs_addMT MDs_addMT MEs_addMT
MCF_addMT MCD_addMT MCE_addMT
FunktionElement-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/Delphiuses 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/Delphiuses 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 );
BeschreibungNormalversion: MCij = MAij + MBTji
Skalierte Version: MCij = C * (MAij + MBTji)
QuerverweisMF_addM,   MF_subMT,   Kap. 9

 
MF_autocorr MD_autocorr ME_autocorr
MFb_autocorr MDb_autocorr MEb_autocorr
FunktionRä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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_autocorr( d_MY, d_MX:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_autocorr( h_MY, h_MX:fMatrix; ht, len:UIntSize );
BeschreibungDie 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.

FehlerbehandlungFalls 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.
QuerverweisMF_FFT,   MF_xcorr,   MF_convolve,   VF_autocorr,   Kap. 12

 
MF_block_equM MD_block_equM ME_block_equM
MCF_block_equM MCD_block_equM MCE_block_equM
MI_block_equMMBI_block_equMMSI_block_equMMLI_block_equMMQI_block_equM
MU_block_equMMUB_block_equMMUS_block_equMMUL_block_equMMUQ_block_equM
FunktionMatrix 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMDesti+firstRow, j+firstCol = MSrcei, j,  i=0,...,srceHt-1;  j=0,...,srceLen-1
QuerverweisMF_block_equMT,   MF_equMblock,   MF_submatrix_equM,   Kap. 5

 
MF_block_equMT MD_block_equMT ME_block_equMT
MCF_block_equMT MCD_block_equMT MCE_block_equMT
MI_block_equMTMBI_block_equMTMSI_block_equMTMLI_block_equMTMQI_block_equMT
MU_block_equMTMUB_block_equMTMUS_block_equMTMUL_block_equMTMUQ_block_equMT
FunktionTransponierte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMDesti+firstRow, j+firstCol = MSrcej, i,  i=0,...,srceLen-1;  j=0,...,srceHt-1
QuerverweisMF_block_equM,   MF_equMblockT,   MF_submatrix_equM,   Kap. 5

 

M_CDtoCFM_CDtoCE
M_CEtoCFM_CEtoCD
M_CFtoCDM_CFtoCE
FunktionDatentyp-Umwandlungen. Siehe M_FtoD.

 

MF_centerOfGravityIndMD_centerOfGravityIndME_centerOfGravityInd
FunktionSchwerpunkt 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDer 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.
Fehlerbehandlungkeine
Rückgabewert(Interpolierte) Koordinaten des Schwerpunktes
QuerverweisMF_centerOfGravityV

 
MF_chexprint MD_chexprint ME_chexprint
MCF_chexprint MCD_chexprint MCE_chexprint
MI_chexprintMBI_chexprintMSI_chexprintMLI_chexprintMQI_chexprint
MU_chexprintMUB_chexprintMUS_chexprintMUL_chexprintMUQ_chexprint
FunktionMatrix 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/Delphiuses 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/Delphiuses 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;
BeschreibungDie 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.
 
 
FehlerbehandlungWenn 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.
QuerverweisMF_cprint,   VF_chexprint,   Kap. 14

 

MF_centerOfGravityIndMD_centerOfGravityIndME_centerOfGravityInd
FunktionSchwerpunkt 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDer 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.
Fehlerbehandlungkeine
RückgabewertKoordinaten des Schwerpunkts
QuerverweisMF_centerOfGravityInd

 
MF_CholeskyLdecompose MD_CholeskyLdecompose ME_CholeskyLdecompose
MF_CholeskyRdecompose MD_CholeskyRdecompose ME_CholeskyRdecompose
FunktionCholesky-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/Delphiuses MFstd;
function MF_CholeskyLdecompose( ML:fMatrix; MA:fMatrix; len:UIntSize ):Integer;
function MF_CholeskyRdecompose( MR:fMatrix; MA:fMatrix; len:UIntSize ):Integer;
BeschreibungDie 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).

FehlerbehandlungIm Falle einer nicht-positiv-definiten Matrix bleibt ML bzw. MR undefiniert, und der Rückgabewert wird auf 1 gesetzt.
RückgabewertBei Erfolg FALSE(0), andernfalls TRUE (1)
QuerverweisKap. 10

 
MF_CholeskyDet MD_CholeskyDet ME_CholeskyDet
FunktionDeterminante 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/Delphiuses MFstd;
function MF_CholeskyDet( MLR:fMatrix; len:UIntSize ): Single;
BeschreibungMF_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.
RückgabewertDeterminante
QuerverweisMFsym_det,   Kap. 10

 
MF_CholeskyLimprove MD_CholeskyLimprove ME_CholeskyLimprove
MF_CholeskyRimprove MD_CholeskyRimprove ME_CholeskyRimprove
Funktioniterative 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/Delphiuses MFstd;
procedure MF_CholeskyLimprove( X, B:fVector; MA, ML:fMatrix; len:UIntSize );
procedure MFb_CholeskyRimprove( X, B:fVector; MA, MR:fMatrix; len:UIntSize );
BeschreibungVor 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.
QuerverweisKap. 10

 
MF_CholeskyLinv MD_CholeskyLinv ME_CholeskyLinv
MF_CholeskyRinv MD_CholeskyRinv ME_CholeskyRinv
FunktionInvertierung 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/Delphiuses MFstd;
procedure MF_CholeskyLinv( MInv, ML:fMatrix; len:UIntSize );
procedure MF_CholeskyRinv( MInv, MR:fMatrix; len:UIntSize );
BeschreibungMF_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.
QuerverweisKap. 10

 
MF_CholeskyLsolve MD_CholeskyLsolve ME_CholeskyLsolve
MF_CholeskyRsolve MD_CholeskyRsolve ME_CholeskyRsolve
Funktionsymmetrisches 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/Delphiuses MFstd;
procedure MF_CholeskyLsolve( X:fVector; ML:fMatrix; B:fVector; len:UIntSize );
procedure MF_CholeskyRsolve( X:fVector; MR:fMatrix; B:fVector; len:UIntSize );
BeschreibungDas 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.
QuerverweisKap. 10

 
MF_Col_addC MD_Col_addC ME_Col_addC
MCF_Col_addC MCD_Col_addC MCE_Col_addC
Funktioneine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,iCol += C,  i=0,...,ht-1
QuerverweisMF_Col_subC,   MF_Row_addC,   MF_Col_addV,   Kap. 6

 
MF_Col_addV MD_Col_addV ME_Col_addV
MCF_Col_addV MCD_Col_addV MCE_Col_addV
Funktioneinen 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,iCol += Xi,  i=0,...,ht-1
QuerverweisMF_Col_subV,   MF_Row_addV,   MF_Col_addC,   Kap. 6

 
MCF_Col_conj MCD_Col_conj MCE_Col_conj
FunktionKomplex-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/Delphiuses 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/Delphiuses MCFstd;
function cudaMCF_Col_conj( d_MA:cfMatrix; ht, len, iCol:UIntSize ): IntBool;
procedure MCFcu_Col_conj( h_MA:cfMatrix; ht, len, iCol:UIntSize );
BeschreibungMAiCol,i = MA*i,iCol,  i=0,...,ht-1
QuerverweisMF_Col_neg, Kap. 6

 
MF_Col_delete MD_Col_delete ME_Col_delete
MCF_Col_delete MCD_Col_delete MCE_Col_delete
MI_Col_deleteMBI_Col_deleteMSI_Col_deleteMLI_Col_deleteMQI_Col_delete
MU_Col_deleteMUB_Col_deleteMUS_Col_deleteMUL_Col_deleteMUL_Col_delete
Funktioneine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie 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
QuerverweisMF_Col_insert,   MF_Row_delete,   VF_delete,   Kap. 5

 
MF_Col_divC MD_Col_divC ME_Col_divC
MCF_Col_divC MCD_Col_divC MCE_Col_divC
Funktionalle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,iCol /= C,  i=0,...,ht-1
QuerverweisMF_Col_divrC,   MF_Row_divC,   MF_Col_mulC,   Kap. 6

 
MF_Col_divrC MD_Col_divrC ME_Col_divrC
MCF_Col_divrC MCD_Col_divrC MCE_Col_divrC
FunktionUmgekehrte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,iCol = C / MAi,iCol,  i=0,...,ht-1
QuerverweisMF_Col_divC,   MF_Row_divrC,   MF_Col_divV,   Kap. 6

 
MF_Col_divrV MD_Col_divrV ME_Col_divrV
MCF_Col_divrV MCD_Col_divrV MCE_Col_divrV
FunktionUmgekehrte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,iCol = Xi / MAi,iCol,  i=0,...,ht-1
QuerverweisMF_Col_divV,   MF_Row_divrV,   MF_Col_divrC,   Kap. 6

 
MF_Col_divV MD_Col_divV ME_Col_divV
MCF_Col_divV MCD_Col_divV MCE_Col_divV
FunktionElement-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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,iCol /= Xi,  i=0,...,ht-1
QuerverweisMF_Col_divrV,   MF_Row_divV,   MF_Col_divC,   Kap. 6

 
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_equ0MBI_Col_equ0MSI_Col_equ0MLI_Col_equ0MQI_Col_equ0
MU_Col_equ0MUB_Col_equ0MUS_Col_equ0MUL_Col_equ0MUQ_Col_equ0
Funktionalle 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/Delphiuses 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/Delphiuses 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)
QuerverweisMF_Col_equC,   MF_Row_equ0,   MF_Dia_equ0,   Kap. 6

 
MF_Col_equC MD_Col_equC ME_Col_equC
MCF_Col_equC MCD_Col_equC MCE_Col_equC
MI_Col_equCMBI_Col_equCMSI_Col_equCMLI_Col_equCMQI_Col_equC
MU_Col_equCMUB_Col_equCMUS_Col_equCMUL_Col_equCMUQ_Col_equC
Funktionalle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,iCol = C,  i=0,...,ht-1
QuerverweisMF_Col_equV,   MF_Row_equC,   MF_Dia_equC,   Kap. 6

 
MF_Col_equV MD_Col_equV ME_Col_equV
MCF_Col_equV MCD_Col_equV MCE_Col_equV
MI_Col_equVMBI_Col_equVMSI_Col_equVMLI_Col_equVMQI_Col_equV
MU_Col_equVMUB_Col_equVMUS_Col_equVMUL_Col_equVMUQ_Col_equV
FunktionVektor 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,iCol = Xi,  i=0,...,ht-1
QuerverweisMF_Col_equ0,   MF_Row_equV,   MF_Dia_equV,   Kap. 6

 
MF_Col_extract MD_Col_extract ME_Col_extract
MCF_Col_extract MCD_Col_extract MCE_Col_extract
MI_Col_extractMBI_Col_extractMSI_Col_extractMLI_Col_extractMQI_Col_extract
MU_Col_extractMUB_Col_extractMUS_Col_extractMUL_Col_extractMUQ_Col_extract
FunktionSpalte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = MAi,iCol,  i=0,...,ht-1
QuerverweisMF_Row_extract,   MF_Dia_extract,   MF_Col_equV,   Kap. 3

 
MF_Col_insert MD_Col_insert ME_Col_insert
MCF_Col_insert MCD_Col_insert MCE_Col_insert
MI_Col_insertMBI_Col_insertMSI_Col_insertMLI_Col_insertMQI_Col_insert
MU_Col_insertMUB_Col_insertMUS_Col_insertMUL_Col_insertMUQ_Col_insert
FunktionMatrix 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMBi,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
QuerverweisMF_Col_delete,   Kap. 5

 
MF_Col_mulC MD_Col_mulC ME_Col_mulC
MCF_Col_mulC MCD_Col_mulC MCE_Col_mulC
Funktionalle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,iCol *= C,  i=0,...,ht-1
QuerverweisMF_Col_divC,   MF_Row_divC,   MF_Col_mulV,   Kap. 6

 
MF_Col_mulV MD_Col_mulV ME_Col_mulV
MCF_Col_mulV MCD_Col_mulV MCE_Col_mulV
FunktionElement-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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,iCol *= Xi,  i=0,..,ht-1
QuerverweisMF_Col_divV,   MF_Row_divV,   MF_Col_mulC,   Kap. 6

 
MF_Col_neg MD_Col_neg ME_Col_neg
MCF_Col_neg MCD_Col_neg MCE_Col_neg
FunktionMultiplikation 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Col_neg( d_MA:fMatrix; ht, len, iCol:UIntSize ): IntBool;
procedure MFcu_Col_neg( h_MA:fMatrix; ht, len, iCol:UIntSize );
BeschreibungMAi,iCol *= -1,  i=0,...,ht-1
QuerverweisMF_Col_mulC,   MF_Row_neg,   MCF_Col_conj,   Kap. 6

 
MF_Col_subC MD_Col_subC ME_Col_subC
MCF_Col_subC MCD_Col_subC MCE_Col_subC
Funktioneine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,iCol -= C,  i=0,..,ht-1
QuerverweisMF_Col_addC,   MF_Row_subC,   MF_Col_subV,   MF_Col_subrC,   Kap. 6

 
MF_Col_subrC MD_Col_subrC ME_Col_subrC
MCF_Col_subrC MCD_Col_subrC MCE_Col_subrC
Funktionumgekehrte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,iCol = C - MAi,iCol,  i=0,..,ht-1
QuerverweisMF_Col_addC,   MF_Row_subC,   MF_Col_subrV,   MF_Col_subC,   Kap. 6

 
MF_Col_subrV MD_Col_subrV ME_Col_subrV
MCF_Col_subrV MCD_Col_subrV MCE_Col_subrV
FunktionUmgekehrte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,iCol = Xi - MAi,iCol,  i=0,..,ht-1
QuerverweisMF_Col_subV,   MF_Row_subrV,   MF_Col_subrC,   Kap. 6

 
MF_Col_subV MD_Col_subV ME_Col_subV
MCF_Col_subV MCD_Col_subV MCE_Col_subV
FunktionVektor 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,iCol -= Xi,  i=0,..,ht-1
QuerverweisMF_Col_subC,   MF_Row_subV,   MF_Col_subrC,   Kap. 6

 
MF_Cols_absmax MD_Cols_absmax ME_Cols_absmax
MCF_Cols_absmax MCD_Cols_absmax MCE_Cols_absmax
FunktionBetrags-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/Delphiuses 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/Delphiuses 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 );
BeschreibungDas Betrags-Maximum jeder Spalte j wird gespeichert als Element Yj für j=0,..,len-1
QuerverweisMF_Cols_max,   MF_Cols_absmin,   MF_Rows_absmax,   MF_Dia_absmax,   Kap. 7

 
MCF_Cols_absmaxReIm MCD_Cols_absmaxReIm MCE_Cols_absmaxReIm
FunktionBetrags-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/Delphiuses 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/Delphiuses 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 );
BeschreibungFü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.
QuerverweisMCF_Cols_absmax,   MCF_Cols_minReIm,   MCF_Rows_absmaxReIm,   Kap. 7

 
MF_Cols_absmin MD_Cols_absmin ME_Cols_absmin
MCF_Cols_absmin MCD_Cols_absmin MCE_Cols_absmin
FunktionBetrags-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/Delphiuses 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/Delphiuses 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 );
BeschreibungDas Betrags-Minimum jeder Spalte j wird gespeichert als Element Yj für j=0,..,len-1
QuerverweisMF_Cols_min,   MF_Cols_absmax,   MF_Rows_absmin,   MF_Dia_absmin,   Kap. 7

 
MCF_Cols_absminReIm MCD_Cols_absminReIm MCE_Cols_absminReIm
FunktionBetrags-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/Delphiuses 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/Delphiuses 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 );
BeschreibungFü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.
QuerverweisMCF_Cols_absmin,   MCF_Cols_minReIm,   MCF_Rows_absminReIm,   Kap. 7

 
MF_Cols_add MD_Cols_add ME_Cols_add
MCF_Cols_add MCD_Cols_add MCE_Cols_add
Funktioneine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,destCol += MAi,sourceCol,  i=0,..,ht-1
QuerverweisMF_Cols_sub,   MF_Cols_Cadd,   MF_Cols_lincomb,   Kap. 8

 
MCF_Cols_cabsmax MCD_Cols_cabsmax MCE_Cols_cabsmax
FunktionDenjenigen 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDasjenige 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
QuerverweisMCF_Cols_absmax,   MCF_Cols_cabsmin,   MCF_Cols_sabsmax,   MCF_Rows_cabsmax,   MCF_Dia_cabsmax,   Kap. 7

 
MCF_Cols_cabsmin MCD_Cols_cabsmin MCE_Cols_cabsmin
FunktionDenjenigen 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDasjenige 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
QuerverweisMCF_Cols_absmin,   MCF_Cols_cabsmax,   MCF_Cols_sabsmin,   MCF_Rows_cabsmin,   MCF_Dia_cabsmin,   Kap. 7

 
MF_Cols_Cadd MD_Cols_Cadd ME_Cols_Cadd
MCF_Cols_Cadd MCD_Cols_Cadd MCE_Cols_Cadd
Funktioneine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,destCol += C * MAi,sourceCol,  i=0,..,ht-1
QuerverweisMF_Cols_add,   MF_Cols_lincomb,   Kap. 8

 

MF_Cols_distributionMD_Cols_distributionME_Cols_distribution
MI_Cols_distributionMBI_Cols_distributionMSI_Cols_distributionMLI_Cols_distributionMQI_Cols_distribution
MU_Cols_distributionMUB_Cols_distributionMUS_Cols_distributionMUL_Cols_distributionMUQ_Cols_distribution
FunktionHistogramm: 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/Delphiuses 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/Delphiuses 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 );
BeschreibungFü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.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_distribution   MF_Rows_distribution

 
MF_Cols_exchange MD_Cols_exchange ME_Cols_exchange
MCF_Cols_exchange MCD_Cols_exchange MCE_Cols_exchange
MI_Cols_exchangeMBI_Cols_exchangeMSI_Cols_exchangeMLI_Cols_exchangeMQI_Cols_exchange
MU_Cols_exchangeMUB_Cols_exchangeMUS_Cols_exchangeMUL_Cols_exchangeMUL_Cols_exchange
Funktionzwei 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie Elemente der Spalten i1 und i2 werden vertauscht.
QuerverweisMF_Rows_exchange,   Kap. 8

 
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
FunktionSchnelle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie 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, iU0, i.Re
Y1, iUN/2, i.Re
Y2, iU1, i.Re
Y3, iU1, i.Im
  .....    .....  
YN-2, iUN/2-1, i.Re
YN-1, iUN/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).

FehlerbehandlungFalls ht nicht eine Potenz von 2 ist, bricht das Programm mit der Fehlermeldung "Size must be an integer power of 2" ab.
QuerverweisMF_Rows_FFT,   MF_FFT,   Kap. 12,   Kap. 4.8 von HANDBUCH.HTM

 
MF_Cols_lincomb MD_Cols_lincomb ME_Cols_lincomb
MCF_Cols_lincomb MCD_Cols_lincomb MCE_Cols_lincomb
FunktionLinearkombination 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,destCol = destC * MAi,destCol+ srceC * MAi,srceCol,  i=0,..,ht-1
QuerverweisMF_Cols_add,   MF_Cols_Cadd,   Kap. 8

 
MF_Cols_max MD_Cols_max ME_Cols_max
MI_Cols_maxMBI_Cols_maxMSI_Cols_maxMLI_Cols_maxMQI_Cols_max
MU_Cols_maxMUB_Cols_maxMUS_Cols_maxMUL_Cols_maxMUQ_Cols_max
FunktionMaxima 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDas Maximum jeder Spalte j wird gespeichert als Element Yj für j=0,..,len-1
QuerverweisMF_Cols_absmax,   MF_Cols_min,   MF_Rows_max,   Kap. 7

 
MCF_Cols_maxReIm MCD_Cols_maxReIm MCE_Cols_maxReIm
FunktionMaxima 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/Delphiuses 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/Delphiuses 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 );
BeschreibungFü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.
QuerverweisMCF_Cols_absmax,   MCF_Cols_minReIm,   MCF_Rows_maxReIm,   Kap. 7

 
MF_Cols_min MD_Cols_min ME_Cols_min
MI_Cols_minMBI_Cols_minMSI_Cols_minMLI_Cols_minMQI_Cols_min
MU_Cols_minMUB_Cols_minMUS_Cols_minMUL_Cols_minMUQ_Cols_min
FunktionMinima 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDas Minimum jeder Spalte j wird gespeichert als Element Yj für j=0,..,len-1
QuerverweisMF_Cols_absmax,   MF_Cols_min,   MF_Rows_max,   Kap. 7

 
MCF_Cols_minReIm MCD_Cols_minReIm MCE_Cols_minReIm
FunktionMinima 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/Delphiuses 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/Delphiuses 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 );
BeschreibungFü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.
QuerverweisMCF_Cols_absmin,   MCF_Cols_maxReIm,   MCF_Rows_minReIm,   Kap. 7

 
MF_Cols_prod MD_Cols_prod ME_Cols_prod
MCF_Cols_prod MCD_Cols_prod MCE_Cols_prod
FunktionProdukte ü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/Delphiuses 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/Delphiuses 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 );
BeschreibungYj = prod( MAi,j, i=0,..,ht-1),  j=0,..,len-1
QuerverweisMF_Cols_runprod,   MF_Cols_sum,   Kap. 7

 
MF_Cols_reflect MD_Cols_reflect ME_Cols_reflect
MCF_Cols_reflect MCD_Cols_reflect MCE_Cols_reflect
MI_Cols_reflectMBI_Cols_reflectMSI_Cols_reflectMLI_Cols_reflectMQI_Cols_reflect
MU_Cols_reflectMUB_Cols_reflectMUS_Cols_reflectMUL_Cols_reflectMUQ_Cols_reflect
FunktionZweite 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Cols_reflect( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Cols_reflect( h_MA:fMatrix; ht, len:UIntSize );
BeschreibungMAht-i-1,j = MAi, j,  i=0,..(ht-1)/2;  j=0,..,len-1
QuerverweisMF_Cols_rotate,   MF_Rows_reflect,   Kap. 7

 
MF_Cols_rev MD_Cols_rev ME_Cols_rev
MCF_Cols_rev MCD_Cols_rev MCE_Cols_rev
MI_Cols_revMBI_Cols_revMSI_Cols_revMLI_Cols_revMQI_Cols_rev
MU_Cols_revMUB_Cols_revMUS_Cols_revMUL_Cols_revMUQ_Cols_rev
FunktionUmkehrung 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Cols_rev( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Cols_rev( h_MA:fMatrix; ht, len:UIntSize );
BeschreibungMAi,j = MAht-i-1, j
QuerverweisMF_Rows_rev,   MF_Cols_reflect,   MF_rotate90,   Kap. 5,   Kap. 7

 
MF_Cols_rotate MD_Cols_rotate ME_Cols_rotate
MCF_Cols_rotate MCD_Cols_rotate MCE_Cols_rotate
MI_Cols_rotateMBI_Cols_rotateMSI_Cols_rotateMLI_Cols_rotateMQI_Cols_rotate
MU_Cols_rotateMUB_Cols_rotateMUS_Cols_rotateMUL_Cols_rotateMUQ_Cols_rotate
Funktionalle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,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.

QuerverweisMF_Cols_reflect,   MF_Rows_rotate,   Kap. 7

 
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_bufMBI_Cols_rotate_bufMSI_Cols_rotate_bufMLI_Cols_rotate_bufMQI_Cols_rotate_buf
MU_Cols_rotate_bufMUB_Cols_rotate_bufMUS_Cols_rotate_bufMUL_Cols_rotate_bufMUQ_Cols_rotate_buf
Funktioneffiziente 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Cols_rotate_buf( d_MA:fMatrix; ht, len:UIntSize; pos:Integer; d_MBuf:fMatrix ): IntBool;
BeschreibungMAi,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.

QuerverweisMF_Cols_rotate,   MF_Rows_rotate_buf,   Kap. 7

 
MF_Cols_runprod MD_Cols_runprod ME_Cols_runprod
MCF_Cols_runprod MCD_Cols_runprod MCE_Cols_runprod
Funktionlaufendes 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Cols_runprod( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Cols_runprod( h_MA:fMatrix; ht, len:UIntSize );
BeschreibungFü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.
QuerverweisMF_Cols_prod,   MF_Rows_runprod,   Kap. 7

 
MF_Cols_runsum MD_Cols_runsum ME_Cols_runsum
MCF_Cols_runsum MCD_Cols_runsum MCE_Cols_runsum
Funktionlaufende 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Cols_runsum( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Cols_runsum( h_MA:fMatrix; ht, len:UIntSize );
BeschreibungFür alle Spalten einzeln wird jedes Element als Summe seiner selbst und aller vorhergehender Elemente berechnet.
QuerverweisMF_Cols_sum,   MF_Rows_runsum,   Kap. 7

 
MCF_Cols_sabsmax MCD_Cols_sabsmax MCE_Cols_sabsmax
FunktionDenjenigen 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDas 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
QuerverweisMCF_Cols_absmax,   MCF_Cols_cabsmin,   MCF_Cols_sabsmax,   MCF_Rows_cabsmax,   MCF_Dia_cabsmax,   Kap. 7

 
MCF_Cols_sabsmin MCD_Cols_sabsmin MCE_Cols_sabsmin
FunktionDenjenigen 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDas 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
QuerverweisMCF_Cols_absmin,   MCF_Cols_cabsmax,   MCF_Cols_sabsmin,   MCF_Rows_cabsmin,   MCF_Dia_cabsmin,   Kap. 7

 
MF_Cols_sub MD_Cols_sub ME_Cols_sub
MCF_Cols_sub MCD_Cols_sub MCE_Cols_sub
FunktionEine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,destCol -= MAi,sourceCol,  i=0,..,ht-1
QuerverweisMF_Cols_add,   MF_Cols_Cadd,   Kap. 8

 
MF_Cols_sum MD_Cols_sum ME_Cols_sum
MCF_Cols_sum MCD_Cols_sum MCE_Cols_sum
FunktionSummen ü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/Delphiuses 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/Delphiuses 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 );
BeschreibungYj = sum( MAi,j, i=0,..,ht-1),  j=0,..,len-1
QuerverweisMF_Cols_prod,   MF_Cols_runsum,   Kap. 7

 
MCF_conj MCD_conj MCE_conj
Funktionkomplex-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/Delphiuses 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/Delphiuses MCFstd;
function cudaMCF_conj( d_MB, d_MA:cfMatrix; ht, len:UIntSize ): IntBool;
procedure MCFcu_conj( h_MB, h_MA:cfMatrix; ht, len:UIntSize );
BeschreibungMBij.Re = MAij.Re
MBij.Im = -MAij.Im
QuerverweisMCF_neg,   Kap. 3

 
MF_coherence MD_coherence ME_coherence
MFb_coherence MDb_coherence MEb_coherence
MFb_coherence_sizeBuf MDb_coherence_sizeBuf MEb_coherence_sizeBuf
FunktionRä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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie 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.

FehlerbehandlungFalls 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.
QuerverweisMF_spectrum,   MF_xspectrum,   MF_FFT,   MF_convolve,   MF_autocorr,   MF_xcorr,   MF_filter,   Kap. 12

 
MF_convolve MD_convolve ME_convolve
MF_convolvewEdit MD_convolvewEdit ME_convolvewEdit
MFb_convolve MDb_convolve MEb_convolve
MFb_convolvewEdit MDb_convolvewEdit MEb_convolvewEdit
FunktionFaltung (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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie 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.
FehlerbehandlungFalls 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.
QuerverweisMF_deconvolve,   MF_FFT,   Kap. 12

 
MF_cprint MD_cprint ME_cprint
MCF_cprint MCD_cprint MCE_cprint
MI_cprintMBI_cprintMSI_cprintMLI_cprintMQI_cprint
MU_cprintMUB_cprintMUS_cprintMUL_cprintMUQ_cprint
FunktionMatrix 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/Delphiuses 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/Delphiuses 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;
BeschreibungDie 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.
FehlerbehandlungWenn 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.
QuerverweisMF_fprint,   MF_chexprint,   VF_cprint,   Kap. 14

 

MF_decElementMD_decElementME_decElement
MCF_decElementMCD_decElementMCE_decElement
MCF_decElementReMCD_decElementReMCE_decElementRe
MCF_decElementImMCD_decElementImMCE_decElementIm
MI_decElementMBI_decElementMSI_decElementMLI_decElementMQI_decElement 
MU_decElementMUB_decElementMUS_decElementMUL_decElementMUQ_decElementMUI_decElement
FunktionEin 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/Delphiuses 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/Delphiuses 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 );
BeschreibungReelle 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.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisMF_Pelement,   MF_element,   MF_getElement,   MF_setElement,   MF_accElement

 
MF_deconvolve MD_deconvolve ME_deconvolve
MF_deconvolvewEdit MD_deconvolvewEdit ME_deconvolvewEdit
MFb_deconvolve MDb_deconvolve MEb_deconvolve
MFb_deconvolvewEdit MDb_deconvolvewEdit MEb_deconvolvewEdit
FunktionRä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/Delphiuses 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/Delphiuses 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 );
BeschreibungMX 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.

FehlerbehandlungFalls 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).
QuerverweisMF_convolve,   MF_FFT,   Kap. 12

 
MF_det MD_det ME_det
MCF_det MCD_det MCE_det
MF_detwEdit MD_detwEdit ME_detwEdit
MCF_detwEdit MCD_detwEdit MCE_detwEdit
   
MFb_det MDb_det MEb_det
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
FunktionDeterminante 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/Delphiuses 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;
BeschreibungDie 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ückgabewertDeterminante der Matrix
QuerverweisMF_LUdecompose,   MF_CholeskyLdecompose,   MF_solve,   Kap. 10

 
MF_Dia_absmax MD_Dia_absmax ME_Dia_absmax
MCF_Dia_absmax MCD_Dia_absmax MCE_Dia_absmax
FunktionBetrags-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/Delphiuses 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/Delphiuses 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;
BeschreibungDas Betrags-Maximum der Elemente MAi,i wird als Skalar zurückgegeben.
RückgabewertBetrags-Maximum der Diagonalen
QuerverweisMF_Dia_max,   MF_Dia_absmin,   Kap. 7

 
MCF_Dia_absmaxReIm MCD_Dia_absmaxReIm MCE_Dia_absmaxReIm
FunktionGetrennte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie 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.
QuerverweisMCF_Dia_absminReIm,   MCF_Dia_absmax,   MCF_Dia_maxReIm,   MCF_Rows_absmaxReIm,   Kap. 7

 
MF_Dia_absmin MD_Dia_absmin ME_Dia_absmin
MCF_Dia_absmin MCD_Dia_absmin MCE_Dia_absmin
FunktionBetrags-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/Delphiuses 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/Delphiuses 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;
BeschreibungDas Betrags-Minimum der Elemente MAi,i wird als Skalar zurückgegeben.
RückgabewertBetrags-Minimum der Diagonalen
QuerverweisMF_Dia_min,   MF_Dia_absmax,   Kap. 7

 
MCF_Dia_absminReIm MCD_Dia_absminReIm MCE_Dia_absminReIm
FunktionGetrennte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie 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.
QuerverweisMCF_Dia_absmaxReIm,   MCF_Dia_absmin,   MCF_Dia_minReIm,   MCF_Rows_absmaxReIm,   Kap. 7

 
MF_Dia_addC MD_Dia_addC ME_Dia_addC
MCF_Dia_addC MCD_Dia_addC MCE_Dia_addC
Funktioneine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,i += C,  i=0,...,len-1
QuerverweisMF_Dia_addV,   MF_Dia_subC,   Kap. 6

 
MF_Dia_addV MD_Dia_addV ME_Dia_addV
MCF_Dia_addV MCD_Dia_addV MCE_Dia_addV
FunktionElement-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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,i += Xi,  i=0,...,len-1
QuerverweisMF_Dia_addC,   MF_Dia_subV,   Kap. 6

 
MCF_Dia_cabsmax MCD_Dia_cabsmax MCE_Dia_cabsmax
FunktionFinden 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDasjenige 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).
QuerverweisMCF_Dia_cabsmin,   MCF_Dia_absmax,   MCF_Dia_maxReIm,   MCF_Rows_cabsmax,   Kap. 7

 
MCF_Dia_cabsmin MCD_Dia_cabsmin MCE_Dia_cabsmin
FunktionFinden 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDasjenige 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).
QuerverweisMCF_Dia_cabsmax,   MCF_Dia_absmin,   MCF_Dia_minReIm,   MCF_Rows_cabsmin,   Kap. 7

 
MF_Dia_divC MD_Dia_divC ME_Dia_divC
MCF_Dia_divC MCD_Dia_divC MCE_Dia_divC
Funktionalle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,i /= C,  i=0,...,len-1
QuerverweisMF_Dia_divV,   MF_Dia_mulC,   MF_Dia_divrC,   Kap. 6

 
MF_Dia_divrC MD_Dia_divrC ME_Dia_divrC
MCF_Dia_divrC MCD_Dia_divrC MCE_Dia_divrC
Funktionumgekehrte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,i = C / MAi,i,  i=0,...,len-1
QuerverweisMF_Dia_divrV,   MF_Dia_mulC,   MF_Dia_divC,   Kap. 6

 
MF_Dia_divrV MD_Dia_divrV ME_Dia_divrV
MCF_Dia_divrV MCD_Dia_divrV MCE_Dia_divrV
Funktionumgekehrte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,i = Xi / MAi,i,  i=0,...,len-1
QuerverweisMF_Dia_divV,   MF_Dia_mulV,   MF_Dia_divrC,   Kap. 6

 
MF_Dia_divV MD_Dia_divV ME_Dia_divV
MCF_Dia_divV MCD_Dia_divV MCE_Dia_divV
FunktionElement-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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,i / Xi,  i=0,...,len-1
QuerverweisMF_Dia_divrV,   MF_Dia_mulV,   MF_Dia_divC,   Kap. 6

 
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_equ0MBI_Dia_equ0MSI_Dia_equ0MLI_Dia_equ0MQI_Dia_equ0
MU_Dia_equ0MUB_Dia_equ0MUS_Dia_equ0MUL_Dia_equ0MUQ_Dia_equ0
Funktionalle 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/Delphiuses 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/Delphiuses 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)
QuerverweisMF_Dia_equC,   MF_Dia_equV,   Kap. 3,   Kap. 6,   Kap. 7

 
MF_Dia_equC MD_Dia_equC ME_Dia_equC
MCF_Dia_equC MCD_Dia_equC MCE_Dia_equC
MI_Dia_equCMBI_Dia_equCMSI_Dia_equCMLI_Dia_equCMQI_Dia_equC
MU_Dia_equCMUB_Dia_equCMUS_Dia_equCMUL_Dia_equCMUQ_Dia_equC
Funktionalle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,i = C,  i=0,...,len-1
QuerverweisMF_Dia_equ0,   MF_Dia_equV,   Kap. 3,   Kap. 6,   Kap. 7

 
MF_Dia_equV MD_Dia_equV ME_Dia_equV
MCF_Dia_equV MCD_Dia_equV MCE_Dia_equV
MI_Dia_equVMBI_Dia_equVMSI_Dia_equVMLI_Dia_equVMQI_Dia_equV
MU_Dia_equVMUB_Dia_equVMUS_Dia_equVMUL_Dia_equVMUQ_Dia_equV
FunktionVektor 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,i = Xi,  i=0,...,len-1
QuerverweisMF_Dia_equ0,   MF_Dia_equC,   Kap. 3,   Kap. 6,   Kap. 7

 
MF_Dia_extract MD_Dia_extract ME_Dia_extract
MCF_Dia_extract MCD_Dia_extract MCE_Dia_extract
MI_Dia_extractMBI_Dia_extractMSI_Dia_extractMLI_Dia_extractMQI_Dia_extract
MU_Dia_extractMUB_Dia_extractMUS_Dia_extractMUL_Dia_extractMUQ_Dia_extract
Funktiondie 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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = MAi,i,  i=0,...,len-1
QuerverweisMF_Dia_equV,   Kap. 3,   Kap. 6

 
MF_Dia_max MD_Dia_max ME_Dia_max
MI_Dia_maxMBI_Dia_maxMSI_Dia_maxMLI_Dia_maxMQI_Dia_max
MU_Dia_maxMUB_Dia_maxMUS_Dia_maxMUL_Dia_maxMUQ_Dia_max
FunktionMaximum 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/Delphiuses 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/Delphiuses 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;
BeschreibungDas größte Element der Diagonalen wird als Skalar zurückgegeben
RückgabewertMaximum der Diagonalen
QuerverweisMF_Dia_absmax,   MF_Dia_min,   Kap. 6,   Kap. 7

 
MCF_Dia_maxReIm MCD_Dia_maxReIm MCE_Dia_maxReIm
FunktionGetrennte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie 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.
QuerverweisMCF_Dia_minReIm,   MCF_Dia_absmax,   MCF_Dia_max,   MCF_Rows_maxReIm,   Kap. 7

 
MF_Dia_min MD_Dia_min ME_Dia_min
MI_Dia_minMBI_Dia_minMSI_Dia_minMLI_Dia_minMQI_Dia_min
MU_Dia_minMUB_Dia_minMUS_Dia_minMUL_Dia_minMUQ_Dia_min
FunktionMinimum 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/Delphiuses 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/Delphiuses 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;
BeschreibungDas kleinste oder "negativste" Element der Diagonalen wird als Skalr zurückgegeben
RückgabewertMinimum der Diagonalen
QuerverweisMF_Dia_absmin,   MF_Dia_max,   Kap. 6,   Kap. 7

 
MCF_Dia_minReIm MCD_Dia_minReIm MCE_Dia_minReIm
FunktionGetrennte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie 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.
QuerverweisMCF_Dia_maxReIm,   MCF_Dia_min,   MCF_Dia_absminReIm,   MCF_Rows_absmaxReIm,   Kap. 7

 
MF_Dia_mulC MD_Dia_mulC ME_Dia_mulC
MCF_Dia_mulC MCD_Dia_mulC MCE_Dia_mulC
Funktionalle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,i *= C,  i=0,...,len-1
QuerverweisMF_Dia_mulV,   MF_Dia_divC,   Kap. 6

 
MF_Dia_mulV MD_Dia_mulV ME_Dia_mulV
MCF_Dia_mulV MCD_Dia_mulV MCE_Dia_mulV
FunktionElement-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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,i *= Xi,  i=0,...,len-1
QuerverweisMF_Dia_mulC,   MF_Dia_divV,   Kap. 6

 
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 );
MF_Dia_prod MD_Dia_prod ME_Dia_prod
MCF_Dia_prod MCD_Dia_prod MCE_Dia_prod
FunktionProdukt 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/Delphiuses MFstd, MCFstd;
function MF_Dia_prod( MA:fMatrix; len:UIntSize ):Single;
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/Delphiuses 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 );
BeschreibungDas Produkt der Diagonal-Elemente wird als Skalar zurückgegeben
RückgabewertProdukt der Diagonal-Elemente
QuerverweisMF_Dia_sum,   Kap. 7

 
MCF_Dia_sabsmax MCD_Dia_sabsmax MCE_Dia_sabsmax
FunktionFinden 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDasjenige 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).
QuerverweisMCF_Dia_sabsmin,   MCF_Dia_absmax,   MCF_Dia_maxReIm,   MCF_Rows_sabsmax,   Kap. 7

 
MCF_Dia_sabsmin MCD_Dia_sabsmin MCE_Dia_sabsmin
FunktionFinden 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDasjenige 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).
QuerverweisMCF_Dia_sabsmax,   MCF_Dia_absmin,   MCF_Dia_minReIm,   MCF_Rows_sabsmin,   Kap. 7

 
MF_Dia_subC MD_Dia_subC ME_Dia_subC
MCF_Dia_subC MCD_Dia_subC MCE_Dia_subC
Funktioneine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,i -= C,  i=0,...,len-1
QuerverweisMF_Dia_subV,   MF_Dia_subrC,   Kap. 6

 
MF_Dia_subrC MD_Dia_subrC ME_Dia_subrC
MCF_Dia_subrC MCD_Dia_subrC MCE_Dia_subrC
Funktionumgekehrte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,i = C - MAi,i,  i=0,...,len-1
QuerverweisMF_Dia_subrV,   MF_Dia_subC,   Kap. 6

 
MF_Dia_subrV MD_Dia_subrV ME_Dia_subrV
MCF_Dia_subrV MCD_Dia_subrV MCE_Dia_subrV
Funktionumgekehrte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,i = Xi - MAi,i,  i=0,...,len-1
QuerverweisMF_Dia_subV,   MF_Dia_subrC,   Kap. 6

 
MF_Dia_subV MD_Dia_subV ME_Dia_subV
MCF_Dia_subV MCD_Dia_subV MCE_Dia_subV
FunktionElement-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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,i -= Xi,  i=0,...,len-1
QuerverweisMF_Dia_subrV,   MF_Dia_subC,   Kap. 6

 
MF_Dia_sum MD_Dia_sum ME_Dia_sum
MCF_Dia_sum MCD_Dia_sum MCE_Dia_sum
FunktionSumme ü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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie Diagonal-Elemente werden aufsummiert und als Skalar zurückgegeben
RückgabewertSumme über die Diagonal-Elemente
QuerverweisMF_Dia_prod,   Kap. 7

 
MF_divC MD_divC ME_divC
MCF_divC MCD_divC MCE_divC
MCF_divReC MCD_divReC MCE_divReC
Funktionalle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMi,j /= C,  i=0,...,ht-1;  j=0,..,len-1
QuerverweisMF_mulC,   Kap. 3

 
M_DtoFM_DtoE
FunktionDatentyp-Umwandlungen. Siehe M_FtoD.

 
MFsym_eigenvalues MDsym_eigenvalues MEsym_eigenvalues
FunktionEigenwerte 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/Delphiuses MFstd;
function MFsym_eigenvalues( EigVals:fVector; EigVecs, MA:fMatrix; len:UIntSize; CalcEigenVec:IntBool ): IntBool;
BeschreibungDie 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ückgabewertFALSE (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!
QuerverweisKap. 10,   Kap. 11

 
MF_element MD_element ME_element
MCF_element MCD_element MCE_element
MI_elementMBI_elementMSI_elementMLI_elementMQI_element
MU_elementMUB_elementMUS_elementMUL_elementMUQ_element
FunktionLese-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/Delphiuses 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/Delphiuses 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 );
BeschreibungDas 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ückgabewertDas Matrix-Element m,n (außer komplexe Version Pascal/Delphi)
QuerverweisMF_Pelement,   Kap. 2

 
MF_equ0 MD_equ0 ME_equ0
MCF_equ0 MCD_equ0 MCE_equ0
MCF_Reequ0 MCD_Reequ0 MCE_Reequ0
MCF_Imequ0 MCD_Imequ0 MCE_Imequ0
MI_equ0MBI_equ0MSI_equ0MLI_equ0MQI_equ0
MU_equ0MUB_equ0MUS_equ0MUL_equ0MUQ_equ0
Funktionalle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungM?_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)
QuerverweisMF_equ1,   MF_equM,   Kap. 3

 
MF_equ1 MD_equ1 ME_equ1
MCF_equ1 MCD_equ1 MCE_equ1
MI_equ1MBI_equ1MSI_equ1MLI_equ1MQI_equ1
MU_equ1MUB_equ1MUS_equ1MUL_equ1MUQ_equ1
FunktionEinheits-Matrix
Syntax C/C++#include <MFstd.h>
void MF_equ1( fMatrix MA, ui len );
C++ MatObj#include <OptiVec.h>
void matrix<T>::equ1( );
Pascal/Delphiuses 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/Delphiuses MFstd;
function cudaMF_equ1( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_equ1( h_MA:fMatrix; ht, len:UIntSize );
BeschreibungMAi,i = 1
MAi,j = 0,  i != j
QuerverweisMF_equ0,   MF_equm1,   Kap. 3

 
MF_equM MD_equM ME_equM
MCF_equM MCD_equM MCE_equM
MI_equMMBI_equMMSI_equMMLI_equMMQI_equM
MU_equMMUB_equMMUS_equMMUL_equMMUQ_equM
FunktionMatrix kopieren
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/Delphiuses 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/Delphiuses 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;
BeschreibungMBi,j = MAi,j

CUDA-Versionen: cudaMF_equMhost und MF_equMdevice kopieren Matrizen von Host- zu Device-Memory und umgekehrt.

QuerverweisMF_transpose,   MF_neg,   Kap. 3

 
MF_equm1 MD_equm1 ME_equm1
MCF_equm1 MCD_equm1 MCE_equm1
MI_equm1MBI_equm1MSI_equm1MLI_equm1MQI_equm1
Funktionnegative 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_equm1( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_equm1( h_MA:fMatrix; ht, len:UIntSize );
BeschreibungMAi,i = -1
MAi,j = 0,  i != j
QuerverweisMF_equ0,   MF_equ1,   Kap. 3

 
MF_equMblock MD_equMblock ME_equMblock
MCF_equMblock MCD_equMblock MCE_equMblock
MI_equMblockMBI_equMblockMSI_equMblockMLI_equMblockMQI_equMblock
MU_equMblockMUB_equMblockMUS_equMblockMUL_equMblockMUQ_equMblock
FunktionBlock 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMSubi, j = MSrcei+firstRow, j+firstCol,  i=0,...,subHt-1;  j=0,...,subLen-1
QuerverweisMF_block_equM,   MF_equMblockT,   MF_submatrix_equM,   Kap. 5

 
MF_equMblockT MD_equMblockT ME_equMblockT
MCF_equMblockT MCD_equMblockT MCE_equMblockT
MI_equMblockTMBI_equMblockTMSI_equMblockTMLI_equMblockTMQI_equMblockT
MU_equMblockTMUB_equMblockTMUS_equMblockTMUL_equMblockTMUQ_equMblockT
FunktionBlock 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMSubj, i = MSrcei+firstRow, j+firstCol,  i=0,...,subLen-1;  j=0,...,subHt-1
QuerverweisMF_block_equMT,   MF_equMblock,   MF_submatrix_equM,   Kap. 5

 
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
FunktionZwei-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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie 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.ReU0,len/2.ReU0,1.ReU0,1.Im···U0,len/2-1.ReU0,len/2-1.Im
Uht/2,0.ReUht/2,len/2.ReU1,1.ReU1,1.Im···U1,len/2-1.ReU1,len/2-1.Im
U1,0.ReU1,len/2.ReU2,1.ReU2,1.Im···U2,len/2-1.ReU2,len/2-1.Im
U1,0.ImU1,len/2.ImU3,1.ReU3,1.Im···U3,len/2-1.ReU3,len/2-1.Im
·····················
Uht/2-1,0.ReUht/2-1,len/2.Re···············
Uht/2-1,0.ImUht/2-1,len/2.ImUht-1,1.ReUht-1,1.Im···Uht-1,len/2-1.ReUht-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.

FehlerbehandlungFalls 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.
QuerverweisMF_Cols_FFT,   MF_Rows_FFT,   Kap. 12,   Kap. 4.8 von HANDBUCH.HTM

 
MF_fhexprint MD_fhexprint ME_fhexprint
MCF_fhexprint MCD_fhexprint MCE_fhexprint
MI_fhexprintMBI_fhexprintMSI_fhexprintMLI_fhexprintMQI_fhexprint
MU_fhexprintMUB_fhexprintMUS_fhexprintMUL_fhexprintMUQ_fhexprint
FunktionMatrix 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/Delphiuses 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/Delphiuses 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;
BeschreibungDie 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.

FehlerbehandlungFalls 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.
QuerverweisMF_cprint,   MF_fprint,   Kap. 14

 
MF_filter MD_filter ME_filter
MCF_filter MCD_filter MCE_filter
MFb_filter MDb_filter MEb_filter
MCFb_filter MCDb_filter MCEb_filter
FunktionRaumfrequenz-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/Delphiuses 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/Delphiuses 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 );
BeschreibungDer 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.

FehlerbehandlungFalls 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.
QuerverweisMF_FFT,   MF_convolve,   Kap. 12,   Kap. 4.8 of HANDBUCH.HTM

 
M_findDensityMapBounds
FunktionFarbtonskala 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/Delphiuses 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.

QuerverweisMF_xyzAutoDensityMap,   MF_zAutoDensityMap,   Kap. 15

 
MF_fprint MD_fprint ME_fprint
MCF_fprint MCD_fprint MCE_fprint
MI_fprintMBI_fprintMSI_fprintMLI_fprintMQI_fprint
MU_fprintMUB_fprintMUS_fprintMUL_fprintMUQ_fprint
FunktionMatrix 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/Delphiuses 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/Delphiuses 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;
BeschreibungDie 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.

FehlerbehandlungFalls 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.
QuerverweisMF_cprint,   MF_fhexprint,   Kap. 14

 
M_free
FunktionSpeicherplatz einer Matrix freigeben
Syntax C/C++#include <MFstd.h>
void M_free( void **M );
C++ MatObj#include <OptiVec.h>
void matrix<T>::free();
Pascal/Delphiuses MFstd;
procedure M_free( M:Pointer );
CUDA-Funktion C/C++#include <cudaMatLib.h>
int cudaM_free( void **d_M );
CUDA-Funktion Pascal/Delphiuses MFstd;
function cudaM_free( d_M:Pointer ): IntBool;
BeschreibungDie 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.
FehlerbehandlungDer 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.
QuerverweisM_nfree,   V_freeAll,   cudaM_pinnedFree,   MF_matrix,   MF_matrix0

 
M_FtoDM_FtoEM_CFtoCDM_CFtoCE
M_DtoFM_DtoEM_CDtoCFM_CDtoCE
M_EtoFM_EtoDM_CEtoCFM_CEtoCD
FunktionDatentyp-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/Delphiuses 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/Delphiuses 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 );
BeschreibungJedes Element von MX wird aus dem für MX spezifizierten Datentyp in denjenigen für MY umgewandelt und in MY gespeichert.
FehlerbehandlungOVERFLOW-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.
QuerverweisKap. 4

 
MF_getElement MD_getElement ME_getElement
MCF_getElement MCD_getElement MCE_getElement
MI_getElementMBI_getElementMSI_getElementMLI_getElementMQI_getElement
MU_getElementMUB_getElementMUS_getElementMUL_getElementMUQ_getElement
FunktionLese-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/Delphiuses 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/Delphiuses 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 );
BeschreibungDas Element MAm,n wird in die durch RetVal spezifizierte Speicherstelle kopiert.
Rückgabewertnone
QuerverweisMF_setElement,   MF_Pelement,   Kap. 2

 
VF_getLinfitNeglect VD_getLinfitNeglect VE_getLinfitNeglect
Funktionaktuelle 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/Delphiuses MFstd;
function VF_getLinfitNeglect:Single;
BeschreibungIntern 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ückgabewertderzeit eingestellte Signifikanz-Schwelle für Datenanpassung an lineare Modelle
QuerverweisVF_linfit,   VF_multiLinfit,   Kap. 13.2

 
VF_getNonlinfitOptions VD_getNonlinfitOptions VE_getNonlinfitOptions
VF_getNonlinfitDefaultOptions VD_getNonlinfitDefaultOptions VE_getNonlinfitDefaultOptions
Funktionderzeit 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/Delphiuses MFstd;
procedure VF_getNonlinfitOptions( var Options: VF_NONLINFITOPTIONS );
procedure VF_getNonlinfitDefaultOptions( var Options: VF_NONLINFITOPTIONS );
BeschreibungDie 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.
QuerverweisKap. 13.3

 
MF_Hann MD_Hann ME_Hann
Funktionzwei-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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Hann( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Hann( h_MA:fMatrix; ht, len:UIntSize );
BeschreibungMAi,j = 0.25 * (1 - cos( 2 p i / (ht-1) )) * (1 - cos( 2 p j / (len-1) ))
QuerverweisMF_Parzen,   MF_Welch,   MF_spectrum

 
MCF_hermconj MCD_hermconj MCE_hermconj
FunktionHermitesch-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/Delphiuses 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/Delphiuses MCFstd;
function cudaMCF_hermconj( d_MTr, d_MA:cfMatrix; htTr, lenTr:UIntSize ): IntBool;
procedure MCFcu_hermconj( h_MTr, h_MA:cfMatrix; htTr, lenTr:UIntSize );
BeschreibungDie 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.
QuerverweisMCF_transpose,   MCF_conj,   Kap. 5

 
MCF_HmulM MCD_HmulM MCE_HmulM
FunktionHermitesch-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/Delphiuses 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/Delphiuses 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 );
BeschreibungMC = 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.
QuerverweisMCF_hermconj,   MCF_mulMH,   MF_TmulM,   Kap. 9

 
MF_hexprint MD_hexprint ME_hexprint
MCF_hexprint MCD_hexprint MCE_hexprint
MI_hexprintMBI_hexprintMSI_hexprintMLI_hexprintMQI_hexprint
MU_hexprintMUB_hexprintMUS_hexprintMUL_hexprintMUQ_hexprint
FunktionMatrix 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/Delphiuses 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/Delphiuses 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;
BeschreibungDie 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.

QuerverweisVF_hexprint,   MF_chexprint,   MF_print,   MF_fhexprint,   Kap. 14

 
MF_inv MD_inv ME_inv
MCF_inv MCD_inv MCE_inv
MF_invwEdit MD_invwEdit ME_invwEdit
MCF_invwEdit MCD_invwEdit MCE_invwEdit
   
MFb_inv MDb_inv MEb_inv
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
FunktionMatrix-Inversion
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/Delphiuses 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;
BeschreibungDie 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ückgabewertBedeutung
0Matrix MA ist regulär und konnte erfolgreich invertiert werden
1Matrix MA ist singulär; Ergebnis MInv komplett unbrauchbar
2Matrix 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ückgabewertEin Code 0, 1 oder 2; siehe oben
QuerverweisKap. 10

 
MF_LequU MD_LequU ME_LequU
MCF_LequU MCD_LequU MCE_LequU
MI_LequUMBI_LequUMSI_LequUMLI_LequUMQI_LequU
MU_LequUMUB_LequUMUS_LequUMUL_LequUMUQ_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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_LequU( d_MA:fMatrix; len:UIntSize ): IntBool;
procedure MFcu_LequU( h_MA:fMatrix; len:UIntSize );
BeschreibungMAi,j = MAj,i,  i > j
QuerverweisMF_UequL,   Kap. 3

 
MF_lincomb MD_lincomb ME_lincomb
MCF_lincomb MCD_lincomb MCE_lincomb
FunktionLinearkombination 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMC = CA * MA + CB * MB
QuerverweisMF_Rows_lincomb,   Kap. 9

 
VF_linfit VD_linfit VE_linfit
VF_linfitwW VD_linfitwW VE_linfitwW
FunktionDatenanpassung 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/Delphiuses 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;
BeschreibungDie 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:
AVektor der Länge npars; gibt die berechneten Koeffizienten zurück
CovarMatrix 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.
AStatusVektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind
nparsGesamtzahl der Parameter
X, Y, InvVarVektoren der Länge sizex mit den Eingabe-Daten
funcsBenutzer-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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (!= 0).
QuerverweisMF_linfit,   VF_nonlinfit,   Kap. 13,  FITDEMO*.*

 
MF_linfit MD_linfit ME_linfit
MF_linfitwW MD_linfitwW ME_linfitwW
FunktionDatenanpassung 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/Delphiuses 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;
BeschreibungDie 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:
AVektor der Länge npars; gibt die berechneten Koeffizienten zurück
CovarMatrix 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.
AStatusVektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind
nparsGesamtzahl der Parameter
X, YVektoren der Länge lenZbzw. htZ, die das X-Y-Koordinatensystem der Matrix Z aufspannen
MZ, MInvVarMatrizen der Dimensionen [htZ, lenZ] mit den Eingabedaten sowie, bei der gewichteten Variante, dem Kehrwert von deren Varianzen
funcsBenutzer-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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (!= 0).
QuerverweisVF_linfit,   MF_nonlinfit,   Kap. 13,  FITDEMO*.*

 
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
FunktionLU-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/Delphiuses 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;
BeschreibungMA 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ückgabewertBedeutung
0Matrix singulär, Ergebnis komplett unbrauchbar
+1Matrix erfolgreich zerlegt; gerade Anzahl von Permutationen
-1Matrix erfolgreich zerlegt; ungerade Anzahl von Permutationen
+2Matrix nahezu singulär; konnte durch Pivot-Editierung zerlegt werden; Ergebnis nur teilweise brauchbar; gerade Anzahl von Permutationen
+2Matrix 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!).

FehlerbehandlungIm 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ückgabewertCode 0, +-1 oder +-2, der Erfolg sowie gerade oder ungerade Anzahl von Zeilen-Permutationen anzeigt, s.o.
QuerverweisKap. 10

 
MF_LUdet MD_LUdet ME_LUdet
MCF_LUdet MCD_LUdet MCE_LUdet
FunktionDeterminante 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/Delphiuses MFstd;
function MF_LUdet( MLU:fMatrix; len:UIntSize; permut:Integer ): Single;
BeschreibungMF_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.
RückgabewertDeterminante
QuerverweisMF_det,   Kap. 10

 
MF_LUimprove MD_LUimprove ME_LUimprove
MCF_LUimprove MCD_LUimprove MCE_LUimprove
   
MFb_LUimprove MDb_LUimprove MEb_LUimprove
MCFb_LUimprove MCDb_LUimprove MCEb_LUimprove
Funktioniterative 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/Delphiuses 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 );
BeschreibungVor 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.

QuerverweisKap. 10

 
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
FunktionInvertierung 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/Delphiuses 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;
BeschreibungMF_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!).

QuerverweisKap. 10

 
MF_LUDgetEdit MD_LUDgetEdit ME_LUDgetEdit
MCF_LUgetEdit MCD_LUgetEdit MCE_LUgetEdit
FunktionEditierungs-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/Delphiuses MFstd;
function MF_LUDgetEdit: Single;
BeschreibungDerzeit eingestellte Schwelle für Pivot-Editierung bei MF_LUdecompose,   MF_inv und MF_solve lesen. Die Schwelle kann mit MF_LUDsetEdit modifiziert werden.
QuerverweisKap. 10

 
MF_LUDresult MD_LUDresult ME_LUDresult
MCF_LUDresult MCD_LUDresult MCE_LUDresult
Funktionprü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/Delphiuses MFstd;
function MF_LUDresult: IntBool;
BeschreibungNach 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.
Rückgabewertsee above
QuerverweisKap. 10

 
MF_LUDsetEdit MD_LUDsetEdit ME_LUDsetEdit
MCF_LUDsetEdit MCD_LUDsetEdit MCE_LUDsetEdit
FunktionSchwelle 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/Delphiuses MFstd;
procedure MF_LUDsetEdit( Thresh:Single );
procedure MCF_LUDsetEdit( Thresh:Single );
BeschreibungMit 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.
QuerverweisKap. 10

 
MF_LUsolve MD_LUsolve ME_LUsolve
MCF_LUsolve MCD_LUsolve MCE_LUsolve
Funktionlineares 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/Delphiuses MFstd;
procedure MF_LUsolve( X:fVector; MLU:fMatrix; B:fVector; Ind:uiVector; len:UIntSize );
BeschreibungDas 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.
QuerverweisKap. 10

 
MF_matrix MD_matrix ME_matrix
MCF_matrix MCD_matrix MCE_matrix
MI_matrixMBI_matrixMSI_matrixMLI_matrixMQI_matrix
MU_matrixMUB_matrixMUS_matrixMUL_matrixMUQ_matrix
FunktionSpeicherzuweisung für eine Matrix
Syntax C/C++#include <MFstd.h>
fMatrix MF_matrix( ui ht, ui len );
Pascal/Delphiuses 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/Delphiuses MFstd;
function cudaMF_matrix( ht, len:UIntSize ): fMatrix;
BeschreibungJe 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.
FehlerbehandlungFalls 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ückgabewertC/C++: Zeiger auf das Feld von Zeilen-Zeigern
Pascal/Delphi: Zeiger auf den zugewiesenen Speicher
QuerverweisMF_matrix0,   VF_vector,   cudaMF_pinnedMatrix,   Kap. 2

 
MF_matrix0 MD_matrix0 ME_matrix0
MCF_matrix0 MCD_matrix0 MCE_matrix0
MI_matrix0MBI_matrix0MSI_matrix0MLI_matrix0MQI_matrix0
MU_matrix0MUB_matrix0MUS_matrix0MUL_matrix0MUQ_matrix0
FunktionSpeicherzuweisung für eine Matrix und Initialisierung aller Elemente mit 0
Syntax C/C++#include <MFstd.h>
fMatrix F_matrix0( ui ht, ui len );
Pascal/Delphiuses 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/Delphiuses MFstd;
function cudaMF_matrix0( ht, len:UIntSize ): fMatrix;
BeschreibungDie 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.
FehlerbehandlungFalls 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ückgabewertC/C++: Zeiger auf das Feld von Zeilen-Zeigern
Pascal/Delphi: Zeiger auf den zugewiesenen Speicher
QuerverweisMF_matrix,   VF_vector0,   cudaMF_pinnedMatrix0,   Kap. 2

 
MF_MatrixTo2DArray MD_MatrixTo2DArray ME_MatrixTo2DArray
MCF_MatrixTo2DArray MCD_MatrixTo2DArray MCE_MatrixTo2DArray
MI_MatrixTo2DArrayMBI_MatrixTo2DArrayMSI_MatrixTo2DArrayMLI_MatrixTo2DArrayMQI_MatrixTo2DArray
MU_MatrixTo2DArrayMUB_MatrixTo2DArrayMUS_MatrixTo2DArrayMUL_MatrixTo2DArrayMUQ_MatrixTo2DArray
FunktionOptiVec-Matrix in 2D-Array von Delphi 4 oder höher konvertieren
Syntax C/C++N.A.
Pascal/Delphiuses VecLib, MFstd;
type fArray = array of Single;
type f2DArray = array of fArray;
procedure MF_MatrixTo2DArray( DelphiArr:f2DArray; MF:fMatrix; ht,len:UIntSize);
BeschreibungDiese 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.
QuerverweisMF_2DArrayToMatrix,   Kap. 1.4

 
MF_mulC MD_mulC ME_mulC
MCF_mulC MCD_mulC MCE_mulC
MCF_mulReC MCD_mulReC MCE_mulReC
Funktionalle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMBij = MAij + C
QuerverweisMF_mulV,   MF_mulM,   Kap. 9

 
VF_mulM VD_mulM VE_mulM
FunktionZeilen-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/Delphiuses 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/Delphiuses 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 );
BeschreibungY = X * MA;
Die Dimensionen von X und Y sind implizit durch die Matrix-Dimensionen gegeben: sizX = htA, sizY = lenA.
QuerverweisMF_mulV,   MF_mulM,   Kap. 9

 
MF_mulM MD_mulM ME_mulM
MCF_mulM MCD_mulM MCE_mulM
FunktionMatrix-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/Delphiuses 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/Delphiuses 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 );
BeschreibungMC = MA * MB
htA, lenA und lenB müssen spezifiziert werden; die übrigen Dimensionen sind implizit gegeben als: htB = lenA, lenC = lenB, htC = htA.
QuerverweisMF_mulMT,   MF_TmulM,   VF_mulM,   Kap. 9

 
MFdia_mulM MDdia_mulM MEdia_mulM
MCFdia_mulM MCDdia_mulM MCEdia_mulM
FunktionMultiplikation 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMC = 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.
QuerverweisMFdia_mulMT,   Kap. 9

 
MF_mulMdia MD_mulMdia ME_mulMdia
MCF_mulMdia MCD_mulMdia MCE_mulMdia
Funktionallgemeine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMC = MA * MBDia.
htA und lenA müssen spezifiziert werden; sizB = lenA.
QuerverweisMFdia_mulM,   MF_TmulMdia,   Kap. 9

 
MCF_mulMH MCD_mulMH MCE_mulMH
Funktioneine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMC = MA * MBT *.
htA, lenA und htB müssen spezifiziert werden; die übrigen Dimensionen sind implizit gegeben als: lenB = lenA, lenC = htB, htC = htA.
QuerverweisMCF_hermconj,   MF_mulMT,   MCF_HmulM,   Kap. 9

 
MF_mulMT MD_mulMT ME_mulMT
MCF_mulMT MCD_mulMT MCE_mulMT
Funktioneine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMC = MA * MBT.
htA, lenA und htB müssen spezifiziert werden; die übrigen Dimensionen sind implizit gegeben als: lenB = lenA, lenC = htB, htC = htA.
QuerverweisMF_mulM,   MF_TmulM,   VF_mulMT,   Kap. 9

 
MFdia_mulMT MDdia_mulMT MEdia_mulMT
MCFdia_mulMT MCDdia_mulMT MCEdia_mulMT
FunktionDiagonalmatrix 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMC = MADia * MBT
htB und lenB müssen spezifiziert werden; sizA = lenB.
QuerverweisMFdia_mulM,   Kap. 9

 
VF_mulMT VD_mulMT VE_mulMT
FunktionZeilen-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/Delphiuses 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/Delphiuses 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 );
BeschreibungY = 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.
QuerverweisVF_mulM,   MF_mulV,   Kap. 9

 
VF_multiLinfit VD_multiLinfit VE_multiLinfit
VF_multiLinfitwW VD_multiLinfitwW VE_multiLinfitwW
Funktionaus 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/Delphiuses 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;
BeschreibungDie 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:
AVektor der Länge npars; gibt die berechneten Koeffizienten zurück
CovarMatrix 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.
AStatusVektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind
nparsGesamtzahl der Parameter
ListOfExperimentsEingabedaten, siehe Kap. 13.4
nexperimentsAnzahl der Datensätze in ListOfExperiments
modelfuncBenutzer-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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (!= 0).
QuerverweisMF_linfit,   VF_nonlinfit,   Kap. 13,  FITDEMO*.*

 
MF_multiLinfit MD_multiLinfit ME_multiLinfit
MF_multiLinfitwW MD_multiLinfitwW ME_multiLinfitwW
Funktionaus 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/Delphiuses 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;
BeschreibungDie 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:
AVektor der Länge npars; gibt die berechneten Koeffizienten zurück
CovarMatrix 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.
AStatusVektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind
nparsGesamtzahl der Parameter
ListOfExperimentsEingabedaten, siehe Kap. 13.4
nexperimentsAnzahl der Datensätze in ListOfExperiments
modelfuncBenutzer-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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (!= 0).
QuerverweisMF_linfit,   MF_nonlinfit,   MF_multiNonlinfit,   Kap. 13,  FITDEMO*.*

 
VF_multiNonlinfit VD_multiNonlinfit VE_multiNonlinfit
VF_multiNonlinfitwW VD_multiNonlinfitwW VE_multiNonlinfitwW
Funktionaus 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/Delphiuses 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 simplifieduses 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;
BeschreibungDie in ListOfExperiments enthaltenen Eingabe-Daten werden benutzt, um die Parameter ai einer allgemeinen nicht-linearen Modell-Funktion y = f(x) zu bestimmen.

Argumente:
AVektor der Länge npars; gibt die berechneten Koeffizienten zurück
CovarMatrix der Dimensionen [npars, npars]; gibt die Kovarianzen der Koeffizenten zurück
AStatusVektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind
nparsGesamtzahl der Parameter
ListOfExperimentsEingabedaten, siehe Kap. 13.4
nexperimentsAnzahl der Datensätze in ListOfExperiments
modelfuncBenutzer-definierte Modell-Funktion
derivativesBenutzer-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.
FitOptsZeiger auf eine Struktur mit Fit-Optionen, siehe chap. 13.3
WorkSpaceZeiger 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-threadingDie 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ückgabewertBei Erfolg: Anpassungstest-Wert c2 (chi-Quadrat)
Wenn keine Verbesserung des Parametersatzes erzielt werden konnte: -1
QuerverweisVF_setNonlinfitOptions,   MF_multiNonlinfit,   VF_linfit,   Kap. 13,  FITDEMO*.*

 
VF_multiNonlinfit_... VD_multiNonlinfit_... VE_multiNonlinfit_...
VF_multiNonlinfitwW_... VD_multiNonlinfitwW_... VE_multiNonlinfitwW_...
..._autoDeriv
..._getFOM
..._getFOMDetail
..._getBestValues
..._getTestRun
..._getTestPar
..._getTestDir
..._stop
FunktionHilfs- und Überwachungs-Funktionen für VF_multiNonlinfit und VF_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/Delphiuses 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)
BeschreibungVF_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.

QuerverweisKap. 13

 
MF_multiNonlinfit MD_multiNonlinfit ME_multiNonlinfit
MF_multiNonlinfitwW MD_multiNonlinfitwW ME_multiNonlinfitwW
Funktionaus 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/Delphiuses 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 vereinfachtuses 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;
BeschreibungDie 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:
AVektor der Länge npars; gibt die berechneten Koeffizienten zurück
CovarMatrix der Dimensionen [npars, npars]; gibt die Kovarianzen der Koeffizenten zurück
AStatusVektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind
nparsGesamtzahl der Parameter
ListOfExperimentsEingabedaten, siehe Kap. 13.4
nexperimentsAnzahl der Datensätze in ListOfExperiments
modelfuncBenutzer-definierte Modell-Funktion
derivativesBenutzer-definierte Funktion, die die partiellen Ableitungen der Modellfunktion nach den einzelnen Parametern berechnet
FitOptsZeiger auf eine Struktur mit Fit-Optionen, siehe chap. 13.3
WorkSpaceZeiger 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-threadingDie 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ückgabewertBei Erfolg: Anpassungstest-Wert c2 (chi-Quadrat)
Wenn keine Verbesserung des Parametersatzes erzielt werden konnte: -1
QuerverweisVF_setNonlinfitOptions,   VF_multiNonlinfit,   MF_linfit,   Kap. 13,  FITDEMO*.*

 
MF_multiNonlinfit_... MD_multiNonlinfit_... ME_multiNonlinfit_...
MF_multiNonlinfitwW_... MD_multiNonlinfitwW_... ME_multiNonlinfitwW_...
..._autoDeriv
..._getFOM
..._getFOMDetail
..._getBestValues
..._getTestRun
..._getTestPar
..._getTestDir
..._stop
FunktionHilfs- und Überwachungs-Funktionen für MF_multiNonlinfit und MF_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/Delphiuses 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)
BeschreibungMF_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.

QuerverweisKap. 13

 
MF_mulV MD_mulV ME_mulV
MCF_mulV MCD_mulV MCE_mulV
FunktionMatrix 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/Delphiuses 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/Delphiuses 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 );
BeschreibungY = MA * X
Die Dimensionen von X und Y sind implizit gegeben durch die Matrix-Dimensionen: sizX = lenA, sizY = htA.
QuerverweisMF_TmulV,   VF_mulM,   Kap. 9

 

MF_natCubSplineInterpolMD_natCubSplineInterpolME_natCubSplineInterpol
Funktionnatü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/Delphiuses 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/Delphiuses 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 );
BeschreibungFür jedes der htlen 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.
Fehlerbehandlungkeine (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.)
Rückgabewertkeiner
QuerverweisMF_ratinterpol,   MF_polyinterpol,   VF_natCubSplineInterpol

 
MF_neg MD_neg ME_neg
MCF_neg MCD_neg MCE_neg
MI_negMBI_negMSI_negMLI_negMQI_neg
FunktionNegation
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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_neg( d_MB, d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_neg( h_MB, h_MA:fMatrix; ht, len:UIntSize );
BeschreibungMBi,j = -MAi,j
QuerverweisMCF_conj,   Kap. 3

 
M_nfree
FunktionSpeicher mehrerer Matrizen freigeben (nur C/C++)
Syntax C/C++#include <MFstd.h>
void M_nfree( unsigned numfree, ... );
Pascal/DelphiDiese Funktion existiert nicht
CUDA-Funktion C/C++#include <cudaMatLib.h>
int cudaM_nfree( unsigned numfree, ... );
BeschreibungDer 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 );
QuerverweisM_free,   V_freeAll,   Kap. 2

 
VF_nonlinfit VD_nonlinfit VE_nonlinfit
VF_nonlinfitwW VD_nonlinfitwW VE_nonlinfitwW
Funktionnicht-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/Delphiuses 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 vereinfachtuses 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;
BeschreibungDie 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:
AVektor der Länge npars; gibt die berechneten Koeffizienten zurück
CovarMatrix der Dimensionen [npars, npars]; gibt die Kovarianzen der Koeffizenten zurück
AStatusVektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind
nparsGesamtzahl der Parameter
X, Y, InvVarVektoren der Länge sizex mit den Eingabe-Daten sowie, bei der gewichteten Variante, dem Kehrwert von deren Varianzen
modelfuncBenutzer-definierte Modell-Funktion
derivativesBenutzer-definierte Funktion, die die partiellen Ableitungen der Modellfunktion nach den einzelnen Parametern berechnet
FitOptsZeiger auf eine Struktur mit Anpassungs-Optionen, siehe chap. 13.3
WorkSpaceZeiger 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-threadingDie 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ückgabewertBei Erfolg: Anpassungstest-Wert c2 (chi-Quadrat)
Wenn keine Verbesserung des Parametersatzes erzielt werden konnte: -1
QuerverweisVF_setNonlinfitOptions,   MF_nonlinfit,   VF_linfit,   Kap. 13,  FITDEMO*.*

 
VF_nonlinfit_... VD_nonlinfit_... VE_nonlinfit_...
VF_nonlinfitwW_... VD_nonlinfitwW_... VE_nonlinfitwW_...
..._autoDeriv
..._getFOM
..._getBestValues
..._getTestRun
..._getTestPar
..._getTestDir
..._stop
FunktionHilfsfunktionen für VF_nonlinfit und VF_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/Delphiuses 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)
BeschreibungVF_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.

QuerverweisKap. 13

 
MF_nonlinfit MD_nonlinfit ME_nonlinfit
MF_nonlinfitwW MD_nonlinfitwW ME_nonlinfitwW
Funktionnicht-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/Delphiuses 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 vereinfachtuses 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;
BeschreibungDie 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:
AVektor der Länge npars; gibt die berechneten Koeffizienten zurück
CovarMatrix der Dimensionen [npars, npars]; gibt die Kovarianzen der Koeffizenten zurück
AStatusVektor der Länge npars; entscheidet darüber, welche Parameter frei oder eingefroren sind
nparsGesamtzahl der Parameter
X, YVektoren der Länge lenZbzw. htZ, die das X-Y-Koordinatensystem der Matrix Z aufspannen
MZ, MInvVarMatrizen der Dimensionen [htZ, lenZ] mit den Eingabedaten sowie, bei der gewichteten Variante, dem Kehrwert von deren Varianzen
modelfuncBenutzer-definierte Modell-Funktion
derivativesBenutzer-definierte Funktion, die die partiellen Ableitungen der Modellfunktion nach den einzelnen Parametern berechnet
FitOptsZeiger auf eine Struktur mit Anpassungs-Optionen, siehe chap. 13.3
WorkSpaceZeiger 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-threadingDie 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ückgabewertBei Erfolg: Anpassungstest-Wert c2 (chi-Quadrat)
Wenn keine Verbesserung des Parametersatzes erzielt werden konnte: -1
QuerverweisVF_setNonlinfitOptions,   VF_nonlinfit,   MF_multiNonlinfit,   MF_linfit,   Kap. 13,  FITDEMO*.*

 
MF_nonlinfit_... MD_nonlinfit_... ME_nonlinfit_...
MF_nonlinfitwW_... MD_nonlinfitwW_... ME_nonlinfitwW_...
..._autoDeriv
..._getFOM
..._getBestValues
..._getTestRun
..._getTestPar
..._getTestDir
..._stop
FunktionHilfsfunktionen für MF_nonlinfit und MF_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/Delphiuses 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)
BeschreibungMF_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.

QuerverweisKap. 13

 
MF_outerprod MD_outerprod ME_outerprod
MCF_outerprod MCD_outerprod MCE_outerprod
MI_outerprodMBI_outerprodMSI_outerprodMLI_outerprodMQI_outerprod
MU_outerprodMUB_outerprodMUS_outerprodMUL_outerprodMUQ_outerprod
FunktionBildung 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,j = Xi * Yj
QuerverweisVF_mulM,   Kap. 3

 
MF_Parzen MD_Parzen ME_Parzen
Funktionzwei-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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Parzen( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Parzen( h_MA:fMatrix; ht, len:UIntSize );
BeschreibungMAi,j = (1 - |(i - 0.5*(ht - 1)) / 0.5*(ht + 1)|) * (1 - |(j - 0.5*(len - 1)) / 0.5*(len + 1)|)
QuerverweisMF_Hann,   MF_Welch,   MF_spectrum

 
MF_Pelement MD_Pelement ME_Pelement
MCF_Pelement MCD_Pelement MCE_Pelement
MI_PelementMBI_PelementMSI_PelementMLI_PelementMQI_Pelement
MU_PelementMUB_PelementMUS_PelementMUL_PelementMUQ_Pelement
FunktionZeiger 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Pelement( d_MA:fMatrix; ht, len, m, n:UIntSize ): PSingle;
BeschreibungEin 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/DelphiMF_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ückgabewertZeiger auf das Matrix-Element MAm,n
QuerverweisMF_element,   MF_getElement,   MF_setElement,   Kap. 2

 

cudaM_pinnedFree
FunktionNur 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/Delphiuses VecLib;
function cudaM_pinnedFree( h_X:Pointer ): IntBool;
BeschreibungDie "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).
FehlerbehandlungDer 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ückgabewertFALSE (0) bei Erfolg, sonst TRUE (nicht-Null)
QuerverweisCudaOptiVecD.htm, Kap. 3,   cudaM_pinnedNfree,   cudaV_pinnedFreeAll,   cudaMF_pinnedMatrix

 
cudaMF_pinnedMatrix cudaMD_pinnedMatrix cudaME_pinnedMatrix
cudaMCF_pinnedMatrix cudaMCD_pinnedMatrix cudaMCE_pinnedMatrix
cudaMI_pinnedMatrixcudaMBI_pinnedMatrixcudaMSI_pinnedMatrix
cudaMLI_pinnedMatrixcudaMQI_pinnedMatrix 
cudaMU_pinnedMatrixcudaMUB_pinnedMatrixcudaMUS_pinnedMatrix
cudaMUL_pinnedMatrixcudaMUQ_pinnedMatrixcudaMUI_pinnedMatrix
FunktionErzeugung 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/Delphiuses VecLib;
function cudaMF_pinnedMatrix( var h_MA:fMatrix; ht, len:UIntSize ): fMatrix;
BeschreibungHost-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.
FehlerbehandlungFalls nicht genug Speicher vorhanden ist, oder im Falle von size=0, wird eine Fehlermeldung "Not enough memory" ausgegeben und das Programm abgebrochen.
RückgabewertDevice-Zeiger auf den reservierten Speicherbereich
QuerverweisCudaOptiVecD.htm, Kap. 3,   cudaMF_pinnedMatrix0,   cudaVF_pinnedVector,  

 
cudaMF_pinnedMatrix0 cudaMD_pinnedMatrix0 cudaME_pinnedMatrix0
cudaMCF_pinnedMatrix0 cudaMCD_pinnedMatrix0 cudaMCE_pinnedMatrix0
cudaMI_pinnedMatrix0cudaMBI_pinnedMatrix0cudaMSI_pinnedMatrix0
cudaMLI_pinnedMatrix0cudaMQI_pinnedMatrix0 
cudaMU_pinnedMatrix0cudaMUB_pinnedMatrix0cudaMUS_pinnedMatrix0
cudaMUL_pinnedMatrix0cudaMUQ_pinnedMatrix0cudaMUI_pinnedMatrix0
FunktionReservierung 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/Delphiuses VecLib;
function cudaMF_pinnedMatrix0( var h_MA:fMatrix0; ht, len:UIntSize ): fMatrix0;
BeschreibungHost-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.
FehlerbehandlungFalls nicht genug Speicher vorhanden ist, oder im Falle von size=0, wird eine Fehlermeldung "Not enough memory" ausgegeben und das Programm abgebrochen.
RückgabewertDevice-Zeiger auf den reservierten Speicherbereich
QuerverweisCudaOptiVecD.htm, Kap. 3,   cudaMF_pinnedMatrix,   cudaVF_pinnedVector0,  

 

cudaM_pinnedNfree
FunktionDe-Allocation mehrerer "pinned" Host-Memory Matrizen
CUDA-Funktion C/C++#include <cudaMatLib.h>
int cudaV_pinnedNfree( unsigned numfree, ... );
BeschreibungDer 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ückgabewertFALSE (0) bei Erfolg, sonst TRUE (nicht-Null)
QuerverweisCudaOptiVecD.htm, Kap. 3,   cudaV_pinnedFree,   cudaV_pinnedFreeAll,   cudaVF_pinnedVector,   cudaVF_pinnedVector0

 
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
FunktionPolynom-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/Delphiuses 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
BeschreibungDie 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:
AVektor der Länge deg+1; gibt die berechneten Koeffizienten zurück
CovarMatrix 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.
degGrad des Fit-Polynoms
X, Y, InvVarVektoren 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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (!= 0).
QuerverweisVF_linregress,   VF_linfit,   VF_chi2,   Kap. 13

 

MF_polyinterpolMD_polyinterpolME_polyinterpol
FunktionPolynom-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/Delphiuses 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/Delphiuses 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 );
BeschreibungFür jedes der htlen 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.
FehlerbehandlungWerte 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.)
Rückgabewertkeiner
QuerverweisMF_ratinterpol,   MF_natCubSplineInterpol,   VF_polyinterpol

 
MF_print MD_print ME_print
MCF_print MCD_print MCE_print
MI_printMBI_printMSI_printMLI_printMQI_print
MU_printMUB_printMUS_printMUL_printMUQ_print
FunktionMatrix 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/Delphiuses 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/Delphiuses 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;
BeschreibungDie 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.

QuerverweisVF_print,   MF_cprint,   MF_hexprint,   MF_fprint,   Kap. 14

 
MF_random MD_random ME_random
MCF_random MCD_random MCE_random
MI_randomMBI_randomMSI_randomMLI_randomMQI_random
MU_randomMUB_randomMUS_randomMUL_randomMUQ_random
FunktionMatrix 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/Delphiuses 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/Delphiuses 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;
BeschreibungDie 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.

Fehlerbehandlungkeine
Rückgabewertletzte intern generierte 32-bit-Zufallszahl; kann als neuer Startwert für spätere Aufrufe verwandt werden
QuerverweisVF_random,   Kap. 3

 
MF_randomLC MD_randomLC ME_randomLC
MCF_randomLC MCD_randomLC MCE_randomLC
MI_randomLCMBI_randomLCMSI_randomLCMLI_randomLCMQI_randomLC
MU_randomLCMUB_randomLCMUS_randomLCMUL_randomLCMUQ_randomLC;
FunctionMatrix 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/Delphiuses 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/Delphiuses 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;
BeschreibungDie 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.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_randomLC,   Kap. 3

 

MF_ratinterpolMD_ratinterpolME_ratinterpol
Funktiondiagonal-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/Delphiuses 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/Delphiuses 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 );
BeschreibungFür jedes der htlen 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.
FehlerbehandlungEine 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.)
Rückgabewertkeiner
QuerverweisMF_polyinterpol,   MF_natCubSplineInterpol,   VF_ratinterpol

 
MF_read MD_read ME_read
MCF_read MCD_read MCE_read
MI_readMBI_readMSI_readMLI_readMQI_read
MU_readMUB_readMUS_readMUL_readMUQ_read
Funktioneine 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/Delphiuses 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/Delphiuses 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;
BeschreibungDie 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.

FehlerbehandlungC/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ückgabewertkeiner, außCUDA-Variante; dort: 0, wenn fehlerfrei, sonst ungleich 0
QuerverweisMF_write,   VF_nread,   MF_store,   MF_recall,   Kap. 14

 
MF_recall MD_recall ME_recall
MCF_recall MCD_recall MCE_recall
MI_recallMBI_recallMSI_recallMLI_recallMQI_recall
MU_recallMUB_recallMUS_recallMUL_recallMUQ_recall
FunktionMatrix 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/Delphiuses 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/Delphiuses 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;
BeschreibungDie 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-SicherheitVerschiedene 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.
Fehlerbehandlungwird durch die C-Funktion fread bzw. die Delphi-Funktion BlockRead durchgeführt, auf der MF_recall etc. basieren
Rückgabewert0, wenn fehlerfrei; ansonsten 1. Um mehr Information im Falle eines Fehlers zu erhalten, inspiziere man errno (C/C++) oder IOResult (Delphi).
QuerverweisMF_store,   Kap. 14

 
MF_rotate90 MD_rotate90 ME_rotate90
MCF_rotate90 MCD_rotate90 MCE_rotate90
MI_rotate90MBI_rotate90MSI_rotate90MLI_rotate90MQI_rotate90
MU_rotate90MUB_rotate90MUS_rotate90MUL_rotate90MUQ_rotate90
FunktionRotation 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_rotate90( d_MRot, MA:fMatrix; htRot, lenRot:UIntSize ): IntBool;
procedure MFcu_rotate90( h_MRot, h_MA:fMatrix; htRot, lenRot:UIntSize );
BeschreibungMRoti,j = MAlenRot-j-1, i
Die Dimensionen htRot und lenRot beziehen sich auf die Ausgabe-Matrix, nicht auf die Eingabe-Matrix.
QuerverweisMF_rotate180,   MF_rotate270   MF_transpose,   MF_Rows_rev   MF_Cols_rev   Kap. 9,   Kap. 5

 
MF_rotate180 MD_rotate180 ME_rotate180
MCF_rotate180 MCD_rotate180 MCE_rotate180
MI_rotate180MBI_rotate180MSI_rotate180MLI_rotate180MQI_rotate180
MU_rotate180MUB_rotate180MUS_rotate180MUL_rotate180MUQ_rotate180
FunktionRotation 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_rotate180( d_MRot, MA:fMatrix; htRot, lenRot:UIntSize ): IntBool;
procedure MFcu_rotate180( h_MRot, h_MA:fMatrix; htRot, lenRot:UIntSize );
BeschreibungMRoti,j = MAht-i-1, len-j-1
QuerverweisMF_rotate90,   MF_rotate270   MF_transpose,   MF_Rows_rev   MF_Cols_rev   Kap. 9,   Kap. 5

 
MF_rotate270 MD_rotate270 ME_rotate270
MCF_rotate270 MCD_rotate270 MCE_rotate270
MI_rotate270MBI_rotate270MSI_rotate270MLI_rotate270MQI_rotate270
MU_rotate270MUB_rotate270MUS_rotate270MUL_rotate270MUQ_rotate270
FunktionRotation 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_rotate270( d_MRot, MA:fMatrix; htRot, lenRot:UIntSize ): IntBool;
procedure MFcu_rotate270( h_MRot, h_MA:fMatrix; htRot, lenRot:UIntSize );
BeschreibungMRoti,j = MAj, htRot-i-1
Die Dimensionen htRot und lenRot beziehen sich auf die Ausgabe-Matrix, nicht auf die Eingabe-Matrix.
QuerverweisMF_rotate90,   MF_rotate180   MF_transpose,   MF_Rows_rev   MF_Cols_rev   Kap. 9,   Kap. 5

 
MF_Row_addC MD_Row_addC ME_Row_addC
MCF_Row_addC MCD_Row_addC MCE_Row_addC
FunktionKonstante 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAiRow,i += C,  i=0,...,len-1
QuerverweisMF_Col_addC,   MF_Dia_addC,   Kap. 6

 
MF_Row_addV MD_Row_addV ME_Row_addV
MCF_Row_addV MCD_Row_addV MCE_Row_addV
FunktionElement-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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAiRow,i += Xi,  i=0,...,len-1
QuerverweisMF_Col_addV,   MF_Dia_addV,   Kap. 6

 
MCF_Row_conj MCD_Row_conj MCE_Row_conj
FunktionKomplex-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/Delphiuses 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/Delphiuses MCFstd;
function cudaMCF_Row_conj( d_MA:cfMatrix; ht, len, iRow:UIntSize ): IntBool;
procedure MCFcu_Row_conj( h_MA:cfMatrix; ht, len, iRow:UIntSize );
BeschreibungMAiRow,i = MA*iRow,i,  i=0,...,len-1
QuerverweisMF_Row_neg, Kap. 6

 
MF_Row_delete MD_Row_delete ME_Row_delete
MCF_Row_delete MCD_Row_delete MCE_Row_delete
MI_Row_deleteMBI_Row_deleteMSI_Row_deleteMLI_Row_deleteMQI_Row_delete
MU_Row_deleteMUB_Row_deleteMUS_Row_deleteMUL_Row_deleteMUQ_Row_delete
Funktioneine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMBi,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
QuerverweisMF_Row_insert,   MF_Col_delete,   Kap. 5

 
MF_Row_divC MD_Row_divC ME_Row_divC
MCF_Row_divC MCD_Row_divC MCE_Row_divC
Funktionalle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAiRow,i /= C,  i=0,...,len-1
QuerverweisMF_Col_divC,   MF_Dia_divC,   Kap. 6

 
MF_Row_divrC MD_Row_divrC ME_Row_divrC
MCF_Row_divrC MCD_Row_divrC MCE_Row_divrC
Funktionumgekehrte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAiRow,i = C / MAiRow,i,  i=0,...,len-1
QuerverweisMF_Col_divrC,   MF_Dia_divrC,   Kap. 6

 
MF_Row_divrV MD_Row_divrV ME_Row_divrV
MCF_Row_divrV MCD_Row_divrV MCE_Row_divrV
FunktionElement-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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAiRow,i = Xi / MAiRow,i,  i=0,...,len-1
QuerverweisMF_Col_divrV,   MF_Dia_divrV,   Kap. 6

 
MF_Row_divV MD_Row_divV ME_Row_divV
MCF_Row_divV MCD_Row_divV MCE_Row_divV
FunktionElement-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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAiRow,i /= Xi,  i=0,...,len-1
QuerverweisMF_Col_divV,   MF_Dia_divV,   Kap. 6

 
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_equ0MBI_Row_equ0MSI_Row_equ0MLI_Row_equ0MQI_Row_equ0
MU_Row_equ0MUB_Row_equ0MUS_Row_equ0MUL_Row_equ0MUQ_Row_equ0
Funktionalle 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/Delphiuses 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/Delphiuses 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)
QuerverweisMF_Col_equ0,   MF_Dia_equ0,   MF_Row_equC,   Kap. 3

 
MF_Row_equC MD_Row_equC ME_Row_equC
MCF_Row_equC MCD_Row_equC MCE_Row_equC
MI_Row_equCMBI_Row_equCMSI_Row_equCMLI_Row_equCMQI_Row_equC
MU_Row_equCMUB_Row_equCMUS_Row_equCMUL_Row_equCMUQ_Row_equC
Funktionalle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAiRow,i = C,  i=0,...,len-1
QuerverweisMF_Col_equC,   MF_Dia_equC,   MF_Row_equ0,   Kap. 3

 
MF_Row_equV MD_Row_equV ME_Row_equV
MCF_Row_equV MCD_Row_equV MCE_Row_equV
MI_Row_equVMBI_Row_equVMSI_Row_equVMLI_Row_equVMQI_Row_equV
MU_Row_equVMUB_Row_equVMUS_Row_equVMUL_Row_equVMUQ_Row_equV
FunktionVektor 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAiRow,i = Xi,  i=0,...,len-1
QuerverweisMF_Col_equV,   MF_Dia_equV,   MF_Row_equC,   Kap. 3

 
MF_Row_extract MD_Row_extract ME_Row_extract
MCF_Row_extract MCD_Row_extract MCE_Row_extract
MI_Row_extractMBI_Row_extractMSI_Row_extractMLI_Row_extractMQI_Row_extract
MU_Row_extractMUB_Row_extractMUS_Row_extractMUL_Row_extractMUQ_Row_extract
Funktioneine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungXi = MAiRow,i,  i=0,...,len-1
QuerverweisMF_Row_equV,   MF_Row_insert  Kap. 5

 
MF_Row_insert MD_Row_insert ME_Row_insert
MCF_Row_insert MCD_Row_insert MCE_Row_insert
MI_Row_insertMBI_Row_insertMSI_Row_insertMLI_Row_insertMQI_Row_insert
MU_Row_insertMUB_Row_insertMUS_Row_insertMUL_Row_insertMUQ_Row_insert
FunktionMatrix 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMBi,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
QuerverweisMF_Row_delete,   Kap. 5

 
MF_Row_mulC MD_Row_mulC ME_Row_mulC
MCF_Row_mulC MCD_Row_mulC MCE_Row_mulC
Funktionalle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAiRow,i *= C,  i=0,...,len-1
QuerverweisMF_Col_mulC,   MF_Dia_mulC,   MF_Row_mulV,   Kap. 6

 
MF_Row_mulV MD_Row_mulV ME_Row_mulV
MCF_Row_mulV MCD_Row_mulV MCE_Row_mulV
FunktionElement-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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAiRow,i *= Xi,  i=0,...,len-1
QuerverweisMF_Col_mulV,   MF_Dia_mulV,   MF_Row_divV,   Kap. 6

 
MF_Row_neg MD_Row_neg ME_Row_neg
MCF_Row_neg MCD_Row_neg MCE_Row_neg
FunktionMultiplikation 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Row_neg( d_MA:fMatrix; ht, len, iRow:UIntSize ): IntBool;
procedure MFcu_Row_neg( h_MA:fMatrix; ht, len, iRow:UIntSize );
BeschreibungMAiRow,i *= -1,  i=0,...,len-1
QuerverweisMF_Row_mulC,   MF_Col_neg,   MCF_Row_conj,   Kap. 6

 
MF_Row_subC MD_Row_subC ME_Row_subC
MCF_Row_subC MCD_Row_subC MCE_Row_subC
Funktioneine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAiRow,i -= C,  i=0,...,len-1
QuerverweisMF_Col_subC,   MF_Dia_subC,   MF_Row_subV,   Kap. 6

 
MF_Row_subrC MD_Row_subrC ME_Row_subrC
MCF_Row_subrC MCD_Row_subrC MCE_Row_subrC
Funktionumgekehrte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAiRow,i = C - MAiRow,i,  i=0,...,len-1
QuerverweisMF_Row_subC,   MF_Col_subrC,   MF_Dia_subrC,   MF_Row_subV,   Kap. 6

 
MF_Row_subrV MD_Row_subrV ME_Row_subrV
MCF_Row_subrV MCD_Row_subrV MCE_Row_subrV
FunktionElement-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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAiRow,i = Xi - MAiRow,i,  i=0,...,len-1
QuerverweisMF_Row_subV,   MF_Col_subrV,   MF_Dia_subrV,   MF_Row_addV,   Kap. 6

 
MF_Row_subV MD_Row_subV ME_Row_subV
MCF_Row_subV MCD_Row_subV MCE_Row_subV
FunktionElement-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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAiRow,i -= Xi,  i=0,...,len-1
QuerverweisMF_Row_subC,   MF_Col_subV,   MF_Dia_subV,   MF_Row_subrV,   Kap. 6

 
MF_Rows_absmax MD_Rows_absmax ME_Rows_absmax
MCF_Rows_absmax MCD_Rows_absmax MCE_Rows_absmax
FunktionBetrags-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/Delphiuses 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/Delphiuses 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 );
BeschreibungThe Betrags-Maximum jeder Zeile i wird gespeichert als Element Yi für i=0,...,ht-1
QuerverweisMF_Rows_max,   MF_Rows_absmin,   MF_Cols_absmax,   MF_Dia_absmax,   Kap. 7

 
MCF_Rows_absmaxReIm MCD_Rows_absmaxReIm MCE_Rows_absmaxReIm
FunktionBetrags-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/Delphiuses 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/Delphiuses 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 );
BeschreibungFü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.
QuerverweisMCF_Rows_absmax,   MCF_Rows_maxReIm,   MCF_Cols_absmaxReIm,   Kap. 7

 
MF_Rows_absmin MD_Rows_absmin ME_Rows_absmin
MCF_Rows_absmin MCD_Rows_absmin MCE_Rows_absmin
FunktionBetrags-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/Delphiuses 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/Delphiuses 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 );
BeschreibungThe Betrags-Minimum jeder Zeile i wird gespeichert als Element Yi für i=0,...,ht-1
QuerverweisMF_Rows_min,   MF_Rows_absmax,   MF_Cols_absmin,   MF_Dia_absmin,   Kap. 7

 
MCF_Rows_absminReIm MCD_Rows_absminReIm MCE_Rows_absminReIm
FunktionBetrags-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/Delphiuses 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/Delphiuses 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 );
BeschreibungFü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.
QuerverweisMCF_Rows_absmax,   MCF_Rows_maxReIm,   MCF_Cols_absmaxReIm,   Kap. 7

 
MF_Rows_add MD_Rows_add ME_Rows_add
MCF_Rows_add MCD_Rows_add MCE_Rows_add
Funktioneine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAdestRow, j += MAsourceRow, j,  i=0,...,len-1
QuerverweisMF_Rows_sub,   MF_Rows_Cadd,   MF_Rows_lincomb,   Kap. 8

 
MCF_Rows_cabsmax MCD_Rows_cabsmax MCE_Rows_cabsmax
FunktionDenjenigen 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDasjenige 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
QuerverweisMCF_Rows_absmax,   MCF_Rows_cabsmin,   MCF_Rows_sabsmax,   MCF_Cols_cabsmax,   MCF_Dia_cabsmax,   Kap. 7

 
MCF_Rows_cabsmin MCD_Rows_cabsmin MCE_Rows_cabsmin
FunktionDenjenigen 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDasjenige 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
QuerverweisMCF_Rows_absmin,   MCF_Rows_cabsmax,   MCF_Rows_sabsmin,   MCF_Cols_cabsmin,   MCF_Dia_cabsmin,   Kap. 7

 
MF_Rows_Cadd MD_Rows_Cadd ME_Rows_Cadd
MCF_Rows_Cadd MCD_Rows_Cadd MCE_Rows_Cadd
Funktioneine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAdestRow, j += C * MAsourceRow, j,  i=0,...,len-1
QuerverweisMF_Rows_add,   MF_Rows_lincomb,   Kap. 8

 

MF_Rows_distributionMD_Rows_distributionME_Rows_distribution
MI_Rows_distributionMBI_Rows_distributionMSI_Rows_distributionMLI_Rows_distributionMQI_Rows_distribution
MU_Rows_distributionMUB_Rows_distributionMUS_Rows_distributionMUL_Rows_distributionMUQ_Rows_distribution
FunktionHistogramm: 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/Delphiuses 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/Delphiuses 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 );
BeschreibungFü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.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_distribution   MF_Cols_distribution

 
MF_Rows_exchange MD_Rows_exchange ME_Rows_exchange
MCF_Rows_exchange MCD_Rows_exchange MCE_Rows_exchange
MI_Rows_exchangeMBI_Rows_exchangeMSI_Rows_exchangeMLI_Rows_exchangeMQI_Rows_exchange
MU_Rows_exchangeMUB_Rows_exchangeMUS_Rows_exchangeMUL_Rows_exchangeMUQ_Rows_exchange
Funktionzwei 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie Elemente der Zeilen i1 und i2 werden miteinander vertauscht.
QuerverweisMF_Cols_exchange,   Kap. 8

 
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
FunktionSchnelle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie 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,0MYi,1MYi,2 MYi,3  .....   MYi,N-2MYi,N-1
Ui,0.ReUi,N/2.ReUi,1.Re Ui,1.Im  .....   Ui,N/2-1.ReUi,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).

FehlerbehandlungFalls 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.
QuerverweisMF_Cols_FFT,   MF_FFT,   Kap. 12,   Kap. 4.8 von HANDBUCH.HTM

 
MF_Rows_lincomb MD_Rows_lincomb ME_Rows_lincomb
MCF_Rows_lincomb MCD_Rows_lincomb MCE_Rows_lincomb
FunktionLinearkombination 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAdestRow, j = destC * MAdestRow, j+ srceC * MAsrceRow, j,  j=0,...,len-1
QuerverweisMF_Rows_add,   MF_Rows_Cadd,   Kap. 8

 
MF_Rows_max MD_Rows_max ME_Rows_max
MI_Rows_maxMBI_Rows_maxMSI_Rows_maxMLI_Rows_maxMQI_Rows_max
MU_Rows_maxMUB_Rows_maxMUS_Rows_maxMUL_Rows_maxMUQ_Rows_max
FunktionMaxima 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDas Maximum jeder Zeile i wird gespeichert als Element Yi für i=0,...,ht-1
QuerverweisMF_Rows_absmax,   MF_Rows_min,   MF_Cols_max,   Kap. 7

 
MCF_Rows_maxReIm MCD_Rows_maxReIm MCE_Rows_maxReIm
FunktionMaxima 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/Delphiuses 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/Delphiuses 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 );
BeschreibungFü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.
QuerverweisMCF_Rows_absmax,   MCF_Rows_minReIm,   MCF_Cols_maxReIm,   Kap. 7

 
MF_Rows_min MD_Rows_min ME_Rows_min
MI_Rows_minMBI_Rows_minMSI_Rows_minMLI_Rows_minMQI_Rows_min
MU_Rows_minMUB_Rows_minMUS_Rows_minMUL_Rows_minMUQ_Rows_min
FunktionMinima 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDas kleinste oder "negativste" Element jeder Zeile i wird gespeichert als Element Yi für i=0,...,ht-1
QuerverweisMF_Rows_absmin,   MF_Rows_max,   MF_Cols_min,   Kap. 7

 
MCF_Rows_minReIm MCD_Rows_minReIm MCE_Rows_minReIm
FunktionMinima 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/Delphiuses 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/Delphiuses 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 );
BeschreibungFü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.
QuerverweisMCF_Rows_absmin,   MCF_Rows_maxReIm,   MCF_Cols_minReIm,   Kap. 7

 
MF_Rows_prod MD_Rows_prod ME_Rows_prod
MCF_Rows_prod MCD_Rows_prod MCE_Rows_prod
FunktionProdukte ü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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = prod( MAi,j, j=0,...,len-1),  i=0,...,ht-1
QuerverweisMF_Rows_runprod,   MF_Rows_sum,   Kap. 7

 
MF_Rows_reflect MD_Rows_reflect ME_Rows_reflect
MCF_Rows_reflect MCD_Rows_reflect MCE_Rows_reflect
MI_Rows_reflectMBI_Rows_reflectMSI_Rows_reflectMLI_Rows_reflectMQI_Rows_reflect
MU_Rows_reflectMUB_Rows_reflectMUS_Rows_reflectMUL_Rows_reflectMUQ_Rows_reflect
FunktionZweite 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Rows_reflect( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_reflect( h_MA:fMatrix; ht, len:UIntSize );
BeschreibungMAi, len-j-1 = MAi, j,  i=0,...,ht-1;  j=0,...,(len-1)/2;
QuerverweisMF_Rows_rotate,   MF_Cols_reflect,   Kap. 7

 
MF_Rows_rev MD_Rows_rev ME_Rows_rev
MCF_Rows_rev MCD_Rows_rev MCE_Rows_rev
MI_Rows_revMBI_Rows_revMSI_Rows_revMLI_Rows_revMQI_Rows_rev
MU_Rows_revMUB_Rows_revMUS_Rows_revMUL_Rows_revMUQ_Rows_rev
FunktionUmkehrung 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Rows_rev( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_rev( h_MA:fMatrix; ht, len:UIntSize );
BeschreibungMAi,j = MAi, len-j-1
QuerverweisMF_Cols_rev,   MF_Rows_reflect,   MF_rotate90,   chapter 5,   chapter 7

 
MF_Rows_rotate MD_Rows_rotate ME_Rows_rotate
MCF_Rows_rotate MCD_Rows_rotate MCE_Rows_rotate
MI_Rows_rotateMBI_Rows_rotateMSI_Rows_rotateMLI_Rows_rotateMQI_Rows_rotate
MU_Rows_rotateMUB_Rows_rotateMUS_Rows_rotateMUL_Rows_rotateMUQ_Rows_rotate
Funktionalle 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAi,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.

QuerverweisMF_Rows_reflect,   MF_Cols_rotate,   Kap. 7

 
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_bufMBI_Rows_rotate_bufMSI_Rows_rotate_bufMLI_Rows_rotate_bufMQI_Rows_rotate_buf
MU_Rows_rotate_bufMUB_Rows_rotate_bufMUS_Rows_rotate_bufMUL_Rows_rotate_bufMUQ_Rows_rotate_buf
Funktionalle 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Rows_rotate_buf( d_MA:fMatrix; ht, len:UIntSize; pos:Integer; d_MBuf:fMatrix ): IntBool;
BeschreibungMAi,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.

QuerverweisMF_Rows_rotate,   MF_Cols_rotate_buf,   Kap. 7

 
MF_Rows_runprod MD_Rows_runprod ME_Rows_runprod
MCF_Rows_runprod MCD_Rows_runprod MCE_Rows_runprod
Funktionlaufendes 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Rows_runprod( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_runprod( h_MA:fMatrix; ht, len:UIntSize );
BeschreibungFü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.
QuerverweisMF_Rows_prod,   MF_Cols_runprod,   Kap. 7

 
MF_Rows_runsum MD_Rows_runsum ME_Rows_runsum
MCF_Rows_runsum MCD_Rows_runsum MCE_Rows_runsum
Funktionlaufende 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Rows_runsum( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Rows_runsum( h_MA:fMatrix; ht, len:UIntSize );
BeschreibungFür alle Zeilen einzeln wird jedes Element als Summe seiner selbst und aller vorhergehender Elemente berechnet.
QuerverweisMF_Rows_sum,   MF_Cols_runsum,   Kap. 7

 
MCF_Rows_sabsmax MCD_Rows_sabsmax MCE_Rows_sabsmax
FunktionDenjenigen 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDas 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
QuerverweisMCF_Rows_absmax,   MCF_Rows_sabsmin,   MCF_Cols_sabsmax,   MCF_Dia_sabsmax,   MCF_Rows_cabsmax,   Kap. 7

 
MCF_Rows_sabsmin MCD_Rows_sabsmin MCE_Rows_sabsmin
FunktionDenjenigen 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDas 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
QuerverweisMCF_Rows_absmin,   MCF_Rows_cabsmax,   MCF_Cols_sabsmin,   MCF_Rows_cabsmin,   MCF_Dia_cabsmin,   Kap. 7

 
MF_Rows_sub MD_Rows_sub ME_Rows_sub
MCF_Rows_sub MCD_Rows_sub MCE_Rows_sub
Funktioneine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMAdestRow, j -= MAsourceRow, j,  i=0,...,len-1
QuerverweisMF_Rows_add,   MF_Rows_Cadd,   Kap. 8

 
MF_Rows_sum MD_Rows_sum ME_Rows_sum
MCF_Rows_sum MCD_Rows_sum MCE_Rows_sum
FunktionSummen ü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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = Summe( MAi,j, j=0,...,len-1),  i=0,...,ht-1
QuerverweisMF_Rows_runsum,   MF_Rows_prod,   Kap. 7

 
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/Delphiuses 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;
BeschreibungMF_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!).

QuerverweisMF_solve,   Kap. 10

 
M_setDensityBounds
FunktionFarbskala für Farbton-Plots berechnen
Syntax C/C++#include <Mgraph.h>
void M_setDensityBounds( extended zmin, extended zmax, COLORREF mincolor, COLORREF maxcolor );
Pascal/Delphiuses Mgraph;
procedure M_setDensityBounds( zmin, zmax: Extended; mincolor, maxcolor: COLORREF );
BeschreibungEine 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.
QuerverweisM_setDensityMapBounds,   M_findDensityMapBounds,   Kap. 15

 
M_setDensityMapBounds
Funktionz-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/Delphiuses 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.
QuerverweisMF_xyzAutoDensityMap,   MF_zAutoDensityMap,   Kap. 15

 
MF_setElement MD_setElement ME_setElement
MCF_setElement MCD_setElement MCE_setElement
MI_setElementMBI_setElementMSI_setElementMLI_setElementMQI_setElement
MU_setElementMUB_setElementMUS_setElementMUL_setElementMUQ_setElement
FunktionSchreib-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/Delphiuses 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/Delphiuses 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 );
BeschreibungDas Element MAm,n wird mit dem Wert C überschrieben.
Rückgabewertkeiner
QuerverweisMF_getElement,   MF_Pelement,   Kap. 2

 
VF_setLinfitNeglect VD_setLinfitNeglect VE_setLinfitNeglect
FunktionSignifikanz-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/Delphiuses MFstd;
procedure VF_setLinfitNeglect( Thresh:Single );
BeschreibungWie 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.
QuerverweisVF_getLinfitNeglect,   VF_linfit,   Kap. 13

 
VF_setNonlinfitOptions VD_setNonlinfitOptions VE_setNonlinfitOptions
VF_setNonlinfitDefaultOptions VD_setNonlinfitDefaultOptions VE_setNonlinfitDefaultOptions
FunktionOptionen für nicht-lineare Datenanpassungs-Routinen setzen
Syntax C/C++#include <MFstd.h>
void VF_setNonlinfitOptions( VF_NONLINFITOPTIONS *Options );
void VF_setNonlinfitDefaultOptions( void );
Pascal/Delphiuses MFstd;
procedure VF_setNonlinfitOptions( Options: VF_NONLINFITOPTIONS );
procedure VF_setNonlinfitDefaultOptions( );
BeschreibungDie 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/DelphiOpt: 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 );
QuerverweisKap. 13.3

 
MF_setWriteFormat MD_setWriteFormat ME_setWriteFormat
MCF_setWriteFormat MCD_setWriteFormat MCE_setWriteFormat
FunktionDefinition 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/DelphiDiese Funktionen existieren nicht.
BeschreibungDiese 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.

VersionStandard-FormatAlternativ-Beispielmax. 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

FehlerbehandlungFormat-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.
QuerverweisMF_setWriteSeparate,   MF_write,   VF_write,   MF_read,   Kap. 14

 
MF_setWriteSeparate MD_setWriteSeparate ME_setWriteSeparate
MCF_setWriteSeparate MCD_setWriteSeparate MCE_setWriteSeparate
FunktionZeichenkette 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/Delphiuses MFstd;
procedure MF_setWriteSeparate( SepString:PChar );
BeschreibungDiese 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).
FehlerbehandlungFalls 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.
QuerverweisMF_setWriteFormat,   MF_write,   MF_read,   Kap. 14

 
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
Funktionlineares 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/Delphiuses 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;
BeschreibungDiesen 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ückgabewertBedeutung
0Matrix MA ist regulär; Gleichungssystem konnte erfolgreich gelöst werden
1Matrix MA ist singulär; Ergebnis X komplett unbrauchbar
2Matrix 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ückgabewertBedeutung
0Matrix MA ist regulär; Gleichungssystem konnte erfolgreich entweder über Cholesky oder über LUD gelöst werden
1Matrix MA ist singulär; sowohl Cholesky als auch LUD scheiterten; Ergebnis X komplett unbrauchbar
2Matrix 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ückgabewertEin Code 0, 1 oder 2, siehe oben
QuerverweisMF_LUdecompose,   MF_CholeskyLdecompose,   MF_inv,   Kap. 10

 
MF_solveBySVD MD_solveBySVD ME_solveBySVD
MFb_solveBySVD MDb_solveBySVD MEb_solveBySVD
MFb_solveBySVD_sizeBuf MDb_solveBySVD_sizeBuf MEb_solveBySVD_sizeBuf
Funktionmö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/Delphiuses 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;
BeschreibungDas 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ückgabewertnormalerweise FALSE (0); nur in dem sehr unwahrscheinlichen Fall eines Scheiterns von SVD wird TRUE (1) zurückgegeben.
QuerverweisMF_SVdecompose,   MF_solve,   Kap. 10

 
MF_spectrum MD_spectrum ME_spectrum
MFb_spectrum MDb_spectrum MEb_spectrum
MFb_spectrum_sizeBuf MDb_spectrum_sizeBuf MEb_spectrum_sizeBuf
FunktionRaumfrequenz-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/Delphiuses 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/Delphiuses 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 );
BeschreibungDas 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.

FehlerbehandlungFalls 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.
QuerverweisMF_FFT,   MF_convolve,   MF_autocorr,   MF_xcorr,   MF_filter,   Kap. 12

 
MFsym_sqrt MDsym_sqrt MEsym_sqrt
FunktionQuadratwurzel 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/Delphiuses MFstd;
function MFsym_sqrt( MB, MA:fMatrix; len:UIntSize ):IntBool;
BeschreibungDie 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ückgabewertim Erfolgsfall FALSE (0); sonst TRUE (1)
QuerverweisMF_eigenvalues,   Kap. 11

 
MF_store MD_store ME_store
MCF_store MCD_store MCE_store
MI_storeMBI_storeMSI_storeMLI_storeMQI_store
MU_storeMUB_storeMUS_storeMUL_storeMUQ_store
FunktionMatrix 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/Delphiuses 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/Delphiuses 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;
BeschreibungDie 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-SicherheitVerschiedene 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.
Fehlerbehandlungwird durch die C-Funktion fwrite bzw. die Delphi-Funktion BlockWrite durchgeführt, auf der MF_store etc. basieren
Rückgabewert0, wenn fehlerfrei; ansonsten 1. Um mehr Information im Falle eines Fehlers zu erhalten, inspiziere man errno (C/C++) oder IOResult (Delphi).
QuerverweisMF_recall,  Kap. 14

 
MF_subM MD_subM ME_subM
MFs_subM MDs_subM MEs_subM
MCF_subM MCD_subM MCE_subM
FunktionElement-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/Delphiuses 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/Delphiuses 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 );
BeschreibungNormalversion: MCij = MAij - MBij
Skalierte Version: MCij = C * (MAij - MBij)
QuerverweisMF_subMT,   MF_addM,   Kap. 9

 
MF_subMT MD_subMT ME_subMT
MFs_subMT MDs_subMT MEs_subMT
MCF_subMT MCD_subMT MCE_subMT
FunktionTransponierte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungNormalversion: MCi,j = MAi,j - MBTj,i
Skalierte Version: MCi,j = C * (MAi,j - MBTj,i)
QuerverweisMF_subM,   MF_addM,   MF_subrMT,   Kap. 9

 
MF_subrMT MD_subrMT ME_subrMT
MFs_subrMT MDs_subrMT MEs_subrMT
MCF_subrMT MCD_subrMT MCE_subrMT
Funktionumgekehrte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungNormalversion: MCi,j = MBTj,i - MAi,j
Skalierte Version: MCi,j = C * (MBTj,i - MAi,j)
QuerverweisMF_addM,   MF_subMT,   Kap. 9

 
MF_submatrix MD_submatrix ME_submatrix
MCF_submatrix MCD_submatrix MCE_submatrix
MI_submatrixMBI_submatrixMSI_submatrixMLI_submatrixMQI_submatrix
MU_submatrixMUB_submatrixMUS_submatrixMUL_submatrixMUQ_submatrix
FunktionTeilmatrix 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMSubi, j = MSrcei*sampInCol+firstRowInCol, j*sampInRow+firstColInRow
QuerverweisVF_subvector,   MF_Row_extract,   MF_submatrix_equM,   Kap. 5

 
MF_submatrix_equM MD_submatrix_equM ME_submatrix_equM
MCF_submatrix_equM MCD_submatrix_equM MCE_submatrix_equM
MI_submatrix_equMMBI_submatrix_equMMSI_submatrix_equMMLI_submatrix_equMMQI_submatrix_equM
MU_submatrix_equMMUB_submatrix_equMMUS_submatrix_equMMUL_submatrix_equMMUQ_submatrix_equM
FunktionMatrix 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMDesti*sampInCol+firstRowInCol, j*sampInRow+firstColInRow = MSrcei, j
Diese Funktion stellt die Umkehrung von MF_submatrix dar.
QuerverweisVF_subvector,   MF_Row_equV,   MF_submatrix,   Kap. 5

 
MF_SVdecompose MD_SVdecompose ME_SVdecompose
MFb_SVdecompose MDb_SVdecompose MEb_SVdecompose
MFb_SVdecompose_sizeBuf MDb_SVdecompose_sizeBuf MEb_SVdecompose_sizeBuf
FunktionSingulä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/Delphiuses 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;
BeschreibungDie 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:

  1. 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.
  2. 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.
  3. 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üfenDie 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 );
}

QuerverweisMF_SVsort,   MF_SVsolve,   MF_safeSolve,   MF_solveBySVD,   Kap. 10

 
MF_SVDgetEdit MD_SVDgetEdit ME_SVDgetEdit
Funktionaktuelle 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/Delphiuses MFstd;
function MF_SVDgetEdit: Single;
BeschreibungDiese 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ückgabewertaktuelle Schwelle für Dimensions-Reduktion
QuerverweisMF_SVdecompose,   MF_SVsolve,   Kap. 10

 
MF_SVDsetEdit MD_SVDsetEdit ME_SVDsetEdit
FunktionSchwelle 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/Delphiuses MFstd;
procedure MF_SVDsetEdit( Thresh:Single );
BeschreibungWie 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.

QuerverweisMF_SVdecompose,   MF_SVsolve,   Kap. 10

 
MF_SVsolve MD_SVsolve ME_SVsolve
MFb_SVsolve MDb_SVsolve MEb_SVsolve
MFb_SVsolve_sizeBuf MDb_SVsolve_sizeBuf MEb_SVsolve_sizeBuf
Funktionlineares 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/Delphiuses 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;
BeschreibungMF_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!).

QuerverweisMF_SVdecompose,   MF_solveBySVD,   Kap. 10

 
MF_SVsort MD_SVsort ME_SVsort
FunktionSortierung 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/Delphiuses MFstd;
procedure MF_SVsort( MUraw, MVraw:fMatrix; Wraw:fVector; MUraw, MVraw:fMatrix; Wraw:fVector; htU, lenU:UIntSize );
BeschreibungMF_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;

QuerverweisMF_SVdecompose,   Kap. 10

 
MF_TmulM MD_TmulM ME_TmulM
MCF_TmulM MCD_TmulM MCE_TmulM
FunktionTransponierte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMC = 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.
QuerverweisMF_mulM,   MF_mulMT,   Kap. 9

 
MF_TmulMdia MD_TmulMdia ME_TmulMdia
MCF_TmulMdia MCD_TmulMdia MCE_TmulMdia
FunktionTransponierte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMC = MAT * MBDia
htA und lenA müssen spezifiziert werden. Sie beziehen sich auf die originale, nicht-transponierte Eingabe-Matrix. Implizit ist sizB = htA.
QuerverweisMFdia_mulM,   Kap. 9

 
MCF_TmulMH MCD_TmulMH MCE_TmulMH
FunktionTransponierte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMC = 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.
QuerverweisMF_mulM,   MF_TmulMT,   MF_mulMH,   Kap. 9

 
MF_TmulMT MD_TmulMT ME_TmulMT
MCF_TmulMT MCD_TmulMT MCE_TmulMT
FunktionTransponierte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungMC = 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.
QuerverweisMF_mulM,   MF_TmulM,   MF_mulMT,   Kap. 9

 
MF_TmulV MD_TmulV ME_TmulV
MCF_TmulV MCD_TmulV MCE_TmulV
FunktionTransponierte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungY = 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.
QuerverweisMF_mulV,   VF_mulM,   Kap. 9

 
MF_transpose MD_transpose ME_transpose
MCF_transpose MCD_transpose MCE_transpose
MI_transposeMBI_transposeMSI_transposeMLI_transposeMQI_transpose
MU_transposeMUB_transposeMUS_transposeMUL_transposeMUQ_transpose
FunktionTransponierte 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_transpose( d_MTr, d_MA:fMatrix; htTr, lenTr:UIntSize ): IntBool;
procedure MFcu_transpose( h_MTr, h_MA:fMatrix; htTr, lenTr:UIntSize );
BeschreibungMTri,j = MAj,i
Die an diese Funktion übergebenen Dimensionen htTr und lenTr beziehen sich auf die transponierte Ausgabe-Matrix.
QuerverweisMCF_hermconj,   MF_mulMT,   Kap. 9,   Kap. 5

 
MF_Trd_equM MD_Trd_equM ME_Trd_equM
MCF_Trd_equM MCD_Trd_equM MCE_Trd_equM
MI_Trd_equMMBI_Trd_equMMSI_Trd_equMMLI_Trd_equMMQI_Trd_equM
MU_Trd_equMMUB_Trd_equMMUS_Trd_equMMUL_Trd_equMMUQ_Trd_equM
FunktionTridiagonal-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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Trd_equM( d_MA, d_MTrd:fMatrix; len:UIntSize ): IntBool;
procedure MFcu_Trd_equM( h_MA, h_MTrd:fMatrix; len:UIntSize );
BeschreibungZeile 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.
QuerverweisMF_Dia_equV,   MF_Trd_extract,   Kap. 2

 
MF_Trd_extract MD_Trd_extract ME_Trd_extract
MCF_Trd_extract MCD_Trd_extract MCE_Trd_extract
MI_Trd_extractMBI_Trd_extractMSI_Trd_extractMLI_Trd_extractMQI_Trd_extract
MU_Trd_extractMUB_Trd_extractMUS_Trd_extractMUL_Trd_extractMUQ_Trd_extract
FunktionTridiagonal-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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Trd_extract( d_MTrd, d_MA:fMatrix; len:UIntSize ): IntBool;
procedure MFcu_Trd_extract( h_MTrd, h_MA:fMatrix; len:UIntSize );
BeschreibungDie 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.
QuerverweisMF_Dia_extract,   MF_Trd_equM,   Kap. 1.2,   Kap. 2

 
MF_UequL MD_UequL ME_UequL
MCF_UequL MCD_UequL MCE_UequL
MI_UequLMBI_UequLMSI_UequLMLI_UequLMQI_UequL
MU_UequLMUB_UequLMUS_UequLMUL_UequLMUQ_UequL
FunktionUnterdiagonalelemente 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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_UequL( d_MA:fMatrix; len:UIntSize ): IntBool;
procedure MFcu_UequL( h_MA:fMatrix; len:UIntSize );
BeschreibungMAi,j = MAj,i,  i < j
QuerverweisMF_LequU,   Kap. 3

 
MF_Welch MD_Welch ME_Welch
Funktionzwei-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/Delphiuses 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/Delphiuses MFstd;
function cudaMF_Welch( d_MA:fMatrix; ht, len:UIntSize ): IntBool;
procedure MFcu_Welch( h_MA:fMatrix; ht, len:UIntSize );
BeschreibungMAi,j = (1 - ( (i - 0.5*(ht - 1)) / (0.5*(ht + 1)) )2) * (1 - ( (j - 0.5*(len - 1)) / (0.5*(len + 1)) )2)
QuerverweisMF_Parzen,   MF_Hann,   MF_spectrum

 
MF_write MD_write ME_write
MCF_write MCD_write MCE_write
MI_writeMBI_writeMSI_writeMLI_writeMQI_write
MU_writeMUB_writeMUS_writeMUL_writeMUQ_write
FunktionMatrix 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/Delphiuses 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/Delphiuses 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;
BeschreibungDie 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.

QuerverweisMF_setWriteFormat,   MF_setWriteSeparate,   MF_read,   MF_store,   MF_print,   Kap. 14

 
MF_xcorr MD_xcorr ME_xcorr
MFb_xcorr MDb_xcorr MEb_xcorr
FunktionRä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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie 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.

FehlerbehandlungFalls 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.
QuerverweisMF_autocorr,   Kap. 12

 
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
FunktionRaumfrequenz-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/Delphiuses 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/Delphiuses 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 );
BeschreibungDas 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.

FehlerbehandlungFalls 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.
QuerverweisMF_spectrum,   MF_coherence,   MF_FFT,   MF_convolve,   MF_autocorr,   MF_xcorr,   MF_filter,   Kap. 12

 
MF_xyzAutoDensityMap MD_xyzAutoDensityMap ME_xyzAutoDensityMap
MI_xyzAutoDensityMapMBI_xyzAutoDensityMapMSI_xyzAutoDensityMapMLI_xyzAutoDensityMapMQI_xyzAutoDensityMap
MU_xyzAutoDensityMapMUB_xyzAutoDensityMapMUS_xyzAutoDensityMapMUL_xyzAutoDensityMapMUQ_xyzAutoDensityMap
FunktionAutomatisch 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/Delphiuses Mgraph;
procedure MF_xyzAutoDensityMap( X, Y:fVector; MZ:fMatrix; ht, len: UIntSize; mincolor, maxcolor: COLORREF );
BeschreibungEin 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.

QuerverweisMF_zAutoDensityMap,   MF_xyzDataDensityMap,   VF_xyAutoPlot,   Kap. 15

 
MF_xyzDataDensityMap MD_xyzDataDensityMap ME_xyzDataDensityMap
MI_xyzDataDensityMapMBI_xyzDataDensityMapMSI_xyzDataDensityMapMLI_xyzDataDensityMapMQI_xyzDataDensityMap
MU_xyzDataDensityMapMUB_xyzDataDensityMapMUS_xyzDataDensityMapMUL_xyzDataDensityMapMUQ_xyzDataDensityMap
FunktionFarbtonplot 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/Delphiuses Mgraph;
procedure MF_xyzDataDensityMap( X, Y:fVector; MZ:fMatrix; ht, len: UIntSize );
BeschreibungDie 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.
QuerverweisMF_zDataDensityMap,   MF_xyzAutoDensityMap,   Kap. 15

 
MF_zAutoDensityMap MD_zAutoDensityMap ME_zAutoDensityMap
MI_zAutoDensityMapMBI_zAutoDensityMapMSI_zAutoDensityMapMLI_zAutoDensityMapMQI_zAutoDensityMap
MU_zAutoDensityMapMUB_zAutoDensityMapMUS_zAutoDensityMapMUL_zAutoDensityMapMUQ_zAutoDensityMap
Funktionautomatisch 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/Delphiuses Mgraph;
procedure MF_xyzDataDensityMap( X, Y:fVector; MZ:fMatrix; ht, len: UIntSize );
BeschreibungDiese Funktion ähnelt MF_xyzAutoDensityMap, aber hier wird MZ gegen die Indizes beider Matrix-Dimensionen anstelle expliziter X -und Y-Werte aufgetragen.
QuerverweisMF_xyzAutoDensityMap,   Kap. 15

 
MF_zDataDensityMap MD_zDataDensityMap ME_zDataDensityMap
MI_zDataDensityMapMBI_zDataDensityMapMSI_zDataDensityMapMLI_zDataDensityMapMQI_zDataDensityMap
MU_zDataDensityMapMUB_zDataDensityMapMUS_zDataDensityMapMUL_zDataDensityMapMUQ_zDataDensityMap
FunktionFarbton-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/Delphiuses Mgraph;
procedure MF_zDataDensityMap( MZ:fMatrix; ht, len: UIntSize );
BeschreibungDiese 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.
QuerverweisMF_xyzDataDensityMap,   MF_xyzAutoDensityMap,   Kap. 15

 
MF_2DArrayToMatrix MD_2DArrayToMatrix ME_2DArrayToMatrix
MCF_2DArrayToMatrix MCD_2DArrayToMatrix MCE_2DArrayToMatrix
MI_2DArrayToMatrixMBI_2DArrayToMatrixMSI_2DArrayToMatrixMLI_2DArrayToMatrixMQI_2DArrayToMatrix
MU_2DArrayToMatrixMUB_2DArrayToMatrixMUS_2DArrayToMatrixMUL_2DArrayToMatrixMUQ_2DArrayToMatrix
Funktion2D-Array von Delphi 4 oder höher in OptiVec-Matrix konvertieren
Syntax C/C++N.A.
Pascal/Delphiuses MFstd, VecLib;
type fArray = array of Single;
type f2DArray = array of fArray;
procedure MF_2DArrayToMatrix( MF:fMatrix; DelphiArr:f2DArray; ht,len:UIntSize);
BeschreibungDiese 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.
QuerverweisMF_MatrixTo2DArray,   Kap. 1.4

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!