tree_projection.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_TREE_PROJECTION_HPP
#define ACADO_TOOLKIT_TREE_PROJECTION_HPP


#include <acado/symbolic_operator/symbolic_operator_fwd.hpp>


BEGIN_NAMESPACE_ACADO


class Expression;
class ConstraintComponent;


class TreeProjection : public Projection{

public:

    TreeProjection();

    TreeProjection( const std::string& name_ );

    TreeProjection( const TreeProjection &arg );

    virtual ~TreeProjection();

    Operator& operator=( const Operator &arg );


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



     virtual TreeProjection* clone() const;


     virtual TreeProjection* cloneTreeProjection() const;



     virtual returnValue loadIndices( SymbolicIndexList *indexList );


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


     returnValue clearStaticCounters();



     Operator *getArgument() const;



     virtual NeutralElement isOneOrZero() const;



     virtual Operator* passArgument() const;


     virtual BooleanType isTrivial() const;

     virtual returnValue initDerivative();

//
//  PROTECTED FUNCTIONS:
//

protected:



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



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


     virtual 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 void copy( const Projection &arg );


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

    //
    //  PROTECTED MEMBERS:
    //
    protected:

        Operator   *argument;
        static int  count   ;
        NeutralElement    ne;
};


static TreeProjection emptyTreeProjection;


CLOSE_NAMESPACE_ACADO



#endif