OptiVec: VF

procedure VCFx_mulVconj( Z, X, Y:cfVector; size:UInt; A, B:fComplex );

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

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:UInt ); procedure VFs_mulV( Z, X, Y:fVector; size:UInt; C:Single ); procedure VFx_mulV( Z, X, Y:fVector; size:UInt; A, B:Single ); procedure VCF_mulV( Z, X, Y:cfVector; size:UInt ); procedure VCF_mulReV( Z, X:cfVector; Y:fVector; size:UInt ); procedure VCF_mulVconj( Z, X, Y:cfVector; size:UInt ); procedure VCFx_mulV( Z, X, Y:cfVector; size:UInt; A, B:fComplex ); procedure VCFx_mulReV( Z, X:cfVector; Y:fVector; size:UInt; A, B:fComplex );

Description

normal 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