vctDynamicConstNArrayBase.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):  Anton Deguet, Daniel Li, Ofri Sadowsky
  Created on: 2006-06-23

  (C) Copyright 2006-2012 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 _vctDynamicConstNArrayBase_h
#define _vctDynamicConstNArrayBase_h

#include <cisstCommon/cmnTypeTraits.h>
#include <cisstCommon/cmnThrow.h>
#include <cisstCommon/cmnAssert.h>

#include <cisstVector/vctContainerTraits.h>
#include <cisstVector/vctDynamicNArrayLoopEngines.h>
#include <cisstVector/vctFixedSizeVector.h>
#include <cisstVector/vctForwardDeclarations.h>


template <class _nArrayOwnerType, class __nArrayOwnerType, class _elementType,
          class _elementOperationType, vct::size_type _dimension>
inline vctReturnDynamicNArray<bool, _dimension>
vctDynamicNArrayElementwiseCompareNArray(const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & nArray1,
                                         const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & nArray2);

template <class _nArrayOwnerType, class _elementType, class _elementOperationType, vct::size_type _dimension>
inline vctReturnDynamicNArray<bool, _dimension>
vctDynamicNArrayElementwiseCompareScalar(const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & nArray,
                                         const _elementType & scalar);


/* Functions used to generate slices based on dimension, i.e. if
   dimension is 1 return an element, otherwise return an NArray of
   lesser dimension.  The class below is used to specify which
   function is used. */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
inline vctDynamicNArrayRef<_elementType, _dimension - 1>
vctDynamicNArrayNArraySlice(vctDynamicNArrayBase<_nArrayOwnerType, _elementType, _dimension> & input,
                            vct::size_type dimension,
                            vct::index_type index);

template <class _nArrayOwnerType, class _elementType>
inline _elementType &
vctDynamicNArrayElementSlice(vctDynamicNArrayBase<_nArrayOwnerType, _elementType, 1> & input,
                             vct::index_type index);

template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
inline vctDynamicConstNArrayRef<_elementType, _dimension - 1>
vctDynamicNArrayConstNArraySlice(const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & input,
                                 vct::size_type dimension,
                                 vct::index_type index);

template <class _nArrayOwnerType, class _elementType>
inline const _elementType &
vctDynamicNArrayConstElementSlice(const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, 1> & input,
                                  vct::index_type index);

#ifndef SWIG
/* Class used to specify the type of a slice based on the dimension.
   The class also provides a static method to select the right
   function to call.  Code couldn't be inline since it requires a full
   definition of vctDynamicNArrayRef and vctDynamicConstNArrayRef.
   This can't be solved just with forward declarations. */
template <vct::size_type _dimension>
class vctDynamicNArrayTypes
{
public:
    template <class _elementType>
    class SlicesTypes
    {
    public:
        typedef vctDynamicConstNArrayRef<_elementType, _dimension - 1> ConstSliceRefType;
        typedef vctDynamicNArrayRef<_elementType, _dimension - 1> SliceRefType;

        template <class _nArrayOwnerType>
        static ConstSliceRefType ConstSliceOf(const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & input,
                                              vct::size_type dimension, vct::index_type index) {
            return vctDynamicNArrayConstNArraySlice(input, dimension, index);
        }

        template <class _nArrayOwnerType>
        static SliceRefType SliceOf(vctDynamicNArrayBase<_nArrayOwnerType, _elementType, _dimension> & input,
                                    vct::size_type dimension, vct::index_type index) {
            return vctDynamicNArrayNArraySlice(input, dimension, index);
        }
    };
};

/* Specialisation of class for dimension 1.  In this case, a slice is
   a single element. */
template <>
class vctDynamicNArrayTypes<1>
{
public:
    template <class _elementType>
    class SlicesTypes
    {
    public:
        typedef const _elementType & ConstSliceRefType;
        typedef _elementType & SliceRefType;

        template <class _nArrayOwnerType>
        static ConstSliceRefType ConstSliceOf(const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, 1> & input,
                                              vct::size_type CMN_UNUSED(dimension), vct::index_type index) {
            return vctDynamicNArrayConstElementSlice(input, index);
        }

        template <class _nArrayOwnerType>
        static SliceRefType SliceOf(vctDynamicNArrayBase<_nArrayOwnerType, _elementType, 1> & input,
                                    vct::size_type CMN_UNUSED(dimension), vct::index_type index) {
            return vctDynamicNArrayElementSlice(input, index);
        }
    };
};
#endif // SWIG


template <class _nArrayOwnerType, typename _elementType, vct::size_type _dimension>
class vctDynamicConstNArrayBase
{
public:
    /* define most types from vctContainerTraits and vctNArrayTraits */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    VCT_NARRAY_TRAITS_TYPEDEFS(_dimension);

    typedef vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> ThisType;

    typedef _nArrayOwnerType OwnerType;

    enum {DIMENSION = OwnerType::DIMENSION};

    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 vctDynamicConstNArrayRef<value_type, DIMENSION> ConstSubarrayRefType;
    typedef vctDynamicNArrayRef<value_type, DIMENSION> SubarrayRefType;

    typedef vctDynamicConstNArrayRef<value_type, DIMENSION> ConstPermutationRefType;
    typedef vctDynamicNArrayRef<value_type, DIMENSION> PermutationRefType;

#ifndef SWIG
    typedef typename vctDynamicNArrayTypes<DIMENSION>::template SlicesTypes<_elementType> SlicesTypes;
#endif // SWIG
    typedef typename SlicesTypes::ConstSliceRefType ConstSliceRefType;
    typedef typename SlicesTypes::SliceRefType SliceRefType;


    typedef vctReturnDynamicNArray<value_type, DIMENSION> NArrayValueType;

    typedef vctDynamicNArray<value_type, DIMENSION> NArrayReturnType;

    typedef cmnTypeTraits<value_type> TypeTraits;

    typedef typename TypeTraits::BoolType BoolType;

    typedef vctReturnDynamicNArray<BoolType, DIMENSION> BoolNArrayReturnType;



protected:
    OwnerType NArray;

    inline void ThrowUnlessValidDimensionIndex(dimension_type dimensionIndex) const
        throw(std::out_of_range)
    {
        if (! ValidDimensionIndex(dimensionIndex))
        {
            cmnThrow(std::out_of_range("vctDynamicNArray: Invalid index"));
        }
    }

    inline void ThrowUnlessValidIndex(size_type index) const
        throw(std::out_of_range)
    {
        if (! ValidIndex(index))
        {
            cmnThrow(std::out_of_range("vctDynamicNArray: Invalid index"));
        }
    }

    inline void ThrowUnlessValidIndex(const nsize_type & indices) const
        throw(std::out_of_range)
    {
        if (! ValidIndex(indices))
        {
            cmnThrow(std::out_of_range("vctDynamicNArray: Invalid indices"));
        }
    }

    inline void ThrowUnlessValidIndex(dimension_type dimension, size_type index) const
        throw(std::out_of_range)
    {
        if (! ValidIndex(dimension, index))
        {
            cmnThrow(std::out_of_range("vctDynamicNArray: Invalid index"));
        }
    }


public:
    const_iterator begin(void) const
    {
        return NArray.begin();
    }

    const_iterator end(void) const
    {
        return NArray.end();
    }

    const_reverse_iterator rbegin(void) const
    {
        return NArray.rbegin();
    }

    const_reverse_iterator rend(void) const
    {
        return NArray.rend();
    }

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

    const nsize_type & sizes(void) const
    {
        return NArray.sizes();
    }

    size_type size(dimension_type dimension) const
    {
        return NArray.size(dimension);
    }

    const nstride_type & strides(void) const
    {
        return NArray.strides();
    }

    difference_type stride(dimension_type dimension) const
    {
        return NArray.stride(dimension);
    }

    dimension_type dimension(void) const
    {
        return NArray.dimension();
    }

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


    inline bool ValidDimension(dimension_type dimension) const
    {
        return (dimension == this->dimension());
    }

    inline bool ValidDimensionIndex(dimension_type dimensionIndex) const
    {
        return (dimensionIndex < this->dimension());
    }

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

    inline bool ValidIndex(const nsize_type & indices) const
    {
        nsize_type sizes = this->NArray.sizes();
        typename nsize_type::const_iterator sizesIter;
        typename nsize_type::const_iterator indicesIter;

        if (indices.size() != sizes.size())
            return false;

        for (sizesIter = sizes.begin(), indicesIter = indices.begin();
             sizesIter != sizes.end();
             sizesIter++, indicesIter++)
        {
            if (*indicesIter >= *sizesIter)
                return false;
        }

        return true;
    }

    inline bool ValidIndex(dimension_type dimension, size_type index) const
    {
        return ( index < this->size(dimension) );
    }


    const_reference at(size_type metaIndex) const
        throw(std::out_of_range)
    {
        ThrowUnlessValidIndex(metaIndex);
        return (begin())[metaIndex];
    }

    const_reference at(const nsize_type & coordinates) const
        throw(std::out_of_range)
    {
        ThrowUnlessValidIndex(coordinates);
        return *(Pointer(coordinates));
    }

    const_reference operator () (const nsize_type & coordinates) const
        throw(std::out_of_range)
    {
        return this->at(coordinates);
    }


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


    const_pointer Pointer(void) const
    {
        return NArray.Pointer();
    }

    const_pointer Pointer(const nsize_type & indices) const
    {
        return NArray.Pointer(indices);
    }


    const_reference Element(const nsize_type & coordinates) const
    {
        return *(Pointer(coordinates));
    }


    ConstSubarrayRefType Subarray(const nsize_type & startPosition,
                                  const nsize_type & lengths) const
    {
        ConstSubarrayRefType subarray;
        subarray.SubarrayOf(*this, startPosition, lengths);
        return subarray;
    }


    ConstPermutationRefType Permutation(const ndimension_type & dimensions) const
    {
        ConstPermutationRefType permutation;
        permutation.PermutationOf(*this, dimensions);
        return permutation;
    }


    ConstSliceRefType Slice(dimension_type dimension, size_type index) const
        throw(std::runtime_error, std::out_of_range)
    {
        return SlicesTypes::ConstSliceOf(*this, dimension, index);
    }


    ConstSliceRefType operator [] (size_type index) const
    {
        return this->Slice(0, index);
    }



    inline value_type SumOfElements(void) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNi<typename vctBinaryOperations<value_type>::Addition,
            typename vctUnaryOperations<value_type>::Identity>::
            Run(*this);
    }

    inline value_type ProductOfElements(void) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNi<typename vctBinaryOperations<value_type>::Multiplication,
            typename vctUnaryOperations<value_type>::Identity>::
            Run(*this);
    }

    inline value_type NormSquare(void) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNi<typename vctBinaryOperations<value_type>::Addition,
            typename vctUnaryOperations<value_type>::Square>::
            Run(*this);
    }

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

    inline value_type L1Norm(void) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNi<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 vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNi<typename vctBinaryOperations<value_type>::Maximum,
            typename vctUnaryOperations<value_type>::Identity>::
            Run(*this);
    }

    inline value_type MinElement(void) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNi<typename vctBinaryOperations<value_type>::Minimum,
            typename vctUnaryOperations<value_type>::Identity>::
            Run(*this);
    }

    inline value_type MaxAbsElement(void) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNi<typename vctBinaryOperations<value_type>::Maximum,
            typename vctUnaryOperations<value_type>::AbsValue>::
            Run(*this);
    }

    inline value_type MinAbsElement(void) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNi<typename vctBinaryOperations<value_type>::Minimum,
            typename vctUnaryOperations<value_type>::AbsValue>::
            Run(*this);
    }


    inline void MinAndMaxElement(value_type & minElement, value_type & maxElement) const
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::MinAndMax::Run((*this), minElement, maxElement);
    }


    inline bool IsPositive(void) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNi<typename vctBinaryOperations<bool>::And,
            typename vctUnaryOperations<bool, value_type>::IsPositive>::
            Run(*this);
    }

    inline bool IsNonNegative(void) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNi<typename vctBinaryOperations<bool>::And,
            typename vctUnaryOperations<bool, value_type>::IsNonNegative>::
            Run(*this);
    }

    inline bool IsNonPositive(void) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNi<typename vctBinaryOperations<bool>::And,
            typename vctUnaryOperations<bool, value_type>::IsNonPositive>::
            Run(*this);
    }

    inline bool IsNegative (void) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNi< typename vctBinaryOperations<bool>::And,
            typename vctUnaryOperations<bool, value_type>::IsNegative>::
            Run(*this);
    }

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

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

    inline bool IsFinite(void) const {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNi< typename vctBinaryOperations<bool>::And,
            typename vctUnaryOperations<bool, value_type>::IsFinite>::
            Run(*this);
    }

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



    inline bool IsCompact(void) const
    {
        return NArray.IsCompact();
    }


    template <class __nArrayOwnerType>
    inline bool FastCopyCompatible(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & source) const
    {
        return vctFastCopy::NArrayCopyCompatible(*this, source);
    }


    template <class __nArrayOwnerType>
    inline bool Equal(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNiNi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Equal>::
            Run(*this, otherNArray);
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline bool operator == (const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray) const
    {
        return Equal(otherNArray);
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline bool AlmostEqual(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray,
                            value_type tolerance) const
    {
        return ((*this - otherNArray).LinfNorm() <= tolerance);
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline bool AlmostEqual(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray) const
    {
        return ((*this - otherNArray).LinfNorm() <= TypeTraits::Tolerance());
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline bool NotEqual(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNiNi<typename vctBinaryOperations<bool>::Or,
            typename vctBinaryOperations<bool, value_type, value_type>::NotEqual>::
            Run(*this, otherNArray);
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline bool operator != (const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray) const
    {
        return NotEqual(otherNArray);
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline bool Lesser(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNiNi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Lesser>::
            Run(*this, otherNArray);
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline bool LesserOrEqual(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNiNi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::LesserOrEqual>::
            Run(*this, otherNArray);
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline bool Greater(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNiNi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Greater>::
            Run(*this, otherNArray);
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline bool GreaterOrEqual(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNiNi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::GreaterOrEqual>::
            Run(*this, otherNArray);
    }


    template <class __nArrayOwnerType>
    inline BoolNArrayReturnType
    ElementwiseEqual(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray) const
    {
        return vctDynamicNArrayElementwiseCompareNArray<_nArrayOwnerType, __nArrayOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::Equal>(*this, otherNArray);
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline BoolNArrayReturnType
    ElementwiseNotEqual(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray) const
    {
        return vctDynamicNArrayElementwiseCompareNArray<_nArrayOwnerType, __nArrayOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::NotEqual>(*this, otherNArray);
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline BoolNArrayReturnType
    ElementwiseLesser(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray) const
    {
        return vctDynamicNArrayElementwiseCompareNArray<_nArrayOwnerType, __nArrayOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::Lesser>(*this, otherNArray);
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline BoolNArrayReturnType
    ElementwiseLesserOrEqual(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray) const
    {
        return vctDynamicNArrayElementwiseCompareNArray<_nArrayOwnerType, __nArrayOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::LesserOrEqual>(*this, otherNArray);
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline BoolNArrayReturnType
    ElementwiseGreater(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray) const
    {
        return vctDynamicNArrayElementwiseCompareNArray<_nArrayOwnerType, __nArrayOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::Greater>(*this, otherNArray);
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline BoolNArrayReturnType
    ElementwiseGreaterOrEqual(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray) const
    {
        return vctDynamicNArrayElementwiseCompareNArray<_nArrayOwnerType, __nArrayOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::GreaterOrEqual>(*this, otherNArray);
    }



    inline bool Equal(const value_type & scalar) const
    {
        return vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNiSi<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 vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNiSi<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 vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNiSi<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 vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNiSi<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 vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNiSi<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 vctDynamicNArrayLoopEngines<DIMENSION>::template
            SoNiSi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::GreaterOrEqual>::
            Run(*this, scalar);
    }


    BoolNArrayReturnType ElementwiseEqual(const value_type & scalar) const;

    /* documented above */
    BoolNArrayReturnType ElementwiseNotEqual(const value_type & scalar) const;

    /* documented above */
    BoolNArrayReturnType ElementwiseLesser(const value_type & scalar) const;

    /* documented above */
    BoolNArrayReturnType ElementwiseLesserOrEqual(const value_type & scalar) const;

    /* documented above */
    BoolNArrayReturnType ElementwiseGreater(const value_type & scalar) const;

    /* documented above */
    BoolNArrayReturnType ElementwiseGreaterOrEqual(const value_type & scalar) const;


    inline NArrayReturnType Abs(void) const;

    /* documented above */
    inline NArrayReturnType Negation(void) const;

    /* documented above */
    inline NArrayReturnType Floor(void) const;

    /* documented above */
    inline NArrayReturnType Ceil(void) const;


    std::string ToString(void)
    {
        std::stringstream outputStream;
        ToStream(outputStream);
        return outputStream.str();
    }


    void ToStream(std::ostream & outputStream) const {
        // preserve the formatting flags as they were
        const size_t width = outputStream.width(12);
        const size_t precision = outputStream.precision(6);
        bool showpoint = ((outputStream.flags() & std::ios_base::showpoint) != 0);
        outputStream << std::setprecision(6) << std::showpoint;
#if 0
        // this needs to be implemented using template based recursion on dimension, See [] operator implementation.
        this->ToStreamInternal(outputStream);
#endif
        // resume the formatting flags
        outputStream << std::setprecision(precision) << std::setw(width);
        if (!showpoint) {
            outputStream << std::noshowpoint;
        }
    }
};

#ifndef DOXYGEN
/* documented in class.  Implementation moved here for .Net 2003 */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
inline typename vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::BoolNArrayReturnType
vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::ElementwiseEqual(const _elementType & scalar) const
{
    return vctDynamicNArrayElementwiseCompareScalar<_nArrayOwnerType, _elementType,
        typename vctBinaryOperations<bool, _elementType, _elementType>::Equal>(*this, scalar);
}

/* documented in class.  Implementation moved here for .Net 2003 */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
inline typename vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::BoolNArrayReturnType
vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::ElementwiseNotEqual(const _elementType & scalar) const
{
    return vctDynamicNArrayElementwiseCompareScalar<_nArrayOwnerType, _elementType,
        typename vctBinaryOperations<bool, _elementType, _elementType>::NotEqual>(*this, scalar);
}

/* documented in class.  Implementation moved here for .Net 2003 */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
inline typename vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::BoolNArrayReturnType
vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::ElementwiseLesser(const _elementType & scalar) const
{
    return vctDynamicNArrayElementwiseCompareScalar<_nArrayOwnerType, _elementType,
        typename vctBinaryOperations<bool, _elementType, _elementType>::Lesser>(*this, scalar);
}

/* documented in class.  Implementation moved here for .Net 2003 */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
inline typename vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::BoolNArrayReturnType
vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::ElementwiseLesserOrEqual(const _elementType & scalar) const
{
    return vctDynamicNArrayElementwiseCompareScalar<_nArrayOwnerType, _elementType,
        typename vctBinaryOperations<bool, _elementType, _elementType>::LesserOrEqual>(*this, scalar);
}

/* documented in class.  Implementation moved here for .Net 2003 */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
inline typename vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::BoolNArrayReturnType
vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::ElementwiseGreater(const _elementType & scalar) const
{
    return vctDynamicNArrayElementwiseCompareScalar<_nArrayOwnerType, _elementType,
        typename vctBinaryOperations<bool, _elementType, _elementType>::Greater>(*this, scalar);
}

/* documented in class.  Implementation moved here for .Net 2003 */
template <class _nArrayOwnerType, class _elementType, vct::size_type _dimension>
inline typename vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::BoolNArrayReturnType
vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension>::ElementwiseGreaterOrEqual(const _elementType & scalar) const
{
    return vctDynamicNArrayElementwiseCompareScalar<_nArrayOwnerType, _elementType,
        typename vctBinaryOperations<bool, _elementType, _elementType>::GreaterOrEqual>(*this, scalar);
}
#endif // DOXYGEN

template <class _nArrayOwnerType, typename _elementType, vct::size_type _dimension>
inline bool vctAll(const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & nArray)
{
    return nArray.All();
}

template <class _nArrayOwnerType, typename _elementType, vct::size_type _dimension>
inline bool vctAny(const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & nArray) {
    return nArray.Any();
}

template <class _nArrayOwnerType, typename _elementType, vct::size_type _dimension>
std::ostream & operator << (std::ostream & output,
                            const vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> & nArray) {
    nArray.ToStream(output);
    return output;
}


#endif // _vctDynamicConstNArrayBase_h