rb-gsl 1.16.0.4 → 1.16.0.5

data/ext/{gsl → gsl_native}/sum.c

@@ -16,17 +16,17 @@ static VALUE rb_gsl_sum_accel(VALUE obj)
 {
   gsl_sum_levin_u_workspace *w = NULL;
   double sum, err, sum_plain, *ptr;
-  size_t terms_used, n, stride;  
+  size_t terms_used, n, stride;
   ptr = get_vector_ptr(obj, &stride, &n);
   w = gsl_sum_levin_u_alloc(n);
   gsl_sum_levin_u_accel(ptr, n, w, &sum, &err);
   sum_plain = w->sum_plain;
   terms_used = w->terms_used;
   gsl_sum_levin_u_free(w);
- return rb_ary_new3(4, rb_float_new(sum), rb_float_new(err), 
-		    rb_float_new(sum_plain), INT2FIX(terms_used));
+  return rb_ary_new3(4, rb_float_new(sum), rb_float_new(err),
+                     rb_float_new(sum_plain), INT2FIX(terms_used));
 }
- 
+
 static VALUE rb_gsl_utrunc_accel(VALUE obj)
 {
   gsl_sum_levin_utrunc_workspace *w = NULL;
@@ -38,8 +38,8 @@ static VALUE rb_gsl_utrunc_accel(VALUE obj)
   sum_plain = w->sum_plain;
   terms_used = w->terms_used;
   gsl_sum_levin_utrunc_free(w);
-  return rb_ary_new3(4, rb_float_new(sum), rb_float_new(err), 
-		     rb_float_new(sum_plain), INT2FIX(terms_used));
+  return rb_ary_new3(4, rb_float_new(sum), rb_float_new(err),
+                     rb_float_new(sum_plain), INT2FIX(terms_used));
 }
 
 static VALUE rb_gsl_sum_levin_u_new(VALUE klass, VALUE nn)
@@ -71,8 +71,8 @@ static VALUE rb_gsl_sum_levin_u_accel2(VALUE obj, VALUE vv)
   sum_plain = w->sum_plain;
   terms_used = w->terms_used;
   gsl_sum_levin_u_free(w);
-  return rb_ary_new3(4, rb_float_new(sum), rb_float_new(err), 
-		     rb_float_new(sum_plain), INT2FIX(terms_used));
+  return rb_ary_new3(4, rb_float_new(sum), rb_float_new(err),
+                     rb_float_new(sum_plain), INT2FIX(terms_used));
 }
 
 static VALUE rb_gsl_sum_levin_utrunc_accel2(VALUE obj, VALUE vv)
@@ -87,8 +87,8 @@ static VALUE rb_gsl_sum_levin_utrunc_accel2(VALUE obj, VALUE vv)
   sum_plain = w->sum_plain;
   terms_used = w->terms_used;
   gsl_sum_levin_utrunc_free(w);
-  return rb_ary_new3(4, rb_float_new(sum), rb_float_new(err), 
-		     rb_float_new(sum_plain), INT2FIX(terms_used));
+  return rb_ary_new3(4, rb_float_new(sum), rb_float_new(err),
+                     rb_float_new(sum_plain), INT2FIX(terms_used));
 }
 
 static VALUE rb_gsl_sum_levin_u_sum_plain(VALUE obj)
@@ -119,39 +119,39 @@ static VALUE rb_gsl_sum_levin_utrunc_terms_used(VALUE obj)
   return INT2FIX(w->terms_used);
 }
 
-void Init_gsl_sum(VALUE module) 
+void Init_gsl_sum(VALUE module)
 {
   VALUE mgsl_sum;
   VALUE cgsl_sum_levin_u, cgsl_sum_levin_utrunc;
 
   mgsl_sum = rb_define_module_under(module, "Sum");
-  cgsl_sum_levin_u = rb_define_class_under(mgsl_sum, 
-					   "Levin_u", cGSL_Object);
-  cgsl_sum_levin_utrunc = rb_define_class_under(mgsl_sum, 
-						"Levin_utrunc", cGSL_Object);
+  cgsl_sum_levin_u = rb_define_class_under(mgsl_sum,
+                                           "Levin_u", cGSL_Object);
+  cgsl_sum_levin_utrunc = rb_define_class_under(mgsl_sum,
+                                                "Levin_utrunc", cGSL_Object);
 
   rb_define_singleton_method(cgsl_sum_levin_u, "new", rb_gsl_sum_levin_u_new, 1);
   rb_define_singleton_method(cgsl_sum_levin_u, "alloc", rb_gsl_sum_levin_u_new, 1);
-  rb_define_singleton_method(cgsl_sum_levin_utrunc, "new", 
-			     rb_gsl_sum_levin_utrunc_new, 1);
-  rb_define_singleton_method(cgsl_sum_levin_utrunc, "alloc", 
-			     rb_gsl_sum_levin_utrunc_new, 1);
-  rb_define_singleton_method(cgsl_sum_levin_u, "accel", 
-			     rb_gsl_sum_levin_u_accel2, 1);
-
-  rb_define_singleton_method(cgsl_sum_levin_utrunc, "accel", 
-			     rb_gsl_sum_levin_utrunc_accel2, 1);
+  rb_define_singleton_method(cgsl_sum_levin_utrunc, "new",
+                             rb_gsl_sum_levin_utrunc_new, 1);
+  rb_define_singleton_method(cgsl_sum_levin_utrunc, "alloc",
+                             rb_gsl_sum_levin_utrunc_new, 1);
+  rb_define_singleton_method(cgsl_sum_levin_u, "accel",
+                             rb_gsl_sum_levin_u_accel2, 1);
+
+  rb_define_singleton_method(cgsl_sum_levin_utrunc, "accel",
+                             rb_gsl_sum_levin_utrunc_accel2, 1);
   rb_define_method(cgsl_sum_levin_u, "accel", rb_gsl_sum_levin_u_accel2, 1);
-  rb_define_method(cgsl_sum_levin_utrunc, "accel", 
-		   rb_gsl_sum_levin_utrunc_accel2, 1);
+  rb_define_method(cgsl_sum_levin_utrunc, "accel",
+                   rb_gsl_sum_levin_utrunc_accel2, 1);
 
   rb_define_method(cgsl_sum_levin_u, "sum_plain", rb_gsl_sum_levin_u_sum_plain, 0);
-  rb_define_method(cgsl_sum_levin_u, "terms_used", 
-		   rb_gsl_sum_levin_u_terms_used, 0);
-  rb_define_method(cgsl_sum_levin_utrunc, "sum_plain", 
-		   rb_gsl_sum_levin_utrunc_sum_plain, 0);
-  rb_define_method(cgsl_sum_levin_utrunc, "terms_used", 
-		   rb_gsl_sum_levin_utrunc_terms_used, 0);
+  rb_define_method(cgsl_sum_levin_u, "terms_used",
+                   rb_gsl_sum_levin_u_terms_used, 0);
+  rb_define_method(cgsl_sum_levin_utrunc, "sum_plain",
+                   rb_gsl_sum_levin_utrunc_sum_plain, 0);
+  rb_define_method(cgsl_sum_levin_utrunc, "terms_used",
+                   rb_gsl_sum_levin_utrunc_terms_used, 0);
   /***/
 
   rb_define_method(cgsl_vector, "accel_sum", rb_gsl_sum_accel, 0);

data/ext/{gsl → gsl_native}/tensor.c

@@ -18,19 +18,17 @@
 
 #include "include/rb_gsl_tensor.h"
 
-#ifdef HAVE_NARRAY_H
 #include "include/rb_gsl_with_narray.h"
-#endif
 
 #define BASE_DOUBLE
 #include "include/templates_on.h"
-#include "tensor_source.c"
+#include "tensor_source.h"
 #include "include/templates_off.h"
 #undef  BASE_DOUBLE
 
 #define BASE_INT
 #include "include/templates_on.h"
-#include "tensor_source.c"
+#include "tensor_source.h"
 #include "include/templates_off.h"
 #undef  BASE_INT
 

data/ext/{gsl/tensor_source.c → gsl_native/tensor_source.h}

@@ -38,26 +38,26 @@ VALUE cgsl_tensor_view, cgsl_tensor_int_view;
 #define MAT_P(x) MATRIX_INT_P(x)
 #endif
 
-GSL_TYPE(rbgsl_tensor)* FUNCTION(rbgsl_tensor,alloc)(const unsigned int rank, 
-						     const size_t dimension)
+GSL_TYPE(rbgsl_tensor)* FUNCTION(rbgsl_tensor,alloc)(const unsigned int rank,
+                                                     const size_t dimension)
 {
   GSL_TYPE(rbgsl_tensor) *t;
   t = ALLOC(GSL_TYPE(rbgsl_tensor));
   t->tensor = FUNCTION(tensor,alloc)(rank, dimension);
-  if (rank == 0) 
+  if (rank == 0)
     t->indices = gsl_permutation_alloc(1);
   else
     t->indices = gsl_permutation_alloc(rank);
   return t;
 }
 
-GSL_TYPE(rbgsl_tensor)* FUNCTION(rbgsl_tensor,calloc)(const unsigned int rank, 
-						      const size_t dimension)
+GSL_TYPE(rbgsl_tensor)* FUNCTION(rbgsl_tensor,calloc)(const unsigned int rank,
+                                                      const size_t dimension)
 {
   GSL_TYPE(rbgsl_tensor) *t;
   t = ALLOC(GSL_TYPE(rbgsl_tensor));
   t->tensor = FUNCTION(tensor,calloc)(rank, dimension);
-  if (rank == 0) 
+  if (rank == 0)
     t->indices = gsl_permutation_alloc(1);
   else
     t->indices = gsl_permutation_alloc(rank);
@@ -68,7 +68,7 @@ GSL_TYPE(rbgsl_tensor)* FUNCTION(rbgsl_tensor,copy)(const GSL_TYPE(rbgsl_tensor)
 {
   GSL_TYPE(rbgsl_tensor) *tnew;
   tnew = ALLOC(GSL_TYPE(rbgsl_tensor));
-  if (t->tensor->rank == 0) 
+  if (t->tensor->rank == 0)
     tnew->indices = gsl_permutation_alloc(1);
   else
     tnew->indices = gsl_permutation_alloc(t->tensor->rank);
@@ -80,14 +80,14 @@ void FUNCTION(rbgsl_tensor,free)(GSL_TYPE(rbgsl_tensor) *t)
 {
   gsl_permutation_free(t->indices);
   FUNCTION(tensor,free)(t->tensor);
-  free((GSL_TYPE(rbgsl_tensor) *) t);
+  free((GSL_TYPE(rbgsl_tensor) *)t);
 }
 
 void FUNCTION(rbgsl_tensor,free2)(GSL_TYPE(rbgsl_tensor) *t)
 {
   gsl_permutation_free(t->indices);
-  free((GSL_TYPE(tensor)*) t->tensor);
-  free((GSL_TYPE(rbgsl_tensor) *) t);
+  free((GSL_TYPE(tensor)*)t->tensor);
+  free((GSL_TYPE(rbgsl_tensor) *)t);
 }
 
 /* singleton methods */
@@ -104,7 +104,7 @@ static VALUE FUNCTION(rb_tensor,new)(int argc, VALUE *argv, VALUE klass)
     break;
   default:
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 2, rank and dimension)",
-	     argc);
+             argc);
     break;
   }
   return Data_Wrap_Struct(GSL_TYPE(cgsl_tensor), 0, FUNCTION(rbgsl_tensor,free), t);
@@ -175,8 +175,8 @@ static VALUE FUNCTION(rb_tensor,set_all)(VALUE obj, VALUE xx)
 }
 
 static void rb_tensor_get_indices_array(tensor_indices *v, VALUE ary);
-static void rbgsl_tensor_get_indices(int argc, VALUE *argv, tensor_indices *indices, 
-				     size_t *n);
+static void rbgsl_tensor_get_indices(int argc, VALUE *argv, tensor_indices *indices,
+                                     size_t *n);
 #ifdef BASE_DOUBLE
 static void rb_tensor_get_indices_array(tensor_indices *v, VALUE ary)
 {
@@ -187,8 +187,8 @@ static void rb_tensor_get_indices_array(tensor_indices *v, VALUE ary)
     v->data[i] = FIX2UINT(rb_ary_entry(ary, i));
 }
 
-static void rbgsl_tensor_get_indices(int argc, VALUE *argv, 
-				     tensor_indices *indices, size_t *n)
+static void rbgsl_tensor_get_indices(int argc, VALUE *argv,
+                                     tensor_indices *indices, size_t *n)
 {
   size_t i;
   for (i = 0; i < indices->size; i++) indices->data[i] = 0;
@@ -206,7 +206,7 @@ static void rbgsl_tensor_get_indices(int argc, VALUE *argv,
       break;
     default:
       rb_raise(rb_eTypeError, "wrong argument type %s (Array expected)",
-	       rb_class2name(CLASS_OF(argv[0])));
+               rb_class2name(CLASS_OF(argv[0])));
       break;
     }
     break;
@@ -222,13 +222,13 @@ static void rbgsl_tensor_get_indices(int argc, VALUE *argv,
 #endif
 
 size_t FUNCTION(tensor,position)(const size_t * indices,
-				     const GSL_TYPE(tensor) * t);
+                                 const GSL_TYPE(tensor) * t);
 static VALUE FUNCTION(rb_tensor,position)(int argc, VALUE *argv, VALUE obj)
 {
   GSL_TYPE(rbgsl_tensor) *t = NULL;
   size_t n, position;
-  Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t);  
-  rbgsl_tensor_get_indices(argc, argv, t->indices, &n);  
+  Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t);
+  rbgsl_tensor_get_indices(argc, argv, t->indices, &n);
   position = (size_t) FUNCTION(tensor,position)(t->indices->data,t->tensor);
   return INT2FIX(position);
 }
@@ -238,8 +238,8 @@ static VALUE FUNCTION(rb_tensor,get)(int argc, VALUE *argv, VALUE obj)
   GSL_TYPE(rbgsl_tensor) *t = NULL;
   BASE x;
   size_t n;
-  Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t);  
-  rbgsl_tensor_get_indices(argc, argv, t->indices, &n);  
+  Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t);
+  rbgsl_tensor_get_indices(argc, argv, t->indices, &n);
   if (n < t->tensor->rank) {
     return FUNCTION(rb_tensor,subtensor)(argc, argv, obj);
   } else {
@@ -254,9 +254,9 @@ static VALUE FUNCTION(rb_tensor,set)(int argc, VALUE *argv, VALUE obj)
   GSL_TYPE(rbgsl_tensor) *t = NULL;
   size_t n;
   BASE x;
-  if (argc < 2) 
+  if (argc < 2)
     rb_raise(rb_eArgError, "wrong number of arguments (%d for >= 2)", argc);
-  Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t);  
+  Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t);
   rbgsl_tensor_get_indices(argc-1, argv, t->indices, &n);
   x = NUMCONV(argv[argc-1]);
   FUNCTION(tensor,set)(t->tensor, t->indices->data, x);
@@ -292,7 +292,7 @@ static VALUE FUNCTION(rb_tensor,fprintf)(int argc, VALUE *argv, VALUE obj)
   GSL_TYPE(rbgsl_tensor) *h = NULL;
   FILE *fp = NULL;
   int status, flag = 0;
-  if (argc != 1 && argc != 2) 
+  if (argc != 1 && argc != 2)
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 1 or 2)", argc);
   Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), h);
   fp = rb_gsl_open_writefile(argv[0], &flag);
@@ -317,7 +317,7 @@ static VALUE FUNCTION(rb_tensor,printf)(int argc, VALUE *argv, VALUE obj)
   int status;
   Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), h);
   if (argc == 1) {
-    if (TYPE(argv[0]) != T_STRING) 
+    if (TYPE(argv[0]) != T_STRING)
       rb_raise(rb_eTypeError, "String expected");
     else
       status = FUNCTION(tensor,fprintf)(stdout, h->tensor, STR2CSTR(argv[0]));
@@ -344,7 +344,7 @@ static VALUE FUNCTION(rb_tensor,swap_indices)(VALUE obj, VALUE ii, VALUE jj)
   GSL_TYPE(rbgsl_tensor) *t, *tnew;
   Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t);
   tnew = ALLOC(GSL_TYPE(rbgsl_tensor));
-  if (t->tensor->rank == 0) 
+  if (t->tensor->rank == 0)
     tnew->indices = gsl_permutation_alloc(1);
   else
     tnew->indices = gsl_permutation_alloc(t->tensor->rank);
@@ -405,8 +405,8 @@ static VALUE FUNCTION(rb_tensor,minmax_index)(VALUE obj)
   }
   FUNCTION(tensor,minmax_index)(t->tensor, min->data, max->data);
   return rb_ary_new3(2,
-		     Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, min), 
-		     Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, max));
+                     Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, min),
+                     Data_Wrap_Struct(cgsl_index, 0, gsl_permutation_free, max));
 }
 
 static VALUE FUNCTION(rb_tensor,isnull)(VALUE obj)
@@ -427,7 +427,7 @@ static VALUE FUNCTION(rb_tensor,isnull2)(VALUE obj)
 }
 
 static VALUE FUNCTION(rb_tensor,oper)(VALUE obj, VALUE bb,
-					   int flag)
+                                      int flag)
 {
   GSL_TYPE(rbgsl_tensor) *a, *b, *anew;
   BASE x;
@@ -443,28 +443,28 @@ static VALUE FUNCTION(rb_tensor,oper)(VALUE obj, VALUE bb,
     case TENSOR_MUL_ELEMENTS: f = FUNCTION(&tensor,mul_elements); break;
     case TENSOR_DIV_ELEMENTS: f = FUNCTION(&tensor,div_elements); break;
     default: rb_raise(rb_eRuntimeError, "unknown operation"); break;
-    } 
+    }
     (*f)(anew->tensor, b->tensor);
   } else {
     switch (flag) {
     case TENSOR_ADD:
-    case TENSOR_ADD_CONSTANT: 
+    case TENSOR_ADD_CONSTANT:
       x = NUMCONV(bb);
-      f2 = FUNCTION(&tensor,add_constant); 
+      f2 = FUNCTION(&tensor,add_constant);
       break;
     case TENSOR_SUB:
       x = -NUMCONV(bb);
-      f2 = FUNCTION(&tensor,add_constant); 
+      f2 = FUNCTION(&tensor,add_constant);
       break;
     case TENSOR_ADD_DIAGONAL: f2 = FUNCTION(&tensor,add_diagonal); break;
     case TENSOR_MUL_ELEMENTS:
     case TENSOR_SCALE:
-      x = NUMCONV(bb); 
-      f2 = FUNCTION(&tensor,scale); 
+      x = NUMCONV(bb);
+      f2 = FUNCTION(&tensor,scale);
       break;
-    case TENSOR_DIV_ELEMENTS: 
-      x = 1.0/NUMCONV(bb); 
-      f2 = FUNCTION(&tensor,scale); 
+    case TENSOR_DIV_ELEMENTS:
+      x = 1.0/NUMCONV(bb);
+      f2 = FUNCTION(&tensor,scale);
       break;
     default: rb_raise(rb_eRuntimeError, "unknown operation"); break;
     }
@@ -489,28 +489,28 @@ static VALUE FUNCTION(rb_tensor,oper_bang)(VALUE obj, VALUE bb, int flag)
     case TENSOR_MUL_ELEMENTS: f = FUNCTION(&tensor,mul_elements); break;
     case TENSOR_DIV_ELEMENTS: f = FUNCTION(&tensor,div_elements); break;
     default: rb_raise(rb_eRuntimeError, "unknown operation"); break;
-    } 
+    }
     (*f)(a->tensor, b->tensor);
   } else {
     switch (flag) {
     case TENSOR_ADD:
-    case TENSOR_ADD_CONSTANT: 
+    case TENSOR_ADD_CONSTANT:
       x = NUMCONV(bb);
-      f2 = FUNCTION(&tensor,add_constant); 
+      f2 = FUNCTION(&tensor,add_constant);
       break;
     case TENSOR_SUB:
       x = -NUMCONV(bb);
-      f2 = FUNCTION(&tensor,add_constant); 
+      f2 = FUNCTION(&tensor,add_constant);
       break;
     case TENSOR_ADD_DIAGONAL: f2 = FUNCTION(&tensor,add_diagonal); break;
     case TENSOR_MUL_ELEMENTS:
     case TENSOR_SCALE:
-      x = NUMCONV(bb); 
-      f2 = FUNCTION(&tensor,scale); 
+      x = NUMCONV(bb);
+      f2 = FUNCTION(&tensor,scale);
       break;
-    case TENSOR_DIV_ELEMENTS: 
-      x = 1.0/NUMCONV(bb); 
-      f2 = FUNCTION(&tensor,scale); 
+    case TENSOR_DIV_ELEMENTS:
+      x = 1.0/NUMCONV(bb);
+      f2 = FUNCTION(&tensor,scale);
       break;
     default: rb_raise(rb_eRuntimeError, "unknown operation"); break;
     }
@@ -688,7 +688,7 @@ static VALUE FUNCTION(rb_tensor,2matrix)(VALUE obj)
   GSL_TYPE(rbgsl_tensor) *t;
   GSL_TYPE(gsl_matrix) *m = NULL;
   Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t);
-  m = (GSL_TYPE(gsl_matrix)*) FUNCTION(tensor,2matrix)(t->tensor);
+  m = (GSL_TYPE(gsl_matrix)*)FUNCTION(tensor,2matrix)(t->tensor);
   return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_matrix,view), 0, FUNCTION(gsl_matrix,free), m);
 }
 
@@ -697,7 +697,7 @@ static VALUE FUNCTION(rb_tensor,2vector)(VALUE obj)
   GSL_TYPE(rbgsl_tensor) *t;
   GSL_TYPE(gsl_vector) *v = NULL;
   Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t);
-  v = (GSL_TYPE(gsl_vector) *) FUNCTION(tensor,2vector)(t->tensor);
+  v = (GSL_TYPE(gsl_vector) *)FUNCTION(tensor,2vector)(t->tensor);
   return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_vector,view), 0, FUNCTION(gsl_vector,free), v);
 }
 
@@ -718,8 +718,8 @@ static VALUE FUNCTION(rb_tensor,to_v)(VALUE obj)
   rank: rank of the tensor created
 */
 GSL_TYPE(tensor) FUNCTION(tensor,subtensor)(const GSL_TYPE(tensor) *t,
-						     const unsigned int rank,
-						     size_t *indices)
+                                            const unsigned int rank,
+                                            size_t *indices)
 {
   GSL_TYPE(tensor) tnew;
   size_t position;
@@ -740,16 +740,16 @@ static VALUE FUNCTION(rb_tensor,subtensor)(int argc, VALUE *argv, VALUE obj)
   size_t n;
   Data_Get_Struct(obj, GSL_TYPE(rbgsl_tensor), t);
   /* n: number of indices given */
-  rbgsl_tensor_get_indices(argc, argv, t->indices, &n);  
-  rank = t->tensor->rank - n; 
+  rbgsl_tensor_get_indices(argc, argv, t->indices, &n);
+  rank = t->tensor->rank - n;
   tnew = ALLOC(GSL_TYPE(rbgsl_tensor));
-  tnew->tensor = (GSL_TYPE(tensor)*) malloc(sizeof(GSL_TYPE(tensor)));
+  tnew->tensor = (GSL_TYPE(tensor)*)malloc(sizeof(GSL_TYPE(tensor)));
   *(tnew->tensor) = FUNCTION(tensor,subtensor)(t->tensor, rank, t->indices->data);
-  if (rank == 0) 
+  if (rank == 0)
     tnew->indices = gsl_permutation_alloc(1);
   else
     tnew->indices = gsl_permutation_alloc(rank);
-  return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_tensor,view), 0, FUNCTION(rbgsl_tensor,free2), tnew);	       
+  return Data_Wrap_Struct(QUALIFIED_VIEW(cgsl_tensor,view), 0, FUNCTION(rbgsl_tensor,free2), tnew);
 }
 
 #ifdef BASE_DOUBLE
@@ -782,29 +782,29 @@ static VALUE FUNCTION(rb_tensor,to_s)(VALUE obj)
     m = &(matrix.matrix);
     for (i = 0; i < m->size1; i++) {
       if (i != 0) {
-	strcpy(buf, "  ");
-	rb_str_cat(str, buf, strlen(buf));
+        strcpy(buf, "  ");
+        rb_str_cat(str, buf, strlen(buf));
       }
       for (j = 0; j < m->size2; j++) {
-	sprintf(buf, PRINTF_FORMAT, FUNCTION(gsl_matrix,get)(m, i, j));
-	rb_str_cat(str, buf, strlen(buf));
-	if (j == SHOW_ELM) {
-	  strcpy(buf, "... ");
-	  rb_str_cat(str, buf, strlen(buf));
-	  break;
-	}
+        sprintf(buf, PRINTF_FORMAT, FUNCTION(gsl_matrix,get)(m, i, j));
+        rb_str_cat(str, buf, strlen(buf));
+        if (j == SHOW_ELM) {
+          strcpy(buf, "... ");
+          rb_str_cat(str, buf, strlen(buf));
+          break;
+        }
       }
       if (i == 6) {
-	strcpy(buf, "\n  ... ]");
-	rb_str_cat(str, buf, strlen(buf));
-	break;
+        strcpy(buf, "\n  ... ]");
+        rb_str_cat(str, buf, strlen(buf));
+        break;
       }
       if (i == m->size1 - 1) {
-	strcpy(buf, "]");
-	rb_str_cat(str, buf, strlen(buf));
+        strcpy(buf, "]");
+        rb_str_cat(str, buf, strlen(buf));
       } else {
-	strcpy(buf, "\n");
-	rb_str_cat(str, buf, strlen(buf));
+        strcpy(buf, "\n");
+        rb_str_cat(str, buf, strlen(buf));
       }
     }
     return str;
@@ -871,8 +871,8 @@ VALUE FUNCTION(rb_tensor,equal)(int argc, VALUE *argv, VALUE obj)
     if (a->tensor->dimension != b->tensor->dimension) return Qfalse;
     if (a->tensor->size != b->tensor->size) return Qfalse;
     for (i = 0; i < a->tensor->size; i++)
-      if (fabs(a->tensor->data[i]-b->tensor->data[i]) > eps) 
-	return Qfalse;
+      if (fabs(a->tensor->data[i]-b->tensor->data[i]) > eps)
+        return Qfalse;
     return Qtrue;
   } else if (MAT_P(other)) {
     if (a->tensor->rank != 2) return Qfalse;
@@ -880,19 +880,19 @@ VALUE FUNCTION(rb_tensor,equal)(int argc, VALUE *argv, VALUE obj)
     if (a->tensor->dimension != m->size1 || a->tensor->dimension != m->size2)
       return Qfalse;
     for (i = 0; i < a->tensor->size; i++)
-      if (fabs(a->tensor->data[i]-m->data[i]) > eps) 
-	return Qfalse;
+      if (fabs(a->tensor->data[i]-m->data[i]) > eps)
+        return Qfalse;
     return Qtrue;
   } else if (VEC_P(other)) {
     Data_Get_Struct(other, GSL_TYPE(gsl_vector), v);
     if (a->tensor->size != v->size) return Qfalse;
     for (i = 0; i < a->tensor->size; i++)
-      if (fabs(a->tensor->data[i]-v->data[i]) > eps) 
-	return Qfalse;
+      if (fabs(a->tensor->data[i]-v->data[i]) > eps)
+        return Qfalse;
     return Qtrue;
   } else {
-    rb_raise(rb_eTypeError, "wrong argument type %s (Tensor, Matrix or Vector expected)", 
-	     rb_class2name(CLASS_OF(other)));
+    rb_raise(rb_eTypeError, "wrong argument type %s (Tensor, Matrix or Vector expected)",
+             rb_class2name(CLASS_OF(other)));
   }
 }
 
@@ -927,8 +927,8 @@ static VALUE FUNCTION(rb_tensor,coerce)(VALUE obj, VALUE other)
     return rb_ary_new3(2, tt, obj);
     break;
   default:
-    rb_raise(rb_eRuntimeError, "undefined operation with %s", 
-	     rb_class2name(CLASS_OF(other)));
+    rb_raise(rb_eRuntimeError, "undefined operation with %s",
+             rb_class2name(CLASS_OF(other)));
     break;
   }
 }
@@ -953,99 +953,99 @@ void FUNCTION(Init_tensor,init)(VALUE module)
   cgsl_tensor_int = rb_define_class_under(cgsl_tensor, "Int", cGSL_Object);
   cgsl_tensor_view = rb_define_class_under(cgsl_tensor, "View", cgsl_tensor);
   cgsl_tensor_int_view = rb_define_class_under(cgsl_tensor_int, "View",
-					       cgsl_tensor_int);
+                                               cgsl_tensor_int);
   /*
-  cgsl_index = rb_define_class_under(cgsl_tensor, "Index", 
+  cgsl_index = rb_define_class_under(cgsl_tensor, "Index",
   cgsl_permutation);*/
 #endif
 
   rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "new",
-			     FUNCTION(rb_tensor,new), -1);
+                             FUNCTION(rb_tensor,new), -1);
   rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "[]",
-			     FUNCTION(rb_tensor,new), -1);
+                             FUNCTION(rb_tensor,new), -1);
   rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "alloc",
-			     FUNCTION(rb_tensor,new), -1);
+                             FUNCTION(rb_tensor,new), -1);
   rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "calloc",
-			     FUNCTION(rb_tensor,calloc), 2);
+                             FUNCTION(rb_tensor,calloc), 2);
   rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "copy",
-			     FUNCTION(rb_tensor,copy_singleton), 1);
+                             FUNCTION(rb_tensor,copy_singleton), 1);
   rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "memcpy",
-			     FUNCTION(rb_tensor,memcpy_singleton), 2);
+                             FUNCTION(rb_tensor,memcpy_singleton), 2);
   rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "swap",
-			     FUNCTION(rb_tensor,swap_singleton), 2);
+                             FUNCTION(rb_tensor,swap_singleton), 2);
 
   /*****/
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "copy",
-			     FUNCTION(rb_tensor,copy), 0);
+                   FUNCTION(rb_tensor,copy), 0);
   rb_define_alias(GSL_TYPE(cgsl_tensor), "clone", "copy");
   rb_define_alias(GSL_TYPE(cgsl_tensor), "duplicate", "copy");
   rb_define_method(GSL_TYPE(cgsl_tensor), "set_zero",
-			     FUNCTION(rb_tensor,set_zero), 0);
+                   FUNCTION(rb_tensor,set_zero), 0);
   rb_define_method(GSL_TYPE(cgsl_tensor), "set_all",
-			     FUNCTION(rb_tensor,set_all), 1);
+                   FUNCTION(rb_tensor,set_all), 1);
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "position",
-		   FUNCTION(rb_tensor,position), -1);
+                   FUNCTION(rb_tensor,position), -1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "get",
-			     FUNCTION(rb_tensor,get), -1);
+                   FUNCTION(rb_tensor,get), -1);
   rb_define_alias(GSL_TYPE(cgsl_tensor), "[]", "get");
   rb_define_method(GSL_TYPE(cgsl_tensor), "set",
-			     FUNCTION(rb_tensor,set), -1);
+                   FUNCTION(rb_tensor,set), -1);
   rb_define_alias(GSL_TYPE(cgsl_tensor), "[]=", "set");
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "fread",
-			     FUNCTION(rb_tensor,fread), 1);
+                   FUNCTION(rb_tensor,fread), 1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "fwrite",
-			     FUNCTION(rb_tensor,fwrite), 1);
+                   FUNCTION(rb_tensor,fwrite), 1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "fprintf",
-			     FUNCTION(rb_tensor,fprintf), -1);
+                   FUNCTION(rb_tensor,fprintf), -1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "printf",
-			     FUNCTION(rb_tensor,printf), -1);
+                   FUNCTION(rb_tensor,printf), -1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "fscanf",
-			     FUNCTION(rb_tensor,fscanf), 1);
+                   FUNCTION(rb_tensor,fscanf), 1);
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "swap_indices",
-			     FUNCTION(rb_tensor,swap_indices), 2);
+                   FUNCTION(rb_tensor,swap_indices), 2);
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "max",
-			     FUNCTION(rb_tensor,max), 0);
+                   FUNCTION(rb_tensor,max), 0);
   rb_define_method(GSL_TYPE(cgsl_tensor), "min",
-			     FUNCTION(rb_tensor,min), 0);
+                   FUNCTION(rb_tensor,min), 0);
   rb_define_method(GSL_TYPE(cgsl_tensor), "minmax",
-			     FUNCTION(rb_tensor,minmax), 0);
+                   FUNCTION(rb_tensor,minmax), 0);
   rb_define_method(GSL_TYPE(cgsl_tensor), "max_index",
-			     FUNCTION(rb_tensor,max_index), 0);
+                   FUNCTION(rb_tensor,max_index), 0);
   rb_define_method(GSL_TYPE(cgsl_tensor), "min_index",
-			     FUNCTION(rb_tensor,min_index), 0);
+                   FUNCTION(rb_tensor,min_index), 0);
   rb_define_method(GSL_TYPE(cgsl_tensor), "minmax_index",
-			     FUNCTION(rb_tensor,minmax_index), 0);
+                   FUNCTION(rb_tensor,minmax_index), 0);
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "isnull",
-			     FUNCTION(rb_tensor,isnull), 0);
+                   FUNCTION(rb_tensor,isnull), 0);
   rb_define_method(GSL_TYPE(cgsl_tensor), "isnull?",
-			     FUNCTION(rb_tensor,isnull2), 0);
+                   FUNCTION(rb_tensor,isnull2), 0);
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "add",
-			     FUNCTION(rb_tensor,add), 1);
+                   FUNCTION(rb_tensor,add), 1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "sub",
-			     FUNCTION(rb_tensor,sub), 1);
+                   FUNCTION(rb_tensor,sub), 1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "mul_elements",
-			     FUNCTION(rb_tensor,mul_elements), 1);
+                   FUNCTION(rb_tensor,mul_elements), 1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "div_elements",
-			     FUNCTION(rb_tensor,div_elements), 1);
+                   FUNCTION(rb_tensor,div_elements), 1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "add_constant",
-			     FUNCTION(rb_tensor,add_constant), 1);
+                   FUNCTION(rb_tensor,add_constant), 1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "add_diagonal",
-			     FUNCTION(rb_tensor,add_diagonal), 1);
+                   FUNCTION(rb_tensor,add_diagonal), 1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "scale",
-			     FUNCTION(rb_tensor,scale), 1);
+                   FUNCTION(rb_tensor,scale), 1);
   rb_define_singleton_method(GSL_TYPE(cgsl_tensor), "product",
-			     FUNCTION(rb_tensor,product_singleton), 2);
+                             FUNCTION(rb_tensor,product_singleton), 2);
   rb_define_method(GSL_TYPE(cgsl_tensor), "product",
-			     FUNCTION(rb_tensor,product), 1);
+                   FUNCTION(rb_tensor,product), 1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "contract",
-			     FUNCTION(rb_tensor,contract), 2);
+                   FUNCTION(rb_tensor,contract), 2);
 
   rb_define_alias(GSL_TYPE(cgsl_tensor), "+", "add");
   rb_define_alias(GSL_TYPE(cgsl_tensor), "-", "sub");
@@ -1054,62 +1054,62 @@ void FUNCTION(Init_tensor,init)(VALUE module)
   rb_define_alias(GSL_TYPE(cgsl_tensor), "*", "product");
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "add!",
-			     FUNCTION(rb_tensor,add_bang), 1);
+                   FUNCTION(rb_tensor,add_bang), 1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "sub!",
-			     FUNCTION(rb_tensor,sub_bang), 1);
+                   FUNCTION(rb_tensor,sub_bang), 1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "mul_elements!",
-			     FUNCTION(rb_tensor,mul_elements_bang), 1);
+                   FUNCTION(rb_tensor,mul_elements_bang), 1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "div_elements!",
-			     FUNCTION(rb_tensor,div_elements_bang), 1);
+                   FUNCTION(rb_tensor,div_elements_bang), 1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "add_constant!",
-			     FUNCTION(rb_tensor,add_constant_bang), 1);
+                   FUNCTION(rb_tensor,add_constant_bang), 1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "add_diagonal!",
-			     FUNCTION(rb_tensor,add_diagonal_bang), 1);
+                   FUNCTION(rb_tensor,add_diagonal_bang), 1);
   rb_define_method(GSL_TYPE(cgsl_tensor), "scale!",
-			     FUNCTION(rb_tensor,scale_bang), 1);
+                   FUNCTION(rb_tensor,scale_bang), 1);
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "+@",
-			     FUNCTION(rb_tensor,uplus), 0);
+                   FUNCTION(rb_tensor,uplus), 0);
   rb_define_method(GSL_TYPE(cgsl_tensor), "-@",
-			     FUNCTION(rb_tensor,uminus), 0);
+                   FUNCTION(rb_tensor,uminus), 0);
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "size",
-			     FUNCTION(rb_tensor,size), 0);
+                   FUNCTION(rb_tensor,size), 0);
   rb_define_method(GSL_TYPE(cgsl_tensor), "rank",
-			     FUNCTION(rb_tensor,rank), 0);
+                   FUNCTION(rb_tensor,rank), 0);
   rb_define_method(GSL_TYPE(cgsl_tensor), "dimension",
-			     FUNCTION(rb_tensor,dimension), 0);
+                   FUNCTION(rb_tensor,dimension), 0);
   rb_define_alias(GSL_TYPE(cgsl_tensor), "dim", "dimension");
   rb_define_method(GSL_TYPE(cgsl_tensor), "data",
-			     FUNCTION(rb_tensor,data), 0);
+                   FUNCTION(rb_tensor,data), 0);
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "to_v",
-			     FUNCTION(rb_tensor,to_v), 0);
+                   FUNCTION(rb_tensor,to_v), 0);
   rb_define_alias(GSL_TYPE(cgsl_tensor), "to_gv", "to_v");
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "to_vector",
-			     FUNCTION(rb_tensor,2vector), 0);
+                   FUNCTION(rb_tensor,2vector), 0);
   rb_define_method(GSL_TYPE(cgsl_tensor), "to_matrix",
-			     FUNCTION(rb_tensor,2matrix), 0);
+                   FUNCTION(rb_tensor,2matrix), 0);
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "subtensor",
-			     FUNCTION(rb_tensor,subtensor), -1);
+                   FUNCTION(rb_tensor,subtensor), -1);
   rb_define_alias(GSL_TYPE(cgsl_tensor), "view", "subtensor");
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "to_s",
-			     FUNCTION(rb_tensor,to_s), 0);
+                   FUNCTION(rb_tensor,to_s), 0);
   rb_define_method(GSL_TYPE(cgsl_tensor), "inspect",
-			     FUNCTION(rb_tensor,inspect), 0);
+                   FUNCTION(rb_tensor,inspect), 0);
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "equal?",
-			     FUNCTION(rb_tensor,equal), -1);
+                   FUNCTION(rb_tensor,equal), -1);
   rb_define_alias(GSL_TYPE(cgsl_tensor), "==", "equal?");
 
   rb_define_method(GSL_TYPE(cgsl_tensor), "coerce",
-			     FUNCTION(rb_tensor,coerce), 1);
+                   FUNCTION(rb_tensor,coerce), 1);
 
-  rb_define_method(GSL_TYPE(cgsl_tensor), "info", 
-		   FUNCTION(rb_tensor,info), 0);
+  rb_define_method(GSL_TYPE(cgsl_tensor), "info",
+                   FUNCTION(rb_tensor,info), 0);
 }
 
 #undef NUMCONV