initial add

1 files changed, 451 insertions, 0 deletions

diff --git a/build/Bonmin/include/coin/IpNLPScaling.hpp b/build/Bonmin/include/coin/IpNLPScaling.hpp
new file mode 100644
index 0000000..be5f13d
--- /dev/null
+++ b/build/Bonmin/include/coin/IpNLPScaling.hpp
@@ -0,0 +1,451 @@
+// 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;
+  
+  /** This is the abstract base class for problem scaling.
+   *  It is repsonsible for determining the scaling factors
+   *  and mapping quantities in and out of scaled and unscaled
+   *  versions 
+   */
+  class NLPScalingObject : public ReferencedObject
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    NLPScalingObject();
+
+    /** Default destructor */
+    virtual ~NLPScalingObject();
+    //@}
+
+    /** Method to initialize the options */
+    bool Initialize(const Journalist& jnlst,
+                    const OptionsList& options,
+                    const std::string& prefix)
+    {
+      jnlst_ = &jnlst;
+      return InitializeImpl(options, prefix);
+    }
+
+    /** Methods to map scaled and unscaled matrices */
+    //@{
+    /** Returns an obj-scaled version of the given scalar */
+    virtual Number apply_obj_scaling(const Number& f)=0;
+    /** Returns an obj-unscaled version of the given scalar */
+    virtual Number unapply_obj_scaling(const Number& f)=0;
+    /** Returns an x-scaled version of the given vector */
+    virtual SmartPtr<Vector>
+    apply_vector_scaling_x_NonConst(const SmartPtr<const Vector>& v)=0;
+    /** Returns an x-scaled version of the given vector */
+    virtual SmartPtr<const Vector>
+    apply_vector_scaling_x(const SmartPtr<const Vector>& v)=0;
+    /** Returns an x-unscaled version of the given vector */
+    virtual SmartPtr<Vector>
+    unapply_vector_scaling_x_NonConst(const SmartPtr<const Vector>& v)=0;
+    /** Returns an x-unscaled version of the given vector */
+    virtual SmartPtr<const Vector>
+    unapply_vector_scaling_x(const SmartPtr<const Vector>& v)=0;
+    /** Returns an c-scaled version of the given vector */
+    virtual SmartPtr<const Vector>
+    apply_vector_scaling_c(const SmartPtr<const Vector>& v)=0;
+    /** Returns an c-unscaled version of the given vector */
+    virtual SmartPtr<const Vector>
+    unapply_vector_scaling_c(const SmartPtr<const Vector>& v)=0;
+    /** Returns an c-scaled version of the given vector */
+    virtual SmartPtr<Vector>
+    apply_vector_scaling_c_NonConst(const SmartPtr<const Vector>& v)=0;
+    /** Returns an c-unscaled version of the given vector */
+    virtual SmartPtr<Vector>
+    unapply_vector_scaling_c_NonConst(const SmartPtr<const Vector>& v)=0;
+    /** Returns an d-scaled version of the given vector */
+    virtual SmartPtr<const Vector>
+    apply_vector_scaling_d(const SmartPtr<const Vector>& v)=0;
+    /** Returns an d-unscaled version of the given vector */
+    virtual SmartPtr<const Vector>
+    unapply_vector_scaling_d(const SmartPtr<const Vector>& v)=0;
+    /** Returns an d-scaled version of the given vector */
+    virtual SmartPtr<Vector>
+    apply_vector_scaling_d_NonConst(const SmartPtr<const Vector>& v)=0;
+    /** Returns an d-unscaled version of the given vector */
+    virtual SmartPtr<Vector>
+    unapply_vector_scaling_d_NonConst(const SmartPtr<const Vector>& v)=0;
+    /** Returns a scaled version of the jacobian for c.  If the
+     *  overloaded method does not make a new matrix, make sure to set
+     *  the matrix ptr passed in to NULL.
+     */
+    virtual SmartPtr<const Matrix>
+    apply_jac_c_scaling(SmartPtr<const Matrix> matrix)=0;
+    /** Returns a scaled version of the jacobian for d If the
+     *  overloaded method does not create a new matrix, make sure to
+     *  set the matrix ptr passed in to NULL.
+     */
+    virtual SmartPtr<const Matrix>
+    apply_jac_d_scaling(SmartPtr<const Matrix> matrix)=0;
+    /** Returns a scaled version of the hessian of the lagrangian If
+     *  the overloaded method does not create a new matrix, make sure
+     *  to set the matrix ptr passed in to NULL.
+     */
+    virtual SmartPtr<const SymMatrix>
+    apply_hessian_scaling(SmartPtr<const SymMatrix> matrix)=0;
+    //@}
+
+    /** Methods for scaling bounds - these wrap those above */
+    //@{
+    /** Returns an x-scaled vector in the x_L or x_U space */
+    SmartPtr<Vector> apply_vector_scaling_x_LU_NonConst(
+      const Matrix& Px_LU,
+      const SmartPtr<const Vector>& lu,
+      const VectorSpace& x_space);
+    /** Returns an x-scaled vector in the x_L or x_U space */
+    SmartPtr<const Vector> apply_vector_scaling_x_LU(
+      const Matrix& Px_LU,
+      const SmartPtr<const Vector>& lu,
+      const VectorSpace& x_space);
+    /** Returns an d-scaled vector in the d_L or d_U space */
+    SmartPtr<Vector> apply_vector_scaling_d_LU_NonConst(
+      const Matrix& Pd_LU,
+      const SmartPtr<const Vector>& lu,
+      const VectorSpace& d_space);
+    /** Returns an d-scaled vector in the d_L or d_U space */
+    SmartPtr<const Vector> apply_vector_scaling_d_LU(
+      const Matrix& Pd_LU,
+      const SmartPtr<const Vector>& lu,
+      const VectorSpace& d_space);
+    /** Returns an d-unscaled vector in the d_L or d_U space */
+    SmartPtr<Vector> unapply_vector_scaling_d_LU_NonConst(
+      const Matrix& Pd_LU,
+      const SmartPtr<const Vector>& lu,
+      const VectorSpace& d_space);
+    /** Returns an d-unscaled vector in the d_L or d_U space */
+    SmartPtr<const Vector> unapply_vector_scaling_d_LU(
+      const Matrix& Pd_LU,
+      const SmartPtr<const Vector>& lu,
+      const VectorSpace& d_space);
+    //@}
+
+    /** Methods for scaling the gradient of the objective - wraps the
+     *  virtual methods above
+     */
+    //@{
+    /** Returns a grad_f scaled version (d_f * D_x^{-1}) of the given vector */
+    virtual SmartPtr<Vector>
+    apply_grad_obj_scaling_NonConst(const SmartPtr<const Vector>& v);
+    /** Returns a grad_f scaled version (d_f * D_x^{-1}) of the given vector */
+    virtual SmartPtr<const Vector>
+    apply_grad_obj_scaling(const SmartPtr<const Vector>& v);
+    /** Returns a grad_f unscaled version (d_f * D_x^{-1}) of the
+     *  given vector */
+    virtual SmartPtr<Vector>
+    unapply_grad_obj_scaling_NonConst(const SmartPtr<const Vector>& v);
+    /** Returns a grad_f unscaled version (d_f * D_x^{-1}) of the
+     *  given vector */
+    virtual SmartPtr<const Vector>
+    unapply_grad_obj_scaling(const SmartPtr<const Vector>& v);
+    //@}
+
+    /** @name Methods for determining whether scaling for entities is
+     *  done */
+    //@{
+    /** Returns true if the primal x variables are scaled. */
+    virtual bool have_x_scaling()=0;
+    /** Returns true if the equality constraints are scaled. */
+    virtual bool have_c_scaling()=0;
+    /** Returns true if the inequality constraints are scaled. */
+    virtual bool have_d_scaling()=0;
+    //@}
+
+    /** This method is called by the IpoptNLP's at a convenient time to
+     *  compute and/or read scaling factors 
+     */
+    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:
+    /** Implementation of the initialization method that has to be
+     *  overloaded by for each derived class. */
+    virtual bool InitializeImpl(const OptionsList& options,
+                                const std::string& prefix)=0;
+
+    /** Accessor method for the journalist */
+    const Journalist& Jnlst() const
+    {
+      return *jnlst_;
+    }
+  private:
+
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+
+    /** Copy Constructor */
+    NLPScalingObject(const NLPScalingObject&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const NLPScalingObject&);
+    //@}
+
+    SmartPtr<const Journalist> jnlst_;
+  };
+
+  /** This is a base class for many standard scaling
+   *  techniques. The overloaded classes only need to
+   *  provide the scaling parameters
+   */
+  class StandardScalingBase : public NLPScalingObject
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    StandardScalingBase();
+
+    /** Default destructor */
+    virtual ~StandardScalingBase();
+    //@}
+
+    /** Methods to map scaled and unscaled matrices */
+    //@{
+    /** Returns an obj-scaled version of the given scalar */
+    virtual Number apply_obj_scaling(const Number& f);
+    /** Returns an obj-unscaled version of the given scalar */
+    virtual Number unapply_obj_scaling(const Number& f);
+    /** Returns an x-scaled version of the given vector */
+    virtual SmartPtr<Vector>
+    apply_vector_scaling_x_NonConst(const SmartPtr<const Vector>& v);
+    /** Returns an x-scaled version of the given vector */
+    virtual SmartPtr<const Vector>
+    apply_vector_scaling_x(const SmartPtr<const Vector>& v);
+    /** Returns an x-unscaled version of the given vector */
+    virtual SmartPtr<Vector>
+    unapply_vector_scaling_x_NonConst(const SmartPtr<const Vector>& v);
+    /** Returns an x-unscaled version of the given vector */
+    virtual SmartPtr<const Vector>
+    unapply_vector_scaling_x(const SmartPtr<const Vector>& v);
+    /** Returns an c-scaled version of the given vector */
+    virtual SmartPtr<const Vector>
+    apply_vector_scaling_c(const SmartPtr<const Vector>& v);
+    /** Returns an c-unscaled version of the given vector */
+    virtual SmartPtr<const Vector>
+    unapply_vector_scaling_c(const SmartPtr<const Vector>& v);
+    /** Returns an c-scaled version of the given vector */
+    virtual SmartPtr<Vector>
+    apply_vector_scaling_c_NonConst(const SmartPtr<const Vector>& v);
+    /** Returns an c-unscaled version of the given vector */
+    virtual SmartPtr<Vector>
+    unapply_vector_scaling_c_NonConst(const SmartPtr<const Vector>& v);
+    /** Returns an d-scaled version of the given vector */
+    virtual SmartPtr<const Vector>
+    apply_vector_scaling_d(const SmartPtr<const Vector>& v);
+    /** Returns an d-unscaled version of the given vector */
+    virtual SmartPtr<const Vector>
+    unapply_vector_scaling_d(const SmartPtr<const Vector>& v);
+    /** Returns an d-scaled version of the given vector */
+    virtual SmartPtr<Vector>
+    apply_vector_scaling_d_NonConst(const SmartPtr<const Vector>& v);
+    /** Returns an d-unscaled version of the given vector */
+    virtual SmartPtr<Vector>
+    unapply_vector_scaling_d_NonConst(const SmartPtr<const Vector>& v);
+    /** Returns a scaled version of the jacobian for c.  If the
+     *  overloaded method does not make a new matrix, make sure to set
+     *  the matrix ptr passed in to NULL.
+     */
+    virtual SmartPtr<const Matrix>
+    apply_jac_c_scaling(SmartPtr<const Matrix> matrix);
+    /** Returns a scaled version of the jacobian for d If the
+     *  overloaded method does not create a new matrix, make sure to
+     *  set the matrix ptr passed in to NULL.
+     */
+    virtual SmartPtr<const Matrix>
+    apply_jac_d_scaling(SmartPtr<const Matrix> matrix);
+    /** Returns a scaled version of the hessian of the lagrangian If
+     *  the overloaded method does not create a new matrix, make sure
+     *  to set the matrix ptr passed in to NULL.
+     */
+    virtual SmartPtr<const SymMatrix>
+    apply_hessian_scaling(SmartPtr<const SymMatrix> matrix);
+    //@}
+
+    /** @name Methods for determining whether scaling for entities is
+     *  done */
+    //@{
+    virtual bool have_x_scaling();
+    virtual bool have_c_scaling();
+    virtual bool have_d_scaling();
+    //@}
+
+    /** This method is called by the IpoptNLP's at a convenient time to
+     *  compute and/or read scaling factors 
+     */
+    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);
+
+    /** Methods for IpoptType */
+    //@{
+    static void RegisterOptions(SmartPtr<RegisteredOptions> roptions);
+    //@}
+
+  protected:
+    /** Overloaded initialization method */
+    virtual bool InitializeImpl(const OptionsList& options,
+                                const std::string& prefix);
+
+    /** This is the method that has to be overloaded by a particular
+     *  scaling method that somehow computes the scaling vectors dx,
+     *  dc, and dd.  The pointers to those vectors can be NULL, in
+     *  which case no scaling for that item will be done later. */
+    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:
+
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+
+    /** Copy Constructor */
+    StandardScalingBase(const StandardScalingBase&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const StandardScalingBase&);
+    //@}
+
+    /** Scaling parameters - we only need to keep copies of
+     *  the objective scaling and the x scaling - the others we can
+     *  get from the scaled matrix spaces.
+     */
+    //@{
+    /** objective scaling parameter */
+    Number df_;
+    /** x scaling */
+    SmartPtr<Vector> dx_;
+    //@}
+
+    /** Scaled Matrix Spaces */
+    //@{
+    /** Scaled jacobian of c space */
+    SmartPtr<ScaledMatrixSpace> scaled_jac_c_space_;
+    /** Scaled jacobian of d space */
+    SmartPtr<ScaledMatrixSpace> scaled_jac_d_space_;
+    /** Scaled hessian of lagrangian spacea */
+    SmartPtr<SymScaledMatrixSpace> scaled_h_space_;
+    //@}
+
+    /** @name Algorithmic parameters */
+    //@{
+    /** Additional scaling value for the objective function */
+    Number obj_scaling_factor_;
+    //@}
+  };
+
+  /** Class implementing the scaling object that doesn't to any scaling */
+  class NoNLPScalingObject : public StandardScalingBase
+  {
+  public:
+    /**@name Constructors/Destructors */
+    //@{
+    NoNLPScalingObject()
+    {}
+
+    /** Default destructor */
+    virtual ~NoNLPScalingObject()
+    {}
+    //@}
+
+
+  protected:
+    /** Overloaded from StandardScalingBase */
+    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:
+
+    /**@name Default Compiler Generated Methods
+     * (Hidden to avoid implicit creation/calling).
+     * These methods are not implemented and 
+     * we do not want the compiler to implement
+     * them for us, so we declare them private
+     * and do not define them. This ensures that
+     * they will not be implicitly created/called. */
+    //@{
+
+    /** Copy Constructor */
+    NoNLPScalingObject(const NoNLPScalingObject&);
+
+    /** Overloaded Equals Operator */
+    void operator=(const NoNLPScalingObject&);
+    //@}
+  };
+
+} // namespace Ipopt
+
+#endif