OptiVec logo 

OptiVec
 
Version 8


für C/C++ und für Pascal / Delphi

OptiCode
Dr. Martin Sander Software-Entwicklung
Brahmsstr. 6
D-32756 Detmold
http://www.optivec.com
e-mail: optivec@gmx.de

Teil I. B: Funktions-Referenz
für VectorLib


Eine grundlegende Beschreibung von VectorLib befindet sich in der Datei HANDBUCH.HTM.
Die Funktionen von MatrixLib werden in MATRIXD.HTM behandelt, die komplexen Funktionen von CMATH in CMATHD.HTM.
Kap. 1.2 von HANDBUCH.HTM enthält die Lizenz-Bedingungen der Shareware-Version, Kap. 1.3 diejenigen der registrierten Vollversion.
 
OptiCode™ und OptiVec™ sind Warenzeichen von Dr. Martin Sander Software-Entwicklung. Andere zum Zwecke der Identifikation hier erwähnte Warenzeichen sind Eigentum der jeweiligen Hersteller.
 


8. Funktions-Referenz VectorLib

Die Funktionen werden in alphabetischer Reihenfolge besprochen. Dabei zählt das den Datentyp bezeichnende Präfix nicht mit. Die Überschrift jeder Gruppe listet alle verfügbaren Versionen der jeweiligen Funktion auf:

VF_exampleVD_exampleVE_example
VCF_exampleVCD_exampleVCE_example
FunktionMan betrachte beispielsweise die Funktionenfamilie "abs". Sie enthält die vektorisierte Absolutwert-Funktion für
  • die drei Fließkomma-Datentypen float, double und extended (long double) mit den Präfixen VF_,   VD_ und VE_,
  • für alle drei cartesisch-komplexen Datentypen (Präfixe VCF_,   VCD_ und VCE_),
  • für die drei polar-komplexen Datentypen (Präfixe VPF_,   VPD_ und VPE_)
  • sowie für die vorzeichen-behafteten Ganzzahltypen int, byte, short int, long int und quad (Präfixe VI_,   VBI_,   VSI_,   VLI_ und VQI_).
Da vorzeichenlose Ganzzahltypen per definitionem positiv sind, macht die Berechnung des Absolutwertes für sie wenig Sinn; man findet die Funktion "abs" daher nicht als VU_,   VUB_,   VUS_,   VUL_ oder VUI_- Version.
Syntax C/C++In den meisten Fällen wird nur die VF_-Version beschrieben. Alle übrigen ergeben sich aus ihr durch Ersatz der in der Deklaration genannten "float" und "fVector" durch die jeweils gewünschten Datentypen und durch Ersatz der genannten Include-Datei durch die zum gewünschten Datentyp gehörige.
C++ VecObjHier wird die Syntax für das objekt-orientierte Interface VecObj angegeben
Pascal/DelphiÄhnlich wie bei der C/C++-Syntax wird wieder zumeist nur die VF_-Version aufgeführt. Man ersetze die Datentypen "float" und "fVector" durch die jeweils gewünschten und schließe die zu diesem Datentyp gehörige unit in die "uses"-Deklaration ein.
BeschreibungAuf eckige Klammern bei der Angabe von Vektor-Elementen wird aus Gründen der Übersichtlichkeit verzichtet und stattdessen der Index als Subskript angegeben. Ebenfalls wird darauf verzichtet, jedes Mal von neuem anzugeben, dass sich die beschriebene Operation selbstverständlich auf alle Elemente vom nullten bis zum letzten (dem mit der Nummer size−1) bezieht. Eine Formelangabe wie
      Yi = | Xi |
ist also die abkürzende Schreibweise für
      Y[i] = | X[i] |, i=0,...,size−1
oder, als C/C++-Schleife geschrieben:
      for( i=0; i<size; i++ ) Y[i] = fabs( X[i] );
FehlerbehandlungEs werden die abgefangenen Fehler aufgeführt mit dem jeweils standardmäßig gesetzten Resultat.
nur C/C++:
Alle mathematischen Fehler, bei denen nicht ausdrücklich etwas anderes angegeben ist, werden über _matherr bzw. _matherrl behandelt. Durch Modifizieren von _matherr und _matherrl kann der Anwender auch andere Resultate als die vorgeschlagenen spezifizieren. Hiervon wird allerdings abgeraten. Siehe Kap. 5.3 des Handbuches).
RückgabewertDer Rückgabewert der jeweiligen Funktion im bei der Syntax-Beschreibung angegebenen Datentyp
QuerverweisVerweise nach Funktionen ohne ein mit "V" beginnendes Präfix beziehen sich auf die Dokumentation Ihres C/C++- oder Pascal/Delphi−Compilers. Verweise auf Kap 1. bis 7. beziehen sich auf die Datei HANDBUCH.HTM.

 

VF_absVD_absVE_abs
VCF_absVCD_absVCE_abs
VPF_absVPD_absVPE_abs
VI_absVBI_absVSI_absVLI_absVQI_abs
FunktionAbsolutwert
Syntax C/C++#include <VFmath.h>
int VF_abs( fVector Y, fVector X, ui size );

    (analog VD_,   VE_,   VBI_,   VSI_,   VI_,   VLI_,   VQI_)
int VCF_abs( fVector Y, cfVector X, ui size );
    (analog VCD_,   VCE_,   VPF_,   VPD_,   VPE_)
C++ VecObj#include <OptiVec.h>
int vector<T>::abs( const vector<T>& X );
int vector<T>::abs( const vector<complex<T>>& X );
Pascal/Delphiuses VFmath;
function VF_abs( Y, X:fVector; size:UIntSize ): IntBool;

    (analog VD_,   VE_,   VSI_,   VI_,   VLI_,   VQI_)
function VCF_abs( Y:fVector; X:cfVector; size:UIntSize ): IntBool;
    (analog VCD_,   VCE_,   VPF_,   VPD_,   VPE_)
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_abs( fVector d_Y, fVector d_X, ui size );
int VFcu_abs( fVector h_Y, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_abs( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function VFcu_abs( h_Y, h_X:fVector; size:UIntSize ): IntBool;
BeschreibungReelle und Ganzzahl-Versionen: Yi = | Xi |
VBI_, VSI_-, VI_- und VLI_-Versionen: Durch die implizite modulo-2n-Arithmetik der Ganzzahlen wird der Absolutwert der "negativsten" möglichen Zahlen (also −128 für byte/ByteInt, -32768 für short/SmallInt, -2147483648 für long/LongInt) als dieselbe negative(!) Zahl -32768 bzw. -2147483648 gespeichert.
Komplexe Versionen: Yi = sqrt( Xi.Re2 + Xi.Im2 )
Man beachte bei den komplexen Versionen, dass der Ergebnis-Vektor reell ist. Dieselbe Operation der Bildung des Absolutwertes wird für cartesisch-komplexe Vektoren etwas schneller, dafür ohne Fehlerbehandlung, von VF_CtoAbs durchgeführt.
FehlerbehandlungReelle und Ganzzahl-Versionen: Es sollten keine Fehler auftreten.
Komplexe Versionen: OVERFLOW-Fehler ergeben +HUGE_VAL.
RückgabewertFließkomma-Versionen: FALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
Die Ganzzahl-Versionen haben keinen Rückgabewert.
QuerverweisVF_neg,   VCF_conj

 

VF_absHugeVD_absHugeVE_absHuge
FunktionErsatz von negativen Polstellen (−HUGE_VAL) durch positive (+HUGE_VAL)
Syntax C/C++#include <VFmath.h>
void VF_absHuge( fVector Y, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::absHuge( const vector<T>& X );
Pascal/Delphiuses VFmath;
procedure VF_absHuge( Y, X:fVector; size:UIntSize );
CUDA-FunKtion C/C++#include <cudaVFmath.h>
int cudaVF_absHuge( fVector d_Y, fVector d_X, ui size );
void VFcu_absHuge( fVector h_Y, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_absHuge( d_Y, d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_absHuge( h_Y, h_X:fVector; size:UIntSize );
BeschreibungYi = Xi , wenn Xi > −HUGE
Yi = Max, wenn Xi ≤ −HUGE_VAL
(wobei HUGE je nach Datentyp FLT_MAX, DBL_MAX oder LDBL_MAX bedeutet)
Etliche mathematische Funktionen wie z.B. Kehrwert, Tangens o.a. weisen divergierende Polstellen auf (z.B., 1/+0 = +INF, aber 1/−0 = −INF, wobei INF, um Folgefehler zu vermeiden, meist, aber nicht immer, als HUGE_VAL dargestellt wird). In solchen Fällen wird der kleinste Rundungsfehler darüber entscheiden, ob das Ergebnis +INF oder −INF wird. Gelegentlich wird man um der Konsistenz der Ergebnisse willen 1/−0 und 1/+0 identisch behandeln, also den negativen Pol durch einen positiven ersetzen wollen. Dies ist die Aufgabe von VF_absHuge. Man beachte, dass sowohl −HUGE_VAL als auch −INF zu +HUGE_VAL geändert werden, während +INF unverändert bleibt.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_replaceNAN,   VF_maxC,   VF_minC,   VF_min,   VF_flush0,   VF_limit

 

VF_absmaxVD_absmaxVE_absmax
VCF_absmaxVCD_absmaxVCE_absmax
VPF_absmaxVPD_absmaxVPE_absmax
FunktionGrößter Absolutwert innerhalb eines Vektors
Syntax C/C++#include <VFstd.h>
float VF_absmax( fVector X, ui size );

    (analog VD_,   VE_)
float VCF_absmax( cfVector X, ui size);
    (analog VCD_,   VCE_,   VPF_,   VPD_,   VPE_)
C++ VecObj#include <OptiVec.h>
T vector<T>::absmax();
T vector<complex<T>>::absmax();
Pascal/Delphiuses VFstd;
function VF_absmax( X:fVector; size:UIntSize ): Single;

    (analog VD_,   VE_)
function VCF_absmax( X:cfVector; size:UIntSize ): Single;
    (analog VCD_,   VCE_,   VPF_,   VPD_,   VPE_)
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_absmax( float *h_RetVal, fVector d_X, ui size );
int cusdVF_absmax( float *d_RetVal, fVector d_X, ui size );
float VFcu_absmax( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_absmax( var h_RetVal:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_absmax( d_RetVal:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_absmax( X:fVector; size:UIntSize ): Single;
BeschreibungDer größte innerhalb eines Vektors vorkommende Absolutwert wird gefunden.
Bei komplexen Vektoren ist dies die größte vorkommende Zeigerlänge und ist eine reelle Zahl. Wird die betragsmäßig größte komplexe Zahl selbst und nicht nur ihre Zeigerlänge benötigt, rufe man VCF_cabsmax. Um bei cartesisch-komplexen Vektoren den jeweils größten Absolutwert von Real- und Imaginärteil getrennt zu erhalten, gebrauche man VCF_absmaxReIm.
Fehlerbehandlungkeine
Rückgabewertgefundenes Betrags-Maximum
QuerverweisVF_max,   VF_absmin,   VF_absminmax,   VF_maxexp,   VF_runmax,   VF_absmaxind,   VCF_absmaxReIm,   VCF_cabsmax,   VCF_sabsmax

 

VF_absmaxindVD_absmaxindVE_absmaxind
VCF_absmaxindVCD_absmaxindVCE_absmaxind
VPF_absmaxindVPD_absmaxindVPE_absmaxind
FunktionGrößter Absolutwert und sein Index
Syntax C/C++#include <VFstd.h>
float VF_absmaxind( ui *Ind, fVector X, ui size );

    (analog VD_,   VE_)
float VCF_absmaxind( ui *Ind, cfVector X, ui size );
    (analog VCD_,   VCE_,   VPF_,   VPD_,   VPE_)
C++ VecObj#include <OptiVec.h>
T vector<T>::absmaxind( ui *Ind );
T vector<complex<T>>::absmaxind( ui *Ind );
Pascal/Delphiuses VFstd;
function VF_absmaxind( var Ind:UIntSize; X:fVector; size:UIntSize ): Single;

    (analog VD_,   VE_)
function VCF_absmaxind( var Ind:UIntSize; X:cfVector; size:UIntSize ): Single;
    (analog VCD_,   VCE_,   VPF_,   VPD_,   VPE_)
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_absmaxind( float *h_RetVal, ui *h_Ind, fVector d_X, ui size );
int cusdVF_absmaxind( float *d_RetVal, ui *h_Ind, fVector d_X, ui size );
float VFcu_absmaxind( ui *h_Ind, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_absmaxind( var h_RetVal:Single; var h_Ind:UIntSize; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_absmaxind( d_RetVal:PSingle; var h_Ind:UIntSize; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_absmaxind( var h_Ind:UIntSize; h_X:fVector; size:UIntSize ): Single;
BeschreibungDer größte auftretende Absolutwert wird gefunden und zurückgegeben. Sein Index wird an der durch Ind bezeichneten Adresse gespeichert. Im Falle wiederholten Auftretens desselben Maximalwertes wird der Index des ersten Auftretens gewählt.
Fehlerbehandlungkeine
Rückgabewertgefundenes Betrags-Maximum.
QuerverweisVF_maxind,   VF_absmax,   VF_runmax,   VF_maxind,   VCF_absmaxReIm

 

VCF_absmaxReImVCD_absmaxReImVCE_absmaxReIm
FunktionGetrennte Bestimmung des größten Absolutwertes von Real- und Imaginärteil cartesisch-komplexer Vektoren.
Syntax C/C++#include <VCFstd.h>
fComplex VCF_absmaxReIm( cfVector X, ui size );

    (analog VCD_,   VCE_)
C++ VecObj#include <OptiVec.h>
complex<T> vector<complex<T>>::absmaxReIm();
Pascal/Delphiuses VCFstd;
function VCF_absmaxReIm( X:cfVector; size:UIntSize ):fComplex;

Alternative Syntax (veraltet, aber weiterhin unterstützt):
procedure VCF_absmaxReIm( var RetVal:fComplex; X:cfVector; size:UIntSize );

    (analog VCD_,   VCE_)
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVCF_absmaxReIm( fComplex *h_RetVal, cfVector d_X, ui size );
int cusdVCF_absmaxReIm( fComplex *d_RetVal, cfVector d_X, ui size );
fComplex VCFcu_absmaxReIm( cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVCF_absmaxReIm( var h_RetVal:fComplex; d_X:cfVector; size:UIntSize ): IntBool;
function cusdVCF_absmaxReIm( d_RetVal:PfComplex; d_X:cfVector; size:UIntSize ): IntBool;
function VCFcu_absmaxReIm( h_X:cfVector; size:UIntSize ):fComplex;
BeschreibungDer größte innerhalb aller Realteile auftretende Absolutwert sowie der größte innerhalb aller Imaginärteile auftretende Absolutwert werden getrennt voneinander bestimmt.
Fehlerbehandlungkeine
RückgabewertRealteil: größter Absolutwert der Realteile,
Imaginärteil: größter Absolutwert der Imaginärteile.
QuerverweisVCF_maxReIm,   VCF_absminReIm

 

VF_absminVD_absminVE_absmin
VCF_absminVCD_absminVCE_absmin
VPF_absminVPD_absminVPE_absmin
FunktionKleinster Absolutwert innerhalb eines Vektors
Syntax C/C++#include <VFstd.h>
float VF_absmin( fVector X, ui size );

    (analog VD_,   VE_)
float VCF_absmin( cfVector X, ui size );
    (analog VCD_,   VCE_,   VPF_,   VPD_,   VPE_)
C++ VecObj#include <OptiVec.h>
T vector<T>::absmin();
T vector<complex<T>>::absmin();
Pascal/Delphiuses VFstd;
function VF_absmin( X:fVector; size:UIntSize ): Single;

    (analog VD_,   VE_)
function VCF_absmin( X:cfVector; size:UIntSize ): Single;
    (analog VCD_,   VCE_,   VPF_,   VPD_,   VPE_)
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_absmin( float *h_RetVal, fVector d_X, ui size );
int cusdVF_absmin( float *d_RetVal, fVector d_X, ui size );
float VFcu_absmin( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_absmin( var h_RetVal:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_absmin( d_RetVal:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_absmin( X:fVector; size:UIntSize ): Single;
BeschreibungDer kleinste innerhalb eines Vektors vorkommende Absolutwert wird gefunden.
Bei komplexen Vektoren ist dies die kleinste vorkommende Zeigerlänge und ist eine reelle Zahl. Wird die betragsmäßig kleinste komplexe Zahl selbst und nicht nur ihre Zeigerlänge benötigt, rufe man VCF_cabsmin. Um bei cartesisch-komplexen Vektoren den jeweils kleinsten Absolutwert von Real- und Imaginärteil getrennt zu erhalten, gebrauche man VCF_absminReIm.
Fehlerbehandlungkeine
Rückgabewertgefundenes Betrags-Minimum
QuerverweisVF_min,   VF_absmax,   VF_absminmax,   VF_minexp,   VF_runmin,   VF_minind,   VCF_absminReIm,   VCF_cabsmin,   VCF_sabsmin

 

VF_absminindVD_absminindVE_absminind
VCF_absminindVCD_absminindVCE_absminind
VPF_absminindVPD_absminindVPE_absminind
FunktionKleinster Absolutwert und sein Index
Syntax C/C++#include <VFstd.h>
float VF_absminind( ui *Ind, fVector X, ui size );

    (analog VD_,   VE_)
float VCF_absminind( ui *Ind, cfVector X, ui size );
    (analog VCD_,   VCE_,   VPF_,   VPD_,   VPE_)
C++ VecObj#include <OptiVec.h>
T vector<T>::absminind( ui *Ind );
T vector<complex<T>>::absminind( ui *Ind );
Pascal/Delphiuses VFstd;
function VF_absminind( var Ind:UIntSize; X:fVector; size:UIntSize ): Single;

    (analog VD_,   VE_)
function VCF_absminind( var Ind:UIntSize; X:cfVector; size:UIntSize ): Single;
    (analog VCD_,   VCE_,   VPF_,   VPD_,   VPE_)
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_absminind( float *h_RetVal, ui *h_Ind, fVector d_X, ui size );
int cusdVF_absminind( float *d_RetVal, ui *h_Ind, fVector d_X, ui size );
float VFcu_absminind( ui *h_Ind, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_absminind( var h_RetVal:Single; var h_Ind:UIntSize; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_absminind( d_RetVal:PSingle; var h_Ind:UIntSize; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_absminind( var h_Ind:UIntSize; h_X:fVector; size:UIntSize ): Single;
BeschreibungDer kleinste auftretende Absolutwert wird gefunden und zurückgegeben. Sein Index wird an der durch Ind bezeichneten Adresse gespeichert. Im Falle wiederholten Auftretens desselben Minimalwertes wird der Index des ersten Auftretens gewählt.
Fehlerbehandlungkeine
Rückgabewertgefundenes Betrags-Minimum
QuerverweisVF_minind,   VF_absmin,   VF_runmin,   VF_maxind,   VCF_absminReIm

 

VF_absminmaxVD_absminmaxVE_absminmax
VI_absminmaxVBI_absminmaxVSI_absminmaxVLI_absminmaxVQI_absminmax
VU_absminmaxVUB_absminmaxVUS_absminmaxVUL_absminmaxVUI_absminmax
FunktionAbsolutwert-Minimum und -Maximum einer Verteilung
Syntax C/C++#include <VFstd.h>
float VF_absminmax( float *xmax, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::absminmax(T *xmax);
Pascal/Delphiuses VFstd;
function VF_absminmax( var xmax:Single; X:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_absminmax( float *h_xmin, float *h_xmax, fVector d_X, ui size );
int cusdVF_absminmax( float *d_xmin, float *d_xmax, fVector d_X, ui size );
float VFcu_absminmax( float *xmax, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_absminmax( var h_xmin, h_xmax:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_absminmax( d_xmin, d_xmax:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_absminmax( var h_xmax:Single; h_X:fVector; size:UIntSize ): Single;
BeschreibungDer kleinste Absolutwert von X wird zurückgegeben. Das Absolutwert-Maximum wird in xmax/i> gespeichert.
Fehlerbehandlungkeine
Rückgabewertgefundenes Absolutwert-Minimum
QuerverweisVF_minmax,   VF_absmin,   VF_absmax,   VF_min_max_mean_stddev

 

VCF_absminReImVCD_absminReImVCE_absminReIm
FunktionGetrennte Bestimmung des kleinsten Absolutwertes von Real- und Imaginärteil cartesisch-komplexer Vektoren.
Syntax C/C++#include <VCFstd.h>
fComplex VCF_absminReIm( cfVector X, ui size );

    (analog VCD_,   VCE_)
C++ VecObj#include <OptiVec.h>
complex<T> vector<complex<T>>::absminReIm();
Pascal/Delphiuses VCFstd;
function VCF_absminReIm( X:cfVector; size:UIntSize ):fComplex;

Alternative Syntax (veraltet, aber weiterhin unterstützt):
procedure VCF_absminReIm( var Min:fComplex; X:cfVector; size:UIntSize );

    (analog VCD_,   VCE_)
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVCF_absminReIm( fComplex *h_RetVal, cfVector d_X, ui size );
int cusdVCF_absminReIm( fComplex *d_RetVal, cfVector d_X, ui size );
fComplex VCFcu_absminReIm( cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVCF_absminReIm( var h_RetVal:fComplex; d_X:cfVector; size:UIntSize ): IntBool;
function cusdVCF_absminReIm( d_RetVal:PfComplex; d_X:cfVector; size:UIntSize ): IntBool;
function VCFcu_absminReIm( h_X:cfVector; size:UIntSize ):fComplex;
BeschreibungDer kleinste innerhalb aller Realteile auftretende Absolutwert sowie der kleinste innerhalb aller Imaginärteile auftretende Absolutwert werden getrennt voneinander bestimmt.
Fehlerbehandlungkeine
RückgabewertRealteil: kleinster Absolutwert der Realteile,
Imaginärteil: kleinster Absolutwert der Imaginärteile.
QuerverweisVCF_minReIm,   VCF_absmaxReIm

 

VF_accElementVD_accElementVE_accElement
VCF_accElementVCD_accElementVCE_accElement
VCF_accElementReVCD_accElementReVCE_accElementRe
VCF_accElementImVCD_accElementImVCE_accElementIm
VI_accElementVBI_accElementVSI_accElementVLI_accElementVQI_accElement 
VU_accElementVUB_accElementVUS_accElementVUL_accElementVUQ_accElementVUI_accElement
FunktionEin Vektor-Element um einen bestimmten Wert erhöhen
Syntax C/C++#include <VFstd.h>
void VF_accElement( fVector X, ui pos, float C );
#include <VCFstd.h>
void VCF_accElement( cfVector X, ui pos, fComplex C );
void VCF_accElementRe( fVector X, ui pos, float C );
void VCF_accElementIm( fVector X, ui pos, float C );
C++ VecObj#include <OptiVec.h>
vector<T>::accElement( ui pos, T C );
vector<complex<T>>::accElement( ui pos, complex<T> C );
vector<complex<T>>::accElementRe( ui pos, T C );
vector<complex<T>>::accElementIm( ui pos, T C );
Pascal/Delphiuses VFstd;
procedure VF_accElement( X:fVector; pos:UIntSize; C:Single );
uses VCFstd;
procedure VCF_accElement( X:cfVector; pos:UIntSize; C:fComplex );
procedure VCF_accElementRe( X:cfVector; pos:UIntSize; C:Single );
procedure VCF_accElementIm( X:cfVector; pos:UIntSize; C:Single );
CUDA-Funktion C/C++#include <cudaVFstd.h>
void cudaVF_accElement( fVector d_X, ui pos, float C );
void cusdVF_accElement( fVector d_X, ui pos, float *d_C );
#include <cudaVCFstd.h>
void cudaVCF_accElement( cfVector d_X, ui pos, fComplex C );
void cusdVCF_accElement( cfVector d_X, ui pos, fComplex *d_C );
void cudaVCF_accElementRe( cfVector d_X, ui pos, float C );
void cusdVCF_accElementRe( cfVector d_X, ui pos, float *d_C );
void cudaVCF_accElementIm( cfVector d_X, ui pos, float C );
void cusdVCF_accElementIm( cfVector d_X, ui pos, float *d_C );
CUDA-Funktion Pascal/Delphiuses VFstd;
procedure cudaVF_accElement( d_X:fVector; pos:UIntSize; C:Single );
procedure cusdVF_accElement( d_X:fVector; pos:UIntSize; d_C:PSingle );
uses VCFstd;
procedure cudaVCF_accElement( d_X:cfVector; pos:UIntSize; C:fComplex );
procedure cusdVCF_accElement( d_X:cfVector; pos:UIntSize; d_C:PfComplex );
procedure cudaVCF_accElementRe( d_X:cfVector; pos:UIntSize; C:Single );
procedure cusdVCF_accElementRe( d_X:cfVector; pos:UIntSize; d_C:PSingle );
procedure cudaVCF_accElementIm( d_X:cfVector; pos:UIntSize; C:Single );
procedure cusdVCF_accElementIm( d_X:cfVector; pos:UIntSize; d_C:PSingle );
BeschreibungReelle Versionen:
X[i] += C;
Das Element an der Position pos wird um den Wert C erhöht.

Komplexe Versionen VCF_accElement usw.:
X[i].Re += C.Re; X[i].Im += C.Im;

Komplexe Versionen VCF_accElementRe usw.:
X[i].Re += C.Re;
Der Imaginärteil X[i].Im bleibt unangetastet.

Komplexe Versionen VCF_accElementIm usw.:
X[i].Im += C.Im;
Der Realteil X[i].Re bleibt unangetastet.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_Pelement,   VF_element,   VF_getElement,   VF_setElement,   VF_decElement

 

VF_accVVD_accVVE_accV
VCF_accVVCD_accVVCE_accV
VI_accVVBI_accVVSI_accVVLI_accVVQI_accV 
VU_accVVUB_accVVUS_accVVUL_accVVUQ_accVVUI_accV
gemischte Versionen:
VD_accVFVE_accVFVE_accVD
VCD_accVCFVCE_accVCFVCE_accVCD
VSI_accVBI
VI_accVBIVI_accVSI 
VLI_accVBIVLI_accVSIVLI_accVI 
VUS_accVUB
VU_accVUBVU_accVUS 
VUL_accVUBVUL_accVUSVUL_accVU 
VUQ_accVUBVUQ_accVUSVUQ_accVUVUQ_accVUL 
VUI_accVUBVUI_accVUSVUI_accVUVUI_accVULVUI_accVUQ
VQI_accVBIVQI_accVSIVQI_accVIVQI_accVLI 
VQI_accVUBVQI_accVUSVQI_accVUVQI_accVULVQI_accVUI
VF_...VD_...VE_...
        ...accVI        ...accVBI        ...accVSI        ...accVLI        ...accVQI 
        ...accVU        ...accVUB        ...accVUS        ...accVUL        ...accVUQ        ...accVUI
FunktionAkkumulation (entspricht dem Operator += )
Syntax C/C++#include <VFmath.h>
void VF_accV( fVector Y, fVector X, ui size );
void VD_accVF( dVector Y, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::accV( const vector<T>& X );
void vector<double>::accVF( const vector<float>& X );
Pascal/Delphiuses VFmath;
procedure VF_accV( Y, X:fVector; size:UIntSize );
procedure VD_accVF( Y:dVector; X:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFmath.h>
#include <cudaVDmath.h>
int cudaVF_accV( fVector d_Y, fVector d_X, ui size );
int cudaVD_accVF( dVector d_Y, fVector d_X, ui size );
void VFcu_accV( fVector h_Y, fVector h_X, ui size );
void VDcu_accVF( dVector h_Y, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath, VDmath;
function cudaVF_accV( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVD_accVF( d_Y:dVector; d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_accV( h_Y, h_X:fVector; size:UIntSize );
procedure VDcu_accVF( h_Y:dVector; h_X:fVector; size:UIntSize );
BeschreibungYi += Xi
Diese Familie von Funktionen besteht aus zwei Untergruppen. Die erste enthält die "normalen" Versionen, bei denen die beiden addierten Vektoren denselben Datentyp haben, z.B. VF_accV.
Die viel größere zweite Gruppe enthält die Funktionen zur Akkumulation niedrigerer in höheren Datentypen, wie z.B. VD_accVF. Für die Ganzzahl-Typen wird nur der höchste, quad, zur Akkumulation sowohl vorzeichenbehafteter als auch vorzeichenloser niedrigerer Typen verwandt. 32-bit- und 16-bit-Ganzzahltypen können demgegenüber nur niedrigere Typen derselben Kategorie (vorzeichenlos oder -behaftet) akkumulieren.
Alle Ganzzahltypen können in jedem der drei Fließkomma-Typen akkumuliert werden.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_acc2V,   VF_addV,   VF_accV2,   VCF_accVmulVconj

 

VF_accV2VD_accV2VE_accV2
VCF_accV2VCD_accV2VCE_accV2
gemischte Versionen:
VD_accVF2VE_accVF2VE_accVD2
VCD_accVCF2VCE_accVCF2VCE_accVCD2
FunktionAkkumulation von Quadraten
Syntax C/C++#include <VFmath.h>
void VF_accV2( fVector Y, fVector X, ui size );
void VD_accVF2( dVector Y, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::accV2( const vector<T>& X );
void vector<double>::accVF2( const vector<float>& X );
Pascal/Delphiuses VFmath;
procedure VF_accV2( Y, X:fVector; size:UIntSize );
procedure VD_accVF2( Y:dVector; X:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFmath.h>
#include <cudaVDmath.h>
int cudaVF_accV2( fVector d_Y, fVector d_X, ui size );
int cudaVD_accVF2( dVector d_Y, fVector d_X, ui size );
void VFcu_accV2( fVector h_Y, fVector h_X, ui size );
void VDcu_accVF2( dVector h_Y, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath, VDmath;
function cudaVF_accV2( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVD_accVF2( d_Y:dVector; d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_accV2( h_Y, h_X:fVector; size:UIntSize );
procedure VDcu_accVF2( h_Y:dVector; h_X:fVector; size:UIntSize );
BeschreibungYi += Xi2
Die Quadrate aller Elemente von X werden in den korrespondierenden Elementen von Y akkumuliert. Ähnlich wie bei der Familie VF_accV kann auch hier die Akkumulation entweder in einen Vektor derselben oder einen von höherer Genauigkeit erfolgen.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_acc2V,   VF_addV,   VF_accV,   VCF_accVmulVconj

 

VCF_accVmulVconjVCD_accVmulVconjVCE_accVmulVconj
gemischte Versionen:
VCD_accVCFmulVconjVCE_accVCFmulVconjVCE_accVCDmulVconj
FunktionComplexe Vektoren: Akkumulation von Produkten
Syntax C/C++#include <VCFmath.h>
void VCF_accVmulVconj( cfVector Z, cfVector X, cfVector Y, ui size );
void VCD_accVCFmulVconj( cdVector Z, cfVector X, cfVector Y, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::accVmulVconj( const vector<T>& X, const vector<T>& Y );
void vector<double>::accVFmulVconj( const vector<float>& X, const vector<float>& Y );
Pascal/Delphiuses VCFmath;
procedure VCF_accVmulVconj( Z, X, Y:cfVector; size:UIntSize );
procedure VCD_accVCFmulVconj( Z:cdVector; X, Y:cfVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVCFmath.h>
#include <cudaVCDmath.h>
int cudaVCF_accVmulVconj( cfVector d_Z, cfVector d_X, cfVector d_Y, ui size );
int cudaVCD_accVCFmulVconj( cdVector d_Z, cfVector d_X, cfVector d_Y, ui size );
void VCFcu_accVmulVconj( cfVector h_Z, cfVector h_X, cfVector h_Y, ui size );
void VCDcu_accVCFmulVconj( cdVector h_Z, cfVector h_X, cfVector h_Y, ui size );
CUDA-Funktion Pascal/Delphiuses VCFmath, VCDmath;
function cudaVCF_accVmulVconj( d_Z, d_X, d_Y:cfVector; size:UIntSize ): IntBool;
function cudaVCD_accVCFmulVconj( d_Z:cdVector; d_X, d_Y:cfVector; size:UIntSize ): IntBool;
procedure VCFcu_accVmulVconj( h_Z, h_X, h_Y:cfVector; size:UIntSize );
procedure VCDcu_accVCFmulVConj( h_Z:cdVector; h_X, h_Y:cfVector; size:UIntSize );
BeschreibungZi += Xi * Yi*
Die Produkte aller Elemente von X mit der complex-conjugierten Form der entsprechenden Elemente von Y werden in den korrespondierenden Elementen von Z akkumuliert. Ähnlich wie bei der Familie VF_accV kann auch hier die Akkumulation entweder in einen Vektor derselben oder einen von höherer Genauigkeit erfolgen.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_accV2,   VF_accV

 

VF_acc2VVD_acc2VVE_acc2V
gemischte Versionen:
VD_acc2VFVE_acc2VFVE_acc2VD
FunktionAkkumulation (entspricht dem Operator += ) von zwei Vektoren
Syntax C/C++#include <VFmath.h>
void VF_acc2V( fVector Y, fVector X1, fVector X2, ui size );
void VD_accVF( dVector Y, fVector X1, fVector X2, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::acc2V( const vector<T>& X1, const vector<T>& X2 );
void vector<double>::acc2VF( const vector<float>& X1, const vector<float>& X2 );
Pascal/Delphiuses VFmath;
procedure VF_acc2V( Y, X1, X2:fVector; size:UIntSize );
procedure VD_acc2VF( Y:dVector; X1, X2:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFmath.h>
#include <cudaVDmath.h>
int cudaVF_acc2V( fVector d_Y, fVector d_X1, fVector d_X2, ui size );
int cudaVD_acc2VF( dVector d_Y, fVector d_X1, fVector d_X2, ui size );
void VFcu_acc2V( fVector h_Y, fVector h_X1, fVector h_X2, ui size );
void VDcu_acc2VF( dVector h_Y, fVector h_X1, fVector h_X2, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath, VDmath;
function cudaVF_acc2V( d_Y, d_X1, d_X2:fVector; size:UIntSize ): IntBool;
function cudaVD_acc2VF( d_Y:dVector; d_X1, d_X2:fVector; size:UIntSize ): IntBool;
procedure VFcu_acc2V( h_Y, h_X1, h_X2:fVector; size:UIntSize );
procedure VDcu_acc2VF( h_Y:dVector; h_X1, h_X2:fVector; size:UIntSize );
BeschreibungYi += X1i + X2i
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_accV,   VF_add2V

 

VF_acosVD_acosVE_acos
VCF_acosVCD_acosVCE_acos
VFx_acosVDx_acosVEx_acos
VCFx_acosVCDx_acosVCEx_acos
Funktionarcus cosinus-Funktion
Syntax C/C++#include <VFmath.h>
int VF_acos( fVector Y, fVector X, ui size );
int VFx_acos( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::acos( const vector<T>& X );
int vector<T>::x_acos( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_acos( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_acos( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_acos( fVector d_Y, fVector d_X, ui size );
int cudaVFx_acos( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_acos( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_acos( fVector h_Y, fVector h_X, ui size );
int VFxcu_acos( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_acos( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_acos( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_acos( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_acos( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_acos( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = arccos ( Xi )
erweiterte Versionen: Yi = C * arccos (A*Xi + B )
FehlerbehandlungReelle Versionen: DOMAIN-Fehler entstehen durch Argumente außerhalb des Bereiches −1 < Xi < 1 und ergeben NAN ("not-a-number").
Komplexe Versionen: Solange der Parameter C in den erweiterten Formen nicht schon nahe an der Überlauf-Grenze ist, dürften keine Fehler auftreten.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_cos,   VF_asin,   VF_atan,   acos

 

VF_addCVD_addCVE_addC
VCF_addCVCD_addCVCE_addC
VCF_addReCVCD_addReCVCE_addReC
VI_addCVBI_addCVSI_addCVLI_addCVQI_addC 
VU_addCVUB_addCVUS_addCVUL_addCVUQ_addCVUI_addC
FunktionKonstante zu allen Vektor-Elementen addieren
Syntax C/C++#include <VFmath.h>
void VF_addC( fVector Y, fVector X, ui size, float C);

    (analog VD_,   VI_, etc.)
void VCF_addC( cfVector Y, cfVector X, ui size, fComplex C );
void VCF_addReC( cfVector Y, cfVector X, ui size, float CRe );

    (analog VCD_,   VCE_)
C++ VecObj#include <OptiVec.h>
void vector<T>::addC( const vector<T>& X, const T& C); );
void vector<complex<T>>::addC( const vector<complex<T>>& X, complex<T> C );
void vector<complex<T>>::addReC( const vector<complex<T>>& X, const T& CRe );
Pascal/Delphiuses VFmath;
procedure VF_addC( Y, X:fVector; size:UIntSize; C:Single );

    (analog VD_,   VI_, etc.)
procedure VCF_addC( Y, X:cfVector; size:UIntSize; C:fComplex );
procedure VCF_addReC( Y, X:cfVector; size:UIntSize; CRe:Single );

    (analog VCD_,   VCE_)
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_addC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_addC( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_addC( fVector d_Y, fVector d_X, ui size, float C );
#include <cudaVCFmath.h>
int cudaVCF_addReC( cfVector d_Y, cfVector d_X, ui size, float CRe );
int cusdVCF_addReC( cfVector d_Y, cfVector d_X, ui size, float *d_CRe );
void VCFcu_addReC( cfVector h_Y, cfVector h_X, ui size, float CRe );
CUDA-Funktion Pascal/Delphiuses VFmath, VCFmath;
function cudaVF_addC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_addC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VFcu_addC( h_Y, h_X:fVector; size:UIntSize; C:Single );
function cudaVCF_addReC( d_Y, d_X:cfVector; size:UIntSize; CRe:Single );
function cusdVCF_addReC( d_Y, d_X:cfVector; size:UIntSize; d_CRe:PSingle );
procedure VCFcu_addReC( h_Y, h_X:cfVector; size:UIntSize; CRe:Single );
BeschreibungYi = Xi + C
Die komplexen Versionen existieren in zwei Varianten: eine für komplexe Konstanten C, die andere für reelle Konstanten CRe.
FehlerbehandlungFließkomma-Versionen: keine;
Ganzzahl-Versionen: siehe Kap. 5.2.
Rückgabewertkeiner
QuerverweisVF_addV,   VF_subC,   VF_mulC,   VF_divC,   VF_visC,   VF_redC

 

VF_addVVD_addVVE_addV
VCF_addVVCD_addVVCE_addV
VCF_addReVVCD_addReVVCE_addReV
VFs_addVVDs_addVVEs_addV
VFx_addVVDx_addVVEx_addV
VCFx_addVVCDx_addVVCEx_addV
VCFx_addReVVCDx_addReVVCEx_addReV
VI_addVVBI_addVVSI_addVVLI_addVVQI_addV 
VU_addVVUB_addVVUS_addVVUL_addVVUQ_addVVUI_addV
Funktionzwei Vektoren addieren
Syntax C/C++#include <VFmath.h>
void VF_addV( fVector Z, fVector X, fVector Y,ui size );
void VFs_addV( fVector Z, fVector X, fVector Y, ui size, float C );
void VFx_addV( fVector Z, fVector X, fVector Y, ui size, float A, float B );

    (analog VD_,   VDx_,   VE_,   VEx_,   VI_, etc.)
void VCF_addV( cfVector Z, cfVector X, cfVector Y, ui size );
void VCF_addReV( cfVector Z, cfVector X, fVector Y, ui size );
void VCFx_addV( cfVector Z, cfVector X, cfVector Y, ui size, fComplex A, fComplex B );
void VCFx_addReV( cfVector Z, cfVector X, fVector Y, ui size, fComplex A, fComplex B );

    (analog VCD_,   VCDx_,   VCE_,   VCEx_)
C++ VecObj#include <OptiVec.h>
void vector<T>::addV( const vector<T>& X, const vector<T>& Y );
void vector<T>::s_addV( const vector<T>& X, const vector<T>& Y, const T& C );
void vector<T>::x_addV( const vector<T>& X, const vector<T>& Y, const T& A, const T& B );
void vector<complex<T>>::addV( const vector<complex<T>>& X, const vector<complex<T>>& Y );
void vector<complex<T>>::addReV( const vector<complex<T>>& X, const vector<T>& Y );
void vector<complex<T>>::x_addV( const vector<complex<T>>& X, const vector<complex<T>>& Y, complex<T> A, complex<T> B );
void vector<complex<T>>::x_addReV( const vector<complex<T>>& X, const vector<T>& Y, complex<T> A, complex<T> B );
Pascal/Delphiuses VFmath;
procedure VF_addV( Z, X, Y:fVector; size:UIntSize );
procedure VFx_addV( Z, X, Y:fVector; size:UIntSize; A, B:Single );

    (analog VD_,   VDx_,   VE_,   VEx_,   VI_, etc.)
procedure VCF_addV( Z, X, Y:cfVector; size:UIntSize );
procedure VCF_addReV( Z, X:cfVector; Y:fVector; size:UIntSize );
procedure VCFx_addV( Z, X, Y:cfVector; size:UIntSize; A, B:fComplex );
procedure VCFx_addReV( Z, X:cfVector; Y:fVector; size:UIntSize; A, B:fComplex );

    (analog VCD_, VCDx_, VCE_,   VCEx_)
CUDA-Funktion C/C++#include <cudaVFmath.h>
#include <cudaVCFmath.h>
int cudaVF_addV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
int cudaVFs_addV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float C );
int cusdVFs_addV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_C );
int cudaVFx_addV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float A, float B );
int cusdVFx_addV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_A, float *d_B );
int cudaVCF_addReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size );
int cudaVCFx_addReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size, fComplex A, fComplex B );
int cusdVCFx_addReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size, fComplex *d_A, fComplex *d_B );
void VFcu_addV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
void VFscu_addV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float C );
void VFxcu_addV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float A, float B );
void VCFcu_addReV( cfVector h_Z, cfVector h_X, fVector h_Y, ui size );
void VCFxcu_addV( cfVector h_Z, cfVector h_X, cfVector h_Y, ui size, fComplex A, fComplex B );
void VCFxcu_addReV( cfVector h_Z, cfVector h_X, fVector h_Y, ui size, fComplex A, fComplex B );
CUDA-Funktion Pascal/Delphiuses VFmath, VCFmath;
function cudaVF_addV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cudaVFs_addV( d_Z, d_X, d_Y:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVFs_addV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function cudaVFx_addV( d_Z, d_X, d_Y:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_addV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function cudaVCF_addReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize ): IntBool;
function cudaVCFx_addReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize; A, B:fComplex ): IntBool;
function cusdVCFx_addReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize; d_A, d_B:PfComplex ): IntBool;
procedure VFcu_addV( h_Z, h_X, h_Y:fVector; size:UIntSize );
procedure VFscu_addV( h_Z, h_X, h_Y:fVector; size:UIntSize; C:Single );
procedure VFxcu_addV( h_Z, h_X, h_Y:fVector; size:UIntSize; A, B:Single );
procedure VCFcu_addReV( h_Z, h_X:cfVector; h_Y:fVector; size:UIntSize );
procedure VCFxcu_addReV( h_Z, h_X:cfVector; h_Y:fVector; size:UIntSize; A, B:fComplex );
Beschreibungeinfache 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_addV,   VCFx_addV) sind X, Y und Z komplex; bei der zweiten ist Y reell (z.B. VCF_addReV - "reellen Vektor addieren").
FehlerbehandlungFließkomma-Versionen: keine;
Ganzzahl-Versionen: siehe Kap. 5.2.
Rückgabewertkeiner
QuerverweisVF_addC,   VF_add2V,   VF_subV,   VF_mulV,   VF_divV,   VF_accV,   VF_addVI

 

VF_addVIVD_addVIVE_addVI
VF_addVBIVD_addVBIVE_addVBI
VF_addVSIVD_addVSIVE_addVSI
VF_addVLIVD_addVLIVE_addVLI
VF_addVQIVD_addVQIVE_addVQI
VF_addVUVD_addVUVE_addVU
VF_addVUBVD_addVUBVE_addVUB
VF_addVUSVD_addVUSVE_addVUS
VF_addVULVD_addVULVE_addVUL
VF_addVUQVD_addVUQVE_addVUQ
VF_addVUIVD_addVUIVE_addVUI
FunktionGanzzahlvektor zu Fließkomma-Vektor addieren
Syntax C/C++#include <VFmath.h>
void VF_addVI( fVector Z, fVector X, iVector Y,ui size );
void VF_addVUB( fVector Z, fVector X, ubVector Y, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::addVI( const vector<T>& X, const vector<int>& Y );
void vector<T>::addVUS( const vector<T>& X, const vector<unsigned short>& Y, );
Pascal/Delphiuses VFmath;
procedure VF_addVI( Z, X:fVector; Y:iVector; size:UIntSize );
procedure VF_addVUL( Z, X:fVector; Y:ulVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_addVI( fVector d_Z, fVector d_X, iVector d_Y,ui size );
int cudaVF_addVUB( fVector d_Z, fVector d_X, ubVector d_Y, ui size );
void VFcu_addVI( fVector h_Z, fVector h_X, iVector h_Y,ui size );
void VFcu_addVUB( fVector h_Z, fVector h_X, ubVector h_Y, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_addVI( d_Z, d_X:fVector; d_Y:iVector; size:UIntSize ): IntBool;
function cudaVF_addVUL( d_Z, d_X:fVector; d_Y:ulVector; size:UIntSize ): IntBool;
procedure VFcu_addVI( h_Z, h_X:fVector; h_Y:iVector; size:UIntSize );
procedure VFcu_addVUL( h_Z, h_X:fVector; h_Y:ulVector; size:UIntSize );
BeschreibungZi = Xi + Yi
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_addV,   VF_accV

 

VF_add2VVD_add2VVE_add2V
Funktiondrei Vektoren addieren
Syntax C/C++#include <VFmath.h>
void VF_add2V( fVector Z, fVector X, fVector Y1, fVector Y2, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::add2V( const vector<T>& X, const vector<T>& Y1, const vector<T>& Y2 );
Pascal/Delphiuses VFmath;
procedure VF_add2V( Z, X, Y1, Y2:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_add2V( fVector d_Z, fVector d_X, fVector d_Y1, fVector d_Y2, ui size );
void VFcu_add2V( fVector h_Z, fVector h_X, fVector h_Y1, fVector h_Y2, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_add2V( d_Z, d_X, d_Y1, d_Y2:fVector; size:UIntSize ): IntBool;
procedure VFcu_add2V( h_Z, h_X, h_Y1, h_Y2:fVector; size:UIntSize );
BeschreibungZi = Xi + Y1i + Y2i
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_addV,   VF_sub2V

 

VI_andVBI_andVSI_andVLI_andVQI_and 
VU_andVUB_andVUS_andVUL_andVUQ_andVUI_and
FunktionBit-weise "AND"-Operation
Syntax C/C++#include <VImath.h>
void VI_and( iVector Y, iVector X, ui size, int C );

    (analog alle übrigen Funktionen dieser Familie)
C++ VecObj#include <OptiVec.h>
void vector<T>::and( const vector<T>& X, const T& C );
Pascal/Delphiuses VImath;
procedure VI_and( Y, X:iVector; size:UIntSize; C:Integer );

    (analog alle übrigen Funktionen dieser Familie)
CUDA-Funktion C/C++#include <cudaVImath.h>
int cudaVI_and( iVector d_Y, iVector d_X, ui size, int C );
int cusdVI_and( iVector d_Y, iVector d_X, ui size, int *d_C );
void VIcu_and( iVector h_Y, iVector h_X, ui size, int C );
CUDA-Funktion Pascal/Delphiuses VImath;
function cudaVI_and( d_Y, d_X:iVector; size:UIntSize; C:Integer ): IntBool;
function cusdVI_and( d_Y, d_X:iVector; size:UIntSize; d_C:PInteger ): IntBool;
procedure VIcu_and( h_Y, h_X:iVector; size:UIntSize; C:Integer );
BeschreibungYi = (Xi) & C
Die bit-weise AND-Operation mit der in C definierten Bit-Maske wird auf alle Elemente i angewandt. Ein Bit von Yi wird gleich 1 gesetzt, wenn das entsprechende Bit sowohl in Xi als auch in C gleich 1 ist; andernfalls wird es gleich 0 gesetzt. Die vielleicht sinnvollste Anwendung der Funktionen dieser Familie ist die schnelle "modulo"-Operation vorzeichenloser oder positiver Zahlen mit einer ganzzahligen Potenz von 2 als Divisor. Beispielsweise wird eine modulo-Division durch 64 ausgeführt durch:
VU_and( Y, X, size, 64−1 );
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVI_not,   VI_or,   VI_xor

 

VCF_argVCD_argVCE_arg
VPF_argVPD_argVPE_arg
FunktionArgument (Zeigerwinkel in der komplexen Ebene).
Syntax C/C++#include <VCFstd.h>
void VCF_arg( fVector Arg, cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::arg( const vector<complex<T>>& X );
Pascal/Delphiuses VCFstd;
procedure VCF_arg( Arg:fVector; X:cfVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVCF_arg( fVector d_Arg, cfVector d_X, ui size );
void VCFcu_arg( fVector h_Arg, cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVCF_arg( d_Arg:fVector; d_X:cfVector; size:UIntSize ): IntBool;
procedure VCFcu_arg( h_Arg:fVector; h_X:cfVector; size:UIntSize );
BeschreibungIdentisch mit VF_CtoArg,   VD_CtoArg bzw. VE_CtoArg. Siehe dort.

 

VF_ArgtoPVD_ArgtoPVE_ArgtoP
FunktionArg-Teil eines polar-komplexen Vektors mit einem reellen Vektor überschreiben
Syntax C/C++#include <VPFstd.h>
void VF_ArgtoP( pfVector Y, fVector Arg, ui size );
C++ VecObj#include <OptiVec.h>
void vector<polar<T>>::ArgtoP( const vector<T>& Arg );
Pascal/Delphiuses VPFstd;
procedure VF_ArgtoP( X:pfVector; Arg:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVPFstd.h>
int cudaVF_ArgtoP( pfVector d_Y, fVector d_Arg, ui size );
void VFcu_ArgtoP( pfVector h_Y, fVector h_Arg, ui size );
CUDA-Funktion Pascal/Delphiuses VPFstd;
function cudaVF_ArgtoP( d_X:pfVector; d_Arg:fVector; size:UIntSize ): IntBool;
procedure VFcu_ArgtoP( h_X:pfVector; h_Arg:fVector; size:UIntSize );
BeschreibungDer Arg-Teil des polar-komplexen Vektors Y wird mit den Elementen des reellen Vectors Arg überschrieben. Dabei bleibt der Mag-Teil von Y unangetastet.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_PtoMagArg,   VF_MagArgtoP

 

VF_asinVD_asinVE_asin
VCF_asinVCD_asinVCE_asin
VFx_asinVDx_asinVEx_asin
VCFx_asinVCDx_asinVCEx_asin
Funktionarcus sinus-Funktion
Syntax C/C++#include <VFmath.h>
int VF_asin( fVector Y, fVector X, ui size );
int VFx_asin( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::asin( const vector<T>& X );
int vector<T>::x_asin( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_asin( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_asin( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_asin( fVector d_Y, fVector d_X, ui size );
int cudaVFx_asin( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_asin( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_asin( fVector h_Y, fVector h_X, ui size );
int VFxcu_asin( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_asin( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_asin( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_asin( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_asin( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_asin( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = arcsin ( Xi )
erweiterte Versionen: Yi = C * arcsin (A*Xi + B )
FehlerbehandlungReelle Versionen: DOMAIN-Fehler entstehen für Argumente außerhalb des Bereiches −1 < Xi < 1 und ergeben NAN ("not-a-number").
Komplexe Versionen: Solange der Parameter C in den erweiterten Formen nicht schon nahe am Überlauf ist, dürften keine Fehler auftreten.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_sin,   VF_acos,   VF_atan,   asin

 

VF_atanVD_atanVE_atan
VCF_atanVCD_atanVCE_atan
VFx_atanVDx_atanVEx_atan
VCFx_atanVCDx_atanVCEx_atan
Funktionarcus tangens-Funktion
Syntax C/C++#include <VFmath.h>
int VF_atan( fVector Y, fVector X, ui size );
int VFx_atan( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::atan( const vector<T>& X );
int vector<T>::x_atan( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_atan( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_atan( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_atan( fVector d_Y, fVector d_X, ui size );
int cudaVFx_atan( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_atan( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_atan( fVector h_Y, fVector h_X, ui size );
int VFxcu_atan( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_atan( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_atan( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_atan( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_atan( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_atan( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = arctan ( Xi )
erweiterte Versionen: Yi = C * arctan (A*Xi + B )
FehlerbehandlungReelle Versionen: Solange der Parameter C in den erweiterten Formen nicht schon nahe am Überlauf ist, dürften keine Fehler auftreten.
Komplexe Versionen: Für ein Argument {0, −1} wird das Ergebnis stillschweigend auf {0, -p} gesetzt. Es folgt kein Programm-Abbruch wie bei der komplexen atan-Funktion von Borland C++.
Rückgabewertimmer FALSE(0).
QuerverweisVF_tan,   VF_asin,   VF_acos,   VF_atan2,   atan,   atan2

 

VF_atan2VD_atan2VE_atan2
VFx_atan2VDx_atan2VEx_atan2
Funktionarcus tangens-Funktion von als Quotienten angegebenen Argumenten
Syntax C/C++#include <VFmath.h>
int VF_atan2( fVector Z, fVector X, fVector Y, ui size );
int VFx_atan2( fVector Z, fVector X, fVector Y, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::atan2( const vector<T>& X, const vector<T>& Y );
int vector<T>::x_atan2( const vector<T>& X, const vector<T>& Y, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_atan2( Z, X, Y:fVector; size:UIntSize ): IntBool;
function VFx_atan2( Z, X, Y:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_atan2( fVector d_Z, fVector d_X, fVector d_Y, ui size );
int cudaVFx_atan2( fVector d_Z, fVector d_X, fVector d_Y, ui size, float A, float B, float C );
int cusdVFx_atan2( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_atan2( fVector h_Z, fVector h_X, fVector h_Y, ui size );
int VFxcu_atan2( fVector h_Z, fVector h_X, fVector h_Y, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_atan2( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cudaVFx_atan2( d_Z, d_X, d_Y:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_atan2( d_Z, d_X, d_Y:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_atan2( h_Z, h_X, h_Y:fVector; size:UIntSize ): IntBool;
function VFxcu_atan2( h_Z, h_X, h_Y:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Zi = arctan( Yi / Xi )
erweiterte Versionen: Zi = C * arctan( Yi / (A*Xi+B) )
Aus cartesischen X-Y-Koordinaten wird der Winkel der entsprechenden Polar-Koordinaten berechnet.
Vorsicht: bei der Funktion atan2 von ANSI−C werden X und Y in umgekehrter Reihenfolge angegeben!
FehlerbehandlungSind Xi und Yi beide 0, entsteht ein DOMAIN-Fehler mit dem vorgeschlagenen Resultat NAN ("not-a-number").
In C/C++; werden Xi und Yi für die Behandlung über _matherr und _matherrl als e->x und e->y übergeben.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_tan,   VF_asin,   VF_acos,   VF_atan,  atan,  atan2

 

VF_autocorrVD_autocorrVE_autocorr
VFb_autocorrVDb_autocorrVEb_autocorr
FunktionAutokorrelationsfunktion
Syntax C/C++#include <VFstd.h>
void VF_autocorr( fVector Y, fVector X, ui size );
void VFb_autocorr( fVector Y, fVector X, ui size, fVector Buf );
C++ VecObj#include <OptiVec.h>
void vector<float>::autocorr( const vector<float>& X );
void vector<float>::b_autocorr( const vector<float>& X, vector<float>& Buf );
Pascal/Delphiuses VFstd;
procedure VF_autocorr( Y, X:fVector; size:UIntSize );
procedure VFb_autocorr( Y, X:fVector; size:UIntSize; Buf:fVector );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_autocorr( fVector d_Y, fVector d_X, ui size );
void VFcu_autocorr( fVector h_Y, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_autocorr( d_Y, d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_autocorr( h_Y, h_X:fVector; size:UIntSize );
BeschreibungDie Autokorrelationsfunktion (AKF) von X wird berechnet und in Y gespeichert. Dabei erhalten die Elemente Y0 bis Ysize/2−1 die AKF für 0 und für positive Verschiebungen; für negative Verschiebungen wird die AKF beginnend mit der am stärksten negativen Verschiebung in Ysize/2+1 bis Ysize−1 gespeichert. Da diese Funktion (wie alle auf der Fourier-Transformation basierenden Routinen) implizit von periodischen X, Y und Z ausgeht, ist die AKF für die stärkste positive Verschiebung identisch mit der AKF für die stärkste negative Verschiebung. Dieser Wert befindet sich im Element Ysize/2.
Um die AKF in normale Ordnung zu bringen, kann
VF_rotate( Y, Y, 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_autocorr zusätzlichen Pufferspeicher, der automatisch reserviert und wieder freigegeben wird. Bei wiederholten Aufrufen wäre dies ineffizient. Es wird empfohlen, für solche Fälle stattdessen VFb_autocorr zu verwenden. Die Größe von Buf muss dabei ≥ 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.

FehlerbehandlungWenn size nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf VF_autocorr basiert) mit der Fehlermeldung "Size must be integer power of 2." und bricht das Programm ab.
Rückgabewertkeiner
QuerverweisVF_FFT,   VF_convolve,   VF_xcorr,   VF_spectrum

 

VCF_autoPlotVCD_autoPlotVCE_autoPlot
FunktionAutomatische Auftragung eines cartesisch-komplexen Vektors in die komplexe Ebene
Syntax C/C++#include <Vgraph.h>
void VCF_autoPlot( cfVector X, ui size, unsigned form, COLORREF color );
C++ VecObj#include <OptiVec.h>
void vector<complex<T>>::autoPlot( unsigned form, COLORREF color );
Pascal/Delphiuses Vgraph;
procedure VCF_autoPlot( X:cfVector; size:UIntSize; form:UInt; color:COLORREF );
BeschreibungEin cartesisches Koordinatensystem wird mit automatischer Achsenskalierung erzeugt und der komplexe Vektor X darin dargestellt.
Die Parameter form und color werden bei VF_xyAutoPlot beschrieben. Bevor VCF_autoPlot aufgerufen werden kann, müssen die Plot-Routinen durch Aufruf von V_initPlot initialisiert werden.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVCF_2AutoPlot,   VCF_dataPlot,   VF_xyAutoPlot,  Kap. 4.12

 

VCF_2AutoPlotVCD_2AutoPlotVCE_2AutoPlot
FunktionAutomatische Auftragung zweier Vektoren in der komplexen Ebene
Syntax C/C++#include <Vgraph.h>
void VCF_2AutoPlot( cfVector X1, ui size1, unsigned form1, COLORREF color1, cfVector X2, ui size2, unsigned form2, COLORREF color2 );
C++ VecObj#include <OptiVec.h>
void vector<complex<T>>::_2AutoPlot( unsigned form1, COLORREF color1, const vector<complex<T>>& X2, unsigned form2, COLORREF color2 );
Pascal/Delphiuses Vgraph;
procedure VCF_2AutoPlot( X1:cfVector; size1:UIntSize; form1:UInt; color1:COLORREF; X2:cfVector; size2:UIntSize; form2:UInt; color2:COLORREF );
BeschreibungEin cartesisches Koordinatensystem wird erzeugt mit automatischer Skalierung der Achsen. Darin werden beide komplexe Vektoren gleichzeitig dargestellt. Bezüglich der Parameter form1, form2, color1 und color2 vergleiche man VF_xyAutoPlot. Bevor VCF_2AutoPlot aufgerufen werden kann, müssen die Plot-Routinen durch Aufruf von V_initPlot initialisiert werden.
Man beachte den Unterstrich im VecObj-Funktionsnamen. (Er ist erforderlich, da in C/C++ Funktionsnamen nicht mit einer Ziffer beginnen dürfen.)
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVCF_autoPlot,   VCF_dataPlot,   VF_xyAutoPlot,  Kap. 4.11

 

VF_avdevCVD_avdevCVE_avdevC
FunktionMittlere Abweichung (engl.: average deviation) von einem Soll-Wert
Syntax C/C++#include <VFstd.h>
float VF_avdevC( fVector X, ui size, float C );
C++ VecObj#include <OptiVec.h>
T vector<T>::avdevC( const T& C );
Pascal/Delphiuses VFstd;
function VF_avdevC( X:fVector; size:UIntSize; C:Single ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_avdevC( float *h_RetVal, fVector d_X, ui size, float C );
int cusdVF_avdevC( float *d_RetVal, fVector d_X, ui size, float *d_C );
float VFcu_avdevC( fVector X, ui size, float C );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_avdevC( var h_RetVal:Single; d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_avdevC( d_RetVal:PSingle; d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function VFcu_avdevC( h_X:fVector; size:UIntSize; C:Single ): Single;
BeschreibungavdevC = 1/size * Summe( |Xi - C| )
Der Mittelwert des Abweichungsbetrages jedes X-Elementes von der Konstanten C wird berechnet und zurückgegeben.
Fehlerbehandlungkeine
Rückgabewertmittlere Abweichung
QuerverweisVF_ssq,   VF_ssqdevC,   VF_avdevV,   VF_sumdevC,   VF_chiabs

 

VF_avdevVVD_avdevVVE_avdevV
FunktionMittlere Abweichung (engl.: average deviation) der Elemente eines Vektors von denen eines anderen
Syntax C/C++#include <VFstd.h>
float VF_avdevV( fVector X, fVector Y, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::avdevV( const vector<T>& Y );
Pascal/Delphiuses VFstd;
function VF_avdevV( X, Y:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_avdevV( float *h_RetVal, fVector X, fVector Y, ui size );
int cusdVF_avdevV( float *d_RetVal, fVector X, fVector Y, ui size );
float VFcu_avdevV( fVector h_X, fVector h_Y, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_avdevV( var h_RetVal:Single; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cusdVF_avdevV( d_RetVal:PSingle; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function VFcu_avdevC( h_X, h_Y:fVector; size:UIntSize ): Single;
BeschreibungavdevV = 1/size * Summe( |Xi - Yi| )
Der Mittelwert des Abweichungsbetrages jedes X-Elementes vom entsprechenden Y-Element wird berechnet und zurückgegeben.
Fehlerbehandlungkeine
Rückgabewertmittlere Abweichung
QuerverweisVF_ssq,   VF_ssqdevV,   VF_avdevC,   VF_sumdevV,   VF_chiabs

 

VF_biquadVD_biquadVE_biquad
FunktionBiquadratische Filterung
Syntax C/C++#include <VFstd.h>
void VF_biquad( fVector Y, fVector X, ui size, fVector Param );
C++ VecObj#include <OptiVec.h>
void vector<T>::biquad( const vector<T>& X, const vector<T>& Param, );
Pascal/Delphiuses VFstd;
procedure VF_biquad( Y,X:fVector; size:UIntSize; Param:fVector );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_biquad( fVector d_Y, fVector d_X, ui size, fVector h_Param );
int cusdVF_biquad( fVector d_Y, fVector d_X, ui size, fVector d_Param );
float VFcu_biquad( fVector h_Y, fVector h_X, ui size, fVector h_Param );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_biquad( d_Y, d_X:fVector; size:UIntSize; h_Param:fVector ): IntBool;
function cusdVF_biquad( d_Y, d_X:fVector; size:UIntSize; d_Param:fVector ): IntBool;
procedure VFcu_biquad( h_Y, h_X:fVector; size:UIntSize; h_Param:fVector );
BeschreibungDie insbesondere zur Bearbeitung von Audio-Daten verwendete biquadratische Filterung berechnet Ausgangswerte Y aus den Eingangswerten X nach der Formel:
Y[i] = a0*X[i] + a1*X[i−1] + a2*X[i-2] - b1*Y[i−1] - b2*Y[i-2]
Da es sich hierbei um einen rekursiven Filter handelt, müssen außer den eigentlichen Filter-Koeffizienten auch die jeweils zwei Ein- und Ausgangswerte vor Beginn des eigentlichen Eingabevektors als Parameter übergeben werden. Hierbei soll der an die Funktion übergebene Vektor Param die folgenden neun Werte enthalten:
Param[0]=a0 Param[1]=a1 Param[2]=a2 Param[3]=b1 Param[4]=b2 Param[5]=X[−1] Param[6]=X[-2] Param[7]=Y[−1] Param[8]=Y[-2]
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_filter,   VF_smooth

 

VCF_cabsmaxVCD_cabsmaxVCE_cabsmax
FunktionBetragsmäßig größtes Element eines komplexen Vektors
Syntax C/C++#include <VCFstd.h>
fComplex VCF_cabsmax( cfVector X, ui size);
C++ VecObj#include <OptiVec.h>
T vector<complex<T>>::cabsmax();
Pascal/Delphiuses VCFstd;
function VCF_cabsmax( X:cfVector; size:UIntSize ):fComplex;

Alternative Syntax (veraltet, aber weiterhin unterstützt):
procedure VCF_cabsmax( var RetVal:fComplex; X:cfVector; size:UIntSize );

    (analog VCD_,   VCE_)
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVCF_cabsmax( fComplex *h_RetVal, cfVector d_X, ui size );
int cusdVCF_cabsmax( fComplex *d_RetVal, cfVector d_X, ui size );
fComplex VCFcu_cabsmax( cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVCF_cabsmax( var h_RetVal:fComplex; d_X:cfVector; size:UIntSize ): IntBool;
function cusdVCF_cabsmax( d_RetVal:PfComplex; d_X:cfVector; size:UIntSize ): IntBool;
function VCFcu_cabsmax( h_X:cfVector; size:UIntSize ):fComplex;
BeschreibungDie in bezug auf ihren Absolutwert größte innerhalb eines komplexen Vektors vorkommende Zahl wird gefunden und zurückgegeben. Eine ähnliche Funktion, die die in bezug auf die Summe |Re| + |Im| größte Zahl findet, ist VCF_sabsmax. Die letztere Funktion ist wesentlich schneller als VCF_cabsmax.
Fehlerbehandlungkeine
Rückgabewertbetragsmäßig größtes Vektorelement
QuerverweisVCF_absmax,   VCF_absmaxReIm,   VCF_sabsmax

 

VCF_cabsminVCD_cabsminVCE_cabsmin
FunktionBetragsmäßig kleinstes Element eines komplexen Vektors
Syntax C/C++#include <VCFstd.h>
fComplex VCF_cabsmin( cfVector X, ui size);
C++ VecObj#include <OptiVec.h>
T vector<complex<T>>::cabsmin();
Pascal/Delphiuses VCFstd;
function VCF_cabsmin( X:cfVector; size:UIntSize ):fComplex;

Alternative Syntax (veraltet, aber weiterhin unterstützt):
procedure VCF_cabsmin( var Max:fComplex; X:cfVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVCF_cabsmin( fComplex *h_RetVal, cfVector d_X, ui size );
int cusdVCF_cabsmin( fComplex *d_RetVal, cfVector d_X, ui size );
fComplex VCFcu_cabsmin( cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVCF_cabsmin( var h_RetVal:fComplex; d_X:cfVector; size:UIntSize ): IntBool;
function cusdVCF_cabsmin( d_RetVal:PfComplex; d_X:cfVector; size:UIntSize ): IntBool;
function VCFcu_cabsmin( h_X:cfVector; size:UIntSize ):fComplex;
BeschreibungDie in bezug auf ihren Absolutwert kleinste innerhalb eines komplexen Vektors vorkommende Zahl wird gefunden und zurückgegeben. Eine ähnliche Funktion, die die in bezug auf die Summe |Re| + |Im| kleinste Zahl findet, ist VCF_sabsmin. Die letztere Funktion ist wesentlich schneller als VCF_cabsmin.
Fehlerbehandlungkeine
Rückgabewertbetragsmäßig kleinstes Vektorelement
QuerverweisVCF_absmin,   VCF_absminReIm,   VCF_sabsmin

 

V_CDtoCFV_CDtoCE
V_CEtoCFV_CEtoCD
V_CFtoCDV_CFtoCE
FunktionDatentyp-Umwandlungen. Siehe V_FtoD.

 

VF_ceilVD_ceilVE_ceil
VF_ceiltoIVD_ceiltoIVE_ceiltoI
VF_ceiltoBIVD_ceiltoBIVE_ceiltoBI
VF_ceiltoSIVD_ceiltoSIVE_ceiltoSI
VF_ceiltoLIVD_ceiltoLIVE_ceiltoLI
VF_ceiltoQIVD_ceiltoQIVE_ceiltoQI
VF_ceiltoUVD_ceiltoUVE_ceiltoU
VF_ceiltoUBVD_ceiltoUBVE_ceiltoUB
VF_ceiltoUSVD_ceiltoUSVE_ceiltoUS
VF_ceiltoULVD_ceiltoULVE_ceiltoUL
VF_ceiltoUQVD_ceiltoUQVE_ceiltoUQ
VF_ceiltoUIVD_ceiltoUIVE_ceiltoUI
FunktionAufrunden
Syntax C/C++#include <VFmath.h>
int VF_ceil( fVector Y, fVector X, ui size );
int VF_ceiltoI( iVector Y, fVector X, ui size );
int VF_ceiltoLI( liVector Y, fVector X, ui size );

    (analog alle übrigen Funktionen dieser Familie)
C++ VecObj#include <OptiVec.h>
int vector<T>::ceil( const vector<T>& X );
int vector<int>::ceiltoI( const vector<T>& X );
int vector<long>::ceiltoLI( const vector<T>& X );
Pascal/Delphiuses VFmath;
function VF_ceil( Y, X:fVector; size:UIntSize ):IntBool;
function VF_ceiltoI( Y:iVector; X:fVector; size:UIntSize ): IntBool;
function VF_ceiltoLI( Y:liVector; X:fVector; size:UIntSize ): IntBool;

    (analog alle übrigen Funktionen dieser Familie)
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_ceil( fVector d_Y, fVector d_X, ui size );
int cudaVF_ceiltoI( iVector d_Y, fVector d_X, ui size );
int VFcu_ceil( fVector h_Y, fVector h_X, ui size );
int VFcu_ceiltoI( iVector h_Y, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_ceil( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVF_ceiltoI( d_Y:iVector; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_ceil( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFcu_ceiltoI( h_Y:iVector; h_X:fVector; size:UIntSize ): IntBool;
BeschreibungJedes Element von X wird auf die nächste größere oder gleiche ganze Zahl gerundet und das Ergebnis in Y gespeichert. Hierbei wandeln die Funktionen VF_ceiltoI,   VF_ceiltoLI,   VF_ceiltoU etc. das Ergebnis in die verschiedenen Ganzzahl-Typen um.
FehlerbehandlungOVERFLOW-Fehler werden behandelt, indem das Resultat gleich dem größten (bzw. am stärksten negativen) Wert gesetzt wird, der in dem jeweiligen Ziel-Datentyp möglich ist. DOMAIN-Fehler entstehen durch negative Zahlen in den Funktionen VF_ceiltoU,   VD_ceiltoUS etc.; sie führen zum Resultat 0.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_round,   VF_floor,   VF_chop,   VF_trunc,   ceil,   floor (nur C/C++)

 

VF_centerOfGravityIndVD_centerOfGravityIndVE_centerOfGravityInd
FunktionSchwerpunkt eines Vektors bezüglich seiner Indizes
Syntax C/C++#include <VFstd.h>
float VF_centerOfGravityInd( fVector X, ui siz );
C++ VecObj#include <OptiVec.h>
T vector<T>::centerOfGravityInd();
Pascal/Delphiuses VFstd;
function VF_centerOfGravityInd( X:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_centerOfGravityInd( float *h_RetVal, fVector d_X, ui siz );
int cusdVF_centerOfGravityInd( float *d_RetVal, fVector d_X, ui siz );
float VFcu_centerOfGravityInd( fVector h_X, ui siz );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_centerOfGravityInd( var h_RetVal:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_centerOfGravityInd( d_RetVal:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_centerOfGravityInd( h_X:fVector; size:UIntSize ): Single;
BeschreibungDer Schwerpunkt des Vektors X wird gemäß der folgenden Formel berechnet:
COG = Summe( Xi * i ) / Summe( Xi ).
Es wird angenommen, dass die Werte von X Punkt-Massen darstellen, die sich jeweils an der durch ihren Index gegebenen Position befinden. Der Schwerpunkt wird als Fließkomma-Zahl berechnet, da er in der Regel zwischen zwei benachbarten Indizes zu liegen kommt. Falls alle Elemente von X gleich 0 sind, so gibt es zwar keine Masse und strenggenommen auch keinen Schwerpunkt. Dieser wird dann jedoch als der Mittelpunkt von X angenommen, also als (size−1) / 2.
Um den Schwerpunkt eines Y-Vektors über explizit gegebener X-Achse zu berechnen, rufe man VF_centerOfGravityV.
Fehlerbehandlungkeine
Rückgabewert(Interpolierte) Position des Schwerpunktes
QuerverweisVF_centerOfGravityV

 

VF_centerOfGravityVVD_centerOfGravityVVE_centerOfGravityV
FunktionSchwerpunkt eines Y-Vektors über gegebener X-Achse
Syntax C/C++#include <VFstd.h>
float VF_centerOfGravityV( fVector X, fVector Y, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::centerOfGravityV( const vector<T>& X );
Pascal/Delphiuses VFstd;
function VF_centerOfGravityV( X, Y:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_centerOfGravityV( float *h_RetVal, fVector d_X, fVector d_Y, ui siz );
int cusdVF_centerOfGravityV( float *d_RetVal, fVector d_X, fVector d_Y, ui siz );
float VFcu_centerOfGravityV( fVector h_X, fVector h_Y, ui siz );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_centerOfGravityV( var h_RetVal:Single; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cusdVF_centerOfGravityV( d_RetVal:PSingle; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function VFcu_centerOfGravityV( h_X, h_Y:fVector; size:UIntSize ): Single;
BeschreibungDer Schwerpunkt des Vektors Y über der durch X gegebenen Abszisse wird gemäß der folgenden Formel berechnet:
COG = Summe( Yi * Xi ) / Summe( Yi ).
Es wird angenommen, dass die Werte von Y Punkt-Massen darstellen, die sich an den durch X gegebenen Positionen befinden. Falls alle Elemente von Y gleich 0 sind, so gibt es zwar keine Masse und strenggenommen auch keinen Schwerpunkt. Dieser wird dann jedoch als der Mittelpunkt der X-Achse angenommen, also als (X[size−1)] - X[0]) / 2.
Um den Schwerpunkt eines Vektors über der durch die Indizes gegebenen Achse zu berechnen, rufe man VF_centerOfGravityInd.
Fehlerbehandlungkeine
RückgabewertX-Koordinate des Schwerpunkts
QuerverweisVF_centerOfGravityInd

 

V_checkBoundaries
FunktionKonsistenzprüfung von verlangter und tatsächlicher Vektor-/Matrix-Größe
Syntax C/C++#include <Veclib.h>
void V_checkBoundaries( void *X, ui size, int FlagRW, char *funcname );
Pascal/Delphiuses Veclib;
procedure V_checkBoundaries( X:Pointer; size:UIntSize; FlagRW:Integer; funcname:PChar );
BeschreibungDer häufigste Grund für schwer zu findende Fehler in Vektor- und Matrix-Berechnungen sind falsche Dimensions-Parameter. Durch sie können die Vektor-/Matrix-Grenzen überschrieben oder überlesen werden. Hierdurch wiederum wird der Heap beschädigt, was letztlich zu Fehlern und Abstürzen oft viel später im Programmablauf führt. Durch den Abstand zwischen Ursache und Absturz lässt sich die Ursache solcher Fehler oft nur sehr mühsam ermitteln. Aus diesem Grund bietet OptiVec Debug-Bibliotheken mit Prüfung der Dimensions-Konsistenz: (VCF4WD.LIB für Borland / CodeGear C++, OVVC4D.LIB für Visual C++, bzw. die units in LIB4D für Delphi). In diesen Debug-Bibliotheken ruft jede Vektor- oder Matrix-Funktion V_checkBoundaries auf, um für alle als Parameter erhaltenen Vektoren und Matrizen deren tatsächliche Größe mit den in den Aufrufparametern (size, ht, len) genannten Werten zu vergleichen. Im Falle von Inkonsistenzen werden Warnungen und/order Fehlermeldungen ausgegeben. Auf diese Weise ist es wesentlich einfacher, eventuell zu Speicherfehlern führenden Code zu identifizieren und zu korrigieren.
Obwohl der Hauptzweck von V_checkBoundaries in der internen Anwendung durch die Debug-Bibliotheken besteht, kann diese Funktion auch in Benutzerprogrammen für eigene Konsistenzprüfungen eingesetzt werden.

Eingabe-Parameter von V_checkBoundaries:
XDie Definition als generalisierter Zeiger (void * in C/C++, Pointer in Pascal/Delphi) bedeutet, dass diese Funktion jeden Vektor bzw. Matrix als Argument akzeptiert, unabhängig von ihrem Datentyp.
sizeDie Größe in Bytes, bis zu der der betreffende Vektor bzw. die betreffende Matrix gelesen oder geschrieben werden soll
FlagRWBit 0 dieses Parameters zeigt Lese- (0) oder Schreibzugriff (1). Falls ein Vektor sowohl gelesen als auch geschrieben wird, wird Schreiben (1) angezeigt.
Bit 1 gibt an, ob X ein Vektor (0) oder eine Matrix (1) ist.
Z.B. wird ein nur gelesener Vektor durch FlagRW = 0 angezeigt, während eine zu schreibende Matrix durch FlagRW=2+1 angezeigt wird.
funcnameEin String, der den Namen der untersuchten Funktion enthält
 
V_checkBoundaries identifiziert die folgenden Arten von Problemen und ergreift die erforderlichen Maßnahmen:
Gefundenes ProblemFehlermeldungWeitere Maßnahmen
X = NULL oder nilFuncName: read / write at address 0000.
(Lesen / Schreiben an Adresse 0000)
Sofortiger Programm-Abbruch
size = 0FuncName: Function called with size = 0 (must be ≥ 1)
(Funktion mit size=0 aufgerufen - muss ≥ 1 sein)
Sofortiger Programm-Abbruch
size > VectorSizeFuncName: Boundary violation: vector / matrix starting at StartAddress, ending at EndAddress, is read / written up to OffendingAddress.
(Begrenzungs-Verletzung: Vektor / Matrix mit Start bei StartAdresse und Ende bei EndAdresse wird bis zu SchlechteAdresse gelesen / geschrieben.)
Programm wird weiter ausgeführt.
X ist ein Sub-Vektor, und size > RestlicheVektorGrößeFuncName: Boundary violation: subvector / submatrix StartAddress of BasicAddress, ending at EndAddress, is read / written up to OffendingAddress.
(Begrenzungs-Verletzung: Subvektor / Submatrix StartAdresse von BasisAdresse mit Ende bei EndAdresse wird bis zu SchlechteAdresse gelesen / geschrieben.)
Programm wird weiter ausgeführt.
X ist nicht als OptiVec-Vektor / Matrix alloziertFuncName: Warning: read / write of unallocated or non-OptiVec vector StartAddress
(Warnung: Lesen / Schreiben von nicht alloziertem oder Nicht-OptiVec-Vektor StartAdresse)
Programm wird weiter ausgeführt.
 
Falls Sie den Gebrauch von statischen Arrays oder von Arrays, die mit malloc oder den Speicherverwaltungsfunktionen der Windows API erzeugt wurden, nicht umgehen können, aber die zuletzt beschriebenen Warnhinweise nicht sehen möchten, können Sie sie abschalten mittels
V_setBoundaryCheckWarn( 0 );  (C/C++) oder
V_setBoundaryCheckWarn( FALSE );  (Pascal / Delphi).
Hierdurch werden nur die Warnungen, nicht aber die Fehlermeldungen abgeschaltet.

Fehlerbehandlungkeine
RückgabewertX-Koordinate des Schwerpunkts
QuerverweisV_setBoundaryCheckWarn

 

VF_chexprintVD_chexprintVE_chexprint
VCF_chexprintVCD_chexprintVCE_chexprint
VPF_chexprintVPD_chexprintVPE_chexprint
VI_chexprintVBI_chexprintVSI_chexprintVLI_chexprintVQI_chexprint
VU_chexprintVUB_chexprintVUS_chexprintVUL_chexprintVUI_chexprint
Funktioneinen Vektor im Hexadezimal-Format auf dem Bildschirm ausgeben. Nur für Konsolenanwendungen.
Syntax C/C++#include <VFstd.h>
void VF_chexprint( fVector X, ui size, unsigned nperline );
C++ VecObj#include <OptiVec.h>
void vector<T>::chexprint( unsigned nperline );
Pascal/Delphiuses VFstd;
procedure VF_chexprint( X:fVector; size:UIntSize; nperline:UInt );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_chexprint( fVector d_X, ui size, unsigned nperline );
int cudaVF_chexprint_buf( fVector d_X, ui size, unsigned nperline, fVector h_Wk );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_chexprint( d_X:fVector; size:UIntSize; nperline:UInt ): IntBool;
function cudaVF_chexprint_buf( d_X:fVector; size:UIntSize; nperline:UInt; h_Wk:fVector ): IntBool;
BeschreibungNur Windows mit MS Visual C++ oder Borland / Embarcadero−Compilern:
size Elemente von X werden im Hexadezimal-Format auf dem Bildschirm (der "Console"; daher das "c" im Funktionsnamen) ausgegeben.
Die Ausgabe beginnt stets mit einer neuen Zeile. Dies kann zu einer Leerzeile zu Beginn führen.
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.
Cartesisch-komplexe Zahlen werden in geschweifte Klammern gefasst, wobei der Imaginärteil durch ein Komma vom Realteil getrennt wird: {Re, Im}. Polar-komplexe Zahlen werden ebenfalls in geschweifte Klammern gefaßt, wobei der Mag- vom Arg-Teil durch ein at-Zeichen getrennt wird: {Mag @ Arg}.
Die Ausgabe erfolgt in das aktuelle Textfenster unter automatischer Anpassung an die Bildschirm-Daten des aktuellen Text-Modus. Sind mehr Zeilen erforderlich als auf einer Bildschirmseite Platz finden, wird ein Seitenumbruch durchgeführt und der Benutzer vor jeder neuen Seite aufgefordert, eine beliebige Taste zu drücken.
Die Anzahl pro Element ausgegebener Stellen richtet sich nach dem zur Verfügung stehenden Platz, also nach der Zeilenlänge und dem Parameter nperline.

Diese Familie von Funktionen ist nur für Konsolenanwendungen verwendbar.
 

nur CUDA-Versionen: cudaV?_chexprint_buf übernimmt einen Host-Vektor h_Wk als zusätzliches Argument. Dieser dient als Pufferspeicher und muss (mindestens) dieselbe Größe haben wie X. Hierdurch wird die interne Bereitstellung von Pufferspeicher bei cudaV?_chexprint eingespart, so dass cudaV?_chexprint_buf etwas schneller ist.
 
Andere Windows−Compiler sowie Linux: Da hier die Textfenster-Breite und Höhe nicht ohne weiteres verfügbar sind, werden Aufrufe von V?_chexprint nach VF_hexprint umgeleitet.
 
 
GCC-Windows-spezifisch:Anders als VE_cprint, VCE_cprint, VPE_cprint, wo long doubles auf double abgeschnitten erscheinen, geben VE_chexprint, VCE_chexprint und VPE_chexprint alle Werte in voller 80-bit-Genauigkeit aus.
FehlerbehandlungWenn nperline die im aktuellen Text-Modus maximal mögliche Anzahl von Einträgen übersteigt, wird eine Fehlermeldung "Cannot use requested format (too many entries per line)." ausgegeben und die Ausgabe mit so vielen Einträgen pro Zeile durchgeführt wie möglich.
Rückgabewertkeiner
QuerverweisVF_cprint,   VF_fhexprint,   VF_hexprint,   VF_write,   VF_store,   cprintf

 

VF_chiabsVD_chiabsVE_chiabs
VF_chiabswSaturationVD_chiabswSaturationVE_chiabswSaturation
FunktionBetrags-Anologon des Chi-Quadrat-Anpassungstests
Syntax C/C++#include <VFstd.h>
float VF_chiabs( fVector X, fVector Y, fVector Wt, ui size );
float VF_chiabswSaturation( fVector X, fVector Y, fVector Wt, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::chiabs( const vector<T>& Y, const vector<T>& Wt )
T vector<T>::chiabswSaturation( const vector<T>& Y, const vector<T>& Wt );
Pascal/Delphiuses VFstd;
function VF_chiabs( X, Y, Wt:fVector; size:UIntSize ): Single;
function VF_chiabswSaturation( X, Y, Wt:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_chiabs( float *h_RetVal, fVector d_X, fVector d_Y, fVector d_Wt, ui size );
int cusdVF_chiabs( float *d_RetVal, fVector d_X, fVector d_Y, fVector d_Wt, ui size );
float VFcu_chiabs( fVector h_X, fVector h_Y, fVector h_Wt, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_chiabs( var h_RetVal:Single; d_X, d_Y, d_Wt:fVector; size:UIntSize ): IntBool;
function cusdVF_chiabs( d_RetVal:PSingle; d_X, d_Y, d_Wt:fVector; size:UIntSize ): IntBool;
function VFcu_chiabs( h_X, h_Y, h_Wt:fVector; size:UIntSize ): Single;
Beschreibungchiabs = Summe( Wti * |Xi - Yi| ).
Die chiabs-Funktion ist ein der c2- (Chi-Quadrat)-Funktion analoges, aber "robusteres" Maß der Übereinstimmung von X und Y. Die chiabs-Funktion wird durch sog. Ausreißer-Punkte weniger stark beeinträchtigt als die Chi-Quadrat-Funktion.

V?_chiabswSaturation ist sehr ähnlich zu V?_chiabs, außer in der Behandlung von Überlauf und von NAN. Während V?_chiabs zu INF überlaufen kann und im Falle von einem oder mehreren Eingabe-Elementen = NAN auch NAN zurückgeben wird, „sättigt” V?_chiabswSaturation INF zu HUGE_VAL und behandelt Eingabewerte von ±NAN als ±HUGE_VAL, gibt also auch in diesem Fall HUGE_VAL zurück.

Fehlerbehandlungkeine
Rückgabewertchiabs-Anpassungstestwert
QuerverweisVF_chi2

 

VF_chi2VD_chi2VE_chi2
VF_chi2wSaturationVD_chi2wSaturationVE_chi2wSaturation
FunktionChi-Quadrat-Anpassungstest
Syntax C/C++#include <VFstd.h>
float VF_chi2( fVector X, fVector Y, fVector InvVar, ui size );
float VF_chi2wSaturation( fVector X, fVector Y, fVector InvVar, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::chi2( const vector<T>& Y, const vector<T>& InvVar );
T vector<T>::chi2wSaturation( const vector<T>& Y, const vector<T>& InvVar );
Pascal/Delphiuses VFstd;
function VF_chi2( X, Y, InvVar:fVector; size:UIntSize ): Single;
function VF_chi2wSaturation( X, Y, InvVar:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_chi2( float *h_RetVal, fVector d_X, fVector d_Y, fVector d_InvVar, ui size );
int cusdVF_chi2( float *d_RetVal, fVector d_X, fVector d_Y, fVector d_InvVar, ui size );
float VFcu_chi2( fVector h_X, fVector h_Y, fVector h_InvVar, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_chi2( var h_RetVal:Single; d_X, d_Y, d_InvVar:fVector; size:UIntSize ): IntBool;
function cusdVF_chi2( d_RetVal:PSingle; d_X, d_Y, d_InvVar:fVector; size:UIntSize ): IntBool;
function VFcu_chi2( h_X, h_Y, h_InvVar:fVector; size:UIntSize ): Single;
Beschreibungc2 = Summe( 1/si2 * (Xi - Yi)2 ).
Der Anpassungstestwert c2 (chi-Quadrat) gibt das Maß der Übereinstimmung von X und Y unter Berücksichtigung der Standardabweichungen si (sigmai) der einzelnen Datenpunkte an. Wenn die in X enthaltenen (Meß-) Daten einer Normalverteilung folgen und wenn s das korrekte Maß für die Qualität dieser Daten ist, dann stellt c2 das Maß für die Qualität einer berechneten Anpassung Y an X dar. Anstelle der Standardabweichungen selbst benötigt die Routine den Kehrwert der Quadrate der Standardabweichungen (also den Kehrwert der Varianzen) als Vektor InvVar.

V?_chi2wSaturation ist sehr ähnlich zu V?_chi2, außer in der Behandlung von Überlauf und von NAN. Während V?_chi2 zu INF überlaufen kann und im Falle von einem oder mehreren Eingabe-Elementen = NAN auch NAN zurückgeben wird, „sättigt” V?_chi2wSaturation INF zu HUGE_VAL und behandelt Eingabewerte von ±NAN als ±HUGE_VAL, gibt also auch in diesem Fall HUGE_VAL zurück.

Fehlerbehandlungkeine
RückgabewertAnpassungstestwert c2
QuerverweisVF_meanwW,   VF_varianceVwW,   VF_varianceV,   VF_varianceCwW,   VF_chiabs,   VF_square,   VF_inv,   VF_linregress

 

VF_chopVD_chopVE_chop
VF_choptoIVD_choptoIVE_choptoI
VF_choptoBIVD_choptoBIVE_choptoBI
VF_choptoSIVD_choptoSIVE_choptoSI
VF_choptoLIVD_choptoLIVE_choptoLI
VF_choptoQIVD_choptoQIVE_choptoQI
VF_choptoUVD_choptoUVE_choptoU
VF_choptoUBVD_choptoUBVE_choptoUB
VF_choptoUSVD_choptoUSVE_choptoUS
VF_choptoULVD_choptoULVE_choptoUL
VF_choptoUQVD_choptoUQVE_choptoUQ
VF_choptoUIVD_choptoUIVE_choptoUI
FunktionRundung Richtung 0 durch Abschneiden (engl. chop) aller Stellen nach dem Komma
Syntax C/C++#include <VFmath.h>
int VF_chop( fVector Y, fVector X, ui size );
int VF_choptoI( iVector Y, fVector X, ui size );
int VF_choptoLI( liVector Y, fVector X, ui size );

    (analog alle übrigen Funktionen dieser Familie)
C++ VecObj#include <OptiVec.h>
int vector<T>::chop( const vector<T>& X );
int vector<int>::choptoI( const vector<T>& X );
int vector<long>::choptoLI( const vector<T>& X );
Pascal/Delphiuses VFmath;
function VF_chop( Y, X:fVector; size:UIntSize ):IntBool;
function VF_choptoI( Y:iVector; X:fVector; size:UIntSize ): IntBool;
function VF_choptoLI( Y:liVector; X:fVector; size:UIntSize ): IntBool;

    (analog alle übrigen Funktionen dieser Familie)
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_chop( fVector d_Y, fVector d_X, ui size );
int cudaVF_choptoI( iVector d_Y, fVector d_X, ui size );
int VFcu_chop( fVector h_Y, fVector h_X, ui size );
int VFcu_choptoI( iVector h_Y, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_chop( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVF_choptoI( d_Y:iVector; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_chop( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFcu_choptoI( h_Y:iVector; h_X:fVector; size:UIntSize ): IntBool;
BeschreibungJedes Element von X wird durch Abschneiden der Nachkommastellen zu einer ganzen Zahl gerundet. Dies führt beispielsweise für die Zahl -3.9 zum Ergebnis -3 und für +3.9 zu +3. Die Rundung erfolgt also immer in Richtung 0. In den Funktionen VF_choptoI,   VF_choptoLI etc. wird das Ergebnis in den jeweils gewünschten Ganzzahl-Typ umgewandelt.
FehlerbehandlungOVERFLOW-Fehler werden behandelt, indem das Resultat gleich dem größten (bzw. am stärksten negativen) Wert gesetzt wird, der in dem jeweiligen Ziel-Datentyp möglich ist. DOMAIN-Fehler entstehen durch negative Zahlen in den Funktionen VF_choptoU,   VD_choptoUS etc.; sie führen zum Resultat 0.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_round,   VF_floor,   VF_ceil,   ceil,   floor (nur C/C++)

 

V_closeErrorEventFile
FunktionWiederherstellung der Standard-Ausgabe von Fehlermeldungen, d.h. in stderr
Syntax C/C++#include <VecLib.h>
void V_closeErrorEventFile( void );
Pascal/Delphiuses VecLib;
procedure V_closeErrorEventFile;
BeschreibungNachdem die Ausgabe von Fehlermeldungen durch V_setErrorEventFile in eine Ereignis-Datei umgeleitet wurde, schließt V_closeErrorEventFile die Ereignis-Datei. Die Ausgabe eventueller Meldungen erfolgt anschließend entsprechend dem bei der Erzeugung der Ereignis-Datei angegebenen Parameter ScreenAndFile (0=gar keine Ausgabe; 1=MessageBox; 2=Text-Ausgabe in stderr bei Consolen-Programmen, siehe Kap. 5.5).

Einige Konfigurationen der von OptiVec unterstützten Compiler erlauben nicht den vollen Umfang der oben angegebenen Optionen. Bei manchen fehlt entweder die Ausgabe in eine Message-Box oder die Ausgabe auf den Konsolen-Bildschirm. In diesen Fällen wird ggf. eine Fehlermeldung ausgegeben und die Ausgabe auf die jeweils andere Option umgeleitet.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisV_noteError,   V_setErrorEventFile,   _matherr (nur C/C++)

 

V_closeMT
FunktionBeendigung der zusätzlichen Arbeits-Threads bei Verwendung der für Mehrkern-Prozessoren optimierten Bibliotheken
Syntax C/C++#include <VecLib.h>
int V_closeMT( void );
Pascal/Delphiuses VecLib;
function V_closeMT: IntBool;
BeschreibungDiese Funktion beendet die durch V_initMT initialisierten zusätzlichen Arbeits-Threads. Diese werden für die Verwendung der für Mehrkern-Prozessoren optimierten Bibliotheken benötigt.

V_closeMT sollte am Ende eines die Multi-Prozessor-Bibliotheken verwendenden Programmes stehen, um die Threads "aufzuräumen". Nach Aufruf von V_closeMT dürfen keine Vektor- oder Matrix-Funktion von OptiVec mehr aufgerufen werden.

Um ein einfacheres Hin- und Herschalten zwischen den verschiedenen Versionen der OptiVec-Bibliotheken zu Testzwecken zu ermöglichen, ist V_initMT auch in den (nicht gethreadeten) Allzweck-Bibliotheken enthalten, dort allerdings als leere Funktion, deren Aufruf nichts bewirkt.

RückgabewertFALSE (0), wenn die Threads fehlerfrei abgeschlossen werden konnten, andernfalls TRUE (≠ 0)
QuerverweisV_initMT, Kap. 1.1.2.

 

VF_cmp0VD_cmp0VE_cmp0
VI_cmp0VBI_cmp0VSI_cmp0VLI_cmp0VQI_cmp0
FunktionVergleich mit 0 (signum-Funktion)
Syntax C/C++#include <VFmath.h>
void VF_cmp0( fVector Y, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::cmp0( const vector<T>& X );
Pascal/Delphiuses VFstd;
procedure VF_cmp0( Y,X:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cmp0( fVector d_Y, fVector d_X, ui size );
void VFcu_cmp0( fVector h_Y, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cmp0( d_Y, d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_cmp0( h_Y, h_X:fVector; size:UIntSize );
BeschreibungJedes Element von X wird mit 0 verglichen und das Ergebnis des Vergleiches in Y wie folgt gespeichert:
Yi = +1.0, wenn Xi > 0
Yi =   0.0, wenn Xi = 0
Yi =  −1.0, wenn Xi < 0.
Diese Funktion kann auch unter ihrem Synonym VF_sgn aufgerufen werden.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_cmp_...,   VF_cmpC,   VF_cmpV

 

VF_cmpCVD_cmpCVE_cmpC
VI_cmpCVBI_cmpCVSI_cmpCVLI_cmpCVQI_cmpC 
VU_cmpCVUB_cmpCVUS_cmpCVUL_cmpCVUQ_cmpCVUI_cmpC
FunktionVergleich mit einer Konstanten
Syntax C/C++#include <VFmath.h>
void VF_cmpC( fVector Y, fVector X, ui size, float C );
void VI_cmpC( iVector Y, iVector X, ui size, int C );
void VU_cmpC( iVector Y, uVector X, ui size, unsigned C );
C++ VecObj#include <OptiVec.h>
void vector<T>::cmpC( const vector<T>& X, const T& C );

vorzeichenlose Ganzzahl-Typen: Funktion gehört zur entsprechenden vorzeichenbehafteten Klasse:
void vector<T>::cmpC( const vector<unsigned T>& X, const unsigned T& C );
Pascal/Delphiuses VFstd;
procedure VF_cmpC( Y,X:fVector; size:UIntSize; C:Single );
procedure VI_cmpC( Y,X:iVector; size:UIntSize; C:Integer );
procedure VU_cmpC( Y:iVector; X:uVector; size:UIntSize; C:UInt );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cmpC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_cmpC( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_cmpC( fVector h_Y, fVector h_X, ui size, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cmpC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_cmpC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VFcu_cmpC( h_Y, h_X:fVector; size:UIntSize; C:Single );
BeschreibungJedes Element von X wird mit C verglichen und das Ergebnis des Vergleiches in Y wie folgt gespeichert:
Yi = +1.0, wenn Xi > C
Yi =   0.0, wenn Xi = C
Yi =  −1.0, wenn Xi < C
Um mit C=0 zu vergleichen, benutze man die Funktion VF_cmp0.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_cmp_...,  VF_cmp0,   VF_cmpV,   VF_iselementC

 

VF_cmpVVD_cmpVVE_cmpV
VI_cmpVVBI_cmpVVSI_cmpVVLI_cmpVVQI_cmpV 
VU_cmpVVUB_cmpVVUS_cmpVVUL_cmpVVUQ_cmpVVUI_cmpV
FunktionVergleich der Elemente eines Vektors mit denen eines anderen
Syntax C/C++#include <VFmath.h>
void VF_cmpV( fVector Z, fVector X, fVector Y, ui size );
void VI_cmpV( iVector Z, iVector X, iVector Y, ui size );
void VU_cmpV( iVector Z, uVector X, uVector Y, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::cmpV( const vector<T>& X, const vector<T>& Y );

vorzeichenlose Ganzzahl-Typen: Funktion gehört zur entsprechenden vorzeichenbehafteten Klasse:
void vector<T>::cmpV( const vector<unsigned T>& X, const vector<unsigned T>& Y );
Pascal/Delphiuses VFstd;
procedure VF_cmpV( Z, X, Y:fVector; size:UIntSize );
procedure VI_cmpV( Z, X, Y:iVector; size:UIntSize );
procedure VU_cmpV( Z:uVector; X, Y:iVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cmpV( fVector d_Z, fVector d_X, fVector d_Y, ui size );
void VFcu_cmpV( fVector h_Z, fVector h_X, fVector h_Y, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cmpV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
procedure VFcu_cmpV( h_Z, h_X, h_Y:fVector; size:UIntSize );
BeschreibungJedes Element von X wird mit dem korrespondierenden Element von Y verglichen und das Resultat des Vergleiches wie folgt in Z gespeichert:
Zi = +1.0, wenn Xi > Yi
Zi =   0.0, wenn Xi = Yi
Zi =  −1.0, wenn Xi < Yi.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_cmp_...,  VF_cmp0,   VF_cmpC

 

VF_cmp_...VD_cmp_...VE_cmp_...
VI_cmp_...VBI_cmp_...VSI_cmp_...VLI_cmp_...VQI_cmp_... 
VU_cmp_...VUB_cmp_...VUS_cmp_...VUL_cmp_...VUQ_cmp_...VUI_cmp_...
      ...eq0      ...ne0      ...gt0      ...ge0      ...le0      ...lt0
      ...eqC      ...neC      ...gtC      ...geC      ...leC      ...ltC
      ...eqV      ...neV      ...gtV      ...geV      ...leV      ...ltV      ...stV      ...dtV
      ...eq0ind      ...ne0ind      ...gt0ind      ...ge0ind      ...le0ind      ...lt0ind
      ...eqCind      ...neCind      ...gtCind      ...geCind      ...leCind      ...ltCind
      ...eqVind      ...neVind      ...gtVind      ...geVind      ...leVind      ...ltVind      ...stVind      ...dtVind
        ...inclrange0C        ...exclrange0C
        ...inclrangeCC        ...exclrangeCC
        ...inclrange0Cind        ...exclrange0Cind
        ...inclrangeCCind        ...exclrangeCCind
VCF_cmp_...VCD_cmp_...VCE_cmp_...
VPF_cmp_...VPD_cmp_...VPE_cmp_...
      ...eq0      ...ne0
      ...eqC      ...neC
      ...eqV      ...neV      ...stV      ...dtV
      ...eq0ind      ...ne0ind
      ...eqCind      ...neCind
      ...eqVind      ...neVind      ...stVind      ...dtVind
FunktionVergleichsoperationen
Syntax C/C++#include <VFmath.h>
ui VF_cmp_eq0( fVector Y, fVector X, ui size );
ui VF_cmp_ne0( fVector Y, fVector X, ui size );
ui VF_cmp_gt0( fVector Y, fVector X, ui size );
ui VF_cmp_ge0( fVector Y, fVector X, ui size );
ui VF_cmp_lt0( fVector Y, fVector X , ui size );
ui VF_cmp_le0( fVector Y, fVector X, ui size );

ui VF_cmp_eqC( fVector Y, fVector X, ui size, float C );
    (analog: ..._neC, ..._gtC, ..._geC, ..._ltC, ..._leC)

ui VF_cmp_eqV( fVector Z, fVector X, fVector Y, ui size);
    (analog: ..._neV, ..._gtV, ..._geV, ..._ltV, ..._leV)
ui VF_cmp_stV( fVector Z, fVector X, fVector Y, ui size, float TolRel, float TolAbs );
ui VF_cmp_dtV( fVector Z, fVector X, fVector Y, ui size, float TolRel, float TolAbs );

ui VF_cmp_eq0ind( uiVector Ind, fVector X, ui size );
    (analog: ..._ne0ind, ..._gt0ind, ..._ge0ind, ..._lt0ind, ..._le0ind)
ui VF_cmp_eqCind( uiVector Ind, fVector X, ui size, float C );
    (analog: ..._neCind, ..._gtCind, ..._geCind, ..._ltCind, ..._leCind)
ui VF_cmp_eqVind( uiVector Ind, fVector X, fVector Y, ui size );
    (analog: ..._neVind, ..._gtVind, ..._geVind, ..._ltVind, ..._leVind)
ui VF_cmp_stVind( uiVector Ind, fVector X, fVector Y, ui size, float TolRel, float TolAbs );
ui VF_cmp_dtVind( uiVector Ind, fVector X, fVector Y, ui size, float TolRel, float TolAbs );
    (analog VD_,   VE_)

ui VF_cmp_inclrange0C( fVector Y, fVector X, ui size, float C );
ui VF_cmp_exclrange0C( fVector Y, fVector X, ui size, float C );
ui VF_cmp_inclrangeCC( fVector Y, fVector X, ui size, float CLo, float CHi );
ui VF_cmp_exclrangeCC( fVector Y, fVector X, ui size, float CLo, float CHi );

    (analog VD_,   VE_)

ui VF_cmp_inclrange0Cind( uiVector Ind, fVector X, ui size, float C );
ui VF_cmp_exclrange0Cind( uiVector Ind, fVector X, ui size, float C );
ui VF_cmp_inclrangeCCind( uiVector Ind, fVector X, ui size, float CLo, float CHi );
ui VF_cmp_exclrangeCCind( uiVector Ind, fVector X, ui size, float CLo, float CHi );

    (analog VD_,   VE_)

ui VCF_cmp_eq0( cfVector Y, cfVector X, ui size );
ui VCF_cmp_ne0( cfVector Y, cfVector X, ui size );
ui VCF_cmp_eqC( cfVector Y, cfVector X, ui size, fComplex C );
ui VCF_cmp_neC( cfVector Y, cfVector X, ui size, fComplex C );
ui VCF_cmp_eqV( cfVector Z, cfVector X, cfVector Y, ui size );
ui VCF_cmp_neV( cfVector Z, cfVector X, cfVector Y, ui size );
ui VCF_cmp_stV( cfVector Z, cfVector X, cfVector Y, ui size, fComplex TolRel, fComplex TolAbs );
ui VCF_cmp_dtV( cfVector Z, cfVector X, cfVector Y, ui size, fComplex TolRel, fComplex TolAbs );
ui VCF_cmp_eq0ind( uiVector Ind, cfVector X, ui size );
ui VCF_cmp_ne0ind( uiVector Ind, cfVector X, ui size );
ui VCF_cmp_eqCind( uiVector Ind, cfVector X, ui size, fComplex C );
ui VCF_cmp_neCind( uiVector Ind, cfVector X, ui size, fComplex C );
ui VCF_cmp_eqVind( uiVector Ind, cfVector X, cfVector Y, ui size );
ui VCF_cmp_neVind( uiVector Ind, cfVector X, cfVector Y, ui size );
ui VCF_cmp_stVind( uiVector Ind, cfVector X, cfVector Y, ui size, fComplex TolRel, fComplex TolAbs );
ui VCF_cmp_dtVind( uiVector Ind, cfVector X, cfVector Y, ui size, fComplex TolRel, fComplex TolAbs );

    (analog VCD_,   VCE_)

C++ VecObj#include <OptiVec.h>
ui vector<T>::cmp_eq0( const vector<T>& X );
ui vector<T>::cmp_ne0( const vector<T>& X );
ui vector<T>::cmp_gt0( const vector<T>& X );
ui vector<T>::cmp_ge0( const vector<T>& X );
ui vector<T>::cmp_lt0( const vector<T>& X );
ui vector<T>::cmp_le0( const vector<T>& X );
ui vector<T>::cmp_eqC( const vector<T>& X, const T& C );
ui vector<T>::cmp_eqV( const vector<T>& X, const vector<T>& Y );
ui vector<T>::cmp_stV( const vector<T>& X, const vector<T>& Y, const T& TolRel, const T& TolAbs );
ui vector<ui>::cmp_eq0ind( const vector<ui>& Ind, const vector<T>& X );
ui vector<ui>::cmp_eqCind( const vector<ui>& Ind, const vector<T>& X );
ui vector<ui>::cmp_eqVind( const vector<ui>& Ind, const vector<T>& X );
ui vector<ui>::cmp_stVind( const vector<ui>& Ind, const vector<T>& X, const T& TolRel, const T& TolAbs );
ui vector<T>::cmp_inclrange0C( const vector<T>& X, const T& C );
ui vector<T>::cmp_exclrange0C( const vector<T>& X, const T& C );
ui vector<T>::cmp_inclrangeCC( const vector<T>& X, const T& CLo, const T& CHi );
ui vector<T>::cmp_exclrangeCC( const vector<T>& X, const T& CLo, const T& CHi );
ui vector<ui>::cmp_inclrange0Cind( const vector<ui>& Ind, const vector<T>& X, const T& C );
ui vector<ui>::cmp_exclrange0Cind( const vector<ui>& Ind, const vector<T>& X, const T& C );
ui vector<ui>::cmp_inclrangeCCind( const vector<ui>& Ind, const vector<T>& X, const T& CLo, const T& CHi );
ui vector<ui>::cmp_exclrangeCCind( const vector<ui>& Ind, const vector<T>& X, const T& CLo, const T& CHi );
ui vector<complex<T>>::cmp_eq0( const vector<complex<T>>& X );
ui vector<complex<T>>::cmp_ne0( const vector<complex<T>>& X );
ui vector<complex<T>>::cmp_eqC( const vector<complex<T>>& X, complex<T> C );
ui vector<complex<T>>::cmp_neC( const vector<complex<T>>& X, complex<T> C );
ui vector<complex<T>>::cmp_eqV( const vector<complex<T>>& X, const vector<complex<T>>& Y );
ui vector<complex<T>>::cmp_neV( const vector<complex<T>>& X, const vector<complex<T>>& Y );
ui vector<complex<T>>::cmp_stV( const vector<complex<T>>& X, const vector<complex<T>>& Y, complex<T>TolRel, complex<T>TolAbs );
ui vector<ui>::cmp_eq0ind( const vector<ui>& Ind, const vector<complex<T>>& X );
ui vector<ui>::cmp_ne0ind( const vector<ui>& Ind, const vector<complex<T>>& X );
ui vector<ui>::cmp_eqCind( const vector<ui>& Ind, const vector<complex<T>>& X );
ui vector<ui>::cmp_neCind( const vector<ui>& Ind, const vector<complex<T>>& X );
ui vector<ui>::cmp_eqVind( const vector<ui>& Ind, const vector<complex<T>>& X );
ui vector<ui>::cmp_neVind( const vector<ui>& Ind, const vector<complex<T>>& X );
ui vector<ui>::cmp_stVind( const vector<ui>& Ind, const vector<complex<T>>& X, complex<T>TolRel, complex<T>TolAbs );
Pascal/Delphiuses VFstd;
function VF_cmp_eq0( Y,X:fVector; size:UIntSize ):UIntSize;
function VF_cmp_ne0( Y,X:fVector; size:UIntSize ):UIntSize;
function VF_cmp_gt0( Y,X:fVector; size:UIntSize ):UIntSize;
function VF_cmp_ge0( Y,X:fVector; size:UIntSize ):UIntSize;
function VF_cmp_lt0( Y,X:fVector; size:UIntSize ):UIntSize;
function VF_cmp_le0( Y,X:fVector; size:UIntSize ):UIntSize;

function VF_cmp_eqC( Y,X:fVector; size:UIntSize; C:Single ):UIntSize;
    (analog: ..._neC, ..._gtC, ..._geC, ..._ltC, ..._leC)

function VF_cmp_eqV( Z, X, Y:fVector; size:UIntSize ):UIntSize;
    (analog: ..._neV, ..._gtV, ..._geV, ..._ltV, ..._leV)
function VF_cmp_stV( Z, X, Y:fVector; size:UIntSize; TolRel, TolAbs:Single ):UIntSize;
function VF_cmp_dtV( Z, X, Y:fVector; size:UIntSize; TolRel, TolAbs:Single ):UIntSize;

function VF_cmp_eq0ind( Ind:uiVector; X:fVector; size:UIntSize ):UIntSize;
    (analog: ..._ne0ind, ..._gt0ind, ..._ge0ind, ..._lt0ind, ..._le0ind)
function VF_cmp_eqCind( Ind:uiVector; X:fVector; size:UIntSize; C:Single ):UIntSize;
    (analog: ..._neCind, ..._gtCind, ..._geCind, ..._ltCind, ..._leCind)
function VF_cmp_eqVind( Ind:uiVector; X, Y:fVector; size:UIntSize ):UIntSize;
    (analog: ..._neVind, ..._gtVind, ..._geVind, ..._ltVind, ..._leVind)
function VF_cmp_stVind( Ind:uVector; X, Y:fVector; size:UIntSize; TolRel, TolAbs:Single ):UIntSize;
function VF_cmp_dtVind( Ind:uVector; X, Y:fVector; size:UIntSize; TolRel, TolAbs:Single ):UIntSize;

    (analog VD_ und VE_-Versionen)

function VF_cmp_inclrange0C( Y, X:fVector; size:UIntSize; C:Single ): UIntSize;
function VF_cmp_exclrange0C( Y, X:fVector; size:UIntSize; C:Single ): UIntSize;
function VF_cmp_inclrangeCC( Y, X:fVector; size:UIntSize; CLo, CHi:Single ): UIntSize;
function VF_cmp_exclrangeCC( Y, X:fVector; size:UIntSize; CLo, CHi:Single ): UIntSize;

    (analog VD_ und VE_-Versionen)

function VF_cmp_inclrange0Cind( Ind:uiVector; X:fVector; size:UIntSize; C:Single ): UIntSize;
function VF_cmp_exclrange0Cind( Ind:uiVector; X:fVector; size:UIntSize; C:Single ): UIntSize;
function VF_cmp_inclrangeCCind( Ind:uiVector; X:fVector; size:UIntSize; CLo, CHi:Single ): UIntSize;
function VF_cmp_exclrangeCCind( Ind:uiVector; X:fVector; size:UIntSize; CLo, CHi:Single ): UIntSize;

    (analog VD_ und VE_-Versionen)

function VCF_cmp_eq0( Y, X:cfVector; size:UIntSize ):UIntSize;
function VCF_cmp_ne0( Y, X:cfVector; size:UIntSize ):UIntSize;
function VCF_cmp_eqC( Y, X:cfVector; size:UIntSize; C:fComplex ):UIntSize;
function VCF_cmp_neC( Y, X:cfVector; size:UIntSize; C:fComplex ):UIntSize;
function VCF_cmp_eqV( Z, X, Y:cfVector; size:UIntSize ):UIntSize;
function VCF_cmp_neV( Z, X, Y:cfVector; size:UIntSize ):UIntSize;
function VCF_cmp_stV( Z, X, Y:cfVector; size:UIntSize; TolRel, TolAbs:fComplex ):UIntSize;
function VCF_cmp_dtV( Z, X, Y:cfVector; size:UIntSize; TolRel, TolAbs:fComplex ):UIntSize;

function VCF_cmp_eq0ind( Ind:uiVector; X:cfVector; size:UIntSize ):UIntSize;
function VCF_cmp_ne0ind( Ind:uiVector; X:cfVector; size:UIntSize ):UIntSize;
function VCF_cmp_eqCind( Ind:uiVector; X:cfVector; size:UIntSize; C:fComplex ):UIntSize;
function VCF_cmp_neCind( Ind:uiVector; X:cfVector; size:UIntSize; C:fComplex ):UIntSize;
function VCF_cmp_eqVind( Ind:uiVector; X, Y:cfVector; size:UIntSize ):UIntSize;
function VCF_cmp_neVind( Ind:uiVector; X, Y:cfVector; size:UIntSize ):UIntSize;
function VCF_cmp_stVind( Ind:uVector; X, Y:cfVector; size:UIntSize; TolRel, TolAbs:fComplex ):UIntSize;
function VCF_cmp_dtVind( Ind:uVector; X, Y:cfVector; size:UIntSize; TolRel, TolAbs:fComplex ):UIntSize;

    (analog VCD_ und VCE_-Versionen)

CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cmp_eq0( ui *h_nTrue, fVector d_Y, fVector d_X, ui size );
ui VFcu_cmp_eq0( fVector h_Y, fVector h_X, ui size );

    (analog .._ne0, .._gt0, .._ge0, .._le0, .._lt0)

int cudaVF_cmp_eqC( ui *h_nTrue, fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_cmp_eqC( ui *h_nTrue, fVector d_Y, fVector d_X, ui size, float *d_C );
ui VFcu_cmp_eqC( fVector h_Y, fVector h_X, ui size, float C );

    (analog: ..._neC, ..._gtC, ..._geC, ..._ltC, ..._leC)

int cudaVF_cmp_eqV( ui *h_nTrue, fVector d_Z, fVector d_X, fVector d_Y, ui size);
ui VFcu_cmp_eqV( fVector h_Z, fVector h_X, fVector h_Y, ui size);

    (analog: ..._neV, ..._gtV, ..._geV, ..._ltV, ..._leV)

int cudaVF_cmp_stV( ui *h_nTrue, fVector d_Z, fVector d_X, fVector d_Y, ui size, float TolRel, float TolAbs);
int cusdVF_cmp_stV( ui *h_nTrue, fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_TolRel, float *d_TolAbs);
ui VFcu_cmp_stV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float TolRel, float TolAbs);

    (analog: ..._dtV)

int cudaVF_cmp_inclrange0C( ui *h_nTrue, fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_cmp_inclrange0C( ui *h_nTrue, fVector d_Y, fVector d_X, ui size, float *d_C );
int cudaVF_cmp_inclrangeCC( ui *h_nTrue, fVector d_Y, fVector d_X, ui size, float CLo, float CHi );
int cusdVF_cmp_inclrangeCC( ui *h_nTrue, fVector d_Y, fVector d_X, ui size, float *d_CLo, float *d_CHi );
ui VFcu_cmp_inclrange0C( fVector h_Y, fVector h_X, ui size, float C );
ui VFcu_cmp_inclrangeCC( fVector h_Y, fVector h_X, ui size, float CLo, float CHi );

    (analog: ..._exclrange0C and ..._exclrangeCC)
    (es gibt keine cudaV?_cmp_???ind oder V?cu_cmp_???ind Funktionen!)

CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cmp_eq0( var h_nTrue:UIntSize; d_Y, d_X:fVector; size:UIntSize ): IntBool;
function VFcu_cmp_eq0( h_Y, h_X:fVector; size:UIntSize ): UIntSize;

    (analog .._ne0, .._gt0, .._ge0, .._le0, .._lt0)

function cudaVF_cmp_eqC( var h_nTrue:UIntSize; d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_cmp_eqC( var h_nTrue:UIntSize; d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function VFcu_cmp_eqC( h_Y, h_X:fVector; size:UIntSize; C:Single ): UIntSize;

    (analog: ..._neC, ..._gtC, ..._geC, ..._ltC, ..._leC)

function cudaVF_cmp_eqV( var h_nTrue:UIntSize; d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function VFcu_cmp_eqV( h_Z, h_X, h_Y:fVector; size:UIntSize ): UIntSize;

    (analog: ..._neV, ..._gtV, ..._geV, ..._ltV, ..._leV)

function cudaVF_cmp_stV( var h_nTrue:UIntSize; d_Z, d_X, d_Y:fVector; size:UIntSize; TolRel, TolAbs:Single ): IntBool;
function cusdVF_cmp_stV( var h_nTrue:UIntSize; d_Z, d_X, d_Y:fVector; size:UIntSize; d_TolRel, d_TolAbs:PSingle ): IntBool;
function VFcu_cmp_stV( h_Z, h_X, h_Y:fVector; size:UIntSize; TolRel, TolAbs:Single ): UIntSize;

    (analog: ..._dtV)

function cudaVF_cmp_inclrange0C( var h_nTrue:UIntSize; d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_cmp_inclrange0C( var h_nTrue:UIntSize; d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function cudaVF_cmp_inclrangeCC( var h_nTrue:UIntSize; d_Y, d_X:fVector; size:UIntSize; CLo, CHi:Single ): IntBool;
function cusdVF_cmp_inclrangeCC( var h_nTrue:UIntSize; d_Y, d_X:fVector; size:UIntSize; d_CLo, d_CHi:PSingle ): IntBool;
function VFcu_cmp_inclrange0C( h_Y, h_X:fVector; size:UIntSize; C:Single ): UIntSize;
function VFcu_cmp_inclrangeCC( h_Y, h_X:fVector; size:UIntSize; CLo, CHi:Single ): UIntSize;

    (analog: ..._exclrange0C and ..._exclrangeCC)
    (es gibt keine cudaV?_cmp_???ind oder V?cu_cmp_???ind Funktionen!)

Beschreibunga) Einfache Vergleichsfunktionen:
Jedes Element von X wird mit 0, einer Konstanten C oder dem korrespondierenden Element eines anderen Vektors, Y, verglichen. Die dabei zu überprüfende Bedingung wird durch zwei Buchstaben angegeben:
 
"eq" ("equal")True, wenn Xi = 0 (oder C bzw. Yi)
"ne" ("not equal")True, wenn Xi ≠ 0 (oder C bzw. Yi)
"gt" ("gteater than")True, wenn Xi > 0 (oder C bzw. Yi)
"ge" ("greater or equal")   True, wenn Xi ≥ 0 (oder C bzw. Yi)
"lt" ("less than")True, wenn Xi < 0 (oder C bzw. Yi)
"le" ("less or equal")True, wenn Xi ≤ 0 (oder C bzw. Yi)
"st" ("similar to")True, wenn Xi ≈ Yi,   d.h. | Xi − Yi | ≤ max( |Yi| * TolRel, TolAbs)
"dt" ("dissimilar to")True, wenn Xi ≉ Yi,   d.h. | Xi − Yi | > max( |Yi| * TolRel, TolAbs)

Für komplexe Zahlen machen nur der Test auf Gleichheit ("eq"), Ungleichheit ("ne"), Ähnlichkeit ("st") und Unähnlichkeit ("dt") Sinn. Die übrigen Testbedingungen existieren nicht für komplexe Zahlen. Bei den Tests auf Ähnlichkeit ("st") und Unähnlichkeit ("dt") für komplexe Zahlen sind die Parameter TolRel und TolAbs ebenfalls komplex, um ggf. unterschiedliche Toleranzen für Real- und Imaginärteile festlegen zu können.
Für vorzeichenlose Ganzzahl-Typen existieren naturgemäß diejenigen Funktionen nicht, die die Bedingung Xi < 0 oder Xi ≤ 0 prüfen, ebensowenig wie die trivialen Tests Xi ≥ 0.

b) Bereichsprüfungs-Funktionen:
Für jedes Element von X wird geprüft, ob es in den Bereich fällt, der entweder durch 0 und eine (positive oder negative) Konstante C oder durch zwei Konstanten, CLo und CHi, spezifiziert wird. Dabei kann gewählt werden, ob der Bereich inclusiv oder exclusiv der Endpunkte zu verstehen ist:
VF_cmp_inclrange0C prüft, ob 0 ≤ x ≤ C (für positives C) oder 0 ≥ x ≥ C (für negatives C), während VF_cmp_exclrangeCC den Test auf CLo < x < CHi durchführt.
Für vorzeichenlose Ganzzahl-Typen existieren keine Funktionen "VU_cmp_inclrange0C", da die Bedingung Xi ≥ 0 trivialerweise immer erfüllt ist.

a) und b):
Das Resultat des Vergleiches kann auf zwei verschiedene Arten behandelt werden. Entweder wird für jedes Element das Ergebnis als 1.0 für TRUE oder 0.0 für FALSE gespeichert (bei den komplexen Versionen wird der Imaginärteil immer gleich 0 gesetzt), oder die Indizes derjenigen Elemente, für die das Ergebnis TRUE war, werden in einem Index-Array gespeichert. Diese letztere Variante wird durch das Suffix "ind" im Funktionsnamen angegeben, z.B. VF_cmp_neCind. Bei beiden Varianten wird die Anzahl der TRUE-Resultate zurückgegeben.
Die die Indizes findende Variante ist gut zu gebrauchen, um in einem zweiten Schritt mit Hilfe von VF_indpick diejenigen Elemente, die die Testbedingung erfüllen, in einen anderen Vektor zu kopieren. Vorsicht ist allerdings geboten, dass VF_indpick nicht aufgerufen wird mit size=0, wenn also überhaupt kein Element die Bedingung erfüllte. Man muss daher immer überprüfen, ob der Rückgabewert nTrue ungleich 0 ist. (Man erinnere sich, dass der Parameter size für alle VectorLib-Funktionen größer als 0 sein muss!)
Die Länge von Ind muss immer (mindestens) gleich der Länge von X sein, selbst dann, wenn man von vornherein weiß, dass die Zahl der TRUE-Elemente klein ist. Der Grund hierfür ist, dass die Routine Teile von Ind für Zwischenspeicherungen benutzen kann.

Fehlerbehandlungkeine
RückgabewertAnzahl der die Testbedingung erfüllenden Elemente
QuerverweisVF_cnt_...,   VF_cmp0,   VF_cmpC,   VF_cmpV,   VF_indpick,   VF_iselementC

 

VF_cnt_...VD_cnt_...VE_cnt_...
VI_cnt_...VBI_cnt_...VSI_cnt_...VLI_cnt_...VQI_cnt_... 
VU_cnt_...VUB_cnt_...VUS_cnt_...VUL_cnt_...VUQ_cnt_...VUI_cnt_...
      ...eq0      ...ne0      ...gt0      ...ge0      ...le0      ...lt0
      ...eqC      ...neC      ...gtC      ...geC      ...leC      ...ltC
      ...eqV      ...neV      ...gtV      ...geV      ...leV      ...ltV      ...stV      ...dtV
        ...inclrange0C        ...exclrange0C
        ...inclrangeCC        ...exclrangeCC
VCF_cnt_...VCD_cnt_...VCE_cnt_...
VPF_cnt_...VPD_cnt_...VPE_cnt_...
      ...eq0      ...ne0
      ...eqC      ...neC
      ...eqV      ...neV      ...stV      ...dtV
FunktionAnzahl der eine Testbedingung erfüllenden Vektor-Elemente
Syntax C/C++#include <VFmath.h>
ui VF_cnt_eq0( fVector X, ui size );
ui VF_cnt_ne0( fVector X, ui size );
ui VF_cnt_gt0( fVector X, ui size );
ui VF_cnt_ge0( fVector X, ui size );
ui VF_cnt_lt0( fVector X , ui size );
ui VF_cnt_le0( fVector X, ui size );

ui VF_cnt_eqC( fVector X, ui size, float C );
    (analog: ..._neC, ..._gtC, ..._geC, ..._ltC, ..._leC)

ui VF_cnt_eqV( fVector X, fVector Y, ui size);
    (analog: ..._neV, ..._gtV, ..._geV, ..._ltV, ..._leV)
ui VF_cnt_stV( fVector X, fVector Y, ui size, float TolRel, float TolAbs );
ui VF_cnt_dtV( fVector X, fVector Y, ui size, float TolRel, float TolAbs );

ui VF_cnt_inclrange0C( fVector X, ui size, float C );
ui VF_cnt_exclrange0C( fVector X, ui size, float C );
ui VF_cnt_inclrangeCC( fVector X, ui size, float CLo, float CHi );
ui VF_cnt_exclrangeCC( fVector X, ui size, float CLo, float CHi );

    (analog VD_, VE_, VI_ usw.)

ui VCF_cnt_eq0( cfVector X, ui size );
ui VCF_cnt_ne0( cfVector X, ui size );
ui VCF_cnt_eqC( cfVector X, ui size, fComplex C );
ui VCF_cnt_neC( cfVector X, ui size, fComplex C );
ui VCF_cnt_eqV( cfVector X, cfVector Y, ui size );
ui VCF_cnt_neV( cfVector X, cfVector Y, ui size );
ui VCF_cnt_stV( cfVector X, cfVector Y, ui size, fComplex TolRel, fComplex TolAbs );
ui VCF_cnt_dtV( cfVector X, cfVector Y, ui size, fComplex TolRel, fComplex TolAbs );

    (analog VPF_, VPD_, VPE_, VCD_ und VCE_ Versionen)

C++ VecObj#include <OptiVec.h>
ui vector<T>::cnt_eq0( );
ui vector<T>::cnt_ne0( );
ui vector<T>::cnt_gt0( );
ui vector<T>::cnt_ge0( );
ui vector<T>::cnt_lt0( );
ui vector<T>::cnt_le0( );
ui vector<T>::cnt_eqC( const T& C );
ui vector<T>::cnt_eqV( const vector<T>& Y );
ui vector<T>::cnt_stV( const vector<T>& Y, const T& TolRel, const T& TolAbs );
ui vector<T>::cnt_dtV( const vector<T>& Y, const T& TolRel, const T& TolAbs );
ui vector<T>::cnt_inclrange0C( const T& C );
ui vector<T>::cnt_exclrange0C( const T& C );
ui vector<T>::cnt_inclrangeCC( const T& CLo, const T& CHi );
ui vector<T>::cnt_exclrangeCC( const T& CLo, const T& CHi );
ui vector<complex<T>>::cnt_eq0( );
ui vector<complex<T>>::cnt_ne0( );
ui vector<complex<T>>::cnt_eqC( complex<T> C );
ui vector<complex<T>>::cnt_neC( complex<T> C );
ui vector<complex<T>>::cnt_eqV( const vector<complex<T>>& Y );
ui vector<complex<T>>::cnt_neV( const vector<complex<T>>& Y );
ui vector<complex<T>>::cnt_stV( const vector<complex<T>>& Y, complex<T> TolRel, complex<T> TolAbs );
ui vector<complex<T>>::cnt_dtV( const vector<complex<T>>& Y, complex<T> TolRel, complex<T> TolAbs );
Pascal/Delphiuses VFstd;
function VF_cnt_eq0( X:fVector; size:UIntSize ):UIntSize;
function VF_cnt_ne0( X:fVector; size:UIntSize ):UIntSize;
function VF_cnt_gt0( X:fVector; size:UIntSize ):UIntSize;
function VF_cnt_ge0( X:fVector; size:UIntSize ):UIntSize;
function VF_cnt_lt0( X:fVector; size:UIntSize ):UIntSize;
function VF_cnt_le0( X:fVector; size:UIntSize ):UIntSize;

function VF_cnt_eqC( X:fVector; size:UIntSize; C:Single ):UIntSize;
    (analog: ..._neC, ..._gtC, ..._geC, ..._ltC, ..._leC)

function VF_cnt_eqV( X, Y:fVector; size:UIntSize ):UIntSize;
    (analog: ..._neV, ..._gtV, ..._geV, ..._ltV, ..._leV)
function VF_cnt_stV( X, Y:fVector; size:UIntSize; TolRel, TolAbs:Single ):UIntSize;
function VF_cnt_dtV( X, Y:fVector; size:UIntSize; TolRel, TolAbs:Single ):UIntSize;

    (analog VD_, VE_, VI_ usw.)

function VF_cnt_inclrange0C( X:fVector; size:UIntSize; C:Single ): UIntSize;
function VF_cnt_exclrange0C( X:fVector; size:UIntSize; C:Single ): UIntSize;
function VF_cnt_inclrangeCC( X:fVector; size:UIntSize; CLo, CHi:Single ): UIntSize;
function VF_cnt_exclrangeCC( X:fVector; size:UIntSize; CLo, CHi:Single ): UIntSize;

    (analog VD_, VE_, VI_ usw.)

function VCF_cnt_eq0( X:cfVector; size:UIntSize ):UIntSize;
function VCF_cnt_ne0( X:cfVector; size:UIntSize ):UIntSize;
function VCF_cnt_eqC( X:cfVector; size:UIntSize; C:fComplex ):UIntSize;
function VCF_cnt_neC( X:cfVector; size:UIntSize; C:fComplex ):UIntSize;
function VCF_cnt_eqV( X, Y:cfVector; size:UIntSize ):UIntSize;
function VCF_cnt_neV( X, Y:cfVector; size:UIntSize ):UIntSize;
function VCF_cnt_stV( X, Y:cfVector; size:UIntSize; TolRel, TolAbs:fComplex ):UIntSize;
function VCF_cnt_dtV( X, Y:cfVector; size:UIntSize; TolRel, TolAbs:fComplex ):UIntSize;

    (analog VPF_, VPD_, VPE_, VCD_ und VCE_ Versionen)

CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cnt_eq0( ui *h_nTrue, fVector d_X, ui size );
ui VFcu_cnt_eq0( fVector h_X, ui size );

    (analog .._ne0, .._gt0, .._ge0, .._le0, .._lt0)

int cudaVF_cnt_eqC( ui *h_nTrue, fVector d_X, ui size, float C );
int cusdVF_cnt_eqC( ui *h_nTrue, fVector d_X, ui size, float *d_C );
ui VFcu_cnt_eqC( fVector h_X, ui size, float C );

    (analog: ..._neC, ..._gtC, ..._geC, ..._ltC, ..._leC)

int cudaVF_cnt_eqV( ui *h_nTrue, fVector d_X, fVector d_Y, ui size);
ui VFcu_cnt_eqV( fVector h_X, fVector h_Y, ui size);

    (analog: ..._neV, ..._gtV, ..._geV, ..._ltV, ..._leV)

int cudaVF_cnt_stV( ui *h_nTrue, fVector d_X, fVector d_Y, ui size, float TolRel, float TolAbs);
int cusdVF_cnt_stV( ui *h_nTrue, fVector d_X, fVector d_Y, ui size, float *d_TolRel, float *d_TolAbs);
ui VFcu_cnt_stV( fVector h_X, fVector h_Y, ui size, float TolRel, float TolAbs);

    (analog: ..._dtV)

int cudaVF_cnt_inclrange0C( ui *h_nTrue, fVector d_X, ui size, float C );
int cusdVF_cnt_inclrange0C( ui *h_nTrue, fVector d_X, ui size, float *d_C );
int cudaVF_cnt_inclrangeCC( ui *h_nTrue, fVector d_X, ui size, float CLo, float CHi );
int cusdVF_cnt_inclrangeCC( ui *h_nTrue, fVector d_X, ui size, float *d_CLo, float *d_CHi );
ui VFcu_cnt_inclrange0C( fVector h_X, ui size, float C );
ui VFcu_cnt_inclrangeCC( fVector h_X, ui size, float CLo, float CHi );

    (analog: ..._exclrange0C and ..._exclrangeCC)

CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cnt_eq0( var h_nTrue:UIntSize; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_cnt_eq0( h_X:fVector; size:UIntSize ): UIntSize;

    (analog: .._ne0, .._gt0, .._ge0, .._le0, .._lt0)

function cudaVF_cnt_eqC( var h_nTrue:UIntSize; d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_cnt_eqC( var h_nTrue:UIntSize; d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function VFcu_cnt_eqC( h_X:fVector; size:UIntSize; C:Single ): UIntSize;

    (analog: ..._neC, ..._gtC, ..._geC, ..._ltC, ..._leC)

function cudaVF_cnt_eqV( var h_nTrue:UIntSize; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function VFcu_cnt_eqV( h_X, h_Y:fVector; size:UIntSize ): UIntSize;

    (analog: ..._neV, ..._gtV, ..._geV, ..._ltV, ..._leV)

function cudaVF_cnt_eqV( var h_nTrue:UIntSize; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function VFcu_cnt_eqV( h_X, h_Y:fVector; size:UIntSize ): UIntSize;

    (similarly: ..._neV, ..._gtV, ..._geV, ..._ltV, ..._leV)

function cudaVF_cnt_stV( var h_nTrue:UIntSize; d_X, d_Y:fVector; size:UIntSize, TolRel, TolAbs:Single ): IntBool;
function cusdVF_cnt_stV( var h_nTrue:UIntSize; d_X, d_Y:fVector; size:UIntSize, d_TolRel, d_TolAbs:PSingle ): IntBool;
function VFcu_cnt_stV( h_X, h_Y:fVector; size:UIntSize, TolRel, TolAbs:Single ): UIntSize;

    (similarly: ..._dtV)

function cudaVF_cnt_inclrange0C( var h_nTrue:UIntSize; d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_cnt_inclrange0C( var h_nTrue:UIntSize; d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function cudaVF_cnt_inclrangeCC( var h_nTrue:UIntSize; d_X:fVector; size:UIntSize; CLo, CHi:Single ): IntBool;
function cusdVF_cnt_inclrangeCC( var h_nTrue:UIntSize; d_X:fVector; size:UIntSize; d_CLo, d_CHi:PSingle ): IntBool;
function VFcu_cnt_inclrange0C( h_X:fVector; size:UIntSize; C:Single ): UIntSize;
function VFcu_cnt_inclrangeCC( h_X:fVector; size:UIntSize; CLo, CHi:Single ): UIntSize;

    (analog: ..._exclrange0C and ..._exclrangeCC)

BeschreibungDie vorliegenden Funktionen arbeiten ähnlich VF_cmp_.... Hier allerdings wird nur die Anzahl der erfüllten Bedingungen (anstelle jedes einzelnen Vergleichs-Ergebnisses) ermittelt und zurückgegeben.

a) Einfache Vergleichsfunktionen:
Jedes Element von X wird mit 0, einer Konstanten C oder dem korrespondierenden Element eines anderen Vektors, Y, verglichen. Die dabei zu überprüfende Bedingung wird durch zwei Buchstaben angegeben:
 
"eq" ("equal")True, wenn Xi = 0 (oder C bzw. Yi)
"ne" ("not equal")True, wenn Xi ≠ 0 (oder C bzw. Yi)
"gt" ("gteater than")True, wenn Xi > 0 (oder C bzw. Yi)
"ge" ("greater or equal")   True, wenn Xi ≥ 0 (oder C bzw. Yi)
"lt" ("less than")True, wenn Xi < 0 (oder C bzw. Yi)
"le" ("less or equal")True, wenn Xi ≤ 0 (oder C bzw. Yi)
"st" ("similar to")True, wenn Xi ≈ Yi,   d.h. | Xi − Yi | ≤ max( |Yi| * TolRel, TolAbs)
"dt" ("dissimilar to")True, wenn Xi ≉ Yi,   d.h. | Xi − Yi | > max( |Yi| * TolRel, TolAbs)

Für komplexe Zahlen machen nur der Test auf Gleichheit ("eq"), Ungleichheit ("ne"), Ähnlichkeit ("st") und Unähnlichkeit ("dt") Sinn. Die übrigen Testbedingungen existieren nicht für komplexe Zahlen. Bei den Tests auf Ähnlichkeit ("st") und Unähnlichkeit ("dt") für komplexe Zahlen sind die Parameter TolRel und TolAbs ebenfalls komplex, um ggf. unterschiedliche Toleranzen für Real- und Imaginärteile festlegen zu können.
Für vorzeichenlose Ganzzahl-Typen existieren naturgemäß diejenigen Funktionen nicht, die die Bedingung Xi < 0 oder Xi ≤ 0 prüfen, ebensowenig wie die trivialen Tests Xi ≥ 0.

b) Bereichsprüfungs-Funktionen:
Für jedes Element von X wird geprüft, ob es in den Bereich fällt, der entweder durch 0 und eine (positive oder negative) Konstante C oder durch zwei Konstanten, CLo und CHi, spezifiziert wird. Dabei kann gewählt werden, ob der Bereich inclusiv oder exclusiv der Endpunkte zu verstehen ist:
VF_cnt_inclrange0C prüft, ob 0 ≤ x ≤ C (für positives C) oder 0 ≥ x ≥ C (für negatives C), während VF_cnt_exclrangeCC den Test auf CLo < x < CHi durchführt.
Für vorzeichenlose Ganzzahl-Typen existieren keine Funktionen "VU_cnt_inclrange0C", da die Bedingung Xi ≥ 0 trivialerweise immer erfüllt ist.

Fehlerbehandlungkeine
RückgabewertAnzahl der die Testbedingung erfüllenden Elemente
QuerverweisVF_cmp_...

 

VF_coherenceVD_coherenceVE_coherence
FunktionKohärenzfunktion zweier Signale
Syntax C/C++#include <VFstd.h>
float VF_coherence( fVector Coher, ui specsiz, fVector X, fVector Y, ui xsiz, fVector Win );
float VFb_coherence( fVector Coher, ui specsiz, fVector X, fVector Y, ui xsiz, fVector Win, fVector Buf );
C++ VecObj#include <OptiVec.h>
T vector<T>::coherence( const vector<T>& X, const vector<T>& Y, const vector<T>& Win );
T vector<T>::b_coherence( const vector<T>& X, const vector<T>& Y, const vector<T>& Win, vector<T>& Buf );
Pascal/Delphiuses VFstd;
function VF_coherence( Coher:fVector; specsiz:UIntSize; X,Y:fVector; xsiz:UIntSize; Win:fVector ): Single;
function VFb_coherence( Coher:fVector; specsiz:UIntSize; X,Y:fVector; xsiz:UIntSize; Win, Buf:fVector ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_coherence( float *h_coherfNyq, fVector d_Coher, ui specsiz, fVector d_X, fVector d_Y, ui xsiz, fVector d_Win );
int cusdVF_coherence( float *d_coherfNyq, fVector d_Coher, ui specsiz, fVector d_X, fVector d_Y, ui xsiz, fVector d_Win );
float VFcu_coherence( fVector h_Coher, ui specsiz, fVector h_X, fVector h_Y, ui xsiz, fVector h_Win );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_coherence( var h_coherfNyq:Single; d_Coher:fVector; specsiz:UIntSize; d_X, d_Y:fVector; xsiz:UIntSize; d_Win:fVector ): IntBool;
function cusdVF_coherence( d_coherfNyq:PSingle; d_Coher:fVector; specsiz:UIntSize; d_X, d_Y:fVector; xsiz:UIntSize; d_Win:fVector ): IntBool;
function VFcu_coherence( h_Coher:fVector; specsiz:UIntSize; h_X, h_Y:fVector; xsiz:UIntSize; h_Win:fVector ): Single;
BeschreibungDie Kohärenzfunktion der beiden Datensätze X und Y wird ermittelt. Sie ist definiert als das Betragsquadrat des Kreuzleistungsspektrums von X und Y dividiert durch das Produkt der beiden Autoleistungsspektren von X und Y:
CXY = SXY2 / (SXX * SYY).
Da das Ergebnis für negative und positive Frequenzen identisch ist, wird hier das Ergebnis nur für f=0 und positive Frequenzen gespeichert. Um specsiz als ganzzahlige Potenz von 2 definieren zu können, werden hier jedoch nur specsiz Punkte in Spc zurückgegeben. Der letzte Wert, d.h. die Kohärenzfunktion für die Nyquist-Frequenz, 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
Coher[specsiz] = VF_coherence( Coher, specsiz, X, X, xsiz, Win );
In diesem Fall muss Coher 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 Kreuz- sowie Autoleistungsspektren gemittelt, bevor aus den Mittelwerten die Kohärenzfunktion bestimmt wird.

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_coherence zusätzlichen Pufferspeicher, der automatisch reserviert und wieder freigegeben wird. Bei wiederholten Aufrufen wäre dies ineffizient. Es wird empfohlen, für solche Fälle stattdessen VFb_coherence zu verwenden. Die Größe von Buf muss dabei ≥ 4*xsiz + 8*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.

FehlerbehandlungWenn size nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf VF_coherence basiert) mit der Fehlermeldung "Size must be integer power of 2." und bricht das Programm ab.
RückgabewertKohärenzfunktion bei der Nyquist-Frequenz
QuerverweisVF_FFT,   VF_spectrum,   VF_xspectrum,   VF_convolve,   VF_autocorr,   VF_xcorr,   VF_filter

 

VF_combVD_combVE_comb
FunktionKamm-Funktion
Syntax C/C++#include <VFstd.h>
void VF_comb( fVector X, ui size, ui spac, float C );
C++ VecObj#include <OptiVec.h>
void vector<T>::comb( ui spac, const T& C );
Pascal/Delphiuses VFstd;
procedure VF_comb( X:fVector; size:UIntSize; spac:Word; C:Single );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_comb( fVector d_X, ui size, ui spac, float C );
int cusdVF_comb( fVector d_X, ui size, ui spac, float *d_C );
void VFcu_comb( fVector h_X, ui size, ui spac, float C );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_comb( d_X:fVector; size:UIntSize; spac:Word; C:Single ): IntBool;
function cusdVF_comb( d_X:fVector; size:UIntSize; spac:Word; d_C:PSingle ): IntBool;
procedure VFcu_comb( h_X:fVector; size:UIntSize; spac:Word; C:Single );
BeschreibungXi = C, i = 0, 1*spac, 2*spac,...
Xi = 0, ansonsten
FehlerbehandlungWenn das Intervall spac zwischen den "Zinken" des Kammes größer ist als size, wird eine Fehlermeldung "Invalid parameter(s)" ausgegeben und das Programm abgebrochen.
Rückgabewertkeiner
QuerverweisVF_equ1,   VF_equ0,   VF_equC

 

VCF_complexVCD_complexVCE_complex
VPF_complexVPD_complexVPE_complex
FunktionKonstruktion eines (cartesisch- oder polar-) komplexen Vektors aus Real- und Imaginärteil.
Syntax C/C++#include <VCFstd.h>
void VCF_complex( cfVector X, fVector Re, fVector Im, ui size );
C++ VecObj#include <OptiVec.h>
void vector<complex<T>>::complex( vector<T> Re, vector<T> Im );
Pascal/Delphiuses VCFstd;
procedure VCF_complex( X:cfVector; Re, Im:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVCF_complex( cfVector d_X, fVector d_Re, fVector d_Im, ui size );
void VCFcu_complex( cfVector h_X, fVector h_Re, fVector h_Im, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVCF_complex( d_X:cfVector; d_Re, d_Im:fVector; size:UIntSize ): IntBool;
procedure VCFcu_complex( h_X:cfVector; h_Re, h_Im:fVector; size:UIntSize );
BeschreibungIdentisch mit VF_ReImtoC,   VD_ReImtoC und VE_ReImtoC. Siehe dort.

 

VCF_conjVCD_conjVCE_conj
VPF_conjVPD_conjVPE_conj
FunktionKomplex-konjugierte Form
Syntax C/C++#include <VCFmath.h>
int VCF_conj( cfVector Y, cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<complex<T>>::conj( const vector<complex<T>>& X );
Pascal/Delphiuses VCFmath;
function VCF_conj( Y, X:cfVector; size:UIntSize ): IntBool;
CUDA-Funktion C/C++#include <cudaVCFmath.h>
int cudaVCF_conj( cfVector d_Y, cfVector d_X, ui size );
void VCFcu_conj( cfVector h_Y, cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFmath;
function cudaVCF_conj( d_Y, d_X:cfVector; size:UIntSize ): IntBool;
procedure VCFcu_conj( h_Y, h_X:cfVector; size:UIntSize );
BeschreibungRe(Yi) = Re(Xi)
Im(Yi) = -Im(Xi)
Fehlerbehandlungkeine
Rückgabewertimmer FALSE(0)
QuerverweisVCF_neg,   VCF_revconj,   VCF_abs

 

V_continuePlot
FunktionZum letzten für Plot-Operationen verwendeten Viewport zurückkehren
Syntax C/C++#include <Vgraph.h>
void V_continuePlot( void );
Pascal/Delphiuses Vgraph;
procedure V_continuePlot;
BeschreibungFalls man neue DataPlots zu einem existierenden Koordinatensystem hinzufügen möchte, nachdem man bereits einen neuen Viewport definiert hat (z.B. für Textausgabe), bringt einen diese Funktion zurück zum letzt-verwendeten Koordinatensystem und stellt alle nötigen Skalierungs- und Positions-Einstellungen wieder her.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisV_getCoordSystem,   V_setCoordSystem,   V_setPlotRegion

 

VF_convolveVD_convolveVE_convolve
VF_convolvewEditVD_convolvewEditVE_convolvewEdit
VFb_convolveVDb_convolveVEb_convolve
VFb_convolvewEditVDb_convolvewEditVEb_convolvewEdit
FunktionFaltung (Konvolution) mit einer Impuls-Antwortfunktion
Syntax C/C++#include <VFstd.h>
void VF_convolve( fVector Y, fVector Flt, fVector X, fVector Rsp, ui size );
void VF_convolvewEdit( fVector Y, fVector Flt, fVector X, fVector Rsp, ui size; fComplex thresh );
void VFb_convolve( fVector Y, fVector Flt, fVector X, fVector Rsp, ui size, fVector Buf );
void VFb_convolvewEdit( fVector Y, fVector Flt, fVector X, fVector Rsp, ui size; fComplex thresh, fVector Buf );
C++ VecObj#include <OptiVec.h>
void vector<T>::convolve( vector<T> Flt, const vector<T>& X, const vector<T>& Rsp );
void vector<T>::convolvewEdit( vector<T> Flt, const vector<T>& X, const vector<T>& Rsp, complex<T> thresh );
void vector<T>::b_convolve( vector<T> Flt, const vector<T>& X, const vector<T>& Rsp, vector<T> Buf );
void vector<T>::b_convolvewEdit( vector<T> Flt, const vector<T>& X, const vector<T>& Rsp, complex<T> thresh, vector<T> Buf );
Pascal/Delphiuses VFstd;
procedure VF_convolve( Y, Flt, X, Rsp:fVector; size:UIntSize );
procedure VF_convolvewEdit( Y, Flt, X, Rsp:fVector; size:UIntSize; thresh:fComplex );
procedure VFb_convolve( Y, Flt, X, Rsp:fVector; size:UIntSize; Buf:fVector );
procedure VFb_convolvewEdit( Y, Flt, X, Rsp:fVector; size:UIntSize; thresh:fComplex; Buf:fVector );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_convolve( fVector d_Y, fVector d_Flt, fVector d_X, fVector d_Rsp, ui size );
void VFcu_convolve( fVector h_Y, fVector h_Flt, fVector h_X, fVector h_Rsp, ui size );
int cudaVF_convolvewEdit( fVector d_Y, fVector d_Flt, fVector d_X, fVector d_Rsp, ui size, fComplex thresh );
void VFcu_convolvewEdit( fVector h_Y, fVector h_Flt, fVector h_X, fVector h_Rsp, ui size, fComplex thresh );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_convolve( d_Y, d_Flt, d_X, d_Rsp:fVector; size:UIntSize ): IntBool;
procedure VFcu_convolve( h_Y, h_Flt, h_X, h_Rsp:fVector; size:UIntSize );
function cudaVF_convolvewEdit( d_Y, d_Flt, d_X, d_Rsp:fVector; size:UIntSize; thresh:fComplex ): IntBool;
procedure VFcu_convolvewEdit( h_Y, h_Flt, h_X, h_Rsp:fVector; size:UIntSize; thresh:fComplex );
BeschreibungDer Vektor X wird mit der Impulsantwortfunktion (engl: response function) Rsp gefaltet und das Ergebnis in Y gespeichert. Ein Filter Flt wird gleichzeitig berechnet. Sollen mehr als nur ein Vektor mit derselben Impulsantwortfunktion gefaltet werden, so benutze man VF_convolve lediglich für den ersten. Für die weiteren rufe man VF_filter mit dem durch VF_convolve berechneten Filter.
Die Response-Funktion muss so in Rsp übergeben werden, dass der Nullpunkt auf dem nullten Element liegt. Die Elemente für positive Zeiten (oder was immer die unabhängige Variable ist) folgen als Rsp1 bis Rspsize/2 und die Elemente für negative Zeiten, beginnend mit der am stärksten negativen Zeit, als Rspsize/2+1 bis Rspsize−1. Um diese Ordnung zu erreichen, bediene man sich gegebenenfalls der Funktionen VF_rotate oder VF_reflect.

Das Ergebnis der Faltung erscheint skaliert mit der Summe aller Elemente von Rsp. Um eine Amplituden-neutrale Faltung durchzuführen, muss Rsp also auf 1.0 normiert sein.

X, Y, Rsp und Flt müssen alle dieselbe Größe size besitzen; diese muss eine ganzzahlige Potenz von 2 sein. X darf durch Y überschrieben werden und Rsp durch Flt, aber X und Flt sowie Y und Rsp müssen voneinander verschieden sein.

Eine Response-Funktion, bei der manche Frequenzen so stark gedämpft werden, dass für sie jegliche Information verlorengeht (also z.B. die hohen Frequenzen bei einem Tiefpass-Filter), erkennt man an sehr kleinen Werten von Flt für die betreffenden Frequenzen. Sehr klein" bedeutet dabei, dass sie relativ zu dem Spitzenwert im Bereich der Genauigkeit des jeweiligen Datentypes liegen, also in der Größenordnung von VF_absmax(Flt, size)*epsilon. Zur Minimierung von Rundungsfehlern bei der Faltung ersetzt VF_convolve solche sehr kleinen Werte in Flt durch 0. Der standardmäßig verwendete Schwellenwert hierfür kann durch VF_setRspEdit ausgelesen werden. Um für sämtliche Aufrufe von VF_convolve und VF_deconvolve einen anderen Schwellenwert einzustellen, kann die Funktion VF_setRspEdit aufgerufen werden. Diese Methode ist aber nicht fiber-sicher und daher nicht geeignet, um den Schwellenwert bei verschiedenen Aufrufen von VF_convolve bzw. VF_deconvolve unterschiedlich einzustellen. Hier muss die Variante VF_convolvewEdit verwendet werden, die den gewünschten Schwellenwert als Argument thresh übernimmt (und die standardmäßig eingestellte Schwelle ignoriert). Da Flt aus komplexen Zahlen besteht und es gelegentlich wünschenswert ist, Real- und Imaginärteile unterschiedlich zu behandeln, ist thresh ebenfalls komplex.

Intern benötigt VF_convolve / VF_convolvewEdit zusätzlichen Pufferspeicher, der automatisch reserviert und wieder freigegeben wird. Bei wiederholten Aufrufen wäre dies ineffizient. Es wird empfohlen, für solche Fälle stattdessen VFb_convolve / VFb_convolvewEdit zu verwenden. Die Größe von Buf muss dabei ≥ 2*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.
 

Beispiel C/C++VF_ramp( Time, 1024, 0.0, 1.0 );
VF_Gauss( Rsp, Time, 513, 10.0, 0.0, 1.0 );
      /* Response-Funktion für positive Zeiten ab 0 */
VF_reflect( Rsp+1, 1023 );
      /* ... und für negative Zeiten */
VF_divC( Rsp, Rsp, 1024, VF_sum( Rsp, 1024 ) );
      /* Normierung */
VF_convolve( X, Rsp, X, Rsp, 1024 );
      /* Faltung; X wird durch das gesuchte Ergebnis über-
         schrieben und Rsp durch das Frequenzfilter */
VF_filter( Y, Y, Rsp, 1024 );
      /* nächste Faltung: Anstatt eines erneuten Aufrufs von
         VF_convolve wird Y mit dem eben aus Rsp gewonnenen
         Frequenzfilter gefiltert */
 
Beispiel Pascal/DelphiVF_ramp( Time, 1024, 0.0, 1.0 );
VF_Gauss( Rsp, Time, 513, 10.0, 0.0, 1.0 );
      (* Response-Funktion für positive Zeiten ab 0 *)
VF_reflect( VF_Pelement(Rsp,1), 1023 );
      (* ... und für negative Zeiten *)
VF_divC( Rsp, Rsp, 1024, VF_sum( Rsp, 1024 ) );
      (* Normierung *)
VF_convolve( X, Rsp, X, Rsp, 1024 );
      (* Faltung; X wird durch das gesuchte Ergebnis über-
         schrieben und Rsp durch das Frequenzfilter *)
VF_filter( Y, Y, Rsp, 1024 );
      (* nächste Faltung: Anstatt eines erneuten Aufrufs von
         VF_convolve wird Y mit dem eben aus Rsp gewonnenen
         Frequenzfilter gefiltert  *)

Mathematisch basiert diese Faltung auf der Annahme, dass X periodisch ist. Sie funktioniert auch dann noch gut, wenn X zwar nicht periodisch ist, aber an beiden Enden zu demselben Wert konvergiert (also X0 = Xsize−1). Ist dies nicht der Fall, so beeinflussen sich die Elemente an beiden Enden gegenseitig, und es kommt zu Rand-Effekten. Um diese zu vermeiden, muss X gegebenenfalls an beiden Enden so extrapoliert werden, dass sich der ursprüngliche Vektor X in der Mitte eines größeren Vektors wiederfindet. Es sind mindestens so viele Elemente an beiden Seiten anzufügen, wie der halben Breite der Impulsantwortfunktion entspricht (bei asymmetrischen Antwortfunktionen nehme man die breitere Flanke als Maß). Die Faltung ist dann für den größeren Vektor durchzuführen. Die gesuchte Faltung von X mit Rsp befindet sich in der Mitte des so erhaltenen Ergebnis-Vektors.

Sind die Werte an beiden Enden von X zwar nicht gleich, werden aber jeweils durch genügend "sanfte" Konvergenz erreicht, so kann der Unterschied zwischen den Endpunkten auch als linearer Trend betrachtet werden. Man muss diesen dann nur für die Faltung beseitigen und zum erhaltenen Ergebnis wieder hinzuaddieren.

Beispiel C/C++d = (X[size−1] - X[0]) / (size−1);
VF_ramp( Trend, size, 0.0, d );
VF_subV( Y, X, Trend, size );
VF_convolve( Y, Flt, Y, Rsp, size );
VF_addV( Y, Y, Trend, size );
Beispiel für die Vermeidung von Randeffekten in Pascal/Delphi d := (VF_element(X,size−1) - X^) / (size−1);
VF_ramp( Trend, size, 0.0, d );
VF_subV( Y, X, Trend, size );
VF_convolve( Y, Flt, Y, Rsp, size );
VF_addV( Y, Y, Trend, size );

Man wird bemerken, dass Flt als fVector und nicht als cfVector deklariert ist, obwohl die in Flt gespeicherte Information aus komplexen Zahlen besteht. Der Grund ist, dass diese Zahlen in dem bei VF_FFT beschriebenen gepackten Format vorliegen, das ausschließlich im Zusammenhang mit der Fourier-Transformation reeller Vektoren angewandt wird.

FehlerbehandlungWenn size nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf VF_convolve basiert) mit der Fehlermeldung "Size must be integer power of 2." und bricht das Programm ab.
Rückgabewertkeiner
QuerverweisVF_filter,   VF_deconvolve,   VF_FFT,   VF_autocorr,   VF_xcorr,   VF_spectrum

 

VF_corrcoeffVD_corrcoeffVE_corrcoeff
FunktionLinearer Korrelationskoeffizient zwischen zwei Verteilungen
Syntax C/C++#include <VFstd.h>
float VF_corrcoeff( fVector X, fVector Y, ui size, float Xmean, float Ymean );
C++ VecObj#include <OptiVec.h>
T vector<T>::corrcoeff( const vector<T>& Y, T Xmean, T Ymean );
Pascal/Delphiuses VFstd;
function VF_corrcoeff( X, Y:fVector; size:UIntSize; Xmean, Ymean:Single ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_corrcoeff( ui *h_RetVal, fVector d_X, fVector d_Y, ui size, float Xmean, float Ymean );
int cusdVF_corrcoeff( ui *d_RetVal, fVector d_X, fVector d_Y, ui size, float *d_Xmean, float *d_Ymean );
float VFcu_corrcoeff( fVector h_X, fVector h_Y, ui size, float Xmean, float Ymean );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_corrcoeff( var h_RetVal:Single; d_X, d_Y:fVector; size:UIntSize; Xmean, Ymean:Single ): IntBool;
function cusdVF_corrcoeff( d_RetVal:PSingle; d_X, d_Y:fVector; size:UIntSize; d_Xmean, d_Ymean:PSingle ): IntBool;
procedure VFcu_corrcoeff( h_X, h_Y:fVector; size:UIntSize; Xmean, Ymean:Single );
BeschreibungDer Pearson'sche lineare Korrelationskoeffizient r liegt zwischen −1.0 und +1.0. Die Mittelwerte beider Verteilungen müssen bekannt sein und an VF_corrcoeff als Parameter Xmean und Ymean übergeben werden.
Beispiel C/C++r = VF_corrcoeff( X, Y, n, VF_mean( X, n ), VF_mean( Y, n ) );
Rückgabewertlinearer Korrelationskoeffizient r
QuerverweisVF_mean,   VF_varianceV,   VF_linregress

 

VF_cosVD_cosVE_cos
VFx_cosVDx_cosVEx_cos
VFr_cosVDr_cosVEr_cos
VFrx_cosVDrx_cosVErx_cos
VCF_cosVCD_cosVCE_cos
VCFx_cosVCDx_cosVCEx_cos
FunktionCosinus-Funktion
Syntax C/C++#include <VFmath.h>
int VF_cos( fVector Y, fVector X, ui size );
int VFx_cos( fVector Y, fVector X, ui size, float A, float B, float C );
int VFr_cos( fVector Y, fVector X, ui size );
int VFrx_cos( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::cos( const vector<T>& X );
int vector<T>::x_cos( const vector<T>& X, const T& A, const T& B, const T& C );
int vector<T>::r_cos( const vector<T>& X );
int vector<T>::rx_cos( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_cos( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_cos( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function VFr_cos( Y, X:fVector; size:UIntSize ): IntBool;
function VFrx_cos( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cos( fVector d_Y, fVector d_X, ui size );
int cudaVFx_cos( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_cos( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_cos( fVector h_Y, fVector h_X, ui size );
int VFxcu_cos( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cos( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_cos( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_cos( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_cos( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_cos( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = cos ( Xi )
erweiterte Versionen: Yi = C * cos ( 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_cosrpi als VF_cos 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.

FehlerbehandlungGenauigkeits-Fehler führen in den reellen Funktionen zum Resultat 1.0 (als ob das Argument 0.0 wäre) und zu einem Rückgabewert TRUE (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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_cos2,   VF_cosrpi,   VF_sin,   VF_cosh,   VF_acos,   cos

 

VF_cos2VD_cos2VE_cos2
VFx_cos2VDx_cos2VEx_cos2
VFr_cos2VDr_cos2VEr_cos2
VFrx_cos2VDrx_cos2VErx_cos2
FunktionQuadrat der Cosinus-Funktion
Syntax C/C++#include <VFmath.h>
int VF_cos2( fVector Y, fVector X, ui size );
int VFx_cos2( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::cos2( const vector<T>& X );
int vector<T>::x_cos2( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_cos2( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_cos2( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cos2( fVector d_Y, fVector d_X, ui size );
int cudaVFx_cos2( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_cos2( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_cos2( fVector h_Y, fVector h_X, ui size );
int VFxcu_cos2( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cos2( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_cos2( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_cos2( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_cos2( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_cos2( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = cos2( Xi )
erweiterte Versionen: Yi = 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.

FehlerbehandlungGenauigkeits-Fehler führen zum Resultat 1.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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_cos,   VF_cosrpi,  cos

 

VF_cosecVD_cosecVE_cosec
VFx_cosecVDx_cosecVEx_cosec
FunktionCosecans-Funktion
Syntax C/C++#include <VFmath.h>
int VF_cosec( fVector Y, fVector X, ui size );
int VFx_cosec( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::cosec( const vector<T>& X );
int vector<T>::x_cosec( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_cosec( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_cosec( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cosec( fVector d_Y, fVector d_X, ui size );
int cudaVFx_cosec( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_cosec( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_cosec( fVector h_Y, fVector h_X, ui size );
int VFxcu_cosec( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cosec( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_cosec( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_cosec( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_cosec( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_cosec( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = cosec ( Xi ) = 1.0 / sin ( Xi )
erweiterte Versionen: Yi = C * cosec ( A*Xi + B )
Der Cosecans ist als Kehrwert des Sinus definiert (nicht zu verwechseln mit der Umkehrfunktion des Sinus, arcsin). 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_cosecrpi als VF_cosec verwenden.
FehlerbehandlungFür TLOSS-Genauigkeitsfehler wird das Ergebnis willkürlich gleich 1.0 gesetzt. Dies stellt eine Ausnahme von der Regel dar, nach der das Ergebnis der Mittelwert der Funktionswerte für +0 und −0 sein sollte. Dieser wäre 0.0, gehört aber nicht zum Wertebereich der Cosecans-Funktion.
Für SING- und OVERFLOW-Fehler ist das Ergebnis ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_cosec2,   VF_cosecrpi,   VF_sin,   VF_cosech,   sin

 

VF_cosec2VD_cosec2VE_cosec2
VFx_cosec2VDx_cosec2VEx_cosec2
FunktionQuadrat des Cosecans
Syntax C/C++#include <VFmath.h>
int VF_cosec2( fVector Y, fVector X, ui size );
int VFx_cosec2( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::cosec2( const vector<T>& X );
int vector<T>::x_cosec2( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_cosec2( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_cosec2( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cosec2( fVector d_Y, fVector d_X, ui size );
int cudaVFx_cosec2( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_cosec2( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_cosec2( fVector h_Y, fVector h_X, ui size );
int VFxcu_cosec2( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cosec2( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_cosec2( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_cosec2( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_cosec2( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_cosec2( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = cosec2 ( Xi )
erweiterte Versionen: Yi = C * cosec2 ( A*Xi + B )
Das Quadrat trigonometrischer Funktionen läßt sich schneller und genauer direkt als über den Umweg der jeweils zugrundeliegenden Funktion bestimmen.
FehlerbehandlungFür SING-, OVERFLOW- und TLOSS-Fehler ist das Ergebnis ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_cosec,   VF_cosecrpi,  sin

 

VF_cosechVD_cosechVE_cosech
VFx_cosechVDx_cosechVEx_cosech
FunktionHyperbel−Cosecans
Syntax C/C++#include <VFmath.h>
int VF_cosech( fVector Y, fVector X, ui size );
int VFx_cosech( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::cosech( const vector<T>& X );
int vector<T>::x_cosech( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_cosech( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_cosech( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cosech( fVector d_Y, fVector d_X, ui size );
int cudaVFx_cosech( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_cosech( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_cosech( fVector h_Y, fVector h_X, ui size );
int VFxcu_cosech( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cosech( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_cosech( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_cosech( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_cosech( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_cosech( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = cosech ( Xi )
erweiterte Versionen: Yi = C * cosech ( A*Xi+B )
FehlerbehandlungSING-Fehler ergeben ein Ergebnis von 0 (Mittelwert von +HUGE_VAL und -HUGE_VAL). OVERFLOW-Fehler ergeben ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_sinh,   VF_exp,   sinh

 

VF_cosecrpiVD_cosecrpiVE_cosecrpi
VF_cosecrpi2VD_cosecrpi2VE_cosecrpi2
VF_cosecrpi3VD_cosecrpi3VE_cosecrpi3
FunktionCosecans von gebrochenzahligen Vielfachen von p
Syntax C/C++#include <VFmath.h>
int VF_cosecrpi( fVector Y, iVector P, ui size, int q );
int VF_cosecrpi2( fVector Y, iVector P, ui size, int q );
int VF_cosecrpi3( fVector Y, iVector P, ui size, int q );
C++ VecObj#include <OptiVec.h>
int vector<T>::cosecrpi( const vector<int>& P, int q );
int vector<T>::cosecrpi2( const vector<int>& P, int q );
int vector<T>::cosecrpi3( const vector<int>& P, int q );
Pascal/Delphiuses VFmath;
function VF_cosecrpi( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
function VF_cosecrpi2( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
function VF_cosecrpi3( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cosecrpi( fVector d_Y, iVector d_P, ui size, int q );
int cudaVF_cosecrpi2( fVector d_Y, iVector d_P, ui size, int q );
int cudaVF_cosecrpi3( fVector d_Y, iVector d_P, ui size, int q );
int VFcu_cosecrpi( fVector h_Y, iVector h_P, ui size, int q );
int VFcu_cosecrpi2( fVector h_Y, iVector h_P, ui size, int q );
int VFcu_cosecrpi3( fVector h_Y, iVector h_P, ui size, int q );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cosecrpi( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function cudaVF_cosecrpi2( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function cudaVF_cosecrpi3( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_cosecrpi( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_cosecrpi2( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_cosecrpi3( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
BeschreibungYi = cosec( (Pi / q) * p )
Es gibt drei Versionen. VF_cosecrpi 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_cosecrpi2 eingesetzt werden, die viele Funktionswerte einer Tabelle entnimmt. Wenn q ein Vielfaches von 3 ist, sollte VF_cosecrpi3 gebraucht werden. VF_cosecrpi2 und VF_cosecrpi3 funktionieren auch mit Werten von q, für die sie nicht optimiert sind. Es wird allerdings Speicherplatz für die dann nutzlosen Tabellen vergeudet.
FehlerbehandlungSING-Fehler entstehen, wenn Pi exakt durch q teilbar ist. Das Resultat ist in diesem Fall 0.0 (der Mittelwert zwischen +HUGE_VAL und -HUGE_VAL; anders als bei VF_cosec wird hier keine Rücksicht darauf genommen, dass 0.0 nicht zum Wertebereich der Cosecans-Funktion gehört).
q muss ungleich 0 sein; dies wird allerdings nicht überprüft.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_cosec,   sin

 

VF_cosectab2VD_cosectab2VE_cosectab2
VF_cosectab3VD_cosectab3VE_cosectab3
 Tabelle der Cosecans-Funktion für Argumente zwischen 0 und p/2.
Syntax C/C++#include <xmath.h>
extern float    VF_cosectab2[ VF_tabsz2+1 ];
extern double   VD_cosectab2[ VD_tabsz2+1 ];
extern extended VE_cosectab2[ VE_tabsz2+1 ];
extern float    VF_cosectab3[ VF_tabsz3+1 ];
extern double   VD_cosectab3[ VD_tabsz3+1 ];
extern extended VE_cosectab3[ VE_tabsz3+1 ];
Pascal/Delphiuses FCSCTAB3, DCSCTAB3, ECSCTAB3;
VF_cosectab2: array[0..VF_tabsz2] of Single;
VD_cosectab2: array[0..VD_tabsz2] of Double;
VE_cosectab2: array[0..VE_tabsz2] of Extended;
VF_cosectab3: array[0..VF_tabsz3] of Single;
VD_cosectab3: array[0..VD_tabsz3] of Double;
VE_cosectab3: array[0..VE_tabsz3] of Extended;
Beschreibung VF_cosectab2[ i ] = cosec ( i/(2*VF_tabsz2) * p ),    i=0,...,VF_tabsz2−1
VF_cosectab3[ i ] = cosec ( i/(2*VF_tabsz3) * p ),    i=0,...,VF_tabsz3−1
VF_cosectab2[ VF_tabsz2 ] = VF_cosectab3[ VF_tabsz3 ] = 0

Diese Tabellen werden von VF_cosecrpi2 und den übrigen Funktionen dieser Familie benutzt und sind auch für andere Zwecke zugänglich. Da der Cosecans von p/2 nicht definiert ist, ist eine 0 an seiner Stelle gespeichert.
C/C++: Die Symbole VF_tabsz2 etc., die die Größe der Tabellen angeben, sind in <xmath.h> definiert.
Delphi: Die Symbole VF_tabsz2 etc. sind jeweils in derselben unit wie die Tabellen definiert.
Lazarus / FreePascal: Diese Tabellen stehen für Lazarus / FreePascal nicht zur Verfügung.

 

VF_coshVD_coshVE_cosh
VFx_coshVDx_coshVEx_cosh
VCF_coshVCD_coshVCE_cosh
VCFx_coshVCDx_coshVCEx_cosh
FunktionHyperbel−Cosinus
Syntax C/C++#include <VFmath.h>
int VF_cosh( fVector Y, fVector X, ui size );
int VFx_cosh( fVector Y, fVector X, ui size, float A, float B, float C );
int VCF_cosh( cfVector Y, cfVector X, ui size );
int VCFx_cosh( cfVector Y, cfVector X, ui size, fComplex A, fComplex B, fComplex C );
C++ VecObj#include <OptiVec.h>
int vector<T>::cosh( const vector<T>& X );
int vector<T>::x_cosh( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_cosh( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_cosh( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cosh( fVector d_Y, fVector d_X, ui size );
int cudaVFx_cosh( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_cosh( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_cosh( fVector h_Y, fVector h_X, ui size );
int VFxcu_cosh( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cosh( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_cosh( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_cosh( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_cosh( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_cosh( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = cosh ( Xi )
erweiterte Versionen: Yi = C * cosh ( A*Xi+B )
FehlerbehandlungOVERFLOW-Fehler ergeben ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_sinh,   VF_exp,  cosh

 

VF_cosrpiVD_cosrpiVE_cosrpi
VF_cosrpi2VD_cosrpi2VE_cosrpi2
VF_cosrpi3VD_cosrpi3VE_cosrpi3
FunktionCosinus von gebrochenzahligen Vielfachen von p
Syntax C/C++#include <VFmath.h>
int VF_cosrpi( fVector Y, iVector P, ui size, int q );
int VF_cosrpi2( fVector Y, iVector P, ui size, int q );
int VF_cosrpi3( fVector Y, iVector P, ui size, int q );
C++ VecObj#include <OptiVec.h>
int vector<T>::cosrpi( const vector<int>& P, int q );
int vector<T>::cosrpi2( const vector<int>& P, int q );
int vector<T>::cosrpi3( const vector<int>& P, int q );
Pascal/Delphiuses VFmath;
function VF_cosrpi( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
function VF_cosrpi2( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
function VF_cosrpi3( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cosrpi( fVector d_Y, iVector d_P, ui size, int q );
int cudaVF_cosrpi2( fVector d_Y, iVector d_P, ui size, int q );
int cudaVF_cosrpi3( fVector d_Y, iVector d_P, ui size, int q );
int VFcu_cosrpi( fVector h_Y, iVector h_P, ui size, int q );
int VFcu_cosrpi2( fVector h_Y, iVector h_P, ui size, int q );
int VFcu_cosrpi3( fVector h_Y, iVector h_P, ui size, int q );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cosrpi( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function cudaVF_cosrpi2( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function cudaVF_cosrpi3( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_cosrpi( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_cosrpi2( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_cosrpi3( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
BeschreibungYi = cos( (Pi / q) * p )
Es gibt drei Versionen. VF_cosrpi 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_cosrpi2 eingesetzt werden, die viele Funktionswerte einer Tabelle entnimmt. Wenn q ein Vielfaches von 3 ist, sollte VF_cosrpi3 gebraucht werden. VF_cosrpi2 und VF_cosrpi3 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_cosrpi3 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.
FehlerbehandlungEs dürften keine Fehler auftreten, so lange q ≠ 0.
Rückgabewertimmer FALSE(0)
QuerverweisVF_cos,   cos

 

VF_cotVD_cotVE_cot
VFx_cotVDx_cotVEx_cot
FunktionCotangent function
Syntax C/C++#include <VFmath.h>
int VF_cot( fVector Y, fVector X, ui size );
int VFx_cot( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::cot( const vector<T>& X );
int vector<T>::x_cot( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_cot( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_cot( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cot( fVector d_Y, fVector d_X, ui size );
int cudaVFx_cot( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_cot( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_cot( fVector h_Y, fVector h_X, ui size );
int VFxcu_cot( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cot( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_cot( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_cot( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_cot( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_cot( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = cot ( Xi )
erweiterte Versionen: Yi = C * cot ( A*Xi+B )
Der Cotangens ist als Kehrwert des Tangens definiert (nicht zu verwechseln mit dessen Umkehrfunktion arctan). 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_cotrpi als VF_cot verwenden.
FehlerbehandlungTLOSS-Genauigkeitsfehler führen zu einem Resultat von 0.0 (dem Mittelwert von +HUGE_VAL und -HUGE_VAL); für SING- und OVERFLOW-Fehler ist das vorgeschlagene Ergebnis ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_cot2,   VF_cotrpi,   VF_coth,   VF_atan,   VF_atan2,   tan

 

VF_cot2VD_cot2VE_cot2
VFx_cot2VDx_cot2VEx_cot2
FunktionQuadrat der Cotangens-Funktion
Syntax C/C++#include <VFmath.h>
int VF_cot2( fVector Y, fVector X, ui size );
int VFx_cot2( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::cot2( const vector<T>& X );
int vector<T>::x_cot2( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_cot2( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_cot2( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cot2( fVector d_Y, fVector d_X, ui size );
int cudaVFx_cot2( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_cot2( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_cot2( fVector h_Y, fVector h_X, ui size );
int VFxcu_cot2( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cot2( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_cot2( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_cot2( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_cot2( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_cot2( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = cot2( Xi )
erweiterte Versionen: Yi = C * cot2( A*Xi+B )
Das Quadrat trigonometrischer Funktionen läßt sich schneller und genauer direkt als über den Umweg der jeweils zugrundeliegenden Funktion bestimmen.
FehlerbehandlungFür SING-, OVERFLOW- und TLOSS-Fehler ist das Ergebnis HUGE_VAL (multipliziert mit dem Vorzeichen von C in den erweiterten Versionen).
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_cot,   VF_cotrpi,   tan

 

VF_cothVD_cothVE_coth
VFx_cothVDx_cothVEx_coth
FunktionHyperbel−Cotangens
Syntax C/C++#include <VFmath.h>
int VF_coth( fVector Y, fVector X, ui size );
int VFx_coth( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::coth( const vector<T>& X );
int vector<T>::x_coth( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_coth( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_coth( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_coth( fVector d_Y, fVector d_X, ui size );
int cudaVFx_coth( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_coth( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_coth( fVector h_Y, fVector h_X, ui size );
int VFxcu_coth( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_coth( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_coth( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_coth( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_coth( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_coth( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = coth ( Xi )
erweiterte Versionen: Yi = C * coth ( A*Xi+B )
FehlerbehandlungSING-Fehler führen zu einem Ergebnis von 0.0 (Mittelwert zwischen +HUGE_VAL und -HUGE_VAL). OVERFLOW-Fehler ergeben ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_sinh,   VF_tanh,   VF_exp,   tanh

 

VF_cotrpiVD_cotrpiVE_cotrpi
VF_cotrpi2VD_cotrpi2VE_cotrpi2
VF_cotrpi3VD_cotrpi3VE_cotrpi3
FunktionCotangens-Funktion für gebrochenzahlige Vielfache von p
Syntax C/C++#include <VFmath.h>
int VF_cotrpi( fVector Y, iVector P, ui size, int q );
int VF_cotrpi2( fVector Y, iVector P, ui size, int q );
int VF_cotrpi3( fVector Y, iVector P, ui size, int q );
C++ VecObj#include <OptiVec.h>
int vector<T>::cotrpi( const vector<int>& P, int q );
int vector<T>::cotrpi2( const vector<int>& P, int q );
int vector<T>::cotrpi3( const vector<int>& P, int q );
Pascal/Delphiuses VFmath;
function VF_cotrpi( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
function VF_cotrpi2( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
function VF_cotrpi3( Y:fVector; P:iVector; size:UIntSize; q:Integer ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cotrpi( fVector d_Y, iVector d_P, ui size, int q );
int cudaVF_cotrpi2( fVector d_Y, iVector d_P, ui size, int q );
int cudaVF_cotrpi3( fVector d_Y, iVector d_P, ui size, int q );
int VFcu_cotrpi( fVector h_Y, iVector h_P, ui size, int q );
int VFcu_cotrpi2( fVector h_Y, iVector h_P, ui size, int q );
int VFcu_cotrpi3( fVector h_Y, iVector h_P, ui size, int q );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cotrpi( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function cudaVF_cotrpi2( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function cudaVF_cotrpi3( d_Y:fVector; d_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_cotrpi( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_cotrpi2( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
function VFcu_cotrpi3( h_Y:fVector; h_P:iVector; size:UIntSize; q:Integer ): IntBool;
BeschreibungYi = cot( (Pi / q) * p )
Es gibt drei Versionen. VF_cotrpi 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_cotrpi2 eingesetzt werden, die viele Funktionswerte einer Tabelle entnimmt. Wenn q ein Vielfaches von 3 ist, sollte VF_cotrpi3 gebraucht werden. VF_cotrpi2 und VF_cotrpi3 funktionieren auch mit Werten von q, für die sie nicht optimiert sind. Es wird allerdings Speicherplatz für die dann nutzlosen Tabellen vergeudet.
FehlerbehandlungSING-Fehler entstehen, wenn Pi exakt durch q teilbar ist. Das vorgeschlagene Ergebnis ist 0.0 (Mittelwert von +HUGE_VAL und -HUGE_VAL).
q muss ungleich 0 sein; dies wird nicht überprüft.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_cot,   tan

 

VF_cprintVD_cprintVE_cprint
VCF_cprintVCD_cprintVCE_cprint
VPF_cprintVPD_cprintVPE_cprint
VI_cprintVBI_cprintVSI_cprintVLI_cprintVQI_cprint
VU_cprintVUB_cprintVUS_cprintVUL_cprintVUI_cprint
Funktioneinen Vektor auf dem Bildschirm ausgeben. Nur für Konsolenanwendungen.
Syntax C/C++#include <VFstd.h>
void VF_cprint( fVector X, ui size, unsigned nperline );
C++ VecObj#include <OptiVec.h>
void vector<T>::cprint( unsigned nperline );
Pascal/Delphiuses VFstd;
procedure VF_cprint( X:fVector; size:UIntSize; nperline:UInt );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_cprint( fVector d_X, ui size, unsigned nperline );
int cudaVF_cprint_buf( fVector d_X, ui size, unsigned nperline, fVector h_Wk );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_cprint( d_X:fVector; size:UIntSize; nperline:UInt ): IntBool;
function cudaVF_cprint_buf( d_X:fVector; size:UIntSize; nperline:UInt; h_Wk:fVector ): IntBool;
BeschreibungNur Windows mit Borland / Embarcadero−Compilern oder MS Visual C++, DLL-Runtime:
size Elemente von X werden auf dem Bildschirm (der "Console"; daher das "c" im Funktionsnamen) ausgegeben.
Die Ausgabe beginnt stets mit einer neuen Zeile. Dies kann zu einer Leerzeile zu Beginn führen.
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.
Cartesisch-komplexe Zahlen werden in geschweifte Klammern gefasst, wobei der Imaginärteil durch ein Komma vom Realteil getrennt wird: {Re, Im}. Polar-komplexe Zahlen werden ebenfalls in geschweifte Klammern gefaßt, wobei der Mag- vom Arg-Teil durch ein at-Zeichen getrennt wird: {Mag @ Arg}.
Die Ausgabe erfolgt in das aktuelle Textfenster unter automatischer Anpassung an die Bildschirm-Daten des aktuellen Text-Modus. Sind mehr Zeilen erforderlich als auf einer Bildschirmseite Platz finden, wird ein Seitenumbruch durchgeführt und der Benutzer vor jeder neuen Seite aufgefordert, eine beliebige Taste zu drücken.
Die Anzahl pro Element ausgegebener Stellen richtet sich nach dem zur Verfügung stehenden Platz, also nach der Zeilenlänge und dem Parameter nperline.

Diese Familie von Funktionen ist nur für Konsolenanwendungen verwendbar.
 

nur CUDA-Versionen: cudaV?_cprint_buf übernimmt einen Host-Vektor h_Wk als zusätzliches Argument. Dieser dient als Pufferspeicher und muss (mindestens) dieselbe Größe haben wie X. Hierdurch wird die interne Bereitstellung von Pufferspeicher bei cudaV?_cprint eingespart, so dass cudaV?_cprint_buf etwas schneller ist.
 
Andere Windows−Compiler sowie Linux: Da hier die Textfenster-Breite und Höhe nicht ohne weiteres verfügbar sind, werden Aufrufe von V?_cprint nach VF_print umgeleitet.
Dieselbe Umleitung erfolgt auch für Visual C++ mit statischer Laufzeitbibliothek, hier wegen Inkompatibilitäten zwischen den verschiedenen Visual C++-Versionen.
 
 
GCC-Windows-spezifisch:Zwar unterstützt GCC auch in der Windows-Portierung den 80-bit-Fließkomma-Typ long double. Die I/O-Routinen verwenden aber die Laufzeitbibliothek von Visual C++, wo 80-bit-long doubles schon seit langem nicht mehr vorkommen. Dies bedeutet, dass VE_cprint, VCE_cprint und VPE_cprint bei GCC nur mit double-Genauigkeit und innerhalb des für doubles möglichen Größenbereiches arbeiten (also Eingabewerte ggf. auf diesen abgeschnitten werden). Um wenigstens eine Ausgabe im Hexadezimal-Format in voller Genauigkeit zu erhalten, rufe man VE_chexprint etc.
FehlerbehandlungWenn nperline die im aktuellen Text-Modus maximal mögliche Anzahl von Einträgen übersteigt, wird eine Fehlermeldung "Cannot use requested format (too many entries per line)." ausgegeben und die Ausgabe mit so vielen Einträgen pro Zeile durchgeführt wie möglich.
Rückgabewertkeiner
QuerverweisVF_fprint,   VF_print,   VF_chexprint,   VF_write,   VF_store,   cprintf

 

V_createCudaWorkspace
FunktionNeuen V_CUDAWORKSPACE (CUDA-Stream mit zugehörigem Pufferspeicher) anlegen
Syntax C/C++#include <cudaVecLib.h>
V_CUDAWORKSPACE V_createCudaWorkspace( void );
Delphiuses VecLib;
function V_createCudaWorkspace: V_CUDAWORKSPACE;
BeschreibungEin neuer V_CUDAWORKSPACE, der aus einem CUDA-Stream mit zugehörigem Pufferspeicher besteht, wird angelegt. Wenn dieser Workspace nicht mehr benötigt wird, sollte er durch Aufruf von V_destroyCudaWorkspace wieder entfernt und die durch ihn belegten Ressourcen freigegeben werden.
RückgabewertDer erzeugte Workspace vom Typ V_CUDAWORKSPACE
QuerverweisCudaOptiVecD.htm, Kap 5. Streams und Workspaces

 

VF_CtoAbsVD_CtoAbsVE_CtoAbs
FunktionAbsolutwert cartesisch-komplexer Zahlen
Syntax C/C++#include <VCFstd.h>
void VF_CtoAbs( fVector Abs, cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::CtoAbs( const vector<complex<T>>& X );
Pascal/Delphiuses VCFstd;
procedure VF_CtoAbs( Abs:fVector; X:cfVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVF_CtoAbs( fVector d_Abs, cfVector d_X, ui size ); void VFcu_CtoAbs( fVector h_Abs, cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVF_CtoAbs( d_Abs:fVector; d_X:cfVector; size:UIntSize ): IntBool;
procedure VFcu_CtoAbs( h_Abs:fVector; h_X:cfVector; size:UIntSize );
BeschreibungAbsi = sqrt( Re2(Xi) + Im2(Xi) )
Diese Funktion ist der Funktion VCF_abs sehr ähnlich, führt anders als diese aber keine Fehlerbehandlung durch und verlangt Eingabewerte, deren Real- und Imaginärteil jeweils kleiner als +- sqrt( HUGE ) sind.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVCF_abs,   VF_PolartoC,   VF_CtoReIm,   VF_CtoArg,   VF_CtoNorm

 

VF_CtoArgVD_CtoArgVE_CtoArg
FunktionArgument (Zeigerwinkel) cartesisch-komplexer Zahlen
Syntax C/C++#include <VCFstd.h>
void VF_CtoArg( fVector Arg, cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::CtoArg( const vector<complex<T>>& X );
Pascal/Delphiuses VCFstd;
procedure VF_CtoArg( Arg:fVector; X:cfVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVF_CtoArg( fVector d_Arg, cfVector d_X, ui size ); void VFcu_CtoArg( fVector h_Arg, cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVF_CtoArg( d_Arg:fVector; d_X:cfVector; size:UIntSize ): IntBool;
procedure VFcu_CtoArg( h_Arg:fVector; h_X:cfVector; size:UIntSize );
BeschreibungArgi = arctan( Im(Xi) / Re(Xi) )
Für cartesische Koordinaten {0, 0} ist der Zeigerwinkel Arg unbestimmt und wird willkürlich auf 0 gesetzt. Abhängig vom Vorzeichen der Real- und Imaginärteile wird p zum Ergebnis addiert oder von ihm subtrahiert, um den korrekten Quadranten zu erhalten.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_PolartoC,   VF_CtoPolar,   VF_atan2,   VF_CtoAbs,   VF_CtoReIm

 

VF_CtoImVD_CtoImVE_CtoIm
FunktionImaginärteil eines cartesisch-komplexen Vektors extrahieren
Syntax C/C++#include <VCFstd.h>
void VF_CtoIm( fVector Im, cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::CtoIm( const vector<complex<T>>& X );
Pascal/Delphiuses VCFstd;
procedure VF_CtoIm( Im:fVector; X:cfVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVF_CtoIm( fVector d_Im, cfVector d_X, ui size ); void VFcu_CtoIm( fVector h_Im, cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVF_CtoIm( d_Im:fVector; d_X:cfVector; size:UIntSize ): IntBool;
procedure VFcu_CtoIm( h_Im:fVector; h_X:cfVector; size:UIntSize );
BeschreibungDer Imaginärteil des komplexen Vektors X wird in den reellen Vektor Im kopiert.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_CtoReIm,   VF_ReImtoC,   VF_ImtoC,   VF_PolartoC

 

VF_CtoNormVD_CtoNormVE_CtoNorm
FunktionNorm, d.h. Quadrat des Absolutwertes der Elemente eines cartesisch-komplexen Vektors.
Syntax C/C++#include <VCFstd.h>
void VF_CtoNorm( fVector Norm, cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::CtoNorm( const vector<complex<T>>& X );
Pascal/Delphiuses VCFstd;
procedure VF_CtoNorm( Norm:fVector; X:cfVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVF_CtoNorm( fVector d_Norm, cfVector d_X, ui size ); void VFcu_CtoNorm( fVector h_Norm, cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVF_CtoNorm( d_Norm:fVector; d_X:cfVector; size:UIntSize ): IntBool;
procedure VFcu_CtoNorm( h_Norm:fVector; h_X:cfVector; size:UIntSize );
BeschreibungNormi = Re2(Xi) + Im2(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 steht. Dieser selbst ist durch VF_CtoAbs (ohne Fehlerbehandlung) und VCF_abs (mit Fehlerbehandlung) erhältlich.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_PolartoC,   VF_CtoReIm,   VF_CtoArg,   VF_CtoAbs

 

VF_CtoPVD_CtoPVE_CtoP
FunktionUmwandlung komplexer Zahlen von cartesischen in Polar-Koordinaten
Syntax C/C++#include <VPFstd.h>
void VF_CtoP( pfVector Y, cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<polar<T>>::CtoP( const vector<complex<T>>& X );
Pascal/Delphiuses VPFstd;
procedure VF_CtoP( Y:pfVector; X:cfVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVPFstd.h>
int cudaVF_CtoP( pfVector d_Y, cfVector d_X, ui size ); void VFcu_CtoP( pfVector h_Y, cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VPFstd;
function cudaVF_CtoP( d_Y:pfVector; d_X:cfVector; size:UIntSize ): IntBool;
procedure VFcu_CtoP( h_Y:pfVector; h_X:cfVector; size:UIntSize );
BeschreibungX wird von cartesischen Koordinaten {Re, Im} in Polarkoordinaten {Mag @ Arg} umgewandelt.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_CtoPolar,   VF_PtoC

 

VF_CtoPolarVD_CtoPolarVE_CtoPolar
FunktionUmwandlung komplexer Zahlen von cartesischen in Polarkoordinaten, die in separaten Vektoren Mag und Arg abgespeichert werden.
Syntax C/C++#include <VCFstd.h>
void VF_CtoPolar( fVector Mag, fVector Arg, cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::CtoPolar( vector<T> Arg, const vector<complex<T>>& X );
Pascal/Delphiuses VCFstd;
procedure VF_CtoPolar( Mag, Arg:fVector; X:cfVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVF_CtoPolar( fVector d_Mag, fVector d_Arg, cfVector d_X, ui size ); void VFcu_CtoPolar( fVector h_Mag, fVector h_Arg, cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVF_CtoPolar( d_Mag, d_Arg:fVector; d_X:cfVector; size:UIntSize ): IntBool;
procedure VFcu_CtoPolar( h_Mag, h_Arg:fVector; h_X:cfVector; size:UIntSize );
BeschreibungDie Polarkoordinaten Mag (Zeigerlänge, Absolutwert) und Arg (Argument, Zeigerwinkel) jedes Elementes des in cartesischen Koordinaten vorliegenden Vektors X werden berechnet. Für cartesische Koordinaten {0, 0} werden die Polar-Koordinaten willkürlich auf {0 @ 0} gesetzt.
Diese Funktion unterscheidet sich von VF_CtoP darin, dass Mag und Arg in getrennten reellen Vektoren statt wie dort in einem polar-komplexen Vektors gespeichert werden.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_CtoP,   VF_PolartoC,   VF_CtoReIm,   VF_CtoAbs,   VF_CtoArg

 

VF_CtoReVD_CtoReVE_CtoRe
FunktionRealteil eines cartesisch-komplexen Vektors extrahieren
Syntax C/C++#include <VCFstd.h>
void VF_CtoRe( fVector Re, cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::CtoRe( const vector<complex<T>>& X );
Pascal/Delphiuses VCFstd;
procedure VF_CtoRe( Re:fVector; X:cfVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVF_CtoRe( fVector d_Re, cfVector d_X, ui size ); void VFcu_CtoRe( fVector h_Re, cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVF_CtoRe( d_Re:fVector; d_X:cfVector; size:UIntSize ): IntBool;
procedure VFcu_CtoRe( h_Re:fVector; h_X:cfVector; size:UIntSize );
BeschreibungDer Realteil des komplexen Vektors X wird in den reellen Vektor Re kopiert.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_CtoReIm,   VF_ReImtoC,   VF_RetoC,   VF_PolartoC

 

VF_CtoReImVD_CtoReImVE_CtoReIm
FunktionReal- und Imaginärteil eines cartesisch-komplexen Vektors extrahieren
Syntax C/C++#include <VCFstd.h>
void VF_CtoReIm( fVector Re, fVector Im, cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::CtoReIm( vector<T> Im, const vector<complex<T>>& X );
Pascal/Delphiuses VCFstd;
procedure VF_CtoReIm( Re, Im:fVector; X:cfVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVF_CtoReIm( fVector d_Re, fVector d_Im, cfVector d_X, ui size ); void VFcu_CtoReIm( fVector h_Re, fVector h_Im, cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVF_CtoReIm( d_Re, d_Im:fVector; d_X:cfVector; size:UIntSize ): IntBool;
procedure VFcu_CtoReIm( h_Re, h_Im:fVector; h_X:cfVector; size:UIntSize );
BeschreibungReal- und Imaginärteil des komplexen Vektors X werden in die reellen Vektoren Re und Im kopiert.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_CtoRe,   VF_ReImtoC,   VF_RetoC,   VF_PolartoC

 

VF_cubicVD_cubicVE_cubic
VFx_cubicVDx_cubicVEx_cubic
VFu_cubicVDu_cubicVEu_cubic
VFux_cubicVDux_cubicVEux_cubic
VCF_cubicVCD_cubicVCE_cubic
VCFx_cubicVCDx_cubicVCEx_cubic
VCFu_cubicVCDu_cubicVCEu_cubic
VCFux_cubicVCDux_cubicVCEux_cubic
VPF_cubicVPD_cubicVPE_cubic
VPFu_cubicVPDu_cubicVPEu_cubic
FunktionKubik (dritte Potenz)
Syntax C/C++#include <VFmath.h>
int VF_cubic( fVector Y, fVector X, ui size );
int VFx_cubic( fVector Y, fVector X, ui size, float A, float B );
int VFu_cubic( fVector Y, fVector X, ui size );
int VFux_cubic( fVector Y, fVector X, ui size, float A, float B );
C++ VecObj#include <OptiVec.h>
int vector<T>::cubic( const vector<T>& X );
int vector<T>::x_cubic( const vector<T>& X, const T& A, const T& B );
int vector<T>::u_cubic( const vector<T>& X );
int vector<T>::ux_cubic( const vector<T>& X, const T& A, const T& B );
Pascal/Delphiuses VFmath;
function VF_cubic( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_cubic( Y, X:fVector; size:UIntSize; A, B:Single ): IntBool;
function VFu_cubic( Y, X:fVector; size:UIntSize ): IntBool;
function VFux_cubic( Y, X:fVector; size:UIntSize; A, B:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_cubic( fVector d_Y, fVector d_X, ui size );
int cudaVFx_cubic( fVector d_Y, fVector d_X, ui size, float A, float B );
int cusdVFx_cubic( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B );
int VFucu_cubic( fVector h_Y, fVector h_X, ui size );
int VFuxcu_cubic( fVector h_Y, fVector h_X, ui size, float A, float B );
int cudaVFu_cubic( fVector d_Y, fVector d_X, ui size );
int cudaVFux_cubic( fVector d_Y, fVector d_X, ui size, float A, float B );
int cusdVFux_cubic( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B );
int VFucu_cubic( fVector h_Y, fVector h_X, ui size );
int VFuxcu_cubic( fVector h_Y, fVector h_X, ui size, float A, float B );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_cubic( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_cubic( d_Y, d_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_cubic( d_Y, d_X:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function VFcu_cubic( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_cubic( h_Y, h_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cudaVFu_cubic( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFux_cubic( d_Y, d_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFux_cubic( d_Y, d_X:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function VFucu_cubic( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFuxcu_cubic( h_Y, h_X:fVector; size:UIntSize; A, B:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = Xi3
erweiterte Versionen: Yi = (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. 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.

FehlerbehandlungOVERFLOW-Fehler ergeben ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_square,   VF_quartic,   VF_rcubic,   VF_sqrt,   VF_pow,   VF_ipow,   VF_poly

 

VCF_dataPlotVCD_dataPlotVCE_dataPlot
FunktionPlot eines komplexen Vektors in ein bereits existierendes Koordinatensystem
Syntax C/C++#include <Vgraph.h>
void VCF_dataPlot( cfVector X, ui size, unsigned form, COLORREF color );
C++ VecObj#include <OptiVec.h>
void vector<complex<T>>::dataPlot( unsigned form, COLORREF color );
Pascal/Delphiuses Vgraph;
procedure VCF_dataPlot( X:cfVector; size:UIntSize; form:UInt; color:COLORREF );
BeschreibungDer Vektor X wird in das durch vorherige Aufrufe von z.B. VCF_autoPlot,   VCF_2AutoPlot oder V_drawAxes bereits bestehende Koordinatensystem gezeichnet.
Die Parameter form und color werden bei VF_xyAutoPlot besprochen.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVCF_autoPlot,   VCF_2AutoPlot,   VF_xyAutoPlot,  Kap. 4.12

 

VF_decElementVD_decElementVE_decElement
VCF_decElementVCD_decElementVCE_decElement
VCF_decElementReVCD_decElementReVCE_decElementRe
VCF_decElementImVCD_decElementImVCE_decElementIm
VI_decElementVBI_decElementVSI_decElementVLI_decElementVQI_decElement 
VU_decElementVUB_decElementVUS_decElementVUL_decElementVUQ_decElementVUI_decElement
FunktionEin Vektor-Element um einen bestimmten Wert erniedrigen
Syntax C/C++#include <VFstd.h>
void VF_decElement( fVector X, ui pos, float C );
#include <VCFstd.h>
void VCF_decElement( cfVector X, ui pos, fComplex C );
void VCF_decElementRe( fVector X, ui pos, float C );
void VCF_decElementIm( fVector X, ui pos, float C );
C++ VecObj#include <OptiVec.h>
vector<T>::decElement( ui pos, T C );
vector<complex<T>>::decElement( ui pos, complex<T> C );
vector<complex<T>>::decElementRe( ui pos, T C );
vector<complex<T>>::decElementIm( ui pos, T C );
Pascal/Delphiuses VFstd;
procedure VF_decElement( X:fVector; pos:UIntSize; C:Single );
uses VCFstd;
procedure VCF_decElement( X:cfVector; pos:UIntSize; C:fComplex );
procedure VCF_decElementRe( X:cfVector; pos:UIntSize; C:Single );
procedure VCF_decElementIm( X:cfVector; pos:UIntSize; C:Single );
CUDA-Funktion C/C++#include <cudaVFstd.h>
void cudaVF_decElement( fVector d_X, ui pos, float C );
void cusdVF_decElement( fVector d_X, ui pos, float *d_C );
#include <cudaVCFstd.h>
void cudaVCF_decElement( cfVector d_X, ui pos, fComplex C );
void cusdVCF_decElement( cfVector d_X, ui pos, fComplex *d_C );
void cudaVCF_decElementRe( cfVector d_X, ui pos, float C );
void cusdVCF_decElementRe( cfVector d_X, ui pos, float *d_C );
void cudaVCF_decElementIm( cfVector d_X, ui pos, float C );
void cusdVCF_decElementIm( cfVector d_X, ui pos, float *d_C );
CUDA-Funktion Pascal/Delphiuses VFstd;
procedure cudaVF_decElement( d_X:fVector; pos:UIntSize; C:Single );
procedure cusdVF_decElement( d_X:fVector; pos:UIntSize; d_C:PSingle );
uses VCFstd;
procedure cudaVCF_decElement( d_X:cfVector; pos:UIntSize; C:fComplex );
procedure cusdVCF_decElement( d_X:cfVector; pos:UIntSize; d_C:PfComplex );
procedure cudaVCF_decElementRe( d_X:cfVector; pos:UIntSize; C:Single );
procedure cusdVCF_decElementRe( d_X:cfVector; pos:UIntSize; d_C:PSingle );
procedure cudaVCF_decElementIm( d_X:cfVector; pos:UIntSize; C:Single );
procedure cusdVCF_decElementIm( d_X:cfVector; pos:UIntSize; d_C:PSingle );
BeschreibungReelle Versionen:
X[i] -= C;
Das Element an der Position pos wird um den Wert C erniedrigt.

Komplexe Versionen VCF_decElement usw.:
X[i].Re -= C.Re; X[i].Im -= C.Im;

Komplexe Versionen VCF_decElementRe usw.:
X[i].Re -= C.Re;
Der Imaginärteil X[i].Im bleibt unangetastet.

Komplexe Versionen VCF_decElementIm usw.:
X[i].Im -= C.Im;
Der Realteil X[i].Re bleibt unangetastet.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_Pelement,   VF_element,   VF_getElement,   VF_setElement,   VF_accElement

 

VF_deconvolveVD_deconvolveVE_deconvolve
VF_deconvolvewEditVD_deconvolvewEditVE_deconvolvewEdit
VFb_deconvolveVDb_deconvolveVEb_deconvolve
VFb_deconvolvewEditVDb_deconvolvewEditVEb_deconvolvewEdit
FunktionEntfaltung (Dekonvolution)
Syntax C/C++#include <VFstd.h>
void VF_deconvolve( fVector Y, fVector Flt, fVector X, fVector Rsp, ui size );
void VF_deconvolvewEdit( fVector Y, fVector Flt, fVector X, fVector Rsp, ui size; fComplex thresh );
void VFb_deconvolve( fVector Y, fVector Flt, fVector X, fVector Rsp, ui size, fVector Buf );
void VFb_deconvolvewEdit( fVector Y, fVector Flt, fVector X, fVector Rsp, ui size; fComplex thresh, fVector Buf );
C++ VecObj#include <OptiVec.h>
void vector<T>::deconvolve( vector<T> Flt, const vector<T>& X, const vector<T>& Rsp );
void vector<T>::deconvolvewEdit( vector<T> Flt, const vector<T>& X, const vector<T>& Rsp, complex<T> thresh );
void vector<T>::b_deconvolve( vector<T> Flt, const vector<T>& X, const vector<T>& Rsp, vector<T> Buf );
void vector<T>::b_deconvolvewEdit( vector<T> Flt, const vector<T>& X, const vector<T>& Rsp, complex<T> thresh, vector<T> Buf );
Pascal/Delphiuses VFstd;
procedure VF_deconvolve( Y, Flt, X, Rsp:fVector; size:UIntSize );
procedure VF_deconvolvewEdit( Y, Flt, X, Rsp:fVector; size:UIntSize; thresh:fComplex );
procedure VFb_deconvolve( Y, Flt, X, Rsp:fVector; size:UIntSize; Buf:fVector );
procedure VFb_deconvolvewEdit( Y, Flt, X, Rsp:fVector; size:UIntSize; thresh:fComplex; Buf:fVector );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_deconvolve( fVector d_Y, fVector d_Flt, fVector d_X, fVector d_Rsp, ui size );
void VFcu_deconvolve( fVector h_Y, fVector h_Flt, fVector h_X, fVector h_Rsp, ui size );
int cudaVF_deconvolvewEdit( fVector d_Y, fVector d_Flt, fVector d_X, fVector d_Rsp, ui size, fComplex thresh );
void VFcu_deconvolvewEdit( fVector h_Y, fVector h_Flt, fVector h_X, fVector h_Rsp, ui size, fComplex thresh );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_deconvolve( d_Y, d_Flt, d_X, d_Rsp:fVector; size:UIntSize ): IntBool;
procedure VFcu_deconvolve( h_Y, h_Flt, h_X, h_Rsp:fVector; size:UIntSize );
function cudaVF_deconvolvewEdit( d_Y, d_Flt, d_X, d_Rsp:fVector; size:UIntSize; thresh:fComplex ): IntBool;
procedure VFcu_deconvolvewEdit( h_Y, h_Flt, h_X, h_Rsp:fVector; size:UIntSize; thresh:fComplex );
BeschreibungX wird als das Resultat der Faltung eines "echten" Profils mit der Impulsantwort-Funktion (Response-Funktion) Rsp angenommen. Eine Dekonvolution wird versucht und in Y gespeichert. Ein Filter Flt wird ebenfalls berechnet. Soll die Entfaltung nicht nur für einen einzigen Vektor durchgeführt werden, so sollte für weitere Vektoren nicht wieder VF_deconvolve aufgerufen werden, sondern VF_filter mit Flt als Filter.

Die Response-Funktion Rsp muss mit dem Nullpunkt beim nullten Element vorliegen. Elemente für positive Zeiten (oder was immer die unabhängige Variable ist) folgen in Rsp1 bis Rspsize/2 und die Elemente für negative Zeiten, beginnend mit der am stärksten negativen Zeit, in Rspsize/2+1 bis Rspsize−1. Um diese Ordnung herzustellen, bediene man sich gegebenenfalls der Funktionen VF_rotate oder VF_reflect.

X, Y, Rsp und Flt müssen alle dieselbe Größe size besitzen; diese muss eine ganzzahlige Potenz von 2 sein. X darf durch Y überschrieben werden und Rsp durch Flt, aber X und Flt sowie Y und Rsp müssen voneinander verschieden sein.

Mathematisch ist Flt der Kehrwert der Fourier-Transformierten von Rsp. Falls die Fourier-Transformierte von Rsp Nullen enthält, bedeutet dies jedoch, dass für die jeweilige Frequenz jegliche Information verloren gegangen ist bei der angenommenen Faltung. Sie kann also nicht durch Entfaltung rekonstruiert werden. Man sollte nur für diejenigen Frequenzen eine Rekonstruktion der ursprünglichen Information versuchen, wo auch noch etwas von ihr übrig ist. Hier ist also einer der seltenen Fälle gegeben, wo an die Stelle einer Division durch 0 sinnvoll eine Multiplikation mit 0 tritt! Um Missverständnisse zu vermeiden: Ob besagte Information noch vorhanden ist, lässt sich nicht aus dem Eingangsvektor X entnehmen, sondern liegt allein in der angenommenen Response-Funktion begründet.

Man sollte Entfaltung jedenfalls nicht blind anwenden, sondern am besten die Fourier-Transformierte von Rsp inspizieren und danach für die jeweilige Anwendung entscheiden, was zu tun ist. Wen diese Bemerkungen noch nicht von der Verwendung dieser Entfaltungs-Funktion abgeschreckt haben, für den führt VF_deconvolve standardmäßig eine Editierung des Filters durch. Hierbei werden alle Frequenzen mit einem Filterwert unterhalb der durch Rundungsfehler gegebenen Schwelle "verloren gegeben". Anstelle des Inversen von sehr kleinen Werten (was zu OVERFLOW- oder SING-Fehlern führen könnte) wird wie oben beschrieben Null im Filter gespeichert.
Der standardmäßig verwendete Schwellenwert hierfür kann durch VF_setRspEdit ausgelesen werden. Um für sämtliche Aufrufe von VF_deconvolve und VF_convolve einen anderen Schwellenwert einzustellen, kann die Funktion VF_setRspEdit aufgerufen werden. Diese Methode ist aber nicht fiber-sicher und daher nicht geeignet, um den Schwellenwert bei verschiedenen Aufrufen von VF_deconvolve bzw. VF_convolve unterschiedlich einzustellen. Hier muss die Variante VF_deconvolvewEdit verwendet werden, die den gewünschten Schwellenwert als Argument thresh übernimmt (und die standardmäßig eingestellte Schwelle ignoriert). Da Flt aus komplexen Zahlen besteht und es gelegentlich wünschenswert ist, Real- und Imaginärteile unterschiedlich zu behandeln, ist thresh ebenfalls komplex.

Diese Entfaltung basiert auf der Annahme, X sei periodisch oder konvergiere zumindest an beiden Enden zu demselben Wert (nulltes und letztes Element identisch). Ist dies nicht der Fall, so sollten Randeffekte mit den bei VF_convolve beschriebenen Methoden vermieden werden.

Intern benötigt VF_deconvolve / VF_deconvolvewEdit zusätzlichen Pufferspeicher, der automatisch reserviert und wieder freigegeben wird. Bei wiederholten Aufrufen wäre dies ineffizient. Es wird empfohlen, für solche Fälle stattdessen VFb_deconvolve / VFb_deconvolvewEdit zu verwenden. Die Größe von Buf muss dabei ≥ 2*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.
 

FehlerbehandlungWenn size nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf VF_deconvolve basiert) mit der Fehlermeldung "Size must be integer power of 2." und bricht das Programm ab.
Wenn über VF_setRspEdit Trunc.Re = Trunc.Im = 0 eingestellt wurde, oder wenn VF_deconvolvewEdit mit fcplx(0,0) als Argument thresh aufgerufen wird, können SING-Fehler entstehen, die zu ±HUGE_VAL als Ergebnisvorschlag führen. In diesem Fall droht allerdings bei der anschließenden Multiplikation von Flt mit der Transformierten von X unbehandelter Fließkomma-Überlauf (dann nämlich, wenn an den fraglichen Frequenzen doch noch Information vorhanden ist, obwohl gemäß der angenommenen Rsp-Funktion gar keine mehr zu erwarten war).
Rückgabewertkeiner
QuerverweisVF_filter,   VF_convolve,   VF_FFT,   VF_xcorr,   VF_spectrum

 

VF_deleteVD_deleteVE_delete
VCF_deleteVCD_deleteVCE_delete
VPF_deleteVPD_deleteVPE_delete
VI_deleteVBI_deleteVSI_deleteVLI_deleteVQI_delete 
VU_deleteVUB_deleteVUS_deleteVUL_deleteVUQ_deleteVUI_delete
FunktionEin Element aus einem Vektor entfernen
Syntax C/C++#include <VFstd.h>
void VF_delete( fVector X, ui size, ui pos );
C++ VecObj#include <OptiVec.h>
void vector<T>::delete( ui pos );
Pascal/Delphiuses VFstd;
procedure VF_delete( X:fVector; size, pos:UIntSize );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_delete( fVector d_X, ui size, ui pos );
void VFcu_delete( fVector h_X, ui size, ui pos );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_delete( d_X:fVector; size, pos:UIntSize ): IntBool;
procedure VFcu_delete( h_X:fVector; size, pos:UIntSize );
BeschreibungDies ist eine der wenigen Funktionen, die einen Eingabevektor selbst ändern, anstatt das Ergebnis in einem Ausgabevektor abzulegen. Das Element mit dem Index pos wird aus dem Vektor X entfernt und alle ihm folgenden Elemente eine Position niedriger gerückt. Das letzte Element bleibt undefiniert.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_rotate,   VF_insert

 

VF_derivCVD_derivCVE_derivC
Funktionnumerische Ableitung bei Vorliegen eines konstanten Abtastintervalles
Syntax C/C++#include <VFstd.h>
void VF_derivC( fVector Y, fVector X, ui size, float DeltaT );
C++ VecObj#include <OptiVec.h>
void vector<T>::derivC( const vector<T>& X, T DeltaT );
Pascal/Delphiuses VFstd;
procedure VF_derivC( Y, X:fVector; size:UIntSize; DeltaT:Single );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_derivC( fVector d_Y, fVector d_X, ui size, float DeltaT );
int cusdVF_derivC( fVector d_Y, fVector d_X, ui size, float *d_DeltaT );
void VFcu_derivC( fVector h_Y, fVector h_X, ui size, float DeltaT );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_derivC( d_Y, d_X:fVector; size:UIntSize; DeltaT:Single ): IntBool;
function cusdVF_derivC( d_Y, d_X:fVector; size:UIntSize; d_DeltaT:PSingle ): IntBool;
procedure VFcu_derivC( h_Y, h_X:fVector; size:UIntSize; DeltaT:Single );
BeschreibungY(t) = dX(t) / dt.
Der Vektor X wird als Funktion der Variablen t angenommen, wobei die t-Werte selbst einen konstanten Abstand DeltaT voneinander aufweisen. X wird mit parabolischer Interpolation nach t differenziert. Diese Funktion ist das Gegenstück zu VF_runintegralC.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_derivV,   VF_runintegralC

 

VF_derivVVD_derivVVE_derivV
FunktionAbleitung eines Vektors nach einem anderen
Syntax C/C++#include <VFstd.h>
void VF_derivV( fVector Z, fVector X, fVector Y, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::derivV( const vector<T>& X, const vector<T>& Y );
Pascal/Delphiuses VFstd;
procedure VF_derivV( Z, X, Y:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_derivV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
void VFcu_derivV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_derivV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
procedure VFcu_derivV( h_Z, h_X, h_Y:fVector; size:UIntSize );
BeschreibungZ(X) = dY(X) / dX.
Die Ableitung von Y nach X wird unter Verwendung von parabolischer Interpolation berechnet und in Z gespeichert. Falls die Elemente von X voneinander konstante Abstände aufweisen, sollte die schnellere Funktion VF_derivC verwendet werden. Die Funktion VF_derivV ist das Gegenstück zu VF_runintegralV.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_derivC,   VF_runintegralV

 

V_destroyCudaWorkspace
FunktionBeseitigung eines cudaOptiVec Workspaces
Syntax C/C++#include <cudaVecLib.h>
overror_t V_destroyCudaWorkspace( V_CUDAWORKSPACE *wsp );
Delphiuses VecLib;
function V_destroyCudaWorkspace( wsp: PV_CUDAWORKSPACE ): Integer;
BeschreibungAlle cudaOptiVec-Workspaces, die durch V_createCudaWorkspace erzeugt wurden, müssen durch diese Funktion wieder entfernt werden, um die durch sie belegten Ressourcen freizugeben.
Rückgabewert0 bei Erfolg; nicht-Null, wenn der Workspace nicht gültig war
QuerverweisCudaOptiVecD.htm, Kap 5. Streams und Workspaces

 

VF_distributionVD_distributionVE_distribution
VI_distributionVBI_distributionVSI_distributionVLI_distributionVQI_distribution
VU_distributionVUB_distributionVUS_distributionVUL_distributionVUQ_distribution
FunktionVerteilungsfunktion (Histogramm-Berechnung)
Syntax C/C++#include <VFstd.h>
ui VF_distribution( uiVector Abund, fVector Limits, ui nbins, fVector X, ui sizex, int mode );
C++ VecObj#include <OptiVec.h>
ui vector<ui>::distribution( const vector<T>& Limits, const vector<T>& X, int mode=0 );
Pascal/Delphiuses VFstd;
function VF_distribution( Abund:uiVector; Limits:fVector; bins:UIntSize; X:fVector; sizex:UIntSize; mode:Integer ):UIntSize;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_distribution( ui *h_nOutside, uiVector d_Abund, fVector d_Limits, ui nbins, fVector d_X, ui sizex, int mode );
int cusdVF_distribution( ui *d_nOutside, uiVector d_Abund, fVector d_Limits, ui nbins, fVector d_X, ui sizex, int mode );
ui VFcu_distribution( uiVector h_Abund, fVector h_Limits, ui nbins, fVector h_X, ui sizex, int mode );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_distribution( var h_nOutside:UIntSize; d_Abund:uiVector; d_Limits:fVector; bins:UIntSize; d_X:fVector; sizex:UIntSize; mode:Integer ): IntBool;
function cusdVF_distribution( d_nOutside:PUIntSize; d_Abund:uiVector; d_Limits:fVector; bins:UIntSize; d_X:fVector; sizex:UIntSize; mode:Integer ): IntBool;
function VFcu_distribution( h_Abund:uiVector; h_Limits:fVector; bins:UIntSize; h_X:fVector; sizex:UIntSize; mode:Integer ): UIntSize;
BeschreibungDiese Funktion zählt, wieviele Elemente von X in jedes einzelne der in Limits definierten Intervalle fallen. Die gefundenen Häufigkeitswerte werden in Abund gespeichert.
Es gibt nbins Intervalle (engl. bins). Die Größe des zu durchsuchenden Vektors ist sizex.

Limits muss in aufsteigender Folge sortiert sein. Die Abstände zwischen den einzelnen Werten von Limits müssen aber nicht unbedingt konstant sein.

Der Parameter mode entscheidet darüber, wie die in Limits angegebenen Werte interpretiert werden sollen.
mode > 0: Die Werte von Limits geben die Obergrenzen der Intervalle an.
mode < 0: Die Werte von Limits geben die Untergrenzen der Intervalle an.
mode = 0: Die Werte von Limits geben die Intervall-Mittelpunkte an. Ein X-Wert wird also demjenigen Intervall zugerechnet, zu dessen in Limits angegebenen Wert er den geringsten Abstand hat. Befindet sich ein X-Wert exakt in der Mitte zwischen zwei Limits-Werten, so wird er dem Intervall mit dem niedrigeren Index zugeschlagen. Das durch Limits0 angegebene Intervall ist nach unten hin offen, das durch Limitsnbins−1 angegebene reicht bis +HUGE_VAL.

Der Rückgabewert gibt die Anzahl der Elemente von X an, die außerhalb der spezifierten Intervalle liegen. Für mode > 0 sind dies die das höchste Limit übersteigenden Elemente und für mode < 0 die das niedrigste Limit unterschreitenden Elemente. Für mode = 0 ist der Rückgabewert immer 0, denn die Intervalle sind ja nach beiden Seiten hin offen, so dass jedes Element von X erfaßt wird.

Um die normierte Verteilungsfunktion zu erhalten, gebrauche man die Sequenz VF_distribution( Abund, Limits, nbins, X, sizex, 0 );
V_UItoD( Y, Abund, nbins );
VD_divC( Y, Y, nbins, VD_integralV(Limits,Y,nbins) );

Durch anschließenden Aufruf von
VD_runintegralC( Y, Y, nbins, 1.0 );
erhält man hieraus die kumulierte Verteilungsfunktion.

Zur Stapelverarbeitung mehrerer Vektoren gleicher Größe bieten sich die Funktionen MF_Rows_distribution (vorzugsweise fü C/C++) und MF_Cols_distribution (für Delphi) an.

Fehlerbehandlungkeine
RückgabewertAnzahl der nicht in Abund berücksichtigten Elemente von X
QuerverweisVF_searchV

 

VF_divCVD_divCVE_divC
VCF_divCVCD_divCVCE_divC
VCF_divReCVCD_divReCVCE_divReC
VPF_divCVPD_divCVPE_divC
VPF_divReCVPD_divReCVPE_divReC
VI_divCVBI_divCVSI_divCVLI_divCVQI_divC 
VU_divCVUB_divCVUS_divCVUL_divCVUQ_divCVUI_divC
FunktionDurch eine Konstante dividieren
Syntax C/C++#include <VFmath.h>
void VF_divC( fVector Y, fVector X, ui size, float C );
void VCF_divC( cfVector Y, cfVector X, ui size, fComplex C );
void VCF_divReC( cfVector Y, cfVector X, ui size, float CRe );
C++ VecObj#include <OptiVec.h>
void vector<T>::divC( const vector<T>& X, const T& C );
void vector<complex<T>>::divC( const vector<complex<T>>& X, complex<T> C );
void vector<complex<T>>::divReC( const vector<complex<T>>& X, const T& CRe );
Pascal/Delphiuses VFmath;
procedure VF_divC( Y, X:fVector; size:UIntSize; C:Single );
procedure VCF_divC( Y, X:cfVector; size:UIntSize; C:fComplex );
procedure VCF_divReC( Y, X:cfVector; size:UIntSize; CRe:Single );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_divC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_divC( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_divC( fVector d_Y, fVector d_X, ui size, float C );
#include <cudaVCFmath.h>
int cudaVCF_divReC( cfVector d_Y, cfVector d_X, ui size, float CRe );
int cusdVCF_divReC( cfVector d_Y, cfVector d_X, ui size, float *d_CRe );
void VCFcu_divReC( cfVector h_Y, cfVector h_X, ui size, float CRe );
CUDA-Funktion Pascal/Delphiuses VFmath, VCFmath;
function cudaVF_divC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_divC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VFcu_divC( h_Y, h_X:fVector; size:UIntSize; C:Single );
function cudaVCF_divReC( d_Y, d_X:cfVector; size:UIntSize; CRe:Single );
function cusdVCF_divReC( d_Y, d_X:cfVector; size:UIntSize; d_CRe:PSingle );
procedure VCFcu_divReC( h_Y, h_X:cfVector; size:UIntSize; CRe:Single );
BeschreibungYi = Xi / C
Die Ganzzahl-Versionen führen eine Integer-Division durch, d.h. ein eventueller Divisions-Rest wird verworfen. Um diesen zu erhalten, gebrauche man die Funktionen der VI_modC- Familie.
Die komplexen Fließkomma-Versionen existieren in zwei Varianten, einer für komplexe Konstanten C sowie einer für reelle CRe, durch die der komplexe Vektor dividiert wird.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_divV,   VF_addC,   VF_subC,   VF_mulC,   VF_divrC,   VF_modC,   VF_visC,   VF_redC

 

VF_divrCVD_divrCVE_divrC
VCF_divrCVCD_divrCVCE_divrC
VCF_divrReCVCD_divrReCVCE_divrReC
VFx_divrCVDx_divrCVEx_divrC
VCFx_divrCVCDx_divrCVCEx_divrC
VPF_divrCVPD_divrCVPE_divrC
VPF_divrReCVPD_divrReCVPE_divrReC
VI_divrCVBI_divrCVSI_divrCVLI_divrCVQI_divrC 
VU_divrCVUB_divrCVUS_divrCVUL_divrCVUQ_divrCVUI_divrC
FunktionUmgekehrte Division: Konstante durch Vektorelemente dividieren
Syntax C/C++#include <VFmath.h>
void VF_divrC( fVector Y, fVector X, ui size, float C );
void VFx_divrC( fVector Y, fVector X, ui size, float A, float B, float C );
void VCF_divrC( cfVector Y, cfVector X, ui size, fComplex C );
void VCFx_divrC( cfVector Y, cfVector X, ui size, fComplex A, fComplex B, fComplex C );
void VCF_divrReC( cfVector Y, cfVector X, ui size, float CRe );
C++ VecObj#include <OptiVec.h>
void vector<T>::divrC( const vector<T>& X, const T& C );
void vector<T>::x_divrC( const vector<T>& X, const T& A, const T& B, const T& C );
void vector<complex<T>>::divrC( const vector<complex<T>>& X, complex<T> C );
void vector<complex<T>>::x_divrC( const vector<complex<T>>& X, complex<T> A, complex<T> B, complex<T> C );
void vector<complex<T>>::divrReC( const vector<complex<T>>& X, const T& CRe );
Pascal/Delphiuses VFmath;
procedure VF_divrC( Y, X:fVector; size:UIntSize; C:Single );
procedure VFx_divrC( Y, X:fVector; size:UIntSize; A, B, C:Single );
procedure VCF_divrC( Y, X:cfVector; size:UIntSize; C:fComplex );
procedure VCFx_divrC( Y, X:cfVector; size:UIntSize; A, B, C:fComplex );
procedure VCF_divrReC( Y, X:cfVector; size:UIntSize; CRe:Single );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_divrC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_divrC( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_divrC( fVector d_Y, fVector d_X, ui size, float C );
int cudaVFx_divrC( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_divrC( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
void VFxcu_divrC( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
#include <cudaVCFmath.h>
int cudaVCF_divrReC( cfVector d_Y, cfVector d_X, ui size, float CRe );
int cusdVCF_divrReC( cfVector d_Y, cfVector d_X, ui size, float *d_CRe );
void VCFcu_divrReC( cfVector h_Y, cfVector h_X, ui size, float CRe );
CUDA-Funktion Pascal/Delphiuses VFmath, VCFmath;
function cudaVF_divrC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_divrC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VFcu_divrC( h_Y, h_X:fVector; size:UIntSize; C:Single );
function cudaVFx_divrC( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single );
function cusdVFx_divrC( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle );
procedure VFxcu_divrC( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single );
function cudaVCF_divrReC( d_Y, d_X:cfVector; size:UIntSize; CRe:Single );
function cusdVCF_divrReC( d_Y, d_X:cfVector; size:UIntSize; d_CRe:PSingle );
procedure VCFcu_divrReC( h_Y, h_X:cfVector; size:UIntSize; CRe:Single );
Beschreibungeinfache Versionen: Yi = C / Xi
erweiterte Versionen: Yi = C / (A*Xi+B)
Die komplexen Versionen existieren in zwei Varianten: eine für komplexe Konstanten C, die andere für reelle Konstanten CRe, die durch die komplexen Vektorelemente geteilt werden.
Fehlerbehandlungkeine; für die Fließkomma-Versionen gibt es ähnliche Funktionen, die 1.0 / Xi und 1.0 / (A*Xi+B) berechnen: VF_inv bzw. VFx_inv. Beide fangen SING-Fehler ab.
Rückgabewertkeiner
QuerverweisVF_divV,   VF_inv,   VF_addC,   VF_subC,   VF_mulC,   VF_divC,   VF_modC,   VF_visC,   VF_redC

 

VF_divrVVD_divrVVE_divrV
VCF_divrVVCD_divrVVCE_divrV
VCF_divrReVVCD_divrReVVCE_divrReV
VFs_divrVVDs_divrVVEs_divrV
VFx_divrVVDx_divrVVEx_divrV
VCFx_divrVVCDx_divrVVCEx_divrV
VCFx_divrReVVCDx_divrReVVCEx_divrReV
VPF_divrVVPD_divrVVPE_divrV
VPF_divrReVVPD_divrReVVPE_divrReV
VI_divrVVBI_divrVVSI_divrVVLI_divrVVQI_divrV 
VU_divrVVUB_divrVVUS_divrVVUL_divrVVUQ_divrVVUI_divrV
FunktionUmgekehrte Division zweier Vektoren
Syntax C/C++#include <VFmath.h>
void VF_divrV( fVector Z, fVector X, fVector Y, ui size );
void VFx_divrV( fVector Z, fVector X, fVector Y, ui size, float A, float B );
void VCF_divrV( cfVector Z, cfVector X, cfVector Y, ui size );
void VCF_divrReV( cfVector Z, cfVector X, fVector Y, ui size );
void VCFx_divrV( cfVector Z, cfVector X, cfVector Y, ui size, fComplex A, fComplex B );
void VCFx_divrReV( cfVector Z, cfVector X, fVector Y, ui size, fComplex A, fComplex B );
C++ VecObj#include <OptiVec.h>
void vector<T>::divrV( const vector<T>& X, const vector<T>& Y );
void vector<T>::x_divrV( const vector<T>& X, const vector<T>& Y, const T& A, const T& B );
void vector<complex<T>>::divrV( const vector<complex<T>>& X, const vector<complex<T>>& Y );
void vector<complex<T>>::divrReV( const vector<complex<T>>& X, const vector<T>& Y );
void vector<complex<T>>::x_divrV( const vector<complex<T>>& X, const vector<complex<T>>& Y, complex<T> A, complex<T> B );
void vector<complex<T>>::x_divrReV( const vector<complex<T>>& X, const vector<T>& Y, complex<T> A, complex<T> B );
Pascal/Delphiuses VFmath;
procedure VF_divrV( Z, X, Y:fVector; size:UIntSize );
procedure VFx_divrV( Z, X, Y:fVector; size:UIntSize; A, B:Single );
procedure VCF_divrV( Z, X, Y:cfVector; size:UIntSize );
procedure VCF_divrReV( Z, X:cfVector; Y:fVector; size:UIntSize );
procedure VCFx_divrV( Z, X, Y:cfVector; size:UIntSize; A, B:fComplex );
procedure VCFx_divrReV( Z, X:cfVector; Y:fVector; size:UIntSize; A, B:fComplex );
CUDA-Funktion C/C++#include <cudaVFmath.h>
#include <cudaVCFmath.h>
int cudaVF_divrV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
int cudaVFs_divrV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float C );
int cusdVFs_divrV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_C );
int cudaVFx_divrV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float A, float B );
int cusdVFx_divrV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_A, float *d_B );
int cudaVCF_divrReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size );
int cudaVCFx_divrReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size, fComplex A, fComplex B );
int cusdVCFx_divrReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size, fComplex *d_A, fComplex *d_B );
void VFcu_divrV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
void VFscu_divrV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float C );
void VFxcu_divrV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float A, float B );
void VCFcu_divrReV( cfVector h_Z, cfVector h_X, fVector h_Y, ui size );
void VCFxcu_divrV( cfVector h_Z, cfVector h_X, cfVector h_Y, ui size, fComplex A, fComplex B );
void VCFxcu_divrReV( cfVector h_Z, cfVector h_X, fVector h_Y, ui size, fComplex A, fComplex B );
CUDA-Funktion Pascal/Delphiuses VFmath, VCFmath;
function cudaVF_divrV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cudaVFs_divrV( d_Z, d_X, d_Y:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVFs_divrV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function cudaVFx_divrV( d_Z, d_X, d_Y:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_divrV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function cudaVCF_divrReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize ): IntBool;
function cudaVCFx_divrReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize; A, B:fComplex ): IntBool;
function cusdVCFx_divrReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize; d_A, d_B:PfComplex ): IntBool;
procedure VFcu_divrV( h_Z, h_X, h_Y:fVector; size:UIntSize );
procedure VFscu_divrV( h_Z, h_X, h_Y:fVector; size:UIntSize; C:Single );
procedure VFxcu_divrV( h_Z, h_X, h_Y:fVector; size:UIntSize; A, B:Single );
procedure VCFcu_divrReV( h_Z, h_X:cfVector; h_Y:fVector; size:UIntSize );
procedure VCFxcu_divrReV( h_Z, h_X:cfVector; h_Y:fVector; size:UIntSize; A, B:fComplex );
Beschreibungeinfache Versionen: Zi = Yi / Xi
erweiterte Versionen: Zi = Yi / (A*Xi+B)
Die komplexen Fließkomma-Versionen existieren in zwei Varianten. In der ersten (z.B. VCF_divrV,   VCFx_divrV) sind X, Y und Z alle komplex; in der zweiten ist Y reell (z.B. VCF_divrReV - umgekehrte Division, bei der ein reeller durch einen komplexen Vektor dividiert wird).
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_divrC,   VF_divrVI,   VF_addV,   VF_mulV,   VF_modV,   VF_visV,   VF_redV

 

VF_divrVIVD_divrVIVE_divrVI
VF_divrVBIVD_divrVBIVE_divrVBI
VF_divrVSIVD_divrVSIVE_divrVSI
VF_divrVLIVD_divrVLIVE_divrVLI
VF_divrVQIVD_divrVQIVE_divrVQI
VF_divrVUVD_divrVUVE_divrVU
VF_divrVUBVD_divrVUBVE_divrVUB
VF_divrVUSVD_divrVUSVE_divrVUS
VF_divrVULVD_divrVULVE_divrVUL
VF_divrVUQVD_divrVUQVE_divrVUQ
VF_divrVUIVD_divrVUIVE_divrVUI
FunktionUmgekehrte Division: Elemente von Ganzzahlvektor durch entsprechende Elemente von Fließkomma-Vektor dividieren
Syntax C/C++#include <VFmath.h>
void VF_divrVI( fVector Z, fVector X, iVector Y,ui size );
void VF_divrVUB( fVector Z, fVector X, ubVector Y, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::divrVI( const vector<T>& X, const vector<int>& Y );
void vector<T>::divrVUS( const vector<T>& X, const vector<unsigned short>& Y, );
Pascal/Delphiuses VFmath;
procedure VF_divrVI( Z, X:fVector; Y:iVector; size:UIntSize );
procedure VF_divrVUL( Z, X:fVector; Y:ulVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_divrVI( fVector d_Z, fVector d_X, iVector d_Y,ui size );
int cudaVF_divrVUB( fVector d_Z, fVector d_X, ubVector d_Y, ui size );
void VFcu_divrVI( fVector h_Z, fVector h_X, iVector h_Y,ui size );
void VFcu_divrVUB( fVector h_Z, fVector h_X, ubVector h_Y, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_divrVI( d_Z, d_X:fVector; d_Y:iVector; size:UIntSize ): IntBool;
function cudaVF_divrVUL( d_Z, d_X:fVector; d_Y:ulVector; size:UIntSize ): IntBool;
procedure VFcu_divrVI( h_Z, h_X:fVector; h_Y:iVector; size:UIntSize );
procedure VFcu_divrVUL( h_Z, h_X:fVector; h_Y:ulVector; size:UIntSize );
BeschreibungZi = Yi / Xi
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_divrV,   VF_divVI,   VF_addVI

 

VF_divVVD_divVVE_divV
VFs_divVVDs_divVVEs_divV
VFx_divVVDx_divVVEx_divV
VCF_divVVCD_divVVCE_divV
VCF_divReVVCD_divReVVCE_divReV
VCFx_divVVCDx_divVVCEx_divV
VCFx_divReVVCDx_divReVVCEx_divReV
VPF_divVVPD_divVVPE_divV
VPF_divReVVPD_divReVVPE_divReV
VI_divVVBI_divVVSI_divVVLI_divVVQI_divV 
VU_divVVUB_divVVUS_divVVUL_divVVUQ_divVVUI_divV
FunktionDivision zweier Vektoren
Syntax C/C++#include <VFmath.h>
void VF_divV( fVector Z, fVector X, fVector Y, ui size );
void VFs_divV( fVector Z, fVector X, fVector Y, ui size, float C );
void VFx_divV( fVector Z, fVector X, fVector Y, ui size, float A, float B );
void VCF_divV( cfVector Z, cfVector X, cfVector Y, ui size );
void VCF_divReV( cfVector Z, cfVector X, fVector Y, ui size );
void VCFx_divV( cfVector Z, cfVector X, cfVector Y, ui size, fComplex A, fComplex B );
void VCFx_divReV( cfVector Z, cfVector X, fVector Y, ui size, fComplex A, fComplex B );
C++ VecObj#include <OptiVec.h>
void vector<T>::divV( const vector<T>& X, const vector<T>& Y );
void vector<T>::s_divV( const vector<T>& X, const vector<T>& Y, const T& C );
void vector<T>::x_divV( const vector<T>& X, const vector<T>& Y, const T& A, const T& B );
void vector<complex<T>>::divV( const vector<complex<T>>& X, const vector<complex<T>>& Y );
void vector<complex<T>>::divReV( const vector<complex<T>>& X, const vector<T>& Y );
void vector<complex<T>>::x_divV( const vector<complex<T>>& X, const vector<complex<T>>& Y, complex<T> A, complex<T> B );
void vector<complex<T>>::x_divReV( const vector<complex<T>>& X, const vector<T>& Y, complex<T> A, complex<T> B );
Pascal/Delphiuses VFmath;
procedure VF_divV( Z, X, Y:fVector; size:UIntSize );
procedure VFs_divV( Z, X, Y:fVector; size:UIntSize; C:Single );
procedure VFx_divV( Z, X, Y:fVector; size:UIntSize; A, B:Single );
procedure VCF_divV( Z, X, Y:cfVector; size:UIntSize );
procedure VCF_divReV( Z, X:cfVector; Y:fVector; size:UIntSize );
procedure VCFx_divV( Z, X, Y:cfVector; size:UIntSize; A, B:fComplex );
procedure VCFx_divrReV( Z, X:cfVector; Y:fVector; size:UIntSize; A, B:fComplex );
CUDA-Funktion C/C++#include <cudaVFmath.h>
#include <cudaVCFmath.h>
int cudaVF_divV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
int cudaVFs_divV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float C );
int cusdVFs_divV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_C );
int cudaVFx_divV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float A, float B );
int cusdVFx_divV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_A, float *d_B );
int cudaVCF_divReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size );
int cudaVCFx_divReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size, fComplex A, fComplex B );
int cusdVCFx_divReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size, fComplex *d_A, fComplex *d_B );
void VFcu_divV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
void VFscu_divV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float C );
void VFxcu_divV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float A, float B );
void VCFcu_divReV( cfVector h_Z, cfVector h_X, fVector h_Y, ui size );
void VCFxcu_divV( cfVector h_Z, cfVector h_X, cfVector h_Y, ui size, fComplex A, fComplex B );
void VCFxcu_divReV( cfVector h_Z, cfVector h_X, fVector h_Y, ui size, fComplex A, fComplex B );
CUDA-Funktion Pascal/Delphiuses VFmath, VCFmath;
function cudaVF_divV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cudaVFs_divV( d_Z, d_X, d_Y:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVFs_divV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function cudaVFx_divV( d_Z, d_X, d_Y:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_divV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function cudaVCF_divReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize ): IntBool;
function cudaVCFx_divReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize; A, B:fComplex ): IntBool;
function cusdVCFx_divReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize; d_A, d_B:PfComplex ): IntBool;
procedure VFcu_divV( h_Z, h_X, h_Y:fVector; size:UIntSize );
procedure VFscu_divV( h_Z, h_X, h_Y:fVector; size:UIntSize; C:Single );
procedure VFxcu_divV( h_Z, h_X, h_Y:fVector; size:UIntSize; A, B:Single );
procedure VCFcu_divReV( h_Z, h_X:cfVector; h_Y:fVector; size:UIntSize );
procedure VCFxcu_divReV( h_Z, h_X:cfVector; h_Y:fVector; size:UIntSize; A, B:fComplex );
Beschreibungeinfache Versionen: Zi = Xi / Yi
skalierte Versionen: Zi = C * (Xi / Yi)
erweiterte Versionen: Zi = (A*Xi+B) / Yi
Die komplexen Fließkomma-Versionen existieren in zwei Varianten. In der ersten (z.B. VCF_divV,   VCFx_divV) sind X, Y, und Z alle komplex; in der zweiten ist Y reell (z.B. VCF_divReV - "Division durch reellen Vektor").
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_divC,   VF_divVI,   VF_addV,   VF_mulV,   VF_modV,   VF_visV,   VF_redV

 

VF_divVIVD_divVIVE_divVI
VF_divVBIVD_divVBIVE_divVBI
VF_divVSIVD_divVSIVE_divVSI
VF_divVLIVD_divVLIVE_divVLI
VF_divVQIVD_divVQIVE_divVQI
VF_divVUVD_divVUVE_divVU
VF_divVUBVD_divVUBVE_divVUB
VF_divVUSVD_divVUSVE_divVUS
VF_divVULVD_divVULVE_divVUL
VF_divVUQVD_divVUQVE_divVUQ
VF_divVUIVD_divVUIVE_divVUI
FunktionElement-weise Division von Fließkomma- durch Ganzzahl-Vektor
Syntax C/C++#include <VFmath.h>
void VF_divVI( fVector Z, fVector X, iVector Y,ui size );
void VF_divVUB( fVector Z, fVector X, ubVector Y, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::divVI( const vector<T>& X, const vector<int>& Y );
void vector<T>::divVUS( const vector<T>& X, const vector<unsigned short>& Y, );
Pascal/Delphiuses VFmath;
procedure VF_divVI( Z, X:fVector; Y:iVector; size:UIntSize );
procedure VF_divVUL( Z, X:fVector; Y:ulVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_divVI( fVector d_Z, fVector d_X, iVector d_Y,ui size );
int cudaVF_divVUB( fVector d_Z, fVector d_X, ubVector d_Y, ui size );
void VFcu_divVI( fVector h_Z, fVector h_X, iVector h_Y,ui size );
void VFcu_divVUB( fVector h_Z, fVector h_X, ubVector h_Y, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_divVI( d_Z, d_X:fVector; d_Y:iVector; size:UIntSize ): IntBool;
function cudaVF_divVUL( d_Z, d_X:fVector; d_Y:ulVector; size:UIntSize ): IntBool;
procedure VFcu_divVI( h_Z, h_X:fVector; h_Y:iVector; size:UIntSize );
procedure VFcu_divVUL( h_Z, h_X:fVector; h_Y:ulVector; size:UIntSize );
BeschreibungZi = Xi / Yi
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_divV,   VF_divrVI,   VF_addVI

 

V_drawAxes
FunktionX-Y-Koordinatensystem zeichnen
Syntax C/C++#include <Vgraph.h>
void V_drawAxes( long double Xmin, long double Xmax, long double Ymin, long double Ymax );
Pascal/Delphiuses Vgraph;
procedure V_drawAxes( xmin, xmax, ymin, ymax:Extended );
BeschreibungEin cartesisches Koordinatensystem wird gezeichnet mit einer X-Achse von xmin bis xmax und einer Y-Achse von ymin bis ymax. Jede Achse wird zehnfach unterteilt. Wenn eine automatische Optimierung der Skalierung erwünscht ist, verwende man statt V_drawAxes die Funktion V_findAxes.
Wie alle graphischen Funktionen von VectorLib kann auch diese erst aufgerufen werden, nachdem die Zeichenroutinen mittels V_initPlot initialisiert worden sind. V_drawAxes wird intern von allen Funktionen der VF_xyAutoPlot-Familie aufgerufen.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisV_findAxes,   V_initPlot,   VF_xyAutoPlot,   VF_xyDataPlot,  Kap. 4.12

 

V_DtoFV_DtoE
FunktionDatentyp-Umwandlungen. Siehe V_FtoD.

 

VF_elementVD_elementVE_element
VCF_elementVCD_elementVCE_element
VCF_elementReVCD_elementReVCE_elementRe
VCF_elementImVCD_elementImVCE_elementIm
VPF_elementVPD_elementVPE_element
VPF_elementMagVPD_elementMagVPE_elementMag
VPF_elementArgVPD_elementArgVPE_elementArg
VI_elementVBI_elementVSI_elementVLI_elementVQI_element 
VU_elementVUB_elementVUS_elementVUL_elementVUQ_elementVUI_element
FunktionWert eines bestimmten Vektorelementes
Syntax C/C++#include <VFstd.h>
float VF_element( fVector X, ui pos );
#include <VCFstd.h>
fComplex VCF_element( cfVector X, ui pos );
float VCF_elementRe( cfVector X, ui pos );
float VCF_elementIm( cfVector X, ui pos );
C++ VecObj#include <OptiVec.h>
T vector<T>::element( ui pos );
complex<T> vector<complex<T>>::element( ui pos );
T vector<complex<T>>::elementRe( ui pos );
T vector<complex<T>>::elementIm( ui pos );
Pascal/Delphiuses VFstd;
function VF_element( X:fVector; pos:UIntSize ): Single;
uses VCFstd;
function VCF_element( X:cfVector; pos:UIntSize ): fComplex;
function VCF_elementRe( X:cfVector; pos:UIntSize ): Single;
function VCF_elementIm( X:cfVector; pos:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
float cudaVF_element( fVector d_X, ui pos );
#include <cudaVCFstd.h>
fComplex cudaVCF_element( cfVector d_X, ui pos );
float cudaVCF_elementRe( cfVector d_X, ui pos );
float cudaVCF_elementIm( cfVector d_X, ui pos );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_element( d_X:fVector; pos:UIntSize ): Single;
uses VCFstd;
function cudaVCF_element( d_X:cfVector; pos:UIntSize ): fComplex;
function cudaVCF_elementRe( d_X:cfVector; pos:UIntSize ): Single;
function cudaVCF_elementIm( d_X:cfVector; pos:UIntSize ): Single;
Beschreibunggibt Xpos zurück.
Diese Funktion wird benötigt, um einzelne Elemente dynamisch allozierter Vektoren zu lesen. Man beachte, dass die Notation mit eckigen Klammern, X[i], in Delphi und Lazarus nicht auf die dynamisch erzeugten Vektoren von OptiVec angewandt werden kann. Auch für Device-Vektoren mit CUDA darf sie nicht verwendet werden. Ferner verhindert ein Bug in CLang die korrekte Adressierung von extended-genauen Vektor-Elementen als X[i]. Für alle diese Fälle benutze man also V?_element.
VF_element gestattet nur Lesezugriff. Dies bedeutet, dass eine Anweisung wie
VF_element( X, 4 ) := 5;
nicht zulässig ist. Für Schreibzugriff rufe man vielmehr V?_setElement.
Fehlerbehandlungkeine
RückgabewertX[pos]
QuerverweisVF_Pelement,   VF_setElement,   VF_getElement,   VF_accElement,   VF_decElement

 

VF_equ0VD_equ0VE_equ0
VCF_equ0VCD_equ0VCE_equ0
VCF_Reequ0VCD_Reequ0VCE_Reequ0
VCF_Imequ0VCD_Imequ0VCE_Imequ0
VPF_equ0VPD_equ0VPE_equ0
VI_equ0VBI_equ0VSI_equ0VLI_equ0VQI_equ0 
VU_equ0VUB_equ0VUS_equ0VUL_equ0VUQ_equ0VUI_equ0
Funktion(Re-) Initialisierung eines Vektors mit 0
Syntax C/C++#include <VFstd.h>
void VF_equ0( fVector X, ui size );
void VCF_Reequ0( cfVector X, ui size );
void VCF_Imequ0( cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::equ0();
void vector<complex<T>>::Reequ0();
void vector<complex<T>>::Imequ0();
Pascal/Delphiuses VFstd;
procedure VF_equ0( X:fVector; size:UIntSize );
procedure VCF_Reequ0( X:cfVector; size:UIntSize );
procedure VCF_Imequ0( X:cfVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_equ0( fVector d_X, ui size );
int cudaVCF_Reequ0( cfVector d_X, ui size );
int cudaVCF_Imequ0( cfVector d_X, ui size );
void VFcu_equ0( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_equ0( d_X:fVector; size:UIntSize ): IntBool;
function cudaVCF_Reequ0( d_X:cfVector; size:UIntSize ): IntBool;
function cudaVCF_Imequ0( d_X:cfVector; size:UIntSize ): IntBool;
procedure VFcu_equ0( h_X:fVector; size:UIntSize );
BeschreibungV?_equ0: Xi = 0
VC?_Reequ0: Xi.Re = 0 (Xi.Im bleibt unverändert)
VC?_Imequ0: Xi.Im = 0 (Xi.Re bleibt unverändert)
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_equ1,   VF_equC,   VF_equV

 

VF_equ1VD_equ1VE_equ1
VCF_equ1VCD_equ1VCE_equ1
VPF_equ1VPD_equ1VPE_equ1
FunktionInitialisierung eines Vektors mit 1.0
Syntax C/C++#include <VFstd.h>
void VF_equ1( fVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::equ1();
Pascal/Delphiuses VFstd;
procedure VF_equ1( X:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_equ1( fVector d_X, ui size );
void VFcu_equ1( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_equ1( d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_equ1( h_X:fVector; size:UIntSize );
BeschreibungXi = 1.0
In den cartesisch-komplexen Versionen wird der Imaginärteil gleich 0 gesetzt. In den polar-komplexen Versionen werden alle Elemente auf den Wert {1.0 @ 0} gesetzt.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_equ0,   VF_equm1,   VF_equC,   VF_equV

 

VF_equCVD_equCVE_equC
VCF_equCVCD_equCVCE_equC
VPF_equCVPD_equCVPE_equC
VI_equCVBI_equCVSI_equCVLI_equCVQI_equC 
VU_equCVUB_equCVUS_equCVUL_equCVUQ_equCVUI_equC
FunktionInitialisierung eines Vektors mit einem bestimmten Wert
Syntax C/C++#include <VFstd.h>
void VF_equC( fVector X, ui size, float C );
C++ VecObj#include <OptiVec.h>
void vector<T>::equC( const T& C );
Pascal/Delphiuses VFstd;
procedure VF_equC( X:fVector; size:UIntSize; C:Single );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_equC( fVector d_X, ui size, float C );
int cusdVF_equC( fVector d_X, ui size, float *d_C );
void VFcu_equC( fVector h_X, ui size, float C );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_equC( d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_equC( d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VFcu_equC( h_X:fVector; size:UIntSize; C:Single );
BeschreibungXi = C
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_equ0,   VF_equ1,   VF_equV,   VF_comb

 

VF_equm1VD_equm1VE_equm1
VCF_equm1VCD_equm1VCE_equm1
VPF_equm1VPD_equm1VPE_equm1
FunktionInitialisierung aller Vektorelemente mit −1.0.
Syntax C/C++#include <VFstd.h>
void VF_equm1( fVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::equm1();
Pascal/Delphiuses VFstd;
procedure VF_equm1( X:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_equm1( fVector d_X, ui size );
void VFcu_equm1( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_equm1( d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_equm1( h_X:fVector; size:UIntSize );
BeschreibungXi = −1.0
In den cartesisch-komplexen Versionen wird der Imaginärteil gleich 0 gesetzt. In den polar-komplexen Versionen werden alle Elemente auf den Wert {1.0 @ p } gesetzt.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_equ0,   VF_equ1,   VF_equC,   VF_equV

 

VF_equVVD_equVVE_equV
VCF_equVVCD_equVVCE_equV
VFx_equVVDx_equVVEx_equV
VCFx_equVVCDx_equVVCEx_equV
VPF_equVVPD_equVVPE_equV
VI_equVVBI_equVVSI_equVVLI_equVVQI_equV 
VU_equVVUB_equVVUS_equVVUL_equVVUQ_equVVUI_equV
FunktionInitialisierung eines Vektors mit der Kopie eines anderen
Syntax C/C++#include <VFstd.h>
void VF_equV( fVector Y, fVector X, ui size );
void VFx_equV( fVector Y, fVector X, ui size, float A, float B );
C++ VecObj#include <OptiVec.h>
void vector<T>::equV( const vector<T>& X );
void vector<T>::x_equV( const vector<T>& X, const T& A, const T& B );
Pascal/Delphiuses VFstd;
procedure VF_equV( Y, X:fVector; size:UIntSize );
procedure VFx_equV( Y, X:fVector; size:UIntSize; A, B:Single );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_equV( fVector d_Y, fVector d_X, ui size );
int cudaVFx_equV( fVector d_Y, fVector d_X, ui size, float A, float B );
int cusdVFx_equV( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B );
void VFcu_equV( fVector h_Y, fVector h_X, ui size );
void VFxcu_equV( fVector h_Y, fVector h_X, ui size, float A, float B );
 
int cudaVF_equVhost( fVector d_Y, fVector h_X, ui size );
int VF_equVdevice( fVector h_Y, fVector d_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_equV( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_equV( d_Y, d_X:fVector; size:UIntSize; A, B:Single );
function cusdVFx_equV( d_Y, d_X:fVector; size:UIntSize; d_A, d_B:PSingle );
procedure VFcu_equV( h_Y, h_X:fVector; size:UIntSize );
procedure VFxcu_equV( h_Y, h_X:fVector; size:UIntSize; A, B:Single );
 
function cudaVF_equVhost( d_Y, h_X:fVector; size:UIntSize ): IntBool;
function VF_equVdevice( h_Y, d_X:fVector; size:UIntSize ): IntBool;
Beschreibungeinfache Versionen: Yi = Xi
erweiterte Versionen: Yi = A * Xi + B
CUDA-Versionen: cudaVF_equVhost und VF_equVdevice kopieren Vektoren von Host- zu Device-Memory und umgekehrt.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_equ0,   VF_equ1,   VF_equC

 

VF_erfVD_erfVE_erf
VFx_erfVDx_erfVEx_erf
FunktionGauss'sches Fehlerintegral (engl.: error function)
Syntax C/C++#include <VFmath.h>
int VF_erf( fVector Y, fVector X, ui size );
int VFx_erf( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::erf( const vector<T>& X );
int vector<T>::x_erf( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_erf( Y,X:fVector; size:UIntSize ): IntBool;
function VFx_erf( Y,X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_erf( fVector d_Y, fVector d_X, ui size );
int cudaVFx_erf( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_erf( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_erf( fVector h_Y, fVector h_X, ui size );
int VFxcu_erf( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_erf( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_erf( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_erf( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_erf( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_erf( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = erf( Xi )
erweiterte Versionen: Yi = C * erf( A*Xi+B )
FehlerbehandlungEs dürften keine Fehler auftreten.
Rückgabewertimmer FALSE(0)
QuerverweisVF_erfc,   VF_Gauss

 

VF_erfcVD_erfcVE_erfc
VFx_erfcVDx_erfcVEx_erfc
FunktionKomplement des Gauss'schen Fehlerintegrals (engl.: complementary error function)
Syntax C/C++#include <VFmath.h>
int VF_erfc( fVector Y, fVector X, ui size );
int VFx_erfc( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::erfc( const vector<T>& X );
int vector<T>::x_erfc( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_erfc( Y,X:fVector; size:UIntSize ): IntBool;
function VFx_erfc( Y,X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_erfc( fVector d_Y, fVector d_X, ui size );
int cudaVFx_erfc( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_erfc( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_erfc( fVector h_Y, fVector h_X, ui size );
int VFxcu_erfc( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_erfc( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_erfc( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_erfc( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_erfc( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_erfc( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = 1.0 - erf( Xi )
erweiterte Versionen: Yi = C * (1.0 - erf( A*Xi+B ))
FehlerbehandlungEs dürften keine Fehler auftreten.
Rückgabewertimmer FALSE(0)
QuerverweisVF_erf,   VF_Gauss

 

VF_EuclidVD_EuclidVE_Euclid
FunktionEuclid'sche Norm eines Vektors
Syntax C/C++#include <VFstd.h>
float VF_Euclid( fVector X, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::Euclid();
Pascal/Delphiuses VFstd;
function VF_Euclid( X:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_Euclid( float *h_RetVal, fVector d_X, ui size );
int cusdVF_Euclid( float *d_RetVal, fVector d_X, ui size );
float VFcu_Euclid( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_Euclid( var h_RetVal:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_Euclid( d_RetVal:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_Euclid( h_X:fVector; size:UIntSize ): Single;
Beschreibungnorm = sqrt( Summe( Xi2 ) )
Die Euclid'sche Norm eines Vektors ist als die Wurzel des Skalarproduktes des Vektors mit sich selbst definiert.
Fehlerbehandlungkeine (aber Vorsicht vor möglichem Überlaufs!)
RückgabewertNorm des Vektors
QuerverweisVF_ssq,   VF_rms,   VF_scalprod,   VF_xprod

 

VF_expVD_expVE_exp
VCF_expVCD_expVCE_exp
VFx_expVDx_expVEx_exp
VCFx_expVCDx_expVCEx_exp
VCF_exptoPVCD_exptoPVCE_exptoP
FunktionExponentialfunktion
Syntax C/C++#include <VFmath.h>
int VF_exp( fVector Y, fVector X, ui size );
int VFx_exp( fVector Y, fVector X, ui size, float A, float B, float C );
int VCF_exptoP( pfVector Y, cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::exp( const vector<T>& X );
int vector<T>::x_exp( const vector<T>& X, const T& A, const T& B, const T& C );
int vector<polar<T>>::exptoP( const vector<complex<T>>& X );
Pascal/Delphiuses VFmath;
function VF_exp( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_exp( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function VCF_exptoP( Y:pfVector; X:cfVector; size:UIntSize ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_exp( fVector d_Y, fVector d_X, ui size );
int cudaVFx_exp( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_exp( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_exp( fVector h_Y, fVector h_X, ui size );
int VFxcu_exp( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_exp( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_exp( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_exp( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_exp( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_exp( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = exp( Xi )
erweiterte Versionen: Yi = C * exp( A*Xi+B )
Die Euler'sche Konstante e wird in die Xi-te Potenz erhoben.
Für cartesisch-komplexe Eingabezahlen kann das Ergebnis entweder wieder im cartesisch-komplexen Format (VCF_exp) oder in Polarkoordinaten (VCF_exptoP) gespeichert werden.
Es existieren etliche von der Exponentialfunktion abgeleitete Funktionen, z.B. ihr Komplement (VF_expc), die Hyperbelfunktionen (z.B. VF_sinh) oder die Gauss'sche Verteilungsfunktion (VF_Gauss); siehe Kap. 4.6.7.
FehlerbehandlungOVERFLOW-Fehler ergeben ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_log,   VF_expc,   VF_pow,   VF_powexp,   VF_sinh,   VF_exp2,   VF_Gauss,   VPF_logtoC,   exp

 

VF_exp2VD_exp2VE_exp2
VFx_exp2VDx_exp2VEx_exp2
FunktionExponentialfunktion zur Basis 2
Syntax C/C++#include <VFmath.h>
int VF_exp2( fVector Y, fVector X, ui size );
int VFx_exp2( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::exp2( const vector<T>& X );
int vector<T>::x_exp2( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_exp2( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_exp2( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_exp2( fVector d_Y, fVector d_X, ui size );
int cudaVFx_exp2( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_exp2( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_exp2( fVector h_Y, fVector h_X, ui size );
int VFxcu_exp2( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_exp2( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_exp2( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_exp2( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_exp2( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_exp2( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = 2 Xi
erweiterte Versionen: Yi = C * 2 (A*Xi+B)
2.0 wird in die Xi-te Potenz erhoben. Diese Funktionsnamen werden als Synonyme für VF_pow2 etc. verwendet.
FehlerbehandlungOVERFLOW-Fehler ergeben ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_exp,   VF_exp10,   VF_ipow2,   VF_scale2,   VF_log2

 

VF_exp10VD_exp10VE_exp10
VFx_exp10VDx_exp10VEx_exp10
FunktionExponentialfunktion zur Basis 10
Syntax C/C++#include <VFmath.h>
int VF_exp10( fVector Y, fVector X, ui size );
int VFx_exp10( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::exp10( const vector<T>& X );
int vector<T>::x_exp10( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_exp10( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_exp10( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_exp10( fVector d_Y, fVector d_X, ui size );
int cudaVFx_exp10( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_exp10( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_exp10( fVector h_Y, fVector h_X, ui size );
int VFxcu_exp10( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_exp10( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_exp10( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_exp10( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_exp10( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_exp10( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = 10 Xi
erweiterte Versionen: Yi = C * 10 (A*Xi+B)
10.0 wird in die Xi-te Potenz erhoben. Diese Funktionsnamen werden als Synonyme für VF_pow10 etc. verwendet.
FehlerbehandlungOVERFLOW-Fehler ergeben ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_exp,   VF_exp2,   VF_ipow10,   VF_scale10,   VF_log10

 

VF_expArbBaseVD_expArbBaseVE_expArbBase
VCF_expArbBaseVCD_expArbBaseVCE_expArbBase
VFx_expArbBaseVDx_expArbBaseVEx_expArbBase
VCFx_expArbBaseVCDx_expArbBaseVCEx_expArbBase
FunktionExponentialfunktion zu beliebiger Basis
Syntax C/C++#include <VFmath.h>
int VF_expArbBase( fVector Y, fVector X, ui size, float Base );
int VFx_expArbBase( fVector Y, fVector X, ui size, float Base, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::expArbBase( const vector<T>& X, const T& Base );
int vector<T>::x_expArbBase( const vector<T>& X, const T& Base, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_expArbBase( Y, X:fVector; size:UIntSize; Base:Single ): IntBool;
function VFx_expArbBase( Y, X:fVector; size:UIntSize; Base, A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_expArbBase( fVector d_Y, fVector d_X, ui size, float Base );
int cusdVF_expArbBase( fVector d_Y, fVector d_X, ui size, float *d_Base );
int cudaVFx_expArbBase( fVector d_Y, fVector d_X, ui size, float Base, float A, float B, float C );
int cusdVFx_expArbBase( fVector d_Y, fVector d_X, ui size, float *d_Base, float *d_A, float *d_B, float *d_C );
int VFcu_expArbBase( fVector h_Y, fVector h_X, ui size, float Base );
int VFxcu_expArbBase( fVector h_Y, fVector h_X, ui size, float Base, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_expArbBase( d_Y, d_X:fVector; size:UIntSize; Base:Single ): IntBool;
function cusdVF_expArbBase( d_Y, d_X:fVector; size:UIntSize; d_Base:PSingle ): IntBool;
function cudaVFx_expArbBase( d_Y, d_X:fVector; size:UIntSize; Base, A, B, C:Single ): IntBool;
function cusdVFx_expArbBase( d_Y, d_X:fVector; size:UIntSize; d_Base, d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_expArbBase( h_Y, h_X:fVector; size:UIntSize; Base:Single ): IntBool;
function VFxcu_expArbBase( h_Y, h_X:fVector; size:UIntSize; Base, A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = Base Xi
erweiterte Versionen: Yi = C * Base (A*Xi+B)
Die Basis muss in den reellen Versionen positiv und nicht Null sein; in den komplexen Versionen darf sie lediglich nicht Null sein.
FehlerbehandlungOVERFLOW-Fehler ergeben ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_exp,   VF_pow

 

VF_expcVD_expcVE_expc
VFx_expcVDx_expcVEx_expc
FunktionKomplement der Exponentialfunktion
Syntax C/C++#include <VFmath.h>
int VF_expc( fVector Y, fVector X, ui size );
int VFx_expc( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::expc( const vector<T>& X );
int vector<T>::x_expc( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_expc( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_expc( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_expc( fVector d_Y, fVector d_X, ui size );
int cudaVFx_expc( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_expc( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_expc( fVector h_Y, fVector h_X, ui size );
int VFxcu_expc( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_expc( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_expc( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_expc( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_expc( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_expc( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = 1 - exp( Xi )
erweiterte Versionen: Yi = C * (1 - exp [A*Xi + B ])
Die Differenz zwischen 1.0 und der Exponentialfunktion von Xi wird berechnet. (Die Prozessoren der 80x87-Familie liefern die expc-Funktion direkt in hoher Genauigkeit; tatsächlich wird die Exponentialfunktion über die expc-Funktion berechnet und nicht umgekehrt.) Diese Funktion tritt häufig in der Beschreibung von Zerfallsprozessen auf.
FehlerbehandlungOVERFLOW-Fehler ergeben ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_log,   VF_exp,   VF_pow,   VF_sinh,   VF_exp2,   VF_Gauss,  exp

 

VF_expmx2VD_expmx2VE_expmx2
VFx_expmx2VDx_expmx2VEx_expmx2
FunktionExponentialfunktion des negativen Quadrates des Arguments
Syntax C/C++#include <VFmath.h>
int VF_expmx2( fVector Y, fVector X, ui size );
int VFx_expmx2( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::expmx2( const vector<T>& X );
int vector<T>::x_expmx2( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_expmx2( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_expmx2( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_expmx2( fVector d_Y, fVector d_X, ui size );
int cudaVFx_expmx2( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_expmx2( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_expmx2( fVector h_Y, fVector h_X, ui size );
int VFxcu_expmx2( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_expmx2( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_expmx2( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_expmx2( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_expmx2( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_expmx2( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = exp( −Xi2 )
erweiterte Versionen: Yi = C * exp( -(A*Xi+B)2 )
Diese Funktion stellt eine Primitiv-Form der Gauss'schen Glockenkurve dar.
FehlerbehandlungEs dürften keine Fehler auftreten.
Rückgabewertimmer FALSE(0)
QuerverweisVF_log,   VF_exp,   VF_Gauss,   VF_sech2,   VF_Lorentz,   exp

 

VF_FFTVD_FFTVE_FFT
VFb_FFTVDb_FFTVEb_FFT
VF_FFTtoCVD_FFTtoCVE_FFTtoC
VFb_FFTtoCVDb_FFTtoCVEb_FFTtoC
VCF_FFTVCD_FFTVCE_FFT
VCFb_FFTVCDb_FFTVCEb_FFT
FunktionSchnelle Fourier-Transformation (engl. Fast Fourier Transform, FFT)
Syntax C/C++#include <VFstd.h>
void VF_FFT( fVector Y, fVector X, ui size, int dir );
void VCF_FFT( cfVector Y, cfVector X, ui size, int dir );
void VF_FFTtoC( cfVector Y, fVector X, ui size );
void VFb_FFT( fVector Y, fVector X, ui size, int dir; fVector Buf );
void VCFb_FFT( cfVector Y, cfVector X, ui size, int dir; cfVector Buf );
void VFb_FFTtoC( cfVector Y, fVector X, ui size; cfVector Buf );
C++ VecObj#include <OptiVec.h>
void vector<T>::FFT( const vector<T>& X, int dir=1 );
void vector<complex<T>>::FFT( const vector<complex<T>>& X, int dir=1 );
void vector<complex<T>>::FFTtoC( const vector<T>& X );
void vector<T>::b_FFT( const vector<T>& X, int dir, vector<T>& Buf );
void vector<complex<T>>::b_FFT( const vector<complex<T>>& X, int dir, vector<complex<T>>& Buf );
void vector<complex<T>>::b_FFTtoC( const vector<T>& X, vector<complex<T>>& Buf );
Pascal/Delphiuses VFstd;
procedure VF_FFT( Y, X:fVector; size:UIntSize; dir:Integer );
procedure VCF_FFT( Y, X:cfVector; size:UIntSize; dir:Integer );
procedure VF_FFTtoC( Y:cfVector; X:fVector; size:UIntSize );
procedure VFb_FFT( Y, X:fVector; size:UIntSize; dir:Integer; Buf: fVector );
procedure VCFb_FFT( Y, X:cfVector; size:UIntSize; dir:Integer; Buf: fVector );
procedure VFb_FFTtoC( Y:cfVector; X:fVector; size:UIntSize; Buf: cfVector );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_FFT( fVector d_Y, fVector d_X, ui size, int dir );
int cudaVCF_FFT( cfVector d_Y, cfVector d_X, ui size, int dir );
int cudaVF_FFTtoC( cfVector d_Y, fVector d_X, ui size );
void VFcu_FFT( fVector h_Y, fVector h_X, ui size, int dir );
void VCFcu_FFT( cfVector h_Y, cfVector h_X, ui size, int dir );
void VFcu_FFTtoC( cfVector h_Y, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd, VCFstd;
function cudaVF_FFT( d_Y, d_X:fVector; size:UIntSize; dir:Integer ): IntBool;
function cudaVCF_FFT( d_Y, d_X:cfVector; size:UIntSize; dir:Integer ): IntBool;
function cudaVF_FFTtoC( d_Y:cfVector; d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_FFT( h_Y, h_X:fVector; size:UIntSize; dir:Integer );
procedure VCFcu_FFT( h_Y, h_X:cfVector; size:UIntSize; dir:Integer );
procedure VFcu_FFTtoC( h_Y:cfVector; h_X:fVector; size:UIntSize );
BeschreibungDie Fourier-Transformation von X wird berechnet und in Y gespeichert. Dabei dürfen X und Y auch identisch sein (also X durch Y überschrieben werden). Die Vorwärts-Transformation erhält man für dir = 1, die Rückwärts-Transformation für dir = −1. Gemäß Konvention enthält die Rückwärts-Transformation eine Skalierung des Ergebnisses mit dem Faktor 1.0/size (wodurch das Ergebnis von einmal Vorwärts- und einmal Rückwärts-Transformation wieder – von Rundungsfehlern abgesehen – den Ursprungsvektor ergibt). Für Situationen, in denen man diese implizite Skalierung umgehen möchte, spezifiziere man dir = -2.
Es wird ein FFT-Algorithmus angewandt, der es erfordert, dass size eine Potenz von 2 sein muss.
Komplexe Version: Sowohl X als auch Y enthalten komplexe Zahlen.
Reell-komplexe Version: Der Eingabevektor X ist reell. Der Ausgabevektor Y ist komplex. Da diese Funktion nur eine Vorwärts-Transformation durchführen kann, wird ein Argument "dir" hier nicht benötigt.
Rein reelle Version: Für die Vorwärts-Transformation ist X ein reeller Vektor. Das Ergebnis Y ist zwar als fVector definiert (also als reeller Vektor), besteht aber aus komplexen Zahlen. Diese sind auf spezielle Weise so gepackt, dass sie in den für einen gleich großen reellen Vektor zur Verfügung stehenden Speicherplatz passen (N=size, U ist die unkomprimierte Fourier-Transformierte von X):
 
Y0Y1Y2Y3  .....  YN-2YN−1
U0.ReUN/2.ReU1.ReU1.Im  .....  UN/2−1.ReUN/2−1.Im

Die Begründung für diese Art des Speicherns ist die folgende: Wenn die size Datenpunkte von X eine reelle Funktion der Zeit darstellen, X = g(t), dann liefert die Vorwärts-Transformation von X eine Funktion U=G(f) in der Frequenz-Domäne. Im Prinzip besteht U aus size+1 komplexen Datenpunkten: size/2 Punkte für positive Frequenzen, noch einmal size/2 Punkte für negative Frequenzen sowie einen Punkt für die Frequenz 0.
Nun gilt für die Fourier-Transformierte einer reellen Funktion die Symmetriebedingung G(-f) = |G(f)|* (der Stern bezeichnet die komplex-konjugierte Form). Daher brauchen die Punkte für negative Frequenzen nicht gespeichert zu werden. Die gesamte Information ist bereits in der positiven Hälfte enthalten. Außerdem sind noch das nullte und das Element mit dem Index size/2 der Transformierten reell, ihre Imaginärteile also 0. Diese beiden nehmen demnach nur je einen reellen Speicherplatz in Anspruch, während die noch verbliebenen size/2−1 komplexen Datenpunkte genau in die übrigen size-2 reellen Speicherplätze passen. So ist sichergestellt, dass X von seiner Transformierten überschrieben werden darf, wenn dies gewünscht wird.

Für die Fourier-Transformation mehrerer gleich-großer Vektoren empfehlen wir, die einzelnen Vektoren in die Zeilen (C/C++) oder Spalten (Pascal/Delphi) einer Matrix zu kopieren und MF_Rows_FFT bzw. MF_Cols_FFT aufzurufen. Je nach Größe der einzelnen Vektoren ist dieses Verfahren ab ca. 4 Vektoren effizienter als die Einzel-Verarbeitung.

Für die reelle Version der Rückwärts-Transformation muss X ein gepackt-komplexer Vektor sein, und man erhält einen reellen Vektor Y.

VFb_FFT, VFb_FFTtoC und VCFb_FFT verwenden den als Argument Buf übergebenen Puffer-Speicher, anstatt ihn selbst zu reservieren. Dadurch sind sie etwas effizienter als die ungepufferten Versionen. Buf muss (mindestens) so groß sein wie X und Y. Außerdem muss Buf 128-bit (P8) bzw. 256-bit( P9) ausgerichtet sein. Um dies zu garantieren, sollte man nur Vektoren als Buf verwenden, die mit der VF_vector-Familie alloziert wurden.

FehlerbehandlungWenn size nicht eine Potenz von 2 ist, wird eine Fehlermeldung "Size must be integer power of 2." ausgegeben und das Programm abgebrochen.
Rückgabewertkeiner
QuerverweisVF_filter,   VF_convolve,   VF_autocorr,   VF_xcorr,   VF_spectrum,   VF_xspectrum,   VF_xspectrumAbs,   VF_coherence

 

VF_fhexprintVD_fhexprintVE_fhexprint
VCF_fhexprintVCD_fhexprintVCE_fhexprint
VPF_fhexprintVPD_fhexprintVPE_fhexprint
VI_fhexprintVBI_fhexprintVSI_fhexprintVLI_fhexprintVQI_fhexprint 
VU_fhexprintVUB_fhexprintVUS_fhexprintVUL_fhexprintVUQ_fhexprintVUI_fhexprint
FunktionAusgabe eines Vektors im Hexadezimal-Format in einen Stream
Syntax C/C++#include <VFstd.h>
void VF_fhexprint( FILE *stream, fVector X, ui size, unsigned nperline, unsigned linewidth );
C++ VecObj#include <OptiVec.h>
void vector<T>::fhexprint( FILE *stream, unsigned nperline, unsigned linewidth );
Pascal/Delphiuses VFstd;
procedure VF_fhexprint( var Stream:Text; X:fVector; size:UIntSize; nperline, linewidth:UInt );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_fhexprint( FILE *stream, fVector d_X, ui size, unsigned nperline, unsigned linewidth );
int cudaVF_fhexprint_buf( FILE *stream, fVector d_X, ui size, unsigned nperline, unsigned linewidth, fVector h_Wk );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_fhexprint( var Stream:Text; d_X:fVector; size:UIntSize; nperline, linewidth:UInt ): IntBool;
function cudaVF_fhexprint_buf( var Stream:Text; d_X:fVector; size:UIntSize; nperline, linewidth:UInt; h_Wk:fVector ): IntBool;
Beschreibungsize Elemente von X werden im Hexadezimal-Format in stream geschrieben, wobei nperline Einträge in jede Zeile der Breite linewidth aufgenommen werden.

Die Ausgabe beginnt immer mit einer neuen Zeile. Man beachte, dass hierdurch Leerzeilen entstehen können. Insbesondere bleibt die erste Zeile einer Datei für eine eventuelle Überschrift reserviert.

Zu Beginn jeder Zeile steht der Index des ersten in diese Zeile geschriebenen Elementes. Danach folgen ein Doppelpunkt und die verlangten nperline Elemente des Vectors X.
Cartesisch-komplexe Zahlen werden in geschweifte Klammern gefaßt, wobei der Imaginärteil durch ein Komma vom Realteil getrennt wird: {Re, Im}. Polar-komplexe Zahlen werden ebenfalls in geschweifte Klammern gefaßt und der Mag- vom Arg-Teil durch ein at-Zeichen getrennt: {Mag @ Arg}.

nur CUDA-Versionen:cudaV?_fhexprint_buf übernimmt einen Host-Vektor h_Wk als zusätzliches Argument. Dieser dient als Pufferspeicher und muss (mindestens) dieselbe Größe haben wie X. Hierdurch wird die interne Bereitstellung von Pufferspeicher bei cudaV?_fhexprint eingespart, so dass cudaV?_fhexprint_buf etwas schneller ist.
 
FehlerbehandlungWenn linewidth nicht für die geforderten nperline Einträge pro Zeile ausreicht, wird eine Fehlermeldung "Cannot use requested format (too many entries per line)." ausgegeben und die Ausgabe mit der maximal möglichen Anzahl von Einträgen pro Zeile durchgeführt.
Rückgabewertkeiner
QuerverweisVF_chexprint,   VF_hexprint,   VF_write,   VF_store,   fprintf

 

VF_filterVD_filterVE_filter
VCF_filterVCD_filterVCE_filter
VFb_filterVDb_filterVEb_filter
VCFb_filterVCDb_filterVCEb_filter
FunktionFrequenz-Filterung
Syntax C/C++#include <VFstd.h>
void VF_filter(fVector Y, fVector X, fVector Flt, ui size );
void VFb_filter(fVector Y, fVector X, fVector Flt, ui size, fVector Buf );
C++ VecObj#include <OptiVec.h>
void vector<T>::filter( const vector<T>& X, const vector<T>& Flt );
void vector<T>::b_filter( const vector<T>& X, const vector<T>& Flt, vector<T>& Buf );
Pascal/Delphiuses VFstd;
procedure VF_filter( Y, X, Flt:fVector; size:UIntSize );
procedure VFb_filter( Y, X, Flt:fVector; size:UIntSize; Buf:fVector );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_filter(fVector d_Y, fVector d_X, fVector d_Flt, ui size );
void VFcu_filter(fVector h_Y, fVector h_X, fVector h_Flt, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_filter( d_Y, d_X, d_Flt:fVector; size:UIntSize ): IntBool;
procedure VFcu_filter( h_Y, h_X, h_Flt:fVector; size:UIntSize );
BeschreibungDas Frequenzfilter Flt wird auf den Vektor X angewendet. Intern wird hierzu eine Fourier-Transformation durchgeführt, die Transformierte mit Flt multipliziert und das Ergebnis wieder zurücktransformiert.

Komplexe Versionen: X, Y und der Filter Flt sind komplexe Vektoren.
Reelle Versionen: X und Y sind reell. Flt muss in dem bei VF_FFT beschriebenen gepackten komplexen Format vorliegen, das man automatisch durch Erzeugung des Filters mittels VF_FFT,   VF_convolve oder VF_deconvolve erhält.

Intern benötigt VF_filter zusätzlichen Pufferspeicher, der automatisch reserviert und wieder freigegeben wird. Bei wiederholten Aufrufen wäre dies ineffizient. Es wird empfohlen, für solche Fälle stattdessen VFb_filter zu verwenden. Die Größe von Buf muss dabei ≥ 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.

Für rein reelle, analytisch bekannte Filterfunktionen konstruiere man den Filter, indem man ihn zunächst für einen reellen Vektor von size/2+1 Elementen berechnet und diesen reellen Vektor anschließen in Flt kopiert, wie in dem folgenden Beispiel (fNyquist = 0.5 / Abtast-Intervall; die gewünschte Grenzwinkelfrequenz ist fGrenz):
 

Beispiel C/C++:float Coeffs[3] = {1.0, 1.4142135, 1.0};
fVector Flt = VF_vector0( size );
fVector RealFlt = VF_vector( size/2+1 );
fVector Freq = VF_vector( size/2+1 );
VF_ramp( Freq, size/2+1, 0, (fNyquist / fGrenz) / (size/2) );
    /* normierte Frequenzen von 0 bis fNyquist / fGrenz */
VF_poly( RealFlt, Freq, size/2+1, Coeffs, 2 );
VF_inv( RealFlt, RealFlt, size/2+1 );
    /* Übertragungsfunktion aus Koeffizienten dieses Filters 2. Ordnung berechnen */
VF_RetoC( (cfVector)Flt, RealFlt, size/2 );
    /* Imaginärteile bleiben 0 */
Flt[1] = RealFlt[ size/2 ]; /* Übertragungsfunktion bei der Nyquist-Frequenz */
VF_filter( Y, X, Flt, size ); /* Anwendung des gerade konstruierten Filters auf X */

 
Dasselbe Beispiel für Pascal/Delphi:const Coeffs: array[0..2] of Single = (1.0, 1.4142135, 1.0);
var Flt, RealFlt, Freq: fVector;
    size_2: UIntSize;
begin
  ...
  size_2 := size div 2;
  Flt := VF_vector0( size );
  RealFlt := VF_vector( size_2+1 );
  Freq := VF_vector( size_2+1 );
  VF_ramp( Freq, size_2+1, 0, (fNyquist / fGrenz) / (size_2) );
      (* normierte Frequenzen von 0 bis fNyquist / fGrenz *)
  VF_poly( RealFlt, Freq, size_2+1, @Coeffs, 2 );
  VF_inv( RealFlt, RealFlt, size_2+1 );
      (* Übertragungsfunktion aus Koeffizienten dieses Filters 2. Ordnung berechnen *)
  VF_RetoC( cfVector(Flt), RealFlt, size_2 );
      (* Imaginärteile bleiben 0 *)
  VF_Pelement( Flt, 1 )^ := VF_element( RealFlt, size_2 );
      (* Übertragungsfunktion bei der Nyquist-Frequenz *)
  
VF_filter( Y, X, Flt, size ); (* Anwendung des gerade konstruierten Filters auf X *)
end;

Für nicht-periodisches X besteht die Gefahr von Rand-Effekten. Man sollte X in die Mitte eines doppelt so großen Vektors kopieren, so dass an beiden Enden genügend Nullen für die erforderliche Isolation sorgen. VF_filter ist dann auf den so erhaltenen größeren Vektor anzuwenden (siehe VF_convolve).

FehlerbehandlungWenn size nicht eine Potenz von 2 ist, meldet sich VF_FFT (worauf VF_filter basiert) mit der Fehlermeldung "Size must be integer power of 2." und bricht das Programm ab.
Rückgabewertkeiner
QuerverweisVF_FFT,   VF_convolve,   VF_autocorr,   VF_xcorr,   VF_spectrum,   VF_smooth,   VF_biquad

 

V_findAxes
FunktionZeichnung eines auf "glatte" Werte an allen Gitternetzlinien skalierten X-Y-Koordinatensystems.
Syntax C/C++#include <Vgraph.h>
void V_findAxes( long double Xmin, long double Xmax, long double Ymin, long double Ymax );
Pascal/Delphiuses Vgraph;
procedure V_findAxes( xmin, xmax, ymin, ymax:Extended );
BeschreibungDiese Funktion wird wohl nur selten vom Programmierer direkt aufgerufen; intern benutzen sie alle V?_xyAutoPlot und weitere Plot-Funktionen. Gemäß den in den Parametern Xmin, Xmax, Ymin und Ymax spezifizierten Achsenbereichen wird ein lineares cartesisches Koordinatensystem gezeichnet mit zehn Unterteilungen sowohl der Abszisse als auch der Ordinate. Wenn nötig, werden dabei die durch beide Achsen abgedeckten Bereiche so vergrößert, dass die folgenden Bedingungen erfüllt sind:
1. Jede Gitternetzlinie repräsentiert einen exakten (und nicht nur gerundeten) Wert.
2. Falls eine oder beide Achsen die Null enthalten, fällt 0 exakt auf eine Gitternetzlinie.

Wenn diese automatische Skalierung nicht erwünscht ist, benutze man V_drawAxes anstelle von V_findAxes.
Bevor V_findAxes aufgerufen werden kann, müssen die Zeichenroutinen durch V_initPlot initialisiert worden sein.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisV_drawAxes,   V_initPlot,   VF_xyAutoPlot

 

VF_floorVD_floorVE_floor
VF_floortoIVD_floortoIVE_floortoI
VF_floortoBIVD_floortoBIVE_floortoBI
VF_floortoSIVD_floortoSIVE_floortoSI
VF_floortoLIVD_floortoLIVE_floortoLI
VF_floortoQIVD_floortoQIVE_floortoQI
VF_floortoUVD_floortoUVE_floortoU
VF_floortoUBVD_floortoUBVE_floortoUB
VF_floortoUSVD_floortoUSVE_floortoUS
VF_floortoULVD_floortoULVE_floortoUL
VF_floortoUQVD_floortoUQVE_floortoUQ
VF_floortoUIVD_floortoUIVE_floortoUI
FunktionAbrunden
Syntax C/C++#include <VFmath.h>
int VF_floor( fVector Y, fVector X, ui size );
int VF_floortoI( iVector Y, fVector X, ui size );
int VF_floortoLI( liVector Y, fVector X, ui size );
int VF_floortoU( uVector Y, fVector X, ui size );

    (analog alle übrigen)
C++ VecObj#include <OptiVec.h>
int vector<T>::floor( const vector<T>& X );
int vector<int>::floortoI( const vector<T>& X );
int vector<long>::floortoLI( const vector<T>& X );
int vector<unsigned>::floortoU( const vector<T>& X );
Pascal/Delphiuses VFmath;
function VF_floor( Y, X:fVector; size:UIntSize ):IntBool;
function VF_floortoI( Y:iVector; X:fVector; size:UIntSize ):IntBool;
function VF_floortoLI( Y:liVector; X:fVector; size:UIntSize ):IntBool;

    (analog alle übrigen)
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_floor( fVector d_Y, fVector d_X, ui size );
int cudaVF_floortoI( iVector d_Y, fVector d_X, ui size );
int VFcu_floor( fVector h_Y, fVector h_X, ui size );
int VFcu_floortoI( iVector h_Y, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_floor( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVF_floortoI( d_Y:iVector; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_floor( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFcu_floortoI( h_Y:iVector; h_X:fVector; size:UIntSize ): IntBool;
BeschreibungJedes Element von X wird auf die nächste kleinere oder gleiche ganze Zahl abgerundet und das Ergebnis in Y gespeichert. Hierbei erfolgt gegebenenfalls eine Umwandlung des Datentyps (in den Varianten VF_floortoI,   VF_floortoLI,   VF_floortoU etc.)
FehlerbehandlungOVERFLOW-Fehler werden behandelt, indem das Resultat gleich dem größten (bzw. am stärksten negativen) Wert gesetzt wird, der in dem jeweiligen Zi-Datentyp möglich ist. DOMAIN-Fehler entstehen durch negative Zahlen in den Funktionen VF_floortoU,   VD_floortoUS etc.; sie führen zum Resultat 0.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_round,   VF_ceil,   VF_chop,   VF_trunc,   ceil,   floor

 

VF_flush0VD_flush0VE_flush0
VCF_flush0VCD_flush0VCE_flush0
FunktionElemente unterhalb eines Schwellenwertes auf 0 setzen
Syntax C/C++#include <VFmath.h>
void VF_flush0( fVector Y, fVector X, ui size, float AbsMin );
void VCF_flush0( fVector Y, fVector X, ui size, fComplex AbsMin );
C++ VecObj#include <OptiVec.h>
void vector<T>::flush0( const vector<T>& X, const T& AbsMin );
void vector<T>::flush0( const vector<T>& X, complex<T> AbsMin );
Pascal/Delphiuses VFmath;
procedure VF_flush0( Y, X:fVector; size:UIntSize; AbsMin:Single );
procedure VCF_flush0( Y, X:cfVector; size:UIntSize; AbsMin:fComplex );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_flush0( fVector d_Y, fVector d_X, ui size, float AbsMin );
int cusdVF_flush0( fVector d_Y, fVector d_X, ui size, float *d_AbsMin );
void VFcu_flush0( fVector h_Y, fVector h_X, ui size, float AbsMin );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_flush0( d_Y, d_X:fVector; size:UIntSize; AbsMin:Single ): IntBool;
function cusdVF_flush0( d_Y, d_X:fVector; size:UIntSize; d_AbsMin:PSingle ): IntBool;
procedure VFcu_flush0( h_Y, h_X:fVector; size:UIntSize; AbsMin:Single );
BeschreibungYi = Xi, wenn | Xi | ≥ AbsMin,
Yi = 0, ansonsten
Diese Funktion ist nach Operationen anzuwenden, bei denen (wie beispielsweise nach VF_FFT) Elemente gleich 0 sein sollten, dies aber durch Rundungsfehler nicht exakt sind. Die komplexen Versionen behandeln Real- und Imaginärteil getrennt. Dabei werden die jeweiligen Schwellenwerte dem Real- und Imaginärteil von AbsMin entnommen. Wenn nur der Imaginärteil editiert werden soll, ist der Realteil von AbsMin gleich 0 zu setzen, z.B. (für C/C++):
VCF_flush0( Y, X, size, fcplx( 0, 1.e-6 ));
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_limit,   VF_flushInv,   VF_absHuge,   VF_maxC

 

VF_flushInvVD_flushInvVE_flushInv
VCF_flushInvVCD_flushInvVCE_flushInv
FunktionVon Elementen oberhalb eines Schwellenwertes den Kehrwert bilden, das Resultat für die übrigen auf 0 setzen
Syntax C/C++#include <VFmath.h>
void VF_flushInv( fVector Y, fVector X, ui size, float AbsMin );
void VCF_flushInv( fVector Y, fVector X, ui size, fComplex AbsMin );
C++ VecObj#include <OptiVec.h>
void vector<T>::flushInv( const vector<T>& X, const T& AbsMin );
void vector<T>::flushInv( const vector<T>& X, complex<T> AbsMin );
Pascal/Delphiuses VFmath;
procedure VF_flushInv( Y, X:fVector; size:UIntSize; AbsMin:Single );
procedure VCF_flushInv( Y, X:cfVector; size:UIntSize; AbsMin:fComplex );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_flushInv( fVector d_Y, fVector d_X, ui size, float AbsMin );
int cusdVF_flushInv( fVector d_Y, fVector d_X, ui size, float *d_AbsMin );
void VFcu_flushInv( fVector h_Y, fVector h_X, ui size, float AbsMin );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_flushInv( d_Y, d_X:fVector; size:UIntSize; AbsMin:Single ): IntBool;
function cusdVF_flushInv( d_Y, d_X:fVector; size:UIntSize; d_AbsMin:PSingle ): IntBool;
procedure VFcu_flushInv( h_Y, h_X:fVector; size:UIntSize; AbsMin:Single );
BeschreibungYi = 1.0 / Xi, if | Xi | ≥ AbsMin,
Yi = 0, ansonsten.

Komplexe Versionen:
Yi = 1.0 / Xi, if | Xi.Re | ≥ AbsMin.Re and | Xi.Im | ≥ AbsMin.Im,
   1.0 / Xi.Re, if | Xi.Re | ≥ AbsMin.Re and | Xi.Im | < AbsMin.Im,
   {0.0, −1.0 / Xi.Im}, if | Xi.Re | < AbsMin.Re and | Xi.Im | ≥ AbsMin.Im,
   0, ansonsten.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_flush0,   VF_limit,   VF_absHuge,   VF_maxC

 

VF_fmodCVD_fmodCVE_fmodC
VF_fmodVVD_fmodVVE_fmodV
VFx_fmodVVDx_fmodVVEx_fmodV
FunktionDivisions-Rest bei Fließkomma-Division
Syntax C/C++#include <VFmath.h>
void VF_fmodC( fVector Y, fVector X, ui size, float C );
void VF_fmodV( fVector Z, fVector X, fVector Y, ui size );
void VFx_fmodV( fVector Z, fVector X, fVector Y, ui size, float A, float B );
C++ VecObj#include <OptiVec.h>
void vector<T>::fmodC( const vector<T>& X, const T& C );
void vector<T>::fmodV( const vector<T>& X, const vector<T>& Y );
void vector<T>::x_fmodV( const vector<T>& X, const vector<T>& Y, const T& A, const T& B );
Pascal/DelphiDiese Funktionen sind nicht für Pascal/Delphi definiert. Man benutze VF_modC,   VF_modV etc.
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_fmodC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_fmodC( fVector d_Y, fVector d_X, ui size, float *d_C );
int cudaVF_fmodV( fVector d_Z, fVector d_X, fVector d_Y, ui size );
int cudaVFx_fmodV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float A, float B );
int cusdVFx_fmodV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_A, float *d_B );
void VFcu_fmodC( fVector h_Y, fVector h_X, ui size, float C );
void VFcu_fmodV( fVector h_Z, fVector h_X, fVector h_Y, ui size );
void VFxcu_fmodV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float A, float B );
BeschreibungDiese Funktionen sind aus Gründen der Konsistenz mit dem Funktionsnamen fmod des ANSI-Standards von C definiert. Sie sind als Makros implementiert, die VF_modC,   VF_modV,   VFx_modV etc. aufrufen. Siehe dort.

 

VF_fprintVD_fprintVE_fprint
VCF_fprintVCD_fprintVCE_fprint
VPF_fprintVPD_fprintVPE_fprint
VI_fprintVBI_fprintVSI_fprintVLI_fprintVQI_fprint 
VU_fprintVUB_fprintVUS_fprintVUL_fprintVUQ_fprintVUI_fprint
FunktionAusgabe eines Vektors in einen Stream
Syntax C/C++#include <VFstd.h>
void VF_fprint( FILE *stream, fVector X, ui size, unsigned nperline, unsigned linewidth );
C++ VecObj#include <OptiVec.h>
void vector<T>::fprint( FILE *stream, unsigned nperline, unsigned linewidth );
Pascal/Delphiuses VFstd;
procedure VF_fprint( var Stream:Text; X:fVector; size:UIntSize; nperline, linewidth:UInt );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_fprint( FILE *stream, fVector d_X, ui size, unsigned nperline, unsigned linewidth );
int cudaVF_fprint_buf( FILE *stream, fVector d_X, ui size, unsigned nperline, unsigned linewidth, fVector h_Wk );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_fprint( var Stream:Text; d_X:fVector; size:UIntSize; nperline, linewidth:UInt ): IntBool;
function cudaVF_fprint_buf( var Stream:Text; d_X:fVector; size:UIntSize; nperline, linewidth:UInt; h_Wk:fVector ): IntBool;
Beschreibungsize Elemente von X werden im ASCII-Format in stream geschrieben, wobei nperline Einträge in jede Zeile der Breite linewidth aufgenommen werden.

Die Ausgabe beginnt immer mit einer neuen Zeile. Man beachte, dass hierdurch Leerzeilen entstehen können. Insbesondere bleibt die erste Zeile einer Datei für eine eventuelle Überschrift reserviert.

Zu Beginn jeder Zeile steht der Index des ersten in diese Zeile geschriebenen Elementes. Danach folgen ein Doppelpunkt und die verlangten nperline Elemente des Vectors X.
Cartesisch-komplexe Zahlen werden in geschweifte Klammern gefaßt, wobei der Imaginärteil durch ein Komma vom Realteil getrennt wird: {Re, Im}. Polar-komplexe Zahlen werden ebenfalls in geschweifte Klammern gefaßt und der Mag- vom Arg-Teil durch ein at-Zeichen getrennt: {Mag @ Arg}.

Anders als bei VF_write und VF_nwrite gibt es bei dieser Familie von Funktion keine Möglichkeit, das Ausgabeformat selbst zu definieren. Die Anzahl pro Element ausgegebener Stellen richtet sich vielmehr nach dem zur Verfügung stehenden Platz, also nach den Parametern linewidth und nperline.
 

nur CUDA-Versionen:cudaV?_fprint_buf übernimmt einen Host-Vektor h_Wk als zusätzliches Argument. Dieser dient als Pufferspeicher und muss (mindestens) dieselbe Größe haben wie X. Hierdurch wird die interne Bereitstellung von Pufferspeicher bei cudaV?_fprint eingespart, so dass cudaV?_fprint_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_fprint, VCE_fprint und VPE_fprint bei GCC nur mit double-Genauigkeit und innerhalb des für doubles möglichen Größenbereiches arbeiten (also Eingabewerte ggf. auf diesen abgeschnitten werden).
FehlerbehandlungWenn linewidth nicht für die geforderten nperline Einträge pro Zeile ausreicht, wird eine Fehlermeldung "Cannot use requested format (too many entries per line)." ausgegeben und die Ausgabe mit der maximal möglichen Anzahl von Einträgen pro Zeile durchgeführt.
Rückgabewertkeiner
QuerverweisVF_cprint,   VF_print,   VF_write,   VF_store,   fprintf

 

V_free
FunktionDen von einem Vektor belegten Speicherplatz freigeben
Syntax C/C++#include <VecLib.h>
void V_free( void *X );
Pascal/Delphiuses VecLib;
procedure V_free( Ptr:Pointer );
CUDA-Funktion C/C++#include <cudaVecLib.h>
int cudaV_free( void *d_X );
CUDA-Funktion Pascal/Delphiuses VecLib;
function cudaV_free( d_X:Pointer ): IntBool;
BeschreibungDer Vektor X wird freigegeben (de-alloziert). V_free sollte nur für Vektoren benutzt werden, die mit Hilfe einer Funktion der VF_vector- oder VF_vector0- Familie generiert wurden. Um mehrere Vektoren in einem Aufruf freizugeben, verwende man V_nfree (nur C/C++). Sämtliche existierende Vektoren und Matrizen lassen sich gleichzeitig durch V_freeAll freigeben.
FehlerbehandlungBei dem Versuch, einen Vektor freizugeben, dem kein Speicher (mehr) zugewiesen ist, wird eine Warnung "Cannot free non-existent vector" ausgegeben. In diesem Fall erfolgt keine Freigabe, und das Programm wird fortgesetzt.
Rückgabewertkeiner
QuerverweisV_nfree,   V_freeAll,   cudaV_pinnedFree,   VF_vector,   VF_vector0

 

V_freeAll
FunktionSämtliche Vektoren (und Matrizen) freigeben
Syntax C/C++#include <VecLib.h>
void V_freeAll( void );
Pascal/Delphiuses VecLib;
procedure V_freeAll;
CUDA-Funktion C/C++#include <cudaVecLib.h>
int cudaV_freeAll( void );
CUDA-Funktion Pascal/Delphiuses VecLib;
function cudaV_freeAll: IntBool;
BeschreibungV_freeAll gibt den Speicherplatz sämtlicher Vektoren und Matrizen frei, die mit Hilfe einer Funktion der VF_vector-,   VF_vector0- oder MF_matrix-Familien generiert wurden.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisV_free,   V_nfree,   V_pinnedFreeAll,   VF_vector,   VF_vector0

 

VF_frexpVD_frexpVE_frexp
FunktionAufspaltung in Mantisse und Exponent
Syntax C/C++#include <VFmath.h>
int VF_frexp( fVector Mant, iVector Exp, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::frexp( vector<int> Exp, const vector<T>& X );
Pascal/DelphiDiese Funktionen sind für Pascal/Delphi nicht definiert.
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_frexp( fVector d_Mant, iVector d_Exp, fVector d_X, ui size );
int VFcu_frexp( fVector h_Mant, iVector h_Exp, fVector h_X, ui size );
BeschreibungDiese Funktion ist aus Gründen der Konsistenz mit dem Funktionsnamen frexp von ANSI−C definiert. Sie ist als Makro implementiert, das VF_mantexp aufruft. Siehe dort.

 

VI_fsumVBI_fsumVSI_fsumVLI_fsumVQI_fsum 
VU_fsumVUB_fsumVUS_fsumVUL_fsumVUQ_fsumVUI_fsum
FunktionSumme aller Elemente eines Ganzzahl-Vektors als Fließkomma-Zahl
Syntax C/C++#include <VIstd.h>
double VI_fsum( iVector X, ui size );

    (analog VBI_,   VSI_,   VLI_,   VU_,   VUB_,   VUS_,   VUL_,   VUI_)
extended VQI_fsum( qiVector X, ui size );
C++ VecObj#include <OptiVec.h>
double vector<int>::fsum();
extended vector<quad>::fsum();
Pascal/Delphiuses VIstd;
function VI_fsum( X:iVector; size:UIntSize ); Double;

    (analog VBI_,   VSI_,   VLI_,   VU_,   VUB_,   VUS_,   VUL_)
function VQI_fsum( X:qiVector; size:UIntSize ); Extended;
CUDA-Funktion C/C++#include <cudaVIstd.h>
int cudaVI_fsum( double *h_RetVal, iVector d_X, ui size );
int cusdVI_fsum( double *d_RetVal, iVector d_X, ui size );
double VIcu_fsum( iVector h_X, ui size );
int cudaVQI_fsum( double *h_RetVal, qiVector d_X, ui size );
int cusdVQI_fsum( double *d_RetVal, qiVector d_X, ui size );
double VQIcu_fsum( qiVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VIstd;
function cudaVI_fsum( var h_RetVal:Double; d_X:iVector; size:UIntSize ): IntBool;
function cusdVI_fsum( d_RetVal:PDouble; d_X:iVector; size:UIntSize ): IntBool;
function VIcu_fsum( h_X:iVector; size:UIntSize ): Double;
function cudaVQI_fsum( var h_RetVal:Double; d_X:qiVector; size:UIntSize ): IntBool;
function cusdVQI_fsum( d_RetVal:PDouble; d_X:qiVector; size:UIntSize ): IntBool;
function VQIcu_fsum( h_X:qiVector; size:UIntSize ): Double;
BeschreibungAlle Elemente von X werden aufsummiert. Um Überlauf zu vermeiden, wird dabei die Summe als Fließkomma-Zahl akkumuliert, und zwar in den 8-, 16- und 32-bit-Varianten als double und in der 64-bit-Variante VQI_fsum als extended.
Fehlerbehandlungkeine
Rückgabewertdie Summe als Fließkommazahl
QuerverweisVF_sum,   VF_mean

 

V_FtoDV_FtoEV_CFtoCDV_CFtoCE
V_DtoFV_DtoEV_CDtoCFV_CDtoCE
V_EtoFV_EtoDV_CEtoCFV_CEtoCD
FunktionDatentyp-Umwandlungen
Syntax C/C++#include <VDstd.h>
    (stets die zum Ziel-Datentyp gehörige <V..std.h>-Datei einschließen!)
void V_FtoD( dVector Y, fVector X, ui size );
    (analog alle übrigen Funktionen dieser Familie)
C++ VecObj#include <OptiVec.h>
void vector<double>::FtoD( const vector<float>& Y );
Pascal/Delphiuses VDstd;
    (stets die zum Ziel-Datentyp gehörige unit einschließen!)
procedure V_FtoD( Y:dVector; X:fVector; size:UIntSize );
    (analog alle übrigen Funktionen dieser Familie)
CUDA-Funktion C/C++#include <cudaVDstd.h>
int cudaV_FtoD( dVector d_Y, fVector d_X, ui size );
void Vcu_FtoD( dVector h_Y, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VDstd;
function cudaV_FtoD( d_Y:dVector; d_X:fVector; size:UIntSize ): IntBool;
procedure Vcu_FtoD( h_Y:dVector; h_X:fVector; size:UIntSize );
BeschreibungJedes Element von X wird aus dem für X spezifizierten Datentyp in den für Y gültigen umgewandelt und in Y gespeichert.
FehlerbehandlungOVERFLOW-Fehler bei den "Abwärts-Umwandlungen" (z.B. V_EtoF) werden stillschweigend behoben, indem der größte noch mögliche Wert in Y gespeichert wird. _matherr wird nicht aufgerufen.
Rückgabewertkeiner
QuerverweisVF_limit,   V_ItoF,   V_roundtoI,   V_roundtoLI

 

VF_GaussVD_GaussVE_Gauss
FunktionGauss'sche Normalverteilungs-Funktion
Syntax C/C++#include <VFmath.h>
int VF_Gauss( fVector Y, fVector X, ui size, float Wid, float Cent, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::Gauss( const vector<T>& X, T Wid, const T& Cent, const T& C );
Pascal/Delphiuses VFmath;
function VF_Gauss( Y, X:fVector; size:UIntSize; Wid, Cent, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVDstd.h>
int cudaVF_Gauss( fVector d_Y, fVector d_X, ui size, float Wid, float Cent, float C );
int cusdVF_Gauss( fVector d_Y, fVector d_X, ui size, float *d_Wid, float *d_Cent, float *d_C );
int VFcu_Gauss( fVector h_Y, fVector h_X, ui size, float Wid, float Cent, float C );
CUDA-Funktion Pascal/Delphiuses VDstd;
function cudaVF_Gauss( d_Y, d_X:fVector; size:UIntSize; Wid, Cent, C:Single ): IntBool;
function cusdVF_Gauss( d_Y, d_X:fVector; size:UIntSize; d_Wid, d_Cent, d_C:PSingle ): IntBool;
function VFcu_Gauss( h_Y, h_X:fVector; size:UIntSize; Wid, Cent, C:Single ): IntBool;
BeschreibungYi = C / (Wid * sqrt(2*p)) * exp( −0.5*((Xi−Cent) / Wid)2 )
Wid = Breite der Verteilung
Cent = Zentrum der Verteilung
C ist ein Skalierungsfaktor. Für C = 1 ist die Verteilung normiert. Für eine Breite von 0 geht die Normalverteilung in eine Delta-Verteilung über mit Y = C * INF für X = Cent und Y = 0 für alle übrigen Werte von X. Da ein Wert von Unendlich aber nicht dargestellt werden kann, führt die Existenz von Punkten X = Cent zu SING-Fehlern, wenn Wid = 0.
FehlerbehandlungSING-Fehler können nur bei Wid=0 auftreten und führen zu einem Ergebnis von ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_expmx2,   VF_erf,   VF_sech2,   VF_Lorentz

 

V_getCoordSystem
FunktionSpeichern der Positions- und Skalierungs-Einstellungen des aktuell für VectorLib-Plotoperationen verwendeten Koordinatensystems
Syntax C/C++#include <Vgraph.h>
void V_getCoordSystem( VCOORDSYSTEM *csys );
Pascal/Delphiuses Vgraph;
procedure V_getCoordSystem( var csys: VCOORDSYSTEM );
BeschreibungUm zwischen mehreren gleichzeitig in einem Fenster angeslegten 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 oder record VCOORDSYSTEM (definiert in <Vgraph.h> (C/C++) oder der unit Vgraph (Pascal/Delphi)).
Beispiel C/C++VCOORDSYSTEM csys1;
   ....
  /* ersten Plot erzeugen: */
V_setPlotRegion( 0, 0, 339, 200 );
VF_xyAutoPlot( X1, Y1, size1, PS_SOLID, LightGreen );
V_getCoordSystem( &csys1 ); /* für später speichern */
   /* zweiten Plot erzeugen: */
V_setPlotRegion( 340, 0, 679, 200 );
VF_xyAutoPlot( X2, Y2, size2, PS_SOLID, LightRed );
   /* zurück zum ersten Plot: */
VF_setCoordSystem( &csys1 );
   /* dem ersten Plot noch einen DataPlot hinzufügen: */
VF_xyDataPlot( X1, Z1, size1, PS_SOLID, LightBlue );
Beispiel Pascal/Delphivar cxyx1: VCOORDSYSTEM;
begin
   ....
     (* ersten Plot erzeugen: *)
   V_setPlotRegion( 0, 0, 339, 200 );
   VF_xyAutoPlot( X1, Y1, size1, PS_SOLID, LightGreen );
   V_getCoordSystem( csys1 ); (* für später speichern *)
      (* zweiten Plot erzeugen: *)
   V_setPlotRegion( 340, 0, 679, 200 );
   VF_xyAutoPlot( X2, Y2, size2, PS_SOLID, LightRed );
      (* zurück zum ersten Plot: *)
   VF_setCoordSystem( csys1 );
      (* dem ersten Plot noch einen DataPlot hinzufügen: *)
   VF_xyDataPlot( X1, Z1, size1, PS_SOLID, LightBlue );
end;
Rückgabewertkeiner
QuerverweisV_setCoordSystem,   V_setPlotRegion,   V_continuePlot

 

V_getCudaWorkspace
FunktionDerzeit genutzten cudaOptiVec-Workspace erfragen
Syntax C/C++#include <cudaVecLib.h>
V_CUDAWORKSPACE V_getCudaWorkspace( void );
Delphiuses VecLib;
function V_getCudaWorkspace: V_CUDAWORKSPACE;
BeschreibungDer derzeit genutzte cudaOptiVec-Workspace wird zurückgegeben.
RückgabewertDerzeit verwendeter Workspace vom Typ V_CUDAWORKSPACE
QuerverweisCudaOptiVecD.htm, Kap. 5. Streams und Workspaces

 

V_getDefaultCudaWorkspace
FunktionAbfrage des standardmäßig verwendeten cudaOptiVec-Workspaces des aktuellen Host Threads
Syntax C/C++#include <cudaVecLib.h>
V_CUDAWORKSPACE V_getDefaultCudaWorkspace( void );
Delphiuses VecLib;
function V_getDefaultCudaWorkspace: V_CUDAWORKSPACE;
BeschreibungDer standardmäßig vorhandene cudaOptiVec-Workspace wird zurückgegeben. Wie in CudaOptiVecD.htm, Kap. 5 beschrieben, erzeugt cudaOptiVec-Initialisierung einen standardmäßen Workspace für jeden Host-Thread. V_getDefaultCudaWorkspace kann aufgerufen werden, um diesen abzufragen.
RückgabewertDer standardmäßig vorhandene Workspace vom Typ V_CUDAWORKSPACE
QuerverweisCudaOptiVecD.htm, Kap. 5. Streams und Workspaces

 

VF_getElementVD_getElementVE_getElement
VCF_getElementVCD_getElementVCE_getElement
VPF_getElementVPD_getElementVPE_getElement
VI_getElementVBI_getElementVSI_getElementVLI_getElementVQI_getElement 
VU_getElementVUB_getElementVUS_getElementVUL_getElementVUQ_getElementVUI_getElement
FunktionWert eines bestimmten Vektorelementes
Syntax C/C++#include <VFstd.h>
void VF_getElement( float *Y, fVector X, ui pos );
C++ VecObj#include <OptiVec.h>
void vector<T>::getElement( T *Y, ui pos );
Pascal/Delphiuses VFstd;
procedure VF_getElement( Y:PSingle; X:fVector; pos:UIntSize );
CUDA-Funktion C/C++#include <cudaVDstd.h>
void cudaVF_getElement( float *y, fVector d_X, ui pos );
void cusdVF_getElement( float *d_y, fVector d_X, ui pos );
CUDA-Funktion Pascal/Delphiuses VDstd;
procedure cudaVF_getElement( var y:Single; d_X:fVector; pos:UIntSize );
procedure cusdVF_getElement( d_y:PSingle; d_X:fVector; pos:UIntSize );
BeschreibungDiese Funktion kopiert Xpos in die durch ihre Adresse angegebene Variable Y.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_element,   VF_setElement,   VF_Pelement,   VF_accElement,   VF_decElement

 

V_getFPAccuracy
FunktionTest, auf welche Genauigkeit die FPU (bzw. der mathematische Coprozessor) aktuell eingestellt ist
Syntax C/C++#include <VecLib.h>
unsigned V_getFPAccuracy( void );
Pascal/Delphiuses VecLib;
function V_getFPAccuracy: UInt;
BeschreibungDiese Funktion fragt das Control-Word des Coprozessors ab. Ist es auf float / Single-Genauigkeit eingestellt, so wird 1 zurückgegeben, bei der Einstellung double ist der Rückgabewert 2, und extended-Genauigkeit liefert den Rückgabewert 3. Um die Coprozessor-Genauigkeit umzuschalten, verwende man entweder die von den verschiedenen Compilern hierfür zur Verfügung gestellten (nicht-standardisierten) Funktionen oder die OptiVec-Funktion V_setFPAccuracy.
Rückgabewert1, 2 oder 3
QuerverweisV_setFPAccuracy

 

V_getLibVersion
FunktionVersion der verwendeten OptiVec-Bibliotheken
Syntax C/C++#include <VecLib.h>
const char * V_getLibVersion( void );
Delphiuses VecLib;
function V_getLibVersion: PChar;
BeschreibungDie Version der für ein Programm verwendeten OptiVec-Bibliotheken (Basis-Bibliothek, prozessor-spezifische Bibliothek, ggf. cudaOptiVec-DLL) wird als String (genauer: als char* bzw. PChar) zurückgegeben.
RückgabewertBeschreibung der verwendeten OptiVec-Bibliotheken
Beispiel
  • C/C++:
    printf( "\nVerwendete OptiVec Libs: %s", V_getLibVersion() );
  • Pascal / Delphi:
    writeln( 'Verwendete OptiVec Libs: ', V_getLibVersion );

 

VF_getRspEditVD_getRspEditVE_getRspEdit
FunktionAuslesen der derzeit eingestellten Filter-Editierung bei VF_convolve und VF_deconvolve
Syntax C/C++#include <VFstd.h>
fComplex VF_getRspEdit( void );
C++ VecObj#include <OptiVec.h>
complex <T> vector<T>::getRspEdit();
Pascal/Delphiuses VFstd;
procedure VF_getRspEdit( var Trunc:fComplex );
CUDA-Funktion C/C++#include <cudaVFstd.h>
fComplex cudaVF_getRspEdit( void );
CUDA-Funktion Pascal/Delphiuses VDstd;
procedure cudaVF_getRspEdit( var Trunc:fComplex );
BeschreibungDie standardmäßig eingestellte oder durch VF_setRspEdit gesetzte Schwelle für die Behandlung von Rundungsfehlern in den Konvolutions- und Dekonvolutions-Funktionen wird zurückgegeben.
Fehlerbehandlungkeine
Rückgabewertderzeit eingestellter Schwellenwert.
Realteil: bezieht sich auf die Realteile des Filters;
Imaginärteil: bezieht sich auf die Imaginärteile des Filters
QuerverweisVF_setRspEdit,   VF_convolve,   VF_deconvolve

 

VF_HannVD_HannVE_Hann
Funktion"Hann"-Fenster für die Spektrenanalyse
Syntax C/C++#include <VFstd.h>
void VF_Hann( fVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::Hann();
Pascal/Delphiuses VFstd;
procedure VF_Hann( X:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_Hann( fVector d_X, ui size );
void VFcu_Hann( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_Hann( d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_Hann( h_X:fVector; size:UIntSize );
BeschreibungXi = 0.5 * (1 - cos( 2 p i / (size−1) ))
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_Welch,   VF_Parzen,   VF_spectrum

 

VF_hexprintVD_hexprintVE_hexprint
VCF_hexprintVCD_hexprintVCE_hexprint
VI_hexprintVBI_hexprintVSI_hexprintVLI_hexprintVQI_hexprint 
VU_hexprintVUB_hexprintVUS_hexprintVUL_hexprintVUQ_hexprintVUI_hexprint
FunktionVektor im Hexadezimal-Format nach stdout ausgeben (nur für Konsolen-Anwendungen)
Syntax C/C++#include <VFstd.h>
void VF_hexprint( fVector X, ui size, unsigned nperline );
C++ VecObj#include <OptiVec.h>
void vector<T>::hexprint( unsigned nperline );
Pascal/Delphiuses VFstd;
procedure VF_hexprint( X:fVector; size:UIntSize; nperline:UInt );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_hexprint( fVector d_X, ui size, unsigned nperline );
int cudaVF_hexprint_buf( fVector d_X, ui size, unsigned nperline, fVector h_Wk );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_hexprint( d_X:fVector; size:UIntSize; nperline:UInt ): IntBool;
function cudaVF_hexprint_buf( d_X:fVector; size:UIntSize; nperline:UInt; h_Wk:fVector ): IntBool;
Beschreibungsize Elemente von X werden im Hexadezimal-Format nach stdout ausgegeben, nperline in jeder Zeile. Der einzige Unterschied zu den Funktionen der VF_print-Familie ist die Ausgabe im Hexadezimal-Format.
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_chexprint 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?_hexprint_buf übernimmt einen Host-Vektor h_Wk als zusätzliches Argument. Dieser dient als Pufferspeicher und muss (mindestens) dieselbe Größe haben wie X. Hierdurch wird die interne Bereitstellung von Pufferspeicher bei cudaV?_hexprint eingespart, so dass cudaV?_hexprint_buf etwas schneller ist.

Diese Funktionen-Familie kann nur im Zusammenhang mit Konsolenanwendungen gebraucht werden.

FehlerbehandlungWenn 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.
Rückgabewertkeiner
QuerverweisVF_chexprint,   VF_fhexprint,   VF_print,   VF_write,   VF_store,   printf (nur C/C++)

 

VF_hypCVD_hypCVE_hypC
FunktionQuotient von Xi und der Summe von Xi und einer Konstanten
Syntax C/C++#include <VFmath.h>
void VF_hypC( fVector Y, fVector X, ui size, float C );
C++ VecObj#include <OptiVec.h>
void vector<T>::hypC( const vector<T>& X, const T& C );
Pascal/Delphiuses VFmath;
procedure VF_hypC( Y, X:fVector; size:UIntSize; C:Single );
CUDA-Funktion C/C++#include <cudaVFmath.h>
#include <cudaVDmath.h>
int cudaVF_hypC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_hypC( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_hypC( fVector d_Y, fVector d_X, ui size, float C );
CUDA-Funktion Pascal/Delphiuses VFmath, VDmath;
function cudaVF_hypC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_hypC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VF_hypC( Y, X:fVector; size:UIntSize; C:Single );
BeschreibungYi = hyp( Xi, C ) = Xi / (Xi + C)
Wegen der Ähnlichkeit dieser Formel mit dem Ausdruck zur Konstruktion einer Hyperbel bezeichnen wir diese Funktion als "hyp".
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_hypV,   VF_redC,   VF_addC,   VF_subC,   VF_divC,   VF_visC

 

VF_hypVVD_hypVVE_hypV
VFx_hypVVDx_hypVVEx_hypV
FunktionQuotient von Xi und der Summe Xi + Yi
Syntax C/C++#include <VFmath.h>
void VF_hypV( fVector Z, fVector X, fVector Y, ui size );
void VFx_hypV( fVector Z, fVector X, fVector Y, ui size, float A, float B );
C++ VecObj#include <OptiVec.h>
void vector<T>::hypV( const vector<T>& X, const vector<T>& Y );
void vector<T>::x_hypV( const vector<T>& X, const vector<T>& Y, const T& A, const T& B );
Pascal/Delphiuses VFmath;
procedure VF_hypV( Z, X, Y:fVector; size:UIntSize );
procedure VFx_hypV( Z, X, Y:fVector; size:UIntSize; A, B:Single );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_hypV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
int cudaVFx_hypV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float A, float B );
int cusdVFx_hypV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_A, float *d_B );
void VFcu_hypV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
void VFxcu_hypV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float A, float B );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_hypV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cudaVFx_hypV( d_Z, d_X, d_Y:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_hypV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
procedure VFcu_hypV( h_Z, h_X, h_Y:fVector; size:UIntSize );
procedure VFxcu_hypV( h_Z, h_X, h_Y:fVector; size:UIntSize; A, B:Single );
Beschreibungeinfache Versionen: Zi = hyp( Xi, Yi ) = Xi / (Xi + Yi)
erweiterte Versionen: Zi = hyp( A*Xi+B), Yi )
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_hypC,   VF_redV,   VF_addV,   VF_subV,   VF_divV,   VF_visV

 

VF_hypotCVD_hypotCVE_hypotC
FunktionHypotenuse (Pythagoras-Funktion)
Syntax C/C++#include <VFmath.h>
int VF_hypotC( fVector Y, fVector X, ui size, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::hypotC( const vector<T>& X, const T& C );
Pascal/Delphiuses VFmath;
function VF_hypotC( Y, X:fVector; size:UIntSize; C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_hypotC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_hypotC( fVector d_Y, fVector d_X, ui size, float *d_C );
int VFcu_hypotC( fVector d_Y, fVector d_X, ui size, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_hypotC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_hypotC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function VF_hypotC( Y, X:fVector; size:UIntSize; C:Single ): IntBool;
BeschreibungYi = sqrt( Xi2 + C2 )
Diese Funktion ist eine Variante des Pythagoras-Theorems zur Berechnung der Hypotenuse eines rechtwinkligen Dreiecks.
FehlerbehandlungOVERFLOW-Fehler führen zum Ergebnis-Vorschlag HUGE_VAL. Im Unterschied zu der Behandlung der ANSI−C-Funktion hypot bei vielen Compilern wird ein Überlauf des Zwischenergebnisses Xi2 + C2 durch geeignete Maßnahmen ausgeschlossen.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_hypotV,   VF_redC,   VF_visC,   VCF_abs,   hypot

 

VF_hypotVVD_hypotVVE_hypotV
VFx_hypotVVDx_hypotVVEx_hypotV
FunktionHypotenuse (Pythagoras-Funktion)
Syntax C/C++#include <VFmath.h>
int VF_hypotV( fVector Z, fVector X, fVector Y, ui size );
int VFx_hypotV( fVector Z, fVector X, fVector Y, ui size, float A, float B );
C++ VecObj#include <OptiVec.h>
int vector<T>::hypotV( const vector<T>& X, const vector<T>& Y );
int vector<T>::x_hypotV( const vector<T>& X, const vector<T>& Y, const T& A, const T& B );
Pascal/Delphiuses VFmath;
function VF_hypotV( Z, X, Y:fVector; size:UIntSize ): IntBool;
function VFx_hypotV( Z, X, Y:fVector; size:UIntSize; A, B:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
#include <cudaVCFmath.h>
int cudaVF_hypotV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
int cudaVFx_hypotV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float A, float B );
int cusdVFx_hypotV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_A, float *d_B );
void VFcu_hypotV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
void VFxcu_hypotV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float A, float B );
CUDA-Funktion Pascal/Delphiuses VFmath, VCFmath;
function cudaVF_hypotV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cudaVFx_hypotV( d_Z, d_X, d_Y:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_hypotV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
procedure VFcu_hypotV( h_Z, h_X, h_Y:fVector; size:UIntSize );
procedure VFxcu_hypotV( h_Z, h_X, h_Y:fVector; size:UIntSize; A, B:Single );
Beschreibungeinfache Version: Yi = sqrt( Xi2 + Yi2 )
erweiterte Version: Yi = sqrt( (A*Xi+B)2 + Yi2 )
Diese Funktionen sind Varianten des Pythagoras-Theorems zur Berechnung der Hypotenuse eines rechtwinkligen Dreiecks.
FehlerbehandlungOVERFLOW-Fehler ergeben HUGE_VAL. Im Unterschied zu der Behandlung der ANSI−C-Funktion hypot bei vielen Compilern wird ein Überlauf des Zwischenergebnisses Xi2 + Yi2 durch geeignete Maßnahmen ausgeschlossen.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_redC,   VF_visC,   VCF_abs,   hypot

 

VCF_imagVCD_imagVCE_imag
VPF_imagVPD_imagVPE_imag
FunktionImaginärteil eines komplexen Vektors extrahieren
Syntax C/C++#include <VCFstd.h>
void VCF_imag( fVector Im, cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::imag( const vector<complex<T>>& X );
Pascal/Delphiuses VCFstd;
procedure VCF_imag( Im:fVector; X:cfVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVCF_imag( fVector d_Im, cfVector d_X, ui size );
void VCFcu_imag( fVector h_Im, cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVCF_imag( d_Im:fVector; d_X:cfVector; size:UIntSize ): IntBool;
procedure VCFcu_imag( h_Im:fVector; h_X:cfVector; size:UIntSize );
BeschreibungIdentisch mit den Familien VF_CtoIm und VF_PtoIm. Siehe dort.

 

VF_ImtoCVD_ImtoCVE_ImtoC
FunktionImaginärteil eines cartesisch-komplexen Vektors neu initialisieren
Syntax C/C++#include <VCFstd.h>
void VF_ImtoC( cfVector Y, fVector Im, ui size );
C++ VecObj#include <OptiVec.h>
void vector<complex<T>>::ImtoC( const vector<T>& Im );
Pascal/Delphiuses VCFstd;
procedure VF_ImtoC( X:cfVector; Im:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVF_ImtoC( cfVector d_Y, fVector d_Im, ui size );
void VFcu_ImtoC( cfVector h_Y, fVector h_Im, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVF_ImtoC( d_X:cfVector; d_Im:fVector; size:UIntSize ): IntBool;
procedure VFcu_ImtoC( h_X:cfVector; h_Im:fVector; size:UIntSize );
BeschreibungDer reelle Vektor Im wird in den Imaginärteil von Y kopiert. Der Realteil von Y ist hiervon nicht betroffen.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_CtoReIm,   VF_ReImtoC,   VF_RetoC,   VF_CtoIm,   VF_PolartoC

 

VF_indpickVD_indpickVE_indpick
VCF_indpickVCD_indpickVCE_indpick
VPF_indpickVPD_indpickVPE_indpick
VI_indpickVBI_indpickVSI_indpickVLI_indpickVQI_indpick 
VU_indpickVUB_indpickVUS_indpickVUL_indpickVUQ_indpickVUI_indpick
FunktionElemente aus einem Vektor ihren Indizes gemäß "herauspicken"
Syntax C/C++#include <VFstd.h>
void VF_indpick( fVector Y, uiVector Ind, ui size, fVector X );
C++ VecObj#include <OptiVec.h>
void vector<T>::indpick( const vector<ui>& Ind, const vector<T>& X );
Pascal/Delphiuses VFstd;
procedure VF_indpick( Y:fVector; Ind:uiVector; size:UIntSize; X:fVector );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_indpick( fVector d_Y, uiVector d_Ind, ui size, fVector d_X );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_indpick( d_Y:fVector; d_Ind:uVector; size:UIntSize; d_X:fVector ): IntBool;

   (es gibt keine Funktion V?cu_indpick - weder für C/C++ noch für Pascal/Delphi!)
BeschreibungYi = X[ Indi ],   i=0,..size−1
Der Vektor Y wird mit size Elementen gefüllt, die gemäß ihren in Ind spezifizierten Indizes aus X ausgelesen werden. Der Parameter size bezieht sich auf Y und Ind. Die Größe von X ist unwichtig, so lange nur die durch Ind spezifizierten Indizes die Größe nicht übersteigen.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_indput,   VF_subvector,   VF_sortind

 

VF_indputVD_indputVE_indput
VCF_indputVCD_indputVCE_indput
VPF_indputVPD_indputVPE_indput
VI_indputVBI_indputVSI_indputVLI_indputVQI_indput 
VU_indputVUB_indputVUS_indputVUL_indputVUQ_indputVUI_indput
FunktionElemente eines Vektor auf die durch ihre Indizes spezifizierten Plätze eines anderen Vektors verteilen
Syntax C/C++#include <VFstd.h>
void VF_indput( fVector Y, fVector X, uiVector Ind, ui sizex );
C++ VecObj#include <OptiVec.h>
void vector<T>::indput( const vector<T>& X, const vector<ui>& Ind );
Pascal/Delphiuses VFstd;
procedure VF_indput( Y, X:fVector; Ind:uiVector; sizex:UIntSize );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_indput( fVector d_Y, fVector d_X, uiVector d_Ind, ui sizex );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_indput( d_Y, d_X:fVector; d_Ind:uVector; sizex:UIntSize ): IntBool;

   (es gibt keine Funktion V?cu_indput - weder für C/C++ noch für Pascal/Delphi!)
BeschreibungY[ Indi ] = Xi,   i=0,..sizex−1
Die sizex Elemente von X werden kopiert in die durch Ind spezifizierten Elemente von Y. Der Parameter sizex bezieht sich auf X und Ind. Die Größe von Y ist unwichtig, solange nur die durch Ind spezifizierten Indizes sie nicht übersteigen.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_indpick,   VF_subvector,   VF_sortind

 

VU_indrampVUQ_indrampVUI_indramp
Funktion"Index-Rampe": Initialisierung jedes Vektor-Elements mit seinem Index
Syntax C/C++#include <VUIstd.h>
void VUI_indramp( uiVector X, ui size );

    (analog VU_)
C++ VecObj#include <OptiVec.h>
void vector<T>::indramp( void );
Pascal/Delphiuses VUIstd;
procedure VUI_indramp( X:uiVector; size:UIntSize );

    (similarly VU_)
CUDA-Funktion C/C++#include <cudaVUIstd.h>
int cudaVUI_indramp( uiVector d_X, ui size );
void VUIcu_indramp( uiVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VUIstd;
function cudaVUI_indramp( d_X:uiVector; size:UIntSize ): IntBool;
procedure VUIcu_indramp( h_X:uiVector; size:UIntSize );
BeschreibungXi = i
Jedes Element von X wird mit seinem Index initialisiert, so dass eine "Rampe" 0, 1, 2, 3, ... entsteht.
Für von 0 verschiedene Start-Werte, oder für andere Intervalle als 1, oder für andere Datentypen als ui / UIntSize nutze man VF_ramp.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_ramp,   VF_Parzen,   VF_Welch,   VF_equ1,   VF_random

 

V_initMT
FunktionInitialisierung der für Mehrkern-Prozessoren optimierten Bibliotheken
Syntax C/C++#include <VecLib.h>
int V_initMT( unsigned nProcCores );
Pascal/Delphiuses VecLib;
function V_initMT( nProcCores:UInt ): IntBool;
BeschreibungDiese Funktion initialisiert die für Mehrkern-Prozessoren optimierten Bibliotheken. Sie liest die Zahl der zur Verfügung stehenden Prozessor-Kerne als Argument und generiert die passende Anzahl von Arbeits-Threads, so dass folgende Aufrufe von OptiVec-Funktionen ihre Berechnungen über die vorhandenen Prozessoren verteilen können. Derzeit kann nProcCores Werte von 2 bis 128 annehmen. Sobald Intel, AMD oder andere Hersteller die Entwicklung von Systemen mit noch mehr Prozessor-Kernen ankündigen, werden auch künftige Versionen von OptiVec Vorkehrungen für so viele Prozessor-Kerne treffen, wie es dann geben mag.

V_initMT muss einmal (und genau einmal) aufgerufen werden, bevor irgendeine Vektor- oder Matrix-Funktion von OptiVec aus der Multi-Prozessor-Bibliothek ausgeführt werden kann. Andersherum schadet aber der Aufruf von V_initMT nicht, wenn Sie eine der (für single-thread optimierten) Allzweck-Bibliotheken verwenden. In diesen Bibliotheken ist V_initMT als leere Funktion enthalten, deren Aufruf nichts bewirkt. Auf diese Weise können Sie zu Test-Zwecken zwischen den verschiedenen Versionen der OptiVec-Bibliotheken hin- und herschalten, ohne sich um die Aktivierung und Deaktivierung von V_initMT kümmern zu müssen.

Auf Rechnern mit vielen Prozessor-Kernen (etwa ab 8 oder 16) ist es u.U. sinnvoll, die Zahl der von jeder einzelnen OptiVec-Funktion beanspruchbaren Threads zu begrenzen. Dies gilt vor allem, wenn eine Anwendung selbst mehrere Arbeits-Threads generiert und aus allen oder mehreren von ihnen OptiVec-Funktionen aufgerufen werden. Im Interesse einer optimalen Ausnutzung der Prozessor-Kapazitäten sollte durch Aufruf von V_limitThreadsPerFunc die Zahl der Threads festgelegt werden, die jeder Aufruf einer OptiVec-Funktion für sich beanspruchen darf. Es empfiehlt sich allerdings, relativ großzügig zu sein. Bei 16 Kernen und vier Anwendungs-Threads etwa sollte man den OptiVec-Funktionen nicht nur 16/4=4, sondern lieber 8 Threads erlauben. Das Betriebssystem wird sich dann um das optimale Scheduling aller Threads kümmern.

Falls Sie die Funktion V_setFPAccuracy verwenden, um die Fließkomma-Genauigkeit der FPU zu modifizieren, muss der Aufruf von V_initMT nach dem Aufruf von V_setFPAccuracy erfolgen. Der Grund hierfür ist, dass V_initMT die zusätzlichen Threads mit denjenigen FPU-Einstellungen erstellt, wie sie bei Aufruf dieser Funktion vorgefunden werden.

nProcCores muss nicht der tatsächlich vorhandenen Zahl der Prozessor-Kerne entsprechen. Zu Test-Zwecken können Sie jeden beliebigen zulässigen Wert eingeben. Optimale Ausführungsgeschwindigkeit wird natürlich nur bei der korrekten Zahl erreicht. Für Anwendungen, die auf Kunden-Systemen laufen, deren Konfiguration außerhalb Ihres Einflussbereiches liegt, sollte die tatsächlich vorhandene Zahl der Prozessor-Kerne durch eine Detektions-Routine ermittelt werden (siehe die Prozessor-Dokumentationen von Intel und AMD). Zur Not kann die automatische Detektion natürlich durch eine Benutzer-Eingabe ersetzt werden.
Obwohl nicht unbedingt erforderlich, empfiehlt es sich, am Programm-Ende die zusätzlichen Threads wieder zu schließen durch Aufruf von V_closeMT.
Die durch V_initMT gesetzte Anzahl der verwendeten Prozessor-Kerne wird in der öffentlichen Variable V_nProcCores abgelegt. Diese ist in C/C++ als (in C++ extern "C") unsigned definiert, in Delphi als UInt. Durch Überprüfung dieser Variablen lässt sich auch feststellen, ob V_initMT bereits aufgerufen wurde.

MT in DLL'sDie Verwendung der Multiprozessor-Bibliotheken in DLL's verlangt eigene Überlegungen:
  • DLL zur Weitergabe an andere:
    Jede einzelne zum Vertrieb bestimmte DLL, die mit der "M"-Bibliothek gebunden wird, muss einen Aufruf von V_initMT in ihrer Initialisierung enthalten.
  • Eine oder wenige DLL's werden von einem Hauptprogramm aus verwendet:
    Auch hier empfiehlt es sich, jede einzelne DLL durch Aufruf von V_initMT zu initialisieren. Dann hat jede DLL ihre eigenen Threads, und das Betriebssystem wird für geeignetes Scheduling sorgen.
  • Mehrere bis viele DLL's werden gleichzeitig verwendet:
    Wenn mehrere oder gar viele DLL's OptiVec-Routinen aufrufen und alle von ein- und demselbem Hauptprogramm aus verwaltet werden, muss man daran denken, die Zahl der gleichzeitig existierenden Threads nicht zu sehr ausufern zu lassen. Hier bieten sich zwei unterschiedliche Strategien an:
    Entweder die weniger zeitkritischen DLL's werden nicht mit der "M"-Bibliothek von OptiVec gebunden, sondern nur diejenigen, bei denen das Auto-Threading wirklich zu einem Performance-Gewinn führt. Dann muss auch nur in letzteren V_initMT aufgerufen werden.
    Oder man installiert ein Callback in jeder einzelnen DLL's, durch das der Thread-Handler des Haupt-Programms auch den OptiVec-Funktionen in den DLL's die Arbeits-Threads zuteilt. Dies ist die beste, aber auch aufwendigste Lösung. Hierzu muss man in jeder betroffenen DLL eine Funktion schreiben und exportieren:
    • C/C++:
      #include <VecLib.h>

      int V_DLLxxx_setThreadHandler( V_THREADHANDLERFUNC ThreadHandler )
      { return V_setThreadHandler( ThreadHandler ); }

      Dabei muss "DLLxxx" eine nur für jeweils eine einzige DLL vergebene Kennung sein.

      Vom Hauptprogramm aus werden dann nacheinander für alle DLL's die eben geschriebenen Funktionen aufgerufen:

      int main( ..... )
      {   ....
          V_initMT( nProcCores ); // Threads im Hauptprogramm initialisieren
          V_DLL001_setThreadHandler( V_threadHandler ); // Callback in DLL 1 installieren
          V_DLL002_setThreadHandler( V_threadHandler ); // Callback in DLL 2 installieren
          // usw. für alle teilnehmenden DLL's
          ....
      }

    • Pascal/Delphi:
      uses VecLib.h;

      function V_DLLxxx_setThreadHandler( ThreadHandler:V_THREADHANDLERFUNC ): IntBool;
      begin V_DLLxxx_setThreadHandler := V_setThreadHandler( ThreadHandler ); end;

      Dabei muss "DLLxxx" eine nur für jeweils eine einzige DLL vergebene Kennung sein.

      Vom Hauptprogramm aus werden dann nacheinander für alle DLL's die eben geschriebenen Funktionen aufgerufen:

      begin   ....
          V_initMT( nProcCores ); // Threads im Hauptprogramm initialisieren
          V_DLL001_setThreadHandler( V_threadHandler ); // Callback in DLL 1 installieren
          V_DLL002_setThreadHandler( V_threadHandler ); // Callback in DLL 2 installieren
          // usw. für alle teilnehmenden DLL's
          ....
      end.

RückgabewertFALSE (0), wenn die Threads fehlerfrei initialisiert werden konnten, andernfalls TRUE (≠ 0)
QuerverweisV_closeMT,  V_setThreadHandler,  V_limitThreadsPerFunc,  Kap. 1.1.2.

 

V_initPlot
FunktionInitialisierung der globalen Variablen für VectorLib-Plotfunktionen
Syntax C/C++#include <Vgraph.h>
    void V_initPlot( HWND vwindow, HDC vdc );
Delphiuses Vgraph;
procedure V_initPlot( VPaintBox: TPaintBox );
Beschreibungvwindow ist das Handle des Fensters, in das die Zeichenausgabe erfolgen soll und vdc das Handle des zugehörigen Zeichen-Kontexts. So lange wie das Fenster und der Zeichenkontext gültig bleiben, werden alle Auftragungen (wie z.B. VF_xyAutoPlot) in diesem Fenster und mit den in diesem Kontext spezifizierten Zeichensätzen durchgeführt. Wenn Sie sich einmal nicht sicher sind, ob vwindow und vdc noch gültig sind, rufen Sie V_initPlot einfach erneut auf.
C++ Builder mit OWL: Man wird die VectorLib-Zeichenfunktionen wohl vorrangig innerhalb der virtuellen Elementfunktion Paint anwenden. V_initPlot ist dann mit dem Handle des aktuellen Fensters (das als HWindow von OWL zur Verfügung gestellt wird) und mit dem an Paint als Parameter übergebenen Zeichenkontext aufzurufen (siehe Beispiel-Datei VDEMOW.CPP).

Delphi-Programme:
VPaintBox ist die Paintbox, in die Sie einen VectorLib-Plot auftragen möchten. Alle künftigen VectorLib-Plots werden in diese Paintbox geleitet, bis Sie V_initPlot mit einer neuen Paintbox als Argument erneut aufrufen.

V_initPlot reserviert die rechten etwa 2/3 des Bild- schirms für Plot-Operationen, wobei oben eine und unten zwei bis drei Zeilen freigelassen werden. Um diese Standardeinstellung zu ändern, rufe man V_setPlotRegion nach V_initPlot.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_xyAutoPlot,   V_findAxes,   V_drawAxes,   V_setPlotRegion,   V_initPrint

 

V_initPrint
FunktionInitialisierung der VectorLib-Plotfunktionen für Ausgabe auf einem Drucker
Syntax C/C++#include <Vgraph.h>
void V_initPrint( HDC printdc );
Pascal/Delphiuses Vgraph;
procedure V_initPrint( printdc: HDC );
BeschreibungDiese Funktion existiert nur für Windows. Durch sie wird den folgenden VectorLib-Plotfunktionen mitgeteilt, dass sie den durch printdc spezifizierten Druckerkontext zu verwenden haben. Standardmäßig wird eine ganze Druckseite für die Ausgabe reserviert. Dies läßt sich durch Aufruf von V_setPlotRegion ändern. Der Aufruf von V_setPlotRegion muss dabei nach dem Aufruf von V_initPrint erfolgen. Um wieder auf Bildschirmausgabe umzuschalten, rufe man V_initPlot.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisV_initPlot,   V_setPlotRegion,   VF_xyAutoPlot

 

VF_insertVD_insertVE_insert
VCF_insertVCD_insertVCE_insert
VPF_insertVPD_insertVPE_insert
VI_insertVBI_insertVSI_insertVLI_insertVQI_insert 
VU_insertVUB_insertVUS_insertVUL_insertVUQ_insertVUI_insert
FunktionEin Element in einen Vektor einfügen
Syntax C/C++#include <VFstd.h>
void VF_insert( fVector X, ui size, ui pos, float C );
C++ VecObj#include <OptiVec.h>
void vector<T>::insert( ui pos, const T& C );
Pascal/Delphiuses VFstd;
procedure VF_insert( X:fVector; size, pos:UIntSize; C:Single );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_insert( fVector d_X, ui size, ui pos, float C );
int cusdVF_insert( fVector d_X, ui size, ui pos, float *d_C );
void VFcu_insert( fVector h_X, ui size, ui pos, float C );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_insert( d_X:fVector; size, pos:UIntSize; C:Single ): IntBool;
function cusdVF_insert( d_X:fVector; size, pos:UIntSize; d_C:PSingle ): IntBool;
procedure VFcu_insert( h_X:fVector; size, pos:UIntSize; C:Single );

   (no VFcu_indput function available - neither for C/C++ nor for Pascal/Delphi!)
BeschreibungAn der Stelle pos wird ein Element mit dem Wert C in den Vektor X eingefügt. Dies ist eine der wenigen Funktionen, die den Eingangs-Vektor X selbst verändern, anstatt das Ergebnis in einem Ausgabe-Vektor Y abzulegen. Elemente vor pos werden nicht verändert; Elemente nach pos werden um eine Position nach hinten verschoben. Das letzte Element geht verloren. (Um es zu retten, muss X von vornherein um ein Dummy-Element größer sein, so dass es der Dummy ist, der verloren geht.)
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_delete,   VF_rotate

 

VF_integralCVD_integralCVE_integralC
FunktionIntegral über einer Abszisse mit konstantem Abtastintervall
Syntax C/C++#include <VFstd.h>
float VF_integralC( fVector X, ui size, float DeltaT );
C++ VecObj#include <OptiVec.h>
T vector<T>::integralC( T DeltaT );
Pascal/Delphiuses VFstd;
function VF_integralC( X:fVector; size:UIntSize; DeltaT:Single ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_integralC( float *h_RetVal, fVector X, ui size, float C );
int cusdVF_integralC( float *d_RetVal, fVector X, ui size, float *d_C );
float VFcu_integralC( fVector X, ui size, float C );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_integralC( var h_RetVal:Single; d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_integralC( d_RetVal:PSingle; d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function VFcu_integralC( h_X:fVector; size:UIntSize; C:Single ): Single;
BeschreibungDer Vektor X wird als Funktion der Variablen t angenommen. Die t-Werte selbst liegen dabei mit konstantem Abstand DeltaT voneinander vor. Für die Berechnung des bestimmten Integrals von t0 bis tsize−1 (d.h. der Fläche unter dem Vektor) muss daher nur DeltaT an die Funktion übergeben werden (und nicht die einzelnen t-Werte). Wenn nicht nur der Wert des Integrals benötigt wird, sondern eine Punkt-für- Punkt-Integration erwünscht ist, gebrauche man VF_runintegralC.
Fehlerbehandlungkeine
RückgabewertWert des Integrals
QuerverweisVF_integralV,   VF_runintegralC,   VF_derivC

 

VF_integralVVD_integralVVE_integralV
FunktionIntegral
Syntax C/C++#include <VFstd.h>
float VF_integralV( fVector X, fVector Y, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::integralV( const vector<T>& X );
Pascal/Delphiuses VFstd;
function VF_integralV( X, Y:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_integralV( float *h_RetVal, fVector X, fVector Y, ui size );
int cusdVF_integralV( float *d_RetVal, fVector X, fVector Y, ui size );
float VFcu_integralV( fVector h_X, fVector h_Y, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_integralV( var h_RetVal:Single; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cusdVF_integralV( d_RetVal:PSingle; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function VFcu_integralV( h_X, h_Y:fVector; size:UIntSize ): Single;
BeschreibungDas Integral von Y über X wird berechnet. Falls X aus Abtastwerten mit konstantem Abstand voneinander besteht, kann effizienter die Funktion VF_integralC eingesetzt werden. Ist nicht nur der Wert des Integrals von Interesse, sondern eine Punkt-für-Punkt-Integration durchzuführen, gebrauche man VF_runintegralV.
Fehlerbehandlungkeine
RückgabewertWert des Integrals
QuerverweisVF_integralC,   VF_runintegralV,   VF_derivV

 

VF_intfracVD_intfracVE_intfrac
FunktionAufspaltung in Ganzzahl- und Nachkomma-Anteil
Syntax C/C++#include <VFmath.h>
int VF_intfrac( fVector IntPart, fVector FracPart, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::intfrac( vector<T> FracPart, const vector<T>& X );
Pascal/Delphiuses VFmath;
function VF_intfrac( IntPart, FracPart, X:fVector; size:UIntSize ):IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_intfrac( fVector d_IntPart, fVector d_FracPart, fVector d_X, ui size );
int VFcu_intfrac( fVector h_IntPart, fVector h_FracPart, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_intfrac( d_IntPart, d_FracPart, d_X:fVector; size:UIntSize ): IntBool;
function VFcu_intfrac( h_IntPart, h_FracPart, h_X:fVector; size:UIntSize ): IntBool;
BeschreibungDer Ganzzahl-Anteil jedes Elements von X wird in IntPart gespeichert, der gebrochenzahlige Anteil in FracPart. Man beachte, dass IntPart ein Fließkomma-Vektor ist, obwohl er ganze Zahlen enthält. Der Grund hierfür ist, dass der ganzzahlige Anteil von Fließkomma-Zahlen weit größer sein kann als die für die verschiedenen Ganzzahl-Typen geltenden Grenzen.
Fehlerbehandlungkeine
Rückgabewertimmer FALSE(0)
QuerverweisVF_mantexp,   modf (nur C/C++)

 

VF_invVD_invVE_inv
VFx_invVDx_invVEx_inv
VFu_invVDu_invVEu_inv
VFux_invVDux_invVEux_inv
VCF_invVCD_invVCE_inv
VCFx_invVCDx_invVCEx_inv
VPF_invVPD_invVPE_inv
FunktionKehrwert

int VFu_inv( fVector Y, fVector X, ui size );
int VFux_inv( fVector Y, fVector X, ui size, float A, float B );
Syntax C/C++#include <VFmath.h>
int VF_inv( fVector Y, fVector X, ui size );
int VFx_inv( fVector Y, fVector X, ui size, float A, float B );
C++ VecObj#include <OptiVec.h>
int vector<T>::inv( const vector<T>& X );
int vector<T>::x_inv( const vector<T>& X, const T& A, const T& B );
int vector<T>::u_inv( const vector<T>& X );
int vector<T>::ux_inv( const vector<T>& X, const T& A, const T& B );
Pascal/Delphiuses VFmath;
function VF_inv( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_inv( Y, X:fVector; size:UIntSize; A, B:Single ): IntBool;
function VFu_inv( Y, X:fVector; size:UIntSize ): IntBool;
function VFux_inv( Y, X:fVector; size:UIntSize; A, B:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_inv( fVector d_Y, fVector d_X, ui size );
int cudaVFx_inv( fVector d_Y, fVector d_X, ui size, float A, float B );
int cusdVFx_inv( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B );
int VFcu_inv( fVector h_Y, fVector h_X, ui size );
int VFxcu_inv( fVector h_Y, fVector h_X, ui size, float A, float B );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_inv( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_inv( d_Y, d_X:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_inv( d_Y, d_X:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function VFcu_inv( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_inv( h_Y, h_X:fVector; size:UIntSize; A, B:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = 1.0 / Xi
erweiterte Versionen: Yi = 1.0 / (A*Xi+B)
FehlerbehandlungNormale Versionen (VF_, VFx_ etc.): SING- und OVERFLOW-Fehler führen zum Resultat ±HUGE_VAL.
Ungeschützte Versionen (VFu_, VFux_ etc.): keine Fehlerbehandlung
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_divrC,   VF_divrV

 

VF_ipowVD_ipowVE_ipow
VFx_ipowVDx_ipowVEx_ipow
VFu_ipowVDu_ipowVEu_ipow
VFux_ipowVDux_ipowVEux_ipow
VCF_ipowVCD_ipowVCE_ipow
VCFx_ipowVCDx_ipowVCEx_ipow
VCFu_ipowVCDu_ipowVCEu_ipow
VCFux_ipowVCDux_ipowVCEux_ipow
VPF_ipowVPD_ipowVPE_ipow
VPFu_ipowVPDu_ipowVPEu_ipow
Funktionganzzahlige Potenzen
Syntax C/C++#include <VFmath.h>
int VF_ipow( fVector Y, fVector X, ui size, int Expo );
int VFx_ipow( fVector Y, fVector X, ui size, int Expo, float A, float B, float C );
int VFu_ipow( fVector Y, fVector X, ui size, int Expo );
int VFux_ipow( fVector Y, fVector X, ui size, int Expo, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::ipow( const vector<T>& X );
int vector<T>::x_ipow( const vector<T>& X, const T& A, const T& B, const T& C );
int vector<T>::u_ipow( const vector<T>& X );
int vector<T>::ux_ipow( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphiuses VFmath;
function VF_ipow( Y, X:fVector; size:UIntSize; ipow:Integer ): IntBool;
function VFx_ipow( Y, X:fVector; size:UIntSize; ipow:Integer; A, B, C:Single ): IntBool;
function VFu_ipow( Y, X:fVector; size:UIntSize; ipow:Integer ): IntBool;
function VFux_ipow( Y, X:fVector; size:UIntSize; ipow:Integer; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_ipow( fVector d_Y, fVector d_X, ui size, int Expo );
int cudaVFx_ipow( fVector d_Y, fVector d_X, ui size, int Expo, float A, float B, float C );
int cusdVFx_ipow( fVector d_Y, fVector d_X, ui size, int Expo, float *_dA, float *d_B, float *d_C );
int cudaVFu_ipow( fVector d_Y, fVector d_X, ui size, int Expo );
int cudaVFux_ipow( fVector d_Y, fVector d_X, ui size, int Expo, float A, float B, float C );
int cusdVFux_ipow( fVector d_Y, fVector d_X, ui size, int Expo, float *_dA, float *d_B, float *d_C );
int VFcu_ipow( fVector h_Y, fVector h_X, ui size, int Expo );
int VFxcu_ipow( fVector h_Y, fVector h_X, ui size, int Expo, float A, float B, float C );
int VFucu_ipow( fVector h_Y, fVector h_X, ui size, int Expo );
int VFuxcu_ipow( fVector h_Y, fVector h_X, ui size, int Expo, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_ipow( d_Y, d_X:fVector; size:UIntSize; Expo:Integer ): IntBool;
function cudaVFx_ipow( d_Y, d_X:fVector; size:UIntSize; Expo:Integer; A, B, C:Single ): IntBool;
function cusdVFx_ipow( d_Y, d_X:fVector; size:UIntSize; Expo:Integer; d_A, d_B, d_C:PSingle ): IntBool;
function cudaVFu_ipow( d_Y, d_X:fVector; size:UIntSize; Expo:Integer ): IntBool;
function cudaVFux_ipow( d_Y, d_X:fVector; size:UIntSize; Expo:Integer; A, B, C:Single ): IntBool;
function cusdVFux_ipow( d_Y, d_X:fVector; size:UIntSize; Expo:Integer; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_ipow( h_Y, h_X:fVector; size:UIntSize; Expo:Integer ): IntBool;
function VFxcu_ipow( h_Y, h_X:fVector; size:UIntSize; Expo:Integer; A, B, C:Single ): IntBool;
function VFucu_ipow( h_Y, h_X:fVector; size:UIntSize; Expo:Integer ): IntBool;
function VFuxcu_ipow( h_Y, h_X:fVector; size:UIntSize; Expo:Integer; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = XiExpo
erweiterte Versionen: Yi = C * (A*Xi+B)Expo
Wenn Expo größer als eine gewisse Schwelle ist, leitet VF_ipow die Aufgabe intern zwecks sichererer und schnellerer Bearbeitung an VF_pow weiter.
Die "ungeschützten" Versionen (Präfix VFu_ und VFux_) fangen OVERFLOW-Fehler nicht ab und leiten auch für große Expo keine Aufrufe auf VF_pow um. Durch diese Vereinfachungen sind sie wesentlich schneller, aber auch etwas riskanter und daher nur mit Vorsicht anzuwenden.
FehlerbehandlungSING-Fehler entstehen als Kehrwert von 0. Das Resultat ist ±HUGE_VAL. Dasselbe gilt für OVERFLOW-Fehler.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_pow,   VF_poly,   VF_ratio,   VF_pow2,   VF_exp,  pow

 

VF_ipow10VD_ipow10VE_ipow10
Funktionganzzahlige Potenzen von 10
Syntax C/C++#include <VFmath.h>
int VF_ipow10( fVector Y, iVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::ipow10( const vector<T>& X );
Pascal/Delphiuses VFmath;
function VF_ipow10( Y:fVector; X:iVector; size:UIntSize ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_ipow10( fVector d_Y, iVector d_X, ui size );
int VFcu_ipow10( fVector h_Y, iVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_ipow10( d_Y:fVector; d_X:iVector; size:UIntSize ): IntBool;
function VFcu_ipow10( h_Y:fVector; h_X:iVector; size:UIntSize ): IntBool;
BeschreibungYi = 10Xi
Man beachte, dass es diese Funktion (und nicht VF_pow10) ist, welche die vektorisierte Form der in Borland C definierten Funktion pow10 darstellt.
FehlerbehandlungOVERFLOW-Fehler ergeben HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_pow10,   VF_scale10,   VF_log10,   VF_ipow,   VF_exp,   pow

 

VF_ipow2VD_ipow2VE_ipow2
Funktionganzzahlige Potenzen von 2
Syntax C/C++#include <VFmath.h>
int VF_ipow2( fVector Y, iVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::ipow2( const vector<T>& X );
Pascal/Delphiuses VFmath; function VF_ipow2( Y:fVector; X:iVector; size:UIntSize ):
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_ipow2( fVector d_Y, iVector d_X, ui size );
int VFcu_ipow2( fVector h_Y, iVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_ipow2( d_Y:fVector; d_X:iVector; size:UIntSize ): IntBool;
function VFcu_ipow2( h_Y:fVector; h_X:iVector; size:UIntSize ): IntBool;
BeschreibungYi = 2Xi
FehlerbehandlungOVERFLOW-Fehler ergeben HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_pow2,   VF_scale2,   VF_log2,   VF_pow,   VF_exp,   pow

 

VF_iselementCVD_iselementCVE_iselementC
VCF_iselementCVCD_iselementCVCE_iselementC
VPF_iselementCVPD_iselementCVPE_iselementC
VI_iselementCVBI_iselementCVSI_iselementCVLI_iselementCVQI_iselementC 
VU_iselementCVUB_iselementCVUS_iselementCVUL_iselementCVUQ_iselementCVUI_iselementC
FunktionTest, ob ein bestimmter Wert in einer Tabelle auftaucht
Syntax C/C++#include <VFstd.h>
int VF_iselementC( fVector Tab, ui size, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::iselementC( const T& C );
Pascal/Delphiuses VFstd;
function VF_iselementC( Tab:fVector; size:UIntSize; C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_iselementC( fVector d_Tab, ui size, float C );
int cusdVF_iselementC( fVector d_Tab, ui size, float *d_C );
int VFcu_iselementC( fVector h_Tab, ui size, float C );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_iselementC( d_Tab:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_iselementC( d_Tab:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function VFcu_iselementC( h_Tab:fVector; size:UIntSize; C:Single ): IntBool;
BeschreibungDie Tabelle Tab wird nach dem Wert C durchsucht. Wird dieser mindestens einmal gefunden, so gibt die Funktion TRUE (+1) zurück, andernfalls FALSE (0). Die Suche wird linear durchgeführt, d.h. die Tabelle braucht nicht geordnet zu sein. Im Unterschied zu den Vergleichs- und Zähl-Funktionen, VF_cmp_eqC bzw. VF_cnt_eqC, werden +0.0 und –0.0 hier als voneinander verschieden behandelt, da diese Funktion nach der exakten Bit-Repräsentation von C sucht.
Man beachte die Querverweise nach weiteren verwandten Funktionen!
Fehlerbehandlungkeine
RückgabewertTRUE (+1), wenn C ein Element von X ist, andernfalls FALSE (0).
QuerverweisVF_searchC,   VF_iselementV,   lfind,   lsearch (nur C/C++)

 

VF_iselementVVD_iselementVVE_iselementV
VCF_iselementVVCD_iselementVVCE_iselementV
VPF_iselementVVPD_iselementVVPE_iselementV
VI_iselementVVBI_iselementVVSI_iselementVVLI_iselementVVQI_iselementV 
VU_iselementVVUB_iselementVVUS_iselementVVUL_iselementVVUQ_iselementVVUI_iselementV
FunktionTest, ob bestimmte Werte in einer Tabelle vorkommen
Syntax C/C++#include <VFstd.h>
ui VF_iselementV( fVector Y, fVector X, ui sizex, fVector Tab, ui sizetab );
C++ VecObj#include <OptiVec.h>
ui vector<T>::iselementV( const vector<T>& X, const vector<T>& Tab );
Pascal/Delphiuses VFstd;
function VF_iselementV( Y, X:fVector; sizex:UIntSize; Tab:fVector; sizetab:UIntSize ):UIntSize;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_iselementV( ui *h_nFound, fVector d_Y, fVector d_X, ui sizex, fVector d_Tab, ui sizetab );
ui VFcu_iselementV( fVector h_Y, fVector h_X, ui sizex, fVector h_Tab, ui sizetab );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_iselementV( var h_nFound:UIntSize; d_Y, d_X:fVector; sizex:UIntSize; d_Tab:fVector; sizetab:UIntSize ): IntBool;
function VFcu_iselementV( h_Y, h_X:fVector; sizex:UIntSize; h_Tab:fVector; sizetab:UIntSize ): UIntSize;
BeschreibungDie Tabelle Tab wird nach jedem einzelnen Element von X durchsucht. Wird es gefunden, erhält das entsprechende Element von Y den Eintrag TRUE (+1.0, in den komplexen Versionen: {1, 0} bzw. {1 @ 0}), andernfalls FALSE (0). Sowohl X als auch Tab werden als ungeordnet angenommen, und die Suche erfolgt linear. Im Unterschied zu den Vergleichs- und Zähl-Funktionen, VF_cmp_eqV bzw. VF_cnt_eqV, werden +0.0 und –0.0 hier als voneinander verschieden behandelt, da diese Funktion nach der exakten Bit-Repräsentation von Tab[i] sucht.
Eine verwandte Funktion, die für jedes X-Element den nächsten (aber nicht notwendigerweise exakt übereinstimmenden) Eintrag in einer geordneten Tabelle ermittelt, ist VF_searchV.
Fehlerbehandlungkeine
RückgabewertAnzahl der X-Elemente, für die ein identischer Eintrag in Tab ermittelt werden konnte
QuerverweisVF_searchV,   VF_iselementC

 

VF_ismonotonVD_ismonotonVE_ismonoton
FunktionTest, ob ein Vektor monoton steigend oder fallend geordnet ist
Syntax C/C++#include <VFstd.h>
int VF_ismonoton( fVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::ismonoton( const vector<T>& X );
Pascal/Delphiuses VFstd;
function VF_ismonoton( X:fVector; size:UIntSize ): Integer;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_ismonoton( int *h_isSorted, fVector d_X, ui size );
int VFcu_ismonoton( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_ismonoton( var h_isSorted:Integer; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_ismonoton( h_X:fVector; size:UIntSize ): Integer;
BeschreibungDer Vektor X wird untersucht. Befinden sich seine Elemente in strikt fallender Ordnung, wird −1 zurückgegeben; sind sie entweder konstant oder in strikt aufsteigender Ordnung, ist der Rückgabewert +1. Ansonsten wird 0 zurückgegeben. Wenn X Passagen mit konstant bleibenden Werten enthält, wird X nur dann als monoton angesehen, wenn eventuelle ansteigende Passagen auf diese konstante Passage folgen, nicht jedoch im umgekehrten Fall. Die Folge 0, 0, 1, 2, 3 ergibt demnach den Rückgabewert +1 (monoton steigend), die Folge 1, 2, 3, 4, 4, 4 jedoch den Rückgabewert 0. Auch die zunächst konstante, dann fallende Reihe 0, 0, 0, −1, -2, -3 wird nicht als monoton angesehen.
Fehlerbehandlungkeine
Rückgabewert+1 für monotonen Anstieg, −1 für monotonen Abfall, sonst 0
QuerverweisVF_sort

 

V_ItoFV_ItoDV_ItoE
V_BItoFV_BItoDV_BItoE
V_SItoFV_SItoDV_SItoE
V_LItoFV_LItoDV_LItoE
V_QItoFV_QItoDV_QItoE
V_UtoFV_UtoDV_UtoE
V_UBtoFV_UBtoDV_UBtoE
V_UStoFV_UStoDV_UStoE
V_ULtoFV_ULtoDV_ULtoE
V_UQtoFV_UQtoDV_UQtoE
V_UItoFV_UItoDV_UItoE
FunktionUmwandlung von Ganzzahl- in Fließkomma-Typen
Syntax C/C++#include <VFstd.h>
    (stest die zum Ziel-Datetyp gehörige include-Datei einschließen!)
void V_ItoF( fVector Y, iVector X, ui size );
    (analog alle übrigen Funktionen dieser Familie)
C++ VecObj#include <OptiVec.h>
void vector<float>::ItoF( const vector<int>& Y );
Pascal/Delphiuses VFstd;
    (stets die zum Ziel-Datentyp gehörige unit einschließen!)
procedure V_ItoF( Y:fVector; X:iVector; size:UIntSize );
    (analog alle übrigen Funktionen dieser Familie)
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaV_ItoF( fVector d_Y, iVector d_X, ui size );
void Vcu_ItoF( fVector h_Y, iVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaV_ItoF( d_Y:fVector; d_X:iVector; size:UIntSize ): IntBool;
procedure Vcu_ItoF( h_Y:fVector; h_X:iVector; size:UIntSize );
BeschreibungJedes Element von X wird aus dem betreffenden Ganzzahl- Datentyp in den gewünschten Fließkomma-Typ umgewandelt und in Y gespeichert. Für den umgekehrten Vorgang, also die Umwandlung von Fließkomma- in Ganzzahl-Typen, bediene man sich der Funktionen der Familien VF_roundtoI,   VF_floortoI,   VF_ceiltoI und VF_choptoI.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_roundtoI,   VF_floortoI,   VF_ceiltoI,   VF_choptoI,   VF_trunctoI,   V_ItoLI

 

V_ItoBIV_ItoSIV_ItoLIV_ItoQI
V_BItoIV_BItoSIV_BItoLIV_BItoQI
V_SItoIV_SItoBIV_SItoLIV_SItoQI
V_LItoIV_LItoBIV_LItoSIV_LItoQI
V_QItoIV_QItoBIV_QItoSIV_QItoLI
V_UtoUBV_UtoUSV_UtoULV_UtoUI
V_UBtoUV_UBtoUSV_UBtoULV_UBtoUI
V_UStoUV_UStoUBV_UStoULV_UStoUI
V_ULtoUV_ULtoUBV_ULtoUSV_ULtoUI
V_UItoUV_UItoUBV_UItoUSV_UItoUL
V_ItoUV_BItoUBV_SItoUSV_LItoUL
V_UtoIV_UBtoBIV_UStoSIV_ULtoLI
FunktionUmwandlungen innerhalb der Ganzzahl-Datentypen
Syntax C/C++#include <VLIstd.h>
    (oder <VIstd.h>, <VUstd.h>,..., abhängig vom Ziel-Datentyp!)
void V_ItoLI( liVector Y, iVector X, ui size );
    (analog alle übrigen Funktionen dieser Familie)
C++ VecObj#include <OptiVec.h>
void vector<long>::ItoLI( const vector<long>& Y );
Pascal/Delphiuses VLIstd;
    (stets die zum Ziel-Datentyp gehörige unit einschließen!)
procedure V_ItoLI( Y:liVector; X:iVector; size:UIntSize );
    (analog alle übrigen Funktionen dieser Familie)
CUDA-Funktion C/C++#include <cudaVLIstd.h>
int cudaV_ItoLI( liVector d_Y, iVector d_X, ui size );
void Vcu_ItoLI( liVector h_Y, iVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VLIstd;
function cudaV_ItoLI( d_Y:liVector; d_X:iVector; size:UIntSize ): IntBool;
procedure Vcu_ItoLI( h_Y:liVector; h_X:iVector; size:UIntSize );
BeschreibungJedes Element von X wird in den gewünschten Datentyp konvertiert und in Y gespeichert.
Fehlerbehandlungsiehe Kap. 5.2.
Rückgabewertkeiner
QuerverweisV_ItoF

 

VF_KeplerVD_KeplerVE_Kepler
VFx_KeplerVDx_KeplerVEx_Kepler
FunktionWinkelposition eines Himmelskörpers nach dem Zweiten Keplerschen Gesetz
Syntax C/C++#include <VFmath.h>
int VF_Kepler( fVector Y, fVector X, ui size, float T, float e );
int VFx_Kepler( fVector Y, fVector X, ui size, float T, float e, float A, float B );
C++ VecObj#include <OptiVec.h>
int vector<T>::Kepler( const vector<T>& X, T t, T e );
int vector<T>::x_Kepler( const vector<T>& X, T t, T e, const T& A, const T& B );
Pascal/Delphi#include <VFmath.h>
function VF_Kepler( Y, X:fVector; size:UIntSize; T, e:Single ): IntBool;
function VFx_Kepler( Y, X:fVector; size:UIntSize; T, e, A, B:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_Kepler( fVector d_Y, fVector d_X, ui size, float T, float e );
int cusdVF_Kepler( fVector d_Y, fVector d_X, ui size, float *d_T, float *d_e );
int cudaVFx_Kepler( fVector d_Y, fVector d_X, ui size, float T, float e, float A, float B );
int cusdVFx_Kepler( fVector d_Y, fVector d_X, ui size, float *d_T, float *d_e, float *d_A, float *d_B );
int VFcu_Kepler( fVector h_Y, fVector h_X, ui size, float T, float e );
int VFxcu_Kepler( fVector h_Y, fVector h_X, ui size, float T, float e, float A, float B );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_Kepler( d_Y, d_X:fVector; size:UIntSize; T, e:Single ): IntBool;
function cusdVF_Kepler( d_Y, d_X:fVector; size:UIntSize; d_T, d_e:PSingle ): IntBool;
function cudaVFx_Kepler( d_Y, d_X:fVector; size:UIntSize; T, e, A, B:Single ): IntBool;
function cusdVFx_Kepler( d_Y, d_X:fVector; size:UIntSize; d_T, d_e, d_A, d_B:PSingle ): IntBool;
function VFcu_Kepler( h_Y, h_X:fVector; size:UIntSize; T, e:Single ): IntBool;
function VFxcu_Kepler( h_Y, h_X:fVector; size:UIntSize; T, e, A, B:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = Kepler( Xi/T, e );
erweiterte Versionen: Yi = Kepler( (A*Xi+B)/T, e );
Die zeitabhängige Winkelposition eines Planeten oder Kometen auf einer elliptischen Bahn wird aus seiner Umlaufzeit T und der Bahn-Exzentrizität e berechnet.
T muss ungleich Null sein; e kann Werte im Bereich 0 ≤ e ≤ 1 annehmen.
Zwar existiert keine analytische Lösung dieses Problems, wohl aber ein sehr effizienter iterativer Algorithmus, der hier eingesetzt wird. Er bleibt bis hinauf zum hyperbolischen Grenzwert e = 1.0 schnell und stabil.
Während die "Lehrbuch-Behandlung" des Problems üblicherweise die reduzierte Zeit m = t/T verwendet, erwartet VF_Kepler die tatsächliche Zeit in X und führt die Division durch die Umlaufzeit intern durch.
Da man wohl nur sehr selten die erhaltene Winkelposition mit einer Konstante skalieren wird, ist - anders als bei den meisten "erweiterten Versionen" mathematischer Funktionen in VectorLib - in der VFx_-Version keine Multiplikation mit C vorgesehen. Diese übernimmt als zusätzliche Parameter daher lediglich A und B.
Diese Funktion darf nicht aufgerufen werden, wenn die FPU auf reduzierte Genauigkeit geschaltet wurde. Andernfalls kann sie in einer unendlichen Schleife hängenbleiben, siehe V_setFPAccuracy. Da manche Versionen von Windows (ab XP x64) die FPU automatisch auf double-Genauigkeit reduzieren, sollte vor dem Aufruf der VE_ -Version sicherheitshalber V_setFPAccuracy( 3 ); gerufen werden.
FehlerbehandlungFür negatives e oder e > 1.0 resultiert ein "Invalid parameter(s)"-Fehler und Programm-Abbruch. Für T = 0 werden alle Yi gleich 0 gesetzt.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)

 

VF_LangevinVD_LangevinVE_Langevin
VFx_LangevinVDx_LangevinVEx_Langevin
FunktionLangevin-Funktion für dielektrische Relaxation
Syntax C/C++#include <VFmath.h>
int VF_Langevin( fVector Y, fVector X, ui size );
int VFx_Langevin( fVector Y, fVector X, ui size, float A, float B, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::Langevin( const vector<T>& X );
int vector<T>::x_Langevin( const vector<T>& X, const T& A, const T& B, const T& C );
Pascal/Delphi#include <VFmath.h>
function VF_Langevin( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_Langevin( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_Langevin( fVector d_Y, fVector d_X, ui size );
int cudaVFx_Langevin( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_Langevin( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_Langevin( fVector h_Y, fVector h_X, ui size );
int VFxcu_Langevin( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_Langevin( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_Langevin( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_Langevin( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_Langevin( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_Langevin( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = cot( Xi ) - 1/Xi;
erweiterte Versionen: x = A * Xi + B;
                                Yi = C * (cot(x) - 1/x);
Die Langevin-Funktion weist einen S-förmigen Graphen auf und beschreibt beispielsweise dielektrische Relaxations-Phänomene.
FehlerbehandlungEs dürften keine Fehler auftreten.
Rückgabewertimmer FALSE(0).

 

VF_ldexpVD_ldexpVE_ldexp
FunktionSkalierung mit einer ganzzahligen Potenz von 2
Syntax C/C++#include <VFmath.h>
int VF_ldexp( fVector Y, fVector X, ui size, int expo );
C++ VecObj#include <OptiVec.h>
int vector<T>::ldexp( const vector<T>& X );
Pascal/DelphiDiese Funktionen sind für Pascal/Delphi nicht definiert. Man benutze VF_scale2 etc.
BeschreibungDiese Funktionen sind als Alias-Namen für VF_scale2 etc. implementiert, um Konsistenz mit dem in ANSI−C definierten Funktionsnamen ldexp zu bewahren. Siehe VF_scale2.

 

VF_limitVD_limitVE_limit
VCF_limitVCD_limitVCE_limit
FunktionWertebereich limitieren
Syntax C/C++#include <VFmath.h>
void VF_limit( fVector Y, fVector X, ui size, float Min, float Max );
void VCF_limit( cfVector Y, cfVector X, ui size, fComplex Min, fComplex Max );
C++ VecObj#include <OptiVec.h>
void vector<T>::limit( const vector<T>& X, T Min, T Max );
void vector<complex<T>>::limit( const vector<complex<T>>& X, complex<T> Min, complex<T> Max );
Pascal/Delphiuses VFmath;
procedure VF_limit( Y, X:fVector; size:UIntSize; Min, Max:Single );
procedure VCF_limit( Y, X:cfVector; size:UIntSize; Min, Max:fComplex );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_limit( fVector d_Y, fVector d_X, ui size, float Min, float Max );
int cusdVF_limit( fVector d_Y, fVector d_X, ui size, float *d_Min, float *d_Max );
void VFcu_limit( fVector h_Y, fVector h_X, ui size, float Min, float Max );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_limit( d_Y, d_X:fVector; size:UIntSize; Min, Max:Single ): IntBool;
function cusdVF_limit( d_Y, d_X:fVector; size:UIntSize; d_Min, d_Max:PSingle ): IntBool;
procedure VFcu_limit( h_Y, h_X:fVector; size:UIntSize; Min, Max:Single );
BeschreibungReelle Versionen:
Yi = Xi , wenn Min ≤ Xi ≤ Max
Yi = Max, wenn Xi > Max
Yi = Min, wenn Xi < Min
Diese Funktion kann als Kombination von VF_maxC und VF_minC angesehen werden.
Komplexe Versionen:
Analog den reellen Versionen; jedoch werden Real- und Imaginärteile getrennt und gemäß den in den Real- und Imaginärteilen von Min und Max spezifizierten Grenzen behandelt.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_maxC,   VF_minC,   VF_min,   VF_flush0,   VF_absHuge

 

V_limitThreadsPerFunc
FunktionBegrenzung der Anzahl von Threads, die jeder Aufruf einer OptiVec-Funktion beanspruchen darf
Syntax C/C++#include <VecLib.h>
int V_limitThreadsPerFunc( unsigned nMaxThreads );
Pascal/Delphiuses VecLib;
function V_limitThreadsPerFunc( nMaxThreads:UInt ): IntBool;
BeschreibungWie bei V_initMT beschrieben, ist es auf Rechnern mit vielen Prozessor-Kernen (etwa ab 8 oder 16) u.U. sinnvoll, die Zahl der von jeder einzelnen OptiVec-Funktion beanspruchbaren Threads zu begrenzen. Dies gilt vor allem, wenn eine Anwendung selbst mehrere Arbeits-Threads generiert und aus allen oder mehreren von ihnen OptiVec-Funktionen aufgerufen werden. Im Interesse einer optimalen Ausnutzung der Prozessor-Kapazitäten sollte in einer solchen Situation durch Aufruf von V_limitThreadsPerFunc die Zahl der Threads festgelegt werden, die jeder Aufruf einer OptiVec-Funktion maximal für sich beanspruchen darf. Es empfiehlt sich allerdings, relativ großzügig zu sein. Bei 16 Kernen und vier Anwendungs-Threads etwa sollte man den OptiVec-Funktionen nicht nur 16/4=4, sondern lieber 8 Threads erlauben. Das Betriebssystem wird sich dann um das optimale Scheduling aller Threads kümmern.

V_limitThreadsPerFunc sollte unmittelbar nach V_initMT aufgerufen werden. Der so eingestellte Wert gilt für sämtliche Aufrufe von OptiVec-Funktionen aus allen Threads der Anwendung. Er kann zwar prinzipiell durch erneuten Aufruf von V_limitThreadsPerFunc modifiziert werden. Da V_limitThreadsPerFunc aber nicht fiber-sicher ist, wäre es jeweils dem Zufall überlassen, für welchen Funktionsaufruf bereits der "neue" und für welchen noch der "alte" Wert Anwendung findet.

Rückgabewertimmer FALSE (0)
QuerverweisV_initMT,   V_closeMT, Kap. 1.1.2.

 

VF_lincombVD_lincombVE_lincomb
VCF_lincombVCD_lincombVCE_lincomb
FunktionLinearkombination zweier Vektoren
Syntax C/C++#include <VFstd.h>
void VF_lincomb( fVector Z, fVector X, fVector Y, ui size, float CX, float CY );
C++ VecObj#include <OptiVec.h>
void vector<T>::lincomb( const vector<T>& X, const vector<T>& Y, const T& CX, const T& CY );
Pascal/Delphiuses VFstd;
procedure VF_lincomb( Z, X, Y:fVector; size:UIntSize; CX, CY:Single );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_lincomb( fVector d_Z, fVector d_X, fVector d_Y, ui size, float CX, float CY );
int cusdVF_lincomb( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_CX, float *d_CY );
void VFcu_lincomb( fVector h_Z, fVector h_X, fVector h_Y, ui size, float CX, float CY );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_lincomb( d_Z, d_X, d_Y:fVector; size:UIntSize; CX, CY:Single ): IntBool;
function cusdVF_lincomb( d_Z, d_X, d_Y:fVector; size:UIntSize; d_CX, d_CY:PSingle ): IntBool;
procedure VFcu_lincomb( h_Z, h_X, h_Y:fVector; size:UIntSize; CX, CY:Single );
BeschreibungZi = CX * Xi + CY * Yi
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVFx_addV,   VF_rotateCoordinates

 

VF_linregressVD_linregressVE_linregress
FunktionLineare Regression
Syntax C/C++#include <VFstd.h>
void VF_linregress( fVector Param, fVector X, fVector Y, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::linregress( const vector<T>& X, const vector<T>& Y );
Pascal/Delphiuses VFstd;
procedure VF_linregress( Param, X, Y:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_linregress( fVector h_Param, fVector d_X, fVector d_Y, ui size );
int cusdVF_linregress( fVector d_Param, fVector d_X, fVector d_Y, ui size );
void VF_linregress( fVector h_Param, fVector h_X, fVector h_Y, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_linregress( h_Param, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cusdVF_linregress( d_Param, d_X, d_Y:fVector; size:UIntSize ): IntBool;
procedure VFcu_linregress( h_Param, h_X, h_Y:fVector; size:UIntSize );
BeschreibungEine Gerade y = ax + b wird durch die X-Y- Daten gelegt.
Dabei werden die Parameter a und b so bestimmt, dass der Ausdruck
h2 = Summe( (Yi - y(x=Xi) )2 )
minimal wird. Die Unsicherheiten (Fehlerbreiten) da und db werden ebenfalls berechnet. Die erhaltenen Parameter werden in der Reihenfolge {a, da, b, db, h2} in Param gespeichert.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_linregresswW,   VF_corrcoeff,   VF_chi2,   VF_linfit,   VF_nonlinfit

 

VF_linregresswWVD_linregresswWVE_linregresswW
Funktionlineare Regression mit Wichtung der einzelnen Datenpunkte
Syntax C/C++#include <VFstd.h>
void VF_linregresswW( fVector Param, fVector X, fVector Y, fVector InvVar, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::linregresswW( const vector<T>& X, const vector<T>& Y, const vector<T>& InvVar );
Pascal/Delphiuses VFstd;
procedure VF_linregresswW( Param, X, Y, InvVar:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_linregresswW( fVector h_Param, fVector d_X, fVector d_Y, fVector d_InvVar, ui size );
int cusdVF_linregresswW( fVector d_Param, fVector d_X, fVector d_Y, fVector d_InvVar, ui size );
void VF_linregresswW( fVector h_Param, fVector h_X, fVector h_Y, fVector h_InvVar, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_linregresswW( h_Param, d_X, d_Y, d_InvVar:fVector; size:UIntSize ): IntBool;
function cusdVF_linregresswW( d_Param, d_X, d_Y, d_InvVar:fVector; size:UIntSize ): IntBool;
procedure VFcu_linregresswW( h_Param, h_X, h_Y, h_InvVar:fVector; size:UIntSize );
BeschreibungDie X-Y- Datenpunkte werden mit dem Kehrwert ihrer Varianzen gewichtet und eine Gerade y = ax + b durch die Punkte gelegt. Dabei werden die Parameter a und b so bestimmt, dass der Anpassungstestwert
c2 = sum( (1 / Vari) * (Yi - y(x=Xi) )2 )
(siehe auch VF_chi2) minimiert wird.
Der Kehrwert der Varianzen (d.h. der quadrierten Standardabweichungen) muss als Vektor InvVar übergeben werden. Die Unsicherheiten (Fehlerbreiten) da und db werden ebenfalls berechnet. Die so erhaltenen Parameter werden in der Reihenfolge {a, da, b, db, c2} in Param gespeichert.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_linregress,   VF_corrcoeff,   VF_chi2

 

V_LItoFV_LItoDV_LItoE
FunktionDatentyp-Umwandlungen. Siehe V_ItoF!

 

VF_lnVD_lnVE_ln
VCF_lnVCD_lnVCE_ln
VFx_lnVDx_lnVEx_ln
VCFx_lnVCDx_lnVCEx_ln
VPF_lntoCVPD_lntoCVPE_lntoC
Funktionnatürlicher Logarithmus
Syntax C/C++#include <VFmath.h>
int VF_ln( fVector Y, fVector X, ui size );
int VFx_ln( fVector Y, fVector X, ui size, float A, float B, float C );
int VPF_lntoC( cfVector Y, pfVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::ln( const vector<T>& X );
int vector<T>::x_ln( const vector<T>& X, const T& A, const T& B, const T& C );
int vector<complex<T>>::lntoC( const vector<polar<T>>& X );
Pascal/Delphiuses VFmath;
function VF_ln( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_ln( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function VPF_lntoC( Y:cfVector; X:pfVector; size:UIntSize ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_ln( fVector d_Y, fVector d_X, ui size );
int cudaVFx_ln( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_ln( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_ln( fVector h_Y, fVector h_X, ui size );
int VFxcu_ln( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_ln( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_ln( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_ln( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_ln( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_ln( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
BeschreibungDiese Funktionsnamen werden als Synonym für die Funktionen der VF_log-Familie gebraucht. Siehe dort.

 

VF_localmaximaVD_localmaximaVE_localmaxima
Funktionlokale Maxima
Syntax C/C++#include <VFstd.h>
ui VF_localmaxima( uiVector Ind, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
ui vector<ui>::localmaxima( const vector<T>& X );
Pascal/Delphiuses VFstd;
function VF_localmaxima( Ind:uiVector; X:fVector; size:UIntSize ):UIntSize;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_localmaxima( ui *h_nFound, uiVector d_Ind, fVector d_X, ui size );
ui VFcu_localmaxima( uiVector h_Ind, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_localmaxima( var h_nFound:UIntSize; d_Ind:uiVector; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_localmaxima( h_Ind:uiVector; h_X:fVector; size:UIntSize ): UIntSize;
BeschreibungDie Indizes aller lokalen Maxima in X werden in Ind gespeichert und ihre Anzahl zurückgegeben. Ein lokales Maximum wird dabei als ein Element von X definiert, das größer als sowohl sein "rechter" als auch sein "linker" Nachbar ist. Dies bedeutet, dass das nullte und das letzte Element (die ja nur je einen Nachbarn haben) nicht als lokale Maxima angesehen werden können. Außerdem kann, wenn zwei benachbarte Elemente gleich sind, keines von beiden ein lokales Maximum sein.
Fehlerbehandlungkeine
RückgabewertAnzahl der gefundenen lokalen Maxima
QuerverweisVF_maxind,   VF_max,   VF_indpick,   VF_localminima

 

VF_localminimaVD_localminimaVE_localminima
Funktionlokale Minima
Syntax C/C++#include <VFstd.h>
ui VF_localminima( uiVector Ind, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
ui vector<ui>::localminima( const vector<T>& Ind );
Pascal/Delphiuses VFstd;
function VF_localminima( Ind:uiVector; X:fVector; size:UIntSize ):UIntSize;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_localminima( ui *h_nFound, uiVector d_Ind, fVector d_X, ui size );
ui VFcu_localminima( uiVector h_Ind, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_localminima( var h_nFound:UIntSize; d_Ind:uiVector; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_localminima( h_Ind:uiVector; h_X:fVector; size:UIntSize ): UIntSize;
BeschreibungDie Indizes aller lokalen Minima in X werden in Ind gespeichert und ihre Anzahl zurückgegeben. Ein lokales Minimum wird dabei als ein Element von X definiert, das kleiner als sowohl sein "rechter" als auch sein "linker" Nachbar ist. Dies bedeutet, dass das nullte und das letzte Element (die ja nur je einen Nachbarn haben) nicht als lokale Minima angesehen werden können. Außerdem kann, wenn zwei benachbarte Elemente gleich sind, keines von beiden ein lokales Minimum sein.
Fehlerbehandlungkeine
RückgabewertAnzahl der gefundenen lokalen Minima
QuerverweisVF_minind,   VF_min,   VF_indpick,   VF_localmaxima

 

VF_logVD_logVE_log
VCF_logVCD_logVCE_log
VFx_logVDx_logVEx_log
VCFx_logVCDx_logVCEx_log
VPF_logtoCVPD_logtoCVPE_logtoC
Funktionnatürlicher Logarithmus
Syntax C/C++#include <VFmath.h>
int VF_log( fVector Y, fVector X, ui size );
int VFx_log( fVector Y, fVector X, ui size, float A, float B, float C );
int VPF_logtoC( cfVector Y, pfVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::log( const vector<T>& X );
int vector<T>::x_log( const vector<T>& X, const T& A, const T& B, const T& C );
int vector<complex<T>>::logtoC( const vector<polar<T>>& X );
Pascal/Delphiuses VFmath;
function VF_log( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_log( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function VPF_logtoC( Y:cfVector; X:pfVector; size:UIntSize ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_log( fVector d_Y, fVector d_X, ui size );
int cudaVFx_log( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_log( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_log( fVector h_Y, fVector h_X, ui size );
int VFxcu_log( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_log( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_log( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_log( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_log( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_log( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = ln( Xi )
erweiterte Versionen: Yi = C * ln( A*Xi+B )
Der "logarithmus naturalis", d.h. der Logarithmus zur Euler'schen Zahl e wird berechnet.
Der Logarithmus polar-komplexer Zahlen führt auf natürliche Weise zu cartesischen Koordinaten:
log{Mag@Arg} = {Mag,Arg}.
Daher existiert die VPF_-Version nur mit cartesischem Ausgabevektor.
FehlerbehandlungReelle Versionen: DOMAIN-Fehler entstehen für negative Xi (einschließlich −0.0) mit dem vorgeschlagenen Ergebnis NAN (IEEE-"Nicht-Zahl"). SING-Fehler entstehen für Xi= +0.0 und ergeben ein Resultat von -HUGE_VAL.
In den komplexen Versionen werden Zahlen mit einem Imaginärteil von 0 immer als reelle Zahlen behandelt. Daher wird ein Argument von {0, 0} als reelle 0 angesehen, die einen SING-Fehler mit dem Ergebnis {-HUGE_VAL, 0} zur Folge hat.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_exp,   VF_log2,   VF_log10,   VF_pow,   log

 

VF_log10VD_log10VE_log10
VCF_log10VCD_log10VCE_log10
VFx_log10VDx_log10VEx_log10
VCFx_log10VCDx_log10VCEx_log10
VPF_log10toCVPD_log10toCVPE_log10toC
Funktiondekadischer Logarithmus
Syntax C/C++#include <VFmath.h>
int VF_log10( fVector Y, fVector X, ui size );
int VFx_log10( fVector Y, fVector X, ui size, float A, float B, float C );
int VPF_log10toC( cfVector Y, pfVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::log10( const vector<T>& X );
int vector<T>::x_log10( const vector<T>& X, const T& A, const T& B, const T& C );
int vector<complex<T>>::log10toC( const vector<polar<T>>& X );
Pascal/Delphiuses VFmath;
function VF_log10( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_log10( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function VPF_log10toC( Y:cfVector; X:pfVector; size:UIntSize ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_log10( fVector d_Y, fVector d_X, ui size );
int cudaVFx_log10( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_log10( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_log10( fVector h_Y, fVector h_X, ui size );
int VFxcu_log10( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_log10( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_log10( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_log10( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_log10( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_log10( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = lg( Xi )
erweiterte Versionen: Yi = C * lg( A*Xi+B )
Der dekadische Logarithmus, d.h. der Logarithmus zur Basis 10 wird berechnet.
FehlerbehandlungReelle Versionen: DOMAIN-Fehler entstehen für negative Xi (einschließlich −0.0) mit dem vorgeschlagenen Ergebnis NAN (IEEE-"Nicht-Zahl"). SING-Fehler entstehen für Xi= +0.0 und ergeben ein Resultat von -HUGE_VAL.
In den komplexen Versionen werden Zahlen mit einem Imaginärteil von 0 immer als reelle Zahlen behandelt. Daher wird ein Argument von {0, 0} als reelle 0 angesehen, die einen SING-Fehler mit dem Ergebnis {-HUGE_VAL, 0} zur Folge hat.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_pow10,   VF_log,   VF_log2,   VF_pow,   log10 (diese Funktion ist in ANSI C definiert; für Pascal/Delphi wird sie in der mit OptiVec ausgelieferten unit XMATH zur Verfügung gestellt).

 

VF_log2VD_log2VE_log2
VCF_log2VCD_log2VCE_log2
VFx_log2VDx_log2VEx_log2
VCFx_log2VCDx_log2VCEx_log2
VPF_log2toCVPD_log2toCVPE_log2toC
Funktionbinärer Logarithmus
Syntax C/C++#include <VFmath.h>
int VF_log2( fVector Y, fVector X, ui size );
int VFx_log2( fVector Y, fVector X, ui size, float A, float B, float C );
int VPF_log2toC( cfVector Y, pfVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::log2( const vector<T>& X );
int vector<T>::x_log2( const vector<polar<T>>& X, const T& A, const T& B, const T& C );
int vector<complex<T>>::log2toC( const vector<T>& X );
Pascal/Delphiuses VFmath;
function VF_log2( Y, X:fVector; size:UIntSize ): IntBool;
function VFx_log2( Y, X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function VPF_log2toC( Y:cfVector; X:pfVector; size:UIntSize ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_log2( fVector d_Y, fVector d_X, ui size );
int cudaVFx_log2( fVector d_Y, fVector d_X, ui size, float A, float B, float C );
int cusdVFx_log2( fVector d_Y, fVector d_X, ui size, float *d_A, float *d_B, float *d_C );
int VFcu_log2( fVector h_Y, fVector h_X, ui size );
int VFxcu_log2( fVector h_Y, fVector h_X, ui size, float A, float B, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_log2( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function cudaVFx_log2( d_Y, d_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
function cusdVFx_log2( d_Y, d_X:fVector; size:UIntSize; d_A, d_B, d_C:PSingle ): IntBool;
function VFcu_log2( h_Y, h_X:fVector; size:UIntSize ): IntBool;
function VFxcu_log2( h_Y, h_X:fVector; size:UIntSize; A, B, C:Single ): IntBool;
Beschreibungeinfache Versionen: Yi = lb( Xi )
erweiterte Versionen: Yi = C * lb( A*Xi+B )
Der "logarithmus binarius", d.h. der Logarithmus zur Basis 2 wird berechnet.
FehlerbehandlungReelle Versionen: DOMAIN-Fehler entstehen für negative Xi (einschließlich −0.0) mit dem vorgeschlagenen Ergebnis NAN (IEEE-"Nicht-Zahl"). SING-Fehler entstehen für Xi= +0.0 und ergeben ein Resultat von -HUGE_VAL.
In den komplexen Versionen werden Zahlen mit einem Imaginärteil von 0 immer als reelle Zahlen behandelt. Daher wird ein Argument von {0, 0} als reelle 0 angesehen, die einen SING-Fehler mit dem Ergebnis {-HUGE_VAL, 0} zur Folge hat.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_pow2,   VF_log,   VF_log10,   VF_pow,   log2 (diese Funktion ist weder in in ANSI C noch in Pascal/Delphi definiert, wird aber in <xmath.h> bzw. der unit XMATH zur Verfügung gestellt).

 

VF_LorentzVD_LorentzVE_Lorentz
FunktionLorentz'sche Linienbreiten-Funktion
Syntax C/C++#include <VFmath.h>
int VF_Lorentz( fVector Y, fVector X, ui size, float Wid, float Cent, float C );
C++ VecObj#include <OptiVec.h>
int vector<T>::Lorentz( const vector<T>& X, T Wid, const T& Cent, const T& C );
Pascal/Delphiuses VFmath;
function VF_Lorentz( Y, X:fVector; size:UIntSize; Wid, Cent, C:Single ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_Lorentz( fVector d_Y, fVector d_X, ui size, float Wid, float Cent, float C );
int cusdVF_Lorentz( fVector d_Y, fVector d_X, ui size, float *d_Wid, float *d_Cent, float *d_C );
int VFcu_Lorentz( fVector h_Y, fVector h_X, ui size, float Wid, float Cent, float C );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_Lorentz( d_Y, d_X:fVector; size:UIntSize; Wid, Cent, C:Single ): IntBool;
function cusdVF_Lorentz( d_Y, d_X:fVector; size:UIntSize; d_Wid, d_Cent, d_C:PSingle ): IntBool;
function VFcu_Lorentz( h_Y, h_X:fVector; size:UIntSize; Wid, Cent  C:Single ): IntBool;
BeschreibungYi = C * Wid2 / ( (Xi - Cent)2 + Wid2 )
Wid = Breite der Resonanzlinie
Cent = Zentrum der Linie
C = Skalierungsfaktor; im Zentrum der Linie ist die Amplitude gleich C. Dies gilt auch dann, wenn Wid gleich 0 ist.
FehlerbehandlungEs dürften keine Fehler auftreten.
Rückgabewertimmer FALSE(0)
QuerverweisVF_Gauss,   VF_sech2

 

VF_MagArgtoPVD_MagArgtoPVE_MagArgtoP
FunktionPolar-komplexen Vektor aus separaten Vektoren für Zeigerlänge und -winkel konstruieren
Syntax C/C++#include <VPFstd.h>
void VF_MagArgtoP( pfVector Y, fVector Mag, fVector Arg, ui size );
C++ VecObj#include <OptiVec.h>
void vector<polar<T>>::MagArgtoP( const vector<T>& Mag, const vector<T>& Arg );
Pascal/Delphiuses VPFstd;
procedure VF_MagArgtoP( X:pfVector; Mag, Arg:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVPFstd.h>
int cudaVF_MagArgtoP( cfVector d_Y, fVector d_Mag, fVector d_Arg, ui size );
void VFcu_MagArgtoP( cfVector h_Y, fVector h_Mag, fVector h_Arg, ui size );
CUDA-Funktion Pascal/Delphiuses VPFstd;
function cudaVF_MagArgtoP( d_X:cfVector; d_Mag, d_Arg:fVector; size:UIntSize ): IntBool;
procedure VFcu_MagArgtoP( h_X:cfVector; h_Mag, h_Arg:fVector; size:UIntSize );
BeschreibungDer polar-komplexe Vektor Y wird aus den zwei reellen Vektoren Mag (Zeigerlänge) und Arg (Zeigerwinkel) gewonnen.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_PtoMagArg,   VF_ReImtoC,   VF_MagtoP,   VF_ArgtoP

 

VF_MagArgtoPrincipalVD_MagArgtoPrincipalVE_MagArgtoPrincipal
FunktionPolar-komplexen Vektor aus separat angegebenen Zeigerlängen und -Winkeln konstruieren und auf den Hauptwert normieren
Syntax C/C++#include <VPFstd.h>
void VF_MagArgtoPrincipal( pfVector Y, fVector Mag, fVector Arg, ui size );
C++ VecObj#include <OptiVec.h>
void vector<polar<T>>::MagArgtoPrincipal( const vector<T>& Mag, const vector<T>& Arg );
Pascal/Delphiuses VPFstd;
procedure VF_MagArgtoPrincipal( X:pfVector; Mag, Arg:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVPFstd.h>
int cudaVF_MagArgtoPrincipal( cfVector d_Y, fVector d_Mag, fVector d_Arg, ui size );
void VFcu_MagArgtoPrincipal( cfVector h_Y, fVector h_Mag, fVector h_Arg, ui size );
CUDA-Funktion Pascal/Delphiuses VPFstd;
function cudaVF_MagArgtoPrincipal( d_X:cfVector; d_Mag, d_Arg:fVector; size:UIntSize ): IntBool;
procedure VFcu_MagArgtoPrincipal( h_X:cfVector; h_Mag, h_Arg:fVector; size:UIntSize );
BeschreibungDer polar-komplexe Vektor Y wird aus den beiden reellen Vektoren Mag (Zeigerlänge) und Arg (Zeigerwinkel) zusammengesetzt. Dabei werden die Zeigerwinkel auf den Hauptwert reduziert: p < Arg ≤ +p
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVPF_principal,   VF_MagArgtoP

 

VF_MagtoPVD_MagtoPVE_MagtoP
FunktionMag-Teil eines polar-komplexen Vektors (re-)initialisieren
Syntax C/C++#include <VPFstd.h>
void VF_MagtoP( pfVector Y, fVector Mag, ui size );
C++ VecObj#include <OptiVec.h>
void vector<polar<T>>::MagtoP( const vector<T>& Mag );
Pascal/Delphiuses VPFstd;
procedure VF_MagtoP( X:pfVector; Mag:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVPFstd.h>
int cudaVF_MagtoP( pfVector d_Y, fVector d_Mag, ui size );
void VFcu_MagtoP( pfVector h_Y, fVector h_Mag, ui size );
CUDA-Funktion Pascal/Delphiuses VPFstd;
function cudaVF_MagtoP( d_X:pfVector; d_Mag:fVector; size:UIntSize ): IntBool;
procedure VFcu_MagtoP( h_X:pfVector; h_Mag:fVector; size:UIntSize );
BeschreibungDer Mag-Teil des polar-komplexen Vektors Y wird mit dem reellen Vektor Mag überschrieben. Der Arg-Teil wird hiervon nicht berührt.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_PtoMagArg,   VF_MagArgtoP,   VF_ArgtoP

 

VF_mantexpVD_mantexpVE_mantexp
FunktionAufspaltung in Mantisse und Exponenten
Syntax C/C++#include <VFmath.h>
int VF_mantexp( fVector MantPart, iVector ExpPart, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::mantexp( vector<int> ExpPart, const vector<T>& X );
Pascal/Delphiuses VFmath;
function VF_mantexp( MantPart:fVector; ExpPart:iVector; X:fVector; size:UIntSize ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_mantexp( fVector d_MantPart, iVector d_ExpPart, fVector d_X, ui size );
int VFcu_mantexp( fVector h_MantPart, iVector h_ExpPart, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_mantexp( d_MantPart:fVector; d_ExpPart:iVector; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_mantexp( h_MantPart:fVector; h_ExpPart:iVector; h_X:fVector; size:UIntSize ): IntBool;
BeschreibungDie Elemente von X werden in Mantisse und Exponenten aufgespalten. Erstere wird in MantPart gespeichert, letzterer in eine int/Integer konvertiert und in ExpPart gespeichert.
Fehlerbehandlungkeine
Rückgabewertimmer FALSE(0)
QuerverweisVF_scale2,   VF_intfrac,   frexp (nur C/C++),   ldexp (nur C/C++)

 

VF_maxVD_maxVE_max
VI_maxVBI_maxVSI_maxVLI_maxVQI_max 
VU_maxVUB_maxVUS_maxVUL_maxVUQ_maxVUI_max
Funktiongrößtes Element eines Vektors
Syntax C/C++#include <VFstd.h>
float VF_max( fVector X, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::_max();
Pascal/Delphiuses VFstd;
function VF_max( X:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_max( float *h_RetVal, fVector d_X, ui size );
int cusdVF_max( float *d_RetVal, fVector d_X, ui size );
float VFcu_max( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_max( var h_RetVal:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_max( d_RetVal:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_max( h_X:fVector; size:UIntSize ): Single;
BeschreibungDer Wert des größten in X vorkommenden Elementes wird zurückgegeben. Um in C++ Verwechslungen mit dem macro "max" zu vermeiden, wird die VecObj-Version dieser Funktion mit einem Unterstrich geschrieben als "_max".
Fehlerbehandlungkeine
RückgabewertMaximum
QuerverweisVF_min,   VF_minmax,   VF_absmax,   VF_maxexp,   VF_runmax,   VF_maxind,   VF_min_max_mean_stddev

 

VF_maxCVD_maxCVE_maxC
VI_maxCVBI_maxCVSI_maxCVLI_maxCVQI_maxC 
VU_maxCVUB_maxCVUS_maxCVUL_maxCVUQ_maxCVUI_maxC
FunktionVergleich jedes Vektorelementes mit einem bestimmten Wert und Auswahl des größeren dieser beiden Werte
Syntax C/C++#include <VFmath.h>
void VF_maxC( fVector Y, fVector X, ui size, float C );
C++ VecObj#include <OptiVec.h>
void vector<T>::maxC( const vector<T>& X, const T& C );
Pascal/Delphiuses VFmath;
procedure VF_maxC( Y, X:fVector; size:UIntSize; C:Single );
CUDA-Funktion C/C++#include <cudaVFmath.h>
#include <cudaVDmath.h>
int cudaVF_maxC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_maxC( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_maxC( fVector d_Y, fVector d_X, ui size, float C );
CUDA-Funktion Pascal/Delphiuses VFmath, VDmath;
function cudaVF_maxC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_maxC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VF_maxC( Y, X:fVector; size:UIntSize; C:Single );
BeschreibungYi = Xi, wenn Xi > C
Yi = C, wenn Xi ≤ C
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_maxV,   VF_minC,   VF_max,   VF_absmax,   VF_limit,   VF_flush0

 

VF_maxdevCVD_maxdevCVE_maxdevC
FunktionMaximum der Abweichungs-Beträge von einem Sollwert
Syntax C/C++#include <VFstd.h>
float VF_maxdevC( fVector X, ui size, float C );
C++ VecObj#include <OptiVec.h>
T vector<T>::maxdevC( const T& C );
Pascal/Delphiuses VFstd;
function VF_maxdevC( X:fVector; size:UIntSize; C:Single ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_maxdevC( float *h_RetVal, fVector d_X, ui size, float C );
int cusdVF_maxdevC( float *d_RetVal, fVector d_X, ui size, float *d_C );
float VFcu_maxdevC( fVector h_X, ui size, float C );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_maxdevC( var h_RetVal:Single; d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_maxdevC( d_RetVal:PSingle; d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function VFcu_maxdevC( h_X:fVector; size:UIntSize; C:Single ): Single;
BeschreibungmaxdevC = max( |Xi - C| )
Fehlerbehandlungkeine
RückgabewertMaximale betragsmäßige Abweichung
QuerverweisVF_maxreldevC,   VF_maxdevV,   VF_sumdevC,   VF_sqdevC,   VF_avdevC

 

VF_maxdevVVD_maxdevVVE_maxdevV
FunktionMaximale Abweichung (als Absolutwert) einer Verteilung von einer anderen
Syntax C/C++#include <VFstd.h>
float VF_maxdevV( fVector X, fVector Y, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::maxdevV( const vector<T>& Y );
Pascal/Delphiuses VFstd;
function VF_maxdevV( X, Y:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_maxdevV( float *h_RetVal, fVector X, fVector Y, ui size );
int cusdVF_maxdevV( float *d_RetVal, fVector X, fVector Y, ui size );
float VFcu_maxdevV( fVector h_X, fVector h_Y, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_maxdevV( var h_RetVal:Single; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cusdVF_maxdevV( d_RetVal:PSingle; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function VFcu_maxdevV( h_X, h_Y:fVector; size:UIntSize ): Single;
BeschreibungmaxdevV = max( |Xi - Yi| )
Fehlerbehandlungkeine
RückgabewertMaximale betragsmäßige Abweichung
QuerverweisVF_maxreldevV,   VF_maxdevC,   VF_sumdevV,   VF_avdevV,   VF_ssqdevV

 

VF_maxexpVD_maxexpVE_maxexp
Funktiongrößter Exponent innerhalb eines Vektors
Syntax C/C++#include <VFstd.h>
int VF_maxexp( fVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::_maxexp();
Pascal/Delphiuses VFstd;
function VF_maxexp( X:fVector; size:UIntSize ): Integer;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_maxexp( int *h_RetVal, fVector d_X, ui size );
int cusdVF_maxexp( int *d_RetVal, fVector d_X, ui size );
int VFcu_maxexp( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_maxexp( var h_RetVal:Integer; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_maxexp( d_RetVal:PInteger; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_maxexp( h_X:fVector; size:UIntSize ): Integer;
BeschreibungUnter Berücksichtigung der Tatsache, dass jede Zahl als Produkt Mantisse * 2exponent geschrieben werden kann, wobei 1.0 ≤ Mantisse < 2.0, wird der größte in X vorkommende Exponent gesucht und zurückgegeben. Falls sämtliche Elemente von X gleich 0 sind, wird -231 (32-bit-Modelle) bzw. -215 (16-bit-Modelle) zurückgegeben.
Fehlerbehandlungkeine
RückgabewertMaximaler Exponent
QuerverweisVF_minexp,   VF_max,   VF_absmax,   VF_runmax,   VF_maxind

 

VF_maxindVD_maxindVE_maxind
VI_maxindVBI_maxindVSI_maxindVLI_maxindVQI_maxind 
VU_maxindVUB_maxindVUS_maxindVUL_maxindVUQ_maxindVUI_maxind
Funktiongrößtes Element eines Vektors und sein Index
Syntax C/C++#include <VFstd.h>
float VF_maxind( ui *Ind, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::maxind( ui *Ind );
Pascal/Delphiuses VFstd;
function VF_maxind( var Ind:UIntSize; X:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_maxind( float *h_RetVal, ui *h_Ind, fVector d_X, ui size );
int cusdVF_maxind( float *d_RetVal, ui *h_Ind, fVector d_X, ui size );
float VFcu_maxind( ui *h_Ind, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_maxind( var h_RetVal:Single; var h_Ind:UIntSize; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_maxind( d_RetVal:PSingle; var h_Ind:UIntSize; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_maxind( var h_Ind:UIntSize; h_X:fVector; size:UIntSize ): Single;
Beschreibung Der größte auftretende Wert wird gefunden und zurückgegeben. Sein Index wird an der durch Ind bezeichneten Adresse gespeichert. Im Falle wiederholten Auftretens desselben Maximalwertes wird der Index des ersten Auftretens gewählt.
Fehlerbehandlungkeine
Rückgabewertgefundenes Maximum
QuerverweisVF_max,   VF_minind,   VF_absmax,   VF_runmax

 

VF_maxinddevCVD_maxinddevCVE_maxinddevC
FunktionMaximum der Abweichungs-Beträge von einem Sollwert und der Index dieses Maximums
Syntax C/C++#include <VFstd.h>
float VF_maxinddevC( ui *Ind, fVector X, ui size, float C );
C++ VecObj#include <OptiVec.h>
T vector<T>::maxinddevC( ui *Ind, const T& C );
Pascal/Delphiuses VFstd;
function VF_maxinddevC( var Ind:UIntSize; X:fVector; size:UIntSize; C:Single ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_maxinddevC( float *h_RetVal, ui *h_Ind, fVector d_X, ui size, float C );
int cusdVF_maxinddevC( float *d_RetVal, ui *h_Ind, fVector d_X, ui size, float *d_C );
float VFcu_maxinddevC( ui *Ind, fVector h_X, ui size, float C );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_maxinddevC( var h_RetVal:Single; var h_Ind:UIntSize; d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_maxinddevC( d_RetVal:PSingle; var h_Ind:UIntSize; d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function VFcu_maxinddevC( var Ind:UIntSize; h_X:fVector; size:UIntSize; C:Single ): Single;
BeschreibungmaxdevC = max( |Xi - C| )
Die maximale gefundene Abweichung wird zurückgegeben und ihr Index i an der als Parameter übernommenen Adresse ind gespeichert.
Fehlerbehandlungkeine
RückgabewertMaximale betragsmäßige Abweichung
QuerverweisVF_maxreldevC,   VF_maxinddevV,   VF_sumdevC,   VF_sqdevC,   VF_avdevC

 

VF_maxinddevVVD_maxinddevVVE_maxinddevV
FunktionMaximaler Abweichungs-Betrag einer Verteilung von einer anderen und der Index dieses Maximums
Syntax C/C++#include <VFstd.h>
float VF_maxinddevV( ui *Ind, fVector X, fVector Y, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::maxinddevV( ui *Ind, const vector<T>& Y );
Pascal/Delphiuses VFstd;
function VF_maxinddevV( var Ind:UIntSize; X, Y:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_maxinddevV( float *h_RetVal, ui *h_Ind, fVector X, fVector Y, ui size );
int cusdVF_maxinddevV( float *d_RetVal, ui *h_Ind, fVector X, fVector Y, ui size );
float VFcu_maxinddevV( ui *h_Ind, fVector h_X, fVector h_Y, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_maxinddevV( var h_RetVal:Single; var h_Ind:UIntSize; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cusdVF_maxinddevV( d_RetVal:PSingle; var h_Ind:UIntSize; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function VFcu_maxinddevV( var Ind:UIntSize; h_X, h_Y:fVector; size:UIntSize ): Single;
BeschreibungmaxdevV = max( |Xi - Yi| )
Die maximale gefundene Abweichung wird zurückgegeben und ihr Index i an der als Parameter übernommenen Adresse ind gespeichert.
Fehlerbehandlungkeine
RückgabewertMaximale betragsmäßige Abweichung
QuerverweisVF_maxreldevV,   VF_maxinddevC,   VF_sumdevV,   VF_avdevV,   VF_ssqdevV

 

VF_maxindreldevCVD_maxindreldevCVE_maxindreldevC
FunktionMaximum der normierten Abweichung von einem Sollwert und der Index dieses Maximums
Syntax C/C++#include <VFstd.h>
float VF_maxindreldevC( ui *Ind, fVector X, ui size, float C );
C++ VecObj#include <OptiVec.h>
T vector<T>::maxindreldevC( ui *Ind, const T& C );
Pascal/Delphiuses VFstd;
function VF_maxindreldevC( var Ind:UIntSize; X:fVector; size:UIntSize; C:Single ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_maxindreldevC( float *h_RetVal, ui *h_Ind, fVector d_X, ui size, float C );
int cusdVF_maxindreldevC( float *d_RetVal, ui *h_Ind, fVector d_X, ui size, float *d_C );
float VFcu_maxindreldevC( ui *Ind, fVector h_X, ui size, float C );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_maxindreldevC( var h_RetVal:Single; var h_Ind:UIntSize; d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_maxindreldevC( d_RetVal:PSingle; var h_Ind:UIntSize; d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function VFcu_maxindreldevC( var Ind:UIntSize; h_X:fVector; size:UIntSize; C:Single ): Single;
BeschreibungmaxreldevC = max( |Xi - C|  /  |C| )
Die maximale gefundene relative Abweichung wird zurückgegeben und ihr Index i an der als Parameter übernommenen Adresse ind gespeichert.
Fehlerbehandlungkeine
RückgabewertMaximale relative Abweichung
QuerverweisVF_maxreldevC,   VF_maxindreldevV,   VF_sumdevC,   VF_sqdevC,   VF_avdevC

 

VF_maxindreldevVVD_maxindreldevVVE_maxindreldevV
FunktionMaximale relative (normierte) Abweichung einer Verteilung von einer anderen und der Index dieses Maximums
Syntax C/C++#include <VFstd.h>
float VF_maxindreldevV( ui *Ind, fVector X, fVector Y, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::maxindreldevV( ui *Ind, const vector<T>& Y );
Pascal/Delphiuses VFstd;
function VF_maxindreldevV( var Ind:UIntSize; X, Y:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_maxindreldevV( float *h_RetVal, ui *h_Ind, fVector X, fVector Y, ui size );
int cusdVF_maxindreldevV( float *d_RetVal, ui *h_Ind, fVector X, fVector Y, ui size );
float VFcu_maxindreldevV( ui *h_Ind, fVector h_X, fVector h_Y, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_maxindreldevV( var h_RetVal:Single; var h_Ind:UIntSize; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cusdVF_maxindreldevV( d_RetVal:PSingle; var h_Ind:UIntSize; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function VFcu_maxindreldevV( var Ind:UIntSize; h_X, h_Y:fVector; size:UIntSize ): Single;
BeschreibungmaxreldevV = max( |Xi - Yi|  /  max(|Xi|, |Yi|) )
Die relative Abweichung wird definiert als die Differenz jeweils korrespondierender Vektor-Elemente, normiert durch den größeren der beiden beteiligten Werte (jeweils als Absolutwert). Das gefundene Maximum der relativen Abweichung wird zurückgegeben und der Index i dieses Maximums an der als Parameter übernommenen Adresse ind gespeichert.
Fehlerbehandlungkeine
RückgabewertMaximale relative Abweichung
QuerverweisVF_maxreldevV,   VF_maxindreldevC,   VF_sumdevV,   VF_avdevV,   VF_ssqdevV

 

VCF_maxReImVCD_maxReImVCE_maxReIm
FunktionGetrennte Bestimmung des größten auftretenden Wertes von Real- und Imaginärteil cartesisch-komplexer Vektoren
Syntax C/C++#include <VFmath.h>
fComplex VCF_maxReIm( cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
complex<T> vector<complex<T>>::maxReIm();
Pascal/Delphiuses VCFstd;
function VCF_maxReIm( X:cfVector; size:UIntSize ):fComplex;

Alternative Syntax (veraltet, aber weiterhin unterstützt):
procedure VCF_maxReIm( var RetVal:fComplex; X:cfVector; size:UIntSize );

    (analog VCD_,   VCE_)
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVCF_maxReIm( fComplex *h_RetVal, cfVector d_X, ui size );
int cusdVCF_maxReIm( fComplex *d_RetVal, cfVector d_X, ui size );
fComplex VCFcu_maxReIm( cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVCF_maxReIm( var h_RetVal:fComplex; d_X:cfVector; size:UIntSize ): IntBool;
function cusdVCF_maxReIm( d_RetVal:PfComplex; d_X:cfVector; size:UIntSize ): IntBool;
function VCFcu_maxReIm( h_X:cfVector; size:UIntSize ):fComplex;
BeschreibungDer größte innerhalb aller Realteile auftretende Wert sowie der größte innerhalb aller Imaginärteile auftretende Wert werden getrennt voneinander bestimmt. Diese werden als eine komplexe Zahl zusammengefaßt und entweder als fComplex zurückgegeben (in C/C++) oder in der Variablen Max gespeichert (in Pascal/Delphi):
Max.Re: größter gefundener Realteil,
Max.Im: größter gefundener Imaginärteil
Fehlerbehandlungkeine
RückgabewertC/C++:
struct oder class-Instanz vom Typ fComplex (bzw. dComplex, eComplex), in dem die Maxima der Real- und Imaginärteile von X zusammengefaßt sind.
Pascal/Delphi:
Da Pascal die Rückgabe von als records definierten komplexen Zahlen nicht zuläßt, wird das Ergebnis nicht zurückgegeben, sondern in der Variablen Max gespeichert.
QuerverweisVCF_minReIm,   VCF_absmaxReIm,   VCF_absmax,   VCF_absmaxind

 

VF_maxreldevCVD_maxreldevCVE_maxreldevC
FunktionGrößte Abweichung zwischen den Elementen eines Vektors und einem Sollwert, genormt durch den Sollwert.
Syntax C/C++#include <VFstd.h>
float VF_maxreldevC( fVector X, ui size, float C );
C++ VecObj#include <OptiVec.h>
T vector<T>::maxreldevC(const T& C);
Pascal/Delphiuses VFstd;
function VF_maxreldevC( X:fVector; size:UIntSize; C:Single ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_maxreldevC( float *h_RetVal, fVector d_X, ui size, float C );
int cusdVF_maxreldevC( float *d_RetVal, fVector d_X, ui size, float *d_C );
float VFcu_maxreldevC( fVector h_X, ui size, float C );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_maxreldevC( var h_RetVal:Single; d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_maxreldevC( d_RetVal:PSingle; d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function VFcu_maxreldevC( h_X:fVector; size:UIntSize; C:Single ): Single;
BeschreibungDie relative Abweichung (in Absolutwerten) jedes Elementes des Vektors X vom Sollwert C wird berechnet als
reldev = |Xi − C|  /  |C|
und das größte gefundene reldev wird zurückgegeben.

Der Sollwert C=0 ist nicht zulässig, da er zu einer Divion durch 0 führen würde.

Fehlerbehandlungkeine
Rückgabewertmaximale relative Abweichung.
QuerverweisVF_maxreldevV,   VF_maxdevC,   VF_maxindreldevC,   VF_reldevC

 

VF_maxreldevVVD_maxreldevVVE_maxreldevV
FunktionGrößte relative Abweichung zwischen den korrespondierenden Elementen zweier Vektoren.
Syntax C/C++#include <VFstd.h>
float VF_maxreldevV( fVector X, fVector Y, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::maxreldevV( const vector<T>& Y );
Pascal/Delphiuses VFstd;
function VF_maxreldevV( X, Y:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_maxreldevV( float *h_RetVal, fVector X, fVector Y, ui size );
int cusdVF_maxreldevV( float *d_RetVal, fVector X, fVector Y, ui size );
float VFcu_maxreldevV( fVector h_X, fVector h_Y, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_maxreldevV( var h_RetVal:Single; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cusdVF_maxreldevV( d_RetVal:PSingle; d_X, d_Y:fVector; size:UIntSize ): IntBool;
function VFcu_avdevC( h_X, h_Y:fVector; size:UIntSize ): Single;
BeschreibungDie relative Abweichung (als Absolutwert) zwischen korrespondierenden Elementen der Vektoren X und Y wird berechnet als
reldev = |Xi − Xi |  /  max( |Xi|, |Yi| )
und der größte gefundene Wert von reldev wird zurückgegeben. Falls sowohl Xi als auch Yi gleich 0 sind, wird reldev ebenfalls als 0 genommen (wodurch eine undefinierte 0/0-Situation aufgelöst wird).
Fehlerbehandlungkeine
Rückgabewertmaximale relative Abweichung.
QuerverweisVF_maxreldevC,   VF_maxdevV,,   VF_maxindreldevC,   VF_reldevC

 

VF_maxVVD_maxVVE_maxV
VI_maxVVBI_maxVVSI_maxVVLI_maxVVQI_maxV 
VU_maxVVUB_maxVVUS_maxVVUL_maxVVUQ_maxVVUI_maxV
FunktionJedes Element eines Vektors mit dem korrespondierenden Element eines anderen Vektors vergleichen und den größeren dieser beiden Werte auswählen
Syntax C/C++#include <VFmath.h>
void VF_maxV( fVector Z, fVector X, fVector Y, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::maxV( const vector<T>& X, const vector<T>& Y );
Pascal/Delphiuses VFmath;
procedure VF_maxV( Z, X, Y:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_maxV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
void VFcu_maxV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_maxV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
procedure VFcu_maxV( h_Z, h_X, h_Y:fVector; size:UIntSize );
BeschreibungZi = Xi, wenn Xi > Yi
Zi = Yi, wenn Xi ≤ Yi
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_minV,   VF_maxC,   VF_max,   VF_absmax

 

VF_meanVD_meanVE_mean
VCF_meanVCD_meanVCE_mean
VI_meanVBI_meanVSI_meanVLI_meanVQI_mean 
VU_meanVUB_meanVUS_meanVUL_meanVUQ_meanVUI_mean
FunktionMittelwert einer eindimensionalen Verteilung
Syntax C/C++#include <VFstd.h>
float VF_mean( fVector X, ui size );

    (analog VD_,   VE_,   VCF_,   VCD_,   VCE_)
double VI_mean( iVector X, ui size );
    (analog VBI_,   VSI_,   VLI_,   VU_,   VUB_,   VUS_,   VUL_,   VUI_)
extended VQI_mean( qiVector X, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::mean();
double vector<int>::mean();
extended vector<quad>::mean();
Pascal/Delphiuses VFstd;
function VF_mean( X:fVector; size:UIntSize ): Single;

    (analog VD_,   VE_)
procedure VCF_mean( var Mean:fComplex; X:cfVector; size:UIntSize );
    (analog VCD_,   VCE_)
function VI_mean( X:iVector; size:UIntSize ); Double;
    (analog VBI_,   VSI_,   VLI_,   VU_,   VUB_,   VUS_,   VUL_)
function VQI_mean( X:qiVector; size:UIntSize ); Extended;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_mean( float *h_RetVal, fVector d_X, ui size );
int cusdVF_mean( float *d_RetVal, fVector d_X, ui size );
float VFcu_mean( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_mean( var h_RetVal:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_mean( d_RetVal:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_mean( h_X:fVector; size:UIntSize ): Single;
Beschreibungmean = (1 / size) * Summe( Xi )
Ganzzahl-Versionen: Der Mittelwert einer aus ganzen Zahlen bestehenden Verteilung ist grundsätzlich eine rationale, also eine Fließkomma-Zahl. Daher ist der Rückgabewert bei den 8, 16 und 32-bit-Ganzzahl-Versionen eine double und bei der 64-bit-Ganzzahl-Version VQI_mean eine extended.
Fehlerbehandlungkeine
Rückgabewertgefundener Mittelwert (außer komplexen Versionen in Pascal/Delphi)
QuerverweisVF_meanwW,   VF_selected_mean,   VF_meanabs,   VF_median,   VF_meanvar,   VF_min_max_mean_stddev,   VI_fsum,   VF_varianceC,   VF_linregress

 

VF_meanabsVD_meanabsVE_meanabs
FunktionBetrags-Mittelwert einer eindimensionalen Verteilung
Syntax C/C++#include <VFstd.h>
float VF_meanabs( fVector X, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::meanabs();
Pascal/Delphiuses VFstd;
function VF_meanabs( X:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_meanabs( float *h_RetVal, fVector d_X, ui size );
int cusdVF_meanabs( float *d_RetVal, fVector d_X, ui size );
float VFcu_meanabs( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_meanabs( var h_RetVal:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_meanabs( d_RetVal:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_meanabs( h_X:fVector; size:UIntSize ): Single;
Beschreibungmeanabs = (1 / size) * Summe(| Xi |)
Fehlerbehandlungkeine
Rückgabewertgefundener Betrags-Mittelwert
QuerverweisVF_mean,   VF_selected_mean,  VF_sumabs

 

VF_meanvarVD_meanvarVE_meanvar
FunktionMittelwert und Varianz einer eindimensionalen Verteilung
Syntax C/C++#include <VFstd.h>
float VF_meanvar( float *Var, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::meanvar( T *Var );
Pascal/Delphiuses VFstd;
function VF_meanvar( var Variance:Single; X:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_meanvar( float *h_RetValMean, float *h_RetValVariance, fVector d_X, ui size );
int cusdVF_meanvar( float *d_RetValMean, float *d_RetValVariance, fVector d_X, ui size );
float VFcu_meanvar( float *h_RetValVariance, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_meanvar( var h_RetValMean, h_RetValVariance:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_meanvar( d_RetValMean, d_RetValVariance:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_meanvar( h_X:fVector; size:UIntSize ): Single;
Beschreibungmean = (1 / size) * Summe( Xi )
var = (1 / (size−1)) * Summe( (Xi - mean)2 )
Man beachte, dass der Nenner in der Definition von var nicht - wie bei VF_varianceC - size, sondern size−1 ist. Der Grund dafür ist, dass hier der Mittelwert zuerst berechnet und die Varianz auf ihn bezogen wird. Dagegen wird der Parameter C in VF_varianceC als vorher bekannter Soll-Wert interpretiert.
Der Mittelwert wird zurückgegeben und die Varianz in C/C++ an der Adresse Var bzw. in Pascal/Delphi in der Variablen variance gespeichert .
FehlerbehandlungIm Falle von size=1 wird die Standardabweichung (theoretisch: unendlich) auf HUGE_VAL gesetzt.
RückgabewertMittelwert
QuerverweisVF_mean,   VF_min_max_mean_stddev,   VF_varianceC,   VF_varianceV,   VF_sum,   VF_ssq,   VF_ssqdevC,   VF_linregress

 

VF_meanvarwWVD_meanvarwWVE_meanvarwW
FunktionMittelwert und Varianz mit Wichtung der einzelnen Datenpunkte
Syntax C/C++#include <VFmath.h>
float VF_meanvarwW( float *Var, fVector X, fVector Wt, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::meanvarwW( T *Var, const vector<T>& Wt );
Pascal/Delphiuses VFmath;
function VF_meanvarwW( var variance:Single; X, Wt:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_meanvarwW( float *h_RetValMean, float *h_RetValVariance, fVector d_X, fVector d_Wt, ui size );
int cusdVF_meanvarwW( float *d_RetValMean, float *d_RetValVariance, fVector d_X, fVector d_Wt, ui size );
float VFcu_meanvarwW( float *h_RetValVariance, fVector h_X, fVector h_Wt, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_meanvarwW( var h_RetValMean, h_RetValVariance:Single; d_X, d_Wt:fVector; size:UIntSize ): IntBool;
function cusdVF_meanvarwW( d_RetValMean, d_RetValVariance:PSingle; d_X, d_Wt:fVector; size:UIntSize ): IntBool;
function VFcu_meanvarwW( h_X, h_Wt:fVector; size:UIntSize ): Single;
Beschreibungmean = (1 / Summe( Wti )) * Summe( Xi * Wti )
var = (1 / Summe( Wti )) * Summe( Wti * (Xi - mean)2 )
Der gewichtete Mittelwert wird zurückgegeben und die Varianz an der Adresse Var (C/C++) bzw. in der Variablen variance (Pascal/Delphi) gespeichert.
Fehlerbehandlungkeine
Rückgabewertgewichtetes Mittel
QuerverweisVF_meanwW,   VF_varianceCwW,   VF_varianceVwW,   VF_linregress

 

VF_meanwWVD_meanwWVE_meanwW
VCF_meanwWVCD_meanwWVCE_meanwW
Funktiongewichteter Mittelwert
Syntax C/C++#include <VFstd.h>
float VF_meanwW( fVector X, fVector Wt, ui size );

    (analog VD_,   VE_)
fComplex VCF_meanwW( cfVector X, fVector Wt, ui size );
    (analog VCD_,   VCE_)
C++ VecObj#include <OptiVec.h>
T vector<T>::meanwW( const vector<T>& Wt );
fComplex vector<complex<T>>::meanwW( const vector<T>& Wt );
Pascal/Delphiuses VFstd;
function VF_meanwW( X, Wt:fVector; size:UIntSize ): Single;

    (analog VD_,   VE_)
procedure VCF_meanwW( var Mean:fComplex; X:cfVector; Wt:fVector; size:UIntSize );
    (analog VCD_,   VCE_)
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_meanwW( float *h_RetVal, fVector d_X, fVector d_Wt, ui size );
int cusdVF_meanwW( float *d_RetVal, fVector d_X, fVector d_Wt, ui size );
float VFcu_meanwW( fVector h_X, fVector h_Wt, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_meanwW( var h_RetVal:Single; d_X, d_Wt:fVector; size:UIntSize ): IntBool;
function cusdVF_meanwW( d_RetVal:PSingle; d_X, d_Wt:fVector; size:UIntSize ): IntBool;
function VFcu_meanwW( h_X, h_Wt:fVector; size:UIntSize ): Single;
BeschreibungmeanwW = (1 / Summe( Wti )) * Summe( Xi * Wti )
Man beachte, dass die Gewichte immer reell sind, auch in den komplexen Versionen.
Fehlerbehandlungkeine
Rückgabewertgewichtetes Mittel (außer komplexe Varianten in Pascal/Delphi).
QuerverweisVF_mean,   VF_selected_mean,  VF_sum,   VF_ssq,   VF_ssqdevC,   VF_median,   VF_meanvarwW,   VF_linregresswW

 

VF_medianVD_medianVE_median
VI_medianVBI_medianVSI_medianVLI_medianVQI_median 
VU_medianVUB_medianVUS_medianVUL_medianVUQ_medianVUI_median
FunktionMedian einer eindimensionalen Verteilung
Syntax C/C++#include <VFmath.h>
float  VF_median( fVector X, ui size );
double VD_median( dVector X, ui size );
float  VBI_median( biVector X, ui size );
float  VUB_median( ubVector X, ui size );
float  VSI_median( siVector X, ui size );
float  VUS_median( usVector X, ui size );
double VI_median( iVector X, ui size );
double VU_median( uVector X, ui size );
extended VQI_median( qiVector X, ui size );
extended VUQ_median( uqVector X, ui size );

Für Windows (long = dword-Ganzzahlen):
double VLI_median( liVector X, ui size );
double VUL_median( ulVector X, ui size );

Für Linux (long = qword-Ganzzahlen):
extended VLI_median( liVector X, ui size );
extended VUL_median( ulVector X, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::median(); // floating-point variants
float vector<T>::median(); // byte- and word-sized integer variants
double vector<T>::median(); // dword-sized integer variants
extended vector<T>::median(); // qword-sized integer variants
Pascal/Delphiuses VFmath;
function VF_median( X:fVector; size:UIntSize ): Single;
function VD_median( X:dVector; size:UIntSize ): Double;
function VBI_median( X:biVector; size:UIntSize ): Single;
function VUB_median( X:ubVector; size:UIntSize ): Single;
function VSI_median( X:siVector; size:UIntSize ): Single;
function VUS_median( X:usVector; size:UIntSize ): Single;
function VI_median( X:iVector; size:UIntSize ): Double;
function VU_median( X:uVector; size:UIntSize ): Double;
function VQI_median( X:qiVector; size:UIntSize ): Extended;
function VUQ_median( X:uqVector; size:UIntSize ): Extended;

Für Windows (long = dword-Ganzzahlen):
function VLI_median( X:liVector; size:UIntSize ): Double;
function VUL_median( X:ulVector; size:UIntSize ): Double;

Für Linux (long = qword-Ganzzahlen):
function VLI_median( X:liVector; size:UIntSize ): Extended;
function VUL_median( X:ulVector; size:UIntSize ): Extended;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_median( float *h_RetVal, fVector d_X, ui size );
int cusdVF_median( float *d_RetVal, fVector d_X, ui size );
float VFcu_median( fVector h_X, ui size );
 
int cudaVBI_median( float *h_RetVal, biVector d_X, ui size );
int cusdVBI_median( float *d_RetVal, biVector d_X, ui size );
float VBIcu_median( biVector h_X, ui size );
(analog VUB_, VSI_, VUS_)
 
int cudaVI_median( double *h_RetVal, iVector d_X, ui size );
int cusdVI_median( double *d_RetVal, iVector d_X, ui size );
double VIcu_median( iVector h_X, ui size );
(analog VU_, VLI_, VLU_, VQI_, VUQ_)
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_median( var h_RetVal:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_median( d_RetVal:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_median( h_X:fVector; size:UIntSize ): Single;

function cudaVBI_median( var h_RetVal:Single; d_X:biVector; size:UIntSize ): IntBool;
function cusdVBI_median( d_RetVal:PSingle; d_X:biVector; size:UIntSize ): IntBool;
function VBIcu_median( h_X:biVector; size:UIntSize ): Single;
(analog VUB_, VSI_, VUS_)

function cudaVI_median( var h_RetVal:Double; d_X:iVector; size:UIntSize ): IntBool;
function cusdVI_median( d_RetVal:PDouble; d_X:iVector; size:UIntSize ): IntBool;
function VIcu_median( h_X:iVector; size:UIntSize ): Double;
(analog VU_, VLI_, VLU_, VQI_, VUQ_)
BeschreibungDer Median einer Verteilung ist als derjenige Wert definiert, für den gilt, dass Werte oberhalb von ihm mit gleicher Wahrscheinlichkeit vorkommen wie Werte unterhalb von ihm. Wenn die Tabelle X geordnet ist, ist der Median also das Element mit dem Index (size-1)/2 (wenn size ungerade ist) oder der Mittelwert zwischen den beiden Elementen im Zentrum der Tabelle (wenn size gerade ist). Für nicht-geordnete Tabellen findet VF_median den Median durch mehrfaches Durchsuchen der Tabelle, ohne tatsächlich eine Sortierung vorzunehmen.
Der Rückgabewert der Ganzzahl-Versionen ist immer eine Fließkomma-Zahl, da der Median in der Mitte zwischen zwei Tabellenwerten liegen und also einen Abstand von 0.5 zu dem nächsten Ganzzahl-Wert besitzen kann. Für die 8-byte-Ganzzahl-Versionen (VQI_median und VUQ_median) führt dies allerdings zu einer wichtigen Einschränkung: Ganzzahlen können durch Fließkommazahlen nur bis zu einer bestimmten Grenze exakt dargestellt werden. Für double liegt diese Grenze bei ±253, für extended bei ±263. Deshalb wird der Rückgabewert von VQI_median und VUQ_median nur dann exakt sein, wenn er innerhalb dieser Bereiche liegt.
Fehlerbehandlungkeine
Rückgabewertder gefundene Median
QuerverweisVF_mean,   VF_meanwW,   VF_sum

 

VF_minVD_minVE_min
VI_minVBI_minVSI_minVLI_minVQI_min 
VU_minVUB_minVUS_minVUL_minVUQ_minVUI_min
Funktionkleinstes oder am stärksten negatives Element eines Vektors
Syntax C/C++#include <VFstd.h>
float VF_min( fVector X, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::_min();
Pascal/Delphiuses VFstd;
function VF_min( X:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_min( float *h_RetVal, fVector d_X, ui size );
int cusdVF_min( float *d_RetVal, fVector d_X, ui size );
float VFcu_min( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_min( var h_RetVal:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_min( d_RetVal:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_min( h_X:fVector; size:UIntSize ): Single;
BeschreibungDer Wert des kleinsten (oder am stärksten negativen) in X vorkommenden Elementes wird zurückgegeben. Um in C++ Verwechslungen mit dem macro "min" zu vermeiden, erhält die VecObj-Version dieser Funktion einen führenden Unterstrich und lautet "_min".
Fehlerbehandlungkeine
Rückgabewertgefundenes Minimum
QuerverweisVF_minpos,   VF_absmin,   VF_minmax,   VF_minexp,   VF_runmin,   VF_minind,   VF_min_max_mean_stddev

 

VF_minCVD_minCVE_minC
VI_minCVBI_minCVSI_minCVLI_minCVQI_minC 
VU_minCVUB_minCVUS_minCVUL_minCVUQ_minCVUI_minC
FunktionVergleich jedes Vektorelementes mit einem bestimmten Wert und Auswahl des kleineren dieser beiden Werte
Syntax C/C++#include <VFmath.h>
void VF_minC( fVector Y, fVector X, ui size, float C );
C++ VecObj#include <OptiVec.h>
void vector<T>::minC( const vector<T>& X, const T& C );
Pascal/Delphiuses VFmath;
procedure VF_minC( Y, X:fVector; size:UIntSize; C:Single );
CUDA-Funktion C/C++#include <cudaVFmath.h>
#include <cudaVDmath.h>
int cudaVF_minC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_minC( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_minC( fVector d_Y, fVector d_X, ui size, float C );
CUDA-Funktion Pascal/Delphiuses VFmath, VDmath;
function cudaVF_minC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_minC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VF_minC( Y, X:fVector; size:UIntSize; C:Single );
BeschreibungYi = Xi,  wenn Xi ≤ C
Yi = C,  wenn Xi > C
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_minV,   VF_maxC,   VF_min,   VF_absmin,   VF_limit,   VF_flush0

 

VF_minexpVD_minexpVE_minexp
Funktionkleinster Exponent innerhalb eines Vektors
Syntax C/C++#include <VFstd.h>
int VF_minexp( fVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::_minexp();
Pascal/Delphiuses VFstd;
function VF_minexp( X:fVector; size:UIntSize ): Integer;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_minexp( int *h_RetVal, fVector d_X, ui size );
int cusdVF_minexp( int *d_RetVal, fVector d_X, ui size );
int VFcu_minexp( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_minexp( var h_RetVal:Integer; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_minexp( d_RetVal:PInteger; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_minexp( h_X:fVector; size:UIntSize ): Integer;
BeschreibungUnter Berücksichtigung der Tatsache, dass jede Zahl als Produkt Mantisse * 2exponent geschrieben werden kann, wobei 1.0 ≤ Mantisse < 2.0, wird der kleinste bzw. am stärksten negative in X vorkommende Exponent gesucht und zurückgegeben. Falls das absolut kleinste Element von X gleich 0 ist, wird -231 (32-bit-Modelle) bzw. -215 (16-bit-Modelle) zurückgegeben.
Fehlerbehandlungkeine
RückgabewertMinimaler Exponent
QuerverweisVF_maxexp,   VF_min,   VF_absmin,   VF_runmin,   VF_minind

 

VF_minindVD_minindVE_minind
VI_minindVBI_minindVSI_minindVLI_minindVQI_minind 
VU_minindVUB_minindVUS_minindVUL_minindVUQ_minindVUI_minind
Funktionkleinstes Element eines Vektors und sein Index
Syntax C/C++#include <VFstd.h>
float VF_minind( ui *Ind, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::minind( ui *Ind );
Pascal/Delphiuses VFstd;
function VF_minind( var Ind:UIntSize; X:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_minind( float *h_RetVal, ui *h_Ind, fVector d_X, ui size );
int cusdVF_minind( float *d_RetVal, ui *h_Ind, fVector d_X, ui size );
float VFcu_minind( ui *h_Ind, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_minind( var h_RetVal:Single; var h_Ind:UIntSize; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_minind( d_RetVal:PSingle; var h_Ind:UIntSize; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_minind( var h_Ind:UIntSize; h_X:fVector; size:UIntSize ): Single;
BeschreibungDer kleinste auftretende Wert wird gefunden und zurückgegeben. Sein Index wird an der durch Ind bezeichneten Adresse gespeichert. Im Falle wiederholten Auftretens desselben Minimalwertes wird der Index des ersten Auftretens gewählt.
Fehlerbehandlungkeine
Rückgabewertgefundenes Minimum
QuerverweisVF_min,   VF_maxind,   VF_absmin,   VF_runmin

 

VF_minmaxVD_minmaxVE_minmax
VI_minmaxVBI_minmaxVSI_minmaxVLI_minmaxVQI_minmax 
VU_minmaxVUB_minmaxVUS_minmaxVUL_minmaxVUQ_minmaxVUI_minmax
FunktionMinimum und Maximum einer Verteilung
Syntax C/C++#include <VFstd.h>
float VF_minmax( float *xmax, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::minmax(T *xmax);
Pascal/Delphiuses VFstd;
function VF_minmax( var xmax:Single; X:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_minmax( float *h_xmin, float *h_xmax, fVector d_X, ui size );
int cusdVF_minmax( float *d_xmin, float *d_xmax, fVector d_X, ui size );
float VFcu_minmax( float *xmax, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_minmax( var h_xmin, h_xmax:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_minmax( d_xmin, d_xmax:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_minmax( var h_xmax:Single; h_X:fVector; size:UIntSize ): Single;
BeschreibungDer Wert des kleinsten (oder am stärksten negativen) in X vorkommenden Elementes wird zurückgegeben. Derjenige des größten Elementes wird in xmax/i> gespeichert.
Fehlerbehandlungkeine
Rückgabewertgefundenes Minimum
QuerverweisVF_absminmax,   VF_min,   VF_max,   VF_min_max_mean_stddev

 

VF_min_max_mean_stddevVD_min_max_mean_stddevVE_min_max_mean_stddev
Funktiongleichzeitige Berechnung von Minimum, Maximum, Mittelwert und Standardabweichung einer eindimensionalen Verteilung
Syntax C/C++#include <VFstd.h>
void VF_min_max_mean_stddev( fVector Stats, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::min_max_mean_stddev( vector<T> X );
Pascal/Delphiuses VFstd;
procedure VF_min_max_mean_stddev( Stats, X:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_min_max_mean_stddev( fVector h_Stats, fVector d_X, ui size );
int cusdVF_min_max_mean_stddev( fVector d_Stats, fVector d_X, ui size );
void VFcu_min_max_mean_stddev( fVector h_Stats, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_min_max_mean_stddev( h_Stats, d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_min_max_mean_stddev( d_Stats, d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_min_max_mean_stddev( h_Stats, h_X:fVector; size:UIntSize );
BeschreibungDie vier grundlegenden beschreibenden Statististik-Funktionen werden für eine eindimensionale Verteilung gleichzeitig berechnet und in dem Vector Stats gespeichert:
Stats[0] = Minimum;
Stats[1] = Maximum;
Stats[2] = Mittelwert;
Stats[3] = Standardabweichung;
FehlerbehandlungIm Falle von size=1 wird die Standardabweichung (theoretisch: unendlich) auf HUGE_VAL gesetzt.
Rückgabewertkeiner
QuerverweisVF_min,   VF_max,   VF_minmax,   VF_mean,   VF_meanvar

 

VF_minposVD_minposVE_minpos
VI_minposVBI_minposVSI_minposVLI_minposVQI_minpos 
VU_minposVUB_minposVUS_minposVUL_minposVUQ_minposVUI_minpos
Funktionkleinstes positives Element eines Vektors
Syntax C/C++#include <VFstd.h>
float VF_minpos( fVector X, ui size );
C++ VecObj#include <OptiVec.h>
T vector<T>::minpos();
Pascal/Delphiuses VFstd;
function VF_minpos( X:fVector; size:UIntSize ): Single;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_minpos( float *h_RetVal, fVector d_X, ui size );
int cusdVF_minpos( float *d_RetVal, fVector d_X, ui size );
float VFcu_minpos( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_minpos( var h_RetVal:Single; d_X:fVector; size:UIntSize ): IntBool;
function cusdVF_minpos( d_RetVal:PSingle; d_X:fVector; size:UIntSize ): IntBool;
function VFcu_minpos( h_X:fVector; size:UIntSize ): Single;
BeschreibungDer Wert des kleinsten positiven und nicht-verschwindenden in X vorkommenden Elementes wird zurückgegeben (also das kleinste Xi > 0). Falls überhaupt kein Element größer als 0 ist, wird 0 zurückgegeben.
Fehlerbehandlungkeine
Rückgabewertgefundenes Minimum der positiven Werte
QuerverweisVF_min,   VF_absmin,   VF_minmax,   VF_minexp,   VF_runmin,   VF_minind,   VF_min_max_mean_stddev

 

VCF_minReImVCD_minReImVCE_minReIm
FunktionGetrennte Bestimmung des kleinsten (bzw. am stärksten negativen) Wertes von Real- und Imaginärteil cartesisch-komplexer Vektoren
Syntax C/C++#include <VCFstd.h>
fComplex VCF_minReIm( cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
complex<T> vector<complex<T>>::minReIm();
Pascal/Delphiuses VCFstd;
function VCF_minReIm( X:cfVector; size:UIntSize ):fComplex;

Alternative Syntax (veraltet, aber weiterhin unterstützt):
procedure VCF_minReIm( var RetVal:fComplex; X:cfVector; size:UIntSize );

    (analog VCD_,   VCE_)
CUDA-Funktion C/C++#include <cudaVCFstd.h>
int cudaVCF_minReIm( fComplex *h_RetVal, cfVector d_X, ui size );
int cusdVCF_minReIm( fComplex *d_RetVal, cfVector d_X, ui size );
fComplex VCFcu_minReIm( cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVCF_minReIm( var h_RetVal:fComplex; d_X:cfVector; size:UIntSize ): IntBool;
function cusdVCF_minReIm( d_RetVal:PfComplex; d_X:cfVector; size:UIntSize ): IntBool;
function VCFcu_minReIm( h_X:cfVector; size:UIntSize ):fComplex;
BeschreibungDer kleinste innerhalb aller Realteile auftretende Wert sowie der kleinste innerhalb aller Imaginärteile auftretende Wert werden getrennt voneinander bestimmt. Diese werden als eine komplexe Zahl zusammengefaßt und entweder als fComplex zurückgegeben (in C/C++) oder in der Variablen Min gespeichert (in Pascal/Delphi):
Min.Re: kleinster gefundener Realteil,
Min.Im: kleinster gefundener Imaginärteil
Fehlerbehandlungkeine
RückgabewertC/C++:
struct oder class-Instanz vom Typ fComplex (bzw. dComplex, eComplex), in dem die Minima der Real- und Imaginärteile von X zusammengefaßt sind.
Pascal/Delphi:
Da Pascal die Rückgabe von als records definierten komplexen Zahlen nicht zuläßt, wird das Ergebnis nicht zurückgegeben, sondern in der Variablen Min gespeichert.
QuerverweisVCF_maxReIm,   VCF_absminReIm,   VCF_absmin,   VCF_absminind

 

VF_minVVD_minVVE_minV
VI_minVVBI_minVVSI_minVVLI_minVVQI_minV 
VU_minVVUB_minVVUS_minVVUL_minVVUQ_minVVUI_minV
FunktionJedes Element eines Vektors mit dem korrespondierenden Element eines anderen Vektors vergleichen und den kleineren (bzw. am stärksten negativen) dieser beiden Werte auswählen
Syntax C/C++#include <VFmath.h>
void VF_minV( fVector Z, fVector X, fVector Y, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::minV( const vector<T>& X, const vector<T>& Y );
Pascal/Delphiuses VFstd;
procedure VF_minV( Z, X, Y:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_minV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
void VFcu_minV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_minV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
procedure VFcu_minV( h_Z, h_X, h_Y:fVector; size:UIntSize );
BeschreibungZi = Xi,  wenn Xi ≤ Yi
Zi = Yi,  wenn Xi > Yi
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_maxV,   VF_minC,   VF_min,   VF_absmin

 

VF_modCVD_modCVE_modC
VI_modCVBI_modCVSI_modCVLI_modCVQI_modC 
VU_modCVUB_modCVUS_modCVUL_modCVUQ_modCVUI_modC
FunktionRest der Division durch eine Konstante
Syntax C/C++#include <VFmath.h>
void VF_modC( fVector Y, fVector X, ui size, float C );
C++ VecObj#include <OptiVec.h>
void vector<T>::modC( const vector<T>& X, const T& C );
Pascal/Delphiuses VFmath;
procedure VF_modC( Y, X:fVector; size:UIntSize; C:Single );
CUDA-Funktion C/C++#include <cudaVFmath.h>
#include <cudaVDmath.h>
int cudaVF_modC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_modC( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_modC( fVector d_Y, fVector d_X, ui size, float C );
CUDA-Funktion Pascal/Delphiuses VFmath, VDmath;
function cudaVF_modC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_modC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VF_modC( Y, X:fVector; size:UIntSize; C:Single );
BeschreibungYi = Xi mod C
Fließkomma-Versionen: Eine Konstante C = 0.0 führt dazu, dass alle Yi gleich 0.0 werden, unabhängig von den Xi-Werten (genau wie in der ANSI−C-Funktion fmod).
Ganzzahl-Versionen: Eine Konstante C = 0 führt zu einem ZERODIVIDE-Fehler (wie in der "%"-Operation von ANSI−C).
Fehlerbehandlungkeine
Rückgabewertkeiner (auch die Fließkomma-Versionen werden als arithmetische Grundfunktionen behandelt und nicht als mathematische Funktionen mit Fehlerbehandlung, trotz ihrer Verwandschaft zur mathematischen Funktion fmod)
QuerverweisVF_modV,   VF_addC,   VF_mulC,   VF_divC,   VF_visC,   VF_redC

 

VF_modfVD_modfVE_modf
FunktionAufspaltung in Ganzzahl- und Nachkomma-Teil
Syntax C/C++#include <VFmath.h>
int VF_modf( fVector IntPart, fVector FracPart, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::modf( vector<T> FracPart, const vector<T>& X );
Pascal/DelphiDiese Funktionen sind nicht für Pascal/Delphi definiert. Man benutze VF_intfrac etc.
BeschreibungDiese Funktionen sind als Synonyme für VF_intfrac etc. definiert, um Konsistenz mit dem in ANSI−C definierten Funktionsnamen modf zu wahren. Siehe unter VF_intfrac.

 

VF_modVVD_modVVE_modV
VFx_modVVDx_modVVEx_modV
VI_modVVBI_modVVSI_modVVLI_modVVQI_modV 
VU_modVVUB_modVVUS_modVVUL_modVVUQ_modVVUI_modV
FunktionRest der Division korrespondierender Vektor-Elemente
Syntax C/C++#include <VFmath.h>
void VF_modV( fVector Z, fVector X, fVector Y, ui size );
void VFx_modV( fVector Z, fVector X, fVector Y, ui size, float A, float B );
C++ VecObj#include <OptiVec.h>
void vector<T>::modV( const vector<T>& X, const vector<T>& Y );
void vector<T>::x_modV( const vector<T>& X, const vector<T>& Y, const T& A, const T& B );
Pascal/Delphiuses VFmath;
procedure VF_modV( Z, X, Y:fVector; size:UIntSize );
procedure VFx_modV( Z, X, Y:fVector; size:UIntSize; A, B:Single );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_modV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
int cudaVFx_modV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float A, float B );
int cusdVFx_modV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_A, float *d_B );
void VFcu_modV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
void VFxcu_modV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float A, float B );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_modV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cudaVFx_modV( d_Z, d_X, d_Y:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_modV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
procedure VFcu_modV( h_Z, h_X, h_Y:fVector; size:UIntSize );
procedure VFxcu_modV( h_Z, h_X, h_Y:fVector; size:UIntSize; A, B:Single );
Beschreibungeinfache Versionen: Zi = Xi mod Yi
erweiterte Versionen: Zi = (A * Xi + B) mod Yi
Fließkomma-Versionen: Ein Argument Xi = 0.0 führt zu Zi gleich 0.0, unabhängig von Yi (wie in der ANSI−C- Funktion fmod).
Ganzzahl-Versionen: Ein Argument Xi = 0 führt zu einem ZERODIVIDE-Fehler (wie bei der "%"-Operation von ANSI−C).
Fehlerbehandlungkeine
Rückgabewertkeiner (auch die Fließkomma-Versionen werden als arithmetische Grundfunktionen behandelt und nicht als mathematische Funktionen mit Fehlerbehandlung, trotz ihrer Verwandschaft zur mathematischen Funktion fmod).
QuerverweisVF_modC,   VF_addV,   VF_mulV,   VF_divV,   VF_visV,   VF_redV

 

VF_mulCVD_mulCVE_mulC
VCF_mulCVCD_mulCVCE_mulC
VCF_mulReCVCD_mulReCVCE_mulReC
VPF_mulCVPD_mulCVPE_mulC
VPF_mulReCVPD_mulReCVPE_mulReC
VI_mulCVBI_mulCVSI_mulCVLI_mulCVQI_mulC 
VU_mulCVUB_mulCVUS_mulCVUL_mulCVUQ_mulCVUI_mulC
FunktionMultiplikation mit einer Konstanten
Syntax C/C++#include <VFmath.h>
void VF_mulC( fVector Y, fVector X, ui size, float C );

    (analog VD_,   VE_,   VI_, etc.)
void VCF_mulC( cfVector Y, cfVector X, ui size, fComplex C );
void VCF_mulReC( cfVector Y, cfVector X, ui size, float CRe );

    (analog VCD_,   VCE_,   VPF_,   VPD_,   VPE_)
C++ VecObj#include <OptiVec.h>
void vector<T>::mulC( const vector<T>& X, const T& C );
void vector<complex<T>>::mulC( const vector<complex<T>>& X, complex<T> C );
void vector<complex<T>>::mulReC( const vector<complex<T>>& X, const T& CRe );
Pascal/Delphiuses VFmath;
procedure VF_mulC( Y, X:fVector; size:UIntSize; C:Single );
procedure VCF_mulC( Y, X:cfVector; size:UIntSize; C:fComplex );
procedure VCF_mulReC( Y, X:cfVector; size:UIntSize; CRe:Single );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_mulC( fVector d_Y, fVector d_X, ui size, float C );
int cusdVF_mulC( fVector d_Y, fVector d_X, ui size, float *d_C );
void VFcu_mulC( fVector d_Y, fVector d_X, ui size, float C );
#include <cudaVCFmath.h>
int cudaVCF_mulReC( cfVector d_Y, cfVector d_X, ui size, float CRe );
int cusdVCF_mulReC( cfVector d_Y, cfVector d_X, ui size, float *d_CRe );
void VCFcu_mulReC( cfVector h_Y, cfVector h_X, ui size, float CRe );
CUDA-Funktion Pascal/Delphiuses VFmath, VCFmath;
function cudaVF_mulC( d_Y, d_X:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVF_mulC( d_Y, d_X:fVector; size:UIntSize; d_C:PSingle ): IntBool;
procedure VFcu_mulC( h_Y, h_X:fVector; size:UIntSize; C:Single );
function cudaVCF_mulReC( d_Y, d_X:cfVector; size:UIntSize; CRe:Single );
function cusdVCF_mulReC( d_Y, d_X:cfVector; size:UIntSize; d_CRe:PSingle );
procedure VCFcu_mulReC( h_Y, h_X:cfVector; size:UIntSize; CRe:Single );
BeschreibungYi = C * Xi
Die komplexen Versionen existieren in zwei Varianten: eine für komplexe Konstanten C, die andere für reelle Konstanten CRe, mit denen der komplexe Vektor multipliziert wird
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_mulV,   VF_addC,   VF_divC,   VF_divrC,   VF_visC,   VF_redC

 

VF_mulVVD_mulVVE_mulV
VCF_mulVVCD_mulVVCE_mulV
VCF_mulReVVCD_mulReVVCE_mulReV
VCF_mulVconjVCD_mulVconjVCE_mulVconj
VFs_mulVVDs_mulVVEs_mulV
VFx_mulVVDx_mulVVEx_mulV
VCFx_mulVVCDx_mulVVCEx_mulV
VCFx_mulReVVCDx_mulReVVCEx_mulReV
VCFx_mulVconjVCDx_mulVconjVCEx_mulVconj
VPF_mulVVPD_mulVVPE_mulV
VPF_mulReVVPD_mulReVVPE_mulReV
VI_mulVVBI_mulVVSI_mulVVLI_mulVVQI_mulV 
VU_mulVVUB_mulVVUS_mulVVUL_mulVVUQ_mulVVUI_mulV
FunktionMultiplikation korrespondierender Vektorelemente
Syntax C/C++#include <VFmath.h>
void VF_mulV( fVector Z, fVector X, fVector Y, ui size );
void VFs_mulV( fVector Z, fVector X, fVector Y, ui size, float C );
void VFx_mulV( fVector Z, fVector X, fVector Y, ui size, float A, float B );
void VCF_mulV( cfVector Z, cfVector X, cfVector Y, ui size );
void VCF_mulReV( cfVector Z, cfVector X, fVector Y, ui size );
void VCF_mulVconj( cfVector Z, cfVector X, cfVector Y, ui size );
void VCFx_mulV( cfVector Z, cfVector X, cfVector Y, ui size, fComplex A, fComplex B );
void VCFx_mulReV( cfVector Z, cfVector X, fVector Y, ui size, fComplex A, fComplex B );
void VCFx_mulVconj( cfVector Z, cfVector X, cfVector Y, ui size, fComplex A, fComplex B );
C++ VecObj#include <OptiVec.h>
void vector<T>::mulV( const vector<T>& X, const vector<T>& Y );
void vector<T>::s_mulV( const vector<T>& X, const vector<T>& Y, const T& C );
void vector<T>::x_mulV( const vector<T>& X, const vector<T>& Y, const T& A, const T& B );
void vector<complex<T>>::mulV( const vector<complex<T>>& X, const vector<complex<T>>& Y );
void vector<complex<T>>::mulReV( const vector<complex<T>>& X, const vector<T>& Y );
void vector<complex<T>>::mulVconj( const vector<complex<T>>& X, const vector<complex<T>>& Y );
void vector<complex<T>>::x_mulV( const vector<complex<T>>& X, const vector<complex<T>>& Y, complex<T> A, complex<T> B );
void vector<complex<T>>::x_mulReV( const vector<complex<T>>& X, const vector<T>& Y, complex<T> A, complex<T> B );
void vector<complex<T>>::x_mulVconj( const vector<complex<T>>& X, const vector<complex<T>>& Y, complex<T> A, complex<T> B );
Pascal/Delphiuses VFmath;
procedure VF_mulV( Z, X, Y:fVector; size:UIntSize );
procedure VFs_mulV( Z, X, Y:fVector; size:UIntSize; C:Single );
procedure VFx_mulV( Z, X, Y:fVector; size:UIntSize; A, B:Single );
procedure VCF_mulV( Z, X, Y:cfVector; size:UIntSize );
procedure VCF_mulReV( Z, X:cfVector; Y:fVector; size:UIntSize );
procedure VCF_mulVconj( Z, X, Y:cfVector; size:UIntSize );
procedure VCFx_mulV( Z, X, Y:cfVector; size:UIntSize; A, B:fComplex );
procedure VCFx_mulReV( Z, X:cfVector; Y:fVector; size:UIntSize; A, B:fComplex );
procedure VCFx_mulVconj( Z, X, Y:cfVector; size:UIntSize; A, B:fComplex );
CUDA-Funktion C/C++#include <cudaVFmath.h>
#include <cudaVCFmath.h>
int cudaVF_mulV( fVector d_Z, fVector d_X, fVector d_Y,ui size );
int cudaVFs_mulV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float C );
int cusdVFs_mulV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_C );
int cudaVFx_mulV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float A, float B );
int cusdVFx_mulV( fVector d_Z, fVector d_X, fVector d_Y, ui size, float *d_A, float *d_B );
int cudaVCF_mulReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size );
int cudaVCF_mulVconj( cfVector d_Z, cfVector d_X, cfVector d_Y, ui size );
int cudaVCFx_mulReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size, fComplex A, fComplex B );
int cusdVCFx_mulReV( cfVector d_Z, cfVector d_X, fVector d_Y, ui size, fComplex *d_A, fComplex *d_B );
int cudaVCFx_mulVconj( cfVector d_Z, cfVector d_X, cfVector d_Y, ui size, fComplex A, fComplex B );
int cusdVCFx_mulVconj( cfVector d_Z, cfVector d_X, cfVector d_Y, ui size, fComplex *d_A, fComplex *d_B );
void VFcu_mulV( fVector h_Z, fVector h_X, fVector h_Y,ui size );
void VFscu_mulV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float C );
void VFxcu_mulV( fVector h_Z, fVector h_X, fVector h_Y, ui size, float A, float B );
void VCFcu_mulReV( cfVector h_Z, cfVector h_X, fVector h_Y, ui size );
void VCFcu_mulVconj( cfVector h_Z, cfVector h_X, cfVector h_Y, ui size );
void VCFxcu_mulV( cfVector h_Z, cfVector h_X, cfVector h_Y, ui size, fComplex A, fComplex B );
void VCFxcu_mulReV( cfVector h_Z, cfVector h_X, fVector h_Y, ui size, fComplex A, fComplex B );
void VCFxcu_mulVconj( cfVector h_Z, cfVector h_X, cfVector h_Y, ui size, fComplex A, fComplex B );
CUDA-Funktion Pascal/Delphiuses VFmath, VCFmath;
function cudaVF_mulV( d_Z, d_X, d_Y:fVector; size:UIntSize ): IntBool;
function cudaVFs_mulV( d_Z, d_X, d_Y:fVector; size:UIntSize; C:Single ): IntBool;
function cusdVFs_mulV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_C:PSingle ): IntBool;
function cudaVFx_mulV( d_Z, d_X, d_Y:fVector; size:UIntSize; A, B:Single ): IntBool;
function cusdVFx_mulV( d_Z, d_X, d_Y:fVector; size:UIntSize; d_A, d_B:PSingle ): IntBool;
function cudaVCF_mulReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize ): IntBool;
function cudaVCF_mulVconj( d_Z, d_X, d_Y:cfVector; size:UIntSize ): IntBool;
function cudaVCFx_mulReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize; A, B:fComplex ): IntBool;
function cusdVCFx_mulReV( d_Z, d_X:cfVector; d_Y:fVector; size:UIntSize; d_A, d_B:PfComplex ): IntBool;
function cudaVCFx_mulVconj( d_Z, d_X, d_Y:cfVector; size:UIntSize; A, B:fComplex ): IntBool;
function cusdVCFx_mulVconj( d_Z, d_X, d_Y:cfVector; size:UIntSize; d_A, d_B:PfComplex ): IntBool;
procedure VFcu_mulV( h_Z, h_X, h_Y:fVector; size:UIntSize );
procedure VFscu_mulV( h_Z, h_X, h_Y:fVector; size:UIntSize; C:Single );
procedure VFxcu_mulV( h_Z, h_X, h_Y:fVector; size:UIntSize; A, B:Single );
procedure VCFcu_mulReV( h_Z, h_X:cfVector; h_Y:fVector; size:UIntSize );
procedure VCFcu_mulVconj( h_Z, h_X, h_Y:cfVector; size:UIntSize );
procedure VCFxcu_mulReV( h_Z, h_X:cfVector; h_Y:fVector; size:UIntSize; A, B:fComplex );
procedure VCFxcu_mulVconj( h_Z, h_X, h_Y:cfVector; size:UIntSize; A, B:fComplex );
Beschreibungeinfache Versionen: Zi = Xi * Yi
skalierte Versionen (VFs_ etc.): Zi = C * (Xi * Yi)
erweiterte Versionen (VFx_ etc.): Zi = (A * Xi + B) * Yi
Die komplexen Fließkomma-Versionen existieren in drei Varianten. In der ersten (z.B. VCF_mulV,   VCFx_mulV) sind X, Y und Z alle komplex; in der zweiten ist Y reell (z.B. VCF_mulReV - "Multiplikation mit einem reellen Vektor"). In der dritten schließlich (z.B. VCF_mulV,   VCFx_mulV) wird X mit der komplex-konjugierten Form von Y statt mit Y selbst multipliziert.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_mulC,   VF_addV,   VF_subV,   VF_divV,   VF_visV,   VF_mulVI

 

VF_mulVIVD_mulVIVE_mulVI
VF_mulVBIVD_mulVBIVE_mulVBI
VF_mulVSIVD_mulVSIVE_mulVSI
VF_mulVLIVD_mulVLIVE_mulVLI
VF_mulVQIVD_mulVQIVE_mulVQI
VF_mulVUVD_mulVUVE_mulVU
VF_mulVUBVD_mulVUBVE_mulVUB
VF_mulVUSVD_mulVUSVE_mulVUS
VF_mulVULVD_mulVULVE_mulVUL
VF_mulVUQVD_mulVUQVE_mulVUQ
VF_mulVUIVD_mulVUIVE_mulVUI
FunktionElement-weise Multiplikation von Fließkomma- mit Ganzzahl-Vektor
Syntax C/C++#include <VFmath.h>
void VF_mulVI( fVector Z, fVector X, iVector Y,ui size );
void VF_mulVUB( fVector Z, fVector X, ubVector Y, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::mulVI( const vector<T>& X, const vector<int>& Y );
void vector<T>::mulVUS( const vector<T>& X, const vector<unsigned short>& Y, );
Pascal/Delphiuses VFmath;
procedure VF_mulVI( Z, X:fVector; Y:iVector; size:UIntSize );
procedure VF_mulVUL( Z, X:fVector; Y:ulVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_mulVI( fVector d_Z, fVector d_X, iVector d_Y,ui size );
int cudaVF_mulVUB( fVector d_Z, fVector d_X, ubVector d_Y, ui size );
void VFcu_mulVI( fVector h_Z, fVector h_X, iVector h_Y,ui size );
void VFcu_mulVUB( fVector h_Z, fVector h_X, ubVector h_Y, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_mulVI( d_Z, d_X:fVector; d_Y:iVector; size:UIntSize ): IntBool;
function cudaVF_mulVUL( d_Z, d_X:fVector; d_Y:ulVector; size:UIntSize ): IntBool;
procedure VFcu_mulVI( h_Z, h_X:fVector; h_Y:iVector; size:UIntSize );
procedure VFcu_mulVUL( h_Z, h_X:fVector; h_Y:ulVector; size:UIntSize );
BeschreibungZi = Xi * Yi
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_mulV,   VF_divVI,   VF_addVI

 

VF_natCubSplineInterpolVD_natCubSplineInterpolVE_natCubSplineInterpol
Funktionnatürliche kubische Spline-Interpolation
Syntax C/C++#include <VFstd.h>
void VF_natCubSplineInterpol( fVector Y, fVector X, ui sizex, fVector XTab, fVector YTab, ui sizetab );
C++ VecObj#include <OptiVec.h>
void vector<T>::natCubSplineInterpol( const vector<T>& X, const vector<T>& XTab, const vector<T>& YTab );
Pascal/Delphiuses VFstd;
procedure VF_natCubSplineInterpol( Y, X:fVector; sizex:UIntSize; XTab, YTab:fVector; sizetab:UIntSize );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_natCubSplineInterpol( fVector d_Y, fVector d_X, ui sizex, fVector d_XTab, fVector d_YTab, ui sizetab );
void VFcu_natCubSplineInterpol( fVector h_Y, fVector h_X, ui sizex, fVector h_XTab, fVector h_YTab, ui sizetab );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_natCubSplineInterpol( d_Y, d_X:fVector; sizex:UIntSize; d_XTab, d_YTab:fVector; sizetab:UIntSize ): IntBool;
procedure VFcu_natCubSplineInterpol( h_Y, h_X:fVector; sizex:UIntSize; h_XTab, h_YTab:fVector; sizetab:UIntSize );
BeschreibungFü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. 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.
Die vorliegende Funktion berechnet die "natürliche" kubische Spline-Interpolation. Für eine allgemeine Form der kubischen Spline-Interpolation mit spezifizierten 2. Ableitungen der YTab-Werte rufe man VF_splineinterpol auf.
sizetab muss mindestens 3 betragen.
Die CUDA-Version dieser Funktion ist vergleichsweise langsam, da sie die CPU zur Berechnung der Ableitungs-Tabelle verwendet muss.
Fehlerbehandlungkeine (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.)
Rückgabewertkeiner
QuerverweisVF_splineinterpol,   VF_ratinterpol,   VF_polyinterpol

 

VF_negVD_negVE_neg
VCF_negVCD_negVCE_neg
VPF_negVPD_negVPE_neg
VI_negVBI_negVSI_negVLI_negVQI_neg
FunktionNegation
Syntax C/C++#include <VFmath.h>
int VF_neg( fVector Y, fVector X, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::neg( const vector<T>& X );
Pascal/Delphiuses VFmath;
function VF_neg( Y, X:fVector; size:UIntSize ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_neg( fVector d_Y, fVector d_X, ui size );
int VFcu_neg( fVector h_Y, fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_neg( d_Y, d_X:fVector; size:UIntSize ): IntBool;
function VFcu_neg( h_Y, h_X:fVector; size:UIntSize );
BeschreibungYi = - (Xi)
nur VBI_,   VSI_,   VI_ und VLI_-Versionen: Durch die implizite modulo-2n-Arithmetik der Ganzzahlen wird die Negation der "negativsten" möglichen Zahlen (also −128 für byte/ByteInt, -32768 für short/SmallInt, -2147483648 für long/LongInt) als dieselbe negative (!) Zahl −128, -32768 bzw. -2147483648 gespeichert.
Fehlerbehandlungkeine
RückgabewertIn Analogie zu VF_abs werden die Fließkomma-Versionen als mathematische Funktionen behandelt. Dementsprechend haben sie einen Rückgabewert, der - da keine Fehler auftreten können - aber stets FALSE (0) ist. Die Ganzzahl-Versionen haben keinen Rückgabewert.
QuerverweisVF_abs,   VCF_conj

 

V_nfree
FunktionMehrere Vektoren in einem Aufruf freigeben
Syntax C/C++#include <VecLib.h>
void V_nfree( unsigned numfree, ... );
Pascal/DelphiDiese Funktion existiert nicht für Pascal/Delphi
CUDA-Funktion C/C++#include <cudaVecLib.h>
void cudaV_nfree( unsigned numfree, ... );
BeschreibungDer Parameter numfree teilt der Funktion mit, wie viele Vektoren verworfen werden sollen. Diese Vektoren folgen in der Parameterliste nach numfree. V_nfree sollte nicht zur Freigabe von Speicher verwendet werden, der mittels anderer Funktionen als denen der VF_vector- oder VF_vector0- Familien zugewiesen wurde.
Pascal/Delphi: Da eine variable Zahl von Parametern nicht unterstützt wird, fehlt diese Funktion hier.
Beispiel C/C++V_nfree( 3, X, Y, Z );
Rückgabewertkeiner
QuerverweisV_free,   V_freeAll,   VF_vector,   VF_vector0

 

VF_noiseVD_noiseVE_noise
Funktionweißes Rauschen
Syntax C/C++#include <VFstd.h>
long VF_noise( fVector X, ui size, long seed, float Amp );
C++ VecObj#include <OptiVec.h>
long vector<T>::noise( long seed, const T& Amp );
Pascal/Delphiuses VFstd;
function VF_noise( X:fVector; size:UIntSize; Seed:LongInt; Amp:Single ): LongInt;
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_noise( fVector X, ui size, long seed, float Amp );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_noise( X:fVector; size:UIntSize; Seed:LongInt; Amp:Single ): IntBool;
BeschreibungWeißes Rauschen wird mit der Amplitude Amp generiert, d.h. die erzeugten Werte liegen zwischen -Amp/2 und +Amp/2 (beide Extremwerte eingeschlossen). seed kann völlig willkürlich gewählt werden. Nachfolgende Aufrufe mit demselben Wert von seed ergeben identische Resultate; für verschiedene Werte von seed sind die Resultate unkorreliert.

Intern gebrauchen diese Funktionen einen 32-bit-Zufallszahlengenerator nach H.W.Lewis, wobei zusätzliche Schritte (sog. "Bays-Durham shuffle") der weitgehenden Vermeidung sequentieller Korrelationen dienen.
Eine 32-bit-Zahl wird zurückgegeben, die als Seed für einen neuen Funktionsaufruf dienen könnte. Dieser neue Aufruf würde allerdings nicht einfach die Serie fortsetzen, da intern bei jedem Aufruf erst ein "State" des Zufallszahlen-Generators aufgebaut wird. Falls die Möglichkeit gewünscht wird, die Serie fortsetzen zu können, sollte statt dieser Funktion VF_noiseLC gewählt werden.
Durch die Beschränkung auf 32-bit ist die Qualität der Zufallszahlen ergibt sich eine gewisse Granularität der erhaltenen Fließkomma-Zahlen. Für höhere Auflösung in den VD_ und VE_ Versionen sollte man VD_random verwenden.

Ein long-Wert wird zurückgegeben, der als neuer seed-Wert für spätere Aufrufe verwendet werden kann.

Fehlerbehandlungkeine
Rückgabewertletzte intern generierte 32-bit-Zufallszahl; kann als neuer Startwert für spätere Aufrufe verwandt werden
Querverweisrand,   random,   VF_random,   VF_noiseLC

 

VF_noiseLCVD_noiseLCVE_noiseLC
Funktionweißes Rauschen
Syntax C/C++#include <VFstd.h>
void VF_noiseLC( fVector X, ui size, long seed, float Amp,  V_RANDOMLCSTATE *state );
C++ VecObj#include <OptiVec.h>
void vector<T>::noiseLC( long seed, const T& Amp,  V_RANDOMLCSTATE *state );
Pascal/Delphiuses VFstd;
procedure VF_noiseLC( X:fVector; size:UIntSize; Seed:LongInt; Amp:Single;  state:PV_RANDOMLCSTATE );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_noiseLC( fVector X, ui size, long seed, float Amp, V_RANDOMLCSTATE );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_noiseLC( X:fVector; size:UIntSize; Seed:LongInt; Amp:Single; state:PV_RANDOMLCSTATE ): IntBool;
BeschreibungWeißes Rauschen wird mit der Amplitude Amp generiert, d.h. die erzeugten Werte liegen zwischen -Amp/2 und +Amp/2 (beide Extremwerte eingeschlossen).

Der 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 einen linear-kongruenten (daher der Namensteil "LC") 32-bit-Zufallszahlengenerator nach H.W.Lewis, wobei zusätzliche Schritte (sog. "Bays-Durham shuffle") der Vermeidung sequentieller Korrelationen dienen.
Als vereinfachte Form dieser Funktion steht VF_noise zur Verfügung.
Durch die Beschränkung auf 32-bit ist die Qualität der Zufallszahlen ergibt sich eine gewisse Granularität der erhaltenen Fließkomma-Zahlen. Für höhere Auflösung in den VD_ und VE_ Versionen sollte man VD_randomLC verwenden.

Fehlerbehandlungkeine
Rückgabewertkeiner
Querverweisrand,   random,   VF_randomLC,   VF_noise

 

VCF_normVCD_normVCE_norm
VCF_normtoCVCD_normtoCVCE_normtoC
VPF_normVPD_normVPE_norm
FunktionNorm (Quadrat der Zeigerlänge) komplexer Vektorelemente
Syntax C/C++#include <VCFstd>
void VCF_norm( fVector Norm, cfVector X, ui size );
void VPF_norm( fVector Norm, pfVector X, ui size );
void VCF_normtoC( cfVector Norm, cfVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::norm( const vector<complex<T>>& X );
void vector<complex<T>>::normtoC( const vector<complex<T>>& X );
Pascal/Delphiuses VCFstd;
procedure VCF_norm( Norm:fVector; X:cfVector; size:UIntSize );
procedure VPF_norm( Norm:fVector; X:pfVector; size:UIntSize );
procedure VCF_normtoC( Norm, X:cfVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVCFstd.h> #include <cudaVPFstd.h>
int cudaVCF_norm( fVector d_Norm, cfVector d_X, ui size );
int cudaVPF_norm( fVector d_Norm, pfVector d_X, ui size );
int cudaVCF_normtoC( cfVector d_Norm, cfVector d_X, ui size );
void VCFcu_norm( fVector h_Norm, cfVector h_X, ui size );
void VPFcu_norm( fVector h_Norm, pfVector h_X, ui size );
void VCFcu_normtoC( cfVector h_Norm, cfVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VCFstd;
function cudaVCF_norm( d_Norm:fVector; d_X:cfVector; size:UIntSize ): IntBool;
function cudaVPF_norm( d_Norm:fVector; d_X:pfVector; size:UIntSize ): IntBool;
function cudaVCF_normtoC( d_Norm, d_X:cfVector; size:UIntSize ): IntBool;
procedure VCFcu_norm( h_Norm:fVector; h_X:cfVector; size:UIntSize );
procedure VPFcu_norm( h_Norm:fVector; h_X:pfVector; size:UIntSize );
procedure VCFcu_normtoC( h_Norm, h_X:cfVector; size:UIntSize );
BeschreibungVCF_norm und VPF_norm sind identisch mit den Familien VF_CtoNorm und VF_PtoNorm. Siehe dort.
VCF_normtoC berechnet die Norm und speichert sie als komplexen Vektor (mit allen Imaginärteilen gleich 0).

 

VI_notVBI_notVSI_notVLI_notVQI_not 
VU_notVUB_notVUS_notVUL_notVUQ_notVUI_not
FunktionBit-weises Komplement
Syntax C/C++#include <VImath.h>
void VI_not( iVector Y, iVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::not( const vector<T>& X );
Pascal/Delphiuses VImath;
procedure VI_not( Y, X:iVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVImath.h>
int cudaVI_not( iVector d_Y, iVector d_X, ui size );
int VIcu_not( iVector h_Y, iVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VImath;
function cudaVI_not( d_Y, d_X:iVector; size:UIntSize ): IntBool;
function VIcu_not( h_Y, h_X:iVector; size:UIntSize );
BeschreibungYi = ~(Xi)
Jedes einzelne Bit wird invertiert (d.h. es wird 0 in Yi, wenn es 1 in Xi war und umgekehrt).
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVI_and,   VI_or,   VI_neg

 

V_noteError
FunktionKonstruktion und Ausgabe einer Fehlermeldung
Syntax C/C++#include <VecLib.h>
void V_noteError( char *fname, unsigned why );
Pascal/Delphiuses VecLib;
procedure V_noteError( fname:PChar; why:UInt );
BeschreibungIm Falle einer Fehlerbedingung unternehmen die mathematischen Funktionen von OptiVec die folgenden Schritte:
  • Das Ergebnis wird auf den je nach Funktion passendsten Standardwert gesetzt.
  • Nur Debug-Bibliotheken: Falls V_FPErrorHandlingMode fpErrorNote für den aufgetretenen Fehler enthält, wird V_noteError aufgerufen.
  • V_noteError setzt dann aus dem Funktionsnamen fname und dem als why übergebenen Kürzel für den Fehler die passende Meldung zusammen und gibt sie mittels V_printErrorMsg aus.
Die Ausgabe erfolgt standardmäßig auf dem Bildschirm, kann aber durch vorherigen Aufruf von V_setErrorEventFile in eine Ereignis-Datei umgeleitet werden (siehe Kap. 5.3).

Der Parameter why kann die folgenden Werte annehmen:
1 für DOMAIN-Fehler
2 für SING-Fehler
3 für OVERFLOW-Fehler
4 für UNDERFLOW-Fehler
5 für TLOSS-Fehler

Rückgabewertkeiner
QuerverweisV_setErrorEventFile,   V_printErrorMsg

 

VF_nreadVD_nreadVE_nread
VCF_nreadVCD_nreadVCE_nread
VPF_nreadVPD_nreadVPE_nread
VI_nreadVBI_nreadVSI_nreadVLI_nreadVQI_nread 
VU_nreadVUB_nreadVUS_nreadVUL_nreadVUQ_nreadVUI_nread
FunktionEinlesen der Spalten einer im ASCII-Format vorliegenden Tabelle aus einem Stream
Syntax C/C++#include <VFstd.h>
void VF_nread( unsigned n, ui size, FILE *stream, ... );
Pascal/Delphiuses VFstd;
procedure VF_nread( VecList:^fVector; n:Word; size:UIntSize; var stream:Text );
Beschreibung C/C++n Spalten einer Tabelle werden in die an VF_nread übergebenen Vektoren eingelesen. Die Anzahl der Zeilen gibt also die Anzahl der Elemente jedes Vektors an: size.

Die einzelnen Einträge einer Zeile sollten durch Leerzeichen (' ') oder Tabulatoren ('\t') voneinander getrennt sein.

Jede Zeile muss durch einen Zeilenvorschub ('\n') abgeschlossen sein. Die Zeilenlänge ist dabei gemäß folgenden Regeln begrenzt:
- Entweder alle Zeilen sind gleich lang. Dann wird die Länge automatisch bestimmt und darf im Prinzip bis zu 65535 Zeichen betragen.
- Oder die maximale Länge einer Zeile richtet sich nach dem Datentyp und der Anzahl n einzulesender Vektoren:
 
VF_ 24*n
VBI_,   VUB_13*n
VD_ 32*n
VSI_,   VUS_21*n
VE_ 40*n
VLI_,   VUL_37*n
VCF_,   VPF_ 48*n
VQI_32*n
VCD_,   VPD_ 64*n
VI_,   VU_wie VLI_,   VUL_
(in den 16-bit-Modellen wie VSI_,   VUS_)
VCE_,   VPE_ 80*n
 

Es ist möglich, weniger Vektoren einzulesen als eine Tabelle Spalten hat. Dann bleiben die hintersten Spalten unberücksichtigt. Liegen jedoch weniger Spalten vor als Vektoren eingelesen werden sollen, ist mit merkwürdigen bis katastrophalen Ergebnissen zu rechnen.

Komplexe Versionen (cartesisch und polar):
Real- und Imaginärteil (bzw. Mag- und Arg-Teil) dürfen (müssen aber nicht) durch geschweifte Klammern { } zusammengefaßt sein. Die Behandlung muss aber einheitlich sein: Entweder alle oder gar kein Element darf mit geschweiften Klammern geschrieben sein!

Ganzzahl-Versionen außer VQI_nread:
Standardmäßig werden die zu lesenden Zahlen als Dezimalzahlen interpretiert. Mittels V_setRadix läßt sich aber auch eine andere Basis zwischen 2 und 36 definieren.

Beispiel C/C++VF_nread( 3, 100, DataFile, X, Y, Z );
 
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_nread, VCE_nread und VPE_nread bei GCC nur mit double-Genauigkeit und innerhalb des für doubles möglichen Größenbereiches arbeiten.
Beschreibung Pascal/Delphin Spalten einer Tabelle werden in die als Liste VecList an VF_nread übergebenen Vektoren eingelesen. Die Anzahl der Zeilen ist durch size, die Anzahl der Elemente jedes Vektors, gegeben.

Die einzelnen Einträge einer Zeile müssen durch Leerzeichen (' ') oder Tabulatoren (#9) voneinander getrennt sein. Andere Trennzeichen sind nicht zulässig. Jede Zeile muss durch einen Zeilenvorschub (#13) abgeschlossen sein.

Es ist möglich, weniger Vektoren einzulesen als eine Tabelle Spalten hat. Dann bleiben die hintersten Spalten unberücksichtigt. Liegen jedoch weniger Spalten vor als Vektoren eingelesen werden sollen, ist mit merkwürdigen bis katastrophalen Ergebnissen zu rechnen.

Komplexe Versionen (cartesisch und polar):
Real- und Imaginärteil (bzw. Mag- und Arg-Teil) dürfen (müssen aber nicht) durch geschweifte Klammern { } zusammengefaßt sein. Sie müssen voneinander durch Leer- oder Tab-Zeichen getrennt sein. Die Behandlung muss aber einheitlich sein: Entweder alle oder gar kein Element darf mit geschweiften Klammern geschrieben sein! Zusätzlich ist ein unmittelbar (ohne vorherigen Whitespace) auf den Realteil folgendes Komma zugelassen.

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 der Pascal/Delphi-Version zur Folge:
- keine Trennzeichen außer ' ' und #9 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).
 

Beispiel Pascal/Delphivar MyFile: Text;
    X, Y1, Y2: fVector;
    VList: array[0..2] of fVector;
begin
    X := VF_vector( 100 );
    Y1 := VF_vector( 100 );
    Y2 := VF_vector( 100 );
    VList[0] := X; VList[1] := Y1; VList[2] := Y2;
    Assign( MyFile, 'Myfile.DAT' );
    Reset( MyFile );
    VF_nread( @VList, 3, 100, MyFile );
    ...
end;
FehlerbehandlungC/C++:
Reelle, komplexe und quad-Versionen:
Überlaufende Zahlen werden stillschweigend auf ±HUGE_VAL abgeschnitten.
Ganzzahl-Versionen außer VQI_nread:
Solange sich die Zahlen als long bzw. unsigned long darstellen lassen, werden in den kleineren Daten-Typen die übergelaufenen Bits ignoriert. Überschreiten die Zahlen aber auch den long-Bereich, so resultiert −1 (vorzeichenbehaftete Typen) bzw. der größte darstellbare Wert (vorzeichenlose Typen).
Pascal/Delphi:
Überlaufende oder anderweitig nicht den Format-Beschränkungen genügende Zahlen führen zu einem I/O-Fehler.
Rückgabewertkeiner
QuerverweisVF_nwrite,   VF_read,   VF_store,   VF_recall, strtod,   strtol (nur C/C++)

 

VF_nwriteVD_nwriteVE_nwrite
VCF_nwriteVCD_nwriteVCE_nwrite
VPF_nwriteVPD_nwriteVPE_nwrite
VI_nwriteVBI_nwriteVSI_nwriteVLI_nwriteVQI_nwrite 
VU_nwriteVUB_nwriteVUS_nwriteVUL_nwriteVUQ_nwriteVUI_nwrite
FunktionAusgabe mehrerer Vektoren als Spalten einer Tabelle in einen Stream
Syntax C/C++#include <VFstd.h>
void VF_nwrite( FILE *stream, unsigned n, ui size, ... );
Pascal/Delphiuses VFstd;
procedure VF_nwrite( var stream:Text; VecList:^fVector; n:UInt; size:UIntSize );
Beschreibung C/C++n Vektoren werden im ASCII-Format als Spalten einer Tabelle in stream ausgegeben. Die Anzahl der Zeilen ist durch die Anzahl der Elemente jedes Vektors gegeben: size.

Ausgabeformat und Trennzeichen lassen sich über die Funktionen VF_setWriteFormat bzw. VF_setNWriteSeparate setzen.

Beispiel C/C++VF_nwrite( DataFile, 3, 100, X, Y, Z );
     /* erzeugt eine Tabelle mit 3 Spalten und 100 Zeilen;
        die Spalten sind durch X, Y und Z gegeben. */

 
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_nwrite, VCE_nwrite und VPE_nwrite bei GCC nur mit double-Genauigkeit und innerhalb des für doubles möglichen Größenbereiches arbeiten (also Eingabewerte ggf. auf diesen abgeschnitten werden).
Beschreibung Pascal/Delphin als Liste VecList an VF_nwrite übergebene Vektoren werden im ASCII-Format als Spalten einer Tabelle in stream ausgegeben. Die Anzahl der Zeilen ist durch die Anzahl der Elemente jedes Vektors gegeben: size.

Die Trennzeichen zwischen den einzelnen Spalten lassen sich über die Funktion VF_setNWriteSeparate definieren (Standard-Einstellung: Tab-Zeichen, #9).

Man beachte, dass die Pascal/Delphi-Version dieser Funktionen keine freie Definition des Ausgabeformates zuläßt. Eine Funktion VF_setWriteFormat existiert hier daher nicht.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_write,   VF_nread,   VF_store,   VF_recall,   fprintf

 

VF_ODVD_ODVE_OD
VU_ODtoFVU_ODtoDVU_ODtoE
VUB_ODtoFVUB_ODtoDVUB_ODtoE
VUS_ODtoFVUS_ODtoDVUS_ODtoE
VUL_ODtoFVUL_ODtoDVUL_ODtoE
VUQ_ODtoFVUQ_ODtoDVUQ_ODtoE
VUI_ODtoFVUI_ODtoDVUI_ODtoE
VQI_ODtoFVQI_ODtoDVQI_ODtoE
FunktionOptische Dichte
Syntax C/C++#include <VFmath.h>
int VF_OD( fVector OD, fVector X, fVector X0, ui size );
int VUS_ODtoF( fVector OD, usVector X, usVector X0, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::OD( const vector<T>& X, const vector<T>& X0 );
int vector<flot>::ODtoF( const vector<unsigned>& X, const vector<unsigned>& X0 );
Pascal/Delphiuses VFmath;
function VF_OD( OD, X, X0:fVector; size:UIntSize ): IntBool;
function VUS_ODtoF( OD:fVector; X, X0:usVector; size:UIntSize ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_OD( fVector d_OD, fVector d_X, fVector d_X0, ui size );
int cudaVUS_ODtoF( fVector d_OD, usVector d_X, usVector d_X0, ui size );
int VFcu_OD( fVector h_OD, fVector h_X, fVector h_X0, ui size );
int VUScu_ODtoF( fVector h_OD, usVector h_X, usVector h_X0, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_OD( d_OD, d_X, d_X0:fVector; size:UIntSize ): IntBool;
function cudaVUS_ODtoF( d_OD:fVector; d_X, d_X0:usVector; size:UIntSize ): IntBool;
function VFcu_OD( h_OD, h_X, h_X0:fVector; size:UIntSize ): IntBool;
function VUScu_ODtoF( h_OD:fVector; h_X, h_X0:usVector; size:UIntSize ): IntBool;
BeschreibungODi = log10( X0i/Xi ), wenn (X0i ≥ ODThresh0 & Xi ≥ ODThresh),
ODi = 0.0, ansonsten
Die "Optische Dichte" wird für positive Eingabe-Werte (außer 0) berechnet. Die Standard-Einstellung für ODThresh und ODThresh0 ist FLT_MIN, DBL_MIN bzw. LDBL_MIN für die Fließkomma-Versionen (VF_OD,   VD_OD und VE_OD) und 1 für die Ganzzahl-Versionen.
Die typische Anwendung für diese Funktionen besteht aus einer Absorptions-Messung. Jedes Element von X enthält die durch eine Probe hindurch gemessene Lichtintensität für eine bestimmte Wellenlänge, während X0 die Intensitäten in Luft bzw. für eine Referenz-Probe enthält. Normalerweise werden die Intensitäten mit 12-bit oder 16-bit Auflösung in usVectoren vorliegen. Die geeigneten Funktionen für die Berechnung der OD sind dann VUS_ODtoF oder VUS_ODtoD. Für die selteneren Fälle von 8-bit oder mehr als 16-bit Auflösung benutze man die VUB_- oder VUL_-Versionen.

Häufig wird man auch eine ganze Reihe von Messungen akkumulieren wollen vor der Berechnung der OD. Man könnte also beispielsweise mehrere 16-bit Messungen mittels VUL_accVUS in einem ulVector akkumulieren und dann VUL_ODtoD aufrufen. Entsprechend bietet sich an, VQI_accVUL für Messungen höherer Genauigkeit zu verwenden und dann beispielsweise VQI_ODtoE aufzurufen.

Um Rauschen und Störungen abschneiden zu können, bieten die Funktionen VF_setODThresh usw. die Möglichkeit, ODThresh und ODThresh0 auf beliebige positive Werte zu setzen.

Ist ein Untergrund wie z.B. Dunkelströme abzuziehen, verwende man statt VF_OD besser VF_ODwDark.

Fehlerbehandlungkeine
Rückgabewertimmer FALSE(0)
QuerverweisVF_ODwDark,   VF_log10

 

VF_ODwDarkVD_ODwDarkVE_ODwDark
VU_ODtoFwDarkVU_ODtoDwDarkVU_ODtoEwDark
VUB_ODtoFwDarkVUB_ODtoDwDarkVUB_ODtoEwDark
VUS_ODtoFwDarkVUS_ODtoDwDarkVUS_ODtoEwDark
VUL_ODtoFwDarkVUL_ODtoDwDarkVUL_ODtoEwDark
VUQ_ODtoFwDarkVUQ_ODtoDwDarkVUQ_ODtoEwDark
VUI_ODtoFwDarkVUI_ODtoDwDarkVUI_ODtoEwDark
VQI_ODtoFwDarkVQI_ODtoDwDarkVQI_ODtoEwDark
FunktionOptische Dichte mit Dunkelstrom-Korrektur
Syntax C/C++#include <VFmath.h>
int VF_ODwDark( fVector OD, fVector X, fVector XDark, fVector X0, fVector X0Dark, ui size );
int VUS_ODtoFwDark( fVector OD, usVector X, usVector XDark, usVector X0, usVector X0Dark, ui size );
C++ VecObj#include <OptiVec.h>
int vector<T>::ODwDark( const vector<T>& X, const vector<T>& XDark, const vector<T>& X0, const vector<T>& X0Dark );
int vector<float>::ODtoFwDark( const vector<unsigned>& X, const vector<unsigned>& XDark, const vector<unsigned>& X0, const vector<unsigned>& X0Dark );
Pascal/Delphiuses VFmath;
function VF_ODwDark( OD, X, XDark, X0, X0Dark:fVector; size:UIntSize ): IntBool;
function VUS_ODtoFwDark( OD:fVector; X, XDark, X0, X0Dark:usVector; size:UIntSize ): IntBool;
CUDA-Funktion C/C++#include <cudaVFmath.h>
int cudaVF_ODwDark( fVector d_OD, fVector d_X, fVector d_XDark, fVector d_X0, fVector d_X0Dark, ui size );
int cudaVUS_ODtoFwDark( fVector d_OD, usVector d_X, usVector d_XDark, usVector d_X0, usVector d_X0Dark, ui size );
int VFcu_ODwDark( fVector h_OD, fVector h_X, fVector h_XDark, fVector h_X0, fVector h_X0Dark, ui size );
int VUScu_ODtoFwDark( fVector h_OD, usVector h_X, usVector h_XDark, usVector h_X0, usVector h_X0Dark, ui size );
CUDA-Funktion Pascal/Delphiuses VFmath;
function cudaVF_ODwDark( d_OD, d_X, d_ XDark, d_X0, d_X0Dark:fVector; size:UIntSize ): IntBool;
function cudaVUS_ODtoFwDark( d_OD:fVector; d_X, d_XDark, d_X0, d_X0Dark:usVector; size:UIntSize ): IntBool;
function VFcu_ODwDark( h_OD, h_X, h_XDark, h_X0, h_X0Dark:fVector; size:UIntSize ): IntBool;
function VUScu_ODtoFwDark( h_OD:fVector; h_X, h_XDark, h_X0, h_X0Dark:usVector; size:UIntSize ): IntBool;
Beschreibungxxi = Xi - XiDark
x0i = X0i - X0iDark
ODi = log10( x0i/xxi ),   wenn (x0i ≥ ODThresh0 & xxi ≥ ODThresh),
ODi = 0.0,   ansonsten

Die Dunkelströme XDark und X0Dark werden von den gemessenen Intensitäten X und X0 abgezogen und die Optische Dichte aufgrund der so korrigierten Daten berechnet. Falls diese negativ oder kleiner als die Schwellen ODThresh bzw. ODThresh0 werden, wird die OD gleich 0.0 gesetzt.

Die Schwellen lassen sich mittels VF_setODThresh,   VUS_setODThresh, usw. auf beliebige positive Werte setzen.

Fehlerbehandlungkeine
Rückgabewertimmer FALSE(0)
QuerverweisVF_OD,   VF_setODThresh

 

VI_orVBI_orVSI_orVLI_orVQI_or 
VU_orVUB_orVUS_orVUL_orVUQ_orVUI_or
FunktionBit-weises ODER
Syntax C/C++#include <VImath.h>
void VI_or( iVector Y, iVector X, ui size, int C);
void VUL_or( ulVector Y, ulVector X, ui size, unsigned long C );
C++ VecObj#include <OptiVec.h>
void vector<T>::or( const vector<T>& X, const T& C );
Pascal/Delphiuses VImath;
procedure VI_or( Y, X:iVector; size:UIntSize; C:Integer );
CUDA-Funktion C/C++#include <cudaVImath.h>
int cudaVI_or( iVector d_Y, iVector d_X, ui size, int C );
int cusdVI_or( iVector d_Y, iVector d_X, ui size, int *d_C );
void VIcu_or( iVector h_Y, iVector h_X, ui size, int C );
CUDA-Funktion Pascal/Delphiuses VImath;
function cudaVI_or( d_Y, d_X:iVector; size:UIntSize; C:Integer ): IntBool;
function cusdVI_or( d_Y, d_X:iVector; size:UIntSize; d_C:PInteger ): IntBool;
procedure VIcu_or( h_Y, h_X:iVector; size:UIntSize; C:Integer );
BeschreibungYi = (Xi) | C
Das Bit-weise "inclusive ODER" (im Unterschied zum exclusiven ODER, siehe VI_xor) wird mit der Bit-Maske C auf jedes Element von X angewandt und das Ergebnis in Y gespeichert. Ein Bit ist 1 in Yi, wenn es in Xi und C nicht gleichzeitig 0 ist (also mindestens in einem von beiden 1).
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVI_not,   VI_and,   VI_xor

 

VF_ParzenVD_ParzenVE_Parzen
FunktionParzen-Fenster für die Spektralanalyse
Syntax C/C++#include <VFmath.h>
void VF_Parzen( fVector X, ui size );
C++ VecObj#include <OptiVec.h>
void vector<T>::Parzen();
Pascal/Delphiuses VFmath;
procedure VF_Parzen( X:fVector; size:UIntSize );
CUDA-Funktion C/C++#include <cudaVFstd.h>
int cudaVF_Parzen( fVector d_X, ui size );
void VFcu_Parzen( fVector h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_Parzen( d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_Parzen( h_X:fVector; size:UIntSize );
BeschreibungXi = 1 - |(i - 0.5*(size - 1)) / 0.5*(size + 1)|
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_Welch,   VF_Hann,   VF_spectrum

 

VF_PelementVD_PelementVE_Pelement
VCF_PelementVCD_PelementVCE_Pelement
VCF_elementReVCD_elementReVCE_elementRe
VCF_elementImVCD_elementImVCE_elementIm
VPF_elementVPD_elementVPE_element
VPF_elementMagVPD_elementMagVPE_elementMag
VPF_elementArgVPD_elementArgVPE_elementArg
VI_PelementVBI_PelementVSI_PelementVLI_PelementVQI_Pelement 
VU_PelementVUB_PelementVUS_PelementVUL_PelementVUQ_PelementVUI_Pelement
FunktionZeiger 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/Delphiuses 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/Delphiuses 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;
BeschreibungReelle 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.

Fehlerbehandlungkeine
RückgabewertC/C++:        X+pos
Pascal/Delphi: @( X[pos] )
QuerverweisVF_element

 

V_PDtoPFV_PDtoPE
V_PEtoPFV_PEtoPD
V_PFtoPDV_PFtoPE
FunktionDatentyp-Umwandlungen. Siehe V_FtoD.

 

cudaV_pinnedFree
Funktionnur cudaOptiVec: Freigabe eines "pinned" Vektors im Host-Memory
CUDA-Funktion C/C++#include <cudaVecLib.h>
int cudaV_pinnedFree( void *h_X );
CUDA-Funktion Pascal/Delphiuses VecLib;
function cudaV_pinnedFree( h_X:Pointer ): IntBool;
BeschreibungDer "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++).
FehlerbehandlungDer 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ückgabewertFALSE (0) bei Erfolg, sonst TRUE (nicht-Null)
QuerverweisCudaOptiVecD.htm, Kap. 3,   cudaV_pinnedNfree,   cudaV_pinnedFreeAll,   cudaVF_pinnedVector

 

cudaV_pinnedFreeAll
Funktionnur cudaOptiVec: Freigabe aller "pinned" Host-Memory Vektoren (und -Matrizen)
CUDA-Funktion C/C++#include <cudaVecLib.h>
int cudaV_pinnedFreeAll( void );
CUDA-Funktion Pascal/Delphiuses VecLib;
function cudaV_pinnedFreeAll: IntBool;
BeschreibungAlle "pinned" Host-Memory Vektoren und Matrizen, die zuvor mit cudaVF_pinnedVector,   oder cudaMF_pinnedMatrix alloziert wurden, werden freigegeben.
Fehlerbehandlungkeine
RückgabewertFALSE (0) bei Erfolg, sonst TRUE (nicht-Null)
QuerverweisCudaOptiVecD.htm, Kap. 3,   cudaV_pinnedFree,   cudaV_pinnedNfree,   cudaVF_pinnedVector

 

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

 

cudaVF_pinnedVectorcudaVD_pinnedVectorcudaVE_pinnedVector
cudaVCF_pinnedVectorcudaVCD_pinnedVectorcudaVCE_pinnedVector
cudaVPF_pinnedVectorcudaVPD_pinnedVectorcudaVPE_pinnedVector
cudaVI_pinnedVectorcudaVBI_pinnedVectorcudaVSI_pinnedVector
cudaVLI_pinnedVectorcudaVQI_pinnedVector 
cudaVU_pinnedVectorcudaVUB_pinnedVectorcudaVUS_pinnedVector
cudaVUL_pinnedVectorcudaVUQ_pinnedVectorcudaVUI_pinnedVector
FunktionAllokation von "pinned" Host-Memory
CUDA-Funktion C/C++#include <cudaVFstd.h>
fVector cudaVF_pinnedVector( fVector *h_X, ui size );
CUDA-Funktion Pascal/Delphiuses VecLib;
function cudaVF_pinnedVector( var h_X:fVector; size:UIntSize ): fVector;
BeschreibungHost-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.
FehlerbehandlungFalls nicht genug Speicher vorhanden ist, oder im Falle von size=0, wird eine Fehlermeldung "Not enough memory" ausgegeben und das Programm abgebrochen.
RückgabewertDevice-Zeiger auf den reservierten Speicherbereich
QuerverweisCudaOptiVecD.htm, Kap. 3,   cudaVF_pinnedVector0

 

cudaVF_pinnedVector0cudaVD_pinnedVector0cudaVE_pinnedVector0
cudaVCF_pinnedVector0cudaVCD_pinnedVector0cudaVCE_pinnedVector0
cudaVPF_pinnedVector0cudaVPD_pinnedVector0cudaVPE_pinnedVector0
cudaVI_pinnedVector0cudaVBI_pinnedVector0cudaVSI_pinnedVector0
cudaVLI_pinnedVector0cudaVQI_pinnedVector0 
cudaVU_pinnedVector0cudaVUB_pinnedVector0cudaVUS_pinnedVector0
cudaVUL_pinnedVector0cudaVUQ_pinnedVector0cudaVUI_pinnedVector0
FunktionAllokation 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/Delphiuses VecLib;
function cudaVF_pinnedVector( var h_X:fVector; size:UIntSize ): fVector;
BeschreibungHost-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.
FehlerbehandlungFalls nicht genug Speicher vorhanden ist, oder im Falle von size=0, wird eine Fehlermeldung "Not enough memory" ausgegeben und das Programm abgebrochen.
RückgabewertDevice-Zeiger auf den reservierten Speicherbereich
QuerverweisCudaOptiVecD.htm, Kap. 3,   cudaVF_pinnedVector

 

VCF_polarVCD_polarVCE_polar
VPF_polarVPD_polarVPE_polar
FunktionKonstruktion 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/Delphiuses 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/Delphiuses 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);
BeschreibungIdentisch mit VF_PolartoC etc. bzw. VF_MagArgtoP. Siehe dort.

 

VF_PolartoCVD_PolartoCVE_PolartoC
FunktionKonstruktion 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/Delphiuses 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/Delphiuses 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);
BeschreibungAus 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.
FehlerbehandlungDer vollständige Genauigkeitsverlust für sehr große Argi wird stillschweigend durch Wahl der cartesischen Koordinaten {Magi, 0} behandelt.
Rückgabewertkeiner
QuerverweisVF_PtoC,   VF_CtoPolar,   VF_ReImtoC,   VF_CtoArg,   VF_CtoNorm

 

VF_polyVD_polyVE_poly
VF_poly_dVF_poly_eVD_poly_e
VFx_polyVDx_polyVEx_poly
VFx_poly_dVFx_poly_eVDx_poly_e
VF_polyOddVD_polyOddVE_polyOdd
VF_polyOdd_dVF_polyOdd_eVD_polyOdd_e
VFx_polyOddVDx_polyOddVEx_polyOdd
VFx_polyOdd_dVFx_polyOdd_eVDx_polyOdd_e
VF_polyEvenVD_polyEvenVE_polyEven
VF_polyEven_dVF_polyEven_eVD_polyEven_e
VFx_polyEvenVDx_polyEvenVEx_polyEven
VFx_polyEven_dVFx_polyEven_eVDx_polyEven_e
FunktionPolynom
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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.

FehlerbehandlungOVERFLOW-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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_ratio,   VF_ipow,   VF_pow,   poly

 

VF_polyinterpolVD_polyinterpolVE_polyinterpol
FunktionPolynom-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/Delphiuses 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/Delphiuses 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 );
BeschreibungFü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.
FehlerbehandlungWerte 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).
Rückgabewertkeiner
QuerverweisVF_ratinterpol,   VF_splineinterpol

 

VF_powVD_powVE_pow
VCF_powVCD_powVCE_pow
VFx_powVDx_powVEx_pow
VCFx_powVCDx_powVCEx_pow
VCF_powReExpoVCD_powReExpoVCE_powReExpo
VCFx_powReExpoVCDx_powReExpoVCEx_powReExpo
VPF_powReExpoVPD_powReExpoVPE_powReExpo
Funktionbeliebige 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/Delphiuses 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/Delphiuses 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 );
Beschreibungeinfache 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).
FehlerbehandlungDOMAIN-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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_ipow,   VF_poly,   VF_pow2,   VF_exp,   VF_powexp,   pow

 

VF_pow10VD_pow10VE_pow10
VFx_pow10VDx_pow10VEx_pow10
Funktionreelle 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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache Versionen: Yi = 10.0 Xi
erweiterte Versionen: Yi = C * 10.0A*Xi+B
Dies ist eine Exponentialfunktion zur Basis 10
FehlerbehandlungOVERFLOW-Fehler ergeben ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_ipow10,   VF_scale10,   VF_log10,   VF_pow,   VF_exp,   pow10

 

VF_pow2VD_pow2VE_pow2
VFx_pow2VDx_pow2VEx_pow2
Funktionreelle 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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache Versionen: Yi = 2.0 Xi
erweiterte Versionen: Yi = C * 2.0A*Xi+B
Dies ist eine Exponentialfunktion zur Basis 2.
FehlerbehandlungOVERFLOW-Fehler ergeben ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_ipow2,   VF_scale2,   VF_log2,   VF_pow,   VF_exp,   pow

 

VF_powexpVD_powexpVE_powexp
VFx_powexpVDx_powexpVEx_powexp
Funktionreelle 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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.
FehlerbehandlungDOMAIN-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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_pow,   VF_poly,   VF_exp pow,  exp

 

VPF_principalVPD_principalVPE_principal
FunktionHauptwert 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/Delphiuses 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/Delphiuses VPFstd;
function cudaVPF_principal( h_Y, h_X:pfVector; size:UIntSize ): IntBool;
procedure VPFcu_principal( h_Y, h_X:pfVector; size:UIntSize );
BeschreibungDas Argument, d.h. der Zeigerwinkel jedes Elementes wird auf den Bereich -p < Arg ≤ +p normiert.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_MagArgtoPrincipal

 

VF_printVD_printVE_print
VCF_printVCD_printVCE_print
VI_printVBI_printVSI_printVLI_printVQI_print 
VU_printVUB_printVUS_printVUL_printVUQ_printVUI_print
FunktionVektor 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/Delphiuses 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/Delphiuses 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;
Beschreibungsize 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.

FehlerbehandlungWenn 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.
Rückgabewertkeiner
QuerverweisVF_cprint,   VF_fprint,   VF_hexprint,   VF_write,   VF_store,   printf (nur C/C++)

 

V_printErrorMsg
FunktionAusgabe einer Fehlermeldung
Syntax C/C++#include <VecLib.h>
void V_printErrorMsg( char *ErrMsg );
Pascal/Delphiuses VecLib;
procedure V_printErrMsg( ErrMsg: PChar );
BeschreibungErrMsg 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.
Rückgabewertkeiner
QuerverweisV_setErrorEventFile,   V_noteError,   _matherr (nur C/C++)

 

VF_prodVD_prodVE_prod
VCF_prodVCD_prodVCE_prod
VPF_prodVPD_prodVPE_prod
FunktionProdukt 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/Delphiuses 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/Delphiuses 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;
BeschreibungAlle 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.
Fehlerbehandlungkeine (aber Vorsicht: diese Funktion neigt zum Über- oder Unterlauf!)
RückgabewertProdukt der Vektorelemente (außer komplexe Versionen in Pascal/Delphi)
QuerverweisVF_runprod,   VF_sum

 

VF_PtoAbsVD_PtoAbsVE_PtoAbs
FunktionAbsolutwert (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/Delphiuses 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/Delphiuses VPFstd;
function cudaVF_PtoAbs( d_Abs:fVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoAbs( h_Abs:fVector; h_X:pfVector; size:UIntSize );
BeschreibungDer 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVPF_abs,   VF_PtoMagArg,   VF_PtoArg,   VF_PtoNorm

 

VF_PtoArgVD_PtoArgVE_PtoArg
FunktionArgument (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/Delphiuses 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/Delphiuses VPFstd;
function cudaVF_PtoArg( d_Arg:fVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoArg( h_Arg:fVector; h_X:pfVector; size:UIntSize );
BeschreibungDas 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_PtoAbs,   VF_PtoMagArg,   VF_PtoReIm

 

VF_PtoCVD_PtoCVE_PtoC
FunktionUmwandlung 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/Delphiuses 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/Delphiuses VPFstd;
function cudaVF_PtoC( d_Abs:cfVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoC( h_Abs:cfVector; h_X:pfVector; size:UIntSize );
BeschreibungX wird aus Polarkoordinaten {Mag @ Arg} in cartesische Koordinaten {Re, Im} umgewandelt.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_CtoP,   VF_PtoReIm

 

VF_PtoImVD_PtoImVE_PtoIm
FunktionImaginä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/Delphiuses 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/Delphiuses VPFstd;
function cudaVF_PtoIm( d_Im:fVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoIm( h_Im:fVector; h_X:pfVector; size:UIntSize );
BeschreibungDer Imaginärteil des polar-komplexen Vektors X wird berechnet und in Im gespeichert.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_PtoReIm,   VF_ReImtoP

 

VF_PtoMagVD_PtoMagVE_PtoMag
FunktionZeigerlä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/Delphiuses 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/Delphiuses VPFstd;
function cudaVF_PtoMag( d_Mag:fVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoMag( h_Mag:fVector; h_X:pfVector; size:UIntSize );
BeschreibungDie Zeigerlänge jedes Elementes von X wird extrahiert und in Mag gespeichert.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_PtoArg

 

VF_PtoMagArgVD_PtoMagArgVE_PtoMagArg
FunktionAufspaltung 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie Mag- und Arg- Teile des polar-komplexen Vektors X werden extrahiert und in getrennten Vektoren Mag und Arg abgelegt.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_PtoRe,   VF_MagArgtoP

 

VF_PtoNormVD_PtoNormVE_PtoNorm
FunktionNorm (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/Delphiuses 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/Delphiuses VPFstd;
function cudaVF_PtoNorm( d_Norm:fVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoNorm( h_Norm:fVector; h_X:pfVector; size:UIntSize );
BeschreibungNormi = 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_PtoReIm,   VPF_abs

 

VF_PtoReVD_PtoReVE_PtoRe
FunktionRealteil 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/Delphiuses 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/Delphiuses VPFstd;
function cudaVF_PtoRe( d_Re:fVector; d_X:pfVector; size:UIntSize ): IntBool;
procedure VF_PtoRe( h_Re:fVector; h_X:pfVector; size:UIntSize );
BeschreibungDer Realteil des polar-komplexen Vektors X wird berechnet und in Re gespeichert.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_PtoReIm,   VF_PtoIm

 

VF_PtoReImVD_PtoReImVE_PtoReIm
FunktionReal- 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDer polar-komplexe Vektor X wird in cartesische Koordinaten umgewandelt, die in getrennten Vektoren Re und Im gespeichert werden.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_PtoRe,   VF_ReImtoP

 

VF_quarticVD_quarticVE_quartic
VFx_quarticVDx_quarticVEx_quartic
VFu_quarticVDu_quarticVEu_quartic
VFux_quarticVDux_quarticVEux_quartic
VCF_quarticVCD_quarticVCE_quartic
VCFx_quarticVCDx_quarticVCEx_quartic
VCFu_quarticVCDu_quarticVCEu_quartic
VCFux_quarticVCDux_quarticVCEux_quartic
VPF_quarticVPD_quarticVPE_quartic
VPFu_quarticVPDu_quarticVPEu_quartic
Funktionvierte Potenz
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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.
FehlerbehandlungOVERFLOW-Fehler ergeben HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_square,   VF_cubic,   VF_rquartic,   VF_sqrt,   VF_pow,   VF_ipow,   VF_poly

 

VF_rampVD_rampVE_ramp
VCF_rampVCD_rampVCE_ramp
VI_rampVBI_rampVSI_rampVLI_rampVQI_ramp 
VU_rampVUB_rampVUS_rampVUL_rampVUQ_rampVUI_ramp
Funktionaufsteigende 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/Delphiuses 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/Delphiuses 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 );
BeschreibungXi = 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.

FehlerbehandlungFließkomma-Versionen: keine;
Ganzzahl-Versionen: siehe Kap. 5.2.
Rückgabewertkeiner
QuerverweisVF_Parzen,   VF_Welch,   VF_equ1,   VUI_indramp,   VF_random

 

VF_randomVD_randomVE_random
VCF_randomVCD_randomVCE_random
VI_randomVBI_randomVSI_randomVLI_randomVQI_random 
VU_randomVUB_randomVUS_randomVUL_randomVUQ_randomVUI_random
Funktiongleichverteilte 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/Delphiuses 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/Delphiuses 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;
BeschreibungX 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.

Fehlerbehandlungkeine
Rückgabewertletzte intern generierte 32-bit-Zufallszahl; kann als neuer Startwert für spätere Aufrufe verwandt werden
QuerverweisVF_noise,   VF_randomLC,   rand,   srand (nur C/C++),   random

 

VF_randomLCVD_randomLCVE_randomLC
VCF_randomLCVCD_randomLCVCE_randomLC
VI_randomLCVBI_randomLCVSI_randomLCVLI_randomLCVQI_randomLC 
VU_randomLCVUB_randomLCVUS_randomLCVUL_randomLCVUQ_randomLCVUI_randomLC
Funktiongleichverteilte 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/Delphiuses 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/Delphiuses 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;
BeschreibungX 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/Delphiuses 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 }
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_noise,   VF_random,   rand,   srand (nur C/C++),   random

 

VF_ratinterpolVD_ratinterpolVE_ratinterpol
Funktiondiagonal-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/Delphiuses 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/Delphiuses 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 );
BeschreibungFü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.

FehlerbehandlungEine Polstelle (d.h. ein Wert von Unendlich) in der Interpolationsfunktion wird als SING-Fehler behandelt mit dem Ergebnis ±HUGE_VAL. (Der in C/C++ an _matherr übergebene x-Wert ist dabei das erste Element von XTab). 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.
Rückgabewertkeiner
QuerverweisVF_polyinterpol,   VF_splineinterpol

 

VF_ratioVD_ratioVE_ratio
VF_ratio_dVF_ratio_eVD_ratio_e
VFx_ratioVDx_ratioVEx_ratio
VFx_ratio_dVFx_ratio_eVDx_ratio_e
VF_ratioOddEvenVD_ratioOddEvenVE_ratioOddEven
VF_ratioOddEven_dVF_ratioOddEven_eVD_ratioOddEven_e
VFx_ratioOddEvenVDx_ratioOddEvenVEx_ratioOddEven
VFx_ratioOddEven_dVFx_ratioOddEven_eVDx_ratioOddEven_e
VF_ratioEvenOddVD_ratioEvenOddVE_ratioEvenOdd
VF_ratioEvenOdd_dVF_ratioEvenOdd_eVD_ratioEvenOdd_e
VFx_ratioEvenOddVDx_ratioEvenOddVEx_ratioEvenOdd
VFx_ratioEvenOdd_dVFx_ratioEvenOdd_eVDx_ratioEvenOdd_e
   
VFu_ratioVDu_ratioVEu_ratio
VFu_ratio_dVFu_ratio_eVDu_ratio_e
VFux_ratioVDux_ratioVEux_ratio
VFux_ratio_dVFux_ratio_eVDux_ratio_e
VFu_ratioOddEvenVDu_ratioOddEvenVEu_ratioOddEven
VFu_ratioOddEven_dVFu_ratioOddEven_eVDu_ratioOddEven_e
VFux_ratioOddEvenVDux_ratioOddEvenVEux_ratioOddEven
VFux_ratioOddEven_dVFux_ratioOddEven_eVDux_ratioOddEven_e
VFu_ratioEvenOddVDu_ratioEvenOddVEu_ratioEvenOdd
VFu_ratioEvenOdd_dVFu_ratioEvenOdd_eVDu_ratioEvenOdd_e
VFux_ratioEvenOddVDux_ratioEvenOddVEux_ratioEvenOdd
VFux_ratioEvenOdd_dVFux_ratioEvenOdd_eVDux_ratioEvenOdd_e
FunktionRatio: 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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.

FehlerbehandlungOVERFLOW- 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ückgabewertFALSE (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.
QuerverweisVF_poly,   VF_ipow,   VF_pow

 

VF_readVD_readVE_read
VCF_readVCD_readVCE_read
VPF_readVPD_readVPE_read
VI_readVBI_readVSI_readVLI_readVQI_read 
VU_readVUB_readVUS_readVUL_readVUQ_readVUI_read
FunktionEinlesen 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/Delphiuses 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/Delphiuses 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;
Beschreibungsize 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).

FehlerbehandlungC/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.

Rückgabewertkeiner
QuerverweisVF_nread,   VF_write,   VF_store,   VF_recall,   strtod,   strtol

 

VCF_realVCD_realVCE_real
VPF_realVPD_realVPE_real
FunktionRealteil 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/Delphiuses 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/Delphiuses VCFstd;
function cudaVCF_real( d_Re:fVector; d_X:cfVector; size:UIntSize ): IntBool;
procedure VCFcu_real( h_Re:fVector; h_X:cfVector; size:UIntSize );
BeschreibungIdentisch mit VF_CtoRe,   VD_CtoRe und VE_CtoRe. Siehe dort.

 

VF_recallVD_recallVE_recall
VCF_recallVCD_recallVCE_recall
VPF_recallVPD_recallVPE_recall
VI_recallVBI_recallVSI_recallVLI_recallVQI_recall 
VU_recallVUB_recallVUS_recallVUL_recallVUQ_recallVUI_recall
FunktionVektor 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/Delphiuses 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/Delphiuses 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;
Beschreibungsize 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-SicherheitVerschiedene Threads können gefahrlos mehrere Funktionen der VF_ / MF_store- und VF_ / MF_recall-Familien gleichzeitig aufrufen, solange sie auf verschiedene Streams zugreifen. Falls sie allerdings auf ein- und denselben Stream zugreifen, müssen unbedingt durch geeignete Maßnahmen (Critical Sections, Mutexes) Race−Conditions verhindert werden.
Fehlerbehandlungwird durch die C-Funktion fread bzw. die Delphi-Funktion BlockRead durchgeführt, auf der VF_recall etc. basieren
Rückgabewert0, wenn fehlerfrei; ansonsten 1. Um mehr Information im Falle eines Fehlers zu erhalten, inspiziere man errno (C/C++) oder IOResult (Delphi).
QuerverweisVF_store,   VF_write,   VF_print,   fwrite,   fread

 

VF_redCVD_redCVE_redC
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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = 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).
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_redV,   VF_addC,   VF_subC,   VF_divC,   VF_visC

 

VF_redVVD_redVVE_redV
VFx_redVVDx_redVVEx_redV
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/Delphiuses 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/Delphiuses 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 );
Beschreibungeinfache Versionen:
Zi = red( Xi, Yi ) = Xi * Yi / (Xi + Yi)
erweiterte Versionen:
xi = (A * Xi + B),
Zi = red( xi, Yi )
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_redC,   VF_addV,   VF_subV,   VF_divV,   VF_visV

 

VF_reflectVD_reflectVE_reflect
VCF_reflectVCD_reflectVCE_reflect
VPF_reflectVPD_reflectVPE_reflect
VI_reflectVBI_reflectVSI_reflectVLI_reflectVQI_reflect 
VU_reflectVUB_reflectVUS_reflectVUL_reflectVUQ_reflectVUI_reflect
Funktionobere 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/Delphiuses 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/Delphiuses VFstd;
function cudaVF_reflect( d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_reflect( h_X:fVector; size:UIntSize );
BeschreibungXsize-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).
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_rotate,   VF_rev,   VF_convolve,   VF_deconvolve,   VF_filter

 

VF_ReImtoCVD_ReImtoCVE_ReImtoC
Funktioncartesisch-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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie reellen Vektoren Re und Im werden in den Real- bzw. Imaginärteil des komplexen Vektors Y kopiert.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_CtoReIm,   VF_RetoC,   VF_PolartoC

 

VF_ReImtoPVD_ReImtoPVE_ReImtoP
FunktionPolar-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/Delphiuses 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/Delphiuses 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 );
BeschreibungAus den in den getrennten Vektoren Re und Im übergebenen cartesischen Koordinaten werden die Polarkoordinaten des Ausgabevektors Y berechnet.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_PtoReIm,   VF_MagArgtoP

 

VF_reldevCVD_reldevCVE_reldevC
FunktionRelative 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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = |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.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_reldevV,   VF_reldiffC,   VF_maxreldevC,   VF_maxindreldevC

 

VF_reldevVVD_reldevVVE_reldevV
FunktionRelative 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/Delphiuses 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/Delphiuses 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 );
BeschreibungZi = |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.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_reldiffV,   VF_reldevC,   VF_maxreldevV,   VF_maxindreldevV

 

VF_reldiffCVD_reldiffCVE_reldiffC
FunktionRelative 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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = (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

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_reldiffV,   VF_reldevC,   VF_maxreldiffC,   VF_maxindreldiffC

 

VF_reldiffVVD_reldiffVVE_reldiffV
FunktionRelative 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/Delphiuses 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/Delphiuses 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 );
BeschreibungZi = (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.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_reldevV,   VF_reldiffC,   VF_maxreldiffV,   VF_maxindreldiffV

 

VF_replaceNANVD_replaceNANVE_replaceNAN
VCF_replaceNANVCD_replaceNANVCE_replaceNAN
VPF_replaceNANVPD_replaceNANVPE_replaceNAN
FunktionErsatz 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/Delphiuses 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/Delphiuses 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 );
BeschreibungX 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_absHuge,   VF_maxC,   VF_minC,   VF_min,   VF_flush0,   VF_limit

 

VF_RetoCVD_RetoCVE_RetoC
Funktionreellen 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/Delphiuses 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/Delphiuses VCFstd;
function cudaVF_RetoC( d_X:cfVector; d_Im:fVector; size:UIntSize ): IntBool;
procedure VFcu_RetoC( h_X:cfVector; h_Im:fVector; size:UIntSize );
BeschreibungDer Realteil des komplexen Vektors Y wird mit den Elementen des reellen Vektors Re überschrieben. Der Imaginärteil von Y wird hierdurch nicht berührt.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_CtoReIm,   VF_ReImtoC,   VF_ImtoC,   VF_PolartoC

 

VF_revVD_revVE_rev
VCF_revVCD_revVCE_rev
VPF_revVPD_revVPE_rev
VI_revVBI_revVSI_revVLI_revVQI_rev 
VU_revVUB_revVUS_revVUL_revVUQ_revVUI_rev
FunktionUmkehrung 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/Delphiuses 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/Delphiuses VFstd;
function cudaVF_rev( d_Y, d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_rev( h_Y, h_X:fVector; size:UIntSize );
BeschreibungYi = Xsize-i−1
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_reflect,   VF_rotate,   VF_revconj

 

VCF_revconjVCD_revconjVCE_revconj
VPF_revconjVPD_revconjVPE_revconj
FunktionKomplex-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/Delphiuses 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/Delphiuses VCFmath;
function cudaVCF_revconj( d_Y, d_X:cfVector; size:UIntSize ): IntBool;
procedure VCFcu_revconj( h_Y, h_X:cfVector; size:UIntSize );
BeschreibungRe(Ysize-i−1) = Re(Xi)
Im(Ysize-i−1) = -Im(Xi)
Fehlerbehandlungkeine
Rückgabewertimmer FALSE(0)
QuerverweisVCF_rev,   VCF_conj,   VCF_abs

 

VF_rmsVD_rmsVE_rms
FunktionWurzel 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/Delphiuses 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/Delphiuses 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;
Beschreibungrms = sqrt( (1/size) * sum( Xi2 ) )
Fehlerbehandlungkeine
RückgabewertWurzel des mittleren Quadrates
QuerverweisVF_ssq,   VF_Euclid,   VF_mean

 

VF_rotateVD_rotateVE_rotate
VCF_rotateVCD_rotateVCE_rotate
VPF_rotateVPD_rotateVPE_rotate
VI_rotateVBI_rotateVSI_rotateVLI_rotateVQI_rotate 
VU_rotateVUB_rotateVUS_rotateVUL_rotateVUQ_rotateVUI_rotate
FunktionRotation 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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_reflect,   VF_rev

 

VF_rotate_bufVD_rotate_bufVE_rotate_buf
VCF_rotate_bufVCD_rotate_bufVCE_rotate_buf
VPF_rotate_bufVPD_rotate_bufVPE_rotate_buf
VI_rotate_bufVBI_rotate_bufVSI_rotate_bufVLI_rotate_bufVQI_rotate_buf 
VU_rotate_bufVUB_rotate_bufVUS_rotate_bufVUL_rotate_bufVUQ_rotate_bufVUI_rotate_buf
FunktionRotation 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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_rotate

 

VF_rotateCoordinatesVD_rotateCoordinatesVE_rotateCoordinates
VCF_rotateCoordinatesVCD_rotateCoordinatesVCE_rotateCoordinates
FunktionRotation 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie 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.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_lincomb

 

VF_roundVD_roundVE_round
VF_roundtoIVD_roundtoIVE_roundtoI
VF_roundtoBIVD_roundtoBIVE_roundtoBI
VF_roundtoSIVD_roundtoSIVE_roundtoSI
VF_roundtoLIVD_roundtoLIVE_roundtoLI
VF_roundtoQIVD_roundtoQIVE_roundtoQI
VF_roundtoUVD_roundtoUVE_roundtoU
VF_roundtoUBVD_roundtoUBVE_roundtoUB
VF_roundtoUSVD_roundtoUSVE_roundtoUS
VF_roundtoULVD_roundtoULVE_roundtoUL
VF_roundtoUQVD_roundtoUQVE_roundtoUQ
VF_roundtoUIVD_roundtoUIVE_roundtoUI
FunktionRundung 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/Delphiuses 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/Delphiuses 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;
BeschreibungJedes 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.
FehlerbehandlungOVERFLOW- 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ückgabewertimmer FALSE (0)
QuerverweisVF_ceil,   VF_floor,   VF_chop,   VF_trunc

 

VF_rcubicVD_rcubicVE_rcubic
VFx_rcubicVDx_rcubicVEx_rcubic
VFu_rcubicVDu_rcubicVEu_rcubic
VFux_rcubicVDux_rcubicVEux_rcubic
FunktionKehrwert 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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.

FehlerbehandlungSING- und OVERFLOW-Fehler ergeben ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_square,   VF_quartic,   VF_cubic,   VF_sqrt,   VF_pow,   VF_ipow,   VF_poly

 

VF_rquarticVD_rquarticVE_rquartic
VFx_rquarticVDx_rquarticVEx_rquartic
VFu_rquarticVDu_rquarticVEu_rquartic
VFux_rquarticVDux_rquarticVEux_rquartic
FunktionKehrwert 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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.
FehlerbehandlungSING- und OVERFLOW-Fehler ergeben HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_rsquare,   VF_rcubic,   VF_quartic,   VF_sqrt,   VF_pow,   VF_ipow,   VF_poly

 

VF_rsqrtVD_rsqrtVE_rsqrt
VFu_rsqrtVDu_rsqrtVEu_rsqrt
FunktionKehrwert 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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.

FehlerbehandlungNormale 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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_square,   VF_sqrt,   VF_pow,   VF_ipow,   VF_poly

 

VF_rsquareVD_rsquareVE_rsquare
VFx_rsquareVDx_rsquareVEx_rsquare
VFu_rsquareVDu_rsquareVEu_rsquare
VFux_rsquareVDux_rsquareVEux_rsquare
FunktionKehrwert 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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.

FehlerbehandlungSING- und OVERFLOW-Fehler ergeben HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_cubic,   VF_square,   VF_sqrt,   VF_pow,   VF_ipow,   VF_poly

 

VF_runintegralCVD_runintegralCVE_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/Delphiuses 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/Delphiuses 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 );
BeschreibungDer 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_runintegralV,   VF_integralC,   VF_derivC,   VF_runsum

 

VF_runintegralVVD_runintegralVVE_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/Delphiuses 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/Delphiuses 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 );
BeschreibungY 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_runintegralC,   VF_integralV,   VF_derivV

 

VF_runmaxVD_runmaxVE_runmax
VI_runmaxVBI_runmaxVSI_runmaxVLI_runmaxVQI_runmax
VU_runmaxVUB_runmaxVUS_runmaxVUL_runmaxVUI_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/Delphiuses 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/Delphiuses VFstd;
function cudaVF_runmax( d_Y, d_X:fVector; size:UIntSize );
procedure VFcu_runmax( h_Y, h_X:fVector; size:UIntSize );
BeschreibungJedes Element von Y ist der größte bis einschließlich zum korrespondierenden Element angetroffene Wert in X.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_max,   VF_runmin,   VF_runsum

 

VF_runminVD_runminVE_runmin
VI_runminVBI_runminVSI_runminVLI_runminVQI_runmin
VU_runminVUB_runminVUS_runminVUL_runminVUI_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/Delphiuses 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/Delphiuses VFstd;
function cudaVF_runmin( d_Y, d_X:fVector; size:UIntSize );
procedure VFcu_runmin( h_Y, h_X:fVector; size:UIntSize );
BeschreibungJedes Element von Y ist der kleinste (bzw. am stärksten negative) bis einschließlich zum korrespondierenden Element angetroffene Wert in X.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_min,   VF_runmax,   VF_runsum

 

VF_runprodVD_runprodVE_runprod
VCF_runprodVCD_runprodVCE_runprod
VPF_runprodVPD_runprodVPE_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/Delphiuses 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/Delphiuses VFstd;
function cudaVF_runprod( d_Y, d_X:fVector; size:UIntSize );
procedure VFcu_runprod( h_Y, h_X:fVector; size:UIntSize );
BeschreibungJedes 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_prod,   VF_runsum

 

VF_runsumVD_runsumVE_runsum
VCF_runsumVCD_runsumVCE_runsum
VI_runsumVBI_runsumVSI_runsumVLI_runsumVQI_runsum
VU_runsumVUB_runsumVUS_runsumVUL_runsumVUI_runsum
Funktion"Laufende" Summe
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/Delphiuses 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/Delphiuses VFstd;
function cudaVF_runsum( d_Y, d_X:fVector; size:UIntSize );
procedure VFcu_runsum( h_Y, h_X:fVector; size:UIntSize );
BeschreibungJedes Element von Y ist die Summe aller vorhergehenden und dem korrespondierenden Element von X.
Fehlerbehandlungkeine (aber Vorsicht: Überlauf kann schnell erreicht werden!)
Rückgabewertkeiner
QuerverweisVF_sum,   VF_runprod

 

VCF_sabsmaxVCD_sabsmaxVCE_sabsmax
FunktionGröß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/Delphiuses 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/Delphiuses 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;
BeschreibungDie 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).
Fehlerbehandlungkeine
Rückgabewertgrößtes Vektorelement
QuerverweisVCF_absmax,   VCF_absmaxReIm,   VCF_cabsmax

 

VCF_sabsminVCD_sabsminVCE_sabsmin
FunktionKleinstes 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/Delphiuses 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/Delphiuses 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;
BeschreibungDie 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).
Fehlerbehandlungkeine
Rückgabewertkleinstes Vektorelement
QuerverweisVCF_absmin,   VCF_absminReIm,   VCF_sabsmin

 

VF_scale10VD_scale10VE_scale10
FunktionSkalierung 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/Delphiuses 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/Delphiuses 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;
BeschreibungYi = 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.
FehlerbehandlungOVERFLOW-Fehler ergeben ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_scale2,   VF_mantexp

 

VF_scale2VD_scale2VE_scale2
FunktionSkalierung 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/Delphiuses 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/Delphiuses 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;
BeschreibungYi = Xi * (2 Expo)
FehlerbehandlungOVERFLOW-Fehler ergeben ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_scale10,   VF_mantexp,   ldexp (C/C++)

 

VF_scalprodVD_scalprodVE_scalprod
FunktionSkalarprodukt 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/Delphiuses 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/Delphiuses 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;
Beschreibungscalprod = 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.
Fehlerbehandlungkeine
RückgabewertSkalarprodukt
QuerverweisVF_prod,   VF_xprod,   VF_sum,   VF_ssq

 

VF_searchCVD_searchCVE_searchC
Funktionbinä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/Delphiuses 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/Delphiuses 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;
BeschreibungX 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.
Fehlerbehandlungkeine
RückgabewertIndex des gefundenen Tabellenelementes
QuerverweisVF_searchV,   VF_sort,   VF_polyinterpol

 

VF_searchVVD_searchVVE_searchV
Funktionbinä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/Delphiuses 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/Delphiuses 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 );
BeschreibungTab 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.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_searchC,   VF_indpick,   VF_sortind,   VF_polyinterpol

 

VF_secVD_secVE_sec
VFx_secVDx_secVEx_sec
FunktionSecans-Funktion
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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.
FehlerbehandlungSING- 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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_sec2,   VF_secrpi,   VF_cos,   VF_sech,   cos

 

VF_sec2VD_sec2VE_sec2
VFx_sec2VDx_sec2VEx_sec2
FunktionQuadrat 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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.
FehlerbehandlungSING- 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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_sec,   VF_secrpi

 

VF_sechVD_sechVE_sech
VFx_sechVDx_sechVEx_sech
FunktionHyperbel-Secans
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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache Versionen:
Yi = sech( Xi )
    = 2 / (exp( Xi ) + exp( −Xi ))
erweiterte Versionen:
Yi = C * sech( A*Xi+B )
FehlerbehandlungEs dürften keine Fehler auftreten.
Rückgabewertimmer FALSE(0)
QuerverweisVF_sinh,   VF_sech2,   VF_exp,   sinh

 

VF_sech2VD_sech2VE_sech2
VFx_sech2VDx_sech2VEx_sech2
FunktionQuadrat 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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.
FehlerbehandlungEs dürften keine Fehler auftreten.
Rückgabewertimmer FALSE(0)
QuerverweisVF_sech,   VF_sinh,   VF_exp,   VF_Gauss,   VF_Lorentz

 

VF_secrpiVD_secrpiVE_secrpi
VF_secrpi2VD_secrpi2VE_secrpi2
VF_secrpi3VD_secrpi3VE_secrpi3
FunktionSecans-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/Delphiuses 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/Delphiuses 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;
BeschreibungYi = 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.
FehlerbehandlungSING-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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_sec,   cos

 

VF_selected_meanVD_selected_meanVE_selected_mean
FunktionMittelwert 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/Delphiuses 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/Delphiuses 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;
BeschreibungEs 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.
FehlerbehandlungFalls ü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ückgabewertgefundener Mittelwert der selektierten Vektor-Elemente
QuerverweisVF_mean

 

V_setAutoCudaUse
FunktionAngabe, ob OptiVec-Funktionen automatisch den CUDA-Device nutzen sollen oder nicht
Syntax C/C++#include <cudaVecLib.h>
void V_setAutoCudaUse( int UseCuda );
Delphiuses VecLib;
procedure V_setAutoCudaUse( UseCuda: Integer );
BeschreibungStandardmäß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.
Rückgabewertkeiner
QuerverweisCudaOptiVecD.htm, Kap. 4. Unterscheidung zwischen OptiVec-Funktionen für Host- und für Device-Memory

 

V_setBoundaryCheckWarn
FunktionEin-/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/Delphiuses Veclib;
procedure V_setBoundaryCheckWarn( WarnLevel: IntBool );
BeschreibungDie 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisV_checkBoundaries

 

V_setCoordSystem
FunktionWiederherstellen der Positions- und Skalierungs-Einstellungen eines zuvor mittels V_getCoordSystem gespeicherten Koordinatensystems
Syntax C/C++#include <Vgraph.h>
void V_setCoordSystem( VCOORDSYSTEM *csys );
Pascal/Delphiuses Vgraph;
procedure V_setCoordSystem( csys: VCOORDSYSTEM );
BeschreibungUm 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisV_getCoordSystem,   V_setPlotRegion,   V_continuePlot

 

V_setCudaWorkspace
FunktionAuswahl eines cudaOptiVec-Workspace für die folgenden Funktionsaufrufe
Syntax C/C++#include <cudaVecLib.h>
overror_t V_setCudaWorkspace( V_CUDAWORKSPACE wsp );
Delphiuses VecLib;
function V_setCudaWorkspace( wsp: V_CUDAWORKSPACE ): Integer;
BeschreibungEin cudaOptiVec-Workspace, der zuvor mittels V_createCudaWorkspace angelegt wurde, wird ausgewählt für die folgenden Aufrufe von cudaV?_-Funktionen.
Rückgabewert0 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.
QuerverweisCudaOptiVecD.htm, Kap. 5. Streams und Workspaces

 

VF_setElementVD_setElementVE_setElement
VCF_setElementVCD_setElementVCE_setElement
VPF_setElementVPD_setElementVPE_setElement
VI_setElementVBI_setElementVSI_setElementVLI_setElementVQI_setElement 
VU_setElementVUB_setElementVUS_setElementVUL_setElementVUQ_setElementVUI_setElement
FunktionEin 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/Delphiuses 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/Delphiuses VFstd;
procedure cudaVF_setElement( d_X:fVector; pos:UIntSize; C:Single );
procedure cusdVF_setElement( d_X:fVector; pos:UIntSize; d_C:PSingle );
BeschreibungDas 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_Pelement,   VF_element,   VF_getElement,   VF_accElement,   VF_decElement

 

V_setErrorEventFile
FunktionEreignis-Datei zur Aufnahme von Fehlermeldungen vorbereiten
Syntax C/C++#include <VecLib.h>
void V_setErrorEventFile( char *filename, unsigned ScreenAndFile );
Pascal/Delphiuses VecLib;
procedure V_setErrorEventFile( filename:PChar; ScreenAndFile:UInt );
BeschreibungDiese 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.

FehlerbehandlungKann die Ereignisdatei nicht erzeugt oder geöffnet werden, wird das Programm mit der auf dem Bildschirm ausgegebenen Fehlermeldung "Cannot open error event file" abgebrochen.
Rückgabewertkeiner
QuerverweisV_noteError,   V_closeErrorEventFile

 

V_setFPAccuracy
FunktionGenauigkeit des Coprozessors (FPU) einstellen
Syntax C/C++#include <VecLib.h>
void V_setFPAccuracy( unsigned level );
Pascal/Delphiuses VecLib;
procedure V_setFPAccuracy( level:UInt );
BeschreibungDiese 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.
Rückgabewertkeiner
QuerverweisV_getFPAccuracy

 

V_setFPErrorHandling
FunktionVerhalten im Falle von Fließkomma-Fehlern festlegen
Syntax C/C++#include <VecLib.h>
void V_setFPErrorHandling( int fpHandlingMode );
Syntax Pascal/Delphiuses VecLib;
type V_fphand = 0..$1717;
procedure V_setFPErrorHandling( fpHandlingMode:V_fpHand );
 
BeschreibungV_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:
 
KonstanteWertBedeutung
fperrIgnore0alle Fließkomma-Fehler ignorieren: Ergebnis stillschweigend auf Standardwert setzen, keine Fehlermeldung ausgeben, Programmausführung fortsetzen
fperrNoteDOMAIN$0001Fehlermeldung für DOMAIN-Fehler ausgeben
fperrNoteSING$0002Fehlermeldung für SING-Fehler ausgeben
fperrNoteOVERFLOW$0003Fehlermeldung für OVERFLOW-Fehler ausgeben
fperrNoteTLOSS$0004Fehlermeldung für TLOSS-Fehler ausgeben
fperrAbortDOMAIN$0101Programm im Falle von DOMAIN-Fehler abbrechen
fperrAbortSING$0202Programm im Falle von SING-Fehler abbrechen
fperrAbortOVERFLOW$0303Programm im Falle von OVERFLOW-Fehler abbrechen
fperrAbortTLOSS$0404Programm im Falle von TLOSS-Fehler abbrechen
fperrDefaultHandling$0107Entspricht fperrAbortDOMAIN + fperrNoteSING + fperrNoteOVERFLOW
BeispielV_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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisV_setIntErrorHandling,   V_setErrorEventFile,   V_noteError,   V_printErrorMsg

 

V_setIntErrorHandling
FunktionVerhalten 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/Delphiuses VecLib;
type V_ihand = 0..2;
procedure V_setIntErrorHandling( ihand:V_iHand );
BeschreibungDiese 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisV_setFPErrorHandling,   V_setErrorEventFile,   V_noteError,   V_printErrorMsg,  Kap. 5.2

 

V_setLineThickness
FunktionLinienstärke für Plot-Funktionen modifizieren
Syntax C/C++#include <Vgraph.h>
void V_setLineThickness( unsigned linethickness );
Pascal/Delphiuses Vgraph;
procedure V_setLineThickness( linethickness:UInt );
BeschreibungDie 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.
FehlerbehandlungEin 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.
Rückgabewertkeiner
QuerverweisVF_xyAutoPlot,   V_setSymbolSize

 

VF_setNWriteSeparateVD_setNWriteSeparateVE_setNWriteSeparate
VCF_setNWriteSeparateVCD_setNWriteSeparateVCE_setNWriteSeparate
VPF_setNWriteSeparateVPD_setNWriteSeparateVPE_setNWriteSeparate
VI_setNWriteSeparateVBI_setNWriteSeparateVSI_setNWriteSeparate
VLI_setNWriteSeparateVQI_setNWriteSeparate
VU_setNWriteSeparateVUB_setNWriteSeparateVUS_setNWriteSeparate
VUL_setNWriteSeparateVUI_setNWriteSeparate
FunktionDefinition des von den V.._nwrite-Funktionen zu verwendenden Trenn-Strings
Syntax C/C++#include <VFstd.h>
void VF_setNWriteSeparate( char *SepString );
Pascal/Delphiuses VFstd;
procedure VF_setNWriteSeparate( SepString:PChar );
BeschreibungDiese 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).
FehlerbehandlungIm 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.
Rückgabewertkeiner
QuerverweisVF_setWriteFormat,   VF_setWriteSeparate,   VF_nwrite,   VF_nread

 

VF_setODThreshVD_setODThreshVE_setODThresh
VU_setODThreshVUB_setODThreshVUS_setODThresh
VUL_setODThreshVQI_setODThresh
FunktionSetzen 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/Delphiuses VFmath;
procedure VF_setODThresh( minX, minX0:Single );
BeschreibungWie 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_OD,   VF_ODwDark

 

V_setPlotRegion
FunktionDefinieren 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/Delphiuses Vgraph;
procedure V_setPlotRegion( left, top, right, bottom:Integer);
BeschreibungDurch 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisV_initPlot,   V_initPrint

 

V_setRadix
FunktionDefinieren 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 );
BeschreibungNach 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.

FehlerbehandlungDie Eingabe von negativen Werten, von 1 oder Werten größer als 36 führt zum Programmabbruch mit der Fehlermeldung "Invalid Parameter(s)".
Rückgabewertkeiner
QuerverweisVI_read,   VI_nread,   strtol,   strtoul

 

VF_setRspEditVD_setRspEditVE_setRspEdit
FunktionBehandlung von Rundungsfehlern in den Funktionen VF_convolve und VF_deconvolve modifizieren
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/Delphiuses VFstd;
procedure VF_setRspEdit( Trunc:fComplex );
CUDA-Funktion C/C++#include <cudaVFstd.h>
void cudaVF_setRspEdit( fComplex Trunc );
CUDA-Funktion Pascal/Delphiuses VFstd;
procedure cudaVF_setRspEdit( Trunc:fComplex );
BeschreibungIn 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.

FehlerbehandlungFalls Trunc.Re oder Trunc.Im ≥ 1.0 sind, erfolgt eine Fehlermeldung "Invalid Parameter(s)" und Abbruch des Programms.
Rückgabewertkeiner
QuerverweisVF_convolve,   VF_deconvolve,   VF_getRspEdit

 

V_setSymbolSize
FunktionGröße der in den Plot-Funktionen verwandten Symbole modifizieren
Syntax C/C++#include <Vgraph.h>
void V_setSymbolSize( float symsiz );
Pascal/Delphiuses Vgraph;
procedure V_setSymbolSize( symsize:Single );
BeschreibungDie 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.

FehlerbehandlungEin 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.
Rückgabewertkeiner
QuerverweisVF_xyAutoPlot,   V_setLineThickness

 

V_setThreadHandler
FunktionArbeits-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/Delphiuses VecLib;
function V_setThreadHandler( ThreadHandler:V_THREADHANDLERFUNC ): IntBool;
BeschreibungDiese 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ückgabewertFALSE (0), wenn der Callback fehlerfrei initialisiert werden konnte, andernfalls TRUE (≠ 0)
QuerverweisV_initMT,  Kap. 1.1.2.

 

VF_setWriteFormatVD_setWriteFormatVE_setWriteFormat
VCF_setWriteFormatVCD_setWriteFormatVCE_setWriteFormat
VPF_setWriteFormatVPD_setWriteFormatVPE_setWriteFormat
VI_setWriteFormatVBI_setWriteFormantVSI_setWriteFormat
VLI_setWriteFormatVQI_setWriteFormat
VU_setWriteFormatVUB_setWriteFormatVUS_setWriteFormat
VUL_setWriteFormatVUI_setWriteFormat
FunktionDefinition 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 );
BeschreibungDie 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.

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

FehlerbehandlungIm 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.
Rückgabewertkeiner
QuerverweisVF_setWriteSeparate,   VF_write,   VF_nwrite,   VF_read,   VF_nread

 

VF_setWriteSeparateVD_setWriteSeparateVE_setWriteSeparate
VCF_setWriteSeparateVCD_setWriteSeparateVCE_setWriteSeparate
VPF_setWriteSeparateVPD_setWriteSeparateVPE_setWriteSeparate
VI_setWriteSeparateVBI_setWriteSeparateVSI_setWriteSeparate
VLI_setWriteSeparateVQI_setWriteSeparate
VU_setWriteSeparateVUB_setWriteSeparateVUS_setWriteSeparate
VUL_setWriteSeparateVUI_setWriteSeparate
FunktionDefinition 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/Delphiuses VFstd;
procedure VF_setWriteSeparate( SepString:PChar );
BeschreibungDiese 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.

FehlerbehandlungIm 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.
Rückgabewertkeiner
QuerverweisVF_setWriteFormat,   VF_setNWriteSeparate,   VF_write,   VF_read

 

VF_sgnVD_sgnVE_sgn
FunktionSignum-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/Delphiuses 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/Delphiuses VFmath;
function cudaVF_sgn( d_Y, d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_sgn( h_Y, h_X:fVector; size:UIntSize );
BeschreibungJedes 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_cmp_...,   VF_cmpC,   VF_cmpV

 

VI_shlVBI_shlVSI_shlVLI_shlVQI_shl 
VU_shlVUB_shlVUS_shlVUL_shlVUQ_shlVUI_shl
FunktionBit-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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVI_mulC,   VI_shr

 

VI_shrVBI_shrVSI_shrVLI_shrVQI_shr 
VU_shrVUB_shrVUS_shrVUL_shrVUQ_shrVUI_shr
FunktionBit-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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVI_divC,   VI_shl

 

VF_sinVD_sinVE_sin
VFx_sinVDx_sinVEx_sin
VFr_sinVDr_sinVEr_sin
VFrx_sinVDrx_sinVErx_sin
VCF_sinVCD_sinVCE_sin
VCFx_sinVCDx_sinVCEx_sin
FunktionSinus-Funktion
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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.

FehlerbehandlungGenauigkeits-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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_sin2,   VF_sinrpi,   VF_cos,   VF_sinh,   VF_asin,   sin

 

VF_sin2VD_sin2VE_sin2
VFx_sin2VDx_sin2VEx_sin2
VFr_sin2VDr_sin2VEr_sin2
VFrx_sin2VDrx_sin2VErx_sin2
FunktionQuadrat 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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.

FehlerbehandlungGenauigkeits-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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_sin,   VF_sinrpi,  sin

 

VF_sincVD_sincVE_sinc
VFx_sincVDx_sincVEx_sinc
FunktionSinc-Funktion
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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.
FehlerbehandlungFü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ückgabewertimmer FALSE(0).
QuerverweisVF_sin,   VF_sinrpi,   sin

 

VF_sincosVD_sincosVE_sincos
VFx_sincosVDx_sincosVEx_sincos
VFr_sincosVDr_sincosVEr_sincos
VFrx_sincosVDrx_sincosVErx_sincos
FunktionSinus- 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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.

FehlerbehandlungGenauigkeits-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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_sincos2,   VF_sincosrpi,   sin,   cos

 

VF_sincos2VD_sincos2VE_sincos2
VFx_sincos2VDx_sincos2VEx_sinco2
VFr_sincos2VDr_sincos2VEr_sincos2
VFrx_sincos2VDrx_sincos2VErx_sinco2
FunktionQuadrat 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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.

FehlerbehandlungGenauigkeits-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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_sincos,   sin,   cos

 

VF_sincosrpiVD_sincosrpiVE_sincosrpi
VF_sincosrpi2VD_sincosrpi2VE_sincosrpi2
VF_sincosrpi3VD_sincosrpi3VE_sincosrpi3
FunktionSinus 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/Delphiuses 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/Delphiuses 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;
BeschreibungYSini = 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.
FehlerbehandlungEs dürften keine Fehler auftreten, solange q ≠ 0.
Rückgabewertimmer FALSE(0)
QuerverweisVF_sincos,   sin,   cos

 

VF_sinhVD_sinhVE_sinh
VCF_sinhVCD_sinhVCE_sinh
VFx_sinhVDx_sinhVEx_sinh
VCFx_sinhVCDx_sinhVCEx_sinh
FunktionHyperbel-Sinus
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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache Versionen: Yi = sinh( Xi )
erweiterte Versionen: Yi = C * sinh ( A*Xi+B )
FehlerbehandlungOVERFLOW-Fehler ergeben ±HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_cosh,   VF_exp,   sinh

 

VF_sinrpiVD_sinrpiVE_sinrpi
VF_sinrpi2VD_sinrpi2VE_sinrpi2
VF_sinrpi3VD_sinrpi3VE_sinrpi3
FunktionSinus 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/Delphiuses 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/Delphiuses 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;
BeschreibungYi = 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.
FehlerbehandlungEs dürften keine Fehler auftreten, solange q ≠ 0.
Rückgabewertimmer FALSE(0)
QuerverweisVF_sin,   sin

 

VF_sintab2VD_sintab2VE_sintab2
VF_sintab3VD_sintab3VE_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/Delphiuses 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;
BeschreibungVF_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.

QuerverweisVF_sinrpi2,   VF_tantab2,   VF_cosectab2

 

VF_smoothVD_smoothVE_smooth
FunktionGlättung
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/Delphiuses 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/Delphiuses 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 );
BeschreibungEs 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_filter,   VF_biquad

 

VF_sortVD_sortVE_sort
VI_sortVBI_sortVSI_sortVLI_sortVQI_sort
VU_sortVUB_sortVUS_sortVUL_sortVUI_sort
FunktionSortieren 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/Delphiuses 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/Delphiuses 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 );
BeschreibungFü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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_sortind,   VF_rotate,   VF_rev,   qsort (nur C/C++)

 

VF_sortindVD_sortindVE_sortind
VI_sortindVBI_sortindVSI_sortindVLI_sortindVQI_sortind
VU_sortindVUB_sortindVUS_sortindVUL_sortindVUI_sortind
FunktionSortieren 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/Delphiuses 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/Delphiuses 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_sort,   VF_indpick

 

VF_spectrumVD_spectrumVE_spectrum
VFb_spectrumVDb_spectrumVEb_spectrum
Funktioneinseitige 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/Delphiuses 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/Delphiuses 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;
BeschreibungDer 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.

FehlerbehandlungWenn 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ückgabewertspektrale Leistungsdichte bei der Nyquist-Frequenz
QuerverweisVF_FFT,   VF_xspectrum,   VF_convolve,   VF_autocorr,   VF_xcorr,   VF_filter

 

VF_splinederiv2VD_splinederiv2VE_splinederiv2
FunktionErzeugung 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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie 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.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_splineinterpol

 

VF_splineinterpolVD_splineinterpolVE_splineinterpol
Funktionallgemeine 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/Delphiuses 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/Delphiuses 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 );
BeschreibungFü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.
Fehlerbehandlungkeine (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.)
Rückgabewertkeiner
QuerverweisVF_splinederiv2,   VF_natCubSplineInterpol,   VF_ratinterpol,   VF_polyinterpol

 

VF_sqrtVD_sqrtVE_sqrt
VFu_sqrtVDu_sqrtVEu_sqrt
VCF_sqrtVCD_sqrtVCE_sqrt
VFx_sqrtVDx_sqrtVEx_sqrt
VFux_sqrtVDux_sqrtVEux_sqrt
VCFx_sqrtVCDx_sqrtVCEx_sqrt
VPF_sqrtVPD_sqrtVPE_sqrt
FunktionQuadratwurzel
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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.

FehlerbehandlungNormale 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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_square,   VF_rsqrt,   VF_pow,   VF_ipow,   VF_poly

 

VF_squareVD_squareVE_square
VFx_squareVDx_squareVEx_square
VFu_squareVDu_squareVEu_square
VFux_squareVDux_squareVEux_square
VCF_squareVCD_squareVCE_square
VCFx_squareVCDx_squareVCEx_square
VCFu_squareVCDu_squareVCEu_square
VCFux_squareVCDux_squareVCEux_square
VPF_squareVPD_squareVPE_square
VPFu_squareVPDu_squareVPEu_square
FunktionQuadrat
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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.

FehlerbehandlungOVERFLOW-Fehler ergeben HUGE_VAL.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0)
QuerverweisVF_cubic,   VF_rsquare,   VF_sqrt,   VF_pow,   VF_ipow,   VF_poly

 

VF_ssqVD_ssqVE_ssq
FunktionQuadratsumme (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/Delphiuses 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/Delphiuses 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;
Beschreibungssq = Summe( Xi2 )
Fehlerbehandlungkeine (aber Vorsicht: diese Funktion neigt zum Überlauf!)
RückgabewertQuadratsumme
QuerverweisVF_sum,   VF_rms,   VF_ssqdevC,   VF_scalprod,   VF_Euclid

 

VF_ssqdevCVD_ssqdevCVE_ssqdevC
FunktionQuadratsumme 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/Delphiuses 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/Delphiuses 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;
BeschreibungssqdevC = sum( (Xi - C)2 )
Fehlerbehandlungkeine
Rückgabewertdie gefundene Quadratsumme der Abweichungen
QuerverweisVF_ssq,   VF_ssqdevV,   VF_avdevC,   VF_sumdevC,   VF_chi2

 

VF_ssqdevVVD_ssqdevVVE_ssqdevV
VF_ssqdevVwSaturationVD_ssqdevVwSaturationVE_ssqdevVwSaturation
FunktionQuadratsumme 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/Delphiuses 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/Delphiuses 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;
BeschreibungssqdevV = 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.

Fehlerbehandlungkeine
Rückgabewertdie gefundene Quadratsumme der Abweichungen
QuerverweisVF_ssq,   VF_ssqdevC,   VF_avdevV,   VF_sumdevV,   VF_chi2

 

VF_storeVD_storeVE_store
VCF_storeVCD_storeVCE_store
VPF_storeVPD_storeVPE_store
VI_storeVBI_storeVSI_storeVLI_storeVQI_store 
VU_storeVUB_storeVUS_storeVUL_storeVUQ_storeVUI_store
FunktionSpeichern 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/Delphiuses 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/Delphiuses 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 );
Beschreibungsize 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-SicherheitVerschiedene Threads können gefahrlos mehrere Funktionen der VF_ / MF_store- und VF_ / MF_recall-Familien gleichzeitig aufrufen, solange sie auf verschiedene Streams zugreifen. Falls sie allerdings auf ein- und denselben Stream zugreifen, müssen unbedingt durch geeignete Maßnahmen (Critical Sections, Mutexes) Race−Conditions verhindert werden.
Fehlerbehandlungwird durch die C-Funktion fwrite bzw. die Delphi-Funktion BlockWrite durchgeführt, auf der MF_store etc. basieren
Rückgabewert0, wenn fehlerfrei; ansonsten 1. Um mehr Information im Falle eines Fehlers zu erhalten, inspiziere man errno (C/C++) oder IOResult (Delphi).
QuerverweisVF_recall,   VF_write,   VF_cprint,   VF_print

 

VF_subCVD_subCVE_subC
VCF_subCVCD_subCVCE_subC
VCF_subReCVCD_subReCVCE_subReC
VI_subCVBI_subCVSI_subCVLI_subCVQI_subC 
VU_subCVUB_subCVUS_subCVUL_subCVUQ_subCVUI_subC
FunktionKonstante 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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = 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.
FehlerbehandlungFließkomma-Versionen: keine;
Ganzzahl-Versionen: siehe Kap. 5.2.
Rückgabewertkeiner
QuerverweisVF_subV,   VF_subrC,   VF_addC,   VF_mulC,   VF_divC

 

VF_subrCVD_subrCVE_subrC
VCF_subrCVCD_subrCVCE_subrC
VCF_subrReCVCD_subrReCVCE_subrReC
VI_subrCVBI_subrCVSI_subrCVLI_subrCVQI_subrC 
VU_subrCVUB_subrCVUS_subrCVUL_subrCVUQ_subrCVUI_subrC
Funktionumgekehrte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = 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.
FehlerbehandlungFließkomma-Versionen: keine;
Ganzzahl-Versionen: siehe Kap. 5.2.
Rückgabewertkeiner
QuerverweisVF_addV,   VF_subC,   VF_mulC,   VF_divC,   VF_visC,   VF_redC

 

VF_subrVVD_subrVVE_subrV
VCF_subrVVCD_subrVVCE_subrV
VCF_subrReVVCD_subrReVVCE_subrReV
VFx_subrVVDx_subrVVEx_subrV
VCFx_subrVVCDx_subrVVCEx_subrV
VCFx_subrReVVCDx_subrReVVCEx_subrReV
VI_subrVVBI_subrVVSI_subrVVLI_subrVVQI_subrV 
VU_subrVVUB_subrVVUS_subrVVUL_subrVVUQ_subrVVUI_subrV
FunktionUmgekehrte 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/Delphiuses 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/Delphiuses 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 );
Beschreibungeinfache 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).
FehlerbehandlungFließkomma-Versionen: keine;
Ganzzahl-Versionen: siehe Kap. 5.2.
Rückgabewertkeiner
QuerverweisVF_subrC,   VF_addV,   VF_mulV,   VF_divV,   VF_subV,   VF_subrVI

 

VF_subrVIVD_subrVIVE_subrVI
VF_subrVBIVD_subrVBIVE_subrVBI
VF_subrVSIVD_subrVSIVE_subrVSI
VF_subrVLIVD_subrVLIVE_subrVLI
VF_subrVQIVD_subrVQIVE_subrVQI
VF_subrVUVD_subrVUVE_subrVU
VF_subrVUBVD_subrVUBVE_subrVUB
VF_subrVUSVD_subrVUSVE_subrVUS
VF_subrVULVD_subrVULVE_subrVUL
VF_subrVUQVD_subrVUQVE_subrVUQ
VF_subrVUIVD_subrVUIVE_subrVUI
FunktionUmgekehrte 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/Delphiuses 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/Delphiuses 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 );
BeschreibungZi = Yi - Xi
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_subrV,   VF_subVI,   VF_addVI

 

VF_subVVD_subVVE_subV
VCF_subVVCD_subVVCE_subV
VCF_subReVVCD_subReVVCE_subReV
VFs_subVVDs_subVVEs_subV
VFx_subVVDx_subVVEx_subV
VCFx_subVVCDx_subVVCEx_subV
VCFx_subReVVCDx_subReVVCEx_subReV
VI_subVVBI_subVVSI_subVVLI_subVVQI_subV 
VU_subVVUB_subVVUS_subVVUL_subVVUQ_subVVUI_subV
FunktionSubtraktion 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/Delphiuses 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/Delphiuses 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 );
Beschreibungeinfache 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").
FehlerbehandlungFließkomma-Versionen: keine;
Ganzzahl-Versionen: siehe Kap. 5.2.
Rückgabewertkeiner
QuerverweisVF_subC,   VF_addV,   VF_mulV,   VF_divV,   VF_subrV,   VF_subVI

 

VF_subVIVD_subVIVE_subVI
VF_subVBIVD_subVBIVE_subVBI
VF_subVSIVD_subVSIVE_subVSI
VF_subVLIVD_subVLIVE_subVLI
VF_subVQIVD_subVQIVE_subVQI
VF_subVUVD_subVUVE_subVU
VF_subVUBVD_subVUBVE_subVUB
VF_subVUSVD_subVUSVE_subVUS
VF_subVULVD_subVULVE_subVUL
VF_subVUQVD_subVUQVE_subVUQ
VF_subVUIVD_subVUIVE_subVUI
FunktionGanzzahlvektor 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/Delphiuses 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/Delphiuses 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 );
BeschreibungZi = Xi - Yi
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_subV,   VF_subrVI,   VF_addVI

 

VF_subV_chiabsVD_subV_chiabsVE_subV_chiabs
FunktionZwei 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/Delphiuses 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/Delphiuses 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;
BeschreibungZi = 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.

Fehlerbehandlungkeine
Rückgabewertchiabs-Funktion der Differenzen zwischen den einzelnen Elementen der beiden Vektoren
QuerverweisVF_subV,   VF_chiabs,   VF_subV_ssq,   VF_subV_chi2,   Kap. 13 von MATRIXD.HTM

 

VF_subV_chi2VD_subV_chi2VE_subV_chi2
FunktionZwei 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/Delphiuses 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/Delphiuses 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;
BeschreibungZi = 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.

Fehlerbehandlungkeine
Rückgabewertc2-Funktion der Differenzen zwischen den einzelnen Elementen der beiden Vektoren
QuerverweisVF_subV,   VF_chi2,   VF_subV_ssq,   VF_subV_chiabs,   Kap. 13 von MATRIXD.HTM

 

VF_subV_ssqVD_subV_ssqVE_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/Delphiuses 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/Delphiuses 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;
BeschreibungZi = 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.

Fehlerbehandlungkeine
RückgabewertQuadrat-Summe der Differenzen zwischen den einzelnen Elementen der beiden Vektoren
QuerverweisVF_subV,   VF_ssqdevV,   VF_subV_sumabs,   VF_subV_chi2,   Kap. 13 von MATRIXD.HTM

 

VF_subV_sumabsVD_subV_sumabsVE_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/Delphiuses 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/Delphiuses 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;
BeschreibungZi = 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.

Fehlerbehandlungkeine
RückgabewertSumme der Absolutwerte der Differenzen zwischen den einzelnen Elementen der beiden Vektoren
QuerverweisVF_subV,   VF_sumdevV,   VF_subV_ssq,   VF_subV_chi2,   Kap. 13 von MATRIXD.HTM

 

VF_sub2VVD_sub2VVE_sub2V
FunktionZwei 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/Delphiuses 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/Delphiuses 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 );
BeschreibungZi = Xi - Y1i - Y2i
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_subV,   VF_add2V

 

VF_subvectorVD_subvectorVE_subvector
VCF_subvectorVCD_subvectorVCE_subvector
VPF_subvectorVPD_subvectorVPE_subvector
VI_subvectorVBI_subvectorVSI_subvectorVLI_subvectorVQI_subvector 
VU_subvectorVUB_subvectorVUS_subvectorVUL_subvectorVUQ_subvectorVUI_subvector
FunktionUnter-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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_indpick,   VF_CtoRe

 

VF_subvector_...VD_subvector_...VE_subvector_...
VCF_subvector_...VCD_subvector_...VCE_subvector_...
VPF_subvector_...VPD_subvector_...VPE_subvector_...
 ..._addC..._addV
 ..._divC..._divV
 ..._divrC..._divrV
 ..._mulC..._mulV
 ..._subC..._subV
 ..._subrC..._subrV
FunktionArithmetische 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/Delphiuses 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/Delphiuses 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.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_subvector,   VF_subvector_equC,   VF_subvector_equV,   VF_addC

 

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_...
 ..._equC..._equV
 ..._equC..._equV

FunktionInitialisierung 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/Delphiuses 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/Delphiuses 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_subvector,   VF_equC,   VF_equV,   VF_subvector_addC

 

VF_sumVD_sumVE_sum
VCF_sumVCD_sumVCE_sum
VI_sumVBI_sumVSI_sumVLI_sumVQI_sum 
VU_sumVUB_sumVUS_sumVUL_sumVUQ_sumVUI_sum
FunktionSumme 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/Delphiuses 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/Delphiuses 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;
Beschreibungsum = 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.
Fehlerbehandlungkeine (aber Vorsicht: diese Funktion neigt zum Überlauf!)
RückgabewertSumme der Vektorelemente (außer komplexe Versionen in Pascal/Delphi)
QuerverweisVF_runsum,   VI_fsum,   VF_prod,   VF_ssq,   VF_ssqdevC,   VF_mean

 

VF_sumabsVD_sumabsVE_sumabs
FunktionSumme 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/Delphiuses 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/Delphiuses 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;
Beschreibungsumabs = Summe(| Xi |)
Fehlerbehandlungkeine (aber Vorsicht: diese Funktion neigt zum Überlauf!)
RückgabewertBetragssumme
QuerverweisVF_sum,   VF_meanabs

 

VF_sumdevCVD_sumdevCVE_sumdevC
FunktionSumme 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/Delphiuses 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/Delphiuses 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;
BeschreibungsumdevC = sum( |Xi - C| )
Fehlerbehandlungkeine
RückgabewertSumme der Abweichungs-Beträge
QuerverweisVF_ssqdevC,   VF_sumdevV,   VF_avdevC

 

VF_sumdevVVD_sumdevVVE_sumdevV
VF_sumdevVwSaturationVD_sumdevVwSaturationVE_sumdevVwSaturation
FunktionSumme 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/Delphiuses 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/Delphiuses 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;
BeschreibungsumdevV = 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.

Fehlerbehandlungkeine
RückgabewertSumme der Abweichungs-Beträge
QuerverweisVF_sum,   VF_sumdevC,   VF_avdevV,   VF_ssqdevV

 

cudaV_synchronize
FunktionWarten bis zum Abschluss aller aktiven Prozesse im aktuellen Workspace
Syntax C/C++#include <cudaVecLib.h>
void cudaV_synchronize( void );
Delphiuses VecLib;
procedure cudaV_synchronize;
BeschreibungWie 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.
Rückgabewertkeiner
QuerverweisCudaOptiVecD.htm - Kap. 4. Die Unterscheidung von OptiVec-Funktionen für Host- und für Device-Memory

 

VF_tanVD_tanVE_tan
VCF_tanVCD_tanVCE_tan
VFx_tanVDx_tanVEx_tan
VCFx_tanVCDx_tanVCEx_tan
FunktionTangens-Funktion
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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.
FehlerbehandlungSING- und OVERFLOW-Fehler (für Argumente nahe p/2) führen zum Ergebnis ±HUGE_VAL. TLOSS-Fehler ergeben ein Resultat von 0.0.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_tan2,   VF_tanrpi,   VF_sin,   VF_tanh,   VF_atan,   VF_atan2,   tan

 

VF_tan2VD_tan2VE_tan2
VFx_tan2VDx_tan2VEx_tan2
FunktionQuadrat 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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache 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.
FehlerbehandlungSING- und OVERFLOW-Fehler (für Argumente nahe p/2) führen zum Ergebnis ±HUGE_VAL. TLOSS-Fehler ergeben ein Resultat von 0.0.
RückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_tan,   VF_tanrpi

 

VF_tanhVD_tanhVE_tanh
VCF_tanhVCD_tanhVCE_tanh
VFx_tanhVDx_tanhVEx_tanh
VCFx_tanhVCDx_tanhVCEx_tanh
FunktionHyperbel-Tangens
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/Delphiuses 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/Delphiuses 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;
Beschreibungeinfache Versionen:
Yi =  tanh( Xi )
     =  exp( Xi ) - exp( −Xi )
exp( Xi ) + exp( −Xi )
 
erweiterte Versionen:
Yi = C * tanh( A*Xi+B )
FehlerbehandlungEs dürften keine Fehler auftreten.
Rückgabewertimmer FALSE(0).
QuerverweisVF_sinh,   VF_exp,   tanh

 

VF_tanrpiVD_tanrpiVE_tanrpi
VF_tanrpi2VD_tanrpi2VE_tanrpi2
VF_tanrpi3VD_tanrpi3VE_tanrpi3
FunktionTangens 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/Delphiuses 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/Delphiuses 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;
BeschreibungYi = 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.
FehlerbehandlungSING-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ückgabewertFALSE (0), wenn fehlerfrei, andernfalls TRUE (≠ 0).
QuerverweisVF_tan,   tan

 

VF_tantab2VD_tantab2VE_tantab2
VF_tantab3VD_tantab3VE_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/Delphiuses 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;
BeschreibungVF_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.

QuerverweisVF_tanrpi2,   VF_sintab2,   VF_cosectab2

 

VF_truncVD_truncVE_trunc
VF_trunctoIVD_trunctoIVE_trunctoI
VF_trunctoBIVD_trunctoBIVE_trunctoBI
VF_trunctoSIVD_trunctoSIVE_trunctoSI
VF_trunctoLIVD_trunctoLIVE_trunctoLI
VF_trunctoQIVD_trunctoQIVE_trunctoQI
VF_trunctoUVD_trunctoUVE_trunctoU
VF_trunctoUBVD_trunctoUBVE_trunctoUB
VF_trunctoUSVD_trunctoUSVE_trunctoUS
VF_trunctoULVD_trunctoULVE_trunctoUL
VF_trunctoUQVD_trunctoUQVE_trunctoUQ
VF_trunctoUIVD_trunctoUIVE_trunctoUI
FunktionRundung 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/Delphiuses 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/Delphiuses 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;
BeschreibungDiese 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.

 

V_UtoFV_UtoDV_UtoE
V_UBtoFV_UBtoDV_UBtoE
V_UStoFV_UStoDV_UStoE
V_ULtoFV_ULtoDV_ULtoE
V_UQtoFV_UQtoDV_UQtoE
V_UItoFV_UItoDV_UItoE
FunktionDatentyp-Umwandlungen. Siehe V_ItoF!

 

VF_varianceCVD_varianceCVE_varianceC
FunktionVarianz 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/Delphiuses 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/Delphiuses 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;
Beschreibungvar = (1 / size) * Summe( (Xi - C)2 )
Fehlerbehandlungkeine
Rückgabewertberechnete Varianz
QuerverweisVF_mean,   VF_varianceV,   VF_ssq,   VF_ssqdevC,   VF_linregress

 

VF_varianceCwWVD_varianceCwWVE_varianceCwW
Funktiongewichtete 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/Delphiuses 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/Delphiuses 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;
Beschreibungvar = (1 / Summe( Wti )) * Summe( Wti * (Xi - C)2 )
Die Wichtung muss nicht normiert sein.
Fehlerbehandlungkeine
Rückgabewertberechnete Varianz
QuerverweisVF_meanwW,   VF_varianceC,   VF_varianceVwW,   VF_linregress

 

VF_varianceVVD_varianceVVE_varianceV
FunktionVarianz 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/Delphiuses 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/Delphiuses 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;
Beschreibungvar = (1 / size) * Summe( (Xi - Yi)2 )
Fehlerbehandlungkeine
Rückgabewertberechnete Varianz
QuerverweisVF_mean,   VF_varianceC,   VF_ssq,   VF_ssqdevV,   VF_linregress

 

VF_varianceVwWVD_varianceVwWVE_varianceVwW
FunktionVarianz 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/Delphiuses 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/Delphiuses 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;
Beschreibungvar = (1 / Summe(Wti)) * Summe( Wti * (Xi - Yi)2 )
Die Gewichte müssen nicht normiert sein.
Fehlerbehandlungkeine
Rückgabewertberechnete Varianz
QuerverweisVF_meanwW,   VF_chi2,   VF_varianceV,   VF_varianceCwW,   VF_linregress

 

VF_vectorVD_vectorVE_vector
VCF_vectorVCD_vectorVCE_vector
VPF_vectorVPD_vectorVPE_vector
VI_vectorVBI_vectorVSI_vectorVLI_vectorVQI_vector 
VU_vectorVUB_vectorVUS_vectorVUL_vectorVUQ_vectorVUI_vector
FunktionSpeicher-Reservierung für einen Vektor
Syntax C/C++#include <VFstd.h>
fVector VF_vector( ui size );
Pascal/Delphiuses VecLib;
function VF_vector( size:UIntSize ): fVector;
CUDA-Funktion C/C++#include <cudaVFstd.h>
fVector cudaVF_vector( ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_vector( size:UIntSize ): fVector;
BeschreibungEs 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.

FehlerbehandlungIm 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ückgabewertZeiger auf die reservierte Speicherstelle
Querverweismalloc,   calloc,   cudaVF_pinnedVector

 

VF_vector0VD_vector0VE_vector0
VCF_vector0VCD_vector0VCE_vector0
VPF_vector0VPD_vector0VPE_vector0
VI_vector0VBI_vector0VSI_vector0VLI_vector0VQI_vector0 
VU_vector0VUB_vector0VUS_vector0VUL_vector0VUQ_vector0VUI_vector0
FunktionSpeicher-Zuweisung und Initialisierung mit 0
Syntax C/C++#include <VFstd.h>
fVector VF_vector0( ui size );
Pascal/Delphiuses VecLib;
function VF_vector0( size:UIntSize ): fVector;
CUDA-Funktion C/C++#include <cudaVFstd.h>
fVector cudaVF_vector0( ui size );
CUDA-Funktion Pascal/Delphiuses VFstd;
function cudaVF_vector0( size:UIntSize ): fVector;
BeschreibungIn 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.
FehlerbehandlungIm 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ückgabewertZeiger auf die reservierte Speicherstelle
Querverweismalloc,   calloc,   cudaVF_pinnedVector0

 

VF_visCVD_visCVE_visC
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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_redV,   VF_addC,   VF_subC,   VF_divC,   VF_visV

 

VF_visVVD_visVVE_visV
VFx_visVVDx_visVVEx_visV
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/Delphiuses 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/Delphiuses 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 );
Beschreibungeinfache 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_visC,   VF_addV,   VF_subV,   VF_divV,   VF_redV

 

VF_WelchVD_WelchVE_Welch
FunktionWelch-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/Delphiuses 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/Delphiuses VFstd;
function cudaVF_Welch( d_X:fVector; size:UIntSize ): IntBool;
procedure VFcu_Welch( h_X:fVector; size:UIntSize );
BeschreibungXi = 1 - ( (i - 0.5*(size - 1)) / (0.5*(size + 1)) )2
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_Parzen,   VF_Hann,   VF_spectrum

 

VF_writeVD_writeVE_write
VCF_writeVCD_writeVCE_write
VPF_writeVPD_writeVPE_write
VI_writeVBI_writeVSI_writeVLI_writeVQI_write 
VU_writeVUB_writeVUS_writeVUL_writeVUQ_writeVUI_write
FunktionVektor 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/Delphiuses 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/Delphiuses 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;
Beschreibungsize 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).
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_setWriteFormat,   VF_setWriteSeparate,   VF_nwrite,   VF_read,   VF_store,   VF_cprint,   VF_print,   fprintf

 

VF_xcorrVD_xcorrVE_xcorr
VFb_xcorrVDb_xcorrVEb_xcorr
FunktionKreuzkorrelationsfunktion
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/Delphiuses 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/Delphiuses 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 );
BeschreibungDie 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.

FehlerbehandlungWenn 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.
Rückgabewertkeiner
QuerverweisVF_FFT,   VF_xspectrum,   VF_coherence,   VF_convolve,   VF_autocorr,   VF_spectrum

 

VI_xorVBI_xorVSI_xorVLI_xorVQI_xor 
VU_xorVUB_xorVUS_xorVUL_xorVUQ_xorVUI_xor
FunktionBit-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/Delphiuses 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/Delphiuses 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 );
BeschreibungYi = (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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVI_not,   VI_and,   VI_or

 

VF_xprodVD_xprodVE_xprod
FunktionKreuz- 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/Delphiuses 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/Delphiuses VFstd;
function cudaVF_xprod( d_Z, d_X, d_Y:fVector ): IntBool;
procedure VF_xprod( h_Z, h_X, h_Y:fVector );
BeschreibungZ = 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_scalprod,   VF_Euclid

 

VF_xspectrumVD_xspectrumVE_xspectrum
VF_xspectrumAbsVD_xspectrumAbsVE_xspectrumAbs
VFb_xspectrumVDb_xspectrumVEb_xspectrum
VFb_xspectrumAbsVDb_xspectrumAbsVEb_xspectrumAbs
FunktionKreuz-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/Delphiuses 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/Delphiuses 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;
BeschreibungDas 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.

FehlerbehandlungWenn 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ückgabewertVF_xspectrum: keiner.
VF_xspectrumAbs: spektrale Kreuz-Leistungsdichte bei der Nyquist-Frequenz
QuerverweisVF_FFT,   VF_spectrum,   VF_convolve,   VF_autocorr,   VF_xcorr,   VF_filter

 

VF_xyAutoPlotVD_xyAutoPlotVE_xyAutoPlot
VI_xyAutoPlotVBI_xyAutoPlotVSI_xyAutoPlot
VLI_xyAutoPlotVQI_xyAutoPlot
VU_xyAutoPlotVUB_xyAutoPlotVUS_xyAutoPlot
VUL_xyAutoPlotVUQ_xyAutoPlotVUI_xyAutoPlot
 ..._xyAutoPlot_xlg_ylin 
 ..._xyAutoPlot_xlg_ylg 
 ..._xyAutoPlot_xlin_ylg 
FunktionAuftragung 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/Delphiuses 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 );
BeschreibungEin 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_ylinX-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-StilBGI C/C++BGI PascalAussehen
PS_SOLIDSOLID_LINESolidLn–––– (Standard)
PS_DOTDOTTED_LINEDottedLn·········
PS_DASHDASHED_LINEDashedLn- - - -
PS_DASHDOTCENTER_LINECenterLn- · - · -
PS_DASHDOTDOT  - · · - · ·
PS_NULLNULL_LINENullLn(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_HOLLOWohne Füllung   (Standard)
SY_FILLEDganz ausgefüllt
SY_DOTTEDhohl 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.

Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_xyDataPlot,   VF_yAutoPlot,   VCF_autoPlot,   V_drawAxes,   V_findAxes,   V_setSymbolSize,  Kap. 4.12

 

VF_xy2AutoPlotVD_xy2AutoPlotVE_xy2AutoPlot
VI_xy2AutoPlotVBI_xy2AutoPlotVSI_xy2AutoPlot
VLI_xy2AutoPlotVQI_xy2AutoPlot
VU_xy2AutoPlotVUB_xy2AutoPlotVUS_xy2AutoPlot
VUL_xy2AutoPlotVUQ_xy2AutoPlotVUI_xy2AutoPlot
 ..._xy2AutoPlot_xlg_ylin 
 ..._xy2AutoPlot_xlg_ylg 
 ..._xy2AutoPlot_xlin_ylg 
FunktionCartesisches 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/Delphiuses 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 );
BeschreibungY1 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_ylinX-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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_xyAutoPlot,   VF_yAutoPlot,   VCF_autoPlot,   V_drawAxes,   V_findAxes

 

VF_xyDataPlotVD_xyDataPlotVE_xyDataPlot
VI_xyDataPlotVBI_xyDataPlotVSI_xyDataPlot
VLI_xyDataPlotVQI_xyDataPlot
VU_xyDataPlotVUB_xyDataPlotVUS_xyDataPlot
VUL_xyDataPlotVUQ_xyDataPlotVUI_xyDataPlot
FunktionAuftragung 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/Delphiuses Vgraph;
procedure VF_xyDataPlot( X, Y:fVector; size:UIntSize; form:UInt; color:COLORREF );
BeschreibungDer 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_xyAutoPlot,   VF_yAutoPlot,   VCF_autoPlot,   V_drawAxes,   V_findAxes

 

VF_yAutoPlotVD_yAutoPlotVE_yAutoPlot
VI_yAutoPlotVBI_yAutoPlotVSI_yAutoPlot
VLI_yAutoPlotVQI_yAutoPlot
VU_yAutoPlotVUB_yAutoPlotVUS_yAutoPlot
VUL_yAutoPlotVUQ_yAutoPlotVUI_yAutoPlot
 ..._yAutoPlot_xlg_ylin 
 ..._yAutoPlot_xlg_ylg 
 ..._yAutoPlot_xlin_ylg 
FunktionAuftragung 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/Delphiuses 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 );
BeschreibungEin 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_ylinX-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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_yDataPlot,   VF_y2AutoPlot,   VF_xyAutoPlot,   VCF_autoPlot,   V_drawAxes,   V_findAxes,  Kap. 4.12

 

VF_y2AutoPlotVD_y2AutoPlotVE_y2AutoPlot
VI_y2AutoPlotVBI_y2AutoPlotVSI_y2AutoPlot
VLI_y2AutoPlotVQI_y2AutoPlot
VU_y2AutoPlotVUB_y2AutoPlotVUS_y2AutoPlot
VUL_y2AutoPlotVUQ_y2AutoPlotVUI_y2AutoPlot
 ..._y2AutoPlot_xlg_ylin 
 ..._y2AutoPlot_xlg_ylg 
 ..._y2AutoPlot_xlin_ylg 
FunktionAuftragung 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/Delphiuses 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 );
BeschreibungEin 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_ylinX-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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_yDataPlot,   VF_y2AutoPlot,   VF_xyAutoPlot,   VCF_autoPlot,   V_drawAxes,   V_findAxes,  Kap. 4.12

 

VF_yDataPlotVD_yDataPlotVE_yDataPlot
VI_yDataPlotVBI_yDataPlotVSI_yDataPlot
VLI_yDataPlotVQI_yDataPlot
VU_yDataPlotVUB_yDataPlotVUS_yDataPlot
VUL_yDataPlotVUQ_yDataPlotVUI_yDataPlot
FunktionAuftragung 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/Delphiuses Vgraph;
procedure VF_yDataPlot( Y:fVector; size:UIntSize; form:UInt; color:COLORREF );
BeschreibungDie 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.
Fehlerbehandlungkeine
Rückgabewertkeiner
QuerverweisVF_yAutoPlot,   VF_y2AutoPlot,   VF_xyAutoPlot,   VCF_autoPlot,   V_drawAxes,   V_findAxes,  Kap. 4.12
 


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:

 

fcplxdcplxecplx
FunktionInitialisierung cartesisch-komplexer Zahlen
Syntax C/C++#include <VecLib.h>
fComplex fcplx( float ReVal, float ImVal );

    (analog dcplx,   ecplx)
Pascal/Delphiuses VecLib;
procedure fcplx( var zy:fComplex; xRe, xIm: Single );

    (analog dcplx,   ecplx)
BeschreibungDiese 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;
Fehlerbehandlungkeine
Rückgabewertdie erzeugte komplexe Zahl (C/C++)
Querverweisfpolr

 

isintisintlisintd
FunktionTest, ob eine Fließkommazahl ganzzahlig ist
Syntax C/C++#include <xmath.h>
int isint( double x );
int isintl( long double x );
Pascal/Delphiuses xmath;
function isint( x:Extended ): IntBool;
function isintd( x:Double ): IntBool;
BeschreibungWenn x eine ganze Zahl ist, wird TRUE (eine Zahl ungleich 0) zurückgegeben, andernfalls FALSE (0).
Fehlerbehandlungkeine
Rückgabewertsiehe oben

 

isipow2sisipow2lisipow2
FunktionTest, 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/Delphiuses xmath;
function isipow2( x:UInt ): IntBool;
function sisipow2( x:USmall ): IntBool;
function lisipow2( x:ULong ): IntBool;
BeschreibungGibt 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.
Fehlerbehandlungkeine
Rückgabewertsiehe oben

 

loglogd
FunktionNatürlicher Logarithmus: nur Pascal/Delphi!
Syntaxuses xmath;
function log( x:Extended x ): Extended;
function logd( x:double x ): Double;
BeschreibungDer 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.
FehlerbehandlungEin 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ückgabewertnatürlicher Logarithmus des Argumentes
Querverweislog2,   log2d,   log10,   log10d,   VF_log

 

log2log2llog2d
Funktionbinärer Logarithmus
Syntax C/C++#include <xmath.h>
double       log2( double x );
long double  log2l( long double x );
Pascal/Delphiuses xmath;
function log2( x:Extended ): Extended;
function log2d( x:Double ): Double;
BeschreibungDer binäre Logarithmus, d.h. der Logarithmus zur Basis 2, wird berechnet und zurückgegeben.
FehlerbehandlungEin 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ückgabewertbinärer Logarithmus des Argumentes
Querverweislog,   log10,   VF_log2

 

log10log10d
Funktiondekadischer Logarithmus: nur Pascal/Delphi!
Syntaxuses xmath;
function log10( x:Extended x ): Extended;
function log10d( x:double x ): Double;
BeschreibungDer Logarithmus zur Basis 10 wird berechnet und zurückgegeben.
FehlerbehandlungEin 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ückgabewertdekadischer Logarithmus des Argumentes
Querverweislog,   logd,   log2,   log2d,   VF_log10

 

fpolrdpolrepolr
FunktionInitialisierung komplexer Zahlen in Polarkoordinaten
Syntax C/C++#include <VecLib.h>
fPolar fpolr( float MagVal, float ArgVal );

    (similarly dpolr,   epolr)
Pascal/Delphiuses VecLib;
procedure fpolr( var py:fPolar; xMag, xArg: Single );

    (similarly dpolr,   epolr)
BeschreibungDiese 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;
Fehlerbehandlungkeine
Rückgabewertdie erzeugte polar-komplexe Zahl (C/C++)
Querverweisfcplx

 

quadtod_quadtold
FunktionUmwandlung 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 );
BeschreibungDiese 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 ));
Fehlerbehandlungkeine
RückgabewertWert von x als double bzw. long double

 

setquad
FunktionUmwandlung einer long double in eine quad: nur C/C++!
Syntax C/C++#include <VecLib.h>
quad setquad( long double x );
BeschreibungDiese 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 ));
Fehlerbehandlungkeine
RückgabewertWert 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.