vctDynamicMatrixBase.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 _vctDynamicMatrixBase_h
#define _vctDynamicMatrixBase_h

#include <cstdarg>
#include <cisstVector/vctDynamicConstMatrixBase.h>
#include <cisstVector/vctStoreBackUnaryOperations.h>
#include <cisstVector/vctStoreBackBinaryOperations.h>

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

    typedef vctDynamicMatrixBase ThisType;
    typedef vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> BaseType;

    typedef _matrixOwnerType OwnerType;

    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::ConstRowRefType ConstRowRefType;
    typedef typename BaseType::RowRefType RowRefType;

    typedef typename BaseType::ConstColumnRefType ConstColumnRefType;
    typedef typename BaseType::ColumnRefType ColumnRefType;

    typedef typename BaseType::ConstDiagonalRefType ConstDiagonalRefType;
    typedef typename BaseType::DiagonalRefType DiagonalRefType;

    typedef typename BaseType::ConstRefTransposeType ConstRefTransposeType;
    typedef typename BaseType::RefTransposeType RefTransposeType;

    typedef typename BaseType::ConstVectorPointerType ConstVectorPointerType;
    typedef typename BaseType::VectorPointerType VectorPointerType;


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

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

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

    reverse_iterator rend(void) {
        return this->Matrix.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();
    }

    RowRefType operator[](size_type index) {
        return RowRefType(this->cols(), Pointer(index, 0), this->col_stride());
    }

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


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


    pointer Pointer(size_type rowIndex, size_type colIndex) {
        return this->Matrix.Pointer(rowIndex, colIndex);
    }

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

    /* documented in base class */
    const_pointer Pointer(size_type rowIndex, size_type colIndex) const {
        return BaseType::Pointer(rowIndex, colIndex);
    }

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


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


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


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

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


    reference operator () (size_type rowIndex, size_type colIndex) throw(std::out_of_range) {
        return this->at(rowIndex, colIndex);
    }

    /* documented in base class */
    const_reference operator () (size_type rowIndex, size_type colIndex) const throw(std::out_of_range) {
        return BaseType::operator()(rowIndex, colIndex);
    }


    reference Element(size_type rowIndex, size_type colIndex) {
        return *(Pointer(rowIndex, colIndex));
    }

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


    RowRefType Row(size_type index) throw(std::out_of_range) {
        this->ThrowUnlessValidRowIndex(index);
        return RowRefType(this->cols(), Pointer(index, 0), this->col_stride());
    }

    ColumnRefType Column(size_type index) throw(std::out_of_range) {
        this->ThrowUnlessValidColIndex(index);
        return ColumnRefType(this->rows(), Pointer(0, index), this->row_stride());
    }

    DiagonalRefType Diagonal(void) {
        return DiagonalRefType( std::min(this->rows(), this->cols()), Pointer(0, 0), this->row_stride() + this->col_stride() );
    }

    VectorPointerType & RowPointers(VectorPointerType & rowPointers) throw(std::runtime_error) {
        if (! this->col_stride() == 1) {
            cmnThrow(std::runtime_error("vctDynamicMatrix: RowPointers requires compact rows"));
        }
        const size_type rows = this->rows();
        // resize the vector
        rowPointers.SetSize(rows);
        index_type index;
        for (index = 0; index < rows; ++index) {
            rowPointers[index] = this->Row(index).Pointer();
        }
        return rowPointers;
    }


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

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

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

    /* documented in base class */
    ConstVectorPointerType RowPointers(ConstVectorPointerType & rowPointers) const throw(std::runtime_error) {
        return BaseType::RowPointers(rowPointers);
    }


    vctDynamicMatrixRef<_elementType>
    Ref(const size_type rows, const size_type cols,
        const size_type startRow = 0, const size_type startCol = 0) throw (std::out_of_range) {
        if (((startRow + rows) > this->rows())
            || ((startCol + cols) > this->cols())) {
            cmnThrow(std::out_of_range("vctDynamicMatrixBase::Ref: reference is out of range"));
        }
        return vctDynamicMatrixRef<_elementType>(rows, cols,
                                                 this->row_stride(), this->col_stride(),
                                                 Pointer(startRow, startCol));
    }

    vctDynamicConstMatrixRef<_elementType>
    Ref(const size_type rows, const size_type cols,
        const size_type startRow = 0, const size_type startCol = 0) const throw (std::out_of_range) {
        return BaseType::Ref(rows, cols, startRow, startCol);
    }


    void ExchangeRows(const size_type row1Index, const size_type row2Index) {
        RowRefType row1( Row(row1Index) );
        RowRefType row2( Row(row2Index) );
        row1.SwapElementsWith(row2);
    }

    void ExchangeColumns(const size_type col1Index, const size_type col2Index) {
        ColumnRefType col1( Column(col1Index) );
        ColumnRefType col2( Column(col2Index) );
        col1.SwapElementsWith(col2);
    }


    template <class __inputMatrixOwnerType, class __indexVectorOwnerType>
    void SelectRowsFrom(const vctDynamicConstMatrixBase<__inputMatrixOwnerType, _elementType> & inputMatrix,
                        const vctDynamicConstVectorBase<__indexVectorOwnerType, index_type> & rowIndexVector)
    {
        vctDynamicMatrixLoopEngines::SelectRowsByIndex::
            Run(*this, inputMatrix, rowIndexVector);
    }

    template <class __inputMatrixOwnerType, class __indexVectorOwnerType>
    void SelectColsFrom(const vctDynamicConstMatrixBase<__inputMatrixOwnerType, _elementType> & inputMatrix,
                        const vctDynamicConstVectorBase<__indexVectorOwnerType, index_type> & colIndexVector)
    {
        this->TransposeRef().SelectRowsFrom(inputMatrix.TransposeRef(), colIndexVector);
    }

    template <class __matrixOwnerType>
    void RowPermutationOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & inputMatrix,
                          const index_type permutedRowIndexes[])
    {
        const size_type numRows = this->rows();
        size_type thisRowIndex;
        for (thisRowIndex = 0; thisRowIndex < numRows; ++thisRowIndex) {
            Row(thisRowIndex).Assign( inputMatrix.Row(permutedRowIndexes[thisRowIndex]) );
        }
    }

    template <class __matrixOwnerType>
    void RowInversePermutationOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & inputMatrix,
                                 const index_type permutedRowIndexes[])
    {
        const size_type numRows = this->rows();
        size_type thisRowIndex;
        for (thisRowIndex = 0; thisRowIndex < numRows; ++thisRowIndex) {
            Row(permutedRowIndexes[thisRowIndex]).Assign( inputMatrix.Row(thisRowIndex) );
        }
    }

    template <class __matrixOwnerType>
    void ColumnPermutationOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & inputMatrix,
                             const index_type permutedColumnIndexes[])
    {
        const size_type numCols = this->cols();
        size_type thisColumnIndex;
        for (thisColumnIndex = 0; thisColumnIndex < numCols; ++thisColumnIndex) {
            Column(thisColumnIndex).Assign( inputMatrix.Column(permutedColumnIndexes[thisColumnIndex]) );
        }
    }

    template <class __matrixOwnerType>
    void ColumnInversePermutationOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & inputMatrix,
                                    const index_type permutedColumnIndexes[])
    {
        const size_type numCols = this->cols();
        size_type thisColumnIndex;
        for (thisColumnIndex = 0; thisColumnIndex < numCols; ++thisColumnIndex) {
            Column(permutedColumnIndexes[thisColumnIndex]).Assign( inputMatrix.Column(thisColumnIndex) );
        }
    }

    inline value_type SetAll(const value_type value) {
        vctDynamicMatrixLoopEngines::
            MioSi<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 if (this->col_stride() == 1) {
            /* memset row by row */
            const size_type sizeOfRow = this->cols() * sizeof(value_type);
            const stride_type rowStride = this->row_stride();
            pointer currentPointer = this->Pointer();
            const pointer endPointer = currentPointer + this->rows() * rowStride;
            for (;
                 currentPointer != endPointer;
                 currentPointer += rowStride) {
                memset(currentPointer, 0, sizeOfRow);
            }
            return true;
        } else if (this->row_stride() == 1) {
            /* memset col by col */
            const size_type sizeOfCol = this->rows() * sizeof(value_type);
            const stride_type colStride = this->col_stride();
            pointer currentPointer = this->Pointer();
            const pointer endPointer = currentPointer + this->cols() * colStride;
            for (;
                 currentPointer != endPointer;
                 currentPointer += colStride) {
                memset(currentPointer, 0, sizeOfCol);
            }
            return true;
        } else {
            this->SetAll(static_cast<value_type>(0));
            return false;
        }
    }


    template <class __matrixOwnerType>
    inline ThisType & Assign(const vctDynamicConstMatrixBase<__matrixOwnerType, value_type> & other) {
        if (this->FastCopyCompatible(other)) {
            this->FastCopyOf(other, false);
        } else {
            vctDynamicMatrixLoopEngines::
                MoMi<typename vctUnaryOperations<value_type,
                typename __matrixOwnerType::value_type>::Identity>::
                Run(*this, other);
        }
        return *this;
    }


    template <class __matrixOwnerType, typename __elementType>
    inline ThisType & Assign(const vctDynamicConstMatrixBase<__matrixOwnerType, __elementType> & other) {
        vctDynamicMatrixLoopEngines::
            MoMi<typename vctUnaryOperations<value_type,
            typename __matrixOwnerType::value_type>::Identity>::
            Run(*this, other);
        return *this;
    }

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

    template <size_type __rows, size_type __cols,
              stride_type __rowStride, stride_type __colStride,
              class __elementType, class __dataPtrType>
    inline ThisType & Assign(const vctFixedSizeConstMatrixBase<__rows, __cols, __rowStride, __colStride, __elementType, __dataPtrType>
                             & other) {
        vctDynamicMatrixLoopEngines::
            MoMi<typename vctUnaryOperations<value_type, __elementType>::Identity>::
            Run(*this, vctDynamicConstMatrixRef<__elementType>(other));
        return *this;
    }


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

    template <size_type __rows, size_type __cols,
              stride_type __rowStride, stride_type __colStride,
              class __elementType, class __dataPtrType>
    inline ThisType & ForceAssign(const vctFixedSizeConstMatrixBase<__rows, __cols,
                                                                    __rowStride, __colStride,
                                                                    __elementType, __dataPtrType>  & other) {
        return this->Assign(other);
    }


    template <class __matrixOwnerType>
    inline bool FastCopyOf(const vctDynamicConstMatrixBase<__matrixOwnerType, value_type> & source,
                           bool performSafetyChecks = vctFastCopy::PerformChecks)
        throw(std::runtime_error)
    {
        return vctFastCopy::MatrixCopy(*this, source, performSafetyChecks);
    }

    template <size_type __rows, size_type __cols, stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline bool FastCopyOf(const vctFixedSizeConstMatrixBase<__rows, __cols, __rowStride, __colStride, value_type, __dataPtrType> & source,
                           bool performSafetyChecks = vctFastCopy::PerformChecks)
        throw(std::runtime_error)
    {
        return vctFastCopy::MatrixCopy(*this, source, performSafetyChecks);
    }


    inline ThisType & Assign(const value_type * elements, bool inputIsRowMajor = true)
    {
        // The row stride is the difference between two rows.  That is, in row-major
        // storage it is equal to the number of columns, and in column-major it is
        // equal to 1.
        const difference_type inputRowStride = (inputIsRowMajor) ? this->cols() : 1;
        const difference_type inputColStride = (inputIsRowMajor) ? 1 : this->rows();
        const vctDynamicConstMatrixRef<value_type> tmpRef( this->rows(), this->cols(),
            inputRowStride, inputColStride, elements );
        this->Assign(tmpRef);
        return *this;
    }


    inline ThisType & Assign(const value_type element0, ...)
    {
        iterator iter = begin();
        (*iter) = element0;
        ++iter;
        va_list nextArg;
        va_start(nextArg, element0);
        for (; iter != end(); ++iter) {
            (*iter) = static_cast<value_type>(va_arg(nextArg, typename cmnTypeTraits<value_type>::VaArgPromotion));
        }
        va_end(nextArg);
        return *this;
    }



    RefTransposeType TransposeRef(void)
    {
        return RefTransposeType(this->cols(), this->rows(), this->col_stride(), this->row_stride(), Pointer());
    }

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

    template <class __matrixOwnerType1, class __matrixOwnerType2>
    inline ThisType & SumOf(const vctDynamicConstMatrixBase<__matrixOwnerType1, _elementType> & matrix1,
                            const vctDynamicConstMatrixBase<__matrixOwnerType2, _elementType> & matrix2) {
        vctDynamicMatrixLoopEngines::
            MoMiMi< typename vctBinaryOperations<value_type>::Addition >
            ::Run(*this, matrix1, matrix2);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType1, class __matrixOwnerType2>
    inline ThisType & DifferenceOf(const vctDynamicConstMatrixBase<__matrixOwnerType1, _elementType> & matrix1,
                                   const vctDynamicConstMatrixBase<__matrixOwnerType2, _elementType> & matrix2) {
        vctDynamicMatrixLoopEngines::
            MoMiMi< typename vctBinaryOperations<value_type>::Subtraction >
            ::Run(*this, matrix1, matrix2);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType1, class __matrixOwnerType2>
    inline ThisType & ElementwiseProductOf(const vctDynamicConstMatrixBase<__matrixOwnerType1, _elementType> & matrix1,
                                           const vctDynamicConstMatrixBase<__matrixOwnerType2, _elementType> & matrix2) {
        vctDynamicMatrixLoopEngines::
            MoMiMi< typename vctBinaryOperations<value_type>::Multiplication >
            ::Run(*this, matrix1, matrix2);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType1, class __matrixOwnerType2>
    inline ThisType & ElementwiseRatioOf(const vctDynamicConstMatrixBase<__matrixOwnerType1, _elementType> & matrix1,
                                         const vctDynamicConstMatrixBase<__matrixOwnerType2, _elementType> & matrix2) {
        vctDynamicMatrixLoopEngines::
            MoMiMi< typename vctBinaryOperations<value_type>::Division >
            ::Run(*this, matrix1, matrix2);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType1, class __matrixOwnerType2>
    inline ThisType & ElementwiseMinOf(const vctDynamicConstMatrixBase<__matrixOwnerType1, _elementType> & matrix1,
                                       const vctDynamicConstMatrixBase<__matrixOwnerType2, _elementType> & matrix2) {
        vctDynamicMatrixLoopEngines::
            MoMiMi< typename vctBinaryOperations<value_type>::Minimum >
            ::Run(*this, matrix1, matrix2);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType1, class __matrixOwnerType2>
    inline ThisType & ElementwiseMaxOf(const vctDynamicConstMatrixBase<__matrixOwnerType1, _elementType> & matrix1,
                                       const vctDynamicConstMatrixBase<__matrixOwnerType2, _elementType> & matrix2) {
        vctDynamicMatrixLoopEngines::
            MoMiMi< typename vctBinaryOperations<value_type>::Maximum >
            ::Run(*this, matrix1, matrix2);
        return *this;
    }



    template <class __matrixOwnerType>
    inline ThisType & Add(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) {
        vctDynamicMatrixLoopEngines::
            MioMi<typename vctStoreBackBinaryOperations<value_type>::Addition >::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & Subtract(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) {
        vctDynamicMatrixLoopEngines::
            MioMi< typename vctStoreBackBinaryOperations<value_type>::Subtraction >::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & ElementwiseMultiply(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) {
        vctDynamicMatrixLoopEngines::
            MioMi< typename vctStoreBackBinaryOperations<value_type>::Multiplication >::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & ElementwiseDivide(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) {
        vctDynamicMatrixLoopEngines::
            MioMi< typename vctStoreBackBinaryOperations<value_type>::Division >::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & ElementwiseMin(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) {
        vctDynamicMatrixLoopEngines::
            MioMi< typename vctStoreBackBinaryOperations<value_type>::Minimum >::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & ElementwiseMax(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) {
        vctDynamicMatrixLoopEngines::
            MioMi< typename vctStoreBackBinaryOperations<value_type>::Maximum >::
            Run(*this, otherMatrix);
        return *this;
    }

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

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


    template <class __matrixOwnerType>
    inline ThisType & SumOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & matrix,
                            const value_type scalar) {
        vctDynamicMatrixLoopEngines::
            MoMiSi< typename vctBinaryOperations<value_type>::Addition >::
            Run(*this, matrix, scalar);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & DifferenceOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & matrix,
                                   const value_type scalar) {
        vctDynamicMatrixLoopEngines::
            MoMiSi< typename vctBinaryOperations<value_type>::Subtraction >::
            Run(*this, matrix, scalar);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & ProductOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & matrix,
                                const value_type scalar) {
        vctDynamicMatrixLoopEngines::
            MoMiSi< typename vctBinaryOperations<value_type>::Multiplication >::
            Run(*this, matrix, scalar);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & RatioOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & matrix,
                              const value_type scalar) {
        vctDynamicMatrixLoopEngines::
            MoMiSi< typename vctBinaryOperations<value_type>::Division >::
            Run(*this, matrix, scalar);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & ClippedAboveOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & matrix,
                                     const value_type lowerBound) {
        vctDynamicMatrixLoopEngines::
            MoMiSi<typename vctBinaryOperations<value_type>::Minimum>::
            Run(*this, matrix, lowerBound);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & ClippedBelowOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & matrix,
                                     const value_type upperBound) {
        vctDynamicMatrixLoopEngines::
            MoMiSi< typename vctBinaryOperations<value_type>::Maximum >::
            Run(*this, matrix, upperBound);
        return *this;
    }



    template <class __matrixOwnerType>
    inline ThisType & SumOf(const value_type scalar,
                            const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & matrix) {
        vctDynamicMatrixLoopEngines::
            MoSiMi< typename vctBinaryOperations<value_type>::Addition >::
            Run(*this, scalar, matrix);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & DifferenceOf(const value_type scalar,
                                   const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & matrix) {
        vctDynamicMatrixLoopEngines::
            MoSiMi< typename vctBinaryOperations<value_type>::Subtraction >::
            Run(*this, scalar, matrix);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & ProductOf(const value_type scalar,
                                const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & matrix) {
        vctDynamicMatrixLoopEngines::
            MoSiMi< typename vctBinaryOperations<value_type>::Multiplication >::
            Run(*this, scalar, matrix);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & RatioOf(const value_type scalar,
                              const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & matrix) {
        vctDynamicMatrixLoopEngines::
            MoSiMi< typename vctBinaryOperations<value_type>::Division >::
            Run(*this, scalar, matrix);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & ClippedAboveOf(const value_type upperBound,
                                     const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & matrix) {
        vctDynamicMatrixLoopEngines::
            MoSiMi< typename vctBinaryOperations<value_type>::Minimum >::
            Run(*this, upperBound, matrix);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & ClippedBelowOf(const value_type lowerBound,
                                     const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & matrix) {
        vctDynamicMatrixLoopEngines::
            MoSiMi< typename vctBinaryOperations<value_type>::Maximum >::
            Run(*this, lowerBound, matrix);
        return *this;
    }



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

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

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

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

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

    /* documented above */
    inline ThisType & ClipBelow(const value_type lowerBound) {
        vctDynamicMatrixLoopEngines::
            MioSi< 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 __matrixOwnerType>
    inline ThisType & AddProductOf(const value_type scalar,
                                   const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix)
    {
        vctDynamicMatrixLoopEngines::
            MioSiMi<
            typename vctStoreBackBinaryOperations<value_type>::Addition,
            typename vctBinaryOperations<value_type>::Multiplication >::
            Run(*this, scalar, otherMatrix);
        return *this;
    }


    template <class __matrixOwnerType1, class __matrixOwnerType2>
    inline ThisType & AddElementwiseProductOf(const vctDynamicConstMatrixBase<__matrixOwnerType1, _elementType> & matrix1,
                                              const vctDynamicConstMatrixBase<__matrixOwnerType2, _elementType> & matrix2)
    {
        vctDynamicMatrixLoopEngines::
            MioMiMi<
            typename vctStoreBackBinaryOperations<value_type>::Addition,
            typename vctBinaryOperations<value_type>::Multiplication >::
            Run(*this, matrix1, matrix2);
        return *this;
    }


    template <class __matrixOwnerType>
    inline ThisType & AbsOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) {
        vctDynamicMatrixLoopEngines::
            MoMi<typename vctUnaryOperations<value_type>::AbsValue>::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & NegationOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) {
        vctDynamicMatrixLoopEngines::
            MoMi<typename vctUnaryOperations<value_type>::Negation>::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & FloorOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) {
        vctDynamicMatrixLoopEngines::
            MoMi<typename vctUnaryOperations<value_type>::Floor>::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline ThisType & CeilOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) {
        vctDynamicMatrixLoopEngines::
            MoMi<typename vctUnaryOperations<value_type>::Ceil>::
            Run(*this, otherMatrix);
        return *this;
    }

    template <class __matrixOwnerType>
    inline ThisType & TransposeOf(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) {
        Assign(otherMatrix.TransposeRef());
        return *this;
    }


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

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

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

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


    template <class __matrixOwnerType1, class __matrixOwnerType2>
    void ProductOf(const vctDynamicConstMatrixBase<__matrixOwnerType1, _elementType> & matrix1,
                   const vctDynamicConstMatrixBase<__matrixOwnerType2, _elementType> & matrix2) {
        typedef vctDynamicConstMatrixBase<__matrixOwnerType1, _elementType> Input1MatrixType;
        typedef vctDynamicConstMatrixBase<__matrixOwnerType2, _elementType> Input2MatrixType;
        typedef typename Input1MatrixType::ConstRowRefType Input1RowRefType;
        typedef typename Input2MatrixType::ConstColumnRefType Input2ColumnRefType;
        vctDynamicMatrixLoopEngines::
            Product<typename vctBinaryOperations<value_type, Input1RowRefType, Input2ColumnRefType>::DotProduct>::
            Run((*this), matrix1, matrix2);
    }


    template <class __vectorOwnerType1, class __vectorOwnerType2>
    void OuterProductOf(const vctDynamicConstVectorBase<__vectorOwnerType1, _elementType> & colVector,
                        const vctDynamicConstVectorBase<__vectorOwnerType2, _elementType> & rowVector)
    {
        vctDynamicConstMatrixRef<_elementType> colMatrix, rowMatrix;
        colMatrix.SetRef(colVector.size(), 1, colVector.stride(), 1, colVector.Pointer(0));
        rowMatrix.SetRef(1, rowVector.size(), 1, rowVector.stride(), rowVector.Pointer(0));
        this->ProductOf(colMatrix, rowMatrix);
    }



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

};


#endif // _vctDynamicMatrixBase_h