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
        ...eq0ind        ...ne0ind        ...gt0ind        ...ge0ind        ...le0ind        ...lt0ind
        ...eqCind        ...neCind        ...gtCind        ...geCind        ...leCind        ...ltCind
        ...eqVind        ...neVind        ...gtVind        ...geVind        ...leVind        ...ltVind
        ...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
        ...eq0ind        ...ne0ind        ...eqCind        ...neCind        ...eqVind        ...neVind
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_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)
    (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_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 );

    (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<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<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<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 );
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_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)
    (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_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;

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

Für komplexe Zahlen macht nur der Test auf Gleichheit ("eq") oder Ungleichheit ("ne") Sinn. Die übrigen Testbedingungen existieren nicht für komplexe Zahlen.
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, daß VF_indpick nicht aufgerufen wird mit size=0, wenn also überhaupt kein Element die Bedingung erfüllte. Man muß daher immer überprüfen, ob der Rückgabewert nTrue ungleich 0 ist. (Man erinnere sich, daß der Parameter size für alle VectorLib-Funktionen größer als 0 sein muß!)
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

VectorLib Inhaltsverzeichnis  OptiVec Home