nugrid.cpp File Reference

#include "nugrid.h"
#include <cmath>
#include <stdlib.h>
#include <assert.h>
#include <boost/math/special_functions/log1p.hpp>
#include <boost/math/special_functions/expm1.hpp>

Go to the source code of this file.

Functions
int	center_grid_reverse_map (void *gridptr, double x)
NUgrid *	create_center_grid (double start, double end, double ratio, int num_points)
NUgrid *	create_general_grid (double *points, int num_points)
NUgrid *	create_log_grid (double start, double end, int num_points)
void	destroy_grid (NUgrid *grid)
int	general_grid_reverse_map (void *gridptr, double x)
int	log_grid_reverse_map (void *gridptr, double x)

Function Documentation

center_grid_reverse_map()

int center_grid_reverse_map	(	void *	gridptr,
		double	x )

Definition at line 32 of file nugrid.cpp.

{
  center_grid *grid = (center_grid *)gridptr;
 
  x -= grid->center;
  double index = 
      copysign (log1p(fabs(x)*grid->aInv)*grid->bInv, x);
  return (int)floor(grid->half_points + index - grid->even_half);
}

References center_grid::aInv, center_grid::bInv, center_grid::center, center_grid::even_half, and center_grid::half_points.

create_center_grid()

NUgrid * create_center_grid	(	double	start,
		double	end,
		double	ratio,
		int	num_points )

Definition at line 83 of file nugrid.cpp.

{
  center_grid *grid = new center_grid;
  if (grid != NULL) {
    assert (ratio > 1.0);
    grid->start       = start;
    grid->end         = end;
    grid->center      = 0.5*(start + end);
    grid->num_points  = num_points;
    grid->half_points = num_points/2;
    grid->odd = ((num_points % 2) == 1);
    grid->b = log(ratio) / (double)(grid->half_points-1);
    grid->bInv = 1.0/grid->b;
    grid->points = new double[num_points];
    if (grid->odd) {
      grid->even_half = 0.0;  
      grid->odd_one   = 1;
      grid->a = 0.5*(end-start)/expm1(grid->b*grid->half_points);
      grid->aInv = 1.0/grid->a;
      for (int i=-grid->half_points; i<=grid->half_points; i++) {
    double sign;
    if (i<0) 
      sign = -1.0;
    else
      sign =  1.0;
    grid->points[i+grid->half_points] = 
      sign * grid->a*expm1(grid->b*abs(i))+grid->center;
      }
    }
    else {
      grid->even_half = 0.5;  
      grid->odd_one   = 0;
      grid->a = 
    0.5*(end-start)/expm1(grid->b*(-0.5+grid->half_points));
      grid->aInv = 1.0/grid->a;
      for (int i=-grid->half_points; i<grid->half_points; i++) {
    double sign;
    if (i<0) sign = -1.0; 
    else     sign =  1.0;
    grid->points[i+grid->half_points] = 
      sign * grid->a*expm1(grid->b*fabs(0.5+i)) + grid->center;
      }
    }
    grid->reverse_map = center_grid_reverse_map;
    grid->code = CENTER;
  }
  return (NUgrid*) grid;
}

References center_grid::a, center_grid::aInv, center_grid::b, center_grid::bInv, CENTER, center_grid::center, center_grid_reverse_map(), center_grid::code, center_grid::end, center_grid::even_half, center_grid::half_points, center_grid::num_points, center_grid::odd, center_grid::odd_one, center_grid::points, center_grid::reverse_map, sign(), and center_grid::start.

create_general_grid()

NUgrid * create_general_grid	(	double *	points,
		int	num_points )

Definition at line 155 of file nugrid.cpp.

{
  NUgrid* grid = new NUgrid;
  if (grid != NULL) {
    grid->reverse_map = general_grid_reverse_map;
    grid->code = GENERAL;
    grid->points = new double[num_points];
    grid->start = points[0];
    grid->end   = points[num_points-1];
    grid->num_points = num_points;
    for (int i=0; i<num_points; i++) 
      grid->points[i] = points[i];
    grid->code = GENERAL;
  }
  return grid;
}

References NUgrid::code, NUgrid::end, GENERAL, general_grid_reverse_map(), NUgrid::num_points, NUgrid::points, NUgrid::reverse_map, and NUgrid::start.

create_log_grid()

NUgrid * create_log_grid	(	double	start,
		double	end,
		int	num_points )

Definition at line 135 of file nugrid.cpp.

{
  log_grid *grid = new log_grid;
  grid->code = LOG;
  grid->start = start;
  grid->end = end;
  grid->num_points = num_points;
  grid->points = new double[num_points];
  grid->a = 1.0/(double)(num_points-1)*log(end/start);
  grid->ainv = 1.0/grid->a;
  grid->startinv = 1.0/start;
  for (int i=0; i<num_points; i++)
    grid->points[i] = start*exp(grid->a*(double)i);
  grid->reverse_map = log_grid_reverse_map;
  return (NUgrid*) grid;
}

References log_grid::a, log_grid::ainv, log_grid::code, log_grid::end, LOG, log_grid_reverse_map(), log_grid::num_points, log_grid::points, log_grid::reverse_map, log_grid::start, and log_grid::startinv.

destroy_grid()

void destroy_grid

(

NUgrid *

grid

)

Definition at line 173 of file nugrid.cpp.

{
  delete[] grid->points;
  delete grid;
}

References NUgrid::points.

general_grid_reverse_map()

int general_grid_reverse_map	(	void *	gridptr,
		double	x )

Definition at line 57 of file nugrid.cpp.

{
  NUgrid* grid = (NUgrid*) gridptr;
  int N = grid->num_points;
  double *points = grid->points;
  if (x <= points[0])
    return (0);
  else if (x >= points[N-1])
    return (N-1);
  else {
    int hi = N-1;
    int lo = 0;
    bool done = false;
    while (!done) {
      int i = (hi+lo)>>1;
      if (points[i] > x)
    hi = i;
      else
    lo = i;
      done = (hi-lo)<2;
    }
    return (lo);
  }
}

References NUgrid::num_points, and NUgrid::points.

log_grid_reverse_map()

int log_grid_reverse_map	(	void *	gridptr,
		double	x )

Definition at line 43 of file nugrid.cpp.

{
  log_grid *grid = (log_grid *)gridptr;
  
  int index = (int) floor(grid->ainv*log(x*grid->startinv));
 
  if (index < 0)
    return 0;
  else
    return index;
}

References log_grid::ainv, and log_grid::startinv.