IANlp.hpp

Go to the documentation of this file.

// IANnl.hpp
// Interval Assignment for Meshkit
//
// This is the solver-translation from Meshkit to the ipopt library
// Here we provide the functions that ipopt needs to solve the optimization problem
//
// Adapted from: 
// Copyright (C) 2005, 2007 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// $Id: hs071_nlp.hpp 1864 2010-12-22 19:21:02Z andreasw $
//
// Authors:  Carl Laird, Andreas Waechter     IBM    2005-08-09

#ifndef MESHKIT_IA_IANLP_HP
#define MESHKIT_IA_IANLP_HP

#include "MKVersion.h"

#include "IpTNLP.hpp"
//using namespace Ipopt;
using Ipopt::Index;
using Ipopt::Number;
using Ipopt::SolverReturn;
using Ipopt::IpoptData;
using Ipopt::IpoptCalculatedQuantities;
using Ipopt::TNLP;
// IndexStyleEnum defined by Ipopt in global space

namespace MeshKit 
{
    
class IAData;
class IASolution;

class IANlp : public TNLP
{
public:
  IANlp(const IAData *data_ptr, IASolution *solution_ptr, const bool set_silent = true); 

  virtual ~IANlp();
  
  virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g,
                            Index& nnz_h_lag, IndexStyleEnum& index_style);

  virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u,
                               Index m, Number* g_l, Number* g_u);

  virtual bool get_starting_point(Index n, bool init_x, Number* x_init,
                                  bool init_z, Number* z_L, Number* z_U,
                                  Index m, bool init_lambda,
                                  Number* lambda);

  virtual bool eval_f(Index n, const Number* x, bool new_x, Number& obj_value);

  virtual bool eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f);

  virtual bool eval_g(Index n, const Number* x, bool new_x, Index m, Number* g);

  virtual bool eval_jac_g(Index n, const Number* x, bool new_x,
                          Index m, Index nele_jac, Index* iRow, Index *jCol,
                          Number* values);

  virtual bool eval_h(Index n, const Number* x, bool new_x,
                      Number obj_factor, Index m, const Number* lambda,
                      bool new_lambda, Index nele_hess, Index* iRow,
                      Index* jCol, Number* values);


  virtual void finalize_solution(SolverReturn status,
                                 Index n, const Number* x, const Number* z_L, const Number* z_U,
                                 Index m, const Number* g, const Number* lambda,
                                 Number obj_value,
                                 const IpoptData *ip_data,
                                 IpoptCalculatedQuantities* ip_cq);
  
  // Common routines, could be used by other Nlp's 
  int get_neleJac() const { return neleJac; }
  
        // return the value of the ith sum-even constraint, given current values of x
  double eval_even_sum(const int i, const Number* x) const;
  
        // return the value of the ith sum-equal constraint, given current values of x
  double eval_equal_sum(const int i, const Number* x) const;

private:  
  // hide untrusted default methods
  //  IA_NLP();
  IANlp();
  IANlp(const IANlp&);
  IANlp& operator=(const IANlp&);
  
  // input data
  const IAData *data;
  static const int p_norm;
  // solution data
  IASolution *solution;
  int neleJac;
  
  const bool silent;
  const bool debugging;
  const bool verbose; // verbose debugging
  
  // internally used methods
  // contributions of one variable to the objective function and gradient
  // underlying function 


  // r functions: if x>I then x-I / I else I-x / x
  static Number eval_r_i(const Number& I_i, const Number& x_i); 
  static Number eval_grad_r_i(const Number& I_i, const Number& x_i); 
  static Number eval_hess_r_i(const Number& I_i, const Number& x_i); 

  // s functions: r weighted by x: r*x
  static Number eval_s_i(const Number& I_i, const Number& x_i); 
  static Number eval_grad_s_i(const Number& I_i, const Number& x_i); 
  static Number eval_hess_s_i(const Number& I_i, const Number& x_i); 

  // Capital functions, l-p norms of the lowercase functions
public:
  static Number eval_R_i(const Number& I_i, const Number& x_i); 
private:
  static Number eval_grad_R_i(const Number& I_i, const Number& x_i); 
  static Number eval_hess_R_i(const Number& I_i, const Number& x_i); 

  static Number eval_S_i(const Number& I_i, const Number& x_i); 
  static Number eval_grad_S_i(const Number& I_i, const Number& x_i); 
  static Number eval_hess_S_i(const Number& I_i, const Number& x_i); 
  

};

} // namespace MeshKit 

#endif