| 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) |
|
|