objbounds_hook.h

Go to the documentation of this file.

// Search Node objbounds updated computation hook implementation -*- C++ -*-

// $Id: objbounds_hook.h 963 2010-02-04 13:16:40Z herman $
// Copyright (C) 2003 Hermann Schichl
//
// 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 _OBJBOUNDS_HOOK_H
#define _OBJBOUNDS_HOOK_H

#include <comp_hook.h>
#include <int_evaluator.h>
#include <bound_delta.h>

namespace coco {


class objbounds_comp_hook : public wnc_hook_base
{
private:
  bool update_bounds;
  bool create_delta;

public:
  objbounds_comp_hook(bool _ub = false, bool _cd = false)
     : wnc_hook_base("objbounds"),
       update_bounds(_ub), create_delta(_cd)
    {}

  virtual ~objbounds_comp_hook() {}

  objbounds_comp_hook* new_copy() const
        { return new objbounds_comp_hook(*this); }

  void operator()(const work_node& wn, dbt_row& dbr,
                  std::list<delta>* add_ds = NULL,
                  std::list<certificate>* add_cs = NULL) const
  {
    const model* m = wn.get_model();
    model::const_walker w(m->objective);
    interval _h(0.);
    double _s;

    if(m->ocoeff != 0)
    {
      if(update_bounds)
      {
        unsigned int nvars(m->number_of_variables());
        variable_indicator vi(nvars);
        std::vector<interval> box(nvars, 0.);
        interval rg;

        vi.set(0,nvars);

        for(unsigned int i = 0; i < nvars; ++i)
          box[i] = wn.node_ranges[m->var(i)->node_num];
        interval_eval ie(box, vi, *m, NULL, true);

        _h = evaluate(ie, w)*m->ocoeff;
        _h.intersectwith(wn.node_ranges[w->node_num]);
      }
      else
        _h = wn.node_ranges[w->node_num];

      if(update_bounds && create_delta && add_ds && add_cs &&
         _h != wn.node_ranges[w->node_num])
      {
        (*add_ds).push_back(delta(bound_delta(w->node_num, _h)));
        (*add_cs).push_back(
             certificate(rigorous_module_certificate("objbounds_hook")));
      }
      
      _s = m->ocoeff;
      _h *= _s;
    }
    else
      _h = 0;

    dbr.add("obj lowbound", _h.inf());
    dbr.add("obj upbound", _h.sup());
    dbr.add("obj diameter", _h.diam());
  }

  bool init_columns(vdbl::standard_table& stable)
  {
    bool ret = _init_column(stable, "obj lowbound", -COCO_INF);
    ret = _init_column(stable, "obj upbound", COCO_INF) || ret;
    ret = _init_column(stable, "obj diameter", COCO_INF) || ret;
    return ret;
  }

  bool drop_columns(vdbl::standard_table& stable)
        { return _drop_columns(stable); }
};

} // namespace coco

#endif // _OBJBOUNDS_HOOK_H

---