You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
261 lines
9.6 KiB
261 lines
9.6 KiB
// Copyright (C) 2004, 2006 International Business Machines and others.
|
|
// All Rights Reserved.
|
|
// This code is published under the Eclipse Public License.
|
|
//
|
|
// $Id: IpIpoptNLP.hpp 2594 2015-08-09 14:31:05Z stefan $
|
|
//
|
|
// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13
|
|
|
|
#ifndef __IPIPOPTNLP_HPP__
|
|
#define __IPIPOPTNLP_HPP__
|
|
|
|
#include "IpNLP.hpp"
|
|
#include "IpJournalist.hpp"
|
|
#include "IpNLPScaling.hpp"
|
|
|
|
namespace Ipopt
|
|
{
|
|
// forward declarations
|
|
class IteratesVector;
|
|
|
|
/** This is the abstract base class for classes that map
|
|
* the traditional NLP into
|
|
* something that is more useful by Ipopt.
|
|
* This class takes care of storing the
|
|
* calculated model results, handles cacheing,
|
|
* and (some day) takes care of addition of slacks.
|
|
*/
|
|
class IpoptNLP : public ReferencedObject
|
|
{
|
|
public:
|
|
/**@name Constructors/Destructors */
|
|
//@{
|
|
IpoptNLP(const SmartPtr<NLPScalingObject> nlp_scaling)
|
|
:
|
|
nlp_scaling_(nlp_scaling)
|
|
{}
|
|
|
|
/** Default destructor */
|
|
virtual ~IpoptNLP()
|
|
{}
|
|
//@}
|
|
|
|
/** Initialization method. Set the internal options and
|
|
* initialize internal data structures. */
|
|
virtual bool Initialize(const Journalist& jnlst,
|
|
const OptionsList& options,
|
|
const std::string& prefix)
|
|
{
|
|
bool ret = true;
|
|
if (IsValid(nlp_scaling_)) {
|
|
ret = nlp_scaling_->Initialize(jnlst, options, prefix);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/**@name Possible Exceptions */
|
|
//@{
|
|
/** thrown if there is any error evaluating values from the nlp */
|
|
DECLARE_STD_EXCEPTION(Eval_Error);
|
|
//@}
|
|
/** Initialize (create) structures for
|
|
* the iteration data */
|
|
virtual bool InitializeStructures(SmartPtr<Vector>& x,
|
|
bool init_x,
|
|
SmartPtr<Vector>& y_c,
|
|
bool init_y_c,
|
|
SmartPtr<Vector>& y_d,
|
|
bool init_y_d,
|
|
SmartPtr<Vector>& z_L,
|
|
bool init_z_L,
|
|
SmartPtr<Vector>& z_U,
|
|
bool init_z_U,
|
|
SmartPtr<Vector>& v_L,
|
|
SmartPtr<Vector>& v_U
|
|
) = 0;
|
|
|
|
/** Method accessing the GetWarmStartIterate of the NLP */
|
|
virtual bool GetWarmStartIterate(IteratesVector& warm_start_iterate)=0;
|
|
|
|
/** Accessor methods for model data */
|
|
//@{
|
|
/** Objective value */
|
|
virtual Number f(const Vector& x) = 0;
|
|
|
|
/** Gradient of the objective */
|
|
virtual SmartPtr<const Vector> grad_f(const Vector& x) = 0;
|
|
|
|
/** Equality constraint residual */
|
|
virtual SmartPtr<const Vector> c(const Vector& x) = 0;
|
|
|
|
/** Jacobian Matrix for equality constraints */
|
|
virtual SmartPtr<const Matrix> jac_c(const Vector& x) = 0;
|
|
|
|
/** Inequality constraint residual (reformulated
|
|
* as equalities with slacks */
|
|
virtual SmartPtr<const Vector> d(const Vector& x) = 0;
|
|
|
|
/** Jacobian Matrix for inequality constraints */
|
|
virtual SmartPtr<const Matrix> jac_d(const Vector& x) = 0;
|
|
|
|
/** Hessian of the Lagrangian */
|
|
virtual SmartPtr<const SymMatrix> h(const Vector& x,
|
|
Number obj_factor,
|
|
const Vector& yc,
|
|
const Vector& yd
|
|
) = 0;
|
|
|
|
/** Lower bounds on x */
|
|
virtual SmartPtr<const Vector> x_L() const = 0;
|
|
|
|
/** Permutation matrix (x_L_ -> x) */
|
|
virtual SmartPtr<const Matrix> Px_L() const = 0;
|
|
|
|
/** Upper bounds on x */
|
|
virtual SmartPtr<const Vector> x_U() const = 0;
|
|
|
|
/** Permutation matrix (x_U_ -> x */
|
|
virtual SmartPtr<const Matrix> Px_U() const = 0;
|
|
|
|
/** Lower bounds on d */
|
|
virtual SmartPtr<const Vector> d_L() const = 0;
|
|
|
|
/** Permutation matrix (d_L_ -> d) */
|
|
virtual SmartPtr<const Matrix> Pd_L() const = 0;
|
|
|
|
/** Upper bounds on d */
|
|
virtual SmartPtr<const Vector> d_U() const = 0;
|
|
|
|
/** Permutation matrix (d_U_ -> d */
|
|
virtual SmartPtr<const Matrix> Pd_U() const = 0;
|
|
|
|
/** x_space */
|
|
virtual SmartPtr<const VectorSpace> x_space() const = 0;
|
|
|
|
/** Accessor method to obtain the MatrixSpace for the Hessian
|
|
* matrix (or it's approximation) */
|
|
virtual SmartPtr<const SymMatrixSpace> HessianMatrixSpace() const = 0;
|
|
//@}
|
|
|
|
/** Accessor method for vector/matrix spaces pointers. */
|
|
virtual void GetSpaces(SmartPtr<const VectorSpace>& x_space,
|
|
SmartPtr<const VectorSpace>& c_space,
|
|
SmartPtr<const VectorSpace>& d_space,
|
|
SmartPtr<const VectorSpace>& x_l_space,
|
|
SmartPtr<const MatrixSpace>& px_l_space,
|
|
SmartPtr<const VectorSpace>& x_u_space,
|
|
SmartPtr<const MatrixSpace>& px_u_space,
|
|
SmartPtr<const VectorSpace>& d_l_space,
|
|
SmartPtr<const MatrixSpace>& pd_l_space,
|
|
SmartPtr<const VectorSpace>& d_u_space,
|
|
SmartPtr<const MatrixSpace>& pd_u_space,
|
|
SmartPtr<const MatrixSpace>& Jac_c_space,
|
|
SmartPtr<const MatrixSpace>& Jac_d_space,
|
|
SmartPtr<const SymMatrixSpace>& Hess_lagrangian_space) = 0;
|
|
|
|
/** Method for adapting the variable bounds. This is called if
|
|
* slacks are becoming too small */
|
|
virtual void AdjustVariableBounds(const Vector& new_x_L,
|
|
const Vector& new_x_U,
|
|
const Vector& new_d_L,
|
|
const Vector& new_d_U)=0;
|
|
|
|
/** @name Counters for the number of function evaluations. */
|
|
//@{
|
|
virtual Index f_evals() const = 0;
|
|
virtual Index grad_f_evals() const = 0;
|
|
virtual Index c_evals() const = 0;
|
|
virtual Index jac_c_evals() const = 0;
|
|
virtual Index d_evals() const = 0;
|
|
virtual Index jac_d_evals() const = 0;
|
|
virtual Index h_evals() const = 0;
|
|
//@}
|
|
|
|
/** @name Special method for dealing with the fact that the
|
|
* restoration phase objective function depends on the barrier
|
|
* parameter */
|
|
//@{
|
|
/** Method for telling the IpoptCalculatedQuantities class whether
|
|
* the objective function depends on the barrier function. This
|
|
* is only used for the restoration phase NLP
|
|
* formulation. Probably only RestoIpoptNLP should overwrite
|
|
* this. */
|
|
virtual bool objective_depends_on_mu() const
|
|
{
|
|
return false;
|
|
}
|
|
|
|
/** Replacement for the default objective function method which
|
|
* knows about the barrier parameter */
|
|
virtual Number f(const Vector& x, Number mu) = 0;
|
|
|
|
/** Replacement for the default objective gradient method which
|
|
* knows about the barrier parameter */
|
|
virtual SmartPtr<const Vector> grad_f(const Vector& x, Number mu) = 0;
|
|
|
|
/** Replacement for the default Lagrangian Hessian method which
|
|
* knows about the barrier parameter */
|
|
virtual SmartPtr<const SymMatrix> h(const Vector& x,
|
|
Number obj_factor,
|
|
const Vector& yc,
|
|
const Vector& yd,
|
|
Number mu) = 0;
|
|
|
|
/** Provides a Hessian matrix from the correct matrix space with
|
|
* uninitialized values. This can be used in LeastSquareMults to
|
|
* obtain a "zero Hessian". */
|
|
virtual SmartPtr<const SymMatrix> uninitialized_h() = 0;
|
|
//@}
|
|
|
|
/**@name solution routines */
|
|
//@{
|
|
virtual void FinalizeSolution(SolverReturn status,
|
|
const Vector& x, const Vector& z_L, const Vector& z_U,
|
|
const Vector& c, const Vector& d,
|
|
const Vector& y_c, const Vector& y_d,
|
|
Number obj_value,
|
|
const IpoptData* ip_data,
|
|
IpoptCalculatedQuantities* ip_cq)=0;
|
|
|
|
virtual bool IntermediateCallBack(AlgorithmMode mode,
|
|
Index iter, Number obj_value,
|
|
Number inf_pr, Number inf_du,
|
|
Number mu, Number d_norm,
|
|
Number regularization_size,
|
|
Number alpha_du, Number alpha_pr,
|
|
Index ls_trials,
|
|
SmartPtr<const IpoptData> ip_data,
|
|
SmartPtr<IpoptCalculatedQuantities> ip_cq)=0;
|
|
//@}
|
|
|
|
/** Returns the scaling strategy object */
|
|
SmartPtr<NLPScalingObject> NLP_scaling() const
|
|
{
|
|
DBG_ASSERT(IsValid(nlp_scaling_));
|
|
return nlp_scaling_;
|
|
}
|
|
|
|
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 */
|
|
IpoptNLP(const IpoptNLP&);
|
|
|
|
/** Overloaded Equals Operator */
|
|
void operator=(const IpoptNLP&);
|
|
//@}
|
|
|
|
SmartPtr<NLPScalingObject> nlp_scaling_;
|
|
};
|
|
|
|
} // namespace Ipopt
|
|
|
|
#endif
|
|
|