operator.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_OPERATOR_HPP
#define ACADO_TOOLKIT_OPERATOR_HPP


#include <acado/symbolic_operator/symbolic_operator_fwd.hpp>


BEGIN_NAMESPACE_ACADO


class Expression;
class ConstraintComponent;
class EvaluationBase;


class Operator{

public:


           Operator();

    virtual ~Operator();


    virtual Operator& operator=( const double      & arg );
    virtual Operator& operator=( const DVector      & arg );
    virtual Operator& operator=( const DMatrix      & arg );
    virtual Operator& operator=( const Expression  & arg );
    virtual Operator& operator=( const Operator    & arg );


    Operator& operator+=( const double      & arg );
    Operator& operator+=( const DVector      & arg );
    Operator& operator+=( const DMatrix      & arg );
    Operator& operator+=( const Expression  & arg );

    Operator& operator-=( const double      & arg );
    Operator& operator-=( const DVector      & arg );
    Operator& operator-=( const DMatrix      & arg );
    Operator& operator-=( const Expression  & arg );

    Operator& operator*=( const double      & arg );
    Operator& operator*=( const DVector      & arg );
    Operator& operator*=( const DMatrix      & arg );
    Operator& operator*=( const Expression  & arg );

    Operator& operator/=( const double      & arg );
    Operator& operator/=( const Expression  & arg );


    Expression operator+( const double        & arg ) const;
    Expression operator+( const DVector        & arg ) const;
    Expression operator+( const DMatrix        & arg ) const;
    Expression operator+( const Operator& arg ) const;
    Expression operator+( const Expression    & arg ) const;

    friend Expression operator+( const double & arg1, const Operator& arg2 );
    friend Expression operator+( const DVector & arg1, const Operator& arg2 );
    friend Expression operator+( const DMatrix & arg1, const Operator& arg2 );

    Expression operator-( const double          & arg ) const;
    Expression operator-( const DVector          & arg ) const;
    Expression operator-( const DMatrix          & arg ) const;
    Expression operator-( const Operator  & arg ) const;
    Expression operator-( const Expression      & arg ) const;

    Expression operator-( ) const;

    friend Expression operator-( const double & arg1, const Operator& arg2 );
    friend Expression operator-( const DVector & arg1, const Operator& arg2 );
    friend Expression operator-( const DMatrix & arg1, const Operator& arg2 );

    Expression operator*( const double         & arg ) const;
    Expression operator*( const DVector         & arg ) const;
    Expression operator*( const DMatrix         & arg ) const;
    Expression operator*( const Operator & arg ) const;
    Expression operator*( const Expression     & arg ) const;

    friend Expression operator*( const double& arg1, const Operator& arg2 );
    friend Expression operator*( const DVector& arg1, const Operator& arg2 );
    friend Expression operator*( const DMatrix& arg1, const Operator& arg2 );

    Expression operator/( const double         & arg ) const;
    Expression operator/( const Operator & arg ) const;
    Expression operator/( const Expression     & arg ) const;


    friend Expression operator/( const double& arg1, const Operator& arg2 );
    friend Expression operator/( const DVector& arg1, const Operator& arg2 );
    friend Expression operator/( const DMatrix& arg1, const Operator& arg2 );

    ConstraintComponent operator<=( const double& ub ) const;
    ConstraintComponent operator>=( const double& lb ) const;
    ConstraintComponent operator==( const double&  b ) const;

    ConstraintComponent operator<=( const DVector& ub ) const;
    ConstraintComponent operator>=( const DVector& lb ) const;
    ConstraintComponent operator==( const DVector&  b ) const;

    ConstraintComponent operator<=( const VariablesGrid& ub ) const;
    ConstraintComponent operator>=( const VariablesGrid& lb ) const;
    ConstraintComponent operator==( const VariablesGrid&  b ) const;

    friend ConstraintComponent operator<=( double lb, const Operator &arg );
    friend ConstraintComponent operator==( double  b, const Operator &arg );
    friend ConstraintComponent operator>=( double ub, const Operator &arg );

    friend ConstraintComponent operator<=( DVector lb, const Operator &arg );
    friend ConstraintComponent operator==( DVector  b, const Operator &arg );
    friend ConstraintComponent operator>=( DVector ub, const Operator &arg );

    friend ConstraintComponent operator<=( VariablesGrid lb, const Operator &arg );
    friend ConstraintComponent operator==( VariablesGrid  b, const Operator &arg );
    friend ConstraintComponent operator>=( VariablesGrid ub, const Operator &arg );


    virtual returnValue evaluate( int     number    ,
                                  double *x         ,
                                  double *result      ) = 0;


    virtual returnValue evaluate( EvaluationBase *x ) = 0;
        
        
     virtual Operator* differentiate( int index      ) = 0;



     virtual Operator* AD_forward( int                dim      , 
                                     VariableType      *varType  , 
                                     int               *component, 
                                     Operator       **seed     , 
                                     int                &nNewIS  , 
                                     TreeProjection ***newIS     ) = 0;



    virtual returnValue AD_backward( int           dim      , 
                                     VariableType *varType  , 
                                     int          *component, 
                                     Operator     *seed     , 
                                     Operator    **df       , 
                                     int           &nNewIS  , 
                                     TreeProjection ***newIS   ) = 0;

    
    
     virtual returnValue AD_symmetric( int            dim       , 
                                      VariableType  *varType   , 
                                      int           *component , 
                                      Operator      *l         , 
                                      Operator     **S         , 
                                      int            dimS      , 
                                      Operator     **dfS       , 
                                      Operator     **ldf       , 
                                      Operator     **H         , 
                                      int            &nNewLIS  , 
                                      TreeProjection ***newLIS , 
                                      int            &nNewSIS  , 
                                      TreeProjection ***newSIS , 
                                      int            &nNewHIS  , 
                                      TreeProjection ***newHIS    ) = 0;



     virtual Operator* substitute( int   index            ,
                                     const Operator *sub  ) = 0;



     virtual NeutralElement isOneOrZero() const = 0;



     virtual BooleanType isDependingOn( VariableType var ) const = 0;



     virtual BooleanType isDependingOn( int           dim      ,    
                                          VariableType *varType  ,    
                                          int          *component,    
                                          BooleanType   *implicit_dep  ) = 0;




     virtual BooleanType isLinearIn( int           dim      ,    
                                       VariableType *varType  ,    
                                       int          *component,    
                                       BooleanType  *implicit_dep   ) = 0;



     virtual BooleanType isPolynomialIn( int           dim      ,    
                                           VariableType *varType  ,    
                                           int          *component,    
                                           BooleanType  *implicit_dep   ) = 0;



     virtual BooleanType isRationalIn( int           dim      ,    
                                         VariableType *varType  ,    
                                         int          *component,    
                                         BooleanType  *implicit_dep   ) = 0;

     virtual BooleanType isSmooth( ) const = 0;


     virtual MonotonicityType getMonotonicity( ) = 0;



     virtual CurvatureType getCurvature( ) = 0;



     virtual returnValue setMonotonicity( MonotonicityType monotonicity_ ) = 0;




     virtual returnValue setCurvature( CurvatureType curvature_  ) = 0;



     virtual returnValue AD_forward( int     number  ,
                                     double *x       ,
                                     double *seed    ,
                                     double *f       ,
                                     double *df        ) = 0;



     virtual returnValue AD_forward( int     number  ,
                                     double *seed    ,
                                     double *df        ) = 0;



    // IMPORTANT REMARK FOR AD_BACKWARD: run evaluate first to define
    //                                   the point x and to compute f.

     virtual returnValue AD_backward( int    number ,
                                      double seed   ,
                                      double  *df   ) = 0;



     virtual returnValue AD_forward2( int    number  ,
                                      double *seed1  ,
                                      double *seed2  ,
                                      double *df     ,
                                      double *ddf    ) = 0;



    // IMPORTANT REMARK FOR AD_BACKWARD2: run AD_forward first to define
    //                                    the point x and to compute f and df.

     virtual returnValue AD_backward2( int    number ,
                                       double seed1  ,
                                       double seed2  ,
                                       double   *df  ,
                                       double  *ddf     ) = 0;

     virtual std::ostream& print(std::ostream& stream) const = 0;


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

     virtual Operator* clone() const = 0;


     virtual TreeProjection* cloneTreeProjection() const;



     virtual returnValue clearBuffer() = 0;



     virtual returnValue enumerateVariables( SymbolicIndexList *indexList ) = 0;



     virtual OperatorName getName() = 0;


     //virtual int getVariableIndex( ) const;


     virtual int getGlobalIndex( ) const;


     virtual BooleanType isVariable( VariableType &varType,
                                     int &component          ) const = 0;


     virtual returnValue loadIndices( SymbolicIndexList *indexList  ) = 0;



     virtual double getValue() const;



     virtual Operator* passArgument() const;


    virtual BooleanType isSymbolic() const = 0;


    int nCount;



    virtual returnValue setVariableExportName(  const VariableType &_type,
                                                                                        const std::vector< std::string >& _name
                                                                                        );


    
    
    virtual Operator* myProd(Operator* a,Operator* b);
    virtual Operator* myAdd (Operator* a,Operator* b);
    virtual Operator* mySubtract (Operator* a,Operator* b);
    virtual Operator* myPower (Operator* a,Operator* b);
    virtual Operator* myPowerInt (Operator* a,int b);
    virtual Operator* myLogarithm (Operator* a);


    virtual BooleanType isTrivial() const;


    virtual returnValue initDerivative();
    
    
//
//  PROTECTED FUNCTIONS:
//

protected:


    virtual TreeProjection* convert2TreeProjection( Operator* a ) const; // Caution: a is deleted inside...
    
    returnValue ADsymCommon(    Operator     *a  ,
                                TreeProjection &da ,
                                TreeProjection &dda,
                                int            dim       , 
                                VariableType  *varType   , 
                                int           *component , 
                                Operator      *l         , 
                                Operator     **S         , 
                                int            dimS      , 
                                Operator     **dfS       , 
                                Operator     **ldf       , 
                                Operator     **H         , 
                                int            &nNewLIS  , 
                                TreeProjection ***newLIS , 
                                int            &nNewSIS  , 
                                TreeProjection ***newSIS , 
                                int            &nNewHIS  , 
                                TreeProjection ***newHIS    );

        
    returnValue ADsymCommon2(     Operator       *a  ,
                                                                  Operator       *b  ,
                                  TreeProjection &dx ,
                                  TreeProjection &dy ,
                                  TreeProjection &dxx,
                                  TreeProjection &dxy,
                                  TreeProjection &dyy,
                                  int            dim       , 
                                  VariableType  *varType   , 
                                  int           *component , 
                                  Operator      *l         , 
                                  Operator     **S         , 
                                  int            dimS      , 
                                  Operator     **dfS       , 
                                  Operator     **ldf       , 
                                  Operator     **H         , 
                                  int            &nNewLIS  , 
                                  TreeProjection ***newLIS , 
                                  int            &nNewSIS  , 
                                  TreeProjection ***newSIS , 
                                  int            &nNewHIS  , 
                                  TreeProjection ***newHIS    );

    //
    //  PROTECTED MEMBERS:
    //

    protected:

        BooleanType  initialized;


};


CLOSE_NAMESPACE_ACADO



#endif