OptiVec: VF

VF_mulV

VD_mulV

VE_mulV

VCF_mulV

VCD_mulV

VCE_mulV

VCF_mulReV

VCD_mulReV

VCE_mulReV

VCF_mulVconj

VCD_mulVconj

VCE_mulVconj

VFs_mulV

VDs_mulV

VEs_mulV

VFx_mulV

VDx_mulV

VEx_mulV

VCFx_mulV

VCDx_mulV

VCEx_mulV

VCFx_mulReV

VCDx_mulReV

VCEx_mulReV

VCFx_mulVconj

VCDx_mulVconj

VCEx_mulVconj

VPF_mulV

VPD_mulV

VPE_mulV

VPF_mulReV

VPD_mulReV

VPE_mulReV

VI_mulV

VBI_mulV

VSI_mulV

VLI_mulV

VQI_mulV

VU_mulV

VUB_mulV

VUS_mulV

VUL_mulV

VUQ_mulV

VUI_mulV

Function

Multiply corresponding vector elements

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

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

Description

simple versions: Z_i = X_i * Y_i
scaled versions (VFs_ etc.): Z_i = C * (X_i * Y_i)
expanded versions (VFx_ etc.): Z_i = (A * X_i + B) * Y_i
The complex floating-point versions exist in three variants: in the first variant (e.g. VCF_mulV, VCFx_mulV), X, Y, and Z are all complex; in the second variant, Y is real-valued (e.g. VCF_mulReV - "multiply by a real vector"); in the third variant, finally (e.g. VCF_mulVconj, VCFx_mulVconj), X is multiplied by the complex conjugate of Y instead of Y itself.

Error handling

none

Return value

none