vctDynamicVectorBase.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: 2004-07-01

  (C) Copyright 2004-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 _vctDynamicVectorBase_h
#define _vctDynamicVectorBase_h

#include <cstdarg>

#include <cisstVector/vctDynamicConstVectorBase.h>
#include <cisstVector/vctDynamicConstVectorRef.h>
#include <cisstVector/vctStoreBackUnaryOperations.h>
#include <cisstVector/vctStoreBackBinaryOperations.h>


#ifndef DOXYGEN
// forward declaration of auxiliary function to multiply matrix * vector
template <class _resultVectorOwnerType, class _matrixOwnerType, class _vectorOwnerType, class _elementType>
inline
void vctMultiplyMatrixVector(vctDynamicVectorBase<_resultVectorOwnerType, _elementType> & result,
                             const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & matrix,
                             const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & vector);

// forward declaration of auxiliary function to multiply matrix * vector
template <class _resultVectorOwnerType, class _vectorOwnerType, class _matrixOwnerType, class _elementType>
inline
void vctMultiplyVectorMatrix(vctDynamicVectorBase<_resultVectorOwnerType, _elementType> & result,
                             const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & vector,
                             const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & matrix);
#endif // DOXYGEN

template <class _vectorOwnerType, typename _elementType>
class vctDynamicVectorBase : public vctDynamicConstVectorBase<_vectorOwnerType, _elementType>
{
public:
    friend class vctDynamicVectorLoopEngines;

    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);

    typedef vctDynamicVectorBase ThisType;
    typedef vctDynamicConstVectorBase<_vectorOwnerType, _elementType> BaseType;

    typedef _vectorOwnerType VectorOwnerType;

    typedef typename BaseType::iterator iterator;
    typedef typename BaseType::reverse_iterator reverse_iterator;
    typedef typename BaseType::const_iterator const_iterator;
    typedef typename BaseType::const_reverse_iterator const_reverse_iterator;

    typedef typename BaseType::CopyType CopyType;
    typedef typename BaseType::VectorValueType VectorValueType;


    typedef class cmnTypeTraits<value_type> TypeTraits;
    typedef typename TypeTraits::VaArgPromotion ElementVaArgPromotion;


public:
    iterator begin(void) {
        return this->Vector.begin();
    }

    iterator end(void) {
        return this->Vector.end();
    }

    reverse_iterator rbegin(void) {
        return this->Vector.rbegin();
    }

    reverse_iterator rend(void) {
        return this->Vector.rend();
    }

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

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

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

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

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

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

    /* documented in base class */
    const VectorOwnerType & Owner(void) const {
        return BaseType::Owner();
    }
    VectorOwnerType & Owner(void) {
        return this->Vector;
    }

    pointer Pointer(index_type index = 0) {
        return this->Vector.Pointer(index);
    }

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

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

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

    inline reference operator() (index_type index) throw(std::out_of_range) {
        return this->at(index);
    }

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


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

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


    inline value_type SetAll(const value_type value) {
        vctDynamicVectorLoopEngines::
            VioSi<typename vctStoreBackBinaryOperations<value_type>::SecondOperand>::
            Run(*this, value);
        return 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 <class __vectorOwnerType>
    inline ThisType & Assign(const vctDynamicConstVectorBase<__vectorOwnerType, value_type> & other) {
        if (this->FastCopyCompatible(other)) {
            this->FastCopyOf(other, false);
        } else {
            vctDynamicVectorLoopEngines::
                VoVi<typename vctUnaryOperations<value_type,
                typename __vectorOwnerType::value_type>::Identity>::
                Run(*this, other);
        }
        return *this;
    }

    template <class __vectorOwnerType>
    inline ThisType & Assign(const vctDynamicConstVectorBase<__vectorOwnerType, value_type> & other,
                             size_type length, size_type startPositionThis = 0, size_type startPositionOther = 0) {
        vctDynamicVectorRef<value_type> thisRef(*this, startPositionThis, length);
        vctDynamicConstVectorRef<value_type> otherRef(other, startPositionOther, length);
        thisRef.Assign(otherRef);
        return *this;
    }

    template <class __vectorOwnerType, typename __elementType>
    inline ThisType & Assign(const vctDynamicConstVectorBase<__vectorOwnerType, __elementType> & other) {
        vctDynamicVectorLoopEngines::
            VoVi<typename vctUnaryOperations<value_type,
            typename __vectorOwnerType::value_type>::Identity>::
            Run(*this, other);
        return *this;
    }

    template <class __vectorOwnerType, typename __elementType>
    inline ThisType & operator = (const vctDynamicConstVectorBase<__vectorOwnerType, __elementType> & other) {
        return this->Assign(other);
    }

    template <size_type __size, stride_type __stride, class __elementType, class __dataPtrType>
    inline ThisType & Assign(const vctFixedSizeConstVectorBase<__size, __stride, __elementType, __dataPtrType>
                             & other) {
        vctDynamicVectorLoopEngines::
            VoVi<typename vctUnaryOperations<value_type, __elementType>::Identity>::
            Run(*this, vctDynamicConstVectorRef<__elementType>(other));
        return *this;
    }


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

    template <size_type __size, 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 bool FastCopyOf(const vctDynamicConstVectorBase<__vectorOwnerType, value_type> & source,
                           bool performSafetyChecks = true)
        throw(std::runtime_error)
    {
        return vctFastCopy::VectorCopy(*this, source, performSafetyChecks);
    }

    template <size_type __size, stride_type __stride, 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);
    }



    inline ThisType & Assign(const value_type * elements)
    {
        vctDynamicVectorLoopEngines::
            VoVi< typename vctUnaryOperations<value_type>::Identity >::
            Run(*this, vctDynamicConstVectorRef<value_type>(this->size(), elements));
        return *this;
    }

    inline ThisType & Assign(value_type element0, value_type element1, ...) throw(std::runtime_error) {
        const size_type size = this->size();
        if (size < 2) {
            cmnThrow(std::runtime_error("vctDynamicVector: Assign from va_list requires size >= 2"));
        }
        this->at(0) = element0;
        this->at(1) = element1;
        va_list nextArg;
        va_start(nextArg, element1);
        for (index_type i = 2; i < size; ++i) {
            this->at(i) = value_type( va_arg(nextArg, ElementVaArgPromotion) );
        }
        va_end(nextArg);
        return *this;
    }


    template <class __vectorOwnerType, class __elementType>
    inline ThisType & ConcatenationOf(const vctDynamicConstVectorBase<__vectorOwnerType, __elementType> & otherVector,
                                      __elementType lastElement) {
    vctDynamicVectorRef<value_type> firstElements(*this, 0, otherVector.size() - 1);
        vctDynamicVectorLoopEngines::
            VoVi<typename vctUnaryOperations<value_type, __elementType>::Identity>::
            Run(firstElements, otherVector);
        (*this)[otherVector.size()] = value_type(lastElement);
        return *this;
    }



    value_type & X(void) {
        CMN_ASSERT(this->size() > 0);
        return *(Pointer(0));
    }

    // we have to redeclare it here, shadowed
    const value_type & X(void) const {
        return BaseType::X();
    }


    value_type & Y(void) {
        CMN_ASSERT(this->size() > 1);
        return *(Pointer(1));
    }

    // we have to redeclare it here, shadowed
    const value_type & Y(void) const {
        return BaseType::Y();
    }


    value_type & Z(void) {
        CMN_ASSERT(this->size() > 2);
        return *(Pointer(2));
    }

    // we have to redeclare it here, shadowed
    const value_type & Z(void) const {
        return BaseType::Z();
    }

    value_type & W(void) {
        CMN_ASSERT(this->size() > 3);
        return *(Pointer(3));
    }

    // we have to redeclare it here, shadowed
    const value_type & W(void) const {
        return BaseType::W();
    }

    vctDynamicVectorRef<_elementType> XY(void) {
        CMN_ASSERT(this->size() > 1);
        return vctDynamicVectorRef<_elementType>(2, Pointer(0), this->stride());
    }

    vctDynamicVectorRef<_elementType> XZ(void) {
        CMN_ASSERT(this->size() > 2);
        return vctDynamicVectorRef<_elementType>(2, Pointer(0), 2 * this->stride());
    }

    vctDynamicVectorRef<_elementType> XW(void) {
        CMN_ASSERT(this->size() > 3);
        return vctDynamicVectorRef<_elementType>(2, Pointer(0), 3 * this->stride());
    }

    vctDynamicVectorRef<_elementType> YZ(void) {
        CMN_ASSERT(this->size() > 2);
        return vctDynamicVectorRef<_elementType>(2, Pointer(1), this->stride());
    }

    vctDynamicVectorRef<_elementType> YW(void) {
        CMN_ASSERT(this->size() > 3);
        return vctDynamicVectorRef<_elementType>(2, Pointer(1), 2 * this->stride());
    }

    vctDynamicVectorRef<_elementType> ZW(void) {
        CMN_ASSERT(this->size() > 3);
        return vctDynamicVectorRef<_elementType>(2, Pointer(2), this->stride());
    }

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

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

    /* documented in base class */
    vctDynamicConstVectorRef<_elementType> XW(void) const {
        return BaseType::XW();
    }

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

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

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

    vctDynamicVectorRef<_elementType> XYZ(void) {
        CMN_ASSERT(this->size() > 2);
        return vctDynamicVectorRef<_elementType>(3, Pointer(0), this->stride());
    }

    vctDynamicVectorRef<_elementType> YZW(void) {
        CMN_ASSERT(this->size() > 3);
        return vctDynamicVectorRef<_elementType>(3, Pointer(1),  this->stride());
    }

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

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

    vctDynamicVectorRef<_elementType> XYZW(void) {
        CMN_ASSERT(this->size() > 3);
        return vctDynamicVectorRef<_elementType>(4, Pointer(0), this->stride());
    }

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

    vctDynamicVectorRef<_elementType>
    Ref(const size_type size, const size_type startPosition = 0) throw (std::out_of_range) {
        if ((startPosition + size) > this->size()) {
            cmnThrow(std::out_of_range("vctDynamicConstVectorBase::Ref: reference is out of range"));
        }
        return vctDynamicVectorRef<_elementType>(size, Pointer(startPosition), this->stride());
    }

    vctDynamicConstVectorRef<_elementType>
    Ref(const size_type size, const size_type startPosition = 0) const throw (std::out_of_range) {
        return BaseType::Ref(size, startPosition);
    }

    template <class __inputVectorOwner, class __indexVectorOwner>
    inline void SelectFrom(
        const vctDynamicConstVectorBase<__inputVectorOwner, _elementType> & input,
        const vctDynamicConstVectorBase<__indexVectorOwner, index_type> & index)
    {
        vctDynamicVectorLoopEngines::SelectByIndex::Run(*this, input, index);
    }

    template <class __vectorOwnerType1, class __vectorOwnerType2>
    inline void CrossProductOf(
            const vctDynamicConstVectorBase<__vectorOwnerType1, _elementType> & inputVector1,
            const vctDynamicConstVectorBase<__vectorOwnerType2, _elementType> & inputVector2)
    {
        CMN_ASSERT(this->size() == 3);
        CMN_ASSERT(inputVector1.size() == 3);
        CMN_ASSERT(inputVector2.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 <class __vectorOwnerType1, class __vectorOwnerType2>
    inline ThisType & SumOf(const vctDynamicConstVectorBase<__vectorOwnerType1, _elementType> & vector1,
                            const vctDynamicConstVectorBase<__vectorOwnerType2, _elementType> & vector2) {
        vctDynamicVectorLoopEngines::
            VoViVi< typename vctBinaryOperations<value_type>::Addition >
            ::Run(*this, vector1, vector2);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType1, class __vectorOwnerType2>
    inline ThisType & DifferenceOf(const vctDynamicConstVectorBase<__vectorOwnerType1, _elementType> & vector1,
                                   const vctDynamicConstVectorBase<__vectorOwnerType2, _elementType> & vector2) {
        vctDynamicVectorLoopEngines::
            VoViVi< typename vctBinaryOperations<value_type>::Subtraction >
            ::Run(*this, vector1, vector2);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType1, class __vectorOwnerType2>
    inline ThisType & ElementwiseProductOf(const vctDynamicConstVectorBase<__vectorOwnerType1, _elementType> & vector1,
                                           const vctDynamicConstVectorBase<__vectorOwnerType2, _elementType> & vector2) {
        vctDynamicVectorLoopEngines::
            VoViVi< typename vctBinaryOperations<value_type>::Multiplication >
            ::Run(*this, vector1, vector2);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType1, class __vectorOwnerType2>
    inline ThisType & ElementwiseRatioOf(const vctDynamicConstVectorBase<__vectorOwnerType1, _elementType> & vector1,
                                         const vctDynamicConstVectorBase<__vectorOwnerType2, _elementType> & vector2) {
        vctDynamicVectorLoopEngines::
            VoViVi< typename vctBinaryOperations<value_type>::Division >
            ::Run(*this, vector1, vector2);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType1, class __vectorOwnerType2>
    inline ThisType & ElementwiseMinOf(const vctDynamicConstVectorBase<__vectorOwnerType1, _elementType> & vector1,
                                       const vctDynamicConstVectorBase<__vectorOwnerType2, _elementType> & vector2) {
        vctDynamicVectorLoopEngines::
            VoViVi< typename vctBinaryOperations<value_type>::Minimum >
            ::Run(*this, vector1, vector2);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType1, class __vectorOwnerType2>
    inline ThisType & ElementwiseMaxOf(const vctDynamicConstVectorBase<__vectorOwnerType1, _elementType> & vector1,
                                       const vctDynamicConstVectorBase<__vectorOwnerType2, _elementType> & vector2) {
        vctDynamicVectorLoopEngines::
            VoViVi< typename vctBinaryOperations<value_type>::Maximum >
            ::Run(*this, vector1, vector2);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType1, class __vectorOwnerType2>
    inline ThisType & ElementwiseClippedInOf(const vctDynamicConstVectorBase<__vectorOwnerType1, _elementType> & boundVector,
                                             const vctDynamicConstVectorBase<__vectorOwnerType2, _elementType> & vector) {
        vctDynamicVectorLoopEngines::
            VoViVi< typename vctBinaryOperations<value_type>::ClipIn >
            ::Run(*this, boundVector, vector);
        return *this;
    }



    template <class __vectorOwnerType>
    inline ThisType & Add(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) {
        vctDynamicVectorLoopEngines::
            VioVi<typename vctStoreBackBinaryOperations<value_type>::Addition >::
            Run(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & Subtract(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) {
        vctDynamicVectorLoopEngines::
            VioVi< typename vctStoreBackBinaryOperations<value_type>::Subtraction >::
            Run(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & ElementwiseMultiply(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) {
        vctDynamicVectorLoopEngines::
            VioVi< typename vctStoreBackBinaryOperations<value_type>::Multiplication >::
            Run(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & ElementwiseDivide(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) {
        vctDynamicVectorLoopEngines::
            VioVi< typename vctStoreBackBinaryOperations<value_type>::Division >::
            Run(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & ElementwiseMin(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) {
        vctDynamicVectorLoopEngines::
            VioVi< typename vctStoreBackBinaryOperations<value_type>::Minimum >::
            Run(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & ElementwiseMax(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) {
        vctDynamicVectorLoopEngines::
            VioVi< typename vctStoreBackBinaryOperations<value_type>::Maximum >::
            Run(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & ElementwiseClipIn(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & boundVector) {
        vctDynamicVectorLoopEngines::
            VioVi< typename vctStoreBackBinaryOperations<value_type>::ClipIn >::
            Run(*this, boundVector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & operator += (const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) {
        return this->Add(otherVector);
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & operator -= (const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) {
        return this->Subtract(otherVector);
    }


    template <class __vectorOwnerType>
    inline ThisType & SwapElementsWith(vctDynamicVectorBase<__vectorOwnerType, _elementType> & otherVector) {
        vctDynamicVectorLoopEngines::
            VioVio<typename vctStoreBackBinaryOperations<value_type>::Swap >::
            Run(*this, otherVector);
        return *this;
    }

    template <class __vectorOwnerType>
    inline ThisType & SumOf(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & vector,
                            const value_type scalar) {
        vctDynamicVectorLoopEngines::
            VoViSi< typename vctBinaryOperations<value_type>::Addition >::
            Run(*this, vector, scalar);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & DifferenceOf(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & vector,
                                   const value_type scalar) {
        vctDynamicVectorLoopEngines::
            VoViSi< typename vctBinaryOperations<value_type>::Subtraction >::
            Run(*this, vector, scalar);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & ProductOf(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & vector,
                                const value_type scalar) {
        vctDynamicVectorLoopEngines::
            VoViSi< typename vctBinaryOperations<value_type>::Multiplication >::
            Run(*this, vector, scalar);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & RatioOf(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & vector,
                              const value_type scalar) {
        vctDynamicVectorLoopEngines::
            VoViSi< typename vctBinaryOperations<value_type>::Division >::
            Run(*this, vector, scalar);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & ClippedAboveOf(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & vector,
                                     const value_type upperBound) {
        vctDynamicVectorLoopEngines::
            VoViSi<typename vctBinaryOperations<value_type>::Minimum>::
            Run(*this, vector, upperBound);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & ClippedBelowOf(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & vector,
                                     const value_type lowerBound) {
        vctDynamicVectorLoopEngines::
            VoViSi< typename vctBinaryOperations<value_type>::Maximum >::
            Run(*this, vector, lowerBound);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & ClippedInOf(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & vector,
                                  const value_type bound) {
        vctDynamicVectorLoopEngines::
            VoViSi< typename vctBinaryOperations<value_type>::ClipIn >::
            Run(*this, vector, bound);
        return *this;
    }



    template <class __vectorOwnerType>
    inline ThisType & SumOf(const value_type scalar,
                            const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & vector) {
        vctDynamicVectorLoopEngines::
            VoSiVi< typename vctBinaryOperations<value_type>::Addition >::
            Run(*this, scalar, vector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & DifferenceOf(const value_type scalar,
                                   const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & vector) {
        vctDynamicVectorLoopEngines::
            VoSiVi< typename vctBinaryOperations<value_type>::Subtraction >::
            Run(*this, scalar, vector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & ProductOf(const value_type scalar,
                                const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & vector) {
        vctDynamicVectorLoopEngines::
            VoSiVi< typename vctBinaryOperations<value_type>::Multiplication >::
            Run(*this, scalar, vector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & RatioOf(const value_type scalar,
                              const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & vector) {
        vctDynamicVectorLoopEngines::
            VoSiVi< typename vctBinaryOperations<value_type>::Division >::
            Run(*this, scalar, vector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & ClippedAboveOf(const value_type upperBound,
                                     const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & vector) {
        vctDynamicVectorLoopEngines::
            VoSiVi< typename vctBinaryOperations<value_type>::Minimum >::
            Run(*this, upperBound, vector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & ClippedBelowOf(const value_type lowerBound,
                                     const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & vector) {
        vctDynamicVectorLoopEngines::
            VoSiVi< typename vctBinaryOperations<value_type>::Maximum >::
            Run(*this, lowerBound, vector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & ClippedInOf(const value_type bound,
                                  const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & vector) {
        vctDynamicVectorLoopEngines::
            VoSiVi< typename vctBinaryOperations<value_type>::ClipIn >::
            Run(*this, bound, vector);
        return *this;
    }



    inline ThisType & Add(const value_type scalar) {
        vctDynamicVectorLoopEngines::
            VioSi< typename vctStoreBackBinaryOperations<value_type>::Addition >::
            Run(*this, scalar);
        return *this;
    }

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

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

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

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

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

    /* documented above */
    inline ThisType & ClipIn(const value_type bound) {
        vctDynamicVectorLoopEngines::
            VioSi< typename vctStoreBackBinaryOperations<value_type>::ClipIn >::
            Run(*this, bound);
        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 <class __vectorOwnerType>
    inline ThisType & AddProductOf(const value_type scalar,
                                   const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector)
    {
        vctDynamicVectorLoopEngines::
            VioSiVi<
            typename vctStoreBackBinaryOperations<value_type>::Addition,
            typename vctBinaryOperations<value_type>::Multiplication >::
            Run(*this, scalar, otherVector);
        return *this;
    }

    template <class __vectorOwnerType1, class __vectorOwnerType2>
    inline ThisType & AddElementwiseProductOf(const vctDynamicConstVectorBase<__vectorOwnerType1, _elementType> & vector1,
                                              const vctDynamicConstVectorBase<__vectorOwnerType2, _elementType> & vector2)
    {
        vctDynamicVectorLoopEngines::
            VioViVi<
            typename vctStoreBackBinaryOperations<value_type>::Addition,
            typename vctBinaryOperations<value_type>::Multiplication >::
            Run(*this, vector1, vector2);
        return *this;
    }




    template <class __matrixOwnerType, class __vectorOwnerType>
    inline ThisType & ProductOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & inputMatrix,
                                const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & inputVector) {
        vctMultiplyMatrixVector(*this, inputMatrix, inputVector);
        return *this;
    }


    template <class __vectorOwnerType, class __matrixOwnerType>
    inline ThisType & ProductOf(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & inputVector,
                                const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & inputMatrix) {
        vctMultiplyVectorMatrix(*this, inputVector, inputMatrix);
        return *this;
    }



#ifndef SWIG
    class Subvector
    {
    public:
        typedef vctDynamicVectorRef<value_type> Type;
    };
#endif

    template <class __vectorOwnerType>
    inline ThisType & AbsOf(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) {
        vctDynamicVectorLoopEngines::
            VoVi<typename vctUnaryOperations<value_type>::AbsValue>::
            Run(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & NegationOf(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) {
        vctDynamicVectorLoopEngines::
            VoVi<typename vctUnaryOperations<value_type>::Negation>::
            Run(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & FloorOf(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) {
        vctDynamicVectorLoopEngines::
            VoVi<typename vctUnaryOperations<value_type>::Floor>::
            Run(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & CeilOf(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) {
        vctDynamicVectorLoopEngines::
            VoVi<typename vctUnaryOperations<value_type>::Ceil>::
            Run(*this, otherVector);
        return *this;
    }

    /* documented above */
    template <class __vectorOwnerType>
    inline ThisType & NormalizedOf(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) throw(std::runtime_error) {
        *this = otherVector;
        this->NormalizedSelf();
        return *this;
    }

    inline ThisType & AbsSelf(void) {
        vctDynamicVectorLoopEngines::
            Vio<typename vctStoreBackUnaryOperations<value_type>::MakeAbs>::
            Run(*this);
        return *this;
    }

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

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

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

    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 vctDynamicVector NormalizedSelf()"));
        }
        return *this;
    }


};


#endif // _vctDynamicVectorBase_h