SparseSolver.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_SPARSESOLVER_HPP
#define QPOASES_SPARSESOLVER_HPP
#include <limits>
#include <sstream>
 
#include <qpOASES/Utils.hpp>
 
 
BEGIN_NAMESPACE_QPOASES
 
 
class SparseSolver
{
    /*
     *  PUBLIC MEMBER FUNCTIONS
     */
    public:
        SparseSolver( );
 
        SparseSolver(   const SparseSolver& rhs     
                        );
 
        virtual ~SparseSolver( );
 
        virtual SparseSolver& operator=(    const SparseSolver& rhs 
                                            );
 
        virtual returnValue setMatrixData( int_t dim,                   
                                           int_t numNonzeros,           
                                           const int_t* const airn,     
                                           const int_t* const acjn,     
                                           const real_t* const avals    
                                           ) = 0;
 
        virtual returnValue factorize( ) = 0;
 
        virtual returnValue solve( int_t dim, 
                       const real_t* const rhs, 
                       real_t* const sol 
                       ) = 0;
 
        virtual returnValue reset( );
 
        virtual int_t getNegativeEigenvalues( );
 
        virtual int_t getRank( );
 
        virtual returnValue getZeroPivots( int_t *&zeroPivots );
 
    /*
     *  PROTECTED MEMBER FUNCTIONS
     */
    protected:
        returnValue clear( );
 
        returnValue copy(   const SparseSolver& rhs 
                            );
 
    /*
     *  PROTECTED MEMBER VARIABLES
     */
    protected:
};
 
 
#ifdef SOLVER_MA27
 
class Ma27SparseSolver: public SparseSolver
{
    /*
     *  PUBLIC MEMBER FUNCTIONS
     */
    public:
        Ma27SparseSolver( );
 
        Ma27SparseSolver(   const Ma27SparseSolver& rhs     
                            );
 
        virtual ~Ma27SparseSolver( );
 
        virtual Ma27SparseSolver& operator=(    const SparseSolver& rhs 
                                                );
 
        virtual returnValue setMatrixData( int_t dim,                   
                                           int_t numNonzeros,           
                                           const int_t* const airn,     
                                           const int_t* const acjn,     
                                           const real_t* const avals    
                                           );
 
        virtual returnValue factorize( );
 
        virtual returnValue solve( int_t dim,               
                                   const real_t* const rhs, 
                                   real_t* const sol        
                                   );
 
        virtual returnValue reset( );
 
        virtual int_t getNegativeEigenvalues( );
 
        virtual int getRank( );
 
    /*
     *  PROTECTED MEMBER FUNCTIONS
     */
    protected:
        returnValue clear( );
 
        returnValue copy(   const Ma27SparseSolver& rhs 
                            );
 
    /*
     *  PRIVATE MEMBER FUNCTIONS
     */
    private:
    /*
     *  PRIVATE MEMBER VARIABLES
     */
    private:
        fint_t dim; 
        fint_t numNonzeros; 
        fint_t la_ma27; 
        double* a_ma27; 
        fint_t* irn_ma27; 
        fint_t* jcn_ma27; 
        fint_t icntl_ma27[30];  
        double cntl_ma27[5];  
        fint_t liw_ma27;  
        fint_t* iw_ma27; 
        fint_t* ikeep_ma27;  
        fint_t nsteps_ma27;  
        fint_t maxfrt_ma27;  
        bool have_factorization; 
        fint_t neig;    
        fint_t rank;    
};
 
#endif /* SOLVER_MA27 */
 
 
#ifdef SOLVER_MA57
 
class Ma57SparseSolver: public SparseSolver
{
    /*
     *  PUBLIC MEMBER FUNCTIONS
     */
    public:
        Ma57SparseSolver( );
 
        Ma57SparseSolver(   const Ma57SparseSolver& rhs     
                            );
 
        virtual ~Ma57SparseSolver( );
 
        virtual Ma57SparseSolver& operator=(    const SparseSolver& rhs 
                                                );
 
        virtual returnValue setMatrixData( int_t dim,                   
                                           int_t numNonzeros,           
                                           const int_t* const airn,     
                                           const int_t* const acjn,     
                                           const real_t* const avals    
                                           );
 
        virtual returnValue factorize( );
 
        virtual returnValue solve(  int_t dim,                  
                                    const real_t* const rhs,    
                                    real_t* const sol           
                                    );
 
        virtual returnValue reset( );
 
        virtual int_t getNegativeEigenvalues( );
 
        virtual int_t getRank( );
 
        virtual returnValue getZeroPivots(  int_t* &zeroPivots  
                                            );
    /*
     *  PROTECTED MEMBER FUNCTIONS
     */
    protected:
        returnValue clear( );
 
        returnValue copy(   const Ma57SparseSolver& rhs 
                            );
 
    /*
     *  PRIVATE MEMBER FUNCTIONS
     */
    private:
    /*
     *  PRIVATE MEMBER VARIABLES
     */
    private:
        fint_t dim;             
        fint_t numNonzeros;     
        double* a_ma57;         
        fint_t* irn_ma57;           
        fint_t* jcn_ma57;           
        fint_t icntl_ma57[30];  
        double cntl_ma57[5];    
        double* fact_ma57;      
        fint_t lfact_ma57;      
        fint_t* ifact_ma57;     
        fint_t lifact_ma57;     
        bool have_factorization;
        fint_t neig;                
        fint_t rank;                
        fint_t* pivots;         
};
 
#endif /* SOLVER_MA57 */
 
 
#ifdef SOLVER_MUMPS
 
class MumpsSparseSolver: public SparseSolver
{
    /*
     *  PUBLIC MEMBER FUNCTIONS
     */
    public:
        MumpsSparseSolver( );
 
        MumpsSparseSolver(  const MumpsSparseSolver& rhs        
                            );
 
        virtual ~MumpsSparseSolver( );
 
        virtual MumpsSparseSolver& operator=(   const SparseSolver& rhs 
                                                );
 
        virtual returnValue setMatrixData( int_t dim,                   
                                           int_t numNonzeros,           
                                           const int_t* const airn,     
                                           const int_t* const acjn,     
                                           const real_t* const avals    
                                           );
 
        virtual returnValue factorize( );
 
        virtual returnValue solve(  int_t dim,                  
                                    const real_t* const rhs,    
                                    real_t* const sol           
                                    );
 
        virtual returnValue reset( );
 
        virtual int_t getNegativeEigenvalues( );
 
        virtual int_t getRank( );
 
        virtual returnValue getZeroPivots(  int_t* &zeroPivots  
                                            );
    /*
     *  PROTECTED MEMBER FUNCTIONS
     */
    protected:
        returnValue clear( );
 
        returnValue copy(   const MumpsSparseSolver& rhs    
                            );
 
    /*
     *  PRIVATE MEMBER FUNCTIONS
     */
    private:
    /*
     *  PRIVATE MEMBER VARIABLES
     */
    private:
 
        
        void* mumps_ptr_;           
        int dim;                    
        int numNonzeros;            
        double* a_mumps;            
        int* irn_mumps;         
        int* jcn_mumps;         
        bool have_factorization;    
        int negevals_;          
        int mumps_pivot_order_;  /* pivot order*/
 
        bool initialized_;
        bool pivtol_changed_;
        bool refactorize_;
 
 
        double pivtol_;
 
        double pivtolmax_;
 
        int mem_percent_;
 
        int mumps_permuting_scaling_;
 
        int mumps_scaling_;
 
        double mumps_dep_tol_;
 
        bool warm_start_same_structure_;
 
        bool have_symbolic_factorization_;
};
 
template<typename T>
inline void ComputeMemIncrease(
   T&          len,          
   double      recommended,  
   T           min,          
   const char* context       
)
{
   if( recommended >= std::numeric_limits<T>::max() )
   {
      // increase len to the maximum possible, if that is still an increase
      if( len < std::numeric_limits<T>::max() )
      {
         len = std::numeric_limits<T>::max();
      }
      else
      {
         std::stringstream what;
         what << "Cannot allocate more than " << std::numeric_limits<T>::max()*sizeof(T) << " bytes for " << context << " due to limitation on integer type";
         throw std::overflow_error(what.str());
      }
   }
   else
   {
      len = std::max(min, (T) recommended);
   }
}
 
#endif /* SOLVER_MUMPS */
 
 
 
#ifdef SOLVER_NONE
 
class DummySparseSolver: public SparseSolver
{
    /*
     *  PUBLIC MEMBER FUNCTIONS
     */
    public:
        virtual returnValue setMatrixData(  int_t dim,                  
                                            int_t numNonzeros,          
                                            const int_t* const airn,    
                                            const int_t* const acjn,    
                                            const real_t* const avals   
                                            );
 
        virtual returnValue factorize( );
 
        virtual returnValue solve(  int_t dim,                  
                                    const real_t* const rhs,    
                                    real_t* const sol           
                                    );
};
 
#endif /* SOLVER_NONE */
 
 
END_NAMESPACE_QPOASES
 
#endif  /* QPOASES_SPARSESOLVER_HPP */
 
/*
 *  end of file
 */