---

tab_fn.H

Go to the documentation of this file.

/*
 * Copyright 2000, Brown University, Providence, RI.
 * 
 *                         All Rights Reserved
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose other than its incorporation into a
 * commercial product is hereby granted without fee, provided that the
 * above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of Brown University not be used in
 * advertising or publicity pertaining to distribution of the software
 * without specific, written prior permission.
 * 
 * BROWN UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ANY
 * PARTICULAR PURPOSE.  IN NO EVENT SHALL BROWN UNIVERSITY BE LIABLE FOR
 * ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
/**********************************************************************
 * tab_fn.H:
 **********************************************************************/
#ifndef TAB_FN_H_IS_INCLUDED
#define TAB_FN_H_IS_INCLUDED

#include <math.h>
#include "std/error.H"

typedef double (*real_fn_t)(double);
/**********************************************************************
 * tab_fn.H:
 *
 *      tabulates values of a given function over an interval [a,b]
 *      using a specified resolution. approximations of the function
 *      at values in [a,b) are returned as interpolations of the
 *      tabulated values. at values outside that range the function
 *      itself is used to compute the value.
 **********************************************************************/
class TabulatedFunction {
 protected:
   double       _a;             // a
   double       _b;             // b
   double       _len;           // b - a
   int          _res;           // resolution (# of subintervals)
   double       _rlen;          // _res / _len (used in computation)
   double*      _tab;           // table of values
   real_fn_t    _f;             // the given function

 public:
   TabulatedFunction(double a, double b, real_fn_t f, int res) :
      _tab(0) {
      init(a,b,f,res);
   }
   TabulatedFunction(double a, double b, double vals[], int res) :
      _tab(0) {
      init(a,b,vals,res);
   }

   void init(double a, double b, double vals[], int res) {
      _a = a;
      _b = b;
      _len = (b-a);
      _f = 0;
      _res = res;
      
      delete _tab;
      _tab = 0;

      if (_len <= 0 ) {
         err_msg("TabulatedFunction::init: interval (%f,%f) is bad", a, b);
      } else if (_res < 1) {
         err_msg("TabulatedFunction::init: resolution (%d) is too small", _res);
      } else if ((_tab = new double [ _res + 1 ]) == 0) {
         err_ret("TabulatedFunction::init: can't allocate table");
      } else {
         _rlen = _res / _len;
         for (int n=0; n<=_res; n++) {
            _tab[n] = vals[n];
         }
      }
   }

   void init(double a, double b, real_fn_t f, int res) {
      _a = a;
      _b = b;
      _len = (b - a);
      _f = f;
      _res = res;

      delete _tab;
      _tab = 0;

      if (_len <= 0 ) {
         err_msg("TabulatedFunction::init: interval (%f,%f) is bad", a, b);
      } else if (_res < 1) {
         err_msg("TabulatedFunction::init: resolution (%d) is too small", _res);
      } else if ((_tab = new double [ _res + 1 ]) == 0) {
         err_ret("TabulatedFunction::init: can't allocate table");
      } else {
         _rlen = _res / _len;
         for (int n=0; n<=_res; n++) {
            _tab[n] = (*_f)(n/_rlen + _a);
         }
      }
   }

   double map(double x) const {
      // if out of bounds, compute the function if we have it.
      // if we don't have it, extend the function to be constant
      // outside of its defined range.
      if (x<_a || x>=_b || !_tab)
         return _f ? (*_f)(x) : _tab ? _tab[x<_a? 0 : _res] : 0;
      else {
         double t = _rlen*(x - _a);
         int n = (int) floor(t);
         double d = t - n;
         return _tab[n] + (_tab[n+1] - _tab[n])*d;
      }
   }
};

#endif // TAB_FN_H_IS_INCLUDED

/* end of file tab_fn.H */

---