IpNLPScaling.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2007 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 __IPNLPSCALING_HPP__
#define __IPNLPSCALING_HPP__
 
#include "IpOptionsList.hpp"
#include "IpRegOptions.hpp"
 
namespace Ipopt
{
// forward declarations
class Vector;
class VectorSpace;
class Matrix;
class MatrixSpace;
class SymMatrix;
class SymMatrixSpace;
class ScaledMatrixSpace;
class SymScaledMatrixSpace;
 
class IPOPTLIB_EXPORT NLPScalingObject: public ReferencedObject
{
public:
   NLPScalingObject();
 
   virtual ~NLPScalingObject();
 
   bool Initialize(
      const Journalist&  jnlst,
      const OptionsList& options,
      const std::string& prefix
   )
   {
      jnlst_ = &jnlst;
      return InitializeImpl(options, prefix);
   }
 
 
   virtual Number apply_obj_scaling(
      const Number& f
   ) = 0;
 
   virtual Number unapply_obj_scaling(
      const Number& f
   ) = 0;
 
   virtual SmartPtr<Vector>
   apply_vector_scaling_x_NonConst(
      const SmartPtr<const Vector>& v
   ) = 0;
 
   virtual SmartPtr<const Vector>
   apply_vector_scaling_x(
      const SmartPtr<const Vector>& v
   ) = 0;
 
   virtual SmartPtr<Vector>
   unapply_vector_scaling_x_NonConst(
      const SmartPtr<const Vector>& v
   ) = 0;
 
   virtual SmartPtr<const Vector>
   unapply_vector_scaling_x(
      const SmartPtr<const Vector>& v
   ) = 0;
 
   virtual SmartPtr<const Vector>
   apply_vector_scaling_c(
      const SmartPtr<const Vector>& v
   ) = 0;
 
   virtual SmartPtr<const Vector>
   unapply_vector_scaling_c(
      const SmartPtr<const Vector>& v
   ) = 0;
 
   virtual SmartPtr<Vector>
   apply_vector_scaling_c_NonConst(
      const SmartPtr<const Vector>& v
   ) = 0;
 
   virtual SmartPtr<Vector>
   unapply_vector_scaling_c_NonConst(
      const SmartPtr<const Vector>& v
   ) = 0;
 
   virtual SmartPtr<const Vector>
   apply_vector_scaling_d(
      const SmartPtr<const Vector>& v
   ) = 0;
 
   virtual SmartPtr<const Vector>
   unapply_vector_scaling_d(
      const SmartPtr<const Vector>& v
   ) = 0;
 
   virtual SmartPtr<Vector>
   apply_vector_scaling_d_NonConst(
      const SmartPtr<const Vector>& v
   ) = 0;
 
   virtual SmartPtr<Vector>
   unapply_vector_scaling_d_NonConst(
      const SmartPtr<const Vector>& v
   ) = 0;
 
   virtual SmartPtr<const Matrix>
   apply_jac_c_scaling(
      SmartPtr<const Matrix> matrix
   ) = 0;
 
   virtual SmartPtr<const Matrix>
   apply_jac_d_scaling(
      SmartPtr<const Matrix> matrix
   ) = 0;
 
   virtual SmartPtr<const SymMatrix>
   apply_hessian_scaling(
      SmartPtr<const SymMatrix> matrix
   ) = 0;
 
 
   SmartPtr<Vector> apply_vector_scaling_x_LU_NonConst(
      const Matrix&                 Px_LU,
      const SmartPtr<const Vector>& lu,
      const VectorSpace&            x_space
   );
 
   SmartPtr<const Vector> apply_vector_scaling_x_LU(
      const Matrix&                 Px_LU,
      const SmartPtr<const Vector>& lu,
      const VectorSpace&            x_space
   );
 
   SmartPtr<Vector> apply_vector_scaling_d_LU_NonConst(
      const Matrix&                 Pd_LU,
      const SmartPtr<const Vector>& lu,
      const VectorSpace&            d_space
   );
 
   SmartPtr<const Vector> apply_vector_scaling_d_LU(
      const Matrix&                 Pd_LU,
      const SmartPtr<const Vector>& lu,
      const VectorSpace&            d_space
   );
 
   SmartPtr<Vector> unapply_vector_scaling_d_LU_NonConst(
      const Matrix&                 Pd_LU,
      const SmartPtr<const Vector>& lu,
      const VectorSpace&            d_space
   );
 
   SmartPtr<const Vector> unapply_vector_scaling_d_LU(
      const Matrix&                 Pd_LU,
      const SmartPtr<const Vector>& lu,
      const VectorSpace&            d_space
   );
 
 
   virtual SmartPtr<Vector>
   apply_grad_obj_scaling_NonConst(
      const SmartPtr<const Vector>& v
   );
 
   virtual SmartPtr<const Vector>
   apply_grad_obj_scaling(
      const SmartPtr<const Vector>& v
   );
 
   virtual SmartPtr<Vector>
   unapply_grad_obj_scaling_NonConst(
      const SmartPtr<const Vector>& v
   );
 
   virtual SmartPtr<const Vector>
   unapply_grad_obj_scaling(
      const SmartPtr<const Vector>& v
   );
 
 
   virtual bool have_x_scaling() = 0;
   virtual bool have_c_scaling() = 0;
   virtual bool have_d_scaling() = 0;
 
   virtual void DetermineScaling(
      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,
      SmartPtr<const MatrixSpace>&         new_jac_c_space,
      SmartPtr<const MatrixSpace>&         new_jac_d_space,
      SmartPtr<const SymMatrixSpace>&      new_h_space,
      const Matrix&                        Px_L,
      const Vector&                        x_L,
      const Matrix&                        Px_U,
      const Vector&                        x_U
   ) = 0;
 
protected:
   virtual bool InitializeImpl(
      const OptionsList& options,
      const std::string& prefix
   ) = 0;
 
   const Journalist& Jnlst() const
   {
      return *jnlst_;
   }
 
private:
 
   NLPScalingObject(
      const NLPScalingObject&
   );
 
   void operator=(
      const NLPScalingObject&
   );
 
   SmartPtr<const Journalist> jnlst_;
};
 
class IPOPTLIB_EXPORT StandardScalingBase: public NLPScalingObject
{
public:
   StandardScalingBase();
 
   virtual ~StandardScalingBase();
 
   virtual Number apply_obj_scaling(
      const Number& f
   );
 
   virtual Number unapply_obj_scaling(
      const Number& f
   );
 
   virtual SmartPtr<Vector>
   apply_vector_scaling_x_NonConst(
      const SmartPtr<const Vector>& v
   );
 
   virtual SmartPtr<const Vector>
   apply_vector_scaling_x(
      const SmartPtr<const Vector>& v
   );
 
   virtual SmartPtr<Vector>
   unapply_vector_scaling_x_NonConst(
      const SmartPtr<const Vector>& v
   );
 
   virtual SmartPtr<const Vector>
   unapply_vector_scaling_x(
      const SmartPtr<const Vector>& v
   );
 
   virtual SmartPtr<const Vector>
   apply_vector_scaling_c(
      const SmartPtr<const Vector>& v
   );
 
   virtual SmartPtr<const Vector>
   unapply_vector_scaling_c(
      const SmartPtr<const Vector>& v
   );
 
   virtual SmartPtr<Vector>
   apply_vector_scaling_c_NonConst(
      const SmartPtr<const Vector>& v
   );
 
   virtual SmartPtr<Vector>
   unapply_vector_scaling_c_NonConst(
      const SmartPtr<const Vector>& v
   );
 
   virtual SmartPtr<const Vector>
   apply_vector_scaling_d(
      const SmartPtr<const Vector>& v
   );
 
   virtual SmartPtr<const Vector>
   unapply_vector_scaling_d(
      const SmartPtr<const Vector>& v
   );
 
   virtual SmartPtr<Vector>
   apply_vector_scaling_d_NonConst(
      const SmartPtr<const Vector>& v
   );
 
   virtual SmartPtr<Vector>
   unapply_vector_scaling_d_NonConst(
      const SmartPtr<const Vector>& v
   );
 
   virtual SmartPtr<const Matrix>
   apply_jac_c_scaling(
      SmartPtr<const Matrix> matrix
   );
 
   virtual SmartPtr<const Matrix>
   apply_jac_d_scaling(
      SmartPtr<const Matrix> matrix
   );
 
   virtual SmartPtr<const SymMatrix>
   apply_hessian_scaling(
      SmartPtr<const SymMatrix> matrix);
 
   virtual bool have_x_scaling();
   virtual bool have_c_scaling();
   virtual bool have_d_scaling();
 
   virtual void DetermineScaling(
      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,
      SmartPtr<const MatrixSpace>&         new_jac_c_space,
      SmartPtr<const MatrixSpace>&         new_jac_d_space,
      SmartPtr<const SymMatrixSpace>&      new_h_space,
      const Matrix&                        Px_L,
      const Vector&                        x_L,
      const Matrix&                        Px_U,
      const Vector&                        x_U
   );
 
   static void RegisterOptions(
      SmartPtr<RegisteredOptions> roptions
   );
 
protected:
   virtual 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
   ) = 0;
 
private:
 
   StandardScalingBase(
      const StandardScalingBase&
   );
 
   void operator=(
      const StandardScalingBase&
   );
 
 
   Number df_;
 
   SmartPtr<Vector> dx_;
 
 
   SmartPtr<ScaledMatrixSpace> scaled_jac_c_space_;
 
   SmartPtr<ScaledMatrixSpace> scaled_jac_d_space_;
 
   SmartPtr<SymScaledMatrixSpace> scaled_h_space_;
 
 
   Number obj_scaling_factor_;
};
 
class IPOPTLIB_EXPORT NoNLPScalingObject: public StandardScalingBase
{
public:
   NoNLPScalingObject()
   { }
 
   virtual ~NoNLPScalingObject()
   { }
 
protected:
   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:
 
   NoNLPScalingObject(
      const NoNLPScalingObject&
   );
 
   void operator=(
      const NoNLPScalingObject&
   );
};
 
} // namespace Ipopt
 
#endif