vctFixedSizeVectorBase.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*
  Author(s):  Ofri Sadowsky, Anton Deguet
  Created on: 2003-09-30

  (C) Copyright 2003-2015 Johns Hopkins University (JHU), All Rights Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---
*/

#pragma once
#ifndef _vctFixedSizeVectorBase_h
#define _vctFixedSizeVectorBase_h

#include <cisstCommon/cmnDeSerializer.h>
#include <cisstVector/vctFixedSizeConstVectorBase.h>

#include <cstdarg>



#ifndef DOXYGEN
// forward declaration of auxiliary function to multiply matrix*vector
template <vct::size_type _resultSize, vct::stride_type _resultStride, class _resultElementType, class _resultDataPtrType,
          vct::size_type _matrixCols, vct::stride_type _matrixRowStride, vct::stride_type _matrixColStride, class _matrixDataPtrType,
          vct::stride_type _vectorStride, class _vectorDataPtrType>
inline void MultiplyMatrixVector(
    vctFixedSizeVectorBase<_resultSize, _resultStride, _resultElementType, _resultDataPtrType> & result,
    const vctFixedSizeConstMatrixBase<_resultSize, _matrixCols, _matrixRowStride, _matrixColStride,
    _resultElementType, _matrixDataPtrType> & matrix,
    const vctFixedSizeConstVectorBase<_matrixCols, _vectorStride, _resultElementType, _vectorDataPtrType> & vector);

// forward declaration of auxiliary function to multiply vector*matrix
template <vct::size_type _resultSize, vct::stride_type _resultStride, class _resultElementType, class _resultDataPtrType,
          vct::size_type _vectorSize, vct::stride_type _vectorStride, class _vectorDataPtrType,
          vct::stride_type _matrixRowStride, vct::stride_type _matrixColStride, class _matrixDataPtrType >
inline void MultiplyVectorMatrix(
    vctFixedSizeVectorBase<_resultSize, _resultStride, _resultElementType, _resultDataPtrType> & result,
    const vctFixedSizeConstVectorBase<_vectorSize, _vectorStride, _resultElementType, _vectorDataPtrType> & vector,
    const vctFixedSizeConstMatrixBase<_vectorSize, _resultSize, _matrixRowStride, _matrixColStride,
    _resultElementType, _matrixDataPtrType> & matrix);

// forward declaration of Assign method from dynamic vector to fixed size
template <vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType, class _vectorOwnerType>
inline void vctFixedSizeVectorBaseAssignDynamicConstVectorBase(
    vctFixedSizeVectorBase<_size, _stride, _elementType, _dataPtrType> & fixedSizeVector,
    const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & dynamicVector);

#endif // DOXYGEN


template <vct::size_type _size, vct::stride_type _stride, class _elementType, class _dataPtrType>
class vctFixedSizeVectorBase : public vctFixedSizeConstVectorBase<_size, _stride, _elementType, _dataPtrType>
{
 public:
    /* define most types from vctContainerTraits */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);

    typedef vctFixedSizeVectorTraits<_elementType, _size, _stride> VectorTraits;
    /* documented in the base class */
    typedef vctFixedSizeVectorBase<_size, _stride, _elementType, _dataPtrType> ThisType;
    typedef vctFixedSizeConstVectorBase<_size, _stride, _elementType, _dataPtrType> BaseType;
    typedef typename BaseType::CopyType CopyType;
    typedef cmnTypeTraits<value_type> TypeTraits;

    /* Declare the container-defined typed required by STL, plus the
       types completed by our traits class */
    typedef typename VectorTraits::iterator iterator;
    typedef typename VectorTraits::const_iterator const_iterator;
    typedef typename VectorTraits::reverse_iterator reverse_iterator;
    typedef typename VectorTraits::const_reverse_iterator const_reverse_iterator;

    typedef typename BaseType::RowConstMatrixRefType RowConstMatrixRefType;
    typedef typename BaseType::RowMatrixRefType RowMatrixRefType;

    typedef typename BaseType::ColConstMatrixRefType ColConstMatrixRefType;
    typedef typename BaseType::ColMatrixRefType ColMatrixRefType;

    enum {SIZE = BaseType::SIZE};
    enum {STRIDE = BaseType::STRIDE};
    enum {SIZEMINUSONE = SIZE - 1};

    inline iterator begin(void) {
        return iterator(this->Data);
    }


    /* documented in base class */
    inline const_iterator begin(void) const {
        return BaseType::begin();
    }


    iterator end(void) {
        return iterator(this->Data + STRIDE * SIZE);
    }


    /* documented in base class */
    inline const_iterator end(void) const {
        return BaseType::end();
    }


    reverse_iterator rbegin(void) {
        return reverse_iterator(this->Data + STRIDE * (SIZE - 1));
    }


    /* documented in base class */
    const_reverse_iterator rbegin(void) const {
        return BaseType::rbegin();
    }


    reverse_iterator rend(void) {
        return reverse_iterator(this->Data - STRIDE);
    }


    /* documented in base class */
    const_reverse_iterator rend(void) const {
        return BaseType::rend();
    }


    reference operator[](size_type index) {
        return *(Pointer(index));
    }


    /* documented in base class */
    const_reference operator[](size_type index) const {
        return BaseType::operator[](index);
    }

    reference at(size_type index) throw(std::out_of_range) {
        this->ThrowUnlessValidIndex(index);
        return *(Pointer(index));
    }

    /* documented in base class */
    const_reference at(size_type index) const throw(std::out_of_range) {
        return BaseType::at(index);
    }

#ifndef SWIG

    reference operator()(size_type index) throw(std::out_of_range) {
        return at(index);
    }

    /* documented in base class */
    const_reference operator()(size_type index) const throw(std::out_of_range) {
        return BaseType::operator()(index);
    }
#endif


    reference Element(size_type index) {
        return *(Pointer(index));
    }

    /* documented in base class */
    const_reference Element(size_type index) const {
        return BaseType::Element(index);
    }


    pointer Pointer(size_type index = 0) {
        return this->Data + STRIDE * index;
    }


    /* documented in base class */
    const_pointer Pointer(size_type index = 0) const {
        return BaseType::Pointer(index);
    }


    inline value_type SetAll(const value_type & value) {
        return vctFixedSizeVectorRecursiveEngines<_size>::template
            SoVoSi<typename vctBinaryOperations<value_type>::SecondOperand>::
            Unfold(*this, value);
    }


    inline bool Zeros(void) {
        if (this->IsCompact()) {
            memset(this->Pointer(), 0, this->size() * sizeof(value_type));
            return true;
        } else {
            this->SetAll(static_cast<value_type>(0));
            return false;
        }
    }


    template <stride_type __stride, class __elementType, class __dataPtrType>
    inline ThisType & Assign(const vctFixedSizeConstVectorBase<_size, __stride, __elementType, __dataPtrType> & other) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoVi< typename vctUnaryOperations<value_type, __elementType>::Identity >::
            Unfold(*this, other);
        return *this;
    }

    template <stride_type __stride, class __elementType, class __dataPtrType>
    inline ThisType & operator = (const vctFixedSizeConstVectorBase<_size, __stride, __elementType, __dataPtrType> & other) {
        return this->Assign(other);
    }

    inline ThisType & Assign(const value_type element0) throw(std::runtime_error)
    {
        if (this->size() != 1) {
            cmnThrow(std::runtime_error("Mismatch between number of arguments assigned (1) and vector size"));
        }
        (*this)[0] = element0;
        return *this;
    }

    inline ThisType & Assign(const value_type element0, const value_type element1) throw(std::runtime_error)
    {
        if (this->size() != 2) {
            cmnThrow(std::runtime_error("Mismatch between number of arguments assigned (2) and vector size"));
        }
        (*this)[0] = element0;
        (*this)[1] = element1;
        return *this;
    }

    inline ThisType & Assign(const value_type element0, const value_type element1,
                             const value_type element2) throw(std::runtime_error)
    {
        if (this->size() != 3) {
            cmnThrow(std::runtime_error("Mismatch between number of arguments assigned (3) and vector size"));
        }
        (*this)[0] = element0;
        (*this)[1] = element1;
        (*this)[2] = element2;
        return *this;
    }

    inline ThisType & Assign(const value_type element0, const value_type element1,
                             const value_type element2, const value_type element3) throw(std::runtime_error)
    {
        if (this->size() != 4) {
            cmnThrow(std::runtime_error("Mismatch between number of arguments assigned (4) and vector size"));
        }
        (*this)[0] = element0;
        (*this)[1] = element1;
        (*this)[2] = element2;
        (*this)[3] = element3;
        return *this;
    }

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


    inline ThisType & Assign(const value_type * elements)
    {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoVi< typename vctUnaryOperations<value_type>::Identity >::
            Unfold(*this, elements);
        return *this;
    }


    template <class __vectorOwnerType>
    inline ThisType & Assign(const vctDynamicConstVectorBase<__vectorOwnerType, value_type> & other) {
        vctFixedSizeVectorBaseAssignDynamicConstVectorBase(*this, other);
        return *this;
    }


    template <stride_type __stride, class __elementType, class __dataPtrType>
    inline ThisType & ForceAssign(const vctFixedSizeConstVectorBase<_size, __stride, __elementType, __dataPtrType> & other) {
        return this->Assign(other);
    }

    template <class __vectorOwnerType>
    inline ThisType & ForceAssign(const vctDynamicConstVectorBase<__vectorOwnerType, value_type> & other) {
        return this->Assign(other);
    }


    template <class __vectorOwnerType>
    inline bool FastCopyOf(const vctDynamicConstVectorBase<__vectorOwnerType, value_type> & source,
                           bool performSafetyChecks = true)
        throw(std::runtime_error)
    {
        return vctFastCopy::VectorCopy(*this, source, performSafetyChecks);
    }

    template <class __dataPtrType>
    inline bool FastCopyOf(const vctFixedSizeConstVectorBase<SIZE, STRIDE, value_type, __dataPtrType> & source,
                           bool performSafetyChecks = true)
        throw(std::runtime_error)
    {
        return vctFastCopy::VectorCopy(*this, source, performSafetyChecks);
    }



    template <stride_type __stride, class __elementTypeVector, class __dataPtrType, class __elementType>
    inline ThisType & ConcatenationOf(const vctFixedSizeConstVectorBase<SIZEMINUSONE, __stride, __elementTypeVector, __dataPtrType> & other,
                                      __elementType last) {
        // recursive copy for the first size-1 elements
        vctFixedSizeVectorRecursiveEngines<SIZEMINUSONE>::template
            VoVi<typename vctUnaryOperations<value_type, __elementTypeVector>::Identity>::
            Unfold(*this, other);
        // cast and assign last element
        (*this)[SIZEMINUSONE] = value_type(last);
        return *this;
    }




    value_type & X(void) {
        CMN_ASSERT(_size > 0);
        return *(Pointer(0));
    }

    /* documented in base class */
    const value_type & X(void) const {
        return BaseType::X();
    }


    value_type & Y(void) {
        CMN_ASSERT(_size > 1);
        return *(Pointer(1));
    }

    /* documented in base class */
    const value_type & Y(void) const {
        return BaseType::Y();
    }


    value_type & Z(void) {
        CMN_ASSERT(_size > 2);
        return *(Pointer(2));
    }

    /* documented in base class */
    const value_type & Z(void) const {
        return BaseType::Z();
    }

    value_type & W(void) {
        CMN_ASSERT(_size > 3);
        return *(Pointer(3));
    }

    /* documented in base class */
    const value_type & W(void) const {
        return BaseType::W();
    }


    vctFixedSizeVectorRef<_elementType, 2, _stride> XY(void) {
        CMN_ASSERT(_size > 1);
        return vctFixedSizeVectorRef<_elementType, 2, _stride>(Pointer(0));
    }

    vctFixedSizeVectorRef<_elementType, 2, 2 * _stride> XZ(void) {
        CMN_ASSERT(_size > 2);
        return vctFixedSizeVectorRef<_elementType, 2, 2 * _stride>(Pointer(0));
    }

    vctFixedSizeVectorRef<_elementType, 2, 3 * _stride> XW(void) {
        CMN_ASSERT(_size > 3);
        return vctFixedSizeVectorRef<_elementType, 2, 3 * _stride>(Pointer(0));
    }

    vctFixedSizeVectorRef<_elementType, 2, _stride> YZ(void) {
        CMN_ASSERT(_size > 2);
        return vctFixedSizeVectorRef<_elementType, 2, _stride>(Pointer(1));
    }

    vctFixedSizeVectorRef<_elementType, 2, 2 * _stride> YW(void) {
        CMN_ASSERT(_size > 3);
        return vctFixedSizeVectorRef<_elementType, 2, 2 * _stride>(Pointer(1));
    }

    vctFixedSizeVectorRef<_elementType, 2, _stride> ZW(void) {
        CMN_ASSERT(_size > 3);
        return vctFixedSizeVectorRef<_elementType, 2, _stride>(Pointer(2));
    }

    /* documented in base class */
    vctFixedSizeConstVectorRef<_elementType, 2, _stride> XY(void) const {
        return BaseType::XY();
    }

    /* documented in base class */
    vctFixedSizeConstVectorRef<_elementType, 2, 2 * _stride> XZ(void) const {
        return BaseType::XZ();
    }

    /* documented in base class */
    vctFixedSizeConstVectorRef<_elementType, 2, 3 * _stride> XW(void) const {
        return BaseType::XW();
    }

    /* documented in base class */
    vctFixedSizeConstVectorRef<_elementType, 2, _stride> YZ(void) const {
        return BaseType::YZ();
    }

    /* documented in base class */
    vctFixedSizeConstVectorRef<_elementType, 2, 2 * _stride> YW(void) const {
        return BaseType::YW();
    }

    /* documented in base class */
    vctFixedSizeConstVectorRef<_elementType, 2, _stride> ZW(void) const {
        return BaseType::ZW();
    }

    vctFixedSizeVectorRef<_elementType, 3, _stride> XYZ(void) {
        CMN_ASSERT(_size > 2);
        return vctFixedSizeVectorRef<_elementType, 3, _stride>(Pointer(0));
    }


    vctFixedSizeVectorRef<_elementType, 3, _stride> YZW(void) {
        CMN_ASSERT(_size > 3);
        return vctFixedSizeVectorRef<_elementType, 3, _stride>(Pointer(1));
    }

    /* documented in base class */
    vctFixedSizeConstVectorRef<_elementType, 3, _stride> XYZ(void) const {
        return BaseType::XYZ();
    }

    /* documented in base class */
    vctFixedSizeConstVectorRef<_elementType, 3, _stride> YZW(void) const {
        return BaseType::YZW();
    }

    vctFixedSizeVectorRef<_elementType, 4, _stride> XYZW(void) {
        CMN_ASSERT(_size > 3);
        return vctFixedSizeVectorRef<_elementType, 4, _stride>(Pointer(0));
    }

    /* documented in base class */
    vctFixedSizeConstVectorRef<_elementType, 4, _stride> XYZW(void) const {
        return BaseType::XYZW();
    }

    RowConstMatrixRefType AsRowMatrix(void) const
    {
        return BaseType::AsRowMatrix();
    }

    RowMatrixRefType AsRowMatrix(void)
    {
        return RowMatrixRefType(Pointer());
    }

    ColConstMatrixRefType AsColMatrix(void) const
    {
        return BaseType::AsColMatrix();
    }

    ColMatrixRefType AsColMatrix(void)
    {
        return ColMatrixRefType(Pointer());
    }

    template <vct::size_type __subSize>
    vctFixedSizeConstVectorRef<_elementType, __subSize, _stride>
    Ref(const size_type startPosition = 0) const throw (std::out_of_range) {
        return BaseType::Ref(startPosition);
    }

    template <vct::size_type __subSize>
    vctFixedSizeVectorRef<_elementType, __subSize, _stride>
    Ref(const size_type startPosition = 0) throw (std::out_of_range) {
        vctFixedSizeVectorRef<_elementType, __subSize, _stride> result(*this, startPosition);
        return result;
    }

    template <size_type __inputSize, stride_type __inputStride, class __inputDataPtrType,
              stride_type __indexStride, class __indexDataPtrType>
    inline void SelectFrom(const vctFixedSizeConstVectorBase<__inputSize, __inputStride, _elementType, __inputDataPtrType> & input,
                           const vctFixedSizeConstVectorBase<_size, __indexStride, index_type, __indexDataPtrType> & index)
    {
        vctFixedSizeVectorRecursiveEngines<_size>::SelectByIndex::Unfold(*this, input, index);
    }


    template <stride_type __stride1, class __dataPtr1Type, stride_type __stride2, class __dataPtr2Type>
    inline void CrossProductOf(const vctFixedSizeConstVectorBase<3, __stride1, _elementType, __dataPtr1Type> & inputVector1,
                               const vctFixedSizeConstVectorBase<3, __stride2, _elementType, __dataPtr2Type> & inputVector2)
    {
        CMN_ASSERT(SIZE == 3);
        (*this)[0] = inputVector1[1] *  inputVector2[2] - inputVector1[2] * inputVector2[1];
        (*this)[1] = inputVector1[2] *  inputVector2[0] - inputVector1[0] * inputVector2[2];
        (*this)[2] = inputVector1[0] *  inputVector2[1] - inputVector1[1] * inputVector2[0];
    }


    template <stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
    inline ThisType & SumOf(const vctFixedSizeConstVectorBase<_size, __stride1, value_type, __dataPtrType1> & vector1,
                            const vctFixedSizeConstVectorBase<_size, __stride2, value_type, __dataPtrType2> & vector2) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoViVi< typename vctBinaryOperations<value_type>::Addition >
            ::Unfold(*this, vector1, vector2);
        return *this;
    }


    /* documented above */
    template <stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
    inline ThisType & DifferenceOf(const vctFixedSizeConstVectorBase<_size, __stride1, value_type, __dataPtrType1> & vector1,
                                   const vctFixedSizeConstVectorBase<_size, __stride2, value_type, __dataPtrType2> & vector2) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoViVi< typename vctBinaryOperations<value_type>::Subtraction >
            ::Unfold(*this, vector1, vector2);
        return *this;
    }

    /* documented above */
    template <stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
    inline ThisType & ElementwiseProductOf(const vctFixedSizeConstVectorBase<_size, __stride1, value_type, __dataPtrType1> & vector1,
                                           const vctFixedSizeConstVectorBase<_size, __stride2, value_type, __dataPtrType2> & vector2) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoViVi< typename vctBinaryOperations<value_type>::Multiplication >
            ::Unfold(*this, vector1, vector2);
        return *this;
    }

    /* documented above */
    template <stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
    inline ThisType & ElementwiseRatioOf(const vctFixedSizeConstVectorBase<_size, __stride1, value_type, __dataPtrType1> & vector1,
                                         const vctFixedSizeConstVectorBase<_size, __stride2, value_type, __dataPtrType2> & vector2) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoViVi< typename vctBinaryOperations<value_type>::Division >
            ::Unfold(*this, vector1, vector2);
        return *this;
    }

    /* documented above */
    template <stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
    inline ThisType & ElementwiseMinOf(const vctFixedSizeConstVectorBase<_size, __stride1, value_type, __dataPtrType1> & vector1,
                                       const vctFixedSizeConstVectorBase<_size, __stride2, value_type, __dataPtrType2> & vector2) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoViVi< typename vctBinaryOperations<value_type>::Minimum >
            ::Unfold(*this, vector1, vector2);
        return *this;
    }

    /* documented above */
    template <stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
    inline ThisType & ElementwiseMaxOf(const vctFixedSizeConstVectorBase<_size, __stride1, value_type, __dataPtrType1> & vector1,
                                       const vctFixedSizeConstVectorBase<_size, __stride2, value_type, __dataPtrType2> & vector2) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoViVi< typename vctBinaryOperations<value_type>::Maximum >
            ::Unfold(*this, vector1, vector2);
        return *this;
    }

    template <stride_type __stride, class __dataPtrType>
    inline ThisType & Add(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & otherVector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VioVi< typename vctStoreBackBinaryOperations<value_type>::Addition >::
            Unfold(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & Subtract(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & otherVector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VioVi< typename vctStoreBackBinaryOperations<value_type>::Subtraction >::
            Unfold(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & ElementwiseMultiply(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & otherVector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VioVi< typename vctStoreBackBinaryOperations<value_type>::Multiplication >::
            Unfold(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & ElementwiseDivide(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & otherVector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VioVi< typename vctStoreBackBinaryOperations<value_type>::Division >::
            Unfold(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & ElementwiseMin(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & otherVector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VioVi< typename vctStoreBackBinaryOperations<value_type>::Minimum >::
            Unfold(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & ElementwiseMax(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & otherVector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VioVi< typename vctStoreBackBinaryOperations<value_type>::Maximum >::
            Unfold(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & operator += (const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & otherVector) {
        return this->Add(otherVector);
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & operator -= (const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & otherVector) {
        return this->Subtract(otherVector);
    }


    template <stride_type __stride, class __dataPtrType>
    inline ThisType & SwapElementsWith(vctFixedSizeVectorBase<_size, __stride, value_type, __dataPtrType> & otherVector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VioVio< typename vctStoreBackBinaryOperations<value_type>::Swap >::
            Unfold(*this, otherVector);
        return *this;
    }


    template <stride_type __stride, class __dataPtrType>
    inline ThisType & SumOf(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & vector,
                            const value_type scalar) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoViSi< typename vctBinaryOperations<value_type>::Addition >::
            Unfold(*this, vector, scalar);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & DifferenceOf(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & vector,
                                   const value_type scalar) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoViSi< typename vctBinaryOperations<value_type>::Subtraction >::
            Unfold(*this, vector, scalar);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & ProductOf(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & vector,
                                const value_type scalar) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoViSi< typename vctBinaryOperations<value_type>::Multiplication >::
            Unfold(*this, vector, scalar);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & RatioOf(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & vector,
                              const value_type scalar) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoViSi< typename vctBinaryOperations<value_type>::Division >::
            Unfold(*this, vector, scalar);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & ClippedAboveOf(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & vector,
                                     const value_type upperBound) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoViSi<typename vctBinaryOperations<value_type>::Minimum>::
            Unfold(*this, vector, upperBound);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & ClippedBelowOf(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & vector,
                                     const value_type lowerBound) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoViSi< typename vctBinaryOperations<value_type>::Maximum >::
            Unfold(*this, vector, lowerBound);
        return *this;
    }



    template <stride_type __stride, class __dataPtrType>
    inline ThisType & SumOf(const value_type scalar,
                            const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & vector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoSiVi< typename vctBinaryOperations<value_type>::Addition >::
            Unfold(*this, scalar, vector);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & DifferenceOf(const value_type scalar,
                                   const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & vector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoSiVi< typename vctBinaryOperations<value_type>::Subtraction >::
            Unfold(*this, scalar, vector);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & ProductOf(const value_type scalar,
                                const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & vector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoSiVi< typename vctBinaryOperations<value_type>::Multiplication >::
            Unfold(*this, scalar, vector);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & RatioOf(const value_type scalar,
                              const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & vector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoSiVi< typename vctBinaryOperations<value_type>::Division >::
            Unfold(*this, scalar, vector);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & ClippedAboveOf(const value_type upperBound,
                                     const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & vector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoSiVi< typename vctBinaryOperations<value_type>::Minimum >::
            Unfold(*this, upperBound, vector);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & ClippedBelowOf(const value_type lowerBound,
                                     const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & vector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoSiVi< typename vctBinaryOperations<value_type>::Maximum >::
            Unfold(*this, lowerBound, vector);
        return *this;
    }


    inline ThisType & Add(const value_type scalar) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VioSi< typename vctStoreBackBinaryOperations<value_type>::Addition >::
            Unfold(*this, scalar);
      return *this;
    }

    /* documented above */
    inline ThisType & Subtract(const value_type scalar) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VioSi< typename vctStoreBackBinaryOperations<value_type>::Subtraction >::
            Unfold(*this, scalar);
        return *this;
    }

    /* documented above */
    inline ThisType & Multiply(const value_type scalar) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VioSi< typename vctStoreBackBinaryOperations<value_type>::Multiplication >::
            Unfold(*this, scalar);
        return *this;
    }

    /* documented above */
    inline ThisType & Divide(const value_type scalar) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VioSi< typename vctStoreBackBinaryOperations<value_type>::Division >::
            Unfold(*this, scalar);
        return *this;
    }

    /* documented above */
    inline ThisType & ClipAbove(const value_type upperBound) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VioSi< typename vctStoreBackBinaryOperations<value_type>::Minimum >::
            Unfold(*this, upperBound);
        return *this;
    }

    /* documented above */
    inline ThisType & ClipBelow(const value_type lowerBound) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VioSi< typename vctStoreBackBinaryOperations<value_type>::Maximum >::
            Unfold(*this, lowerBound);
        return *this;
    }

    /* documented above */
    inline ThisType & operator += (const value_type scalar) {
        return this->Add(scalar);
    }

    /* documented above */
    inline ThisType & operator -= (const value_type scalar) {
        return this->Subtract(scalar);
    }

    /* documented above */
    inline ThisType & operator *= (const value_type scalar) {
        return this->Multiply(scalar);
    }

    /* documented above */
    inline ThisType & operator /= (const value_type scalar) {
        return this->Divide(scalar);
    }


    template <stride_type __stride, class __dataPtrType>
    inline ThisType & AddProductOf(const value_type scalar,
                                   const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & otherVector)
    {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VioSiVi<
            typename vctStoreBackBinaryOperations<value_type>::Addition,
            typename vctBinaryOperations<value_type>::Multiplication >::
            Unfold(*this, scalar, otherVector);
        return *this;
    }

    template <stride_type __stride1, class __dataPtrType1,
              stride_type __stride2, class __dataPtrType2>
    inline ThisType & AddElementwiseProductOf(const vctFixedSizeConstVectorBase<_size, __stride1, value_type, __dataPtrType1> & vector1,
                                              const vctFixedSizeConstVectorBase<_size, __stride2, value_type, __dataPtrType2> & vector2)

    {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VioViVi<
            typename vctStoreBackBinaryOperations<value_type>::Addition,
            typename vctBinaryOperations<value_type>::Multiplication >::
            Unfold(*this, vector1, vector2);
        return *this;
    }

    template <size_type __matrixCols, stride_type __matrixRowStride, stride_type __matrixColStride, class __matrixDataPtrType,
              stride_type __vectorStride, class __vectorDataPtrType>
    inline ThisType & ProductOf(const vctFixedSizeConstMatrixBase<_size, __matrixCols, __matrixRowStride, __matrixColStride, _elementType, __matrixDataPtrType> & inputMatrix,
                                const vctFixedSizeConstVectorBase<__matrixCols, __vectorStride, _elementType, __vectorDataPtrType> & inputVector)
    {
        MultiplyMatrixVector(*this, inputMatrix, inputVector);
        return *this;
    }

    template <size_type __vectorSize, stride_type __vectorStride, class __vectorDataPtrType,
              stride_type __matrixRowStride, stride_type __matrixColStride, class __matrixDataPtrType>
    inline ThisType & ProductOf(const vctFixedSizeConstVectorBase<__vectorSize,  __vectorStride, _elementType, __vectorDataPtrType> & inputVector,
                                const vctFixedSizeConstMatrixBase<__vectorSize, _size, __matrixRowStride, __matrixColStride, _elementType, __matrixDataPtrType> & inputMatrix )
    {
        MultiplyVectorMatrix(*this, inputVector, inputMatrix);
        return *this;
    }



    template <stride_type __stride, class __dataPtrType>
    inline ThisType & AbsOf(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & otherVector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoVi< typename vctUnaryOperations<value_type>::AbsValue >::
            Unfold(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & NegationOf(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & otherVector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoVi< typename vctUnaryOperations<value_type>::Negation >::
            Unfold(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & FloorOf(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & otherVector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoVi< typename vctUnaryOperations<value_type>::Floor >::
            Unfold(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & CeilOf(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & otherVector) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            VoVi< typename vctUnaryOperations<value_type>::Ceil>::
            Unfold(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <stride_type __stride, class __dataPtrType>
    inline ThisType & NormalizedOf(const vctFixedSizeConstVectorBase<_size, __stride, value_type, __dataPtrType> & otherVector) throw(std::runtime_error) {
        *this = otherVector;
        this->NormalizedSelf();
        return *this;
    }

    inline ThisType & AbsSelf(void) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            Vio< typename vctStoreBackUnaryOperations<value_type>::MakeAbs >::
            Unfold(*this);
        return *this;
    }

    /* documented above */
    inline ThisType & NegationSelf(void) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            Vio< typename vctStoreBackUnaryOperations<value_type>::MakeNegation >::
            Unfold(*this);
        return *this;
    }

    /* documented above */
    inline ThisType & FloorSelf(void) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            Vio< typename vctStoreBackUnaryOperations<value_type>::MakeFloor >::
            Unfold(*this);
        return *this;
    }

    /* documented above */
    inline ThisType & CeilSelf(void) {
        vctFixedSizeVectorRecursiveEngines<_size>::template
            Vio< typename vctStoreBackUnaryOperations<value_type>::MakeCeil >::
            Unfold(*this);
        return *this;
    }

    /* documented above */
    inline ThisType & NormalizedSelf(void) throw(std::runtime_error) {
        value_type norm = value_type(this->Norm());
        if (norm >= TypeTraits::Tolerance()) {
            this->Divide(norm);
        } else {
            cmnThrow(std::runtime_error("Division by quasi zero detected in vctFixedSizeVector NormalizedSelf()"));
        }
        return *this;
    }


#if 0   // eliminating definition of GetSubsequence and GetConstSubsequence methods

    template <class _subsequenceType>
    void GetSubsequence(size_type position, _subsequenceType & result) {
        CMN_ASSERT( (_subsequenceType::STRIDE % ThisType::STRIDE) == 0 );
        CMN_ASSERT( position +
                    ((_subsequenceType::SIZE-1) * (_subsequenceType::STRIDE / ThisType::STRIDE))
                    <= (ThisType::SIZE-1) );
        result.SetRef( Pointer(position) );
    }

    template <class _subsequenceType>
    void GetConstSubsequence(size_type position, _subsequenceType & result) {
        BaseType::GetConstSubsequence(position, result);
    }
#endif  // eliminate definition

    template <size_type _subSize>
    class Subvector {
    public:
        typedef vctFixedSizeVectorRef<value_type, _subSize, STRIDE> Type;
    };

};


#endif  // _vctFixedSizeVectorBase_h