IpMa57TSolverInterface.hpp

Go to the documentation of this file.

// Copyright (C) 2005, 2006 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// $Id: IpMa57TSolverInterface.hpp 2158 2012-12-04 19:24:42Z stefan $
//
// Authors:  Michael Hagemann               Univ of Basel 2005-10-28
//               original version (based on MA27TSolverInterface.hpp)

#ifndef __IPMA57TSOLVERINTERFACE_HPP__
#define __IPMA57TSOLVERINTERFACE_HPP__

#include "IpSparseSymLinearSolverInterface.hpp"

#ifdef FUNNY_MA57_FINT
#include <cstddef>
typedef ptrdiff_t ma57int;
#else
typedef ipfint ma57int;
#endif

namespace Ipopt
{
  class Ma57TSolverInterface: public SparseSymLinearSolverInterface
  {
  public:
    Ma57TSolverInterface();

    virtual ~Ma57TSolverInterface();

    bool InitializeImpl(const OptionsList&  options,
                        const std::string&  prefix);


    virtual ESymSolverStatus InitializeStructure(
      Index        dim,
      Index nonzeros,
      const Index     *airn,
      const Index     *ajcn);

    virtual double* GetValuesArrayPtr();

    virtual ESymSolverStatus MultiSolve(bool        new_matrix,
                                        const Index*    airn,
                                        const Index*    ajcn,
                                        Index       nrhs,
                                        double*     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);

  private:
    Ma57TSolverInterface(const Ma57TSolverInterface&);

    void operator=(const Ma57TSolverInterface&);

    Index dim_;

    Index nonzeros_;

    Index negevals_;

    bool initialized_;
    bool pivtol_changed_;
    bool refactorize_;

    Number pivtol_;
    Number pivtolmax_;
    Number ma57_pre_alloc_;
    bool warm_start_same_structure_;

    double   wd_cntl_[5];
    ma57int  wd_icntl_[20];

    ma57int  wd_info_[40];
    double   wd_rinfo_[20];

    ma57int  wd_lkeep_;      /* LKEEP >= 5*N + NE + max(N,NE) + 42. */
    ma57int *wd_keep_;

    ma57int *wd_iwork_;      /* 5 * N. */

    double  *wd_fact_;
    ma57int  wd_lfact_;
    ma57int *wd_ifact_;
    ma57int  wd_lifact_;


    double* a_;

    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,
                               double   *rhs_vals);
  };

} // namespace Ipopt
#endif