cisst-saw
Loading...
Searching...
No Matches
Public Types | Public Member Functions | List of all members
vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType > Class Template Reference

A template for a fixed length vector with fixed spacing in memory. More...

#include <vctFixedSizeVectorBase.h>

Inheritance diagram for vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >:
vctFixedSizeConstVectorBase< _size, _stride, _elementType, _dataPtrType > vctFixedSizeVector< value_type, DIMENSION > vctFixedSizeVector< value_type, 3 > vctFixedSizeVector< bool, _size > vctFixedSizeVector< value_type, _size > vctFixedSizeVector< double, 1 > vctFixedSizeVector< double, 2 > vctFixedSizeVector< double, 3 > vctFixedSizeVector< double, 4 > vctFixedSizeVector< double, 5 > vctFixedSizeVector< double, 6 > vctFixedSizeVector< double, 7 > vctFixedSizeVector< double, 8 > vctFixedSizeVector< double, 9 > vctFixedSizeVector< float, 1 > vctFixedSizeVector< float, 2 > vctFixedSizeVector< float, 3 > vctFixedSizeVector< float, 4 > vctFixedSizeVector< float, 5 > vctFixedSizeVector< float, 6 > vctFixedSizeVector< float, 7 > vctFixedSizeVector< float, 8 > vctFixedSizeVector< float, 9 > vctFixedSizeVector< long, 1 > vctFixedSizeVector< long, 2 > vctFixedSizeVector< long, 3 > vctFixedSizeVector< long, 4 > vctFixedSizeVector< long, 5 > vctFixedSizeVector< long, 6 > vctFixedSizeVector< long, 7 > vctFixedSizeVector< long, 8 > vctFixedSizeVector< long, 9 > vctFixedSizeVector< unsigned long, 1 > vctFixedSizeVector< unsigned long, 2 > vctFixedSizeVector< unsigned long, 3 > vctFixedSizeVector< unsigned long, 4 > vctFixedSizeVector< unsigned long, 5 > vctFixedSizeVector< unsigned long, 6 > vctFixedSizeVector< unsigned long, 7 > vctFixedSizeVector< unsigned long, 8 > vctFixedSizeVector< unsigned long, 9 > vctFixedSizeVector< int, 1 > vctFixedSizeVector< int, 2 > vctFixedSizeVector< int, 3 > vctFixedSizeVector< int, 4 > vctFixedSizeVector< int, 5 > vctFixedSizeVector< int, 6 > vctFixedSizeVector< int, 7 > vctFixedSizeVector< int, 8 > vctFixedSizeVector< int, 9 > vctFixedSizeVector< unsigned int, 1 > vctFixedSizeVector< unsigned int, 2 > vctFixedSizeVector< unsigned int, 3 > vctFixedSizeVector< unsigned int, 4 > vctFixedSizeVector< unsigned int, 5 > vctFixedSizeVector< unsigned int, 6 > vctFixedSizeVector< unsigned int, 7 > vctFixedSizeVector< unsigned int, 8 > vctFixedSizeVector< unsigned int, 9 > vctFixedSizeVector< short, 1 > vctFixedSizeVector< short, 2 > vctFixedSizeVector< short, 3 > vctFixedSizeVector< short, 4 > vctFixedSizeVector< short, 5 > vctFixedSizeVector< short, 6 > vctFixedSizeVector< short, 7 > vctFixedSizeVector< short, 8 > vctFixedSizeVector< short, 9 > vctFixedSizeVector< unsigned short, 1 > vctFixedSizeVector< unsigned short, 2 > vctFixedSizeVector< unsigned short, 3 > vctFixedSizeVector< unsigned short, 4 > vctFixedSizeVector< unsigned short, 5 > vctFixedSizeVector< unsigned short, 6 > vctFixedSizeVector< unsigned short, 7 > vctFixedSizeVector< unsigned short, 8 > vctFixedSizeVector< unsigned short, 9 > vctFixedSizeVector< char, 1 > vctFixedSizeVector< char, 2 > vctFixedSizeVector< char, 3 > vctFixedSizeVector< char, 4 > vctFixedSizeVector< char, 5 > vctFixedSizeVector< char, 6 > vctFixedSizeVector< char, 7 > vctFixedSizeVector< char, 8 > vctFixedSizeVector< char, 9 > vctFixedSizeVector< unsigned char, 1 > vctFixedSizeVector< unsigned char, 2 > vctFixedSizeVector< unsigned char, 3 > vctFixedSizeVector< unsigned char, 4 > vctFixedSizeVector< unsigned char, 5 > vctFixedSizeVector< unsigned char, 6 > vctFixedSizeVector< unsigned char, 7 > vctFixedSizeVector< unsigned char, 8 > vctFixedSizeVector< unsigned char, 9 > vctFixedSizeVector< bool, 1 > vctFixedSizeVector< bool, 2 > vctFixedSizeVector< bool, 3 > vctFixedSizeVector< bool, 4 > vctFixedSizeVector< bool, 5 > vctFixedSizeVector< bool, 6 > vctFixedSizeVector< bool, 7 > vctFixedSizeVector< bool, 8 > vctFixedSizeVector< bool, 9 > vctFixedSizeVector< value_type, SIZE > vctFixedSizeVector< CISSTNETLIB_INTEGER, MAX_SIZE_1 > vctFixedSizeVector< CISSTNETLIB_DOUBLE, LWORK > vctFixedSizeVector< CISSTNETLIB_INTEGER, LIWORK > vctFixedSizeVector< CISSTNETLIB_DOUBLE, _n > vctFixedSizeVector< CISSTNETLIB_DOUBLE, _ma+_me > vctFixedSizeVector< size_type, 2 > vctFixedSizeVector< CISSTNETLIB_INTEGER, MIN_MN > vctFixedSizeVector< CISSTNETLIB_DOUBLE, MIN_MN >

Public Types

enum  { SIZE = BaseType::SIZE }
enum  { STRIDE = BaseType::STRIDE }
enum  { SIZEMINUSONE = SIZE - 1 }
typedef vctFixedSizeVectorTraits< _elementType, _size, _stride > VectorTraits
typedef vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType > ThisType
typedef vctFixedSizeConstVectorBase< _size, _stride, _elementType, _dataPtrType > BaseType
typedef BaseType::CopyType CopyType
typedef cmnTypeTraits< value_type > TypeTraits
typedef VectorTraits::iterator iterator
typedef VectorTraits::const_iterator const_iterator
typedef VectorTraits::reverse_iterator reverse_iterator
typedef VectorTraits::const_reverse_iterator const_reverse_iterator
typedef BaseType::RowConstMatrixRefType RowConstMatrixRefType
typedef BaseType::RowMatrixRefType RowMatrixRefType
typedef BaseType::ColConstMatrixRefType ColConstMatrixRefType
typedef BaseType::ColMatrixRefType ColMatrixRefType
Public Types inherited from vctFixedSizeConstVectorBase< _size, _stride, _elementType, _dataPtrType >
enum  { SIZE = VectorTraits::SIZE }
enum  { STRIDE = VectorTraits::STRIDE }
typedef vctFixedSizeConstVectorBase< _size, _stride, _elementType, _dataPtrType > ThisType
typedef vctFixedSizeVectorTraits< _elementType, _size, _stride > VectorTraits
typedef VectorTraits::iterator iterator
typedef VectorTraits::const_iterator const_iterator
typedef VectorTraits::reverse_iterator reverse_iterator
typedef VectorTraits::const_reverse_iterator const_reverse_iterator
typedef vctFixedSizeConstMatrixRef< _elementType, 1, _size, _stride *_size, _stride > RowConstMatrixRefType
typedef vctFixedSizeMatrixRef< _elementType, 1, _size, _stride *_size, _stride > RowMatrixRefType
typedef vctFixedSizeConstMatrixRef< _elementType, _size, 1, _stride, _stride *_size > ColConstMatrixRefType
typedef vctFixedSizeMatrixRef< _elementType, _size, 1, _stride, _stride *_size > ColMatrixRefType
typedef vctFixedSizeVector< _elementType, _size > VectorValueType
typedef vctFixedSizeVector< _elementType, _size > CopyType
typedef vctFixedSizeVector< bool, _size > BoolVectorValueType

Public Member Functions

 VCT_CONTAINER_TRAITS_TYPEDEFS (_elementType)
iterator begin (void)
const_iterator begin (void) const
iterator end (void)
const_iterator end (void) const
reverse_iterator rbegin (void)
const_reverse_iterator rbegin (void) const
reverse_iterator rend (void)
const_reverse_iterator rend (void) const
reference operator[] (size_type index)
const_reference operator[] (size_type index) const
reference at (size_type index) CISST_THROW(std
const_reference at (size_type index) const CISST_THROW(std
reference operator() (size_type index) CISST_THROW(std
const_reference operator() (size_type index) const CISST_THROW(std
reference Element (size_type index)
const_reference Element (size_type index) const
pointer Pointer (size_type index=0)
const_pointer Pointer (size_type index=0) const
value_type SetAll (const value_type &value)
bool Zeros (void)
Assignment operation between vectors of different types.
Parameters
otherThe vector to be copied.
template<stride_type __stride, class __elementType, class __dataPtrType>
ThisType & Assign (const vctFixedSizeConstVectorBase< _size, __stride, __elementType, __dataPtrType > &other)
template<stride_type __stride, class __elementType, class __dataPtrType>
ThisType & operator= (const vctFixedSizeConstVectorBase< _size, __stride, __elementType, __dataPtrType > &other)
ThisType & Assign (const value_type element0) CISST_THROW(std
ThisType & Assign (const value_type element0, const value_type element1) CISST_THROW(std
ThisType & Assign (const value_type element0, const value_type element1, const value_type element2) CISST_THROW(std
ThisType & Assign (const value_type element0, const value_type element1, const value_type element2, const value_type element3) CISST_THROW(std
ThisType & Assign (const value_type *elements)
template<class __vectorOwnerType>
ThisType & Assign (const vctDynamicConstVectorBase< __vectorOwnerType, value_type > &other)
Forced assignment operation between vectors of

different types. On fixed size vectors this method is equivalent to Assign. See notes below!

Note
For a non-reallocating Assign, it is recommended to use the Assign() methods.
This method is provided for both fixed size and dynamic vectors for API consistency (usable in templated code). There is obviously not resize involved on fixed size vectors.
If the destination vector doesn't have the same size as the source and can not be resized, an exception will be thrown by the Assign method called internally.
Parameters
otherThe vector to be copied.
template<stride_type __stride, class __elementType, class __dataPtrType>
ThisType & ForceAssign (const vctFixedSizeConstVectorBase< _size, __stride, __elementType, __dataPtrType > &other)
template<class __vectorOwnerType>
ThisType & ForceAssign (const vctDynamicConstVectorBase< __vectorOwnerType, value_type > &other)
template<class __vectorOwnerType>
bool FastCopyOf (const vctDynamicConstVectorBase< __vectorOwnerType, value_type > &source, bool performSafetyChecks=true) CISST_THROW(std
template<class __dataPtrType>
bool FastCopyOf (const vctFixedSizeConstVectorBase< SIZE, STRIDE, value_type, __dataPtrType > &source, bool performSafetyChecks=true) CISST_THROW(std
template<stride_type __stride, class __elementTypeVector, class __dataPtrType, class __elementType>
ThisType & ConcatenationOf (const vctFixedSizeConstVectorBase< SIZEMINUSONE, __stride, __elementTypeVector, __dataPtrType > &other, __elementType last)
Size dependant methods.

The following methods are size dependant, i.e. don't necessarily mean anything for all sizes of vector. For example, using the Z() method on a vector of size 2 shouldn't be allowed. It would have been possible to check these errors at compilation time, but this would require an overhead of code and therefore execution time which is not worth it. Therefore, we are using and CMN_ASSERT() to check that the template parameter _size is valid

Note
Using CMN_ASSERT on a template parameter still allows the compiler to perform some optimization, which would be harder if CMN_ASSERT was testing a method paramater.
value_type & X (void)
const value_type & X (void) const
value_type & Y (void)
const value_type & Y (void) const
value_type & Z (void)
const value_type & Z (void) const
value_type & W (void)
const value_type & W (void) const
vctFixedSizeVectorRef< _elementType, 2, _stride > XY (void)
vctFixedSizeVectorRef< _elementType, 2, 2 *_stride > XZ (void)
vctFixedSizeVectorRef< _elementType, 2, 3 *_stride > XW (void)
vctFixedSizeVectorRef< _elementType, 2, _stride > YZ (void)
vctFixedSizeVectorRef< _elementType, 2, 2 *_stride > YW (void)
vctFixedSizeVectorRef< _elementType, 2, _stride > ZW (void)
vctFixedSizeConstVectorRef< _elementType, 2, _stride > XY (void) const
vctFixedSizeConstVectorRef< _elementType, 2, 2 *_stride > XZ (void) const
vctFixedSizeConstVectorRef< _elementType, 2, 3 *_stride > XW (void) const
vctFixedSizeConstVectorRef< _elementType, 2, _stride > YZ (void) const
vctFixedSizeConstVectorRef< _elementType, 2, 2 *_stride > YW (void) const
vctFixedSizeConstVectorRef< _elementType, 2, _stride > ZW (void) const
vctFixedSizeVectorRef< _elementType, 3, _stride > XYZ (void)
vctFixedSizeVectorRef< _elementType, 3, _stride > YZW (void)
vctFixedSizeConstVectorRef< _elementType, 3, _stride > XYZ (void) const
vctFixedSizeConstVectorRef< _elementType, 3, _stride > YZW (void) const
vctFixedSizeVectorRef< _elementType, 4, _stride > XYZW (void)
vctFixedSizeConstVectorRef< _elementType, 4, _stride > XYZW (void) const
RowConstMatrixRefType AsRowMatrix (void) const
RowMatrixRefType AsRowMatrix (void)
ColConstMatrixRefType AsColMatrix (void) const
ColMatrixRefType AsColMatrix (void)
template<vct::size_type __subSize>
vctFixedSizeConstVectorRef< _elementType, __subSize, _stride > Ref (const size_type startPosition=0) const CISST_THROW(std
template<vct::size_type __subSize>
vctFixedSizeVectorRef< _elementType, __subSize, _stride > Ref (const size_type startPosition=0) CISST_THROW(std
template<size_type __inputSize, stride_type __inputStride, class __inputDataPtrType, stride_type __indexStride, class __indexDataPtrType>
void SelectFrom (const vctFixedSizeConstVectorBase< __inputSize, __inputStride, _elementType, __inputDataPtrType > &input, const vctFixedSizeConstVectorBase< _size, __indexStride, index_type, __indexDataPtrType > &index)
template<stride_type __stride1, class __dataPtr1Type, stride_type __stride2, class __dataPtr2Type>
void CrossProductOf (const vctFixedSizeConstVectorBase< 3, __stride1, _elementType, __dataPtr1Type > &inputVector1, const vctFixedSizeConstVectorBase< 3, __stride2, _elementType, __dataPtr2Type > &inputVector2)
Binary elementwise operations between two vectors.

Operate on both elements and store values in both.

template<stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
ThisType & SumOf (const vctFixedSizeConstVectorBase< _size, __stride1, value_type, __dataPtrType1 > &vector1, const vctFixedSizeConstVectorBase< _size, __stride2, value_type, __dataPtrType2 > &vector2)
template<stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
ThisType & DifferenceOf (const vctFixedSizeConstVectorBase< _size, __stride1, value_type, __dataPtrType1 > &vector1, const vctFixedSizeConstVectorBase< _size, __stride2, value_type, __dataPtrType2 > &vector2)
template<stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
ThisType & ElementwiseProductOf (const vctFixedSizeConstVectorBase< _size, __stride1, value_type, __dataPtrType1 > &vector1, const vctFixedSizeConstVectorBase< _size, __stride2, value_type, __dataPtrType2 > &vector2)
template<stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
ThisType & ElementwiseRatioOf (const vctFixedSizeConstVectorBase< _size, __stride1, value_type, __dataPtrType1 > &vector1, const vctFixedSizeConstVectorBase< _size, __stride2, value_type, __dataPtrType2 > &vector2)
template<stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
ThisType & ElementwiseMinOf (const vctFixedSizeConstVectorBase< _size, __stride1, value_type, __dataPtrType1 > &vector1, const vctFixedSizeConstVectorBase< _size, __stride2, value_type, __dataPtrType2 > &vector2)
template<stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
ThisType & ElementwiseMaxOf (const vctFixedSizeConstVectorBase< _size, __stride1, value_type, __dataPtrType1 > &vector1, const vctFixedSizeConstVectorBase< _size, __stride2, value_type, __dataPtrType2 > &vector2)
template<stride_type __stride, class __dataPtrType>
ThisType & Add (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector)
template<stride_type __stride, class __dataPtrType>
ThisType & Subtract (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector)
template<stride_type __stride, class __dataPtrType>
ThisType & ElementwiseMultiply (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector)
template<stride_type __stride, class __dataPtrType>
ThisType & ElementwiseDivide (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector)
template<stride_type __stride, class __dataPtrType>
ThisType & ElementwiseMin (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector)
template<stride_type __stride, class __dataPtrType>
ThisType & ElementwiseMax (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector)
template<stride_type __stride, class __dataPtrType>
ThisType & operator+= (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector)
template<stride_type __stride, class __dataPtrType>
ThisType & operator-= (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector)
template<stride_type __stride, class __dataPtrType>
ThisType & SwapElementsWith (vctFixedSizeVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector)
Binary elementwise operations a vector and a scalar.

Store the result of op(vector, scalar) to a third vector.

template<stride_type __stride, class __dataPtrType>
ThisType & SumOf (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &vector, const value_type scalar)
template<stride_type __stride, class __dataPtrType>
ThisType & DifferenceOf (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &vector, const value_type scalar)
template<stride_type __stride, class __dataPtrType>
ThisType & ProductOf (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &vector, const value_type scalar)
template<stride_type __stride, class __dataPtrType>
ThisType & RatioOf (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &vector, const value_type scalar)
template<stride_type __stride, class __dataPtrType>
ThisType & ClippedAboveOf (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &vector, const value_type upperBound)
template<stride_type __stride, class __dataPtrType>
ThisType & ClippedBelowOf (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &vector, const value_type lowerBound)
Binary elementwise operations a scalar and a vector.

Store the result of op(scalar, vector) to a third vector.

template<stride_type __stride, class __dataPtrType>
ThisType & SumOf (const value_type scalar, const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &vector)
template<stride_type __stride, class __dataPtrType>
ThisType & DifferenceOf (const value_type scalar, const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &vector)
template<stride_type __stride, class __dataPtrType>
ThisType & ProductOf (const value_type scalar, const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &vector)
template<stride_type __stride, class __dataPtrType>
ThisType & RatioOf (const value_type scalar, const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &vector)
template<stride_type __stride, class __dataPtrType>
ThisType & ClippedAboveOf (const value_type upperBound, const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &vector)
template<stride_type __stride, class __dataPtrType>
ThisType & ClippedBelowOf (const value_type lowerBound, const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &vector)
Binary elementwise operations between a vector and a scalar.

Store the result of op(this, scalar) back to this vector.

ThisType & Add (const value_type scalar)
ThisType & Subtract (const value_type scalar)
ThisType & Multiply (const value_type scalar)
ThisType & Divide (const value_type scalar)
ThisType & ClipAbove (const value_type upperBound)
ThisType & ClipBelow (const value_type lowerBound)
ThisType & operator+= (const value_type scalar)
ThisType & operator-= (const value_type scalar)
ThisType & operator*= (const value_type scalar)
ThisType & operator/= (const value_type scalar)
template<stride_type __stride, class __dataPtrType>
ThisType & AddProductOf (const value_type scalar, const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector)
template<stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
ThisType & AddElementwiseProductOf (const vctFixedSizeConstVectorBase< _size, __stride1, value_type, __dataPtrType1 > &vector1, const vctFixedSizeConstVectorBase< _size, __stride2, value_type, __dataPtrType2 > &vector2)
Binary elementwise operations between a vector and a matrix.

Store the result of op() to a third vector.

template<size_type __matrixCols, stride_type __matrixRowStride, stride_type __matrixColStride, class __matrixDataPtrType, stride_type __vectorStride, class __vectorDataPtrType>
ThisType & ProductOf (const vctFixedSizeConstMatrixBase< _size, __matrixCols, __matrixRowStride, __matrixColStride, _elementType, __matrixDataPtrType > &inputMatrix, const vctFixedSizeConstVectorBase< __matrixCols, __vectorStride, _elementType, __vectorDataPtrType > &inputVector)
template<size_type __vectorSize, stride_type __vectorStride, class __vectorDataPtrType, stride_type __matrixRowStride, stride_type __matrixColStride, class __matrixDataPtrType>
ThisType & ProductOf (const vctFixedSizeConstVectorBase< __vectorSize, __vectorStride, _elementType, __vectorDataPtrType > &inputVector, const vctFixedSizeConstMatrixBase< __vectorSize, _size, __matrixRowStride, __matrixColStride, _elementType, __matrixDataPtrType > &inputMatrix)
Unary elementwise operations.

Store the result of op(vector) to another vector.

template<stride_type __stride, class __dataPtrType>
ThisType & AbsOf (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector)
template<stride_type __stride, class __dataPtrType>
ThisType & NegationOf (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector)
template<stride_type __stride, class __dataPtrType>
ThisType & FloorOf (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector)
template<stride_type __stride, class __dataPtrType>
ThisType & CeilOf (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector)
template<stride_type __stride, class __dataPtrType>
ThisType & NormalizedOf (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) CISST_THROW(std
Store back unary elementwise operations.

Store the result of op(this) to this vector.

ThisType & AbsSelf (void)
ThisType & NegationSelf (void)
ThisType & FloorSelf (void)
ThisType & CeilSelf (void)
ThisType & NormalizedSelf (void) CISST_THROW(std
Public Member Functions inherited from vctFixedSizeConstVectorBase< _size, _stride, _elementType, _dataPtrType >
 VCT_CONTAINER_TRAITS_TYPEDEFS (_elementType)
const_iterator begin (void) const
const_iterator end (void) const
const_reverse_iterator rbegin (void) const
const_reverse_iterator rend (void) const
size_type size (void) const
size_type max_size (void) const
difference_type stride (void) const
bool empty (void) const
const_reference operator[] (size_type index) const
const_reference at (size_type index) const CISST_THROW(std
const_reference operator() (size_type index) const CISST_THROW(std
const_reference Element (size_type index) const
const_pointer Pointer (size_type index=0) const
bool ValidIndex (size_type index) const
const value_type & X (void) const
const value_type & Y (void) const
const value_type & Z (void) const
const value_type & W (void) const
vctFixedSizeConstVectorRef< _elementType, 2, _stride > XY (void) const
vctFixedSizeConstVectorRef< _elementType, 2, 2 *_stride > XZ (void) const
vctFixedSizeConstVectorRef< _elementType, 2, 3 *_stride > XW (void) const
vctFixedSizeConstVectorRef< _elementType, 2, _stride > YZ (void) const
vctFixedSizeConstVectorRef< _elementType, 2, 2 *_stride > YW (void) const
vctFixedSizeConstVectorRef< _elementType, 2, _stride > ZW (void) const
vctFixedSizeConstVectorRef< _elementType, 3, _stride > XYZ (void) const
vctFixedSizeConstVectorRef< _elementType, 3, _stride > YZW (void) const
vctFixedSizeConstVectorRef< _elementType, 4, _stride > XYZW (void) const
RowConstMatrixRefType AsRowMatrix (void) const
ColConstMatrixRefType AsColMatrix (void) const
template<vct::size_type __subSize>
vctFixedSizeConstVectorRef< _elementType, __subSize, _stride > Ref (const size_type startPosition=0) const CISST_THROW(std
value_type SumOfElements (void) const
value_type ProductOfElements (void) const
value_type NormSquare (void) const
NormType Norm (void) const
bool IsNormalized (_elementType tolerance=cmnTypeTraits< _elementType >::Tolerance()) const
value_type L1Norm (void) const
value_type LinfNorm (void) const
value_type MaxElement (void) const
value_type MinElement (void) const
value_type MaxAbsElement (void) const
value_type MinAbsElement (void) const
void MinAndMaxElement (value_type &minElement, value_type &maxElement) const
bool IsPositive (void) const
bool IsNonNegative (void) const
bool IsNonPositive (void) const
bool IsNegative (void) const
bool All (void) const
bool Any (void) const
bool IsFinite (void) const
bool HasNaN (void) const
bool IsCompact (void) const
bool IsFortran (void) const
template<size_type __size, stride_type __stride, class __dataPtrType>
bool FastCopyCompatible (const vctFixedSizeConstVectorBase< __size, __stride, value_type, __dataPtrType > &source) const
template<class __vectorOwnerType>
bool FastCopyCompatible (const vctDynamicConstVectorBase< __vectorOwnerType, value_type > &source) const
template<stride_type __stride, class __dataPtrType>
value_type DotProduct (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
template<stride_type __stride, class __dataPtrType>
bool Equal (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
template<stride_type __stride, class __dataPtrType>
bool operator== (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
template<stride_type __stride, class __dataPtrType>
bool AlmostEqual (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector, value_type tolerance) const
template<stride_type __stride, class __dataPtrType>
bool AlmostEqual (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
template<stride_type __stride, class __dataPtrType>
bool NotEqual (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
template<stride_type __stride, class __dataPtrType>
bool operator!= (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
template<stride_type __stride, class __dataPtrType>
bool Lesser (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
template<stride_type __stride, class __dataPtrType>
bool LesserOrEqual (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
template<stride_type __stride, class __dataPtrType>
bool Greater (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
template<stride_type __stride, class __dataPtrType>
bool GreaterOrEqual (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
template<stride_type __stride, class __dataPtrType>
BoolVectorValueType ElementwiseEqual (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
template<stride_type __stride, class __dataPtrType>
BoolVectorValueType ElementwiseNotEqual (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
template<stride_type __stride, class __dataPtrType>
BoolVectorValueType ElementwiseLesser (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
template<stride_type __stride, class __dataPtrType>
BoolVectorValueType ElementwiseLesserOrEqual (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
template<stride_type __stride, class __dataPtrType>
BoolVectorValueType ElementwiseGreater (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
template<stride_type __stride, class __dataPtrType>
BoolVectorValueType ElementwiseGreaterOrEqual (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
bool Equal (const value_type &scalar) const
bool operator== (const value_type &scalar) const
bool NotEqual (const value_type &scalar) const
bool operator!= (const value_type &scalar) const
bool Lesser (const value_type &scalar) const
bool LesserOrEqual (const value_type &scalar) const
bool Greater (const value_type &scalar) const
bool GreaterOrEqual (const value_type &scalar) const
BoolVectorValueType ElementwiseEqual (const value_type &scalar) const
BoolVectorValueType ElementwiseNotEqual (const value_type &scalar) const
BoolVectorValueType ElementwiseLesser (const value_type &scalar) const
BoolVectorValueType ElementwiseLesserOrEqual (const value_type &scalar) const
BoolVectorValueType ElementwiseGreater (const value_type &scalar) const
BoolVectorValueType ElementwiseGreaterOrEqual (const value_type &scalar) const
VectorValueType Abs (void) const
VectorValueType Negation (void) const
VectorValueType Floor (void) const
VectorValueType Ceil (void) const
VectorValueType Normalized(void) const CISST_THROW(std void ToStream (std::ostream &outputStream) const
void ToStreamRaw (std::ostream &outputStream, const char delimiter=' ', bool headerOnly=false, const std::string &headerPrefix="") const
void SerializeRaw (std::ostream &outputStream) const

Additional Inherited Members

Protected Member Functions inherited from vctFixedSizeConstVectorBase< _size, _stride, _elementType, _dataPtrType >
void ThrowUnlessValidIndex (size_type index) const CISST_THROW(std
Protected Attributes inherited from vctFixedSizeConstVectorBase< _size, _stride, _elementType, _dataPtrType >
_dataPtrType Data

Detailed Description

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
class vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >

A template for a fixed length vector with fixed spacing in memory.

This class defines a vector with read/write operations. It extends vctFixedSizeConstVectorBase with non-const methods. See the base class for more documentation.

See also
vctFixedSizeConstVectorBase

Member Typedef Documentation

◆ BaseType

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef vctFixedSizeConstVectorBase<_size, _stride, _elementType, _dataPtrType> vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::BaseType

Type of the base class.

◆ ColConstMatrixRefType

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef BaseType::ColConstMatrixRefType vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ColConstMatrixRefType

type of overlay column matrix over this sequence

◆ ColMatrixRefType

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef BaseType::ColMatrixRefType vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ColMatrixRefType

◆ const_iterator

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef VectorTraits::const_iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::const_iterator

◆ const_reverse_iterator

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef VectorTraits::const_reverse_iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::const_reverse_iterator

◆ CopyType

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef BaseType::CopyType vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::CopyType

◆ iterator

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef VectorTraits::iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::iterator

◆ reverse_iterator

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef VectorTraits::reverse_iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::reverse_iterator

◆ RowConstMatrixRefType

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef BaseType::RowConstMatrixRefType vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::RowConstMatrixRefType

type of overlay row matrix over this sequence

◆ RowMatrixRefType

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef BaseType::RowMatrixRefType vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::RowMatrixRefType

◆ ThisType

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef vctFixedSizeVectorBase<_size, _stride, _elementType, _dataPtrType> vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ThisType

◆ TypeTraits

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef cmnTypeTraits<value_type> vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::TypeTraits

◆ VectorTraits

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef vctFixedSizeVectorTraits<_elementType, _size, _stride> vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::VectorTraits

Type traits for the vector. Based on type of elements, size, stride and data representation, it defines array, pointer, etc. (see vctFixedSizeVectorTraits).

Member Enumeration Documentation

◆ anonymous enum

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
anonymous enum
Enumerator
STRIDE 

◆ anonymous enum

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
anonymous enum
Enumerator
SIZE 

◆ anonymous enum

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
anonymous enum
Enumerator
SIZEMINUSONE 

Member Function Documentation

◆ AbsOf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::AbsOf ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & otherVector)
inline

Unary elementwise operations on a vector. For each element of the vector "this", performs \( this[i] \leftarrow op(otherVector[i])\) where \(op\) can calculate the absolute value (AbsOf), the opposite (NegationOf) or the normalized version (NormalizedOf).

Parameters
otherVectorThe operand of the unary operation.
Returns
The vector "this" modified.

◆ AbsSelf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::AbsSelf ( void )
inline

Unary elementwise operations on a vector. For each element of the vector "this", performs \( this[i] \leftarrow op(this[i])\) where \(op\) can calculate the absolute value (AbsSelf), the opposite (NegationSelf) or the normalized version (NormalizedSelf).

Returns
The vector "this" modified.

◆ Add() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Add ( const value_type scalar)
inline

Store back binary elementwise operations between a vector and a scalar. For each element of the vector "this", performs \(this[i] \leftarrow op(this[i], scalar)\) where \(op\) is either an addition (Add), a subtraction (Subtract), a multiplication (Multiply), a division (Divide), a minimum (ClipAbove) or a maximum (ClipBelow).

Parameters
scalarThe second operand of the binary operation (this[i] is the first operand.
Returns
The vector "this" modified.

◆ Add() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Add ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & otherVector)
inline

Store back binary elementwise operations between two vectors. For each element of the vectors, performs \(this[i] \leftarrow op(this[i], otherVector[i])\) where \(op\) is either an addition (Add), a subtraction (Subtraction), a multiplication (ElementwiseMultiply) a division (ElementwiseDivide), a minimization (ElementwiseMin) or a maximisation (ElementwiseMax).

Parameters
otherVectorThe second operand of the binary operation (this[i] is the first operand)
Returns
The vector "this" modified.

◆ AddElementwiseProductOf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::AddElementwiseProductOf ( const vctFixedSizeConstVectorBase< _size, __stride1, value_type, __dataPtrType1 > & vector1,
const vctFixedSizeConstVectorBase< _size, __stride2, value_type, __dataPtrType2 > & vector2 )
inline

◆ AddProductOf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::AddProductOf ( const value_type scalar,
const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & otherVector )
inline

◆ AsColMatrix() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ColMatrixRefType vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::AsColMatrix ( void )
inline

◆ AsColMatrix() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ColConstMatrixRefType vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::AsColMatrix ( void ) const
inline

◆ AsRowMatrix() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
RowMatrixRefType vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::AsRowMatrix ( void )
inline

◆ AsRowMatrix() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
RowConstMatrixRefType vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::AsRowMatrix ( void ) const
inline

Create an overlay matrix (MatrixRef) on top of this vector and return it.

◆ Assign() [1/7]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Assign ( const value_type * elements)
inline

Assign to this vector a set of values provided as independent arguments, by using cstdarg macros, that is, an unspecified number of arguments, greater than 4. This function is not using a recursive engine, as it may be hard and not worthwhile to use a recursive engine with the va_arg ``iterator''. This operation assumes that all the arguments are of type value_type, and that their number is equal to the size of the vector. The arguments are passed by value. The user may need to explicitly cast the parameters to value_type to avoid runtime bugs and errors.

Returns
a reference to this vector. */ inline ThisType & Assign(const value_type element0, const value_type element1, const value_type element2, const value_type element3, const value_type element4, ...) { (*this)[0] = element0; (*this)[1] = element1; (*this)[2] = element2; (*this)[3] = element3; (*this)[4] = element4; va_list nextArg; va_start(nextArg, element4); index_type i; for (i = 5; i < _size; ++i) { (*this)[i] = static_cast<value_type>(va_arg(nextArg, typename TypeTraits::VaArgPromotion)); } va_end(nextArg); return *this; }

/*! Assign to this vector values from a C array given as a pointer to value_type. The purpose of this method is to simplify the syntax by not necessitating the creation of an explicit vector for the given array. However, we only provide this method for an array of value_type. For arrays of other types a vector still needs to be declared.

This method assumes that the input array has the necessary number of elements.

Returns
a reference to this object.

◆ Assign() [2/7]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Assign ( const value_type element0)
inline

The following Assign() methods provide a convenient interface for assigning a list of values to a vector without a need for type conversion. They precede the use of var-arg, which in turn is incapable of enforcing argument type on the arguments following the ellipsis. This simpler interface is defined for a selected collection of vector sizes, namely 1 to 4. For larger sizes, the va_arg interface takes over.

Each of these implementations checks match between the number of arguments and the size of the target vector object. It throws a std::runtime_error if there is a size mismatch.

◆ Assign() [3/7]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Assign ( const value_type element0,
const value_type element1 )
inline

◆ Assign() [4/7]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Assign ( const value_type element0,
const value_type element1,
const value_type element2 )
inline

◆ Assign() [5/7]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Assign ( const value_type element0,
const value_type element1,
const value_type element2,
const value_type element3 )
inline

◆ Assign() [6/7]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<class __vectorOwnerType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Assign ( const vctDynamicConstVectorBase< __vectorOwnerType, value_type > & other)
inline

Assign to this vector values from a dynamic vector. This method doesn't allow type conversion.

Note
This methods creates a dynamic reference (see vctDynamicVectorRef) over the fixed size vector and then use the Assign between two dynamic vectors. As a consequence, the copy uses a loop and not the recursive engines.
Returns
a reference to this object.

◆ Assign() [7/7]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __elementType, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Assign ( const vctFixedSizeConstVectorBase< _size, __stride, __elementType, __dataPtrType > & other)
inline

◆ at() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
reference vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::at ( size_type index)
inline

Access an element by index (const). Compare with std::vector::at. This method can be a handy substitute for the overloaded operator [] when operator overloading is unavailable or inconvenient.

Returns
a non-const reference to element[index]

◆ at() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
const_reference vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::at ( size_type index) const
inline

◆ begin() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::begin ( void )
inline

Returns an iterator on the first element (STL compatibility).

◆ begin() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
const_iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::begin ( void ) const
inline

◆ CeilOf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::CeilOf ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & otherVector)
inline

◆ CeilSelf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::CeilSelf ( void )
inline

◆ ClipAbove()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ClipAbove ( const value_type upperBound)
inline

◆ ClipBelow()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ClipBelow ( const value_type lowerBound)
inline

◆ ClippedAboveOf() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ClippedAboveOf ( const value_type upperBound,
const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & vector )
inline

◆ ClippedAboveOf() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ClippedAboveOf ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & vector,
const value_type upperBound )
inline

◆ ClippedBelowOf() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ClippedBelowOf ( const value_type lowerBound,
const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & vector )
inline

◆ ClippedBelowOf() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ClippedBelowOf ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & vector,
const value_type lowerBound )
inline

◆ ConcatenationOf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __elementTypeVector, class __dataPtrType, class __elementType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ConcatenationOf ( const vctFixedSizeConstVectorBase< SIZEMINUSONE, __stride, __elementTypeVector, __dataPtrType > & other,
__elementType last )
inline

Concatenate a single element at the end of a shorter-by-1 vector to obtain a vector of my size. The concatenation result is stored in this vector. The function is useful, e.g., when embedding vectors from R^n into R^{n+1} or into homogeneous space.

◆ CrossProductOf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride1, class __dataPtr1Type, stride_type __stride2, class __dataPtr2Type>
void vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::CrossProductOf ( const vctFixedSizeConstVectorBase< 3, __stride1, _elementType, __dataPtr1Type > & inputVector1,
const vctFixedSizeConstVectorBase< 3, __stride2, _elementType, __dataPtr2Type > & inputVector2 )
inline

Cross Product of two vectors. This method uses CMN_ASSERT to check that the size of the vector is 3, and can only be performed on arguments vectors of size 3.

◆ DifferenceOf() [1/3]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::DifferenceOf ( const value_type scalar,
const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & vector )
inline

◆ DifferenceOf() [2/3]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::DifferenceOf ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & vector,
const value_type scalar )
inline

◆ DifferenceOf() [3/3]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::DifferenceOf ( const vctFixedSizeConstVectorBase< _size, __stride1, value_type, __dataPtrType1 > & vector1,
const vctFixedSizeConstVectorBase< _size, __stride2, value_type, __dataPtrType2 > & vector2 )
inline

◆ Divide()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Divide ( const value_type scalar)
inline

◆ Element() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
reference vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Element ( size_type index)
inline

Access an element by index (non const). This method allows to access an element without any bounds checking.

Returns
a reference to the element at index

◆ Element() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
const_reference vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Element ( size_type index) const
inline

◆ ElementwiseDivide()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ElementwiseDivide ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & otherVector)
inline

◆ ElementwiseMax()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ElementwiseMax ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & otherVector)
inline

◆ ElementwiseMaxOf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ElementwiseMaxOf ( const vctFixedSizeConstVectorBase< _size, __stride1, value_type, __dataPtrType1 > & vector1,
const vctFixedSizeConstVectorBase< _size, __stride2, value_type, __dataPtrType2 > & vector2 )
inline

◆ ElementwiseMin()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ElementwiseMin ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & otherVector)
inline

◆ ElementwiseMinOf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ElementwiseMinOf ( const vctFixedSizeConstVectorBase< _size, __stride1, value_type, __dataPtrType1 > & vector1,
const vctFixedSizeConstVectorBase< _size, __stride2, value_type, __dataPtrType2 > & vector2 )
inline

◆ ElementwiseMultiply()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ElementwiseMultiply ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & otherVector)
inline

◆ ElementwiseProductOf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ElementwiseProductOf ( const vctFixedSizeConstVectorBase< _size, __stride1, value_type, __dataPtrType1 > & vector1,
const vctFixedSizeConstVectorBase< _size, __stride2, value_type, __dataPtrType2 > & vector2 )
inline

◆ ElementwiseRatioOf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ElementwiseRatioOf ( const vctFixedSizeConstVectorBase< _size, __stride1, value_type, __dataPtrType1 > & vector1,
const vctFixedSizeConstVectorBase< _size, __stride2, value_type, __dataPtrType2 > & vector2 )
inline

◆ end() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::end ( void )
inline

Returns an iterator on the last element (STL compatibility).

◆ end() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
const_iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::end ( void ) const
inline

◆ FastCopyOf() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<class __vectorOwnerType>
bool vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::FastCopyOf ( const vctDynamicConstVectorBase< __vectorOwnerType, value_type > & source,
bool performSafetyChecks = true )
inline

Fast copy. This method uses memcpy whenever it is possible to perform a fast copy from another vector to this vector.

  • The method will first verify that the source and destination have the same size and throws an exception otherwise (std::runtime_error). See cmnThrow for details.
  • If any of the two vectors is not compact, this method will return false. If both vectors are compact, a memcpy is performed and the method returns true.
  • To avoid the tests above, one can set the parameter performSafetyChecks to false. This should be used only when the programmer knows for sure that the source and destination are compatible (size and compactness).
  • As opposed to Assign, this method doesn't perform any type conversion.
  • Since no constructor is called for the contained elements, this function performs a "shallow copy". If the contained objects have a pointer as data member, the copied object will carry on the same pointer (hence pointing at the same memory block which could easily lead to bugs).

The basic and safe use of this method for a vector would be:

if (!destination.FastCopyOf(source)) {
destination.Assign(source);
}

If the method is to be called many times (in a loop for example), it is recommended to check that the source and destination are compatible once and then use the option to turn off the different safety checks for each FastCopyOf.

bool canUseFastCopy = destination.FastCopyCompatible(source);
index_type index;
for (index = 0; index < 1000; index++) {
DoSomethingUseful(source);
if (canUseFastCopy) {
destination.FastCopyOf(source, false); // Do not check again
} else {
destination.Assign(source);
}
}
Parameters
sourceVector used to set the content of this vector.
performSafetyChecksFlag set to false to avoid safety checks, use with extreme caution.

◆ FastCopyOf() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<class __dataPtrType>
bool vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::FastCopyOf ( const vctFixedSizeConstVectorBase< SIZE, STRIDE, value_type, __dataPtrType > & source,
bool performSafetyChecks = true )
inline

◆ FloorOf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::FloorOf ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & otherVector)
inline

◆ FloorSelf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::FloorSelf ( void )
inline

◆ ForceAssign() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<class __vectorOwnerType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ForceAssign ( const vctDynamicConstVectorBase< __vectorOwnerType, value_type > & other)
inline

◆ ForceAssign() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __elementType, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ForceAssign ( const vctFixedSizeConstVectorBase< _size, __stride, __elementType, __dataPtrType > & other)
inline

◆ Multiply()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Multiply ( const value_type scalar)
inline

◆ NegationOf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::NegationOf ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & otherVector)
inline

◆ NegationSelf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::NegationSelf ( void )
inline

◆ NormalizedOf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::NormalizedOf ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & otherVector)
inline

◆ NormalizedSelf()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::NormalizedSelf ( void )
inline

◆ operator()() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
reference vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::operator() ( size_type index)
inline

Access an element by index (non-const). See method at().

Returns
a non-const reference to element[index]

◆ operator()() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
const_reference vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::operator() ( size_type index) const
inline

◆ operator*=()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::operator*= ( const value_type scalar)
inline

◆ operator+=() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::operator+= ( const value_type scalar)
inline

◆ operator+=() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::operator+= ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & otherVector)
inline

◆ operator-=() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::operator-= ( const value_type scalar)
inline

◆ operator-=() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::operator-= ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & otherVector)
inline

◆ operator/=()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::operator/= ( const value_type scalar)
inline

◆ operator=()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __elementType, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::operator= ( const vctFixedSizeConstVectorBase< _size, __stride, __elementType, __dataPtrType > & other)
inline

◆ operator[]() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
reference vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::operator[] ( size_type index)
inline

Access an element by index.

Returns
a reference to the element[index]

◆ operator[]() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
const_reference vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::operator[] ( size_type index) const
inline

◆ Pointer() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
pointer vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Pointer ( size_type index = 0)
inline

Addition to the STL requirements. Return a pointer to an element of the container, specified by its index.

◆ Pointer() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
const_pointer vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Pointer ( size_type index = 0) const
inline

◆ ProductOf() [1/4]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ProductOf ( const value_type scalar,
const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & vector )
inline

◆ ProductOf() [2/4]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<size_type __matrixCols, stride_type __matrixRowStride, stride_type __matrixColStride, class __matrixDataPtrType, stride_type __vectorStride, class __vectorDataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ProductOf ( const vctFixedSizeConstMatrixBase< _size, __matrixCols, __matrixRowStride, __matrixColStride, _elementType, __matrixDataPtrType > & inputMatrix,
const vctFixedSizeConstVectorBase< __matrixCols, __vectorStride, _elementType, __vectorDataPtrType > & inputVector )
inline

Product of a matrix and a vector.

Parameters
inputMatrixThe first operand of the binary operation
inputVectorThe second operand of the binary operation
Returns
The vector "this" modified.

◆ ProductOf() [3/4]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<size_type __vectorSize, stride_type __vectorStride, class __vectorDataPtrType, stride_type __matrixRowStride, stride_type __matrixColStride, class __matrixDataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ProductOf ( const vctFixedSizeConstVectorBase< __vectorSize, __vectorStride, _elementType, __vectorDataPtrType > & inputVector,
const vctFixedSizeConstMatrixBase< __vectorSize, _size, __matrixRowStride, __matrixColStride, _elementType, __matrixDataPtrType > & inputMatrix )
inline

◆ ProductOf() [4/4]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ProductOf ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & vector,
const value_type scalar )
inline

◆ RatioOf() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::RatioOf ( const value_type scalar,
const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & vector )
inline

◆ RatioOf() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::RatioOf ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & vector,
const value_type scalar )
inline

◆ rbegin() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
reverse_iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::rbegin ( void )
inline

Returns a reverse iterator on the last element (STL compatibility).

◆ rbegin() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
const_reverse_iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::rbegin ( void ) const
inline

◆ Ref() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<vct::size_type __subSize>
vctFixedSizeVectorRef< _elementType, __subSize, _stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Ref ( const size_type startPosition = 0)
inline

◆ Ref() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<vct::size_type __subSize>
vctFixedSizeConstVectorRef< _elementType, __subSize, _stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Ref ( const size_type startPosition = 0) const
inline

Create a reference to a sub vector

◆ rend() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
reverse_iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::rend ( void )
inline

Returns a reverse iterator on the element before first (STL compatibility).

◆ rend() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
const_reverse_iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::rend ( void ) const
inline

◆ SelectFrom()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<size_type __inputSize, stride_type __inputStride, class __inputDataPtrType, stride_type __indexStride, class __indexDataPtrType>
void vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::SelectFrom ( const vctFixedSizeConstVectorBase< __inputSize, __inputStride, _elementType, __inputDataPtrType > & input,
const vctFixedSizeConstVectorBase< _size, __indexStride, index_type, __indexDataPtrType > & index )
inline

Select a subset of elements by a given sequence of indexes. The selected elements from the input vector are stored in this vector. There is no requirement of order or uniqueness in the indexes sequence, and no verification that the indexes are valid.

◆ SetAll()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
value_type vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::SetAll ( const value_type & value)
inline

Assign the given value to all the elements.

Parameters
valuethe value used to set all the elements of the vector
Returns
The value used to set all the elements

◆ Subtract() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Subtract ( const value_type scalar)
inline

◆ Subtract() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Subtract ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & otherVector)
inline

◆ SumOf() [1/3]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::SumOf ( const value_type scalar,
const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & vector )
inline

Binary elementwise operations between a scalar and a vector. For each element of the vector "this", performs \( this[i] \leftarrow op(scalar, vector[i])\) where \(op\) is either an addition (SumOf), a subtraction (DifferenceOf), a multiplication (ProductOf), a division (RatioOf), a minimum (ClippedAboveOf) or a maximum (ClippedBelowOf).

Parameters
scalarThe first operand of the binary operation.
vectorThe second operand of the binary operation.
Returns
The vector "this" modified.

◆ SumOf() [2/3]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::SumOf ( const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > & vector,
const value_type scalar )
inline

Binary elementwise operations between a vector and a scalar. For each element of the vector "this", performs \( this[i] \leftarrow op(vector[i], scalar)\) where \(op\) is either an addition (SumOf), a subtraction (DifferenceOf), a multiplication (ProductOf), a division (RatioOf), a minimum (ClippedAboveOf) or a maximum (ClippedBelowOf).

Parameters
vectorThe first operand of the binary operation.
scalarThe second operand of the binary operation.
Returns
The vector "this" modified.

◆ SumOf() [3/3]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::SumOf ( const vctFixedSizeConstVectorBase< _size, __stride1, value_type, __dataPtrType1 > & vector1,
const vctFixedSizeConstVectorBase< _size, __stride2, value_type, __dataPtrType2 > & vector2 )
inline

Binary elementwise operations between two vectors. For each element of the vectors, performs \( this[i] \leftarrow op(vector1[i], vector2[i])\) where \(op\) is either an addition (SumOf), a subtraction (DifferenceOf), a multiplication (ElementwiseProductOf), a division (ElementwiseRatioOf), a minimum (ElementwiseMinOf) or a maximum (ElementwiseMaxOf).

Parameters
vector1The first operand of the binary operation
vector2The second operand of the binary operation
Returns
The vector "this" modified.

◆ SwapElementsWith()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
template<stride_type __stride, class __dataPtrType>
ThisType & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::SwapElementsWith ( vctFixedSizeVectorBase< _size, __stride, value_type, __dataPtrType > & otherVector)
inline

Swap the elements of both vectors with each other.

◆ VCT_CONTAINER_TRAITS_TYPEDEFS()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::VCT_CONTAINER_TRAITS_TYPEDEFS ( _elementType )

◆ W() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
value_type & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::W ( void )
inline

Returns the fourth element of the vector. This method uses CMN_ASSERT to check that the size is at least 4.

◆ W() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
const value_type & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::W ( void ) const
inline

◆ X() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
value_type & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::X ( void )
inline

Returns the first element of the vector. This method uses CMN_ASSERT to check that the size is at least 1.

◆ X() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
const value_type & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::X ( void ) const
inline

◆ XW() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeVectorRef< _elementType, 2, 3 *_stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::XW ( void )
inline

Return a (non-const) vector reference for the first and fourth elements of this vector.

◆ XW() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeConstVectorRef< _elementType, 2, 3 *_stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::XW ( void ) const
inline

◆ XY() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeVectorRef< _elementType, 2, _stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::XY ( void )
inline

Return a (non-const) vector reference for the first two elements of this vector. May be used when switching from homogeneous coordinates to normal

◆ XY() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeConstVectorRef< _elementType, 2, _stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::XY ( void ) const
inline

◆ XYZ() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeVectorRef< _elementType, 3, _stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::XYZ ( void )
inline

Return a (non-const) vector reference for the first three elements of this vector. May be used when switching from homogeneous coordinates to normal, or when refering to a subvector of a row or a column inside a small matrix.

◆ XYZ() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeConstVectorRef< _elementType, 3, _stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::XYZ ( void ) const
inline

◆ XYZW() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeVectorRef< _elementType, 4, _stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::XYZW ( void )
inline

Return a (non-const) vector reference for the first four elements of this vector. May be used when switching from homogeneous coordinates to normal, or when refering to a subvector of a row or a column inside a small matrix.

◆ XYZW() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeConstVectorRef< _elementType, 4, _stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::XYZW ( void ) const
inline

◆ XZ() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeVectorRef< _elementType, 2, 2 *_stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::XZ ( void )
inline

Return a (non-const) vector reference for the first and third elements of this vector.

◆ XZ() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeConstVectorRef< _elementType, 2, 2 *_stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::XZ ( void ) const
inline

◆ Y() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
value_type & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Y ( void )
inline

Returns the second element of the vector. This method uses CMN_ASSERT to check that the size is at least 2.

◆ Y() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
const value_type & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Y ( void ) const
inline

◆ YW() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeVectorRef< _elementType, 2, 2 *_stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::YW ( void )
inline

Return a (non-const) vector reference for the second and fourth elements of this vector.

◆ YW() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeConstVectorRef< _elementType, 2, 2 *_stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::YW ( void ) const
inline

◆ YZ() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeVectorRef< _elementType, 2, _stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::YZ ( void )
inline

Return a (non-const) vector reference for the two elements of this vector beginning on the second.

◆ YZ() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeConstVectorRef< _elementType, 2, _stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::YZ ( void ) const
inline

◆ YZW() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeVectorRef< _elementType, 3, _stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::YZW ( void )
inline

Return a (non-const) vector reference for the second, third and fourth elements of this vector.

◆ YZW() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeConstVectorRef< _elementType, 3, _stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::YZW ( void ) const
inline

◆ Z() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
value_type & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Z ( void )
inline

Returns the third element of the vector. This method uses CMN_ASSERT to check that the size is at least 3.

◆ Z() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
const value_type & vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Z ( void ) const
inline

◆ Zeros()

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
bool vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Zeros ( void )
inline

Assign zero to all elements. This methods assumes that the element type has a zero and this zero value can be set using memset(0). If the vector is not compact this method will use SetAll(0) and memset otherwise. This provides a slightly more efficent way to set all elements to zero.

Returns
true if the vector is compact and memset was used, false otherwise.

◆ ZW() [1/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeVectorRef< _elementType, 2, _stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ZW ( void )
inline

Return a (non-const) vector reference for the two elements of this vector beginning on the third.

◆ ZW() [2/2]

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeConstVectorRef< _elementType, 2, _stride > vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ZW ( void ) const
inline
The documentation for this class was generated from the following file:
Generated by doxygen 1.18.0