vector.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_VECTOR_HPP
#define ACADO_TOOLKIT_VECTOR_HPP

#include <acado/utils/acado_utils.hpp>
#include <acado/matrix_vector/matrix_vector_tools.hpp>

BEGIN_NAMESPACE_ACADO

enum VectorNorm
{
    VN_L1,
    VN_L2,
    VN_LINF
};

template<typename T>
class GenericVector : public Eigen::Matrix<T, Eigen::Dynamic, 1>
{
public:

        typedef Eigen::Matrix<T, Eigen::Dynamic, 1> Base;

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

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

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

        GenericVector() : Base() {}

        GenericVector(  unsigned _dim ) : Base( _dim ) { Base::setZero(); }

        GenericVector(  unsigned _dim,
                                        const T* const _values
                                        )
                : Base( _dim )
        { std::copy(_values, _values + _dim, Base::data()); }

        GenericVector(  std::vector< T > _values
                                        )
                : Base( _values.size() )
        { std::copy(_values.begin(), _values.end(), Base::data()); }

        virtual ~GenericVector()
        {}

        bool operator==(const GenericVector& _arg) const
        {
                if (Base::rows() != _arg.rows())
                        return false;
                return Base::isApprox(_arg, EQUALITY_EPS);
        }

        bool operator!=(const GenericVector& _arg) const
        {
                return (operator==( _arg ) == false);
        }

        bool operator<=(const GenericVector& _arg) const
        {
                if (Base::rows() != _arg.rows())
                        return false;
                for (unsigned el = 0; el < Base::rows(); ++el)
                        if (Base::data()[ el ] > _arg.data()[ el ])
                                return false;
                return true;
        }

        bool operator>=(const GenericVector& _arg) const
        {
                if (Base::rows() != _arg.rows())
                        return false;
                for (unsigned el = 0; el < Base::rows(); ++el)
                        if (Base::data()[ el ] < _arg.data()[ el ])
                                return false;
                return true;
        }

        bool operator>(const GenericVector& _arg) const
        {
                return operator<=( _arg ) == false;
        }

        bool operator<(const GenericVector& _arg) const
        {
                return operator>=( _arg ) == false;
        }

        void init(      unsigned _dim = 0
                                )
        { Base::_set(GenericVector< T >( _dim )); }

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

        GenericVector& append(  const GenericVector& _arg
                                                        );

        GenericVector& setUnitVector(   unsigned _idx
                                                                        );

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

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

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

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

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

        GenericVector getAbsolute() const
        { return Base::cwiseAbs(); }

        T getNorm(      VectorNorm _norm
                                ) const;

        T getNorm(      VectorNorm _norm,
                                const GenericVector& _scale
                                ) 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(      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(      std::ostream& stream,
                                                                const std::string& name,
                                                                PrintScheme printScheme
                                                                ) 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 GenericVector< 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,
                                                        GenericVector< T >& _arg
)
{
        if (_arg.read( _stream ) != SUCCESSFUL_RETURN )
                ACADOERRORTEXT(RET_INVALID_ARGUMENTS, "Cannot read from input stream.");

        return _stream;
}

typedef GenericVector< double > DVector;
typedef GenericVector< int > IVector;
typedef GenericVector< bool > BVector;

static       DVector emptyVector;
static const DVector emptyConstVector;

CLOSE_NAMESPACE_ACADO

#endif  // ACADO_TOOLKIT_VECTOR_HPP