examples/code_generation/mpc_mhe/getting_started_export/qpoases/INCLUDE/QProblem.hpp

Go to the documentation of this file.

/*
 *      This file is part of qpOASES.
 *
 *      qpOASES -- An Implementation of the Online Active Set Strategy.
 *      Copyright (C) 2007-2008 by Hans Joachim Ferreau et al. All rights reserved.
 *
 *      qpOASES 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 2.1 of the License, or (at your option) any later version.
 *
 *      qpOASES 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 qpOASES; if not, write to the Free Software
 *      Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */


#ifndef QPOASES_QPROBLEM_HPP
#define QPOASES_QPROBLEM_HPP


#include <QProblemB.hpp>
#include <Constraints.hpp>
#include <CyclingManager.hpp>


class QProblem : public QProblemB
{
        /* allow SolutionAnalysis class to access private members */
        friend class SolutionAnalysis;
        
        /*
         *      PUBLIC MEMBER FUNCTIONS
         */
        public:
                QProblem( );

                QProblem(       int _nV,                                        
                                        int _nC                                         
                                        );

                QProblem(       const QProblem& rhs     
                                        );

                ~QProblem( );

                QProblem& operator=(    const QProblem& rhs             
                                                                );


                returnValue reset( );


                returnValue init(       const real_t* const _H,                 
                                                        const real_t* const _g,                 
                                                        const real_t* const _A,                 
                                                        const real_t* const _lb,                
                                                        const real_t* const _ub,                
                                                        const real_t* const _lbA,               
                                                        const real_t* const _ubA,               
                                                        int& nWSR,                                              
                                                        const real_t* const yOpt = 0,   
                                                        real_t* const cputime = 0               
                                                        );


                returnValue hotstart(   const real_t* const g_new,              
                                                                const real_t* const lb_new,             
                                                                const real_t* const ub_new,             
                                                                const real_t* const lbA_new,    
                                                                const real_t* const ubA_new,    
                                                                int& nWSR,                                              
                                                                real_t* const cputime                   
                                                                );


                inline returnValue getA(        real_t* const _A        
                                                                        ) const;

                inline returnValue getA(        int number,                     
                                                                        real_t* const row       
                                                                        ) const;

                inline returnValue getLBA(      real_t* const _lbA      
                                                                        ) const;

                inline returnValue getLBA(      int number,             
                                                                        real_t& value   
                                                                        ) const;

                inline returnValue getUBA(      real_t* const _ubA      
                                                                        ) const;

                inline returnValue getUBA(      int number,             
                                                                        real_t& value   
                                                                        ) const;


                inline returnValue getConstraints(      Constraints* const _constraints 
                                                                                        ) const;


                inline int getNC( ) const;

                inline int getNEC( ) const;

                inline int getNAC( );

                inline int getNIAC( );

                int getNZ( );


                returnValue getDualSolution(    real_t* const yOpt      
                                                                                ) const;


        /*
         *      PROTECTED MEMBER FUNCTIONS
         */
        protected:
                returnValue setupSubjectToType( );

                returnValue setupCholeskyDecompositionProjected( );

                returnValue setupTQfactorisation( );


                returnValue solveInitialQP(     const real_t* const xOpt,                                               
                                                                        const real_t* const yOpt,                                               
                                                                        const Bounds* const guessedBounds,                              
                                                                        const Constraints* const guessedConstraints,    
                                                                        int& nWSR,                                                                              
                                                                        real_t* const cputime                                                   
                                                                        );

                returnValue obtainAuxiliaryWorkingSet(  const real_t* const xOpt,                                               
                                                                                                const real_t* const yOpt,                                               
                                                                                                const Bounds* const guessedBounds,                              
                                                                                                const Constraints* const guessedConstraints,    
                                                                                                Bounds* auxiliaryBounds,                                                
                                                                                                Constraints* auxiliaryConstraints                               
                                                                                                ) const;

                returnValue setupAuxiliaryWorkingSet(   const Bounds* const auxiliaryBounds,                    
                                                                                                const Constraints* const auxiliaryConstraints,  
                                                                                                BooleanType setupAfresh                                                 
                                                                                                );

                returnValue setupAuxiliaryQPsolution(   const real_t* const xOpt,                       
                                                                                                const real_t* const yOpt                        
                                                                                                );

                returnValue setupAuxiliaryQPgradient( );

                returnValue setupAuxiliaryQPbounds(     const Bounds* const auxiliaryBounds,                    
                                                                                        const Constraints* const auxiliaryConstraints,  
                                                                                        BooleanType useRelaxation                                               
                                                                                        );


                returnValue addConstraint(      int number,                                     
                                                                        SubjectToStatus C_status,       
                                                                        BooleanType updateCholesky      
                                                                        );

                returnValue addConstraint_checkLI(      int number                      
                                                                                        );

                returnValue addConstraint_ensureLI(     int number,                                     
                                                                                        SubjectToStatus C_status        
                                                                                        );

                returnValue addBound(   int number,                                     
                                                                SubjectToStatus B_status,       
                                                                BooleanType updateCholesky      
                                                                );

                returnValue addBound_checkLI(   int number                      
                                                                                );

                returnValue addBound_ensureLI(  int number,                                     
                                                                                SubjectToStatus B_status        
                                                                                );

                returnValue removeConstraint(   int number,                                     
                                                                                BooleanType updateCholesky      
                                                                                );

                returnValue removeBound(        int number,                                     
                                                                        BooleanType updateCholesky      
                                                                        );


                returnValue backsolveR( const real_t* const b,  
                                                                BooleanType transposed, 
                                                                real_t* const a                 
                                                                );

                returnValue backsolveR( const real_t* const b,          
                                                                BooleanType transposed,         
                                                                BooleanType removingBound,      
                                                                real_t* const a                         
                                                                );


                returnValue backsolveT( const real_t* const b,  
                                                                BooleanType transposed, 
                                                                real_t* const a                 
                                                                );


                returnValue hotstart_determineDataShift(const int* const FX_idx,        
                                                                                                const int* const AC_idx,        
                                                                                                const real_t* const g_new,      
                                                                                                const real_t* const lbA_new,
                                                                                                const real_t* const ubA_new,
                                                                                                const real_t* const lb_new,     
                                                                                                const real_t* const ub_new,     
                                                                                                real_t* const delta_g,          
                                                                                                real_t* const delta_lbA,        
                                                                                                real_t* const delta_ubA,        
                                                                                                real_t* const delta_lb,         
                                                                                                real_t* const delta_ub,         
                                                                                                BooleanType& Delta_bC_isZero,
                                                                                                BooleanType& Delta_bB_isZero
                                                                                                );

                returnValue hotstart_determineStepDirection(const int* const FR_idx,            
                                                                                                        const int* const FX_idx,                
                                                                                                        const int* const AC_idx,                
                                                                                                        const real_t* const delta_g,    
                                                                                                        const real_t* const delta_lbA,  
                                                                                                        const real_t* const delta_ubA,  
                                                                                                        const real_t* const delta_lb,   
                                                                                                        const real_t* const delta_ub,   
                                                                                                        BooleanType Delta_bC_isZero,    
                                                                                                        BooleanType Delta_bB_isZero,    
                                                                                                        real_t* const delta_xFX,                
                                                                                                        real_t* const delta_xFR,                
                                                                                                        real_t* const delta_yAC,                
                                                                                                        real_t* const delta_yFX                 
                                                                                                        );

                returnValue hotstart_determineStepLength(       const int* const FR_idx,                        
                                                                                                        const int* const FX_idx,                        
                                                                                                        const int* const AC_idx,                        
                                                                                                        const int* const IAC_idx,                       
                                                                                                        const real_t* const delta_lbA,          
                                                                                                        const real_t* const delta_ubA,          
                                                                                                        const real_t* const delta_lb,           
                                                                                                        const real_t* const delta_ub,           
                                                                                                        const real_t* const delta_xFX,          
                                                                                                        const real_t* const delta_xFR,          
                                                                                                        const real_t* const delta_yAC,          
                                                                                                        const real_t* const delta_yFX,          
                                                                                                        real_t* const delta_Ax,                         
                                                                                                        int& BC_idx,                                            
                                                                                                        SubjectToStatus& BC_status,                     
                                                                                                        BooleanType& BC_isBound                         
                                                                                                        );

                returnValue hotstart_performStep(       const int* const FR_idx,                        
                                                                                        const int* const FX_idx,                        
                                                                                        const int* const AC_idx,                        
                                                                                        const int* const IAC_idx,                       
                                                                                        const real_t* const delta_g,            
                                                                                        const real_t* const delta_lbA,          
                                                                                        const real_t* const delta_ubA,          
                                                                                        const real_t* const delta_lb,           
                                                                                        const real_t* const delta_ub,           
                                                                                        const real_t* const delta_xFX,          
                                                                                        const real_t* const delta_xFR,          
                                                                                        const real_t* const delta_yAC,          
                                                                                        const real_t* const delta_yFX,          
                                                                                        const real_t* const delta_Ax,           
                                                                                        int BC_idx,                                             
                                                                                        SubjectToStatus BC_status,                      
                                                                                        BooleanType BC_isBound                          
                                                                                        );


                BooleanType areBoundsConsistent(        const real_t* const delta_lb,   
                                                                                        const real_t* const delta_ub,   
                                                                                        const real_t* const delta_lbA,  
                                                                                        const real_t* const delta_ubA   
                                                                                        ) const;


                returnValue setupQPdata(        const real_t* const _H,         
                                                                        const real_t* const _g,         
                                                                        const real_t* const _A,         
                                                                        const real_t* const _lb,        
                                                                        const real_t* const _ub,        
                                                                        const real_t* const _lbA,       
                                                                        const real_t* const _ubA        
                                                                        );


                #ifdef PC_DEBUG  /* Define print functions only for debugging! */

                returnValue printIteration(     int iteration,                          
                                                                        int BC_idx,                             
                                                                        SubjectToStatus BC_status,      
                                                                        BooleanType BC_isBound          
                                                                        );

                returnValue printIteration(     int iteration,                          
                                                                        int BC_idx,                             
                                                                        SubjectToStatus BC_status       
                                                                        );

                #endif  /* PC_DEBUG */


                returnValue checkKKTconditions( );


                inline returnValue setA(        const real_t* const A_new       
                                                                        );

                inline returnValue setA(        int number,                                     
                                                                        const real_t* const value       
                                                                        );


                inline returnValue setLBA(      const real_t* const lbA_new     
                                                                        );

                inline returnValue setLBA(      int number,             
                                                                        real_t value    
                                                                        );

                inline returnValue setUBA(      const real_t* const ubA_new     
                                                                        );

                inline returnValue setUBA(      int number,             
                                                                        real_t value    
                                                                        );


        /*
         *      PROTECTED MEMBER VARIABLES
         */
        protected:
                real_t A[NCMAX_ALLOC*NVMAX];            
                real_t lbA[NCMAX_ALLOC];                        
                real_t ubA[NCMAX_ALLOC];                        
                Constraints constraints;                        
                real_t T[NVMAX*NVMAX];                          
                real_t Q[NVMAX*NVMAX];                          
                int sizeT;                                                      
                real_t Ax[NCMAX_ALLOC];                         
                CyclingManager cyclingManager;          
};


#include <QProblem.ipp>

#endif  /* QPOASES_QPROBLEM_HPP */


/*
 *      end of file
 */