VISR  0.12.0
Versatile Interactive Scene Renderer
visr::efl Namespace Reference

Namespaces

 python
 
 reference
 
 test
 

Classes

class  AlignedArray
 
class  BasicMatrix
 
class  BasicVector
 
struct  DenormalisedNumbers
 
class  LagrangeCoefficientCalculator
 

Enumerations

enum  ErrorCode { noError = 0, alignmentError = 1, arithmeticError = 2, logicError = 3 }
 

Functions

bool alignmentIsPowerOfTwo (std::size_t alignmentVal)
 
template<typename T >
bool checkAlignment (T const *ptr, std::size_t alignment)
 
std::size_t nextAlignedSize (std::size_t size, std::size_t alignment)
 
template<typename T >
std::tuple< T, T, T > spherical2cartesian (T az, T el, T radius)
 
template<typename T >
std::tuple< T, T, T > cartesian2spherical (T x, T y, T z)
 
template<typename T >
linear2dB (T lin)
 
template<typename T >
dB2linear (T dB)
 
template<typename T >
degree2radian (T deg)
 
template<typename T >
radian2degree (T rad)
 
char const * errorMessage (const ErrorCode &error)
 
template<typename T >
ErrorCode product (T const *op1, T const *op2, T *res, std::size_t numResultRows, std::size_t numResultColumns, std::size_t numOp1Columns, std::size_t op1RowStride, std::size_t op1ColumnStride, std::size_t op2RowStride, std::size_t op2ColumnStride, std::size_t resRowStride, std::size_t resColumnStride)
 
template ErrorCode product< float > (float const *, float const *, float *, std::size_t, std::size_t, std::size_t, std::size_t, std::size_t, std::size_t, std::size_t, std::size_t, std::size_t)
 
template ErrorCode product< double > (double const *op1, double const *, double *, std::size_t, std::size_t, std::size_t, std::size_t, std::size_t, std::size_t, std::size_t, std::size_t, std::size_t)
 
template<typename InputType , typename OutputType >
ErrorCode vectorConvert (InputType const *const src, OutputType *const dest, std::size_t numElements, std::size_t alignment)
 
template<typename InputType , typename OutputType >
ErrorCode vectorConvertInputStride (InputType const *const src, OutputType *const dest, std::size_t numElements, std::size_t inputStride, std::size_t alignment)
 
template<typename InputType , typename OutputType >
ErrorCode vectorConvertOutputStride (InputType const *const src, OutputType *const dest, std::size_t numElements, std::size_t outputStride, std::size_t alignment)
 
template<typename InputType , typename OutputType >
ErrorCode vectorConvertInputOutputStride (InputType const *const src, OutputType *const dest, std::size_t numElements, std::size_t inputStride, std::size_t outputStride, std::size_t alignment)
 
template<typename T >
ErrorCode vectorZero (T *const dest, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorZero< float > (float *const, std::size_t, std::size_t)
 
template ErrorCode vectorZero< double > (double *const, std::size_t, std::size_t)
 
template ErrorCode vectorZero< std::complex< float > > (std::complex< float > *const, std::size_t, std::size_t)
 
template ErrorCode vectorZero< std::complex< double > > (std::complex< double > *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorFill (const T value, T *const dest, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorFill< float > (float const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorFill< double > (double const, double *const, std::size_t, std::size_t)
 
template ErrorCode vectorFill< std::complex< float > > (std::complex< float > const, std::complex< float > *const, std::size_t, std::size_t)
 
template ErrorCode vectorFill< std::complex< double > > (std::complex< double > const, std::complex< double > *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorRamp (T *const dest, std::size_t numElements, T startVal, T endVal, bool startInclusive, bool endInclusive, std::size_t alignment)
 
template ErrorCode vectorRamp (float *const, std::size_t, float, float, bool, bool, std::size_t)
 
template ErrorCode vectorRamp (double *const, std::size_t, double, double, bool, bool, std::size_t)
 
template<typename T >
ErrorCode vectorCopy (T const *const source, T *const dest, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorCopy< float > (float const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorCopy< double > (double const *const, double *const, std::size_t, std::size_t)
 
template ErrorCode vectorCopy< long double > (long double const *const, long double *const, std::size_t, std::size_t)
 
template ErrorCode vectorCopy< int8_t > (int8_t const *const, int8_t *const, std::size_t, std::size_t)
 
template ErrorCode vectorCopy< uint8_t > (uint8_t const *const, uint8_t *const, std::size_t, std::size_t)
 
template ErrorCode vectorCopy< int16_t > (int16_t const *const, int16_t *const, std::size_t, std::size_t)
 
template ErrorCode vectorCopy< uint16_t > (uint16_t const *const, uint16_t *const, std::size_t, std::size_t)
 
template ErrorCode vectorCopy< int32_t > (int32_t const *const, int32_t *const, std::size_t, std::size_t)
 
template ErrorCode vectorCopy< uint32_t > (uint32_t const *const, uint32_t *const, std::size_t, std::size_t)
 
template ErrorCode vectorCopy< std::complex< float > > (std::complex< float > const *const, std::complex< float > *const, std::size_t, std::size_t)
 
template ErrorCode vectorCopy< std::complex< double > > (std::complex< double > const *const, std::complex< double > *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorAdd (T const *const op1, T const *const op2, T *const result, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorAdd< float > (float const *const, float const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorAdd< double > (double const *const, double const *const, double *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorAddInplace (T const *const op1, T *const op2Result, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorAddInplace< float > (float const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorAddInplace< double > (double const *const, double *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorAddConstant (T constantValue, T const *const op, T *const result, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorAddConstant< float > (float, float const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorAddConstant< double > (double, double const *const, double *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorAddConstantInplace (T constantValue, T *const opResult, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorAddConstantInplace< float > (float, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorAddConstantInplace< double > (double, double *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorSubtract (T const *const subtrahend, T const *const minuend, T *const result, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorSubtract (float const *const, float const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorSubtract (double const *const, double const *const, double *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorSubtractInplace (T const *const minuend, T *const subtrahendResult, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorSubtractInplace (float const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorSubtractInplace (double const *const, double *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorSubtractConstant (T constantMinuend, T const *const subtrahend, T *const result, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorSubtractConstant (float, float const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorSubtractConstant (double, double const *const, double *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorSubConstantInplace (T constantMinuend, T *const subtrahendResult, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorSubConstantInplace (float, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorSubConstantInplace (double, double *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorMultiply (T const *const factor1, T const *const factor2, T *const result, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorMultiply (float const *const, float const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiply (double const *const, double const *const, double *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiply (std::complex< double > const *const, std::complex< double > const *const, std::complex< double > *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiply (std::complex< float > const *const, std::complex< float > const *const, std::complex< float > *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorMultiplyInplace (T const *const factor1, T *const factor2Result, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorMultiplyInplace (float const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyInplace (double const *const, double *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorMultiplyConstant (T constantValue, T const *const factor, T *const result, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorMultiplyConstant (float, float const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyConstant (double, double const *const, double *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyConstant (std::complex< float >, std::complex< float > const *const, std::complex< float > *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyConstant (std::complex< double >, std::complex< double > const *const, std::complex< double > *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorMultiplyConstantInplace (T constantValue, T *const factorResult, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorMultiplyConstantInplace (float, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyConstantInplace (double, double *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorMultiplyAdd (T const *const factor1, T const *const factor2, T const *const addend, T *const result, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorMultiplyAdd (float const *const, float const *const, float const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyAdd (double const *const, double const *const, double const *const, double *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyAdd (std::complex< float > const *const, std::complex< float > const *const, std::complex< float > const *const, std::complex< float > *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyAdd (std::complex< double > const *const, std::complex< double > const *const, std::complex< double > const *const, std::complex< double > *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorMultiplyAddInplace (T const *const factor1, T const *const factor2, T *const accumulator, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorMultiplyAddInplace (float const *const, float const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyAddInplace (double const *const, double const *const, double *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyAddInplace (std::complex< float > const *const, std::complex< float > const *const, std::complex< float > *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyAddInplace (std::complex< double > const *const, std::complex< double > const *const, std::complex< double > *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorMultiplyConstantAdd (T constFactor, T const *const factor, T const *const addend, T *const result, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorMultiplyConstantAdd (float, float const *const, float const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyConstantAdd (double, double const *const, double const *const, double *const, std::size_t, std::size_t)
 
template<typename T >
ErrorCode vectorMultiplyConstantAddInplace (T constFactor, T const *const factor, T *const accumulator, std::size_t numElements, std::size_t alignment)
 
template ErrorCode vectorMultiplyConstantAddInplace (float, float const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyConstantAddInplace (double, double const *const, double *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyConstantAddInplace (std::complex< double >, std::complex< double > const *const, std::complex< double > *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyConstantAddInplace (std::complex< float >, std::complex< float > const *const, std::complex< float > *const, std::size_t, std::size_t)
 
template<typename DataType >
ErrorCode vectorCopyStrided (DataType const *src, DataType *dest, std::size_t srcStrideElements, std::size_t destStrideElements, std::size_t numberOfElements, std::size_t alignmentElements)
 
template ErrorCode vectorCopyStrided (float const *, float *, std::size_t, std::size_t, std::size_t, std::size_t)
 
template ErrorCode vectorCopyStrided (double const *, double *, std::size_t, std::size_t, std::size_t, std::size_t)
 
template<typename DataType >
ErrorCode vectorFillStrided (DataType val, DataType *dest, std::size_t destStrideElements, std::size_t numberOfElements, std::size_t alignmentElements)
 
template ErrorCode vectorFillStrided (float, float *, std::size_t, std::size_t, std::size_t)
 
template ErrorCode vectorFillStrided (double, double *, std::size_t, std::size_t, std::size_t)
 
void getCpuId ()
 
template<typename DataType >
efl::ErrorCode vectorFillStrided (DataType val, DataType *dest, std::size_t destStrideElements, std::size_t numberOfElements, std::size_t alignmentElements)
 
template<>
ErrorCode vectorMultiplyConstantAddInplace< float > (float constFactor, float const *const factor, float *const accumulator, std::size_t numElements, std::size_t)
 
template ErrorCode vectorConvert< float, double > (float const *const, double *const, std::size_t, std::size_t)
 
template ErrorCode vectorConvert< float, float > (float const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorConvert< double, float > (double const *const, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorConvert< double, double > (double const *const, double *const, std::size_t, std::size_t)
 
template ErrorCode vectorConvertInputStride< float, double > (float const *const, double *const, std::size_t, std::size_t, std::size_t)
 
template ErrorCode vectorConvertInputStride< float, float > (float const *const, float *const, std::size_t, std::size_t, std::size_t)
 
template ErrorCode vectorConvertInputStride< double, float > (double const *const, float *const, std::size_t, std::size_t, std::size_t)
 
template ErrorCode vectorConvertInputStride< double, double > (double const *const, double *const, std::size_t, std::size_t, std::size_t)
 
template ErrorCode vectorConvertOutputStride< float, double > (float const *const, double *const, std::size_t, std::size_t, std::size_t)
 
template ErrorCode vectorConvertOutputStride< float, float > (float const *const, float *const, std::size_t, std::size_t, std::size_t)
 
template ErrorCode vectorConvertOutputStride< double, float > (double const *const, float *const, std::size_t, std::size_t, std::size_t)
 
template ErrorCode vectorConvertOutputStride< double, double > (double const *const, double *const, std::size_t, std::size_t, std::size_t)
 
template ErrorCode vectorConvertInputOutputStride< float, double > (float const *const, double *const, std::size_t, std::size_t, std::size_t, std::size_t)
 
template ErrorCode vectorConvertInputOutputStride< float, float > (float const *const, float *const, std::size_t, std::size_t, std::size_t, std::size_t)
 
template ErrorCode vectorConvertInputOutputStride< double, float > (double const *const, float *const, std::size_t, std::size_t, std::size_t, std::size_t)
 
template ErrorCode vectorConvertInputOutputStride< double, double > (double const *const, double *const, std::size_t, std::size_t, std::size_t, std::size_t)
 

Enumeration Type Documentation

◆ ErrorCode

Enumerator
noError 
alignmentError 
arithmeticError 
logicError 

Function Documentation

◆ alignmentIsPowerOfTwo()

bool visr::efl::alignmentIsPowerOfTwo ( std::size_t  alignmentVal)
inline

Test whether a given number is an integer power of two (including 1, but not 0)

Returns
true if it is a power of two, false otherwise.

◆ cartesian2spherical()

template<typename T >
std::tuple< T, T, T > visr::efl::cartesian2spherical ( x,
y,
z 
)

Compute the spherical coordinate representation for a given cartesian position.

Template Parameters
TThe data type of both input and returned coordinates.
Parameters
xThe x coordinate of the input position
yThe y coordinate of the input position
zThe z coordinate of the input position
Returns
A tuple consisting (in order) of azimuth, elevation, and radius. azimuth and elevation are in radian, and the elevation is relative to the horizontal (x-y) plane.

◆ checkAlignment()

template<typename T >
bool visr::efl::checkAlignment ( T const *  ptr,
std::size_t  alignment 
)

Check whether a pointer meets a given alignment requirement. That is, whether the address is a integer multiple of the element size times the given alignment.

Template Parameters
TThe element type to which the given pointer points to.
Parameters
ptrThe pointer to be checked
alignmentThe requested alignment, given in number of elements (instead of bytes). The alignment must be an integral power of two, 1 and 0 are also allowed.
Returns
true if ptr meets the alignment requirement, false otherwise.

◆ dB2linear()

template<typename T >
T visr::efl::dB2linear ( dB)

◆ degree2radian()

template<typename T >
T visr::efl::degree2radian ( deg)

◆ errorMessage()

char const * visr::efl::errorMessage ( const ErrorCode error)

Return a textual description of the error state.

◆ getCpuId()

void visr::efl::getCpuId ( )

◆ linear2dB()

template<typename T >
T visr::efl::linear2dB ( lin)

◆ nextAlignedSize()

std::size_t visr::efl::nextAlignedSize ( std::size_t  size,
std::size_t  alignment 
)
inline

Compute the next number that is compatible with a given alignment specification.

Parameters
sizeA given number of elements
alignmentThe alignment requirement.
Returns
The smallest number that is larger or equal than size and an integer multiple of alignment

◆ product()

template<typename T >
ErrorCode visr::efl::product ( T const *  op1,
T const *  op2,
T *  res,
std::size_t  numResultRows,
std::size_t  numResultColumns,
std::size_t  numOp1Columns,
std::size_t  op1RowStride,
std::size_t  op1ColumnStride,
std::size_t  op2RowStride,
std::size_t  op2ColumnStride,
std::size_t  resRowStride,
std::size_t  resColumnStride 
)

◆ product< double >()

template ErrorCode visr::efl::product< double > ( double const *  op1,
double const *  ,
double *  ,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ product< float >()

template ErrorCode visr::efl::product< float > ( float const *  ,
float const *  ,
float *  ,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ radian2degree()

template<typename T >
T visr::efl::radian2degree ( rad)

◆ spherical2cartesian()

template<typename T >
std::tuple< T, T, T > visr::efl::spherical2cartesian ( az,
el,
radius 
)

Compute the cartesian coordinate representation of a position given in the sperical coordinate system.

Template Parameters
Tthe type of both input and returned values.
Parameters
azThe azimuth in radian
elThe elevation coordinate (wrt to the horizontal x-y plane) in radian
radiusThe radius (radial coordinate)
Returns
A tuple consisting of the x, y, and z coordinate.

◆ vectorAdd()

template<typename T >
ErrorCode visr::efl::vectorAdd ( T const *const  op1,
T const *const  op2,
T *const  result,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorAdd< double >()

template ErrorCode visr::efl::vectorAdd< double > ( double const *  const,
double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorAdd< float >()

template ErrorCode visr::efl::vectorAdd< float > ( float const *  const,
float const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorAddConstant()

template<typename T >
ErrorCode visr::efl::vectorAddConstant ( constantValue,
T const *const  op,
T *const  result,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorAddConstant< double >()

template ErrorCode visr::efl::vectorAddConstant< double > ( double  ,
double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorAddConstant< float >()

template ErrorCode visr::efl::vectorAddConstant< float > ( float  ,
float const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorAddConstantInplace()

template<typename T >
ErrorCode visr::efl::vectorAddConstantInplace ( constantValue,
T *const  opResult,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorAddConstantInplace< double >()

template ErrorCode visr::efl::vectorAddConstantInplace< double > ( double  ,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorAddConstantInplace< float >()

template ErrorCode visr::efl::vectorAddConstantInplace< float > ( float  ,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorAddInplace()

template<typename T >
ErrorCode visr::efl::vectorAddInplace ( T const *const  op1,
T *const  op2Result,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorAddInplace< double >()

template ErrorCode visr::efl::vectorAddInplace< double > ( double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorAddInplace< float >()

template ErrorCode visr::efl::vectorAddInplace< float > ( float const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorConvert()

template<typename InputType , typename OutputType >
ErrorCode visr::efl::vectorConvert ( InputType const *const  src,
OutputType *const  dest,
std::size_t  numElements,
std::size_t  alignment 
)

◆ vectorConvert< double, double >()

template ErrorCode visr::efl::vectorConvert< double, double > ( double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorConvert< double, float >()

template ErrorCode visr::efl::vectorConvert< double, float > ( double const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

◆ vectorConvert< float, double >()

template ErrorCode visr::efl::vectorConvert< float, double > ( float const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

Template specialisations Note that we also provide conversions to the same type for two reasons:

  • Enable a uniform interface and calling sequence
  • Provide functions to deal with general striding constellations

◆ vectorConvert< float, float >()

template ErrorCode visr::efl::vectorConvert< float, float > ( float const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

◆ vectorConvertInputOutputStride()

template<typename InputType , typename OutputType >
ErrorCode visr::efl::vectorConvertInputOutputStride ( InputType const *const  src,
OutputType *const  dest,
std::size_t  numElements,
std::size_t  inputStride,
std::size_t  outputStride,
std::size_t  alignment 
)

◆ vectorConvertInputOutputStride< double, double >()

template ErrorCode visr::efl::vectorConvertInputOutputStride< double, double > ( double const *  const,
double *  const,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorConvertInputOutputStride< double, float >()

template ErrorCode visr::efl::vectorConvertInputOutputStride< double, float > ( double const *  const,
float *  const,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorConvertInputOutputStride< float, double >()

template ErrorCode visr::efl::vectorConvertInputOutputStride< float, double > ( float const *  const,
double *  const,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorConvertInputOutputStride< float, float >()

template ErrorCode visr::efl::vectorConvertInputOutputStride< float, float > ( float const *  const,
float *  const,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorConvertInputStride()

template<typename InputType , typename OutputType >
ErrorCode visr::efl::vectorConvertInputStride ( InputType const *const  src,
OutputType *const  dest,
std::size_t  numElements,
std::size_t  inputStride,
std::size_t  alignment 
)

◆ vectorConvertInputStride< double, double >()

template ErrorCode visr::efl::vectorConvertInputStride< double, double > ( double const *  const,
double *  const,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorConvertInputStride< double, float >()

template ErrorCode visr::efl::vectorConvertInputStride< double, float > ( double const *  const,
float *  const,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorConvertInputStride< float, double >()

template ErrorCode visr::efl::vectorConvertInputStride< float, double > ( float const *  const,
double *  const,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorConvertInputStride< float, float >()

template ErrorCode visr::efl::vectorConvertInputStride< float, float > ( float const *  const,
float *  const,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorConvertOutputStride()

template<typename InputType , typename OutputType >
ErrorCode visr::efl::vectorConvertOutputStride ( InputType const *const  src,
OutputType *const  dest,
std::size_t  numElements,
std::size_t  outputStride,
std::size_t  alignment 
)

◆ vectorConvertOutputStride< double, double >()

template ErrorCode visr::efl::vectorConvertOutputStride< double, double > ( double const *  const,
double *  const,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorConvertOutputStride< double, float >()

template ErrorCode visr::efl::vectorConvertOutputStride< double, float > ( double const *  const,
float *  const,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorConvertOutputStride< float, double >()

template ErrorCode visr::efl::vectorConvertOutputStride< float, double > ( float const *  const,
double *  const,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorConvertOutputStride< float, float >()

template ErrorCode visr::efl::vectorConvertOutputStride< float, float > ( float const *  const,
float *  const,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorCopy()

template<typename T >
ErrorCode visr::efl::vectorCopy ( T const *const  source,
T *const  dest,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorCopy< double >()

template ErrorCode visr::efl::vectorCopy< double > ( double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorCopy< float >()

template ErrorCode visr::efl::vectorCopy< float > ( float const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

◆ vectorCopy< int16_t >()

template ErrorCode visr::efl::vectorCopy< int16_t > ( int16_t const *  const,
int16_t *  const,
std::size_t  ,
std::size_t   
)

◆ vectorCopy< int32_t >()

template ErrorCode visr::efl::vectorCopy< int32_t > ( int32_t const *  const,
int32_t *  const,
std::size_t  ,
std::size_t   
)

◆ vectorCopy< int8_t >()

template ErrorCode visr::efl::vectorCopy< int8_t > ( int8_t const *  const,
int8_t *  const,
std::size_t  ,
std::size_t   
)

◆ vectorCopy< long double >()

template ErrorCode visr::efl::vectorCopy< long double > ( long double const *  const,
long double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorCopy< std::complex< double > >()

template ErrorCode visr::efl::vectorCopy< std::complex< double > > ( std::complex< double > const *  const,
std::complex< double > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorCopy< std::complex< float > >()

template ErrorCode visr::efl::vectorCopy< std::complex< float > > ( std::complex< float > const *  const,
std::complex< float > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorCopy< uint16_t >()

template ErrorCode visr::efl::vectorCopy< uint16_t > ( uint16_t const *  const,
uint16_t *  const,
std::size_t  ,
std::size_t   
)

◆ vectorCopy< uint32_t >()

template ErrorCode visr::efl::vectorCopy< uint32_t > ( uint32_t const *  const,
uint32_t *  const,
std::size_t  ,
std::size_t   
)

◆ vectorCopy< uint8_t >()

template ErrorCode visr::efl::vectorCopy< uint8_t > ( uint8_t const *  const,
uint8_t *  const,
std::size_t  ,
std::size_t   
)

◆ vectorCopyStrided() [1/3]

template<typename DataType >
ErrorCode visr::efl::vectorCopyStrided ( DataType const *  src,
DataType *  dest,
std::size_t  srcStrideElements,
std::size_t  destStrideElements,
std::size_t  numberOfElements,
std::size_t  alignmentElements 
)

Copy a strided sequence of values, i.e., a memory area where the elements have a constant, but not necessarily unit distance, to another strided sequence

Template Parameters
DataTypeThe data type contained in the sequences. Must provide an assignment operator.
Parameters
srcThe base pointer of the source sequence (i.e., location of the first element)
destBase pointer of the destination sequence (i.e., location of the first element).
srcStrideElementsStride (i.e., distance between the elements) of the source sequence given in number of elements (not bytes).
destStrideElementsStride (i.e., distance between the elements) of the destination sequence given in number of elements (not bytes).
numberOfElementsThe number of elements to be copied.
alignmentElementsMinimum alignment of the source and destination sequences (in number of elements)
Note
Consider removing the alignmentElements parameter because it is scarcely useful unliess both sequences have stride 1.

◆ vectorCopyStrided() [2/3]

template ErrorCode visr::efl::vectorCopyStrided ( float const *  ,
float *  ,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorCopyStrided() [3/3]

template ErrorCode visr::efl::vectorCopyStrided ( double const *  ,
double *  ,
std::size_t  ,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorFill()

template<typename T >
ErrorCode visr::efl::vectorFill ( const T  value,
T *const  dest,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorFill< double >()

template ErrorCode visr::efl::vectorFill< double > ( double  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorFill< float >()

template ErrorCode visr::efl::vectorFill< float > ( float  const,
float *  const,
std::size_t  ,
std::size_t   
)

◆ vectorFill< std::complex< double > >()

template ErrorCode visr::efl::vectorFill< std::complex< double > > ( std::complex< double >  const,
std::complex< double > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorFill< std::complex< float > >()

template ErrorCode visr::efl::vectorFill< std::complex< float > > ( std::complex< float >  const,
std::complex< float > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorFillStrided() [1/4]

template<typename DataType >
efl::ErrorCode visr::efl::vectorFillStrided ( DataType  val,
DataType *  dest,
std::size_t  destStrideElements,
std::size_t  numberOfElements,
std::size_t  alignmentElements 
)

Fill a strided sequence of values, i.e., a memory area where the elements have a constant, but not necessarily unit distance, with a constant value

Template Parameters
DataTypeThe data type contained in the sequences. Must provide an assignemnt operator.
Parameters
valThe constant value to be assigned to the strided locations.
destThe base pointer of the strided sequence.
destStrideElementsDistance between consecutive addressed elements in the target sequence.
numberOfElementsNumber of values to be assigned.
alignmentElementsThe alignment of the target sequence, i.e., of the base pointer.
Note
Consider removing the alignmentElements parameter, because it it is scarcely useful for non-unit strides.

◆ vectorFillStrided() [2/4]

template<typename DataType >
ErrorCode visr::efl::vectorFillStrided ( DataType  val,
DataType *  dest,
std::size_t  destStrideElements,
std::size_t  numberOfElements,
std::size_t  alignmentElements 
)

Fill a strided sequence of values, i.e., a memory area where the elements have a constant, but not necessarily unit distance, with a constant value

Template Parameters
DataTypeThe data type contained in the sequences. Must provide an assignemnt operator.
Parameters
valThe constant value to be assigned to the strided locations.
destThe base pointer of the strided sequence.
destStrideElementsDistance between consecutive addressed elements in the target sequence.
numberOfElementsNumber of values to be assigned.
alignmentElementsThe alignment of the target sequence, i.e., of the base pointer.
Note
Consider removing the alignmentElements parameter, because it it is scarcely useful for non-unit strides.

◆ vectorFillStrided() [3/4]

template ErrorCode visr::efl::vectorFillStrided ( float  ,
float *  ,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorFillStrided() [4/4]

template ErrorCode visr::efl::vectorFillStrided ( double  ,
double *  ,
std::size_t  ,
std::size_t  ,
std::size_t   
)

◆ vectorMultiply() [1/5]

template<typename T >
ErrorCode visr::efl::vectorMultiply ( T const *const  factor1,
T const *const  factor2,
T *const  result,
std::size_t  numElements,
std::size_t  alignment = 0 
)

Multiply two vectors.

Template Parameters
TThe element type of the operands.
Parameters
factor1First vector to multiply.
factor2Second vector to multiply.
[out]resultThe result of the operation.
numElementsThe number of elements to be multiplied.
alignmentAssured alignment of all vector arguments (measured in elements).

◆ vectorMultiply() [2/5]

template ErrorCode visr::efl::vectorMultiply ( float const *  const,
float const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorMultiply() [3/5]

template ErrorCode visr::efl::vectorMultiply ( double const *  const,
double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorMultiply() [4/5]

template ErrorCode visr::efl::vectorMultiply ( std::complex< double > const *  const,
std::complex< double > const *  const,
std::complex< double > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiply() [5/5]

template ErrorCode visr::efl::vectorMultiply ( std::complex< float > const *  const,
std::complex< float > const *  const,
std::complex< float > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiplyAdd() [1/5]

template<typename T >
ErrorCode visr::efl::vectorMultiplyAdd ( T const *const  factor1,
T const *const  factor2,
T const *const  addend,
T *const  result,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorMultiplyAdd() [2/5]

template ErrorCode visr::efl::vectorMultiplyAdd ( float const *  const,
float const *  const,
float const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorMultiplyAdd() [3/5]

template ErrorCode visr::efl::vectorMultiplyAdd ( double const *  const,
double const *  const,
double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiplyAdd() [4/5]

template ErrorCode visr::efl::vectorMultiplyAdd ( std::complex< float > const *  const,
std::complex< float > const *  const,
std::complex< float > const *  const,
std::complex< float > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiplyAdd() [5/5]

template ErrorCode visr::efl::vectorMultiplyAdd ( std::complex< double > const *  const,
std::complex< double > const *  const,
std::complex< double > const *  const,
std::complex< double > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiplyAddInplace() [1/5]

template<typename T >
ErrorCode visr::efl::vectorMultiplyAddInplace ( T const *const  factor1,
T const *const  factor2,
T *const  accumulator,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorMultiplyAddInplace() [2/5]

template ErrorCode visr::efl::vectorMultiplyAddInplace ( float const *  const,
float const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorMultiplyAddInplace() [3/5]

template ErrorCode visr::efl::vectorMultiplyAddInplace ( double const *  const,
double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiplyAddInplace() [4/5]

template ErrorCode visr::efl::vectorMultiplyAddInplace ( std::complex< float > const *  const,
std::complex< float > const *  const,
std::complex< float > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiplyAddInplace() [5/5]

template ErrorCode visr::efl::vectorMultiplyAddInplace ( std::complex< double > const *  const,
std::complex< double > const *  const,
std::complex< double > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiplyConstant() [1/5]

template<typename T >
ErrorCode visr::efl::vectorMultiplyConstant ( constantValue,
T const *const  factor,
T *const  result,
std::size_t  numElements,
std::size_t  alignment = 0 
)

Multiply a vector with a constant.

Template Parameters
TThe element type of the operands.
Parameters
constantValueThe constant scaling factor.
[in]factorVector to multiply with.
[out]resultThe result of the operation.
numElementsThe number of elements to be multiplied.
alignmentAssured alignment of all vector arguments (measured in elements).

◆ vectorMultiplyConstant() [2/5]

template ErrorCode visr::efl::vectorMultiplyConstant ( float  ,
float const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorMultiplyConstant() [3/5]

template ErrorCode visr::efl::vectorMultiplyConstant ( double  ,
double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiplyConstant() [4/5]

template ErrorCode visr::efl::vectorMultiplyConstant ( std::complex< float >  ,
std::complex< float > const *  const,
std::complex< float > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiplyConstant() [5/5]

template ErrorCode visr::efl::vectorMultiplyConstant ( std::complex< double >  ,
std::complex< double > const *  const,
std::complex< double > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiplyConstantAdd() [1/3]

template<typename T >
ErrorCode visr::efl::vectorMultiplyConstantAdd ( constFactor,
T const *const  factor,
T const *const  addend,
T *const  result,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorMultiplyConstantAdd() [2/3]

template ErrorCode visr::efl::vectorMultiplyConstantAdd ( float  ,
float const *  const,
float const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorMultiplyConstantAdd() [3/3]

template ErrorCode visr::efl::vectorMultiplyConstantAdd ( double  ,
double const *  const,
double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiplyConstantAddInplace() [1/5]

template<typename T >
ErrorCode visr::efl::vectorMultiplyConstantAddInplace ( constFactor,
T const *const  factor,
T *const  accumulator,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorMultiplyConstantAddInplace() [2/5]

template ErrorCode visr::efl::vectorMultiplyConstantAddInplace ( float  ,
float const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorMultiplyConstantAddInplace() [3/5]

template ErrorCode visr::efl::vectorMultiplyConstantAddInplace ( double  ,
double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiplyConstantAddInplace() [4/5]

template ErrorCode visr::efl::vectorMultiplyConstantAddInplace ( std::complex< double >  ,
std::complex< double > const *  const,
std::complex< double > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiplyConstantAddInplace() [5/5]

template ErrorCode visr::efl::vectorMultiplyConstantAddInplace ( std::complex< float >  ,
std::complex< float > const *  const,
std::complex< float > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiplyConstantAddInplace< float >()

template<>
ErrorCode visr::efl::vectorMultiplyConstantAddInplace< float > ( float  constFactor,
float const *const  factor,
float *const  accumulator,
std::size_t  numElements,
std::size_t   
)

◆ vectorMultiplyConstantInplace() [1/3]

template<typename T >
ErrorCode visr::efl::vectorMultiplyConstantInplace ( constantValue,
T *const  factorResult,
std::size_t  numElements,
std::size_t  alignment = 0 
)

Multiply a vector with a constant inplace.

Template Parameters
TThe element type of the operands.
Parameters
constantValueThe constant scaling factor.
[in,out]factorResultVector to multiply with, also holds the result.
numElementsThe number of elements to be multiplied.
alignmentAssured alignment of all vector arguments (measured in elements).

◆ vectorMultiplyConstantInplace() [2/3]

template ErrorCode visr::efl::vectorMultiplyConstantInplace ( float  ,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorMultiplyConstantInplace() [3/3]

template ErrorCode visr::efl::vectorMultiplyConstantInplace ( double  ,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorMultiplyInplace() [1/3]

template<typename T >
ErrorCode visr::efl::vectorMultiplyInplace ( T const *const  factor1,
T *const  factor2Result,
std::size_t  numElements,
std::size_t  alignment = 0 
)

Multiply two vectors inplace.

Template Parameters
TThe element type of the operands.
Parameters
factor1First vector to multiply.
[in,out]factor2ResultSecond vector to multiply, holds also the result of the operation.
numElementsThe number of elements to be multiplied.
alignmentAssured alignment of all vector arguments (measured in elements).

◆ vectorMultiplyInplace() [2/3]

template ErrorCode visr::efl::vectorMultiplyInplace ( float const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorMultiplyInplace() [3/3]

template ErrorCode visr::efl::vectorMultiplyInplace ( double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorRamp() [1/3]

template<typename T >
ErrorCode visr::efl::vectorRamp ( T *const  dest,
std::size_t  numElements,
startVal,
endVal,
bool  startInclusive,
bool  endInclusive,
std::size_t  alignment = 0 
)

Fill an array with a ramp defined by its start and end value. Instantiated for element types float and double.

Template Parameters
TThe Sample type
Parameters
destThe array to be filled
numElementsThe number of element of the ramp.
startValThe start value of the ramp.
endValThe end value of the ramp.
startInclusiveSwitch whether the first ramp value is startVal (true) or whether the ramp is constructed that the value before the first would be startVal (false).
endInclusiveSwitch whether the last ramp value is endVal (true) or whether the ramp is constructed that the value after the last sample would be endVal (false).
alignmentThe aligment of the dest vector, given in numbers of elements.

◆ vectorRamp() [2/3]

template ErrorCode visr::efl::vectorRamp ( float *  const,
std::size_t  ,
float  ,
float  ,
bool  ,
bool  ,
std::size_t   
)

◆ vectorRamp() [3/3]

template ErrorCode visr::efl::vectorRamp ( double *  const,
std::size_t  ,
double  ,
double  ,
bool  ,
bool  ,
std::size_t   
)

◆ vectorSubConstantInplace() [1/3]

template<typename T >
ErrorCode visr::efl::vectorSubConstantInplace ( constantMinuend,
T *const  subtrahendResult,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorSubConstantInplace() [2/3]

template ErrorCode visr::efl::vectorSubConstantInplace ( float  ,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorSubConstantInplace() [3/3]

template ErrorCode visr::efl::vectorSubConstantInplace ( double  ,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorSubtract() [1/3]

template<typename T >
ErrorCode visr::efl::vectorSubtract ( T const *const  subtrahend,
T const *const  minuend,
T *const  result,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorSubtract() [2/3]

template ErrorCode visr::efl::vectorSubtract ( float const *  const,
float const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorSubtract() [3/3]

template ErrorCode visr::efl::vectorSubtract ( double const *  const,
double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorSubtractConstant() [1/3]

template<typename T >
ErrorCode visr::efl::vectorSubtractConstant ( constantMinuend,
T const *const  subtrahend,
T *const  result,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorSubtractConstant() [2/3]

template ErrorCode visr::efl::vectorSubtractConstant ( float  ,
float const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorSubtractConstant() [3/3]

template ErrorCode visr::efl::vectorSubtractConstant ( double  ,
double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorSubtractInplace() [1/3]

template<typename T >
ErrorCode visr::efl::vectorSubtractInplace ( T const *const  minuend,
T *const  subtrahendResult,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorSubtractInplace() [2/3]

template ErrorCode visr::efl::vectorSubtractInplace ( float const *  const,
float *  const,
std::size_t  ,
std::size_t   
)

Explicit instantiation for types float and double

◆ vectorSubtractInplace() [3/3]

template ErrorCode visr::efl::vectorSubtractInplace ( double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorZero()

template<typename T >
ErrorCode visr::efl::vectorZero ( T *const  dest,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorZero< double >()

template ErrorCode visr::efl::vectorZero< double > ( double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorZero< float >()

template ErrorCode visr::efl::vectorZero< float > ( float *  const,
std::size_t  ,
std::size_t   
)

◆ vectorZero< std::complex< double > >()

template ErrorCode visr::efl::vectorZero< std::complex< double > > ( std::complex< double > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorZero< std::complex< float > >()

template ErrorCode visr::efl::vectorZero< std::complex< float > > ( std::complex< float > *  const,
std::size_t  ,
std::size_t   
)