examples/code_generation/mpc_mhe/getting_started_export/qpoases/INCLUDE/QProblemB.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_QPROBLEMB_HPP
#define QPOASES_QPROBLEMB_HPP


#include <Bounds.hpp>



class SolutionAnalysis;

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

                QProblemB(      int _nV                                         
                                        );

                QProblemB(      const QProblemB& rhs    
                                        );

                ~QProblemB( );

                QProblemB& operator=(   const QProblemB& rhs    
                                                                );


                returnValue reset( );


                returnValue init(       const real_t* const _H,                 
                                                        const real_t* const _g,                 
                                                        const real_t* const _lb,                
                                                        const real_t* const _ub,                
                                                        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,     
                                                                int& nWSR,                                      
                                                                real_t* const cputime           
                                                                );


                inline returnValue getH(        real_t* const _H        
                                                                        ) const;

                inline returnValue getG(        real_t* const _g        
                                                                        ) const;

                inline returnValue getLB(       real_t* const _lb       
                                                                        ) const;

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

                inline returnValue getUB(       real_t* const _ub       
                                                                        ) const;

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


                inline returnValue getBounds(   Bounds* const _bounds   
                                                                                ) const;


                inline int getNV( ) const;

                inline int getNFR( );

                inline int getNFX( );

                inline int getNFV( ) const;

                int getNZ( );


                real_t getObjVal( ) const;

                real_t getObjVal(       const real_t* const _x  
                                                        ) const;

                returnValue getPrimalSolution(  real_t* const xOpt                      
                                                                                ) const;

                returnValue getDualSolution(    real_t* const yOpt      
                                                                                ) const;


                inline QProblemStatus getStatus( ) const;


                inline BooleanType isInitialised( ) const;

                inline BooleanType isSolved( ) const;

                inline BooleanType isInfeasible( ) const;

                inline BooleanType isUnbounded( ) const;


                inline PrintLevel getPrintLevel( ) const;

                returnValue setPrintLevel(      PrintLevel _printlevel  
                                                                        );


                inline HessianType getHessianType( ) const;

                inline returnValue setHessianType(      HessianType _hessianType 
                                                                                        );


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

                returnValue setupSubjectToType( );

                returnValue setupCholeskyDecomposition( );


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


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

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

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

                returnValue setupAuxiliaryQPgradient( );

                returnValue setupAuxiliaryQPbounds( BooleanType useRelaxation   
                                                                                        );


                returnValue addBound(   int number,                                     
                                                                SubjectToStatus B_status,       
                                                                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 hotstart_determineDataShift(const int* const FX_idx,        
                                                                                                const real_t* const g_new,      
                                                                                                const real_t* const lb_new,     
                                                                                                const real_t* const ub_new,     
                                                                                                real_t* const delta_g,          
                                                                                                real_t* const delta_lb,         
                                                                                                real_t* const delta_ub,         
                                                                                                BooleanType& Delta_bB_isZero
                                                                                                );


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


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


                inline returnValue setH(        const real_t* const H_new       
                                                                        );

                inline returnValue setG(        const real_t* const g_new       
                                                                        );

                inline returnValue setLB(       const real_t* const lb_new      
                                                                        );

                inline returnValue setLB(       int number,             
                                                                        real_t value    
                                                                        );

                inline returnValue setUB(       const real_t* const ub_new      
                                                                        );

                inline returnValue setUB(       int number,             
                                                                        real_t value    
                                                                        );


                inline void computeGivens(      real_t xold,    
                                                                        real_t yold,    
                                                                        real_t& xnew,   
                                                                        real_t& ynew,   
                                                                        real_t& c,              
                                                                        real_t& s               
                                                                        ) const;

                inline void applyGivens(        real_t c,               
                                                                        real_t s,               
                                                                        real_t xold,    
                                                                        real_t yold,    
                                                                        real_t& xnew,   
                                                                        real_t& ynew    
                                                                        ) const;


        /*
         *      PRIVATE MEMBER FUNCTIONS
         */
        private:
                returnValue hotstart_determineStepDirection(const int* const FR_idx,            
                                                                                                        const int* const FX_idx,                
                                                                                                        const real_t* const delta_g,    
                                                                                                        const real_t* const delta_lb,   
                                                                                                        const real_t* const delta_ub,   
                                                                                                        BooleanType Delta_bB_isZero,    
                                                                                                        real_t* const delta_xFX,                
                                                                                                        real_t* const delta_xFR,                
                                                                                                        real_t* const delta_yFX                 
                                                                                                        );

                returnValue hotstart_determineStepLength(       const int* const FR_idx,                
                                                                                                        const int* const FX_idx,                
                                                                                                        const real_t* const delta_lb,   
                                                                                                        const real_t* const delta_ub,   
                                                                                                        const real_t* const delta_xFR,  
                                                                                                        const real_t* const delta_yFX,  
                                                                                                        int& BC_idx,                                    
                                                                                                        SubjectToStatus& BC_status              
                                                                                                        );

                returnValue hotstart_performStep(       const int* const FR_idx,                        
                                                                                        const int* const FX_idx,                        
                                                                                        const real_t* const delta_g,            
                                                                                        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_yFX,          
                                                                                        int BC_idx,                                             
                                                                                        SubjectToStatus BC_status                       
                                                                                        );


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

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

                #endif  /* PC_DEBUG */


                returnValue checkKKTconditions( );


        /*
         *      PROTECTED MEMBER VARIABLES
         */
        protected:
                real_t H[NVMAX*NVMAX];          
                real_t g[NVMAX];                        
                real_t lb[NVMAX];                       
                real_t ub[NVMAX];                       
                Bounds bounds;                          
                real_t R[NVMAX*NVMAX];          
                real_t x[NVMAX];                        
                real_t y[NVMAX+NCMAX];          
                real_t tau;                                     
                QProblemStatus status;          
                BooleanType infeasible;         
                BooleanType unbounded;          
                HessianType hessianType;        
                PrintLevel printlevel;          
                int count;                                      
};


#include <QProblemB.ipp>

#endif  /* QPOASES_QPROBLEMB_HPP */


/*
 *      end of file
 */