diff options
Diffstat (limited to 'thirdparty/linux/include/coin1/IpNLPScaling.hpp')
| -rw-r--r-- | thirdparty/linux/include/coin1/IpNLPScaling.hpp | 451 |
1 files changed, 451 insertions, 0 deletions
diff --git a/thirdparty/linux/include/coin1/IpNLPScaling.hpp b/thirdparty/linux/include/coin1/IpNLPScaling.hpp new file mode 100644 index 0000000..be5f13d --- /dev/null +++ b/thirdparty/linux/include/coin1/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 |