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-2011 by Hans Joachim Ferreau, Andreas Potschka,
 *      Christian Kirches 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 <qpOASES/Flipper.hpp>
#include <qpOASES/Options.hpp>
#include <qpOASES/Matrices.hpp>


BEGIN_NAMESPACE_QPOASES


class SolutionAnalysis;

class QProblemB
{
        /* allow SolutionAnalysis class to access private members */
        friend class SolutionAnalysis;

        /*
         *      PUBLIC MEMBER FUNCTIONS
         */
        public:
                QProblemB( );

                QProblemB(      int _nV,                                                                
                                        HessianType _hessianType = HST_UNKNOWN  
                                        );

                QProblemB(      const QProblemB& rhs    
                                        );

                virtual ~QProblemB( );

                QProblemB& operator=(   const QProblemB& rhs    
                                                                );


                virtual returnValue reset( );


                returnValue init(       SymmetricMatrix *_H,            
                                                        const real_t* const _g,         
                                                        const real_t* const _lb,        
                                                        const real_t* const _ub,        
                                                        int& nWSR,                                      
                                                        real_t* const cputime           
                                                        );

                returnValue init(       const real_t* const _H,         
                                                        const real_t* const _g,         
                                                        const real_t* const _lb,        
                                                        const real_t* const _ub,        
                                                        int& nWSR,                                      
                                                        real_t* const cputime           
                                                        );

                returnValue init(       const char* const H_file,       
                                                        const char* const g_file,       
                                                        const char* const lb_file,      
                                                        const char* const ub_file,      
                                                        int& nWSR,                                      
                                                        real_t* const cputime           
                                                        );

                returnValue init(       SymmetricMatrix *_H,                            
                                                        const real_t* const _g,                         
                                                        const real_t* const _lb,                        
                                                        const real_t* const _ub,                        
                                                        int& nWSR,                                                      
                                                        real_t* const cputime,                          
                                                        const real_t* const xOpt,                       
                                                        const real_t* const yOpt,                       
                                                        const Bounds* const guessedBounds       
                                                        );

                returnValue init(       const real_t* const _H,                         
                                                        const real_t* const _g,                         
                                                        const real_t* const _lb,                        
                                                        const real_t* const _ub,                        
                                                        int& nWSR,                                                      
                                                        real_t* const cputime,                          
                                                        const real_t* const xOpt,                       
                                                        const real_t* const yOpt,                       
                                                        const Bounds* const guessedBounds       
                                                        );

                returnValue init(       const char* const H_file,                       
                                                        const char* const g_file,                       
                                                        const char* const lb_file,                      
                                                        const char* const ub_file,                      
                                                        int& nWSR,                                                      
                                                        real_t* const cputime,                          
                                                        const real_t* const xOpt,                       
                                                        const real_t* const yOpt,                       
                                                        const Bounds* const guessedBounds       
                                                        );


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

                returnValue hotstart(   const char* const g_file,       
                                                                const char* const lb_file,      
                                                                const char* const ub_file,      
                                                                int& nWSR,                                      
                                                                real_t* const cputime           
                                                                );

                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,                          
                                                                const Bounds* const guessedBounds       
                                                                );

                returnValue hotstart(   const char* const g_file,                       
                                                                const char* const lb_file,                      
                                                                const char* const ub_file,                      
                                                                int& nWSR,                                                      
                                                                real_t* const cputime,                          
                                                                const Bounds* const guessedBounds       
                                                                );


                inline returnValue getBounds(   Bounds& _bounds 
                                                                                ) const;


                inline int getNV( ) const;

                inline int getNFR( ) const;

                inline int getNFX( ) const;

                inline int getNFV( ) const;

                virtual int getNZ( ) const;


                real_t getObjVal( ) const;

                real_t getObjVal(       const real_t* const _x  
                                                        ) const;

                returnValue getPrimalSolution(  real_t* const xOpt                      
                                                                                ) const;

                virtual 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 HessianType getHessianType( ) const;

                inline returnValue setHessianType(      HessianType _hessianType 
                                                                                        );

                inline BooleanType usingRegularisation( ) const;

                inline Options getOptions( ) const;

                inline returnValue setOptions(  const Options& _options 
                                                                                );

                inline PrintLevel getPrintLevel( ) const;

                returnValue setPrintLevel(      PrintLevel _printlevel  
                                                                        );


                virtual returnValue printProperties( );

                returnValue printOptions( ) const;


        /*
         *      PROTECTED MEMBER FUNCTIONS
         */
        protected:
                returnValue clear( );
                
                returnValue copy(       const QProblemB& rhs    
                                                        );
                
                returnValue determineHessianType( );

                virtual returnValue setupSubjectToType( );

                virtual returnValue setupSubjectToType( const real_t* const lb_new,     
                                                                                                const real_t* const ub_new      
                                                                                                );

                returnValue setupCholeskyDecomposition( );


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


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

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


                returnValue determineDataShift( 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
                                                                                );


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

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

                returnValue setupQPdataFromFile(        const char* const H_file,       
                                                                                        const char* const g_file,       
                                                                                        const char* const lb_file,      
                                                                                        const char* const ub_file       
                                                                                        );

                returnValue loadQPvectorsFromFile(      const char* const g_file,       
                                                                                        const char* const lb_file,      
                                                                                        const char* const ub_file,      
                                                                                        real_t* const g_new,            
                                                                                        real_t* const lb_new,           
                                                                                        real_t* const ub_new            
                                                                                        ) const;


                returnValue setInfeasibilityFlag(       returnValue returnvalue
                                                                                        );


                BooleanType isCPUtimeLimitExceeded(     const real_t* const cputime,    
                                                                                        real_t starttime,                               
                                                                                        int nWSR                                                
                                                                                        ) const;


                returnValue regulariseHessian( );


                inline returnValue setH(        SymmetricMatrix* H_new  
                                                                        );
                                                                        
                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 nu,              
                                                                        real_t xold,    
                                                                        real_t yold,    
                                                                        real_t& xnew,   
                                                                        real_t& ynew    
                                                                        ) const;



                real_t relativeHomotopyLength(  const real_t* const g_new,              
                                                                                const real_t* const lb_new,             
                                                                                const real_t* const ub_new              
                                                                                );

                virtual returnValue performRamping( );


                returnValue performRatioTest(   int nIdx,                                                       
                                                                                const int* const idxList,                       
                                                                                const SubjectTo* const subjectTo,       
                                                                                const real_t* const num,                        
                                                                                const real_t* const den,                        
                                                                                real_t epsNum,                                          
                                                                                real_t epsDen,                                          
                                                                                real_t& t,                                                      
                                                                                int& BC_idx                                             
                                                                                ) const;

                inline BooleanType isBlocking(  real_t num,                                                     
                                                                                real_t den,                                                     
                                                                                real_t epsNum,                                          
                                                                                real_t epsDen,                                          
                                                                                real_t& t                                                       
                                                                                ) const;


        /*
         *      PRIVATE MEMBER FUNCTIONS
         */
        private:
                returnValue solveInitialQP(     const real_t* const xOpt,                       
                                                                        const real_t* const yOpt,                       
                                                                        const Bounds* const guessedBounds,      
                                                                        int& nWSR,                                                      
                                                                        real_t* const cputime                           
                                                                        );

                returnValue solveQP(    const real_t* const g_new,      
                                                                const real_t* const lb_new,     
                                                                const real_t* const ub_new,     
                                                                int& nWSR,                                      
                                                                real_t* const cputime,          
                                                                int  nWSRperformed = 0          
                                                                );


                returnValue solveRegularisedQP( const real_t* const g_new,      
                                                                                const real_t* const lb_new,     
                                                                                const real_t* const ub_new,     
                                                                                int& nWSR,                                      
                                                                                real_t* const cputime,          
                                                                                int  nWSRperformed = 0          
                                                                                );


                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 setupAuxiliaryQP(   const Bounds* const guessedBounds       
                                                                                );

                returnValue determineStepDirection(     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 performStep(        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              
                                                                        );

                returnValue changeActiveSet(    int BC_idx,                                             
                                                                                SubjectToStatus BC_status                       
                                                                                );

                returnValue performDriftCorrection( );

                BooleanType shallRefactorise(   const Bounds* const guessedBounds       
                                                                                ) const;


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

                returnValue removeBound(        int number,                                     
                                                                        BooleanType updateCholesky      
                                                                        );


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


        /*
         *      PROTECTED MEMBER VARIABLES
         */
        protected:
                BooleanType freeHessian;        
                SymmetricMatrix* H;                     
                real_t* g;                                      
                real_t* lb;                                     
                real_t* ub;                                     
                Bounds bounds;                          
                real_t* R;                                      
                BooleanType haveCholesky;       
                real_t* x;                                      
                real_t* y;                                      
                real_t tau;                                     
                QProblemStatus status;          
                BooleanType infeasible;         
                BooleanType unbounded;          
                HessianType hessianType;        
                BooleanType isRegularised;      
                int count;                                      
                real_t *delta_xFR_TMP;          
                real_t ramp0;                           
                real_t ramp1;                           
                Options options;                        
                Flipper flipper;                        
};


END_NAMESPACE_QPOASES

#include <qpOASES/QProblemB.ipp>

#endif  /* QPOASES_QPROBLEMB_HPP */


/*
 *      end of file
 */