cisst-saw
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Classes | 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< bool, 2 > vctFixedSizeVector< bool, 6 > vctFixedSizeVector< CISSTNETLIB_DOUBLE, _ma+_me > vctFixedSizeVector< CISSTNETLIB_DOUBLE, _n > vctFixedSizeVector< CISSTNETLIB_DOUBLE, LWORK > vctFixedSizeVector< CISSTNETLIB_DOUBLE, MIN_MN > vctFixedSizeVector< CISSTNETLIB_INTEGER, LIWORK > vctFixedSizeVector< CISSTNETLIB_INTEGER, MAX_SIZE_1 > vctFixedSizeVector< CISSTNETLIB_INTEGER, MIN_MN > vctFixedSizeVector< double, 2 > vctFixedSizeVector< double, 3 > vctFixedSizeVector< double, 4 > vctFixedSizeVector< double, 6 > vctFixedSizeVector< double, 7 > vctFixedSizeVector< double, SVL_MAX_CHANNELS > vctFixedSizeVector< float, 4 > vctFixedSizeVector< int, 2 > vctFixedSizeVector< int, 6 > vctFixedSizeVector< int, SVL_MAX_CHANNELS > vctFixedSizeVector< mtsIntuitiveResearchKitSUJArmData *, 4 > vctFixedSizeVector< svlImageProcessing::Internals, SVL_MAX_CHANNELS > vctFixedSizeVector< svlPoint2D, SVL_MAX_CHANNELS > vctFixedSizeVector< svlRect, 2 > vctFixedSizeVector< unsigned char, 3 > vctFixedSizeVector< value_type, DIMENSION > vctFixedSizeVector< vctDynamicMatrix< unsigned int >, 3 > vctFixedSizeVector< vctDynamicVector< int >, 128 > vctFixedSizeVectorRef< CISSTNETLIB_DOUBLE, _ma, 1 > vctFixedSizeVectorRef< CISSTNETLIB_DOUBLE, LWORK_3, 1 > vctFixedSizeVectorRef< CISSTNETLIB_DOUBLE, MIN_MN, 1 > vctFixedSizeVectorRef< CISSTNETLIB_DOUBLE,(_me==0)?1:_me, 1 >

Classes

class  Subvector
 

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 vctFixedSizeVector
< _elementType, _size > 		VectorValueType
 
typedef vctFixedSizeVector
< _elementType, _size > 		CopyType
 
typedef vctFixedSizeVector
< bool, _size > 		BoolVectorValueType
 
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
 

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) throw (std::out_of_range)
 
const_reference at (size_type index) const throw (std::out_of_range)
 
reference operator() (size_type index) throw (std::out_of_range)
 
const_reference operator() (size_type index) const throw (std::out_of_range)
 
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)
 
ThisType & Assign (const value_type element0, const value_type element1, const value_type element2, const value_type element3, const value_type element4,...)
 
ThisType & Assign (const value_type *elements)
 
template<class __vectorOwnerType >
ThisType & Assign (const vctDynamicConstVectorBase< __vectorOwnerType, value_type > &other)
 
template<stride_type __stride, class __elementTypeVector , class __dataPtrType , class __elementType >
ThisType & ConcatenationOf (const vctFixedSizeConstVectorBase< SIZEMINUSONE, __stride, __elementTypeVector, __dataPtrType > &other, __elementType last)
 
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)
 
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)
 
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) throw (std::runtime_error)
 
ThisType & Assign (const value_type element0, const value_type element1) throw (std::runtime_error)
 
ThisType & Assign (const value_type element0, const value_type element1, const value_type element2) throw (std::runtime_error)
 
ThisType & Assign (const value_type element0, const value_type element1, const value_type element2, const value_type element3) throw (std::runtime_error)
 
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) throw (std::runtime_error)
 
template<class __dataPtrType >
bool FastCopyOf (const vctFixedSizeConstVectorBase< SIZE, STRIDE, value_type, __dataPtrType > &source, bool performSafetyChecks=true) throw (std::runtime_error)
 
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 throw (std::out_of_range)
 
template<vct::size_type __subSize>
vctFixedSizeVectorRef
< _elementType, __subSize,
_stride > 		Ref (const size_type startPosition=0) throw (std::out_of_range)
 
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)
 
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) throw (std::runtime_error)
 
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) throw (std::runtime_error)
 
- 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 throw (std::out_of_range)
 
const_reference operator() (size_type index) const throw (std::out_of_range)
 
const_reference Element (size_type index) const
 
const_pointer Pointer (size_type index=0) const
 
bool ValidIndex (size_type index) const
 
template<vct::size_type __subSize>
vctFixedSizeConstVectorRef
< _elementType, __subSize,
_stride > 		Ref (const size_type startPosition=0) const throw (std::out_of_range)
 
template<stride_type __stride, class __dataPtrType >
value_type DotProduct (const vctFixedSizeConstVectorBase< _size, __stride, value_type, __dataPtrType > &otherVector) const
 
std::string ToString (void) const
 
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
 
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
 
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 >
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 throw (std::runtime_error)
 

Additional Inherited Members

- Protected Member Functions inherited from vctFixedSizeConstVectorBase< _size, _stride, _elementType, _dataPtrType >
void ThrowUnlessValidIndex (size_type index) const throw (std::out_of_range)
 
- 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

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.

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

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef BaseType::ColMatrixRefType vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::ColMatrixRefType
template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef VectorTraits::const_iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::const_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
template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef BaseType::CopyType vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::CopyType
template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef VectorTraits::iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::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
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

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef BaseType::RowMatrixRefType vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::RowMatrixRefType
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
template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
typedef cmnTypeTraits<value_type> vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::TypeTraits
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

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

Member Function Documentation

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.
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.
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.
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.
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
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
template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ColConstMatrixRefType vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::AsColMatrix ( void  ) const
inline
template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ColMatrixRefType vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::AsColMatrix ( void  )
inline
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.

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
RowMatrixRefType vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::AsRowMatrix ( void  )
inline
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
template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType& vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::Assign ( const value_type  element0)
throw (std::runtime_error
)
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.

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 
)
throw (std::runtime_error
)
inline
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 
)
throw (std::runtime_error
)
inline
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 
)
throw (std::runtime_error
)
inline
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,
const value_type  element4,
  ... 
)
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.
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 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.
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.
template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
reference vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::at ( size_type  index)
throw (std::out_of_range
)
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]
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
throw (std::out_of_range
)
inline
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).

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
const_iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::begin ( void  ) const
inline
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
template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType& vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::CeilSelf ( void  )
inline
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
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
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
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
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
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
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.

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.

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
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
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
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
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
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
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
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
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
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
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
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
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
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
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).

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
const_iterator vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::end ( void  ) const
inline
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 
)
throw (std::runtime_error
)
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.
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 
)
throw (std::runtime_error
)
inline
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
template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType& vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::FloorSelf ( void  )
inline
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
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
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
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
template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType& vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::NegationSelf ( void  )
inline
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)
throw (std::runtime_error
)
inline
template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
ThisType& vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::NormalizedSelf ( void  )
throw (std::runtime_error
)
inline
template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
reference vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::operator() ( size_type  index)
throw (std::out_of_range
)
inline

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

Returns
a non-const reference to element[index]
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
throw (std::out_of_range
)
inline
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
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
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
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
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
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
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
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]
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
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.

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
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
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
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.
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
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
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
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).

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
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
throw (std::out_of_range
)
inline

Create a reference to a sub vector

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)
throw (std::out_of_range
)
inline
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).

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
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.

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
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
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
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.
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.
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.
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.

template<vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
vctFixedSizeVectorBase< _size, _stride, _elementType, _dataPtrType >::VCT_CONTAINER_TRAITS_TYPEDEFS ( _elementType  )
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.

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
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.

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
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.

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
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

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
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.

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
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.

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
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.

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
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.

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
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.

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
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.

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
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.

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
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.

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
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.
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.

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.8.6