gsl 1.15.3 → 1.16.0.6

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

@@ -8,9 +8,9 @@
   This library is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY.
 */
-#include "rb_gsl_config.h"
-#include "rb_gsl_rng.h"
-#include "rb_gsl_array.h"
+
+#include "include/rb_gsl_rng.h"
+#include "include/rb_gsl_array.h"
 #include <gsl/gsl_qrng.h>
 #ifdef HAVE_QRNGEXTRA_QRNGEXTRA_H
 #include <qrngextra/qrngextra.h>
@@ -38,34 +38,29 @@ static const gsl_qrng_type* get_gsl_qrng_type(VALUE t)
     strcpy(name, STR2CSTR(t));
     if (strstr(name, "niederreiter_2")) return T = gsl_qrng_niederreiter_2;
 #ifdef HAVE_QRNGEXTRA_QRNGEXTRA_H
-	else if (strstr(name, "hdsobol")) return T = qrngextra_hdsobol;
+    else if (strstr(name, "hdsobol")) return T = qrngextra_hdsobol;
 #endif
     else if (strstr(name, "sobol")) return T = gsl_qrng_sobol;
-#ifdef GSL_1_11_LATER
     else if (strstr(name, "reversehalton")) return T = gsl_qrng_reversehalton;
     else if (strstr(name, "halton")) return T = gsl_qrng_halton;
-
-#endif
     else rb_raise(rb_eArgError, "unknown type");
     break;
   case T_FIXNUM:
     switch (FIX2INT(t)) {
     case GSL_QRNG_NIEDERREITER_2: T = gsl_qrng_niederreiter_2; break;
     case GSL_QRNG_SOBOL: T = gsl_qrng_sobol; break;
-#ifdef GSL_1_11_LATER
     case GSL_QRNG_HALTON: T = gsl_qrng_halton; break;
     case GSL_QRNG_REVERSEHALTON: T = gsl_qrng_reversehalton; break;
-#endif
 #ifdef HAVE_QRNGEXTRA_QRNGEXTRA_H
-	case GSL_QRNG_HDSOBOL: T = qrngextra_hdsobol; break;
+    case GSL_QRNG_HDSOBOL: T = qrngextra_hdsobol; break;
 #endif
-    default: 
+    default:
       rb_raise(rb_eArgError, "unknown type");
     }
     break;
-  default: 
+  default:
     rb_raise(rb_eTypeError, "wrong argument type %s (String or Fixnum expected)",
-	     rb_class2name(CLASS_OF(t)));
+             rb_class2name(CLASS_OF(t)));
   }
   return T;
 }
@@ -81,7 +76,6 @@ static VALUE rb_gsl_qrng_new(VALUE klass, VALUE t, VALUE dd)
   return Data_Wrap_Struct(klass, 0, gsl_qrng_free, q);
 }
 
-#ifdef GSL_1_2_LATER
 static VALUE rb_gsl_qrng_init(VALUE obj)
 {
   gsl_qrng *q = NULL;
@@ -89,7 +83,6 @@ static VALUE rb_gsl_qrng_init(VALUE obj)
   gsl_qrng_init(q);
   return obj;
 }
-#endif
 
 static VALUE rb_gsl_qrng_name(VALUE obj)
 {
@@ -148,9 +141,7 @@ void Init_gsl_qrng(VALUE module)
 
   rb_define_singleton_method(cgsl_qrng, "new", rb_gsl_qrng_new, 2);
   rb_define_singleton_method(cgsl_qrng, "alloc", rb_gsl_qrng_new, 2);
-#ifdef GSL_1_2_LATER
   rb_define_method(cgsl_qrng, "init", rb_gsl_qrng_init, 0);
-#endif
   rb_define_method(cgsl_qrng, "name", rb_gsl_qrng_name, 0);
   rb_define_method(cgsl_qrng, "size", rb_gsl_qrng_size, 0);
   rb_define_method(cgsl_qrng, "clone", rb_gsl_qrng_clone, 0);
@@ -161,11 +152,9 @@ void Init_gsl_qrng(VALUE module)
 
   rb_define_const(cgsl_qrng, "NIEDERREITER_2", INT2FIX(GSL_QRNG_NIEDERREITER_2));
   rb_define_const(cgsl_qrng, "SOBOL", INT2FIX(GSL_QRNG_SOBOL));
-#ifdef GSL_1_11_LATER
   rb_define_const(cgsl_qrng, "HALTON", INT2FIX(GSL_QRNG_HALTON));
   rb_define_const(cgsl_qrng, "REVERSEHALTON", INT2FIX(GSL_QRNG_REVERSEHALTON));
-#endif
 #ifdef HAVE_QRNGEXTRA_QRNGEXTRA_H
-    rb_define_const(cgsl_qrng, "HDSOBOL", INT2FIX(GSL_QRNG_HDSOBOL));
+  rb_define_const(cgsl_qrng, "HDSOBOL", INT2FIX(GSL_QRNG_HDSOBOL));
 #endif
 }

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

@@ -8,21 +8,21 @@
   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_common.h"
-#include "rb_gsl_rng.h"
+
+#include "include/rb_gsl_array.h"
+#include "include/rb_gsl_common.h"
+#include "include/rb_gsl_rng.h"
 #include <gsl/gsl_randist.h>
 
 VALUE rb_gsl_eval_pdf_cdf(VALUE xx, double (*f)(double));
 VALUE rb_gsl_eval_pdf_cdf2(VALUE xx, VALUE aa, double (*f)(double, double));
-VALUE rb_gsl_eval_pdf_cdf3(VALUE xx, VALUE aa, VALUE bb, 
-			   double (*f)(double, double, double));
-VALUE rb_gsl_eval_pdf_cdf2_uint(VALUE xx, VALUE aa, 
-				double (*f)(unsigned int, double));
+VALUE rb_gsl_eval_pdf_cdf3(VALUE xx, VALUE aa, VALUE bb,
+                           double (*f)(double, double, double));
+VALUE rb_gsl_eval_pdf_cdf2_uint(VALUE xx, VALUE aa,
+                                double (*f)(unsigned int, double));
 
 static VALUE rb_gsl_ran_eval0(int argc, VALUE *argv, VALUE obj,
-			      double (*f)(const gsl_rng*))
+                              double (*f)(const gsl_rng*))
 {
   gsl_rng *r;
   switch (TYPE(obj)) {
@@ -30,7 +30,7 @@ static VALUE rb_gsl_ran_eval0(int argc, VALUE *argv, VALUE obj,
     switch (argc) {
     case 1:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       break;
     default:
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
@@ -45,14 +45,14 @@ static VALUE rb_gsl_ran_eval0(int argc, VALUE *argv, VALUE obj,
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc);
       break;
     }
-    Data_Get_Struct(obj, gsl_rng, r);  
+    Data_Get_Struct(obj, gsl_rng, r);
     break;
   }
   return rb_float_new((*f)(r));
 }
 
 static VALUE rb_gsl_ran_eval1(int argc, VALUE *argv, VALUE obj,
-			      double (*f)(const gsl_rng*, double))
+                              double (*f)(const gsl_rng*, double))
 {
   gsl_rng *r;
   gsl_vector *v;
@@ -65,15 +65,15 @@ static VALUE rb_gsl_ran_eval1(int argc, VALUE *argv, VALUE obj,
       n = NUM2INT(argv[2]);
       a = NUM2DBL(argv[1]);
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);    
+      Data_Get_Struct(argv[0], gsl_rng, r);
       v = gsl_vector_alloc(n);
-      for (i = 0; i < n; i++) 
-	gsl_vector_set(v, i, (*f)(r, a));
+      for (i = 0; i < n; i++)
+        gsl_vector_set(v, i, (*f)(r, a));
       return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v);
       break;
     case 2:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       a = NUM2DBL(argv[1]);
       break;
     default:
@@ -86,10 +86,10 @@ static VALUE rb_gsl_ran_eval1(int argc, VALUE *argv, VALUE obj,
     case 2:
       n = NUM2INT(argv[1]);
       a = NUM2DBL(argv[0]);
-      Data_Get_Struct(obj, gsl_rng, r);    
+      Data_Get_Struct(obj, gsl_rng, r);
       v = gsl_vector_alloc(n);
-      for (i = 0; i < n; i++) 
-	gsl_vector_set(v, i, (*f)(r, a));
+      for (i = 0; i < n; i++)
+        gsl_vector_set(v, i, (*f)(r, a));
       return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v);
       break;
     case 1:
@@ -99,14 +99,14 @@ static VALUE rb_gsl_ran_eval1(int argc, VALUE *argv, VALUE obj,
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
       break;
     }
-    Data_Get_Struct(obj, gsl_rng, r);  
+    Data_Get_Struct(obj, gsl_rng, r);
     break;
   }
   return rb_float_new((*f)(r, a));
 }
 
 static VALUE rb_gsl_ran_eval1_uint(int argc, VALUE *argv, VALUE obj,
-			      unsigned int (*f)(const gsl_rng*, double))
+                                   unsigned int (*f)(const gsl_rng*, double))
 {
   gsl_rng *r;
   gsl_vector_int *v;
@@ -119,15 +119,15 @@ static VALUE rb_gsl_ran_eval1_uint(int argc, VALUE *argv, VALUE obj,
       n = NUM2INT(argv[2]);
       a = NUM2DBL(argv[1]);
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);    
+      Data_Get_Struct(argv[0], gsl_rng, r);
       v = gsl_vector_int_alloc(n);
-      for (i = 0; i < n; i++) 
-	gsl_vector_int_set(v, i, (int) (*f)(r, a));
+      for (i = 0; i < n; i++)
+        gsl_vector_int_set(v, i, (int) (*f)(r, a));
       return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, v);
       break;
     case 2:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       a = NUM2DBL(argv[1]);
       break;
     default:
@@ -140,10 +140,10 @@ static VALUE rb_gsl_ran_eval1_uint(int argc, VALUE *argv, VALUE obj,
     case 2:
       n = NUM2INT(argv[1]);
       a = NUM2DBL(argv[0]);
-      Data_Get_Struct(obj, gsl_rng, r);    
+      Data_Get_Struct(obj, gsl_rng, r);
       v = gsl_vector_int_alloc(n);
-      for (i = 0; i < n; i++) 
-	gsl_vector_int_set(v, i, (*f)(r, a));
+      for (i = 0; i < n; i++)
+        gsl_vector_int_set(v, i, (*f)(r, a));
       return Data_Wrap_Struct(cgsl_vector_int, 0, gsl_vector_int_free, v);
       break;
     case 1:
@@ -153,14 +153,14 @@ static VALUE rb_gsl_ran_eval1_uint(int argc, VALUE *argv, VALUE obj,
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
       break;
     }
-    Data_Get_Struct(obj, gsl_rng, r);  
+    Data_Get_Struct(obj, gsl_rng, r);
     break;
   }
   return INT2FIX((*f)(r, a));
 }
 
 static VALUE rb_gsl_ran_eval2(int argc, VALUE *argv, VALUE obj,
-			      double (*f)(const gsl_rng*, double, double))
+                              double (*f)(const gsl_rng*, double, double))
 {
   gsl_rng *r;
   gsl_vector *v;
@@ -171,7 +171,7 @@ static VALUE rb_gsl_ran_eval2(int argc, VALUE *argv, VALUE obj,
     switch (argc) {
     case 4:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       a = NUM2DBL(argv[1]); b = NUM2DBL(argv[2]);
       n = NUM2INT(argv[3]);
       v = gsl_vector_alloc(n);
@@ -180,7 +180,7 @@ static VALUE rb_gsl_ran_eval2(int argc, VALUE *argv, VALUE obj,
       break;
     case 3:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       a = NUM2DBL(argv[1]); b = NUM2DBL(argv[2]);
       break;
     default:
@@ -191,7 +191,7 @@ static VALUE rb_gsl_ran_eval2(int argc, VALUE *argv, VALUE obj,
   default:
     switch (argc) {
     case 3:
-      Data_Get_Struct(obj, gsl_rng, r);  
+      Data_Get_Struct(obj, gsl_rng, r);
       a = NUM2DBL(argv[0]); b = NUM2DBL(argv[1]);
       n = NUM2INT(argv[2]);
       v = gsl_vector_alloc(n);
@@ -205,14 +205,14 @@ static VALUE rb_gsl_ran_eval2(int argc, VALUE *argv, VALUE obj,
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc);
       break;
     }
-    Data_Get_Struct(obj, gsl_rng, r);  
+    Data_Get_Struct(obj, gsl_rng, r);
     break;
   }
   return rb_float_new((*f)(r, a, b));
 }
 
 static VALUE rb_gsl_ran_eval3(int argc, VALUE *argv, VALUE obj,
-			      double (*f)(const gsl_rng*, double, double, double))
+                              double (*f)(const gsl_rng*, double, double, double))
 {
   gsl_rng *r;
   gsl_vector *v;
@@ -223,7 +223,7 @@ static VALUE rb_gsl_ran_eval3(int argc, VALUE *argv, VALUE obj,
     switch (argc) {
     case 5:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       a = NUM2DBL(argv[1]); b = NUM2DBL(argv[2]); c = NUM2DBL(argv[3]);
       n = NUM2INT(argv[4]);
       v = gsl_vector_alloc(n);
@@ -232,7 +232,7 @@ static VALUE rb_gsl_ran_eval3(int argc, VALUE *argv, VALUE obj,
       break;
     case 4:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       a = NUM2DBL(argv[1]); b = NUM2DBL(argv[2]); c = NUM2DBL(argv[3]);
       break;
     default:
@@ -243,7 +243,7 @@ static VALUE rb_gsl_ran_eval3(int argc, VALUE *argv, VALUE obj,
   default:
     switch (argc) {
     case 4:
-      Data_Get_Struct(obj, gsl_rng, r);  
+      Data_Get_Struct(obj, gsl_rng, r);
       a = NUM2DBL(argv[0]); b = NUM2DBL(argv[1]); c = NUM2DBL(argv[2]);
       n = NUM2INT(argv[3]);
       v = gsl_vector_alloc(n);
@@ -257,7 +257,7 @@ static VALUE rb_gsl_ran_eval3(int argc, VALUE *argv, VALUE obj,
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc);
       break;
     }
-    Data_Get_Struct(obj, gsl_rng, r);  
+    Data_Get_Struct(obj, gsl_rng, r);
     break;
   }
   return rb_float_new((*f)(r, a, b, c));
@@ -265,7 +265,7 @@ static VALUE rb_gsl_ran_eval3(int argc, VALUE *argv, VALUE obj,
 
 static VALUE rb_gsl_ran_gaussian(int argc, VALUE *argv, VALUE obj)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   gsl_vector *v;
   size_t n, i;
   double sigma = 1.0;
@@ -276,18 +276,18 @@ static VALUE rb_gsl_ran_gaussian(int argc, VALUE *argv, VALUE obj)
       n = NUM2INT(argv[2]);
       sigma = NUM2DBL(argv[1]);
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);    
+      Data_Get_Struct(argv[0], gsl_rng, r);
       v = gsl_vector_alloc(n);
-      for (i = 0; i < n; i++) 
-	gsl_vector_set(v, i, gsl_ran_gaussian(r, sigma));
+      for (i = 0; i < n; i++)
+        gsl_vector_set(v, i, gsl_ran_gaussian(r, sigma));
       return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v);
       break;
     case 2:
       sigma = NUM2DBL(argv[1]);
-      /* no break */
+    /* no break */
     case 1:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);    
+      Data_Get_Struct(argv[0], gsl_rng, r);
       return rb_float_new(gsl_ran_gaussian(r, sigma));
       break;
     default:
@@ -297,19 +297,19 @@ static VALUE rb_gsl_ran_gaussian(int argc, VALUE *argv, VALUE obj)
     }
     break;
   default:
-    Data_Get_Struct(obj, gsl_rng, r);    
+    Data_Get_Struct(obj, gsl_rng, r);
     switch (argc) {
     case 2:
       n = NUM2INT(argv[1]);
       sigma = NUM2DBL(argv[0]);
       v = gsl_vector_alloc(n);
-      for (i = 0; i < n; i++) 
-	gsl_vector_set(v, i, gsl_ran_gaussian(r, sigma));
+      for (i = 0; i < n; i++)
+        gsl_vector_set(v, i, gsl_ran_gaussian(r, sigma));
       return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v);
       break;
     case 1:
       sigma = NUM2DBL(argv[0]);
-      /* no break */
+    /* no break */
     case 0:
       return rb_float_new(gsl_ran_gaussian(r, sigma));
       break;
@@ -325,17 +325,17 @@ static VALUE rb_gsl_ran_gaussian(int argc, VALUE *argv, VALUE obj)
 
 static VALUE rb_gsl_ran_gaussian_ratio_method(int argc, VALUE *argv, VALUE obj)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   double sigma = 1.0;
   switch (TYPE(obj)) {
   case T_MODULE: case T_CLASS: case T_OBJECT:
     switch (argc) {
     case 2:
       sigma = NUM2DBL(argv[1]);
-      /* no break */
+    /* no break */
     case 1:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);    
+      Data_Get_Struct(argv[0], gsl_rng, r);
       return rb_float_new(gsl_ran_gaussian_ratio_method(r, sigma));
       break;
     default:
@@ -344,11 +344,11 @@ static VALUE rb_gsl_ran_gaussian_ratio_method(int argc, VALUE *argv, VALUE obj)
     }
     break;
   default:
-    Data_Get_Struct(obj, gsl_rng, r);    
+    Data_Get_Struct(obj, gsl_rng, r);
     switch (argc) {
     case 1:
       sigma = NUM2DBL(argv[0]);
-      /* no break */
+    /* no break */
     case 0:
       return rb_float_new(gsl_ran_gaussian_ratio_method(r, sigma));
       break;
@@ -374,7 +374,7 @@ static VALUE rb_gsl_ran_gaussian_pdf(int argc, VALUE *argv, VALUE obj)
 
 static VALUE rb_gsl_ran_gaussian_tail(int argc, VALUE *argv, VALUE obj)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   gsl_vector *v;
   size_t n, i;
   double a, sigma = 1.0;
@@ -386,18 +386,18 @@ static VALUE rb_gsl_ran_gaussian_tail(int argc, VALUE *argv, VALUE obj)
       sigma = NUM2DBL(argv[2]);
       a = NUM2DBL(argv[1]);
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);    
+      Data_Get_Struct(argv[0], gsl_rng, r);
       v = gsl_vector_alloc(n);
-      for (i = 0; i < n; i++) 
-	gsl_vector_set(v, i, gsl_ran_gaussian_tail(r, a, sigma));
+      for (i = 0; i < n; i++)
+        gsl_vector_set(v, i, gsl_ran_gaussian_tail(r, a, sigma));
       return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v);
       break;
     case 3:
       sigma = NUM2DBL(argv[2]);
-      /* no break */
+    /* no break */
     case 2:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);    
+      Data_Get_Struct(argv[0], gsl_rng, r);
       a = NUM2DBL(argv[1]);
       return rb_float_new(gsl_ran_gaussian_tail(r, a, sigma));
       break;
@@ -407,20 +407,20 @@ static VALUE rb_gsl_ran_gaussian_tail(int argc, VALUE *argv, VALUE obj)
     }
     break;
   default:
-    Data_Get_Struct(obj, gsl_rng, r);    
+    Data_Get_Struct(obj, gsl_rng, r);
     switch (argc) {
     case 3:
       n = NUM2INT(argv[2]);
       sigma = NUM2DBL(argv[1]);
       a = NUM2DBL(argv[0]);
       v = gsl_vector_alloc(n);
-      for (i = 0; i < n; i++) 
-	gsl_vector_set(v, i, gsl_ran_gaussian_tail(r, a, sigma));
+      for (i = 0; i < n; i++)
+        gsl_vector_set(v, i, gsl_ran_gaussian_tail(r, a, sigma));
       return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v);
       break;
     case 2:
       sigma = NUM2DBL(argv[1]);
-      /* no break */
+    /* no break */
     case 1:
       a = NUM2DBL(argv[0]);
       return rb_float_new(gsl_ran_gaussian_tail(r, a, sigma));
@@ -450,14 +450,14 @@ static VALUE rb_gsl_ran_gaussian_tail_pdf(int argc, VALUE *argv, VALUE obj)
 
 static VALUE rb_gsl_ran_bivariate_gaussian(int argc, VALUE *argv, VALUE obj)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   double sigmax, sigmay, x, y, rho;
   switch (TYPE(obj)) {
   case T_MODULE: case T_CLASS: case T_OBJECT:
     switch (argc) {
     case 4:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r); 
+      Data_Get_Struct(argv[0], gsl_rng, r);
       sigmax = NUM2DBL(argv[1]); sigmay = NUM2DBL(argv[2]);
       rho = NUM2DBL(argv[3]);
       break;
@@ -469,7 +469,7 @@ static VALUE rb_gsl_ran_bivariate_gaussian(int argc, VALUE *argv, VALUE obj)
   default:
     switch (argc) {
     case 3:
-      Data_Get_Struct(obj, gsl_rng, r);  
+      Data_Get_Struct(obj, gsl_rng, r);
       sigmax = NUM2DBL(argv[0]); sigmay = NUM2DBL(argv[1]);
       rho = NUM2DBL(argv[2]);
       break;
@@ -720,7 +720,7 @@ static VALUE rb_gsl_ran_binomial(int argc, VALUE *argv, VALUE obj)
     switch (argc) {
     case 3:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       p = NUM2DBL(argv[1]);
       n = FIX2UINT(argv[2]);
       break;
@@ -739,16 +739,15 @@ static VALUE rb_gsl_ran_binomial(int argc, VALUE *argv, VALUE obj)
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc);
       break;
     }
-    Data_Get_Struct(obj, gsl_rng, r);  
+    Data_Get_Struct(obj, gsl_rng, r);
     break;
   }
   return UINT2NUM(gsl_ran_binomial(r, p, n));
 }
 
-#ifdef GSL_1_4_LATER
 static VALUE rb_gsl_ran_binomial_tpe(int argc, VALUE *argv, VALUE obj)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   double p;
   unsigned int n;
   switch (TYPE(obj)) {
@@ -756,7 +755,7 @@ static VALUE rb_gsl_ran_binomial_tpe(int argc, VALUE *argv, VALUE obj)
     switch (argc) {
     case 3:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       p = NUM2DBL(argv[1]);
       n = FIX2UINT(argv[2]);
       break;
@@ -775,12 +774,11 @@ static VALUE rb_gsl_ran_binomial_tpe(int argc, VALUE *argv, VALUE obj)
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc);
       break;
     }
-    Data_Get_Struct(obj, gsl_rng, r);  
+    Data_Get_Struct(obj, gsl_rng, r);
     break;
   }
   return UINT2NUM(gsl_ran_binomial_tpe(r, p, n));
 }
-#endif
 
 static VALUE rb_gsl_ran_binomial_pdf(VALUE obj, VALUE x, VALUE p, VALUE n)
 {
@@ -797,7 +795,7 @@ static VALUE rb_gsl_ran_negative_binomial(int argc, VALUE *argv, VALUE obj)
     switch (argc) {
     case 3:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       p = NUM2DBL(argv[1]);
       n = FIX2UINT(argv[2]);
       break;
@@ -816,7 +814,7 @@ static VALUE rb_gsl_ran_negative_binomial(int argc, VALUE *argv, VALUE obj)
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc);
       break;
     }
-    Data_Get_Struct(obj, gsl_rng, r);  
+    Data_Get_Struct(obj, gsl_rng, r);
     break;
   }
   return UINT2NUM(gsl_ran_negative_binomial(r, p, n));
@@ -829,7 +827,7 @@ static VALUE rb_gsl_ran_negative_binomial_pdf(VALUE obj, VALUE x, VALUE p, VALUE
 
 static VALUE rb_gsl_ran_pascal(int argc, VALUE *argv, VALUE obj)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   double p;
   unsigned int n;
   switch (TYPE(obj)) {
@@ -837,7 +835,7 @@ static VALUE rb_gsl_ran_pascal(int argc, VALUE *argv, VALUE obj)
     switch (argc) {
     case 3:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       p = NUM2DBL(argv[1]);
       n = FIX2UINT(argv[2]);
       break;
@@ -856,7 +854,7 @@ static VALUE rb_gsl_ran_pascal(int argc, VALUE *argv, VALUE obj)
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)", argc);
       break;
     }
-    Data_Get_Struct(obj, gsl_rng, r);  
+    Data_Get_Struct(obj, gsl_rng, r);
     break;
   }
   return UINT2NUM(gsl_ran_pascal(r, p, n));
@@ -886,7 +884,7 @@ static VALUE rb_gsl_ran_hypergeometric(int argc, VALUE *argv, VALUE obj)
     switch (argc) {
     case 4:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       n1 = FIX2UINT(argv[1]);
       n2 = FIX2UINT(argv[2]);
       t = FIX2UINT(argv[3]);
@@ -907,7 +905,7 @@ static VALUE rb_gsl_ran_hypergeometric(int argc, VALUE *argv, VALUE obj)
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 3)", argc);
       break;
     }
-    Data_Get_Struct(obj, gsl_rng, r);  
+    Data_Get_Struct(obj, gsl_rng, r);
     break;
   }
   return UINT2NUM(gsl_ran_hypergeometric(r, n1, n2, t));
@@ -930,14 +928,14 @@ static VALUE rb_gsl_ran_logarithmic_pdf(VALUE obj, VALUE x, VALUE mu)
 
 static VALUE rb_gsl_ran_dir_2d(int argc, VALUE *argv, VALUE obj)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   double x, y;
   switch (TYPE(obj)) {
   case T_MODULE: case T_CLASS: case T_OBJECT:
     switch (argc) {
     case 1:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       break;
     default:
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
@@ -947,7 +945,7 @@ static VALUE rb_gsl_ran_dir_2d(int argc, VALUE *argv, VALUE obj)
   default:
     switch (argc) {
     case 0:
-      Data_Get_Struct(obj, gsl_rng, r);  
+      Data_Get_Struct(obj, gsl_rng, r);
       break;
     default:
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc);
@@ -960,14 +958,14 @@ static VALUE rb_gsl_ran_dir_2d(int argc, VALUE *argv, VALUE obj)
 
 static VALUE rb_gsl_ran_dir_2d_trig_method(int argc, VALUE *argv, VALUE obj)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   double x, y;
   switch (TYPE(obj)) {
   case T_MODULE: case T_CLASS: case T_OBJECT:
     switch (argc) {
     case 1:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       break;
     default:
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
@@ -977,7 +975,7 @@ static VALUE rb_gsl_ran_dir_2d_trig_method(int argc, VALUE *argv, VALUE obj)
   default:
     switch (argc) {
     case 0:
-      Data_Get_Struct(obj, gsl_rng, r);  
+      Data_Get_Struct(obj, gsl_rng, r);
       break;
     default:
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc);
@@ -990,14 +988,14 @@ static VALUE rb_gsl_ran_dir_2d_trig_method(int argc, VALUE *argv, VALUE obj)
 
 static VALUE rb_gsl_ran_dir_3d(int argc, VALUE *argv, VALUE obj)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   double x, y, z;
   switch (TYPE(obj)) {
   case T_MODULE: case T_CLASS: case T_OBJECT:
     switch (argc) {
     case 1:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       break;
     default:
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)", argc);
@@ -1007,7 +1005,7 @@ static VALUE rb_gsl_ran_dir_3d(int argc, VALUE *argv, VALUE obj)
   default:
     switch (argc) {
     case 0:
-      Data_Get_Struct(obj, gsl_rng, r);  
+      Data_Get_Struct(obj, gsl_rng, r);
       break;
     default:
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc);
@@ -1020,7 +1018,7 @@ static VALUE rb_gsl_ran_dir_3d(int argc, VALUE *argv, VALUE obj)
 
 static VALUE rb_gsl_ran_dir_nd(int argc, VALUE *argv, VALUE obj)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   size_t n;
   gsl_vector *v;
   switch (TYPE(obj)) {
@@ -1028,7 +1026,7 @@ static VALUE rb_gsl_ran_dir_nd(int argc, VALUE *argv, VALUE obj)
     switch (argc) {
     case 2:
       CHECK_RNG(argv[0]); CHECK_FIXNUM(argv[1]);
-      Data_Get_Struct(argv[0], gsl_rng, r);  
+      Data_Get_Struct(argv[0], gsl_rng, r);
       n = FIX2INT(argv[1]);
       break;
     default:
@@ -1041,7 +1039,7 @@ static VALUE rb_gsl_ran_dir_nd(int argc, VALUE *argv, VALUE obj)
     case 1:
       CHECK_FIXNUM(argv[0]);
       n = FIX2INT(argv[0]);
-      Data_Get_Struct(obj, gsl_rng, r);  
+      Data_Get_Struct(obj, gsl_rng, r);
       break;
     default:
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc);
@@ -1055,7 +1053,7 @@ static VALUE rb_gsl_ran_dir_nd(int argc, VALUE *argv, VALUE obj)
 
 static VALUE rb_gsl_ran_shuffle(int argc, VALUE *argv, VALUE obj)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   gsl_vector *v = NULL;
   gsl_permutation *p = NULL;
   switch (TYPE(obj)) {
@@ -1067,13 +1065,13 @@ static VALUE rb_gsl_ran_shuffle(int argc, VALUE *argv, VALUE obj)
       CHECK_RNG(argv[0]);
       Data_Get_Struct(argv[0], gsl_rng, r);
       if (VECTOR_P(argv[1])) {
-	Data_Get_Struct(argv[1], gsl_vector, v);
-	gsl_ran_shuffle(r, v->data, v->size, sizeof(double));
+        Data_Get_Struct(argv[1], gsl_vector, v);
+        gsl_ran_shuffle(r, v->data, v->size, sizeof(double));
       } else if (PERMUTATION_P(argv[1])) {
-	Data_Get_Struct(argv[1], gsl_permutation, p);
-	gsl_ran_shuffle(r, p->data, p->size, sizeof(size_t));
+        Data_Get_Struct(argv[1], gsl_permutation, p);
+        gsl_ran_shuffle(r, p->data, p->size, sizeof(size_t));
       } else {
-	rb_raise(rb_eTypeError, "wrong argument type %s (Vector or Permutation expected)", rb_class2name(CLASS_OF(argv[1])));
+        rb_raise(rb_eTypeError, "wrong argument type %s (Vector or Permutation expected)", rb_class2name(CLASS_OF(argv[1])));
       }
       break;
     case 3:
@@ -1081,15 +1079,15 @@ static VALUE rb_gsl_ran_shuffle(int argc, VALUE *argv, VALUE obj)
       CHECK_FIXNUM(argv[2]);
       Data_Get_Struct(argv[0], gsl_rng, r);
       if (VECTOR_P(argv[1])) {
-	Data_Get_Struct(argv[1], gsl_vector, v);
-	gsl_ran_shuffle(r, v->data, FIX2INT(argv[2]), sizeof(double));
+        Data_Get_Struct(argv[1], gsl_vector, v);
+        gsl_ran_shuffle(r, v->data, FIX2INT(argv[2]), sizeof(double));
       } else if (PERMUTATION_P(argv[1])) {
-	Data_Get_Struct(argv[1], gsl_permutation, p);
-	gsl_ran_shuffle(r, p->data, FIX2INT(argv[2]), sizeof(size_t));
+        Data_Get_Struct(argv[1], gsl_permutation, p);
+        gsl_ran_shuffle(r, p->data, FIX2INT(argv[2]), sizeof(size_t));
       } else {
-	rb_raise(rb_eTypeError, 
-		 "wrong argument type %s (Vector or Permutation expected)", 
-		 rb_class2name(CLASS_OF(argv[1])));
+        rb_raise(rb_eTypeError,
+                 "wrong argument type %s (Vector or Permutation expected)",
+                 rb_class2name(CLASS_OF(argv[1])));
       }
       break;
     default:
@@ -1098,31 +1096,31 @@ static VALUE rb_gsl_ran_shuffle(int argc, VALUE *argv, VALUE obj)
     }
     break;
   default:
-    Data_Get_Struct(obj, gsl_rng, r);  
+    Data_Get_Struct(obj, gsl_rng, r);
     switch (argc) {
     case 1:
       if (VECTOR_P(argv[0])) {
-	Data_Get_Struct(argv[0], gsl_vector, v);
-	gsl_ran_shuffle(r, v->data, v->size, sizeof(double));
+        Data_Get_Struct(argv[0], gsl_vector, v);
+        gsl_ran_shuffle(r, v->data, v->size, sizeof(double));
       } else if (PERMUTATION_P(argv[0])) {
-	Data_Get_Struct(argv[0], gsl_permutation, p);
-	gsl_ran_shuffle(r, p->data, p->size, sizeof(size_t));
+        Data_Get_Struct(argv[0], gsl_permutation, p);
+        gsl_ran_shuffle(r, p->data, p->size, sizeof(size_t));
       } else {
-	rb_raise(rb_eTypeError, "wrong argument type %s (Vector or Permutation expected)", rb_class2name(CLASS_OF(argv[0])));
+        rb_raise(rb_eTypeError, "wrong argument type %s (Vector or Permutation expected)", rb_class2name(CLASS_OF(argv[0])));
       }
       break;
     case 2:
       CHECK_FIXNUM(argv[1]);
       if (VECTOR_P(argv[0])) {
-	Data_Get_Struct(argv[0], gsl_vector, v);
-	gsl_ran_shuffle(r, v->data, FIX2INT(argv[1]), sizeof(double));
+        Data_Get_Struct(argv[0], gsl_vector, v);
+        gsl_ran_shuffle(r, v->data, FIX2INT(argv[1]), sizeof(double));
       } else if (PERMUTATION_P(argv[0])) {
-	Data_Get_Struct(argv[0], gsl_permutation, p);
-	gsl_ran_shuffle(r, p->data, FIX2INT(argv[1]), sizeof(size_t));
+        Data_Get_Struct(argv[0], gsl_permutation, p);
+        gsl_ran_shuffle(r, p->data, FIX2INT(argv[1]), sizeof(size_t));
       } else {
-	rb_raise(rb_eTypeError, 
-		 "wrong argument type %s (Vector or Permutation expected)", 
-		 rb_class2name(CLASS_OF(argv[0])));
+        rb_raise(rb_eTypeError,
+                 "wrong argument type %s (Vector or Permutation expected)",
+                 rb_class2name(CLASS_OF(argv[0])));
       }
     default:
       rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc);
@@ -1135,31 +1133,31 @@ static VALUE rb_gsl_ran_shuffle(int argc, VALUE *argv, VALUE obj)
 
 static VALUE rb_gsl_ran_choose(int argc, VALUE *argv, VALUE obj)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   gsl_vector *v = NULL, *v2 = NULL;
   size_t k, n;
-  Data_Get_Struct(obj, gsl_rng, r);  
+  Data_Get_Struct(obj, gsl_rng, r);
   switch (argc) {
   case 2:
     CHECK_VECTOR(argv[0]);
     CHECK_FIXNUM(argv[1]);
-    Data_Get_Struct(argv[0], gsl_vector, v);  
+    Data_Get_Struct(argv[0], gsl_vector, v);
     n = v->size;
     k = FIX2INT(argv[1]);
     if (k > n) rb_raise(rb_eArgError, "the argument 1 must be less than or equal to the size of the vector.");
     v2 = gsl_vector_alloc(k);
     gsl_ran_choose(r, v2->data, k, v->data, n, sizeof(double));
-    return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);;
+    return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);
     break;
   case 1:
     CHECK_VECTOR(argv[0]);
-    Data_Get_Struct(argv[0], gsl_vector, v);  
+    Data_Get_Struct(argv[0], gsl_vector, v);
     n = v->size;
     k = v->size;
     if (k > n) rb_raise(rb_eArgError, "the argument 1 must be less than or equal to the size of the vector.");
     v2 = gsl_vector_alloc(k);
     gsl_ran_choose(r, v2->data, k, v->data, n, sizeof(double));
-    return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);;
+    return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);
     break;
   default:
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc);
@@ -1169,7 +1167,7 @@ static VALUE rb_gsl_ran_choose(int argc, VALUE *argv, VALUE obj)
 
 static VALUE rb_gsl_ran_choose_singleton(int argc, VALUE *argv, VALUE obj)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   gsl_vector *v = NULL, *v2 = NULL;
   size_t k, n;
   switch (argc) {
@@ -1177,26 +1175,26 @@ static VALUE rb_gsl_ran_choose_singleton(int argc, VALUE *argv, VALUE obj)
     CHECK_RNG(argv[0]);
     CHECK_VECTOR(argv[1]);
     CHECK_FIXNUM(argv[2]);
-    Data_Get_Struct(argv[0], gsl_rng, r);  
-    Data_Get_Struct(argv[1], gsl_vector, v);  
+    Data_Get_Struct(argv[0], gsl_rng, r);
+    Data_Get_Struct(argv[1], gsl_vector, v);
     n = v->size;
     k = FIX2INT(argv[2]);
     if (k > n) rb_raise(rb_eArgError, "the argument 1 must be less than or equal to the size of the vector.");
     v2 = gsl_vector_alloc(k);
     gsl_ran_choose(r, v2->data, k, v->data, n, sizeof(double));
-    return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);;
+    return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);
     break;
   case 2:
     CHECK_RNG(argv[0]);
     CHECK_VECTOR(argv[1]);
-    Data_Get_Struct(argv[0], gsl_rng, r);  
-    Data_Get_Struct(argv[1], gsl_vector, v);  
+    Data_Get_Struct(argv[0], gsl_rng, r);
+    Data_Get_Struct(argv[1], gsl_vector, v);
     n = v->size;
     k = v->size;
     if (k > n) rb_raise(rb_eArgError, "the argument 1 must be less than or equal to the size of the vector.");
     v2 = gsl_vector_alloc(k);
     gsl_ran_choose(r, v2->data, k, v->data, n, sizeof(double));
-    return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);;
+    return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);
     break;
   default:
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc);
@@ -1206,32 +1204,31 @@ static VALUE rb_gsl_ran_choose_singleton(int argc, VALUE *argv, VALUE obj)
 
 static VALUE rb_gsl_ran_sample(VALUE obj, VALUE vv, VALUE kk)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   gsl_vector *v = NULL, *v2 = NULL;
   size_t k, n;
-  Data_Get_Struct(obj, gsl_rng, r);  
-  Data_Get_Struct(vv, gsl_vector, v);  
+  Data_Get_Struct(obj, gsl_rng, r);
+  Data_Get_Struct(vv, gsl_vector, v);
   n = v->size;
   k = FIX2INT(kk);
   v2 = gsl_vector_alloc(k);
   gsl_ran_sample(r, v2->data, k, v->data, n, sizeof(double));
-  return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);;
+  return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);
 }
 
-#ifdef GSL_1_3_LATER
 static VALUE rb_gsl_ran_dirichlet(int argc, VALUE *argv, VALUE obj)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   gsl_vector *v = NULL, *v2 = NULL;
-  Data_Get_Struct(obj, gsl_rng, r);    
+  Data_Get_Struct(obj, gsl_rng, r);
   if (argc == 1) {
-    Data_Get_Struct(argv[0], gsl_vector, v);    
+    Data_Get_Struct(argv[0], gsl_vector, v);
     v2 = gsl_vector_alloc(v->size);
     gsl_ran_dirichlet(r, v->size, v->data, v2->data);
     return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v2);
   } else if (argc == 2) {
-    Data_Get_Struct(argv[0], gsl_vector, v);    
-    Data_Get_Struct(argv[1], gsl_vector, v2);    
+    Data_Get_Struct(argv[0], gsl_vector, v);
+    Data_Get_Struct(argv[1], gsl_vector, v2);
     gsl_ran_dirichlet(r, v->size, v->data, v2->data);
     return obj;
   } else {
@@ -1242,18 +1239,17 @@ static VALUE rb_gsl_ran_dirichlet(int argc, VALUE *argv, VALUE obj)
 static VALUE rb_gsl_ran_dirichlet_pdf(VALUE obj, VALUE a, VALUE t)
 {
   gsl_vector *alpha = NULL, *theta = NULL;
-  Data_Get_Struct(a, gsl_vector, alpha);    
-  Data_Get_Struct(t, gsl_vector, theta);    
+  Data_Get_Struct(a, gsl_vector, alpha);
+  Data_Get_Struct(t, gsl_vector, theta);
   return rb_float_new(gsl_ran_dirichlet_pdf(alpha->size, alpha->data, theta->data));
 }
 static VALUE rb_gsl_ran_dirichlet_lnpdf(VALUE obj, VALUE a, VALUE t)
 {
   gsl_vector *alpha = NULL, *theta = NULL;
-  Data_Get_Struct(a, gsl_vector, alpha);    
-  Data_Get_Struct(t, gsl_vector, theta);    
+  Data_Get_Struct(a, gsl_vector, alpha);
+  Data_Get_Struct(t, gsl_vector, theta);
   return rb_float_new(gsl_ran_dirichlet_lnpdf(alpha->size, alpha->data, theta->data));
 }
-#endif
 
 static VALUE rb_gsl_ran_discrete_new(VALUE klass, VALUE vv)
 {
@@ -1280,21 +1276,13 @@ static VALUE rb_gsl_ran_discrete_pdf(VALUE obj, VALUE k, VALUE gg)
   return rb_float_new(gsl_ran_discrete_pdf(FIX2INT(k), g));
 }
 
-#ifdef HAVE_NARRAY_H
-#include "narray.h"
-#endif
-
 /*****/
 VALUE rb_gsl_eval_pdf_cdf(VALUE xx, double (*f)(double))
 {
   VALUE x, ary;
   gsl_vector *v = NULL, *vnew = NULL;
   gsl_matrix *m = NULL, *mnew = NULL;
-  size_t i, j, n;  
-#ifdef HAVE_NARRAY_H
-  struct NARRAY *na;
-  double *ptr1, *ptr2;
-#endif
+  size_t i, j, n;
   if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
   switch(TYPE(xx)) {
   case T_FIXNUM:
@@ -1316,6 +1304,8 @@ VALUE rb_gsl_eval_pdf_cdf(VALUE xx, double (*f)(double))
   default:
 #ifdef HAVE_NARRAY_H
     if (NA_IsNArray(xx)) {
+      struct NARRAY *na;
+      double *ptr1, *ptr2;
       xx = na_change_type(xx, NA_DFLOAT);
       GetNArray(xx, na);
       ptr1 = (double *) na->ptr;
@@ -1330,16 +1320,16 @@ VALUE rb_gsl_eval_pdf_cdf(VALUE xx, double (*f)(double))
       Data_Get_Struct(xx, gsl_vector, v);
       vnew = gsl_vector_alloc(v->size);
       for (i = 0; i < v->size; i++) {
-	gsl_vector_set(vnew, i, (*f)(gsl_vector_get(v, i)));
+        gsl_vector_set(vnew, i, (*f)(gsl_vector_get(v, i)));
       }
       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++) {
-	  gsl_matrix_set(mnew, i, j, (*f)(gsl_matrix_get(m, i, j)));
-	}
+        for (j = 0; j < m->size2; j++) {
+          gsl_matrix_set(mnew, i, j, (*f)(gsl_matrix_get(m, i, j)));
+        }
       }
       return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
     } else {
@@ -1351,18 +1341,14 @@ VALUE rb_gsl_eval_pdf_cdf(VALUE xx, double (*f)(double))
   return Qnil;
 }
 
-VALUE rb_gsl_eval_pdf_cdf2(VALUE xx, VALUE aa, 
-			      double (*f)(double, double))
+VALUE rb_gsl_eval_pdf_cdf2(VALUE xx, VALUE aa,
+                           double (*f)(double, double))
 {
   VALUE x, ary;
   double a;
   gsl_vector *v = NULL, *vnew = NULL;
   gsl_matrix *m = NULL, *mnew = NULL;
   size_t i, j, n;
-#ifdef HAVE_NARRAY_H
-  struct NARRAY *na;
-  double *ptr1, *ptr2;
-#endif
   Need_Float(aa);
   a = NUM2DBL(aa);
   if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
@@ -1386,6 +1372,8 @@ VALUE rb_gsl_eval_pdf_cdf2(VALUE xx, VALUE aa,
   default:
 #ifdef HAVE_NARRAY_H
     if (NA_IsNArray(xx)) {
+      struct NARRAY *na;
+      double *ptr1, *ptr2;
       xx = na_change_type(xx, NA_DFLOAT);
       GetNArray(xx, na);
       ptr1 = (double *) na->ptr;
@@ -1400,16 +1388,16 @@ VALUE rb_gsl_eval_pdf_cdf2(VALUE xx, VALUE aa,
       Data_Get_Struct(xx, gsl_vector, v);
       vnew = gsl_vector_alloc(v->size);
       for (i = 0; i < v->size; i++) {
-	gsl_vector_set(vnew, i, (*f)(gsl_vector_get(v, i), a));
+        gsl_vector_set(vnew, i, (*f)(gsl_vector_get(v, i), a));
       }
       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++) {
-	  gsl_matrix_set(mnew, i, j, (*f)(gsl_matrix_get(m, i, j), a));
-	}
+        for (j = 0; j < m->size2; j++) {
+          gsl_matrix_set(mnew, i, j, (*f)(gsl_matrix_get(m, i, j), a));
+        }
       }
       return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
     } else {
@@ -1421,18 +1409,14 @@ VALUE rb_gsl_eval_pdf_cdf2(VALUE xx, VALUE aa,
   return Qnil;
 }
 
-VALUE rb_gsl_eval_pdf_cdf3(VALUE xx, VALUE aa, VALUE bb, 
-			      double (*f)(double, double, double))
+VALUE rb_gsl_eval_pdf_cdf3(VALUE xx, VALUE aa, VALUE bb,
+                           double (*f)(double, double, double))
 {
   VALUE x, ary;
   double a, b;
   gsl_vector *v = NULL, *vnew = NULL;
   gsl_matrix *m = NULL, *mnew = NULL;
   size_t i, j, n;
-#ifdef HAVE_NARRAY_H
-  struct NARRAY *na;
-  double *ptr1, *ptr2;
-#endif
   Need_Float(aa);  Need_Float(bb);
   a = NUM2DBL(aa); b = NUM2DBL(bb);
   if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
@@ -1456,6 +1440,8 @@ VALUE rb_gsl_eval_pdf_cdf3(VALUE xx, VALUE aa, VALUE bb,
   default:
 #ifdef HAVE_NARRAY_H
     if (NA_IsNArray(xx)) {
+      struct NARRAY *na;
+      double *ptr1, *ptr2;
       xx = na_change_type(xx, NA_DFLOAT);
       GetNArray(xx, na);
       ptr1 = (double *) na->ptr;
@@ -1470,16 +1456,16 @@ VALUE rb_gsl_eval_pdf_cdf3(VALUE xx, VALUE aa, VALUE bb,
       Data_Get_Struct(xx, gsl_vector, v);
       vnew = gsl_vector_alloc(v->size);
       for (i = 0; i < v->size; i++) {
-	gsl_vector_set(vnew, i, (*f)(gsl_vector_get(v, i), a, b));
+        gsl_vector_set(vnew, i, (*f)(gsl_vector_get(v, i), a, b));
       }
       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++) {
-	  gsl_matrix_set(mnew, i, j, (*f)(gsl_matrix_get(m, i, j), a, b));
-	}
+        for (j = 0; j < m->size2; j++) {
+          gsl_matrix_set(mnew, i, j, (*f)(gsl_matrix_get(m, i, j), a, b));
+        }
       }
       return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
     } else {
@@ -1491,8 +1477,8 @@ VALUE rb_gsl_eval_pdf_cdf3(VALUE xx, VALUE aa, VALUE bb,
   return Qnil;
 }
 
-VALUE rb_gsl_eval_pdf_cdf2_uint(VALUE xx, VALUE aa, 
-				       double (*f)(unsigned int, double))
+VALUE rb_gsl_eval_pdf_cdf2_uint(VALUE xx, VALUE aa,
+                                double (*f)(unsigned int, double))
 {
   VALUE x, ary;
   double a;
@@ -1501,10 +1487,6 @@ VALUE rb_gsl_eval_pdf_cdf2_uint(VALUE xx, VALUE aa,
   gsl_matrix *m = NULL, *mnew = NULL;
   gsl_matrix_int *mi = NULL;
   size_t i, j, n;
-#ifdef HAVE_NARRAY_H
-  struct NARRAY *na;
-  char *ptr1, *ptr2;
-#endif
   Need_Float(aa);
   a = NUM2DBL(aa);
   if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
@@ -1527,6 +1509,8 @@ VALUE rb_gsl_eval_pdf_cdf2_uint(VALUE xx, VALUE aa,
   default:
 #ifdef HAVE_NARRAY_H
     if (NA_IsNArray(xx)) {
+      struct NARRAY *na;
+      char *ptr1, *ptr2;
       GetNArray(xx, na);
       n = na->total;
       ary = na_make_object(na->type, na->rank, na->shape, CLASS_OF(xx));
@@ -1534,13 +1518,13 @@ VALUE rb_gsl_eval_pdf_cdf2_uint(VALUE xx, VALUE aa,
       ptr2 = (char *)NA_STRUCT(ary)->ptr;
       switch (na->type) {
       case NA_LINT:
-	for (i = 0; i < n; i++) 
-	  ((int*)ptr2)[i] = (*f)((unsigned int) ((int*)ptr1)[i], a);
-	break;
+        for (i = 0; i < n; i++)
+          ((int*)ptr2)[i] = (*f)((unsigned int) ((int*)ptr1)[i], a);
+        break;
       default:
-	for (i = 0; i < n; i++) 
-	  ((double*)ptr2)[i] = (*f)((unsigned int) ((double*)ptr1)[i], a);
-	break;
+        for (i = 0; i < n; i++)
+          ((double*)ptr2)[i] = (*f)((unsigned int) ((double*)ptr1)[i], a);
+        break;
       }
       return ary;
     }
@@ -1549,32 +1533,32 @@ VALUE rb_gsl_eval_pdf_cdf2_uint(VALUE xx, VALUE aa,
       Data_Get_Struct(xx, gsl_vector, v);
       vnew = gsl_vector_alloc(v->size);
       for (i = 0; i < v->size; i++) {
-	gsl_vector_set(vnew, i, (*f)((unsigned int) gsl_vector_get(v, i), a));
+        gsl_vector_set(vnew, i, (*f)((unsigned int) gsl_vector_get(v, i), a));
       }
       return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
     } else if (VECTOR_INT_P(xx)) {
       Data_Get_Struct(xx, gsl_vector_int, vi);
       vnew = gsl_vector_alloc(vi->size);
       for (i = 0; i < vi->size; i++) {
-	gsl_vector_set(vnew, i, (*f)((unsigned int) gsl_vector_int_get(vi, i), a));
+        gsl_vector_set(vnew, i, (*f)((unsigned int) gsl_vector_int_get(vi, i), a));
       }
       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++) {
-	  gsl_matrix_set(mnew, i, j, (*f)((unsigned int) gsl_matrix_get(m, i, j), a));
-	}
+        for (j = 0; j < m->size2; j++) {
+          gsl_matrix_set(mnew, i, j, (*f)((unsigned int) gsl_matrix_get(m, i, j), a));
+        }
       }
       return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
     } else if (MATRIX_INT_P(xx)) {
       Data_Get_Struct(xx, gsl_matrix_int, mi);
       mnew = gsl_matrix_alloc(mi->size1, mi->size2);
       for (i = 0; i < mi->size1; i++) {
-	for (j = 0; j < mi->size2; j++) {
-	  gsl_matrix_set(mnew, i, j, (*f)((unsigned int) gsl_matrix_int_get(mi, i, j), a));
-	}
+        for (j = 0; j < mi->size2; j++) {
+          gsl_matrix_set(mnew, i, j, (*f)((unsigned int) gsl_matrix_int_get(mi, i, j), a));
+        }
       }
       return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
     } else {
@@ -1600,11 +1584,10 @@ static VALUE rb_gsl_ran_erlang_pdf(VALUE obj, VALUE x, VALUE a, VALUE n)
 }
 */
 
-#ifdef GSL_1_8_LATER
 
 static VALUE rb_gsl_ran_gaussian_ziggurat(int argc, VALUE *argv, VALUE obj)
 {
-  gsl_rng *r = NULL;	
+  gsl_rng *r = NULL;
   gsl_vector *v;
   size_t n, i;
   double sigma = 1.0;
@@ -1615,18 +1598,18 @@ static VALUE rb_gsl_ran_gaussian_ziggurat(int argc, VALUE *argv, VALUE obj)
       n = NUM2INT(argv[2]);
       sigma = NUM2DBL(argv[1]);
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);    
+      Data_Get_Struct(argv[0], gsl_rng, r);
       v = gsl_vector_alloc(n);
-      for (i = 0; i < n; i++) 
-	gsl_vector_set(v, i, gsl_ran_gaussian_ziggurat(r, sigma));
+      for (i = 0; i < n; i++)
+        gsl_vector_set(v, i, gsl_ran_gaussian_ziggurat(r, sigma));
       return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v);
       break;
     case 2:
       sigma = NUM2DBL(argv[1]);
-      /* no break */
+    /* no break */
     case 1:
       CHECK_RNG(argv[0]);
-      Data_Get_Struct(argv[0], gsl_rng, r);    
+      Data_Get_Struct(argv[0], gsl_rng, r);
       return rb_float_new(gsl_ran_gaussian_ziggurat(r, sigma));
       break;
     default:
@@ -1636,19 +1619,19 @@ static VALUE rb_gsl_ran_gaussian_ziggurat(int argc, VALUE *argv, VALUE obj)
     }
     break;
   default:
-    Data_Get_Struct(obj, gsl_rng, r);    
+    Data_Get_Struct(obj, gsl_rng, r);
     switch (argc) {
     case 2:
       n = NUM2INT(argv[1]);
       sigma = NUM2DBL(argv[0]);
       v = gsl_vector_alloc(n);
-      for (i = 0; i < n; i++) 
-	gsl_vector_set(v, i, gsl_ran_gaussian_ziggurat(r, sigma));
+      for (i = 0; i < n; i++)
+        gsl_vector_set(v, i, gsl_ran_gaussian_ziggurat(r, sigma));
       return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v);
       break;
     case 1:
       sigma = NUM2DBL(argv[0]);
-      /* no break */
+    /* no break */
     case 0:
       return rb_float_new(gsl_ran_gaussian_ziggurat(r, sigma));
       break;
@@ -1666,7 +1649,6 @@ static VALUE rb_gsl_ran_gamma_mt(int argc, VALUE *argv, VALUE obj)
 {
   return rb_gsl_ran_eval2(argc, argv, obj, gsl_ran_gamma_mt);
 }
-#endif
 
 void Init_gsl_ran(VALUE module)
 {
@@ -1674,18 +1656,18 @@ void Init_gsl_ran(VALUE module)
   VALUE cgsl_ran_discrete;
 
   mgsl_ran = rb_define_module_under(module, "Ran");
-  
+
   rb_define_module_function(mgsl_ran, "gaussian", rb_gsl_ran_gaussian, -1);
   rb_define_module_function(mgsl_ran, "ugaussian", rb_gsl_ran_gaussian, -1);
   rb_define_method(cgsl_rng, "gaussian", rb_gsl_ran_gaussian, -1);
   rb_define_alias(cgsl_rng, "ugaussian", "gaussian");
 
-  rb_define_module_function(mgsl_ran, "gaussian_ratio_method", 
-			    rb_gsl_ran_gaussian_ratio_method, -1);
+  rb_define_module_function(mgsl_ran, "gaussian_ratio_method",
+                            rb_gsl_ran_gaussian_ratio_method, -1);
   rb_define_module_function(mgsl_ran, "ugaussian_ratio_method",
-			    rb_gsl_ran_gaussian_ratio_method, -1);
-  rb_define_method(cgsl_rng, "gaussian_ratio_method", 
-		   rb_gsl_ran_gaussian_ratio_method, -1);
+                            rb_gsl_ran_gaussian_ratio_method, -1);
+  rb_define_method(cgsl_rng, "gaussian_ratio_method",
+                   rb_gsl_ran_gaussian_ratio_method, -1);
   rb_define_alias(cgsl_rng, "ugaussian_ratio_method", "gaussian_ratio_method");
   rb_define_module_function(mgsl_ran,  "gaussian_pdf", rb_gsl_ran_gaussian_pdf, -1);
   rb_define_module_function(mgsl_ran,  "ugaussian_pdf", rb_gsl_ran_gaussian_pdf, -1);
@@ -1694,22 +1676,22 @@ void Init_gsl_ran(VALUE module)
   rb_define_module_function(mgsl_ran, "ugaussian_tail", rb_gsl_ran_gaussian_tail, -1);
   rb_define_method(cgsl_rng, "gaussian_tail", rb_gsl_ran_gaussian_tail, -1);
   rb_define_alias(cgsl_rng, "ugaussian_tail", "gaussian_tail");
-  rb_define_module_function(mgsl_ran,  "gaussian_tail_pdf", 
-			    rb_gsl_ran_gaussian_tail_pdf, -1);
-  rb_define_module_function(mgsl_ran,  "ugaussian_tail_pdf", 
-			    rb_gsl_ran_gaussian_tail_pdf, -1);
-
-  rb_define_module_function(mgsl_ran, "bivariate_gaussian", 
-		   rb_gsl_ran_bivariate_gaussian, -1);
-  rb_define_method(cgsl_rng, "bivariate_gaussian", 
-		   rb_gsl_ran_bivariate_gaussian, -1);
-  rb_define_module_function(mgsl_ran,  "bivariate_gaussian_pdf", 
-			    rb_gsl_ran_bivariate_gaussian_pdf, 5);
+  rb_define_module_function(mgsl_ran,  "gaussian_tail_pdf",
+                            rb_gsl_ran_gaussian_tail_pdf, -1);
+  rb_define_module_function(mgsl_ran,  "ugaussian_tail_pdf",
+                            rb_gsl_ran_gaussian_tail_pdf, -1);
+
+  rb_define_module_function(mgsl_ran, "bivariate_gaussian",
+                            rb_gsl_ran_bivariate_gaussian, -1);
+  rb_define_method(cgsl_rng, "bivariate_gaussian",
+                   rb_gsl_ran_bivariate_gaussian, -1);
+  rb_define_module_function(mgsl_ran,  "bivariate_gaussian_pdf",
+                            rb_gsl_ran_bivariate_gaussian_pdf, 5);
 
   rb_define_module_function(mgsl_ran, "exponential", rb_gsl_ran_exponential, -1);
   rb_define_method(cgsl_rng, "exponential", rb_gsl_ran_exponential, -1);
-  rb_define_module_function(mgsl_ran,  "exponential_pdf", 
-			    rb_gsl_ran_exponential_pdf, 2);
+  rb_define_module_function(mgsl_ran,  "exponential_pdf",
+                            rb_gsl_ran_exponential_pdf, 2);
 
   rb_define_module_function(mgsl_ran, "laplace", rb_gsl_ran_laplace, -1);
   rb_define_method(cgsl_rng, "laplace", rb_gsl_ran_laplace, -1);
@@ -1729,8 +1711,8 @@ void Init_gsl_ran(VALUE module)
 
   rb_define_module_function(mgsl_ran, "rayleigh_tail", rb_gsl_ran_rayleigh_tail, -1);
   rb_define_method(cgsl_rng, "rayleigh_tail", rb_gsl_ran_rayleigh_tail, -1);
-  rb_define_module_function(mgsl_ran,  "rayleigh_tail_pdf", 
-			    rb_gsl_ran_rayleigh_tail_pdf, 3);
+  rb_define_module_function(mgsl_ran,  "rayleigh_tail_pdf",
+                            rb_gsl_ran_rayleigh_tail_pdf, 3);
 
   rb_define_module_function(mgsl_ran, "landau", rb_gsl_ran_landau, -1);
   rb_define_method(cgsl_rng, "landau", rb_gsl_ran_landau, -1);
@@ -1799,14 +1781,12 @@ void Init_gsl_ran(VALUE module)
 
   rb_define_module_function(mgsl_ran, "binomial", rb_gsl_ran_binomial, -1);
   rb_define_method(cgsl_rng, "binomial", rb_gsl_ran_binomial, -1);
-#ifdef GSL_1_4_LATER
   rb_define_module_function(mgsl_ran, "binomial_tpe", rb_gsl_ran_binomial_tpe, -1);
   rb_define_method(cgsl_rng, "binomial_tpe", rb_gsl_ran_binomial_tpe, -1);
-#endif
   rb_define_module_function(mgsl_ran,  "binomial_pdf", rb_gsl_ran_binomial_pdf, 3);
 
-  rb_define_module_function(mgsl_ran, "negative_binomial", 
-			    rb_gsl_ran_negative_binomial, -1);
+  rb_define_module_function(mgsl_ran, "negative_binomial",
+                            rb_gsl_ran_negative_binomial, -1);
   rb_define_method(cgsl_rng, "negative_binomial", rb_gsl_ran_negative_binomial, -1);
   rb_define_module_function(mgsl_ran,  "negative_binomial_pdf", rb_gsl_ran_negative_binomial_pdf, 3);
 
@@ -1820,17 +1800,17 @@ void Init_gsl_ran(VALUE module)
 
   rb_define_module_function(mgsl_ran, "hypergeometric", rb_gsl_ran_hypergeometric, -1);
   rb_define_method(cgsl_rng, "hypergeometric", rb_gsl_ran_hypergeometric, -1);
-  rb_define_module_function(mgsl_ran,  "hypergeometric_pdf", 
-			    rb_gsl_ran_hypergeometric_pdf, 4);
+  rb_define_module_function(mgsl_ran,  "hypergeometric_pdf",
+                            rb_gsl_ran_hypergeometric_pdf, 4);
 
   rb_define_module_function(mgsl_ran, "logarithmic", rb_gsl_ran_logarithmic, -1);
   rb_define_method(cgsl_rng, "logarithmic", rb_gsl_ran_logarithmic, -1);
   rb_define_module_function(mgsl_ran,  "logarithmic_pdf",
-			    rb_gsl_ran_logarithmic_pdf, 2);
+                            rb_gsl_ran_logarithmic_pdf, 2);
 
   rb_define_module_function(mgsl_ran, "dir_2d", rb_gsl_ran_dir_2d, -1);
-  rb_define_module_function(mgsl_ran, "dir_2d_trig_method", 
-			    rb_gsl_ran_dir_2d_trig_method, -1);
+  rb_define_module_function(mgsl_ran, "dir_2d_trig_method",
+                            rb_gsl_ran_dir_2d_trig_method, -1);
   rb_define_module_function(mgsl_ran, "dir_3d", rb_gsl_ran_dir_3d, -1);
   rb_define_module_function(mgsl_ran, "dir_nd", rb_gsl_ran_dir_nd, -1);
 
@@ -1853,21 +1833,16 @@ void Init_gsl_ran(VALUE module)
   rb_define_method(cgsl_rng, "discrete", rb_gsl_ran_discrete, 1);
   rb_define_module_function(mgsl_ran,  "discrete_pdf", rb_gsl_ran_discrete_pdf, 2);
 
-#ifdef GSL_1_3_LATER
   rb_define_method(cgsl_rng, "dirichlet", rb_gsl_ran_dirichlet, -1);
   rb_define_module_function(mgsl_ran,  "dirichlet_pdf", rb_gsl_ran_dirichlet_pdf, 2);
   rb_define_module_function(mgsl_ran,  "dirichlet_lnpdf", rb_gsl_ran_dirichlet_lnpdf, 2);
-#endif
 
   /*  rb_define_method(cgsl_rng, "erlang", rb_gsl_ran_erlang, 2);
   rb_define_method(module, "ran_erlang_pdf", rb_gsl_ran_erlang_pdf, 3);
   rb_define_method(mgsl_ran, "erlang_pdf", rb_gsl_ran_erlang_pdf, 3);*/
 
-#ifdef GSL_1_8_LATER
   rb_define_module_function(mgsl_ran, "gaussian_ziggurat", rb_gsl_ran_gaussian_ziggurat, -1);
   rb_define_method(cgsl_rng, "gaussian_ziggurat", rb_gsl_ran_gaussian_ziggurat, -1);
   rb_define_module_function(mgsl_ran, "gamma_mt", rb_gsl_ran_gamma_mt, -1);
   rb_define_method(cgsl_rng, "gamma_mt", rb_gsl_ran_gamma_mt, -1);
-#endif
-
 }