cached_function.h

Go to the documentation of this file.

// -*- mode: c++; -*-
//
//The Biomolecule Toolkit (BTK) is a C++ library for use in the
//modeling, analysis, and design of biological macromolecules.
//Copyright (C) 2004, Christopher Saunders <ctsa@users.sourceforge.net>
//
//This program is free software; you can redistribute it and/or modify
//it under the terms of the GNU Lesser General Public License as published
//by the Free Software Foundation; either version 2.1 of the License, or (at
//your option) any later version.
//
//This program 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 GNU
//Lesser General Public License for more details.
//
//You should have received a copy of the GNU Lesser General Public License
//along with this program; if not, write to the Free Software Foundation,
//Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.


#ifndef BTK_CACHED_FUNCTION_H
#define BTK_CACHED_FUNCTION_H

#include <functional>


namespace BTK {


template <typename T, typename ArgType>
struct CachedUnaryFunction : public std::unary_function<T,ArgType> {

  template <typename UnaryFunction>
  CachedUnaryFunction(UnaryFunction& func,
                      ArgType min_arg,
                      ArgType max_arg,
                      ArgType sample_spacing);

  ~CachedUnaryFunction() { delete [] _func_val; }

  T operator()(ArgType arg);


private:
  ArgType _min_arg;
  ArgType _max_arg;
  ArgType _sample_spacing;
  T* _func_val;
};


} // Namespace BTK






#include <cassert>


template <typename T, typename ArgType>
template <typename UnaryFunction>
BTK::CachedUnaryFunction<T,ArgType>::
CachedUnaryFunction(UnaryFunction& func,
                    ArgType min_arg,
                    ArgType max_arg,
                    ArgType sample_spacing)
    : _min_arg(min_arg), _max_arg(max_arg), _sample_spacing(sample_spacing)  {
  if(_min_arg>_max_arg) std::swap(_min_arg,_max_arg);
  ArgType range = _max_arg - _min_arg;
  unsigned sample_count = static_cast<unsigned>(range/_sample_spacing)+2;
  _max_arg = ((sample_count-1)*_sample_spacing)+_min_arg;

  _func_val = new T[sample_count];
  for(unsigned i=0;i<sample_count;++i){
    _func_val[i] = func(_min_arg+i*_sample_spacing);
  }
}



template <typename T, typename ArgType>
T
BTK::CachedUnaryFunction<T,ArgType>::
operator()(ArgType arg) {
  assert( arg >= _min_arg && arg <= _max_arg );
  ArgType exact_bin_val = (arg-_min_arg)/_sample_spacing;
  unsigned low_bin = static_cast<unsigned>(exact_bin_val);
  T low_val = _func_val[low_bin];
  ArgType bin_error =
    (exact_bin_val-static_cast<ArgType>(low_bin));
  return low_val + bin_error*(_func_val[low_bin+1]-low_val);
}



#endif

---