IpEquilibrationScaling.hpp

Go to the documentation of this file.

// Copyright (C) 2007 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// Authors:  Andreas Waechter            IBM    2007-05-21
 
#ifndef __IPEQUILIBRATIONSCALING_HPP__
#define __IPEQUILIBRATIONSCALING_HPP__
 
#include "IpNLPScaling.hpp"
#include "IpNLP.hpp"
#include "IpMc19TSymScalingMethod.hpp"  // to get IPOPT_DECL_MC19A
 
namespace Ipopt
{
class EquilibrationScaling: public StandardScalingBase
{
public:
   EquilibrationScaling(
      const SmartPtr<NLP>& nlp,
      SmartPtr<LibraryLoader> hslloader_
   )  : StandardScalingBase(),
      nlp_(nlp),
      hslloader(hslloader_),
      mc19a(NULL)
   { }
 
   virtual ~EquilibrationScaling()
   { }
 
 
   static void RegisterOptions(
      const SmartPtr<RegisteredOptions>& roptions
   );
 
protected:
   bool InitializeImpl(
      const OptionsList& options,
      const std::string& prefix
   );
 
   virtual void DetermineScalingParametersImpl(
      const SmartPtr<const VectorSpace>    x_space,
      const SmartPtr<const VectorSpace>    c_space,
      const SmartPtr<const VectorSpace>    d_space,
      const SmartPtr<const MatrixSpace>    jac_c_space,
      const SmartPtr<const MatrixSpace>    jac_d_space,
      const SmartPtr<const SymMatrixSpace> h_space,
      const Matrix&                        Px_L,
      const Vector&                        x_L,
      const Matrix&                        Px_U,
      const Vector&                        x_U,
      Number&                              df,
      SmartPtr<Vector>&                    dx,
      SmartPtr<Vector>&                    dc,
      SmartPtr<Vector>&                    dd
   );
 
private:
 
 
   EquilibrationScaling(
      const EquilibrationScaling&
   );
 
   void operator=(
      const EquilibrationScaling&
   );
 
   SmartPtr<NLP> nlp_;
 
   Number point_perturbation_radius_;
 
   SmartPtr<LibraryLoader> hslloader;
 
   IPOPT_DECL_MC19A(*mc19a);
};
 
class PointPerturber: public ReferencedObject
{
public:
   PointPerturber(
      const Vector& reference_point,
      Number        random_pert_radius,
      const Matrix& Px_L,
      const Vector& x_L,
      const Matrix& Px_U,
      const Vector& x_U
   );
 
   virtual ~PointPerturber()
   { }
 
   SmartPtr<Vector> MakeNewPerturbedPoint() const;
 
private:
 
 
   PointPerturber(
      const PointPerturber&
   );
 
   void operator=(
      const PointPerturber&
   );
 
   SmartPtr<Vector> ref_point_;
 
   SmartPtr<Vector> pert_dir_;
};
 
} // namespace Ipopt
#endif