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

Functions

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 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 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< 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 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 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 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 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 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 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 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 ErrorCode vectorSubConstantInplace (float, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorSubConstantInplace (double, double *const, std::size_t, std::size_t)
 
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 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 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 vectorMultiplyConstantInplace (float, float *const, std::size_t, std::size_t)
 
template ErrorCode vectorMultiplyConstantInplace (double, double *const, std::size_t, std::size_t)
 
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 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 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 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 T >
ErrorCode vectorZeroReference (T *const dest, std::size_t numElements, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorFillReference (const T value, T *const dest, std::size_t numElements, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorCopyReference (T const *const source, T *const dest, std::size_t numElements, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorRamp (T *const dest, std::size_t numElements, T startVal, T endVal, bool startInclusive, bool endInclusive, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorAdd (T const *const op1, T const *const op2, T *const result, std::size_t numElements, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorAddInplace (T const *const op1, T *const op2Result, std::size_t numElements, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorAddConstant (T constantValue, T const *const op, T *const result, std::size_t numElements, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorAddConstantInplace (T constantValue, T *const opResult, std::size_t numElements, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorSubtract (T const *const subtrahend, T const *const minuend, T *const result, std::size_t numElements, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorSubtractInplace (T const *const minuend, T *const subtrahendResult, std::size_t numElements, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorSubtractConstant (T constantMinuend, T const *const subtrahend, T *const result, std::size_t numElements, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorSubConstantInplace (T constantMinuend, T *const subtrahendResult, std::size_t numElements, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorMultiply (T const *const factor1, T const *const factor2, T *const result, std::size_t numElements, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorMultiplyInplace (T const *const factor1, T *const factor2Result, std::size_t numElements, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorMultiplyConstant (T constantValue, T const *const factor, T *const result, std::size_t numElements, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorMultiplyConstantInplace (T constantValue, T *const factorResult, std::size_t numElements, std::size_t alignment=0)
 
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=0)
 
template<typename T >
ErrorCode vectorMultiplyAddInplace (T const *const factor1, T const *const factor2, T *const accumulator, std::size_t numElements, std::size_t alignment=0)
 
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=0)
 
template<typename T >
ErrorCode vectorMultiplyConstantAddInplace (T constFactor, T const *const factor, T *const accumulator, std::size_t numElements, std::size_t alignment=0)
 
template<typename T >
ErrorCode vectorZero (T *const dest, std::size_t numElements, std::size_t alignment)
 
template<typename T >
ErrorCode vectorFill (const T value, T *const dest, std::size_t numElements, std::size_t alignment)
 
template<typename T >
ErrorCode vectorCopy (T const *const source, T *const dest, std::size_t numElements, std::size_t alignment)
 

Function Documentation

◆ vectorAdd()

template<typename T >
ErrorCode visr::efl::reference::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::reference::vectorAdd< double > ( double const *  const,
double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorAdd< float >()

template ErrorCode visr::efl::reference::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::reference::vectorAddConstant ( constantValue,
T const *const  op,
T *const  result,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorAddConstant< double >()

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

◆ vectorAddConstant< float >()

template ErrorCode visr::efl::reference::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::reference::vectorAddConstantInplace ( constantValue,
T *const  opResult,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorAddConstantInplace< double >()

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

◆ vectorAddConstantInplace< float >()

template ErrorCode visr::efl::reference::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::reference::vectorAddInplace ( T const *const  op1,
T *const  op2Result,
std::size_t  numElements,
std::size_t  alignment = 0 
)

◆ vectorAddInplace< double >()

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

◆ vectorAddInplace< float >()

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

Explicit instantiation for types float and double

◆ vectorCopy()

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

◆ vectorCopy< double >()

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

◆ vectorCopy< float >()

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

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

template ErrorCode visr::efl::reference::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::reference::vectorCopy< std::complex< float > > ( std::complex< float > const *  const,
std::complex< float > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorCopyReference()

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

◆ vectorFill()

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

◆ vectorFill< double >()

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

◆ vectorFill< float >()

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

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

template ErrorCode visr::efl::reference::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::reference::vectorFill< std::complex< float > > ( std::complex< float >  const,
std::complex< float > *  const,
std::size_t  ,
std::size_t   
)

◆ vectorFillReference()

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

◆ vectorMultiply() [1/5]

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

Explicit instantiation for types float and double

◆ vectorMultiply() [2/5]

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

◆ vectorMultiply() [3/5]

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

◆ vectorMultiply() [4/5]

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

◆ vectorMultiply() [5/5]

template<typename T >
ErrorCode visr::efl::reference::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).

◆ vectorMultiplyAdd() [1/5]

template ErrorCode visr::efl::reference::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() [2/5]

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

◆ vectorMultiplyAdd() [3/5]

template ErrorCode visr::efl::reference::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() [4/5]

template ErrorCode visr::efl::reference::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   
)

◆ vectorMultiplyAdd() [5/5]

template<typename T >
ErrorCode visr::efl::reference::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 
)

◆ vectorMultiplyAddInplace() [1/5]

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

Explicit instantiation for types float and double

◆ vectorMultiplyAddInplace() [2/5]

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

◆ vectorMultiplyAddInplace() [3/5]

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

◆ vectorMultiplyAddInplace() [4/5]

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

◆ vectorMultiplyAddInplace() [5/5]

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

◆ vectorMultiplyConstant() [1/3]

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

Explicit instantiation for types float and double

◆ vectorMultiplyConstant() [2/3]

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

◆ vectorMultiplyConstant() [3/3]

template<typename T >
ErrorCode visr::efl::reference::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).

◆ vectorMultiplyConstantAdd() [1/3]

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

Explicit instantiation for types float and double

◆ vectorMultiplyConstantAdd() [2/3]

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

◆ vectorMultiplyConstantAdd() [3/3]

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

◆ vectorMultiplyConstantAddInplace() [1/5]

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

Explicit instantiation for types float and double

◆ vectorMultiplyConstantAddInplace() [2/5]

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

◆ vectorMultiplyConstantAddInplace() [3/5]

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

◆ vectorMultiplyConstantAddInplace() [4/5]

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

◆ vectorMultiplyConstantAddInplace() [5/5]

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

◆ vectorMultiplyConstantInplace() [1/3]

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

Explicit instantiation for types float and double

◆ vectorMultiplyConstantInplace() [2/3]

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

◆ vectorMultiplyConstantInplace() [3/3]

template<typename T >
ErrorCode visr::efl::reference::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).

◆ vectorMultiplyInplace() [1/3]

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

Explicit instantiation for types float and double

◆ vectorMultiplyInplace() [2/3]

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

◆ vectorMultiplyInplace() [3/3]

template<typename T >
ErrorCode visr::efl::reference::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).

◆ vectorRamp() [1/3]

template<typename T >
ErrorCode visr::efl::reference::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::reference::vectorRamp ( float *  const,
std::size_t  ,
float  ,
float  ,
bool  ,
bool  ,
std::size_t   
)

◆ vectorRamp() [3/3]

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

◆ vectorSubConstantInplace() [1/3]

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

Explicit instantiation for types float and double

◆ vectorSubConstantInplace() [2/3]

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

◆ vectorSubConstantInplace() [3/3]

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

◆ vectorSubtract() [1/3]

template<typename T >
ErrorCode visr::efl::reference::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::reference::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::reference::vectorSubtract ( double const *  const,
double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorSubtractConstant() [1/3]

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

Explicit instantiation for types float and double

◆ vectorSubtractConstant() [2/3]

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

◆ vectorSubtractConstant() [3/3]

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

◆ vectorSubtractInplace() [1/3]

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

◆ vectorSubtractInplace() [2/3]

template ErrorCode visr::efl::reference::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::reference::vectorSubtractInplace ( double const *  const,
double *  const,
std::size_t  ,
std::size_t   
)

◆ vectorZero()

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

◆ vectorZeroReference()

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