---

bound_delta.cc

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.

#include <bound_delta.h>

bool bound_delta::apply(work_node& _x, undelta_base*& _u) const
{
  double _gain(1.);
  std::vector<interval>::const_iterator _i;
  if(indices.empty())
  {
    std::vector<interval>::const_iterator _e(new_f_bounds.end()),
                                          _xo(_x.node_ranges.begin());
    _u = (undelta_base *) new bound_undelta(indices, _x.node_ranges,
                                            _x.gain_factor, _x.log_vol);
    _x.node_ranges = new_f_bounds;
    for(_i = new_f_bounds.begin(); _i != _e; ++_i, ++_xo)
      _gain *= gainfactor(*_xo, *_i);
  }
  else
  {
    std::vector<unsigned int>::const_iterator _c,_e;

    _e = indices.end();
    _u = (undelta_base *) new bound_undelta(indices, _x.gain_factor,
                                            _x.log_vol);
    ((bound_undelta*)_u)->old_f_bounds.reserve(indices.size());
    _i = new_f_bounds.begin();
    for(_c = indices.begin(); _c != _e; ++_c)
    {
      const interval& __ix(_x.node_ranges[*_c]);
      _gain *= gainfactor(__ix, *_i);
      ((bound_undelta*)_u)->old_f_bounds.push_back(__ix);
      _x.node_ranges[*_c] = *_i;
      ++_i;
    }
  }
  _x.log_vol = _x.compute_log_volume(_x.node_ranges);
  _x.gain_factor *= _gain;
  return true;
}

bool bound_undelta::unapply(work_node& _x) const
{
  if(indices.empty())
    _x.node_ranges = old_f_bounds;
  else
  {
    std::vector<unsigned int>::const_iterator _c,_e;
    std::vector<interval>::const_iterator _i;

    _e = indices.end();
    _i = old_f_bounds.begin();
    for(_c = indices.begin(); _c != _e; ++_c)
      _x.node_ranges[*_c] = *_i++;
  }
  _x.gain_factor = old_gain;
  _x.log_vol = old_log_vol;
  return true;
}

---