IpStdAugSystemSolver.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    2004-08-13
 
#ifndef __IP_STDAUGSYSTEMSOLVER_HPP__
#define __IP_STDAUGSYSTEMSOLVER_HPP__
 
#include "IpAugSystemSolver.hpp"
#include "IpCompoundMatrix.hpp"
#include "IpCompoundSymMatrix.hpp"
#include "IpCompoundVector.hpp"
#include "IpSumSymMatrix.hpp"
#include "IpDiagMatrix.hpp"
#include "IpIdentityMatrix.hpp"
 
namespace Ipopt
{
class StdAugSystemSolver: public AugSystemSolver
{
public:
 
   StdAugSystemSolver(
      SymLinearSolver& LinSolver
   );
 
   virtual ~StdAugSystemSolver();
 
   bool InitializeImpl(
      const OptionsList& options,
      const std::string& prefix
   );
 
   virtual ESymSolverStatus MultiSolve(
      const SymMatrix*                      W,
      Number                                W_factor,
      const Vector*                         D_x,
      Number                                delta_x,
      const Vector*                         D_s,
      Number                                delta_s,
      const Matrix*                         J_c,
      const Vector*                         D_c,
      Number                                delta_c,
      const Matrix*                         J_d,
      const Vector*                         D_d,
      Number                                delta_d,
      std::vector<SmartPtr<const Vector> >& rhs_xV,
      std::vector<SmartPtr<const Vector> >& rhs_sV,
      std::vector<SmartPtr<const Vector> >& rhs_cV,
      std::vector<SmartPtr<const Vector> >& rhs_dV,
      std::vector<SmartPtr<Vector> >&       sol_xV,
      std::vector<SmartPtr<Vector> >&       sol_sV,
      std::vector<SmartPtr<Vector> >&       sol_cV,
      std::vector<SmartPtr<Vector> >&       sol_dV,
      bool                                  check_NegEVals,
      Index                                 numberOfNegEVals
   );
 
   virtual Index NumberOfNegEVals() const;
 
   virtual bool ProvidesInertia() const;
 
   virtual bool IncreaseQuality();
 
private:
 
   StdAugSystemSolver();
 
   StdAugSystemSolver(
      const StdAugSystemSolver&
   );
 
   void operator=(
      const StdAugSystemSolver&
   );
 
   void CreateAugmentedSpace(
      const SymMatrix& W,
      const Matrix&    J_c,
      const Matrix&    J_d,
      const Vector&    proto_x,
      const Vector&    proto_s,
      const Vector&    proto_c,
      const Vector&    proto_d
   );
 
   void CreateAugmentedSystem(
      const SymMatrix* W,
      Number           W_factor,
      const Vector*    D_x,
      Number           delta_x,
      const Vector*    D_s,
      Number           delta_s,
      const Matrix&    J_c,
      const Vector*    D_c,
      Number           delta_c,
      const Matrix&    J_d,
      const Vector*    D_d,
      Number           delta_d,
      const Vector&    proto_x,
      const Vector&    proto_s,
      const Vector&    proto_c,
      const Vector&    proto_d
   );
 
   bool AugmentedSystemRequiresChange(
      const SymMatrix* W,
      Number           W_factor,
      const Vector*    D_x,
      Number           delta_x,
      const Vector*    D_s,
      Number           delta_s,
      const Matrix&    J_c,
      const Vector*    D_c,
      Number           delta_c,
      const Matrix&    J_d,
      const Vector*    D_d,
      Number           delta_d
   );
 
   SmartPtr<SymLinearSolver> linsolver_;
 
   SmartPtr<CompoundSymMatrixSpace> augmented_system_space_;
   SmartPtr<SumSymMatrixSpace> sumsym_space_x_;
   SmartPtr<DiagMatrixSpace> diag_space_x_;
   SmartPtr<DiagMatrixSpace> diag_space_s_;
   SmartPtr<DiagMatrixSpace> diag_space_c_;
   SmartPtr<IdentityMatrixSpace> ident_space_ds_;
   SmartPtr<DiagMatrixSpace> diag_space_d_;
 
   SmartPtr<CompoundVectorSpace> augmented_vector_space_;
 
 
   TaggedObject::Tag w_tag_;
 
   Number w_factor_;
 
   TaggedObject::Tag d_x_tag_;
 
   Number delta_x_;
 
   TaggedObject::Tag d_s_tag_;
 
   Number delta_s_;
 
   TaggedObject::Tag j_c_tag_;
 
   TaggedObject::Tag d_c_tag_;
 
   Number delta_c_;
 
   TaggedObject::Tag j_d_tag_;
 
   TaggedObject::Tag d_d_tag_;
 
   Number delta_d_;
 
   TaggedObject::Tag augsys_tag_;
 
   SmartPtr<CompoundSymMatrix> augmented_system_;
 
   SmartPtr<const SymMatrix> old_w_;
 
 
   bool warm_start_same_structure_;
};
 
} // namespace Ipopt
 
#endif