function_evaluation_tree.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_FUNCTION_EVALUATION_TREE_HPP
#define ACADO_TOOLKIT_FUNCTION_EVALUATION_TREE_HPP

#include <acado/symbolic_expression/expression.hpp>
#include <acado/symbolic_operator/evaluation_template.hpp>
#include <acado/symbolic_operator/symbolic_index_list.hpp>

BEGIN_NAMESPACE_ACADO

class FunctionEvaluationTree
{

//
// PUBLIC MEMBER FUNCTIONS:
//
public:

    FunctionEvaluationTree( );

    FunctionEvaluationTree( const FunctionEvaluationTree& arg );

    virtual ~FunctionEvaluationTree( );

    FunctionEvaluationTree& operator=( const FunctionEvaluationTree& arg );

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


    virtual int getDim () const;


    virtual int getN   () const;


    virtual int getNX    () const;

    virtual int getNXA   () const;

    virtual int getNDX   () const;


    virtual int getNU   () const;

    virtual int getNUI  () const;

    virtual int getNP   () const;

    virtual int getNPI  () const;

    virtual int getNW  () const;

    virtual int getNT  () const;

    virtual int getNOD  () const;


    virtual int index( VariableType variableType_, int index_ ) const;


    virtual double scale( VariableType variableType_, int index_ ) const;


    virtual int getNumberOfVariables() const;


    virtual Operator* getExpression(    uint componentIdx
                                                                                ) const;


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



    template <typename T> returnValue evaluate( Tmatrix<T> *x, Tmatrix<T> *result );
        
        
        
    virtual returnValue evaluate( double *x         ,
                                  double *result    ,
                                  PrintLevel printL     );




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



     FunctionEvaluationTree* differentiate( int index  );



     virtual FunctionEvaluationTree substitute( VariableType variableType_,
                                             int index_      ,
                                             double sub_     );


     virtual NeutralElement isOneOrZero();



     virtual BooleanType isDependingOn( const Expression     &variable );


     virtual BooleanType isLinearIn( const Expression     &variable );


     virtual BooleanType isPolynomialIn( const Expression     &variable );


     virtual BooleanType isRationalIn( const Expression     &variable );


     virtual MonotonicityType getMonotonicity( );



     virtual CurvatureType getCurvature( );



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



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



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


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

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



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




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



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


     returnValue C_print(       std::ostream& stream = std::cout,
                                                        const char *fcnName = "ACADOfcn",
                                                        const char *realString = "double"
                                                        ) const;

     returnValue exportForwardDeclarations(     std::ostream& stream = std::cout,
                                                                                        const char *fcnName = "ACADOfcn",
                                                                                        const char *realString = "double"
                                                                                        ) const;

     returnValue exportCode(    std::ostream& stream = std::cout,
                                                                const char *fcnName = "ACADOfcn",
                                                                const char *realString = "double",
                                                                uint       _numX = 0,
                                                                uint       _numXA = 0,
                                                                uint       _numU = 0,
                                                                uint       _numP = 0,
                                                                uint       _numDX = 0,
                                                                uint       _numOD = 0,
                                                                bool       allocateMemory = true,
                                                                bool       staticMemory   = false
                                                                ) const;

     virtual returnValue clearBuffer();


     virtual returnValue makeImplicit();
     virtual returnValue makeImplicit( int dim_ );


     virtual BooleanType isSymbolic() const;


     virtual returnValue setScale( double *scale_ );

     virtual returnValue getExpression( Expression& expression ) const;

     returnValue setGlobalExportVariableName(const std::string& _name);

     std::string getGlobalExportVariableName() const;

     unsigned getGlobalExportVariableSize() const;

     //
     // DATA MEMBERS:
     //
protected:

     Operator           **f        ;   
     Operator           **sub      ;   
     int                 *lhs_comp ;   
     SymbolicIndexList   *indexList;   
     int                  dim      ;   
     int                  n        ;   
     Expression           safeCopy ;

     std::string                globalExportVariableName;
};


template <typename T> returnValue FunctionEvaluationTree::evaluate( Tmatrix<T> *x,
                                                                                                                                        Tmatrix<T> *result ){

    int run1;

        EvaluationTemplate<T> y(x);
        
        for( run1 = 0; run1 < n; run1++ ){
                sub[run1]->evaluate(&y);
                x->operator()(indexList->index(VT_INTERMEDIATE_STATE,lhs_comp[run1])) = y.res;
        }
        
        for( run1 = 0; run1 < dim; run1++ ){
                f[run1]->evaluate(&y);
                result->operator()(run1) = y.res;
        }

    return SUCCESSFUL_RETURN;
}



CLOSE_NAMESPACE_ACADO



#include <acado/function/function_evaluation_tree.ipp>


#endif  // ACADO_TOOLKIT_FUNCTION_HPP

// end of file.