SmagMINLP.hpp

Go to the documentation of this file.

// Copyright (C) GAMS Development 2007
// All Rights Reserved.
// This code is published under the Common Public License.
//
// $Id: SmagMINLP.hpp 510 2008-08-16 19:31:27Z stefan $
//
// Authors:  Steve Dirkse, Stefan Vigerske

#ifndef __SMAGMINLP_HPP__
#define __SMAGMINLP_HPP__

#include "GAMSlinksConfig.h"

#include "BonTMINLP.hpp"

// smag.h will try to include stdio.h and stdarg.h
// so we include cstdio and cstdarg before if we know that we have them
#ifdef HAVE_CSTDIO
#include <cstdio>
#endif
#ifdef HAVE_CSTDARG
#include <cstdarg>
#endif
#include "smag.h"

using namespace Ipopt;
using namespace Bonmin;

class SMAG_MINLP : public TMINLP {
public:
  SMAG_MINLP (smagHandle_t prob);

  virtual ~SMAG_MINLP();

  virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g,
                            Index& nnz_h_lag, TNLP::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_variables_types(Index n, VariableType* var_types);

  virtual bool get_variables_linearity(Index n, Ipopt::TNLP::LinearityType* var_linearity);

  virtual bool get_constraints_linearity(Index m, Ipopt::TNLP::LinearityType* const_types);


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

  virtual bool get_scaling_parameters(Number &obj_scaling,
                bool &use_x_scaling, Index n, Number *x_scaling,
                bool &use_g_scaling, Index m, Number *g_scaling);

  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_gi(Index n, const Number* x, bool new_x, Index i, Number& gi);
        
        virtual bool eval_grad_gi(Index n, const Number* x, bool new_x,
                Index i, Index& nele_grad_gi, 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(TMINLP::SolverReturn status,Index n, const Number* x, Number obj_value);

  virtual const SosInfo* sosConstraints() const;
  
  virtual const BranchingInfo* branchingInfo() const;

        double div_iter_tol;
        long int domviolations;
        double clock_start; // time when solving starts
        int model_status, solver_status;
private:
  smagHandle_t prob;
  double *negLambda;
  double isMin;
//      long int domviollimit;

        SosInfo sosinfo;
        BranchingInfo branchinginfo;

  /* Methods to block default compiler methods.
   * The compiler automatically generates the following three methods.
   *  Since the default compiler implementation is generally not what
   *  you want (for all but the most simple classes), we usually 
   *  put the declarations of these methods in the private section
   *  and never implement them. This prevents the compiler from
   *  implementing an incorrect "default" behavior without us
   *  knowing. (See Scott Meyers book, "Effective C++")
   */
        SMAG_MINLP();
  SMAG_MINLP(const SMAG_MINLP&);
  SMAG_MINLP& operator=(const SMAG_MINLP&);

  void setupPrioritiesSOS();
};


#endif /* ifndef __SMAGMINLP_HPP__ */