external_packages/qpOASES-3.0beta/include/qpOASES/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-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_QPROBLEM_HPP
#define QPOASES_QPROBLEM_HPP


#include <qpOASES/QProblemB.hpp>
#include <qpOASES/Constraints.hpp>
#include <qpOASES/ConstraintProduct.hpp>
#include <qpOASES/Matrices.hpp>


BEGIN_NAMESPACE_QPOASES


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

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

                QProblem(       int _nV,                                                                
                                        int _nC,                                                                
                                        HessianType _hessianType = HST_UNKNOWN  
                                        );

                QProblem(       const QProblem& rhs             
                                        );

                virtual ~QProblem( );

                QProblem& operator=(    const QProblem& rhs     
                                                                );


                virtual returnValue reset( );


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


                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,                                      
                                                        real_t* const cputime           
                                                        );

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

                returnValue init(       SymmetricMatrix *_H,                                            
                                                        const real_t* const _g,                                         
                                                        Matrix *_A,                                                             
                                                        const real_t* const _lb,                                        
                                                        const real_t* const _ub,                                        
                                                        const real_t* const _lbA,                                       
                                                        const real_t* const _ubA,                                       
                                                        int& nWSR,                                                                      
                                                        real_t* const cputime,                                          
                                                        const real_t* const xOpt,                                       
                                                        const real_t* const yOpt,                                       
                                                        const Bounds* const guessedBounds,                      
                                                        const Constraints* const guessedConstraints     
                                                        );

                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,                                                                      
                                                        real_t* const cputime,                                          
                                                        const real_t* const xOpt,                                       
                                                        const real_t* const yOpt,                                       
                                                        const Bounds* const guessedBounds,                      
                                                        const Constraints* const guessedConstraints     
                                                        );

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


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

                returnValue hotstart(   const char* const g_file,       
                                                                const char* const lb_file,      
                                                                const char* const ub_file,      
                                                                const char* const lbA_file, 
                                                                const char* const ubA_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,                                     
                                                                const real_t* const lbA_new,                            
                                                                const real_t* const ubA_new,                            
                                                                int& nWSR,                                                                      
                                                                real_t* const cputime,                                          
                                                                const Bounds* const guessedBounds,                      
                                                                const Constraints* const guessedConstraints     
                                                                );

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

        returnValue solveCurrentEQP (   const int n_rhs,                        
                                                                                const real_t* g_in,                     
                                                                                const real_t* lb_in,            
                                                                                const real_t* ub_in,            
                                                                                const real_t* lbA_in,           
                                                                                const real_t* ubA_in,           
                                                                                real_t* x_out,                          
                                                                                real_t* y_out                           
                                                                                );


                inline returnValue getConstraints(      Constraints& _constraints       
                                                                                        ) const;


                inline int getNC( ) const;

                inline int getNEC( ) const;

                inline int getNAC( ) const;

                inline int getNIAC( ) const;

                virtual int getNZ( ) const;


                virtual returnValue getDualSolution(    real_t* const yOpt      
                                                                                                ) const;


                returnValue setConstraintProduct(       ConstraintProduct* const _constraintProduct
                                                                                        );


                virtual returnValue printProperties( );


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

                returnValue copy(       const QProblem& rhs     
                                                        );

                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 solveQP(    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,                  
                                                                int  nWSRperformed = 0                  
                                                                );


                returnValue solveRegularisedQP( 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,                  
                                                                                int  nWSRperformed = 0                  
                                                                                );


                virtual returnValue setupSubjectToType( );

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

                returnValue setupCholeskyDecompositionProjected( );

                returnValue computeInitialCholesky( );

                returnValue setupTQfactorisation( );


                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,     
                                                                        BooleanType ensureLI = BT_TRUE  
                                                                        );

                returnValue addConstraint_checkLI(      int number                      
                                                                                        );

                returnValue addConstraint_ensureLI(     int number,                                     
                                                                                        SubjectToStatus C_status        
                                                                                        );

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

                returnValue addBound_checkLI(   int number                      
                                                                                );

                returnValue addBound_ensureLI(  int number,                                     
                                                                                SubjectToStatus B_status        
                                                                                );

                returnValue removeConstraint(   int number,                                                             
                                                                                BooleanType updateCholesky,                             
                                                                                BooleanType allowFlipping = BT_FALSE,   
                                                                                BooleanType ensureNZC = BT_FALSE                
                                                                                );

                returnValue removeBound(        int number,                                                             
                                                                        BooleanType updateCholesky,                             
                                                                        BooleanType allowFlipping = BT_FALSE,   
                                                                        BooleanType ensureNZC = BT_FALSE                
                                                                        );


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


                returnValue ensureNonzeroCurvature(
                                BooleanType removeBoundNotConstraint,   
                                int remIdx,                                                             
                                BooleanType &exchangeHappened,                  
                                BooleanType &addBoundNotConstraint,             
                                int &addIdx,                                                    
                                SubjectToStatus &addStatus                              
                                );


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


                returnValue determineDataShift( 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 determineStepDirection(     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 performStep(        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,          
                                                                        int& BC_idx,                                            
                                                                        SubjectToStatus& BC_status,                     
                                                                        BooleanType& BC_isBound                         
                                                                        );

                returnValue changeActiveSet(    int BC_idx,                                             
                                                                                SubjectToStatus BC_status,                      
                                                                                BooleanType BC_isBound                          
                                                                                );


                real_t relativeHomotopyLength(  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             
                                                                                );


                virtual returnValue performRamping( );


                returnValue performDriftCorrection( );


                virtual returnValue setupAuxiliaryQP(   const Bounds* const guessedBounds,                      
                                                                                                const Constraints* const guessedConstraints     
                                                                                                );

                BooleanType shallRefactorise(   const Bounds* const guessedBounds,                      
                                                                                const Constraints* const guessedConstraints     
                                                                                ) const;

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


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

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

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


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


                inline returnValue setA(        Matrix *A_new   
                                                                        );

                inline returnValue setA(        const real_t* const A_new       
                                                                        );


                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:
                BooleanType freeConstraintMatrix;               
                Matrix* A;                                                              
                real_t* lbA;                                                    
                real_t* ubA;                                                    
                Constraints constraints;                                
                real_t* T;                                                              
                real_t* Q;                                                              
                int sizeT;                                                              
                real_t* Ax;                                                             
                real_t* Ax_l;                                                   
                real_t* Ax_u;                                                   
                ConstraintProduct* constraintProduct;   
                real_t* tempA;                                                  
                real_t* tempB;                                                  
                real_t* ZFR_delta_xFRz;                                 
                real_t* delta_xFRy;                                             
                real_t* delta_xFRz;                                             
                real_t* delta_yAC_TMP;                                  
                int idxAddB;                                                    
                int idxRemB;                                                    
                int idxAddC;                                                    
                int idxRemC;                                                    
};


END_NAMESPACE_QPOASES

#include <qpOASES/QProblem.ipp>

#endif  /* QPOASES_QPROBLEM_HPP */


/*
 *      end of file
 */