vctFixedSizeMatrixRef.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
  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 _vctFixedSizeMatrixRef_h
#define _vctFixedSizeMatrixRef_h

#include <cisstVector/vctFixedSizeMatrixBase.h>

template <class _elementType, vct::size_type _rows, vct::size_type _cols,
          vct::stride_type _rowStride, vct::stride_type _colStride>
class vctFixedSizeMatrixRef : public vctFixedSizeMatrixBase
  <_rows, _cols,_rowStride, _colStride, _elementType,
   typename vctFixedSizeMatrixTraits<_elementType, _rows, _cols, _rowStride, _colStride>::pointer>
{
 public:
    /* define most types from vctContainerTraits */
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);

    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 vctFixedSizeMatrixRef<value_type, _rows, _cols,
                                  _rowStride, _colStride> ThisType;
    typedef vctFixedSizeMatrixBase<_rows, _cols, _rowStride, _colStride, value_type,
                                   typename MatrixTraits::pointer> BaseType;

    vctFixedSizeMatrixRef()
        {}

    vctFixedSizeMatrixRef(pointer p) {
        SetRef(p);
    }

    template <size_type __rows, size_type __cols, class __dataPtrType>
    inline explicit vctFixedSizeMatrixRef(vctFixedSizeMatrixBase<__rows, __cols, _rowStride, _colStride, _elementType, __dataPtrType> & matrix)
    {
        SetRef(matrix, 0, 0);
    }


    template <size_type __rows, size_type __cols, class __dataPtrType>
    inline vctFixedSizeMatrixRef(
        vctFixedSizeMatrixBase<__rows, __cols, _rowStride, _colStride, _elementType, __dataPtrType>
        & matrix, index_type startRow, index_type startCol )
    {
        SetRef(matrix, startRow, startCol);
    }

    template <class __matrixOwnerType>
    inline vctFixedSizeMatrixRef(vctDynamicMatrixBase<__matrixOwnerType, _elementType> & matrix,
                                 index_type startRow, index_type startCol)
    {
        SetRef(matrix, startRow, startCol);
    }

    void SetRef(pointer p) {
        this->Data = p;
    }

    void SetRef(const ThisType & other) {
        this->SetRef(other.Data);
    }

    template <size_type __rows, size_type __cols, class __dataPtrType>
    inline void SetRef(vctFixedSizeMatrixBase<__rows, __cols, _rowStride, _colStride, _elementType, __dataPtrType> & matrix,
                       index_type startRow, index_type startCol)
    {
        if ((startRow + this->rows() > matrix.rows()) || (startCol + this->cols() > matrix.cols())) {
            cmnThrow(std::out_of_range("vctFixedSizeMatrixRef SetRef out of range"));
        }
        SetRef(matrix.Pointer(startRow, startCol));
    }

    template <class __dataPtrType>
    inline void SetRef(vctFixedSizeMatrixBase<_rows, _cols, _rowStride, _colStride, _elementType, __dataPtrType> & matrix)
    {
        SetRef(matrix.Pointer());
    }

    template <class __matrixOwnerType>
    inline void SetRef(vctDynamicMatrixBase<__matrixOwnerType, _elementType> & matrix,
                       index_type startRow, index_type startCol)
    {
        if ((this->row_stride() != matrix.row_stride()) || (this->col_stride() == matrix.col_stride())) {
            cmnThrow(std::runtime_error("vctFixedSizeMatrixRef SetRef with incompatible stride(s)"));
        }
        if ((startRow + this->rows() > matrix.rows()) || (startCol + this->cols() > matrix.cols())) {
            cmnThrow(std::out_of_range("vctFixedSizeMatrixRef SetRef out of range"));
        }
        SetRef(matrix.Pointer(startRow, startCol));
    }

    inline ThisType & operator = (const ThisType & other) {
        return reinterpret_cast<ThisType &>(this->Assign(other));
    }

    template <stride_type __rowStride, stride_type __colStride>
    inline ThisType & operator = (const vctFixedSizeConstMatrixRef<_elementType, _rows, _cols, __rowStride, __colStride> & other) {
        return reinterpret_cast<ThisType &>(this->Assign(other));
    }

    template <stride_type __rowStride, stride_type __colStride, class __elementType, class __dataPtrType>
    inline ThisType & operator = (const vctFixedSizeConstMatrixBase<_rows, _cols, __rowStride, __colStride, __elementType, __dataPtrType> & other) {
        return reinterpret_cast<ThisType &>(this->Assign(other));
    }

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

    inline ThisType & operator = (const value_type & value) {
        this->SetAll(value);
        return *this;
    }

};


#ifndef DOXYGEN

/* MultiplyMatrixVector function declaration is in
   vctFixedSizeVectorBase. This is an auxiliary function which
   multiplies matrix*vector and stored the result directly into a
   matrix */
template <vct::size_type _resultSize, vct::stride_type _resultStride, class _resultElementType, class _resultDataPtrType,
          vct::size_type _matrixCols, vct::stride_type _matrixRowStride, vct::stride_type _matrixColStride, class _matrixDataPtrType,
          vct::stride_type _vectorStride, class _vectorDataPtrType>
inline void MultiplyMatrixVector(
                                 // create matrix references to both vectors and use the matrix product
                                 vctFixedSizeVectorBase<_resultSize, _resultStride, _resultElementType, _resultDataPtrType> & result,
                                 const vctFixedSizeConstMatrixBase<_resultSize, _matrixCols, _matrixRowStride, _matrixColStride,
                                 _resultElementType, _matrixDataPtrType> & matrix,
                                 const vctFixedSizeConstVectorBase<_matrixCols, _vectorStride, _resultElementType, _vectorDataPtrType> & vector)
{
    const vctFixedSizeConstMatrixRef<_resultElementType, _matrixCols, 1, _vectorStride, 1>
        inputVectorRef(vector.Pointer());
    vctFixedSizeMatrixRef<_resultElementType, _resultSize, 1, _resultStride, 1> resultRef(result.Pointer());
    resultRef.ProductOf(matrix, inputVectorRef);
}

/* MultiplyVectorMatrix function declaration is in
   vctFixedSizeVectorBase. This is an auxiliary function which
   multiplies vector*matrix and stored the result directly into a
   vector */
template <vct::size_type _resultSize, vct::stride_type _resultStride, class _resultElementType, class _resultDataPtrType,
          vct::size_type _vectorSize, vct::stride_type _vectorStride, class _vectorDataPtrType,
          vct::stride_type _matrixRowStride, vct::stride_type _matrixColStride, class _matrixDataPtrType >
inline void MultiplyVectorMatrix(
                                 vctFixedSizeVectorBase<_resultSize, _resultStride, _resultElementType, _resultDataPtrType> & result,
                                 const vctFixedSizeConstVectorBase<_vectorSize, _vectorStride, _resultElementType, _vectorDataPtrType> & vector,
                                 const vctFixedSizeConstMatrixBase<_vectorSize, _resultSize, _matrixRowStride, _matrixColStride,
                                 _resultElementType, _matrixDataPtrType> & matrix
                                 )
{
    // create matrix references to both vectors and use the matrix product
    const vctFixedSizeConstMatrixRef<_resultElementType, 1, _vectorSize, (_vectorStride*_vectorSize), _vectorStride>
        inputVectorRef(vector.Pointer());
    vctFixedSizeMatrixRef<_resultElementType, 1, _resultSize, (_resultStride*_resultSize), _resultStride>
        resultRef(result.Pointer());
    resultRef.ProductOf(inputVectorRef, matrix);
}

#endif // DOXYGEN


#endif // _vctFixedSizeMatrixRef_h