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
FunctionMultiply 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/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 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/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 );
Descriptionnormal versions: Zi = Xi * Yi
scaled versions (VFs_ etc.): Zi = C * (Xi * Yi)
expanded versions (VFx_ etc.): Zi = (A * Xi + B) * Yi
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 handlingnone
Return valuenone
See alsoVF_mulC,   VF_addV,   VF_subV,   VF_divV,   VF_visV,   VF_mulVI

VectorLib Table of Contents  OptiVec home