IpDefaultIterateInitializer.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2008 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Carl Laird, Andreas Waechter              IBM    2004-09-24
 
#ifndef __IPDEFAULTITERATEINITIALIZER_HPP__
#define __IPDEFAULTITERATEINITIALIZER_HPP__
 
#include "IpIterateInitializer.hpp"
#include "IpEqMultCalculator.hpp"
#include "IpAugSystemSolver.hpp"
 
namespace Ipopt
{
 
class DefaultIterateInitializer: public IterateInitializer
{
public:
 
   DefaultIterateInitializer(
      const SmartPtr<EqMultiplierCalculator>& eq_mult_calculator,
      const SmartPtr<IterateInitializer>&     warm_start_initializer,
      const SmartPtr<AugSystemSolver>         aug_system_solver = NULL
   );
 
   virtual ~DefaultIterateInitializer()
   { }
 
   virtual bool InitializeImpl(
      const OptionsList& options,
      const std::string& prefix
   );
 
   virtual bool SetInitialIterates();
 
   static void push_variables(
      const Journalist&       jnlst,
      Number                  bound_push,
      Number                  bound_frac,
      std::string             name,
      const Vector&           orig_x,
      SmartPtr<const Vector>& new_x,
      const Vector&           x_L,
      const Vector&           x_U,
      const Matrix&           Px_L,
      const Matrix&           Px_U
   );
 
   static void least_square_mults(
      const Journalist&                       jnlst,
      IpoptNLP&                               ip_nlp,
      IpoptData&                              ip_data,
      IpoptCalculatedQuantities&              ip_cq,
      const SmartPtr<EqMultiplierCalculator>& eq_mult_calculator,
      Number                                  constr_mult_init_max
   );
 
   static void RegisterOptions(
      SmartPtr<RegisteredOptions> reg_options
   );
 
   enum BoundMultInitMethod
   {
      B_CONSTANT = 0,
      B_MU_BASED
   };
private:
 
   DefaultIterateInitializer();
 
   DefaultIterateInitializer(
      const DefaultIterateInitializer&
   );
 
   void operator=(
      const DefaultIterateInitializer&
   );
 
 
   Number bound_push_;
   Number bound_frac_;
   Number slack_bound_push_;
   Number slack_bound_frac_;
 
   Number constr_mult_init_max_;
   Number bound_mult_init_val_;
   bool warm_start_init_point_;
   bool least_square_init_primal_;
   bool least_square_init_duals_;
   BoundMultInitMethod bound_mult_init_method_;
   Number mu_init_;
 
   SmartPtr<EqMultiplierCalculator> eq_mult_calculator_;
 
   SmartPtr<IterateInitializer> warm_start_initializer_;
 
   SmartPtr<AugSystemSolver> aug_system_solver_;
 
   bool CalculateLeastSquarePrimals(
      Vector& x_ls,
      Vector& s_ls
   );
 
   bool CalculateLeastSquareDuals(
      Vector& zL_new,
      Vector& zU_new,
      Vector& vL_new,
      Vector& vU_new,
      Vector& yc_new,
      Vector& yd_new
   );
};
 
} // namespace Ipopt
 
#endif