vctFixedSizeConstMatrixBase.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-2018 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 _vctFixedSizeConstMatrixBase_h
#define _vctFixedSizeConstMatrixBase_h

 
#include <cisstCommon/cmnSerializer.h>
 
#include <cisstVector/vctFixedSizeVectorRef.h>
#include <cisstVector/vctFixedSizeVector.h>
#include <cisstVector/vctFixedSizeMatrixTraits.h>
#include <cisstVector/vctFixedSizeMatrixLoopEngines.h>
#include <cisstVector/vctFastCopy.h>
 
#include <stdio.h>
 
/* Forward declarations */
#ifndef DOXYGEN
template <vct::size_type _rows, vct::size_type _cols,
          vct::stride_type _rowStride, vct::stride_type _colStride, class _dataPtrType,
          vct::stride_type __rowStride, vct::stride_type __colStride, class __dataPtrType,
          class _elementType,
          class _elementOperationType>
inline vctFixedSizeMatrix<bool, _rows, _cols>
vctFixedSizeMatrixElementwiseCompareMatrix(const vctFixedSizeConstMatrixBase<_rows, _cols, _rowStride, _colStride,
                                           _elementType, _dataPtrType> & matrix1,
                                           const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                                           _elementType, __dataPtrType> & matrix2);
 
template <vct::size_type _rows, vct::size_type _cols,
          vct::stride_type _rowStride, vct::stride_type _colStride, class _dataPtrType,
          class _elementType,
          class _elementOperationType>
inline vctFixedSizeMatrix<bool, _rows, _cols>
vctFixedSizeMatrixElementwiseCompareScalar(const vctFixedSizeConstMatrixBase<_rows, _cols, _rowStride, _colStride,
                                           _elementType, _dataPtrType> & matrix,
                                           const _elementType & scalar);
#endif // DOXYGEN

template<vct::size_type _rows, vct::size_type _cols,
         vct::stride_type _rowStride, vct::stride_type _colStride,
         class _elementType, class _dataPtrType>
class vctFixedSizeConstMatrixBase
{
 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);
    enum {DIMENSION = 2};
    VCT_NARRAY_TRAITS_TYPEDEFS(DIMENSION);

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

    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;

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

    enum {DIAGONAL_LENGTH = (ROWS <= COLS) ? ROWS : COLS,
          DIAGONAL_STRIDE = ROWSTRIDE + COLSTRIDE};

    typedef vctFixedSizeConstVectorRef<_elementType, COLS, COLSTRIDE>
        ConstRowRefType;
    typedef vctFixedSizeVectorRef<_elementType, COLS, COLSTRIDE>
        RowRefType;
    typedef vctFixedSizeConstVectorRef<_elementType, ROWS, ROWSTRIDE>
        ConstColumnRefType;
    typedef vctFixedSizeVectorRef<_elementType, ROWS, ROWSTRIDE>
    ColumnRefType;
    typedef vctFixedSizeConstVectorRef<_elementType, DIAGONAL_LENGTH, DIAGONAL_STRIDE>
    ConstDiagonalRefType;
    typedef  vctFixedSizeVectorRef<_elementType, DIAGONAL_LENGTH, DIAGONAL_STRIDE>
        DiagonalRefType;

    typedef vctFixedSizeVector<_elementType, COLS> RowValueType;
    typedef vctFixedSizeVector<_elementType, ROWS> ColumnValueType;

    typedef vctFixedSizeConstMatrixRef<_elementType, _rows, _cols, _rowStride, _colStride> ConstRefType;

    typedef vctFixedSizeMatrixRef<_elementType, _rows, _cols, _rowStride, _colStride> RefType;
 

    typedef vctFixedSizeConstMatrixRef<_elementType, _cols, _rows,
                                       _colStride, _rowStride> ConstRefTransposeType;

    typedef vctFixedSizeMatrixRef<_elementType, _cols, _rows,
                                  _colStride, _rowStride> RefTransposeType;

    typedef vctFixedSizeMatrix<_elementType, COLS, ROWS,
                               COLSTRIDE <= ROWSTRIDE> TransposeValueType;

    typedef vctFixedSizeMatrix<_elementType, ROWS, COLS,
                               COLSTRIDE <= ROWSTRIDE> MatrixValueType;

    typedef vctFixedSizeMatrix<bool, ROWS, COLS,
                               COLSTRIDE <= ROWSTRIDE> BoolMatrixValueType;
 
    typedef _dataPtrType DataType;
 
 protected:
    DataType Data;
 

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

    inline void ThrowUnlessValidIndex(size_type rowIndex, size_type colIndex) const CISST_THROW(std::out_of_range) {
        if (! ValidIndex(rowIndex, colIndex)) {
            cmnThrow(std::out_of_range("vctFixedSizeMatrix: Invalid indices"));
        }
    }
 
 
 public:
    const_iterator begin() const {
        return const_iterator(Data, 0);
    }
 

    const_iterator end() const {
        return const_iterator(Data) + LENGTH;
    }
 

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

    const_reverse_iterator rend() const {
        return const_reverse_iterator(Data - ROWSTRIDE +
                                      COLSTRIDE * (COLS - 1), 0);
    }

    size_type size() const {
        return LENGTH;
    }

    const nsize_type & sizes(void) const {
        static nsize_type staticSizes(ROWS, COLS);
        return staticSizes;
    }

    size_type rows() const {
      return ROWS;
    }

    size_type cols() const {
      return COLS;
    }
 

    size_type max_size() const {
        return LENGTH;
    }
 

    const nstride_type & strides(void) const {
        static nstride_type staticStrides(ROWSTRIDE, COLSTRIDE);
        return staticStrides;
    }

    difference_type row_stride() const {
        return ROWSTRIDE;
    }

    difference_type col_stride() const {
        return COLSTRIDE;
    }

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

    ConstRowRefType operator[](size_type index) const {
        return ConstRowRefType(Data + ROWSTRIDE * index);
    }
 

    const_pointer Pointer(size_type rowIndex, size_type colIndex) const {
        return Data + ROWSTRIDE * rowIndex + COLSTRIDE * colIndex;
    }

    const_pointer Pointer(void) const {
        return Data;
    }

    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 index) const CISST_THROW(std::out_of_range) {
        ThrowUnlessValidIndex(index);
        return (begin())[index];
    }
 

    const_reference at(size_type rowIndex, size_type colIndex) const CISST_THROW(std::out_of_range) {
        ThrowUnlessValidIndex(rowIndex, colIndex);
        return *(Pointer(rowIndex, colIndex));
    }
 
#ifndef SWIG
    const_reference operator()(size_type rowIndex, size_type colIndex) const CISST_THROW(std::out_of_range) {
        return at(rowIndex, colIndex);
    }
#endif
 

    const_reference Element(size_type rowIndex, size_type colIndex) const {
        return *(Pointer(rowIndex, colIndex));
    }
 
 
    ConstRowRefType Row(size_type index) const {
        return ConstRowRefType(Data + ROWSTRIDE * index);
    }
 
    ConstColumnRefType Column(size_type index) const {
        return ConstColumnRefType(Data + COLSTRIDE * index);
    }
 
    ConstDiagonalRefType Diagonal(void) const
    {
        return ConstDiagonalRefType(Data);
    }

    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 CISST_THROW(std::out_of_range) {
        vctFixedSizeConstMatrixRef<_elementType, __subRows, __subCols, _rowStride, _colStride>
            result(*this, startRow, startCol);
        return result;
    }


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

    inline value_type ProductOfElements() const {
        return vctFixedSizeMatrixLoopEngines::
            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 vctFixedSizeMatrixLoopEngines::
            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 vctFixedSizeMatrixLoopEngines::
            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 vctFixedSizeMatrixLoopEngines::
            SoMi<typename vctBinaryOperations<value_type>::Maximum,
            typename vctUnaryOperations<value_type>::Identity>::
            Run(*this);
    }

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

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

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

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

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

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

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

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

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

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

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

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

 


    inline bool IsColMajor(void) const {
        return (row_stride() <= col_stride());
    }

    inline bool IsRowMajor(void) const {
        return (col_stride() <= row_stride());
    }

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

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

    inline bool StorageOrder(void) const {
        return this->IsRowMajor();
    }

    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 <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 FastCopyCompatible(const vctDynamicConstMatrixBase<__matrixOwnerType, value_type> & source) const
    {
        return vctFastCopy::MatrixCopyCompatible(*this, source);
    }

 


    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline bool Equal(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                      value_type, __dataPtrType> & otherMatrix) const {
        return vctFixedSizeMatrixLoopEngines::
            SoMiMi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Equal>::
            Run(*this, otherMatrix);
    }
 
    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline bool operator == (const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                             value_type, __dataPtrType> & otherMatrix) const {
        return Equal(otherMatrix);
    }
 
    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline bool AlmostEqual(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                            value_type, __dataPtrType> & otherMatrix,
                            value_type tolerance) const {
        return ((*this - otherMatrix).LinfNorm() <= tolerance);
    }
 
    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline bool AlmostEqual(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                            value_type, __dataPtrType> & otherMatrix) const {
        return ((*this - otherMatrix).LinfNorm() <= cmnTypeTraits<_elementType>::Tolerance());
    }
 
    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline bool NotEqual(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                         value_type, __dataPtrType> & otherMatrix) const {
        return vctFixedSizeMatrixLoopEngines::
            SoMiMi<typename vctBinaryOperations<bool>::Or,
            typename vctBinaryOperations<bool, value_type, value_type>::NotEqual>::
            Run(*this, otherMatrix);
    }
 
    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline bool operator != (const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                             value_type, __dataPtrType> & otherMatrix) const {
        return NotEqual(otherMatrix);
    }
 
    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline bool Lesser(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                       value_type, __dataPtrType> & otherMatrix) const {
        return vctFixedSizeMatrixLoopEngines::
            SoMiMi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Lesser>::
            Run(*this, otherMatrix);
    }
 
    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline bool LesserOrEqual(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                              value_type, __dataPtrType> & otherMatrix) const {
        return vctFixedSizeMatrixLoopEngines::
            SoMiMi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::LesserOrEqual>::
            Run(*this, otherMatrix);
    }
 
    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline bool Greater(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                        value_type, __dataPtrType> & otherMatrix) const {
        return vctFixedSizeMatrixLoopEngines::
            SoMiMi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::Greater>::
            Run(*this, otherMatrix);
    }
 
    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline bool GreaterOrEqual(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                               value_type, __dataPtrType> & otherMatrix) const {
        return vctFixedSizeMatrixLoopEngines::
            SoMiMi<typename vctBinaryOperations<bool>::And,
            typename vctBinaryOperations<bool, value_type, value_type>::GreaterOrEqual>::
            Run(*this, otherMatrix);
    }



    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline BoolMatrixValueType
    ElementwiseEqual(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                     value_type, __dataPtrType> & otherMatrix) const {
        return vctFixedSizeMatrixElementwiseCompareMatrix<
            _rows, _cols,
            _rowStride, _colStride, _dataPtrType,
            __rowStride, __colStride, __dataPtrType,
            value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::Equal>(*this, otherMatrix);
    }
 
    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline BoolMatrixValueType
    ElementwiseNotEqual(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                        value_type, __dataPtrType> & otherMatrix) const {
        return vctFixedSizeMatrixElementwiseCompareMatrix<
            _rows, _cols,
            _rowStride, _colStride, _dataPtrType,
            __rowStride, __colStride, __dataPtrType,
            value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::NotEqual>(*this, otherMatrix);
    }
 
    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline BoolMatrixValueType
    ElementwiseLesser(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                      value_type, __dataPtrType> & otherMatrix) const {
        return vctFixedSizeMatrixElementwiseCompareMatrix<
            _rows, _cols,
            _rowStride, _colStride, _dataPtrType,
            __rowStride, __colStride, __dataPtrType,
            value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::Lesser>(*this, otherMatrix);
    }
 
    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline BoolMatrixValueType
    ElementwiseLesserOrEqual(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                             value_type, __dataPtrType> & otherMatrix) const {
        return vctFixedSizeMatrixElementwiseCompareMatrix<
            _rows, _cols,
            _rowStride, _colStride, _dataPtrType,
            __rowStride, __colStride, __dataPtrType,
            value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::LesserOrEqual>(*this, otherMatrix);
    }
 
    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline BoolMatrixValueType
    ElementwiseGreater(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                       value_type, __dataPtrType> & otherMatrix) const {
        return vctFixedSizeMatrixElementwiseCompareMatrix<
            _rows, _cols,
            _rowStride, _colStride, _dataPtrType,
            __rowStride, __colStride, __dataPtrType,
            value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::Greater>(*this, otherMatrix);
    }
 
    /* documented above */
    template <stride_type __rowStride, stride_type __colStride, class __dataPtrType>
    inline BoolMatrixValueType
    ElementwiseGreaterOrEqual(const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride,
                              value_type, __dataPtrType> & otherMatrix) const {
        return vctFixedSizeMatrixElementwiseCompareMatrix<
            _rows, _cols,
            _rowStride, _colStride, _dataPtrType,
            __rowStride, __colStride, __dataPtrType,
            value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::GreaterOrEqual>(*this, otherMatrix);
    }



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

 


    inline BoolMatrixValueType ElementwiseEqual(const value_type & scalar) const {
        return vctFixedSizeMatrixElementwiseCompareScalar<
            _rows, _cols,
            _rowStride, _colStride, _dataPtrType,
            value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::Equal>(*this, scalar);
    }
 
    /* documented above */
    inline BoolMatrixValueType ElementwiseNotEqual(const value_type & scalar) const {
        return vctFixedSizeMatrixElementwiseCompareScalar<
            _rows, _cols,
            _rowStride, _colStride, _dataPtrType,
            value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::NotEqual>(*this, scalar);
    }
 
    /* documented above */
    inline BoolMatrixValueType ElementwiseLesser(const value_type & scalar) const {
        return vctFixedSizeMatrixElementwiseCompareScalar<
            _rows, _cols,
            _rowStride, _colStride, _dataPtrType,
            value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::Lesser>(*this, scalar);
    }
 
    /* documented above */
    inline BoolMatrixValueType ElementwiseLesserOrEqual(const value_type & scalar) const {
        return vctFixedSizeMatrixElementwiseCompareScalar<
            _rows, _cols,
            _rowStride, _colStride, _dataPtrType,
            value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::LesserOrEqual>(*this, scalar);
    }
 
    /* documented above */
    inline BoolMatrixValueType ElementwiseGreater(const value_type & scalar) const {
        return vctFixedSizeMatrixElementwiseCompareScalar<
            _rows, _cols,
            _rowStride, _colStride, _dataPtrType,
            value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::Greater>(*this, scalar);
    }
 
    /* documented above */
    inline BoolMatrixValueType ElementwiseGreaterOrEqual(const value_type & scalar) const {
        return vctFixedSizeMatrixElementwiseCompareScalar<
            _rows, _cols,
            _rowStride, _colStride, _dataPtrType,
            value_type,
            typename vctBinaryOperations<bool, value_type, value_type>::GreaterOrEqual>(*this, scalar);
    }



    inline MatrixValueType Abs(void) const;
 
    /* documented above */
    inline MatrixValueType Negation(void) const;
 
    /* documented above */
    inline MatrixValueType Floor(void) const;
 
    /* documented above */
    inline MatrixValueType Ceil(void) const;
 

    ConstRefTransposeType TransposeRef(void) const;

    TransposeValueType Transpose() const
    {
        return TransposeValueType(TransposeRef());
    }

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

    static const MatrixValueType & Eye(void);

    std::string ToString(void) const {
        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;
                }
            }
        }
    }

    void SerializeRaw(std::ostream & outputStream) const
    {
        const size_type myRows = rows();
        const size_type myCols = cols();
        size_type indexRow, indexCol;
 
        for (indexRow = 0; indexRow < myRows; ++indexRow) {
            for (indexCol = 0; indexCol < myCols; ++indexCol) {
                cmnSerializeRaw(outputStream, this->Element(indexRow, indexCol));
            }
        }
    }
 
};
 
 

template <vct::size_type _rows, vct::size_type _cols,
          vct::stride_type _rowStride, vct::stride_type _colStride,
          class _elementType, class _dataPtrType>
inline bool vctAll(const vctFixedSizeConstMatrixBase<_rows, _cols, _rowStride, _colStride, _elementType, _dataPtrType> & matrix) {
    return matrix.All();
}

template <vct::size_type _rows, vct::size_type _cols,
          vct::stride_type _rowStride, vct::stride_type _colStride,
          class _elementType, class _dataPtrType>
inline bool vctAny(const vctFixedSizeConstMatrixBase<_rows, _cols, _rowStride, _colStride, _elementType, _dataPtrType> & matrix) {
    return matrix.Any();
}

template <vct::size_type _rows, vct::size_type _cols,
          vct::stride_type _rowStride, vct::stride_type _colStride,
          class _elementType, class _dataPtrType>
std::ostream & operator << (std::ostream & output,
                            const vctFixedSizeConstMatrixBase<_rows, _cols, _rowStride, _colStride, _elementType, _dataPtrType> & matrix) {
    matrix.ToStream(output);
    return output;
}
 
 
#endif // _vctFixedSizeConstMatrixBase_h