IpMa27TSolverInterface.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2006 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2005-03-17
 
#ifndef __IPMA27TSOLVERINTERFACE_HPP__
#define __IPMA27TSOLVERINTERFACE_HPP__
 
#include "IpSparseSymLinearSolverInterface.hpp"
#include "IpLibraryLoader.hpp"
#include "IpTypes.h"
 
#define IPOPT_DECL_MA27A(x) void (x)( \
   ipindex*       N,     \
   ipindex*       NZ,    \
   const ipindex* IRN,   \
   const ipindex* ICN,   \
   ipindex*       IW,    \
   ipindex*       LIW,   \
   ipindex*       IKEEP, \
   ipindex*       IW1,   \
   ipindex*       NSTEPS,\
   ipindex*       IFLAG, \
   ipindex*       ICNTL, \
   ipnumber*      CNTL,  \
   ipindex*       INFO,  \
   ipnumber*      OPS    \
)
 
#define IPOPT_DECL_MA27B(x) void (x)( \
   ipindex*       N,      \
   ipindex*       NZ,     \
   const ipindex* IRN,    \
   const ipindex* ICN,    \
   ipnumber*      A,      \
   ipindex*       LA,     \
   ipindex*       IW,     \
   ipindex*       LIW,    \
   ipindex*       IKEEP,  \
   ipindex*       NSTEPS, \
   ipindex*       MAXFRT, \
   ipindex*       IW1,    \
   ipindex*       ICNTL,  \
   ipnumber*      CNTL,   \
   ipindex*       INFO    \
)
 
#define IPOPT_DECL_MA27C(x) void (x)( \
   ipindex*   N,      \
   ipnumber*  A,      \
   ipindex*   LA,     \
   ipindex*   IW,     \
   ipindex*   LIW,    \
   ipnumber*  W,      \
   ipindex*   MAXFRT, \
   ipnumber*  RHS,    \
   ipindex*   IW1,    \
   ipindex*   NSTEPS, \
   ipindex*   ICNTL,  \
   ipindex*   INFO    \
)
 
#define IPOPT_DECL_MA27I(x) void (x)( \
   ipindex*  ICNTL, \
   ipnumber* CNTL   \
)
 
namespace Ipopt
{
class Ma27TSolverInterface: public SparseSymLinearSolverInterface
{
public:
 
   Ma27TSolverInterface(
      SmartPtr<LibraryLoader> hslloader_  
   );
 
   virtual ~Ma27TSolverInterface();
 
   bool InitializeImpl(
      const OptionsList& options,
      const std::string& prefix
   );
 
   virtual ESymSolverStatus InitializeStructure(
      Index        dim,
      Index        nonzeros,
      const Index* airn,
      const Index* ajcn
   );
 
   virtual Number* GetValuesArrayPtr();
 
   virtual ESymSolverStatus MultiSolve(
      bool         new_matrix,
      const Index* airn,
      const Index* ajcn,
      Index        nrhs,
      Number*      rhs_vals,
      bool         check_NegEVals,
      Index        numberOfNegEVals);
 
   virtual Index NumberOfNegEVals() const;
 
   //* @name Options of Linear solver */
   virtual bool IncreaseQuality();
 
   virtual bool ProvidesInertia() const
   {
      return true;
   }
 
   EMatrixFormat MatrixFormat() const
   {
      return Triplet_Format;
   }
 
   static void RegisterOptions(
      SmartPtr<RegisteredOptions> roptions
   );
 
   static void SetFunctions(
      IPOPT_DECL_MA27A(*ma27a),
      IPOPT_DECL_MA27B(*ma27b),
      IPOPT_DECL_MA27C(*ma27c),
      IPOPT_DECL_MA27I(*ma27i)
   );
 
private:
 
   Ma27TSolverInterface(
      const Ma27TSolverInterface&
   );
 
   void operator=(
      const Ma27TSolverInterface&
   );
 
   SmartPtr<LibraryLoader> hslloader;
 
   IPOPT_DECL_MA27A(*ma27a);
   IPOPT_DECL_MA27B(*ma27b);
   IPOPT_DECL_MA27C(*ma27c);
   IPOPT_DECL_MA27I(*ma27i);
 
 
   Index dim_;
 
   Index nonzeros_;
 
 
   Index negevals_;
 
 
   bool initialized_;
   bool pivtol_changed_;
   bool refactorize_;
 
 
   Number pivtol_;
 
   Number pivtolmax_;
 
   Number liw_init_factor_;
   Number la_init_factor_;
   Number meminc_factor_;
   bool warm_start_same_structure_;
   bool skip_inertia_check_;
   bool ignore_singularity_;
 
 
   Index icntl_[30];
   Number cntl_[5];
 
   Index liw_;
   Index* iw_;
 
   Index* ikeep_;
   Index nsteps_;
   Index maxfrt_;
 
   Index la_;
   Number* a_;
 
   bool la_increase_;
   bool liw_increase_;
 
 
   ESymSolverStatus SymbolicFactorization(
      const Index* airn,
      const Index* ajcn
   );
 
   ESymSolverStatus Factorization(
      const Index* airn,
      const Index* ajcn,
      bool         check_NegEVals,
      Index        numberOfNegEVals
   );
 
   ESymSolverStatus Backsolve(
      Index   nrhs,
      Number* rhs_vals
   );
};
 
} // namespace Ipopt
#endif