---

annotation.h

Go to the documentation of this file.

// Annotation implementation -*- C++ -*-

// Copyright (C) 2001-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 _ANNOTATION_H_
#define _ANNOTATION_H_

// FIXED by IRIN as of 08/11/2002
// + re-ordered and/or completed the initialization lists
// + added the assignment operators that raise an exception
// + added the copy constructors
// + fixed memory leaks set_best, set_global_best 

#include <interval.h>
#include <vector>
#include <coconut_config.h>
#include <database>

using namespace vgtl;

#if 0
class point
{
private:
  std::vector<double> x;
  std::vector<double> L_mult;
  double f;
  double kappa;

  bool best;
  bool verified;
  bool feasible;
  bool optimal;
  bool global;

public:
  point() : x(), L_mult(), f(INFINITY), kappa(1.), best(false), verified(false),
            feasible(false), optimal(false), global(false)
  {}

  point(const std::vector<double>& _x, double _f) : x(_x), L_mult(),
                                         f(_f), kappa(1.), best(false),
                                         verified(false), feasible(false),
                                         optimal(false), global(false)
  {}

  point(const std::vector<double>& _x, double _f, const std::vector<double>&
        _Lm, double _kappa, bool _best = false, bool _feas = false,
        bool _opt = false, bool _ver = false, bool _glob = false) :
                                               x(_x), L_mult(_Lm), f(_f),
                                               kappa(_kappa),
                                               best(_best), verified(_ver),
                                               feasible(_feas), optimal(_opt),
                                               global(_glob)
  {}

  point(const point& _p) : x(_p.x), L_mult(_p.L_mult), f(_p.f), kappa(_p.kappa),
                           best(_p.best), verified(_p.verified),
                           feasible(_p.feasible), optimal(_p.optimal),
                           global(_p.global)
  {}

  virtual ~point() {}

public:
  void set_best(bool _best) { best = _best; }
  void set_verified(bool _ver) { verified = _ver; }
  void set_feasible(bool _feas) { feasible = _feas; }
  void set_optimal(bool _opt) { optimal = _opt; }
  void set_global(bool _glob) { global = _glob; }

  void set_val(const std::vector<double>& _x, double _f) { x = _x; f = _f;}
  void set_multiplier(const std::vector<double>& _Lm, double _kappa = 1.)
        { L_mult = _Lm; kappa = _kappa; }

  void clear_multiplier()
        { L_mult.erase(L_mult.begin(), L_mult.end()); kappa = 1.; }

  bool is_empty() const { return x.empty(); }

  bool is_best() const { return best; }
  bool is_verified() const { return verified; }
  bool is_feasible() const { return feasible; }
  bool is_optimal() const { return optimal; }
  bool is_global() const { return global; }

  bool have_multiplier() const { return !L_mult.empty(); }
  
  const std::vector<double>& xval() const { return x; }
  double fval() const { return f; }
  const std::vector<double>& multiplier() const { return L_mult; }
  double kval() const { return kappa; }

  bool operator==(const point& _p)
  {
    return best == _p.best &&
           verified == _p.verified &&
           feasible == _p.feasible &&
           optimal == _p.optimal &&
           global == _p.global &&
           f == _p.f &&
           L_mult == _p.L_mult &&
           x == _p.x;
  }
};

class box
{
private:
  std::vector<interval> x;

  bool _exclusion;
  bool _contains_opt;
  bool _eval_region;

public:
  box() : x(), _exclusion(false), _contains_opt(false), _eval_region(false)
  {}

  box(const std::vector<interval>& _x, bool _excl = false,
      bool _copt = false, bool _evr = false) :
               x(_x), _exclusion(_excl), _contains_opt(_copt),
               _eval_region(_evr)
  {}

  virtual ~box() {}

public:
  void set_val(const std::vector<interval>& _x) { x = _x; }

  void set_exclusion(bool _exc) { _exclusion = _exc; }
  void set_contains_opt(bool _copt) { _contains_opt = _copt; }
  void set_eval_region(bool _evr) { _eval_region = _evr; }

  const std::vector<interval>& val() const { return x; }

  bool is_empty() const { return x.empty(); }

  bool is_exclusion_box() const { return _exclusion; }
  bool contains_opt() const { return _contains_opt; }
  bool is_eval_region() const { return _eval_region; }

  bool operator==(const box& _b)
  {
    return _exclusion == _b._exclusion &&
           _contains_opt == _b._contains_opt &&
           _eval_region == _b._eval_region &&
           x == _b.x;
  }
};

class annotation
{
public:
  point pt;                        // best point for this model

  bool local_is_global;            // best local point is global minimizer

  std::vector<double> priorities;  // when should this model be taken

  bool infeasible;

public:
  annotation(annotation const &a) : pt(a.pt),
                        local_is_global(a.local_is_global),
                        priorities(a.priorities), infeasible(a.infeasible)
    {}

  annotation() : pt(), local_is_global(false), priorities(),
                 infeasible(false)
    {}

  annotation& operator= (annotation const& a)
  {
    pt = a.pt;
    local_is_global = a.local_is_global;
    priorities = a.priorities;
    infeasible = a.infeasible;
    // std :: cout << "Assignment of annotation" << std :: endl;
    // throw "in annotation :: operator = : cannot assign annotations";
    return *this;
  }

  // and others needed
  ~annotation() {}

  void set_best(const std::vector<double>& __xb,
                const std::vector<double>& __Lm, double __fx,
                bool _ver = false, bool _opt = false, bool _glob = false)
  {
    pt.set_best(true);
    pt.set_val(__xb, __fx);
    pt.set_multiplier(__Lm);
    pt.set_feasible(true);
    pt.set_verified(_ver);
    pt.set_optimal(_opt);
    pt.set_global(_glob);
  }

  void set_point(const point& _p) { pt = _p; }

  const point& get_point() const { return pt; }
};

class work_annotation : public annotation
{
private:
  typedef annotation _Base;

public:
  typedef std::vector<point>::iterator point_chg;
  typedef std::vector<box>::iterator box_chg;

  typedef std::vector<point>::const_iterator point_ref;
  typedef std::vector<box>::const_iterator box_ref;
  
  std::vector<point> points;
  std::vector<box> boxes;

  work_annotation() : _Base(), points(), boxes()
      {}

  work_annotation(const work_annotation& a ) : _Base(a),
                                points(a.points), boxes(a.boxes)
      {}

  work_annotation& operator= (const work_annotation& a)
  {
    _Base::operator=(a);
    points = a.points;
    boxes = a.boxes;
    return *this;
  }

  ~work_annotation() {}

  void set_global_best(const std::vector<double>& __xb,
                       const std::vector<double>& __Lm, double __fx,
                       bool verified = false, bool optimal = false,
                       bool replace_all = false)
  {
    for(unsigned int i = points.size(); i != 0; --i)
    {
      point_chg pr = points.begin()+i-1;
      if(pr->is_best() && pr->is_global() && 
          (replace_all || pr->fval() > __fx))
        points.erase(pr);
    }

    point p(__xb, __fx, __Lm, true, true, optimal, verified, true);
    points.push_back(p);
  }

  point_ref get_global_best() const
  {
    point_ref pr;

    for(pr = points.begin(); pr != points.end(); ++pr)
      if(pr->is_best() && pr->is_global())
        return pr;
    return pr;
  }

  std::vector<point_ref> get_all_global_best() const
  {
    std::vector<point_ref> pv;

    for(point_ref pr = points.begin(); pr != points.end(); ++pr)
      if(pr->is_best() && pr->is_global())
        pv.push_back(pr);
    return pv;
  }

  std::vector<box_ref> get_all_exclusion_boxes() const
  {
    std::vector<box_ref> bv;

    for(box_ref br = boxes.begin(); br != boxes.end(); ++br)
      if(br->is_exclusion_box())
        bv.push_back(br);
    return bv;
  }
};
#endif

class annotation : public std::pair<vdbl::tableid,vdbl::rowid>
{
private:  
  typedef std::pair<vdbl::tableid,vdbl::rowid> _Base;

public:
  annotation(const vdbl::tableid& _ti, const vdbl::rowid& _ri) : _Base(_ti,_ri)
        {}
  virtual ~annotation() {}

  vdbl::tableid get_table() const { return first; }
  vdbl::rowid get_entry() const { return second; }
};

#endif // _ANNOTATION_H

---