OptiVec: VF_cmp

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

Funktion

Vergleichsoperationen

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/Delphi

uses 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/Delphi

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

Beschreibung

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 X_i = 0 (oder C bzw. Y_i)
"ne" ("not equal")	True, wenn X_i ≠ 0 (oder C bzw. Y_i)
"gt" ("gteater than")	True, wenn X_i > 0 (oder C bzw. Y_i)
"ge" ("greater or equal")	True, wenn X_i ≥ 0 (oder C bzw. Y_i)
"lt" ("less than")	True, wenn X_i < 0 (oder C bzw. Y_i)
"le" ("less or equal")	True, wenn X_i ≤ 0 (oder C bzw. Y_i)
"st" ("similar to")	True, wenn X_i ≈ Y_i, d.h. \| X_i − Y_i \| ≤ max( \|Y_i\| * TolRel, TolAbs)
"dt" ("dissimilar to")	True, wenn X_i ≉ Y_i, d.h. \| X_i − Y_i \| > max( \|Y_i\| * 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 X_i < 0 oder X_i ≤ 0 prüfen, ebensowenig wie die trivialen Tests X_i ≥ 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 X_i ≥ 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.

Fehlerbehandlung

keine

Rückgabewert

Anzahl der die Testbedingung erfüllenden Elemente

Querverweis

VF_cnt_..., VF_cmp0, VF_cmpC, VF_cmpV, VF_indpick, VF_iselementC

VectorLib Inhaltsverzeichnis OptiVec Home