vctFixedSizeMatrixBase.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: 2003-11-04

  (C) Copyright 2003-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 _vctFixedSizeMatrixBase_h
#define _vctFixedSizeMatrixBase_h

#include <cisstCommon/cmnPortability.h>
#include <cisstCommon/cmnTypeTraits.h>
#include <cisstVector/vctFixedSizeConstMatrixBase.h>

#include <cstdarg>


// forward declaration of Assign method from dynamic matrix to fixed size
template <vct::size_type _rows, vct::size_type _cols,
          vct::stride_type _rowStride, vct::stride_type _colStride,
          class _elementType, class _dataPtrType, class _matrixOwnerType>
inline void vctFixedSizeMatrixBaseAssignDynamicConstMatrixBase(
    vctFixedSizeMatrixBase<_rows, _cols, _rowStride, _colStride, _elementType, _dataPtrType> & fixedSizeMatrix,
    const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & dynamicMatrix);



template <vct::size_type _rows, vct::size_type _cols,
          vct::stride_type _rowStride, vct::stride_type _colStride,
          class _elementType, class _dataPtrType>
class vctFixedSizeMatrixBase : public vctFixedSizeConstMatrixBase
<_rows, _cols, _rowStride, _colStride, _elementType, _dataPtrType>
{
 public:
    /* Declare the container-defined typed required by STL, plus the
       types completed by our traits class */

    /* define most types from vctContainerTraits */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);

    /* documented in base class */
    typedef vctFixedSizeMatrixBase<_rows, _cols,
        _rowStride, _colStride, _elementType, _dataPtrType> ThisType;

    typedef vctFixedSizeConstMatrixBase<_rows, _cols, _rowStride, _colStride,
                                        _elementType, _dataPtrType> BaseType;

    typedef vctFixedSizeMatrixTraits<_elementType, _rows, _cols,
                                     _rowStride, _colStride> MatrixTraits;

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

    typedef typename BaseType::RowRefType RowRefType;
    typedef typename BaseType::ColumnRefType ColumnRefType;
    typedef typename BaseType::ConstRowRefType ConstRowRefType;
    typedef typename BaseType::ConstColumnRefType ConstColumnRefType;
    typedef typename BaseType::DiagonalRefType DiagonalRefType;
    typedef typename BaseType::ConstDiagonalRefType ConstDiagonalRefType;
    typedef typename BaseType::RefTransposeType RefTransposeType;
    typedef typename BaseType::ConstRefTransposeType ConstRefTransposeType;
    typedef typename BaseType::RowValueType RowValueType;
    typedef typename BaseType::ColumnValueType ColumnValueType;

    enum {ROWS = MatrixTraits::ROWS, COLS = MatrixTraits::COLS,
          LENGTH = MatrixTraits::LENGTH};
    enum {ROWSTRIDE = MatrixTraits::ROWSTRIDE,
          COLSTRIDE = MatrixTraits::COLSTRIDE};

 public:
    inline iterator begin() {
        return iterator(this->Data, 0);
    }

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

    inline iterator end() {
        return iterator(this->Data) + LENGTH;
    }

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

    reverse_iterator rbegin() {
        return reverse_iterator(Pointer(ROWS - 1, COLS - 1), 0);
    }

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

    reverse_iterator rend() {
        return reverse_iterator(this->Data - ROWSTRIDE +
                                COLSTRIDE * (COLS - 1), 0);
    }

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


    RowRefType operator[](size_type index) {
        return RowRefType(this->Data + ROWSTRIDE * index);
    }

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


    pointer Pointer(size_type rowIndex, size_type colIndex) {
        return this->Data + ROWSTRIDE * rowIndex + COLSTRIDE * colIndex;
    }

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

    /* 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);
    }

#ifndef SWIG

    reference operator()(size_type rowIndex, size_type colIndex) throw(std::out_of_range) {
        return 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);
    }
#endif


    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) {
        return RowRefType(this->Data + ROWSTRIDE * index);
    }

    ColumnRefType Column(size_type index) {
        return ColumnRefType(this->Data + COLSTRIDE * index);
    }

    DiagonalRefType Diagonal(void) {
        return DiagonalRefType(this->Data);
    }

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

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

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

    template <vct::size_type __subRows, vct::size_type __subCols>
    vctFixedSizeMatrixRef<_elementType, __subRows, __subCols, _rowStride, _colStride>
    Ref(const size_type startRow = 0, const size_type startCol = 0) throw (std::out_of_range) {
        vctFixedSizeMatrixRef<_elementType, __subRows, __subCols, _rowStride, _colStride>
            result(*this, startRow, startCol);
        return result;
    }

    template <vct::size_type __subRows, vct::size_type __subCols>
    vctFixedSizeConstMatrixRef<_elementType, __subRows, __subCols, _rowStride, _colStride>
    Ref(const size_type startRow = 0, const size_type startCol = 0) const throw (std::out_of_range) {
        return BaseType::Ref(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 <size_type __rows, stride_type __rowStride, stride_type __colStride, class __dataPtrType,
              stride_type __indexStride, class __indexDataPtrType>
    void SelectRowsFrom(const vctFixedSizeConstMatrixBase<__rows, _cols, __rowStride, __colStride, _elementType, __dataPtrType> & inputMatrix,
                        const vctFixedSizeConstVectorBase<_rows, __indexStride, index_type, __indexDataPtrType> & rowIndexVector)
    {
        vctFixedSizeMatrixLoopEngines::SelectRowsByIndex::
            Run(*this, inputMatrix, rowIndexVector);
    }

    template <size_type __cols, stride_type __rowStride, stride_type __colStride, class __dataPtrType,
              stride_type __indexStride, class __indexDataPtrType>
    void SelectColsFrom(const vctFixedSizeConstMatrixBase<_rows, __cols, __rowStride, __colStride, _elementType, __dataPtrType> & inputMatrix,
                        const vctFixedSizeConstVectorBase<_cols, __indexStride, index_type, __indexDataPtrType> & colIndexVector)
    {
        this->TransposeRef().SelectRowsFrom(inputMatrix.TransposeRef(), colIndexVector);
    }

    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    void RowPermutationOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                          _elementType, __dataPtrType> & inputMatrix, const index_type permutedRowIndexes[])
    {
        index_type thisRowIndex;
        for (thisRowIndex = 0; thisRowIndex < ROWS; ++thisRowIndex) {
            Row(thisRowIndex).Assign( inputMatrix.Row(permutedRowIndexes[thisRowIndex]) );
        }
    }

    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    void RowInversePermutationOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                                 _elementType, __dataPtrType> & inputMatrix, const index_type permutedRowIndexes[])
    {
        index_type thisRowIndex;
        for (thisRowIndex = 0; thisRowIndex < ROWS; ++thisRowIndex) {
            Row(permutedRowIndexes[thisRowIndex]).Assign( inputMatrix.Row(thisRowIndex) );
        }
    }

    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    void ColumnPermutationOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                             _elementType, __dataPtrType> & inputMatrix, const index_type permutedColumnIndexes[])
    {
        index_type thisColumnIndex;
        for (thisColumnIndex = 0; thisColumnIndex < COLS; ++thisColumnIndex) {
            Column(thisColumnIndex).Assign( inputMatrix.Column(permutedColumnIndexes[thisColumnIndex]) );
        }
    }

    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    void ColumnInversePermutationOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                                    _elementType, __dataPtrType> & inputMatrix, const index_type permutedColumnIndexes[])
    {
        index_type thisColumnIndex;
        for (thisColumnIndex = 0; thisColumnIndex < COLS; ++thisColumnIndex) {
            Column(permutedColumnIndexes[thisColumnIndex]).Assign( inputMatrix.Column(thisColumnIndex) );
        }
    }


    inline value_type SetAll(const value_type value) {
        vctFixedSizeMatrixLoopEngines::
            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 <stride_type __rowStride, stride_type __colStride, class __elementType, class __dataPtrType>
    inline ThisType & Assign(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, __elementType, __dataPtrType> & other) {
        vctFixedSizeMatrixLoopEngines::
            MoMi<typename vctUnaryOperations<value_type, __elementType>::Identity>::
            Run(*this, other);
        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;
    }


    inline ThisType & Assign(const value_type * elements, bool inputIsRowMajor = true)
    {
        if (inputIsRowMajor)
        {
            // row-major input means that the row-stride is equal to the number of elements
            // in a row, i.e, COLS, and the column-stride is 1.
            const vctFixedSizeConstMatrixRef<value_type, ROWS, COLS, COLS, 1> tmpRef(elements);
            this->Assign(tmpRef);
        }
        else
        {
            // column-major input means that the column-stride is equal to the number of
            // elements in a column, i.e., ROWS, and the row-stride is 1.
            const vctFixedSizeConstMatrixRef<value_type, ROWS, COLS, 1, ROWS> tmpRef(elements);
            this->Assign(tmpRef);
        }
        return *this;
    }


    template <class __matrixOwnerType>
    inline ThisType & Assign(const vctDynamicConstMatrixBase<__matrixOwnerType, value_type> & other) {
        vctFixedSizeMatrixBaseAssignDynamicConstMatrixBase(*this, other);
        return *this;
    }


    template <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 ThisType & ForceAssign(const vctDynamicConstMatrixBase<__matrixOwnerType, value_type> & 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 <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);
    }



    RefTransposeType TransposeRef(void);

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


    template <stride_type __input1RowStride, stride_type __input1ColStride, class __input1DataPtrType,
              stride_type __input2RowStride, stride_type __input2ColStride, class __input2DataPtrType>
    inline ThisType & SumOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __input1RowStride, __input1ColStride,
                            value_type, __input1DataPtrType> & input1Matrix,
                            const vctFixedSizeConstMatrixBase<_rows, _cols, __input2RowStride, __input2ColStride,
                            value_type, __input2DataPtrType> & input2Matrix) {
        vctFixedSizeMatrixLoopEngines::MoMiMi<typename vctBinaryOperations<value_type>::Addition>
            ::Run(*this, input1Matrix, input2Matrix);
        return *this;
    }

    /* documented above */
    template <stride_type __input1RowStride, stride_type __input1ColStride, class __input1DataPtrType,
              stride_type __input2RowStride, stride_type __input2ColStride, class __input2DataPtrType>
    inline ThisType & DifferenceOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __input1RowStride, __input1ColStride,
                                   value_type, __input1DataPtrType> & input1Matrix,
                                   const vctFixedSizeConstMatrixBase<_rows, _cols, __input2RowStride, __input2ColStride,
                                   value_type, __input2DataPtrType> & input2Matrix) {
        vctFixedSizeMatrixLoopEngines::MoMiMi<typename vctBinaryOperations<value_type>::Subtraction>
            ::Run(*this, input1Matrix, input2Matrix);
        return *this;
    }

    /* documented above */
    template <stride_type __input1RowStride, stride_type __input1ColStride, class __input1DataPtrType,
              stride_type __input2RowStride, stride_type __input2ColStride, class __input2DataPtrType>
    inline ThisType & ElementwiseProductOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __input1RowStride, __input1ColStride,
                                           value_type, __input1DataPtrType> & input1Matrix,
                                           const vctFixedSizeConstMatrixBase<_rows, _cols, __input2RowStride, __input2ColStride,
                                           value_type, __input2DataPtrType> & input2Matrix) {
        vctFixedSizeMatrixLoopEngines::MoMiMi<typename vctBinaryOperations<value_type>::Multiplication>
            ::Run(*this, input1Matrix, input2Matrix);
        return *this;
    }

    /* documented above */
    template <stride_type __input1RowStride, stride_type __input1ColStride, class __input1DataPtrType,
              stride_type __input2RowStride, stride_type __input2ColStride, class __input2DataPtrType>
    inline ThisType & ElementwiseRatioOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __input1RowStride, __input1ColStride,
                                         value_type, __input1DataPtrType> & input1Matrix,
                                         const vctFixedSizeConstMatrixBase<_rows, _cols, __input2RowStride, __input2ColStride,
                                         value_type, __input2DataPtrType> & input2Matrix) {
        vctFixedSizeMatrixLoopEngines::MoMiMi<typename vctBinaryOperations<value_type>::Division>
            ::Run(*this, input1Matrix, input2Matrix);
        return *this;
    }

    /* documented above */
    template <stride_type __input1RowStride, stride_type __input1ColStride, class __input1DataPtrType,
              stride_type __input2RowStride, stride_type __input2ColStride, class __input2DataPtrType>
    inline ThisType & ElementwiseMinOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __input1RowStride, __input1ColStride,
                                       value_type, __input1DataPtrType> & input1Matrix,
                                       const vctFixedSizeConstMatrixBase<_rows, _cols, __input2RowStride, __input2ColStride,
                                       value_type, __input2DataPtrType> & input2Matrix) {
        vctFixedSizeMatrixLoopEngines::MoMiMi<typename vctBinaryOperations<value_type>::Minimum>
            ::Run(*this, input1Matrix, input2Matrix);
        return *this;
    }

    /* documented above */
    template <stride_type __input1RowStride, stride_type __input1ColStride, class __input1DataPtrType,
              stride_type __input2RowStride, stride_type __input2ColStride, class __input2DataPtrType>
    inline ThisType & ElementwiseMaxOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __input1RowStride, __input1ColStride,
                                       value_type, __input1DataPtrType> & input1Matrix,
                                       const vctFixedSizeConstMatrixBase<_rows, _cols, __input2RowStride, __input2ColStride,
                                       value_type, __input2DataPtrType> & input2Matrix) {
        vctFixedSizeMatrixLoopEngines::MoMiMi<typename vctBinaryOperations<value_type>::Maximum>
            ::Run(*this, input1Matrix, input2Matrix);
        return *this;
    }



    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & Add(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & otherMatrix) {
        vctFixedSizeMatrixLoopEngines::
            MioMi<typename vctStoreBackBinaryOperations<value_type>::Addition>::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & Subtract(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & otherMatrix) {
        vctFixedSizeMatrixLoopEngines::
            MioMi<typename vctStoreBackBinaryOperations<value_type>::Subtraction>::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & ElementwiseMultiply(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & otherMatrix) {
        vctFixedSizeMatrixLoopEngines::
            MioMi<typename vctStoreBackBinaryOperations<value_type>::Multiplication>::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & ElementwiseDivide(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & otherMatrix) {
        vctFixedSizeMatrixLoopEngines::
            MioMi<typename vctStoreBackBinaryOperations<value_type>::Division>::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & ElementwiseMin(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & otherMatrix) {
        vctFixedSizeMatrixLoopEngines::
            MioMi<typename vctStoreBackBinaryOperations<value_type>::Minimum>::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & ElementwiseMax(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & otherMatrix) {
        vctFixedSizeMatrixLoopEngines::
            MioMi<typename vctStoreBackBinaryOperations<value_type>::Maximum>::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & operator += (const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & otherMatrix) {
        return this->Add(otherMatrix);
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & operator -= (const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & otherMatrix) {
        return this->Subtract(otherMatrix);
    }



    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & SumOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & matrix,
                            const value_type scalar) {
        vctFixedSizeMatrixLoopEngines::
            MoMiSi<typename vctBinaryOperations<value_type>::Addition>::
            Run(*this, matrix, scalar);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & DifferenceOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & matrix,
                                   const value_type scalar) {
        vctFixedSizeMatrixLoopEngines::
            MoMiSi<typename vctBinaryOperations<value_type>::Subtraction>::
            Run(*this, matrix, scalar);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & ProductOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & matrix,
                                const value_type scalar) {
        vctFixedSizeMatrixLoopEngines::
            MoMiSi<typename vctBinaryOperations<value_type>::Multiplication>::
            Run(*this, matrix, scalar);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & RatioOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & matrix,
                              const value_type scalar) {
        vctFixedSizeMatrixLoopEngines::
            MoMiSi<typename vctBinaryOperations<value_type>::Division>::
            Run(*this, matrix, scalar);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & ClippedAboveOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & matrix,
                                     const value_type upperBound) {
        vctFixedSizeMatrixLoopEngines::
            MoMiSi<typename vctBinaryOperations<value_type>::Minimum>::
            Run(*this, matrix, upperBound);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & ClippedBelowOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & matrix,
                                     const value_type lowerBound) {
        vctFixedSizeMatrixLoopEngines::
            MoMiSi<typename vctBinaryOperations<value_type>::Maximum>::
            Run(*this, matrix, lowerBound);
        return *this;
    }



    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & SumOf(const value_type scalar,
                            const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & matrix) {
        vctFixedSizeMatrixLoopEngines::
            MoSiMi<typename vctBinaryOperations<value_type>::Addition>::
            Run(*this, scalar, matrix);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & DifferenceOf(const value_type scalar,
                                   const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & matrix) {
        vctFixedSizeMatrixLoopEngines::
            MoSiMi<typename vctBinaryOperations<value_type>::Subtraction>::
            Run(*this, scalar, matrix);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & ProductOf(const value_type scalar,
                                const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & matrix) {
        vctFixedSizeMatrixLoopEngines::
            MoSiMi<typename vctBinaryOperations<value_type>::Multiplication>::
            Run(*this, scalar, matrix);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & RatioOf(const value_type scalar,
                              const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & matrix) {
        vctFixedSizeMatrixLoopEngines::
            MoSiMi<typename vctBinaryOperations<value_type>::Division>::
            Run(*this, scalar, matrix);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & ClippedAboveOf(const value_type upperBound,
                                     const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & matrix) {
        vctFixedSizeMatrixLoopEngines::
            MoSiMi<typename vctBinaryOperations<value_type>::Minimum>::
            Run(*this, upperBound, matrix);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & ClippedBelowOf(const value_type lowerBound,
                                     const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & matrix) {
        vctFixedSizeMatrixLoopEngines::
            MoSiMi<typename vctBinaryOperations<value_type>::Maximum>::
            Run(*this, lowerBound, matrix);
        return *this;
    }

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

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

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

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

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

    /* documented above */
    inline ThisType & ClipBelow(const value_type lowerBound) {
        vctFixedSizeMatrixLoopEngines::
            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 <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & AddProductOf(const value_type scalar,
                                   const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & otherMatrix)
    {
        vctFixedSizeMatrixLoopEngines::
            MioSiMi<
            typename vctStoreBackBinaryOperations<value_type>::Addition,
            typename vctBinaryOperations<value_type>::Multiplication >::
            Run(*this, scalar,  otherMatrix);
        return *this;
    }


    template <stride_type __rowStride1, stride_type __colStride1, class __dataPtrType1,
              stride_type __rowStride2, stride_type __colStride2, class __dataPtrType2>
    inline ThisType & AddElementwiseProductOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride1, __colStride1, value_type, __dataPtrType1> & matrix1,
                                              const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride2, __colStride2, value_type, __dataPtrType2> & matrix2)
    {
        vctFixedSizeMatrixLoopEngines::
            MioMiMi<
            typename vctStoreBackBinaryOperations<value_type>::Addition,
            typename vctBinaryOperations<value_type>::Multiplication >::
            Run(*this, matrix1,  matrix2);
        return *this;
    }


    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & AbsOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & otherMatrix) {
        vctFixedSizeMatrixLoopEngines::
            MoMi<typename vctUnaryOperations<value_type>::AbsValue>::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & NegationOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & otherMatrix) {
        vctFixedSizeMatrixLoopEngines::
            MoMi<typename vctUnaryOperations<value_type>::Negation>::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & FloorOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & otherMatrix) {
        vctFixedSizeMatrixLoopEngines::
            MoMi<typename vctUnaryOperations<value_type>::Floor>::
            Run(*this, otherMatrix);
        return *this;
    }

    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & CeilOf(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, value_type, __dataPtrType> & otherMatrix) {
        vctFixedSizeMatrixLoopEngines::
            MoMi<typename vctUnaryOperations<value_type>::Ceil>::
            Run(*this, otherMatrix);
        return *this;
    }



    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline ThisType & TransposeOf(const vctFixedSizeConstMatrixBase<_cols, _rows, __rowStride, __colStride, value_type, __dataPtrType> & otherMatrix) {
        Assign(otherMatrix.TransposeRef());
        return *this;
    }



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

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

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

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


    template <size_type __input1Cols, stride_type __input1RowStride, stride_type __input1ColStride, class __input1DataPtrType,
              stride_type __input2RowStride, stride_type __input2ColStride, class __input2DataPtrType>
        void ProductOf(const vctFixedSizeConstMatrixBase<_rows, __input1Cols, __input1RowStride, __input1ColStride,
                       _elementType, __input1DataPtrType> & input1Matrix,
                       const vctFixedSizeConstMatrixBase<__input1Cols, _cols, __input2RowStride, __input2ColStride,
                       _elementType, __input2DataPtrType> & input2Matrix) {
        typedef vctFixedSizeConstMatrixBase<_rows, __input1Cols, __input1RowStride, __input1ColStride,
            _elementType, __input1DataPtrType> Input1MatrixType;
        typedef vctFixedSizeConstMatrixBase<__input1Cols, _cols, __input2RowStride, __input2ColStride,
            _elementType, __input2DataPtrType> Input2MatrixType;
        typedef typename Input1MatrixType::ConstRowRefType Input1RowRefType;
        typedef typename Input2MatrixType::ConstColumnRefType Input2ColumnRefType;
        vctFixedSizeMatrixLoopEngines::
            Product<typename vctBinaryOperations<value_type, Input1RowRefType, Input2ColumnRefType>::DotProduct>::
            Run((*this), input1Matrix, input2Matrix);
    }

    template <stride_type __stride1, class __dataPtrType1, stride_type __stride2, class __dataPtrType2>
        void OuterProductOf(const vctFixedSizeConstVectorBase<_rows, __stride1, _elementType, __dataPtrType1> & columnVector,
        const vctFixedSizeConstVectorBase<_cols, __stride2, _elementType, __dataPtrType2> & rowVector)
    {
        typedef vctFixedSizeConstVectorBase<_rows, __stride1, _elementType, __dataPtrType1> InputColumnType;
        typedef vctFixedSizeConstVectorBase<_cols, __stride2, _elementType, __dataPtrType2> InputRowType;
        typedef typename InputColumnType::ColConstMatrixRefType ColMatrixType;
        typedef typename InputRowType::RowConstMatrixRefType RowMatrixType;
        const ColMatrixType colMatrix = columnVector.AsColMatrix();
        const RowMatrixType rowMatrix = rowVector.AsRowMatrix();
        this->ProductOf(colMatrix, rowMatrix);
    }


    template <size_type _subRows, size_type _subCols>
    class Submatrix
    {
    public:
        typedef vctFixedSizeMatrixRef<value_type, _subRows, _subCols, ROWSTRIDE, COLSTRIDE>
            Type;
    };

    bool FromStreamRaw(std::istream & inputStream, const char delimiter = ' ')
    {
        const size_type myRows = this->rows();
        const size_type myCols = this->cols();
        size_type indexRow, indexCol;
        char c;
        bool valid = true;
        ThisType temp;
        for (indexRow = 0; (indexRow < myRows) && valid; ++indexRow) {
            for (indexCol = 0; (indexCol < myCols) && valid; ++indexCol) {
                inputStream >> temp.Element(indexRow, indexCol);
                if (inputStream.fail()) {
                    valid = false;
                    inputStream.clear();
                }
                // Look for the delimiter
                if (valid && !isspace(delimiter) && (indexCol < myCols-1)) {
                    inputStream >> c;
                    if (c != delimiter)
                        valid = false;
                }
            } // end for cols
            // Look for the delimiter
            if (valid && !isspace(delimiter) && (indexRow < myRows-1)) {
                inputStream >> c;
                if (c != delimiter)
                    valid = false;
            }
        } // end for rows
        if (valid) {
            // Only update the object if the parsing was successful for all elements.
            Assign(temp);
        }
        return valid;
    }

    void DeSerializeRaw(std::istream & inputStream)
    {
        const size_type myRows = this->rows();
        const size_type myCols = this->cols();
        size_type indexRow, indexCol;

        for (indexRow = 0; indexRow < myRows; ++indexRow) {
            for (indexCol = 0; indexCol < myCols; ++indexCol) {
                cmnDeSerializeRaw(inputStream, this->Element(indexRow, indexCol));
            }
        }
    }

};


#endif // _vctFixedSizeMatrixBase_h