vctDynamicConstMatrixBase.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 _vctDynamicConstMatrixBase_h
#define _vctDynamicConstMatrixBase_h

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

#include <cisstVector/vctContainerTraits.h>
#include <cisstVector/vctFixedSizeVector.h>
#include <cisstVector/vctDynamicVectorRef.h>
#include <cisstVector/vctDynamicConstVectorRef.h>
#include <cisstVector/vctDynamicVector.h>
#include <cisstVector/vctDynamicMatrixLoopEngines.h>

#include <iostream>
#include <iomanip>


/* Forward declarations */
#ifndef DOXYGEN
template <class _matrixOwnerType, class __matrixOwnerType, class _elementType,
          class _elementOperationType>
inline vctReturnDynamicMatrix<bool>
vctDynamicMatrixElementwiseCompareMatrix(const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & matrix1,
                                         const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & matrix2);

template <class _matrixOwnerType, class _elementType,
          class _elementOperationType>
inline vctReturnDynamicMatrix<bool>
vctDynamicMatrixElementwiseCompareScalar(const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & matrix,
                                         const _elementType & scalar);
#endif // DOXYGEN


template <class _matrixOwnerType, typename _elementType>
class vctDynamicConstMatrixBase
{
public:
    /* define most types from vctContainerTraits */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    enum {DIMENSION = 2};
    VCT_NARRAY_TRAITS_TYPEDEFS(DIMENSION);

    typedef vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> ThisType;

    typedef _matrixOwnerType OwnerType;

    typedef typename OwnerType::iterator iterator;

    typedef typename OwnerType::const_iterator const_iterator;

    typedef typename OwnerType::reverse_iterator reverse_iterator;

    typedef typename OwnerType::const_reverse_iterator const_reverse_iterator;

    typedef vctDynamicConstVectorRef<_elementType> ConstRowRefType;

    typedef vctDynamicVectorRef<_elementType> RowRefType;

    typedef vctDynamicConstVectorRef<_elementType> ConstColumnRefType;

    typedef vctDynamicVectorRef<_elementType> ColumnRefType;

    typedef vctDynamicConstVectorRef<_elementType> ConstDiagonalRefType;

    typedef vctDynamicVectorRef<_elementType> DiagonalRefType;

    typedef vctDynamicConstMatrixRef<_elementType> ConstRefTransposeType;

    typedef vctDynamicMatrixRef<_elementType> RefTransposeType;

    typedef vctDynamicMatrix<_elementType> TransposeValueType;

    typedef vctDynamicMatrix<_elementType> MatrixValueType;

    typedef vctReturnDynamicMatrix<_elementType> MatrixReturnType;

    typedef cmnTypeTraits<value_type> TypeTraits;

    typedef typename TypeTraits::BoolType BoolType;

    typedef vctReturnDynamicMatrix<BoolType> BoolMatrixReturnType;

    typedef vctDynamicVector<const_pointer> ConstVectorPointerType;

    typedef vctDynamicVector<pointer> VectorPointerType;


protected:
    OwnerType Matrix;


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


    inline void ThrowUnlessValidIndex(size_type rowIndex, size_type colIndex) const throw(std::out_of_range) {
        if (! ValidIndex(rowIndex, colIndex)) {
            cmnThrow(std::out_of_range("vctDynamicMatrix: Invalid indices"));
        }
    }


    inline void ThrowUnlessValidRowIndex(size_type index) const throw(std::out_of_range) {
        if (! ValidRowIndex(index)) {
            cmnThrow(std::out_of_range("vctDynamicMatrix: Invalid row index"));
        }
    }

    inline void ThrowUnlessValidColIndex(size_type index) const throw(std::out_of_range) {
        if (! ValidColIndex(index)) {
            cmnThrow(std::out_of_range("vctDynamicMatrix: Invalid column index"));
        }
    }

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

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

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

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

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

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

    size_type rows() const {
        return Matrix.rows();
    }

    size_type cols() const {
        return Matrix.cols();
    }

    size_type height() const {
        return Matrix.rows();
    }

    size_type width() const {
        return Matrix.cols();
    }

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

    difference_type row_stride() const {
        return Matrix.row_stride();
    }

    difference_type col_stride() const {
        return Matrix.col_stride();
    }

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

    ConstRowRefType operator[](size_type index) const {
        return ConstRowRefType(cols(), Pointer(index, 0), col_stride());
    }

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


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


    const_pointer Pointer(index_type rowIndex, index_type colIndex) const {
        return Matrix.Pointer(rowIndex, colIndex);
    }

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


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

    inline bool ValidIndex(size_type rowIndex, size_type colIndex) const {
        return ((rowIndex < rows())
                && (colIndex < cols()));
    }

    inline bool ValidRowIndex(size_type rowIndex) const {
        return (rowIndex < rows());
    }

    inline bool ValidColIndex(size_type colIndex) const {
        return (colIndex < cols());
    }


    const_reference at(size_type rowIndex, size_type colIndex) const throw(std::out_of_range) {
        ThrowUnlessValidIndex(rowIndex, colIndex);
        return *(Pointer(rowIndex, colIndex));
    }

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


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


    ConstRowRefType Row(size_type index) const throw(std::out_of_range) {
        ThrowUnlessValidRowIndex(index);
        return ConstRowRefType(cols(), Pointer(index, 0), col_stride());
    }

    ConstColumnRefType Column(size_type index) const throw(std::out_of_range) {
        ThrowUnlessValidColIndex(index);
        return ConstColumnRefType(rows(), Pointer(0, index), row_stride());
    }

    ConstDiagonalRefType Diagonal() const {
        return ConstDiagonalRefType( std::min(rows(), cols()), Pointer(0, 0), row_stride() + col_stride() );
    }

    ConstVectorPointerType & RowPointers(ConstVectorPointerType & rowPointers) const 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;
    }

    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) {
        if (((startRow + rows) > this->rows())
            || ((startCol + cols) > this->cols())) {
            cmnThrow(std::out_of_range("vctDynamicConstMatrixBase::Ref: reference is out of range"));
        }
        return vctDynamicConstMatrixRef<_elementType>(rows, cols,
                                                      this->row_stride(), this->col_stride(),
                                                      Pointer(startRow, startCol));
    }


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

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

    inline value_type Trace(void) const {
        return this->Diagonal().SumOfElements();
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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



    inline bool IsColMajor(void) const {
        return Matrix.IsColMajor();
    }

    inline bool IsRowMajor(void) const {
        return Matrix.IsRowMajor();
    }

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

    inline bool IsFortran(void) const {
        return (IsColMajor() && (row_stride() == 1) && (col_stride() == static_cast<stride_type>(rows())));
    }

    inline bool StorageOrder(void) const {
        return Matrix.StorageOrder();
    }

    inline bool IsSquare(void) const {
        return (this->rows() == this->cols());
    }

    inline bool IsSquare(size_type size) const {
        return ((this->rows() == size)
                && (this->cols() == size));
    }


    template <class __matrixOwnerType>
    inline bool FastCopyCompatible(const vctDynamicConstMatrixBase<__matrixOwnerType, value_type> & source) const
    {
        return vctFastCopy::MatrixCopyCompatible(*this, source);
    }

    template <size_type __rows, size_type __cols, stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline bool FastCopyCompatible(const vctFixedSizeConstMatrixBase<__rows, __cols, __rowStride, __colStride, value_type, __dataPtrType> & source) const
    {
        return vctFastCopy::MatrixCopyCompatible(*this, source);
    }


    template <class __matrixOwnerType>
    inline bool Equal(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) const {
        return vctDynamicMatrixLoopEngines::
            SoMiMi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Equal>::
            Run(*this, otherMatrix);
    }

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

    /* documented above */
    template <class __matrixOwnerType>
    inline bool AlmostEqual(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix,
                            value_type tolerance) const {
        return ((*this - otherMatrix).LinfNorm() <= tolerance);
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline bool AlmostEqual(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) const {
        return ((*this - otherMatrix).LinfNorm() <= TypeTraits::Tolerance());
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline bool NotEqual(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) const {
        return vctDynamicMatrixLoopEngines::
            SoMiMi<typename vctBinaryOperations<bool>::Or,
            typename vctBinaryOperations<bool, value_type, value_type>::NotEqual>::
            Run(*this, otherMatrix);
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline bool operator != (const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) const {
        return NotEqual(otherMatrix);
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline bool Lesser(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) const {
        return vctDynamicMatrixLoopEngines::
            SoMiMi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Lesser>::
            Run(*this, otherMatrix);
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline bool LesserOrEqual(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) const {
        return vctDynamicMatrixLoopEngines::
            SoMiMi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::LesserOrEqual>::
            Run(*this, otherMatrix);
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline bool Greater(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) const {
        return vctDynamicMatrixLoopEngines::
            SoMiMi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Greater>::
            Run(*this, otherMatrix);
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline bool GreaterOrEqual(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) const {
        return vctDynamicMatrixLoopEngines::
            SoMiMi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::GreaterOrEqual>::
            Run(*this, otherMatrix);
    }

    template <class __matrixOwnerType>
    inline BoolMatrixReturnType
    ElementwiseEqual(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) const {
        return vctDynamicMatrixElementwiseCompareMatrix<_matrixOwnerType, __matrixOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::Equal>(*this, otherMatrix);
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline BoolMatrixReturnType
    ElementwiseNotEqual(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) const {
        return vctDynamicMatrixElementwiseCompareMatrix<_matrixOwnerType, __matrixOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::NotEqual>(*this, otherMatrix);
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline BoolMatrixReturnType
    ElementwiseLesser(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) const {
        return vctDynamicMatrixElementwiseCompareMatrix<_matrixOwnerType, __matrixOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::Lesser>(*this, otherMatrix);
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline BoolMatrixReturnType
    ElementwiseLesserOrEqual(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) const {
        return vctDynamicMatrixElementwiseCompareMatrix<_matrixOwnerType, __matrixOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::LesserOrEqual>(*this, otherMatrix);
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline BoolMatrixReturnType
    ElementwiseGreater(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) const {
        return vctDynamicMatrixElementwiseCompareMatrix<_matrixOwnerType, __matrixOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::Greater>(*this, otherMatrix);
    }

    /* documented above */
    template <class __matrixOwnerType>
    inline BoolMatrixReturnType
    ElementwiseGreaterOrEqual(const vctDynamicConstMatrixBase<__matrixOwnerType, _elementType> & otherMatrix) const {
        return vctDynamicMatrixElementwiseCompareMatrix<_matrixOwnerType, __matrixOwnerType, value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::GreaterOrEqual>(*this, otherMatrix);
    }



    inline bool Equal(const value_type & scalar) const {
        return vctDynamicMatrixLoopEngines::
            SoMiSi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Equal>::
            Run(*this, scalar);
    }

    /* documented above */
    inline bool operator == (const value_type & scalar) const {
        return Equal(scalar);
    }

    /* documented above */
    inline bool NotEqual(const value_type & scalar) const {
        return vctDynamicMatrixLoopEngines::
            SoMiSi<typename vctBinaryOperations<bool>::Or,
            typename vctBinaryOperations<bool, value_type, value_type>::NotEqual>::
            Run(*this, scalar);
    }

    /* documented above */
    inline bool operator != (const value_type & scalar) const {
        return NotEqual(scalar);
    }

    /* documented above */
    inline bool Lesser(const value_type & scalar) const {
        return vctDynamicMatrixLoopEngines::
            SoMiSi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Lesser>::
            Run(*this, scalar);
    }

    /* documented above */
    inline bool LesserOrEqual(const value_type & scalar) const {
        return vctDynamicMatrixLoopEngines::
            SoMiSi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::LesserOrEqual>::
            Run(*this, scalar);
    }

    /* documented above */
    inline bool Greater(const value_type & scalar) const {
        return vctDynamicMatrixLoopEngines::
            SoMiSi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Greater>::
            Run(*this, scalar);
    }

    /* documented above */
    inline bool GreaterOrEqual(const value_type & scalar) const {
        return vctDynamicMatrixLoopEngines::
            SoMiSi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::GreaterOrEqual>::
            Run(*this, scalar);
    }

    BoolMatrixReturnType ElementwiseEqual(const value_type & scalar) const;

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

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

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

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

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


    inline MatrixReturnType Abs(void) const;

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

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

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

    ConstRefTransposeType TransposeRef(void) const
    {
        return ConstRefTransposeType(cols(), rows(), col_stride(), row_stride(), Pointer());
    }

    inline MatrixReturnType Transpose() const
    {
        vctDynamicMatrix<value_type> result( this->TransposeRef() );
        return vctReturnDynamicMatrix<value_type>(result);
    }


    static MatrixReturnType Eye(size_type size);

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

    void ToStream(std::ostream & outputStream) const {
        const size_type myRows = rows();
        const size_type myCols = cols();
        // preserve the formatting flags as they were
        const std::streamsize width = outputStream.width(12);
        const std::streamsize precision = outputStream.precision(6);
        bool showpoint = ((outputStream.flags() & std::ios_base::showpoint) != 0);
        outputStream << std::setprecision(6) << std::showpoint;
        size_type indexRow, indexCol;
        for (indexRow = 0; indexRow < myRows; ++indexRow) {
            for (indexCol = 0; indexCol < myCols; ++indexCol) {
                outputStream << std::setw(12) << this->Element(indexRow, indexCol);
                if (indexCol < (myCols-1)) {
                    outputStream << " ";
                }
            }
            // end of line between rows, not at the end
            if (indexRow != (myRows - 1)) {
                outputStream << std::endl;
            }
        }
        // resume the formatting flags
        outputStream << std::setprecision(precision) << std::setw(width);
        if (!showpoint) {
            outputStream << std::noshowpoint;
        }
    }


    void ToStreamRaw(std::ostream & outputStream, const char delimiter = ' ',
                     bool headerOnly = false, const std::string & headerPrefix = "") const
    {
        const size_type myRows = rows();
        const size_type myCols = cols();
        size_type indexRow, indexCol;

        if (headerOnly) {
            for (indexRow = 0; indexRow < myRows; ++indexRow) {
                for (indexCol = 0; indexCol < myCols; ++indexCol) {
                    outputStream << headerPrefix << "-m" << indexRow << "_" << indexCol;
                    // delimiter between elements
                    if (indexCol < (myCols - 1)) {
                        outputStream << delimiter;
                    }
                }
                // delimiter between rows, not at the end
                if (indexRow < (myRows - 1)) {
                    outputStream << delimiter;
                }
            }
        } else {
            for (indexRow = 0; indexRow < myRows; ++indexRow) {
                for (indexCol = 0; indexCol < myCols; ++indexCol) {
                    outputStream << this->Element(indexRow, indexCol);
                    // delimiter between elements
                    if (indexCol < (myCols - 1)) {
                        outputStream << delimiter;
                    }
                }
                // delimiter between rows, not at the end
                if (indexRow < (myRows - 1)) {
                    outputStream << delimiter;
                }
            }
        }
    }

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

    void SerializeRaw(std::ostream & outputStream) const
    {
        const size_type myRows = rows();
        const size_type myCols = cols();
        size_type indexRow, indexCol;

        cmnSerializeSizeRaw(outputStream, myRows);
        cmnSerializeSizeRaw(outputStream, myCols);
        for (indexRow = 0; indexRow < myRows; ++indexRow) {
            for (indexCol = 0; indexCol < myCols; ++indexCol) {
                cmnSerializeRaw(outputStream, this->Element(indexRow, indexCol));
            }
        }
    }

};

#ifndef DOXYGEN
/* documented in class.  Implementation moved here for .Net 2003 */
template <class _matrixOwnerType, class _elementType>
inline typename vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::BoolMatrixReturnType
vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::ElementwiseEqual(const _elementType & scalar) const {
    return vctDynamicMatrixElementwiseCompareScalar<_matrixOwnerType, _elementType,
        typename vctBinaryOperations<bool, _elementType, _elementType>::Equal>(*this, scalar);
}

/* documented in class.  Implementation moved here for .Net 2003 */
template <class _matrixOwnerType, class _elementType>
inline typename vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::BoolMatrixReturnType
vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::ElementwiseNotEqual(const _elementType & scalar) const {
    return vctDynamicMatrixElementwiseCompareScalar<_matrixOwnerType, _elementType,
        typename vctBinaryOperations<bool, _elementType, _elementType>::NotEqual>(*this, scalar);
}

/* documented in class.  Implementation moved here for .Net 2003 */
template <class _matrixOwnerType, class _elementType>
inline typename vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::BoolMatrixReturnType
vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::ElementwiseLesser(const _elementType & scalar) const {
    return vctDynamicMatrixElementwiseCompareScalar<_matrixOwnerType, _elementType,
        typename vctBinaryOperations<bool, _elementType, _elementType>::Lesser>(*this, scalar);
}

/* documented in class.  Implementation moved here for .Net 2003 */
template <class _matrixOwnerType, class _elementType>
inline typename vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::BoolMatrixReturnType
vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::ElementwiseLesserOrEqual(const _elementType & scalar) const {
    return vctDynamicMatrixElementwiseCompareScalar<_matrixOwnerType, _elementType,
        typename vctBinaryOperations<bool, _elementType, _elementType>::LesserOrEqual>(*this, scalar);
}

/* documented in class.  Implementation moved here for .Net 2003 */
template <class _matrixOwnerType, class _elementType>
inline typename vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::BoolMatrixReturnType
vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::ElementwiseGreater(const _elementType & scalar) const {
    return vctDynamicMatrixElementwiseCompareScalar<_matrixOwnerType, _elementType,
        typename vctBinaryOperations<bool, _elementType, _elementType>::Greater>(*this, scalar);
}

/* documented in class.  Implementation moved here for .Net 2003 */
template <class _matrixOwnerType, class _elementType>
inline typename vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::BoolMatrixReturnType
vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::ElementwiseGreaterOrEqual(const _elementType & scalar) const {
    return vctDynamicMatrixElementwiseCompareScalar<_matrixOwnerType, _elementType,
        typename vctBinaryOperations<bool, _elementType, _elementType>::GreaterOrEqual>(*this, scalar);
}
#endif // DOXYGEN

template <class _matrixOwnerType, typename _elementType>
inline bool vctAll(const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & matrix) {
    return matrix.All();
}

template <class _matrixOwnerType, typename _elementType>
inline bool vctAny(const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & matrix) {
    return matrix.Any();
}

template <class _matrixOwnerType, typename _elementType>
std::ostream & operator << (std::ostream & output,
                            const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & matrix) {
    matrix.ToStream(output);
    return output;
}


// helper function declared and used in vctFixedSizeMatrixBase.h
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)
{
    vctDynamicMatrixRef<_elementType> tempRef(fixedSizeMatrix);
    tempRef.Assign(dynamicMatrix);
}


#endif // _vctDynamicConstMatrixBase_h