tioga 1.11 → 1.13

data/ext/Dobjects/Dvector/extconf.rb

@@ -0,0 +1,22 @@
+# Dtable installation file
+require 'mkmf'
+
+# Conditional use of fftw3
+if have_header("fftw3.h") and have_library("fftw3", "fftw_execute", "fftw3.h")
+  puts "fftw3 was found on this system: Fourier transforms will be available"
+else
+  puts "fftw3 was not found on this system: no Fourier transforms"
+end
+
+# "Safe" way to store doubles (ie in a platform-independant way)
+unless have_header("ieee754.h")
+  puts "You lack the ieee754.h header file, which might mean lower " +
+    "reliability when Marshalling Dvectors and Dtables"
+end
+
+
+# We add include directories
+$INCFLAGS += " -I../../includes"
+
+
+create_makefile 'Dobjects/Dvector'

data/ext/Dobjects/Function/extconf.rb

@@ -0,0 +1,7 @@
+# Function installation file
+require 'mkmf'
+
+# We add include directories
+$INCFLAGS += " -I../../includes -I../Dvector/include"
+
+create_makefile 'Dobjects/Function'

data/{split → ext/Dobjects}/Function/function.c

@@ -5,7 +5,7 @@
    An object embedding two Dvectors for the ease of manipulation as
    a function. 
    
-   Copyright (C) 2006  Vincent Fourmond
+   Copyright (C) 2006,2010  Vincent Fourmond
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Library Public License as published
@@ -26,12 +26,16 @@
 #include <namespace.h>
 #include <ruby.h>
 
-#include "dvector.h"
-#include "../symbols.c"
 
 #include <math.h>
-/* compiler-dependent definitions, such as is_okay_number */
+
+/* Private include files */
+#include "dvector.h"
+#include "symbols.c"
+
+/* compiler-dependent defintions, such as is_okay_number */
 #include <defs.h>
+/* End of private files */
 
 /* the class we're defining */
 static VALUE cFunction;
@@ -609,6 +613,8 @@ static VALUE function_interpolate(VALUE self, VALUE x_values)
   return Qnil;
 }
 
+
+
 /*
   Strips all the points containing NaN values from the function, and
   returns the number of points stripped.
@@ -644,7 +650,6 @@ static VALUE function_strip_nan(VALUE self)
   Returns the array of the subfunctions. The returned values are
   necessarily new values.
 */
-
 static VALUE function_split_monotonic(VALUE self)
 {
   VALUE ret = rb_ary_new();
@@ -707,6 +712,60 @@ static VALUE function_split_monotonic(VALUE self)
 }
 
 
+/*
+  Splits the function on NaN values for x, y or xy, depending on
+  whether _sym_ is +:x+, +:y+ or +:xy+ (or, as a matter of fact,
+  anything else than +:x+ or +:y+).
+
+  This returns an array of new Function objects.
+
+  This function will return empty Function objects between consecutive
+  NaN values.
+*/
+static VALUE function_split_on_nan(VALUE self, VALUE sym)
+{
+  VALUE ret = rb_ary_new();
+  VALUE cur_x = Dvector_Create();
+  VALUE cur_y = Dvector_Create();
+  int on_x = 1;
+  int on_y = 1;
+  long size = function_sanity_check(self);
+  long cur_size = 0;
+  long i;
+  if(size < 2)
+    rb_raise(rb_eRuntimeError, "Function needs to have at least 2 points");
+
+  double *x = Dvector_Data_for_Read(get_x_vector(self),NULL);
+  double *y = Dvector_Data_for_Read(get_y_vector(self),NULL);
+
+  VALUE f;
+  
+  if(sym == ID2SYM(rb_intern("x")))
+    on_y = 0;
+  else if(sym == ID2SYM(rb_intern("y")))
+    on_x = 0;
+
+
+  for(i = 0; i < size; i++) {
+    if((on_x && isnan(x[i])) ||
+       (on_y && isnan(y[i]))) {
+      /* We split */
+      f = Function_Create(cur_x, cur_y);
+      rb_ary_push(ret, f);
+      cur_x = Dvector_Create();
+      cur_y = Dvector_Create();
+    }
+    else {
+      Dvector_Push_Double(cur_x, x[i]);
+      Dvector_Push_Double(cur_y, y[i]);
+    }
+  }
+  f = Function_Create(cur_x, cur_y);
+  rb_ary_push(ret, f);
+  return ret;
+}
+
+
 /*
   Sorts the X values while keeping the matching Y values. 
 */
@@ -899,7 +958,8 @@ static VALUE function_primitive(VALUE self)
   Computes the derivative of the Function and returns it as a new Function.
   The newly created function shares the X vector with the previous one.
 
-  WARNING: this is a very naive 3-points algorithm.
+  WARNING: this is a very naive 3-points algorithm; you should
+  consider using diff_5p
 */
 static VALUE function_derivative(VALUE self)
 {
@@ -924,6 +984,139 @@ static VALUE function_derivative(VALUE self)
   return Function_Create(get_x_vector(self), derivative);
 }
 
+/*
+  Computes a 4th order accurate derivative of the Function.
+
+  This function *requires* that there are at the very least 5 data
+  points !
+*/
+static VALUE function_diff_5p(VALUE self)
+{
+  long size = function_sanity_check(self);
+  const double *x = Dvector_Data_for_Read(get_x_vector(self),NULL);
+  const double *y = Dvector_Data_for_Read(get_y_vector(self),NULL);
+  VALUE derivative = Dvector_Create();
+  long i = 0;
+  double delta_1, delta_2, delta_3, delta_4;
+  double alpha_1, alpha_2, alpha_3, alpha_4;
+  double v0,v1,v2,v3,v4;
+  /* TODO: what happens when there are less than 5 points ? */
+
+  for(i = 0; i < size; i++) {
+    /* First initialize values, though this is very suboptimal */
+    v0 = y[i];
+    if(i == 0) {
+      delta_1 = x[1] - x[0]; v1 = y[1];
+      delta_2 = x[2] - x[0]; v2 = y[2];
+      delta_3 = x[3] - x[0]; v3 = y[3];
+      delta_4 = x[4] - x[0]; v4 = y[4];
+    } else if(i == 1) {
+      delta_1 = x[0] - x[1]; v1 = y[0];
+      delta_2 = x[2] - x[1]; v2 = y[2];
+      delta_3 = x[3] - x[1]; v3 = y[3];
+      delta_4 = x[4] - x[1]; v4 = y[4];
+    } else if(i == size - 2) {
+      delta_1 = x[size-1] - x[size-2]; v1 = y[size-1];
+      delta_2 = x[size-3] - x[size-2]; v2 = y[size-3];
+      delta_3 = x[size-4] - x[size-2]; v3 = y[size-4];
+      delta_4 = x[size-5] - x[size-2]; v4 = y[size-5];
+    } else if(i == size - 1) {
+      delta_1 = x[size-2] - x[size-1]; v1 = y[size-2];
+      delta_2 = x[size-3] - x[size-1]; v2 = y[size-3];
+      delta_3 = x[size-4] - x[size-1]; v3 = y[size-4];
+      delta_4 = x[size-5] - x[size-1]; v4 = y[size-5];
+    } else {
+      delta_1 = x[i-2] - x[i]; v1 = y[i-2];
+      delta_2 = x[i-1] - x[i]; v2 = y[i-1];
+      delta_3 = x[i+2] - x[i]; v3 = y[i+2];
+      delta_4 = x[i+1] - x[i]; v4 = y[i+1];
+    }
+    alpha_1 = delta_2*delta_3*delta_4/
+      (delta_1 * (delta_2 - delta_1) * (delta_3 - delta_1) 
+       * (delta_4 - delta_1));
+    alpha_2 = delta_1*delta_3*delta_4/
+      (delta_2 * (delta_1 - delta_2) * (delta_3 - delta_2) 
+       * (delta_4 - delta_2));
+    alpha_3 = delta_1*delta_2*delta_4/
+      (delta_3 * (delta_1 - delta_3) * (delta_2 - delta_3) 
+       * (delta_4 - delta_3));
+    alpha_4 = delta_1*delta_2*delta_3/
+      (delta_4 * (delta_1 - delta_4) * (delta_2 - delta_4) 
+       * (delta_3 - delta_4));
+    Dvector_Push_Double(derivative,
+			-(alpha_1 + alpha_2 + alpha_3 + alpha_4) * v0 +
+			alpha_1 * v1 + alpha_2 * v2 + 
+			alpha_3 * v3 + alpha_4 * v4);
+  }
+  return Function_Create(get_x_vector(self), derivative);
+}
+
+/*
+  Computes a 4th order accurate second derivative of the Function.
+
+  This function *requires* that there are at the very least 5 data
+  points!  
+*/
+static VALUE function_diff2_5p(VALUE self)
+{
+  long size = function_sanity_check(self);
+  const double *x = Dvector_Data_for_Read(get_x_vector(self),NULL);
+  const double *y = Dvector_Data_for_Read(get_y_vector(self),NULL);
+  VALUE derivative = Dvector_Create();
+  long i = 0;
+  double delta_1, delta_2, delta_3, delta_4;
+  double alpha_1, alpha_2, alpha_3, alpha_4;
+  double v0,v1,v2,v3,v4;
+
+  for(i = 0; i < size; i++) {
+    /* First initialize values, though this is very suboptimal */
+    v0 = y[i];
+    if(i == 0) {
+      delta_1 = x[1] - x[0]; v1 = y[1];
+      delta_2 = x[2] - x[0]; v2 = y[2];
+      delta_3 = x[3] - x[0]; v3 = y[3];
+      delta_4 = x[4] - x[0]; v4 = y[4];
+    } else if(i == 1) {
+      delta_1 = x[0] - x[1]; v1 = y[0];
+      delta_2 = x[2] - x[1]; v2 = y[2];
+      delta_3 = x[3] - x[1]; v3 = y[3];
+      delta_4 = x[4] - x[1]; v4 = y[4];
+    } else if(i == size - 2) {
+      delta_1 = x[size-1] - x[size-2]; v1 = y[size-1];
+      delta_2 = x[size-3] - x[size-2]; v2 = y[size-3];
+      delta_3 = x[size-4] - x[size-2]; v3 = y[size-4];
+      delta_4 = x[size-5] - x[size-2]; v4 = y[size-5];
+    } else if(i == size - 1) {
+      delta_1 = x[size-2] - x[size-1]; v1 = y[size-2];
+      delta_2 = x[size-3] - x[size-1]; v2 = y[size-3];
+      delta_3 = x[size-4] - x[size-1]; v3 = y[size-4];
+      delta_4 = x[size-5] - x[size-1]; v4 = y[size-5];
+    } else {
+      delta_1 = x[i-2] - x[i]; v1 = y[i-2];
+      delta_2 = x[i-1] - x[i]; v2 = y[i-1];
+      delta_3 = x[i+2] - x[i]; v3 = y[i+2];
+      delta_4 = x[i+1] - x[i]; v4 = y[i+1];
+    }
+    alpha_1 = -2 * (delta_2*delta_3 + delta_2*delta_4 + delta_3*delta_4)/
+      (delta_1 * (delta_2 - delta_1) * (delta_3 - delta_1) 
+       * (delta_4 - delta_1));
+    alpha_2 = -2 * (delta_1*delta_3 + delta_1*delta_4 + delta_3*delta_4)/
+      (delta_2 * (delta_1 - delta_2) * (delta_3 - delta_2) 
+       * (delta_4 - delta_2));
+    alpha_3 = -2 * (delta_2*delta_1 + delta_2*delta_4 + delta_1*delta_4)/
+      (delta_3 * (delta_1 - delta_3) * (delta_2 - delta_3) 
+       * (delta_4 - delta_3));
+    alpha_4 = -2 * (delta_2*delta_3 + delta_2*delta_1 + delta_3*delta_1)/
+      (delta_4 * (delta_1 - delta_4) * (delta_2 - delta_4) 
+       * (delta_3 - delta_4));
+    Dvector_Push_Double(derivative,
+			-(alpha_1 + alpha_2 + alpha_3 + alpha_4) * v0 +
+			alpha_1 * v1 + alpha_2 * v2 + 
+			alpha_3 * v3 + alpha_4 * v4);
+  }
+  return Function_Create(get_x_vector(self), derivative);
+}
+
 /*
   Returns the number of points inside the function.
 */
@@ -1026,6 +1219,418 @@ static VALUE function_bound_values(VALUE self,
   return Function_Create(x_out, y_out);
 }
 
+/* Reverses the function. Equivalent to doing 
+
+   x.reverse!
+   y.reverse!
+  
+  excepted that it is faster (though not *much* faster).
+*/
+static VALUE function_reverse(VALUE self)
+{
+  long len = function_sanity_check(self);
+  double *xs = Dvector_Data_for_Write(get_x_vector(self),NULL);
+  double *ys = Dvector_Data_for_Write(get_y_vector(self),NULL);
+  
+  double *xe = xs+len-1;
+  double *ye = ys+len-1;
+  double tmp;
+  long i;
+  for(i = 0; i < len/2; i++, xs++, ys++, xe--, ye--) {
+    tmp = *xe; *xe = *xs; *xs = tmp;
+    tmp = *ye; *ye = *ys; *ys = tmp;
+  }
+  return self;
+}
+
+/* Computes the linear regression of the dataset. */
+static void reglin(const double *x, const double *y, long nb, 
+		   double *a, double *b)
+{
+  double sx = 0;
+  double sy = 0;
+  double sxx = 0;
+  double sxy = 0;
+  long i = 0;
+  double det;
+  for(i = 0; i < nb; i++, x++, y++) {
+    sx += *x;
+    sy += *y;
+    sxx += *x * *x;
+    sxy += *x * *y;
+  }
+  det = nb*sxx - sx*sx;
+  if(det == 0) {
+    *a = 0;			/* Whichever, we only have one point */
+    *b = sy/nb;
+  }
+  else {
+    *a = (nb *sxy - sx*sy)/det; 
+    *b = (sxx * sy - sx * sxy)/(det);
+  }
+}
+
+
+/* 
+   Performs a linear regression of the Function; returns the pair
+    [ a, b]
+   where f(x) = a*x + b
+
+   if the optional arguments _first_ and _last_ are provided, they
+   represent the indices of the first and last elements.
+ */
+static VALUE function_reglin(int argc, VALUE *argv, VALUE self)
+{
+  long len = function_sanity_check(self);
+  const double *x = Dvector_Data_for_Read(get_x_vector(self),NULL);
+  const double *y = Dvector_Data_for_Read(get_y_vector(self),NULL);
+  VALUE ret = rb_funcall(cDvector, idNew, 1, INT2NUM(2));
+  double * dat = Dvector_Data_for_Write(ret, NULL);
+  long nb;
+  if(argc == 2) {
+    long f = NUM2LONG(argv[0]);
+    long l = NUM2LONG(argv[1]);
+    if(f < 0)
+      f = len + f;
+    if(l < 0)
+      l = len + l;
+    x += f;
+    y += f;
+    nb = l - f;
+  }
+  else if(argc == 0) {
+    nb = len;
+  }
+  else {
+    rb_raise(rb_eArgError, "reglin should have 0 or 2 parameters");
+  }
+  reglin(x,y,nb,dat,dat+1);
+  return ret;
+}
+
+
+/* Simply returns the sign */
+static int signof(double x)
+{
+  if(x > 0)
+    return 1;
+  else if(x < 0)
+    return -1;
+  else
+    return 0;
+}
+
+/* 
+   Returns a "smoothed" value, according to the algorithm implented
+   for "smooth" markers in Soas. See DOI:
+   10.1016/j.bioelechem.2009.02.010
+   
+   Basically, we start at a given range, and narrow the range until
+   the number of consecutive residuals of the same sign is lower than
+   a quarter of the interval.
+
+   It works
+
+*/
+double smooth_pick(const double *x, const double *y, 
+		   long nb, long idx, long range)
+{
+  long left, right,i,nb_same_sign;
+  double a,b;
+  int last_sign;
+  do {
+    left = idx - range/2;
+    if(left < 0) 
+      left = 0;
+    right = idx + range/2;
+    if(right > nb)
+      right = nb;
+    reglin(x+left, y+left, right-left,&a,&b);
+    if(range == 6)
+      break; 			/* We stop here */
+    last_sign = 0;
+    for(i = left; i < right; i++) {
+      double residual = y[i] - a * x[i] - b;
+      if(! last_sign)
+	last_sign = signof(residual);
+      else if(last_sign == signof(residual))
+	nb_same_sign ++;
+      else {
+	nb_same_sign = 1;
+	last_sign = signof(residual);
+      }
+    }
+    if(nb_same_sign * 4 <= right - left)
+      break;
+    range -= (nb_same_sign * 4 -range)/2 + 2;
+    if(range < 6)
+      range = 6;
+  } while(1);
+  /* Now, we have a and b for the last range measured. */
+  return a*x[idx] + b;
+}
+
+/* 
+   Attempts to pick a smooth value for a point, according to the
+   algorithm implented for "smooth" markers in Soas. See DOI:
+   10.1016/j.bioelechem.2009.02.010
+
+   Warning: be wary of this function as it will return a correct
+   value only for rather noisy data !
+ */
+static VALUE function_smooth_pick(int argc, VALUE *argv, VALUE self)
+{
+  long len = function_sanity_check(self);
+  const double *x = Dvector_Data_for_Read(get_x_vector(self),NULL);
+  const double *y = Dvector_Data_for_Read(get_y_vector(self),NULL);
+  long idx;
+  long range;
+  switch(argc) {
+  case 2:
+    range = NUM2LONG(argv[1]);
+    break;
+  case 1:
+    range = len > 500 ? 50 : len/10;
+    break;
+  default:
+    rb_raise(rb_eArgError, "smooth_a=t should have 1 or 2 parameters");
+  }
+  idx = NUM2LONG(argv[0]);
+  if(idx < 0)
+    idx = len + idx;
+  return rb_float_new(smooth_pick(x,y,len,idx,range));
+}
+
+/* 
+   Computes the convolution of the kernel with the dataset; the
+   overall result is scaled
+ */
+static double norm_convolve(const double *y, long len, long idx,
+			    const double * kernel, long klen, long kmid)
+{
+  double ret = 0;
+  long ki,yi;
+  double norm = 0;
+  yi = idx - kmid;
+  /* We ensure we don't go */
+  if(yi < 0) {
+    ki -= yi;
+    yi = 0;
+  }
+  for(; ki < klen && yi < len; yi++, ki++) {
+    norm += kernel[ki];
+    ret += kernel[ki] * y[yi];
+  }
+  return ret/norm;
+}
+
+/*
+  This functions tries to approximate the given data using a spline.
+
+  The algorithm is the following:
+  * one starts with 3 points: 2 on the sides and one at the middle
+  * then, we pick an interval between the points where the sum of the
+    square of the residuals is the greatest, and place a point there.
+  * then, we repeat until we reach a maximum number of points (_nbmax_)
+
+  Point positions are averaged over _nbavg_ using a gaussian-like
+  filter.
+
+  Interpolation is returned into the _xi_, _yi_ and _y2i_ vectors
+
+  TODO: try to place the points more in the middle ? (provide a factor
+  governing this)
+  
+  TODO: use moments to decide of the precise position of the
+  points ?
+
+*/
+static void internal_spline_approximation(const double *x, const double *y,
+					  long len, 
+					  double *xi, double *yi, 
+					  double *y2i,
+					  long nbmax,
+					  long nbavg, 
+					  double * target) 
+{
+  double left_slope;		/* Derivative on the left */
+  double right_slope;		/* Same on the right */
+  
+  /* The gaussian kernel for the average */
+  double kernel[nbavg];
+  
+  /* The indices of the point where the residuals are maximal */
+  long max_res_idx[nbmax-1];
+
+  /* The indices of the corner points*/
+  long indices[nbmax];
+
+  long i;
+  long cur_size = 3;
+  double tmp,tmp2;
+  /* Initialization of the kernel */
+  long mid = nbavg/2;		/* Middle of the kernel */
+  for(i = 0,tmp=0; i < nbavg; i++) {
+    tmp = (3.2 * (i - nbavg/2))/nbavg; /* Gives about 7% left on the
+					  side elements */
+    tmp = exp(-tmp*tmp);
+    kernel[i] = tmp;
+  }
+  
+  /* Left side */
+  xi[0] = x[0];
+  reglin(x,y, mid+1, &left_slope, &tmp2);
+  yi[0] = left_slope * x[0] + tmp2;
+  indices[0] = 0;
+
+  /* Middle */
+  xi[1] = x[len/2];
+  yi[1] = norm_convolve(y, len, len/2, kernel, nbavg, mid);
+  indices[1] = len/2;
+
+  /* Right */
+  xi[2] = x[len-1];
+  reglin(x+(len-(mid+2)),y + (len-(mid+2)), mid+1, &right_slope, &tmp2);
+  yi[2] = right_slope * x[len-1] + tmp2;
+  indices[2] = len - 1;
+
+  do {
+    long cur_seg;
+    long max_res_seg = 0;	/* The segment where the residuals are
+				   the greatest */
+    double max_res = 0;
+
+    long max_deviation_seg = 0; /* The segment where the deviation
+				   (square of the average) is the
+				   greatest */
+    double max_deviation = 0;
+
+    long chosen_seg;	      /* The segment in which we'll add a point */
+    /* Compute interpolation */
+    function_fill_second_derivatives(cur_size, xi, yi, y2i, 
+				     left_slope, right_slope);
+
+
+    /* We stop here if we have reached the max number and we're not
+       interested in Y values */
+    if(cur_size >= nbmax && !target)
+      break;
+
+    /* Now we compute the residuals  */
+    for(cur_seg = 0; cur_seg < cur_size - 1; cur_seg++) {
+      double residuals = 0;
+      double a,b,int_y,delta,h = xi[cur_seg+1] - xi[cur_seg];
+      double imr = 0;		/* Internal max residuals */
+      double deviation = 0;
+      /* printf("seg: %ld/%ld indices %ld -- %ld\n", cur_seg, cur_size-1,  */
+      /* 	     indices[cur_seg], indices[cur_seg+1]); */
+      for(i = indices[cur_seg] + 1; i < indices[cur_seg+1]; i++) {
+	a = (xi[cur_seg+1] - x[i])/h;
+	b = (x[i] - xi[cur_seg])/h;
+	int_y = a * yi[cur_seg] + b * yi[cur_seg + 1] 
+	  + ((a*a*a - a) * y2i[cur_seg] +
+	     (b*b*b - b) * y2i[cur_seg + 1]) * 
+	  (h * h)/6.0;
+	if(target)		/* We set the value if applicable. */
+	  target[i] = int_y;
+	delta = int_y - y[i];
+	deviation += delta;
+	delta *= delta;
+	residuals += delta;
+	if(delta > imr) {
+	  imr = delta;
+	  max_res_idx[cur_seg] = i;
+	}
+      }
+      if(max_res < residuals) {
+	max_res = residuals;
+	max_res_seg = cur_seg;
+      }
+      deviation *= deviation;
+      if(deviation > max_deviation) {
+	max_deviation_seg = cur_seg;
+	max_deviation = deviation;
+      }
+      /* printf(" -> residuals %g\n", cur_seg, cur_size-1,  */
+      /* 	     residuals); */
+    }
+    /* printf("-> max residuals at segment %d\n", max_res_seg); */
+
+    if(cur_size >= nbmax)
+      break;
+
+    
+    /* OK, so now we know in which segment the residuals are the
+       greatest, and which point of this segment is holds the max
+       residuals. So we just add a point there */
+    chosen_seg = max_deviation_seg;
+
+    /* We shift the positions */
+    for(i = cur_size; i > chosen_seg + 1; i--) {
+      xi[i] = xi[i-1];
+      yi[i] = yi[i-1];
+      y2i[i] = y2i[i-1];
+      indices[i] = indices[i-1];
+    }
+    cur_size++;
+    xi[chosen_seg + 1] = x[max_res_idx[chosen_seg]];
+    yi[chosen_seg + 1] = norm_convolve(y, len, max_res_idx[chosen_seg], 
+					kernel, nbavg, mid);
+    indices[chosen_seg + 1] = max_res_idx[chosen_seg];
+  } while(1);
+
+  /* Now fill in the missing values of y, since we do not evaluate them */
+  if(target) {
+    for(i = 0; i < nbmax; i++)
+      target[indices[i]] = yi[i];
+  }
+  
+  
+}
+
+/* 
+   Filters the Function through interpolation. _params_ holds a 
+   hash with the following values:
+   * ??
+
+   It returns a hash.
+*/
+static VALUE function_spline_approximation(VALUE self, VALUE params)
+{
+  long len = function_sanity_check(self);
+  const double *x = Dvector_Data_for_Read(get_x_vector(self),NULL);
+  const double *y = Dvector_Data_for_Read(get_y_vector(self),NULL);
+  VALUE xiret, yiret, y2iret, yintret,ret;
+  double * xi, *yi, *y2i, *yint;
+  long nbavg = 9;  
+  long nbmax = 20;
+  if(RTEST(rb_hash_aref(params, rb_str_new2("number"))))
+    nbmax = NUM2LONG(rb_hash_aref(params, rb_str_new2("number")));
+  if(RTEST(rb_hash_aref(params, rb_str_new2("average"))))
+    nbavg = NUM2LONG(rb_hash_aref(params, rb_str_new2("average")));
+
+  /* TODO: add checks that monotonic and growing. */
+  
+  xiret = rb_funcall(cDvector, idNew, 1, INT2NUM(nbmax)); 
+  xi = Dvector_Data_for_Write(xiret, NULL);
+  yiret = rb_funcall(cDvector, idNew, 1, INT2NUM(nbmax)); 
+  yi = Dvector_Data_for_Write(yiret, NULL);
+  y2iret = rb_funcall(cDvector, idNew, 1, INT2NUM(nbmax)); 
+  y2i = Dvector_Data_for_Write(y2iret, NULL);
+  yintret = rb_funcall(cDvector, idNew, 1, INT2NUM(len)); 
+  yint = Dvector_Data_for_Write(yintret, NULL);
+
+  internal_spline_approximation(x, y, len, xi, yi, y2i,
+				nbmax, nbavg, yint);
+  ret = rb_hash_new();
+  rb_hash_aset(ret, rb_str_new2("xi"), xiret);
+  rb_hash_aset(ret, rb_str_new2("yi"), yiret);
+  rb_hash_aset(ret, rb_str_new2("y2i"), y2iret);
+  rb_hash_aset(ret, rb_str_new2("y"), yintret);
+  return ret;
+}
+
+
 /*
   Document-class: Dobjects::Function
 
@@ -1035,16 +1640,21 @@ static VALUE function_bound_values(VALUE self,
   - facilities for sorting the X while keeping the Y matching, with #sort and
     Function.joint_sort;
   - to check if X data is sorted: #sorted?, #is_sorted;
-  - interpolation, with #compute_spline, #compute_spline_data and #interpolate;
+  - interpolation, with #compute_spline, #compute_spline_data and #interpolate
   - some functions for data access : #x, #y, #point;
-  - some utiliy functions: #split_monotonic, #strip_nan;
+  - some utiliy functions: #split_monotonic, #strip_nan, #reverse!
   - data inspection: #min, #max;
-  - some computational functions: #integrate, #primitive, #derivative.
+  - some computational functions: #integrate, #primitive, #derivative,
+    and now 4th-order accurate first and second derivatives: #diff_5p
+    and #diff2_5p
   - utility for fuzzy operations, when the X values of two functions
     differ, but only slightly, of when points are missing: 
     #fuzzy_sub!
+  - linear regression #reglin
+  - a function to approximate data using a low-order spline:
+    #spline_approximation
 
-  And getting bigger everyday...
+  And getting bigger (almost) everyday...
  */ 
 void Init_Function() 
 {
@@ -1059,6 +1669,7 @@ void Init_Function()
 
   rb_define_method(cFunction, "initialize", function_initialize, 2);
   rb_define_method(cFunction, "sorted?", function_is_sorted, 0);
+  rb_define_method(cFunction, "reverse!", function_reverse, 0);
   rb_define_alias(cFunction,  "is_sorted", "sorted?");
 
   rb_define_singleton_method(cFunction, "joint_sort", function_joint_sort, 2);
@@ -1074,15 +1685,24 @@ void Init_Function()
 		   function_interpolate, 1);
   rb_define_method(cFunction, "make_interpolant", 
 		   function_make_interpolant, 0);
+  rb_define_method(cFunction, "spline_approximation", 
+		   function_spline_approximation, 1);
+
 
   /* access to data */
   rb_define_method(cFunction, "point", function_point, 1);
+  rb_define_method(cFunction, "[]", function_point, 1);
   rb_define_method(cFunction, "x", get_x_vector, 0);
   rb_define_method(cFunction, "y", get_y_vector, 0);
 
 
   rb_define_method(cFunction, "size", function_size, 0);
   rb_define_alias(cFunction,  "length", "size");
+
+  /* Soas-like functions ;-) */
+  rb_define_method(cFunction, "reglin", function_reglin, -1);
+  rb_define_method(cFunction, "smooth_pick", function_smooth_pick, -1);
+
 		   
 
   /* iterator */
@@ -1092,8 +1712,9 @@ void Init_Function()
   /* stripping of NaNs */
   rb_define_method(cFunction, "strip_nan", function_strip_nan, 0);
 
-  /* split into monotonic subfunctions */
+  /* split into subfunctions with given properties */
   rb_define_method(cFunction, "split_monotonic", function_split_monotonic, 0);
+  rb_define_method(cFunction, "split_on_nan", function_split_on_nan, 1);
 
   /* integration between two integer boundaries */
   rb_define_method(cFunction, "integrate", function_integrate, -1);
@@ -1102,6 +1723,10 @@ void Init_Function()
   /* derivative */
   rb_define_method(cFunction, "derivative", function_derivative, 0);
 
+  /* 5-points derivatives */
+  rb_define_method(cFunction, "diff_5p", function_diff_5p, 0);
+  rb_define_method(cFunction, "diff2_5p", function_diff2_5p, 0);
+
   /* distance to a point */
   rb_define_method(cFunction, "distance", function_distance, -1);