IpTNLPAdapter.hpp

Go to the documentation of this file.

// Copyright (C) 2004, 2006 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Common Public License.
//
// $Id: IpTNLPAdapter.hpp 759 2006-07-07 03:07:08Z andreasw $
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13

#ifndef __IPTNLPADAPTER_HPP__
#define __IPTNLPADAPTER_HPP__

#include "IpNLP.hpp"
#include "IpTNLP.hpp"
#include "IpOrigIpoptNLP.hpp"

namespace Ipopt
{

  // forward declarations
  class ExpansionMatrix;
  class ExpansionMatrixSpace;
  class IteratesVector;

  class TNLPAdapter : public NLP
  {
  public:
    TNLPAdapter(const SmartPtr<TNLP> tnlp,
                const SmartPtr<const Journalist> jnlst = NULL);

    virtual ~TNLPAdapter();

    DECLARE_STD_EXCEPTION(INVALID_TNLP);
    DECLARE_STD_EXCEPTION(ERROR_IN_TNLP_DERIVATIVE_TEST);

    virtual bool ProcessOptions(const OptionsList& options,
                                const std::string& prefix);

    virtual bool 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);

    virtual bool GetBoundsInformation(const Matrix& Px_L,
                                      Vector& x_L,
                                      const Matrix& Px_U,
                                      Vector& x_U,
                                      const Matrix& Pd_L,
                                      Vector& d_L,
                                      const Matrix& Pd_U,
                                      Vector& d_U);

    virtual bool GetStartingPoint(
      SmartPtr<Vector> x,
      bool need_x,
      SmartPtr<Vector> y_c,
      bool need_y_c,
      SmartPtr<Vector> y_d,
      bool need_y_d,
      SmartPtr<Vector> z_L,
      bool need_z_L,
      SmartPtr<Vector> z_U,
      bool need_z_U
    );

    virtual bool GetWarmStartIterate(IteratesVector& warm_start_iterate);

    virtual bool Eval_f(const Vector& x, Number& f);

    virtual bool Eval_grad_f(const Vector& x, Vector& g_f);

    virtual bool Eval_c(const Vector& x, Vector& c);

    virtual bool Eval_jac_c(const Vector& x, Matrix& jac_c);

    virtual bool Eval_d(const Vector& x, Vector& d);

    virtual bool Eval_jac_d(const Vector& x, Matrix& jac_d);

    virtual bool Eval_h(const Vector& x,
                        Number obj_factor,
                        const Vector& yc,
                        const Vector& yd,
                        SymMatrix& h);

    virtual void GetScalingParameters(
      const SmartPtr<const VectorSpace> x_space,
      const SmartPtr<const VectorSpace> c_space,
      const SmartPtr<const VectorSpace> d_space,
      Number& obj_scaling,
      SmartPtr<Vector>& x_scaling,
      SmartPtr<Vector>& c_scaling,
      SmartPtr<Vector>& d_scaling) const;

    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);
    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,
                                      const IpoptData* ip_data,
                                      IpoptCalculatedQuantities* ip_cq);

    virtual void
    GetQuasiNewtonApproximationSpaces(SmartPtr<VectorSpace>& approx_space,
                                      SmartPtr<Matrix>& P_approx);

    enum FixedVariableTreatmentEnum {
      MAKE_PARAMETER=0,
      MAKE_CONSTRAINT
    };

    enum DerivativeTestEnum {
      NO_TEST=0,
      FIRST_ORDER_TEST,
      SECOND_ORDER_TEST
    };

    bool CheckDerivatives(DerivativeTestEnum deriv_test);

    static void RegisterOptions(SmartPtr<RegisteredOptions> roptions);

    SmartPtr<TNLP> tnlp() const
    {
      return tnlp_;
    }

  private:
    TNLPAdapter(const TNLPAdapter&);

    void operator=(const TNLPAdapter&);

    void ResortX(const Vector& x, Number* x_orig);
    void ResortG(const Vector& c, const Vector& d, Number *g_orig);
    void ResortBnds(const Vector& x_L, Number* x_L_orig,
                    const Vector& x_U, Number* x_U_orig);

    SmartPtr<TNLP> tnlp_;

    SmartPtr<const Journalist> jnlst_;

    Number nlp_lower_bound_inf_;
    Number nlp_upper_bound_inf_;
    FixedVariableTreatmentEnum fixed_variable_treatment_;
    /* Maximal slack for one-sidedly bounded variables.  If a
     *  variable has only one bound, say a lower bound xL, then an
     *  upper bound xL + max_onesided_bound_slack_.  If this value is
     *  zero, no upper bound is added. */
    /* Took this out:  Number max_onesided_bound_slack_; */
    DerivativeTestEnum derivative_test_;
    Number derivative_test_perturbation_;
    Number derivative_test_tol_;
    bool derivative_test_print_all_;
    bool warm_start_same_structure_;
    HessianApproximationType hessian_approximation_;

    Index n_full_x_;
    Index n_full_g_;
    Index nz_jac_c_;
    Index nz_jac_c_no_fixed_;
    Index nz_jac_d_;
    Index nz_full_jac_g_;
    Index nz_full_h_;
    Index nz_h_;
    Index n_x_fixed_;

    TNLP::IndexStyleEnum index_style_;

    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_;

    Number* full_x_; 
    Number* full_lambda_; 
    Number* full_g_; 
    Number* jac_g_; 
    Number* c_rhs_; 

    TaggedObject::Tag x_tag_for_iterates_;
    TaggedObject::Tag y_c_tag_for_iterates_;
    TaggedObject::Tag y_d_tag_for_iterates_;
    TaggedObject::Tag x_tag_for_g_;
    TaggedObject::Tag x_tag_for_jac_g_;

    bool update_local_x(const Vector& x);
    bool update_local_lambda(const Vector& y_c, const Vector& y_d);

    bool internal_eval_g(bool new_x);
    bool internal_eval_jac_g(bool new_x);

    SmartPtr<ExpansionMatrix> P_x_full_x_;
    SmartPtr<ExpansionMatrixSpace> P_x_full_x_space_;

    SmartPtr<ExpansionMatrix> P_x_x_L_;
    SmartPtr<ExpansionMatrixSpace> P_x_x_L_space_;

    SmartPtr<ExpansionMatrix> P_x_x_U_;
    SmartPtr<ExpansionMatrixSpace> P_x_x_U_space_;

    SmartPtr<ExpansionMatrixSpace> P_c_g_space_;
    SmartPtr<ExpansionMatrix> P_c_g_;

    SmartPtr<ExpansionMatrixSpace> P_d_g_space_;
    SmartPtr<ExpansionMatrix> P_d_g_;

    Index* jac_idx_map_;
    Index* h_idx_map_;

    Index* x_fixed_map_;
  };

} // namespace Ipopt

#endif