unary_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_UNARY_OPERATOR_HPP
#define ACADO_TOOLKIT_UNARY_OPERATOR_HPP


#include <acado/symbolic_operator/symbolic_operator_fwd.hpp>


BEGIN_NAMESPACE_ACADO


class UnaryOperator : public SmoothOperator{

public:

    UnaryOperator();

    UnaryOperator( Operator *_argument );

    UnaryOperator( const UnaryOperator &arg );

    virtual ~UnaryOperator();

    UnaryOperator& operator=( const UnaryOperator &arg );


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


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


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


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

    
    
     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    );
       

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



    virtual NeutralElement isOneOrZero() const;



    virtual BooleanType isDependingOn( VariableType var ) const;


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


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


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


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


    virtual MonotonicityType getMonotonicity( );


    virtual CurvatureType getCurvature( );


    virtual returnValue setMonotonicity( MonotonicityType monotonicity_ );


    virtual returnValue setCurvature( CurvatureType curvature_  );


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


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


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


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


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



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


    virtual Operator* clone() const = 0;


    virtual returnValue clearBuffer();



    virtual returnValue enumerateVariables( SymbolicIndexList *indexList );



    virtual OperatorName getName();


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


    virtual returnValue loadIndices( SymbolicIndexList *indexList );


    virtual BooleanType isSymbolic() const;


//
//  PROTECTED FUNCTIONS:
//

protected:


     Operator* ADforwardProtected( int                dim      , 
                                             VariableType      *varType  , 
                                             int               *component, 
                                             Operator       **seed     , 
                                             int                &nNewIS  , 
                                             TreeProjection ***newIS     );



     returnValue ADbackwardProtected( int            dim      , 
                                              VariableType  *varType  , 
                                              int           *component, 
                                              Operator      *seed     , 
                                              Operator     **df       , 
                                              int            &nNewIS  , 
                                              TreeProjection ***newIS     );


     returnValue ADsymmetricProtected( 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    );


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


  //  PROTECTED MEMBERS:
  // -------------------------
  protected:

    Operator  *derivative;              
    Operator  *derivative2;             
    Operator *argument        ;     
    Operator *dargument       ;     
    double   *argument_result ;     
    double   *dargument_result;     
    int       bufferSize      ;     
    CurvatureType     curvature   ;
    MonotonicityType  monotonicity;
    OperatorName      operatorName;
    std::string       cName       ;

    double (*fcn)(double);
    double (*dfcn)(double);
    double (*ddfcn)(double);
};


CLOSE_NAMESPACE_ACADO



#endif