vctDynamicNArrayBase.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):  Daniel Li, Ofri Sadowsky, Anton Deguet
  Created on: 2006-07-10

  (C) Copyright 2006-2013 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 _vctDynamicNArrayBase_h
#define _vctDynamicNArrayBase_h

#include <cisstVector/vctDynamicConstNArrayBase.h>
#include <cisstVector/vctStoreBackUnaryOperations.h>
#include <cisstVector/vctStoreBackBinaryOperations.h>

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

    typedef vctDynamicNArrayBase ThisType;

    typedef vctDynamicConstNArrayBase<_nArrayOwnerType, _elementType, _dimension> BaseType;

    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 typename BaseType::ConstSubarrayRefType ConstSubarrayRefType;
    typedef typename BaseType::SubarrayRefType SubarrayRefType;

    typedef typename BaseType::ConstPermutationRefType ConstPermutationRefType;
    typedef typename BaseType::PermutationRefType PermutationRefType;

    typedef typename BaseType::SlicesTypes SlicesTypes;
    typedef typename BaseType::ConstSliceRefType ConstSliceRefType;
    typedef typename BaseType::SliceRefType SliceRefType;


    iterator begin(void)
    {
        return this->NArray.begin();
    }

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

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

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

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

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

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

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


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


    pointer Pointer(const nsize_type & indices)
    {
        return this->NArray.Pointer(indices);
    }

    /* documented in base class */
    const_pointer Pointer(const nsize_type & indices) const
    {
        return BaseType::Pointer(indices);
    }

    pointer Pointer(void)
    {
        return this->NArray.Pointer();
    }

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


    reference at(size_type metaIndex)
        throw(std::out_of_range)
    {
        this->ThrowUnlessValidIndex(metaIndex);
        return (begin())[metaIndex];
    }


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


    reference at(const nsize_type & coordinates)
        throw(std::out_of_range)
    {
        this->ThrowUnlessValidIndex(coordinates);
        return *(Pointer(coordinates));
    }

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


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

     const_reference operator () (const nsize_type & coordinates) const
        throw(std::out_of_range)
    {
        return BaseType::operator()(coordinates);
    }


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

    /* documented in base class */
    const_reference Element(const nsize_type & coordinates) const
    {
        return BaseType::Element(coordinates);
    }


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


    ConstSubarrayRefType Subarray(const nsize_type & startPosition,
                                  const nsize_type & lengths) const
    {
        return BaseType::Subarray(startPosition, lengths);
    }


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


    ConstPermutationRefType Permutation(const ndimension_type & dimensions) const
    {
        return BaseType::Permutation(dimensions);
    }


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


    ConstSliceRefType Slice(dimension_type dimension, size_type index) const
        throw(std::runtime_error, std::out_of_range)
    {
        return BaseType::Slice(dimension, index);
    }


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


    ConstSliceRefType operator[](size_type index) const
    {
        return BaseType::operator[](index);
    }


    inline value_type SetAll(const value_type value)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NioSi<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 __nArrayOwnerType>
    inline ThisType & Assign(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & other) {
        if (this->FastCopyCompatible(other)) {
            this->FastCopyOf(other, false);
        } else {
            vctDynamicNArrayLoopEngines<DIMENSION>::template
                NoNi<typename vctUnaryOperations<value_type,
                typename __nArrayOwnerType::value_type>::Identity>::
                Run(*this, other);
        }
        return *this;
    }


    template <class __nArrayOwnerType, typename __elementType>
    inline ThisType & Assign(const vctDynamicConstNArrayBase<__nArrayOwnerType, __elementType, DIMENSION> & other)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNi<typename vctUnaryOperations<value_type,
            typename __nArrayOwnerType::value_type>::Identity>::
            Run(*this, other);
        return *this;
    }

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


    inline ThisType & Assign(const value_type * elements)
    {
        nstride_type strides;
        typename nsize_type::const_reverse_iterator sizesIter = this->sizes().rbegin();
        typename nstride_type::reverse_iterator stridesIter = strides.rbegin();
        const typename nstride_type::const_reverse_iterator stridesEnd = strides.rend();
        size_type sizesIter_value;
        stride_type previous_stride;

        if (stridesIter != stridesEnd)
        {
            *stridesIter = 1;
            previous_stride = 1;
            ++stridesIter;
        }

        for (; stridesIter != stridesEnd;
             ++stridesIter, ++sizesIter)
        {
            sizesIter_value = (*sizesIter == 0) ? 1 : *sizesIter;
            *stridesIter = sizesIter_value * previous_stride;
            previous_stride = *stridesIter;
        }

        const vctDynamicConstNArrayRef<value_type, DIMENSION> tmpRef(elements,
                                                                      this->sizes(),
                                                                      strides);
        this->Assign(tmpRef);
        return *this;
    }


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


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


    template <class __nArrayOwnerType1, class __nArrayOwnerType2>
    inline ThisType & SumOf(const vctDynamicConstNArrayBase<__nArrayOwnerType1, value_type, DIMENSION> & nArray1,
                            const vctDynamicConstNArrayBase<__nArrayOwnerType2, value_type, DIMENSION> & nArray2)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNiNi< typename vctBinaryOperations<value_type>::Addition >
            ::Run(*this, nArray1, nArray2);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType1, class __nArrayOwnerType2>
    inline ThisType & DifferenceOf(const vctDynamicConstNArrayBase<__nArrayOwnerType1, value_type, DIMENSION> & nArray1,
                                   const vctDynamicConstNArrayBase<__nArrayOwnerType2, value_type, DIMENSION> & nArray2)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNiNi< typename vctBinaryOperations<value_type>::Subtraction >
            ::Run(*this, nArray1, nArray2);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType1, class __nArrayOwnerType2>
    inline ThisType & ElementwiseProductOf(const vctDynamicConstNArrayBase<__nArrayOwnerType1, value_type, DIMENSION> & nArray1,
                                           const vctDynamicConstNArrayBase<__nArrayOwnerType2, value_type, DIMENSION> & nArray2)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNiNi< typename vctBinaryOperations<value_type>::Multiplication >
            ::Run(*this, nArray1, nArray2);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType1, class __nArrayOwnerType2>
    inline ThisType & ElementwiseRatioOf(const vctDynamicConstNArrayBase<__nArrayOwnerType1, value_type, DIMENSION> & nArray1,
                                         const vctDynamicConstNArrayBase<__nArrayOwnerType2, value_type, DIMENSION> & nArray2)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNiNi< typename vctBinaryOperations<value_type>::Division >
            ::Run(*this, nArray1, nArray2);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType1, class __nArrayOwnerType2>
    inline ThisType & ElementwiseMinOf(const vctDynamicConstNArrayBase<__nArrayOwnerType1, value_type, DIMENSION> & nArray1,
                                       const vctDynamicConstNArrayBase<__nArrayOwnerType2, value_type, DIMENSION> & nArray2)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNiNi< typename vctBinaryOperations<value_type>::Minimum >
            ::Run(*this, nArray1, nArray2);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType1, class __nArrayOwnerType2>
    inline ThisType & ElementwiseMaxOf(const vctDynamicConstNArrayBase<__nArrayOwnerType1, value_type, DIMENSION> & nArray1,
                                       const vctDynamicConstNArrayBase<__nArrayOwnerType2, value_type, DIMENSION> & nArray2)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNiNi< typename vctBinaryOperations<value_type>::Maximum >
            ::Run(*this, nArray1, nArray2);
        return *this;
    }



    template <class __nArrayOwnerType>
    inline ThisType & Add(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NioNi<typename vctStoreBackBinaryOperations<value_type>::Addition >::
            Run(*this, otherNArray);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & Subtract(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NioNi< typename vctStoreBackBinaryOperations<value_type>::Subtraction >::
            Run(*this, otherNArray);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & ElementwiseMultiply(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NioNi< typename vctStoreBackBinaryOperations<value_type>::Multiplication >::
            Run(*this, otherNArray);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & ElementwiseDivide(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NioNi< typename vctStoreBackBinaryOperations<value_type>::Division >::
            Run(*this, otherNArray);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & ElementwiseMin(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NioNi< typename vctStoreBackBinaryOperations<value_type>::Minimum >::
            Run(*this, otherNArray);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & ElementwiseMax(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NioNi< typename vctStoreBackBinaryOperations<value_type>::Maximum >::
            Run(*this, otherNArray);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & operator += (const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray)
    {
        return this->Add(otherNArray);
    }

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


    template <class __nArrayOwnerType>
    inline ThisType & SumOf(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & nArray,
                            const value_type scalar)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNiSi< typename vctBinaryOperations<value_type>::Addition >::
            Run(*this, nArray, scalar);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & DifferenceOf(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & nArray,
                                   const value_type scalar)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNiSi< typename vctBinaryOperations<value_type>::Subtraction >::
            Run(*this, nArray, scalar);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & ProductOf(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & nArray,
                                const value_type scalar)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNiSi< typename vctBinaryOperations<value_type>::Multiplication >::
            Run(*this, nArray, scalar);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & RatioOf(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & nArray,
                              const value_type scalar)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNiSi< typename vctBinaryOperations<value_type>::Division >::
            Run(*this, nArray, scalar);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & ClippedAboveOf(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & nArray,
                                     const value_type lowerBound)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNiSi<typename vctBinaryOperations<value_type>::Minimum>::
            Run(*this, nArray, lowerBound);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & ClippedBelowOf(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & nArray,
                                     const value_type upperBound)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNiSi< typename vctBinaryOperations<value_type>::Maximum >::
            Run(*this, nArray, upperBound);
        return *this;
    }



    template <class __nArrayOwnerType>
    inline ThisType & SumOf(const value_type scalar,
                            const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & nArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoSiNi< typename vctBinaryOperations<value_type>::Addition >::
            Run(*this, scalar, nArray);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & DifferenceOf(const value_type scalar,
                                   const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & nArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoSiNi< typename vctBinaryOperations<value_type>::Subtraction >::
            Run(*this, scalar, nArray);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & ProductOf(const value_type scalar,
                                const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & nArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoSiNi< typename vctBinaryOperations<value_type>::Multiplication >::
            Run(*this, scalar, nArray);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & RatioOf(const value_type scalar,
                              const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & nArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoSiNi< typename vctBinaryOperations<value_type>::Division >::
            Run(*this, scalar, nArray);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & ClippedAboveOf(const value_type upperBound,
                                     const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & nArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoSiNi< typename vctBinaryOperations<value_type>::Minimum >::
            Run(*this, upperBound, nArray);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & ClippedBelowOf(const value_type lowerBound,
                                     const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & nArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoSiNi< typename vctBinaryOperations<value_type>::Maximum >::
            Run(*this, lowerBound, nArray);
        return *this;
    }


    inline ThisType & Add(const value_type scalar)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NioSi< typename vctStoreBackBinaryOperations<value_type>::Addition >::
            Run(*this, scalar);
        return *this;
    }

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

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

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

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

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

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

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

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

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


    template <class __nArrayOwnerType>
    inline ThisType & AddProductOf(const value_type scalar,
                                   const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NioSiNi<typename vctStoreBackBinaryOperations<value_type>::Addition,
            typename vctBinaryOperations<value_type>::Multiplication >::
            Run(*this, scalar, otherNArray);

        return *this;
    }


    template <class __nArrayOwnerType1, class __nArrayOwnerType2>
    inline ThisType & AddElementwiseProductOf(const vctDynamicConstNArrayBase<__nArrayOwnerType1, value_type, DIMENSION> & nArray1,
                                              const vctDynamicConstNArrayBase<__nArrayOwnerType2, value_type, DIMENSION> & nArray2)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NioNiNi<typename vctStoreBackBinaryOperations<value_type>::Addition,
            typename vctBinaryOperations<value_type>::Multiplication >::
            Run(*this, nArray1, nArray2);

        return *this;
    }


    template <class __nArrayOwnerType>
    inline ThisType & AbsOf(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNi<typename vctUnaryOperations<value_type>::AbsValue>::
            Run(*this, otherNArray);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & NegationOf(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNi<typename vctUnaryOperations<value_type>::Negation>::
            Run(*this, otherNArray);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & FloorOf(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNi<typename vctUnaryOperations<value_type>::Floor>::
            Run(*this, otherNArray);
        return *this;
    }

    /* documented above */
    template <class __nArrayOwnerType>
    inline ThisType & CeilOf(const vctDynamicConstNArrayBase<__nArrayOwnerType, value_type, DIMENSION> & otherNArray)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            NoNi<typename vctUnaryOperations<value_type>::Ceil>::
            Run(*this, otherNArray);
        return *this;
    }


    inline ThisType & AbsSelf(void)
    {
        vctDynamicNArrayLoopEngines<DIMENSION>::template
            Nio<typename vctStoreBackUnaryOperations<value_type>::MakeAbs>::
            Run(*this);
        return *this;
    }

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

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

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


#endif // _vctDynamicNArrayBase_h