vctDynamicConstVectorBase.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-2023 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 _vctDynamicConstVectorBase_h
#define _vctDynamicConstVectorBase_h

 
#include <cisstCommon/cmnPortability.h>
#include <cisstCommon/cmnTypeTraits.h>
#include <cisstCommon/cmnThrow.h>
#include <cisstCommon/cmnAssert.h>
#include <cisstCommon/cmnSerializer.h>
 
#include <cisstVector/vctContainerTraits.h>
#include <cisstVector/vctDynamicVectorLoopEngines.h>
#include <cisstVector/vctUnaryOperations.h>
#include <cisstVector/vctBinaryOperations.h>
#include <cisstVector/vctFastCopy.h>
#include <cisstVector/vctForwardDeclarations.h>
 
#include <iostream>
#include <iomanip>
#include <sstream>
 
/* Forward declarations */
#ifndef DOXYGEN
template <class _vectorOwnerType, class __vectorOwnerType, class _elementType,
          class _elementOperationType>
vctReturnDynamicVector<bool>
vctDynamicVectorElementwiseCompareVector(const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & vector1,
                                         const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & vector2);
 
template <class _vectorOwnerType, class _elementType,
          class _elementOperationType>
vctReturnDynamicVector<bool>
vctDynamicVectorElementwiseCompareScalar(const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & vector,
                                         const _elementType & scalar);
#endif // DOXYGEN
 

template <class _vectorOwnerType, typename _elementType>
class vctDynamicConstVectorBase
{
public:
    /* define most types from vctContainerTraits */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);

    typedef vctDynamicConstVectorBase<_vectorOwnerType, _elementType> ThisType;

    typedef _vectorOwnerType OwnerType;

    typedef typename OwnerType::iterator iterator;

    typedef typename OwnerType::const_iterator const_iterator;

    typedef typename OwnerType::reverse_iterator reverse_iterator;

    typedef typename OwnerType::const_reverse_iterator const_reverse_iterator;

    typedef vctDynamicVector<_elementType> CopyType;

    typedef vctDynamicVector<_elementType> VectorValueType;

    typedef vctDynamicVector<_elementType> VectorReturnType;
 
    typedef cmnTypeTraits<value_type> TypeTraits;

    typedef typename TypeTraits::BoolType BoolType;

    typedef vctReturnDynamicVector<BoolType> BoolVectorReturnType;
 
 
protected:
    OwnerType Vector;
 

    inline void ThrowUnlessValidIndex(size_type index) const CISST_THROW(std::out_of_range) {
        if (! ValidIndex(index)) {
            cmnThrow(std::out_of_range("vctDynamicVector: Invalid index"));
        }
    }
 
public:
    const_iterator begin(void) const {
        return Vector.begin();
    }
    const_iterator cbegin(void) const {
        return Vector.begin();
    }


    const_iterator end(void) const {
        return Vector.end();
    }
    const_iterator cend(void) const {
        return Vector.end();
    }


    const_reverse_iterator rbegin(void) const {
        return Vector.rbegin();
    }
    const_reverse_iterator crbegin(void) const {
        return Vector.rbegin();
    }


    const_reverse_iterator rend(void) const {
        return Vector.rend();
    }
    const_reverse_iterator crend(void) const {
        return Vector.rend();
    }


    size_type size(void) const {
        return Vector.size();
    }

    difference_type stride() const {
        return Vector.stride();
    }

    bool empty() const {
        return (size() == 0);
    }

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

    const_reference at(size_type index) const CISST_THROW(std::out_of_range) {
        ThrowUnlessValidIndex(index);
        return *(Pointer(index));
    }

    inline const_reference operator() (size_type index) const CISST_THROW(std::out_of_range) {
        return this->at(index);
    }
 

    const_reference Element(size_type index) const {
        return *(Pointer(index));
    }
 

    const OwnerType & Owner(void) const {
        return this->Vector;
    }
 

    const_pointer Pointer(index_type index = 0) const {
        return Vector.Pointer(index);
    }
 

    inline bool ValidIndex(size_type index) const {
        return (index < size());
    }
 



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

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

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

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

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

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

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

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

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

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

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

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

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


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


    inline value_type SumOfElements(void) const {
        return vctDynamicVectorLoopEngines::
            SoVi<typename vctBinaryOperations<value_type>::Addition,
            typename vctUnaryOperations<value_type>::Identity>::
            Run(*this);
    }

    inline value_type ProductOfElements(void) const {
        return vctDynamicVectorLoopEngines::
            SoVi<typename vctBinaryOperations<value_type>::Multiplication,
            typename vctUnaryOperations<value_type>::Identity>::
            Run(*this);
    }

    inline value_type NormSquare(void) const {
        return vctDynamicVectorLoopEngines::
            SoVi<typename vctBinaryOperations<value_type>::Addition,
            typename vctUnaryOperations<value_type>::Square>::
            Run(*this);
    }

    inline NormType Norm(void) const {
        return sqrt(NormType(NormSquare()));
    }

    inline bool IsNormalized(void) const {
        if (vctUnaryOperations<_elementType>::AbsValue::Operate(_elementType(Norm() - 1)) < TypeTraits::Tolerance()) {
            return true;
        } else {
            return false;
        }
    }

    inline bool IsNormalized(_elementType tolerance) const {
        if (vctUnaryOperations<_elementType>::AbsValue::Operate(_elementType(Norm() - 1)) < tolerance) {
            return true;
        } else {
            return false;
        }
    }

    inline value_type L1Norm(void) const {
        return vctDynamicVectorLoopEngines::
            SoVi<typename vctBinaryOperations<value_type>::Addition,
            typename vctUnaryOperations<value_type>::AbsValue>::
            Run(*this);
    }

    inline value_type LinfNorm(void) const {
        return this->MaxAbsElement();
    }

    inline value_type MaxElement(void) const {
        return vctDynamicVectorLoopEngines::
            SoVi<typename vctBinaryOperations<value_type>::Maximum,
            typename vctUnaryOperations<value_type>::Identity>::
            Run(*this);
    }

    inline value_type MinElement(void) const {
        return vctDynamicVectorLoopEngines::
            SoVi<typename vctBinaryOperations<value_type>::Minimum,
            typename vctUnaryOperations<value_type>::Identity>::
            Run(*this);
    }

    inline value_type MaxAbsElement(void) const {
        return vctDynamicVectorLoopEngines::
            SoVi<typename vctBinaryOperations<value_type>::Maximum,
            typename vctUnaryOperations<value_type>::AbsValue>::
            Run(*this);
    }

    inline value_type MinAbsElement(void) const {
        return vctDynamicVectorLoopEngines::
            SoVi<typename vctBinaryOperations<value_type>::Minimum,
            typename vctUnaryOperations<value_type>::AbsValue>::
            Run(*this);
    }

    inline void MinAndMaxElement(value_type & minElement, value_type & maxElement) const
    {
        vctDynamicVectorLoopEngines::MinAndMax::Run((*this), minElement, maxElement);
    }

    inline bool IsPositive(void) const {
        return vctDynamicVectorLoopEngines::
            SoVi<typename vctBinaryOperations<bool>::And,
            typename vctUnaryOperations<bool, value_type>::IsPositive>::
            Run(*this);
    }

    inline bool IsNonNegative(void) const {
        return vctDynamicVectorLoopEngines::
            SoVi<typename vctBinaryOperations<bool>::And,
            typename vctUnaryOperations<bool, value_type>::IsNonNegative>::
            Run(*this);
    }

    inline bool IsNonPositive(void) const {
        return vctDynamicVectorLoopEngines::
            SoVi<typename vctBinaryOperations<bool>::And,
            typename vctUnaryOperations<bool, value_type>::IsNonPositive>::
            Run(*this);
    }

    inline bool IsNegative (void) const {
        return vctDynamicVectorLoopEngines::
            SoVi< typename vctBinaryOperations<bool>::And,
            typename vctUnaryOperations<bool, value_type>::IsNegative>::
            Run(*this);
    }

    inline bool All(void) const {
        return vctDynamicVectorLoopEngines::
            SoVi< typename vctBinaryOperations<bool>::And,
            typename vctUnaryOperations<bool, value_type>::IsNonzero>::
            Run(*this);
    }

    inline bool Any(void) const {
        return vctDynamicVectorLoopEngines::
            SoVi< typename vctBinaryOperations<bool>::Or,
            typename vctUnaryOperations<bool, value_type>::IsNonzero>::
            Run(*this);
    }

    inline bool IsFinite(void) const {
        return vctDynamicVectorLoopEngines::
            SoVi< typename vctBinaryOperations<bool>::And,
            typename vctUnaryOperations<bool, value_type>::IsFinite>::
            Run(*this);
    }

    inline bool HasNaN(void) const {
        return vctDynamicVectorLoopEngines::
            SoVi< typename vctBinaryOperations<bool>::Or,
            typename vctUnaryOperations<bool, value_type>::IsNaN>::
            Run(*this);
    }

 


    inline bool IsCompact(void) const {
        return (this->stride() == 1);
    }

    inline bool IsFortran(void) const {
        return this->IsCompact();
    }

    template <class __vectorOwnerType>
    inline bool FastCopyCompatible(const vctDynamicConstVectorBase<__vectorOwnerType, value_type> & source) const
    {
        return vctFastCopy::VectorCopyCompatible(*this, source);
    }

    template <size_type __size, stride_type __stride, class __dataPtrType>
    inline bool FastCopyCompatible(const vctFixedSizeConstVectorBase<__size, __stride, value_type, __dataPtrType> & source) const
    {
        return vctFastCopy::VectorCopyCompatible(*this, source);
    }

 

    template <class __vectorOwnerType>
    inline value_type DotProduct(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return vctDynamicVectorLoopEngines::
            SoViVi<typename vctBinaryOperations<value_type>::Addition,
            typename vctBinaryOperations<value_type>::Multiplication>::
            Run(*this, otherVector);
    }
 


    template <class __vectorOwnerType>
    inline bool Equal(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return vctDynamicVectorLoopEngines::
            SoViVi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Equal>::
            Run(*this, otherVector);
    }
 
    /* documented above */
    template <class __vectorOwnerType>
    inline bool operator == (const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return Equal(otherVector);
    }
 
    /* documented above */
    template <class __vectorOwnerType>
    inline bool AlmostEqual(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector,
                            value_type tolerance) const {
        return ((*this - otherVector).LinfNorm() <= tolerance);
    }
 
    /* documented above */
    template <class __vectorOwnerType>
    inline bool AlmostEqual(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return ((*this - otherVector).LinfNorm() <= TypeTraits::Tolerance());
    }
 
    /* documented above */
    template <class __vectorOwnerType>
    inline bool NotEqual(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return vctDynamicVectorLoopEngines::
            SoViVi<typename vctBinaryOperations<bool>::Or,
            typename vctBinaryOperations<bool, value_type, value_type>::NotEqual>::
            Run(*this, otherVector);
    }
 
    /* documented above */
    template <class __vectorOwnerType>
    inline bool operator != (const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return NotEqual(otherVector);
    }
 
    /* documented above */
    template <class __vectorOwnerType>
    inline bool Lesser(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return vctDynamicVectorLoopEngines::
            SoViVi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Lesser>::
            Run(*this, otherVector);
    }
 
    /* documented above */
    template <class __vectorOwnerType>
    inline bool LesserOrEqual(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return vctDynamicVectorLoopEngines::
            SoViVi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::LesserOrEqual>::
            Run(*this, otherVector);
    }
 
    /* documented above */
    template <class __vectorOwnerType>
    inline bool Greater(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return vctDynamicVectorLoopEngines::
            SoViVi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Greater>::
            Run(*this, otherVector);
    }
 
    /* documented above */
    template <class __vectorOwnerType>
    inline bool GreaterOrEqual(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return vctDynamicVectorLoopEngines::
            SoViVi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::GreaterOrEqual>::
            Run(*this, otherVector);
    }

 


    template <class __vectorOwnerType>
    BoolVectorReturnType
    ElementwiseEqual(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return vctDynamicVectorElementwiseCompareVector<
            _vectorOwnerType, __vectorOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::Equal>(*this, otherVector);
    }
 
 
    /* documented above */
    template <class __vectorOwnerType>
    BoolVectorReturnType
    ElementwiseNotEqual(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return vctDynamicVectorElementwiseCompareVector<
            _vectorOwnerType, __vectorOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::NotEqual>(*this, otherVector);
    }
 
    /* documented above */
    template <class __vectorOwnerType>
    BoolVectorReturnType
    ElementwiseLesser(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return vctDynamicVectorElementwiseCompareVector<
            _vectorOwnerType, __vectorOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::Lesser>(*this, otherVector);
    }
 
    /* documented above */
    template <class __vectorOwnerType>
    BoolVectorReturnType
    ElementwiseLesserOrEqual(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return vctDynamicVectorElementwiseCompareVector<
            _vectorOwnerType, __vectorOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::LesserOrEqual>(*this, otherVector);
    }
 
    /* documented above */
    template <class __vectorOwnerType>
    BoolVectorReturnType
    ElementwiseGreater(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return vctDynamicVectorElementwiseCompareVector<
            _vectorOwnerType, __vectorOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::Greater>(*this, otherVector);
    }
 
    /* documented above */
    template <class __vectorOwnerType>
    BoolVectorReturnType
    ElementwiseGreaterOrEqual(const vctDynamicConstVectorBase<__vectorOwnerType, _elementType> & otherVector) const {
        return vctDynamicVectorElementwiseCompareVector<
            _vectorOwnerType, __vectorOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::GreaterOrEqual>(*this, otherVector);
    }

 


    inline bool Equal(const value_type & scalar) const {
        return vctDynamicVectorLoopEngines::
            SoViSi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Equal>::
            Run(*this, scalar);
    }
 
    /* documented above */
    inline bool operator == (const value_type & scalar) const {
        return Equal(scalar);
    }
 
    /* documented above */
    inline bool NotEqual(const value_type & scalar) const {
        return vctDynamicVectorLoopEngines::
            SoViSi<typename vctBinaryOperations<bool>::Or,
            typename vctBinaryOperations<bool, value_type, value_type>::NotEqual>::
            Run(*this, scalar);
    }
 
    /* documented above */
    inline bool operator != (const value_type & scalar) const {
        return NotEqual(scalar);
    }
 
    /* documented above */
    inline bool Lesser(const value_type & scalar) const {
        return vctDynamicVectorLoopEngines::
            SoViSi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Lesser>::
            Run(*this, scalar);
    }
 
    /* documented above */
    inline bool LesserOrEqual(const value_type & scalar) const {
        return vctDynamicVectorLoopEngines::
            SoViSi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::LesserOrEqual>::
            Run(*this, scalar);
    }
 
    /* documented above */
    inline bool Greater(const value_type & scalar) const {
        return vctDynamicVectorLoopEngines::
            SoViSi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Greater>::
            Run(*this, scalar);
    }
 
    /* documented above */
    inline bool GreaterOrEqual(const value_type & scalar) const {
        return vctDynamicVectorLoopEngines::
            SoViSi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::GreaterOrEqual>::
            Run(*this, scalar);
    }



    BoolVectorReturnType ElementwiseEqual(const value_type & scalar) const;
 
    /* documented above */
    BoolVectorReturnType ElementwiseNotEqual(const value_type & scalar) const;
 
    /* documented above */
    BoolVectorReturnType ElementwiseLesser(const value_type & scalar) const;
 
    /* documented above */
    BoolVectorReturnType ElementwiseLesserOrEqual(const value_type & scalar) const;
 
    /* documented above */
    BoolVectorReturnType ElementwiseGreater(const value_type & scalar) const;
 
    /* documented above */
    BoolVectorReturnType ElementwiseGreaterOrEqual(const value_type & scalar) const;

#ifndef SWIG
    class ConstSubvector
    {
    public:
        typedef vctDynamicConstVectorRef<value_type> Type;
    };
#endif // SWIG


    inline VectorReturnType Abs(void) const;
 
    /* documented above */
    inline VectorReturnType Negation(void) const;
 
    /* documented above */
    inline VectorReturnType Floor(void) const;
 
    /* documented above */
    inline VectorReturnType Ceil(void) const;
 
    /* documented above */
    inline VectorReturnType Normalized(void) const CISST_THROW(std::runtime_error);
 
 
    std::string ToString(void) const {
        std::stringstream outputStream;
        ToStream(outputStream);
        return outputStream.str();
    }
 
    void ToStream(std::ostream & outputStream) const
    {
        size_type index;
        const size_type mySize = size();
        // preserve the formatting flags as they were
        const std::streamsize width = outputStream.width(12);
        const std::streamsize precision = outputStream.precision(6);
        bool showpoint = ((outputStream.flags() & std::ios_base::showpoint) != 0);
        outputStream << std::setprecision(6) << std::showpoint;
        for (index = 0; index < mySize; ++index) {
            outputStream << std::setw(12) << (*this)[index];
            if (index < (mySize-1)) {
                outputStream << " ";
            }
        }
        // resume the formatting flags
        outputStream << std::setprecision(precision) << std::setw(width);
        if (!showpoint) {
            outputStream << std::noshowpoint;
        }
    }
 
 
    void ToStreamRaw(std::ostream & outputStream, const char delimiter = ' ',
                     bool headerOnly = false, const std::string & headerPrefix = "") const
    {
        size_type index;
        const size_type mySize = size();
        if (headerOnly) {
            for (index = 0; index < mySize; ++index) {
                outputStream << headerPrefix << "-v" << index;
                if (index < (mySize-1)) {
                    outputStream << delimiter;
                }
            }
        } else {
            for (index = 0; index < mySize; ++index) {
                outputStream << (*this)[index];
                if (index < (mySize-1)) {
                    outputStream << delimiter;
                }
            }
        }
    }

    void SerializeRaw(std::ostream & outputStream) const
    {
        const size_type mySize = size();
        size_type index;
        cmnSerializeSizeRaw(outputStream, mySize);
        for (index = 0; index < mySize; ++index) {
            cmnSerializeRaw(outputStream, this->Element(index));
        }
    }
 
};
 
 
 
/* documented in class.  Implementation moved here for .Net 2003 */
template <class _vectorOwnerType, class _elementType>
inline typename vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::BoolVectorReturnType
vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::ElementwiseEqual(const value_type & scalar) const {
    return vctDynamicVectorElementwiseCompareScalar<_vectorOwnerType,  value_type,
        typename vctBinaryOperations<bool, value_type, value_type>::Equal>(*this, scalar);
}
 
/* documented in class.  Implementation moved here for .Net 2003 */
template <class _vectorOwnerType, class _elementType>
inline typename vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::BoolVectorReturnType
vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::ElementwiseNotEqual(const value_type & scalar) const {
    return vctDynamicVectorElementwiseCompareScalar<_vectorOwnerType,  value_type,
        typename vctBinaryOperations<bool, value_type, value_type>::NotEqual>(*this, scalar);
}
 
/* documented in class.  Implementation moved here for .Net 2003 */
template <class _vectorOwnerType, class _elementType>
inline typename vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::BoolVectorReturnType
vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::ElementwiseLesser(const value_type & scalar) const {
    return vctDynamicVectorElementwiseCompareScalar<_vectorOwnerType,  value_type,
        typename vctBinaryOperations<bool, value_type, value_type>::Lesser>(*this, scalar);
}
 
/* documented in class.  Implementation moved here for .Net 2003 */
template <class _vectorOwnerType, class _elementType>
inline typename vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::BoolVectorReturnType
vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::ElementwiseLesserOrEqual(const value_type & scalar) const {
    return vctDynamicVectorElementwiseCompareScalar<_vectorOwnerType,  value_type,
        typename vctBinaryOperations<bool, value_type, value_type>::LesserOrEqual>(*this, scalar);
}
 
/* documented in class.  Implementation moved here for .Net 2003 */
template <class _vectorOwnerType, class _elementType>
inline typename vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::BoolVectorReturnType
vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::ElementwiseGreater(const value_type & scalar) const {
    return vctDynamicVectorElementwiseCompareScalar<_vectorOwnerType,  value_type,
        typename vctBinaryOperations<bool, value_type, value_type>::Greater>(*this, scalar);
}
 
/* documented in class.  Implementation moved here for .Net 2003 */
template <class _vectorOwnerType, class _elementType>
inline typename vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::BoolVectorReturnType
vctDynamicConstVectorBase<_vectorOwnerType, _elementType>::ElementwiseGreaterOrEqual(const value_type & scalar) const {
    return vctDynamicVectorElementwiseCompareScalar<_vectorOwnerType,  value_type,
        typename vctBinaryOperations<bool, value_type, value_type>::GreaterOrEqual>(*this, scalar);
}
 

template <class _vector1OwnerType, class _vector2OwnerType, class _elementType>
inline _elementType vctDotProduct(const vctDynamicConstVectorBase<_vector1OwnerType, _elementType> & vector1,
                                  const vctDynamicConstVectorBase<_vector2OwnerType, _elementType> & vector2) {
    return vector1.DotProduct(vector2);
}

template <class _vector1OwnerType, class _vector2OwnerType, class _elementType>
inline _elementType operator * (const vctDynamicConstVectorBase<_vector1OwnerType, _elementType> & vector1,
                                const vctDynamicConstVectorBase<_vector2OwnerType, _elementType> & vector2) {
    return vector1.DotProduct(vector2);
}

template <class _vectorOwnerType, typename _elementType>
inline bool vctAll(const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & vector) {
    return vector.All();
}

template <class _vectorOwnerType, typename _elementType>
inline bool vctAny(const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & vector) {
    return vector.Any();
}

template <class _vectorOwnerType, typename _elementType>
std::ostream & operator << (std::ostream & output,
                            const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & vector) {
    vector.ToStream(output);
    return output;
}
 
#ifndef DOXYGEN
template <vct::size_type __size, class _vectorOwnerType, class __elementType>
std::ostream & operator << (std::ostream & output,
                            const vctDynamicConstVectorBase< _vectorOwnerType, vctFixedSizeVector<__elementType, __size> > & vector)
{
    vct::size_type numElements = vector.size();
    vct::size_type counter;
    for (counter = 0; counter < numElements; ++counter) {
        output << "[ ";
        vector[counter].ToStream(output);
        output << "]\n";
    }
    return output;
}
#endif // DOXYGEN
 
 
// helper function declared and used in vctFixedSizeVectorBase.h
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)
{
    vctDynamicVectorRef<_elementType> tempRef(fixedSizeVector);
    tempRef.Assign(dynamicVector);
}
 
 
 
#endif // _vctDynamicConstVectorBase_h