IpLowRankAugSystemSolver.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: IpLowRankAugSystemSolver.hpp 1861 2010-12-21 21:34:47Z andreasw $
//
// Authors:  Andreas Waechter                IBM    2005-12-27

#ifndef __IP_LOWRANKAUGSYSTEMSOLVER_HPP__
#define __IP_LOWRANKAUGSYSTEMSOLVER_HPP__

#include "IpAugSystemSolver.hpp"
#include "IpDenseGenMatrix.hpp"
#include "IpMultiVectorMatrix.hpp"
#include "IpDiagMatrix.hpp"

namespace Ipopt
{

  class LowRankAugSystemSolver : public AugSystemSolver
  {
  public:
    LowRankAugSystemSolver(AugSystemSolver& aug_system_solver);

    virtual ~LowRankAugSystemSolver();

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

    virtual ESymSolverStatus Solve(
      const SymMatrix* W,
      double W_factor,
      const Vector* D_x,
      double delta_x,
      const Vector* D_s,
      double delta_s,
      const Matrix* J_c,
      const Vector* D_c,
      double delta_c,
      const Matrix* J_d,
      const Vector* D_d,
      double delta_d,
      const Vector& rhs_x,
      const Vector& rhs_s,
      const Vector& rhs_c,
      const Vector& rhs_d,
      Vector& sol_x,
      Vector& sol_s,
      Vector& sol_c,
      Vector& sol_d,
      bool check_NegEVals,
      Index numberOfNegEVals);

    virtual Index NumberOfNegEVals() const;

    virtual bool ProvidesInertia() const;

    virtual bool IncreaseQuality();

  private:
    LowRankAugSystemSolver();
    LowRankAugSystemSolver(const LowRankAugSystemSolver&);

    void operator=(const LowRankAugSystemSolver&);

    SmartPtr<AugSystemSolver> aug_system_solver_;

    TaggedObject::Tag w_tag_;
    double w_factor_;
    TaggedObject::Tag d_x_tag_;
    double delta_x_;
    TaggedObject::Tag d_s_tag_;
    double delta_s_;
    TaggedObject::Tag j_c_tag_;
    TaggedObject::Tag d_c_tag_;
    double delta_c_;
    TaggedObject::Tag j_d_tag_;
    TaggedObject::Tag d_d_tag_;
    double delta_d_;

    bool first_call_;
    SmartPtr<DenseGenMatrix> J1_;
    SmartPtr<DenseGenMatrix> J2_;
    SmartPtr<MultiVectorMatrix> Vtilde1_;
    SmartPtr<MultiVectorMatrix> Utilde2_;
    SmartPtr<DiagMatrix> Wdiag_;
    SmartPtr<const CompoundVectorSpace> compound_sol_vecspace_;

    Index num_neg_evals_;

    ESymSolverStatus UpdateFactorization(
      const SymMatrix* W,
      double W_factor,
      const Vector* D_x,
      double delta_x,
      const Vector* D_s,
      double delta_s,
      const Matrix& J_c,
      const Vector* D_c,
      double delta_c,
      const Matrix& J_d,
      const Vector* D_d,
      double delta_d,
      const Vector& proto_rhs_x,
      const Vector& proto_rhs_s,
      const Vector& proto_rhs_c,
      const Vector& proto_rhs_d,
      bool check_NegEVals,
      Index numberOfNegEVals);

    ESymSolverStatus SolveMultiVector(
      const Vector* D_x,
      double delta_x,
      const Vector* D_s,
      double delta_s,
      const Matrix& J_c,
      const Vector* D_c,
      double delta_c,
      const Matrix& J_d,
      const Vector* D_d,
      double delta_d,
      const Vector& proto_rhs_x,
      const Vector& proto_rhs_s,
      const Vector& proto_rhs_c,
      const Vector& proto_rhs_d,
      const MultiVectorMatrix& V,
      const SmartPtr<const Matrix>& P_LM,
      SmartPtr<MultiVectorMatrix>& V_x,
      SmartPtr<MultiVectorMatrix>& Vtilde1,
      SmartPtr<MultiVectorMatrix>& Vtilde1_x,
      bool check_NegEVals,
      Index numberOfNegEVals);

    bool AugmentedSystemRequiresChange(
      const SymMatrix* W,
      double W_factor,
      const Vector* D_x,
      double delta_x,
      const Vector* D_s,
      double delta_s,
      const Matrix& J_c,
      const Vector* D_c,
      double delta_c,
      const Matrix& J_d,
      const Vector* D_d,
      double delta_d);

  };

} // namespace Ipopt

#endif