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