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.
//
// $Id: IpNLPScaling.hpp 2269 2013-05-05 11:32:40Z stefan $
//
// 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 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 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 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