---

bound_delta.h

Go to the documentation of this file.

// Bound Delta 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 _BOUND_DELTA_H_
#define _BOUND_DELTA_H_

#include <api_delta.h>

class bound_undelta : public undelta_base
{
public:
  std::vector<unsigned int> indices;    // if all variables are being
                                        // updated this vector is empty
  std::vector<interval> old_f_bounds;   // original bounds are stored here
                                        // in order to restore the values
                                        // easily during backtracking
  double old_gain, old_log_vol;
public:
  bound_undelta(const std::vector<unsigned int>& __i,
                const std::vector<interval>& __b,
                double _og, double _olv) : undelta_base(), indices(__i),
                                           old_f_bounds(__b), old_gain(_og),
                                           old_log_vol(_olv)           {}
  
  bound_undelta(const std::vector<unsigned int>& __i, double _og,
                double _olv) : undelta_base(), indices(__i),
                               old_f_bounds(), old_gain(_og),
                               old_log_vol(_olv) {}
  
  bound_undelta(const bound_undelta& __d) : undelta_base(__d),
                                            indices(__d.indices),
                                            old_f_bounds(__d.old_f_bounds),
                                            old_gain(__d.old_gain),
                                            old_log_vol(__d.old_log_vol)
      {
#if DEBUG_DELTA
        std::cerr << "Called bound_undelta copy constructor" << std::endl;
#endif
      }

  bound_undelta* new_copy() const { return new bound_undelta(*this); }
  void destroy_copy(bound_undelta* __d) { delete __d; }

  bool unapply(work_node& _x) const;

  friend class bound_delta;
};

class bound_delta : public delta_base
{
public:
  std::vector<unsigned int> indices;         // if all variables are being
                                             // updated this vector is empty
  std::vector<interval> new_f_bounds;        // new bounds
public:
  bound_delta(const std::vector<unsigned int>& __i,
              const std::vector<interval>& __b)
                    : delta_base("change bounds"), indices(__i),
                      new_f_bounds(__b) {}
  
  bound_delta(unsigned int __i, interval __b)
                    : delta_base("change bounds"), indices(1,__i),
                      new_f_bounds(1,__b) {}
  
  bound_delta(const bound_delta& __d) : delta_base(__d), indices(__d.indices),
                                        new_f_bounds(__d.new_f_bounds)
    {
#if DEBUG_DELTA
        std::cerr << "Called bound_delta copy constructor" << std::endl;
#endif
    }

  bound_delta* new_copy() const { return new bound_delta(*this); }
  void destroy_copy(bound_delta* __d) { delete __d; }

  bool apply(work_node& _x, undelta_base*& _u) const;
};

#endif /* _BOUND_DELTA_H_ */

---