gsl 1.15.3 → 1.16.0.6

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

@@ -8,16 +8,12 @@
   This library is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY.
 */
-#include "rb_gsl_config.h"
-#ifdef GSL_1_4_9_LATER
-#include "rb_gsl_common.h"
-#include "rb_gsl_function.h"
+
+#include "include/rb_gsl_common.h"
+#include "include/rb_gsl_function.h"
 #include <gsl/gsl_math.h>
 #include <gsl/gsl_deriv.h>
 #define RB_GSL_DERIV_H_DEFAULT (1e-8)
-#ifdef HAVE_NARRAY_H
-#include "narray.h"
-#endif
 
 static int get_func2(int argc, VALUE *argv, VALUE obj, VALUE *ff, VALUE *xx, VALUE *hh)
 {
@@ -62,10 +58,10 @@ static int get_func2(int argc, VALUE *argv, VALUE obj, VALUE *ff, VALUE *xx, VAL
 #undef RB_GSL_DERIV_H_DEFAULT
 #endif
 
-static VALUE rb_gsl_deriv_eval(VALUE obj, VALUE xx, VALUE hh, 
-			       int (*deriv)(const gsl_function *, 
-					    double, double,
-					    double *, double *))
+static VALUE rb_gsl_deriv_eval(VALUE obj, VALUE xx, VALUE hh,
+                               int (*deriv)(const gsl_function *,
+                                            double, double,
+                                            double *, double *))
 {
   gsl_function *f = NULL;
   double result, abserr, h;
@@ -74,11 +70,6 @@ static VALUE rb_gsl_deriv_eval(VALUE obj, VALUE xx, VALUE hh,
   gsl_matrix *m = NULL, *mnew = NULL, *merr = NULL;
   size_t n, i, j;
   int status;
-#ifdef HAVE_NARRAY_H
-  struct NARRAY *na;
-  double *ptr1, *ptr2, *ptr3;
-  VALUE ary2, ary3;
-#endif
   Need_Float(hh);
   Data_Get_Struct(obj, gsl_function, f);
   h = NUM2DBL(hh);
@@ -107,6 +98,9 @@ static VALUE rb_gsl_deriv_eval(VALUE obj, VALUE xx, VALUE hh,
   default:
 #ifdef HAVE_NARRAY_H
     if (NA_IsNArray(xx)) {
+      struct NARRAY *na;
+      double *ptr1, *ptr2, *ptr3;
+      VALUE ary2, ary3;
       GetNArray(xx, na);
       n = na->total;
       ptr1 = (double*) na->ptr;
@@ -115,9 +109,9 @@ static VALUE rb_gsl_deriv_eval(VALUE obj, VALUE xx, VALUE hh,
       ptr2 = NA_PTR_TYPE(ary2, double*);
       ptr3 = NA_PTR_TYPE(ary3, double*);
       for (i = 0; i < n; i++) {
-	(*deriv)(f, ptr1[i], h, &result, &abserr);	
-	ptr2[i] = result;
-	ptr3[i] = abserr;
+        (*deriv)(f, ptr1[i], h, &result, &abserr);
+        ptr2[i] = result;
+        ptr3[i] = abserr;
       }
       return rb_ary_new3(2, ary2, ary3);
     }
@@ -127,27 +121,27 @@ static VALUE rb_gsl_deriv_eval(VALUE obj, VALUE xx, VALUE hh,
       vnew = gsl_vector_alloc(v->size);
       verr = gsl_vector_alloc(v->size);
       for (i = 0; i < v->size; i++) {
-	(*deriv)(f, gsl_vector_get(v, i), h, &result, &abserr);	
-	gsl_vector_set(vnew, i, result);
-	gsl_vector_set(verr, i, abserr);
+        (*deriv)(f, gsl_vector_get(v, i), h, &result, &abserr);
+        gsl_vector_set(vnew, i, result);
+        gsl_vector_set(verr, i, abserr);
       }
       return rb_ary_new3(2,
-			 Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew),
-			 Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, verr));
+                         Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew),
+                         Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, verr));
     } else if (MATRIX_P(xx)) {
       Data_Get_Struct(xx, gsl_matrix, m);
       mnew = gsl_matrix_alloc(m->size1, m->size2);
       merr = gsl_matrix_alloc(m->size1, m->size2);
       for (i = 0; i < m->size1; i++) {
-	for (j = 0; j < m->size2; j++) {
-	  (*deriv)(f, gsl_matrix_get(m, i, j), h, &result, &abserr);	
-	  gsl_matrix_set(mnew, i, j, result);
-	  gsl_matrix_set(merr, i, j, abserr);
-	}
+        for (j = 0; j < m->size2; j++) {
+          (*deriv)(f, gsl_matrix_get(m, i, j), h, &result, &abserr);
+          gsl_matrix_set(mnew, i, j, result);
+          gsl_matrix_set(merr, i, j, abserr);
+        }
       }
       return rb_ary_new3(2,
-			 Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew),
-			 Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, merr));
+                         Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew),
+                         Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, merr));
     } else {
       rb_raise(rb_eTypeError, "wrong argument type");
     }
@@ -191,5 +185,3 @@ void Init_gsl_deriv(VALUE module)
   rb_define_singleton_method(mgsl_deriv, "forward", rb_gsl_deriv_forward, -1);
   rb_define_singleton_method(mgsl_deriv, "backward", rb_gsl_deriv_backward, -1);
 }
-
-#endif

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

@@ -9,13 +9,10 @@
   WITHOUT ANY WARRANTY.
 */
 
-#include "rb_gsl.h"
-#include "rb_gsl_array.h"
-#include "rb_gsl_common.h"
+#include "include/rb_gsl.h"
+#include "include/rb_gsl_array.h"
+#include "include/rb_gsl_common.h"
 #include <gsl/gsl_dht.h>
-#ifdef HAVE_NARRAY_H
-#include "narray.h"
-#endif
 
 static VALUE rb_gsl_dht_alloc(int argc, VALUE *argv, VALUE klass)
 {
@@ -29,7 +26,7 @@ static VALUE rb_gsl_dht_alloc(int argc, VALUE *argv, VALUE klass)
     CHECK_FIXNUM(argv[0]);
     Need_Float(argv[1]); Need_Float(argv[2]);
     t = gsl_dht_new(FIX2INT(argv[0]), NUM2DBL(argv[1]), NUM2DBL(argv[2]));
-   break;
+    break;
   default:
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 3)", argc);
     break;
@@ -52,9 +49,6 @@ static VALUE rb_gsl_dht_apply(int argc, VALUE *argv, VALUE obj)
   double *ptr1, *ptr2;
   gsl_vector *vin, *vout;
   size_t size, stride;
-#ifdef HAVE_NARRAY_H
-  struct NARRAY *na;
-#endif
   VALUE ary;
   switch (argc) {
   case 2:
@@ -73,6 +67,7 @@ static VALUE rb_gsl_dht_apply(int argc, VALUE *argv, VALUE obj)
       ary = Data_Wrap_Struct(VECTOR_ROW_COL(argv[0]), 0, gsl_vector_free, vout);
 #ifdef HAVE_NARRAY_H
     } else if (NA_IsNArray(argv[0])) {
+      struct NARRAY *na;
       GetNArray(argv[0], na);
       ptr1 = (double*)na->ptr;
       ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(argv[0]));
@@ -80,7 +75,7 @@ static VALUE rb_gsl_dht_apply(int argc, VALUE *argv, VALUE obj)
 #endif
     } else {
       rb_raise(rb_eTypeError, "wrong argument type %s (Vector expected)",
-	       rb_class2name(CLASS_OF(argv[0])));
+               rb_class2name(CLASS_OF(argv[0])));
     }
     gsl_dht_apply(t, ptr1, ptr2);
     return ary;
@@ -92,8 +87,8 @@ static VALUE rb_gsl_dht_apply(int argc, VALUE *argv, VALUE obj)
   return Qnil; /* never reach here */
 }
 
-static VALUE rb_gsl_dht_xk_sample(VALUE obj, VALUE n, 
-			       double (*sample)(const gsl_dht*, int))
+static VALUE rb_gsl_dht_xk_sample(VALUE obj, VALUE n,
+                                  double (*sample)(const gsl_dht*, int))
 {
   gsl_dht *t = NULL;
   gsl_vector_int *vi;
@@ -102,11 +97,6 @@ static VALUE rb_gsl_dht_xk_sample(VALUE obj, VALUE n,
   int nn;
   VALUE ary;
   double val;
-#ifdef HAVE_NARRAY_H
-  struct NARRAY *na;
-  int *ptr;
-  double *ptr2;
-#endif
   Data_Get_Struct(obj, gsl_dht, t);
   if (CLASS_OF(n) == rb_cRange) n = rb_gsl_range2ary(n);
   switch (TYPE(n)) {
@@ -129,28 +119,30 @@ static VALUE rb_gsl_dht_xk_sample(VALUE obj, VALUE n,
       Data_Get_Struct(n, gsl_vector_int, vi);
       v = gsl_vector_alloc(vi->size);
       for (i = 0; i < v->size; i++) {
-	nn = gsl_vector_int_get(vi, i);
-	val = (*sample)(t, nn);
-	gsl_vector_set(v, i, val);
+        nn = gsl_vector_int_get(vi, i);
+        val = (*sample)(t, nn);
+        gsl_vector_set(v, i, val);
       }
       return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v);
 #ifdef HAVE_NARRAY_H
     } else if (NA_IsNArray(n)) {
+      struct NARRAY *na;
+      int *ptr;
+      double *ptr2;
       GetNArray(n, na);
       ptr = (int*) na->ptr;
       size = na->total;
       ary = na_make_object(NA_DFLOAT, na->rank, na->shape, cNArray);
       ptr2 = NA_PTR_TYPE(ary, double*);
       for (i = 0; i < size; i++) {
-	ptr2[i] = (*sample)(t, ptr[i]);	
+        ptr2[i] = (*sample)(t, ptr[i]);
       }
       return ary;
 #endif
     } else {
       rb_raise(rb_eTypeError, "wrong argument type %s (Vector::Int expected)",
-	       rb_class2name(CLASS_OF(n)));
+               rb_class2name(CLASS_OF(n)));
     }
-
   }
   return Qnil;
 }
@@ -204,8 +196,8 @@ static VALUE rb_gsl_dht_sample(int argc, VALUE *argv, VALUE obj)
     mm = gsl_matrix_alloc(t->size, t->size);
     for (n = 0; n < t->size; n++) {
       for (m = 0; m < t->size; m++) {
-	val =  t->j[n+1]*gsl_dht_x_sample(t, m)/t->xmax;
-	gsl_matrix_set(mm, n, m, val);
+        val = t->j[n+1]*gsl_dht_x_sample(t, m)/t->xmax;
+        gsl_matrix_set(mm, n, m, val);
       }
     }
     return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mm);
@@ -235,8 +227,8 @@ static VALUE rb_gsl_dht_num(int argc, VALUE *argv, VALUE obj)
     mm = gsl_matrix_alloc(t->size, t->size);
     for (n = 0; n < t->size; n++) {
       for (m = 0; m < t->size; m++) {
-	val = gsl_sf_bessel_Jnu(t->nu, t->j[n+1]*gsl_dht_x_sample(t, m)/t->xmax);
-	gsl_matrix_set(mm, n, m, val);
+        val = gsl_sf_bessel_Jnu(t->nu, t->j[n+1]*gsl_dht_x_sample(t, m)/t->xmax);
+        gsl_matrix_set(mm, n, m, val);
       }
     }
     return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mm);
@@ -312,9 +304,9 @@ static VALUE rb_gsl_dht_coef(int argc, VALUE *argv, VALUE obj)
     mm = gsl_matrix_alloc(t->size, t->size);
     for (n = 0; n < t->size; n++) {
       for (m = 0; m < t->size; m++) {
-	val = gsl_sf_bessel_Jnu(t->nu, t->j[n+1]*gsl_dht_x_sample(t, m)/t->xmax);
-	val *= (2.0/t->xmax/t->xmax)/t->J2[m+1];
-	gsl_matrix_set(mm, n, m, val);
+        val = gsl_sf_bessel_Jnu(t->nu, t->j[n+1]*gsl_dht_x_sample(t, m)/t->xmax);
+        val *= (2.0/t->xmax/t->xmax)/t->J2[m+1];
+        gsl_matrix_set(mm, n, m, val);
       }
     }
     return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mm);

data/ext/{diff.c → gsl_native/diff.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_common.h"
-#include "rb_gsl_function.h"
+
+#include "include/rb_gsl_common.h"
+#include "include/rb_gsl_function.h"
 #include <gsl/gsl_math.h>
 #include <gsl/gsl_diff.h>
 
@@ -18,19 +18,19 @@ static int get_func(int argc, VALUE *argv, VALUE obj, VALUE *ff, VALUE *xx);
 
 static int get_func(int argc, VALUE *argv, VALUE obj, VALUE *ff, VALUE *xx)
 {
-   switch (TYPE(obj)) {
+  switch (TYPE(obj)) {
   case T_MODULE:
   case T_CLASS:
   case T_OBJECT:
     if (argc != 2) rb_raise(rb_eArgError, "wrong number of arguments (%d for 2)",
-			    argc);
+                            argc);
     CHECK_FUNCTION(argv[0]);
     *ff = argv[0];
     *xx = argv[1];
     break;
   default:
     if (argc != 1) rb_raise(rb_eArgError, "wrong number of arguments (%d for 1)",
-			    argc);
+                            argc);
     *ff = obj;
     *xx = argv[0];
     break;
@@ -39,7 +39,7 @@ static int get_func(int argc, VALUE *argv, VALUE obj, VALUE *ff, VALUE *xx)
 }
 
 static VALUE rb_gsl_diff_eval(VALUE obj, VALUE xx,
-			      int (*diff)(const gsl_function *, double, double *, double *))
+                              int (*diff)(const gsl_function *, double, double *, double *))
 {
   gsl_function *f = NULL;
   double result, abserr;
@@ -48,11 +48,6 @@ static VALUE rb_gsl_diff_eval(VALUE obj, VALUE xx,
   gsl_matrix *m = NULL, *mnew = NULL, *merr = NULL;
   size_t n, i, j;
   int status;
-#ifdef HAVE_NARRAY_H
-  double *ptr1, *ptr2, *ptr3;
-  struct NARRAY *na;
-  VALUE ary2, ary3;
-#endif
   Data_Get_Struct(obj, gsl_function, f);
   if (CLASS_OF(xx) == rb_cRange) xx = rb_gsl_range2ary(xx);
   switch (TYPE(xx)) {
@@ -79,6 +74,9 @@ static VALUE rb_gsl_diff_eval(VALUE obj, VALUE xx,
   default:
 #ifdef HAVE_NARRAY_H
     if (NA_IsNArray(xx)) {
+      double *ptr1, *ptr2, *ptr3;
+      struct NARRAY *na;
+      VALUE ary2, ary3;
       GetNArray(xx, na);
       n = na->total;
       ptr1 = (double*) na->ptr;
@@ -87,9 +85,9 @@ static VALUE rb_gsl_diff_eval(VALUE obj, VALUE xx,
       ptr2 = NA_PTR_TYPE(ary2, double*);
       ptr3 = NA_PTR_TYPE(ary3, double*);
       for (i = 0; i < n; i++) {
-	(*diff)(f, ptr1[i], &result, &abserr);	
-	ptr2[i] = result;
-	ptr3[i] = abserr;
+        (*diff)(f, ptr1[i], &result, &abserr);
+        ptr2[i] = result;
+        ptr3[i] = abserr;
       }
       return rb_ary_new3(2, ary2, ary3);
     }
@@ -99,27 +97,27 @@ static VALUE rb_gsl_diff_eval(VALUE obj, VALUE xx,
       vnew = gsl_vector_alloc(v->size);
       verr = gsl_vector_alloc(v->size);
       for (i = 0; i < v->size; i++) {
-	(*diff)(f, gsl_vector_get(v, i), &result, &abserr);	
-	gsl_vector_set(vnew, i, result);
-	gsl_vector_set(verr, i, abserr);
+        (*diff)(f, gsl_vector_get(v, i), &result, &abserr);
+        gsl_vector_set(vnew, i, result);
+        gsl_vector_set(verr, i, abserr);
       }
       return rb_ary_new3(2,
-			 Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew),
-			 Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, verr));
+                         Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew),
+                         Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, verr));
     } else if (MATRIX_P(xx)) {
       Data_Get_Struct(xx, gsl_matrix, m);
       mnew = gsl_matrix_alloc(m->size1, m->size2);
       merr = gsl_matrix_alloc(m->size1, m->size2);
       for (i = 0; i < m->size1; i++) {
-	for (j = 0; j < m->size2; j++) {
-	  (*diff)(f, gsl_matrix_get(m, i, j), &result, &abserr);	
-	  gsl_matrix_set(mnew, i, j, result);
-	  gsl_matrix_set(merr, i, j, abserr);
-	}
+        for (j = 0; j < m->size2; j++) {
+          (*diff)(f, gsl_matrix_get(m, i, j), &result, &abserr);
+          gsl_matrix_set(mnew, i, j, result);
+          gsl_matrix_set(merr, i, j, abserr);
+        }
       }
-      return rb_ary_new3(2, 
-			 Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew),
-			 Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, merr));
+      return rb_ary_new3(2,
+                         Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew),
+                         Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, merr));
     } else {
       rb_raise(rb_eTypeError, "wrong argument type");
     }

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

@@ -1,4 +1,4 @@
-#include "rb_gsl_dirac.h"
+#include "include/rb_gsl_dirac.h"
 
 static VALUE cgsl_matrix_complex_const;
 static VALUE cPauli;
@@ -43,8 +43,8 @@ static VALUE rb_dirac_commute(VALUE obj, VALUE mm1, VALUE mm2)
   gsl_matrix_complex_mul(mnew2, m2, m1);
   gsl_matrix_complex_sub(mnew1, mnew2);
   gsl_matrix_complex_free(mnew2);
-  return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, 
-			  mnew1);
+  return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free,
+                          mnew1);
 }
 
 static VALUE rb_dirac_anticommute(VALUE obj, VALUE mm1, VALUE mm2)
@@ -61,8 +61,8 @@ static VALUE rb_dirac_anticommute(VALUE obj, VALUE mm1, VALUE mm2)
   gsl_matrix_complex_mul(mnew2, m2, m1);
   gsl_matrix_complex_add(mnew1, mnew2);
   gsl_matrix_complex_free(mnew2);
-  return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free, 
-			  mnew1);
+  return Data_Wrap_Struct(cgsl_matrix_complex, 0, gsl_matrix_complex_free,
+                          mnew1);
 }
 
 static void Init_gsl_dirac_common(VALUE module)
@@ -72,7 +72,7 @@ static void Init_gsl_dirac_common(VALUE module)
   rb_define_singleton_method(module, "anticommute", rb_dirac_anticommute, 2);
 
   cgsl_matrix_complex_const = rb_define_class_under(module, "Const",
-						    cgsl_matrix_complex);
+                                                    cgsl_matrix_complex);
   rb_define_method(cgsl_matrix_complex_const, "set", rb_dirac_refuse_set, -1);
 
   cPauli = rb_define_class_under(module, "Pauli", cgsl_matrix_complex_const);
@@ -88,16 +88,16 @@ static void define_eye(VALUE module)
   gsl_complex z;
 
   Eye2 = gsl_matrix_complex_calloc(2, 2);
-  VEye2 = Data_Wrap_Struct(cgsl_matrix_complex_const, 0, 
-			   gsl_matrix_complex_free, Eye2);
+  VEye2 = Data_Wrap_Struct(cgsl_matrix_complex_const, 0,
+                           gsl_matrix_complex_free, Eye2);
   z.dat[0] = 1; z.dat[1] = 0;
   gsl_matrix_complex_set(Eye2, 0, 0, z);
   gsl_matrix_complex_set(Eye2, 1, 1, z);
   rb_define_const(module, "Eye2", VEye2);
 
   Eye4 = gsl_matrix_complex_calloc(4, 4);
-  VEye4 = Data_Wrap_Struct(cgsl_matrix_complex_const, 0, 
-			   gsl_matrix_complex_free, Eye4);
+  VEye4 = Data_Wrap_Struct(cgsl_matrix_complex_const, 0,
+                           gsl_matrix_complex_free, Eye4);
   z.dat[0] = 1; z.dat[1] = 0;
   gsl_matrix_complex_set(Eye4, 0, 0, z);
   gsl_matrix_complex_set(Eye4, 1, 1, z);
@@ -106,16 +106,16 @@ static void define_eye(VALUE module)
   rb_define_const(module, "Eye4", VEye4);
 
   IEye2 = gsl_matrix_complex_calloc(2, 2);
-  VIEye2 = Data_Wrap_Struct(cgsl_matrix_complex_const, 0, 
-			    gsl_matrix_complex_free, IEye2);
+  VIEye2 = Data_Wrap_Struct(cgsl_matrix_complex_const, 0,
+                            gsl_matrix_complex_free, IEye2);
   z.dat[0] = 0; z.dat[1] = 1;
   gsl_matrix_complex_set(IEye2, 0, 0, z);
   gsl_matrix_complex_set(IEye2, 1, 1, z);
   rb_define_const(module, "IEye2", VIEye2);
 
   IEye4 = gsl_matrix_complex_calloc(4, 4);
-  VIEye4 = Data_Wrap_Struct(cgsl_matrix_complex_const, 0, 
-			   gsl_matrix_complex_free, IEye4);
+  VIEye4 = Data_Wrap_Struct(cgsl_matrix_complex_const, 0,
+                            gsl_matrix_complex_free, IEye4);
   gsl_matrix_complex_set(IEye4, 0, 0, z);
   gsl_matrix_complex_set(IEye4, 1, 1, z);
   gsl_matrix_complex_set(IEye4, 2, 2, z);
@@ -128,16 +128,16 @@ static void define_pauli(VALUE module)
   gsl_complex z;
 
   Pauli[0] = gsl_matrix_complex_calloc(2, 2);
-  VPauli[0] = Data_Wrap_Struct(cPauli, 0, 
-			   gsl_matrix_complex_free, Pauli[0]);
+  VPauli[0] = Data_Wrap_Struct(cPauli, 0,
+                               gsl_matrix_complex_free, Pauli[0]);
   z.dat[0] = 1; z.dat[1] = 0;
   gsl_matrix_complex_set(Pauli[0], 0, 1, z);
   gsl_matrix_complex_set(Pauli[0], 1, 0, z);
   rb_define_const(module, "Pauli1", VPauli[0]);
 
   Pauli[1] = gsl_matrix_complex_calloc(2, 2);
-  VPauli[1] = Data_Wrap_Struct(cPauli, 0, 
-			   gsl_matrix_complex_free, Pauli[1]);
+  VPauli[1] = Data_Wrap_Struct(cPauli, 0,
+                               gsl_matrix_complex_free, Pauli[1]);
   z.dat[0] = 0; z.dat[1] = -1;
   gsl_matrix_complex_set(Pauli[1], 0, 1, z);
   z.dat[0] = 0; z.dat[1] = 1;
@@ -145,8 +145,8 @@ static void define_pauli(VALUE module)
   rb_define_const(module, "Pauli2", VPauli[1]);
 
   Pauli[2] = gsl_matrix_complex_calloc(2, 2);
-  VPauli[2] = Data_Wrap_Struct(cPauli, 0, 
-			   gsl_matrix_complex_free, Pauli[2]);
+  VPauli[2] = Data_Wrap_Struct(cPauli, 0,
+                               gsl_matrix_complex_free, Pauli[2]);
   z.dat[0] = 1; z.dat[1] = 0;
   gsl_matrix_complex_set(Pauli[2], 0, 0, z);
   z.dat[0] = -1; z.dat[1] = 0;
@@ -159,8 +159,8 @@ static void define_beta(VALUE module)
   gsl_complex z;
 
   Beta = gsl_matrix_complex_calloc(4, 4);
-  VGamma[0] = Data_Wrap_Struct(cGamma, 0, 
-			   gsl_matrix_complex_free, Beta);
+  VGamma[0] = Data_Wrap_Struct(cGamma, 0,
+                               gsl_matrix_complex_free, Beta);
   z.dat[0] = 1; z.dat[1] = 0;
   gsl_matrix_complex_set(Beta, 0, 0, z);
   gsl_matrix_complex_set(Beta, 1, 1, z);
@@ -180,22 +180,21 @@ static void define_alpha(VALUE module)
 
     for (j = 2; j < 4; j++) {
       for (k = 0; k < 2; k++) {
-	gsl_matrix_complex_set(Alpha[i], j, k, 
-			       gsl_matrix_complex_get(Pauli[i], j-2, k));
+        gsl_matrix_complex_set(Alpha[i], j, k,
+                               gsl_matrix_complex_get(Pauli[i], j-2, k));
       }
     }
     for (j = 0; j < 2; j++) {
       for (k = 2; k < 4; k++) {
-	gsl_matrix_complex_set(Alpha[i], j, k, 
-			       gsl_matrix_complex_get(Pauli[i], j, k-2));
+        gsl_matrix_complex_set(Alpha[i], j, k,
+                               gsl_matrix_complex_get(Pauli[i], j, k-2));
       }
     }
-    VAlpha[i] = Data_Wrap_Struct(cAlpha, 0, 
-			    gsl_matrix_complex_free, Alpha[i]);
+    VAlpha[i] = Data_Wrap_Struct(cAlpha, 0,
+                                 gsl_matrix_complex_free, Alpha[i]);
     sprintf(name, "Alpha%d", (int) i+1);
     rb_define_const(module, name, VAlpha[i]);
   }
-  
 }
 
 static void define_gamma(VALUE module)
@@ -206,8 +205,8 @@ static void define_gamma(VALUE module)
   for (i = 1; i <= 3; i++) {
     Gamma[i] = gsl_matrix_complex_calloc(4, 4);
     gsl_matrix_complex_mul(Gamma[i], Beta, Alpha[i-1]);
-    VGamma[i] = Data_Wrap_Struct(cGamma, 0, 
-			    gsl_matrix_complex_free, Gamma[i]);
+    VGamma[i] = Data_Wrap_Struct(cGamma, 0,
+                                 gsl_matrix_complex_free, Gamma[i]);
     sprintf(name, "Gamma%d", (int) i);
     rb_define_const(module, name, VGamma[i]);
   }
@@ -217,8 +216,8 @@ static void define_gamma(VALUE module)
   gsl_matrix_complex_set(Gamma[4], 1, 3, z);
   gsl_matrix_complex_set(Gamma[4], 2, 0, z);
   gsl_matrix_complex_set(Gamma[4], 3, 1, z);
-  VGamma[4] = Data_Wrap_Struct(cGamma, 0, 
-			  gsl_matrix_complex_free, Gamma[4]);
+  VGamma[4] = Data_Wrap_Struct(cGamma, 0,
+                               gsl_matrix_complex_free, Gamma[4]);
   rb_define_const(module, "Gamma5", VGamma[4]);
 }
 
@@ -234,8 +233,8 @@ static void define_lambda(VALUE module)
   zmi.dat[0] = 0; zmi.dat[1] = -1;
   for (i = 0; i < 8; i++) {
     Lambda[i] = gsl_matrix_complex_calloc(3, 3);
-    VLambda[i] = Data_Wrap_Struct(cLambda, 0, 
-			    gsl_matrix_complex_free, Lambda[i]);
+    VLambda[i] = Data_Wrap_Struct(cLambda, 0,
+                                  gsl_matrix_complex_free, Lambda[i]);
     sprintf(name, "Lambda%d", (int) i+1);
     rb_define_const(module, name, VLambda[i]);
   }
@@ -332,17 +331,17 @@ static VALUE rb_Dirac_matrix_is_equal(int argc, VALUE *argv, VALUE obj)
 #define NUM 20
 static VALUE rb_Dirac_matrix_whoami(int argc, VALUE *argv, VALUE obj)
 {
-  VALUE array[NUM] = {VPauli[0], VPauli[1], VPauli[2], 
-		      VGamma[0], VGamma[1], VGamma[2], VGamma[3],
-		      VGamma[4], VEye2, VEye4, VIEye2, VIEye4,
-		      VLambda[0], VLambda[1], VLambda[2], VLambda[3],
-		      VLambda[4], VLambda[5], VLambda[6], VLambda[7]};
-
-  char *name[NUM] = {"Pauli1", "Pauli2", "Pauli3", 
-		     "Gamma0", "Gamma1", "Gamma2", "Gamma3", "Gamma5",
-		     "Eye2", "Eye4", "IEye2", "IEye4", "Lambda1", "Lambda2",
-		     "Lambda3", "Lambda4", "Lambda5", "Lambda6",
-		     "Lambda7", "Lambda8"};
+  VALUE array[NUM] = {VPauli[0], VPauli[1], VPauli[2],
+                      VGamma[0], VGamma[1], VGamma[2], VGamma[3],
+                      VGamma[4], VEye2, VEye4, VIEye2, VIEye4,
+                      VLambda[0], VLambda[1], VLambda[2], VLambda[3],
+                      VLambda[4], VLambda[5], VLambda[6], VLambda[7]};
+
+  const char *name[NUM] = {"Pauli1", "Pauli2", "Pauli3",
+                           "Gamma0", "Gamma1", "Gamma2", "Gamma3", "Gamma5",
+                           "Eye2", "Eye4", "IEye2", "IEye4", "Lambda1", "Lambda2",
+                           "Lambda3", "Lambda4", "Lambda5", "Lambda6",
+                           "Lambda7", "Lambda8"};
   gsl_matrix_complex *m1, *m2;
   VALUE vz;
   gsl_complex ztmp, *z;