function_.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__HPP
#define ACADO_TOOLKIT_FUNCTION__HPP


#include <acado/function/function_evaluation_tree.hpp>


BEGIN_NAMESPACE_ACADO


class EvaluationPoint;
template <typename T> class TevaluationPoint;


class Function{

//
// PUBLIC MEMBER FUNCTIONS:
//

public:

    Function();

    Function( const Function& rhs );

    virtual ~Function( );

    Function& operator=( const Function& rhs );


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

    Function& operator<<( const double &arg );

    Function& operator<<( const DVector& arg );

    Function& operator<<( const DMatrix& arg );

        Function operator()(    uint idx
                                                        ) const;


    returnValue getExpression( Expression& expression ) const;


        returnValue reset( );


    inline int getDim () const;


    inline int getN   () const;

    int getN    (VariableType &variableType_) const;

    int getNX    () const;

    int getNXA   () const;

    int getNDX   () const;

    int getNU   () const;

    int getNUI  () const;

    int getNP   () const;

    int getNPI  () const;

    int getNW  () const;

    int getNT  () const;

    int getNOD() const;


    int index( VariableType variableType_, int index_ ) const;


    double scale( VariableType variableType_, int index_ ) const;


    int getNumberOfVariables() const;

    Operator* getExpression(    uint componentIdx
                                                                ) const;


    DVector evaluate( const EvaluationPoint &x         ,
                     const int             &number = 0  );


    inline DVector operator()( const EvaluationPoint &x         ,
                              const int             &number = 0  );



    template <typename T> Tmatrix<T> evaluate( const TevaluationPoint<T> &x );
        
        
        
    returnValue evaluate( int     number    ,
                          double *x         ,
                          double *_result      );



     returnValue substitute( VariableType variableType_,
                             int index_      ,
                             double sub_      );



     NeutralElement isOneOrZero();



     BooleanType isDependingOn( const Expression     &variable );



     BooleanType isLinearIn( const Expression     &variable );



     BooleanType isPolynomialIn( const Expression     &variable );




     BooleanType isRationalIn( const Expression     &variable );



     BooleanType isNondecreasing();


     BooleanType isNonincreasing();

     BooleanType isConstant();

     BooleanType isAffine();


     BooleanType isConvex();


     BooleanType isConcave();



    DVector AD_forward( const EvaluationPoint &x         ,
                       const int             &number = 0  );



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



     returnValue AD_backward( const    DVector &seed      ,
                              EvaluationPoint &df        ,
                              const    int    &number = 0  );


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



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



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


    returnValue jacobian(DMatrix &x);
    //returnValue jacobian(DMatrix &x,DMatrix &p=emptyMatrix,DMatrix &u=emptyMatrix,DMatrix &w=emptyMatrix);

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

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

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

     returnValue exportCode(    std::ostream& stream,
                                                                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;

     returnValue clearBuffer();



     returnValue setScale( double *scale_ );


     inline BooleanType isSymbolic() const;


     inline BooleanType ADisSupported() const;


     inline returnValue setMemoryOffset( int memoryOffset_ );

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

     std::string getGlobalExportVariableName( ) const;

     unsigned getGlobalExportVariableSize( ) const;

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

protected:

    FunctionEvaluationTree evaluationTree;
    int                    memoryOffset  ;
        
        double* result;
};


template <typename T> Tmatrix<T> Function::evaluate( const TevaluationPoint<T> &x ){

        Tmatrix<T> Tresult(getDim());
        evaluationTree.evaluate( x.getEvaluationPointer(), &Tresult );
        return Tresult;
}


CLOSE_NAMESPACE_ACADO



#include <acado/function/function.ipp>


#endif  // ACADO_TOOLKIT_FUNCTION__HPP

/*
 *   end of file
 */