expression.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_EXPRESSION_HPP
#define ACADO_TOOLKIT_EXPRESSION_HPP

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

BEGIN_NAMESPACE_ACADO

class Operator;

class Expression
{
        friend class COperator;
        friend class CFunction;
        friend class FunctionEvaluationTree;

public:
        Expression( );

        Expression( const Operator &tree_ );

        explicit Expression(    const std::string& name_
                                                        );

        explicit Expression(    const std::string&  name_,                                                      
                                                        uint                    nRows_,                                                 
                                                        uint                    nCols_,                                                 
                                                        VariableType            variableType_  = VT_UNKNOWN,    
                                                        uint                    globalTypeID   = 0                              
                                                        );

        explicit Expression(    int          nRows_                     ,  
                                                        int          nCols_         = 1         ,  
                                                        VariableType variableType_  = VT_UNKNOWN,  
                                                        int          globalTypeID   = 0            
                                                        );

        explicit Expression(    uint         nRows_                     ,  
                                                        uint         nCols_         = 1         ,  
                                                        VariableType variableType_  = VT_UNKNOWN,  
                                                        uint         globalTypeID   = 0            
                                                        );

        Expression( const double& rhs );
        Expression( const DVector      & rhs );
        Expression( const DMatrix      & rhs );
        Expression( const Expression  & rhs );

        virtual ~Expression( );

        virtual Expression* clone() const
        { return new Expression( *this ); }

        Expression& operator=( const Expression& arg );

        Expression& operator<<( const Expression  & arg );

        Expression&  appendRows(const Expression& arg);
        
        Expression&  appendCols(const Expression& arg);

        Expression operator()( uint idx                 ) const;
        Expression operator()( uint rowIdx, uint colIdx ) const;

        Operator& operator()( uint idx                 );
        Operator& operator()( uint rowIdx, uint colIdx );

        friend Expression operator+( const Expression  & arg1, const Expression  & arg2 );
        friend Expression operator-( const Expression  & arg1, const Expression  & arg2 );
        Expression operator-( ) const;
        friend Expression operator*( const Expression  & arg1, const Expression  & arg2 );
        friend Expression operator/( const Expression  & arg1, const Expression  & arg2 );

        Expression& operator+=(const Expression &arg);
        Expression& operator-=(const Expression &arg);
        Expression& operator*=(const Expression &arg);
        Expression& operator/=(const Expression &arg);

        std::ostream& print( std::ostream &stream ) const;
        friend std::ostream& operator<<( std::ostream& stream, const Expression &arg );

        Expression getInverse( ) const;
        
        Expression getRow( const uint& rowIdx ) const;
        Expression getRows( const uint& rowIdx1, const uint& rowIdx2 ) const;
        Expression getCol( const uint& colIdx ) const;
        Expression getCols( const uint& colIdx1, const uint& colIdx2 ) const;
        Expression getSubMatrix( const uint& rowIdx1, const uint& rowIdx2, const uint& colIdx1, const uint& colIdx2 ) const;
        
        DMatrix getDependencyPattern( const Expression& arg ) const;

        DMatrix getSparsityPattern() const;

        Expression getSin    ( ) const;
        Expression getCos    ( ) const;
        Expression getTan    ( ) const;
        Expression getAsin   ( ) const;
        Expression getAcos   ( ) const;
        Expression getAtan   ( ) const;
        Expression getExp    ( ) const;
        Expression getSqrt   ( ) const;
        Expression getLn     ( ) const;

        Expression getPow   ( const Expression &arg ) const;
        Expression getPowInt( const int        &arg ) const;

        Expression getSumSquare    ( ) const;
        Expression getLogSumExp    ( ) const;
        Expression getEuclideanNorm( ) const;
        Expression getEntropy      ( ) const;

        Expression getDot          ( ) const;
        Expression getNext         ( ) const;

        Expression ADforward  ( const Expression &arg ) const;
        Expression ADforward  ( const VariableType &varType_, const int *arg, int nV ) const;
        Expression ADbackward ( const Expression &arg ) const;
        
        Expression ADsymmetric( const Expression &arg, 
                                                        const Expression &S  , 
                                                        const Expression &l  , 
                                                        Expression *dfS = 0,    
                                                        Expression *ldf = 0    
                                                        ) const;
        
        Expression ADsymmetric( const Expression &arg, 
                                                        const Expression &l  , 
                                                        Expression *dfS = 0,    
                                                        Expression *ldf = 0    
                                                        ) const;
        
        Expression getODEexpansion( const int &order, const int *arg ) const;

        Expression ADforward ( const Expression &arg, const Expression &seed ) const;
        Expression ADforward ( const VariableType &varType_, const int *arg, const Expression &seed ) const;
        Expression ADforward ( const VariableType *varType_, const int *arg, const Expression &seed ) const;
        Expression ADbackward( const Expression &arg, const Expression &seed ) const;

        Expression transpose( ) const;

        inline uint getDim( ) const;

        inline uint getNumRows( ) const;

        inline uint getNumCols( ) const;

        inline uint getComponent( const unsigned int idx ) const;

        inline BooleanType isVariable( ) const;

        Operator* getOperatorClone( uint idx ) const;

        inline VariableType getVariableType( ) const;

        BooleanType isDependingOn( VariableType type ) const;
        BooleanType isDependingOn(const  Expression &e ) const;

        returnValue substitute( int idx, const Expression &arg ) const;

protected:

        Expression add(const Expression& arg) const;
        Expression sub(const Expression& arg) const;
        Expression mul(const Expression& arg) const;
        Expression div(const Expression& arg) const;

        void construct( VariableType  variableType_,  
                                        uint          globalTypeID_,  
                                        uint                 nRows_,  
                                        uint                 nCols_,  
                                        const std::string&   name_     );

        void copy( const Expression &rhs );

        void deleteAll( );

        Expression& assignmentSetup( const Expression &arg );

        Operator* product( const Operator *a, const Operator *b ) const;

        Operator**         element     ;   
        uint               dim         ;   
        uint               nRows, nCols;   
        VariableType       variableType;   
        uint               component   ;   
        std::string             name   ;   
};

CLOSE_NAMESPACE_ACADO

#include <acado/symbolic_expression/expression.ipp>

BEGIN_NAMESPACE_ACADO

template<class Derived, VariableType Type, bool AllowCounter = true>
class ExpressionType : public Expression
{
public:

        ExpressionType()
                : Expression("", 1, 1, Type, AllowCounter ? count : 0)
        {
                if (AllowCounter == true)
                        count++;
        }

        ExpressionType(const std::string& _name, unsigned _nRows, unsigned _nCols)
                : Expression(_name, _nRows, _nCols, Type, AllowCounter ? count : 0)
        {
                if (AllowCounter == true)
                        count += _nRows * _nCols;
        }

        ExpressionType(const Expression& _expression, unsigned _componentIdx = 0)
                : Expression( _expression )
        {
                variableType = Type;
                component += _componentIdx;
                if (AllowCounter == true)
                        count++;
        }

        ExpressionType( const double& _arg )
                : Expression( _arg )
        {}

        ExpressionType( const DVector& _arg )
                : Expression( _arg )
        {}

        ExpressionType( const DMatrix& _arg )
                : Expression( _arg )
        {}

        ExpressionType( const Operator& _arg )
                : Expression( _arg )
        {}

        virtual ~ExpressionType() {}

        virtual Expression* clone() const
        { return new Derived( static_cast< Derived const& >( *this ) ); }

        returnValue clearStaticCounters()
        { count = 0; return SUCCESSFUL_RETURN; }

private:
        static unsigned count;
};

template<class Derived, VariableType Type, bool AllowCounter>
unsigned ExpressionType<Derived, Type, AllowCounter>::count( 0 );

CLOSE_NAMESPACE_ACADO

#endif  // ACADO_TOOLKIT_EXPRESSION_HPP