VF_Pelement | VD_Pelement | VE_Pelement |
VCF_Pelement | VCD_Pelement | VCE_Pelement |
VCF_elementRe | VCD_elementRe | VCE_elementRe |
VCF_elementIm | VCD_elementIm | VCE_elementIm |
VPF_element | VPD_element | VPE_element |
VPF_elementMag | VPD_elementMag | VPE_elementMag |
VPF_elementArg | VPD_elementArg | VPE_elementArg |
VI_Pelement | VBI_Pelement | VSI_Pelement | VLI_Pelement | VQI_Pelement | |
VU_Pelement | VUB_Pelement | VUS_Pelement | VUL_Pelement | VUQ_Pelement | VUI_Pelement |
Funktion | Zeiger auf ein Vektor-Element |
|
Syntax C/C++ | #include <VFstd.h>
(float *) VF_Pelement( fVector X, ui pos );
#include <VCFstd.h>
(fComplex *) VCF_Pelement( cfVector X, ui pos );
(float *) VCF_PelementRe( cfVector X, ui pos );
(float *) VCF_PelementIm( cfVector X, ui pos ); |
C++ VecObj | #include <OptiVec.h>
T * vector<T>::Pelement( ui pos );
complex<T> * vector<complex<T>>::Pelement( ui pos );
T * vector<complex<T>>::PelementRe( ui pos );
T * vector<complex<T>>::PelementIm( ui pos ); |
Pascal/Delphi | uses VFstd;
function VF_Pelement( X:fVector; pos:UIntSize ): PSingle;
uses VCFstd;
function VCF_Pelement( X:cfVector; pos:UIntSize ): PfComplex;
function VCF_PelementRe( X:cfVector; pos:UIntSize ): PSingle;
function VCF_PelementIm( X:cfVector; pos:UIntSize ): PSingle; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
(float *) cudaVF_Pelement( fVector d_X, ui pos );
#include <cudaVCFstd.h>
(fComplex *) cudaVCF_Pelement( cfVector d_X, ui pos );
(float *) cudaVCF_PelementRe( cfVector d_X, ui pos );
(float *) cudaVCF_PelementIm( cfVector d_X, ui pos );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_Pelement( d_X:fVector; pos:UIntSize ): PSingle;
uses VCFstd;
function cudaVCF_Pelement( d_X:cfVector; pos:UIntSize ): PfComplex;
function cudaVCF_PelementRe( d_X:cfVector; pos:UIntSize ): PSingle;
function cudaVCF_PelementIm( d_X:cfVector; pos:UIntSize ): PSingle;
|
|
Beschreibung | Reelle Versionen: geben Zeiger auf X[pos], also &( X[pos] ) = X+pos zurück.
Komplexe Version VCF_PelementRe: gibt den Zeiger auf X[pos].Re zurück.
Komplexe Version VCF_PelementIm: gibt den Zeiger auf X[pos].Im zurück.
|
|
|
Rückgabewert | C/C++: X+pos
Pascal/Delphi: @( X[pos] ) |
|
|
|
Funktion | Datentyp-Umwandlungen. Siehe V_FtoD. |
|
|
Funktion | nur cudaOptiVec: Freigabe eines "pinned" Vektors im Host-Memory |
|
CUDA-Funktion C/C++ | #include <cudaVecLib.h>
int cudaV_pinnedFree( void *h_X );
|
CUDA-Funktion Pascal/Delphi | uses VecLib;
function cudaV_pinnedFree( h_X:Pointer ): IntBool;
|
|
Beschreibung | Der "pinned" Host-Memory Vektor X wird freigegeben (de-alloziert). Diese Funktion benötigt die Host-Adresse (nicht die Device-Addresse!) des pinned Vektors als Argument. Um mehrere "pinned" Vektoren gleichzeitig freizugeben, rufe man cudaV_pinnedNfree (nur C/C++). |
|
Fehlerbehandlung | Der Versuch, einen "pinned" Vektor freizugeben, der bereits freigegeben oder der gar nicht erst alloziert wurde, führt zu einer Warnung "Cannot free non-existent vector". Das Programm wird in diesem Fall fortgesetzt, ohne dass etwas freigegeben wird. |
|
Rückgabewert | FALSE (0) bei Erfolg, sonst TRUE (nicht-Null) |
|
|
|
Funktion | nur cudaOptiVec: Freigabe aller "pinned" Host-Memory Vektoren (und -Matrizen) |
|
CUDA-Funktion C/C++ | #include <cudaVecLib.h>
int cudaV_pinnedFreeAll( void );
|
CUDA-Funktion Pascal/Delphi | uses VecLib;
function cudaV_pinnedFreeAll: IntBool;
|
|
|
|
Rückgabewert | FALSE (0) bei Erfolg, sonst TRUE (nicht-Null) |
|
|
|
Funktion | De-Allocation mehrerer "pinned" Host-Memory Vektoren. |
|
CUDA-Funktion C/C++ | #include <cudaVecLib.h>
int cudaV_pinnedNfree( unsigned numfree, ... );
|
|
Beschreibung | Der Parameter numfree teilt der Funktion mit, wie viele Vektoren freizugeben sind. Die Host-Zeiger (also nicht die Device-Zeiger!) dieser Vektoren folgen in der Parameterliste nach numfree. Nur Vektoren, die durch eine Funktion aus der cudaVF_pinnedVector- oder cudaVF_pinnedVector0-Familie alloziert wurden, können durch cudaV_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++ | cudaV_pinnedNfree( 3, h_X, h_Y, h_Z ); |
|
Rückgabewert | FALSE (0) bei Erfolg, sonst TRUE (nicht-Null) |
|
|
cudaVF_pinnedVector | cudaVD_pinnedVector | cudaVE_pinnedVector |
cudaVCF_pinnedVector | cudaVCD_pinnedVector | cudaVCE_pinnedVector |
cudaVPF_pinnedVector | cudaVPD_pinnedVector | cudaVPE_pinnedVector |
cudaVI_pinnedVector | cudaVBI_pinnedVector | cudaVSI_pinnedVector |
cudaVLI_pinnedVector | cudaVQI_pinnedVector | |
cudaVU_pinnedVector | cudaVUB_pinnedVector | cudaVUS_pinnedVector |
cudaVUL_pinnedVector | cudaVUQ_pinnedVector | cudaVUI_pinnedVector |
|
Funktion | Allokation von "pinned" Host-Memory |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
fVector cudaVF_pinnedVector( fVector *h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VecLib;
function cudaVF_pinnedVector( var h_X:fVector; size:UIntSize ): fVector;
|
|
Beschreibung | Host-Speicher wird reserviert und in den "pinned"-Zustand überführt. Der Device-Zeige wird zurückgegeben; der Host-Zeiger wird als h_X gespeichert. Um den so reservierten Speicher wieder freizugeben, benutze man cudaV_pinnedFree, cudaV_pinnedFreeAll, or cudaV_pinnedNfree (letztere Funktion nur in C/C++).
Eine Beschreibung der verschiedenen in cudaOptiVec verwendeten Speichertypen findet sich in CudaOptiVecD.htm, Kap. 3. |
|
Fehlerbehandlung | Falls nicht genug Speicher vorhanden ist, oder im Falle von size=0, wird eine Fehlermeldung "Not enough memory" ausgegeben und das Programm abgebrochen.
|
|
Rückgabewert | Device-Zeiger auf den reservierten Speicherbereich |
|
|
cudaVF_pinnedVector0 | cudaVD_pinnedVector0 | cudaVE_pinnedVector0 |
cudaVCF_pinnedVector0 | cudaVCD_pinnedVector0 | cudaVCE_pinnedVector0 |
cudaVPF_pinnedVector0 | cudaVPD_pinnedVector0 | cudaVPE_pinnedVector0 |
cudaVI_pinnedVector0 | cudaVBI_pinnedVector0 | cudaVSI_pinnedVector0 |
cudaVLI_pinnedVector0 | cudaVQI_pinnedVector0 | |
cudaVU_pinnedVector0 | cudaVUB_pinnedVector0 | cudaVUS_pinnedVector0 |
cudaVUL_pinnedVector0 | cudaVUQ_pinnedVector0 | cudaVUI_pinnedVector0 |
|
Funktion | Allokation von "pinned" Host-Memory und Initialisierung mit 0 |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
fVector cudaVF_pinnedVector( fVector *h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VecLib;
function cudaVF_pinnedVector( var h_X:fVector; size:UIntSize ): fVector;
|
|
Beschreibung | Host-Speicher wird reserviert, in den "pinned"-Zustand überführt und mit 0 initialisiert. Der Device-Zeiger wird zurückgegeben; der Host-Zeiger wird als h_X gespeichert. Um den so reservierten Speicher wieder freizugeben, benutze man cudaV_pinnedFree, cudaV_pinnedFreeAll, or cudaV_pinnedNfree (the latter only in C/C++).
Eine Beschreibung der verschiedenen in cudaOptiVec verwendeten Speichertypen findet sich in CudaOptiVecD.htm, Kap. 3. |
|
Fehlerbehandlung | Falls nicht genug Speicher vorhanden ist, oder im Falle von size=0, wird eine Fehlermeldung "Not enough memory" ausgegeben und das Programm abgebrochen.
|
|
Rückgabewert | Device-Zeiger auf den reservierten Speicherbereich |
|
|
VCF_polar | VCD_polar | VCE_polar |
VPF_polar | VPD_polar | VPE_polar |
|
Funktion | Konstruktion eines cartesischen komplexen Vektors aus Polarkoordinaten, die als separate relle Vektoren Mag und Arg eingelesen werden |
|
Syntax C/C++ | #include <VCFstd>
void VCF_polar( cfVector X, fVector Mag, fVector Arg, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<complex<T>>::polar( const vector<T>& Mag, const vector<T>& Arg ); |
Pascal/Delphi | uses VCFstd;
procedure VCF_polar( X:cfVector; Mag, Arg:fVector; size:UIntSize); |
|
CUDA-Funktion C/C++ | #include <cudaVCFstd.h>
int cudaVCF_polar( cfVector d_X, fVector d_Mag, fVector d_Arg, ui size );
void VCFcu_polar( cfVector h_X, fVector h_Mag, fVector h_Arg, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VCFstd;
function cudaVCF_polar( d_X:cfVector; d_Mag, d_Arg:fVector; size:UIntSize): IntBool;
procedure VCFcu_polar( h_X:cfVector; h_Mag, h_Arg:fVector; size:UIntSize);
|
|
|
VF_PolartoC | VD_PolartoC | VE_PolartoC |
|
Funktion | Konstruktion eines cartesischen komplexen Vektors aus Polarkoordinaten, die als separate relle Vektoren Mag und Arg eingelesen werden |
|
Syntax C/C++ | #include <VFmath.h>
void VF_PolartoC( cfVector X, fVector Mag, fVector Arg, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<complex<T>>::PolartoC( const vector<T>& Mag, const vector<T>& Arg ); |
Pascal/Delphi | uses VFmath;
procedure VF_PolartoC( X:cfVector; Mag, Arg:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVCFstd.h>
int cudaVF_PolartoC( cfVector d_X, fVector d_Mag, fVector d_Arg, ui size );
void VFcu_PolartoC( cfVector h_X, fVector h_Mag, fVector h_Arg, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VCFstd;
function cudaVF_PolartoC( d_X:cfVector; d_Mag, d_Arg:fVector; size:UIntSize): IntBool;
procedure VFcu_PolartoC( h_X:cfVector; h_Mag, h_Arg:fVector; size:UIntSize);
|
|
Beschreibung | Aus den Polarkoordinaten Mag (Zeigerlänge, Absolutwert) nd Arg (Argument, Zeigerwinkel) werden die cartesischen Koordinaten (Real- und Imaginärteil) von X berechnet.
Der Unterschied zwischen dieser Funktion und VF_PtoC besteht darin, dass bei letzterer ein Eingabevektor des Typs pfVector, hier aber zwei getrennte reelle Vektoren Mag und Arg übergeben werden. |
|
Fehlerbehandlung | Der vollständige Genauigkeitsverlust für sehr große Argi wird stillschweigend durch Wahl der cartesischen Koordinaten {Magi, 0} behandelt. |
|
|
|
VF_poly_d | VF_poly_e | VD_poly_e |
VFx_poly_d | VFx_poly_e | VDx_poly_e |
VF_polyOdd | VD_polyOdd | VE_polyOdd |
VF_polyOdd_d | VF_polyOdd_e | VD_polyOdd_e |
VFx_polyOdd | VDx_polyOdd | VEx_polyOdd |
VFx_polyOdd_d | VFx_polyOdd_e | VDx_polyOdd_e |
VF_polyEven | VD_polyEven | VE_polyEven |
VF_polyEven_d | VF_polyEven_e | VD_polyEven_e |
VFx_polyEven | VDx_polyEven | VEx_polyEven |
VFx_polyEven_d | VFx_polyEven_e | VDx_polyEven_e |
|
|
Syntax C/C++ | #include <VFmath.h>
int VF_poly( fVector Y, fVector X, ui size, fVector Coeff, unsigned deg );
int VFx_poly( fVector Y, fVector X, ui size, fVector Coeff, unsigned deg, float A, float B );
int VFu_poly( fVector Y, fVector X, ui size, fVector Coeff, unsigned deg );
int VFux_poly( fVector Y, fVector X, ui size, fVector Coeff, unsigned deg, float A, float B ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::poly( const vector<T>& X, const vector<T>& Coeff, unsigned deg );
int vector<T>::x_poly( const vector<T>& X, const vector<T>& Coeff, unsigned deg, const T& A, const T& B ); |
Pascal/Delphi | uses VFmath;
function VF_poly( Y, X:fVector; size:UIntSize; Coeff:fVector; deg:UInt ): IntBool;
function VFx_poly( Y, X:fVector; size:UIntSize; Coeff:fVector; deg:UInt; A, B:Single ): IntBool;
function VFu_poly( Y, X:fVector; size:UIntSize; Coeff:fVector; deg:UInt ): IntBool;
function VFux_poly( Y, X:fVector; size:UIntSize; Coeff:fVector; deg:UInt; A, B:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_poly( fVector d_Y, fVector d_X, ui size, fVector h_Coeff, unsigned deg );
int cusdVF_poly( fVector d_Y, fVector d_X, ui size, fVector d_Coeff, unsigned deg );
int cudaVFx_poly( fVector d_Y, fVector d_X, ui size, fVector h_Coeff, unsigned deg, float A, float B );
int cusdVFx_poly( fVector d_Y, fVector d_X, ui size, fVector d_Coeff, unsigned deg, float *d_A, float *d_B );
int cudaVFu_poly( fVector d_Y, fVector d_X, ui size, fVector h_Coeff, unsigned deg );
int cusdVFu_poly( fVector d_Y, fVector d_X, ui size, fVector d_Coeff, unsigned deg );
int cudaVFux_poly( fVector d_Y, fVector d_X, ui size, fVector h_Coeff, unsigned deg, float A, float B );
int cusdVFux_poly( fVector d_Y, fVector d_X, ui size, fVector d_Coeff, unsigned deg, float *d_A, float *d_B );
int VFcu_poly( fVector h_Y, fVector h_X, ui size, fVector h_Coeff, unsigned deg );
int VFxcu_poly( fVector h_Y, fVector h_X, ui size, fVector h_Coeff, unsigned deg, float A, float B );
int VFucu_poly( fVector h_Y, fVector h_X, ui size, fVector h_Coeff, unsigned deg );
int VFuxcu_poly( fVector h_Y, fVector h_X, ui size, fVector h_Coeff, unsigned deg, float A, float B );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_poly( d_Y, d_X:fVector; size:UIntSize; h_Coeff:fVector; deg:UInt ): IntBool;
function cusdVF_poly( d_Y, d_X:fVector; size:UIntSize; d_Coeff:fVector; deg:UInt ): IntBool;
function cudaVFx_poly( d_Y, d_X:fVector; size:UIntSize; h_Coeff:fVector; deg:UInt; A, B:Single ): IntBool;
function cusdVFx_poly( d_Y, d_X:fVector; size:UIntSize; d_Coeff:fVector; deg:UInt; d_A, d_B:PSingle ): IntBool;
function cudaVFu_poly( d_Y, d_X:fVector; size:UIntSize; h_Coeff:fVector; deg:UInt ): IntBool;
function cusdVFu_poly( d_Y, d_X:fVector; size:UIntSize; d_Coeff:fVector; deg:UInt ): IntBool;
function cudaVFux_poly( d_Y, d_X:fVector; size:UIntSize; h_Coeff:fVector; deg:UInt; A, B:Single ): IntBool;
function cusdVFux_poly( d_Y, d_X:fVector; size:UIntSize; d_Coeff:fVector; deg:UInt; d_A, d_B:PSingle ): IntBool;
function VFcu_poly( h_Y, h_X:fVector; size:UIntSize; h_Coeff:fVector; deg:UInt ): IntBool;
function VFxcu_poly( h_Y, h_X:fVector; size:UIntSize; h_Coeff:fVector; deg:UInt; A, B:Single ): IntBool;
function VFucu_poly( h_Y, h_X:fVector; size:UIntSize; h_Coeff:fVector; deg:UInt ): IntBool;
function VFuxcu_poly( h_Y, h_X:fVector; size:UIntSize; h_Coeff:fVector; deg:UInt; A, B:Single ): IntBool;
|
|
Beschreibung | einfache Versionen VF_poly, VD_poly, VE_poly:
Yi = c0 + c1 * Xi + c2 * Xi2 + ... + cn * Xin
erweiterte Versionen VFx_poly, VDx_poly, VEx_poly:
xi = (A*Xi + B),
Yi = c0 + c1 * xi + c2 * xi2 + ... + cn * xin
Ein Polynom vom Grade n = deg wird für jedes Element von X ausgewertet, wobei die Koeffizienten ck dem Vektor Coeff entnommen werden. Coeff muss das konstante Glied c0 als nulltes Element enthalten, den linearen Koeffizienten c1 als erstes Element usw. bis hin zum Koeffizienten cdeg als deg-tem Element. Man hüte sich vor einer häufigen Fehlerquelle und beachte, dass ein Polynom vom Grade deg durch deg+1 Koeffizienten spezifiziert wird (für ein Polynom vierter Ordnung also durch 5 Koeffizienten; man vergesse nicht den konstanten Term, der immer angegeben werden muss, auch wenn er gleich 0 sein sollte).
"ungeschützte" Versionen (Präfix VFu_, VFux_, etc.):
Diese Funktionen führen keinerlei Fehlerbehandlung durch und sind hierdurch bis zu 50% schneller als die Normalversionen.
Da Polynome gerne zum numerischen Überlauf neigen, gelegentlich auch zum Überlauf von Zwischenergebnissen bei noch legalem Endergebnis, bietet OptiVec zusätzliche Versionen, die intern in höherer Genauigkeit rechnen: VF_poly_d und VF_poly_e arbeiten intern in double bzw. extended, bevor das Endergebnis zurück in einfache Genauigkeit gewandelt wird. Analog arbeitet VD_poly_e zunächst extended-genau (dies gilt auch, wenn der Compiler eigentlich gar keine extended-Genauigkeit unterstützt!) und wandelt erst das Endergebnis wieder in double um. Diese Versionen existieren aber nur für die CPU, nicht für CUDA.
In der praktischen Anwendung findet man häfig Polynome, die nur aus ungeraden oder nur aus geraden Termen bestehen. Beispiele hierfür sind die Reihenentwicklung des Sinus (nur ungerade Terme) und des Cosinus (nur gerade Terme). Hierfür dienen in OptiVec die folgenden Funktionen:
VF_polyOdd:
Yi = c1 * Xi + c1 * Xi3 + ... + c(2n+1) * Xi2n+1
Coeff enthält hier (deg+1)/2 Koeffizienten: c1, c3, c5 etc.
VF_polyEven:
Yi = c0 + c2 * Xi2 + ... + c2n * Xi2n
Coeff enthält hier (deg/2)+1 Koeffizienten: c0, c2, c4 etc.
|
|
Fehlerbehandlung | OVERFLOW-Fehler führen zu ±HUGE_VAL als Ergebnisvorschlag. Im Unterschied zu der Funktion poly von ANSI−C (wo deg als int deklariert ist) stellt hier die Deklaration von deg als unsigned sicher, dass zu DOMAIN-Fehlern führende negative Werte von deg ausgeschlossen sind. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0) |
|
|
VF_polyinterpol | VD_polyinterpol | VE_polyinterpol |
|
Funktion | Polynom-Interpolation von X-Y-Tabellenwerten |
|
Syntax C/C++ | #include <VFstd.h>
void VF_polyinterpol( fVector Y, fVector X, ui sizex, fVector XTab, fVector YTab, ui sizetab, unsigned deg ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::polyinterpol( const vector<T>& X, const vector<T>& XTab, const vector<T>& YTab, unsigned deg ); |
Pascal/Delphi | uses VFstd;
procedure VF_polyinterpol( Y, X:fVector; sizex:UIntSize; XTab, YTab:fVector; sizetab:UIntSize; deg:UInt ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_polyinterpol( fVector d_Y, fVector d_X, ui sizex, fVector d_XTab, fVector d_YTab, ui sizetab, unsigned deg );
void VFcu_polyinterpol( fVector h_Y, fVector h_X, ui sizex, fVector h_XTab, fVector h_YTab, ui sizetab, unsigned deg );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_polyinterpol( d_Y, d_X:fVector; sizex:UIntSize; d_XTab, d_YTab:fVector; sizetab:UIntSize; deg:UInt ): IntBool;
procedure VFcu_polyinterpol( h_Y, h_X:fVector; sizex:UIntSize; h_XTab, h_YTab:fVector; sizetab:UIntSize; deg:UInt );
|
|
Beschreibung | Für jedes der sizex Elemente von X wird ein Y-Wert aus vorgegebenen XTab-YTab- Wertepaaren interpoliert. XTab muss geordnet sein (streng aufsteigend oder absteigend). Alle Werte von XTab müssen verschieden sein. Andernfalls kann eine Division durch 0 zum Programmabbruch führen. Für die einzelnen Elemente von X findet die Routine selbst die geeignete Stelle in der Tabelle, an der die Interpolation anzusetzen hat.
Der Parameter deg bezeichnet die Anzahl von in die Interpolation einbezogenen Punkten (also nicht den Grad des interpolierenden Polynoms!). Jeder Wert zwischen 0 und 2 wird als lineare Interpolation ausgeführt. Maximal ist eine 10-Punkt-Interpolation möglich. Außerdem muß sizetab mindestens deg+1 betragen. |
|
Fehlerbehandlung | Werte von deg > 10 führen zu einer Fehlermeldung "Not possible with more than 10 elements" und zum Programmabbruch. Wenn deg größer ist als sizetab−1, wird die Meldung "Invalid parameter(s)" ausgegeben und das Programm ebenfalls abgebrochen.
Andere Fehler werden nicht detektiert (Sie müssen also selbst Sorge tragen, dass XTab geordnet ist, dass alle XTab-Werte verschieden sind und dass die YTab-Werte nicht zu dicht an der Überlauf-Grenze liegen). |
|
|
|
VCF_powReExpo | VCD_powReExpo | VCE_powReExpo |
VCFx_powReExpo | VCDx_powReExpo | VCEx_powReExpo |
VPF_powReExpo | VPD_powReExpo | VPE_powReExpo |
|
Funktion | beliebige reelle oder komplexe Potenzen |
|
Syntax C/C++ | #include <VFmath.h>
int VF_pow( fVector Y, fVector X, ui size, float Expo );
int VFx_pow( fVector Y, fVector X, ui size, float Expo, float A, float B, float C );
int VCF_pow( cfVector Y, cfVector X, ui size, fComplex Expo );
int VCFx_pow( cfVector Y, cfVector X, ui size, fComplex Expo, fComplex A, fComplex B, fComplex C );
int VCF_powReExpo( cfVector Y, cfVector X, ui size, float Expo );
int VCFx_powReExpo( cfVector Y, cfVector X, ui size, float Expo, fComplex A, fComplex B, fComplex C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::pow( const vector<T>& X, const T& Expo );
int vector<T>::x_pow( const vector<T>& X, const T& Expo, const T& A, const T& B, const T& C );
int vector<complex<T>>::pow( const vector<complex<T>>& X, complex<T> Expo );
int vector<complex<T>>::x_pow( const vector<complex<T>>& X, complex<T> Expo, complex<T> A, complex<T> B, complex<T> C );
int vector<complex<T>>::powReExpo( const vector<complex<T>>& X, const T& Expo );
int vector<complex<T>>::x_powReExpo( const vector<complex<T>>& X, const T& Expo, complex<T> A, complex<T> B, complex<T> C ); |
Pascal/Delphi | uses VFmath;
function VF_pow( Y, X:fVector; size:UIntSize; Expo:Single ): IntBool;
function VFx_pow( Y, X:fVector; size:UIntSize; Expo, A, B, C:Single ): IntBool;
function VCF_pow( Y, X:cfVector; size:UIntSize; Expo:fComplex ): IntBool;
function VCF_powReExpo( Y, X:cfVector; size:UIntSize; Expo:Single ): IntBool;
function VCFx_powReExpo( Y, X:cfVector; size:UIntSize; Expo:Single; A, B, C:fComplex ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_pow( fVector d_Y, fVector d_X, ui size, float Expo );
int cudaVFx_pow( fVector d_Y, fVector d_X, ui size, float Expo, float A, float B, float C );
int cusdVFx_pow( fVector d_Y, fVector d_X, ui size, float Expo, float *_dA, float *d_B, float *d_C );
int VFcu_pow( fVector h_Y, fVector h_X, ui size, float Expo );
int VFxcu_pow( fVector h_Y, fVector h_X, ui size, float Expo, float A, float B, float C );
#include <cudaVCFmath.h>
int cudaVCF_pow( cfVector d_Y, cfVector d_X, ui size, fComplex Expo );
int cudaVCFx_pow( cfVector d_Y, cfVector d_X, ui size, fComplex Expo, fComplex A, fComplex B, fComplex C );
int cusdVCFx_pow( cfVector d_Y, cfVector d_X, ui size, fComplex Expo, fComplex *d_A, fComplex *d_B, fComplex *d_C );
int cudaVCF_powReExpo( cfVector d_Y, cfVector d_X, ui size, float Expo );
int cudaVCFx_powReExpo( cfVector d_Y, cfVector d_X, ui size, float Expo, fComplex A, fComplex B, fComplex C );
int cusdVCFx_powReExpo( cfVector d_Y, cfVector d_X, ui size, float Expo, fComplex *d_A, fComplex *d_B, fComplex *d_C );
int VCFcu_pow( cfVector h_Y, cfVector h_X, ui size, fComplex Expo );
int VCFxcu_pow( cfVector h_Y, cfVector h_X, ui size, fComplex Expo, fComplex A, fComplex B, fComplex C );
int VCFcu_powReExpo( cfVector h_Y, cfVector h_X, ui size, float Expo );
int VCFxcu_powReExpo( cfVector h_Y, cfVector h_X, ui size, float Expo, fComplex A, fComplex B, fComplex C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_pow( d_Y, d_X:fVector; size:UIntSize; Expo:Single ): IntBool;
function cudaVFx_pow( d_Y, d_X:fVector; size:UIntSize; Expo:Single; A, B, C:Single ): IntBool;
function cusdVFx_pow( d_Y, d_X:fVector; size:UIntSize; Expo:Single; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_pow( h_Y, h_X:fVector; size:UIntSize; Expo:Single ): IntBool;
function VFxcu_pow( h_Y, h_X:fVector; size:UIntSize; Expo:Single; A, B, C:Single ): IntBool;
uses VCFmath;
int cudaVCF_pow( cfVector d_Y, cfVector d_X, ui size, fComplex Expo );
int cudaVCFx_pow( cfVector d_Y, cfVector d_X, ui size, fComplex Expo, fComplex A, fComplex B, fComplex C );
int cusdVCFx_pow( cfVector d_Y, cfVector d_X, ui size, fComplex Expo, fComplex *d_A, fComplex *d_B, fComplex *d_C );
int cudaVCF_powReExpo( cfVector d_Y, cfVector d_X, ui size, float Expo );
int cudaVCFx_powReExpo( cfVector d_Y, cfVector d_X, ui size, float Expo, fComplex A, fComplex B, fComplex C );
int cusdVCFx_powReExpo( cfVector d_Y, cfVector d_X, ui size, float Expo, fComplex *d_A, fComplex *d_B, fComplex *d_C );
int VCFcu_pow( cfVector h_Y, cfVector h_X, ui size, fComplex Expo );
int VCFxcu_pow( cfVector h_Y, cfVector h_X, ui size, fComplex Expo, fComplex A, fComplex B, fComplex C );
int VCFcu_powReExpo( cfVector h_Y, cfVector h_X, ui size, float Expo );
int VCFxcu_powReExpo( cfVector h_Y, cfVector h_X, ui size, float Expo, fComplex A, fComplex B, fComplex C );
|
|
Beschreibung | einfache Versionen: Yi = Xi Expo
erweiterte Versionen: Yi = C * ((A*Xi+B) Expo)
Wenn Expo eine nicht zu große ganze Zahl ist, reicht VF_pow die gestellte Aufgabe an VF_ipow weiter. Effizienter sollte man dies schon beim Programmieren tun.
Die komplexe Version existiert in zwei Varianten: einer für komplexe (VCF_pow) und einer für reelle Exponenten (VCF_powReExpo). |
|
Fehlerbehandlung | DOMAIN-Fehler entstehen für bruchzahlige Potenzen negativer Zahlen. Das vorgeschlagene Ergebnis ist NAN ("not-a-number"). SING-Fehler entstehen durch negative Potenzen von 0. Das vorgeschlagene Resultat ist hier ±HUGE_VAL, ebenso wie für OVERFLOW-Fehler. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0) |
|
|
VFx_pow10 | VDx_pow10 | VEx_pow10 |
|
Funktion | reelle Potenzen von 10 |
|
Syntax C/C++ | #include <VFmath.h>
int VF_pow10( fVector Y, fVector X, ui size );
int VFx_pow10( fVector Y, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::pow10( const vector<T>& X );
int vector<T>::x_pow10( const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_pow10( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_pow10( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_pow10( fVector d_Y, fVector d_X, ui size );
int cudaVFx_pow10( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_pow10( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_pow10( fVector h_Y, fVector h_X, ui size );
int VFxcu_pow10( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_pow10( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_pow10( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_pow10( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_pow10( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_pow10( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = 10.0 Xi
erweiterte Versionen: Yi = C * 10.0A*Xi+B
Dies ist eine Exponentialfunktion zur Basis 10 |
|
Fehlerbehandlung | OVERFLOW-Fehler ergeben ±HUGE_VAL. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0) |
|
|
|
Funktion | reelle Potenzen von 2 |
|
Syntax C/C++ | #include <VFmath.h>
int VF_pow2( fVector Y, fVector X, ui size );
int VFx_pow2( fVector Y, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::pow2( const vector<T>& X );
int vector<T>::x_pow2( const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_pow2( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_pow2( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_pow2( fVector d_Y, fVector d_X, ui size );
int cudaVFx_pow2( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_pow2( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_pow2( fVector h_Y, fVector h_X, ui size );
int VFxcu_pow2( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_pow2( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_pow2( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_pow2( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_pow2( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_pow2( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = 2.0 Xi
erweiterte Versionen: Yi = C * 2.0A*Xi+B
Dies ist eine Exponentialfunktion zur Basis 2. |
|
Fehlerbehandlung | OVERFLOW-Fehler ergeben ±HUGE_VAL. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0) |
|
|
VF_powexp | VD_powexp | VE_powexp |
VFx_powexp | VDx_powexp | VEx_powexp |
|
Funktion | reelle Potenz, multipliziert mit Exponentialfunktion |
|
Syntax C/C++ | #include <VFmath.h>
int VF_powexp( fVector Y, fVector X, ui size, float Expo );
int VFx_powexp( fVector Y, fVector X, ui size, float Expo, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::powexp( const vector<T>& X, const T& Expo );
int vector<T>::x_powexp( const vector<T>& X, const T& Expo, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_powexp( Y, X:fVector; size:UIntSize; Expo:Single ): IntBool;
function VFx_powexp( Y, X:fVector; size:UIntSize; Expo, A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_powexp( fVector d_Y, fVector d_X, ui size, float Expo );
int cudaVFx_powexp( fVector d_Y, fVector d_X, ui size, float Expo, float A, float B, float C );
int cusdVFx_powexp( fVector d_Y, fVector d_X, ui size, float Expo, float *_dA, float *d_B, float *d_C );
int VFcu_powexp( fVector h_Y, fVector h_X, ui size, float Expo );
int VFxcu_powexp( fVector h_Y, fVector h_X, ui size, float Expo, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_powexp( d_Y, d_X:fVector; size:UIntSize; Expo:Single ): IntBool;
function cudaVFx_powexp( d_Y, d_X:fVector; size:UIntSize; Expo:Single; A, B, C:Single ): IntBool;
function cusdVFx_powexp( d_Y, d_X:fVector; size:UIntSize; Expo:Single; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_powexp( h_Y, h_X:fVector; size:UIntSize; Expo:Single ): IntBool;
function VFxcu_powexp( h_Y, h_X:fVector; size:UIntSize; Expo:Single; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = XiExpo * exp(Xi)
erweiterte Versionen: Yi = C * (XiExpo) * exp(A*Xi+B)
Man beachte, dass die erweiterten Versionen (A*Xi+B) nur als Argument der Exponentialfunktion verwenden, die Potenzfunktion aber für (Xi) berechnen. Die Implementation dieser Funktion garantiert den korrekten Ausgleich eventueller gleichzeitiger Über- und Unterläufe in den beiden Faktoren (d.h. für große Xi, wenn entweder Expo oder A*Xi negativ sind, so dass entweder die Potenzfunktion oder die Exponentialfunktion sehr klein wird, während die jeweils andere sehr groß wird).
Anders als bei VF_pow werden negative X-Werte in der Potenzfunktion stets als DOMAIN-Fehler behandelt; es findet also keine Prüfung statt, ob der Exponent vielleicht ganzzahlig ist und das Ergebnis daher doch berechenbar wäre. |
|
Fehlerbehandlung | DOMAIN-Fehler entstehen für negative Xi. Das vorgeschlagene Ergebnis ist NAN ("not-a-number"). SING-Fehler entstehen durch negative Potenzen von 0. Das vorgeschlagene Resultat ist hier ±HUGE_VAL, ebenso wie für OVERFLOW-Fehler. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0) |
|
|
VPF_principal | VPD_principal | VPE_principal |
|
Funktion | Hauptwert polar-komplexer Zahlen |
|
Syntax C/C++ | #include <VPFstd.h>
void VPF_principal( pfVector Y, pfVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<polar<T>>::principal( const vector<polar<T>>& X ); |
Pascal/Delphi | uses VPFstd;
procedure VPF_principal( Y, X:pfVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVPFstd.h>
int cudaVPF_principal( pfVector d_Y, pfVector d_X, ui size );
void VPFcu_principal( pfVector d_Y, pfVector d_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VPFstd;
function cudaVPF_principal( h_Y, h_X:pfVector; size:UIntSize ): IntBool;
procedure VPFcu_principal( h_Y, h_X:pfVector; size:UIntSize );
|
|
Beschreibung | Das Argument, d.h. der Zeigerwinkel jedes Elementes wird auf den Bereich -p < Arg ≤ +p normiert. |
|
|
|
|
VCF_print | VCD_print | VCE_print |
VI_print | VBI_print | VSI_print | VLI_print | VQI_print | |
VU_print | VUB_print | VUS_print | VUL_print | VUQ_print | VUI_print |
|
Funktion | Vektor als ASCII-Zahlen nach stdout ausgeben (nur für Konsolen-Anwendungen) |
|
Syntax C/C++ | #include <VFstd.h>
void VF_print( fVector X, ui size, unsigned nperline ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::print( unsigned nperline ); |
Pascal/Delphi | uses VFstd;
procedure VF_print( X:fVector; size:UIntSize; nperline:UInt ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_print( fVector d_X, ui size, unsigned nperline );
int cudaVF_print_buf( fVector d_X, ui size, unsigned nperline, fVector h_Wk );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_print( d_X:fVector; size:UIntSize; nperline:UInt ): IntBool;
function cudaVF_print_buf( d_X:fVector; size:UIntSize; nperline:UInt; h_Wk:fVector ): IntBool;
|
|
Beschreibung | size Elemente von X werden nach stdout ausgegeben, nperline in jeder Zeile.
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;
Zu Beginn jeder Zeile steht der Index des ersten in diese Zeile geschriebenen Elementes. Danach folgen ein Doppelpunkt und die verlangten nperline Elemente des Vektors X.
Komplexe Zahlen werden in geschweifte Klammern gefaßt. Bei cartesisch-komplexen Zahlen wird der Imaginärteil durch ein Komma vom Realteil getrennt: {Re, Im}. Mag- und Arg-Teil polar-komplexer Zahlen werden durch ein at-Zeichen getrennt: {Re @ Im}.
Die Ausgabe beginnt immer mit einer neuen Zeile. Anders als bei VF_cprint wird kein Seitenumbruch durchgeführt.
Die Anzahl pro Element ausgegebener Stellen richtet sich nach dem pro Element zur Verfügung stehenden Platz, also nach der Zeilenlänge und dem Parameter nperline.
nur CUDA-Versionen: cudaV?_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 cudaV?_print eingespart, so dass cudaV?_print_buf etwas schneller ist.
Diese Funktionen-Familie kann nur im Zusammenhang mit Konsolenanwendungen gebraucht werden. |
|
Fehlerbehandlung | Wenn nperline die Zahl der maximal innerhalb der zur Verfügung stehenden Zeilenlänge möglichen Einträge übersteigt, wird eine Warnung "Cannot use requested format (too many entries per line)." angezeigt und die Ausgabe mit der maximal möglichen Zahl von Einträgen pro Zeile durchgeführt. |
|
|
|
|
Funktion | Ausgabe einer Fehlermeldung |
|
Syntax C/C++ | #include <VecLib.h>
void V_printErrorMsg( char *ErrMsg ); |
Pascal/Delphi | uses VecLib;
procedure V_printErrMsg( ErrMsg: PChar ); |
|
Beschreibung | ErrMsg zeigt auf die auszugebende Meldung. Standardmäßig erfolgt die Ausgabe auf den Bildschirm. Sie kann jedoch durch vorherigen Aufruf von V_setErrorEventFile in eine Ereignis-Datei umgeleitet werden. V_printErrorMsg steht Anwenderprogrammen zur Verfügung, deren Fehlermeldungen in identischer Weise wie die der OptiVec- Funktionen ausgegeben werden sollen. Gegebenenfalls sind Zeilenumbrüche ("\n" oder "\r\n" für C/C++, #13 für Pascal/Delphi) in die Meldung einzufügen. |
|
|
|
|
Funktion | Produkt sämtlicher Elemente eines Vektors |
|
Syntax C/C++ | #include <VFstd.h>
float VF_prod( fVector X, ui size );
fComplex VCF_prod( cfVector X, ui size );
fPolar VPF_prod( pfVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::prod();
complex<T> vector<complex<T>>::prod();
polar<T> vector<polar<T>>::prod(); |
Pascal/Delphi | uses VFstd;
function VF_prod( X:fVector; size:UIntSize ): Single;
procedure VCF_prod( var Prod:fComplex; X:cfVector; size:UIntSize);
procedure VPF_prod( var Prod:fPolar; X:pfVector; size:UIntSize); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_prod( float *h_RetVal, fVector d_X, ui size );
int cusdVF_prod( float *d_RetVal, fVector d_X, ui size );
float VFcu_prod( fVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_prod( var h_RetVal:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_prod( d_RetVal:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_prod( h_X:fVector; size:UIntSize ): Single;
|
|
Beschreibung | Alle Vektorelemente vom Index 0 bis zum Index size−1 werden miteinander multipliziert und das Ergebnis zurückgegeben.
nur Pascal/Delphi: Da die komplexen Datentypen in Pascal/Delphi nicht als Rückgabewerte zulässig sind, werden die Ergebnisse der komplexen Versionen hier in der Variablen Prod gespeichert. |
|
Fehlerbehandlung | keine (aber Vorsicht: diese Funktion neigt zum Über- oder Unterlauf!) |
|
Rückgabewert | Produkt der Vektorelemente (außer komplexe Versionen in Pascal/Delphi) |
|
|
VF_PtoAbs | VD_PtoAbs | VE_PtoAbs |
|
Funktion | Absolutwert (Zeigerlänge) polar-komplexer Zahlen |
|
Syntax C/C++ | #include <VPFstd.h>
void VF_PtoAbs( fVector Abs, pfVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::PtoAbs( const vector<polar<T>>& X ); |
Pascal/Delphi | uses VPFstd;
procedure VF_PtoAbs( Abs:fVector; X:pfVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVPFstd.h>
int cudaVF_PtoAbs( fVector d_Abs, pfVector d_X, ui size );
void VFcu_PtoAbs( fVector h_Abs, pfVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VPFstd;
function cudaVF_PtoAbs( d_Abs:fVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoAbs( h_Abs:fVector; h_X:pfVector; size:UIntSize );
|
|
Beschreibung | Der Absolutwert, d.h. die Zeigerlänge jedes Elementes des polar-komplexen Vektors X wird extrahiert. Diese Funktion ist identisch mit VPF_abs und VF_PtoMag. Aus "historischen Gründen" wurden alle drei Funktionsnamen beibehalten. |
|
|
|
|
VF_PtoArg | VD_PtoArg | VE_PtoArg |
|
Funktion | Argument (Zeigerwinkel) polar-komplexer Zahlen |
|
Syntax C/C++ | #include <VPFstd.h>
void VF_PtoArg( fVector Arg, pfVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::PtoArg( const vector<polar<T>>& X ); |
Pascal/Delphi | uses VPFstd;
procedure VF_PtoArg( Arg:fVector; X:pfVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVPFstd.h>
int cudaVF_PtoArg( fVector d_Arg, pfVector d_X, ui size );
void VFcu_PtoArg( fVector h_Arg, pfVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VPFstd;
function cudaVF_PtoArg( d_Arg:fVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoArg( h_Arg:fVector; h_X:pfVector; size:UIntSize );
|
|
Beschreibung | Das Argument, d.h. der Zeigerwinkel jedes Elementes des polar-komplexen Vektors X wird extrahiert. Im Unterschied zu der analogen Funktion für cartesisch-komplexe Vektoren, VF_CtoArg, wird hier keine Normalisierung des Winkels durchgeführt. Wird sie gewünscht, ist VPF_principal vor VF_PtoArg aufzurufen. |
|
|
|
|
|
Funktion | Umwandlung komplexer Zahlen von Polarkoordinaten in cartesische Koordinaten |
|
Syntax C/C++ | #include <VPFstd.h>
void VF_PtoC( cfVector Y, pfVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<complex<T>>::PtoC( const vector<polar<T>>& X ); |
Pascal/Delphi | uses VPFstd;
procedure VF_PtoC( Y:cfVector; X:pfVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVPFstd.h>
int cudaVF_PtoC( cfVector d_Y, pfVector d_X, ui size );
void VFcu_PtoC( cfVector h_Y, pfVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VPFstd;
function cudaVF_PtoC( d_Abs:cfVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoC( h_Abs:cfVector; h_X:pfVector; size:UIntSize );
|
|
Beschreibung | X wird aus Polarkoordinaten {Mag @ Arg} in cartesische Koordinaten {Re, Im} umgewandelt. |
|
|
|
|
|
Funktion | Imaginärteil eines polar-komplexen Vektors extrahieren |
|
Syntax C/C++ | #include <VPFstd.h>
void VF_PtoIm( fVector Im, pfVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::PtoIm( const vector<polar<T>>& X ); |
Pascal/Delphi | uses VPFstd;
procedure VF_PtoIm( Im:fVector; X:pfVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVPFstd.h>
int cudaVF_PtoIm( fVector d_Im, pfVector d_X, ui size );
void VFcu_PtoIm( fVector h_Im, pfVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VPFstd;
function cudaVF_PtoIm( d_Im:fVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoIm( h_Im:fVector; h_X:pfVector; size:UIntSize );
|
|
Beschreibung | Der Imaginärteil des polar-komplexen Vektors X wird berechnet und in Im gespeichert. |
|
|
|
|
VF_PtoMag | VD_PtoMag | VE_PtoMag |
|
Funktion | Zeigerlänge polar-komplexer Zahlen extrahieren |
|
Syntax C/C++ | #include <VPFstd.h>
void VF_PtoMag( fVector Mag, pfVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::PtoMag( const vector<polar<T>>& X ); |
Pascal/Delphi | uses VPFstd;
procedure VF_PtoMag( Mag:fVector; X:pfVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVPFstd.h>
int cudaVF_PtoMag( fVector d_Mag, pfVector d_X, ui size );
void VFcu_PtoMag( fVector h_Mag, pfVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VPFstd;
function cudaVF_PtoMag( d_Mag:fVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoMag( h_Mag:fVector; h_X:pfVector; size:UIntSize );
|
|
Beschreibung | Die Zeigerlänge jedes Elementes von X wird extrahiert und in Mag gespeichert. |
|
|
|
|
VF_PtoMagArg | VD_PtoMagArg | VE_PtoMagArg |
|
Funktion | Aufspaltung eines polar-komplexen Vektors in getrennte Vektoren für Zeigerlängen und Zeigerwinkel |
|
Syntax C/C++ | #include <VPFstd.h>
void VF_PtoMagArg( fVector Mag, fVector Arg, pfVector X, ui size); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::PtoMagArg( vector<T> Arg, const vector<polar<T>>& X ); |
Pascal/Delphi | uses VPFstd;
procedure VF_PtoMagArg( Mag, Arg:fVector; X:pfVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVPFstd.h>
int cudaVF_PtoMagArg( fVector d_Mag, fVector d_Arg, pfVector d_X, ui size );
void VFcu_PtoMagArg( fVector h_Mag, fVector h_Arg, pfVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VPFstd;
function cudaVF_PtoMagArg( d_Mag, d_Arg:fVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoMagArg( h_Mag, h_Arg:fVector; h_X:pfVector; size:UIntSize );
|
|
Beschreibung | Die Mag- und Arg- Teile des polar-komplexen Vektors X werden extrahiert und in getrennten Vektoren Mag und Arg abgelegt. |
|
|
|
|
VF_PtoNorm | VD_PtoNorm | VE_PtoNorm |
|
Funktion | Norm (Quadrat der Zeigerlänge) polar-komplexer Zahlen |
|
Syntax C/C++ | #include <VPFstd.h>
void VF_PtoNorm( fVector Norm, pfVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::PtoNorm( const vector<polar<T>>& X ); |
Pascal/Delphi | uses VPFstd;
procedure VF_PtoNorm( Norm:fVector; X:pfVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVPFstd.h>
int cudaVF_PtoNorm( fVector d_Norm, pfVector d_X, ui size );
void VFcu_PtoNorm( fVector h_Norm, pfVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VPFstd;
function cudaVF_PtoNorm( d_Norm:fVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoNorm( h_Norm:fVector; h_X:pfVector; size:UIntSize );
|
|
Beschreibung | Normi = Mag2(Xi)
Diese Definition der Norm komplexer Zahlen folgt derjenigen von C++. Dies ist allerdings nicht die in der Mathematik übliche Definition, wo der Begriff "Norm" als Synonym für den Absolutwert, also die Zeigerlänge steht (und nicht wie hier deren Quadrat). Die Zeigerlänge selbst ist durch VPF_abs erhältlich. |
|
|
|
|
|
Funktion | Realteil eines polar-komplexen Vektors extrahieren |
|
Syntax C/C++ | #include <VPFstd.h>
void VF_PtoRe( fVector Re, pfVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::PtoRe( const vector<polar<T>>& X ); |
Pascal/Delphi | uses VPFstd;
procedure VF_PtoRe( Re:fVector; X:pfVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVPFstd.h>
int cudaVF_PtoRe( fVector d_Re, pfVector d_X, ui size );
void VFcu_PtoRe( fVector h_Re, pfVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VPFstd;
function cudaVF_PtoRe( d_Re:fVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoRe( h_Re:fVector; h_X:pfVector; size:UIntSize );
|
|
Beschreibung | Der Realteil des polar-komplexen Vektors X wird berechnet und in Re gespeichert. |
|
|
|
|
VF_PtoReIm | VD_PtoReIm | VE_PtoReIm |
|
Funktion | Real- und Imaginärteil eines polar-komplexen Vektors |
|
Syntax C/C++ | #include <VPFstd.h>
void VF_PtoReIm( fVector Re, fVector Im, pfVector X, ui size); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::PtoReIm( vector<T> Im, const vector<polar<T>>& X ); |
Pascal/Delphi | uses VPFstd;
procedure VF_PtoReIm( Re, Im:fVector; X:pfVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVPFstd.h>
int cudaVF_PtoReIm( fVector d_Re, fVector d_Im, pfVector d_X, ui size );
void VFcu_PtoReIm( fVector h_Re, fVector h_Im, pfVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VPFstd;
function cudaVF_PtoReIm( d_Re, d_Im:fVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoReIm( h_Re, h_Im:fVector; h_X:pfVector; size:UIntSize );
|
|
Beschreibung | Der polar-komplexe Vektor X wird in cartesische Koordinaten umgewandelt, die in getrennten Vektoren Re und Im gespeichert werden. |
|
|
|
|
VF_quartic | VD_quartic | VE_quartic |
VFx_quartic | VDx_quartic | VEx_quartic |
VFu_quartic | VDu_quartic | VEu_quartic |
VFux_quartic | VDux_quartic | VEux_quartic |
VCF_quartic | VCD_quartic | VCE_quartic |
VCFx_quartic | VCDx_quartic | VCEx_quartic |
VCFu_quartic | VCDu_quartic | VCEu_quartic |
VCFux_quartic | VCDux_quartic | VCEux_quartic |
VPF_quartic | VPD_quartic | VPE_quartic |
VPFu_quartic | VPDu_quartic | VPEu_quartic |
|
|
Syntax C/C++ | #include <VFmath.h>
int VF_quartic( fVector Y, fVector X, ui size );
int VFx_quartic( fVector Y, fVector X, ui size, float A, float B );
int VFu_quartic( fVector Y, fVector X, ui size );
int VFux_quartic( fVector Y, fVector X, ui size, float A, float B ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::quartic( const vector<T>& X );
int vector<T>::x_quartic( const vector<T>& X, const T& A, const T& B );
int vector<T>::u_quartic( const vector<T>& X );
int vector<T>::ux_quartic( const vector<T>& X, const T& A, const T& B ); |
Pascal/Delphi | uses VFmath;
function VF_quartic( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_quartic( Y, X:fVector; size:UIntSize; A, B:Single ): IntBool;
function VFu_quartic( Y, X:fVector; size:UIntSize ): IntBool;
function VFux_quartic( Y, X:fVector; size:UIntSize; A, B:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_quartic( fVector d_Y, fVector d_X, ui size );
int cudaVFx_quartic( fVector d_Y, fVector d_X, ui size, float A, float B );
int cusdVFx_quartic( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B );
int VFucu_quartic( fVector h_Y, fVector h_X, ui size );
int VFuxcu_quartic( fVector h_Y, fVector h_X, ui size, float A, float B );
int cudaVFu_quartic( fVector d_Y, fVector d_X, ui size );
int cudaVFux_quartic( fVector d_Y, fVector d_X, ui size, float A, float B );
int cusdVFux_quartic( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B );
int VFucu_quartic( fVector h_Y, fVector h_X, ui size );
int VFuxcu_quartic( fVector h_Y, fVector h_X, ui size, float A, float B );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_quartic( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_quartic( d_Y, d_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_quartic( d_Y, d_X:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function VFcu_quartic( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_quartic( h_Y, h_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cudaVFu_quartic( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFux_quartic( d_Y, d_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFux_quartic( d_Y, d_X:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function VFucu_quartic( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFuxcu_quartic( h_Y, h_X:fVector; size:UIntSize; A, B:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = Xi4
erweiterte Versionen: Yi = (A*Xi+B)4
Die vierte Potenz der Elemente von X wird in Y gespeichert.
Die "ungeschützten" Versionen (Präfix VFu_, VFux_ etc.) führen keinerlei Fehlerbehandlung durch, wodurch sie deutlich schneller als die Standardversionen werden, allerdings riskanter. Die ungeschützten cartesisch-komplexen Versionen in extended-Genauigkeit (VCEu_, VCEux_) verzichten darüberhinaus auf einige Schutzmaßnahmen für sehr große Zahlen. Sie können daher bei sehr nahe an der Überlauf-Grenze liegenden Ergebnissen abstürzen; Ergebnisse nahe der Unterlauf-Grenze können als 0 erscheinen. |
|
Fehlerbehandlung | OVERFLOW-Fehler ergeben HUGE_VAL. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0) |
|
|
VI_ramp | VBI_ramp | VSI_ramp | VLI_ramp | VQI_ramp | |
VU_ramp | VUB_ramp | VUS_ramp | VUL_ramp | VUQ_ramp | VUI_ramp |
|
Funktion | aufsteigende oder absteigende "Rampe" |
|
Syntax C/C++ | #include <VFstd.h>
void VF_ramp( fVector X, ui size, float Start, float Rise );
(analog VD_, VE_, VCF_, VCD_, VCE_, VI_ etc.)
void VU_ramp( uVector X, ui size, unsigned Start, int Rise );
(analog VUB_, VUS_, VUL_) |
C++ VecObj | #include <OptiVec.h>
void vector<T>::ramp( T Start, T Rise );
void vector<unsigned>::ramp( unsigned Start, int Rise ); |
Pascal/Delphi | uses VFstd;
procedure VF_ramp( X:fVector; size:UIntSize; Start, Rise:Single );
(analog VD_, VE_, VCF_, VCD_, VCE_, VI_ etc.)
procedure VU_ramp( X:uVector; size:UIntSize; Start:UInt; Rise:Integer );
(analog VUB_, VUS_, VUL_) |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_ramp( fVector d_X, ui size, float Start, float Rise );
int cusdVF_ramp( fVector d_X, ui size, float *d_Start, float *d_Rise );
void VFcu_ramp( fVector h_X, ui size, float Start, float Rise );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_ramp( d_X:fVector; size:UIntSize; Start, Rise:Single ): IntBool;
function cusdVF_ramp( d_X:fVector; size:UIntSize; d_Start, d_Rise:PSingle ): IntBool;
procedure VFcu_ramp( h_X:fVector; size:UIntSize; Start, Rise:Single );
|
|
Beschreibung | Xi = Start + i * Rise
Bei den Fließkomma-Versionen behalte man die begrenzte Genauigkeit von Fließkomma-Zahlen im Auge. So wird beispielsweise nach dem Aufruf von
VF_ramp( F1, 101, −1.0, 0.01 );
das Element F1[100] nicht - wie vielleicht erhofft - 0.0 sein, sondern 2.2*10-8. Dies ist kein Fehler von VectorLib, sondern kommt daher, dass die als float an die Funktion übergebene Zahl 0.01 als float gar nicht exakt dargestellt werden kann. Wenn daraus Probleme erwachsen, baue man die Rampe zunächst mit nicht zu großen Ganzzahlen auf und dividiere anschließend durch einen geeigneten Nenner:
VF_ramp( F1, 101, −100.0, 1.0 );
VF_divC( F1, F1, 101, 100.0 );
In den Versionen für vorzeichenlose Ganzzahl-Typen beachte man, dass Rise als vorzeichenbehafteter Typ definiert ist (also z.B. als int anstelle von unsigned in der VU_- Version). Hierdurch werden absteigende Rampen auch in den vorzeichenlosen Versionen ermöglicht. |
|
Fehlerbehandlung | Fließkomma-Versionen: keine;
Ganzzahl-Versionen: siehe Kap. 5.2. |
|
|
|
VF_random | VD_random | VE_random |
VCF_random | VCD_random | VCE_random |
VI_random | VBI_random | VSI_random | VLI_random | VQI_random | |
VU_random | VUB_random | VUS_random | VUL_random | VUQ_random | VUI_random |
|
Funktion | gleichverteilte Zufallszahlen hoher Qualität |
|
Syntax C/C++ | #include <VFstd.h>
long VF_random( fVector X, ui siz, long seed, float MinVal, float MaxVal ); |
C++ VecObj | #include <OptiVec.h>
long vector<T>::random( long seed, T MinVal, T MaxVal ); |
Pascal/Delphi | uses VFstd;
function VF_random( X:fVector; size:UIntSize; seed:LongInt; MinVal, MaxVal:Single ): LongInt; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_random( fVector d_X, ui siz, long seed, float MinVal, float MaxVal );
int cusdVF_random( fVector d_X, ui siz, long seed, float *d_MinVal, float *d_MaxVal );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_random( d_X:fVector; size:UIntSize; seed:LongInt; MinVal, MaxVal:Single ): IntBool;
function cusdVF_random( d_X:fVector; size:UIntSize; seed:LongInt; d_MinVal, d_MaxVal:PSingle ): IntBool;
|
|
Beschreibung | X 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 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 für die kleineren Datentypen einen 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, die diejenige von einfacheren Generatoren wie der C/C++-Funktion rand oder der Pascal-Funktion Random bei weitem übertrifft. 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!
Ein long-Wert wird zurückgegeben, der als neuer seed-Wert für spätere Aufrufe verwendet werden kann. Dabei setzt der neue Aufruf allerdings nicht einfach die vorherige Serie fort, da der Generator sich zuerst intern erneut initialisieren muss. Wenn Fortsetzbarkeit der Serie gewünscht wird, verwende man statt dieser Funktion VF_randomLC.
Die CUDA-Versionen dieser Funktion geben keinen neuen seed-Wert zurück, sondern den üblichen cudaOptiVec-Fehlercode.
Es gibt keine VFcu_-Version, da die Zufallszahlen bei diesem Algorithmus ohnehin auf der CPU erzeugt werden. |
|
|
Rückgabewert | letzte intern generierte 32-bit-Zufallszahl; kann als neuer Startwert für spätere Aufrufe verwandt werden |
|
|
VF_randomLC | VD_randomLC | VE_randomLC |
VCF_randomLC | VCD_randomLC | VCE_randomLC |
VI_randomLC | VBI_randomLC | VSI_randomLC | VLI_randomLC | VQI_randomLC | |
VU_randomLC | VUB_randomLC | VUS_randomLC | VUL_randomLC | VUQ_randomLC | VUI_randomLC |
|
Funktion | gleichverteilte Zufallszahlen hoher Qualität |
|
Syntax C/C++ | #include <VFstd.h>
void VF_randomLC( fVector X, ui siz, long seed, float MinVal, float MaxVal, V_RANDOMLCSTATE *state ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::randomLC( long seed, T MinVal, T MaxVal, V_RANDOMLCSTATE *state ); |
Pascal/Delphi | uses VFstd;
procedure VF_randomLC( X:fVector; size:UIntSize; seed:LongInt; MinVal, MaxVal:Single; state:PV_RANDOMLCSTATE ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_randomLC( fVector d_X, ui siz, long seed, float MinVal, float MaxVal, V_RANDOMLCSTATE *h_state );
int cusdVF_randomLC( fVector d_X, ui siz, long seed, float *d_MinVal, float *d_MaxVal, V_RANDOMLCSTATE *h_state );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_randomLC( d_X:fVector; size:UIntSize; seed:LongInt; MinVal, MaxVal:Single; h_state:PV_RANDOMLCSTATE ): IntBool;
function cusdVF_randomLC( d_X:fVector; size:UIntSize; seed:LongInt; d_MinVal, d_MaxVal:PSingle; h_state:PV_RANDOMLCSTATE ): IntBool;
|
|
Beschreibung | X 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, die diejenige von einfacheren Generatoren wie der C/C++-Funktion rand oder der Pascal-Funktion Random bei weitem übertrifft. 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 VF_random zur Verfügung.
|
|
Beispiel C/C++ | #include <VFstd.h>
V_RANDOMLCSTATE MyState; // Speicherplatz für Generator-Zustand
VF_randomLC( X, siz/2, −1111, −1.0, +1.0, &MyState ); // Initialisierung mit seed ≠ 0 und erste Hälfte der Serie
VF_randomLC( X, siz-siz/2, 0, −1.0, +1.0, &MyState ); // Fortsetzung der Serie durch seed = 0
VF_randomLC( Y, siz, −1111, −1.0, +1.0, &MyState ); // identische Serie in Y wie in X, da identisches seed
VF_randomLC( Z, siz, 234567, −1.0, +1.0, &MyState ); // andere Serie in Z, da seed unterschiedlich
|
|
Beispiel Pascal/Delphi | uses VFstd;
var MyState: V_RANDOMLCSTATE; { Speicherplatz für Generator-Zustand }
VF_randomLC( X, siz div 2, −1111, −1.0, +1.0, @MyState ); { Initialisierung mit seed ≠ 0 und erste Hälfte der Serie }
VF_randomLC( X, siz-siz div 2, 0, −1.0, +1.0, @MyState ); { Fortsetzung der Serie durch seed = 0 }
VF_randomLC( Y, siz, −1111, −1.0, +1.0, @MyState ); { identische Serie in Y wie in X, da identisches seed }
VF_randomLC( Z, siz, 234567, −1.0, +1.0, @MyState ); { andere Serie in Z, da seed unterschiedlich }
|
|
|
|
|
VF_ratinterpol | VD_ratinterpol | VE_ratinterpol |
|
Funktion | diagonal-rationale Interpolation nach Stoer und Bulirsch |
|
Syntax C/C++ | #include <VFmath.h>
void VF_ratinterpol( fVector Y, fVector X, ui sizex, fVector XTab, fVector YTab, ui sizetab, unsigned deg ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::ratinterpol( const vector<T>& X, const vector<T>& XTab, const vector<T>& YTab, unsigned deg ); |
Pascal/Delphi | uses VFmath;
procedure VF_ratinterpol( Y, X:fVector; sizex:UIntSize; XTab, YTab:fVector; sizetab:UIntSize; deg:UInt ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_ratinterpol( fVector d_Y, fVector d_X, ui sizex, fVector d_XTab, fVector d_YTab, ui sizetab, unsigned deg );
void VFcu_ratinterpol( fVector h_Y, fVector h_X, ui sizex, fVector h_XTab, fVector h_YTab, ui sizetab, unsigned deg );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_ratinterpol( d_Y, d_X:fVector; sizex:UIntSize; d_XTab, d_YTab:fVector; sizetab:UIntSize; deg:UInt ): IntBool;
procedure VFcu_ratinterpol( h_Y, h_X:fVector; sizex:UIntSize; h_XTab, h_YTab:fVector; sizetab:UIntSize; deg:UInt );
|
|
Beschreibung | Für jedes der sizex Elemente von X wird ein Y-Wert durch diagonal-rationale Interpolation nach Stoer und Bulirsch aus einer Tabelle gewonnen. Die Tabelle muss als XTab-YTab- Wertepaare vorliegen, wobei XTab geordnet sein muss (streng aufsteigend oder absteigend). Außerdem müssen alle Werte von XTab verschieden sein, da andernfalls eine Division durch 0 auftreten kann mit nachfolgendem Programmabbruch.
Die Routine findet für die einzelnen Elemente von X jeweils die geeignete Stelle in der Tabelle als Ausgangspunkt der Interpolation. Der Parameter deg bezeichnet die Anzahl der für die Interpolation in Betracht gezogenen Tabellen-Punkte. 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 immer dann, wenn Polstellen vorhanden sind, der Polynom-Interpolation überlegen. Auf der anderen Seite können bereits geringfügige Rundungsfehler in den Eingabe-Tabellen dazu führen, dass Polstellen an Stellen berechnet werden, wo "eigentlich" keine wären.
deg muss zwischen 3 und 20 liegen. |
|
Fehlerbehandlung | Eine Polstelle (d.h. ein Wert von Unendlich) in der Interpolationsfunktion wird als SING-Fehler behandelt mit dem Ergebnis ±HUGE_VAL. (Der in C/C++ an _matherr übergebene x-Wert ist dabei das erste Element von XTab). Ein zu hoher Grad der Interpolation (deg > 20) führt zu einer Fehlermeldung "Not possible with more than 20 elements" und zum Programmabbruch.
Wenn deg nicht zwischen 3 und 20 ist oder wenn deg sizetab−1 übersteigt, wird eine Fehlermeldung "Invalid parameter(s)" angezeigt und das Programm ebenfalls abgebrochen. |
|
|
|
VF_ratio_d | VF_ratio_e | VD_ratio_e |
VFx_ratio | VDx_ratio | VEx_ratio |
VFx_ratio_d | VFx_ratio_e | VDx_ratio_e |
VF_ratioOddEven | VD_ratioOddEven | VE_ratioOddEven |
VF_ratioOddEven_d | VF_ratioOddEven_e | VD_ratioOddEven_e |
VFx_ratioOddEven | VDx_ratioOddEven | VEx_ratioOddEven |
VFx_ratioOddEven_d | VFx_ratioOddEven_e | VDx_ratioOddEven_e |
VF_ratioEvenOdd | VD_ratioEvenOdd | VE_ratioEvenOdd |
VF_ratioEvenOdd_d | VF_ratioEvenOdd_e | VD_ratioEvenOdd_e |
VFx_ratioEvenOdd | VDx_ratioEvenOdd | VEx_ratioEvenOdd |
VFx_ratioEvenOdd_d | VFx_ratioEvenOdd_e | VDx_ratioEvenOdd_e |
VFu_ratio | VDu_ratio | VEu_ratio |
VFu_ratio_d | VFu_ratio_e | VDu_ratio_e |
VFux_ratio | VDux_ratio | VEux_ratio |
VFux_ratio_d | VFux_ratio_e | VDux_ratio_e |
VFu_ratioOddEven | VDu_ratioOddEven | VEu_ratioOddEven |
VFu_ratioOddEven_d | VFu_ratioOddEven_e | VDu_ratioOddEven_e |
VFux_ratioOddEven | VDux_ratioOddEven | VEux_ratioOddEven |
VFux_ratioOddEven_d | VFux_ratioOddEven_e | VDux_ratioOddEven_e |
VFu_ratioEvenOdd | VDu_ratioEvenOdd | VEu_ratioEvenOdd |
VFu_ratioEvenOdd_d | VFu_ratioEvenOdd_e | VDu_ratioEvenOdd_e |
VFux_ratioEvenOdd | VDux_ratioEvenOdd | VEux_ratioEvenOdd |
VFux_ratioEvenOdd_d | VFux_ratioEvenOdd_e | VDux_ratioEvenOdd_e |
|
Funktion | Ratio: Quotient zweier Polynome |
|
Syntax C/C++ | #include <VFmath.h>
int VF_ratio( fVector Y, fVector X, ui size, fVector Coeff, unsigned degP, unsigned degQ );
int VFx_ratio( fVector Y, fVector X, ui size, fVector Coeff, unsigned degP, unsigned degQ, float A, float B );
int VFu_ratio( fVector Y, fVector X, ui size, fVector Coeff, unsigned degP, unsigned degQ );
int VFux_ratio( fVector Y, fVector X, ui size, fVector Coeff, unsigned degP, unsigned degQ, float A, float B ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::ratio( const vector<T>& X, const vector<T>& Coeff, unsigned degP, unsigned degQ );
int vector<T>::x_ratio( const vector<T>& X, const vector<T>& Coeff, unsigned degP, unsigned degQ, const T& A, const T& B ); |
Pascal/Delphi | uses VFmath;
function VF_ratio( Y, X:fVector; size:UIntSize; Coeff:fVector; degP, degQ:UInt ): IntBool;
function VFx_ratio( Y, X:fVector; size:UIntSize; Coeff:fVector; degP, degQ:UInt; A, B:Single ): IntBool;
function VFu_ratio( Y, X:fVector; size:UIntSize; Coeff:fVector; degP, degQ:UInt ): IntBool;
function VFux_ratio( Y, X:fVector; size:UIntSize; Coeff:fVector; degP, degQ:UInt; A, B:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_ratio( fVector d_Y, fVector d_X, ui size, fVector h_Coeff, unsigned degP, unsigned degQ );
int cusdVF_ratio( fVector d_Y, fVector d_X, ui size, fVector d_Coeff, unsigned degP, unsigned degQ );
int cudaVFx_ratio( fVector d_Y, fVector d_X, ui size, fVector h_Coeff, unsigned degP, unsigned degQ, float A, float B );
int cusdVFx_ratio( fVector d_Y, fVector d_X, ui size, fVector d_Coeff, unsigned degP, unsigned degQ, float *d_A, float *d_B );
int cudaVFu_ratio( fVector d_Y, fVector d_X, ui size, fVector h_Coeff, unsigned degP, unsigned degQ );
int cusdVFu_ratio( fVector d_Y, fVector d_X, ui size, fVector d_Coeff, unsigned degP, unsigned degQ );
int cudaVFux_ratio( fVector d_Y, fVector d_X, ui size, fVector h_Coeff, unsigned degP, unsigned degQ, float A, float B );
int cusdVFux_ratio( fVector d_Y, fVector d_X, ui size, fVector d_Coeff, unsigned degP, unsigned degQ, float *d_A, float *d_B );
int VFcu_ratio( fVector h_Y, fVector h_X, ui size, fVector h_Coeff, unsigned degP, unsigned degQ );
int VFxcu_ratio( fVector h_Y, fVector h_X, ui size, fVector h_Coeff, unsigned degP, unsigned degQ, float A, float B );
int VFucu_ratio( fVector h_Y, fVector h_X, ui size, fVector h_Coeff, unsigned degP, unsigned degQ );
int VFuxcu_ratio( fVector h_Y, fVector h_X, ui size, fVector h_Coeff, unsigned degP, unsigned degQ, float A, float B );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_ratio( d_Y, d_X:fVector; size:UIntSize; h_Coeff:fVector; degP, degQ:UInt ): IntBool;
function cusdVF_ratio( d_Y, d_X:fVector; size:UIntSize; d_Coeff:fVector; degP, degQ:UInt ): IntBool;
function cudaVFx_ratio( d_Y, d_X:fVector; size:UIntSize; h_Coeff:fVector; degP, degQ:UInt; A, B:Single ): IntBool;
function cusdVFx_ratio( d_Y, d_X:fVector; size:UIntSize; d_Coeff:fVector; degP, degQ:UInt; d_A, d_B:PSingle ): IntBool;
function cudaVFu_ratio( d_Y, d_X:fVector; size:UIntSize; h_Coeff:fVector; degP, degQ:UInt ): IntBool;
function cusdVFu_ratio( d_Y, d_X:fVector; size:UIntSize; d_Coeff:fVector; degP, degQ:UInt ): IntBool;
function cudaVFux_ratio( d_Y, d_X:fVector; size:UIntSize; h_Coeff:fVector; degP, degQ:UInt; A, B:Single ): IntBool;
function cusdVFux_ratio( d_Y, d_X:fVector; size:UIntSize; d_Coeff:fVector; degP, degQ:UInt; d_A, d_B:PSingle ): IntBool;
function VFcu_ratio( h_Y, h_X:fVector; size:UIntSize; h_Coeff:fVector; degP, degQ:UInt ): IntBool;
function VFxcu_ratio( h_Y, h_X:fVector; size:UIntSize; h_Coeff:fVector; degP, degQ:UInt; A, B:Single ): IntBool;
function VFucu_ratio( h_Y, h_X:fVector; size:UIntSize; h_Coeff:fVector; degP, degQ:UInt ): IntBool;
function VFuxcu_ratio( h_Y, h_X:fVector; size:UIntSize; h_Coeff:fVector; degP, degQ:UInt; A, B:Single ): IntBool;
|
|
Beschreibung | einfache Versionen VF_ratio, VD_ratio, VE_ratio:
Yi = P/Q mit
P = p0 + p1 * Xi + p2 * Xi2 + ... + pdegP * XidegP,
Q = q0 + q1 * Xi + q2 * Xi2 + ... + qdegQ * XidegQ
erweiterte Versionen VFx_ratio, VDx_ratio, VEx_ratio:
xi = (A*Xi + B),
Yi = P/Q wie oben mit xi anstelle von Xi
Ein Polynom P vom Grade degP wird durch ein Polynom Q vom Grade degQ dividiert, wobei die Koeffizienten pk und qk dem Vektor Coeff entnommen werden. Coeff muss das konstante Glied p0 als nulltes Element enthalten, den linearen Koeffizienten p1 als erstes Element usw. bis hin zum Koeffizienten pdegP als degP-tem Element und direkt anschließend das konstante Glied q0 als (degP+1)-tes, q1 als (degP+2)-tes usw. bis hin zum Koeffizienten qdegQ als (degP+degQ+1)-tes Element. Dies bedeutet, dass Coeff insgesamt (degP+degQ+2) Elemente haben muss.
"ungeschützte" Versionen (Präfix VFu_, VFux_, etc.):
Diese Funktionen führen keinerlei Fehlerbehandlung durch und sind hierdurch bis zu 50% schneller als die Normalversionen. Durch ihren Rückgabewert zeigen sie aber das Auftreten eventueller Fehler an.
Da die einzelnen Polynome gerne zum numerischen Überlauf neigen, während ihr Quotient ein perfekt legales Endergebnis liefern kann, bietet OptiVec zusätzliche Versionen, die intern in höherer Genauigkeit rechnen: VF_ratio_d und VF_ratio_e arbeiten intern in double bzw. extended, bevor das Endergebnis zurück in einfache Genauigkeit gewandelt wird. Analog arbeitet VD_ratio_e zunächst extended-genau (dies gilt auch, wenn der Compiler eigentlich gar keine extended-Genauigkeit unterstützt!) und wandelt erst das Endergebnis wieder in double um. Diese Versionen existieren aber nur für die CPU, nicht für CUDA.
In der praktischen Anwendung findet man gelegentlich rationale Modelle für mathematische Funktionen, bei denen das Zähler-Polynom nur aus ungeraden und das Nenner-Polynom nur aus geraden Termen besteht oder umgekehrt. Beispiele hierfür sind die rationale Darstellung des Tangens (nur ungerade Terme im Zähler, nur gerade Terme im Nenner) und des Cotangens (nur gerade Terme im Zähler, nur ungerade Terme im Nenner). Hierfür dienen in OptiVec die folgenden Funktionen:
VF_ratioOddEven: Zähler nur ungerade, Nenner nur gerade Terme:
Pi = p1 * Xi + p1 * Xi3 + ... + pdegP * XidegP, wobei degP = 2n+1
Qi = q0 + q2 * Xi2 + ... + qdegQ * XidegQ, wobei degQ = 2n
Coeff enthält hier (degP+1)/2 + (degQ/2)+1 Koeffizienten.
VF_ratioEvenOdd: Zähler nur gerade, Nenner nur ungerade Terme:
Pi = p0 + p2 * Xi2 + ... + pdegP * XidegP, wobei degP = 2n
Qi = q1 * Xi + q1 * Xi3 + ... + qdegQ * XidegQ, wobei degQ = 2n+1
Coeff enthält hier (degP/2)+1 + (degQ+1)/2 Koeffizienten.
Mathematisch sind zwar Polynome und Ratios beliebig hohen Grades möglich. Praktisch sorgen aber Überlauf-, Unterlauf- und Rundungsfehler dafür, dass hohe Grade hier sinnlos sind. Dementsprechend erlauben VF_ratio, VF_ratio_d und VD_ratio nur degP+degQ ± 32. Bei Überschreitung dieser Grenze wird eine Fehlermeldung "Invalid Parameter(s)" ausgegeben und die Programmausführung beendet. Nur die VE_-Versionen sowie VF_ratio_e und VD_ratio_e erlauben höhere Grade.
|
|
Fehlerbehandlung | OVERFLOW- oder ZERODIVIDE-Fehler führen zu ±HUGE_VAL als Ergebnis. 0/0-Situationen werden nur in den VE_ und V?_ratio_e-Versionen aufgelöst, indem 0/0 durch den Quotienten aus der 1. Ableitung von P und der 1. Ableitung von Q ersetzt wird. In allen anderen Versionen folgt ±HUGE_VAL als Ergebnis. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls eine Bit-Kombination der aufgetretenen Fehler 0x4 (Division durch 0), 0x8 (OVERFLOW) und 0x1 (0/0).
Obwohl die "ungeschützte" Varianten (Präfix VFu_, VFux_, etc.) keine Fehlerbehandlung durchführen, geben sie dieselben Fehler-Codes zurück wie die "geschützte" Normal-Version. |
|
|
VI_read | VBI_read | VSI_read | VLI_read | VQI_read | |
VU_read | VUB_read | VUS_read | VUL_read | VUQ_read | VUI_read |
|
Funktion | Einlesen von im ASCII-Format vorliegenden Zahlen aus einem Stream |
|
Syntax C/C++ | #include <VFstd.h>
void VF_read( fVector X, ui size, FILE *stream ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::read( FILE *stream ); |
Pascal/Delphi | uses VFstd;
procedure VF_read( X:fVector; size:UIntSize; var Stream:Text ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_read( fVector d_X, ui size, FILE *stream );
int cudaVF_read_buf( fVector d_X, ui size, FILE *stream, fVector h_Wk );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_read( X:fVector; size:UIntSize; var Stream:FILE ): IntBool;
function cudaVF_read_buf( X:fVector; size:UIntSize; var Stream:FILE; h_Wk:fVector ): IntBool;
|
|
Beschreibung | size Elemente werden aus stream gelesen und in X gespeichert. Man gebrauche diese Funktion, um Daten von einem anderen Programm zu importieren, das zu einem direkten Datenaustausch oder zum Abspeichern im Maschinen-Format nicht in der Lage ist. Es können auch Vektoren wieder eingelesen werden, die mittels VF_write auf Festplatte ausgelagert wurden. Sofern nicht besondere Gründe für das Funktionenpaar VF_write/VF_read sprechen, benutze man zum Zweck der temporären Auslagerung allerdings lieber das Paar VF_store/VF_recall (schneller und genauer!).
Die Anzahl der Stellen pro Zahl ist auf 80 beschränkt. Man vergewissere sich daher, dass dieses Limit eingehalten wird, da sonst unweigerlich Fehler entstehen.
Komplexe Versionen:
Real- und Imaginärteil (cartesisch-komplex) bzw. Mag- und Arg-Teil (polar) dürfen, müssen aber nicht, durch runde oder geschweifte Klammern, () oder { }, zusammengefaßt sein. Die Behandlung muss einheitlich sein: Entweder müssen alle Elemente so geschrieben sein oder gar keines.
Ein Komma darf, muss aber nicht, zwischen Real- und Imaginärteil bzw. Mag- und Arg-Teil stehen. Der Imaginärteil bzw. der Arg-Teil muss stets explizit angegeben sein, auch wenn er 0 ist.
Beispiele für zulässige Formate sind:
0.3 0.5 (weder Klammern noch Komma)
0.3, 0.5 (keine Klammern; trennendes Komma)
{0.3 0.5} (geschweifte Klammern; kein Komma)
(0.3, 0.5) (runde Klammern und trennendes Komma) |
C/C++-spezifisch: |
Die Einträge müssen durch "Whitespace" voneinander getrennt sein (' ', '\n' oder '\t'). Außerdem darf nach jeder Zahl höchstens ein (!) "Nicht-Whitespace"-Zeichen stehen. Dieses muss ohne Zwischenraum auf die Zahl folgen, und nach ihm muss mindestens ein Whitespace-Zeichen stehen.
Ganzzahl-Versionen außer VQI_read:
Standardmäßig werden die zu lesenden Zahlen als Dezimalzahlen interpretiert. Mittels V_setRadix läßt sich aber auch eine andere Basis definieren. |
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 VE_read, VCE_read und VPE_read bei GCC nur mit double-Genauigkeit und innerhalb des für doubles möglichen Größenbereiches arbeiten. |
Pascal/Delphi-spezifisch: | Die einzelnen Zahlen müssen durch Leerzeichen (' '), Tabulatoren (#9) oder Zeilenvorschübe (#13) voneinander getrennt sein. Andere Trennzeichen sind nicht zulässig.
Während die C-Version dieser Funktion den Konventionen der C-Funktionen strtod, strtol usw. folgt, richtet sich die Pascal/Delphi-Version nach den Regeln der Pascal/Delphi-Funktion Read. Dies hat eine wesentlich geringere Flexibilität zur Folge:
- keine Trennzeichen außer ' ', #9 und #13 zugelassen,
- keine automatische Anpassung überlaufender Zahlen,
- keine Funktion V_setRadix (mittels derer in der C-Version eine Basis außer 10 für die Ganzzahl-Varianten definiert werden kann). |
|
Fehlerbehandlung | C/C++:
Reelle, komplexe und quad-Versionen:
Überlaufende Zahlen werden stillschweigend auf ±HUGE_VAL abgeschnitten.
Ganzzahl-Versionen außer VQI_read:
Solange sich die Zahlen als long bzw. unsigned long darstellen lassen, werden in den 16-bit-Typen die übergelaufenen Bits ignoriert. Wird dagegen auch der long-Bereich überschritten, so resultiert −1 für vorzeichenbehaftete Typen bzw. der größte darstellbare Wert für vorzeichenlose Typen.
Pascal/Delphi:
Überlaufende oder vom zugelassenen Format abweichende Zahlen führen zu einem I/O-Fehler.
nur CUDA-Versionen: cudaV?_read ü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 cudaV?_read eingespart, so dass cudaV?_read_buf etwas schneller ist.
|
|
|
|
|
Funktion | Realteil eines komplexen Vektors extrahieren |
|
Syntax C/C++ | #include <VCFstd.h>
void VCF_real( fVector Re, cfVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::real( const vector<complex<T>>& X ); |
Pascal/Delphi | uses VCFstd;
procedure VCF_real( Re:fVector; X:cfVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVCFstd.h>
int cudaVCF_real( fVector d_Re, cfVector d_X, ui size );
void VCFcu_real( fVector h_Re, cfVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VCFstd;
function cudaVCF_real( d_Re:fVector; d_X:cfVector; size:UIntSize ): IntBool;
procedure VCFcu_real( h_Re:fVector; h_X:cfVector; size:UIntSize );
|
|
|
VF_recall | VD_recall | VE_recall |
VCF_recall | VCD_recall | VCE_recall |
VPF_recall | VPD_recall | VPE_recall |
VI_recall | VBI_recall | VSI_recall | VLI_recall | VQI_recall | |
VU_recall | VUB_recall | VUS_recall | VUL_recall | VUQ_recall | VUI_recall |
|
Funktion | Vektor im Binärformat aus einem Stream einlesen |
|
Syntax C/C++ | #include <VFstd.h>
int VF_recall( fVector X, ui size, FILE *stream ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::recall( FILE *stream ); |
Pascal/Delphi | uses VFstd;
function VF_recall( X:fVector; size:UIntSize; var Stream:FILE ): Integer; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_recall( fVector d_X, ui size, FILE *stream );
int cudaVF_recall_buf( fVector d_X, ui size, FILE *stream, fVector h_Wk );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_recall( X:fVector; size:UIntSize; var Stream:FILE ): IntBool;
function cudaVF_recall_buf( X:fVector; size:UIntSize; var Stream:FILE; h_Wk:fVector ): IntBool;
|
|
Beschreibung | size Elemente werden aus stream im Binärformat eingelesen und in X gespeichert. Der Datentyp beim Auslesen muss derselbe sein wie der bei der Speicherung mittels einer Funktion der VF_store-Familie. Sie können also nicht Daten beispielsweise mit VF_store speichern und mit VD_recall auslesen (anders als bei der Speicherung im ASCII-Format, siehe VF_read).
Die VecObj-Version unterscheidet sich von der "normalen" C/C++-Version darin, dass sie ein Vektor-Objekt und nicht nur die Vektor-Elemente liest: Zuerst wird eine ui gelesen, die die Vektorgröße size setzt, und erst danach die size Elemente, während die "normalen" V?_recall-Funktionen size als bekannt voraussetzen und als Argument übernehmen. Daher kann die VecObj-Funktion recall nur zum Einlesen von Vektoren verwandt werden, die zuvor auch mit der VecObj-Funktion store gespeichert wurden, nicht aber mit einer der "normalen" V?_store-Funktionen.
nur CUDA-Versionen: cudaV?_recall_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 cudaV?_recall eingespart, so dass cudaV?_recall_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 VE_store / VE_recall, VCE_store / VCE_recall und VPE_store / VPE_recall stets im 10-byte-Format. |
|
Thread-Sicherheit | Verschiedene Threads können gefahrlos mehrere Funktionen der VF_ / MF_store- und VF_ / MF_recall-Familien gleichzeitig aufrufen, solange sie auf verschiedene Streams zugreifen. Falls sie allerdings auf ein- und denselben Stream zugreifen, müssen unbedingt durch geeignete Maßnahmen (Critical Sections, Mutexes) Race−Conditions verhindert werden. |
|
Fehlerbehandlung | wird durch die C-Funktion fread bzw. die Delphi-Funktion BlockRead durchgeführt, auf der VF_recall etc. basieren |
|
Rückgabewert | 0, wenn fehlerfrei; ansonsten 1. Um mehr Information im Falle eines Fehlers zu erhalten, inspiziere man errno (C/C++) oder IOResult (Delphi). |
|
|
|
Funktion | "reduzieren" mit einer Konstanten |
|
Syntax C/C++ | #include <VFmath.h>
void VF_redC( fVector Y, fVector X, ui size, float C ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::redC( const vector<T>& X, const T& C ); |
Pascal/Delphi | uses VFmath;
procedure VF_redC( Y, X:fVector; size:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
#include <cudaVDmath.h>
int cudaVF_redC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_redC( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_redC( fVector d_Y, fVector d_X, ui size, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath, VDmath;
function cudaVF_redC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_redC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VF_redC( Y, X:fVector; size:UIntSize; C:Single );
|
|
Beschreibung | Yi = red( Xi, C ) = Xi * C / (Xi + C)
Ausdrücke dieser Art werden als reduzierte Größen bezeichnet (analog beispielsweise zur reduzierten Masse eines Zweikörper-Systems). |
|
|
|
|
|
Funktion | "Reduzieren" der Elemente eines Vektors durch die korrespondierenden Elemente eines anderen Vektors |
|
Syntax C/C++ | #include <VFmath.h>
void VF_redV( fVector Z, fVector X, fVector Y, ui size );
void VFx_redV( fVector Z, fVector X, fVector Y, ui size, float A, float B ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::redV( const vector<T>& X, const vector<T>& Y );
void vector<T>::x_redV( const vector<T>& X, const vector<T>& Y, const T& A, const T& B ); |
Pascal/Delphi | uses VFmath;
procedure VF_redV( Z, X, Y:fVector; size:UIntSize );
procedure VFx_redV( Z, X, Y:fVector; size:UIntSize; A, B:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_redV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
int cudaVFx_redV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float A, float B );
int cusdVFx_redV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_A, float *d_B );
void VFcu_redV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
void VFxcu_redV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float A, float B );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_redV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cudaVFx_redV( d_Z, d_X, d_Y:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_redV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
procedure VFcu_redV( h_Z, h_X, h_Y:fVector; size:UIntSize );
procedure VFxcu_redV( h_Z, h_X, h_Y:fVector; size:UIntSize; A, B:Single );
|
|
Beschreibung | einfache Versionen:
Zi = red( Xi, Yi ) = Xi * Yi / (Xi + Yi)
erweiterte Versionen:
xi = (A * Xi + B),
Zi = red( xi, Yi ) |
|
|
|
|
VF_reflect | VD_reflect | VE_reflect |
VCF_reflect | VCD_reflect | VCE_reflect |
VPF_reflect | VPD_reflect | VPE_reflect |
VI_reflect | VBI_reflect | VSI_reflect | VLI_reflect | VQI_reflect | |
VU_reflect | VUB_reflect | VUS_reflect | VUL_reflect | VUQ_reflect | VUI_reflect |
|
Funktion | obere Hälfte eines Vektors durch Spiegelung der unteren Hälfte am Mittelpunkt gewinnen |
|
Syntax C/C++ | #include <VFstd.h>
void VF_reflect( fVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::reflect(); |
Pascal/Delphi | uses VFstd;
procedure VF_reflect( X:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_reflect( fVector d_X, ui size );
void VFcu_reflect( fVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_reflect( d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_reflect( h_X:fVector; size:UIntSize );
|
|
Beschreibung | Xsize-i−1 = Xi, i=0,...,(size−1)/2
Die Elemente der unteren Hälfte eines Vektors werden in umgekehrter Reihenfolge in die obere Hälfte kopiert, so dass der Vektor spiegelsymmetrisch bezüglich seines Mittelpunktes wird. Die Elemente der unteren Hälfte werden durch diese Operation nicht beeinflußt. Der Parameter size bezieht sich auf die Gesamt-Größe des Vektors, also nicht nur auf die Anzahl der tatsächlich veränderten Elemente. Anwendung findet diese Funktion u.a. in der Konstruktion von Impulsantwort-Funktionen für Faltungen (siehe VF_convolve). In diesem Fall beachte man, dass der Nullpunkt nur einmal erscheinen darf. Daher ist die Response-Funktion für size/2+1 Elemente zu berechnen und dann die Reflexion ab dem Element 1 anzuwenden (siehe das Beispiel bei VF_convolve). |
|
|
|
|
VF_ReImtoC | VD_ReImtoC | VE_ReImtoC |
|
Funktion | cartesisch-komplexen Vektor aus Real- und Imaginärteil aufbauen |
|
Syntax C/C++ | #include <VCFstd.h>
void VF_ReImtoC( cfVector Y, fVector Re, fVector Im, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<complex<T>>::ReImtoC( const vector<T>& Re, const vector<T>& Im ); |
Pascal/Delphi | uses VCFstd;
procedure VF_ReImtoC( X:cfVector; Re, Im:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVCFstd.h>
int cudaVF_ReImtoC( cfVector Y, fVector d_Re, fVector d_Im, ui size );
void VFcu_ReImtoC( cfVector Y, fVector h_Re, fVector h_Im, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VCFstd;
function cudaVF_ReImtoC( d_X:cfVector; d_Re, d_Im:fVector; size:UIntSize ): IntBool;
procedure VFcu_ReImtoC( h_X:cfVector; h_Re, h_Im:fVector; size:UIntSize );
|
|
Beschreibung | Die reellen Vektoren Re und Im werden in den Real- bzw. Imaginärteil des komplexen Vektors Y kopiert. |
|
|
|
|
VF_ReImtoP | VD_ReImtoP | VE_ReImtoP |
|
Funktion | Polar-Koordinaten aus getrennt übergebenen Real- und Imaginärteilen eines komplexen Vektors konstruieren |
|
Syntax C/C++ | #include <VPFstd.h>
void VF_ReImtoP( pfVector Y, fVector Re, fVector Im, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<polar<T>>::ReImtoP( const vector<T>& Re, const vector<T>& Im ); |
Pascal/Delphi | uses VPFstd;
procedure VF_ReImtoP( X:pfVector; Re, Im:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVPFstd.h>
int cudaVF_ReImtoP( pfVector Y, fVector d_Re, fVector d_Im, ui size );
void VFcu_ReImtoP( pfVector Y, fVector h_Re, fVector h_Im, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VPFstd;
function cudaVF_ReImtoP( d_X:pfVector; d_Re, d_Im:fVector; size:UIntSize ): IntBool;
procedure VFcu_ReImtoP( h_X:pfVector; h_Re, h_Im:fVector; size:UIntSize );
|
|
Beschreibung | Aus den in den getrennten Vektoren Re und Im übergebenen cartesischen Koordinaten werden die Polarkoordinaten des Ausgabevektors Y berechnet. |
|
|
|
|
VF_reldevC | VD_reldevC | VE_reldevC |
|
Funktion | Relative Abweichung (Absolutwert) der Elemente eines Vektors von einem Sollwert |
|
Syntax C/C++ | #include <VFmath.h>
void VF_reldevC( fVector Y, fVector X, ui size, float C ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::reldevC( const vector<T>& X, const T& C ); |
Pascal/Delphi | uses VFmath;
procedure VF_reldevC( Y, X:fVector; size:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
#include <cudaVDmath.h>
int cudaVF_reldevC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_reldevC( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_reldevC( fVector d_Y, fVector d_X, ui size, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath, VDmath;
function cudaVF_reldevC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_reldevC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VF_reldevC( Y, X:fVector; size:UIntSize; C:Single );
|
|
Beschreibung | Yi = |Xi − C| / |C|
Der Sollwert C=0 ist nicht zulässig, da er zu einer Division durch 0 führt.
Während VF_reldevC den Absolutwert der relativen Abweichung liefert, erhält man durch die sehr ähnliche Funktion VF_reldiffC die relative Abweichung mit ±Vorzeichen. |
|
|
|
|
VF_reldevV | VD_reldevV | VE_reldevV |
|
Funktion | Relative Abweichung (Absolutwert) der Elemente eines Vektors von den korrespondierenden Elementen eines anderen, normiert jeweils durch den größeren der beiden Eingabe-Werte |
|
Syntax C/C++ | #include <VFmath.h>
void VF_reldevV( fVector Z, fVector X, fVector Y, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::reldevV( const vector<T>& X, const vector<T>& Y ); |
Pascal/Delphi | uses VFmath;
procedure VF_reldevV( Z, X, Y:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_reldevV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
void VFcu_reldevV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_reldevV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
procedure VFcu_reldevV( h_Z, h_X, h_Y:fVector; size:UIntSize );
|
|
Beschreibung | Zi = |Xi − Yi| / max(|Xi|, |Yi|), wenn |Xi| > 0 oder |Yi| > 0
Zi = 0, wenn Xi = 0 und Yi = 0
Während VF_reldevV den Absolutwert der relativen Abweichung liefert, erhält man durch die sehr ähnliche Funktion VF_reldiffV die relative Abweichung mit ±Vorzeichen. |
|
|
|
|
VF_reldiffC | VD_reldiffC | VE_reldiffC |
|
Funktion | Relative Abweichung (mit Vorzeichen) der Elemente eines Vektors von einem Sollwert |
|
Syntax C/C++ | #include <VFmath.h>
void VF_reldiffC( fVector Y, fVector X, ui size, float C ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::reldiffC( const vector<T>& X, const T& C ); |
Pascal/Delphi | uses VFmath;
procedure VF_reldiffC( Y, X:fVector; size:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
#include <cudaVDmath.h>
int cudaVF_reldiffC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_reldiffC( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_reldiffC( fVector d_Y, fVector d_X, ui size, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath, VDmath;
function cudaVF_reldiffC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_reldiffC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VF_reldiffC( Y, X:fVector; size:UIntSize; C:Single );
|
|
Beschreibung | Yi = (Xi − C) / |C|
Der Sollwert C=0 ist nicht zulässig, da er zu einer Division durch 0 führt.
Während VF_reldiffC die vorzeichen-richtige relativen Abweichung liefert, erhält man durch die sehr ähnliche Funktion VF_reldevC den Absolutwert der relativen Abweichung |
|
|
|
|
VF_reldiffV | VD_reldiffV | VE_reldiffV |
|
Funktion | Relative Abweichung (mit ±Vorzeichen) der Elemente eines Vektors von den korrespondierenden Elementen eines anderen, normiert jeweils durch den größeren der beiden Eingabe-Werte |
|
Syntax C/C++ | #include <VFmath.h>
void VF_reldiffV( fVector Z, fVector X, fVector Y, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::reldiffV( const vector<T>& X, const vector<T>& Y ); |
Pascal/Delphi | uses VFmath;
procedure VF_reldiffV( Z, X, Y:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_reldiffV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
void VFcu_reldiffV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_reldiffV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
procedure VFcu_reldiffV( h_Z, h_X, h_Y:fVector; size:UIntSize );
|
|
Beschreibung | Zi = (Xi − Yi) / max(|Xi|, |Yi|), wenn |Xi| > 0 oder |Yi| > 0
Zi = 0, wenn Xi = 0 und Yi = 0
Während VF_reldiffV die vorzeichen-richtige relative Abweichung liefert, erhält man durch die sehr ähnliche Funktion VF_reldevV Absolutwert der relativen Abweichung. |
|
|
|
|
VF_replaceNAN | VD_replaceNAN | VE_replaceNAN |
VCF_replaceNAN | VCD_replaceNAN | VCE_replaceNAN |
VPF_replaceNAN | VPD_replaceNAN | VPE_replaceNAN |
|
Funktion | Ersatz von NAN durch eine beliebige Zahl |
|
Syntax C/C++ | #include <VFmath.h>
void VF_replaceNAN( fVector Y, fVector X, ui size, float C );
void VCF_replaceNAN( fVector Y, fVector X, ui size, fComplex C ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::replaceNAN( const vector<T>& X, const T& C );
void vector<T>::replaceNAN( const vector<T>& X, complex<T> C ); |
Pascal/Delphi | uses VFmath;
procedure VF_replaceNAN( Y, X:fVector; size:UIntSize; C:Single );
procedure VCF_replaceNAN( Y, X:cfVector; size:UIntSize; C:fComplex ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_replaceNAN( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_replaceNAN( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_replaceNAN( fVector h_Y, fVector h_X, ui size, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_replaceNAN( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_replaceNAN( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VFcu_replaceNAN( h_Y, h_X:fVector; size:UIntSize; C:Single );
|
|
Beschreibung | X wird in Y kopiert, wobei alle NAN ("not a number", IEEE-Nicht-Zahlen), seien es SNaN oder QNaN, durch einen benutzer-definierten Wert C ersetzt werden. |
|
|
|
|
|
Funktion | reellen Vektor in Realteil eines cartesisch-komplexen Vektors kopieren |
|
Syntax C/C++ | #include <VCFstd.h>
void VF_RetoC( cfVector Y, fVector Re, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<complex<T>>::RetoC( const vector<T>& Re ); |
Pascal/Delphi | uses VCFstd;
procedure VF_RetoC( X:cfVector; Re:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVCFstd.h>
int cudaVF_RetoC( cfVector d_Y, fVector d_Im, ui size );
void VFcu_RetoC( cfVector h_Y, fVector h_Im, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VCFstd;
function cudaVF_RetoC( d_X:cfVector; d_Im:fVector; size:UIntSize ): IntBool;
procedure VFcu_RetoC( h_X:cfVector; h_Im:fVector; size:UIntSize );
|
|
Beschreibung | Der Realteil des komplexen Vektors Y wird mit den Elementen des reellen Vektors Re überschrieben. Der Imaginärteil von Y wird hierdurch nicht berührt. |
|
|
|
|
VI_rev | VBI_rev | VSI_rev | VLI_rev | VQI_rev | |
VU_rev | VUB_rev | VUS_rev | VUL_rev | VUQ_rev | VUI_rev |
|
Funktion | Umkehrung der Element-Reihenfolge |
|
Syntax C/C++ | #include <VFstd.h>
void VF_rev( fVector Y, fVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::rev( const vector<T>& X ); |
Pascal/Delphi | uses VFstd;
procedure VF_rev( Y, X:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_rev( fVector d_Y, fVector d_X, ui size );
void VF_rev( fVector h_Y, fVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_rev( d_Y, d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_rev( h_Y, h_X:fVector; size:UIntSize );
|
|
Beschreibung | Yi = Xsize-i−1 |
|
|
|
|
VCF_revconj | VCD_revconj | VCE_revconj |
VPF_revconj | VPD_revconj | VPE_revconj |
|
Funktion | Komplex-konjugierte Form und umgekehrte Element-Reihung |
|
Syntax C/C++ | #include <VCFmath.h>
int VCF_revconj( cfVector Y, cfVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
int vector<complex<T>>::revconj( const vector<complex<T>>& X ); |
Pascal/Delphi | uses VCFmath;
function VCF_revconj( Y, X:cfVector; size:UIntSize ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVCFmath.h>
int cudaVCF_revconj( cfVector d_Y, cfVector d_X, ui size );
void VCFcu_revconj( cfVector h_Y, cfVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VCFmath;
function cudaVCF_revconj( d_Y, d_X:cfVector; size:UIntSize ): IntBool;
procedure VCFcu_revconj( h_Y, h_X:cfVector; size:UIntSize );
|
|
Beschreibung | Re(Ysize-i−1) = Re(Xi)
Im(Ysize-i−1) = -Im(Xi) |
|
|
Rückgabewert | immer FALSE(0) |
|
|
|
Funktion | Wurzel des mittleren Quadrates (engl. root of the mean square, r.m.s.) |
|
Syntax C/C++ | #include <VFstd.h>
float VF_rms( fVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::rms(); |
Pascal/Delphi | uses VFstd;
function VF_rms( X:fVector; size:UIntSize ); Single; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_rms( float *h_RetVal, fVector d_X, ui size );
int cusdVF_rms( float *d_RetVal, fVector d_X, ui size );
float VFcu_rms( fVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_rms( var h_RetVal:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_rms( d_RetVal:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_rms( h_X:fVector; size:UIntSize ): Single;
|
|
Beschreibung | rms = sqrt( (1/size) * sum( Xi2 ) ) |
|
|
Rückgabewert | Wurzel des mittleren Quadrates |
|
|
VF_rotate | VD_rotate | VE_rotate |
VCF_rotate | VCD_rotate | VCE_rotate |
VPF_rotate | VPD_rotate | VPE_rotate |
VI_rotate | VBI_rotate | VSI_rotate | VLI_rotate | VQI_rotate | |
VU_rotate | VUB_rotate | VUS_rotate | VUL_rotate | VUQ_rotate | VUI_rotate |
|
Funktion | Rotation eines Vektors |
|
Syntax C/C++ | #include <VFstd.h>
void VF_rotate( fVector Y, fVector X, ui size, int pos ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::rotate( const vector<T> X, int pos ); |
Pascal/Delphi | uses VFstd;
procedure VF_rotate( Y, X:fVector; size:UIntSize; pos:Integer ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_rotate( fVector d_Y, fVector d_X, ui size, int pos );
void VFcu_rotate( fVector h_Y, fVector h_X, ui size, int pos );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_rotate( d_Y, d_X:fVector; size:UIntSize; pos:Integer ): IntBool;
procedure VFcu_rotate( h_Y, h_X:fVector; size:UIntSize; pos:Integer );
|
|
Beschreibung | Yi = Xsize-pos+i, i=0,..,pos−1
Yi = Xi-pos, i=pos,..,size−1
Der Ergebnisvektor entspricht dem um pos Positionen rotierten Eingangsvektor. Auf der einen Seite herausgeschobene Elemente werden auf der anderen Seite wieder hineingeschoben. Eine Rotation im Uhrzeigersinn wird für eine positive Verschiebung pos erzielt. Da diese Funktion intern bei jedem Aufruf Pufferspeicher vom Betriebssystem anfordern und wieder freigeben muss, ist sie nicht sonderlich effizient. Bei häufiger Verwendung empfiehlt sich ihr Ersatz durch VF_rotate_buf mit einem zuvor explizit reservierten Pufferspeicher. |
|
|
|
|
VF_rotate_buf | VD_rotate_buf | VE_rotate_buf |
VCF_rotate_buf | VCD_rotate_buf | VCE_rotate_buf |
VPF_rotate_buf | VPD_rotate_buf | VPE_rotate_buf |
VI_rotate_buf | VBI_rotate_buf | VSI_rotate_buf | VLI_rotate_buf | VQI_rotate_buf | |
VU_rotate_buf | VUB_rotate_buf | VUS_rotate_buf | VUL_rotate_buf | VUQ_rotate_buf | VUI_rotate_buf |
|
Funktion | Rotation eines Vektors |
|
Syntax C/C++ | #include <VFstd.h>
void VF_rotate_buf( fVector Y, fVector X, ui size, int pos, fVector Buf ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::rotate( const vector<T> X, int pos, const vector<T> Buf ); |
Pascal/Delphi | uses VFstd;
procedure VF_rotate_buf( Y, X:fVector; size:UIntSize; pos:Integer; Buf:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_rotate_buf( fVector d_Y, fVector d_X, ui size, int pos, fVector d_Buf );
void VFcu_rotate_buf( fVector h_Y, fVector h_X, ui size, int pos, fVector h_Buf );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_rotate_buf( d_Y, d_X:fVector; size:UIntSize; pos:Integer; d_Buf:fVector ): IntBool;
procedure VFcu_rotate_buf( h_Y, h_X:fVector; size:UIntSize; pos:Integer; h_Buf:fVector );
|
|
Beschreibung | Yi = Xsize-pos+i, i=0,..,pos−1
Yi = Xi-pos, i=pos,..,size−1
Diese Funktion ist eine effizientere Variante von VF_rotate. Anstatt nötigen Pufferspeicher bei jedem Aufruf intern vom Betriebssystem anzufordern und wieder freizugeben, wird er als Vektor Buf übernonnem. Buf muss ein mit Hilfe der OptiVec Speicherverwaltungs-Funktionen (VF_vector usw.) erzeugter Vektor sein, dessen Größe mindestens der Verschiebung pos entspricht. |
|
|
|
|
VF_rotateCoordinates | VD_rotateCoordinates | VE_rotateCoordinates |
VCF_rotateCoordinates | VCD_rotateCoordinates | VCE_rotateCoordinates |
|
Funktion | Rotation cartesischer Koordinaten entgegen dem Uhrzeigersinn |
|
Syntax C/C++ | #include <VFmath.h>
void VF_rotateCoordinates( fVector Xrot, fVector Yrot, fVector X, fVector Y, ui size, float costheta, float sintheta );
void VCF_rotateCoordinates( cfVector XYrot, cfVector XY, ui size, float costheta, float sintheta ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::rotateCoordinates( const vector<T>& Yrot, const vector<T>& X,const vector<T>& Y, T costheta, T sintheta );
void vector<complex<T> >::rotateCoordinates( const vector<complex<T> >& XY, T costheta, T sintheta ); |
Pascal/Delphi | uses VFmath;
procedure VF_rotateCoordinates( Xrot, Yrot, X, Y:fVector; size:UIntSize; costheta, sintheta:Single );
procedure VCF_rotateCoordinates( XYrot, XY:cfVector; size:UIntSize; costheta, sintheta:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
void cudaVF_rotateCoordinates( fVector d_Xrot, fVector d_Yrot, fVector d_X, fVector d_Y, ui size, float costheta, float sintheta );
void cusdVF_rotateCoordinates( fVector d_Xrot, fVector d_Yrot, fVector d_X, fVector d_Y, ui size, float *d_costheta, float *d_sintheta );
void cudaVCF_rotateCoordinates( cfVector d_XYrot, cfVector d_XY, ui size, float costheta, float sintheta );
void cusdVCF_rotateCoordinates( cfVector d_XYrot, cfVector d_XY, ui size, float *d_costheta, float *d_sintheta );
void VFcu_rotateCoordinates( fVector h_Xrot, fVector h_Yrot, fVector h_X, fVector h_Y, ui size, float costheta, float sintheta );
void VCFcu_rotateCoordinates( cfVector h_XYrot, cfVector h_XY, ui size, float costheta, float sintheta );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
procedure cudaVF_rotateCoordinates( d_Xrot, d_Yrot, d_X, d_Y:fVector; size:UIntSize; costheta, sintheta:Single );
procedure cusdVF_rotateCoordinates( d_Xrot, d_Yrot, d_X, d_Y:fVector; size:UIntSize; d_costheta, d_sintheta:Single );
procedure cudaVCF_rotateCoordinates( d_XYrot, d_XY:cfVector; size:UIntSize; costheta, sintheta:Single );
procedure cusdVCF_rotateCoordinates( d_XYrot, d_XY:cfVector; size:UIntSize; d_costheta, d_sintheta:Single );
procedure VFcu_rotateCoordinates( h_Xrot, h_Yrot, h_X, h_Y:fVector; size:UIntSize; costheta, sintheta:Single );
procedure VCFcu_rotateCoordinates( h_XYrot, h_XY:cfVector; size:UIntSize; costheta, sintheta:Single );
|
|
Beschreibung | Die entweder in dem reellen Vektorpaar X,Y oder in dem komplexen Vektor XY an die Funktion übergebenen Koordinaten werden entgegen dem Uhrzeigersinn um den Winkel theta gedreht. Dabei wird theta nicht selbst angegeben, sondern über seinen Cosinus und Sinus spezifiziert, also als costheta und sintheta:
Xroti = cos(theta) * Xi - sin(theta) * Yi,
Yroti = sin(theta) * Xi + cos(theta) * Yi
Das Ergebnis kann mit einem konstanten Faktor skaliert werden. Hierzu multipliziere man einfach costheta und sintheta mit dem gewünschten Skalierungsfaktor. Diese Funktion läßt sich auch für Berechnungen nach analogen Formeln einsetzen, d.h. costheta und sintheta müssen nicht einem tatsächlichen Drehwinkel entsprechen. |
|
|
|
|
VF_roundtoI | VD_roundtoI | VE_roundtoI |
VF_roundtoBI | VD_roundtoBI | VE_roundtoBI |
VF_roundtoSI | VD_roundtoSI | VE_roundtoSI |
VF_roundtoLI | VD_roundtoLI | VE_roundtoLI |
VF_roundtoQI | VD_roundtoQI | VE_roundtoQI |
VF_roundtoU | VD_roundtoU | VE_roundtoU |
VF_roundtoUB | VD_roundtoUB | VE_roundtoUB |
VF_roundtoUS | VD_roundtoUS | VE_roundtoUS |
VF_roundtoUL | VD_roundtoUL | VE_roundtoUL |
VF_roundtoUQ | VD_roundtoUQ | VE_roundtoUQ |
VF_roundtoUI | VD_roundtoUI | VE_roundtoUI |
|
Funktion | Rundung auf die nächste Ganzzahl |
|
Syntax C/C++ | #include <VFmath.h>
int VF_round( fVector Y, fVector X, ui size );
int VF_roundtoI( iVector Y, fVector X, ui size );
int VF_roundtoLI( liVector Y, fVector X, ui size );
(analog alle übrigen Funktionen dieser Familie) |
C++ VecObj | #include <OptiVec.h>
int vector<T>::round( const vector<T>& X );
int vector<int>::roundtoI( const vector<T>& X );
int vector<long>::roundtoLI( const vector<T>& X ); |
Pascal/Delphi | uses VFmath;
function VF_round( Y, X:fVector; size:UIntSize ):IntBool;
function VF_roundtoI( Y:iVector; X:fVector; size:UIntSize ):IntBool;
function VF_roundtoLI( Y:liVector; X:fVector; size:UIntSize ):IntBool;
(analog alle übrigen Funktionen dieser Familie) |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_round( fVector d_Y, fVector d_X, ui size );
int cudaVF_roundtoI( iVector d_Y, fVector d_X, ui size );
int VFcu_round( fVector h_Y, fVector h_X, ui size );
int VFcu_roundtoI( iVector h_Y, fVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_round( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVF_roundtoI( d_Y:iVector; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_round( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFcu_roundtoI( h_Y:iVector; h_X:fVector; size:UIntSize ): IntBool;
|
|
Beschreibung | Jedes Element von X wird auf die nächste ganze Zahl gerundet und das Ergebnis in Y gespeichert. Hierbei erfolgt gegebenenfalls eine Umwandlung des Datentyps (in den Funktionen VF_roundtoI, VF_roundtoLI, VF_roundtoU etc.). Sind zwei ganze Zahlen exakt gleich weit entfernt, erfolgt Rundung auf die nächste gerade Zahl. 1.5 wird demnach auf 2.0 aufgerundet, während 2.5 auf 2.0 abgerundet wird. |
|
Fehlerbehandlung | OVERFLOW- und DOMAIN-Fehler werden "stillschweigend" abgefangen und führen weder zu einer Fehlermeldung, noch werden sie durch den Rückgabewert angezeigt. Im Falle von OVERFLOW-Fehlern wird das Resultat gleich dem größten (bzw. am stärksten negativen) Wert gesetzt, der in dem jeweiligen Ziel-Datentyp möglich ist. DOMAIN-Fehler entstehen durch negative Zahlen in den Funktionen VF_ceiltoU, VD_ceiltoUS etc.; sie werden behandelt, indem das Resultat auf 0 gesetzt wird. |
|
Rückgabewert | immer FALSE (0) |
|
|
VF_rcubic | VD_rcubic | VE_rcubic |
VFx_rcubic | VDx_rcubic | VEx_rcubic |
VFu_rcubic | VDu_rcubic | VEu_rcubic |
VFux_rcubic | VDux_rcubic | VEux_rcubic |
|
Funktion | Kehrwert des Kubiks (Kehrwert der dritten Potenz) |
|
Syntax C/C++ | #include <VFmath.h>
int VF_rcubic( fVector Y, fVector X, ui size );
int VFx_rcubic( fVector Y, fVector X, ui size, float A, float B );
int VFu_rcubic( fVector Y, fVector X, ui size );
int VFux_rcubic( fVector Y, fVector X, ui size, float A, float B ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::rcubic( const vector<T>& X );
int vector<T>::x_rcubic( const vector<T>& X, const T& A, const T& B );
int vector<T>::u_rcubic( const vector<T>& X );
int vector<T>::ux_rcubic( const vector<T>& X, const T& A, const T& B ); |
Pascal/Delphi | uses VFmath;
function VF_rcubic( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_rcubic( Y, X:fVector; size:UIntSize; A, B:Single ): IntBool;
function VFu_rcubic( Y, X:fVector; size:UIntSize ): IntBool;
function VFux_rcubic( Y, X:fVector; size:UIntSize; A, B:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_rcubic( fVector d_Y, fVector d_X, ui size );
int cudaVFx_rcubic( fVector d_Y, fVector d_X, ui size, float A, float B );
int cusdVFx_rcubic( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B );
int VFucu_rcubic( fVector h_Y, fVector h_X, ui size );
int VFuxcu_rcubic( fVector h_Y, fVector h_X, ui size, float A, float B );
int cudaVFu_rcubic( fVector d_Y, fVector d_X, ui size );
int cudaVFux_rcubic( fVector d_Y, fVector d_X, ui size, float A, float B );
int cusdVFux_rcubic( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B );
int VFucu_rcubic( fVector h_Y, fVector h_X, ui size );
int VFuxcu_rcubic( fVector h_Y, fVector h_X, ui size, float A, float B );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_rcubic( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_rcubic( d_Y, d_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_rcubic( d_Y, d_X:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function VFcu_rcubic( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_rcubic( h_Y, h_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cudaVFu_rcubic( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFux_rcubic( d_Y, d_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFux_rcubic( d_Y, d_X:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function VFucu_rcubic( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFuxcu_rcubic( h_Y, h_X:fVector; size:UIntSize; A, B:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = 1 / Xi3
erweiterte Versionen: Yi = 1 / (A*Xi+B)3
"ungeschützte" Versionen (Präfix VFu_, VFux_, etc.):
Diese Funktionen führen keinerlei Fehlerbehandlung durch und sind hierdurch deutlich schneller als die Normalversionen. |
|
Fehlerbehandlung | SING- und OVERFLOW-Fehler ergeben ±HUGE_VAL. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0) |
|
|
VF_rquartic | VD_rquartic | VE_rquartic |
VFx_rquartic | VDx_rquartic | VEx_rquartic |
VFu_rquartic | VDu_rquartic | VEu_rquartic |
VFux_rquartic | VDux_rquartic | VEux_rquartic |
|
Funktion | Kehrwert der vierten Potenz |
|
Syntax C/C++ | #include <VFmath.h>
int VF_rquartic( fVector Y, fVector X, ui size );
int VFx_rquartic( fVector Y, fVector X, ui size, float A, float B );
int VFu_rquartic( fVector Y, fVector X, ui size );
int VFux_rquartic( fVector Y, fVector X, ui size, float A, float B ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::rquartic( const vector<T>& X );
int vector<T>::x_rquartic( const vector<T>& X, const T& A, const T& B );
int vector<T>::u_rquartic( const vector<T>& X );
int vector<T>::ux_rquartic( const vector<T>& X, const T& A, const T& B ); |
Pascal/Delphi | uses VFmath;
function VF_rquartic( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_rquartic( Y, X:fVector; size:UIntSize; A, B:Single ): IntBool;
function VFu_rquartic( Y, X:fVector; size:UIntSize ): IntBool;
function VFux_rquartic( Y, X:fVector; size:UIntSize; A, B:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_rquartic( fVector d_Y, fVector d_X, ui size );
int cudaVFx_rquartic( fVector d_Y, fVector d_X, ui size, float A, float B );
int cusdVFx_rquartic( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B );
int VFucu_rquartic( fVector h_Y, fVector h_X, ui size );
int VFuxcu_rquartic( fVector h_Y, fVector h_X, ui size, float A, float B );
int cudaVFu_rquartic( fVector d_Y, fVector d_X, ui size );
int cudaVFux_rquartic( fVector d_Y, fVector d_X, ui size, float A, float B );
int cusdVFux_rquartic( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B );
int VFucu_rquartic( fVector h_Y, fVector h_X, ui size );
int VFuxcu_rquartic( fVector h_Y, fVector h_X, ui size, float A, float B );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_rquartic( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_rquartic( d_Y, d_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_rquartic( d_Y, d_X:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function VFcu_rquartic( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_rquartic( h_Y, h_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cudaVFu_rquartic( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFux_rquartic( d_Y, d_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFux_rquartic( d_Y, d_X:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function VFucu_rquartic( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFuxcu_rquartic( h_Y, h_X:fVector; size:UIntSize; A, B:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = 1 / Xi4
erweiterte Versionen: Yi = 1 / (A*Xi+B)4
Der Kehrwert der vierten Potenz der Elemente von X wird in Y gespeichert.
Die "ungeschützten" Versionen (Präfix VFu_, VFux_ etc.) führen keinerlei Fehlerbehandlung durch, wodurch sie deutlich schneller als die Standardversionen werden, allerdings auch riskanter. |
|
Fehlerbehandlung | SING- und OVERFLOW-Fehler ergeben HUGE_VAL. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0) |
|
|
VFu_rsqrt | VDu_rsqrt | VEu_rsqrt |
|
Funktion | Kehrwert der Quadratwurzel |
|
Syntax C/C++ | #include <VFmath.h>
int VF_rsqrt( fVector Y, fVector X, ui size );
int VFx_rsqrt( fVector Y, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::rsqrt( const vector<T>& X );
int vector<T>::x_rsqrt( const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_rsqrt( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_rsqrt( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_rsqrt( fVector d_Y, fVector d_X, ui size );
int cudaVFx_rsqrt( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_rsqrt( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_rsqrt( fVector h_Y, fVector h_X, ui size );
int VFxcu_rsqrt( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_rsqrt( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_rsqrt( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_rsqrt( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_rsqrt( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_rsqrt( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = 1 / sqrt( Xi )
erweiterte Versionen: Yi = C / sqrt( A*Xi+B )
"ungeschützte" Versionen (Präfix VFu_, VFux_, etc.):
Diese Funktionen führen keinerlei Fehlerbehandlung durch und sind hierdurch deutlich schneller, stürzen aber unkontrolliert ab, falls ein negativer oder zu kleiner Eingabewert angetroffen wird. |
|
Fehlerbehandlung | Normale Versionen (VF_, VFx_ etc.): DOMAIN-Fehler entstehen in den reellen Versionen für negative Argumente und führen zum Ergebnis NAN ("not-a-number", IEEE-Nicht-Zahl). Argumente nahe oder gleich 0 führen zum Überlauf mit dem Ergebnis HUGE_VAL.
Ungeschützte Versionen (VFu_, VFux_ etc.): keine Fehlerbehandlung |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0) |
|
|
VF_rsquare | VD_rsquare | VE_rsquare |
VFx_rsquare | VDx_rsquare | VEx_rsquare |
VFu_rsquare | VDu_rsquare | VEu_rsquare |
VFux_rsquare | VDux_rsquare | VEux_rsquare |
|
Funktion | Kehrwert des Quadrats |
|
Syntax C/C++ | #include <VFmath.h>
int VF_rsquare( fVector Y, fVector X, ui size );
int VFx_rsquare( fVector Y, fVector X, ui size, float A, float B );
int VFu_rsquare( fVector Y, fVector X, ui size );
int VFux_rsquare( fVector Y, fVector X, ui size, float A, float B ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::rsquare( const vector<T>& X );
int vector<T>::x_rsquare( const vector<T>& X, const T& A, const T& B );
int vector<T>::u_rsquare( const vector<T>& X );
int vector<T>::ux_rsquare( const vector<T>& X, const T& A, const T& B ); |
Pascal/Delphi | uses VFmath;
function VF_rsquare( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_rsquare( Y, X:fVector; size:UIntSize; A, B:Single ): IntBool;
function VFu_rsquare( Y, X:fVector; size:UIntSize ): IntBool;
function VFux_rsquare( Y, X:fVector; size:UIntSize; A, B:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_rsquare( fVector d_Y, fVector d_X, ui size );
int cudaVFx_rsquare( fVector d_Y, fVector d_X, ui size, float A, float B );
int cusdVFx_rsquare( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B );
int VFucu_rsquare( fVector h_Y, fVector h_X, ui size );
int VFuxcu_rsquare( fVector h_Y, fVector h_X, ui size, float A, float B );
int cudaVFu_rsquare( fVector d_Y, fVector d_X, ui size );
int cudaVFux_rsquare( fVector d_Y, fVector d_X, ui size, float A, float B );
int cusdVFux_rsquare( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B );
int VFucu_rsquare( fVector h_Y, fVector h_X, ui size );
int VFuxcu_rsquare( fVector h_Y, fVector h_X, ui size, float A, float B );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_rsquare( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_rsquare( d_Y, d_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_rsquare( d_Y, d_X:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function VFcu_rsquare( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_rsquare( h_Y, h_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cudaVFu_rsquare( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFux_rsquare( d_Y, d_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFux_rsquare( d_Y, d_X:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function VFucu_rsquare( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFuxcu_rsquare( h_Y, h_X:fVector; size:UIntSize; A, B:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = 1 / Xi2
erweiterte Versionen: Yi = 1 / (A*Xi+B)2
"ungeschützte" Versionen (Präfix VFu_, VFux_, etc.):
Diese Funktionen führen keinerlei Fehlerbehandlung durch und sind hierdurch deutlich schneller als die Normalversionen. |
|
Fehlerbehandlung | SING- und OVERFLOW-Fehler ergeben HUGE_VAL. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0) |
|
|
VF_runintegralC | VD_runintegralC | VE_runintegralC |
|
Funktion | "Laufendes Integral" bei konstantem Abtastintervall |
|
Syntax C/C++ | #include <VFstd.h>
void VF_runintegralC( fVector Y, fVector X, ui size, float DeltaT ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::runintegralC( const vector<T>& X, T DeltaT ); |
Pascal/Delphi | uses VFstd;
procedure VF_runintegralC( Y, X:fVector; size:UIntSize; DeltaT:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_runintegralC( fVector d_Y, fVector d_X, ui size, float DeltaT );
int cusdVF_runintegralC( fVector d_Y, fVector d_X, ui size, float *d_DeltaT );
void VFcu_runintegralC( fVector h_Y, fVector h_X, ui size, float DeltaT );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_runintegralC( d_Y, d_X:fVector; size:UIntSize; DeltaT:Single ): IntBool;
function cusdVF_runintegralC( d_Y, d_X:fVector; size:UIntSize; d_DeltaT:PSingle ): IntBool;
procedure VFcu_runintegralC( h_Y, h_X:fVector; size:UIntSize; DeltaT:Single );
|
|
Beschreibung | Der Vektor X wird als Funktion der Variablen t angenommen mit konstanten Abständen zwischen den einzelnen t-Werten. Unter diesen Voraussetzungen sind die t-Werte im einzelnen unwichtig, und es wird zur Durchführung der Integration lediglich der Abstand DeltaT benötigt. Jedes Element Yi ist das Integral von X bis zum i-ten Element (dieses eingeschlossen). Wird nicht diese Punkt-für-Punkt-Integration, sondern nur die Fläche unter dem gesamten Vektor X benötigt, sollte VF_integralC verwandt werden. |
|
|
|
|
VF_runintegralV | VD_runintegralV | VE_runintegralV |
|
Funktion | "Laufendes Integral" |
|
Syntax C/C++ | #include <VFmath.h>
void VF_runintegralV( fVector Z, fVector X, fVector Y, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::runintegralV( const vector<T>& X, const vector<T>& Y ); |
Pascal/Delphi | uses VFmath;
procedure VF_runintegralV( Z, X, Y:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_runintegralV( fVector d_Z, fVector d_X, fVector d_Y, ui size );
void VFcu_runintegralV( fVector h_Z, fVector h_X, fVector h_Y, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_runintegralV( d_Z, d_X, d_Y:fVector; size:UIntSize );
procedure VFcu_runintegralV( h_Z, h_X, h_Y:fVector; size:UIntSize );
|
|
Beschreibung | Y ist eine Funktion der durch X repräsentierten Variablen x und wird Punkt für Punkt über diese integriert. Jedes Element Zi entspricht dem Integral von Y über x bis hin zum Element Yi (dieses eingeschlossen). Das erste Element von Z ist immer 0.0. Wird nicht diese Punkt-für-Punkt-Integration, sondern nur die Fläche unter dem gesamten Vektor Y benötigt, sollte VF_integralV verwandt werden. |
|
|
|
|
VF_runmax | VD_runmax | VE_runmax |
VI_runmax | VBI_runmax | VSI_runmax | VLI_runmax | VQI_runmax |
VU_runmax | VUB_runmax | VUS_runmax | VUL_runmax | VUI_runmax |
|
Funktion | "Laufendes" Maximum |
|
Syntax C/C++ | #include <VFstd.h>
void VF_runmax( fVector Y, fVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::runmax( const vector<T>& X ); |
Pascal/Delphi | uses VFstd;
procedure VF_runmax( Y, X:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_runmax( fVector d_Y, fVector d_X, ui size );
void VFcu_runmax( fVector h_Y, fVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_runmax( d_Y, d_X:fVector; size:UIntSize );
procedure VFcu_runmax( h_Y, h_X:fVector; size:UIntSize );
|
|
Beschreibung | Jedes Element von Y ist der größte bis einschließlich zum korrespondierenden Element angetroffene Wert in X. |
|
|
|
|
VF_runmin | VD_runmin | VE_runmin |
VI_runmin | VBI_runmin | VSI_runmin | VLI_runmin | VQI_runmin |
VU_runmin | VUB_runmin | VUS_runmin | VUL_runmin | VUI_runmin |
|
Funktion | "Laufendes" Minimum |
|
Syntax C/C++ | #include <VFstd.h>
void VF_runmin( fVector Y, fVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::runmin( const vector<T>& X ); |
Pascal/Delphi | uses VFstd;
procedure VF_runmin( Y, X:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_runmin( fVector d_Y, fVector d_X, ui size );
void VFcu_runmin( fVector h_Y, fVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_runmin( d_Y, d_X:fVector; size:UIntSize );
procedure VFcu_runmin( h_Y, h_X:fVector; size:UIntSize );
|
|
Beschreibung | Jedes Element von Y ist der kleinste (bzw. am stärksten negative) bis einschließlich zum korrespondierenden Element angetroffene Wert in X. |
|
|
|
|
VF_runprod | VD_runprod | VE_runprod |
VCF_runprod | VCD_runprod | VCE_runprod |
VPF_runprod | VPD_runprod | VPE_runprod |
|
Funktion | "Laufendes" Produkt |
|
Syntax C/C++ | #include <VFstd.h>
void VF_runprod( fVector Y, fVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::runprod( const vector<T>& X ); |
Pascal/Delphi | uses VFstd;
procedure VF_runprod( Y, X:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_runprod( fVector d_Y, fVector d_X, ui size );
void VFcu_runprod( fVector h_Y, fVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_runprod( d_Y, d_X:fVector; size:UIntSize );
procedure VFcu_runprod( h_Y, h_X:fVector; size:UIntSize );
|
|
Beschreibung | Jedes Element von Y ist das Produkt aller vorhergehenden und dem korrespondierenden Element von X. Man benutze diese Funktion mit Vorsicht: Überlauf kann schnell erreicht werden, und Unterlauf kann dazu führen, dass alle Elemente von einer Stelle an gleich 0 werden. |
|
|
|
|
VF_runsum | VD_runsum | VE_runsum |
VCF_runsum | VCD_runsum | VCE_runsum |
VI_runsum | VBI_runsum | VSI_runsum | VLI_runsum | VQI_runsum |
VU_runsum | VUB_runsum | VUS_runsum | VUL_runsum | VUI_runsum |
|
|
Syntax C/C++ | #include <VFstd.h>
void VF_runsum( fVector Y, fVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::runsum( const vector<T>& X ); |
Pascal/Delphi | uses VFstd;
procedure VF_runsum( Y, X:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_runsum( fVector d_Y, fVector d_X, ui size );
void VFcu_runsum( fVector h_Y, fVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_runsum( d_Y, d_X:fVector; size:UIntSize );
procedure VFcu_runsum( h_Y, h_X:fVector; size:UIntSize );
|
|
Beschreibung | Jedes Element von Y ist die Summe aller vorhergehenden und dem korrespondierenden Element von X. |
|
Fehlerbehandlung | keine (aber Vorsicht: Überlauf kann schnell erreicht werden!) |
|
|
|
VCF_sabsmax | VCD_sabsmax | VCE_sabsmax |
|
Funktion | Größtes Element eines komplexen Vektors nach Maßgabe der Summe |Re| + |Im| |
|
Syntax C/C++ | #include <VCFstd.h>
fComplex VCF_sabsmax( cfVector X, ui size); |
C++ VecObj | #include <OptiVec.h>
T vector<complex<T>>::sabsmax(); |
Pascal/Delphi | uses VCFstd;
function VCF_sabsmax( X:cfVector; size:UIntSize ):fComplex;
Alternative Syntax (veraltet, aber weiterhin unterstützt):
procedure VCF_sabsmax( var RetVal:fComplex; X:cfVector; size:UIntSize );
(analog VCD_, VCE_) |
|
CUDA-Funktion C/C++ | #include <cudaVCFstd.h>
int cudaVCF_sabsmax( fComplex *h_RetVal, cfVector d_X, ui size );
int cusdVCF_sabsmax( fComplex *d_RetVal, cfVector d_X, ui size );
fComplex VCFcu_sabsmax( cfVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VCFstd;
function cudaVCF_sabsmax( var h_RetVal:fComplex; d_X:cfVector; size:UIntSize ): IntBool;
function cusdVCF_sabsmax( d_RetVal:PfComplex; d_X:cfVector; size:UIntSize ): IntBool;
function VCFcu_sabsmax( h_X:cfVector; size:UIntSize ):fComplex;
|
|
Beschreibung | Die in bezug auf die Summe |Re| + |Im|größte innerhalb eines komplexen Vektors vorkommende Zahl wird gefunden und zurückgegeben. Wo möglich, wird man diese Funktion als wesentlich schnelleren Ersatz für VCF_cabsmax wählen. Die letztere Funktion sucht das Maximum nach dem Kriterium des Absolutwertes, sqrt(Re2 + Im2). |
|
|
Rückgabewert | größtes Vektorelement |
|
|
VCF_sabsmin | VCD_sabsmin | VCE_sabsmin |
|
Funktion | Kleinstes Element eines komplexen Vektors nach Maßgabe der Summe |Re| + |Im| |
|
Syntax C/C++ | #include <VCFstd.h>
fComplex VCF_sabsmin( cfVector X, ui size); |
C++ VecObj | #include <OptiVec.h>
T vector<complex<T>>::sabsmin(); |
Pascal/Delphi | uses VCFstd;
Alternative Syntax (veraltet, aber weiterhin unterstützt):
procedure VCF_sabsmin( var RetVal:fComplex; X:cfVector; size:UIntSize );
(analog VCD_, VCE_) |
|
CUDA-Funktion C/C++ | #include <cudaVCFstd.h>
int cudaVCF_sabsmin( fComplex *h_RetVal, cfVector d_X, ui size );
int cusdVCF_sabsmin( fComplex *d_RetVal, cfVector d_X, ui size );
fComplex VCFcu_sabsmin( cfVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VCFstd;
function cudaVCF_sabsmin( var h_RetVal:fComplex; d_X:cfVector; size:UIntSize ): IntBool;
function cusdVCF_sabsmin( d_RetVal:PfComplex; d_X:cfVector; size:UIntSize ): IntBool;
function VCFcu_sabsmin( h_X:cfVector; size:UIntSize ):fComplex;
|
|
Beschreibung | Die in bezug auf die Summe |Re| + |Im|kleinste innerhalb eines komplexen Vektors vorkommende Zahl wird gefunden und zurückgegeben. Wo möglich, wird man diese Funktion als wesentlich schnelleren Ersatz für VCF_cabsmax wählen. Die letztere Funktion sucht das Minimum nach dem Kriterium des Absolutwertes, sqrt(Re2 + Im2). |
|
|
Rückgabewert | kleinstes Vektorelement |
|
|
VF_scale10 | VD_scale10 | VE_scale10 |
|
Funktion | Skalierung mit ganzzahligen Potenzen von 10 |
|
Syntax C/C++ | #include <VFmath.h>
int VF_scale10( fVector Y, fVector X, ui size, int Expo ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::scale10( const vector<T>& X, int Expo ); |
Pascal/Delphi | uses VFmath;
function VF_scale10( Y, X:fVector; size:UIntSize; Expo:Integer ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_scale10( fVector d_Y, fVector d_X, ui size, int Expo );
int VFcu_scale10( fVector h_Y, fVector h_X, ui size, int Expo );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_scale10( d_Y, d_X:fVector; size:UIntSize; Expo:Integer ): IntBool;
function VFcu_scale10( h_Y, h_X:fVector; size:UIntSize; Expo:Integer ): IntBool;
|
|
Beschreibung | Yi = Xi * (10 Expo)
Höhere Potenzen von 10 können nicht mehr exakt dargestellt werden, wodurch möglicherweise Rundungsfehler entstehen. Bei einer Skalierung mit Potenzen von 2 mittels VF_scale2 tritt dieses Problem nicht auf; überdies ist VF_scale2 schneller als VF_scale10. Man gebrauche diese Funktion also mit Vorsicht. |
|
Fehlerbehandlung | OVERFLOW-Fehler ergeben ±HUGE_VAL. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0) |
|
|
VF_scale2 | VD_scale2 | VE_scale2 |
|
Funktion | Skalierung mit ganzzahligen Potenzen von 2 |
|
Syntax C/C++ | #include <VFmath.h>
int VF_scale2( fVector Y, fVector X, ui size, int Expo ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::scale2( const vector<T>& X, int Expo ); |
Pascal/Delphi | uses VFmath;
function VF_scale2( Y, X:fVector; size:UIntSize; Expo:Integer ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_scale2( fVector d_Y, fVector d_X, ui size, int Expo );
int VFcu_scale2( fVector h_Y, fVector h_X, ui size, int Expo );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_scale2( d_Y, d_X:fVector; size:UIntSize; Expo:Integer ): IntBool;
function VFcu_scale2( h_Y, h_X:fVector; size:UIntSize; Expo:Integer ): IntBool;
|
|
Beschreibung | Yi = Xi * (2 Expo) |
|
Fehlerbehandlung | OVERFLOW-Fehler ergeben ±HUGE_VAL. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0) |
|
|
VF_scalprod | VD_scalprod | VE_scalprod |
|
Funktion | Skalarprodukt zweier Vektoren |
|
Syntax C/C++ | #include <VFstd.h>
float VF_scalprod( fVector X, fVector Y, ui size ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::scalprod( const vector<T>& Y ); |
Pascal/Delphi | uses VFstd;
function VF_scalprod( X, Y:fVector; size:UIntSize ): Single; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_scalprod( float *h_RetVal, fVector d_X, fVector d_Y, ui size );
int cusdVF_scalprod( float *d_RetVal, fVector d_X, fVector d_Y, ui size );
float VFcu_scalprod( fVector h_X, fVector h_Y, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_scalprod( var h_RetVal:Single; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cusdVF_scalprod( d_RetVal:PSingle; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function VFcu_scalprod( h_X, h_Y:fVector; size:UIntSize ): Single;
|
|
Beschreibung | scalprod = Summe( Xi * Yi )
Das Skalarprodukt ist als Summe der Produkte korrespondierender Vektor-Elemente definiert. Der Spezialfall des Skalarproduktes eines Vektors mit sich selbst ist als VF_ssq ebenfalls erhältlich. Dessen Wurzel ist als Euclid'sche Norm über VF_Euclid zu berechnen. |
|
|
Rückgabewert | Skalarprodukt |
|
|
VF_searchC | VD_searchC | VE_searchC |
|
Funktion | binäre Suche nach dem einem vorgegebenen Wert am nächsten kommenden Tabellenelement |
|
Syntax C/C++ | #include <VFstd.h>
ui VF_searchC( fVector X, ui size, float C, int mode ); |
C++ VecObj | #include <OptiVec.h>
ui vector<T>::searchC( const T& C, int mode ); |
Pascal/Delphi | uses VFstd;
function VF_searchC( X:fVector; size:UIntSize; C:Single; mode:Integer ):UIntSize; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_searchC( ui *h_Ind, fVector d_X, ui size, float C, int mode );
int cusdVF_searchC( ui *d_Ind, fVector d_X, ui size, float *d_C, int mode );
ui VFcu_searchC( fVector h_X, ui size, float C, int mode );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_searchC( d_X:fVector; size:UIntSize; C:Single; mode:Integer ): IntBool;
function cusdVF_searchC( d_X:fVector; size:UIntSize; d_C:PSingle; mode:Integer ): IntBool;
function VFcu_searchC( h_X:fVector; size:UIntSize; C:Single; mode:Integer ):UIntSize;
|
|
Beschreibung | X wird als geordnete Tabelle angenommen (in streng aufsteigender oder abfallender Ordnung). Wenn C außerhalb des durch die Tabelle abgedeckten Wertebereiches liegt, wird das erste bzw. letzte Tabellenelement gewählt. Liegt C innerhalb des Tabellenbereiches, so entscheidet der gewählte Such-Modus über das Ergebnis:
mode = +1: | das nächste größere oder gleiche Element wird gefunden; |
mode = 0: | das C am nächsten kommende Element wird gefunden; sind zwei Elemente gleich weit von C entfernt, so wird dasjenige mit dem niedrigeren Index gewählt; |
mode = −1: | das nächste kleinere oder gleiche Element wird gefunden. |
|
|
|
Rückgabewert | Index des gefundenen Tabellenelementes |
|
|
VF_searchV | VD_searchV | VE_searchV |
|
Funktion | binäre Suche nach dem jedem Element eines Vektors am nächsten kommenden Eintrag einer Tabelle |
|
Syntax C/C++ | #include <VFstd.h>
void VF_searchV( uiVector Ind, fVector X, ui sizex, fVector Tab, ui sizetab, int mode ); |
C++ VecObj | #include <OptiVec.h>
void vector<ui>::searchV( const vector<T>& X, const vector<T>& Tab, int mode ); |
Pascal/Delphi | uses VFmath;
procedure VF_searchV( Ind:uiVector; X:fVector; sizex:UIntSize; Tab:fVector; sizetab:UIntSize; mode:Integer ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_searchV( uiVector d_Ind, fVector d_X, ui sizex, fVector d_Tab, ui sizetab, int mode );
void VFcu_searchV( uiVector h_Ind, fVector h_X, ui sizex, fVector h_Tab, ui sizetab, int mode );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_searchV( d_Ind:uiVector; d_X:fVector; sizex:UIntSize; d_Tab:fVector; sizetab:UIntSize; mode:Integer ): IntBool;
procedure VFcu_searchV( h_Ind:uiVector; h_X:fVector; sizex:UIntSize; h_Tab:fVector; sizetab:UIntSize; mode:Integer );
|
|
Beschreibung | Tab wird als geordnete Tabelle angenommen (in streng aufsteigender oder fallender Ordnung). Für jedes Element von X wird der diesem am nächsten kommende Tabelleneintrag gesucht. Liegt Xi außerhalb des durch die Tabelle abgedeckten Wertebereiches, so wird das erste bzw. letzte Tabellenelement gewählt. Liegt Xi innerhalb des Bereiches, so entscheidet der als mode gewählte Such-Modus über das Ergebnis:
mode = +1: | das nächste größere oder gleiche Element wird gefunden; |
mode = 0: | das Xi am nächsten kommende Element wird gefunden; sind zwei Elemente gleich weit von Xi entfernt, so wird dasjenige mit dem niedrigeren Index gewählt; |
mode = −1: | das nächste kleinere oder gleiche Element wird gefunden. |
sizex ist die Größe von X und von Ind, während sizetab die Größe der Tabelle Tab angibt. |
|
|
|
|
|
|
Syntax C/C++ | #include <VFmath.h>
int VF_sec( fVector Y, fVector X, ui size );
int VFx_sec( fVector Y, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::sec( const vector<T>& X );
int vector<T>::x_sec( const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_sec( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_sec( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_sec( fVector d_Y, fVector d_X, ui size );
int cudaVFx_sec( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_sec( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_sec( fVector h_Y, fVector h_X, ui size );
int VFxcu_sec( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_sec( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_sec( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_sec( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_sec( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_sec( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = sec( Xi )
= 1 / cos( Xi )
erweiterte Versionen: Yi = C * sec( A*Xi+B )
Der Secans ist als Kehrwert des Cosinus definiert (nicht zu verwechseln mit dessen Umkehrfunktion arccos). Für große Werte von Xi werden Rundungsfehler bemerkbar. Wenn sich die X-Werte als gebrochenzahlige Vielfache von p darstellen lassen, sollte man lieber VF_secrpi als VF_sec verwenden. |
|
Fehlerbehandlung | SING- oder OVERFLOW-Fehler führen zum Ergebnis ±HUGE_VAL.
TLOSS-Fehler ergeben ein Resultat von 1.0 (als ob das Argument 0.0 wäre). |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0). |
|
|
|
Funktion | Quadrat der Secans-Funktion |
|
Syntax C/C++ | #include <VFmath.h>
int VF_sec2( fVector Y, fVector X, ui size );
int VFx_sec2( fVector Y, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::sec2( const vector<T>& X );
int vector<T>::x_sec2( const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_sec2( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_sec2( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_sec2( fVector d_Y, fVector d_X, ui size );
int cudaVFx_sec2( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_sec2( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_sec2( fVector h_Y, fVector h_X, ui size );
int VFxcu_sec2( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_sec2( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_sec2( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_sec2( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_sec2( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_sec2( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = sec2( Xi )
erweiterte Versionen: Yi = C * sec2( A*Xi+B )
Das Quadrat trigonometrischer Funktionen läßt sich schneller und genauer direkt als über den Umweg der jeweils zugrundeliegenden Funktion bestimmen. |
|
Fehlerbehandlung | SING- oder OVERFLOW-Fehler führen zum vorgeschlagenen Ergebnis ±HUGE_VAL. TLOSS-Fehler ergeben ein Resultat von 1.0 bzw. C (als ob das Argument 0.0 wäre). |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0). |
|
|
|
|
Syntax C/C++ | #include <VFmath.h>
int VF_sech( fVector Y, fVector X, ui size );
int VFx_sech( fVector Y, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::sech( const vector<T>& X );
int vector<T>::x_sech( const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_sech( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_sech( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_sech( fVector d_Y, fVector d_X, ui size );
int cudaVFx_sech( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_sech( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_sech( fVector h_Y, fVector h_X, ui size );
int VFxcu_sech( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_sech( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_sech( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_sech( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_sech( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_sech( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen:
Yi = sech( Xi )
= 2 / (exp( Xi ) + exp( −Xi ))
erweiterte Versionen:
Yi = C * sech( A*Xi+B ) |
|
Fehlerbehandlung | Es dürften keine Fehler auftreten. |
|
Rückgabewert | immer FALSE(0) |
|
|
VFx_sech2 | VDx_sech2 | VEx_sech2 |
|
Funktion | Quadrat des Hyperbel-Secans |
|
Syntax C/C++ | #include <VFmath.h>
int VF_sech2( fVector Y, fVector X, ui size );
int VFx_sech2( fVector Y, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::sech2( const vector<T>& X );
int vector<T>::x_sech2( const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_sech2( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_sech2( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_sech2( fVector d_Y, fVector d_X, ui size );
int cudaVFx_sech2( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_sech2( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_sech2( fVector h_Y, fVector h_X, ui size );
int VFxcu_sech2( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_sech2( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_sech2( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_sech2( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_sech2( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_sech2( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = sech2( Xi )
erweiterte Versionen: Yi = C * sech2( A*Xi+B )
Die sech2-Funktion wird in der Physik beispielsweise zur Beschreibung ultrakurzer Lichtimpulse verwandt. Im Vergleich zu Gauss- oder Lorentz-förmigen Profilen verfügt die sech2-Funktion bei gegebener Autokorrelationsbreite (siehe VF_autocorr) über die kleinste Halbwertsbreite. |
|
Fehlerbehandlung | Es dürften keine Fehler auftreten. |
|
Rückgabewert | immer FALSE(0) |
|
|
VF_secrpi | VD_secrpi | VE_secrpi |
VF_secrpi2 | VD_secrpi2 | VE_secrpi2 |
VF_secrpi3 | VD_secrpi3 | VE_secrpi3 |
|
Funktion | Secans-Funktion für gebrochenzahlige Vielfache von p |
|
Syntax C/C++ | #include <VFmath.h>
int VF_secrpi( fVector Y, iVector P, ui size, int q );
int VF_secrpi2( fVector Y, iVector P, ui size, int q );
int VF_secrpi3( fVector Y, iVector P, ui size, int q ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::secrpi( const vector<int>& P, int q );
int vector<T>::secrpi2( const vector<int>& P, int q );
int vector<T>::secrpi3( const vector<int>& P, int q ); |
Pascal/Delphi | uses VFmath;
function VF_secrpi( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
function VF_secrpi2( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
function VF_secrpi3( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_secrpi( fVector d_Y, iVector d_P, ui size, int q );
int cudaVF_secrpi2( fVector d_Y, iVector d_P, ui size, int q );
int cudaVF_secrpi3( fVector d_Y, iVector d_P, ui size, int q );
int VFcu_secrpi( fVector h_Y, iVector h_P, ui size, int q );
int VFcu_secrpi2( fVector h_Y, iVector h_P, ui size, int q );
int VFcu_secrpi3( fVector h_Y, iVector h_P, ui size, int q );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_secrpi( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function cudaVF_secrpi2( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function cudaVF_secrpi3( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_secrpi( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_secrpi2( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_secrpi3( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
|
|
Beschreibung | Yi = sec( (Pi / q) * p )
Der Secans gebrochenzahliger Vielfacher von p wird berechnet. Es gibt drei Versionen. VF_secrpi ist für den allgemeinen Gebrauch mit beliebigem Nenner q bestimmt. Wenn q eine ganzzahlige Potenz von 2 ist, sollte die hierfür optimierte Funktion VF_secrpi2 eingesetzt werden, die viele Funktionswerte einer Tabelle entnimmt. Wenn q ein Vielfaches von 3 ist, sollte VF_secrpi3 gebraucht werden. VF_secrpi2 und VF_secrpi3 funktionieren auch mit Werten von q, für die sie nicht optimiert sind. Es wird allerdings Speicherplatz für die dann nutzlosen Tabellen vergeudet. |
|
Fehlerbehandlung | SING-Fehler entstehen, wenn Pi / q ein ungeradzahliges Vielfaches von 1/2 ist. Das Resultat ist in diesem Fall 0.0 (der Mittelwert zwischen +HUGE_VAL und -HUGE_VAL; ähnlich wie bei VF_cosecrpi wird hier keine Rücksicht darauf genommen, dass 0.0 nicht zum Wertebereich der Secans-Funktion gehört).
q muss ungleich 0 sein; dies wird nicht überprüft. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0). |
|
|
VF_selected_mean | VD_selected_mean | VE_selected_mean |
|
Funktion | Mittelwert der in ein ausgewähltes Intervall fallenden Elemente einer Verteilung |
|
Syntax C/C++ | #include <VFstd.h>
float VF_selected_mean( ui *nsel, fVector X, ui size
float XMin, float XMax ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::selected_mean( ui *nsel, T XMin, T XMax ); |
Pascal/Delphi | uses VFstd;
function VF_selected_mean( var nsel:UIntSize; X:fVector; size:UIntSize; XMin, XMax:Single ): Single; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_selected_mean( ui *h_nsel, fVector d_X, ui size, float XMin, float XMax );
int cusdVF_selected_mean( ui *h_nsel, fVector d_X, ui size, float *d_XMin, float *d_XMax );
float VFcu_selected_mean( ui *h_nsel, fVector h_X, ui size, float XMin, float XMax );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_selected_mean( var h_RetVal:Single; var h_nsel:UIntSize; d_X:fVector; size:UIntSize; XMin, XMax:Single ):: IntBool;
function cusdVF_selected_mean( d_RetVal:PSingle; var h_nsel:UIntSize; d_X:fVector; size:UIntSize; d_XMin, d_XMax:PSingle ):: IntBool;
function VFcu_selected_mean( var h_nsel:UIntSize; h_X:fVector; size:UIntSize; XMin, XMax:Single ): Single;
|
|
Beschreibung | Es werden diejenigen Elemente von X ausgewählt, für die gilt XMin ≤ Xi ≤ XMax.
Ihr Mittelwert wird bestimmt und zurückgegeben. Die Anzahl der selektierten Elemente wird in nsel gespeichert. Wird nsel nicht benötigt, so kann seine Adresse als NULL (C/C++) bzw. nil (Pascal/Delphi) an die Funktion übergeben, werden. |
|
Fehlerbehandlung | Falls überhaupt kein Element in den spezifizierten Bereich fällt, ist nsel = 0, und der Mittelwert von XMin und XMax wird zurückgegeben. Sofern der Zeiger *nsel als NULL / nil angegeben wurde (und nsel also auch nicht gleich Null gesetzt werden kann), wird zusätzlich eine Warn-Meldung ausgegeben. |
|
Rückgabewert | gefundener Mittelwert der selektierten Vektor-Elemente |
|
|
|
Funktion | Angabe, ob OptiVec-Funktionen automatisch den CUDA-Device nutzen sollen oder nicht |
|
Syntax C/C++ | #include <cudaVecLib.h>
void V_setAutoCudaUse( int UseCuda ); |
Delphi | uses VecLib;
procedure V_setAutoCudaUse( UseCuda: Integer ); |
|
Beschreibung | Standardmäßig werden die (Host-) Funktionen der cudaOptiVec-Bibliotheken (also derjenigen, die durch den Buchstaben "C" im Bibliotheksnamen gekennzeichnet sind, z.B. OVVC8C.LIB) automatisch entscheiden, ob ein Performance-Gewinn durch die Auslagerung von Rechenarbeit auf die GPU - den CUDA-Device - zu erwarten ist oder nicht – und entsprechend die entsprechende V?cu_ Funktion rufen, falls es einen Vorteil verspricht. Da allerdings die OptiVec-Funktionen nicht auf einfache Weise "wissen" können, wie sich die relative Qualität Ihrer CPU und Ihrer GPU zueinander verhält, ist dieser Entscheidungs-Algorithmus weit entfernt von Perfektion. Oft wird es besser sein, ihn abzuschalten. In diesem Fall muss allerdings im Quellcode für alle Funktionen, die tatsächlich auf die GPU ausgelagert werden sollen, in das Präfix vor den Unterstrich die Kennzeichnung "cu" eingefügt werden: Anstelle von VF_ schreiben Sie also VFcu_ usw. Falls Sie sich hierfür entscheiden, müssen Sie die Include-Dateien <cudaVFstd.h>, <cudaVFmath.h> usw. mit einschließen.
UseCuda = 0 schaltet die automatische Auslagerung auf den CUDA-Device ab.
Jeder Wert von UseCuda ungleich 0 schaltet sie wieder ein. |
|
|
|
|
Funktion | Ein-/Aus-Schalten von Warnungen bezüglich Nicht-OptiVec-Vektoren und -Matrizen während der Prüfung von Dimensions-Konsistenz in den Debug-Bibliotheken |
|
Syntax C/C++ | #include <Veclib.h>
void V_setBoundaryCheckWarn( int WarnLevel ); |
Pascal/Delphi | uses Veclib;
procedure V_setBoundaryCheckWarn( WarnLevel: IntBool ); |
|
Beschreibung | Die Debug-Bibliotheken zur Prüfung der Dimensions-Konsistenz (VCF4WD.LIB für Borland / CodeGear C++, OVVC4D.LIB für Visual C++, units in LIB4D für Delphi) geben im Normalfall eine Warnung aus, wenn ein nicht durch V?_vector oder M?_matrix generierter Eingabe-Vektor bzw. -Matrix angetroffen wird. Zwar ist die Verwendung von Nicht-OptiVec-Arrays (z.B. statische Arrays oder solche, die mittels malloc, new oder den Speicherverwaltungsfunktionen der Windows API erzeugt wurden) in OptiVec-Funktionen durchaus legal; es kann aber auch zu Gefahren führen. Eine von diesen Gefahren ist, dass die Debug-Bibliothek nicht überprüfen kann, ob ein Lese- oder Schreibvorgang über die Vektor-Grenzen hinaus droht.
Falls Sie auf die Verwendung von Nicht-OptiVec-Vektoren angewiesen sind und die entsprechenden Warnungen der Debug-Bibliotheken nicht angezeigt bekommen wollen, können Sie sie abschalten mittels Aufruf von
V_setBoundaryCheckWarn( 0 ); (C/C++) oder
V_setBoundaryCheckWarn( FALSE ); (Pascal / Delphi).
Hierdurch schalten Sie lediglich die beschriebenen Warnungen, nicht aber die Fehler-Meldungen ab. Im Detail sind die ausgegebenen Warn- und Fehlermeldungen unter V_checkBoundaries aufgeführt. |
|
|
|
|
|
Funktion | Wiederherstellen der Positions- und Skalierungs-Einstellungen eines zuvor mittels V_getCoordSystem gespeicherten Koordinatensystems |
|
Syntax C/C++ | #include <Vgraph.h>
void V_setCoordSystem( VCOORDSYSTEM *csys ); |
Pascal/Delphi | uses Vgraph;
procedure V_setCoordSystem( csys: VCOORDSYSTEM ); |
|
Beschreibung | Um zwischen mehreren gleichzeitig in einem Fenster angelegten Koordinatensystemen umschalten zu können, ist es nötig, deren Einstellungen mit V_getCoordSystem zu speichern und bei Bedarf mit V_setCoordSystem wiederherzustellen. Das Argument der Funktion ist die Adresse eines
struct VCOORDSYSTEM (C/C++, definiert in <Vgraph.h>) bzw.
record VCOORDSYSTEM (Pascal/Delphi, definiert in der unit VGraph).
Ein sBeispiel befindet sich bei der Beschreibung von V_getCoordSystem. |
|
|
|
|
|
Funktion | Auswahl eines cudaOptiVec-Workspace für die folgenden Funktionsaufrufe |
|
Syntax C/C++ | #include <cudaVecLib.h>
overror_t V_setCudaWorkspace( V_CUDAWORKSPACE wsp ); |
Delphi | uses VecLib;
function V_setCudaWorkspace( wsp: V_CUDAWORKSPACE ): Integer; |
|
Beschreibung | Ein cudaOptiVec-Workspace, der zuvor mittels V_createCudaWorkspace angelegt wurde, wird ausgewählt für die folgenden Aufrufe von cudaV?_-Funktionen. |
|
Rückgabewert | 0 bei Erfolg; Nicht-Null, falls der Workspace nicht existiert, keinen gültigen Stream oder kein gültiges Pufferspeicher-Handle enthält. Da u.U. sogar ein ungültiger Workspace scheinbar gültige Werte enthalten kann, werden eventuell nicht alle solche Fehler entdeckt. |
|
|
VF_setElement | VD_setElement | VE_setElement |
VCF_setElement | VCD_setElement | VCE_setElement |
VPF_setElement | VPD_setElement | VPE_setElement |
VI_setElement | VBI_setElement | VSI_setElement | VLI_setElement | VQI_setElement | |
VU_setElement | VUB_setElement | VUS_setElement | VUL_setElement | VUQ_setElement | VUI_setElement |
|
Funktion | Ein Vektor-Element auf einen bestimmten Wert setzen |
|
Syntax C/C++ | #include <VFstd.h>
void VF_setElement( fVector X, ui pos, float C ); |
C++ VecObj | #include <OptiVec.h>
vector<T>::setElement( ui pos, T C ); |
Pascal/Delphi | uses VFstd;
procedure VF_setElement( X:fVector; pos:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
void cudaVF_setElement( fVector d_X, ui pos, float C );
void cusdVF_setElement( fVector d_X, ui pos, float *d_C );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
procedure cudaVF_setElement( d_X:fVector; pos:UIntSize; C:Single );
procedure cusdVF_setElement( d_X:fVector; pos:UIntSize; d_C:PSingle );
|
|
Beschreibung | Das Element an der Position pos wird mit dem Wert C überschrieben.
Diese Funktion wird benötigt, um einzelne Elemente dynamisch allozierter Vektoren zu setzen. Hierfür gibt es in Delphi keinen anderen Mechanismus, und frühe Versionen von Borland C++ hatten einen Fehler in der Zeiger-Arithmetik, der ebenfalls durch Verwendung von VF_setElement umgangen werden kann. |
|
|
|
|
|
Funktion | Ereignis-Datei zur Aufnahme von Fehlermeldungen vorbereiten |
|
Syntax C/C++ | #include <VecLib.h>
void V_setErrorEventFile(
char *filename, unsigned ScreenAndFile ); |
Pascal/Delphi | uses VecLib;
procedure V_setErrorEventFile( filename:PChar; ScreenAndFile:UInt ); |
|
Beschreibung | Diese Funktion leitet die Ausgabe von durch OptiVec-Funktionen ausgegebenen Fehlermeldungen in eine Log-Datei um. filename ist der gewünschte Name dieser Ereignis-Datei ("Log-file"). ScreenAndFile entscheidet darüber, ob die Fehlermeldungen außer in die Datei zusätzlich auf dem Bildschirm auszugeben sind:
ScreenAndFile = 0: keine Bildschirm-Ausgabe
ScreenAndFile = 1: Ausgabe in Message-Box (also Windows-Standard)
ScreenAndFile = 2: Ausgabe als Text in stderr (nur für Console-Programme)
Über die Nutzung dieser Möglichkeiten für nicht von OptiVec-Funktionen stammende Meldungen informiert Kap. 5.5.
Um die Ereignis-Datei zu schließen und den Zustand der Ausgabe auf den bei ihrer Erzeugung durch den Wert von ScreenAndFile angegebenen Wert zurückzusetzen, rufe man V_closeErrorEventFile.
Durch Aufruf V_setErrorEventFile mit dem Wert von NULL oder "NULL" (C/C++) bzw. nil oder 'nil' (Pascal/Delphi) für filename wird gar keine Datei erzeugt:
V_setErrorEventFile( "NULL", 0 );: Jegliche Meldungen werden unterdrückt und nirgendwohin ausgegeben.
V_setErrorEventFile( "NULL", 1 );: Ausgabe erfolgt nur in Message-Box.
V_setErrorEventFile( "NULL", 2 );: nur für Konsolen-Programme: Ausgabe erfolgt nur als Text in stderr. Diese Option kann in Visual C++ nur mit der dynamischen RTL verwendet werden. In den Konfigurationen DebugStatic und ReleaseStatic ist sie nicht vorhanden und wird als "0" gewertet.
Eine eventuell zuvor erzeugte Log-Datei bleibt hierbei natürlich erhalten.
|
|
Fehlerbehandlung | Kann die Ereignisdatei nicht erzeugt oder geöffnet werden, wird das Programm mit der auf dem Bildschirm ausgegebenen Fehlermeldung "Cannot open error event file" abgebrochen. |
|
|
|
|
Funktion | Genauigkeit des Coprozessors (FPU) einstellen |
|
Syntax C/C++ | #include <VecLib.h>
void V_setFPAccuracy( unsigned level ); |
Pascal/Delphi | uses VecLib;
procedure V_setFPAccuracy( level:UInt ); |
|
Beschreibung | Diese Funktion ändert das Control-Word der FPU (bzw. des Coprozessors) zwecks Einstellung der als Argument level übergebenen Genauigkeit. Für level=1 erhält man float / Single-Genauigkeit, level=2 liefert double-Genauigkeit, und level=3 schaltet die FPU auf extended-Genauigkeit. Um die aktuell eingestellte Genauigkeit abzufragen, rufe man V_getFPAccuracy.
Den Coprozessor nur auf float / Single-Genauigkeit laufen zu lassen, kann eine deutliche Beschleunigung der Programmausführung bewirken, insbesondere für Funktionen mit Divisionen und auf Rechnern ab dem Pentium-Prozessor. Dies gilt für jegliche Funktionen (einschließlich OptiVec-Funktionen) aller Fließkomma-Datentypen. Auf diese Weise können auch VD_- und VE_-Funktionen mit float / Single-Genauigkeit ausgeführt werden – mit dem für double oder extended zulässigen Wertebereich, aber eben nur mit einfacher Genauigkeit.
Auf der anderen Seite reduzieren manche Versionen von Windows XP und Vista automatisch die Fließkomma-Genauigkeit auf doppelte anstelle der früher standardmäßigen dreifachen Genauigkeit (80-bit-extended). Um aus VD_ und VE_-Funktionen ausreichend genaue Ergebnisse zu erhalten, bietet es sich an, V_setFPAccuracy( 3 ); aufrufen und die damit verbundene geringe Geschwindigkeits-Einbuße in Kauf zu nehmen.
Es gibt einige Funktionen, die volle Coprozessor-Genauigkeit für Zwischenergebnisse benötigen, und wieder andere, die Genauigkeits-kontrollierte Iterationen durchführen. Es ist offensichtlich, dass letztere niemals auf doppelte Genauigkeit konvergieren können, wenn die FPU nur einfach-genau arbeitet. Dies kann dazu führen, dass eine solche Funktion in einer Endlos-Schleife hängenbleibt. Man darf daher niemals eine der folgenden Funktionen aufrufen, während die FPU auf einfache (oder, für VE_-Funktionen, auf doppelte) Genauigkeit geschaltet ist:
V?_Kepler,
M?_SVdecompose,
sämtliche nicht-lineare Datenanpassungsfunktionen wie VF_nonlinfit. |
|
|
|
|
Funktion | Verhalten im Falle von Fließkomma-Fehlern festlegen |
|
Syntax C/C++ | #include <VecLib.h>
void V_setFPErrorHandling( int fpHandlingMode ); |
Syntax Pascal/Delphi | uses VecLib;
type V_fphand = 0..$1717;
procedure V_setFPErrorHandling( fpHandlingMode:V_fpHand ); |
|
Beschreibung | V_setFPErrorHandling bestimmt in den Debug-Bibliotheken das Verhalten beim Auftreten von Fließkommafehlern innerhalb von OptiVec-Funktionen. Auf das Verhalten der Produktions-Bibliotheken hat diese Funktion keinen Einfluss, da letztere nie Meldungen über math-Fehler ausgeben.
Eine Anzahl von vordefinierten Konstanten fperrXXX steht für die Konstruktion des gewünschten Fehlerbehandlungs-Modus zur Verfügung:
Konstante | Wert | Bedeutung |
fperrIgnore | 0 | alle Fließkomma-Fehler ignorieren: Ergebnis stillschweigend auf Standardwert setzen, keine Fehlermeldung ausgeben, Programmausführung fortsetzen |
fperrNoteDOMAIN | $0001 | Fehlermeldung für DOMAIN-Fehler ausgeben |
fperrNoteSING | $0002 | Fehlermeldung für SING-Fehler ausgeben |
fperrNoteOVERFLOW | $0003 | Fehlermeldung für OVERFLOW-Fehler ausgeben |
fperrNoteTLOSS | $0004 | Fehlermeldung für TLOSS-Fehler ausgeben |
fperrAbortDOMAIN | $0101 | Programm im Falle von DOMAIN-Fehler abbrechen |
fperrAbortSING | $0202 | Programm im Falle von SING-Fehler abbrechen |
fperrAbortOVERFLOW | $0303 | Programm im Falle von OVERFLOW-Fehler abbrechen |
fperrAbortTLOSS | $0404 | Programm im Falle von TLOSS-Fehler abbrechen |
fperrDefaultHandling | $0107 | Entspricht fperrAbortDOMAIN + fperrNoteSING + fperrNoteOVERFLOW |
|
Beispiel | V_setFPErrorHandling( fperrAbortDOMAIN + fperrAbortSING + fperrAbortOVERFLOW + fperrNoteTLOSS );
In diesem Beispiel wird das Programm mit einer Fehlermeldung abgebrochen, falls einer der schwereren Fehler, DOMAIN oder SING, auftritt. Im Falle der weniger schweren OVERFLOW- und TLOSS-Fehler wird zwar eine Meldung ausgegeben, aber die Programmausführung mit den für die jeweilige Funktion vorgegebenen Standardwerten fortgesetzt. Falls mehrere Fehler desselben Fehlertyps nacheinander innerhalb ein- und derselben Funktion auftreten, wird nur eine einzige Meldung ausgegeben. Die folgenden Fehler werden stillschweigend behoben. |
|
|
|
|
|
Funktion | Verhalten im Falle von INTEGER OVERFLOW- und INTEGER DOMAIN-Fehlern festlegen (nur 32-bit) |
|
Syntax C/C++ | #include <VecLib.h>
typedef enum {
ierrIgnore = 0, ierrNote, ierrAbort
} V_ihand;
void V_setIntErrorHandling( V_ihand ihand ); |
Pascal/Delphi | uses VecLib;
type V_ihand = 0..2;
procedure V_setIntErrorHandling( ihand:V_iHand ); |
|
Beschreibung | Diese Funktion erlaubt es in den 32-bit-Bibliotheken, das Verhalten bei innerhalb von OptiVec-Funktionen auftretenden INTEGER OVERFLOW- und INTEGER DOMAIN-Fehlern zu definieren. In den 64-bit-Bibliotheken hat sie keine Wirkung . Sie muss mit einer der folgenden vordefinierten Konstanten als Argument aufgerufen werden:
ierrIgnore = 0;
ierrNote = 1;
ierrAbort = 2;
Die Standard-Einstellung ist, dass diese Fehler ignoriert und stillschweigend durch Abschneiden der überlaufenden Bits behoben werden (siehe Kap. 5.2 bezüglich Ganzzahl-Fehlern und ihrer Behandlung). Falls dieses Verhalten geändert werden soll, rufe man z.B.
V_setIntErrorHandling( ierrNote );
und füge den Buchstaben "o" an das Präfix aller derjenigen Ganzzahl-Funktionen an, für die Fehler abgefangen werden sollen: VIo_, VUSo_ usw. |
|
|
|
|
|
Funktion | Linienstärke für Plot-Funktionen modifizieren |
|
Syntax C/C++ | #include <Vgraph.h>
void V_setLineThickness( unsigned linethickness ); |
Pascal/Delphi | uses Vgraph;
procedure V_setLineThickness( linethickness:UInt ); |
|
Beschreibung | Die in den Plot-Funktionen VF_xyAutoPlot, VCF_autoPlot etc. verwandte Linienstärke wird auf linethickness gesetzt. Um den Standardzustand wiederherzustellen, rufe man V_setLineThickness mit linethickness = 1.
Für linethickness sind Werte zwischen 1 und 500 zulässig; allerdings endet der brauchbare Bereich bei einer Linienstärke von etwa 10. Eine Eingabe von 0 wird stillschweigend auf 1 heraufgesetzt. Man beachte, dass gepunktete oder gestrichelte Linien nur mit eine Linienstärke von 1 sauber gezeichnet werden. Für höhere Stärken sehen sie wie durchgezogene Linien aus. Dickere Linien werden langsamer gezeichnet als dünne. |
|
Fehlerbehandlung | Ein Wert für linethickness über 500 führt zur Ausgabe einer Warnung "Cannot use line thicker than 500 pixels." Das Programm wird mit der (immer noch unsinnigen) Linienstärke von 500 fortgesetzt. |
|
|
|
VF_setNWriteSeparate | VD_setNWriteSeparate | VE_setNWriteSeparate |
VCF_setNWriteSeparate | VCD_setNWriteSeparate | VCE_setNWriteSeparate |
VPF_setNWriteSeparate | VPD_setNWriteSeparate | VPE_setNWriteSeparate |
VI_setNWriteSeparate | VBI_setNWriteSeparate | VSI_setNWriteSeparate |
VLI_setNWriteSeparate | VQI_setNWriteSeparate |
VU_setNWriteSeparate | VUB_setNWriteSeparate | VUS_setNWriteSeparate |
VUL_setNWriteSeparate | VUI_setNWriteSeparate |
|
Funktion | Definition des von den V.._nwrite-Funktionen zu verwendenden Trenn-Strings |
|
Syntax C/C++ | #include <VFstd.h>
void VF_setNWriteSeparate( char *SepString ); |
Pascal/Delphi | uses VFstd;
procedure VF_setNWriteSeparate( SepString:PChar ); |
|
Beschreibung | Diese Funktion definiert das oder die Trennzeichen, mit denen die einzelnen Spalten in mittels VF_nwrite geschriebenen Tabellen voneinander abgegrenzt werden.
VF_setNWriteSeparate wirkt dabei nur auf die Zwischenräume zwischen den Spalten. Das Zeilenende wird durch VF_setNWriteSeparate nicht berührt und besteht immer aus einem Zeilenvorschub ("\n" für C/C++ und #13 for Pascal/Delphi).
SepString darf bis zu zwölf Zeichen umfassen. Die Standard-Einstellung ist ein Tab-Zeichen ("\t" für C/C++ und #9 for Pascal/Delphi). |
|
Fehlerbehandlung | Im Falle von Trenn-Strings mit mehr als zwölf Zeichen erfolgt ein Programm-Abbruch mit der Fehlermeldung "Invalid Parameter(s)".
Eine Überprüfung des Inhalts erfolgt dagegen nicht. |
|
|
|
VF_setODThresh | VD_setODThresh | VE_setODThresh |
VU_setODThresh | VUB_setODThresh | VUS_setODThresh |
VUL_setODThresh | VQI_setODThresh |
|
Funktion | Setzen der Schwelle für die Berechnung der Optischen Dichte |
|
Syntax C/C++ | #include <VFmath.h>
void VF_setODThresh( float minX, float minX0 ); |
C++ VecObj | #include <OptiVec>
void vector<T>::setODThresh( T minX, T minX0 ); |
Pascal/Delphi | uses VFmath;
procedure VF_setODThresh( minX, minX0:Single ); |
|
Beschreibung | Wie bei VF_OD und VF_ODwDark ausgeführt, führen Eingabewerte unter einer bestimmten Schwelle bei diesen Funktionen zum Ergebnis OD=0.0. Diese Schwelle kann mittels VF_setODThresh usw. auf einen beliebigen positiven Wert gesetzt werden. |
|
|
|
|
|
Funktion | Definieren eines Bildschirm- oder Druckseiten-Bereiches, innerhalb dessen Plot-Operationen vorgenommen werden sollen |
|
Syntax C/C++ | #include <Vgraph.h>
void V_setPlotRegion( int left, int top, int right, int bottom ); |
Pascal/Delphi | uses Vgraph;
procedure V_setPlotRegion( left, top, right, bottom:Integer); |
|
Beschreibung | Durch die an V_setPlotRegion übergebenen Parameter wird ein Rechteck definiert für Plot-Operationen. Das angegebene Rechteck nimmt bei Aufruf einer der VectorLib- Plotfunktionen das Koordinatensystem samt Beschriftung auf. Die Parameter left, top, right, bottom verstehen sich als Pixel-Werte, die von der linken oberen Ecke des Bildschirmes bzw. der Druckseite aus gezählt werden. V_setPlotRegion muss nach (!) V_initPlot oder V_initPrint aufgerufen werden. |
|
|
|
|
|
Funktion | Definieren einer von 10 abweichenden Basis für die Ganzzahl-Einlesefunktionen: nur C/C++! |
|
Syntax C/C++ | #include <VIstd.h>
(oder <VSIstd.h>, <VLIstd.h>, <VUstd.h>, ... *)
void V_setRadix( int radix ); |
|
Beschreibung | Nach dem Aufruf von V_setRadix verwenden die Einlese-Funktionen der Ganzzahl-Typen die als radix eingegebene Basis anstelle der Basis 10. Dies betrifft VI_read, VI_nread sowie die VBI_, VSI_, VLI_, VUB_, VUS_, VU_, VUL_ und VUL_- Versionen, nicht aber VQI_read oder VQI_nread (wo die Basis stets 10 ist).
Mögliche Werte für radix sind die Zahlen 2 bis 36 sowie 0. Im Falle von radix=0 wird eine automatische Erkennung der Basis durchgeführt:
Alle mit den Ziffern 1-9 beginnenden Zahlen werden als Dezimalzahlen erkannt, alle mit "0x" beginnenden Zahlen als Hexadezimalzahlen und alle mit 0 ohne "x" beginnenden Zahlen als Oktalzahlen interpretiert. |
|
Fehlerbehandlung | Die Eingabe von negativen Werten, von 1 oder Werten größer als 36 führt zum Programmabbruch mit der Fehlermeldung "Invalid Parameter(s)". |
|
|
|
VF_setRspEdit | VD_setRspEdit | VE_setRspEdit |
|
|
Syntax C/C++ | #include <VFstd.h>
void VF_setRspEdit( fComplex Trunc ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::setRspEdit( const complex<T>& Trunc ); |
Pascal/Delphi | uses VFstd;
procedure VF_setRspEdit( Trunc:fComplex ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
void cudaVF_setRspEdit( fComplex Trunc );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
procedure cudaVF_setRspEdit( Trunc:fComplex );
|
|
Beschreibung | In den Funktionen VF_convolve und VF_deconvolve wird durch Fourier-Transformation aus einer Response-Funktion ein Frequenzfilter berechnet, das anschließend auf einen Vektor angewendet wird. Falls für "breite" Response-Funktionen das Filter für hohe Frequenzen Null sein sollte, so führen doch Rundungsfehler dazu, dass kleine Zahlen ungleich Null anstelle der "korrekten" Nullen stehen.
Der maximale Rundungsfehler bei der Konstruktion des Filters Flt stellt sich in grober Näherung auf (size * big * prec), wobei big das betragsmäßig größte Element von Flt und prec die relative Fließkomma-Genauigkeit bedeuten. Jedes Element, das kleiner als dieser Wert ist, sollte als 0 betrachtet werden. Die Funktion VF_setRspEdit erlaubt eine genaue Festlegung dieser Schwelle. Der Realteil von Trunc bestimmt die Behandlung der Realteile des Filters und entsprechend der Imaginärteil von Trunc die Behandlung der Imaginärteile. Normalerweise wird man Trunc.Re = Trunc.Im wählen oder auch einen etwas striktereren (d.h. größereren) Wert für Trunc.Im.
Standardmäßig sind Werte von Trunc.Re = 16*EPSILON und Trunc.Im = 32*EPSILON eingestellt, wobei EPSILON je nach Datentyp für FLT_EPSILON, DBL_EPSILON oder LDBL_EPSILON steht (diese Konstanten sind für C/C++ in <float.h> definiert). Sowohl Trunc.Re als auch Trunc.Im müssen < 1.0 sein; andernfalls erfolgt eine Fehlermeldung "Invalid Parameter(s)" und Abbruch des Programms.
Ist die Editierung des Filters nicht erwünscht, wähle man Trunc.Re = Trunc.Im = 0.
Bei der Konvolution führt die Editierung des Filters zu einer (geringfügigen) Glättung des Ergebnisses. Bei der Dekonvolution besitzt sie noch eine andere Bedeutung: Für alle vollständig verlorenen Frequenzen, also für diejenigen Frequenzen, an denen der Filter gleich Null gesetzt wurde, wird eine Rekonstruktion gar nicht erst versucht. Die Editierung des Filters verhindert also eine Division durch sehr kleine Zahlen nahe oder gleich Null, die sonst zu OVERFLOW- oder SING-Fehlern führen könnte. Es wird daher geraten, die Editierung stets beizubehalten.
Um die derzeit eingestellte Schwelle abzufragen, bediene man sich der Funktion VF_getRspEdit. |
|
Fehlerbehandlung | Falls Trunc.Re oder Trunc.Im ≥ 1.0 sind, erfolgt eine Fehlermeldung "Invalid Parameter(s)" und Abbruch des Programms. |
|
|
|
|
Funktion | Größe der in den Plot-Funktionen verwandten Symbole modifizieren |
|
Syntax C/C++ | #include <Vgraph.h>
void V_setSymbolSize( float symsiz ); |
Pascal/Delphi | uses Vgraph;
procedure V_setSymbolSize( symsize:Single ); |
|
Beschreibung | Die Größe der in den Plot-Funktionen VF_xyAutoPlot, VCF_autoPlot etc. verwendeten Symbole wird durch Skalierung mit symsize verändert. Um den Standardwert einzustellen, rufe man V_setSymbolSize mit symsize=1.0.
Eine minimale Größe von einem Pixel ist stets gewährleistet, so dass man die Symbole mit dieser Funktion nicht zum vollständigen Verschwinden bringen kann. Brauchbare Werte für symsize reichen etwa von 0.5 bis 5.0. Werte über 50.0 sind nicht zulässig.
Wenn Sie sich zur Vergrößerung der Symbole entschließen, sollten Sie erwägen, auch die Stärke eventueller verbindender Linien zu modifizieren. Siehe V_setLineThickness.
N.B.: Es wird stets eine automatische Skalierung der Symbolgröße durchgeführt, um eine annähernd konstante Relation zwischen Symbolgröße und Größe des Koordinatensystems aufrecht zu erhalten (besonders wichtig für Windows-Anwendungen). Der Faktor symsize skaliert die Symbolgröße im Verhältnis zu dem automatisch gefundenen Wert. Es ist nicht möglich, die automatische Skalierung auszuschalten. |
|
Fehlerbehandlung | Ein Wert für symsize über 50.0 führt zur Ausgabe einer Warnung "Cannot scale symbols by more than a factor of 50.0". Das Programm wird mit dem (immer noch unsinnigen) Wert von 50.0 fortgesetzt. |
|
|
|
|
Funktion | Arbeits-Thread-Verwalter des Hauptprogramms als Callback in DLL setzen (nur "M"-Bibliotheken) |
|
Syntax C/C++ | #include <VecLib.h>
int V_setThreadHandler( V_THREADHANDLERFUNC ThreadHandler ); |
Pascal/Delphi | uses VecLib;
function V_setThreadHandler( ThreadHandler:V_THREADHANDLERFUNC ): IntBool; |
|
Beschreibung | Diese Funktion installiert ein Callback, durch das die in einer DLL verwendeten Arbeits-Threads vom Hauptprogramm aus verwaltet werden. Für Details siehe V_initMT.
|
|
Rückgabewert | FALSE (0), wenn der Callback fehlerfrei initialisiert werden konnte, andernfalls TRUE (≠ 0) |
|
|
VF_setWriteFormat | VD_setWriteFormat | VE_setWriteFormat |
VCF_setWriteFormat | VCD_setWriteFormat | VCE_setWriteFormat |
VPF_setWriteFormat | VPD_setWriteFormat | VPE_setWriteFormat |
VI_setWriteFormat | VBI_setWriteFormant | VSI_setWriteFormat |
VLI_setWriteFormat | VQI_setWriteFormat |
VU_setWriteFormat | VUB_setWriteFormat | VUS_setWriteFormat |
VUL_setWriteFormat | VUI_setWriteFormat |
|
Funktion | Definition des von den Funktionen V.._write und V.._nwrite zu verwendenden Zahlen-Formates: nur C/C++! |
|
Syntax C/C++ | #include <VFstd.h>
void VF_setWriteFormat( char *FormatString ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::setWriteFormat( char *FormatString ); |
|
Beschreibung | Die Funktionen der VF_write- und VF_nwrite- Familien benutzen intern die ANSI−C-Funktion fprintf zur Ausgabe von Zahlen in einen Stream.
Nach den in der Dokumentation Ihres C/C++−Compilers für printf beschriebenen Regeln läßt sich daher das verwendete Format auf die jeweiligen Bedürfnisse einstellen. Bei aller Freiheit der Format-Wahl denke man allerdings daran, dass sich nicht jedes beliebige Format dazu eignet, hinterher auch wieder eingelesen zu werden (siehe VF_read).
Man gebrauche VF_setWriteFormat nicht zur Definition von Whitespace vor oder nach den Zahlen. Hierfür ist VF_setWriteSeparate zuständig.
Einzelheiten zu den Versionen für die verschiedenen Datentypen entnehme man der folgenden Tabelle. Man beachte dabei die in der letzten Spalte angegebene maximale Länge des an VF_setWriteFormat übergebenen Formatstrings.
Version | Standard-Format | Alternativ-Beispiel | max. Länge |
VF_ | "% 11.8e" | "% 8.4f" | 16 |
VD_ | "% 19.16le" | "% 16.8lf" | 16 |
VE_ | "% 22.19Le" | "% 22.19LG" | 16 |
VCF_ | "% 11.8e, % 11.8e" | "{% 8.4f, % 8.4f}" | 32 |
VCD_ | "% 19.16le, % 19.16le" | "{% 19.16lE % 19.16lE}" | 32 |
VCE_ | "% 22.19Le, % 22.19Le" | "{% 22.19Lg % 22.19Lg}" | 32 |
VPF_ | "% 11.8e @% 11.8e" | "{% 8.4f @% 8.4f}" | 32 |
VPD_ | "% 19.16le @% 19.16le" | "{% 19.16lE @% 19.16lE}" | 32 |
VPE_ | "% 22.19Le @% 22.19Le" | "{% 22.19Lg @% 22.19Lg}" | 32 |
VI_ | 32-bit: "% 10d"
16-bit: "% 5d" | "0x% 8x"
"0x% 4x" | 12 12 |
VBI_ | "% 3hd" | "0x% 2hX" | 12 |
VSI_ | "% 5hd" | "0x% 4hX" | 12 |
VLI_ | "% 10ld" | "%08lXh" | 12 |
VQI_ | "% 20.0Lf" | | 16 |
VU_ | 32-bit: "% 10u" 16-bit "% 5u" | "%04xh"
"%04xh" | 12 12 |
VUB_ | "% 3hu" | "0%02ho" | 12 |
VUS_ | "% 5hu" | "0%04ho" | 12 |
VUL_ | "% 10lu" | "0%08lO" | 12 |
Der Datentyp quad wird intern vor der Ausgabe in extended umgewandelt, um die Funktion fprintf einsetzen zu können (die derzeit keine quads unterstützt). Daraus erklärt sich die Format-Angabe als long double. Ähnlich erklärt sich die 16-bit-Formatangabe für die 8-bit-Ganzzahlen, die zunächst automatisch auf 16 bit erweitert werden. |
|
Fehlerbehandlung | Im Falle von Formatstrings, die die angegebene Maximal-Länge überschreiten, erfolgt ein Programm-Abbruch mit der Fehlermeldung "Invalid Parameter(s)".
Eine Überprüfung des Inhalts des Formatstrings erfolgt dagegen nicht. Eventueller Unsinn macht sich daher erst im Ausgabe-Stream bemerkbar. |
|
|
|
VF_setWriteSeparate | VD_setWriteSeparate | VE_setWriteSeparate |
VCF_setWriteSeparate | VCD_setWriteSeparate | VCE_setWriteSeparate |
VPF_setWriteSeparate | VPD_setWriteSeparate | VPE_setWriteSeparate |
VI_setWriteSeparate | VBI_setWriteSeparate | VSI_setWriteSeparate |
VLI_setWriteSeparate | VQI_setWriteSeparate |
VU_setWriteSeparate | VUB_setWriteSeparate | VUS_setWriteSeparate |
VUL_setWriteSeparate | VUI_setWriteSeparate |
|
Funktion | Definition des von den V.._write Funktionen zu verwendenden Trenn-Strings |
|
Syntax C/C++ | #include <VFstd.h>
void VF_setWriteSeparate( char *SepString ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::setWriteSeparate( char *SepString ); |
Pascal/Delphi | uses VFstd;
procedure VF_setWriteSeparate( SepString:PChar ); |
|
Beschreibung | Diese Funktion setzt den Trenn-String, der von nachfolgenen VF_write verwandt wird. Standardmäßig verwendet VF_write den Zeilenvorschub ("\n" für C/C++; #13 für Pascal/Delphi), schreibt also jedes Vektorelement in eine eigene Zeile. Mittels VF_setWriteSeparate läßt sich beispielsweise stattdessen ein Tabulatorzeichen ("\t" für C/C++; #9 für Pascal/Delphi) als Trennung definieren oder auch eine Folge von Leerzeichen (z.B. " " für C/C++ or ' ' für Pascal/Delphi).
Der Trenn-String wird von VF_write nur zwischen den einzelnen geschriebenen Vektor-Elementen eingesetzt. Am Ende eines Vektors, d.h. nach dem letzten ausgegebenen Element, steht immer ein Zeilenvorschub ("\n" für C/C++; #13 für Pascal/Delphi) anstelle des Trenn-Strings.
SepString darf bis zu zwölf Zeichen umfassen.
nur C/C++:
Falls VF_write verwandt wird, um direkt auf den Drucker zuzugreifen (stream = stdprn), muss meist der Wagenrücklauf explizit angegeben und hierfür
VF_setWriteSeparate( "\n\r" );
aufgerufen werden. |
|
Fehlerbehandlung | Im Falle von Trenn-Strings mit mehr als zwölf Zeichen erfolgt ein Programm-Abbruch mit der Fehlermeldung "Invalid Parameter(s)".
Eine Überprüfung des Inhalts erfolgt dagegen nicht. |
|
|
|
|
Funktion | Signum-Funktion (Vergleich mit 0) |
|
Syntax C/C++ | #include <VFmath.h>
void VF_sgn( fVector Y, fVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::sgn( const vector<T>& X ); |
Pascal/Delphi | uses VFmath;
procedure VF_sgn( Y, X:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_sgn( fVector d_Y, fVector d_X, ui size );
void VFcu_sgn( fVector h_Y, fVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_sgn( d_Y, d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_sgn( h_Y, h_X:fVector; size:UIntSize );
|
|
Beschreibung | Jedes Element von X wird mit 0 verglichen und das Ergebnis des Vergleiches in Y gespeichert:
Yi = +1.0, wenn Xi > 0
Yi = 0.0, wenn Xi = 0
Yi = −1.0, wenn Xi < 0.
Diese Funktion ist identisch mit VF_cmp0. |
|
|
|
|
VI_shl | VBI_shl | VSI_shl | VLI_shl | VQI_shl | |
VU_shl | VUB_shl | VUS_shl | VUL_shl | VUQ_shl | VUI_shl |
|
Funktion | Bit-weise Verschiebung nach links |
|
Syntax C/C++ | #include <VImath.h>
void VI_shl( iVector Y, iVector X, ui size, unsigned C );
void VUL_shl( ulVector Y, ulVector X, ui size, unsigned C );
(analog alle übrigen Funktionen dieser Familie) |
C++ VecObj | #include <OptiVec.h>
void vector<T>::shl( const vector<T>& X, unsigned C ); |
Pascal/Delphi | uses VImath;
procedure VI_shl( Y, X:iVector; size:UIntSize; C:UInt );
procedure VUL_shl( Y, X:ulVector; size:UIntSize; C:UInt );
(analog alle übrigen Funktionen dieser Familie) |
|
CUDA-Funktion C/C++ | #include <cudaVImath.h>
int cudaVI_shl( iVector d_Y, iVector d_X, ui size, unsigned C );
int cudaVUL_shl( ulVector d_Y, ulVector d_X, ui size, unsigned C );
void VIcu_shl( iVector h_Y, iVector h_X, ui size, unsigned C );
void VULcu_shl( ulVector h_Y, ulVector h_X, ui size, unsigned C );
|
CUDA-Funktion Pascal/Delphi | uses VImath;
function cudaVI_shl( d_Y, d_X:iVector; size:UIntSize; C:UInt ): IntBool;
function cudaVUL_shl( d_Y, d_X:ulVector; size:UIntSize; C:UInt ): IntBool;
procedure VIcu_shl( h_Y, h_X:iVector; size:UIntSize; C:UInt );
procedure VULcu_shl( h_Y, h_X:ulVector; size:UIntSize; C:UInt );
|
|
Beschreibung | Yi = Xi << C
Alle Bits von Xi werden um so viele Positionen nach links geschoben wie im Parameter C angegeben. Dies entspricht einer Multiplikation mit 2C, wobei Überlauf in allen Versionen ebenso ignoriert wird wie Verlust des Vorzeichen-Bits (in den vorzeichenbehafteten Versionen).
Man beachte, dass eine Verschiebung von 8-bit-Zahlen (VBI_- und VUB_-Versionen) um mehr als 7 Positionen zum Verlust jeglicher ursprünglich vorhandener Bits ungleich 0 und somit zum Ergebnis 0 führt. Dasselbe gilt für die Verschiebung von 16-Bit-Zahlen (VSI_- und VUS_- Versionen) um mehr als 15 Positionen und für 32-Bit-Zahlen (VLI_- und VUL_-Versionen) bei Verschiebung um mehr als 31 Positionen.
C ist immer vom Datentyp unsigned/UInt. Eine Links-Verschiebung um negative C (sprich: eine Rechts-Verschiebung) ist daher nur durch Aufruf von VI_shr usw. möglich. |
|
|
|
|
VI_shr | VBI_shr | VSI_shr | VLI_shr | VQI_shr | |
VU_shr | VUB_shr | VUS_shr | VUL_shr | VUQ_shr | VUI_shr |
|
Funktion | Bit-weise Verschiebung nach rechts |
|
Syntax C/C++ | #include <VImath.h>
void VI_shr( iVector Y, iVector X, ui size,unsigned C );
void VUL_shr( ulVector Y, ulVector X, ui size, unsigned C );
(analog alle übrigen Funktionen dieser Familie) |
C++ VecObj | #include <OptiVec.h>
void vector<T>::shr( const vector<T>& X, unsigned C ); |
Pascal/Delphi | uses VImath;
procedure VI_shr( Y, X:iVector; size:UIntSize; C:UInt );
procedure VUL_shr( Y, X:ulVector; size:UIntSize; C:UInt );
(analog alle übrigen Funktionen dieser Familie) |
|
CUDA-Funktion C/C++ | #include <cudaVImath.h>
int cudaVI_shr( iVector d_Y, iVector d_X, ui size, unsigned C );
int cudaVUL_shr( ulVector d_Y, ulVector d_X, ui size, unsigned C );
void VIcu_shr( iVector h_Y, iVector h_X, ui size, unsigned C );
void VULcu_shr( ulVector h_Y, ulVector h_X, ui size, unsigned C );
|
CUDA-Funktion Pascal/Delphi | uses VImath;
function cudaVI_shr( d_Y, d_X:iVector; size:UIntSize; C:UInt ): IntBool;
function cudaVUL_shr( d_Y, d_X:ulVector; size:UIntSize; C:UInt ): IntBool;
procedure VIcu_shr( h_Y, h_X:iVector; size:UIntSize; C:UInt );
procedure VULcu_shr( h_Y, h_X:ulVector; size:UIntSize; C:UInt );
|
|
Beschreibung | Yi = Xi >> C
Alle Bits von Xi werden um so viele Positionen nach rechts geschoben wie im Parameter C angegeben. Dies entspricht einer Division durch 2C. Das Vorzeichen von Yi ist immer dasselbe wie von Xi. Im Unterschied zur "echten" Ganzzahl-Division wird das Ergebnis nicht in Richtung 0, sondern in Richtung "minus Unendlich" gerundet: −15 / 2 = -7, aber −15 >> 1 = -8. Durch Verschiebung von 8-bit-Zahlen (VBI_- und VUB_-Versionen) um mehr als 7 Positionen werden vorzeichenlose oder positive Zahlen in 0 überführt, während negative Zahlen −1 ergeben. Entsprechendes gilt für die Verschiebung von 16-Bit-Zahlen (VSI_- und VUS_- Versionen) um mehr als 15 Positionen und für 32-Bit-Zahlen (VLI_- und VUL_-Versionen) bei Verschiebung um mehr als 31 Positionen.
C ist immer vom Datentyp unsigned/UInt. Eine Rechts-Verschiebung um negative C (sprich: eine Links-Verschiebung) ist daher nur durch Aufruf von VI_shl etc. möglich. |
|
|
|
|
|
|
Syntax C/C++ | #include <VFmath.h>
int VF_sin( fVector Y, fVector X, ui size );
int VFx_sin( fVector Y, fVector X, ui size, float A, float B, float C );
int VFr_sin( fVector Y, fVector X, ui size );
int VFrx_sin( fVector Y, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::sin( const vector<T>& X );
int vector<T>::x_sin( const vector<T>& X, const T& A, const T& B, const T& C );
int vector<T>::r_sin( const vector<T>& X );
int vector<T>::rx_sin( const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_sin( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_sin( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function VFr_sin( Y, X:fVector; size:UIntSize ): IntBool;
function VFrx_sin( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_sin( fVector d_Y, fVector d_X, ui size );
int cudaVFx_sin( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_sin( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_sin( fVector h_Y, fVector h_X, ui size );
int VFxcu_sin( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_sin( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_sin( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_sin( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_sin( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_sin( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = sin( Xi )
erweiterte Versionen: Yi = C * sin( A*Xi+B )
Für große Werte von Xi nehmen Rundungsfehler überhand. Wenn sich die X-Werte als gebrochenzahlige Vielfache von p darstellen lassen, sollte man lieber VF_sinrpi als VF_sin verwenden.
Falls man andererseits sicher ist, dass sich alle Eingabewerte innerhalb eines "vernünftigen" Bereiches befinden, so können die schnelleren Funktionen mit reduziertem Eingabe-Bereich eingesetzt werden (Präfix VFr_ und VFrx_). Sie verlangen folgende Begrenzungen:
64-bit: |Xi| < 232 (ungefähr 4.2*109)
32-bit: |Xi| ≤ 2p).
Die Funktionen mit reduziertem Eingabe-Bereich existieren nur für die CPU, nicht für CUDA. |
|
Fehlerbehandlung | Genauigkeits-Fehler führen zum Resultat 0.0 (als ob das Argument 0.0 wäre) und zu einem Rückgabewert ungleich 0. Ansonsten werden diese Fehler ignoriert. _matherr wird daher nicht aufgerufen.
OVERFLOW-Fehler können nur in den komplexen Versionen auftreten und führen zum Resultat ±HUGE_VAL. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0) |
|
|
VFrx_sin2 | VDrx_sin2 | VErx_sin2 |
|
Funktion | Quadrat der Sinus-Funktion |
|
Syntax C/C++ | #include <VFmath.h>
int VF_sin2( fVector Y, fVector X, ui size );
int VFx_sin2( fVector Y, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::sin2( const vector<T>& X );
int vector<T>::x_sin2( const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_sin2( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_sin2( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_sin2( fVector d_Y, fVector d_X, ui size );
int cudaVFx_sin2( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_sin2( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_sin2( fVector h_Y, fVector h_X, ui size );
int VFxcu_sin2( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_sin2( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_sin2( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_sin2( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_sin2( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_sin2( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = sin2( Xi )
erweiterte Versionen: Yi = C * sin2( A*Xi+B )
Das Quadrat trigonometrischer Funktionen läßt sich schneller und genauer direkt als über den Umweg der jeweils zugrundeliegenden Funktion bestimmen.
Falls man andererseits sicher ist, dass sich alle Eingabewerte innerhalb eines "vernünftigen" Bereiches befinden, so können die schnelleren Funktionen mit reduziertem Eingabe-Bereich eingesetzt werden (Präfix VFr_ und VFrx_). Sie verlangen folgende Begrenzungen:
64-bit: |Xi| < 232 (ungefähr 4.2*109)
32-bit: |Xi| ≤ 2p).
Die Funktionen mit reduziertem Eingabe-Bereich existieren nur für die CPU, nicht für CUDA. |
|
Fehlerbehandlung | Genauigkeits-Fehler führen zum Resultat 0.0 (als ob das Argument 0.0 wäre) und zu einem Rückgabewert ungleich 0. Ansonsten werden diese Fehler ignoriert. _matherr wird daher nicht aufgerufen.
OVERFLOW-Fehler können nur in den komplexen Versionen auftreten und führen zum Resultat ±HUGE_VAL. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0). |
|
|
|
|
Syntax C/C++ | #include <VFmath.h>
int VF_sinc( fVector Y, fVector X, ui size );
int VFx_sinc( fVector Y, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::sinc( const vector<T>& X );
int vector<T>::x_sinc( const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_sinc( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_sinc( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_sinc( fVector d_Y, fVector d_X, ui size );
int cudaVFx_sinc( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_sinc( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_sinc( fVector h_Y, fVector h_X, ui size );
int VFxcu_sinc( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_sinc( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_sinc( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_sinc( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_sinc( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_sinc( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = sinc( Xi ) = sin( Xi ) / Xi
erweiterte Versionen: Yi = C * sinc( A*Xi+B )
Die sinc-Funktion für ein Argument von 0.0 ist als 1.0 definiert. Als Fourier-Transformierte eines Rechteck-Impulses wird die sinc-Funktion beispielsweise zur Beschreibung der Beugung an einem Spalt verwendet. |
|
Fehlerbehandlung | Für sehr große Argumente wird der Genauigkeitsverlust in der Berechnung der Sinusfunktion durch den gleichzeitig beginnenden Unterlauf "geheilt". Daher dürften keine Fehler auftreten. |
|
Rückgabewert | immer FALSE(0). |
|
|
VF_sincos | VD_sincos | VE_sincos |
VFx_sincos | VDx_sincos | VEx_sincos |
VFr_sincos | VDr_sincos | VEr_sincos |
VFrx_sincos | VDrx_sincos | VErx_sincos |
|
Funktion | Sinus- und Cosinus-Funktion gleichzeitig |
|
Syntax C/C++ | #include <VFmath.h>
int VF_sincos( fVector YSin, fVector YCos, fVector X, ui size );
int VFx_sincos( fVector YSin, fVector YCos, fVector X, ui size, float A, float B, float C );
int VFr_sincos( fVector YSin, fVector YCos, fVector X, ui size );
int VFrx_sincos( fVector YSin, fVector YCos, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::sincos( vector<T> YCos, const vector<T>& X );
int vector<T>::x_sincos( vector<T> YCos, const vector<T>& X, const T& A, const T& B, const T& C );
int vector<T>::r_sincos( vector<T> YCos, const vector<T>& X );
int vector<T>::rx_sincos( vector<T> YCos, const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_sincos( Sin, Cos, X:fVector; size:UIntSize ): IntBool;
function VFx_sincos( Sin, Cos, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function VFr_sincos( Sin, Cos, X:fVector; size:UIntSize ): IntBool;
function VFrx_sincos( Sin, Cos, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_sincos( fVector d_YSin, fVector d_YCos, fVector d_X, ui size );
int cudaVFx_sincos( fVector d_YSin, fVector d_YCos, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_sincos( fVector d_YSin, fVector d_YCos, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_sincos( fVector h_YSin, fVector h_YCos, fVector h_X, ui size );
int VFxcu_sincos( fVector h_YSin, fVector h_YCos, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_sincos( d_YSin, d_YCos, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_sincos( d_YSin, d_YCos, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_sincos( d_YSin, d_YCos, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_sincos( h_YSin, h_YCos, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_sincos( h_YSin, h_YCos, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen:
YSini = sin( Xi )
YCosi = cos( Xi )
erweiterte Versionen:
YSini = C * sin( A*Xi+B )
YCosi = C * cos( A*Xi+B )
Sinus- und Cosinus-Funktion werden gleichzeitig berechnet, was viel effizienter als die Berechnung in getrennten Aufrufen ist. Für sehr große Werte von Xi nehmen Rundungsfehler überhand. Wenn sich die X-Werte als gebrochenzahlige Vielfache von p darstellen lassen, sollte man lieber VF_sincosrpi als VF_sincos verwenden.
Falls man andererseits sicher ist, dass sich alle Eingabewerte innerhalb eines "vernünftigen" Bereiches befinden, so können die schnelleren Funktionen mit reduziertem Eingabe-Bereich eingesetzt werden (Präfix VFr_ und VFrx_). Sie verlangen folgende Begrenzungen:
64-bit: |Xi| < 232 (ungefähr 4.2*109)
32-bit: |Xi| ≤ 2p).
Die Funktionen mit reduziertem Eingabe-Bereich existieren nur für die CPU, nicht für CUDA. |
|
Fehlerbehandlung | Genauigkeits-Fehler ühren zum Resultat 1.0 für den Cosinus und 0.0 für den Sinus (als ob das Argument 0.0 wäre) sowie zu einem Rückgabewert ungleich 0. Ansonsten werden diese Fehler ignoriert. _matherr wird daher nicht aufgerufen. Andere Fehler dürften nicht auftreten. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0). |
|
|
VF_sincos2 | VD_sincos2 | VE_sincos2 |
VFx_sincos2 | VDx_sincos2 | VEx_sinco2 |
VFr_sincos2 | VDr_sincos2 | VEr_sincos2 |
VFrx_sincos2 | VDrx_sincos2 | VErx_sinco2 |
|
Funktion | Quadrat der Sinus- und der Cosinus-Funktion gleichzeitig |
|
Syntax C/C++ | #include <VFmath.h>
int VF_sincos2( fVector YSin2, fVector YCos2, fVector X, ui size );
int VFx_sincos2( fVector YSin2, fVector YCos2, fVector X, ui size, float A, float B, float C );
int VFr_sincos2( fVector YSin, fVector YCos, fVector X, ui size );
int VFrx_sincos2(fVector YSin, fVector YCos, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::sincos2( vector<T> YCos2, const vector<T>& X );
int vector<T>::x_sincos2( vector<T> YCos2, const vector<T>& X, const T& A, const T& B, const T& C );
int vector<T>::r_sincos2( vector<T> YCos, const vector<T>& X );
int vector<T>::rx_sincos2( vector<T> YCos, const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_sincos2( Sin, Cos, X:fVector; size:UIntSize ): IntBool;
function VFx_sincos2( Sin, Cos, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function VFr_sincos2( Sin, Cos, X:fVector; size:UIntSize ): IntBool;
function VFrx_sincos2(Sin, Cos, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_sincos2( fVector d_YSin, fVector d_YCos, fVector d_X, ui size );
int cudaVFx_sincos2( fVector d_YSin, fVector d_YCos, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_sincos2( fVector d_YSin, fVector d_YCos, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_sincos2( fVector h_YSin, fVector h_YCos, fVector h_X, ui size );
int VFxcu_sincos2( fVector h_YSin, fVector h_YCos, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_sincos2( d_YSin, d_YCos, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_sincos2( d_YSin, d_YCos, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_sincos2( d_YSin, d_YCos, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_sincos2( h_YSin, h_YCos, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_sincos2( h_YSin, h_YCos, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen:
YSin2i = sin2( Xi )
YCos2i = cos2( Xi )
erweiterte Versionen:
YSin2i = C * sin2( A*Xi+B )
YCos2i = C * cos2( A*Xi+B )
Das Quadrat trigonometrischer Funktionen läßt sich schneller und genauer direkt als über den Umweg der jeweils zugrundeliegenden Funktion bestimmen.
Falls man andererseits sicher ist, dass sich alle Eingabewerte innerhalb eines "vernünftigen" Bereiches befinden, so können die schnelleren Funktionen mit reduziertem Eingabe-Bereich eingesetzt werden (Präfix VFr_ und VFrx_). Sie verlangen folgende Begrenzungen:
64-bit: |Xi| < 232 (ungefähr 4.2*109)
32-bit: |Xi| ≤ 2p).
Die Funktionen mit reduziertem Eingabe-Bereich existieren nur für die CPU, nicht für CUDA. |
|
Fehlerbehandlung | Genauigkeits-Fehler führen zum Resultat 0.0 für den sin2 und 1.0 für den cos2 (als ob das Argument 0.0 wäre) sowie zu einem Rückgabewert ungleich 0. Ansonsten werden diese Fehler ignoriert. _matherr wird daher nicht aufgerufen. Andere Fehler dürften nicht auftreten. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0). |
|
|
VF_sincosrpi | VD_sincosrpi | VE_sincosrpi |
VF_sincosrpi2 | VD_sincosrpi2 | VE_sincosrpi2 |
VF_sincosrpi3 | VD_sincosrpi3 | VE_sincosrpi3 |
|
Funktion | Sinus und Cosinus von gebrochenzahligen Vielfachen von p |
|
Syntax C/C++ | #include <VFmath.h>
int VF_sincosrpi( fVector YSin, fVector YCos, iVector P, ui size, int q );
int VF_sincosrpi2( fVector YSin, fVector YCos, iVector P, ui size, int q );
int VF_sincosrpi3( fVector YSin, fVector YCos, iVector P, ui size, int q ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::sincosrpi( vector<T> YCos, const vector<int>& P, int q );
int vector<T>::sincosrpi2( vector<T> YCos, const vector<int>& P, int q );
int vector<T>::sincosrpi3( vector<T> YCos, const vector<int>& P, int q ); |
Pascal/Delphi | uses VFmath;
function VF_sincosrpi( YSin, YCos:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
function VF_sincosrpi2( YSin, YCos:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
function VF_sincosrpi3( YSin, YCos:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_sincosrpi( fVector d_YSin, fVector d_YCos, iVector d_P, ui size, int q );
int cudaVF_sincosrpi2( fVector d_YSin, fVector d_YCos, iVector d_P, ui size, int q );
int cudaVF_sincosrpi3( fVector d_YSin, fVector d_YCos, iVector d_P, ui size, int q );
int VFcu_sincosrpi( fVector h_YSin, fVector h_YCos, iVector h_P, ui size, int q );
int VFcu_sincosrpi2( fVector h_YSin, fVector h_YCos, iVector h_P, ui size, int q );
int VFcu_sincosrpi3( fVector h_YSin, fVector h_YCos, iVector h_P, ui size, int q );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_sincosrpi( d_YSin, d_YCos:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function cudaVF_sincosrpi2( d_YSin, d_YCos:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function cudaVF_sincosrpi3( d_YSin, d_YCos:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_sincosrpi( h_YSin, h_YCos:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_sincosrpi2( h_YSin, h_YCos:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_sincosrpi3( h_YSin, h_YCos:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
|
|
Beschreibung | YSini = sin( (Pi / q) * p )
YCosi = cos( (Pi / q) * p )
Es gibt drei Versionen. VF_sincosrpi ist für den allgemeinen Gebrauch mit beliebigem Nenner q bestimmt. Wenn q eine ganzzahlige Potenz von 2 ist, sollte die hierfür optimierte Funktion VF_sincosrpi2 eingesetzt werden, die viele Funktionswerte einer Tabelle entnimmt. Wenn q ein Vielfaches von 3 ist, sollte VF_sincosrpi3 gebraucht werden. VF_sincosrpi2 und VF_sincosrpi3 funktionieren auch mit Werten von q, für die sie nicht optimiert sind. Es wird allerdings Speicherplatz für die dann nutzlosen Tabellen vergeudet.
VF_sincosrpi3 bietet einen bequemen Weg, mit Grad-Einheiten anstatt im Bogenmaß zu rechnen. Wenn q gleich 180 ist, entspricht eine Einheit von 1 in P einem Grad. |
|
Fehlerbehandlung | Es dürften keine Fehler auftreten, solange q ≠ 0. |
|
Rückgabewert | immer FALSE(0) |
|
|
VCFx_sinh | VCDx_sinh | VCEx_sinh |
|
|
Syntax C/C++ | #include <VFmath.h>
int VF_sinh( fVector Y, fVector X, ui size );
int VFx_sinh( fVector Y, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::sinh( const vector<T>& X );
int vector<T>::x_sinh( const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_sinh( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_sinh( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_sinh( fVector d_Y, fVector d_X, ui size );
int cudaVFx_sinh( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_sinh( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_sinh( fVector h_Y, fVector h_X, ui size );
int VFxcu_sinh( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_sinh( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_sinh( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_sinh( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_sinh( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_sinh( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = sinh( Xi )
erweiterte Versionen: Yi = C * sinh ( A*Xi+B ) |
|
Fehlerbehandlung | OVERFLOW-Fehler ergeben ±HUGE_VAL. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0). |
|
|
VF_sinrpi | VD_sinrpi | VE_sinrpi |
VF_sinrpi2 | VD_sinrpi2 | VE_sinrpi2 |
VF_sinrpi3 | VD_sinrpi3 | VE_sinrpi3 |
|
Funktion | Sinus von gebrochenzahligen Vielfachen von p |
|
Syntax C/C++ | #include <VFmath.h>
int VF_sinrpi( fVector Y, iVector P, ui size, int q );
int VF_sinrpi2( fVector Y, iVector P, ui size, int q );
int VF_sinrpi3( fVector Y, iVector P, ui size, int q ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::sinrpi( const vector<int>& P, int q );
int vector<T>::sinrpi2( const vector<int>& P, int q );
int vector<T>::sinrpi3( const vector<int>& P, int q ); |
Pascal/Delphi | uses VFmath;
function VF_sinrpi( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
function VF_sinrpi2( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
function VF_sinrpi3( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_sinrpi( fVector d_Y, iVector d_P, ui size, int q );
int cudaVF_sinrpi2( fVector d_Y, iVector d_P, ui size, int q );
int cudaVF_sinrpi3( fVector d_Y, iVector d_P, ui size, int q );
int VFcu_sinrpi( fVector h_Y, iVector h_P, ui size, int q );
int VFcu_sinrpi2( fVector h_Y, iVector h_P, ui size, int q );
int VFcu_sinrpi3( fVector h_Y, iVector h_P, ui size, int q );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_sinrpi( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function cudaVF_sinrpi2( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function cudaVF_sinrpi3( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_sinrpi( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_sinrpi2( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_sinrpi3( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
|
|
Beschreibung | Yi = sin( (Pi / q) * p )
Es gibt drei Versionen. VF_sinrpi ist für den allgemeinen Gebrauch mit beliebigem Nenner q bestimmt. Wenn q eine ganzzahlige Potenz von 2 ist, sollte die hierfür optimierte Funktion VF_sinrpi2 eingesetzt werden, die viele Funktionswerte einer Tabelle entnimmt. Wenn q ein Vielfaches von 3 ist, sollte VF_sinrpi3 gebraucht werden. VF_sinrpi2 und VF_sinrpi3 funktionieren auch mit Werten von q, für die sie nicht optimiert sind. Es wird allerdings Speicherplatz für die dann nutzlosen Tabellen vergeudet. VF_sinrpi3 bietet einen bequemen Weg, mit Grad-Einheiten anstatt im Bogenmaß zu rechnen. Wenn q gleich 180 ist, entspricht eine Einheit von 1 in P einem Grad. |
|
Fehlerbehandlung | Es dürften keine Fehler auftreten, solange q ≠ 0. |
|
Rückgabewert | immer FALSE(0) |
|
|
VF_sintab2 | VD_sintab2 | VE_sintab2 |
VF_sintab3 | VD_sintab3 | VE_sintab3 |
|
| Tabelle der Sinus-Funktion für Argumente zwischen 0 und p/2 |
|
Syntax C/C++ | #include <xmath.h>
extern float VF_sintab2[ VF_tabsz2+1 ];
extern double VD_sintab2[ VD_tabsz2+1 ];
extern extended VE_sintab2[ VE_tabsz2+1 ];
extern float VF_sintab3[ VF_tabsz3+1 ];
extern double VD_sintab3[ VD_tabsz3+1 ];
extern extended VE_sintab3[ VE_tabsz3+1 ];
|
Pascal/Delphi | uses FSINTAB2, DSINTAB2, ESINTAB2,
FSINTAB3, DSINTAB3, ESINTAB3;
VF_sintab2: array[0..VF_tabsz2] of Single;
VD_sintab2: array[0..VD_tabsz2] of Double;
VE_sintab2: array[0..VE_tabsz2] of Extended;
VF_sintab3: array[0..VF_tabsz3] of Single;
VD_sintab3: array[0..VD_tabsz3] of Double;
VE_sintab3: array[0..VE_tabsz3] of Extended; |
|
Beschreibung | VF_sintab2[ i ] = sin( i/(2*VF_tabsz2) * p ), i=0,...,VF_tabsz2
VF_sintab3[ i ] = sin( i/(2*VF_tabsz3) * p ), i=0,...,VF_tabsz3
Diese Tabellen werden u.a. von den Funktionen der VF_sinrpi2-Familie benutzt und stehen auch für andere Zwecke zur Verfügung.
C/C++: Die Symbole VF_tabsz2 etc., die die Größe der Tabellen angeben, sind in <xmath.h> definiert.
Pascal/Delphi: Die Symbole VF_tabsz2 etc. sind jeweils in derselben unit wie die Tabellen definiert.
FreePascal/Lazarus: Diese Tabellen stehen für FreePascal/Lazarus nicht zur Verfügung. |
|
|
VF_smooth | VD_smooth | VE_smooth |
|
|
Syntax C/C++ | #include <VFstd.h>
void VF_smooth( fVector Y, fVector X, ui size, unsigned deg); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::smooth( const vector<T>& X, unsigned deg ); |
Pascal/Delphi | uses VFstd;
procedure VF_smooth( Y,X:fVector; size:UIntSize; deg: UInt ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_smooth( fVector d_Y, fVector d_X, ui size, unsigned deg);
void VFcu_smooth( fVector h_Y, fVector h_X, ui size, unsigned deg);
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_smooth( d_Y, d_X:fVector; size:UIntSize; deg:UInt ): IntBool;
procedure VFcu_smooth( h_Y, h_X:fVector; size:UIntSize; deg:UInt );
|
|
Beschreibung | Es handelt sich um eine primitive, aber sehr schnelle Tiefpaß-Filterung. Für jeden Punkt von X wird das gewichtete Mittel aus dem Punkt selbst und seinen nächsten Nachbarn gebildet. Das Argument deg gibt den Grad der Glättung an, d.h. die Zahl der in die Rechnung einbezogenen Punkte. Z.B. bedeutet deg = 3 eine 3-Punkt-Glättung nach der Formel Yi = 0.25 * (2*Xi + Xi−1 + Xi+1)
Höhere Glättungs-Grade (5, 7, 9...) werden intern durch wiederholte 3-Punkt-Glättung erzielt.
deg = 0 oder 1 bedeutet überhaupt keine Glättung, deg = 2 oder 3 wird als 3-Punkt-Glättung interpretiert, deg = 4 oder 5 als 5-Punkt-Glättung usf. |
|
|
|
|
VI_sort | VBI_sort | VSI_sort | VLI_sort | VQI_sort |
VU_sort | VUB_sort | VUS_sort | VUL_sort | VUI_sort |
|
Funktion | Sortieren in ansteigender oder absteigender Folge |
|
Syntax C/C++ | #include <VFstd.h>
void VF_sort( fVector Y, fVector X, ui size, int dir ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::sort( const vector<T>& X, int dir=1 ); |
Pascal/Delphi | uses VFstd;
procedure VF_sort( Y, X:fVector; size:UIntSize; dir:Integer ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_sort( fVector d_Y, fVector d_X, ui size, int dir );
void VFcu_sort( fVector h_Y, fVector h_X, ui size, int dir );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_sort( d_Y, d_X:fVector; size:UIntSize; dir:Integer ): IntBool;
procedure VFcu_sort( h_Y, h_X:fVector; size:UIntSize; dir:Integer );
|
|
Beschreibung | Für positives dir werden die Elemente in aufsteigender Folge sortiert, für negatives dir in abfallender Folge. In der vorliegenden Implementation wird der "Heapsort"- Algorithmus eingesetzt. |
|
|
|
|
VF_sortind | VD_sortind | VE_sortind |
VI_sortind | VBI_sortind | VSI_sortind | VLI_sortind | VQI_sortind |
VU_sortind | VUB_sortind | VUS_sortind | VUL_sortind | VUI_sortind |
|
Funktion | Sortieren des mit einem Vektor assoziierten Index-Arrays |
|
Syntax C/C++ | #include <VFstd.h>
void VF_sortind( uiVector Ind, fVector X, ui size, int dir ); |
C++ VecObj | #include <OptiVec.h>
void vector<ui>::sortind( const vector<T>& X, int dir=1 ); |
Pascal/Delphi | uses VFstd;
procedure VF_sortind( Ind:uiVector; X:fVector; size:UIntSize; dir:Integer ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_sortind( uiVector d_Ind, fVector d_X, ui size, int dir );
void VFcu_sortind( uiVector h_IndY, fVector h_X, ui size, int dir );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_sortind( d_Ind:uiVector; d_X:fVector; size:UIntSize; dir:Integer ): IntBool;
procedure VFcu_sortind( h_Ind:uiVector; h_X:fVector; size:UIntSize; dir:Integer );
|
|
Beschreibung | Ähnlich wie bei VF_sort wird eine Sortierung durchgeführt, jedoch werden hier nicht die Elemente selbst geordnet, sondern ein zugehöriger Index-Array Ind. Aufsteigende Ordnung wird für positives dir erhalten (d.h. der nullte Eintrag von Ind enthält den Index des kleinsten Elementes von X und der letzte Eintrag den Index des größten). Fallende Folge erhält man für negatives dir. Im Falle zweier oder mehrerer gleich großer Vektor-Elemente wird der jeweils niedrigere Index zuerst in Ind eingeordnet, unabhängig davon, ob die Sortierung in aufsteigender oder fallender Folge durchgeführt wird.
Diese Funktion sollte angewandt werden, wenn außer X noch weitere, mit X korrelierte Vektoren analog zu X geordnet werden sollen. Dieser Fall ist beispielsweise gegeben, wenn eine Messung von Y-Werten an zufällig ausgewählten Punkten X durchgeführt wurde und die Meßwerte nach Abschluß der Messung geordnet werden sollen (wobei natürlich jeder Y-Wert bei "seinem" X-Wert bleiben muss!). Man benutze VF_indpick (VD_indpick, VI_indpick etc.), um die tatsächliche Um-Sortierung von X und allen mit X korrelierten Vektoren durchzuführen. |
|
|
|
|
VF_spectrum | VD_spectrum | VE_spectrum |
VFb_spectrum | VDb_spectrum | VEb_spectrum |
|
Funktion | einseitige spektrale Leistungsdichte |
|
Syntax C/C++ | #include <VFstd.h>
float VF_spectrum( fVector Spc, ui specsiz, fVector X, ui xsiz, fVector Win );
float VFb_spectrum( fVector Spc, ui specsiz, fVector X, ui xsiz, fVector Win, fVector Buf ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::spectrum( const vector<T>& X, const vector<T>& Win );
T vector<T>::b_spectrum( const vector<T>& X, const vector<T>& Win, vector<T>& Buf ); |
Pascal/Delphi | uses VFstd;
function VF_spectrum( Spc:fVector; specsiz:UIntSize; X:fVector; xsiz:UIntSize; Win:fVector ): Single;
function VFb_spectrum( Spc:fVector; specsiz:UIntSize; X:fVector; xsiz:UIntSize; Win, Buf:fVector ): Single; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_spectrum( float *h_psdfNyq, fVector d_Spc, ui specsiz, fVector d_X, ui xsiz, fVector d_Win );
int cusdVF_spectrum( float *d_psdfNyq, fVector d_Spc, ui specsiz, fVector d_X, ui xsiz, fVector d_Win );
float VFcu_spectrum( fVector h_Spc, ui specsiz, fVector h_X, ui xsiz, fVector h_Win );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_spectrum( var h_psdfNyq:Single; d_Spc:fVector; specsiz:UIntSize; d_X:fVector; xsiz:UIntSize; d_Win:fVector ): IntBool;
function cusdVF_spectrum( d_psdfNyq:PSingle; d_Spc:fVector; specsiz:UIntSize; d_X:fVector; xsiz:UIntSize; d_Win:fVector ): IntBool;
function VFcu_spectrum( h_Spc:fVector; specsiz:UIntSize; h_X:fVector; xsiz:UIntSize; h_Win:fVector ): Single;
|
|
Beschreibung | Der Datensatz X wird spektral analysiert und die einseitige spektrale Leistungsdichte (engl.: power spectral density, PSD, das ist das mittlere Amplituden-Quadrat) in Spc gespeichert. xsiz muss mindestens 2*specsiz betragen und specsiz eine ganzzahlige Potenz von 2 sein. Intern wird X in (xsiz / specsiz)−1 Segmente unterteilt und über die für die einzelnen Segmente berechneten Spektren gemittelt. Jedes Segment der Länge 2*specsiz ergibt die PSD für specsiz+1 Frequenzen (siehe VF_FFT). Um specsiz als ganzzahlige Potenz von 2 definieren zu können, werden jedoch nur specsiz Punkte in Spc gespeichert. Der letzte Wert, d.h. die Leistungsdichte für die Nyquist-Frequenz fc, wird als Rückgabewert der Funktion behandelt und kann entweder vernachlässigt (durch Aufruf der Funktion wie eine void-Funktion bzw. eine procedure) oder als letztes Element in Spc gespeichert werden durch Aufruf in der Form
Spc[specsiz] = VF_spectrum( Spc, specsiz, X, xsiz, Win );
In diesem Fall muss Spc eine Länge von specsiz+1 haben.
Win ist ein Fenster, das auf die Datensegmente angewendet wird. Seine Größe ist immer 2*specsiz. Innerhalb der VectorLib-Bibliotheken sind drei Funktionen vorhanden, die passende Fenster erzeugen: VF_Welch, VF_Parzen und VF_Hann. Ein Rechteck-Fenster wird über VF_equ1 erhalten. Von seinem Gebrauch wird hier aber abgeraten.
Die Qualität des erhaltenen Spektrums kann auf einfache Weise über das Parseval'sche-Theorem getestet werden (wenn Sie durch Aufruf in der eben skizzierten Form auch den Wert an der Nyquist-Frequenz mit gespeichert haben): 1.0/xsize * VF_ssq( X, xsize ) muss ungefähr gleich VF_sum( Spc, specsiz+1 ) sein. Eine große Abweichung zwischen beiden Ausdrücken deutet auf ein zu großes Abtast-Intervall in X.
Intern benötigt VF_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 VFb_spectrum zu verwenden. Die Größe von Buf muss dabei ≥ 2*xsiz + 2*specsiz sein. 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.
Ein Beispiel für die Verwendung von VF_spectrum ist im Demo-Programm VDEMO gegeben.
|
|
Fehlerbehandlung | Wenn size nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf VF_spectrum basiert) mit der Fehlermeldung "Size must be integer power of 2." und bricht das Programm ab. |
|
Rückgabewert | spektrale Leistungsdichte bei der Nyquist-Frequenz |
|
|
VF_splinederiv2 | VD_splinederiv2 | VE_splinederiv2 |
|
Funktion | Erzeugung einer Tabelle zweiter Ableitungen für den Gebrauch in kubischer Spline-Interpolation |
|
Syntax C/C++ | #include <VFstd.h>
void VF_splinederiv2( fVector Y2, fVector XTab, fVector YTab, ui size, int specify, float Yp0, float Ypn ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::splinederiv2( const vector<T>& XTab, const vector<T>& YTab, int specify, T Yp0, T Ypn ); |
Pascal/Delphi | uses VFstd;
procedure VF_splinederiv2( Y2, XTab, YTab:fVector; size:UIntSize; specify:IntBool; Yp0, Ypn:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_splinederiv2( fVector d_Y2, fVector d_XTab, fVector d_YTab, ui size, int specify, float Yp0, float Ypn );
int cusdVF_splinederiv2( fVector d_Y2, fVector d_XTab, fVector d_YTab, ui size, int specify, float *d_Yp0, float *d_Ypn );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_splinederiv2( d_Y2, d_XTab, d_YTab:fVector; size:UIntSize; specify:IntBool; Yp0, Ypn:Single );
function cusdVF_splinederiv2( d_Y2, d_XTab, d_YTab:fVector; size:UIntSize; specify:IntBool; d_Yp0, d_Ypn:PSingle );
|
|
Beschreibung | Die zweite Ableitung der Tabelle YTab nach XTab wird für den Gebrauch mit VF_splineinterpol berechnet. Um zu einer eindeutigen Lösung zu gelangen, werden zwei zusätzliche Bedingungen benötigt. Wird specify gleich 0 gesetzt, so erhält man den sog. natürlichen kubischen Spline, und die Angabe von Yp0 und Ypn hat keinen Einfluß. Wird specify auf 1 gesetzt, so wird die gewünschte erste (!) Ableitung von Y an den Punkten 0 und size−1 über die Parameter Yp0 und Ypn an die Funktion übergeben.
size muss mindestens 3 betragen.
nur CUDA versionen: Diese Funktionen sind sehr langsam, da die Berechnung der Ableitungs-Tabelle auf der CPU erfolgen muss. Dies ist auch der Grund dafür, warum es keine V?cu_-Version gibt. |
|
|
|
|
VF_splineinterpol | VD_splineinterpol | VE_splineinterpol |
|
Funktion | allgemeine kubische Spline-Interpolation |
|
Syntax C/C++ | #include <VFstd.h>
void VF_splineinterpol( fVector Y, fVector X, ui sizex, fVector XTab, fVector YTab, fVector Y2Tab, ui sizetab ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::splineinterpol( const vector<T>& X, const vector<T>& XTab, const vector<T>& YTab, const vector<T>& Y2Tab ); |
Pascal/Delphi | uses VFstd;
procedure VF_splineinterpol( Y, X:fVector; sizex:UIntSize; XTab, YTab, Y2Tab:fVector; sizetab:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_splineinterpol( fVector d_Y, fVector d_X, ui sizex, fVector d_XTab, fVector d_YTab, fVector d_Y2Tab, ui sizetab );
void VFcu_splineinterpol( fVector h_Y, fVector h_X, ui sizex, fVector h_XTab, fVector h_YTab, fVector h_Y2Tab, ui sizetab );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_splineinterpol( d_Y, d_X:fVector; sizex:UIntSize; d_XTab, d_YTab, d_Y2Tab:fVector; sizetab:UIntSize );
procedure VFcu_splineinterpol( h_Y, h_X:fVector; sizex:UIntSize; h_XTab, h_YTab, h_Y2Tab:fVector; sizetab:UIntSize );
|
|
Beschreibung | Für jedes der sizex Elemente of X wird ein Y-Wert gewonnen durch kubische Spline-Interpolation einer Tabelle. Diese Tabelle muss in Form von XTab-YTab-Wertepaaren vorliegen, wobei zusätzlich die zweite Ableitung von YTab als Y2Tab übergeben werden muss. Y2Tab ist durch vorherigen Aufruf von VF_splinederiv2 zu erstellen. XTab muss geordnet sein (strikt aufsteigend oder abfallend). Außerdem müssen alle Werte von XTab verschieden sein (es können keine zwei YTab-Werte zu ein- und demselben XTab-Wert gehören!). Andernfalls droht Programmabbruch durch eine Division durch 0.
Für die meisten Anwendungszwecke bietet sich als vereinfachte Alternative zu dieser Funktion der Aufruf von VF_natCubSplineInterpol an.
sizetab muss mindestens 3 betragen. |
|
Fehlerbehandlung | keine (Sie sind also selbst dafür verantwortlich, dass alle XTab-Werte verschieden sind, dass die YTab-Werte nicht schon nahe an der Überlaufgrenze sind und dass die Tabelle mindestens aus drei Punkten besteht.) |
|
|
|
VFux_sqrt | VDux_sqrt | VEux_sqrt |
VCFx_sqrt | VCDx_sqrt | VCEx_sqrt |
|
|
Syntax C/C++ | #include <VFmath.h>
int VF_sqrt( fVector Y, fVector X, ui size );
int VFx_sqrt( fVector Y, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::sqrt( const vector<T>& X );
int vector<T>::x_sqrt( const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_sqrt( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_sqrt( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_sqrt( fVector d_Y, fVector d_X, ui size );
int cudaVFx_sqrt( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_sqrt( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_sqrt( fVector h_Y, fVector h_X, ui size );
int VFxcu_sqrt( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_sqrt( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_sqrt( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_sqrt( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_sqrt( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_sqrt( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = sqrt( Xi )
erweiterte Versionen: Yi = C * sqrt( A*Xi+B )
"ungeschützte" Versionen (Präfix VFu_, VFux_, etc.):
Diese Funktionen führen keinerlei Fehlerbehandlung durch und sind hierdurch deutlich schneller als die Normalversionen, stürzen aber unkontrolliert ab, falls ein negativer Eingabewert angetroffen wird. X-Werte nahe der Unterlauf-Grenze können zu dem Ergebnis 0 führen. Die ungeschützte erweiterte Version (VFux_) verlangt außer der Abwesenheit negativer Zahlen auch, dass weder das Produkt A*Xi noch die Summe A*Xi+B überlaufen. |
|
Fehlerbehandlung | Normale Versionen (VF_, VFx_ etc.): DOMAIN-Fehler entstehen in den reellen Versionen für negative Argumente und führen zum Ergebnis NAN ("not-a-number", IEEE-Nicht-Zahl).
Ungeschützte Versionen (VFu_, VFux_ etc.): keine Fehlerbehandlung |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0) |
|
|
VF_square | VD_square | VE_square |
VFx_square | VDx_square | VEx_square |
VFu_square | VDu_square | VEu_square |
VFux_square | VDux_square | VEux_square |
VCF_square | VCD_square | VCE_square |
VCFx_square | VCDx_square | VCEx_square |
VCFu_square | VCDu_square | VCEu_square |
VCFux_square | VCDux_square | VCEux_square |
VPF_square | VPD_square | VPE_square |
VPFu_square | VPDu_square | VPEu_square |
|
|
Syntax C/C++ | #include <VFmath.h>
int VF_square( fVector Y, fVector X, ui size );
int VFx_square( fVector Y, fVector X, ui size, float A, float B );
int VFu_square( fVector Y, fVector X, ui size );
int VFux_square( fVector Y, fVector X, ui size, float A, float B ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::square( const vector<T>& X );
int vector<T>::x_square( const vector<T>& X, const T& A, const T& B );
int vector<T>::u_square( const vector<T>& X );
int vector<T>::ux_square( const vector<T>& X, const T& A, const T& B ); |
Pascal/Delphi | uses VFmath;
function VF_square( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_square( Y, X:fVector; size:UIntSize; A, B:Single ): IntBool;
function VFu_square( Y, X:fVector; size:UIntSize ): IntBool;
function VFux_square( Y, X:fVector; size:UIntSize; A, B:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_square( fVector d_Y, fVector d_X, ui size );
int cudaVFx_square( fVector d_Y, fVector d_X, ui size, float A, float B );
int cusdVFx_square( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B );
int VFucu_square( fVector h_Y, fVector h_X, ui size );
int VFuxcu_square( fVector h_Y, fVector h_X, ui size, float A, float B );
int cudaVFu_square( fVector d_Y, fVector d_X, ui size );
int cudaVFux_square( fVector d_Y, fVector d_X, ui size, float A, float B );
int cusdVFux_square( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B );
int VFucu_square( fVector h_Y, fVector h_X, ui size );
int VFuxcu_square( fVector h_Y, fVector h_X, ui size, float A, float B );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_square( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_square( d_Y, d_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_square( d_Y, d_X:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function VFcu_square( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_square( h_Y, h_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cudaVFu_square( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFux_square( d_Y, d_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFux_square( d_Y, d_X:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function VFucu_square( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFuxcu_square( h_Y, h_X:fVector; size:UIntSize; A, B:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = Xi2
erweiterte Versionen: Yi = (A*Xi+B)2
"ungeschützte" Versionen (Präfix VFu_, VFux_, etc.):
Diese Funktionen führen keinerlei Fehlerbehandlung durch und sind hierdurch deutlich schneller als die Normalversionen. Die ungeschützten cartesisch-komplexen Versionen in extended-Genauigkeit (VCEu_, VCEux_) verzichten darüberhinaus auf einige der Sicherheitsmaßnahmen der Normalversionen und können für Ergebnisse nahe der Überlauf-Grenze abstürzen. Ergebnisse nahe der Unterlauf-Grenze können als 0 zurückgegeben werden. |
|
Fehlerbehandlung | OVERFLOW-Fehler ergeben HUGE_VAL. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0) |
|
|
|
Funktion | Quadratsumme (engl. sum-of-squares) |
|
Syntax C/C++ | #include <VFstd.h>
float VF_ssq( fVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::ssq(); |
Pascal/Delphi | uses VFstd;
function VF_ssq( X:fVector; size:UIntSize ): Single; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_ssq( float *h_RetVal, fVector d_X, ui size );
int cusdVF_ssq( float *d_RetVal, fVector d_X, ui size );
float VFcu_ssq( fVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_ssq( var h_RetVal:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_ssq( d_RetVal:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_ssq( h_X:fVector; size:UIntSize ): Single;
|
|
Beschreibung | ssq = Summe( Xi2 ) |
|
Fehlerbehandlung | keine (aber Vorsicht: diese Funktion neigt zum Überlauf!) |
|
|
|
VF_ssqdevC | VD_ssqdevC | VE_ssqdevC |
|
Funktion | Quadratsumme der Abweichung von einem bestimmtem Wert |
|
Syntax C/C++ | #include <VFstd.h>
float VF_ssqdevC( fVector X, ui size, float C ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::ssqdevC( const T& C ); |
Pascal/Delphi | uses VFstd;
function VF_ssqdevC( X:fVector; size:UIntSize; C:Single ): Single; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_ssqdevC( float *h_RetVal, fVector d_X, ui size, float C );
int cusdVF_ssqdevC( float *d_RetVal, fVector d_X, ui size, float *d_C );
float VFcu_ssqdevC( fVector X, ui size, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_ssqdevC( var h_RetVal:Single; d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_ssqdevC( d_RetVal:PSingle; d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function VFcu_ssqdevC( h_X:fVector; size:UIntSize; C:Single ): Single;
|
|
Beschreibung | ssqdevC = sum( (Xi - C)2 ) |
|
|
Rückgabewert | die gefundene Quadratsumme der Abweichungen |
|
|
VF_ssqdevV | VD_ssqdevV | VE_ssqdevV |
VF_ssqdevVwSaturation | VD_ssqdevVwSaturation | VE_ssqdevVwSaturation |
|
Funktion | Quadratsumme der Abweichung einer Verteilung von einer anderen |
|
Syntax C/C++ | #include <VFstd.h>
float VF_ssqdevV( fVector X, fVector Y, ui size );
float VF_ssqdevVwSaturation( fVector X, fVector Y, ui size ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::ssqdevV( const vector<T>& Y );
T vector<T>::ssqdevVwSaturation( const vector<T>& Y ); |
Pascal/Delphi | uses VFstd;
function VF_ssqdevV( X, Y:fVector; size:UIntSize ): Single;
function VF_ssqdevVwSaturation( X, Y:fVector; size:UIntSize ): Single; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_ssqdevV( float *h_RetVal, fVector X, fVector Y, ui size );
int cusdVF_ssqdevV( float *d_RetVal, fVector X, fVector Y, ui size );
float VFcu_ssqdevV( fVector h_X, fVector h_Y, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_ssqdevV( var h_RetVal:Single; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cusdVF_ssqdevV( d_RetVal:PSingle; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function VFcu_ssqdevV( h_X, h_Y:fVector; size:UIntSize ): Single;
|
|
Beschreibung | ssqdevV = Summe( (Xi - Yi)2 )
V?_ssqdevVwSaturation ist sehr ähnlich zu V?_ssqdevV, außer in der Behandlung von Überlauf und von NAN. Während V?_ssqdevV zu INF überlaufen kann und im Falle von einem oder mehreren Eingabe-Elementen = NAN auch NAN zurückgeben wird, „sättigt” V?_ssqdevVwSaturation INF zu HUGE_VAL und behandelt Eingabewerte von ±NAN als ±HUGE_VAL, gibt also auch in diesem Fall HUGE_VAL zurück. |
|
|
Rückgabewert | die gefundene Quadratsumme der Abweichungen |
|
|
VCF_store | VCD_store | VCE_store |
VPF_store | VPD_store | VPE_store |
VI_store | VBI_store | VSI_store | VLI_store | VQI_store | |
VU_store | VUB_store | VUS_store | VUL_store | VUQ_store | VUI_store |
|
Funktion | Speichern im Maschinenformat in einem Stream |
|
Syntax C/C++ | #include <VFstd.h>
int VF_store( FILE *stream, fVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::store( FILE *stream ); |
Pascal/Delphi | uses VFstd;
function VF_store( var Stream:FILE; X:fVector; size:UIntSize ): Integer; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
void cudaVF_store( FILE *stream, fVector d_X, ui size );
void cudaVF_store_buf( FILE *stream, fVector d_X, ui size, fVector h_Wk );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
procedure cudaVF_store( var Stream:FILE; d_X:fVector; size:UIntSize );
procedure cudaVF_store_buf( var Stream:FILE; d_X:fVector; size:UIntSize; h_Wk:fVector );
|
|
Beschreibung | size Elemente von X werden im Maschinenformat (d.h. binär) in stream abgelegt. stream muss bereits für Schreib-Operationen im Binärfomat geöffnet sein.
Die VecObj-Version speichert nicht nur die Vektor-Elemente, sondern ein ganzes Vektor-Objekt, indem zuerst size und dann die einzelnen Elemente in stream abgelegt werden. Man beachte, dass VF_recall etc. daher nur Vektoren lesen kann, die mit den "normalen" Funktionen VF_store etc. gespeichert wurden, während die VecObj-Funktion recall zum Einlesen von Vektor-Objekten gebraucht wird, die zuvor mit der VecObj-Member-Funktion store gespeichert wurden. Man kann allerdings die Sequenz
VUI_store( stream, &size, 1 );
VF_store( stream, X, size ); /* C/C++ */
oder
VU_store( stream, @size, 1 );
VF_store( stream, X, size ); (* Pascal/Delphi *)
verwenden, um den gespeicherten Vektor X später als Vektor-Objekt einlesen zu können.
nur CUDA-Versionen: cudaV?_store_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 cudaV?_store eingespart, so dass cudaV?_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 VE_store / VE_recall, VCE_store / VCE_recall und VPE_store / VPE_recall stets im 10-byte-Format. |
|
Thread-Sicherheit | Verschiedene Threads können gefahrlos mehrere Funktionen der VF_ / MF_store- und VF_ / MF_recall-Familien gleichzeitig aufrufen, solange sie auf verschiedene Streams zugreifen. Falls sie allerdings auf ein- und denselben Stream zugreifen, müssen unbedingt durch geeignete Maßnahmen (Critical Sections, Mutexes) Race−Conditions verhindert werden. |
|
Fehlerbehandlung | wird durch die C-Funktion fwrite bzw. die Delphi-Funktion BlockWrite durchgeführt, auf der MF_store etc. basieren |
|
Rückgabewert | 0, wenn fehlerfrei; ansonsten 1. Um mehr Information im Falle eines Fehlers zu erhalten, inspiziere man errno (C/C++) oder IOResult (Delphi). |
|
|
VCF_subReC | VCD_subReC | VCE_subReC |
VI_subC | VBI_subC | VSI_subC | VLI_subC | VQI_subC | |
VU_subC | VUB_subC | VUS_subC | VUL_subC | VUQ_subC | VUI_subC |
|
Funktion | Konstante subtrahieren |
|
Syntax C/C++ | #include <VFmath.h>
void VF_subC( fVector Y, fVector X, ui size, float C );
void VCF_subC( cfVector Y, cfVector X, ui size, fComplex C );
void VCF_subReC( cfVector Y, cfVector X, ui size, float CRe ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::subC( const vector<T>& X, const T& C );
void vector<complex<T>>::subC( const vector<complex<T>>& X, complex<T> C );
void vector<complex<T>>::subReC( const vector<complex<T>>& X, const T& CRe ); |
Pascal/Delphi | uses VFmath;
procedure VF_subC( Y, X:fVector; size:UIntSize; C:Single );
procedure VCF_subC( Y, X:cfVector; size:UIntSize; C:fComplex );
procedure VCF_subReC( Y, X:cfVector; size:UIntSize; CRe:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_subC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_subC( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_subC( fVector d_Y, fVector d_X, ui size, float C );
#include <cudaVCFmath.h>
int cudaVCF_subReC( cfVector d_Y, cfVector d_X, ui size, float CRe );
int cusdVCF_subReC( cfVector d_Y, cfVector d_X, ui size, float *d_CRe );
void VCFcu_subReC( cfVector h_Y, cfVector h_X, ui size, float CRe );
|
CUDA-Funktion Pascal/Delphi | uses VFmath, VCFmath;
function cudaVF_subC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_subC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VFcu_subC( h_Y, h_X:fVector; size:UIntSize; C:Single );
function cudaVCF_subReC( d_Y, d_X:cfVector; size:UIntSize; CRe:Single );
function cusdVCF_subReC( d_Y, d_X:cfVector; size:UIntSize; d_CRe:PSingle );
procedure VCFcu_subReC( h_Y, h_X:cfVector; size:UIntSize; CRe:Single );
|
|
Beschreibung | Yi = Xi - C
Die komplexen Versionen existieren in zwei Varianten: eine für komplexe Konstanten C, die andere für reelle Konstanten CRe, die von dem komplexen Vektor abgezogen werden. |
|
Fehlerbehandlung | Fließkomma-Versionen: keine;
Ganzzahl-Versionen: siehe Kap. 5.2. |
|
|
|
VCF_subrC | VCD_subrC | VCE_subrC |
VCF_subrReC | VCD_subrReC | VCE_subrReC |
VI_subrC | VBI_subrC | VSI_subrC | VLI_subrC | VQI_subrC | |
VU_subrC | VUB_subrC | VUS_subrC | VUL_subrC | VUQ_subrC | VUI_subrC |
|
Funktion | umgekehrte Subtraktion: Vektor von einer Konstanten abziehen |
|
Syntax C/C++ | #include <VFmath.h>
void VF_subrC( fVector Y, fVector X, ui size, float C );
void VCF_subrC( cfVector Y, cfVector X, ui size, fComplex C );
void VCF_subrReC( cfVector Y, cfVector X, ui size, float CRe ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::subrC( const vector<T>& X, const T& C );
void vector<complex<T>>::subrC( const vector<complex<T>>& X, complex<T> C );
void vector<complex<T>>::subrReC( const vector<complex<T>>& X, const T& CRe ); |
Pascal/Delphi | uses VFmath;
procedure VF_subrC( Y, X:fVector; size:UIntSize; C:Single );
procedure VCF_subrC( Y, X:cfVector; size:UIntSize; C:fComplex );
procedure VCF_subrReC( Y, X:cfVector; size:UIntSize; CRe:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_subrC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_subrC( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_subrC( fVector d_Y, fVector d_X, ui size, float C );
#include <cudaVCFmath.h>
int cudaVCF_subrReC( cfVector d_Y, cfVector d_X, ui size, float CRe );
int cusdVCF_subrReC( cfVector d_Y, cfVector d_X, ui size, float *d_CRe );
void VCFcu_subrReC( cfVector h_Y, cfVector h_X, ui size, float CRe );
|
CUDA-Funktion Pascal/Delphi | uses VFmath, VCFmath;
function cudaVF_subrC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_subrC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VFcu_subrC( h_Y, h_X:fVector; size:UIntSize; C:Single );
function cudaVCF_subrReC( d_Y, d_X:cfVector; size:UIntSize; CRe:Single );
function cusdVCF_subrReC( d_Y, d_X:cfVector; size:UIntSize; d_CRe:PSingle );
procedure VCFcu_subrReC( h_Y, h_X:cfVector; size:UIntSize; CRe:Single );
|
|
Beschreibung | Yi = C - Xi
Die komplexen Versionen existieren in zwei Varianten: eine für komplexe Konstanten C, die andere für reelle Konstanten CRe, von denen die komplexen Vektorelemente abgezogen werden. |
|
Fehlerbehandlung | Fließkomma-Versionen: keine;
Ganzzahl-Versionen: siehe Kap. 5.2. |
|
|
|
VCF_subrV | VCD_subrV | VCE_subrV |
VCF_subrReV | VCD_subrReV | VCE_subrReV |
VFx_subrV | VDx_subrV | VEx_subrV |
VCFx_subrV | VCDx_subrV | VCEx_subrV |
VCFx_subrReV | VCDx_subrReV | VCEx_subrReV |
VI_subrV | VBI_subrV | VSI_subrV | VLI_subrV | VQI_subrV | |
VU_subrV | VUB_subrV | VUS_subrV | VUL_subrV | VUQ_subrV | VUI_subrV |
|
Funktion | Umgekehrte Subtraktion zweier Vektoren |
|
Syntax C/C++ | #include <VFmath.h>
void VF_subrV( fVector Z, fVector X, fVector Y, ui size );
void VFx_subrV( fVector Z, fVector X, fVector Y, ui size, float A, float B );
void VCF_subrV( cfVector Z, cfVector X, cfVector Y, ui size );
void VCF_subrReV( cfVector Z, cfVector X, fVector Y, ui size );
void VCFx_subrV( cfVector Z, cfVector X, cfVector Y, ui size, fComplex A, fComplex B );
void VCFx_subrReV( cfVector Z, cfVector X, fVector Y, ui size, fComplex A, fComplex B ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::subrV( const vector<T>& X, const vector<T>& Y );
void vector<T>::x_subrV( const vector<T>& X, const vector<T>& Y, const T& A, const T& B );
void vector<complex<T>>::subrV( const vector<complex<T>>& X, const vector<complex<T>>& Y );
void vector<complex<T>>::subrReV( const vector<complex<T>>& X, const vector<T>& Y );
void vector<complex<T>>::x_subrV( const vector<complex<T>>& X, const vector<complex<T>>& Y, complex<T> A, complex<T> B );
void vector<complex<T>>::x_subrReV( const vector<complex<T>>& X, const vector<T>& Y, complex<T> A, complex<T> B ); |
Pascal/Delphi | uses VFmath;
procedure VF_subrV( Z, X, Y:fVector; size:UIntSize );
procedure VFx_subrV( Z, X, Y:fVector; size:UIntSize; A, B:Single);
procedure VCF_subrV( Z, X, Y:cfVector; size:UIntSize );
procedure VCF_subrReV( Z, X:cfVector; Y:fVector; size:UIntSize );
procedure VCFx_subrV( Z, X, Y:cfVector; size:UIntSize; A, B:fComplex );
procedure VCFx_subrReV( Z, X:cfVector; Y:fVector; size:UIntSize; A, B:fComplex ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
#include <cudaVCFmath.h>
int cudaVF_subrV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
int cudaVFs_subrV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float C );
int cusdVFs_subrV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_C );
int cudaVFx_subrV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float A, float B );
int cusdVFx_subrV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_A, float *d_B );
int cudaVCF_subrReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size );
int cudaVCFx_subrReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size, fComplex A, fComplex B );
int cusdVCFx_subrReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size, fComplex *d_A, fComplex *d_B );
void VFcu_subrV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
void VFscu_subrV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float C );
void VFxcu_subrV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float A, float B );
void VCFcu_subrReV( cfVector h_Z, cfVector h_X, fVector h_Y, ui size );
void VCFxcu_subrV( cfVector h_Z, cfVector h_X, cfVector h_Y, ui size, fComplex A, fComplex B );
void VCFxcu_subrReV( cfVector h_Z, cfVector h_X, fVector h_Y, ui size, fComplex A, fComplex B );
|
CUDA-Funktion Pascal/Delphi | uses VFmath, VCFmath;
function cudaVF_subrV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cudaVFs_subrV( d_Z, d_X, d_Y:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVFs_subrV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function cudaVFx_subrV( d_Z, d_X, d_Y:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_subrV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function cudaVCF_subrReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize ): IntBool;
function cudaVCFx_subrReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize; A, B:fComplex ): IntBool;
function cusdVCFx_subrReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize; d_A, d_B:PfComplex ): IntBool;
procedure VFcu_subrV( h_Z, h_X, h_Y:fVector; size:UIntSize );
procedure VFscu_subrV( h_Z, h_X, h_Y:fVector; size:UIntSize; C:Single );
procedure VFxcu_subrV( h_Z, h_X, h_Y:fVector; size:UIntSize; A, B:Single );
procedure VCFcu_subrReV( h_Z, h_X:cfVector; h_Y:fVector; size:UIntSize );
procedure VCFxcu_subrReV( h_Z, h_X:cfVector; h_Y:fVector; size:UIntSize; A, B:fComplex );
|
|
Beschreibung | einfache Versionen: Zi = Yi - Xi
erweiterte Versionen: Zi = Yi - (A*Xi+B)
Die komplexen Versionen existieren in zwei Varianten: Bei der ersten (z.B. VCF_subrV, VCFx_subrV) sind X, Y und Z komplex; bei der zweiten ist Y reell (z.B. VCF_subrReV - "umgekehrte Subtraktion von reellem Vektor", d.h.: komplexen von reellem Vektor abziehen). |
|
Fehlerbehandlung | Fließkomma-Versionen: keine;
Ganzzahl-Versionen: siehe Kap. 5.2. |
|
|
|
VF_subrVI | VD_subrVI | VE_subrVI |
VF_subrVBI | VD_subrVBI | VE_subrVBI |
VF_subrVSI | VD_subrVSI | VE_subrVSI |
VF_subrVLI | VD_subrVLI | VE_subrVLI |
VF_subrVQI | VD_subrVQI | VE_subrVQI |
VF_subrVU | VD_subrVU | VE_subrVU |
VF_subrVUB | VD_subrVUB | VE_subrVUB |
VF_subrVUS | VD_subrVUS | VE_subrVUS |
VF_subrVUL | VD_subrVUL | VE_subrVUL |
VF_subrVUQ | VD_subrVUQ | VE_subrVUQ |
VF_subrVUI | VD_subrVUI | VE_subrVUI |
|
Funktion | Umgekehrte Subtraktion: Fließkomma- von Ganzzahlvektor subtrahieren |
|
Syntax C/C++ | #include <VFmath.h>
void VF_subrVI( fVector Z, fVector X, iVector Y,ui size );
void VF_subrVUB( fVector Z, fVector X, ubVector Y, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::subrVI( const vector<T>& X, const vector<int>& Y );
void vector<T>::subrVUS( const vector<T>& X, const vector<unsigned short>& Y, ); |
Pascal/Delphi | uses VFmath;
procedure VF_subrVI( Z, X:fVector; Y:iVector; size:UIntSize );
procedure VF_subrVUL( Z, X:fVector; Y:ulVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_subrVI( fVector d_Z, fVector d_X, iVector d_Y,ui size );
int cudaVF_subrVUB( fVector d_Z, fVector d_X, ubVector d_Y, ui size );
void VFcu_subrVI( fVector h_Z, fVector h_X, iVector h_Y,ui size );
void VFcu_subrVUB( fVector h_Z, fVector h_X, ubVector h_Y, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_subrVI( d_Z, d_X:fVector; d_Y:iVector; size:UIntSize ): IntBool;
function cudaVF_subrVUL( d_Z, d_X:fVector; d_Y:ulVector; size:UIntSize ): IntBool;
procedure VFcu_subrVI( h_Z, h_X:fVector; h_Y:iVector; size:UIntSize );
procedure VFcu_subrVUL( h_Z, h_X:fVector; h_Y:ulVector; size:UIntSize );
|
|
|
|
|
|
VCF_subReV | VCD_subReV | VCE_subReV |
VCFx_subV | VCDx_subV | VCEx_subV |
VCFx_subReV | VCDx_subReV | VCEx_subReV |
VI_subV | VBI_subV | VSI_subV | VLI_subV | VQI_subV | |
VU_subV | VUB_subV | VUS_subV | VUL_subV | VUQ_subV | VUI_subV |
|
Funktion | Subtraktion zweier Vektoren |
|
Syntax C/C++ | #include <VFmath.h>
void VF_subV( fVector Z, fVector X, fVector Y, ui size );
void VFs_subV( fVector Z, fVector X, fVector Y, ui size, float C );
void VFx_subV( fVector Z, fVector X, fVector Y, ui size, float A, float B );
void VCF_subV( cfVector Z, cfVector X, cfVector Y, ui size );
void VCF_subReV( cfVector Z, cfVector X, fVector Y, ui size );
void VCFx_subV( cfVector Z, cfVector X, cfVector Y, ui size, fComplex A, fComplex B );
void VCFx_subReV( cfVector Z, cfVector X, fVector Y, ui size, fComplex A, fComplex B ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::subV( const vector<T>& X, const vector<T>& Y );
void vector<T>::s_subV( const vector<T>& X, const vector<T>& Y, const T& C );
void vector<T>::x_subV( const vector<T>& X, const vector<T>& Y, const T& A, const T& B );
void vector<complex<T>>::subV( const vector<complex<T>>& X, const vector<complex<T>>& Y );
void vector<complex<T>>::subReV( const vector<complex<T>>& X, const vector<T>& Y );
void vector<complex<T>>::x_subV( const vector<complex<T>>& X, const vector<complex<T>>& Y, complex<T> A, complex<T> B );
void vector<complex<T>>::x_subReV( const vector<complex<T>>& X, const vector<T>& Y, complex<T> A, complex<T> B ); |
Pascal/Delphi | uses VFmath;
procedure VF_subV( Z, X, Y:fVector; size:UIntSize );
procedure VFx_subV( Z, X, Y:fVector; size:UIntSize; A, B:Single);
procedure VCF_subV( Z, X, Y:cfVector; size:UIntSize );
procedure VCF_subReV( Z, X:cfVector; Y:fVector; size:UIntSize );
procedure VCFx_subV( Z, X, Y:cfVector; size:UIntSize; A, B:fComplex );
procedure VCFx_subrReV( Z, X:cfVector; Y:fVector; size:UIntSize; A, B:fComplex ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
#include <cudaVCFmath.h>
int cudaVF_subV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
int cudaVFs_subV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float C );
int cusdVFs_subV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_C );
int cudaVFx_subV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float A, float B );
int cusdVFx_subV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_A, float *d_B );
int cudaVCF_subReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size );
int cudaVCFx_subReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size, fComplex A, fComplex B );
int cusdVCFx_subReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size, fComplex *d_A, fComplex *d_B );
void VFcu_subV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
void VFscu_subV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float C );
void VFxcu_subV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float A, float B );
void VCFcu_subReV( cfVector h_Z, cfVector h_X, fVector h_Y, ui size );
void VCFxcu_subV( cfVector h_Z, cfVector h_X, cfVector h_Y, ui size, fComplex A, fComplex B );
void VCFxcu_subReV( cfVector h_Z, cfVector h_X, fVector h_Y, ui size, fComplex A, fComplex B );
|
CUDA-Funktion Pascal/Delphi | uses VFmath, VCFmath;
function cudaVF_subV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cudaVFs_subV( d_Z, d_X, d_Y:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVFs_subV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function cudaVFx_subV( d_Z, d_X, d_Y:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_subV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function cudaVCF_subReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize ): IntBool;
function cudaVCFx_subReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize; A, B:fComplex ): IntBool;
function cusdVCFx_subReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize; d_A, d_B:PfComplex ): IntBool;
procedure VFcu_subV( h_Z, h_X, h_Y:fVector; size:UIntSize );
procedure VFscu_subV( h_Z, h_X, h_Y:fVector; size:UIntSize; C:Single );
procedure VFxcu_subV( h_Z, h_X, h_Y:fVector; size:UIntSize; A, B:Single );
procedure VCFcu_subReV( h_Z, h_X:cfVector; h_Y:fVector; size:UIntSize );
procedure VCFxcu_subReV( h_Z, h_X:cfVector; h_Y:fVector; size:UIntSize; A, B:fComplex );
|
|
Beschreibung | einfache Versionen: Zi = Xi - Yi
skalierte Versionen: Zi = C * (Xi - Yi)
erweiterte Versionen: Zi = (A*Xi+B) - Yi
Die komplexen Versionen existieren in zwei Varianten: Bei der ersten (z.B. VCF_subV, VCFx_subV) sind X, Y und Z komplex; bei der zweiten ist Y reell (z.B. VCF_subReV - "reellen Vektor abziehen"). |
|
Fehlerbehandlung | Fließkomma-Versionen: keine;
Ganzzahl-Versionen: siehe Kap. 5.2. |
|
|
|
VF_subVBI | VD_subVBI | VE_subVBI |
VF_subVSI | VD_subVSI | VE_subVSI |
VF_subVLI | VD_subVLI | VE_subVLI |
VF_subVQI | VD_subVQI | VE_subVQI |
VF_subVUB | VD_subVUB | VE_subVUB |
VF_subVUS | VD_subVUS | VE_subVUS |
VF_subVUL | VD_subVUL | VE_subVUL |
VF_subVUQ | VD_subVUQ | VE_subVUQ |
VF_subVUI | VD_subVUI | VE_subVUI |
|
Funktion | Ganzzahlvektor von Fließkomma-Vektor subtrahieren |
|
Syntax C/C++ | #include <VFmath.h>
void VF_subVI( fVector Z, fVector X, iVector Y,ui size );
void VF_subrVUB( fVector Z, fVector X, ubVector Y, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::subVI( const vector<T>& X, const vector<int>& Y );
void vector<T>::subVUS( const vector<T>& X, const vector<unsigned short>& Y, ); |
Pascal/Delphi | uses VFmath;
procedure VF_subVI( Z, X:fVector; Y:iVector; size:UIntSize );
procedure VF_subVUL( Z, X:fVector; Y:ulVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_subVI( fVector d_Z, fVector d_X, iVector d_Y,ui size );
int cudaVF_subVUB( fVector d_Z, fVector d_X, ubVector d_Y, ui size );
void VFcu_subVI( fVector h_Z, fVector h_X, iVector h_Y,ui size );
void VFcu_subVUB( fVector h_Z, fVector h_X, ubVector h_Y, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_subVI( d_Z, d_X:fVector; d_Y:iVector; size:UIntSize ): IntBool;
function cudaVF_subVUL( d_Z, d_X:fVector; d_Y:ulVector; size:UIntSize ): IntBool;
procedure VFcu_subVI( h_Z, h_X:fVector; h_Y:iVector; size:UIntSize );
procedure VFcu_subVUL( h_Z, h_X:fVector; h_Y:ulVector; size:UIntSize );
|
|
|
|
|
|
VF_subV_chiabs | VD_subV_chiabs | VE_subV_chiabs |
|
Funktion | Zwei Vektoren voneinander abziehen und chiabs-Funktion über die Differenzen |
|
Syntax C/C++ | #include <VFmath.h>
float VF_subV_chiabs( fVector Z, fVector X, fVector Y, uifVector Wt, size ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::subV_chiabs( const vector<T>& X, const vector<T>& Y, const vector<T>& Wt ); |
Pascal/Delphi | uses VFmath;
function VF_subV_chiabs( Z, X, Y, Wt:fVector; size:UIntSize ): Single; |
|
CUDA function C/C++ | #include <cudaVFmath.h>
int cudaVF_subV_chiabs( float *h_RetVal, fVector d_Z, fVector d_X, fVector d_Y, fVector d_Wt, ui size );
int cusdVF_subV_chiabs( float *d_RetVal, fVector d_Z, fVector d_X, fVector d_Y, fVector d_Wt, ui size );
float VFcu_subV_chiabs( fVector h_Z, fVector h_X, fVector h_Y, fVector h_Wt, ui size );
|
CUDA function Pascal/Delphi | uses VFmath;
function cudaVF_subV_chiabs( var h_RetVal:Single; d_Z, d_X, d_Y, d_Wt:fVector; size:UIntSize ): IntBool;
function cusdVF_subV_chiabs( d_RetVal:PSingle; d_Z, d_X, d_Y, d_Wt:fVector; size:UIntSize ): IntBool;
|
|
Beschreibung | Zi = Xi - Yi
chiabs = Sum(| Zi | * Wti )
Diese Funktion begrenzt eventuellen Überlauf auf HUGE_VAL und behandelt Eingabewerte von ±NAN als ±HUGE_VAL. Diese Vorgehensweise dient der Verwendung von V?_subV_chiabs in den nichtlinearen Datenanpassungs-Routinen: Wenn die Nonlinfit-Routine ein schlechtes Parameter-Set rät, soll sie die Rückmeldung erhalten, dass der Versuch weit entfernt vom Optimum lag; sie soll aber keinesfalls durch eine Exception oder Programm-Abbruch bestraft werden.
|
|
|
Rückgabewert | chiabs-Funktion der Differenzen zwischen den einzelnen Elementen der beiden Vektoren |
|
|
VF_subV_chi2 | VD_subV_chi2 | VE_subV_chi2 |
|
Funktion | Zwei Vektoren voneinander abziehen und c2-Funktion über die Differenzen |
|
Syntax C/C++ | #include <VFmath.h>
float VF_subV_chi2( fVector Z, fVector X, fVector Y, uifVector InvVar, size ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::subV_chi2( const vector<T>& X, const vector<T>& Y, const vector<T>& InvVar ); |
Pascal/Delphi | uses VFmath;
function VF_subV_chi2( Z, X, Y, InvVar:fVector; size:UIntSize ): Single; |
|
CUDA function C/C++ | #include <cudaVFmath.h>
int cudaVF_subV_chi2( float *h_RetVal, fVector d_Z, fVector d_X, fVector d_Y, fVector d_InvVar, ui size );
int cusdVF_subV_chi2( float *d_RetVal, fVector d_Z, fVector d_X, fVector d_Y, fVector d_InvVar, ui size );
float VFcu_subV_chi2( fVector h_Z, fVector h_X, fVector h_Y, fVector h_InvVar, ui size );
|
CUDA function Pascal/Delphi | uses VFmath;
function cudaVF_subV_chi2( var h_RetVal:Single; d_Z, d_X, d_Y, d_InvVar:fVector; size:UIntSize ): IntBool;
function cusdVF_subV_chi2( d_RetVal:PSingle; d_Z, d_X, d_Y, d_InvVar:fVector; size:UIntSize ): IntBool;
|
|
Beschreibung | Zi = Xi - Yi
c2 = Summe( 1/si2 * (Zi)2 )
Diese Funktion begrenzt eventuellen Überlauf auf HUGE_VAL und behandelt Eingabewerte von ±NAN als ±HUGE_VAL. Diese Vorgehensweise dient der Verwendung von V?_subV_chi2 in den nichtlinearen Datenanpassungs-Routinen: Wenn die Nonlinfit-Routine ein schlechtes Parameter-Set rät, soll sie die Rückmeldung erhalten, dass der Versuch weit entfernt vom Optimum lag; sie soll aber keinesfalls durch eine Exception oder Programm-Abbruch bestraft werden.
|
|
|
Rückgabewert | c2-Funktion der Differenzen zwischen den einzelnen Elementen der beiden Vektoren |
|
|
VF_subV_ssq | VD_subV_ssq | VE_subV_ssq |
|
Zwei Vektoren voneinander abziehen und Quadratsumme der Differenzen bilden |
|
Syntax C/C++ | #include <VFmath.h>
float VF_subV_ssq( fVector Z, fVector X, fVector Y, ui size ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::subV_ssq( const vector<T>& X, const vector<T>& Y ); |
Pascal/Delphi | uses VFmath;
function VF_subV_ssq( Z, X, Y:fVector; size:UIntSize ): Single; |
|
CUDA function C/C++ | #include <cudaVFmath.h>
int cudaVF_subV_ssq( float *h_RetVal, fVector d_Z, fVector d_X, fVector d_Y, ui size );
int cusdVF_subV_ssq( float *d_RetVal, fVector d_Z, fVector d_X, fVector d_Y, ui size );
float VFcu_subV_ssq( fVector h_Z, fVector h_X, fVector h_Y, ui size );
|
CUDA function Pascal/Delphi | uses VFmath;
function cudaVF_subV_ssq( var h_RetVal:Single; d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cusdVF_subV_ssq( d_RetVal:PSingle; d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
|
|
Beschreibung | Zi = Xi - Yi
ssq = Sum(Zi2)
Diese Funktion begrenzt eventuellen Überlauf auf HUGE_VAL und behandelt Eingabewerte von ±NAN als ±HUGE_VAL. Diese Vorgehensweise dient der Verwendung von V?_subV_ssq in den nichtlinearen Datenanpassungs-Routinen: Wenn die Nonlinfit-Routine ein schlechtes Parameter-Set rät, soll sie die Rückmeldung erhalten, dass der Versuch weit entfernt vom Optimum lag; sie soll aber keinesfalls durch eine Exception oder Programm-Abbruch bestraft werden.
|
|
|
Rückgabewert | Quadrat-Summe der Differenzen zwischen den einzelnen Elementen der beiden Vektoren |
|
|
VF_subV_sumabs | VD_subV_sumabs | VE_subV_sumabs |
|
Zwei Vektoren voneinander abziehen und Summe der Absolutwerte der Differenzen |
|
Syntax C/C++ | #include <VFmath.h>
float VF_subV_sumabs( fVector Z, fVector X, fVector Y, ui size ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::subV_sumabs( const vector<T>& X, const vector<T>& Y ); |
Pascal/Delphi | uses VFmath;
function VF_subV_sumabs( Z, X, Y:fVector; size:UIntSize ): Single; |
|
CUDA function C/C++ | #include <cudaVFmath.h>
int cudaVF_subV_sumabs( float *h_RetVal, fVector d_Z, fVector d_X, fVector d_Y, ui size );
int cusdVF_subV_sumabs( float *d_RetVal, fVector d_Z, fVector d_X, fVector d_Y, ui size );
float VFcu_subV_sumabs( fVector h_Z, fVector h_X, fVector h_Y, ui size );
|
CUDA function Pascal/Delphi | uses VFmath;
function cudaVF_subV_sumabs( var h_RetVal:Single; d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cusdVF_subV_sumabs( d_RetVal:PSingle; d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
|
|
Beschreibung | Zi = Xi - Yi
sumabs = Sum(| Zi |)
Diese Funktion begrenzt eventuellen Überlauf auf HUGE_VAL und behandelt Eingabewerte von ±NAN als ±HUGE_VAL. Diese Vorgehensweise dient der Verwendung von V?_subV_chi2 in den nichtlinearen Datenanpassungs-Routinen: Wenn die Nonlinfit-Routine ein schlechtes Parameter-Set rät, soll sie die Rückmeldung erhalten, dass der Versuch weit entfernt vom Optimum lag; sie soll aber keinesfalls durch eine Exception oder Programm-Abbruch bestraft werden.
|
|
|
Rückgabewert | Summe der Absolutwerte der Differenzen zwischen den einzelnen Elementen der beiden Vektoren |
|
|
|
Funktion | Zwei Vektoren gleichzeitig von einem anderen Vektor abziehen |
|
Syntax C/C++ | #include <VFmath.h>
void VF_sub2V( fVector Z, fVector X, fVector Y1, fVector Y2, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::sub2V( const vector<T>& X, const vector<T>& Y1, const vector<T>& Y2 ); |
Pascal/Delphi | uses VFmath;
procedure VF_sub2V( Z, X, Y1, Y2:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_sub2V( fVector d_Z, fVector d_X, fVector d_Y1, fVector d_Y2, ui size );
void VFcu_sub2V( fVector h_Z, fVector h_X, fVector h_Y1, fVector h_Y2, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_sub2V( d_Z, d_X, d_Y1, d_Y2:fVector; size:UIntSize ): IntBool;
procedure VFcu_sub2V( h_Z, h_X, h_Y1, h_Y2:fVector; size:UIntSize );
|
|
Beschreibung | Zi = Xi - Y1i - Y2i
|
|
|
|
|
VF_subvector | VD_subvector | VE_subvector |
VCF_subvector | VCD_subvector | VCE_subvector |
VPF_subvector | VPD_subvector | VPE_subvector |
VI_subvector | VBI_subvector | VSI_subvector | VLI_subvector | VQI_subvector | |
VU_subvector | VUB_subvector | VUS_subvector | VUL_subvector | VUQ_subvector | VUI_subvector |
|
Funktion | Unter-Vektor extrahieren |
|
Syntax C/C++ | #include <VFstd.h>
void VF_subvector( fVector Y, ui subsize, fVector X, int samp ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::subvector( const vector<T>& X, int samp, ui start=0 ); |
Pascal/Delphi | uses VFstd;
procedure VF_subvector( Y:fVector; sizey:UIntSize; X:fVector; samp:Integer ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_subvector( fVector d_Y, ui subsize, fVector d_X, int samp );
void VFcu_subvector( fVector h_Y, ui subsize, fVector h_X, int samp );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_subvector( d_Y:fVector; sizey:UIntSize; d_X:fVector; samp:Integer ): IntBool;
procedure VFcu_subvector( h_Y:fVector; sizey:UIntSize; h_X:fVector; samp:Integer );
|
|
Beschreibung | Yi = Xi*samp
Ein Subvektor Y wird mit konstantem Abtastintervall samp aus dem Vektor X extrahiert. Dabei werden, beginnend mit dem nullten Element von X, insgesamt subsize Elemente kopiert. Da für X eine Eingabe wie X+1000 (C/C++) oder VF_Pelement( XX, 1000 ) (Pascal/Delphi) stehen kann, sind für samp nicht nur positive, sondern auch negative sowie der triviale Wert 0 zulässig. X und Y müssen verschieden sein. Anstelle samp gleich 0, 1 oder −1 verwende man VF_equC, VF_equV bzw. VF_rev.
Die VecObj-Version wird mit einem zusätzlichen Argument start aufgerufen, das das Element von X angibt, mit dem begonnen werden soll. Dies ist notwendig, da Ausdrücke wie XX+1000 nur mit Zeigern möglich sind. In dem Klassen-basierten objekt-orientierten Interface würden sie aber als der operator + mißverstanden werden. |
|
|
|
|
VF_subvector_... | VD_subvector_... | VE_subvector_... |
VCF_subvector_... | VCD_subvector_... | VCE_subvector_... |
VPF_subvector_... | VPD_subvector_... | VPE_subvector_... |
|
Funktion | Arithmetische Operationen für eine Untermenge der Elemente eines Vektors |
|
Syntax C/C++ | #include <VFmath.h>
void VF_subvector_addC( fVector Y, ui subsize, unsigned samp, float C );
void VF_subvector_addV( fVector Y, ui subsize, unsigned samp, fVector X );
(analog alle übrigen Funktionen dieser Familie) |
C++ VecObj | #include <OptiVec.h>
void vector<T>::subvector_addC( unsigned samp, const T& C );
void vector<T>::subvector_addV( unsigned samp, const vector<T>& X ); |
Pascal/Delphi | uses VFmath;
procedure VF_subvector_addC( Y:fVector; subsiz:UIntSize; samp:UIntSize; C:Single );
procedure VF_subvector_addV( Y:fVector; subsiz:UIntSize; samp:UIntSize; X:fVector );
(analog alle übrigen Funktionen dieser Familie) |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_subvector_addC( fVector d_Y, ui subsize, unsigned samp, float C );
int cusdVF_subvector_addC( fVector d_Y, ui subsize, unsigned samp, float *d_C );
int cudaVF_subvector_addV( fVector d_Y, ui subsize, unsigned samp, fVector X );
void VFcu_subvector_addC( fVector h_Y, ui subsize, unsigned samp, float C );
void VFcu_subvector_addV( fVector h_Y, ui subsize, unsigned samp, fVector X );
(analog alle übrigen Funktionen dieser Familie)
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_subvector_addC( d_Y:fVector; subsiz:UIntSize; samp:UIntSize; C:Single );
function cusdVF_subvector_addC( d_Y:fVector; subsiz:UIntSize; samp:UIntSize; d_C:PSingle );
function cudaVF_subvector_addV( d_Y:fVector; subsiz:UIntSize; samp:UIntSize; X:fVector );
procedure VFcu_subvector_addC( h_Y:fVector; subsiz:UIntSize; samp:UIntSize; C:Single );
procedure VFcu_subvector_addV( h_Y:fVector; subsiz:UIntSize; samp:UIntSize; X:fVector );
(analog alle übrigen Funktionen dieser Familie)
|
|
Beschreibung | ..._addC: | Yi*samp += C, | i=0,...subsize−1 |
..._addV: | Yi*samp += Xi, | i=0,...subsize−1 |
..._subC: | Yi*samp -= C, | i=0,...subsize−1 |
..._subV: | Yi*samp -= Xi, | i=0,...subsize−1 |
..._subrC: | Yi*samp = C - Yi*samp, | i=0,...subsize−1 |
..._subrV: | Yi*samp = Xi- Yi*samp, | i=0,...subsize−1 |
..._mulC: | Yi*samp *= C, | i=0,...subsize−1 |
..._mulV: | Yi*samp *= Xi, | i=0,...subsize−1 |
..._divC: | Yi*samp /= C, | i=0,...subsize−1 |
..._divV: | Yi*samp /= Xi, | i=0,...subsize−1 |
..._divrC: | Yi*samp = C / Yi*samp, | i=0,...subsize−1 |
..._divrV: | Yi*samp = Xi / Yi*samp, | i=0,...subsize−1 |
Polar-komplexe Versionen:
Es gibt nur Multiplikation und Division: ...mulC, ...mulV, ...divC, ...divV, ...divrC und ...divrV.
Die im Suffix des Funktionsnamens angegebene Operation wird auf eine Untermenge von Elementen eines Vektors angewendet. Das Abtast-Intervall wird durch samp angegeben. Beginnend mit dem nullten, wird die jeweilige Operation auf jedes samp-te Element angewandt, bis hin zu insgesamt subsize Elementen. subsize ist also nicht die Gesamtgröße des Vektors, sondern die Anzahl der veränderten Elemente. Man beachte, dass alle Operationen "an Ort und Stelle", d.h. unter Veränderung des Eingabe-Vektors, ausgeführt werden. Für analoge Funktionen, die in der obigen Aufstellung nicht enthalten sind, ist die erforderliche Aufruf-Sequenz analog dem folgenden Beispiel (in dem size als ganzzahliges Vielfaches von 10 angenommen wird):
VF_subvector( Y, size/10, 10, X ); /* extrahieren */
VF_sinc( Y, Y, size/10 ); /* gewünschte Funktion */
VF_subvector_equV( X, size/10, 10, Y ); /* zurück-kopieren */
In einem so einfachen (und gleichzeitig seltenen) Fall wie diesem sollte man allerdings überlegen, ob man nicht doch auf klassische Schleifen zurückgreifen kann. Nur, wenn die gewünschte Funktion nicht in der mathematischen Bibliothek Ihres Compilers enthalten ist, lohnt der Aufwand des Extrahierens und Zurück-Kopierens. |
|
|
|
|
VF_subvector_... | VD_subvector_... | VE_subvector_... |
VCF_subvector_... | VCD_subvector_... | VCE_subvector_... |
VPF_subvector_... | VPD_subvector_... | VPE_subvector_... |
VI_subvector_... | VBI_subvector_... | VSI_subvector_... |
VLI_subvector_... | VQI_subvector_... |
VU_subvector_... | VUB_subvector_... | VUS_subvector_... |
VUL_subvector_... | VUQ_subvector_... | VUI_subvector_... |
|
Funktion | Initialisierung einer Untermenge von Elementen eines Vektors |
|
Syntax C/C++ | #include <VFstd.h>
void VF_subvector_equC( fVector Y, ui subsize, unsigned samp, float C );
void VF_subvector_equV( fVector Y, ui subsize, unsigned samp, fVector X );
(analog alle übrigen Funktionen dieser Familie) |
C++ VecObj | #include <OptiVec.h>
void vector<T>::subvector_equC( unsigned samp, const T& C );
void vector<T>::subvector_equV( unsigned samp, const vector<T>& X ); |
Pascal/Delphi | uses VFstd;
procedure VF_subvector_equC( Y:fVector; subsz:UIntSize; samp:UIntSize; C:Single );
procedure VF_subvector_equV( Y:fVector; subsz:UIntSize; samp:UIntSize; X:fVector );
(analog alle übrigen Funktionen dieser Familie) |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_subvector_equC( fVector d_Y, ui subsize, unsigned samp, float C );
int cusdVF_subvector_equC( fVector d_Y, ui subsize, unsigned samp, float *d_C );
int cudaVF_subvector_equV( fVector d_Y, ui subsize, unsigned samp, fVector X );
void VFcu_subvector_equC( fVector h_Y, ui subsize, unsigned samp, float C );
void VFcu_subvector_equV( fVector h_Y, ui subsize, unsigned samp, fVector X );
(similarly all other functions of this family)
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_subvector_equC( d_Y:fVector; subsiz:UIntSize; samp:UIntSize; C:Single );
function cusdVF_subvector_equC( d_Y:fVector; subsiz:UIntSize; samp:UIntSize; d_C:PSingle );
function cudaVF_subvector_equV( d_Y:fVector; subsiz:UIntSize; samp:UIntSize; X:fVector );
procedure VFcu_subvector_equC( h_Y:fVector; subsiz:UIntSize; samp:UIntSize; C:Single );
procedure VFcu_subvector_equV( h_Y:fVector; subsiz:UIntSize; samp:UIntSize; X:fVector );
(similarly all other functions of this family)
|
|
Beschreibung | ..._equC: | Yi*samp = C, | i=0,...subsize−1 |
..._equV: | Yi*samp = Xi, | i=0,...subsize−1 |
Beim nullten Element beginnend, wird eine Untermenge der Elemente eines Vektors mit einem Abtastintervall samp ausgewählt und initialisiert. Die Initialisierungswerte sind dabei entweder durch eine Konstante C gegeben oder durch die Elemente eines anderen Vektors. Insgesamt werden subsize Elemente initialisiert (subsize ist also nicht die Gesamtgröße des Vektors!). VF_subvector_equV ist die exakte Umkehrung von VF_subvector.
Während die arithmetischen Funktionen von Unter-Vektoren (z.B. VF_subvector_addV) derzeit nur für die Fließkomma-Datentypen zur Verfügung stehen, sind die hier beschriebenen Initialisierungsfunktionen für alle Datentypen, also auch für die Ganzzahltypen, definiert. |
|
|
|
|
VI_sum | VBI_sum | VSI_sum | VLI_sum | VQI_sum | |
VU_sum | VUB_sum | VUS_sum | VUL_sum | VUQ_sum | VUI_sum |
|
Funktion | Summe aller Vektorelemente |
|
Syntax C/C++ | #include <VFstd.h>
float VF_sum( fVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::sum(); |
Pascal/Delphi | uses VFstd;
function VF_sum( X:fVector; size:UIntSize ): Single;
procedure VCF_sum( var Sum:fComplex; X:cfVector; size:UIntSize); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_sum( float *h_RetVal, fVector d_X, ui size );
int cusdVF_sum( float *d_RetVal, fVector d_X, ui size );
float VFcu_sum( fVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_sum( var h_RetVal:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_sum( d_RetVal:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_sum( h_X:fVector; size:UIntSize ): Single;
|
|
Beschreibung | sum = Summe( Xi )
Die Summe über alle Vektorelemente wird berechnet und zurückgegeben.
nur Pascal/Delphi: Da die komplexen Datentypen in Pascal/Delphi nicht als Rückgabewerte zulässig sind, werden die Ergebnisse der komplexen Versionen hier in der Variablen Sum gespeichert. |
|
Fehlerbehandlung | keine (aber Vorsicht: diese Funktion neigt zum Überlauf!) |
|
Rückgabewert | Summe der Vektorelemente (außer komplexe Versionen in Pascal/Delphi) |
|
|
VF_sumabs | VD_sumabs | VE_sumabs |
|
Funktion | Summe der Beträge aller Vektorelemente |
|
Syntax C/C++ | #include <VFstd.h>
float VF_sumabs( fVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::sumabs(); |
Pascal/Delphi | uses VFstd;
function VF_sumabs( X:fVector; size:UIntSize ): Single; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_sumabs( float *h_RetVal, fVector d_X, ui size );
int cusdVF_sumabs( float *d_RetVal, fVector d_X, ui size );
float VFcu_sumabs( fVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_sumabs( var h_RetVal:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_sumabs( d_RetVal:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_sumabs( h_X:fVector; size:UIntSize ): Single;
|
|
Beschreibung | sumabs = Summe(| Xi |) |
|
Fehlerbehandlung | keine (aber Vorsicht: diese Funktion neigt zum Überlauf!) |
|
|
|
VF_sumdevC | VD_sumdevC | VE_sumdevC |
|
Funktion | Summe der Abweichungs-Beträge von einem bestimmtem Wert |
|
Syntax C/C++ | #include <VFstd.h>
float VF_sumdevC( fVector X, ui size, float C ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::sumdevC( const T& C ); |
Pascal/Delphi | uses VFstd;
function VF_sumdevC( X:fVector; size:UIntSize; C:Single ): Single; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_sumdevC( float *h_RetVal, fVector d_X, ui size, float C );
int cusdVF_sumdevC( float *d_RetVal, fVector d_X, ui size, float *d_C );
float VFcu_sumdevC( fVector h_X, ui size, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_sumdevC( var h_RetVal:Single; d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_sumdevC( d_RetVal:PSingle; d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function VFcu_sumdevC( h_X:fVector; size:UIntSize; C:Single ): Single;
|
|
Beschreibung | sumdevC = sum( |Xi - C| ) |
|
|
Rückgabewert | Summe der Abweichungs-Beträge |
|
|
VF_sumdevV | VD_sumdevV | VE_sumdevV |
VF_sumdevVwSaturation | VD_sumdevVwSaturation | VE_sumdevVwSaturation |
|
Funktion | Summe der Abweichungs-Beträge einer Verteilung von einer anderen |
|
Syntax C/C++ | #include <VFstd.h>
float VF_sumdevV( fVector X, fVector Y, ui size );
float VF_sumdevVwSaturation( fVector X, fVector Y, ui size ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::sumdevV( const vector<T>& Y );
T vector<T>::sumdevVwSaturation( const vector<T>& Y ); |
Pascal/Delphi | uses VFstd;
function VF_sumdevV( X, Y:fVector; size:UIntSize ): Single;
function VF_sumdevVwSaturation( X, Y:fVector; size:UIntSize ): Single; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_sumdevV( float *h_RetVal, fVector X, fVector Y, ui size );
int cusdVF_sumdevV( float *d_RetVal, fVector X, fVector Y, ui size );
float VFcu_sumdevV( fVector h_X, fVector h_Y, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_sumdevV( var h_RetVal:Single; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cusdVF_sumdevV( d_RetVal:PSingle; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function VFcu_sumdevV( h_X, h_Y:fVector; size:UIntSize ): Single;
|
|
Beschreibung | sumdevV = sum( |Xi - Yi| )
V?_sumdevVwSaturation ist sehr ähnlich zu V?_sumdevV, außer in der Behandlung von Überlauf und von NAN. Während V?_sumdevV zu INF überlaufen kann und im Falle von einem oder mehreren Eingabe-Elementen = NAN auch NAN zurückgeben wird, „sättigt” V?_sumdevVwSaturation INF zu HUGE_VAL und behandelt Eingabewerte von ±NAN als ±HUGE_VAL, gibt also auch in diesem Fall HUGE_VAL zurück. |
|
|
Rückgabewert | Summe der Abweichungs-Beträge |
|
|
|
Funktion | Warten bis zum Abschluss aller aktiven Prozesse im aktuellen Workspace |
|
Syntax C/C++ | #include <cudaVecLib.h>
void cudaV_synchronize( void ); |
Delphi | uses VecLib;
procedure cudaV_synchronize; |
|
Beschreibung | Wie in CudaOptiVecD.htm, Kap. 4 näher erläutert, geben die Funktionen mit den Präfixen cudaV?_ und cusdV?_ die Kontrolle an die aufrufende Funktion sofort zurück, ohne den tatsächlichen Abschluss der angeforderten Berechnungen abzuwarten. Dies macht parallele Ausführung von Host- und Device-Funktionen und die gleichzeitige Ausführung mehrerer cudaV?_-Funktionen auf demselben Device (mit verschiedenen Workspaces) möglich. Wenn allerdings das Resultat eines Funktionsaufrufes für die Übertragung in Host-Memory oder für den Aufruf einer cudaV?_-Funktion mit einem anderen Workspace benötigt wird, müssen Aufrufe von cudaV_synchronize eingefügt werden, um die nötige Synchronisation herzustellen. |
|
|
|
|
|
Syntax C/C++ | #include <VFmath.h>
int VF_tan( fVector Y, fVector X, ui size );
int VFx_tan( fVector Y, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::tan( const vector<T>& X );
int vector<T>::x_tan( const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_tan( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_tan( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_tan( fVector d_Y, fVector d_X, ui size );
int cudaVFx_tan( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_tan( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_tan( fVector h_Y, fVector h_X, ui size );
int VFxcu_tan( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_tan( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_tan( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_tan( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_tan( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_tan( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = tan ( Xi )
erweiterte Versionen: Yi = C * tan( A*Xi+B )
Für große Werte von Xi werden Rundungsfehler bemerkbar. Wenn sich die X-Werte als gebrochenzahlige Vielfache von p darstellen lassen, sollte man lieber VF_tanrpi als VF_tan verwenden. |
|
Fehlerbehandlung | SING- und OVERFLOW-Fehler (für Argumente nahe p/2) führen zum Ergebnis ±HUGE_VAL. TLOSS-Fehler ergeben ein Resultat von 0.0. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0). |
|
|
|
Funktion | Quadrat der Tangens-Funktion |
|
Syntax C/C++ | #include <VFmath.h>
int VF_tan2( fVector Y, fVector X, ui size );
int VFx_tan2( fVector Y, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::tan2( const vector<T>& X );
int vector<T>::x_tan2( const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_tan2( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_tan2( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_tan2( fVector d_Y, fVector d_X, ui size );
int cudaVFx_tan2( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_tan2( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_tan2( fVector h_Y, fVector h_X, ui size );
int VFxcu_tan2( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_tan2( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_tan2( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_tan2( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_tan2( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_tan2( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen: Yi = tan2( Xi )
erweiterte Versionen: Yi = C * tan2( A*Xi+B )
Das Quadrat trigonometrischer Funktionen läßt sich schneller und genauer direkt als über den Umweg der jeweils zugrundeliegenden Funktion bestimmen. |
|
Fehlerbehandlung | SING- und OVERFLOW-Fehler (für Argumente nahe p/2) führen zum Ergebnis ±HUGE_VAL. TLOSS-Fehler ergeben ein Resultat von 0.0. |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0). |
|
|
VCFx_tanh | VCDx_tanh | VCEx_tanh |
|
|
Syntax C/C++ | #include <VFmath.h>
int VF_tanh( fVector Y, fVector X, ui size );
int VFx_tanh( fVector Y, fVector X, ui size, float A, float B, float C ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::tanh( const vector<T>& X );
int vector<T>::x_tanh( const vector<T>& X, const T& A, const T& B, const T& C ); |
Pascal/Delphi | uses VFmath;
function VF_tanh( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_tanh( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_tanh( fVector d_Y, fVector d_X, ui size );
int cudaVFx_tanh( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_tanh( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_tanh( fVector h_Y, fVector h_X, ui size );
int VFxcu_tanh( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_tanh( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_tanh( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_tanh( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_tanh( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_tanh( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
|
|
Beschreibung | einfache Versionen:
Yi = | tanh( Xi ) |
= | exp( Xi ) - exp( −Xi )
exp( Xi ) + exp( −Xi ) |
erweiterte Versionen:
Yi = C * tanh( A*Xi+B ) |
|
Fehlerbehandlung | Es dürften keine Fehler auftreten. |
|
Rückgabewert | immer FALSE(0). |
|
|
VF_tanrpi | VD_tanrpi | VE_tanrpi |
VF_tanrpi2 | VD_tanrpi2 | VE_tanrpi2 |
VF_tanrpi3 | VD_tanrpi3 | VE_tanrpi3 |
|
Funktion | Tangens von gebrochenzahligen Vielfachen von p |
|
Syntax C/C++ | #include <VFmath.h>
int VF_tanrpi( fVector Y, iVector P, ui size, int q );
int VF_tanrpi2( fVector Y, iVector P, ui size, int q );
int VF_tanrpi3( fVector Y, iVector P, ui size, int q ); |
C++ VecObj | #include <OptiVec.h>
int vector<T>::tanrpi( const vector<int>& P, int q );
int vector<T>::tanrpi2( const vector<int>& P, int q );
int vector<T>::tanrpi3( const vector<int>& P, int q ); |
Pascal/Delphi | uses VFmath;
function VF_tanrpi( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
function VF_tanrpi2( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
function VF_tanrpi3( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool; |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_tanrpi( fVector d_Y, iVector d_P, ui size, int q );
int cudaVF_tanrpi2( fVector d_Y, iVector d_P, ui size, int q );
int cudaVF_tanrpi3( fVector d_Y, iVector d_P, ui size, int q );
int VFcu_tanrpi( fVector h_Y, iVector h_P, ui size, int q );
int VFcu_tanrpi2( fVector h_Y, iVector h_P, ui size, int q );
int VFcu_tanrpi3( fVector h_Y, iVector h_P, ui size, int q );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_tanrpi( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function cudaVF_tanrpi2( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function cudaVF_tanrpi3( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_tanrpi( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_tanrpi2( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_tanrpi3( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
|
|
Beschreibung | Yi = tan( (Pi / q) * p )
Der Tangens gebrochenzahliger Vielfacher von p wird berechnet. Es gibt drei Versionen. VF_tanrpi ist für den allgemeinen Gebrauch mit beliebigem Nenner q bestimmt. Wenn q eine ganzzahlige Potenz von 2 ist, sollte die hierfür optimierte Funktion VF_tanrpi2 eingesetzt werden, die viele Funktionswerte einer Tabelle entnimmt. Wenn q ein Vielfaches von 3 ist, sollte VF_tanrpi3 gebraucht werden. VF_tanrpi2 und VF_tanrpi3 funktionieren auch mit Werten von q, für die sie nicht optimiert sind. Es wird allerdings Speicherplatz für die dann nutzlosen Tabellen vergeudet. VF_tanrpi3 bietet einen bequemen Weg, mit Grad-Einheiten anstatt im Bogenmaß zu rechnen. Wenn q gleich 180 ist, entspricht eine Einheit von 1 in P einem Grad. |
|
Fehlerbehandlung | SING-Fehler entstehen, wenn Pi / q ein ungeradzahliges Vielfaches von 1/2 ist; das vorgeschlagene Ergebnis ist in diesem Fall 0.0 (der Mittelwert von +HUGE_VAL und -HUGE_VAL).
q muss ungleich 0 sein. Dies wird nicht überprüft und ZERODIVIDE-Fehler nicht abgefangen.S |
|
Rückgabewert | FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0). |
|
|
VF_tantab2 | VD_tantab2 | VE_tantab2 |
VF_tantab3 | VD_tantab3 | VE_tantab3 |
|
| Tabelle der Tangens-Funktion für Argumente zwischen 0 und p/2. |
|
Syntax C/C++ | #include <xmath.h>
extern float VF_tantab2[ VF_tabsz2+1 ];
extern double VD_tantab2[ VD_tabsz2+1 ];
extern extended VE_tantab2[ VE_tabsz2+1 ];
extern float VF_tantab3[ VF_tabsz3+1 ];
extern double VD_tantab3[ VD_tabsz3+1 ];
extern extended VE_tantab3[ VE_tabsz3+1 ]; |
Pascal/Delphi | uses FTANTAB2, DTANTAB2, ETANTAB2,
FTANTAB3, DTANTAB3, ETANTAB3;
VF_tantab2: array[0..VF_tabsz2] of Single;
VD_tantab2: array[0..VD_tabsz2] of Double;
VE_tantab2: array[0..VE_tabsz2] of Extended;
VF_tantab3: array[0..VF_tabsz3] of Single;
VD_tantab3: array[0..VD_tabsz3] of Double;
VE_tantab3: array[0..VE_tabsz3] of Extended; |
|
Beschreibung | VF_tantab2[ i ] = tan( i/(2*VF_tabsz2) * p ), i=0,...,VF_tabsz2−1
VF_tantab3[ i ] = tan( i/(2*VF_tabsz3) * p ), i=0,...,VF_tabsz3−1
VF_tantab2[ VF_tabsz2 ] = VF_tantab3[ VF_tabsz3 ] = 0;
Diese Tabellen werden u.a. von den Funktionen der VF_tanrpi2-Familie benutzt und stehen auch für andere Zwecke zur Verfügung. Anstelle des nicht definierten Tangens von p/2 steht eine 0 in den Tabellen.
C/C++: Die Symbole VF_tabsz2 etc., die die Größe der Tabellen angeben, sind in <xmath.h> definiert.
Pascal/Delphi: Die Symbole VF_tabsz2 etc. sind jeweils in derselben unit wie die Tabellen definiert.
FreePascal/Lazarus: Diese Tabellen stehen für FreePascal/Lazarus nicht zur Verfügung. |
|
|
VF_trunctoI | VD_trunctoI | VE_trunctoI |
VF_trunctoBI | VD_trunctoBI | VE_trunctoBI |
VF_trunctoSI | VD_trunctoSI | VE_trunctoSI |
VF_trunctoLI | VD_trunctoLI | VE_trunctoLI |
VF_trunctoQI | VD_trunctoQI | VE_trunctoQI |
VF_trunctoU | VD_trunctoU | VE_trunctoU |
VF_trunctoUB | VD_trunctoUB | VE_trunctoUB |
VF_trunctoUS | VD_trunctoUS | VE_trunctoUS |
VF_trunctoUL | VD_trunctoUL | VE_trunctoUL |
VF_trunctoUQ | VD_trunctoUQ | VE_trunctoUQ |
VF_trunctoUI | VD_trunctoUI | VE_trunctoUI |
|
Funktion | Rundung Richtung 0 durch Abschneiden (engl. truncate) aller Stellen nach dem Komma |
|
Syntax C/C++ | #include <VFmath.h>
int VF_trunc( fVector Y, fVector X, ui size );
int VF_trunctoI( iVector Y, fVector X, ui size );
int VF_trunctoU( uVector Y, fVector X, ui size );
(analog alle übrigen Funktionen dieser Familie) |
C++ VecObj | #include <OptiVec.h>
int vector<T>::trunc( const vector<T>& X );
int vector<int>::trunctoI( const vector<T>& X );
int vector<unsigned>::trunctoU( const vector<T>& X ); |
Pascal/Delphi | uses VFmath;
function VF_trunc( Y, X:fVector; size:UIntSize ):IntBool;
function VF_trunctoI( Y:iVector; X:fVector; size:UIntSize ):IntBool;
function VF_trunctoLI( Y:liVector; X:fVector; size:UIntSize ):IntBool;
(analog alle übrigen Funktionen dieser Familie) |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_trunc( fVector d_Y, fVector d_X, ui size );
int cudaVF_trunctoI( iVector d_Y, fVector d_X, ui size );
int VFcu_trunc( fVector h_Y, fVector h_X, ui size );
int VFcu_trunctoI( iVector h_Y, fVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_trunc( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVF_trunctoI( d_Y:iVector; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_trunc( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFcu_trunctoI( h_Y:iVector; h_X:fVector; size:UIntSize ): IntBool;
|
|
Beschreibung | Diese Funktionen sind identisch mit den Funktionen der VF_chop-Familie. Sie sind hier der Konsistenz mit der Pascal/Delphi-Funktion trunc wegen definiert. Einzelheiten siehe bei VF_chop. |
|
|
Funktion | Datentyp-Umwandlungen. Siehe V_ItoF! |
|
VF_varianceC | VD_varianceC | VE_varianceC |
|
Funktion | Varianz einer Verteilung bezüglich eines Soll-Wertes |
|
Syntax C/C++ | #include <VFstd.h>
float VF_varianceC( fVector X, ui size, float C ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::varianceC( const T& C ); |
Pascal/Delphi | uses VFstd;
function VF_varianceC( X:fVector; size:UIntSize; C:Single ): Single; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_varianceC( float *h_RetVal, fVector d_X, ui size, float C );
int cusdVF_varianceC( float *d_RetVal, fVector d_X, ui size, float *d_C );
float VFcu_varianceC( fVector h_X, ui size, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_varianceC( var h_RetVal:Single; d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_varianceC( d_RetVal:PSingle; d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function VFcu_varianceC( h_X:fVector; size:UIntSize; C:Single ): Single;
|
|
Beschreibung | var = (1 / size) * Summe( (Xi - C)2 ) |
|
|
Rückgabewert | berechnete Varianz |
|
|
VF_varianceCwW | VD_varianceCwW | VE_varianceCwW |
|
Funktion | gewichtete Varianz bezüglich eines Soll-Wertes |
|
Syntax C/C++ | #include <VFstd.h>
float VF_varianceCwW( fVector X, fVector Wt, ui size, float C ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::varianceCwW( const vector<T>& Wt, const T& C ); |
Pascal/Delphi | uses VFstd;
function VF_varianceCwW( X, Wt:fVector; size:UIntSize; C:Single ): Single; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_varianceCwW( float *h_RetVal, fVector d_X, fVector d_Wt, ui size, float C );
int cusdVF_varianceCwW( float *d_RetVal, fVector d_X, fVector d_Wt, ui size, float *d_C );
float VFcu_varianceCwW( fVector h_X, fVector h_Wt, ui size, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_varianceCwW( var h_RetVal:Single; d_X, d_Wt:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_varianceCwW( d_RetVal:PSingle; d_X, d_Wt:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function VFcu_varianceCwW( h_X, h_Wt:fVector; size:UIntSize; C:Single ): Single;
|
|
Beschreibung | var = (1 / Summe( Wti )) * Summe( Wti * (Xi - C)2 )
Die Wichtung muss nicht normiert sein. |
|
|
Rückgabewert | berechnete Varianz |
|
|
VF_varianceV | VD_varianceV | VE_varianceV |
|
Funktion | Varianz einer Verteilung bezüglich einer zweiten |
|
Syntax C/C++ | #include <VFstd.h>
float VF_varianceV( fVector X, fVector Y, ui size ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::varianceV( const vector<T>& Y ); |
Pascal/Delphi | uses VFstd;
function VF_varianceV( X, Y:fVector; size:UIntSize ): Single; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_varianceV( float *h_RetVal, fVector X, fVector Y, ui size );
int cusdVF_varianceV( float *d_RetVal, fVector X, fVector Y, ui size );
float VFcu_varianceV( fVector h_X, fVector h_Y, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_varianceV( var h_RetVal:Single; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cusdVF_varianceV( d_RetVal:PSingle; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function VFcu_varianceV( h_X, h_Y:fVector; size:UIntSize ): Single;
|
|
Beschreibung | var = (1 / size) * Summe( (Xi - Yi)2 ) |
|
|
Rückgabewert | berechnete Varianz |
|
|
VF_varianceVwW | VD_varianceVwW | VE_varianceVwW |
|
Funktion | Varianz einer Verteilung bezüglich einer zweiten mit Einzelpunkt-Wichtung |
|
Syntax C/C++ | #include <VFstd.h>
float VF_varianceVwW( fVector X, fVector Y, fVector Wt, ui size ); |
C++ VecObj | #include <OptiVec.h>
T vector<T>::varianceVwW( const vector<T>& Y, const vector<T>& Wt ); |
Pascal/Delphi | uses VFstd;
function VF_varianceVwW( X, Y, Wt:fVector; size:UIntSize ): |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_varianceVwW( float *h_RetVal, fVector X, fVector Y, fVector d_Wt, ui size );
int cusdVF_varianceVwW( float *d_RetVal, fVector X, fVector Y, fVector d_Wt, ui size );
float VFcu_varianceVwW( fVector h_X, fVector h_Y, fVector h_Wt, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_varianceVwW( var h_RetVal:Single; d_X, d_Y, d_Wt:fVector; size:UIntSize ): IntBool;
function cusdVF_varianceVwW( d_RetVal:PSingle; d_X, d_Y, d_Wt:fVector; size:UIntSize ): IntBool;
function VFcu_varianceVwW( h_X, h_Y, h_Wt:fVector; size:UIntSize ): Single;
|
|
Beschreibung | var = (1 / Summe(Wti)) * Summe( Wti * (Xi - Yi)2 )
Die Gewichte müssen nicht normiert sein. |
|
|
Rückgabewert | berechnete Varianz |
|
|
VF_vector | VD_vector | VE_vector |
VCF_vector | VCD_vector | VCE_vector |
VPF_vector | VPD_vector | VPE_vector |
VI_vector | VBI_vector | VSI_vector | VLI_vector | VQI_vector | |
VU_vector | VUB_vector | VUS_vector | VUL_vector | VUQ_vector | VUI_vector |
|
Funktion | Speicher-Reservierung für einen Vektor |
|
Syntax C/C++ | #include <VFstd.h>
fVector VF_vector( ui size ); |
Pascal/Delphi | uses VecLib;
function VF_vector( size:UIntSize ): fVector; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
fVector cudaVF_vector( ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_vector( size:UIntSize ): fVector;
|
|
Beschreibung | Es wird Speicher für size Elemente eines Vektors des betreffenden Datentypes reserviert und ein Zeiger auf das nullte Element zurückgegeben. Je nach Umgebung und Speichermodell wird die am besten geeignete Methode der Speicherzuweisung gewählt. Um hiermit zugewiesenen Speicher wieder freizugeben, rufe man V_free, V_freeAll oder V_nfree (letztere Funktion nur für C/C++).
Merke: Die Deklaraton eines Vektors weist zwar einen Namen zu, aber keinen Speicher! Vgl. Kap. 4.1 bezüglich weiterer Einzelheiten der Implementation.
Diese Funktion sollte nicht eingesetzt werden, wenn man mit dem objekt-orientierten Interface VecObj arbeitet. Dieses umfaßt seine eigene automatische Speicherzuweisung in den Konstruktoren, siehe Kap. 3. |
|
Fehlerbehandlung | Im Falle nicht ausreichend vorhandenen Speichers sowie für size=0 erfolgt Programmabbruch mit der Meldung "Not enough memory".
16-bit-Modelle (außer HUGE):
Übersteigt der Speicherbedarf 64 kB, so wird das Programm mit einer Fehlermeldung "Vector > 64 kB not possible" abgebrochen.
32-bit:
Übersteigt der Speicherbedarf 4 GB, so wird das Programm mit einer Fehlermeldung "Vector > 4 GB not possible" abgebrochen. |
|
Rückgabewert | Zeiger auf die reservierte Speicherstelle |
|
|
VF_vector0 | VD_vector0 | VE_vector0 |
VCF_vector0 | VCD_vector0 | VCE_vector0 |
VPF_vector0 | VPD_vector0 | VPE_vector0 |
VI_vector0 | VBI_vector0 | VSI_vector0 | VLI_vector0 | VQI_vector0 | |
VU_vector0 | VUB_vector0 | VUS_vector0 | VUL_vector0 | VUQ_vector0 | VUI_vector0 |
|
Funktion | Speicher-Zuweisung und Initialisierung mit 0 |
|
Syntax C/C++ | #include <VFstd.h>
fVector VF_vector0( ui size ); |
Pascal/Delphi | uses VecLib;
function VF_vector0( size:UIntSize ): fVector; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
fVector cudaVF_vector0( ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_vector0( size:UIntSize ): fVector;
|
|
Beschreibung | In bezug auf die Zuweisung von Speicher sind diese Funktionen identisch mit denen der VF_vector-Familie. Zusätzlich zur Speicher-Reservierung erfolgt jedoch noch eine Initialisierung aller Vektor-Elemente mit 0.
Aufrufe von VF_vector und VF_vector0 können gemischt werden. Sie benutzen dieselben Tabellen, um Buch über die reservierten Speicherstellen zu führen. Weitere Information ist bei VF_vector und in Kap. 4.1 zu finden.
Diese Funktion sollte nicht eingesetzt werden, wenn man mit dem objekt-orientierten Interface VecObj arbeitet. Dieses umfaßt seine eigene automatische Speicherzuweisung in den Konstruktoren, siehe Kap. 3. |
|
Fehlerbehandlung | Im Falle nicht ausreichend vorhandenen Speichers sowie für size=0 erfolgt Programmabbruch mit der Meldung "Not enough memory".
16-bit-Modelle (außer HUGE):
Übersteigt der Speicherbedarf 64 kB, so wird das Programm mit einer Fehlermeldung "Vector > 64 kB not possible" abgebrochen.
32-bit:
Übersteigt der Speicherbedarf 4 GB, so wird das Programm mit einer Fehlermeldung "Vector > 4 GB not possible" abgebrochen. |
|
Rückgabewert | Zeiger auf die reservierte Speicherstelle |
|
|
|
Funktion | "Visibilitäts"- oder Kontrast-Funktion bezüglich einer Konstanten |
|
Syntax C/C++ | #include <VFmath.h>
void VF_visC( fVector Y, fVector X, ui size, float C ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::visC( const vector<T>& X, const T& C ); |
Pascal/Delphi | uses VFmath;
procedure VF_visC( Y, X:fVector; size:UIntSize; C:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
#include <cudaVDmath.h>
int cudaVF_visC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_visC( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_visC( fVector d_Y, fVector d_X, ui size, float C );
|
CUDA-Funktion Pascal/Delphi | uses VFmath, VDmath;
function cudaVF_visC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_visC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VF_visC( Y, X:fVector; size:UIntSize; C:Single );
|
|
Beschreibung | Yi = vis( Xi, C ) = (Xi - C) / (Xi + C)
Diese Funktionen sind Generalisierungen der in der Optik gebräuchlichen Kontrast- (engl.: visibility) Funktion. Für Xi=C wird vis( Xi, C )=0.0 defininert. Dies gilt auch im Falle von Xi=C=0. |
|
|
|
|
|
Funktion | "Visibilitäts"- oder Kontrast-Funktion eines Vektors bezüglich eines anderen |
|
Syntax C/C++ | #include <VFmath.h>
void VF_visV( fVector Z, fVector X, fVector Y, ui size );
void VFx_visV( fVector Z, fVector X, fVector Y, ui size, float A, float B ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::visV( const vector<T>& X, const vector<T>& Y );
void vector<T>::x_visV( const vector<T>& X, const vector<T>& Y, const T& A, const T& B ); |
Pascal/Delphi | uses VFmath;
procedure VF_visV( Z, X, Y:fVector; size:UIntSize );
procedure VFx_visV( Z, X, Y:fVector; size:UIntSize; A, B:Single ); |
|
CUDA-Funktion C/C++ | #include <cudaVFmath.h>
int cudaVF_visV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
int cudaVFx_visV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float A, float B );
int cusdVFx_visV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_A, float *d_B );
void VFcu_visV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
void VFxcu_visV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float A, float B );
|
CUDA-Funktion Pascal/Delphi | uses VFmath;
function cudaVF_visV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cudaVFx_visV( d_Z, d_X, d_Y:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_visV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
procedure VFcu_visV( h_Z, h_X, h_Y:fVector; size:UIntSize );
procedure VFxcu_visV( h_Z, h_X, h_Y:fVector; size:UIntSize; A, B:Single );
|
|
Beschreibung | einfache Versionen:
Zi = vis( Xi, Yi )
= (Xi - Yi) / (Xi + Yi)
erweiterte Versionen:
Zi = vis( A*Xi+B, Yi )
Für Xi=Yi wird vis( Xi, Yi )=0.0 defininert. Dies gilt auch im Falle von Xi=Yi=0. |
|
|
|
|
|
Funktion | Welch-Fenster zum Gebrauch in der Spektrenanalyse |
|
Syntax C/C++ | #include <VFstd.h>
void VF_Welch( fVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::Welch(); |
Pascal/Delphi | uses VFstd;
procedure VF_Welch( X:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_Welch( fVector d_X, ui size );
void VFcu_Welch( fVector h_X, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_Welch( d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_Welch( h_X:fVector; size:UIntSize );
|
|
Beschreibung | Xi = 1 - ( (i - 0.5*(size - 1)) / (0.5*(size + 1)) )2 |
|
|
|
|
VCF_write | VCD_write | VCE_write |
VPF_write | VPD_write | VPE_write |
VI_write | VBI_write | VSI_write | VLI_write | VQI_write | |
VU_write | VUB_write | VUS_write | VUL_write | VUQ_write | VUI_write |
|
Funktion | Vektor im ASCII-Format in einen Stream schreiben |
|
Syntax C/C++ | #include <VFstd.h>
void VF_write( FILE *stream, fVector X, ui size ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::write( FILE *stream ); |
Pascal/Delphi | uses VFstd;
procedure VF_write( var Stream:Text; X:fVector; size:UIntSize ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_write( FILE *stream, fVector d_X, ui size );
int cudaVF_write_buf( FILE *stream, fVector d_X, ui size, fVector h_Wk );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_write( var Stream:Text; d_X:fVector; size:UIntSize ): IntBool;
function cudaVF_write_buf( var Stream:Text; d_X:fVector; size:UIntSize; h_Wk:fVector ): IntBool;
|
|
Beschreibung | size Elemente von X werden im ASCII-Format in stream geschrieben. Standardmäßig wird ein Element pro Zeile ausgegeben. Um diese Funktion benutzen zu können, muss stream bereits für Schreib-Operationen im Textformat geöffnet sein.
Ausgabeformat und Trennzeichen lassen sich über die Funktionen VF_setWriteFormat (nur C/C++) bzw. VF_setWriteSeparate verändern.
Daten im ASCII-Format zu speichern ist nützlich, wenn sie für das menschliche Auge lesbar gemacht oder in andere Programme exportiert werden sollen, die zum direkten Datenaustausch oder zum Einlesen im Maschinenformat nicht in der Lage sind. Wenn man es vermeiden kann, sollte man diese Funktion nicht zum Zwischenspeichern von Resultaten verwenden, die später noch einmal eingelesen werden sollen. Für diesen Zweck sind die Funktionen-Paare der VF_store / VF_recall-Familie besser geeignet, da sie weniger Speicherplatz verbrauchen, schneller und nicht mit Rundungsfehlern behaftet sind. |
nur CUDA-Versionen: | cudaV?_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 cudaV?_write eingespart, so dass cudaV?_write_buf etwas schneller ist.
|
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 VE_write, VCE_write und VPE_write bei GCC nur mit double-Genauigkeit und innerhalb des für doubles möglichen Größenbereiches arbeiten (also ggf. auf diesen abgeschnitten werden). |
|
|
|
|
VFb_xcorr | VDb_xcorr | VEb_xcorr |
|
Funktion | Kreuzkorrelationsfunktion |
|
Syntax C/C++ | #include <VFstd.h>
void VF_xcorr( fVector Z, fVector X, fVector Y, ui size );
void VFb_xcorr( fVector Z, fVector X, fVector Y, ui size, fVector Buf ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::xcorr( const vector<T>& X, const vector<T>& Y ); void vector<T>::b_xcorr( const vector<T>& X, const vector<T>& Y, vector<T>& Buf ); |
Pascal/Delphi | uses VFstd;
procedure VF_xcorr( Z, X, Y:fVector; size:UIntSize );
procedure VFb_xcorr( Z, X, Y:fVector; size:UIntSize; Buf:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_xcorr( fVector d_Z, fVector d_X, fVector d_Y, ui size );
void VFcu_xcorr( fVector h_Z, fVector h_X, fVector h_Y, ui size );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_xcorr( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
procedure VFcu_xcorr( h_Z, h_X, h_Y:fVector; size:UIntSize );
|
|
Beschreibung | Die Kreuzkorrelationsfunktion (KKF) von X und Y wird berechnet und in Z gespeichert. Dabei erhalten die Elemente Z0 bis Zsize/2−1 die KKF für 0 und für positive Verschiebungen; für negative Verschiebungen wird die KKF beginnend mit der am stärksten negativen Verschiebung in Zsize/2+1 bis Zsize−1 gespeichert. Da diese Funktion (wie alle auf der Fourier-Transformation basierenden Routinen) implizit von periodischen X, Y und Z ausgeht, ist die KKF für die stärkste positive Verschiebung identisch mit der KKF für die stärkste negative Verschiebung. Dieser Wert befindet sich im Element Zsize/2. Um die KKF in normale Ordnung zu bringen, kann
VF_rotate( Z, Z, size, size/2 );
aufgerufen werden. Danach befindet sich der Nullpunkt an der Position size/2.
Ist X nicht periodisch, so sollten Randeffekte mit den bei VF_convolve beschriebenen Methoden vermieden werden.
Intern benötigt VF_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 VFb_xcorr zu verwenden. Die Größe von Buf muss dabei ≥ 3*size sein. Außerdem muss Buf 128-bit (P8) bzw. 256-bit( P9) ausgerichtet sein. Um dies zu garantieren, sollte man nur Vektoren als Buf verwenden, die mit der VF_vector-Familie alloziert wurden. |
|
Fehlerbehandlung | Wenn size nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf VF_xcorr basiert) mit der Fehlermeldung "Size must be integer power of 2." und bricht das Programm ab. |
|
|
|
VI_xor | VBI_xor | VSI_xor | VLI_xor | VQI_xor | |
VU_xor | VUB_xor | VUS_xor | VUL_xor | VUQ_xor | VUI_xor |
|
Funktion | Bit-weises "exclusives ODER" |
|
Syntax C/C++ | #include <VImath.h>
void VI_xor( iVector Y, iVector X, ui size, int C );
void VUL_xor( ulVector Y, ulVector X, ui size, unsigned long C ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::xor( const vector<T>& X, const T& C ); |
Pascal/Delphi | uses VImath;
procedure VI_xor( Y, X:iVector; size:UIntSize; C:Integer );
procedure VUL_xor( Y, X:ulVector; size:UIntSize; C:ULong ); |
|
CUDA-Funktion C/C++ | #include <cudaVImath.h>
int cudaVI_xor( iVector d_Y, iVector d_X, ui size, int C );
int cusdVI_xor( iVector d_Y, iVector d_X, ui size, int *d_C );
void VIcu_xor( iVector h_Y, iVector h_X, ui size, int C );
|
CUDA-Funktion Pascal/Delphi | uses VImath;
function cudaVI_xor( d_Y, d_X:iVector; size:UIntSize; C:Integer ): IntBool;
function cusdVI_xor( d_Y, d_X:iVector; size:UIntSize; d_C:PInteger ): IntBool;
procedure VIcu_xor( h_Y, h_X:iVector; size:UIntSize; C:Integer );
|
|
Beschreibung | Yi = (Xi) ^ C
Beim exclusiven ODER (oder XOR) wird ein Bit von Yi gesetzt, wenn genau eines der beiden entsprechenden Bits von Xi und C gesetzt ist, nicht aber beide gleichzeitig. |
|
|
|
|
|
Funktion | Kreuz- oder Vektorprodukt |
|
Syntax C/C++ | #include <VFstd.h>
void VF_xprod( fVector Z, fVector X, fVector Y ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::xprod( const vector<T>& X, const vector<T>& Y ); |
Pascal/Delphi | uses VFstd;
procedure VF_xprod( Z, X, Y:fVector ); |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_xprod( fVector d_Z, fVector d_X, fVector d_Y );
void VFcu_xprod( fVector h_Z, fVector h_X, fVector h_Y );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_xprod( d_Z, d_X, d_Y:fVector ): IntBool;
procedure VF_xprod( h_Z, h_X, h_Y:fVector );
|
|
Beschreibung | Z = X x Y
Das Vektorprodukt von X und Y wird berechnet. Da diese Operation ganz spezifisch für im geometrischen Sinne drei-dimensionale Vektoren definiert ist, enthält diese Funktion keinen Parameter size. Implizit wird also angenommen, dass jeder der partizipierenden Vektoren 3 Elemente hat. |
|
|
|
|
VF_xspectrum | VD_xspectrum | VE_xspectrum |
VF_xspectrumAbs | VD_xspectrumAbs | VE_xspectrumAbs |
VFb_xspectrum | VDb_xspectrum | VEb_xspectrum |
VFb_xspectrumAbs | VDb_xspectrumAbs | VEb_xspectrumAbs |
|
Funktion | Kreuz-Leistungs-Spektrum zweier Signale |
|
Syntax C/C++ | #include <VFstd.h>
void VF_xspectrum( cfVector Spc, ui specsiz, fVector X, fVector Y, ui xsiz, fVector Win );
float VF_xspectrumAbs( fVector Spc, ui specsiz, fVector X, fVector Y, ui xsiz, fVector Win );
void VFb_xspectrum( cfVector Spc, ui specsiz, fVector X, fVector Y, ui xsiz, fVector Win, fVector Buf );
float VFb_xspectrumAbs( fVector Spc, ui specsiz, fVector X, fVector Y, ui xsiz, fVector Win, fVector Buf ); |
C++ VecObj | #include <OptiVec.h>
void vector<complex<T>>::xspectrum( const vector<T>& X, const vector<T>& Y, const vector<T>& Win );
T vector<T>::xspectrumAbs( const vector<T>& X, const vector<T>& Y, const vector<T>& Win );
void vector<complex<T>>::b_xspectrum( const vector<T>& X, const vector<T>& Y, const vector<T>& Win, vector<T>& Buf );
T vector<T>::b_xspectrumAbs( const vector<T>& X, const vector<T>& Y, const vector<T>& Win, vector<T>& Buf );
|
Pascal/Delphi | uses VFstd;
procedure VF_xspectrum( Spc:cfVector; specsiz:UIntSize; X,Y:fVector; xsiz:UIntSize; Win:fVector );
function VF_xspectrumAbs( Spc:fVector; specsiz:UIntSize; X,Y:fVector; xsiz:UIntSize; Win:fVector ): Single;
procedure VFb_xspectrum( Spc:cfVector; specsiz:UIntSize; X,Y:fVector; xsiz:UIntSize; Win, Buf:fVector );
function VFb_xspectrumAbs( Spc:fVector; specsiz:UIntSize; X,Y:fVector; xsiz:UIntSize; Win, Buf:fVector ): Single; |
|
CUDA-Funktion C/C++ | #include <cudaVFstd.h>
int cudaVF_xspectrum( cfVector d_Spc, ui specsiz, fVector d_X, fVector d_Y, ui xsiz, fVector d_Win );
void VFcu_xspectrum( cfVector h_Spc, ui specsiz, fVector h_X, fVector h_Y, ui xsiz, fVector h_Win );
int cudaVF_xspectrumAbs( float *h_csdfNyq, fVector d_Spc, ui specsiz, fVector d_X, fVector d_Y, ui xsiz, fVector d_Win );
int cusdVF_xspectrumAbs( float *d_csdfNyq, fVector d_Spc, ui specsiz, fVector d_X, fVector d_Y, ui xsiz, fVector d_Win );
float VFcu_xspectrumAbs( fVector h_Spc, ui specsiz, fVector h_X, fVector h_Y, ui xsiz, fVector h_Win );
|
CUDA-Funktion Pascal/Delphi | uses VFstd;
function cudaVF_xspectrum( d_Spc:cfVector; specsiz:UIntSize; d_X, d_Y:fVector; xsiz:UIntSize; d_Win:fVector ): IntBool;
procedure VFcu_xspectrum( h_Spc:fVector; specsiz:UIntSize; h_X, h_Y:fVector; xsiz:UIntSize; h_Win:fVector );
function cudaVF_xspectrumAbs( var h_csdfNyq:Single; d_Spc:fVector; specsiz:UIntSize; d_X, d_Y:fVector; xsiz:UIntSize; d_Win:fVector ): IntBool;
function cusdVF_xspectrumAbs( d_csdfNyq:PSingle; d_Spc:fVector; specsiz:UIntSize; d_X, d_Y:fVector; xsiz:UIntSize; d_Win:fVector ): IntBool;
function VFcu_xspectrumAbs( h_Spc:fVector; specsiz:UIntSize; h_X, h_Y:fVector; xsiz:UIntSize; h_Win:fVector ): Single;
|
|
Beschreibung | Das Kreuzleistungsspektrum der beiden Datensätze X und Y wird ermittelt. Es ist definiert als das Produkt der Fourier-Transformierten von X mit der Komplex-Konjugierten der Fourier-Transformierten von Y:
SXY = F(X) * F*(Y).
Da das Ergebnis für negative und positive Frequenzen identisch ist, wird hier das sog. Einseitige Kreuzleistungsspektrum gespeichert:
GXY = SXY für f=0, GXY = 2*SXY für f>0.
Das Ergebnis ist komplex außer für die Frequenz 0 und für die Nyquist-Frequenz.
Dementsprechend kann VF_xspectrum das Ergebnis komprimiert in einem komplexen Vektor der Länge specsiz speichern, wobei Spc[0].Re = GXY[0] und Spc[0].Im = GXY[fNyquist] enthalten.
Da das Kreuzleistungsspektrum häufig nicht in komplexer Form benötigt wird, sondern nur als Absolutwert, ist hier eine zweite Form der Funktion implementiert, VF_xspectrumAbs, die diesen Absolutwert als (reellen) Vektor Spc speichert. Um specsiz als ganzzahlige Potenz von 2 definieren zu können, werden hier jedoch nur specsiz Punkte in Spc gespeichert. Der letzte Wert, d.h. die absolute Kreuzleistungsdichte für die Nyquist-Frequenz fc, wird als Rückgabewert der Funktion behandelt und kann entweder vernachlässigt (durch Aufruf der Funktion wie eine void-Funktion bzw. eine procedure) oder als letztes Element in Spc gespeichert werden durch Aufruf in der Form
Spc[specsiz] = VF_xspectrumAbs( Spc, specsiz, X, Y, xsiz, Win );
In diesem Fall muss Spc eine Länge von specsiz+1 haben.
xsiz muss mindestens 2*specsiz betragen und specsiz eine ganzzahlige Potenz von 2 sein. Intern wird X in xsiz / specsiz - 1 Segmente unterteilt und über die für die einzelnen Segmente berechneten Kreuzleistungsspektren gemittelt. Jedes Segment der Länge 2*specsiz ergibt die Kreuzleistungsdichte für specsiz+1 Frequenzen (siehe VF_FFT).
Win ist ein Fenster, das auf die Datensegmente angewendet wird. Seine Größe ist immer 2*specsiz. Innerhalb der VectorLib-Bibliotheken sind drei Funktionen vorhanden, die passende Fenster erzeugen: VF_Welch, VF_Parzen und VF_Hann. Ein Rechteck-Fenster wird über VF_equ1 erhalten. Von seinem Gebrauch wird hier aber abgeraten.
Intern benötigt VF_xspectrum / VF_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 VFb_xspectrum / VFb_xspectrumAbs zu verwenden. Die Größe von Buf muss dabei ≥ 4*xsiz + 4*specsiz sein. Außerdem muss Buf 128-bit (P8) bzw. 256-bit( P9) ausgerichtet sein. Um dies zu garantieren, sollte man nur Vektoren als Buf verwenden, die mit der VF_vector-Familie alloziert wurden. |
|
Fehlerbehandlung | Wenn size nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf VF_xspectrum basiert) mit der Fehlermeldung "Size must be integer power of 2." und bricht das Programm ab. |
|
Rückgabewert | VF_xspectrum: keiner.
VF_xspectrumAbs: spektrale Kreuz-Leistungsdichte bei der Nyquist-Frequenz |
|
|
VF_xyAutoPlot | VD_xyAutoPlot | VE_xyAutoPlot |
VI_xyAutoPlot | VBI_xyAutoPlot | VSI_xyAutoPlot |
VLI_xyAutoPlot | VQI_xyAutoPlot |
VU_xyAutoPlot | VUB_xyAutoPlot | VUS_xyAutoPlot |
VUL_xyAutoPlot | VUQ_xyAutoPlot | VUI_xyAutoPlot |
| ..._xyAutoPlot_xlg_ylin | |
| ..._xyAutoPlot_xlg_ylg | |
| ..._xyAutoPlot_xlin_ylg | |
|
Funktion | Auftragung eines Y-Vektors gegen einen X-Vektor in ein automatisch erzeugtes cartesisches Koordinatensystem. |
|
Syntax C/C++ | #include <Vgraph.h>
void VF_xyAutoPlot( fVector X, fVector Y, ui size, unsigned form, COLORREF color );
void VF_xyAutoPlot_xlg_ylin( fVector X, fVector Y, ui size, unsigned form, COLORREF color );
void VF_xyAutoPlot_xlg_ylg( fVector X, fVector Y, ui size, unsigned form, COLORREF color );
void VF_xyAutoPlot_xlin_ylg( fVector X, fVector Y, ui size, unsigned form, COLORREF color ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::xyAutoPlot( const vector<T>& X, unsigned form, COLORREF color );
void vector<T>::xyAutoPlot_xlg_ylin( const vector<T>& X, unsigned form, COLORREF color );
void vector<T>::xyAutoPlot_xlg_ylg( const vector<T>& X, unsigned form, COLORREF color );
void vector<T>::xyAutoPlot_xlin_ylg( const vector<T>& X, unsigned form, COLORREF color ); |
Pascal/Delphi | uses Vgraph;
procedure VF_xyAutoPlot( X, Y:fVector; size:UIntSize; form:UInt; color:COLORREF );
procedure VF_xyAutoPlot_xlg_ylin( X, Y:fVector; size:UIntSize; form:UInt; color:COLORREF );
procedure VF_xyAutoPlot_xlg_ylg( X, Y:fVector; size:UIntSize; form:UInt; color:COLORREF );
procedure VF_xyAutoPlot_xlin_ylg( X, Y:fVector; size:UIntSize; form:UInt; color:COLORREF ); |
|
Beschreibung | Ein cartesisches Koordinatensystem wird gemäß den in X und Y vorhandenen Maximal- und Minimalwerten automatisch skaliert und Y in diesem System gegen X aufgetragen. Dabei können beliebige Kombinationen von linearen oder logarithmischen Achsen gewählt werden:
VF_xyAutoPlot: | sowohl X-Achse als auch Y-Achse linear. |
VF_xyAutoPlot_xlg_ylin: | X-Achse logarithmisch, Y-Achse linear. |
VF_xyAutoPlot_xlg_ylg: | sowohl X-Achse als auch Y-Achse logarithmisch. |
VF_xyAutoPlot_xlin_ylg: | X-Achse linear, Y-Achse logarithmisch. |
Bevor VF_xyAutoPlot etc. aufgerufen werden können, müssen die Plot-Routinen mittels V_initPlot initialisiert werden, siehe Kap. 4.11.
Die VecObj-Version dieser Funktion wird als Member-Funktion von Y (nicht von X) aufgerufen.
Als Schriftart der Achsenbeschriftung wird der Font des aktuellen Gerätekontextes benutzt.
Die gewünschte Darstellung der einzelnen Datenpunkte und gegebenenfalls die Art der sie verbindenden Linien werden als Parameter form mittels in <Vgraph.h> (C/C++) bzw. in der unit VGraph (Pascal/Delphi) definierter symbolischer Konstanten angegeben. Für die verschiedenen Linienarten kann wahlweise die Notation Notation der Windows-API oder auch noch diejenige der BGI-Linienarten alter Borland−Compiler verwandt werden. Die für die Übersetzung der einen in die andere Schreibweise nötigen Makros sind in <Vgraph.h> bzw. in der unit VGraph definiert.
1. Linienarten zur Verbindung benachbarter Datenpunkte:
Windows-Stil | BGI C/C++ | BGI Pascal | Aussehen |
PS_SOLID | SOLID_LINE | SolidLn | –––– (Standard) |
PS_DOT | DOTTED_LINE | DottedLn | ········· |
PS_DASH | DASHED_LINE | DashedLn | - - - - |
PS_DASHDOT | CENTER_LINE | CenterLn | - · - · - |
PS_DASHDOTDOT | | | - · · - · · |
PS_NULL | NULL_LINE | NullLn | (gar keine Linie) |
2. Symbole zur Markierung der einzelnen Datenpunkte:
SY_NULL | (gar kein Symbol) (Standard) |
SY_CROSS | ✕ |
SY_PLUS | + |
SY_STAR | * |
SY_CIRCLE | ○ |
SY_BOX | ࡠ |
SY_DIAMOND | ◇ |
SY_TRIANGLEUP | △ |
SY_TRIANGLEDOWN | ▽ |
3. Füllung der Symbole:
SY_HOLLOW | ohne Füllung (Standard) |
SY_FILLED | ganz ausgefüllt |
SY_DOTTED | hohl mit Punkt an exakter Position |
Der Parameter form wird durch Addition von Linienart, Symbol und Füllung konstruiert, z.B. (SOLID_LINE + SY_TRIANGLEUP). Alternativ kann auch das Bit-weise ODER verwandt werden, z.B. (PS_SOLID | SY_CIRCLE | SY_DOTTED ).
In Pascal/Delphi lauten diese Beispiele:
(SolidLn + SY_TRIANGLEUP) und (PS_SOLID or SY_CIRCLE or SY_DOTTED).
NULL_LINE oder PS_NULL muss immer explizit angegeben werden, wenn keine Verbindung der Datenpunkte gewünscht wird. Beispielsweise würde (SY_BOX | SY_HOLLOW) als Verwendung der Standard-Linienart interpretiert werden, also SOLID_LINE zusätzlich zu dem angegebenen Symbol.
SY_NULL und SY_HOLLOW müssen nicht angegeben werden, da diese die Standards für Symbol-Art und -Füllung darstellen. Bei Wahl von SY_NULL, SY_CROSS, SY_PLUS und SY_STAR hat die Angabe einer Füllung keinen Einfluß.
Der Parameter color gibt die für die Symbole und Linien zu verwendende Farbe an. Der Datentyp COLORREF ist unsigned long / ULong. Die Standard-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) definiert. Häufig werden allerdings die mittels des RGB-Makros definierten Farben vorzuziehen sein.
Die Größe der Symbole kann über V_setSymbolSize modifiziert werden. Die Linienstärke kann über V_setLineThickness gesetzt werden.
Beispiele zur Anwendung dieser Funktion finden sich in den Demo-Programmen VDEMO und FITDEMO. |
|
|
|
|
VF_xy2AutoPlot | VD_xy2AutoPlot | VE_xy2AutoPlot |
VI_xy2AutoPlot | VBI_xy2AutoPlot | VSI_xy2AutoPlot |
VLI_xy2AutoPlot | VQI_xy2AutoPlot |
VU_xy2AutoPlot | VUB_xy2AutoPlot | VUS_xy2AutoPlot |
VUL_xy2AutoPlot | VUQ_xy2AutoPlot | VUI_xy2AutoPlot |
| ..._xy2AutoPlot_xlg_ylin | |
| ..._xy2AutoPlot_xlg_ylg | |
| ..._xy2AutoPlot_xlin_ylg | |
|
Funktion | Cartesisches Koordinatensystem zeichnen und zwei X-Y- Vektorpaare auftragen. |
|
Syntax C/C++ | #include <Vgraph.h>
void VF_xy2AutoPlot( fVector X1, fVector Y1, ui size1, unsigned form1, COLORREF color1, fVector X2, fVector Y2, ui size2, unsigned form2, COLORREF color2 );
void VF_xy2AutoPlot_xlg_ylin( fVector X1, fVector Y1, ui size1, unsigned form1, COLORREF color1, fVector X2, fVector Y2, ui size2, unsigned form2, COLORREF color2 );
void VF_xy2AutoPlot_xlg_ylg( fVector X1, fVector Y1, ui size1, unsigned form1, COLORREF color1, fVector X2, fVector Y2, ui size2, unsigned form2, COLORREF color2 );
void VF_xy2AutoPlot_xlin_ylg( fVector X1, fVector Y1, ui size1, unsigned form1, COLORREF color1, fVector X2, fVector Y2, ui size2, unsigned form2, COLORREF color2 ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::xy2AutoPlot( const vector<T>& X1, unsigned form1, COLORREF color1, const vector<T>& X2, const vector<T>& Y2, unsigned form2, COLORREF color2 );
void vector<T>::xy2AutoPlot_xlg_ylin( const vector<T>& X1, unsigned form1, COLORREF color1, const vector<T>& X2, const vector<T>& Y2, unsigned form2, COLORREF color2 );
void vector<T>::xy2AutoPlot_xlg_ylg( const vector<T>& X1, unsigned form1, COLORREF color1, const vector<T>& X2, const vector<T>& Y2, unsigned form2, COLORREF color2 );
void vector<T>::xy2AutoPlot_xlin_ylg( const vector<T>& X1, unsigned form1, COLORREF color1, const vector<T>& X2, const vector<T>& Y2, unsigned form2, COLORREF color2 ); |
Pascal/Delphi | uses Vgraph;
procedure VF_xy2AutoPlot( X1, Y1:fVector; size1:UIntSize; form1:UInt; color1:COLORREF; X2, Y2:fVector; size2:UIntSize; form2:UInt; color2:COLORREF );
procedure VF_xy2AutoPlot_xlg_ylin( X1, Y1:fVector; size1:UIntSize; form1:UInt; color1:COLORREF; X2, Y2:fVector; size2:UIntSize; form2:UInt; color2:COLORREF );
procedure VF_xy2AutoPlot_xlg_ylg( X1, Y1:fVector; size1:UIntSize; form1:UInt; color1:COLORREF; X2, Y2:fVector; size2:UIntSize; form2:UInt; color2:COLORREF );
procedure VF_xy2AutoPlot_xlin_ylg( X1, Y1:fVector; size1:UIntSize; form1:UInt; color1:COLORREF; X2, Y2:fVector; size2:UIntSize; form2:UInt; color2:COLORREF ); |
|
Beschreibung | Y1 wird gegen X1 aufgetragen und Y2 gegen X2, nachdem ein automatisch skaliertes cartesisches Koordinatensystem erzeugt wurde. Für eine nähere Beschreibung der Eingage-Parameter vergleiche man VF_xyAutoPlot. Dabei können beliebige Kombinationen von linearen oder logarithmischen Achsen gewählt werden:
VF_xy2AutoPlot: | sowohl X-Achse als auch Y-Achse linear. |
VF_xy2AutoPlot_xlg_ylin: | X-Achse logarithmisch, Y-Achse linear. |
VF_xy2AutoPlot_xlg_ylg: | sowohl X-Achse als auch Y-Achse logarithmisch. |
VF_xy2AutoPlot_xlin_ylg: | X-Achse linear, Y-Achse logarithmisch. |
Die VecObj-Version dieser Funktion wird als Member-Funktion von Y1 aufgerufen. |
|
|
|
|
VF_xyDataPlot | VD_xyDataPlot | VE_xyDataPlot |
VI_xyDataPlot | VBI_xyDataPlot | VSI_xyDataPlot |
VLI_xyDataPlot | VQI_xyDataPlot |
VU_xyDataPlot | VUB_xyDataPlot | VUS_xyDataPlot |
VUL_xyDataPlot | VUQ_xyDataPlot | VUI_xyDataPlot |
|
Funktion | Auftragung eines Y-Vektors gegen einen X-Vektor in einem bereits existierenden cartesischen Koordinatensystem |
|
Syntax C/C++ | #include <Vgraph.h>
void VF_xyDataPlot( fVector X, fVector Y, ui size, unsigned form, COLORREF color ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::xyDataPlot( const vector<T>& X, unsigned form, COLORREF color ); |
Pascal/Delphi | uses Vgraph;
procedure VF_xyDataPlot( X, Y:fVector; size:UIntSize; form:UInt; color:COLORREF ); |
|
Beschreibung | Der Vektor Y wird gegen den Vektor X aufgetragen in einem cartesischen Koordinatensystem. Dieses muss bereits von einem vorigen Aufruf von z.B. VF_xyAutoPlot, VF_xy2AutoPlot, V_findAxes oder V_drawAxes her existieren.
Für eine nähere Beschreibung vergleiche man VF_xyAutoPlot.
Die VecObj-Version dieser Funktion wird als Member-Funktion von Y aufgerufen. |
|
|
|
|
VF_yAutoPlot | VD_yAutoPlot | VE_yAutoPlot |
VI_yAutoPlot | VBI_yAutoPlot | VSI_yAutoPlot |
VLI_yAutoPlot | VQI_yAutoPlot |
VU_yAutoPlot | VUB_yAutoPlot | VUS_yAutoPlot |
VUL_yAutoPlot | VUQ_yAutoPlot | VUI_yAutoPlot |
| ..._yAutoPlot_xlg_ylin | |
| ..._yAutoPlot_xlg_ylg | |
| ..._yAutoPlot_xlin_ylg | |
|
Funktion | Auftragung eines Y-Vektors gegen den Index in ein automatisch erzeugtes cartesisches Koordinatensystem |
|
Syntax C/C++ | #include <Vgraph.h>.
void VF_yAutoPlot( fVector Y, ui size, unsigned form, COLORREF color );
void VF_yAutoPlot_xlg_ylin( fVector Y, ui size, unsigned form, COLORREF color );
void VF_yAutoPlot_xlg_ylg( fVector Y, ui size, unsigned form, COLORREF color );
void VF_yAutoPlot_xlin_ylg( fVector Y, ui size, unsigned form, COLORREF color ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::yAutoPlot( unsigned form, COLORREF color );
void vector<T>::yAutoPlot_xlg_ylin( unsigned form, COLORREF color );
void vector<T>::yAutoPlot_xlg_ylg( unsigned form, COLORREF color );
void vector<T>::yAutoPlot_xlin_ylg( unsigned form, COLORREF color ); |
Pascal/Delphi | uses Vgraph;
procedure VF_yAutoPlot( Y:fVector; size:UIntSize; form:UInt; color:COLORREF );
procedure VF_yAutoPlot_xlg_ylin( Y:fVector; size:UIntSize; form:UInt; color:COLORREF );
procedure VF_yAutoPlot_xlg_ylg( Y:fVector; size:UIntSize; form:UInt; color:COLORREF );
procedure VF_yAutoPlot_xlin_ylg( Y:fVector; size:UIntSize; form:UInt; color:COLORREF ); |
|
Beschreibung | Ein cartesisches Koordinatensystem wird automatisch gemäß der Größe von Y und den in Y vorkommenden Minimal- und Maximalwerten skaliert und gezeichnet. In dieses werden die einzelnen Elemente von Y gegen ihren die X-Achse bildenden Index aufgetragen. Für eine nähere Beschreibung vergleiche man VF_xyAutoPlot.
Es können beliebige Kombinationen von linearen oder logarithmischen Achsen gewählt werden:
VF_yAutoPlot: | sowohl X-Achse als auch Y-Achse linear. |
VF_yAutoPlot_xlg_ylin: | X-Achse logarithmisch, Y-Achse linear. |
VF_yAutoPlot_xlg_ylg: | sowohl X-Achse als auch Y-Achse logarithmisch. |
VF_yAutoPlot_xlin_ylg: | X-Achse linear, Y-Achse logarithmisch. |
|
|
|
|
|
VF_y2AutoPlot | VD_y2AutoPlot | VE_y2AutoPlot |
VI_y2AutoPlot | VBI_y2AutoPlot | VSI_y2AutoPlot |
VLI_y2AutoPlot | VQI_y2AutoPlot |
VU_y2AutoPlot | VUB_y2AutoPlot | VUS_y2AutoPlot |
VUL_y2AutoPlot | VUQ_y2AutoPlot | VUI_y2AutoPlot |
| ..._y2AutoPlot_xlg_ylin | |
| ..._y2AutoPlot_xlg_ylg | |
| ..._y2AutoPlot_xlin_ylg | |
|
Funktion | Auftragung zweier Y-Vektoren gegen den jeweiligen Index in ein automatisch erzeugtes cartesisches Koordinatensystem |
|
Syntax C/C++ | #include <Vgraph.h>
void VF_y2AutoPlot( fVector Y1, ui size1, unsigned form1, COLORREF color1, fVector Y2, ui size2, unsigned form2, COLORREF color2 );
void VF_y2AutoPlot_xlg_ylin( fVector Y1, ui size1, unsigned form1, COLORREF color1, fVector Y2, ui size2, unsigned form2, COLORREF color2 );
void VF_y2AutoPlot_xlg_ylg( fVector Y1, ui size1, unsigned form1, COLORREF color1, fVector Y2, ui size2, unsigned form2, COLORREF color2 );
void VF_y2AutoPlot_xlin_ylg( fVector Y1, ui size1, unsigned form1, COLORREF color1, fVector Y2, ui size2, unsigned form2, COLORREF color2 ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::y2AutoPlot( unsigned form1, COLORREF color1, const vector<T>& Y2, unsigned form2, COLORREF color2 );
void vector<T>::y2AutoPlot_xlg_ylin( unsigned form1, COLORREF color1, const vector<T>& Y2, unsigned form2, COLORREF color2 );
void vector<T>::y2AutoPlot_xlg_ylg( unsigned form1, COLORREF color1, const vector<T>& Y2, unsigned form2, COLORREF color2 );
void vector<T>::y2AutoPlot_xlin_ylg( unsigned form1, COLORREF color1, const vector<T>& Y2, unsigned form2, COLORREF color2 ); |
Pascal/Delphi | uses Vgraph;
procedure VF_y2AutoPlot( Y1:fVector; size1:UIntSize; form1:UInt; color1:COLORREF; Y2:fVector; size2:UIntSize; form2:UInt; color2:COLORREF );
# procedure VF_y2AutoPlot_xlg_ylin( Y1:fVector; size1:UIntSize; form1:UInt; color1:COLORREF; Y2:fVector; size2:UIntSize; form2:UInt; color2:COLORREF );
procedure VF_y2AutoPlot_xlg_ylg( Y1:fVector; size1:UIntSize; form1:UInt; color1:COLORREF; Y2:fVector; size2:UIntSize; form2:UInt; color2:COLORREF );
procedure VF_y2AutoPlot_xlin_ylg( Y1:fVector; size1:UIntSize; form1:UInt; color1:COLORREF; Y2:fVector; size2:UIntSize; form2:UInt; color2:COLORREF ); |
|
Beschreibung | Ein cartesisches Koordinatensystem wird automatisch gemäß size1 und size2 für die Abszisse und den in Y1 und Y2 vorkommenden Minimal- und Maximalwerten für die Ordinate skaliert und gezeichnet. In dieses werden die einzelnen Elemente von Y1 gegen ihren Index aufgetragen und in gleicher Weise die Elemente von Y2 gegen ihren Index. Für eine nähere Beschreibung vergleiche man VF_xyAutoPlot. Es können beliebige Kombinationen von linearen oder logarithmischen Achsen gewählt werden:
VF_y2AutoPlot: | sowohl X-Achse als auch Y-Achse linear. |
VF_y2AutoPlot_xlg_ylin: | X-Achse logarithmisch, Y-Achse linear. |
VF_y2AutoPlot_xlg_ylg: | sowohl X-Achse als auch Y-Achse logarithmisch. |
VF_y2AutoPlot_xlin_ylg: | X-Achse linear, Y-Achse logarithmisch. |
Die VecObj-Version dieser Funktion wird als Member-Funktion von Y1 aufgerufen. |
|
|
|
|
VF_yDataPlot | VD_yDataPlot | VE_yDataPlot |
VI_yDataPlot | VBI_yDataPlot | VSI_yDataPlot |
VLI_yDataPlot | VQI_yDataPlot |
VU_yDataPlot | VUB_yDataPlot | VUS_yDataPlot |
VUL_yDataPlot | VUQ_yDataPlot | VUI_yDataPlot |
|
Funktion | Auftragung eines Y-Vektors gegen den Index in ein bereits existierendes cartesisches Koordinatensystem |
|
Syntax C/C++ | #include <Vgraph.h>
void VF_yDataPlot( fVector Y, ui size, unsigned form, COLORREF color ); |
C++ VecObj | #include <OptiVec.h>
void vector<T>::yDataPlot( unsigned form, COLORREF color ); |
Pascal/Delphi | uses Vgraph;
procedure VF_yDataPlot( Y:fVector; size:UIntSize; form:UInt; color:COLORREF ); |
|
Beschreibung | Die Elemente des Vektors Y werden gegen ihren Index aufgetragen in einem cartesischen Koordinatensystem. Dieses muss bereits von einem vorigen Aufruf von z.B. VF_yAutoPlot, VF_xyAutoPlot, V_findAxes oder V_drawAxes her existieren. Für eine nähere Beschreibung vergleiche man VF_xyAutoPlot. |
|
|
|
|
9. Skalare (nicht-vektorisierte) Hilfs-Funktionen
Einige wenige nicht-vektorisierte Funktionen, die teilweise aus CMATH und XMATH stammen, sind für die Benutzung von VectorLib erforderlich und werden im folgenden beschrieben:
|
Funktion | Initialisierung cartesisch-komplexer Zahlen |
|
Syntax C/C++ | #include <VecLib.h>
fComplex fcplx( float ReVal, float ImVal );
(analog dcplx, ecplx) |
Pascal/Delphi | uses VecLib;
procedure fcplx( var zy:fComplex; xRe, xIm: Single );
(analog dcplx, ecplx) |
|
Beschreibung | Diese Funktionen erlauben die Erzeugung komplexer Zahlen der drei Datentypen fComplex, dComplex und eComplex. CMATH bietet für C++ weitere (überladene) Versionen von fcplx. Diese sind in CMATHD.HTM, Kap. 2.1 beschrieben.
In C/C++ sollte fcplx vor allem dann eingesetzt werden, wenn temporäre komplexe Variablen als Funktionsargumente benötigt werden. In diesem Fall ersetzt fcplx die umständlichere direkte Zuweisung von Real- und Imaginärteil. |
Beispiel | z.Re = 3.0; z.Im = 4.0;
VCF_equC( X, size, z ); /* etwas umständlich */
VCF_equC( Y, size, fcplx( 3.0, 4.0 )); /* bequemer */
In Pascal/Delphi ist der Aufruf von
fcplx( z, 3.0, 4.0 );
äquivalent mit der Zuweisung
z.Re = 3.0; z.Im = 4.0; |
|
|
Rückgabewert | die erzeugte komplexe Zahl (C/C++) |
|
|
|
Funktion | Test, ob eine Fließkommazahl ganzzahlig ist |
|
Syntax C/C++ | #include <xmath.h>
int isint( double x );
int isintl( long double x ); |
Pascal/Delphi | uses xmath;
function isint( x:Extended ): IntBool;
function isintd( x:Double ): IntBool; |
|
Beschreibung | Wenn x eine ganze Zahl ist, wird TRUE (eine Zahl ungleich 0) zurückgegeben, andernfalls FALSE (0). |
|
|
|
|
Funktion | Test, ob eine vorzeichenlose Ganzzahl eine Potenz von 2 ist |
|
Syntax C/C++ | #include <xmath.h>
int isipow2( unsigned x );
int sisipow2( unsigned short x );
int lisipow2( unsigned long x ); |
Pascal/Delphi | uses xmath;
function isipow2( x:UInt ): IntBool;
function sisipow2( x:USmall ): IntBool;
function lisipow2( x:ULong ): IntBool; |
|
Beschreibung | Gibt TRUE (eine Zahl ≠ 0) zurück, wenn x eine ganzzahlige Potenz von 2 ist:
x = 2n, n=1,2,3,...
Andernfalls wird FALSE (0) zurückgegeben. |
|
|
|
|
Funktion | Natürlicher Logarithmus: nur Pascal/Delphi! |
|
Syntax | uses xmath;
function log( x:Extended x ): Extended;
function logd( x:double x ): Double; |
|
Beschreibung | Der Logarithmus zur Basis e (der Euler'schen Zahl) wird berechnet und zurückgegeben. Die extended-genaue Version dieser Funktion ist fast identisch mit der eingebauten Pascal/Delphi-Funktion Ln. Lediglich die Fehlerbehandlung ist insofern anders, als sie über dieselbe Routine erfolgt wie für die übrigen mathematischen OptiVec-Funktionen und damit über V_setFPErrorHandling beeinflußt werden kann. Die doppelt-genaue Version, logd, ist etwas schneller. |
|
Fehlerbehandlung | Ein DOMAIN-Fehler mit NAN ("not-a-number"; IEEE-Nichtzahl) als Resultat entsteht durch x < 0 (einschließlich x = −0). SING-Fehler mit -HUGE_VAL als Ergebnis resultieren aus x=0. |
|
Rückgabewert | natürlicher Logarithmus des Argumentes |
|
|
|
Funktion | binärer Logarithmus |
|
Syntax C/C++ | #include <xmath.h>
double log2( double x );
long double log2l( long double x ); |
Pascal/Delphi | uses xmath;
function log2( x:Extended ): Extended;
function log2d( x:Double ): Double; |
|
Beschreibung | Der binäre Logarithmus, d.h. der Logarithmus zur Basis 2, wird berechnet und zurückgegeben. |
|
Fehlerbehandlung | Ein DOMAIN-Fehler mit NAN ("not-a-number"; IEEE-Nichtzahl) als Resultat entsteht durch x < 0 (einschließlich x = −0). SING-Fehler mit -HUGE_VAL als Ergebnis resultieren aus x=0.
In C/C++ kann die Behandlung beider Fehler über _matherr bzw. _matherrl modifiziert werden. |
|
Rückgabewert | binärer Logarithmus des Argumentes |
|
|
|
Funktion | dekadischer Logarithmus: nur Pascal/Delphi! |
|
Syntax | uses xmath;
function log10( x:Extended x ): Extended;
function log10d( x:double x ): Double; |
|
Beschreibung | Der Logarithmus zur Basis 10 wird berechnet und zurückgegeben. |
|
Fehlerbehandlung | Ein DOMAIN-Fehler mit NAN ("not-a-number"; IEEE-Nichtzahl) als Resultat entsteht durch x < 0 (einschließlich x = −0). SING-Fehler mit -HUGE_VAL als Ergebnis resultieren aus x=0. |
|
Rückgabewert | dekadischer Logarithmus des Argumentes |
|
|
|
Funktion | Initialisierung komplexer Zahlen in Polarkoordinaten |
|
Syntax C/C++ | #include <VecLib.h>
fPolar fpolr( float MagVal, float ArgVal );
(similarly dpolr, epolr)
|
Pascal/Delphi | uses VecLib;
procedure fpolr( var py:fPolar; xMag, xArg: Single );
(similarly dpolr, epolr) |
|
Beschreibung | Diese Funktionen erlauben die Erzeugung polar-komplexer Zahlen der drei Datentypen fPolar, dPolar und ePolar. CMATH bietet für C++ weitere (überladene) Versionen von fpolr. Diese sind in CMATHD.HTM, Kap. 2.1 beschrieben.
In C/C++ sollte fpolr vor allem dann eingesetzt werden, wenn temporäre komplexe Variablen als Funktionsargumente benötigt werden. In diesem Fall ersetzt fpolr die umständlichere direkte Zuweisung von Zeigerlänge und Zeigerwinkel. |
Beispiel | p.Mag = 3.0; p.Arg = 1.5708;
VPF_equC( X, size, p ); /* etwas umständlich */
VPF_equC( Y, size, fpolr( 3.0, 1.5708 )); /* bequemer */
In Pascal/Delphi ist der Aufruf von
fpolr( p, 3.0, 1.5708 );
äquivalent mit der Zuweisung
p.Mag = 3.0; p.Arg = 1.5708; |
|
|
Rückgabewert | die erzeugte polar-komplexe Zahl (C/C++) |
|
|
|
Funktion | Umwandlung einer quad in eine double oder long double: nur C/C++! |
|
Syntax C/C++ | #include <VecLib.h>
double quadtod( quad x );
long double _quadtold( quad x ); |
|
Beschreibung | Diese Funktionen bieten gemeinsamen mit ihrem Gegenstück setquad die notwendige Hilfe zur Benutzung des Datentyps quad mit C/C++−Compilern, die 64-bit-Integer nicht vollständig unterstützen. Soll beispielsweise der Wert einer quad ausgedruckt werden, so muss dies durch einen Funktionsaufruf geschehen wie
printf( "% 20.0Lf", _quadtold( x )); |
|
|
Rückgabewert | Wert von x als double bzw. long double |
|
|
Funktion | Umwandlung einer long double in eine quad: nur C/C++! |
|
Syntax C/C++ | #include <VecLib.h>
quad setquad( long double x ); |
|
Beschreibung | Diese Funktion bietet gemeinsam mit ihren Gegenstücken quadtod und _quadtold die nötige Vermittlung zur Verwendung des Datentyps quad mit Compilern, die 64-bit-Integers nicht vollständig unterstützen.
Wenn beispielsweise eine VectorLib-Funktion einen quad-Parameter erwartet, so muss er entweder als existierende Variable dieses Typs übergeben oder, wie im folgenden Beispiel, an Ort und Stelle erzeugt werden:
VQI_addC( QI2, QI1,size, setquad( 53563369.L )); |
|
|
Rückgabewert | Wert von x als quad |
|
E N D E
Copyright für OptiVec Software und Dokumentation
© 1996-2024 OptiCode - Dr. Martin Sander Software-Entwicklung
Alle Rechte vorbehalten.
| |