locopt_ret.h

Go to the documentation of this file.

// Definitions for handling return codes and messages of local optimization IEs  -*- C++ -*-

// $Id: termreason.h 347 2008-02-06 15:20:01Z schilly $
// Copyright (C) 2008 Mihaly Csaba Markot
//
// This file is part of the COCONUT API.  This library
// is free software; you can redistribute it and/or modify it under the
// terms of the Library GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// Library GNU General Public License for more details.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the Library GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the Library GNU General Public License.

#ifndef _LOCOPT_RET_H_
#define _LOCOPT_RET_H_

#include <string>
#include <map>

#include <termreason.h>
#include <inference_engine.h>
#include <api_exception.h>

namespace coco {

// definitions of possible return values of the local optimization IEs:
// SUCCESS:  optimal solution found
// PARTSUCC: partial success, approximate optimal solution found,
//           tolerance cannot be satisfied, no further improvement, etc.
// INFEAS:   problem is claimed infeasible
// UNBND:    problem is claimed unbounded
// LIMIT:    built-in limit exceeded, user requested stop
// ERROR:    return messages of any other type, interpreted as errors
#define LOPT_SUCCESS   0
#define LOPT_PARTSUCC  1
#define LOPT_INFEAS    2
#define LOPT_UNBND     3
#define LOPT_LIMIT     4
#define LOPT_ERROR     5

// definitions of the return weights of the local optimization IEs
#define LOPT_WGHT_SUCCESS   10.0
#define LOPT_WGHT_PARTSUCC   5.0
#define LOPT_WGHT_INFEAS     3.0
#define LOPT_WGHT_UNBND      3.0
#define LOPT_WGHT_LIMIT      1.0
#define LOPT_WGHT_ERROR      0.0

class locopt_ret_record;

// the information related to the IE return is stored in the map below. The key
// is the solver status code (note the difference between this and the IE return
// code!).
typedef std::map<int,locopt_ret_record> locopt_ret;

// determines IE return weight associated to the solver return value srval
// from the ret_info map 
double get_locopt_weight_from_rval(const locopt_ret& ret_info,
                                   const std::string& iename, const int srval);

// determines IE termination reason associated to the solver return value srval
// from the ret_info map 
termination_reason get_locopt_termr_from_rval(const locopt_ret& ret_info,
                                   const std::string& iename, const int srval);

// A record of local optimization return stuff: it consists of a termination
// message and the inference engine return value (encapsulated into a
// termination_reason object) and the inference engine return weight.
// The return values and weights are classified for each local optimization IE
// by the LOPT_* and LOPT_RWGHT_* values defined above.
class locopt_ret_record
{
private:
  termination_reason termr;   // termination reason (message + IE return value)
  double weight;              // IE return weight

  void set_weight(const int val)
  {
    switch (val)
    {
      case (LOPT_SUCCESS):
        weight = LOPT_WGHT_SUCCESS;
      break;
      case (LOPT_PARTSUCC):
        weight = LOPT_WGHT_PARTSUCC;
      break;
      case (LOPT_INFEAS):
        weight = LOPT_WGHT_INFEAS;
      break;
      case (LOPT_UNBND):
        weight = LOPT_WGHT_UNBND;
      break;
      case (LOPT_LIMIT):
        weight = LOPT_WGHT_LIMIT;
      break;
      case (LOPT_ERROR):
        weight = LOPT_WGHT_ERROR;
      break;
      default:
        throw api_exception(apiee_internal,
              std::string("locopt_ret_record::set_weight(): undefined return "
                          "value"));
    }
  }

public:
  locopt_ret_record()
    : termr() { set_weight(termr.get_code()); }

  locopt_ret_record(const termination_reason& t)
    : termr(t) { set_weight(termr.get_code()); }

  locopt_ret_record(const std::string& t_msg, int t_code)
    : termr(t_code,t_msg) { set_weight(t_code); }

  locopt_ret_record(const locopt_ret_record& r)
    : termr(r.termr), weight(r.weight) {}

  locopt_ret_record& operator=(const locopt_ret_record& r)
  {
    if (&r != this)
    {
      termr = r.termr;
      weight = r.weight;
    }
    return *this;
  }

  const termination_reason& get_termr() const { return termr; }

  const std::string& get_message() const { return termr.get_message(); }

  int get_code() const { return termr.get_code(); }

  double get_weight() const { return weight; }

};

} // namespace coco

#endif /* _LOCOPT_RET_H_*/

---