vctDynamicMatrix.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-2007 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 _vctDynamicMatrix_h
#define _vctDynamicMatrix_h

#include <cisstVector/vctDynamicVector.h>
#include <cisstVector/vctDynamicMatrixBase.h>
#include <cisstVector/vctDynamicMatrixRef.h>
#include <cisstVector/vctDynamicMatrixOwner.h>

template <class _elementType>
class vctDynamicMatrix : public vctDynamicMatrixBase<vctDynamicMatrixOwner<_elementType>, _elementType>
{

    friend class vctReturnDynamicMatrix<_elementType>;

public:
    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);
    enum {DIMENSION = 2};
    VCT_NARRAY_TRAITS_TYPEDEFS(DIMENSION);

    typedef vctDynamicMatrixBase<vctDynamicMatrixOwner<_elementType>, _elementType> BaseType;
    typedef vctDynamicMatrix<_elementType> ThisType;


    vctDynamicMatrix()
        // The default initialization of vctDynamicMatrixOwner is empty.
    {}


    /* Constructor: Create a matrix of the specified size.  Elements
       initialized with default constructor.  The storage order can be
       either #VCT_ROW_MAJOR or #VCT_COL_MAJOR. */
    vctDynamicMatrix(size_type rows, size_type cols, bool storageOrder = VCT_DEFAULT_STORAGE) {
        this->SetSize(rows, cols, storageOrder);
    }

    vctDynamicMatrix(const nsize_type & matrixSize, bool storageOrder = VCT_DEFAULT_STORAGE) {
        this->SetSize(matrixSize, storageOrder);
    }

    vctDynamicMatrix(size_type rows, size_type cols, value_type value, bool storageOrder = VCT_DEFAULT_STORAGE) {
        this->SetSize(rows, cols, storageOrder);
        this->SetAll(value);
    }

    vctDynamicMatrix(const nsize_type & matrixSize, value_type value, bool storageOrder = VCT_DEFAULT_STORAGE) {
        this->SetSize(matrixSize, storageOrder);
        this->SetAll(value);
    }

    vctDynamicMatrix(const vctReturnDynamicMatrix<value_type> & otherMatrix);


    vctDynamicMatrix(const ThisType & otherMatrix):
        BaseType()
    {
        this->SetSize(otherMatrix.rows(), otherMatrix.cols(), otherMatrix.StorageOrder());
        this->Assign(otherMatrix);
    }


    template <class __matrixOwnerType, typename __otherMatrixElementType>
    vctDynamicMatrix(const vctDynamicConstMatrixBase<__matrixOwnerType, __otherMatrixElementType> & otherMatrix, bool storageOrder) {
        this->SetSize(otherMatrix.rows(), otherMatrix.cols(), storageOrder);
        this->Assign(otherMatrix);
    }


    template <class __matrixOwnerType>
    vctDynamicMatrix(const vctDynamicConstMatrixBase<__matrixOwnerType, value_type> & otherMatrix) {
        this->SetSize(otherMatrix.rows(), otherMatrix.cols(), otherMatrix.StorageOrder());
        this->Assign(otherMatrix);
    }


    template <class __matrixOwnerType, typename __otherMatrixElementType>
    explicit vctDynamicMatrix(const vctDynamicConstMatrixBase<__matrixOwnerType, __otherMatrixElementType> & otherMatrix) {
        this->SetSize(otherMatrix.rows(), otherMatrix.cols(), otherMatrix.StorageOrder());
        this->Assign(otherMatrix);
    }


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


    template <class __matrixOwnerType, typename __elementType>
    ThisType & operator = (const vctDynamicConstMatrixBase<__matrixOwnerType, __elementType> & otherMatrix) {
        this->SetSize(otherMatrix.rows(), otherMatrix.cols());
        this->Assign(otherMatrix);
        return *this;
    }


    ThisType & operator = (const ThisType & otherMatrix) {
        this->SetSize(otherMatrix.rows(), otherMatrix.cols(), otherMatrix.StorageOrder());
        this->Assign(otherMatrix);
        return *this;
    }

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


    ThisType & operator = (const vctReturnDynamicMatrix<value_type> & otherMatrix);

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

    // documented in base class
    template <class __matrixOwnerType, typename __elementType>
    inline ThisType & ForceAssign(const vctDynamicConstMatrixBase<__matrixOwnerType, __elementType> & other) {
        this->SetSize(other.sizes(), other.StorageOrder());
        this->Assign(other);
        return *this;
    }

    // documented in base class
    template <size_type __rows, size_type __cols,
              stride_type __rowStride, stride_type __colStride,
              class __elementType, class __dataPtrType>
    inline ThisType & ForceAssign(const vctFixedSizeConstMatrixBase<__rows, __cols,
                                                                    __rowStride, __colStride,
                                                                    __elementType, __dataPtrType>  & other) {
        this->SetSize(other.sizes(), other.StorageOrder());
        this->Assign(other);
        return *this;
    }

    void resize(size_type rows, size_type cols) {
        this->resize(nsize_type(rows, cols));
    }

    void resize(const nsize_type & newSizes) {
        if (newSizes == this->sizes())
            return;

        const bool isRowMajor = this->IsRowMajor();
        ThisType newData(newSizes, isRowMajor);
        const nsize_type corner(0);
        nsize_type minSizes;
        minSizes.ElementwiseMinOf(this->sizes(), newSizes);
        vctDynamicConstMatrixRef<value_type> myDataMinSpaceRef(*this, corner, minSizes);
        vctDynamicMatrixRef<value_type> newDataMinSpaceRef(newData, corner, minSizes);
        newDataMinSpaceRef.Assign(myDataMinSpaceRef);
        this->Matrix.Disown();
        this->Matrix.Own(newSizes, isRowMajor, newData.Matrix.Release());
    }

    void SetSize(size_type rows, size_type cols, bool storageOrder) {
        this->Matrix.SetSize(rows, cols, storageOrder);
    }

    void SetSize(const nsize_type & matrixSize, bool storageOrder) {
        this->Matrix.SetSize(matrixSize, storageOrder);
    }

    void SetSize(size_type rows, size_type cols) {
        this->Matrix.SetSize(rows, cols, this->StorageOrder());
    }

    void SetSize(const nsize_type & matrixSize) {
        this->Matrix.SetSize(matrixSize, this->StorageOrder());
    }

    void DeSerializeRaw(std::istream & inputStream)
    {
        // get and set size
        size_type myRows = 0;
        size_type myCols = 0;
        cmnDeSerializeSizeRaw(inputStream, myRows);
        cmnDeSerializeSizeRaw(inputStream, myCols);
        this->SetSize(myRows, myCols);

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

};


template <class _elementType>
class vctReturnDynamicMatrix : public vctDynamicMatrix<_elementType> {
public:
    typedef vctDynamicMatrix<_elementType> BaseType;

    VCT_CONTAINER_TRAITS_TYPEDEFS(_elementType);

    explicit vctReturnDynamicMatrix(const BaseType & other)
    {
        BaseType & nonConstOther = const_cast<BaseType &>(other);
        // if we don't save it in a variable, it will be destroyed in the Release operation
        const size_type rows = other.rows();
        const size_type cols = other.cols();
        const bool storageOrder = other.StorageOrder();
        this->Matrix.Own(rows, cols, storageOrder, nonConstOther.Matrix.Release());
    }
};


// implementation of the special copy constuctor of vctDynamicMatrix
template <class _elementType>
vctDynamicMatrix<_elementType>::vctDynamicMatrix(const vctReturnDynamicMatrix<_elementType> & other) {
    vctReturnDynamicMatrix<_elementType> & nonConstOther =
        const_cast< vctReturnDynamicMatrix<_elementType> & >(other);
    // if we don't save it in a variable, it will be destroyed in the Release operation
    const size_type rows = other.rows();
    const size_type cols = other.cols();
    const bool storageOrder = other.StorageOrder();
    this->Matrix.Own(rows, cols, storageOrder, nonConstOther.Matrix.Release());
}


// implementation of the special assignment operator from vctReturnDynamicMatrix to vctDynamicMatrix
template <class _elementType>
vctDynamicMatrix<_elementType> &
vctDynamicMatrix<_elementType>::operator = (const vctReturnDynamicMatrix<_elementType> & other) {
    vctReturnDynamicMatrix<_elementType> & nonConstOther =
        const_cast< vctReturnDynamicMatrix<_elementType> & >(other);
    // if we don't save it in a variable, it will be destroyed in the Release operation
    const size_type rows = other.rows();
    const size_type cols = other.cols();
    const bool storageOrder = other.StorageOrder();
    this->Matrix.Disown();
    this->Matrix.Own(rows, cols, storageOrder, nonConstOther.Matrix.Release());
    return *this;
}


template <class _matrixOwnerType1, class _matrixOwnerType2, class _elementType>
vctReturnDynamicMatrix<_elementType>
operator + (const vctDynamicConstMatrixBase<_matrixOwnerType1, _elementType> & inputMatrix1,
            const vctDynamicConstMatrixBase<_matrixOwnerType2, _elementType> & inputMatrix2) {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(inputMatrix1);
    resultStorage.Add(inputMatrix2);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}

/* documented above */
template <class _matrixOwnerType1, class _matrixOwnerType2, class _elementType>
vctReturnDynamicMatrix<_elementType>
operator - (const vctDynamicConstMatrixBase<_matrixOwnerType1, _elementType> & inputMatrix1,
            const vctDynamicConstMatrixBase<_matrixOwnerType2, _elementType> & inputMatrix2) {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(inputMatrix1);
    resultStorage.Subtract(inputMatrix2);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}



template <class _matrixOwnerType, class _elementType>
vctReturnDynamicMatrix<_elementType>
operator + (const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & inputMatrix,
            const _elementType & inputScalar) {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(inputMatrix);
    resultStorage.Add(inputScalar);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}

/* documented above */
template <class _matrixOwnerType, class _elementType>
vctReturnDynamicMatrix<_elementType>
operator - (const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & inputMatrix,
            const _elementType & inputScalar) {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(inputMatrix);
    resultStorage.Subtract(inputScalar);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}

/* documented above */
template <class _matrixOwnerType, class _elementType>
vctReturnDynamicMatrix<_elementType>
operator * (const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & inputMatrix,
            const _elementType & inputScalar) {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(inputMatrix);
    resultStorage.Multiply(inputScalar);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}

/* documented above */
template <class _matrixOwnerType, class _elementType>
vctReturnDynamicMatrix<_elementType>
operator / (const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & inputMatrix,
            const _elementType & inputScalar) {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(inputMatrix);
    resultStorage.Divide(inputScalar);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}



template <class _matrixOwnerType, class _elementType>
vctReturnDynamicMatrix<_elementType>
operator + (const _elementType & inputScalar,
            const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & inputMatrix) {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(inputMatrix.rows(), inputMatrix.cols());
    resultStorage.SumOf(inputScalar, inputMatrix);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}

/* documented above */
template <class _matrixOwnerType, class _elementType>
vctReturnDynamicMatrix<_elementType>
operator - (const _elementType & inputScalar,
            const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & inputMatrix) {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(inputMatrix.rows(), inputMatrix.cols());
    resultStorage.DifferenceOf(inputScalar, inputMatrix);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}

/* documented above */
template <class _matrixOwnerType, class _elementType>
vctReturnDynamicMatrix<_elementType>
operator * (const _elementType & inputScalar,
            const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & inputMatrix) {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(inputMatrix.rows(), inputMatrix.cols());
    resultStorage.ProductOf(inputScalar, inputMatrix);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}

/* documented above */
template <class _matrixOwnerType, class _elementType>
vctReturnDynamicMatrix<_elementType>
operator / (const _elementType & inputScalar,
            const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & inputMatrix) {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(inputMatrix.rows(), inputMatrix.cols());
    resultStorage.RatioOf(inputScalar, inputMatrix);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}


template <class _matrixOwnerType, class _elementType>
vctReturnDynamicMatrix<_elementType>
operator - (const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & inputMatrix) {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(inputMatrix.rows(), inputMatrix.cols());
    resultStorage.NegationOf(inputMatrix);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}



#ifndef DOXYGEN
template <class _matrixOwnerType1, class _matrixOwnerType2, class _elementType>
vctReturnDynamicMatrix<_elementType>
operator * (const vctDynamicConstMatrixBase<_matrixOwnerType1, _elementType> & inputMatrix1,
            const vctDynamicConstMatrixBase<_matrixOwnerType2, _elementType> & inputMatrix2) {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(inputMatrix1.rows(), inputMatrix2.cols());
    resultStorage.ProductOf(inputMatrix1, inputMatrix2);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}


template <class _matrixOwnerType, class _vectorOwnerType, class _elementType>
vctReturnDynamicVector<_elementType>
operator * (const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & inputMatrix,
            const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & inputVector) {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(inputMatrix.rows());
    resultStorage.ProductOf(inputMatrix, inputVector);
    return vctReturnDynamicVector<value_type>(resultStorage);
}


template <class _vectorOwnerType, class _matrixOwnerType, class _elementType>
vctReturnDynamicVector<_elementType>
operator * (const vctDynamicConstVectorBase<_vectorOwnerType, _elementType> & inputVector,
            const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & inputMatrix) {
    typedef _elementType value_type;
    vctDynamicVector<value_type> resultStorage(inputMatrix.cols());
    resultStorage.ProductOf(inputVector, inputMatrix);
    return vctReturnDynamicVector<value_type>(resultStorage);
}



/*
  Methods declared previously and implemented here because they require vctReturnDynamicMatrix
*/


/* documented in class vctDynamicConstMatrixBase */
template <class _matrixOwnerType, class _elementType>
inline typename vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::MatrixReturnType
vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::Abs(void) const {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(this->rows(), this->cols());
    vctDynamicMatrixLoopEngines::
        MoMi<typename vctUnaryOperations<value_type>::AbsValue>::
        Run(resultStorage, *this);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}

/* documented in class vctDynamicConstMatrixBase */
template <class _matrixOwnerType, class _elementType>
inline typename vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::MatrixReturnType
vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::Negation(void) const {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(this->rows(), this->cols());
    vctDynamicMatrixLoopEngines::
        MoMi<typename vctUnaryOperations<value_type>::Negation>::
        Run(resultStorage, *this);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}

/* documented in class vctDynamicConstMatrixBase */
template <class _matrixOwnerType, class _elementType>
inline typename vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::MatrixReturnType
vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::Floor(void) const {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(this->rows(), this->cols());
    vctDynamicMatrixLoopEngines::
        MoMi<typename vctUnaryOperations<value_type>::Floor>::
        Run(resultStorage, *this);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}

/* documented in class vctDynamicConstMatrixBase */
template <class _matrixOwnerType, class _elementType>
inline typename vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::MatrixReturnType
vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::Ceil(void) const {
    typedef _elementType value_type;
    vctDynamicMatrix<value_type> resultStorage(this->rows(), this->cols());
    vctDynamicMatrixLoopEngines::
        MoMi<typename vctUnaryOperations<value_type>::Ceil>::
        Run(resultStorage, *this);
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}

/* documented in class vctDynamicConstMatrixBase */
template <class _matrixOwnerType, class _elementType>
typename vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::MatrixReturnType
vctDynamicConstMatrixBase<_matrixOwnerType, _elementType>::Eye(size_type size) {
    vctDynamicMatrix<value_type> resultStorage(size, size);
    resultStorage.SetAll(_elementType(0));
    resultStorage.Diagonal().SetAll(_elementType(1));
    return vctReturnDynamicMatrix<value_type>(resultStorage);
}

/* Documented in class vctDynamicConstMatrixBase */
template <class _matrixOwnerType, class __matrixOwnerType, class _elementType,
          class _elementOperationType>
inline vctReturnDynamicMatrix<bool>
vctDynamicMatrixElementwiseCompareMatrix(const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & matrix1,
                                         const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & matrix2) {
    vctDynamicMatrix<bool> result(matrix1.rows(), matrix1.cols());
    vctDynamicMatrixLoopEngines::
        MoMiMi<_elementOperationType>::Run(result, matrix1, matrix2);
    return vctReturnDynamicMatrix<bool>(result);
}

/* documented in class vctDynamicConstMatrixBase */
template <class _matrixOwnerType, class _elementType,
          class _elementOperationType>
inline vctReturnDynamicMatrix<bool>
vctDynamicMatrixElementwiseCompareScalar(const vctDynamicConstMatrixBase<_matrixOwnerType, _elementType> & matrix,
                                         const _elementType & scalar) {
    vctDynamicMatrix<bool> result(matrix.rows(), matrix.cols());
    vctDynamicMatrixLoopEngines::
        MoMiSi<_elementOperationType>::Run(result, matrix, scalar);
    return vctReturnDynamicMatrix<bool>(result);
}

#endif // DOXYGEN


#endif // _vctDynamicMatrix_h