gsl 1.15.3 → 1.16.0.6

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

@@ -8,17 +8,17 @@
   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 "include/rb_gsl_array.h"
 #include <gsl/gsl_permute.h>
 #include <gsl/gsl_permute_vector.h>
 
 VALUE rb_gsl_permutation_alloc(VALUE klass, VALUE nn);
 
 /*
- * Creates a new permutation of size n. The permutation is not initialized 
- * and its elements are undefined. Use the method calloc if you want to create 
- * a permutation which is initialized to the identity. 
+ * Creates a new permutation of size n. The permutation is not initialized
+ * and its elements are undefined. Use the method calloc if you want to create
+ * a permutation which is initialized to the identity.
  */
 VALUE rb_gsl_permutation_alloc(VALUE klass, VALUE nn)
 {
@@ -51,12 +51,17 @@ static VALUE rb_gsl_permutation_init(VALUE obj)
   return obj;
 }
 
-void get_range_int_beg_en_n(VALUE range, int *beg, int *en, size_t *n, int *step);
+#ifndef CHECK_RANGE_OFFSET
+#define CHECK_RANGE_OFFSET(i) if (i < -((int) b->size) || i >= ((int) b->size)) \
+    rb_raise(rb_eRangeError, "offset %d out of range", i);
+#endif
+
 static VALUE rb_gsl_permutation_get(int argc, VALUE *argv, VALUE obj)
 {
   gsl_permutation *b, *bnew;
   gsl_index *p;
-  int beg, en, i, step;
+  long beg;
+  int i;
   size_t n, j, k;
   Data_Get_Struct(obj, gsl_permutation, b);
   switch (argc) {
@@ -67,6 +72,7 @@ static VALUE rb_gsl_permutation_get(int argc, VALUE *argv, VALUE obj)
     switch (TYPE(argv[0])) {
     case T_FIXNUM:
       i = FIX2INT(argv[0]);
+      CHECK_RANGE_OFFSET(i);
       if (i < 0) j = b->size + i; else j = (size_t) i;
       return INT2FIX((int) b->data[j]);
       break;
@@ -75,33 +81,36 @@ static VALUE rb_gsl_permutation_get(int argc, VALUE *argv, VALUE obj)
       n = RARRAY_LEN(argv[0]);
       bnew = gsl_permutation_alloc(n);
       for (j = 0; j < n; j++) {
-	i = FIX2INT(rb_ary_entry(argv[0], j));
-	if (i < 0) k = b->size + i; else k = i;
-	bnew->data[j] = b->data[k];
+        i = FIX2INT(rb_ary_entry(argv[0], j));
+        CHECK_RANGE_OFFSET(i);
+        if (i < 0) k = b->size + i; else k = (size_t) i;
+        bnew->data[j] = b->data[k];
       }
-      return Data_Wrap_Struct(CLASS_OF(argv[0]), 0, gsl_permutation_free, bnew);
+      return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_permutation_free, bnew);
       break;
     default:
       if (PERMUTATION_P(argv[0])) {
-	Data_Get_Struct(argv[0], gsl_index, p);
-	bnew = gsl_permutation_alloc(p->size);
-	for (j = 0; j < p->size; j++) bnew->data[j] = b->data[p->data[j]];
-	return Data_Wrap_Struct(CLASS_OF(argv[0]), 0, gsl_permutation_free, bnew);
+        Data_Get_Struct(argv[0], gsl_index, p);
+        bnew = gsl_permutation_alloc(p->size);
+        for (j = 0; j < p->size; j++) bnew->data[j] = b->data[p->data[j]];
+        return Data_Wrap_Struct(CLASS_OF(argv[0]), 0, gsl_permutation_free, bnew);
       } else if (CLASS_OF(argv[0]) == rb_cRange) {
-	get_range_int_beg_en_n(argv[0], &beg, &en, &n, &step);
-	bnew = gsl_permutation_alloc(n);
-	for (j = 0; j < n; j++) 
-	  bnew->data[j] = b->data[beg+j];
-	return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_permutation_free, bnew);
+        rb_range_beg_len(argv[0], &beg, (long *) &n, (long) b->size, 2);
+        if (n == 0) rb_raise(rb_eRangeError, "range overflow");
+        if (n > b->size) n = b->size;
+        bnew = gsl_permutation_alloc(n);
+        for (j = 0; j < n; j++)
+          bnew->data[j] = b->data[beg+j];
+        return Data_Wrap_Struct(CLASS_OF(obj), 0, gsl_permutation_free, bnew);
       } else {
-	rb_raise(rb_eArgError, "wrong argument type %s (Fixnum, Array, or Range expected)", rb_class2name(CLASS_OF(argv[0])));
-	break;
+        rb_raise(rb_eArgError, "wrong argument type %s (Fixnum, Array, or Range expected)", rb_class2name(CLASS_OF(argv[0])));
+        break;
       }
     }
     break;
   default:
     bnew = gsl_permutation_alloc(argc);
-    for (j = 0; j < argc; j++) {
+    for (j = 0; j < (size_t) argc; j++) {
       i = FIX2INT(argv[j]);
       if (i < 0) k = b->size + i; else k = i;
       bnew->data[j] = b->data[k];
@@ -112,7 +121,6 @@ static VALUE rb_gsl_permutation_get(int argc, VALUE *argv, VALUE obj)
   return Qnil;
 }
 
-#ifdef GSL_1_1_LATER
 static VALUE rb_gsl_permutation_clone(VALUE obj)
 {
   gsl_permutation *p, *p2 = NULL;
@@ -133,7 +141,6 @@ static VALUE rb_gsl_permutation_memcpy(VALUE obj, VALUE pp1, VALUE pp2)
   gsl_permutation_memcpy(p1, p2);
   return pp1;
 }
-#endif
 
 static VALUE rb_gsl_permutation_swap(VALUE obj, VALUE i, VALUE j)
 {
@@ -271,7 +278,6 @@ static VALUE rb_gsl_permute_vector_inverse(VALUE obj, VALUE pp, VALUE vv)
 }
 
 /* singleton method */
-#ifdef GSL_1_2_LATER
 static VALUE rb_gsl_permutation_mul(VALUE obj, VALUE ppa, VALUE ppb)
 {
   gsl_permutation *p = NULL;
@@ -291,7 +297,6 @@ static VALUE rb_gsl_permutation_mul(VALUE obj, VALUE ppa, VALUE ppb)
   if (flag == 1) return obj;
   else return Data_Wrap_Struct(cgsl_permutation, 0, gsl_permutation_free, p);
 }
-#endif
 
 static VALUE rb_gsl_permutation_print(VALUE obj);
 
@@ -367,9 +372,8 @@ static VALUE rb_gsl_permutation_fprintf(int argc, VALUE *argv, VALUE obj)
   FILE *fp = NULL;
   int status, flag = 0;
 
-  if (argc != 1 && argc != 2) rb_raise(rb_eArgError, 
-				       "wrong number of arguments (%d for 1 or 2)", argc);
-
+  if (argc != 1 && argc != 2) rb_raise(rb_eArgError,
+                                       "wrong number of arguments (%d for 1 or 2)", argc);
   Data_Get_Struct(obj, gsl_permutation, h);
   fp = rb_gsl_open_writefile(argv[0], &flag);
   if (argc == 1) {
@@ -409,7 +413,6 @@ static VALUE rb_gsl_permutation_fscanf(VALUE obj, VALUE io)
   return INT2FIX(status);
 }
 
-#ifdef GSL_1_2_LATER
 static VALUE rb_gsl_permutation_linear_to_canonical(int argc, VALUE *argv, VALUE obj)
 {
   gsl_permutation *p, *q;
@@ -476,7 +479,6 @@ static VALUE rb_gsl_permutation_canonical_cycles(VALUE obj)
   Data_Get_Struct(obj, gsl_permutation, p);
   return INT2FIX(gsl_permutation_canonical_cycles(p));
 }
-#endif
 
 static VALUE rb_gsl_vector_permute(VALUE obj, VALUE pp)
 {
@@ -537,10 +539,8 @@ void Init_gsl_permutation(VALUE module)
   rb_define_alias(cgsl_permutation, "[]", "get");
   rb_define_method(cgsl_permutation, "set", rb_gsl_permutation_set, 2);
   rb_define_alias(cgsl_permutation, "[]=", "set");
-#ifdef GSL_1_1_LATER
   rb_define_singleton_method(cgsl_permutation, "memcpy", rb_gsl_permutation_memcpy, 2);
   rb_define_method(cgsl_permutation, "clone", rb_gsl_permutation_clone, 0);
-#endif
   rb_define_method(cgsl_permutation, "swap", rb_gsl_permutation_swap, 2);
   rb_define_method(cgsl_permutation, "valid", rb_gsl_permutation_valid, 0);
   rb_define_method(cgsl_permutation, "valid?", rb_gsl_permutation_valid2, 0);
@@ -556,7 +556,7 @@ void Init_gsl_permutation(VALUE module)
   rb_define_alias(cgsl_permutation, "permute", "permute_vector");
   rb_define_method(cgsl_permutation, "permute_vector_inverse", rb_gsl_permutation_permute_vector_inverse, 1);
   rb_define_alias(cgsl_permutation, "permute_inverse", "permute_vector_inverse");
-  
+
   rb_define_singleton_method(cgsl_permutation, "permute_vector", rb_gsl_permute_vector, 2);
   rb_define_singleton_method(cgsl_permutation, "permute_vector_inverse", rb_gsl_permute_vector_inverse, 2);
   rb_define_module_function(module, "permute_vector", rb_gsl_permute_vector, 2);
@@ -574,7 +574,6 @@ void Init_gsl_permutation(VALUE module)
   rb_define_method(cgsl_permutation, "fscanf", rb_gsl_permutation_fscanf, 1);
   rb_define_method(cgsl_permutation, "print", rb_gsl_permutation_print, 0);
 
-#ifdef GSL_1_2_LATER
   rb_define_singleton_method(cgsl_permutation, "mul", rb_gsl_permutation_mul, 2);
   rb_define_method(cgsl_permutation, "mul", rb_gsl_permutation_mul, 2);
   rb_define_method(cgsl_permutation, "linear_to_canonical", rb_gsl_permutation_linear_to_canonical, -1);
@@ -585,7 +584,6 @@ void Init_gsl_permutation(VALUE module)
   rb_define_method(cgsl_permutation, "inversions", rb_gsl_permutation_inversions, 0);
   rb_define_method(cgsl_permutation, "linear_cycles", rb_gsl_permutation_linear_cycles, 0);
   rb_define_method(cgsl_permutation, "canonical_cycles", rb_gsl_permutation_canonical_cycles, 0);
-#endif
 
   rb_define_method(cgsl_vector, "permute", rb_gsl_vector_permute, 1);
   rb_define_method(cgsl_vector, "permute_inverse", rb_gsl_vector_permute_inverse, 1);
@@ -594,3 +592,7 @@ void Init_gsl_permutation(VALUE module)
   rb_define_alias(cgsl_permutation, "==", "equal?");
 
 }
+
+#ifdef CHECK_RANGE_OFFSET
+#undef CHECK_RANGE_OFFSET
+#endif

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

@@ -8,22 +8,19 @@
   This library is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY.
 */
-#include "rb_gsl_config.h"
-#include "rb_gsl_poly.h"
-#include "rb_gsl_array.h"
-#include "rb_gsl_common.h"
-#ifdef HAVE_NARARY_H
-#include "narray.h"
-#endif
+
+#include "include/rb_gsl_poly.h"
+#include "include/rb_gsl_array.h"
+#include "include/rb_gsl_common.h"
 
 void Init_gsl_poly_init(VALUE module);
 void Init_gsl_poly_int_init(VALUE module);
 void Init_gsl_poly2(VALUE module);
 
 #define BASE_DOUBLE
-#include "templates_on.h"
-#include "poly_source.c"
-#include "templates_off.h"
+#include "include/templates_on.h"
+#include "poly_source.h"
+#include "include/templates_off.h"
 void Init_gsl_poly(VALUE module)
 {
   Init_gsl_poly_init(module);
@@ -32,9 +29,9 @@ void Init_gsl_poly(VALUE module)
 #undef  BASE_DOUBLE
 
 #define BASE_INT
-#include "templates_on.h"
-#include "poly_source.c"
-#include "templates_off.h"
+#include "include/templates_on.h"
+#include "poly_source.h"
+#include "include/templates_off.h"
 void Init_gsl_poly_int(VALUE module)
 {
   Init_gsl_poly_int_init(module);

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

@@ -8,10 +8,10 @@
   This library is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY.
 */
-#include "rb_gsl_config.h"
-#include "rb_gsl_poly.h"
-#include "rb_gsl_math.h"
-#include "rb_gsl_array.h"
+
+#include "include/rb_gsl_poly.h"
+#include "include/rb_gsl_math.h"
+#include "include/rb_gsl_array.h"
 #include <gsl/gsl_sf_gamma.h>
 
 static gsl_poly_int* mygsl_poly_hermite(int n1)
@@ -37,7 +37,7 @@ static gsl_poly_int* mygsl_poly_hermite(int n1)
     p2 = gsl_vector_int_calloc(n1 + 1);
     memcpy(p1->data, coef2, 3*sizeof(int));
     memcpy(p2->data, coef1, 2*sizeof(int));
-    for (n = 2; n < n1; n++) {
+    for (n = 2; (int) n < n1; n++) {
       gsl_vector_int_memcpy(p0, p1);
       mygsl_vector_int_shift_scale2(p0, n);
       gsl_vector_int_scale(p2, 2*n);
@@ -48,7 +48,7 @@ static gsl_poly_int* mygsl_poly_hermite(int n1)
       gsl_vector_int_memcpy(p1, p0);
     }
     gsl_vector_int_free(p2);
-    gsl_vector_int_free(p1);    
+    gsl_vector_int_free(p1);
     break;
   }
   return p0;
@@ -77,7 +77,7 @@ static gsl_poly_int* mygsl_poly_cheb(int n1)
     p2 = gsl_vector_int_calloc(n1 + 1);
     memcpy(p1->data, coef2, 3*sizeof(int));
     memcpy(p2->data, coef1, 2*sizeof(int));
-    for (n = 2; n < n1; n++) {
+    for (n = 2; (int) n < n1; n++) {
       gsl_vector_int_memcpy(p0, p1);
       mygsl_vector_int_shift_scale2(p0, n);
 
@@ -87,7 +87,7 @@ static gsl_poly_int* mygsl_poly_cheb(int n1)
       gsl_vector_int_memcpy(p1, p0);
     }
     gsl_vector_int_free(p2);
-    gsl_vector_int_free(p1);    
+    gsl_vector_int_free(p1);
     break;
   }
   return p0;
@@ -116,7 +116,7 @@ static gsl_poly_int* mygsl_poly_chebII(int n1)
     p2 = gsl_vector_int_calloc(n1 + 1);
     memcpy(p1->data, coef2, 3*sizeof(int));
     memcpy(p2->data, coef1, 2*sizeof(int));
-    for (n = 2; n < n1; n++) {
+    for (n = 2; (int) n < n1; n++) {
       gsl_vector_int_memcpy(p0, p1);
       mygsl_vector_int_shift_scale2(p0, n);
       gsl_vector_int_sub(p0, p2);
@@ -125,7 +125,7 @@ static gsl_poly_int* mygsl_poly_chebII(int n1)
       gsl_vector_int_memcpy(p1, p0);
     }
     gsl_vector_int_free(p2);
-    gsl_vector_int_free(p1);    
+    gsl_vector_int_free(p1);
     break;
   }
   return p0;
@@ -148,7 +148,7 @@ static gsl_poly_int* mygsl_poly_laguerre(int n)
     break;
   default:
     k = gsl_sf_fact(n);
-    for (m = 0; m <= n; m++) {
+    for (m = 0; (int) m <= n; m++) {
       val = k*k/gsl_sf_fact(n-m)/gsl_pow_2(gsl_sf_fact(m));
       if (m%2 == 1) val *= -1;
       gsl_vector_int_set(p0, m, val);
@@ -164,7 +164,7 @@ static gsl_poly_int* mygsl_poly_bessel(int n)
   gsl_vector_int *p0;
   if (n < 0) rb_raise(rb_eArgError, "order must be >= 0");
   p0 = gsl_vector_int_calloc(n + 1);
-  for (k = 0; k <= n; k++) {
+  for (k = 0; (int) k <= n; k++) {
     gsl_vector_int_set(p0, k, gsl_sf_fact(n+k)/gsl_sf_fact(n-k)/gsl_sf_fact(k)/((int) pow(2, k)));
   }
   return p0;
@@ -191,11 +191,11 @@ static gsl_poly_int* mygsl_poly_bell(int n1)
   default:
     p1 = gsl_vector_int_calloc(n1 + 1);
     memcpy(p1->data, coef2, 3*sizeof(int));
-    for (n = 2; n < n1; n++) {
+    for (n = 2; (int) n < n1; n++) {
       gsl_vector_int_memcpy(p0, p1);
       mygsl_vector_int_shift(p0, n);
       for (j = 0; j < n; j++) {
-	gsl_vector_int_set(p1, j, gsl_vector_int_get(p1, j+1)*(j+1));
+        gsl_vector_int_set(p1, j, gsl_vector_int_get(p1, j+1)*(j+1));
       }
       gsl_vector_int_set(p1, n, 0);
       mygsl_vector_int_shift(p1, n);
@@ -203,14 +203,14 @@ static gsl_poly_int* mygsl_poly_bell(int n1)
       /* save for the next iteration */
       gsl_vector_int_memcpy(p1, p0);
     }
-    gsl_vector_int_free(p1);    
+    gsl_vector_int_free(p1);
     break;
   }
   return p0;
 }
 
 static VALUE rb_gsl_poly_define_poly(VALUE klass, VALUE order,
-				     gsl_poly_int* (*f)(int n1)) {
+                                     gsl_poly_int* (*f)(int n1)) {
   int n1;
   gsl_poly_int *pnew = NULL;
   CHECK_FIXNUM(order);

data/ext/{poly_source.c → gsl_native/poly_source.h}

@@ -51,28 +51,21 @@
 VALUE cgsl_poly, cgsl_poly_int;
 VALUE cgsl_poly_workspace;
 VALUE cgsl_poly_complex_workspace;
-#ifdef GSL_1_1_LATER
 VALUE cgsl_poly_dd;
 VALUE cgsl_poly_taylor;
 #endif
-#endif
 
 #ifdef BASE_INT
 double gsl_poly_int_eval(const BASE c[], const int len, const double x)
 {
   int i;
   double ans = (double) c[len-1];
-  for(i=len-1; i>0; i--) ans = (double) c[i-1] + x * ans;
+  for(i = len-1; i>0; i--) ans = (double) c[i-1] + x * ans;
   return ans;
 }
 #endif
 #ifdef BASE_DOUBLE
-#ifdef HAVE_NARRAY_H
-#include "rb_gsl_with_narray.h"
-#endif
-#ifdef GSL_1_11_LATER
 static VALUE rb_gsl_complex_poly_complex_eval(VALUE a, VALUE b);
-#endif
 static VALUE rb_gsl_poly_eval_singleton(VALUE klass, VALUE a, VALUE x)
 {
   gsl_vector *v = NULL, *vx, *vnew;
@@ -82,22 +75,15 @@ static VALUE rb_gsl_poly_eval_singleton(VALUE klass, VALUE a, VALUE x)
   size_t i, N, n;
   VALUE val;
   double *ptr0;
-  double *ptr1, *ptr2;  
-#ifdef HAVE_NARRAY_H
-  int shape[1];
-#endif  
-#ifdef GSL_1_11_LATER
+  double *ptr1, *ptr2;
   gsl_complex *z, zz;
   gsl_vector_complex *vz, *vznew;
-  if (rb_obj_is_kind_of(a, cgsl_vector_complex)) 
+  if (rb_obj_is_kind_of(a, cgsl_vector_complex))
     return rb_gsl_complex_poly_complex_eval(a, x);
-#endif
   switch (TYPE(a)) {
   case T_ARRAY:
-#ifdef GSL_1_11_LATER
-    if (rb_obj_is_kind_of(rb_ary_entry(a, 0), cgsl_complex)) 
+    if (rb_obj_is_kind_of(rb_ary_entry(a, 0), cgsl_complex))
       return rb_gsl_complex_poly_complex_eval(a, x);
-#endif
     v = make_cvector_from_rarray(a);
     N = v->size;
     ptr0 = v->data;
@@ -115,7 +101,7 @@ static VALUE rb_gsl_poly_eval_singleton(VALUE klass, VALUE a, VALUE x)
 #endif
     } else {
       rb_raise(rb_eTypeError, "Wrong argument type %s (Array, GSL::Vector or NArray expected)",
-        rb_class2name(CLASS_OF(a)));
+               rb_class2name(CLASS_OF(a)));
     }
   }
   switch (TYPE(x)) {
@@ -123,7 +109,7 @@ static VALUE rb_gsl_poly_eval_singleton(VALUE klass, VALUE a, VALUE x)
   case T_BIGNUM:
   case T_FLOAT:
     val = rb_float_new(gsl_poly_eval(ptr0, N, NUM2DBL(x)));
-    break;    
+    break;
   case T_ARRAY:
     n = RARRAY_LEN(x);
     val = rb_ary_new2(n);
@@ -131,7 +117,7 @@ static VALUE rb_gsl_poly_eval_singleton(VALUE klass, VALUE a, VALUE x)
       rslt = gsl_poly_eval(ptr0, N, NUM2DBL(rb_ary_entry(x, i)));
       rb_ary_store(val, i, rb_float_new(rslt));
     }
-    break;  
+    break;
   default:
     if (rb_obj_is_kind_of(x, cgsl_vector)) {
       Data_Get_Struct(x, gsl_vector, vx);
@@ -143,19 +129,19 @@ static VALUE rb_gsl_poly_eval_singleton(VALUE klass, VALUE a, VALUE x)
     } else if (rb_obj_is_kind_of(x, cgsl_matrix)) {
       Data_Get_Struct(x, gsl_matrix, mx);
       mnew = gsl_matrix_alloc(mx->size1, mx->size2);
-      val = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);      
+      val = Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
       n = mx->size1*mx->size2;
       ptr1 = mx->data;
       ptr2 = mnew->data;
 #ifdef HAVE_NARRAY_H
     } else if (NA_IsNArray(x)) {
+      int shape[1];
       shape[0] = NA_TOTAL(x);
       n = shape[0];
       val = na_make_object(NA_DFLOAT, 1, shape, CLASS_OF(x));
       ptr1 = NA_PTR_TYPE(x, double*);
-      ptr2 = NA_PTR_TYPE(val, double*);      
+      ptr2 = NA_PTR_TYPE(val, double*);
 #endif
-#ifdef GSL_1_11_LATER
     } else if (rb_obj_is_kind_of(x, cgsl_complex)) {
       Data_Get_Struct(x, gsl_complex, z);
       zz = gsl_poly_complex_eval(ptr0, N, *z);
@@ -166,15 +152,14 @@ static VALUE rb_gsl_poly_eval_singleton(VALUE klass, VALUE a, VALUE x)
       Data_Get_Struct(x, gsl_vector_complex, vz);
       vznew = gsl_vector_complex_alloc(vz->size);
       for (i = 0; i < vz->size; i++) {
-	zz = gsl_poly_complex_eval(ptr0, N, gsl_vector_complex_get(vz, i));
-	gsl_vector_complex_set(vznew, i, zz);
+        zz = gsl_poly_complex_eval(ptr0, N, gsl_vector_complex_get(vz, i));
+        gsl_vector_complex_set(vznew, i, zz);
       }
       if (flag == 1) gsl_vector_free(v);
       return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vznew);
-#endif
     } else {
       rb_raise(rb_eTypeError, "Wrong argument type %s (A number, Array, GSL::Vector or NArray expected)",
-        rb_class2name(CLASS_OF(a)));      
+               rb_class2name(CLASS_OF(a)));
     }
     for (i = 0; i < n; i++) {
       ptr2[i] = gsl_poly_eval(ptr0, N, ptr1[i]);
@@ -183,10 +168,10 @@ static VALUE rb_gsl_poly_eval_singleton(VALUE klass, VALUE a, VALUE x)
   if (flag == 1) gsl_vector_free(v);
   return val;
 }
-#ifdef GSL_1_11_LATER
+
 static VALUE rb_gsl_complex_poly_complex_eval(VALUE a, VALUE b)
 {
-  gsl_vector_complex *coef, *zb, *vnew;
+  gsl_vector_complex *coef = NULL, *zb, *vnew;
   gsl_complex *zc;
   gsl_complex z, *zx, *res;
   VALUE ret;
@@ -207,7 +192,6 @@ static VALUE rb_gsl_complex_poly_complex_eval(VALUE a, VALUE b)
   } else {
     rb_raise(rb_eTypeError, "rb_gsl_complex_poly_complex_solve: wrong argument type %s (GSL::Vector::Complex or Array expected)\n", rb_class2name(CLASS_OF(a)));
   }
-
   switch (TYPE(b)) {
   case T_FIXNUM:
   case T_BIGNUM:
@@ -220,7 +204,7 @@ static VALUE rb_gsl_complex_poly_complex_eval(VALUE a, VALUE b)
     break;
   case T_ARRAY:
     ret = rb_ary_new2(RARRAY_LEN(b));
-    for (i = 0; i < RARRAY_LEN(b); i++) {
+    for (i = 0; (int) i < RARRAY_LEN(b); i++) {
       Data_Get_Struct(rb_ary_entry(b, i), gsl_complex, zx);
       res = (gsl_complex*) malloc(sizeof(gsl_complex));
       *res = gsl_complex_poly_complex_eval(zc, N, *zx);
@@ -238,8 +222,8 @@ static VALUE rb_gsl_complex_poly_complex_eval(VALUE a, VALUE b)
       vnew = gsl_vector_complex_alloc(zb->size);
       ret = Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vnew);
       for (i = 0; i < zb->size; i++) {
-	z = gsl_vector_complex_get(zb, i);
-	gsl_vector_complex_set(vnew, i, gsl_complex_poly_complex_eval(zc, N, z));
+        z = gsl_vector_complex_get(zb, i);
+        gsl_vector_complex_set(vnew, i, gsl_complex_poly_complex_eval(zc, N, z));
       }
     } else {
       rb_raise(rb_eTypeError, "Wrong argument type %s.\n", rb_class2name(CLASS_OF(b)));
@@ -249,7 +233,6 @@ static VALUE rb_gsl_complex_poly_complex_eval(VALUE a, VALUE b)
   return ret;
 }
 #endif
-#endif
 
 static VALUE FUNCTION(rb_gsl_poly,eval)(VALUE obj, VALUE xx)
 {
@@ -261,15 +244,8 @@ static VALUE FUNCTION(rb_gsl_poly,eval)(VALUE obj, VALUE xx)
   VALUE x, ary;
   size_t i, j;
 #ifdef BASE_DOUBLE
-#ifdef HAVE_NARRAY_H
-  struct NARRAY *na;
-  double *ptr1, *ptr2;
-  size_t n;
-#endif
-#ifdef GSL_1_11_LATER
   gsl_complex *z, zz;
   gsl_vector_complex *vz, *vznew;
-#endif
 #endif
 
   Data_Get_Struct(obj, GSL_TYPE(gsl_poly), p);
@@ -282,7 +258,7 @@ static VALUE FUNCTION(rb_gsl_poly,eval)(VALUE obj, VALUE xx)
     break;
   case T_ARRAY:
     ary = rb_ary_new2(RARRAY_LEN(xx));
-    for (i = 0; i < RARRAY_LEN(xx); i++) {
+    for (i = 0; (int) i < RARRAY_LEN(xx); i++) {
       x = rb_ary_entry(xx, i);
       Need_Float(x);
       rb_ary_store(ary, i, rb_float_new(FUNCTION(gsl_poly,eval)(p->data, p->size, NUM2DBL(x))));
@@ -293,6 +269,9 @@ static VALUE FUNCTION(rb_gsl_poly,eval)(VALUE obj, VALUE xx)
 #ifdef BASE_DOUBLE
 #ifdef HAVE_NARRAY_H
     if (NA_IsNArray(xx)) {
+      struct NARRAY *na;
+      double *ptr1, *ptr2;
+      size_t n;
       GetNArray(xx, na);
       ptr1 = (double*) na->ptr;
       n = na->total;
@@ -307,21 +286,20 @@ static VALUE FUNCTION(rb_gsl_poly,eval)(VALUE obj, VALUE xx)
       Data_Get_Struct(xx, GSL_TYPE(gsl_vector), v);
       vnew = gsl_vector_alloc(v->size);
       for (i = 0; i < v->size; i++) {
-	gsl_vector_set(vnew, i, FUNCTION(gsl_poly,eval)(p->data, p->size, FUNCTION(gsl_vector,get)(v, i)));
+        gsl_vector_set(vnew, i, FUNCTION(gsl_poly,eval)(p->data, p->size, FUNCTION(gsl_vector,get)(v, i)));
       }
       return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
     } else if (MAT_P(xx)) {
       Data_Get_Struct(xx, GSL_TYPE(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, 
-			 FUNCTION(gsl_poly,eval)(p->data, p->size, FUNCTION(gsl_matrix,get)(m, i, j)));
-	}
+        for (j = 0; j < m->size2; j++) {
+          gsl_matrix_set(mnew, i, j,
+                         FUNCTION(gsl_poly,eval)(p->data, p->size, FUNCTION(gsl_matrix,get)(m, i, j)));
+        }
       }
       return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
 #ifdef BASE_DOUBLE
-#ifdef GSL_1_11_LATER
     } else if (rb_obj_is_kind_of(xx, cgsl_complex)) {
       Data_Get_Struct(xx, gsl_complex, z);
       zz = gsl_poly_complex_eval(p->data, p->size, *z);
@@ -331,11 +309,10 @@ static VALUE FUNCTION(rb_gsl_poly,eval)(VALUE obj, VALUE xx)
       Data_Get_Struct(xx, gsl_vector_complex, vz);
       vznew = gsl_vector_complex_alloc(vz->size);
       for (i = 0; i < vz->size; i++) {
-	zz = gsl_poly_complex_eval(p->data, p->size, gsl_vector_complex_get(vz, i));
-	gsl_vector_complex_set(vznew, i, zz);
+        zz = gsl_poly_complex_eval(p->data, p->size, gsl_vector_complex_get(vz, i));
+        gsl_vector_complex_set(vznew, i, zz);
       }
       return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vznew);
-#endif
 #endif
     } else {
       rb_raise(rb_eTypeError, "wrong argument type");
@@ -355,12 +332,6 @@ static VALUE FUNCTION(rb_gsl_poly,eval2)(int argc, VALUE *argv, VALUE obj)
   gsl_matrix  *mnew = NULL;
   VALUE xx, x, ary;
   size_t i, j, size;
-#ifdef BASE_DOUBLE
-#ifdef HAVE_NARRAY_H
-  struct NARRAY *na;
-  double *ptr1, *ptr2;
-#endif
-#endif
   switch (argc) {
   case 2:
     Data_Get_Struct(argv[0], GSL_TYPE(gsl_poly), p);
@@ -385,7 +356,7 @@ static VALUE FUNCTION(rb_gsl_poly,eval2)(int argc, VALUE *argv, VALUE obj)
     break;
   case T_ARRAY:
     ary = rb_ary_new2(RARRAY_LEN(xx));
-    for (i = 0; i < RARRAY_LEN(xx); i++) {
+    for (i = 0; (int) i < RARRAY_LEN(xx); i++) {
       x = rb_ary_entry(xx, i);
       Need_Float(x);
       rb_ary_store(ary, i, rb_float_new(FUNCTION(gsl_poly,eval)(p->data, size, NUM2DBL(x))));
@@ -396,6 +367,8 @@ static VALUE FUNCTION(rb_gsl_poly,eval2)(int argc, VALUE *argv, VALUE obj)
 #ifdef BASE_DOUBLE
 #ifdef HAVE_NARRAY_H
     if (NA_IsNArray(xx)) {
+      struct NARRAY *na;
+      double *ptr1, *ptr2;
       GetNArray(xx, na);
       ptr1 = (double*) na->ptr;
       size = na->total;
@@ -410,17 +383,17 @@ static VALUE FUNCTION(rb_gsl_poly,eval2)(int argc, VALUE *argv, VALUE obj)
       Data_Get_Struct(xx, GSL_TYPE(gsl_vector), v);
       vnew = gsl_vector_alloc(v->size);
       for (i = 0; i < v->size; i++) {
-	gsl_vector_set(vnew, i, FUNCTION(gsl_poly,eval)(p->data, size, FUNCTION(gsl_vector,get)(v, i)));
+        gsl_vector_set(vnew, i, FUNCTION(gsl_poly,eval)(p->data, size, FUNCTION(gsl_vector,get)(v, i)));
       }
       return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
     } else if (MAT_P(xx)) {
       Data_Get_Struct(xx, GSL_TYPE(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, 
-			 FUNCTION(gsl_poly,eval)(p->data, size, FUNCTION(gsl_matrix,get)(m, i, j)));
-	}
+        for (j = 0; j < m->size2; j++) {
+          gsl_matrix_set(mnew, i, j,
+                         FUNCTION(gsl_poly,eval)(p->data, size, FUNCTION(gsl_matrix,get)(m, i, j)));
+        }
       }
       return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
     } else {
@@ -441,29 +414,29 @@ static VALUE FUNCTION(rb_gsl_poly,solve_quadratic)(int argc, VALUE *argv, VALUE
   switch (argc) {
   case 3:
     n = gsl_poly_solve_quadratic(NUMCONV2(argv[0]), NUMCONV2(argv[1]), NUMCONV2(argv[2]),
-				 &x0, &x1);
+                                 &x0, &x1);
     break;
   case 1:
     switch (TYPE(argv[0])) {
     case T_ARRAY:
-      n = gsl_poly_solve_quadratic(NUMCONV2(rb_ary_entry(argv[0], 0)), 
-				   NUMCONV2(rb_ary_entry(argv[0], 1)),
-				   NUMCONV2(rb_ary_entry(argv[0], 2)),
-				   &x0, &x1);
+      n = gsl_poly_solve_quadratic(NUMCONV2(rb_ary_entry(argv[0], 0)),
+                                   NUMCONV2(rb_ary_entry(argv[0], 1)),
+                                   NUMCONV2(rb_ary_entry(argv[0], 2)),
+                                   &x0, &x1);
       break;
     default:
       CHECK_VEC(argv[0]);
       Data_Get_Struct(argv[0], GSL_TYPE(gsl_poly), v);
       n = gsl_poly_solve_quadratic(FUNCTION(gsl_vector,get)(v, 0),
-				   FUNCTION(gsl_vector,get)(v, 1),
-				   FUNCTION(gsl_vector,get)(v, 2),
-				   &x0, &x1);
+                                   FUNCTION(gsl_vector,get)(v, 1),
+                                   FUNCTION(gsl_vector,get)(v, 2),
+                                   &x0, &x1);
       break;
     }
     break;
   default:
-    rb_raise(rb_eArgError, 
-	     "wrong number of arguments (3 numbers or 1 array or 1 vector)");
+    rb_raise(rb_eArgError,
+             "wrong number of arguments (3 numbers or 1 array or 1 vector)");
     break;
   }
   // If n == 0, we want to return an empty gsl_vector, but gsl_vectors can'y be
@@ -473,8 +446,8 @@ static VALUE FUNCTION(rb_gsl_poly,solve_quadratic)(int argc, VALUE *argv, VALUE
   }
   r = gsl_vector_alloc(n);
   switch(n) {
-    case 2: gsl_vector_set(r, 1, x1); /* fall through */
-    case 1: gsl_vector_set(r, 0, x0);
+  case 2: gsl_vector_set(r, 1, x1);   /* fall through */
+  case 1: gsl_vector_set(r, 0, x0);
   }
   return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, r);
 }
@@ -487,31 +460,31 @@ static VALUE FUNCTION(rb_gsl_poly,complex_solve_quadratic)(int argc, VALUE *argv
   int n;
   switch (argc) {
   case 3:
-    n = gsl_poly_complex_solve_quadratic(NUMCONV2(argv[0]), 
-					 NUMCONV2(argv[1]), NUMCONV2(argv[2]),
-					 &z0, &z1);
+    n = gsl_poly_complex_solve_quadratic(NUMCONV2(argv[0]),
+                                         NUMCONV2(argv[1]), NUMCONV2(argv[2]),
+                                         &z0, &z1);
     break;
   case 1:
     switch (TYPE(argv[0])) {
     case T_ARRAY:
-      n = gsl_poly_complex_solve_quadratic(NUMCONV2(rb_ary_entry(argv[0], 0)), 
-					   NUMCONV2(rb_ary_entry(argv[0], 1)),
-					   NUMCONV2(rb_ary_entry(argv[0], 2)),
-					   &z0, &z1);
+      n = gsl_poly_complex_solve_quadratic(NUMCONV2(rb_ary_entry(argv[0], 0)),
+                                           NUMCONV2(rb_ary_entry(argv[0], 1)),
+                                           NUMCONV2(rb_ary_entry(argv[0], 2)),
+                                           &z0, &z1);
       break;
     default:
       CHECK_VEC(argv[0]);
       Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v);
       n = gsl_poly_complex_solve_quadratic(FUNCTION(gsl_vector,get)(v, 0),
-					   FUNCTION(gsl_vector,get)(v, 1),
-					   FUNCTION(gsl_vector,get)(v, 2),
-					   &z0, &z1);
+                                           FUNCTION(gsl_vector,get)(v, 1),
+                                           FUNCTION(gsl_vector,get)(v, 2),
+                                           &z0, &z1);
       break;
     }
     break;
   default:
-    rb_raise(rb_eArgError, 
-	     "wrong number of arguments (3 numbers or 1 array or 1 vector)");
+    rb_raise(rb_eArgError,
+             "wrong number of arguments (3 numbers or 1 array or 1 vector)");
     break;
   }
   // If n == 0, we want to return an empty gsl_vector, but gsl_vectors can'y be
@@ -521,8 +494,8 @@ static VALUE FUNCTION(rb_gsl_poly,complex_solve_quadratic)(int argc, VALUE *argv
   }
   r = gsl_vector_complex_alloc(n);
   switch(n) {
-    case 2: gsl_vector_complex_set(r, 1, z1); /* fall through */
-    case 1: gsl_vector_complex_set(r, 0, z0);
+  case 2: gsl_vector_complex_set(r, 1, z1);   /* fall through */
+  case 1: gsl_vector_complex_set(r, 0, z0);
   }
   return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r);
 }
@@ -536,36 +509,36 @@ static VALUE FUNCTION(rb_gsl_poly,solve_cubic)(int argc, VALUE *argv, VALUE obj)
   switch (argc) {
   case 3:
     n = gsl_poly_solve_cubic(NUMCONV2(argv[0]), NUMCONV2(argv[1]), NUMCONV2(argv[2]),
-			     &x0, &x1, &x2);
+                             &x0, &x1, &x2);
     break;
   case 1:
     switch (TYPE(argv[0])) {
     case T_ARRAY:
-      n = gsl_poly_solve_cubic(NUMCONV2(rb_ary_entry(argv[0], 0)), 
-				   NUMCONV2(rb_ary_entry(argv[0], 1)),
-				   NUMCONV2(rb_ary_entry(argv[0], 2)),
-				   &x0, &x1, &x2);
+      n = gsl_poly_solve_cubic(NUMCONV2(rb_ary_entry(argv[0], 0)),
+                               NUMCONV2(rb_ary_entry(argv[0], 1)),
+                               NUMCONV2(rb_ary_entry(argv[0], 2)),
+                               &x0, &x1, &x2);
       break;
     default:
       CHECK_VEC(argv[0]);
       Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v);
       n = gsl_poly_solve_cubic(FUNCTION(gsl_vector,get)(v, 0),
-				   FUNCTION(gsl_vector,get)(v, 1),
-				   FUNCTION(gsl_vector,get)(v, 2),
-				   &x0, &x1, &x2);
+                               FUNCTION(gsl_vector,get)(v, 1),
+                               FUNCTION(gsl_vector,get)(v, 2),
+                               &x0, &x1, &x2);
       break;
     }
     break;
   default:
-    rb_raise(rb_eArgError, 
-	     "wrong number of arguments (3 numbers or 1 array or 1 vector)");
+    rb_raise(rb_eArgError,
+             "wrong number of arguments (3 numbers or 1 array or 1 vector)");
     break;
   }
   r = gsl_vector_alloc(n);
   switch(n) {
-    case 3: gsl_vector_set(r, 2, x2); /* fall through */
-    case 2: gsl_vector_set(r, 1, x1); /* fall through */
-    case 1: gsl_vector_set(r, 0, x0);
+  case 3: gsl_vector_set(r, 2, x2);   /* fall through */
+  case 2: gsl_vector_set(r, 1, x1);   /* fall through */
+  case 1: gsl_vector_set(r, 0, x0);
   }
   return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, r);
 }
@@ -579,41 +552,41 @@ static VALUE FUNCTION(rb_gsl_poly,complex_solve_cubic)(int argc, VALUE *argv, VA
   switch (argc) {
   case 3:
     n = gsl_poly_complex_solve_cubic(NUMCONV2(argv[0]), NUMCONV2(argv[1]), NUMCONV2(argv[2]),
-				     &z0, &z1, &z2);
+                                     &z0, &z1, &z2);
     break;
   case 1:
     switch (TYPE(argv[0])) {
     case T_ARRAY:
-      n = gsl_poly_complex_solve_cubic(NUMCONV2(rb_ary_entry(argv[0], 0)), 
-				   NUMCONV2(rb_ary_entry(argv[0], 1)),
-				   NUMCONV2(rb_ary_entry(argv[0], 2)),
-				   &z0, &z1, &z2);
+      n = gsl_poly_complex_solve_cubic(NUMCONV2(rb_ary_entry(argv[0], 0)),
+                                       NUMCONV2(rb_ary_entry(argv[0], 1)),
+                                       NUMCONV2(rb_ary_entry(argv[0], 2)),
+                                       &z0, &z1, &z2);
       break;
     default:
       CHECK_VEC(argv[0]);
       Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v);
       n = gsl_poly_complex_solve_cubic(FUNCTION(gsl_vector,get)(v, 0),
-				   FUNCTION(gsl_vector,get)(v, 1),
-				   FUNCTION(gsl_vector,get)(v, 2),
-				   &z0, &z1, &z2);
+                                       FUNCTION(gsl_vector,get)(v, 1),
+                                       FUNCTION(gsl_vector,get)(v, 2),
+                                       &z0, &z1, &z2);
       break;
     }
     break;
   default:
-    rb_raise(rb_eArgError, 
-	     "wrong number of arguments (3 numbers or 1 array or 1 vector)");
+    rb_raise(rb_eArgError,
+             "wrong number of arguments (3 numbers or 1 array or 1 vector)");
     break;
   }
   r = gsl_vector_complex_alloc(n);
   switch(n) {
-    case 3: gsl_vector_complex_set(r, 2, z2); /* fall through */
-    case 2: gsl_vector_complex_set(r, 1, z1); /* fall through */
-    case 1: gsl_vector_complex_set(r, 0, z0);
+  case 3: gsl_vector_complex_set(r, 2, z2);   /* fall through */
+  case 2: gsl_vector_complex_set(r, 1, z1);   /* fall through */
+  case 1: gsl_vector_complex_set(r, 0, z0);
   }
   return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r);
 }
 
-#ifdef HAVE_POLY_SOLVE_QUARTIC
+#ifdef HAVE_GSL_POLY_SOLVE_QUARTIC
 static VALUE FUNCTION(rb_gsl_poly,solve_quartic)(int argc, VALUE *argv, VALUE obj)
 {
   double x0, x1, x2, x3;
@@ -623,40 +596,40 @@ static VALUE FUNCTION(rb_gsl_poly,solve_quartic)(int argc, VALUE *argv, VALUE ob
   switch (argc) {
   case 4:
     n = gsl_poly_solve_quartic(NUMCONV2(argv[0]), NUMCONV2(argv[1]), NUMCONV2(argv[2]),
-			       NUMCONV2(argv[3]),
-			       &x0, &x1, &x2, &x3);
+                               NUMCONV2(argv[3]),
+                               &x0, &x1, &x2, &x3);
     break;
   case 1:
     switch (TYPE(argv[0])) {
     case T_ARRAY:
-      n = gsl_poly_solve_quartic(NUMCONV2(rb_ary_entry(argv[0], 0)), 
-			       NUMCONV2(rb_ary_entry(argv[0], 1)),
-			       NUMCONV2(rb_ary_entry(argv[0], 2)),
-			       NUMCONV2(rb_ary_entry(argv[0], 3)),
-			       &x0, &x1, &x2, &x3);
+      n = gsl_poly_solve_quartic(NUMCONV2(rb_ary_entry(argv[0], 0)),
+                                 NUMCONV2(rb_ary_entry(argv[0], 1)),
+                                 NUMCONV2(rb_ary_entry(argv[0], 2)),
+                                 NUMCONV2(rb_ary_entry(argv[0], 3)),
+                                 &x0, &x1, &x2, &x3);
       break;
     default:
       CHECK_VEC(argv[0]);
       Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v);
       n = gsl_poly_solve_quartic(FUNCTION(gsl_vector,get)(v, 0),
-			       FUNCTION(gsl_vector,get)(v, 1),
-			       FUNCTION(gsl_vector,get)(v, 2),
-			       FUNCTION(gsl_vector,get)(v, 3),
-			       &x0, &x1, &x2, &x3);
+                                 FUNCTION(gsl_vector,get)(v, 1),
+                                 FUNCTION(gsl_vector,get)(v, 2),
+                                 FUNCTION(gsl_vector,get)(v, 3),
+                                 &x0, &x1, &x2, &x3);
       break;
     }
     break;
   default:
-    rb_raise(rb_eArgError, 
-	     "wrong number of arguments (3 numbers or 1 array or 1 vector)");
+    rb_raise(rb_eArgError,
+             "wrong number of arguments (3 numbers or 1 array or 1 vector)");
     break;
   }
   r = gsl_vector_alloc(n);
   switch(n) {
-    case 4: gsl_vector_set(r, 3, x3); /* fall through */
-    case 3: gsl_vector_set(r, 2, x2); /* fall through */
-    case 2: gsl_vector_set(r, 1, x1); /* fall through */
-    case 1: gsl_vector_set(r, 0, x0);
+  case 4: gsl_vector_set(r, 3, x3);   /* fall through */
+  case 3: gsl_vector_set(r, 2, x2);   /* fall through */
+  case 2: gsl_vector_set(r, 1, x1);   /* fall through */
+  case 1: gsl_vector_set(r, 0, x0);
   }
   return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, r);
 }
@@ -669,41 +642,41 @@ static VALUE FUNCTION(rb_gsl_poly,complex_solve_quartic)(int argc, VALUE *argv,
   int n;
   switch (argc) {
   case 4:
-    n = gsl_poly_complex_solve_quartic(NUMCONV2(argv[0]), NUMCONV2(argv[1]), 
-				       NUMCONV2(argv[2]), NUMCONV2(argv[3]),
-				       &z0, &z1, &z2, &z3);
+    n = gsl_poly_complex_solve_quartic(NUMCONV2(argv[0]), NUMCONV2(argv[1]),
+                                       NUMCONV2(argv[2]), NUMCONV2(argv[3]),
+                                       &z0, &z1, &z2, &z3);
     break;
   case 1:
     switch (TYPE(argv[0])) {
     case T_ARRAY:
-      n = gsl_poly_complex_solve_quartic(NUMCONV2(rb_ary_entry(argv[0], 0)), 
-					 NUMCONV2(rb_ary_entry(argv[0], 1)),
-					 NUMCONV2(rb_ary_entry(argv[0], 2)),
-					 NUMCONV2(rb_ary_entry(argv[0], 3)),
-					 &z0, &z1, &z2, &z3);
+      n = gsl_poly_complex_solve_quartic(NUMCONV2(rb_ary_entry(argv[0], 0)),
+                                         NUMCONV2(rb_ary_entry(argv[0], 1)),
+                                         NUMCONV2(rb_ary_entry(argv[0], 2)),
+                                         NUMCONV2(rb_ary_entry(argv[0], 3)),
+                                         &z0, &z1, &z2, &z3);
       break;
     default:
       CHECK_VEC(argv[0]);
       Data_Get_Struct(argv[0], GSL_TYPE(gsl_vector), v);
       n = gsl_poly_complex_solve_quartic(FUNCTION(gsl_vector,get)(v, 0),
-					 FUNCTION(gsl_vector,get)(v, 1),
-					 FUNCTION(gsl_vector,get)(v, 2),
-					 FUNCTION(gsl_vector,get)(v, 3),
-					 &z0, &z1, &z2, &z3);
+                                         FUNCTION(gsl_vector,get)(v, 1),
+                                         FUNCTION(gsl_vector,get)(v, 2),
+                                         FUNCTION(gsl_vector,get)(v, 3),
+                                         &z0, &z1, &z2, &z3);
       break;
     }
     break;
   default:
-    rb_raise(rb_eArgError, 
-	     "wrong number of arguments (3 numbers or 1 array or 1 vector)");
+    rb_raise(rb_eArgError,
+             "wrong number of arguments (3 numbers or 1 array or 1 vector)");
     break;
   }
   r = gsl_vector_complex_alloc(n);
   switch(n) {
-    case 4: gsl_vector_complex_set(r, 0, z0); /* fall through */
-    case 3: gsl_vector_complex_set(r, 1, z1); /* fall through */
-    case 2: gsl_vector_complex_set(r, 2, z2); /* fall through */
-    case 1: gsl_vector_complex_set(r, 3, z3);
+  case 4: gsl_vector_complex_set(r, 0, z0);   /* fall through */
+  case 3: gsl_vector_complex_set(r, 1, z1);   /* fall through */
+  case 2: gsl_vector_complex_set(r, 2, z2);   /* fall through */
+  case 1: gsl_vector_complex_set(r, 3, z3);
   }
   return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r);
 }
@@ -809,20 +782,19 @@ static VALUE FUNCTION(rb_gsl_poly,solve_quadratic2)(VALUE obj)
     n = gsl_poly_solve_quadratic(a2, a1, a0, &x0, &x1);
     r = gsl_vector_alloc(n);
     switch(n) {
-      case 2: gsl_vector_set(r, 1, x1); /* fall through */
-      case 1: gsl_vector_set(r, 0, x0);
+    case 2: gsl_vector_set(r, 1, x1);   /* fall through */
+    case 1: gsl_vector_set(r, 0, x0);
     }
     return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, r);
   } else {
     n = gsl_poly_complex_solve_quadratic(a2, a1, a0, &z0, &z1);
     r2 = gsl_vector_complex_alloc(n);
     switch(n) {
-      case 2: gsl_vector_complex_set(r2, 1, z1); /* fall through */
-      case 1: gsl_vector_complex_set(r2, 0, z0);
+    case 2: gsl_vector_complex_set(r2, 1, z1);   /* fall through */
+    case 1: gsl_vector_complex_set(r2, 0, z0);
     }
     return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r2);
   }
-
 }
 
 
@@ -843,8 +815,8 @@ static VALUE FUNCTION(rb_gsl_poly,complex_solve_quadratic2)(VALUE obj)
   n = gsl_poly_complex_solve_quadratic(a2, a1, a0, &z0, &z1);
   r = gsl_vector_complex_alloc(n);
   switch(n) {
-    case 2: gsl_vector_complex_set(r, 1, z1); /* fall through */
-    case 1: gsl_vector_complex_set(r, 0, z0);
+  case 2: gsl_vector_complex_set(r, 1, z1);   /* fall through */
+  case 1: gsl_vector_complex_set(r, 0, z0);
   }
   return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r);
 }
@@ -862,16 +834,16 @@ static VALUE FUNCTION(rb_gsl_poly,solve_cubic2)(VALUE obj)
   if (v->size < 4) {
     rb_raise(rb_eArgError, "the order of the object is less than 4.");
   }
-  a3 = FUNCTION(gsl_vector,get)(v, 3);   
+  a3 = FUNCTION(gsl_vector,get)(v, 3);
   a2 = FUNCTION(gsl_vector,get)(v, 2)/a3;   /* coefficients */
   a1 = FUNCTION(gsl_vector,get)(v, 1)/a3;
   a0 = FUNCTION(gsl_vector,get)(v, 0)/a3;
   n = gsl_poly_solve_cubic(a2, a1, a0, &x0, &x1, &x2);
   r = gsl_vector_alloc(n);
   switch(n) {
-    case 3: gsl_vector_set(r, 2, x2); /* fall through */
-    case 2: gsl_vector_set(r, 1, x1); /* fall through */
-    case 1: gsl_vector_set(r, 0, x0);
+  case 3: gsl_vector_set(r, 2, x2);   /* fall through */
+  case 2: gsl_vector_set(r, 1, x1);   /* fall through */
+  case 1: gsl_vector_set(r, 0, x0);
   }
   return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, r);
 }
@@ -887,21 +859,21 @@ static VALUE FUNCTION(rb_gsl_poly,complex_solve_cubic2)(VALUE obj)
   if (v->size < 4) {
     rb_raise(rb_eArgError, "the order of the object is less than 4.");
   }
-  a3 = FUNCTION(gsl_vector,get)(v, 3);   
+  a3 = FUNCTION(gsl_vector,get)(v, 3);
   a2 = FUNCTION(gsl_vector,get)(v, 2)/a3;   /* coefficients */
   a1 = FUNCTION(gsl_vector,get)(v, 1)/a3;
   a0 = FUNCTION(gsl_vector,get)(v, 0)/a3;
   n = gsl_poly_complex_solve_cubic(a2, a1, a0, &z0, &z1, &z2);
   r = gsl_vector_complex_alloc(n);
   switch(n) {
-    case 3: gsl_vector_complex_set(r, 2, z2); /* fall through */
-    case 2: gsl_vector_complex_set(r, 1, z1); /* fall through */
-    case 1: gsl_vector_complex_set(r, 0, z0);
+  case 3: gsl_vector_complex_set(r, 2, z2);   /* fall through */
+  case 2: gsl_vector_complex_set(r, 1, z1);   /* fall through */
+  case 1: gsl_vector_complex_set(r, 0, z0);
   }
   return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, r);
 }
 
-#ifdef HAVE_POLY_SOLVE_QUARTIC
+#ifdef HAVE_GSL_POLY_SOLVE_QUARTIC
 /* a4 x**4 + a3 x**3 + a2 x**2 + a1 x + a0 = 0 */
 static VALUE FUNCTION(rb_gsl_poly,solve_quartic2)(VALUE obj)
 {
@@ -915,8 +887,8 @@ static VALUE FUNCTION(rb_gsl_poly,solve_quartic2)(VALUE obj)
   if (v->size < 5) {
     rb_raise(rb_eArgError, "the order of the object is less than 4.");
   }
-  a4 = FUNCTION(gsl_vector,get)(v, 4);   
-  a3 = FUNCTION(gsl_vector,get)(v, 3)/a4;   
+  a4 = FUNCTION(gsl_vector,get)(v, 4);
+  a3 = FUNCTION(gsl_vector,get)(v, 3)/a4;
   a2 = FUNCTION(gsl_vector,get)(v, 2)/a4;   /* coefficients */
   a1 = FUNCTION(gsl_vector,get)(v, 1)/a4;
   a0 = FUNCTION(gsl_vector,get)(v, 0)/a4;
@@ -941,8 +913,8 @@ static VALUE FUNCTION(rb_gsl_poly,complex_solve_quartic2)(VALUE obj)
   if (v->size < 5) {
     rb_raise(rb_eArgError, "the order of the object is less than 4.");
   }
-  a4 = FUNCTION(gsl_vector,get)(v, 4);   
-  a3 = FUNCTION(gsl_vector,get)(v, 3)/a4;   
+  a4 = FUNCTION(gsl_vector,get)(v, 4);
+  a3 = FUNCTION(gsl_vector,get)(v, 3)/a4;
   a2 = FUNCTION(gsl_vector,get)(v, 2)/a4;   /* coefficients */
   a1 = FUNCTION(gsl_vector,get)(v, 1)/a4;
   a0 = FUNCTION(gsl_vector,get)(v, 0)/a4;
@@ -978,7 +950,6 @@ VALUE FUNCTION(rb_gsl_poly,complex_solve2)(int argc, VALUE *argv, VALUE obj)
   for (i = 0; i < v->size; i++) {
     gsl_vector_set(a, i, FUNCTION(gsl_vector,get)(v, i));
   }
-
   if (argc == 1 && rb_obj_is_kind_of(argv[0], cgsl_poly_workspace)) {
     Data_Get_Struct(argv[0], gsl_poly_complex_workspace, w);
     flag = 0;
@@ -986,7 +957,6 @@ VALUE FUNCTION(rb_gsl_poly,complex_solve2)(int argc, VALUE *argv, VALUE obj)
     w = gsl_poly_complex_workspace_alloc(size);
     flag = 1;
   }
-  
   /*status =*/ gsl_poly_complex_solve(a->data, size, w, z->data);
 
   r = gsl_vector_complex_alloc(size - 1);
@@ -1009,7 +979,7 @@ static VALUE rb_gsl_poly_int_to_f(VALUE obj)
   size_t i;
   Data_Get_Struct(obj, gsl_vector_int, vi);
   v = gsl_vector_alloc(vi->size);
-  for (i = 0; i < v->size; i++) 
+  for (i = 0; i < v->size; i++)
     gsl_vector_set(v, i, (double) gsl_vector_int_get(vi, i));
   return Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, v);
 }
@@ -1023,7 +993,7 @@ static VALUE rb_gsl_poly_to_i(VALUE obj)
   size_t i;
   Data_Get_Struct(obj, gsl_vector, v);
   vi = gsl_vector_int_alloc(v->size);
-  for (i = 0; i < v->size; i++) 
+  for (i = 0; i < v->size; i++)
     gsl_vector_int_set(vi, i, (int) gsl_vector_get(v, i));
   return Data_Wrap_Struct(cgsl_poly_int, 0, gsl_vector_int_free, vi);
 }
@@ -1035,8 +1005,6 @@ static VALUE FUNCTION(rb_gsl_poly,workspace_new)(VALUE klass, VALUE n)
   return Data_Wrap_Struct(klass, 0, gsl_poly_complex_workspace_free, w);
 }
 
-#ifdef GSL_1_1_LATER
-
 /* singleton method of the class Poly */
 static VALUE rb_gsl_poly_dd_init(VALUE obj, VALUE vxa, VALUE vya)
 {
@@ -1065,7 +1033,7 @@ static VALUE rb_gsl_poly_dd_eval(VALUE obj, VALUE xxa, VALUE xx)
   case T_BIGNUM:
   case T_FLOAT:
     return rb_float_new(gsl_poly_dd_eval(dd->data, xa->data, dd->size,
-					 NUM2DBL(xx)));
+                                         NUM2DBL(xx)));
     break;
   case T_ARRAY:
     size = RARRAY_LEN(xx);
@@ -1073,9 +1041,9 @@ static VALUE rb_gsl_poly_dd_eval(VALUE obj, VALUE xxa, VALUE xx)
     for (i = 0; i < size; i++) {
       x = rb_ary_entry(xx, i);
       Need_Float(x);
-      rb_ary_store(ary, i, 
-		   rb_float_new(gsl_poly_dd_eval(dd->data, xa->data, 
-						 dd->size, NUM2DBL(x))));
+      rb_ary_store(ary, i,
+                   rb_float_new(gsl_poly_dd_eval(dd->data, xa->data,
+                                                 dd->size, NUM2DBL(x))));
     }
     return ary;
     break;
@@ -1085,9 +1053,9 @@ static VALUE rb_gsl_poly_dd_eval(VALUE obj, VALUE xxa, VALUE xx)
       size = v->size;
       vnew = gsl_vector_alloc(v->size);
       for (i = 0; i < size; i++) {
-	gsl_vector_set(vnew, i, 
-		       gsl_poly_dd_eval(dd->data, xa->data, 
-					dd->size, FUNCTION(gsl_vector,get)(v, i)));
+        gsl_vector_set(vnew, i,
+                       gsl_poly_dd_eval(dd->data, xa->data,
+                                        dd->size, FUNCTION(gsl_vector,get)(v, i)));
       }
       return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
     } else if (MAT_P(xx)) {
@@ -1095,11 +1063,11 @@ static VALUE rb_gsl_poly_dd_eval(VALUE obj, VALUE xxa, VALUE xx)
       size = m->size1;
       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, 
-			 gsl_poly_dd_eval(dd->data, xa->data, 
-					  dd->size, gsl_matrix_get(m, i, j)));
-	}
+        for (j = 0; j < m->size2; j++) {
+          gsl_matrix_set(mnew, i, j,
+                         gsl_poly_dd_eval(dd->data, xa->data,
+                                          dd->size, gsl_matrix_get(m, i, j)));
+        }
       }
       return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
     } else {
@@ -1160,7 +1128,6 @@ static VALUE rb_gsl_poly_dd_taylor(int argc, VALUE *argv, VALUE obj)
   return Data_Wrap_Struct(cgsl_poly_taylor, 0, gsl_vector_free, c);
 }
 
-#endif
 #endif
 
 static VALUE FUNCTION(rb_gsl_poly,order)(VALUE obj)
@@ -1171,7 +1138,7 @@ static VALUE FUNCTION(rb_gsl_poly,order)(VALUE obj)
 }
 
 int FUNCTION(gsl_poly,conv)(const BASE *a, size_t na, const BASE *b, size_t nb,
-		  BASE *c, size_t *nc)
+                            BASE *c, size_t *nc)
 {
   BASE x;
   size_t i, j;
@@ -1192,7 +1159,7 @@ GSL_TYPE(gsl_vector)* FUNCTION(gsl_poly,conv_vector)(const GSL_TYPE(gsl_vector)
 {
   GSL_TYPE(gsl_vector) *vnew = NULL;
   size_t n, tmp;
-  if (v1->size == 1) { 
+  if (v1->size == 1) {
     vnew = FUNCTION(make_vector,clone)(v2);
     FUNCTION(gsl_vector,scale)(vnew, FUNCTION(gsl_vector,get)(v1, 0));
     return vnew;
@@ -1249,8 +1216,8 @@ GSL_TYPE(gsl_vector)* FUNCTION(gsl_poly,integ)(const GSL_TYPE(gsl_vector) *v)
   return vnew;
 }
 
-GSL_TYPE(gsl_vector)* FUNCTION(gsl_poly,deconv_vector)(const GSL_TYPE(gsl_vector) *c, const GSL_TYPE(gsl_vector) *a, 
-				   GSL_TYPE(gsl_vector) **r)
+GSL_TYPE(gsl_vector)* FUNCTION(gsl_poly,deconv_vector)(const GSL_TYPE(gsl_vector) *c, const GSL_TYPE(gsl_vector) *a,
+                                                       GSL_TYPE(gsl_vector) **r)
 {
   GSL_TYPE(gsl_vector) *vnew = NULL, *a2 = NULL, *c2 = NULL, *vtmp = NULL;
   GSL_TYPE(gsl_vector) *rtmp = NULL;
@@ -1265,12 +1232,15 @@ GSL_TYPE(gsl_vector)* FUNCTION(gsl_poly,deconv_vector)(const GSL_TYPE(gsl_vector
   FUNCTION(gsl_vector,set)(vnew, n-1, FUNCTION(gsl_vector,get)(c2, c2->size-1)/aa);
   for (i = n - 2, k = 1; k < n; i--, k++) {
     x = FUNCTION(gsl_vector,get)(c2, c2->size-1-k);
-    for (j = n-1; j >= 0; j--) {
+    for (j = n-1;; j--) {
       z = FUNCTION(gsl_vector,get)(vnew, j);
       jj = c2->size-1-k-j;
-      if (jj > k || jj < 0) continue;
-      y = FUNCTION(gsl_vector,get)(a2, jj);
-      x -= y*z;
+      //if (jj > k || jj < 0) continue;
+      if (jj <= k) {
+        y = FUNCTION(gsl_vector,get)(a2, jj);
+        x -= y*z;
+      }
+      if (j == 0) break;
     }
     FUNCTION(gsl_vector,set)(vnew, i, x/aa);
   }
@@ -1354,11 +1324,11 @@ VALUE FUNCTION(rb_gsl_poly,deconv)(VALUE obj, VALUE bb)
   }
   vnew = FUNCTION(gsl_poly,deconv_vector)(v, v2, &r);
   if (flag == 1) FUNCTION(gsl_vector,free)(v2);
-  if (FUNCTION(gsl_vector,isnull)(r)) 
+  if (FUNCTION(gsl_vector,isnull)(r))
     return Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), vnew);
   else
     return rb_ary_new3(2, Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), vnew),
-		       Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), r));
+                       Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), r));
 }
 
 static VALUE FUNCTION(rb_gsl_poly,reduce)(VALUE obj)
@@ -1407,7 +1377,7 @@ static VALUE FUNCTION(rb_gsl_poly,conv2)(VALUE klass, VALUE v1, VALUE v2)
   p3 = FUNCTION(gsl_poly,conv_vector)(p1, p2);
   if (flag1 == 1) FUNCTION(gsl_vector,free)(p1);
   if (flag2 == 1) FUNCTION(gsl_vector,free)(p2);
-  if (flag1 == 1 && flag2 == 1) {	
+  if (flag1 == 1 && flag2 == 1) {
     ary = rb_ary_new2(p3->size);
     for (i = 0; i < p3->size; i++)
       rb_ary_store(ary, i, C_TO_VALUE2(FUNCTION(gsl_vector,get)(p3, i)));
@@ -1428,15 +1398,15 @@ static VALUE FUNCTION(rb_gsl_poly,deconv2)(VALUE klass, VALUE v1, VALUE v2)
   vnew = FUNCTION(gsl_poly,deconv_vector)(p1, p2, &r);
   if (flag1 == 1) FUNCTION(gsl_vector,free)(p1);
   if (flag2 == 1) FUNCTION(gsl_vector,free)(p2);
-  if (FUNCTION(gsl_vector,isnull)(r)) 
+  if (FUNCTION(gsl_vector,isnull)(r))
     return Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), vnew);
   else
     return rb_ary_new3(2, Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), vnew),
-		       Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), r));
+                       Data_Wrap_Struct(GSL_TYPE(cgsl_poly), 0, FUNCTION(gsl_vector,free), r));
 }
 
-GSL_TYPE(gsl_poly)* FUNCTION(gsl_poly,add)(const GSL_TYPE(gsl_poly) *a, 
-	const GSL_TYPE(gsl_poly) *b)
+GSL_TYPE(gsl_poly)* FUNCTION(gsl_poly,add)(const GSL_TYPE(gsl_poly) *a,
+                                           const GSL_TYPE(gsl_poly) *b)
 {
   GSL_TYPE(gsl_poly) *c = NULL;
   const GSL_TYPE(gsl_poly) *longer;
@@ -1446,7 +1416,7 @@ GSL_TYPE(gsl_poly)* FUNCTION(gsl_poly,add)(const GSL_TYPE(gsl_poly) *a,
     longer = a;
   } else {
     c = FUNCTION(gsl_vector,alloc)(b->size);
-      longer = b;
+    longer = b;
   }
   n = GSL_MIN(a->size, b->size);
   for (i = 0; i < n; i++) {
@@ -1518,7 +1488,7 @@ static VALUE FUNCTION(rb_gsl_poly,coerce)(VALUE obj, VALUE other)
     vb = FUNCTION(gsl_vector,calloc)(1);
     FUNCTION(gsl_vector,set)(vb, 0, (BASE) NUM2DBL(other));
     return rb_ary_new3(2, Data_Wrap_Struct(CLASS_OF(obj), 0, FUNCTION(gsl_vector,free), vb),
-		       obj);
+                       obj);
     break;
   default:
     CHECK_VEC(other);
@@ -1545,10 +1515,10 @@ static VALUE FUNCTION(rb_gsl_poly,companion_matrix)(VALUE obj)
   size = p->size - 1;
   m = gsl_matrix_calloc(size, size);
   z = FUNCTION(gsl_vector,get)(p, size);
-  for (j = 0; j < size; j++) 
+  for (j = 0; j < size; j++)
     gsl_matrix_set(m, 0, size-j-1, -FUNCTION(gsl_vector,get)(p, j)/z);
   for (i = 1; i < size; i++) {
-   gsl_matrix_set(m, i, i-1, 1.0);
+    gsl_matrix_set(m, i, i-1, 1.0);
   }
   return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, m);
 }
@@ -1559,17 +1529,13 @@ static VALUE FUNCTION(rb_gsl_poly,info)(VALUE obj)
   char buf[256];
   Data_Get_Struct(obj, GSL_TYPE(gsl_poly), v);
   sprintf(buf, "Class:      %s\n", rb_class2name(CLASS_OF(obj)));
-#ifdef RUBY_1_9_LATER
   sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS_SUPER(CLASS_OF(obj))));
-#else
-  sprintf(buf, "%sSuperClass: %s\n", buf, rb_class2name(RCLASS(CLASS_OF(obj))->super));
-#endif
   sprintf(buf, "%sOrder:      %d\n", buf, (int) v->size-1);
   return rb_str_new2(buf);
 }
 
 #ifdef BASE_DOUBLE
-#include "rb_gsl_fit.h"
+#include "include/rb_gsl_fit.h"
 /* singleton */
 static VALUE rb_gsl_poly_fit(int argc, VALUE *argv, VALUE obj)
 {
@@ -1581,7 +1547,7 @@ static VALUE rb_gsl_poly_fit(int argc, VALUE *argv, VALUE obj)
   double chisq, val;
   int status, flag = 0;
   VALUE vc, vcov;
-  if (argc != 3 && argc != 4) 
+  if (argc != 3 && argc != 4)
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 3 or 4)", argc);
   x = &xx.vector;
   y = &yy.vector;
@@ -1622,7 +1588,7 @@ static VALUE rb_gsl_poly_wfit(int argc, VALUE *argv, VALUE obj)
   double chisq, val;
   int status, flag = 0;
   VALUE vc, vcov;
-  if (argc != 4 && argc != 5) 
+  if (argc != 4 && argc != 5)
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 4 or 5)", argc);
   Data_Get_Vector(argv[0], x);
   Data_Get_Vector(argv[1], w);
@@ -1655,17 +1621,11 @@ static VALUE rb_gsl_poly_wfit(int argc, VALUE *argv, VALUE obj)
 #endif
 
 #ifdef BASE_DOUBLE
-#ifdef GSL_1_13_LATER
 static VALUE rb_gsl_poly_eval_derivs_singleton(int argc, VALUE *argv, VALUE klass)
 {
   VALUE ary;
   gsl_vector *v = NULL, *v2 = NULL;
   size_t i, lenc, lenres;
-#ifdef HAVE_NARRAY_H
-  struct NARRAY *na;
-  double *ptr1, *ptr2;
-  int shape[1];
-#endif
 
   if (argc < 2) rb_raise(rb_eArgError, "Wrong number of arguments (%d for >= 2)", argc);
   if (rb_obj_is_kind_of(argv[0], rb_cArray)) {
@@ -1697,6 +1657,9 @@ static VALUE rb_gsl_poly_eval_derivs_singleton(int argc, VALUE *argv, VALUE klas
   }
 #ifdef HAVE_NARRAY_H
   if (NA_IsNArray(argv[0])) {
+    struct NARRAY *na;
+    double *ptr1, *ptr2;
+    int shape[1];
     GetNArray(argv[0], na);
     ptr1 = (double*) na->ptr;
     lenc = na->total;
@@ -1732,7 +1695,6 @@ static VALUE rb_gsl_poly_eval_derivs(int argc, VALUE *argv, VALUE obj)
   return Data_Wrap_Struct(cgsl_poly, 0, gsl_vector_free, v2);
 }
 #endif
-#endif
 
 void FUNCTION(Init_gsl_poly,init)(VALUE module)
 {
@@ -1743,78 +1705,78 @@ void FUNCTION(Init_gsl_poly,init)(VALUE module)
 
   cgsl_poly_workspace = rb_define_class_under(cgsl_poly, "Workspace", cGSL_Object);
   mgsl_poly_complex = rb_define_module_under(cgsl_poly, "Complex");
-  cgsl_poly_complex_workspace = rb_define_class_under(mgsl_poly_complex, 
-						      "Workspace", cGSL_Object);
-  rb_define_singleton_method(cgsl_poly_workspace, "alloc", 
-			     rb_gsl_poly_workspace_new, 1);
+  cgsl_poly_complex_workspace = rb_define_class_under(mgsl_poly_complex,
+                                                      "Workspace", cGSL_Object);
+  rb_define_singleton_method(cgsl_poly_workspace, "alloc",
+                             rb_gsl_poly_workspace_new, 1);
   rb_define_singleton_method(cgsl_poly_complex_workspace, "alloc",
-			     rb_gsl_poly_workspace_new, 1);
+                             rb_gsl_poly_workspace_new, 1);
 
-  rb_define_singleton_method(mgsl_poly_complex, "solve_quadratic", 
-			     FUNCTION(rb_gsl_poly,complex_solve_quadratic), -1);
+  rb_define_singleton_method(mgsl_poly_complex, "solve_quadratic",
+                             FUNCTION(rb_gsl_poly,complex_solve_quadratic), -1);
   rb_define_singleton_method(mgsl_poly_complex, "solve_cubic",
-			     FUNCTION(rb_gsl_poly,complex_solve_cubic), -1);
-#ifdef HAVE_POLY_SOLVE_QUARTIC
+                             FUNCTION(rb_gsl_poly,complex_solve_cubic), -1);
+#ifdef HAVE_GSL_POLY_SOLVE_QUARTIC
   rb_define_singleton_method(mgsl_poly_complex, "solve_quartic",
-			     FUNCTION(rb_gsl_poly,complex_solve_quartic), -1);
+                             FUNCTION(rb_gsl_poly,complex_solve_quartic), -1);
 #endif
 
   rb_define_singleton_method(mgsl_poly_complex, "solve",
-			     FUNCTION(rb_gsl_poly,complex_solve), -1);
-  rb_define_singleton_method(mgsl_poly_complex, "roots", 
-			     FUNCTION(rb_gsl_poly,complex_solve), -1);
+                             FUNCTION(rb_gsl_poly,complex_solve), -1);
+  rb_define_singleton_method(mgsl_poly_complex, "roots",
+                             FUNCTION(rb_gsl_poly,complex_solve), -1);
 #endif
 
-  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "solve_quadratic", 
-			     FUNCTION(rb_gsl_poly,solve_quadratic), -1);
-  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "solve_cubic", 
-			     FUNCTION(rb_gsl_poly,solve_cubic), -1);
+  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "solve_quadratic",
+                             FUNCTION(rb_gsl_poly,solve_quadratic), -1);
+  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "solve_cubic",
+                             FUNCTION(rb_gsl_poly,solve_cubic), -1);
 
-  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "complex_solve_quadratic", 
-			     FUNCTION(rb_gsl_poly,complex_solve_quadratic), -1);
-  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "complex_solve_cubic", 
-			     FUNCTION(rb_gsl_poly,complex_solve_cubic), -1);
-#ifdef HAVE_POLY_SOLVE_QUARTIC
+  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "complex_solve_quadratic",
+                             FUNCTION(rb_gsl_poly,complex_solve_quadratic), -1);
+  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "complex_solve_cubic",
+                             FUNCTION(rb_gsl_poly,complex_solve_cubic), -1);
+#ifdef HAVE_GSL_POLY_SOLVE_QUARTIC
   rb_define_singleton_method(GSL_TYPE(cgsl_poly), "solve_quartic",
-			     FUNCTION(rb_gsl_poly,solve_quartic), -1);
+                             FUNCTION(rb_gsl_poly,solve_quartic), -1);
 
   rb_define_singleton_method(GSL_TYPE(cgsl_poly), "complex_solve_quartic",
-			     FUNCTION(rb_gsl_poly,complex_solve_quartic), -1);
+                             FUNCTION(rb_gsl_poly,complex_solve_quartic), -1);
 #endif
   rb_define_singleton_method(GSL_TYPE(cgsl_poly), "complex_solve",
-			     FUNCTION(rb_gsl_poly,complex_solve), -1);
+                             FUNCTION(rb_gsl_poly,complex_solve), -1);
 
   rb_define_singleton_method(GSL_TYPE(cgsl_poly), "solve",
-			     FUNCTION(rb_gsl_poly,complex_solve), -1);
-  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "roots", 
-			     FUNCTION(rb_gsl_poly,complex_solve), -1);
+                             FUNCTION(rb_gsl_poly,complex_solve), -1);
+  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "roots",
+                             FUNCTION(rb_gsl_poly,complex_solve), -1);
 
-  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "eval", 
-			     FUNCTION(rb_gsl_poly,eval2), -1);
+  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "eval",
+                             FUNCTION(rb_gsl_poly,eval2), -1);
 
   rb_define_method(GSL_TYPE(cgsl_poly), "eval",
-		   FUNCTION(rb_gsl_poly,eval), 1);
+                   FUNCTION(rb_gsl_poly,eval), 1);
   rb_define_alias(GSL_TYPE(cgsl_poly), "at", "eval");
 
-  rb_define_method(GSL_TYPE(cgsl_poly), "solve_quadratic", 
-		   FUNCTION(rb_gsl_poly,solve_quadratic2), 0);
-  rb_define_method(GSL_TYPE(cgsl_poly), "complex_solve_quadratic", 
-		   FUNCTION(rb_gsl_poly,complex_solve_quadratic2), 0);
-
-  rb_define_method(GSL_TYPE(cgsl_poly), "solve_cubic", 
-		   FUNCTION(rb_gsl_poly,solve_cubic2), 0);
-  rb_define_method(GSL_TYPE(cgsl_poly), "complex_solve_cubic", 
-		   FUNCTION(rb_gsl_poly,complex_solve_cubic2), 0);
-
-#ifdef HAVE_POLY_SOLVE_QUARTIC
-  rb_define_method(GSL_TYPE(cgsl_poly), "solve_quartic", 
-		   FUNCTION(rb_gsl_poly,solve_quartic2), 0);
-  rb_define_method(GSL_TYPE(cgsl_poly), "complex_solve_quartic", 
-		   FUNCTION(rb_gsl_poly,complex_solve_quartic2), 0);
+  rb_define_method(GSL_TYPE(cgsl_poly), "solve_quadratic",
+                   FUNCTION(rb_gsl_poly,solve_quadratic2), 0);
+  rb_define_method(GSL_TYPE(cgsl_poly), "complex_solve_quadratic",
+                   FUNCTION(rb_gsl_poly,complex_solve_quadratic2), 0);
+
+  rb_define_method(GSL_TYPE(cgsl_poly), "solve_cubic",
+                   FUNCTION(rb_gsl_poly,solve_cubic2), 0);
+  rb_define_method(GSL_TYPE(cgsl_poly), "complex_solve_cubic",
+                   FUNCTION(rb_gsl_poly,complex_solve_cubic2), 0);
+
+#ifdef HAVE_GSL_POLY_SOLVE_QUARTIC
+  rb_define_method(GSL_TYPE(cgsl_poly), "solve_quartic",
+                   FUNCTION(rb_gsl_poly,solve_quartic2), 0);
+  rb_define_method(GSL_TYPE(cgsl_poly), "complex_solve_quartic",
+                   FUNCTION(rb_gsl_poly,complex_solve_quartic2), 0);
 #endif
 
-  rb_define_method(GSL_TYPE(cgsl_poly), "complex_solve", 
-		   FUNCTION(rb_gsl_poly,complex_solve2), -1);
+  rb_define_method(GSL_TYPE(cgsl_poly), "complex_solve",
+                   FUNCTION(rb_gsl_poly,complex_solve2), -1);
   rb_define_alias(GSL_TYPE(cgsl_poly), "solve", "complex_solve");
   rb_define_alias(GSL_TYPE(cgsl_poly), "roots", "complex_solve");
 
@@ -1825,18 +1787,14 @@ void FUNCTION(Init_gsl_poly,init)(VALUE module)
 #ifdef BASE_DOUBLE
   //  rb_define_singleton_method(cgsl_poly, "eval", rb_gsl_poly_eval_singleton, 2);
   rb_define_method(cgsl_poly, "to_i", rb_gsl_poly_to_i, 0);
-#ifdef GSL_1_11_LATER
   rb_define_singleton_method(cgsl_poly, "complex_eval", rb_gsl_poly_eval_singleton, 2);
   rb_define_method(cgsl_vector_complex, "eval", rb_gsl_complex_poly_complex_eval, 1);
-#endif
-#ifdef GSL_1_1_LATER
   cgsl_poly_dd = rb_define_class_under(cgsl_poly, "DividedDifference", cgsl_poly);
   cgsl_poly_taylor = rb_define_class_under(cgsl_poly, "Taylor", cgsl_poly);
   rb_define_singleton_method(cgsl_poly, "dd_init", rb_gsl_poly_dd_init, 2);
 
   rb_define_method(cgsl_poly_dd, "eval",rb_gsl_poly_dd_eval, 2);
   rb_define_method(cgsl_poly_dd, "taylor", rb_gsl_poly_dd_taylor, -1);
-#endif
 #endif
 
   rb_define_method(GSL_TYPE(cgsl_poly), "order", FUNCTION(rb_gsl_poly,order), 0);
@@ -1845,15 +1803,15 @@ void FUNCTION(Init_gsl_poly,init)(VALUE module)
   rb_define_method(GSL_TYPE(cgsl_poly), "conv", FUNCTION(rb_gsl_poly,conv), 1);
   rb_define_alias(GSL_TYPE(cgsl_poly), "*", "conv");
   rb_define_singleton_method(GSL_TYPE(cgsl_poly), "conv",
-			     FUNCTION(rb_gsl_poly,conv2), 2);
+                             FUNCTION(rb_gsl_poly,conv2), 2);
 
   rb_define_method(GSL_TYPE(cgsl_poly), "deconv",
-		   FUNCTION(rb_gsl_poly,deconv), 1);
+                   FUNCTION(rb_gsl_poly,deconv), 1);
   rb_define_singleton_method(GSL_TYPE(cgsl_poly), "deconv",
-			     FUNCTION(rb_gsl_poly,deconv2), 2);
+                             FUNCTION(rb_gsl_poly,deconv2), 2);
 
-  rb_define_method(GSL_TYPE(cgsl_poly), "reduce", 
-		   FUNCTION(rb_gsl_poly,reduce), 1);
+  rb_define_method(GSL_TYPE(cgsl_poly), "reduce",
+                   FUNCTION(rb_gsl_poly,reduce), 1);
   rb_define_method(GSL_TYPE(cgsl_poly), "deriv", FUNCTION(rb_gsl_poly,deriv), 1);
   rb_define_method(GSL_TYPE(cgsl_poly), "integ", FUNCTION(rb_gsl_poly,integ), 1);
 
@@ -1867,29 +1825,27 @@ void FUNCTION(Init_gsl_poly,init)(VALUE module)
   rb_define_method(GSL_TYPE(cgsl_poly), "-@", FUNCTION(rb_gsl_poly,uminus), 0);
   rb_define_method(GSL_TYPE(cgsl_poly), "+@", FUNCTION(rb_gsl_poly,uplus), 0);
 
-  rb_define_method(GSL_TYPE(cgsl_poly), "coerce", 
-		   FUNCTION(rb_gsl_poly,coerce), 1);
+  rb_define_method(GSL_TYPE(cgsl_poly), "coerce",
+                   FUNCTION(rb_gsl_poly,coerce), 1);
   rb_define_method(GSL_TYPE(cgsl_poly), "to_gv", FUNCTION(rb_gsl_poly,to_gv), 0);
   rb_define_alias(GSL_TYPE(cgsl_poly), "to_v", "to_gv");
 
-  rb_define_method(GSL_TYPE(cgsl_poly), "companion_matrix", 
-		   FUNCTION(rb_gsl_poly,companion_matrix), 0);
+  rb_define_method(GSL_TYPE(cgsl_poly), "companion_matrix",
+                   FUNCTION(rb_gsl_poly,companion_matrix), 0);
   rb_define_alias(GSL_TYPE(cgsl_poly), "compan", "companion_matrix");
 
   /*****/
-  rb_define_method(GSL_TYPE(cgsl_poly), "info", 
-		   FUNCTION(rb_gsl_poly,info), 0);
+  rb_define_method(GSL_TYPE(cgsl_poly), "info",
+                   FUNCTION(rb_gsl_poly,info), 0);
 
 #ifdef BASE_DOUBLE
-  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "fit", 
-		   FUNCTION(rb_gsl_poly,fit), -1);
-  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "wfit", 
-		   FUNCTION(rb_gsl_poly,wfit), -1);
+  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "fit",
+                             FUNCTION(rb_gsl_poly,fit), -1);
+  rb_define_singleton_method(GSL_TYPE(cgsl_poly), "wfit",
+                             FUNCTION(rb_gsl_poly,wfit), -1);
 
-#ifdef GSL_1_13_LATER
   rb_define_singleton_method(cgsl_poly, "eval_derivs", rb_gsl_poly_eval_derivs_singleton, -1);
   rb_define_method(cgsl_vector, "eval_derivs", rb_gsl_poly_eval_derivs, -1);
-#endif
 
 #endif
 }