matrix.hpp

Go to the documentation of this file.

/*
 *    This file is part of ACADO Toolkit.
 *
 *    ACADO Toolkit -- A Toolkit for Automatic Control and Dynamic Optimization.
 *    Copyright (C) 2008-2014 by Boris Houska, Hans Joachim Ferreau,
 *    Milan Vukov, Rien Quirynen, KU Leuven.
 *    Developed within the Optimization in Engineering Center (OPTEC)
 *    under supervision of Moritz Diehl. All rights reserved.
 *
 *    ACADO Toolkit is free software; you can redistribute it and/or
 *    modify it under the terms of the GNU Lesser General Public
 *    License as published by the Free Software Foundation; either
 *    version 3 of the License, or (at your option) any later version.
 *
 *    ACADO Toolkit is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *    Lesser General Public License for more details.
 *
 *    You should have received a copy of the GNU Lesser General Public
 *    License along with ACADO Toolkit; if not, write to the Free Software
 *    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

#ifndef ACADO_TOOLKIT_MATRIX_HPP
#define ACADO_TOOLKIT_MATRIX_HPP

#include <memory>

#include <acado/matrix_vector/vector.hpp>

BEGIN_NAMESPACE_ACADO

template<typename T>
class GenericMatrix : public Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor | Eigen::AutoAlign>
{
public:

        typedef Eigen::Matrix<T, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor | Eigen::AutoAlign> Base;


        template<typename OtherDerived>
        inline GenericMatrix(const Eigen::MatrixBase<OtherDerived>& other) : Base( other ) {}

        template<typename OtherDerived>
        inline GenericMatrix(const Eigen::ReturnByValue<OtherDerived>& other) : Base( other ) {}

        template<typename OtherDerived>
        inline GenericMatrix(const Eigen::EigenBase<OtherDerived>& other) : Base( other ) {}

        GenericMatrix() : Base() {}

        GenericMatrix(  const T& _value
                                        )
                : Base(1, 1)
        { Base::data()[ 0 ] = _value; }

        GenericMatrix(  unsigned _nRows,
                                        unsigned _nCols
                                        )
                : Base(_nRows, _nCols)
        { Base::setZero(); }

        GenericMatrix(  unsigned _nRows,
                                        unsigned _nCols,
                                        const T* const _values
                                        )
                : Base(_nRows, _nCols)
        { std::copy(_values, _values + _nRows * _nCols, Base::data()); }

        GenericMatrix(  unsigned _nRows,
                                        unsigned _nCols,
                                        std::vector< T >& _values)
                : Base(_nRows, _nCols)
        { std::copy(_values.begin(), _values.end(), Base::data()); }

        GenericMatrix(  unsigned _nRows,
                                        unsigned _nCols,
                                        std::vector< std::vector< T > >& _values
                                        );

        virtual ~GenericMatrix()
        {}

        bool operator==(const GenericMatrix& arg) const
        {
                if (Base::rows() != arg.rows() || Base::cols() != arg.cols())
                        return false;
                return Base::isApprox(arg, EQUALITY_EPS);
        }

        bool operator!=(const GenericMatrix& arg) const
        {
                return (operator==( arg ) == false);
        }

        void init(      unsigned _nRows = 0,
                                unsigned _nCols = 0
                                )
        { Base::_set(GenericMatrix<T>(_nRows, _nCols)); }

        void setAll( const T& _value)
        { Base::setConstant( _value ); }

        GenericMatrix& appendRows(      const GenericMatrix& _arg
                                                                );

        GenericMatrix& appendCols(      const GenericMatrix& _arg
                                                                );

        GenericVector< T > sumCol() const;

        GenericVector< T > sumRow() const;

        GenericMatrix& makeVector( );

        unsigned getDim( ) const
        { return (Base::rows() * Base::cols()); }

        unsigned getNumRows( ) const
        { return Base::rows(); }

        unsigned getNumCols( ) const
        { return Base::cols(); }

        bool isEmpty( ) const
        { return Base::rows() == 0 || Base::cols() == 0; }

        GenericVector< T > getRow(      unsigned _idx
                                                                ) const
        {
                ASSERT( _idx < Base::rows() );
                return Base::row( _idx ).transpose();
        }

        GenericVector< T > getCol(      unsigned _idx
                                                                ) const
        {
                ASSERT( _idx < Base::cols() );
                return Base::col( _idx );
        }

        GenericMatrix& setRow(  unsigned _idx,
                                                        const GenericVector< T >& _values
                                                        )
        {
                ASSERT(Base::cols() == _values.rows() && _idx < Base::rows());
                Base::row( _idx ) = _values.transpose();

                return *this;
        }

        GenericMatrix& setCol(  unsigned _idx,
                                                        const GenericVector< T >& _arg
                                                        )
        {
                ASSERT(Base::rows() == _arg.rows() && _idx < Base::cols());
                Base::col( _idx ) = _arg;

                return *this;
        }

        GenericMatrix getRows(  unsigned _start,
                                                        unsigned _end
                                                        ) const
        {
                if (_start >= Base::rows() || _end >= Base::rows() || _start > _end)
                        return GenericMatrix();

                return Base::block(_start, 0, _end - _start + 1, Base::cols());
        }

        GenericMatrix getCols(  unsigned _start,
                                                        unsigned _end
                                                        ) const
        {
                if (_start >= Base::cols() || _end >= Base::cols() || _start > _end)
                        return GenericMatrix();

                return Base::block(0, _start, Base::rows(), _end - _start + 1);
        }

        GenericVector< T > getDiag( ) const;

        bool isSquare() const;

        bool isSymmetric( ) const;

        returnValue symmetrize( );

        bool isPositiveSemiDefinite( ) const;

        bool isPositiveDefinite( ) const;

        GenericMatrix absolute() const;

        GenericMatrix positive() const;

        GenericMatrix negative() const;

        T getMax( ) const
        { return Base::maxCoeff(); }

        T getMin( ) const
        { return Base::minCoeff(); }

        T getMean( ) const
        { return Base::mean(); }

        GenericMatrix< T > getAbsolute() const
        { return Base::cwiseAbs(); }

        T getNorm( ) const;

        T getTrace( ) const;

        T getConditionNumber( ) const;

        virtual returnValue print(      std::ostream& _stream            = std::cout,
                                                                const std::string& _name         = DEFAULT_LABEL,
                                                                const std::string& _startString  = DEFAULT_START_STRING,
                                                                const std::string& _endString    = DEFAULT_END_STRING,
                                                                uint _width                      = DEFAULT_WIDTH,
                                                                uint _precision                  = DEFAULT_PRECISION,
                                                                const std::string& _colSeparator = DEFAULT_COL_SEPARATOR,
                                                                const std::string& _rowSeparator = DEFAULT_ROW_SEPARATOR
                                                                ) const;

        virtual returnValue print(      std::ostream& stream,
                                                                const std::string& name,
                                                                PrintScheme printScheme
                                                                ) const;

        virtual returnValue print(      const std::string& _filename,
                                                                const std::string& _name         = DEFAULT_LABEL,
                                                                const std::string& _startString  = DEFAULT_START_STRING,
                                                                const std::string& _endString    = DEFAULT_END_STRING,
                                                                uint _width                      = DEFAULT_WIDTH,
                                                                uint _precision                  = DEFAULT_PRECISION,
                                                                const std::string& _colSeparator = DEFAULT_COL_SEPARATOR,
                                                                const std::string& _rowSeparator = DEFAULT_ROW_SEPARATOR
                                                                ) const;

        virtual returnValue print(      const std::string& _filename,
                                                                const std::string& _name,
                                                                PrintScheme _printScheme
                                                                ) const;

        virtual returnValue read(       std::istream& _stream
                                                                );

        virtual returnValue read(       const std::string& _filename
                                                                );
};

template<typename T>
std::ostream& operator<<(       std::ostream& _stream,
                                                        const GenericMatrix< T >& _arg
                                                        )
{
        if (_arg.print( _stream ) != SUCCESSFUL_RETURN)
                ACADOERRORTEXT(RET_INVALID_ARGUMENTS, "Cannot write to output stream.");

        return _stream;
}

template<typename T>
std::istream& operator>>(       std::istream& _stream,
                                                        GenericMatrix< T >& _arg
)
{
        if (_arg.read( _stream ) != SUCCESSFUL_RETURN )
                ACADOERRORTEXT(RET_INVALID_ARGUMENTS, "Cannot read from input stream.");

        return _stream;
}

template<typename T>
GenericMatrix< T > ones(        unsigned _nRows,
                                                        unsigned _nCols = 1
                                                        )
{ return GenericMatrix< T >(_nRows, _nCols).setOnes(); }

template<typename T>
GenericMatrix< T > zeros(       unsigned _nRows,
                                                        unsigned _nCols = 1
                                                        )
{ return GenericMatrix< T >(_nRows, _nCols).setZero(); }

template<typename T>
GenericMatrix< T > eye( unsigned _dim
                                                )
{ return GenericMatrix< T >(_dim, _dim).setIdentity(); }

typedef GenericMatrix< double > DMatrix;
typedef GenericMatrix< int > IMatrix;
typedef GenericMatrix< bool > BMatrix;
typedef std::shared_ptr< GenericMatrix< double > > DMatrixPtr;

static       DMatrix emptyMatrix;
static const DMatrix emptyConstMatrix;

CLOSE_NAMESPACE_ACADO

namespace Eigen
{
namespace internal
{
template<typename T>
struct traits< ACADO::GenericMatrix< T > >
        : traits<Matrix<T, Dynamic, Dynamic, Eigen::RowMajor | Eigen::AutoAlign> >
{};

} // namespace internal
} // namespace Eigen
#endif  // ACADO_TOOLKIT_MATRIX_HPP