include/qpOASES/SQProblem.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-2017 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_SQPROBLEM_HPP
#define QPOASES_SQPROBLEM_HPP


#include <qpOASES/QProblem.hpp>


BEGIN_NAMESPACE_QPOASES


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

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

        SQProblem(  int_t _nV,                              
                    int_t _nC,                              
                    HessianType _hessianType = HST_UNKNOWN, 
                    BooleanType allocDenseMats = BT_TRUE    
                    );

        SQProblem(  const SQProblem& rhs    
                    );

        virtual ~SQProblem( );

        virtual SQProblem& operator=(   const SQProblem& rhs    
                                );


        returnValue hotstart(   SymmetricMatrix *H_new,                         
                                const real_t* const g_new,                      
                                Matrix *A_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_t& nWSR,                                    
                                real_t* const cputime = 0,                      
                                const Bounds* const guessedBounds = 0,          
                                const Constraints* const guessedConstraints = 0 
                                );

        returnValue hotstart(   const real_t* const H_new,                      
                                const real_t* const g_new,                      
                                const real_t* const A_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_t& nWSR,                                    
                                real_t* const cputime = 0,                      
                                const Bounds* const guessedBounds = 0,          
                                const Constraints* const guessedConstraints = 0 
                                );

        returnValue hotstart(   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_t& nWSR,                                    
                                real_t* const cputime = 0,                      
                                const Bounds* const guessedBounds = 0,          
                                const Constraints* const guessedConstraints = 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_t& nWSR,                                    
                                real_t* const cputime = 0,                      
                                const Bounds* const guessedBounds = 0,          
                                const Constraints* const guessedConstraints = 0 
                                );

        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_t& nWSR,                                    
                                real_t* const cputime = 0,                      
                                const Bounds* const guessedBounds = 0,          
                                const Constraints* const guessedConstraints = 0 
                                );


        #ifdef __MATLAB__

        returnValue resetMatrixPointers( );
        #endif


    /*
     *  PROTECTED MEMBER FUNCTIONS
     */
    protected:

        virtual returnValue setupNewAuxiliaryQP(    SymmetricMatrix *H_new,     
                                                    Matrix *A_new,              
                                                    const real_t *lb_new,       
                                                    const real_t *ub_new,       
                                                    const real_t *lbA_new,      
                                                    const real_t *ubA_new       
                                                    );

        virtual returnValue setupNewAuxiliaryQP(    const real_t* const H_new,  
                                                    const real_t* const A_new,  
                                                    const real_t *lb_new,       
                                                    const real_t *ub_new,       
                                                    const real_t *lbA_new,      
                                                    const real_t *ubA_new       
                                                    );


    /*
     *  PROTECTED MEMBER VARIABLES
     */
    protected:

};


END_NAMESPACE_QPOASES

#include <qpOASES/SQProblem.ipp>

#endif  /* QPOASES_SQPROBLEM_HPP */


/*
 *  end of file
 */