gsl 1.15.3 → 1.16.0.6

data/ext/{siman.c → gsl_native/siman.c}

@@ -11,11 +11,11 @@
 
 #include <gsl/gsl_rng.h>
 #include <gsl/gsl_siman.h>
-#include "rb_gsl.h"
-#include "rb_gsl_array.h"
-#include "rb_gsl_function.h"
-#include "rb_gsl_rng.h"
-#include "rb_gsl_common.h"
+#include "include/rb_gsl.h"
+#include "include/rb_gsl_array.h"
+#include "include/rb_gsl_function.h"
+#include "include/rb_gsl_rng.h"
+#include "include/rb_gsl_common.h"
 
 static VALUE cgsl_siman_Efunc;
 static VALUE cgsl_siman_step;
@@ -128,7 +128,7 @@ static VALUE rb_gsl_siman_Efunc_set(int argc, VALUE *argv, VALUE obj)
   Data_Get_Struct(obj, siman_Efunc, se);
   switch (argc) {
   case 0:
-    if (rb_block_given_p()) se->proc = RB_GSL_MAKE_PROC;
+    if (rb_block_given_p()) se->proc = rb_block_proc();
     break;
   case 1:
     if (rb_obj_is_kind_of(argv[0], rb_cProc)) se->proc = argv[0];
@@ -233,7 +233,7 @@ static VALUE rb_gsl_siman_print_set(int argc, VALUE *argv, VALUE obj)
   Data_Get_Struct(obj, siman_print, se);
   switch (argc) {
   case 0:
-    if (rb_block_given_p()) se->proc = RB_GSL_MAKE_PROC;
+    if (rb_block_given_p()) se->proc = rb_block_proc();
     break;
   case 1:
     if (rb_obj_is_kind_of(argv[0], rb_cProc)) se->proc = argv[0];
@@ -302,7 +302,7 @@ static VALUE rb_gsl_siman_step_set(int argc, VALUE *argv, VALUE obj)
   Data_Get_Struct(obj, siman_step, se);
   switch (argc) {
   case 0:
-    if (rb_block_given_p()) se->proc = RB_GSL_MAKE_PROC;
+    if (rb_block_given_p()) se->proc = rb_block_proc();
     break;
   case 1:
     if (rb_obj_is_kind_of(argv[0], rb_cProc)) se->proc = argv[0];
@@ -331,7 +331,7 @@ static siman_metric* siman_metric_alloc()
   se = ALLOC(siman_metric);
   if (se == NULL) rb_raise(rb_eRuntimeError, "ALLOC failed");
   se->siman_metric_t = &rb_gsl_siman_metric_t;
-   return se;
+  return se;
 }
 
 static void siman_metric_mark(siman_metric *se)
@@ -373,7 +373,7 @@ static VALUE rb_gsl_siman_metric_set(int argc, VALUE *argv, VALUE obj)
   Data_Get_Struct(obj, siman_metric, se);
   switch (argc) {
   case 0:
-    if (rb_block_given_p()) se->proc = RB_GSL_MAKE_PROC;
+    if (rb_block_given_p()) se->proc = rb_block_proc();
     break;
   case 1:
     if (rb_obj_is_kind_of(argv[0], rb_cProc)) se->proc = argv[0];
@@ -419,22 +419,22 @@ static VALUE rb_gsl_siman_params_set(int argc, VALUE *argv, VALUE obj)
   switch (argc) {
   case 7:
     params->t_min = NUM2DBL(argv[6]);
-    /* no break */
+  /* no break */
   case 6:
     params->mu_t = NUM2DBL(argv[5]);
-    /* no break */
+  /* no break */
   case 5:
     params->t_initial = NUM2DBL(argv[4]);
-    /* no break */
+  /* no break */
   case 4:
     params->k = NUM2DBL(argv[3]);
-    /* no break */
+  /* no break */
   case 3:
     params->step_size = NUM2DBL(argv[2]);
-    /* no break */
+  /* no break */
   case 2:
     params->iters_fixed_T = NUM2INT(argv[1]);
-    /* no break */
+  /* no break */
   case 1:
     params->n_tries = NUM2INT(argv[0]);
   }
@@ -551,16 +551,16 @@ static VALUE rb_gsl_siman_params_params(VALUE obj)
   gsl_siman_params_t *params = NULL;
   Data_Get_Struct(obj, gsl_siman_params_t, params);
   return rb_ary_new3(7, INT2FIX(params->n_tries), INT2FIX(params->iters_fixed_T),
-		     rb_float_new(params->step_size), rb_float_new(params->k),
-		     rb_float_new(params->t_initial), rb_float_new(params->mu_t),
-		     rb_float_new(params->t_min));
+                     rb_float_new(params->step_size), rb_float_new(params->k),
+                     rb_float_new(params->t_initial), rb_float_new(params->mu_t),
+                     rb_float_new(params->t_min));
 }
 
 /***** solver *****/
 static VALUE rb_gsl_siman_solver_solve(VALUE obj, VALUE rng,
-				       VALUE vx0p, VALUE vefunc,
-				       VALUE vstep, VALUE vmetric, VALUE vprint,
-				       VALUE vparams)
+                                       VALUE vx0p, VALUE vefunc,
+                                       VALUE vstep, VALUE vmetric, VALUE vprint,
+                                       VALUE vparams)
 {
   gsl_rng *r = NULL;
   siman_solver *ss = NULL;
@@ -587,17 +587,16 @@ static VALUE rb_gsl_siman_solver_solve(VALUE obj, VALUE rng,
   }
   if (!rb_obj_is_kind_of(rng, cgsl_rng))
     rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Rng expected)",
-	     rb_class2name(CLASS_OF(rng)));
+             rb_class2name(CLASS_OF(rng)));
   if (!rb_obj_is_kind_of(vefunc, cgsl_siman_Efunc))
     rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Siman::Efunc expected)",
-	     rb_class2name(CLASS_OF(vefunc)));
+             rb_class2name(CLASS_OF(vefunc)));
   if (!rb_obj_is_kind_of(vstep, cgsl_siman_step))
     rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Siman::Step expected)",
-	     rb_class2name(CLASS_OF(vstep)));
+             rb_class2name(CLASS_OF(vstep)));
   if (!rb_obj_is_kind_of(vmetric, cgsl_siman_metric))
     rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Siman::Metric expected)",
-	     rb_class2name(CLASS_OF(vmetric)));
-
+             rb_class2name(CLASS_OF(vmetric)));
   Data_Get_Struct(rng, gsl_rng, r);
   Data_Get_Struct(vefunc, siman_Efunc, efunc);
   Data_Get_Struct(vstep, siman_step, step);
@@ -607,14 +606,13 @@ static VALUE rb_gsl_siman_solver_solve(VALUE obj, VALUE rng,
   } else {
     if (!rb_obj_is_kind_of(vprint, cgsl_siman_print))
       rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Siman::Print expected)",
-	       rb_class2name(CLASS_OF(vprint)));
+               rb_class2name(CLASS_OF(vprint)));
     Data_Get_Struct(vprint, siman_print, print);
     ss->proc_print   = print->proc;
   }
   if (!rb_obj_is_kind_of(vparams, cgsl_siman_params))
     rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Siman::Params expected)",
-	     rb_class2name(CLASS_OF(vparams)));
-
+             rb_class2name(CLASS_OF(vparams)));
   Data_Get_Struct(vparams, gsl_siman_params_t, params);
 
   ss->proc_efunc   = efunc->proc;
@@ -624,30 +622,28 @@ static VALUE rb_gsl_siman_solver_solve(VALUE obj, VALUE rng,
   gsl_vector_memcpy(ss->vx, vtmp);
 
   if (NIL_P(vprint)) {
-    gsl_siman_solve(r, ss, rb_gsl_siman_Efunc_t, 
-		    rb_gsl_siman_step_t, 
-		    rb_gsl_siman_metric_t, 
-		    NULL,
-		    rb_gsl_siman_copy_t, 
-		    rb_gsl_siman_copy_construct_t,
-		    rb_gsl_siman_destroy_t, 0,
-		    *params);
+    gsl_siman_solve(r, ss, rb_gsl_siman_Efunc_t,
+                    rb_gsl_siman_step_t,
+                    rb_gsl_siman_metric_t,
+                    NULL,
+                    rb_gsl_siman_copy_t,
+                    rb_gsl_siman_copy_construct_t,
+                    rb_gsl_siman_destroy_t, 0,
+                    *params);
 
   } else {
-    gsl_siman_solve(r, ss, rb_gsl_siman_Efunc_t, 
-		    rb_gsl_siman_step_t, 
-		    rb_gsl_siman_metric_t, 
-		    rb_gsl_siman_print_t, 
-		    rb_gsl_siman_copy_t, 
-		    rb_gsl_siman_copy_construct_t,
-		    rb_gsl_siman_destroy_t, 0,
-		    *params);
+    gsl_siman_solve(r, ss, rb_gsl_siman_Efunc_t,
+                    rb_gsl_siman_step_t,
+                    rb_gsl_siman_metric_t,
+                    rb_gsl_siman_print_t,
+                    rb_gsl_siman_copy_t,
+                    rb_gsl_siman_copy_construct_t,
+                    rb_gsl_siman_destroy_t, 0,
+                    *params);
   }
-
   gsl_vector_memcpy(vtmp, ss->vx);
 
   if (flag == 1) gsl_siman_solver_free(ss);
-
   return obj;
 }
 
@@ -681,7 +677,7 @@ void Init_gsl_siman(VALUE module)
   rb_define_singleton_method(cgsl_siman_metric, "alloc", rb_gsl_siman_metric_new, -1);
   rb_define_method(cgsl_siman_metric, "set", rb_gsl_siman_metric_set, -1);
   rb_define_alias(cgsl_siman_metric, "set_proc", "set");
-  
+
   /***** params *****/
   rb_define_singleton_method(cgsl_siman_params, "alloc", rb_gsl_siman_params_new, -1);
   rb_define_method(cgsl_siman_params, "set", rb_gsl_siman_params_set, -1);

data/ext/{sort.c → gsl_native/sort.c}

@@ -9,10 +9,10 @@
   WITHOUT ANY WARRANTY.
 */
 
-#include "rb_gsl_config.h"
-#include "rb_gsl_array.h"
+#include "include/rb_gsl_array.h"
 #include <gsl/gsl_heapsort.h>
 #include <gsl/gsl_sort.h>
+
 EXTERN ID RBGSL_ID_call;
 EXTERN VALUE cgsl_complex;
 
@@ -23,7 +23,7 @@ int rb_gsl_comparison_double(const void *aa, const void *bb)
   double *a = NULL, *b = NULL;
   a = (double *) aa;
   b = (double *) bb;
-  return FIX2INT(rb_funcall(RB_GSL_MAKE_PROC, RBGSL_ID_call, 2, rb_float_new(*a), rb_float_new(*b)));
+  return FIX2INT(rb_funcall(rb_block_proc(), RBGSL_ID_call, 2, rb_float_new(*a), rb_float_new(*b)));
 }
 
 int rb_gsl_comparison_complex(const void *aa, const void *bb)
@@ -31,9 +31,9 @@ int rb_gsl_comparison_complex(const void *aa, const void *bb)
   gsl_complex *a = NULL, *b = NULL;
   a = (gsl_complex *) aa;
   b = (gsl_complex *) bb;
-  return FIX2INT(rb_funcall(RB_GSL_MAKE_PROC, RBGSL_ID_call, 2, 
-			    Data_Wrap_Struct(cgsl_complex, 0, NULL, a),
-			    Data_Wrap_Struct(cgsl_complex, 0, NULL, b)));
+  return FIX2INT(rb_funcall(rb_block_proc(), RBGSL_ID_call, 2,
+                            Data_Wrap_Struct(cgsl_complex, 0, NULL, a),
+                            Data_Wrap_Struct(cgsl_complex, 0, NULL, b)));
 }
 
 static VALUE rb_gsl_heapsort_vector(VALUE obj)
@@ -141,7 +141,6 @@ static VALUE rb_gsl_heapsort_index(VALUE obj, VALUE vv)
 /*****/
 
 #ifdef HAVE_NARRAY_H
-#include "narray.h"
 static VALUE rb_gsl_sort_narray(VALUE obj)
 {
   struct NARRAY *na;

data/ext/{spline.c → gsl_native/spline.c}

@@ -9,8 +9,8 @@
   WITHOUT ANY WARRANTY.
 */
 
-#include "rb_gsl_config.h"
-#include "rb_gsl_interp.h"
+#include "include/rb_gsl_interp.h"
+
 EXTERN VALUE cgsl_interp_accel;  /* defined in interp.c */
 
 static void rb_gsl_spline_free(rb_gsl_spline *sp);
@@ -33,10 +33,10 @@ static VALUE rb_gsl_spline_new(int argc, VALUE *argv, VALUE klass)
       break;
     default:
       if (ptrx == NULL) {
-	ptrx = get_vector_ptr(argv[i], &stride, &sizex);
+        ptrx = get_vector_ptr(argv[i], &stride, &sizex);
       } else {
-	ptry = get_vector_ptr(argv[i], &stride, &sizey);
-	size = GSL_MIN_INT(sizex, sizey);
+        ptry = get_vector_ptr(argv[i], &stride, &sizey);
+        size = GSL_MIN_INT(sizex, sizey);
       }
       break;
     }
@@ -65,9 +65,6 @@ static VALUE rb_gsl_spline_init(VALUE obj, VALUE xxa, VALUE yya)
   size_t i, size;
   int flagx = 0, flagy = 0;
   double *ptr1 = NULL, *ptr2 = NULL;
-#ifdef HAVE_NARRAY_H
-  struct NARRAY *nax = NULL, *nay = NULL;
-#endif
   Data_Get_Struct(obj, rb_gsl_spline, sp);
   p = sp->s;
   if (TYPE(xxa) == T_ARRAY) {
@@ -83,9 +80,10 @@ static VALUE rb_gsl_spline_init(VALUE obj, VALUE xxa, VALUE yya)
     ptr1 = xa->data;
 #ifdef HAVE_NARRAY_H
   } else if (NA_IsNArray(xxa)) {
-      GetNArray(xxa, nax);
-      size = nax->total;
-      ptr1 = (double *) nax->ptr;
+    struct NARRAY *nax = NULL;
+    GetNArray(xxa, nax);
+    size = nax->total;
+    ptr1 = (double *) nax->ptr;
 #endif
   } else {
     rb_raise(rb_eTypeError, "not a vector");
@@ -97,8 +95,9 @@ static VALUE rb_gsl_spline_init(VALUE obj, VALUE xxa, VALUE yya)
     flagy = 1;
 #ifdef HAVE_NARRAY_H
   } else if (NA_IsNArray(yya)) {
-      GetNArray(yya, nay);
-      ptr2 = (double *) nay->ptr;
+    struct NARRAY *nay = NULL;
+    GetNArray(yya, nay);
+    ptr2 = (double *) nay->ptr;
 #endif
   } else if (VECTOR_P(yya)) {
     Data_Get_Struct(yya, gsl_vector, ya);
@@ -120,8 +119,8 @@ static VALUE rb_gsl_spline_accel(VALUE obj)
 }
 
 static VALUE rb_gsl_spline_evaluate(VALUE obj, VALUE xx,
-				    double (*eval)(const gsl_spline *, double, 
-						   gsl_interp_accel *))
+                                    double (*eval)(const gsl_spline *, double,
+                                                   gsl_interp_accel *))
 {
   rb_gsl_spline *rgs = NULL;
   gsl_vector *v = NULL, *vnew = NULL;
@@ -129,10 +128,6 @@ static VALUE rb_gsl_spline_evaluate(VALUE obj, VALUE xx,
   VALUE ary, x;
   double val;
   size_t n, i, j;
-#ifdef HAVE_NARRAY_H
-  double *ptr1 = NULL, *ptr2 = NULL;
-  struct NARRAY *na = NULL;
-#endif
   Data_Get_Struct(obj, rb_gsl_spline, rgs);
   if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
   switch (TYPE(xx)) {
@@ -155,13 +150,15 @@ static VALUE rb_gsl_spline_evaluate(VALUE obj, VALUE xx,
   default:
 #ifdef HAVE_NARRAY_H
     if (NA_IsNArray(xx)) {
+      double *ptr1 = NULL, *ptr2 = NULL;
+      struct NARRAY *na = NULL;
       GetNArray(xx, na);
       ptr1 = (double *) na->ptr;
       n = na->total;
       ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(xx));
       ptr2 = NA_PTR_TYPE(ary, double*);
-      for (i = 0; i < n; i++) 
-	ptr2[i] = (*eval)(rgs->s, ptr1[i], rgs->a);
+      for (i = 0; i < n; i++)
+        ptr2[i] = (*eval)(rgs->s, ptr1[i], rgs->a);
       return ary;
     }
 #endif
@@ -169,18 +166,18 @@ static VALUE rb_gsl_spline_evaluate(VALUE obj, VALUE xx,
       Data_Get_Struct(xx, gsl_vector, v);
       vnew = gsl_vector_alloc(v->size);
       for (i = 0; i < v->size; i++) {
-	val = (*eval)(rgs->s, gsl_vector_get(v, i), rgs->a);
-	gsl_vector_set(vnew, i, val);
+        val = (*eval)(rgs->s, gsl_vector_get(v, i), rgs->a);
+        gsl_vector_set(vnew, i, val);
       }
       return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
     } else if (MATRIX_P(xx)) {
       Data_Get_Struct(xx, gsl_matrix, m);
       mnew = gsl_matrix_alloc(m->size1, m->size2);
       for (i = 0; i < m->size1; i++) {
-	for (j = 0; j < m->size2; j++) {
-	  val = (*eval)(rgs->s, gsl_matrix_get(m, i, j), rgs->a);
-	  gsl_matrix_set(mnew, i, j, val);
-	}
+        for (j = 0; j < m->size2; j++) {
+          val = (*eval)(rgs->s, gsl_matrix_get(m, i, j), rgs->a);
+          gsl_matrix_set(mnew, i, j, val);
+        }
       }
       return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
     } else {
@@ -270,7 +267,7 @@ static VALUE rb_gsl_spline_eval_deriv_e(VALUE obj, VALUE xx)
   default:
     return rb_float_new(val);
     break;
-  } 
+  }
   return Qnil;
 }
 
@@ -289,7 +286,7 @@ static VALUE rb_gsl_spline_eval_deriv2_e(VALUE obj, VALUE xx)
   default:
     return rb_float_new(val);
     break;
-  } 
+  }
   return Qnil;
 }
 
@@ -308,7 +305,7 @@ static VALUE rb_gsl_spline_eval_integ_e(VALUE obj, VALUE a, VALUE b)
   default:
     return rb_float_new(val);
     break;
-  } 
+  }
   return Qnil;
 }
 
@@ -318,7 +315,7 @@ static VALUE rb_gsl_spline_info(VALUE obj)
   char buf[256];
   Data_Get_Struct(obj, rb_gsl_spline, p);
   sprintf(buf, "Class:      %s\n", rb_class2name(CLASS_OF(obj)));
-  //  sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS(CLASS_OF(obj))->super));
+  sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS_SUPER(CLASS_OF(obj))));
   sprintf(buf, "%sType:       %s\n", buf, gsl_interp_name(p->s->interp));
   sprintf(buf, "%sxmin:       %f\n", buf, p->s->interp->xmin);
   sprintf(buf, "%sxmax:       %f\n", buf, p->s->interp->xmax);
@@ -326,7 +323,6 @@ static VALUE rb_gsl_spline_info(VALUE obj)
   return rb_str_new2(buf);
 }
 
-#ifdef GSL_1_8_LATER
 static VALUE rb_gsl_spline_name(VALUE obj)
 {
   rb_gsl_spline *p = NULL;
@@ -340,17 +336,6 @@ static VALUE rb_gsl_spline_min_size(VALUE obj)
   return UINT2NUM(gsl_spline_min_size(sp->s));
 }
 
-#else
-
-static VALUE rb_gsl_spline_name(VALUE obj)
-{
-  rb_gsl_spline *sp = NULL;
-  Data_Get_Struct(obj, rb_gsl_spline, sp);
-  return rb_str_new2(gsl_interp_name(sp->s->interp));
-}
-
-#endif
-
 void Init_gsl_spline(VALUE module)
 {
   VALUE cgsl_spline;
@@ -388,8 +373,5 @@ void Init_gsl_spline(VALUE module)
 
   rb_define_method(cgsl_spline, "info", rb_gsl_spline_info, 0);
 
-#ifdef GSL_1_8_LATER
   rb_define_method(cgsl_spline, "min_size", rb_gsl_spline_min_size, 0);
-#endif
-
 }

data/ext/{stats.c → gsl_native/stats.c}

@@ -8,15 +8,12 @@
   This library is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY.
 */
-#include "rb_gsl_config.h"
-#include "rb_gsl_array.h"
-#include "rb_gsl_statistics.h"
-#ifdef HAVE_NARRAY_H
-#include "narray.h"
-#endif
 
-static double* get_vector_stats2(int argc, VALUE *argv, VALUE obj, 
-				 size_t *stride, size_t *size)
+#include "include/rb_gsl_array.h"
+#include "include/rb_gsl_statistics.h"
+
+static double* get_vector_stats2(int argc, VALUE *argv, VALUE obj,
+                                 size_t *stride, size_t *size)
 {
   double *v = NULL;
   switch (TYPE(obj)) {
@@ -32,7 +29,7 @@ static double* get_vector_stats2(int argc, VALUE *argv, VALUE obj,
 }
 
 static VALUE rb_gsl_stats_XXX(int argc, VALUE *argv, VALUE obj,
-			      double (*f)(const double*, size_t, size_t))
+                              double (*f)(const double*, size_t, size_t))
 {
   size_t stride, size;
   double *data = NULL;
@@ -40,8 +37,8 @@ static VALUE rb_gsl_stats_XXX(int argc, VALUE *argv, VALUE obj,
   return rb_float_new((*f)(data, stride, size));
 }
 
-static VALUE rb_gsl_stats_XXX1(int argc, VALUE *argv, VALUE obj, 
-			      double (*f)(const double*, size_t, size_t, double))
+static VALUE rb_gsl_stats_XXX1(int argc, VALUE *argv, VALUE obj,
+                               double (*f)(const double*, size_t, size_t, double))
 {
   size_t stride, size;
   double *data = NULL;
@@ -50,9 +47,9 @@ static VALUE rb_gsl_stats_XXX1(int argc, VALUE *argv, VALUE obj,
   return rb_float_new((*f)(data, stride, size, NUM2DBL(argv[argc-1])));
 }
 
-static VALUE rb_gsl_stats_XXX2(int argc, VALUE *argv, VALUE obj, 
-			       double (*f)(const double*, size_t, size_t),
-			       double (*fm)(const double*, size_t, size_t, double, double))
+static VALUE rb_gsl_stats_XXX2(int argc, VALUE *argv, VALUE obj,
+                               double (*f)(const double*, size_t, size_t),
+                               double (*fm)(const double*, size_t, size_t, double, double))
 {
   double x, a, b, *data = NULL;
   size_t stride, size;
@@ -69,8 +66,8 @@ static VALUE rb_gsl_stats_XXX2(int argc, VALUE *argv, VALUE obj,
       x = (*f)(data, stride, size);
       break;
     default:
-      rb_raise(rb_eArgError, 
-	       "wrong number of arguments (%d for 1 or 2)", argc);
+      rb_raise(rb_eArgError,
+               "wrong number of arguments (%d for 1 or 2)", argc);
       break;
     }
     break;
@@ -86,8 +83,8 @@ static VALUE rb_gsl_stats_XXX2(int argc, VALUE *argv, VALUE obj,
       x = (*fm)(data, stride, size, a, b);
       break;
     default:
-      rb_raise(rb_eArgError, 
-	       "wrong number of arguments (%d for 0 or 1)", argc);
+      rb_raise(rb_eArgError,
+               "wrong number of arguments (%d for 0 or 1)", argc);
       break;
     }
     break;
@@ -101,8 +98,8 @@ static VALUE rb_gsl_stats_mean(int argc, VALUE *argv, VALUE obj)
 }
 
 static VALUE rb_gsl_stats_XXX_m(int argc, VALUE *argv, VALUE obj,
-				double (*f)(const double*, size_t, size_t),
-				double (*fm)(const double*, size_t, size_t, double))
+                                double (*f)(const double*, size_t, size_t),
+                                double (*fm)(const double*, size_t, size_t, double))
 {
   double x, mean, *data = NULL;
   size_t stride, size;
@@ -119,8 +116,8 @@ static VALUE rb_gsl_stats_XXX_m(int argc, VALUE *argv, VALUE obj,
       x = (*f)(data, stride, size);
       break;
     default:
-      rb_raise(rb_eArgError, 
-	       "wrong number of arguments (%d for 1 or 2)", argc);
+      rb_raise(rb_eArgError,
+               "wrong number of arguments (%d for 1 or 2)", argc);
       break;
     }
     break;
@@ -136,8 +133,8 @@ static VALUE rb_gsl_stats_XXX_m(int argc, VALUE *argv, VALUE obj,
       x = (*fm)(data, stride, size, mean);
       break;
     default:
-      rb_raise(rb_eArgError, 
-	       "wrong number of arguments (%d for 0 or 1)", argc);
+      rb_raise(rb_eArgError,
+               "wrong number of arguments (%d for 0 or 1)", argc);
       break;
     }
     break;
@@ -148,70 +145,68 @@ static VALUE rb_gsl_stats_XXX_m(int argc, VALUE *argv, VALUE obj,
 static VALUE rb_gsl_stats_variance_m(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_stats_XXX_m(argc, argv, obj,
-			    gsl_stats_variance, gsl_stats_variance_m);
+                            gsl_stats_variance, gsl_stats_variance_m);
 }
 
 static VALUE rb_gsl_stats_sd_m(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_stats_XXX_m(argc, argv, obj,
-			    gsl_stats_sd, gsl_stats_sd_m);
+                            gsl_stats_sd, gsl_stats_sd_m);
 }
 
-#ifdef GSL_1_11_LATER
 static VALUE rb_gsl_stats_tss_m(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_stats_XXX_m(argc, argv, obj,
-			    gsl_stats_tss, gsl_stats_tss_m);
+                            gsl_stats_tss, gsl_stats_tss_m);
 }
-#endif
 
-static VALUE rb_gsl_stats_variance_with_fixed_mean(int argc, VALUE *argv, 
-						   VALUE obj)
+static VALUE rb_gsl_stats_variance_with_fixed_mean(int argc, VALUE *argv,
+                                                   VALUE obj)
 {
   return rb_gsl_stats_XXX1(argc, argv, obj,
-			   gsl_stats_variance_with_fixed_mean);
+                           gsl_stats_variance_with_fixed_mean);
 }
 
-static VALUE rb_gsl_stats_sd_with_fixed_mean(int argc, VALUE *argv, 
-						   VALUE obj)
+static VALUE rb_gsl_stats_sd_with_fixed_mean(int argc, VALUE *argv,
+                                             VALUE obj)
 {
   return rb_gsl_stats_XXX1(argc, argv, obj,
-			   gsl_stats_sd_with_fixed_mean);
+                           gsl_stats_sd_with_fixed_mean);
 }
 
 static VALUE rb_gsl_stats_absdev_m(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_stats_XXX_m(argc, argv, obj,
-			    gsl_stats_absdev, gsl_stats_absdev_m);
+                            gsl_stats_absdev, gsl_stats_absdev_m);
 }
 
-static VALUE rb_gsl_stats_skew(int argc, VALUE *argv, 
-			       VALUE obj)
+static VALUE rb_gsl_stats_skew(int argc, VALUE *argv,
+                               VALUE obj)
 {
   return rb_gsl_stats_XXX2(argc, argv, obj,
-			   gsl_stats_skew,
-			   gsl_stats_skew_m_sd);
+                           gsl_stats_skew,
+                           gsl_stats_skew_m_sd);
 }
 
-static VALUE rb_gsl_stats_kurtosis(int argc, VALUE *argv, 
-						   VALUE obj)
+static VALUE rb_gsl_stats_kurtosis(int argc, VALUE *argv,
+                                   VALUE obj)
 {
   return rb_gsl_stats_XXX2(argc, argv, obj,
-			   gsl_stats_kurtosis,
-			   gsl_stats_kurtosis_m_sd);
+                           gsl_stats_kurtosis,
+                           gsl_stats_kurtosis_m_sd);
 }
 
 static VALUE rb_gsl_stats_lag1_autocorrelation(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_stats_XXX_m(argc, argv, obj,
-			    gsl_stats_lag1_autocorrelation, gsl_stats_lag1_autocorrelation_m);
+                            gsl_stats_lag1_autocorrelation, gsl_stats_lag1_autocorrelation_m);
 }
 
 /****************************/
 
-static void get_vector_stats3(int argc, VALUE *argv, VALUE obj, 
-			      double **w, size_t *stridew, size_t *sizew,
-			      double **x, size_t *stridex, size_t *sizex)
+static void get_vector_stats3(int argc, VALUE *argv, VALUE obj,
+                              double **w, size_t *stridew, size_t *sizew,
+                              double **x, size_t *stridex, size_t *sizex)
 {
   switch (TYPE(obj)) {
   case T_MODULE:  case T_CLASS:  case T_OBJECT:
@@ -228,8 +223,8 @@ static void get_vector_stats3(int argc, VALUE *argv, VALUE obj,
 }
 
 static VALUE rb_gsl_stats_wXXX(int argc, VALUE *argv, VALUE obj,
-			       double (*f)(const double*, size_t, const double*, 
-					   size_t, size_t))
+                               double (*f)(const double*, size_t, const double*,
+                                           size_t, size_t))
 {
   double *w, *x;
   double mean;
@@ -240,8 +235,8 @@ static VALUE rb_gsl_stats_wXXX(int argc, VALUE *argv, VALUE obj,
 }
 
 static VALUE rb_gsl_stats_wXXX_m(int argc, VALUE *argv, VALUE obj,
-			       double (*f)(const double*, size_t, const double*, 
-					   size_t, size_t, double))
+                                 double (*f)(const double*, size_t, const double*,
+                                             size_t, size_t, double))
 {
   double *w, *x;
   double mean;
@@ -314,7 +309,7 @@ static VALUE rb_gsl_stats_wskew_m_sd(VALUE obj, VALUE ww, VALUE wm, VALUE wsd)
   x = get_vector_ptr(obj, &stridex, &sizex);
   w = get_vector_ptr(ww, &stridew, &sizew);
   skew_m = gsl_stats_wskew_m_sd(w, stridew, x, stridex, sizex, NUM2DBL(wm),
-				NUM2DBL(wsd));
+                                NUM2DBL(wsd));
   return rb_float_new(skew_m);
 }
 
@@ -326,7 +321,7 @@ static VALUE rb_gsl_stats_wkurtosis_m_sd(VALUE obj, VALUE ww, VALUE wm, VALUE ws
   x = get_vector_ptr(obj, &stridex, &sizex);
   w = get_vector_ptr(ww, &stridew, &sizew);
   kurtosis_m = gsl_stats_wkurtosis_m_sd(w, stridew, x, stridex, sizex, NUM2DBL(wm),
-					NUM2DBL(wsd));
+                                        NUM2DBL(wsd));
   return rb_float_new(kurtosis_m);
 }
 
@@ -409,7 +404,7 @@ static VALUE rb_gsl_stats_median(int argc, VALUE *argv, VALUE obj)
 static VALUE rb_gsl_stats_quantile_from_sorted_data(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_stats_XXX1(argc, argv, obj,
-			   gsl_stats_quantile_from_sorted_data);
+                           gsl_stats_quantile_from_sorted_data);
   /*  size_t stride, size;
   double quantile, *data = NULL;
   data = get_vector_ptr(obj, &stride, &size);
@@ -437,21 +432,20 @@ static VALUE rb_gsl_stats_covariance2(VALUE obj, VALUE vv1, VALUE vv2)
   data1 = get_vector_ptr(vv1, &stride1, &size);
   data2 = get_vector_ptr(vv2, &stride2, &size);
   return rb_float_new(gsl_stats_covariance(data1, stride1, data2,
-					   stride2, size));
+                                           stride2, size));
 }
 
 static VALUE rb_gsl_stats_covariance_m2(VALUE obj, VALUE vv1, VALUE vv2,
-					VALUE m1, VALUE m2)
+                                        VALUE m1, VALUE m2)
 {
   double *data1, *data2;
   size_t stride1, stride2, size;
   data1 = get_vector_ptr(vv1, &stride1, &size);
   data2 = get_vector_ptr(vv2, &stride2, &size);
   return rb_float_new(gsl_stats_covariance_m(data1, stride1, data2,
-					   stride2, size, NUM2DBL(m1), NUM2DBL(m2)));
+                                             stride2, size, NUM2DBL(m1), NUM2DBL(m2)));
 }
 
-#ifdef GSL_1_10_LATER
 static VALUE rb_gsl_stats_correlation(VALUE obj, VALUE vv1, VALUE vv2)
 {
   double *data1, *data2;
@@ -459,7 +453,7 @@ static VALUE rb_gsl_stats_correlation(VALUE obj, VALUE vv1, VALUE vv2)
   data1 = get_vector_ptr(vv1, &stride1, &size);
   data2 = get_vector_ptr(vv2, &stride2, &size);
   return rb_float_new(gsl_stats_correlation(data1, stride1, data2,
-					   stride2, size));
+                                            stride2, size));
 }
 static VALUE rb_gsl_stats_pvariance(VALUE obj, VALUE vv1, VALUE vv2)
 {
@@ -468,7 +462,7 @@ static VALUE rb_gsl_stats_pvariance(VALUE obj, VALUE vv1, VALUE vv2)
   data1 = get_vector_ptr(vv1, &stride1, &size1);
   data2 = get_vector_ptr(vv2, &stride2, &size2);
   return rb_float_new(gsl_stats_pvariance(data1, stride1, size1, data2,
-					   stride2, size2));
+                                          stride2, size2));
 }
 static VALUE rb_gsl_stats_ttest(VALUE obj, VALUE vv1, VALUE vv2)
 {
@@ -477,9 +471,8 @@ static VALUE rb_gsl_stats_ttest(VALUE obj, VALUE vv1, VALUE vv2)
   data1 = get_vector_ptr(vv1, &stride1, &size1);
   data2 = get_vector_ptr(vv2, &stride2, &size2);
   return rb_float_new(gsl_stats_ttest(data1, stride1, size1, data2,
-					   stride2, size2));
+                                      stride2, size2));
 }
-#endif
 
 static VALUE rb_gsl_stats_wmean2(VALUE obj, VALUE ww, VALUE dd)
 {
@@ -535,8 +528,8 @@ static VALUE rb_gsl_stats_wsd_m2(VALUE obj, VALUE ww, VALUE dd, VALUE mm)
   return rb_float_new(wsd);
 }
 
-static VALUE rb_gsl_stats_wvariance_with_fixed_mean2(VALUE obj, VALUE ww, VALUE dd, 
-						     VALUE mm)
+static VALUE rb_gsl_stats_wvariance_with_fixed_mean2(VALUE obj, VALUE ww, VALUE dd,
+                                                     VALUE mm)
 {
   double wvariance, m;
   double *dataw = NULL, *data = NULL;
@@ -544,14 +537,14 @@ static VALUE rb_gsl_stats_wvariance_with_fixed_mean2(VALUE obj, VALUE ww, VALUE
   dataw = get_vector_ptr(ww, &stridew, &size);
   data = get_vector_ptr(dd, &strided, &size);
   m = NUM2DBL(mm);
-  wvariance = gsl_stats_wvariance_with_fixed_mean(dataw, stridew, 
-						  data, strided, size, m);
+  wvariance = gsl_stats_wvariance_with_fixed_mean(dataw, stridew,
+                                                  data, strided, size, m);
 
   return rb_float_new(wvariance);
 }
 
-static VALUE rb_gsl_stats_wsd_with_fixed_mean2(VALUE obj, VALUE ww, VALUE dd, 
-						     VALUE mm)
+static VALUE rb_gsl_stats_wsd_with_fixed_mean2(VALUE obj, VALUE ww, VALUE dd,
+                                               VALUE mm)
 {
   double wsd, m;
   double *dataw = NULL, *data = NULL;
@@ -651,10 +644,8 @@ void Init_gsl_stats(VALUE module)
 
   rb_define_singleton_method(mgsl_stats, "sd", rb_gsl_stats_sd_m, -1);
   rb_define_singleton_method(mgsl_stats, "sd_m", rb_gsl_stats_sd_m, -1);
-#ifdef GSL_1_11_LATER
   rb_define_singleton_method(mgsl_stats, "tss", rb_gsl_stats_tss_m, -1);
   rb_define_singleton_method(mgsl_stats, "tss_m", rb_gsl_stats_tss_m, -1);
-#endif
   rb_define_singleton_method(mgsl_stats, "sdev", rb_gsl_stats_sd_m, -1);
   rb_define_singleton_method(mgsl_stats, "sigma", rb_gsl_stats_sd_m, -1);
   rb_define_method(cgsl_vector, "stats_sd_m", rb_gsl_stats_sd_m, -1);
@@ -663,26 +654,24 @@ void Init_gsl_stats(VALUE module)
   rb_define_alias(cgsl_vector, "sd", "stats_sd_m");
   rb_define_alias(cgsl_vector, "sigma", "stats_sd_m");
   rb_define_alias(cgsl_vector, "sdev", "stats_sd_m");
-#ifdef GSL_1_11_LATER
   rb_define_method(cgsl_vector, "stats_tss_m", rb_gsl_stats_tss_m, -1);
   rb_define_alias(cgsl_vector, "stats_tss", "stats_tss_m");
   rb_define_alias(cgsl_vector, "tss_m", "stats_tss_m");
   rb_define_alias(cgsl_vector, "tss", "stats_tss_m");
-#endif
-
-  rb_define_singleton_method(mgsl_stats, "variance_with_fixed_mean", 
-			     rb_gsl_stats_variance_with_fixed_mean, -1);
-  rb_define_method(cgsl_vector, "stats_variance_with_fixed_mean", 
-		   rb_gsl_stats_variance_with_fixed_mean, -1);
-  rb_define_alias(cgsl_vector, "variance_with_fixed_mean", 
-		  "stats_variance_with_fixed_mean");
-
-  rb_define_singleton_method(mgsl_stats, "sd_with_fixed_mean", 
-			     rb_gsl_stats_sd_with_fixed_mean, -1);
-  rb_define_method(cgsl_vector, "stats_sd_with_fixed_mean", 
-		   rb_gsl_stats_sd_with_fixed_mean, -1);
-  rb_define_alias(cgsl_vector, "sd_with_fixed_mean", 
-		  "stats_sd_with_fixed_mean");
+
+  rb_define_singleton_method(mgsl_stats, "variance_with_fixed_mean",
+                             rb_gsl_stats_variance_with_fixed_mean, -1);
+  rb_define_method(cgsl_vector, "stats_variance_with_fixed_mean",
+                   rb_gsl_stats_variance_with_fixed_mean, -1);
+  rb_define_alias(cgsl_vector, "variance_with_fixed_mean",
+                  "stats_variance_with_fixed_mean");
+
+  rb_define_singleton_method(mgsl_stats, "sd_with_fixed_mean",
+                             rb_gsl_stats_sd_with_fixed_mean, -1);
+  rb_define_method(cgsl_vector, "stats_sd_with_fixed_mean",
+                   rb_gsl_stats_sd_with_fixed_mean, -1);
+  rb_define_alias(cgsl_vector, "sd_with_fixed_mean",
+                  "stats_sd_with_fixed_mean");
 
   rb_define_singleton_method(mgsl_stats, "absdev", rb_gsl_stats_absdev_m, -1);
   rb_define_singleton_method(mgsl_stats, "absdev_m", rb_gsl_stats_absdev_m, -1);
@@ -710,24 +699,22 @@ void Init_gsl_stats(VALUE module)
 
   rb_define_singleton_method(mgsl_stats, "covariance", rb_gsl_stats_covariance2, 2);
   rb_define_singleton_method(mgsl_stats, "covariance_m", rb_gsl_stats_covariance_m2, 4);
-  
-#ifdef GSL_1_10_LATER
-  rb_define_singleton_method(mgsl_stats, "correlation", rb_gsl_stats_correlation, 2);  
-  rb_define_singleton_method(mgsl_stats, "pvariance", rb_gsl_stats_pvariance, 2);    
-  rb_define_singleton_method(mgsl_stats, "ttest", rb_gsl_stats_ttest, 2);      
-#endif
+
+  rb_define_singleton_method(mgsl_stats, "correlation", rb_gsl_stats_correlation, 2);
+  rb_define_singleton_method(mgsl_stats, "pvariance", rb_gsl_stats_pvariance, 2);
+  rb_define_singleton_method(mgsl_stats, "ttest", rb_gsl_stats_ttest, 2);
 
   /*****/
-  
+
   rb_define_singleton_method(mgsl_stats, "wmean", rb_gsl_stats_wmean2, -1);
   rb_define_singleton_method(mgsl_stats, "wvariance", rb_gsl_stats_wvariance2, -1);
   rb_define_singleton_method(mgsl_stats, "wvariance_m", rb_gsl_stats_wvariance_m2, -1);
   rb_define_singleton_method(mgsl_stats, "wsd", rb_gsl_stats_wsd2, -1);
   rb_define_singleton_method(mgsl_stats, "wsd_m", rb_gsl_stats_wsd_m2, -1);
-  rb_define_singleton_method(mgsl_stats, "wvariance_with_fixed_mean", 
-			     rb_gsl_stats_wvariance_with_fixed_mean2, -1);
-  rb_define_singleton_method(mgsl_stats, "wsd_with_fixed_mean", 
-			     rb_gsl_stats_wsd_with_fixed_mean2, -1);
+  rb_define_singleton_method(mgsl_stats, "wvariance_with_fixed_mean",
+                             rb_gsl_stats_wvariance_with_fixed_mean2, -1);
+  rb_define_singleton_method(mgsl_stats, "wsd_with_fixed_mean",
+                             rb_gsl_stats_wsd_with_fixed_mean2, -1);
   rb_define_singleton_method(mgsl_stats, "wabsdev", rb_gsl_stats_wabsdev2, -1);
   rb_define_singleton_method(mgsl_stats, "wabsdev_m", rb_gsl_stats_wabsdev_m2, -1);
   rb_define_singleton_method(mgsl_stats, "wskew", rb_gsl_stats_wskew2, -1);
@@ -747,12 +734,12 @@ void Init_gsl_stats(VALUE module)
   rb_define_alias(cgsl_vector, "wsd", "stats_wsd");
   rb_define_method(cgsl_vector, "stats_wsd_m", rb_gsl_stats_wsd_m, -1);
   rb_define_alias(cgsl_vector, "wsd_m", "stats_wsd_m");
-  rb_define_method(cgsl_vector, "stats_wvariance_with_fixed_mean", 
-		   rb_gsl_stats_wvariance_with_fixed_mean, -1);
-  rb_define_alias(cgsl_vector, "wvariance_with_fixed_mean", 
-		  "stats_wvariance_with_fixed_mean");
-  rb_define_method(cgsl_vector, "stats_wsd_with_fixed_mean", 
-		   rb_gsl_stats_wsd_with_fixed_mean, -1);
+  rb_define_method(cgsl_vector, "stats_wvariance_with_fixed_mean",
+                   rb_gsl_stats_wvariance_with_fixed_mean, -1);
+  rb_define_alias(cgsl_vector, "wvariance_with_fixed_mean",
+                  "stats_wvariance_with_fixed_mean");
+  rb_define_method(cgsl_vector, "stats_wsd_with_fixed_mean",
+                   rb_gsl_stats_wsd_with_fixed_mean, -1);
   rb_define_alias(cgsl_vector, "wsd_with_fixed_mean", "stats_wsd_with_fixed_mean");
   rb_define_method(cgsl_vector, "stats_wabsdev", rb_gsl_stats_wabsdev, -1);
   rb_define_alias(cgsl_vector, "wabsdev", "stats_wabsdev");
@@ -764,8 +751,8 @@ void Init_gsl_stats(VALUE module)
   rb_define_alias(cgsl_vector, "wskew_m_sd", "stats_wskew_m_sd");
   rb_define_method(cgsl_vector, "stats_wkurtosis", rb_gsl_stats_wkurtosis, -1);
   rb_define_alias(cgsl_vector, "wkurtosis", "stats_wkurtosis");
-  rb_define_method(cgsl_vector, "stats_wkurtosis_m_sd", 
-		   rb_gsl_stats_wkurtosis_m_sd, 2);
+  rb_define_method(cgsl_vector, "stats_wkurtosis_m_sd",
+                   rb_gsl_stats_wkurtosis_m_sd, 2);
   rb_define_alias(cgsl_vector, "wkurtosis_m_sd", "stats_wkurtosis_m_sd");
 
   /*****/
@@ -774,8 +761,8 @@ void Init_gsl_stats(VALUE module)
   rb_define_singleton_method(mgsl_stats, "minmax", rb_gsl_stats_minmax, -1);
   rb_define_singleton_method(mgsl_stats, "max_index", rb_gsl_stats_max_index, -1);
   rb_define_singleton_method(mgsl_stats, "min_index", rb_gsl_stats_min_index, -1);
-  rb_define_singleton_method(mgsl_stats, "minmax_index", 
-			     rb_gsl_stats_minmax_index, -1);
+  rb_define_singleton_method(mgsl_stats, "minmax_index",
+                             rb_gsl_stats_minmax_index, -1);
 
   rb_define_method(cgsl_vector, "stats_max", rb_gsl_stats_max, -1);
   rb_define_method(cgsl_vector, "stats_min", rb_gsl_stats_min, -1);
@@ -784,17 +771,17 @@ void Init_gsl_stats(VALUE module)
   rb_define_method(cgsl_vector, "stats_min_index", rb_gsl_stats_min_index, -1);
   rb_define_method(cgsl_vector, "stats_minmax_index", rb_gsl_stats_minmax_index, -1);
 
-  rb_define_singleton_method(mgsl_stats, "median_from_sorted_data", 
-			     rb_gsl_stats_median_from_sorted_data, -1);
-  rb_define_method(cgsl_vector, "stats_median_from_sorted_data", 
-		   rb_gsl_stats_median_from_sorted_data, -1);
-  rb_define_alias(cgsl_vector, "median_from_sorted_data", 
-		  "stats_median_from_sorted_data");
+  rb_define_singleton_method(mgsl_stats, "median_from_sorted_data",
+                             rb_gsl_stats_median_from_sorted_data, -1);
+  rb_define_method(cgsl_vector, "stats_median_from_sorted_data",
+                   rb_gsl_stats_median_from_sorted_data, -1);
+  rb_define_alias(cgsl_vector, "median_from_sorted_data",
+                  "stats_median_from_sorted_data");
   rb_define_method(cgsl_vector, "median", rb_gsl_stats_median, -1);
 
-  rb_define_method(cgsl_vector, "stats_quantile_from_sorted_data", 
-		   rb_gsl_stats_quantile_from_sorted_data, -1);
-  rb_define_alias(cgsl_vector, "quantile_from_sorted_data", 
-		  "stats_quantile_from_sorted_data");
+  rb_define_method(cgsl_vector, "stats_quantile_from_sorted_data",
+                   rb_gsl_stats_quantile_from_sorted_data, -1);
+  rb_define_alias(cgsl_vector, "quantile_from_sorted_data",
+                  "stats_quantile_from_sorted_data");
 
 }