rb-gsl 1.16.0.4 → 1.16.0.5

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

@@ -15,17 +15,17 @@
 #include <gsl/gsl_multimin.h>
 
 #ifndef CHECK_MULTIMIN_FUNCTION
-#define CHECK_MULTIMIN_FUNCTION(x) if(CLASS_OF(x)!=cgsl_multimin_function)\
-      rb_raise(rb_eTypeError,\
-      "wrong argument type %s (GSL::MultiMin::Function expected)",\
-      rb_class2name(CLASS_OF(x)));
+#define CHECK_MULTIMIN_FUNCTION(x) if(CLASS_OF(x)!=cgsl_multimin_function) \
+    rb_raise(rb_eTypeError, \
+             "wrong argument type %s (GSL::MultiMin::Function expected)", \
+             rb_class2name(CLASS_OF(x)));
 #endif
 
 #ifndef CHECK_MULTIMIN_FUNCTION_FDF
-#define CHECK_MULTIMIN_FUNCTION_FDF(x) if(CLASS_OF(x)!=cgsl_multimin_function_fdf)\
-      rb_raise(rb_eTypeError,\
-      "wrong argument type %s (GSL::MultiMin::Function_fdf expected)",\
-      rb_class2name(CLASS_OF(x)));
+#define CHECK_MULTIMIN_FUNCTION_FDF(x) if(CLASS_OF(x)!=cgsl_multimin_function_fdf) \
+    rb_raise(rb_eTypeError, \
+             "wrong argument type %s (GSL::MultiMin::Function_fdf expected)", \
+             rb_class2name(CLASS_OF(x)));
 #endif
 
 VALUE cgsl_multimin_function_fdf;  /* Used also in multimin_fsdf.c */
@@ -37,18 +37,12 @@ enum {
   GSL_FDFMINIMIZER_VECTOR_BFGS,
   GSL_FDFMINIMIZER_STEEPEST_DESCENT,
   GSL_FMINIMIZER_NMSIMPLEX,
-#ifdef GSL_1_9_LATER
   GSL_FDFMINIMIZER_VECTOR_BFGS2,
-#endif
-#ifdef GSL_1_13_LATER
   GSL_FMINIMIZER_NMSIMPLEX2RAND,
-#endif
 };
 
 static const gsl_multimin_fdfminimizer_type* get_fdfminimizer_type(VALUE t);
-#ifdef GSL_1_3_LATER
 static const gsl_multimin_fminimizer_type* get_fminimizer_type(VALUE t);
-#endif
 static void define_const();
 
 static void gsl_multimin_function_free(gsl_multimin_function *f);
@@ -57,11 +51,11 @@ static void set_function(int i, VALUE *argv, gsl_multimin_function *F);
 
 static void gsl_multimin_function_fdf_free(gsl_multimin_function_fdf *f);
 
-double rb_gsl_multimin_function_fdf_f(const gsl_vector *x, void *p); 
-void rb_gsl_multimin_function_fdf_df(const gsl_vector *x, void *p, 
-					   gsl_vector *g);
-void rb_gsl_multimin_function_fdf_fdf(const gsl_vector *x, void *p, 
-					    double *f, gsl_vector *g);
+double rb_gsl_multimin_function_fdf_f(const gsl_vector *x, void *p);
+void rb_gsl_multimin_function_fdf_df(const gsl_vector *x, void *p,
+                                     gsl_vector *g);
+void rb_gsl_multimin_function_fdf_fdf(const gsl_vector *x, void *p,
+                                      double *f, gsl_vector *g);
 static void set_function_fdf(int i, VALUE *argv, gsl_multimin_function_fdf *F);
 
 /*** multimin_funcion ***/
@@ -148,10 +142,10 @@ static void set_function(int i, VALUE *argv, gsl_multimin_function *F)
   VALUE ary;
   ary = (VALUE) F->params;
   if (TYPE(argv[i]) == T_FIXNUM) F->n = FIX2INT(argv[i]);
-  else if (rb_obj_is_kind_of(argv[i], rb_cProc)) 
+  else if (rb_obj_is_kind_of(argv[i], rb_cProc))
     rb_ary_store(ary, 0, argv[i]);
   else if (TYPE(argv[i]) == T_ARRAY || rb_obj_is_kind_of(argv[i], cgsl_vector)
-		|| TYPE(argv[i]) == T_FIXNUM || TYPE(argv[i]) == T_FLOAT) {
+           || TYPE(argv[i]) == T_FIXNUM || TYPE(argv[i]) == T_FLOAT) {
     rb_ary_store(ary, 1, argv[i]);
   } else {
     rb_raise(rb_eTypeError, "wrong type of argument %d (Fixnum or Proc)", i);
@@ -268,8 +262,8 @@ static void set_function_fdf(int argc, VALUE *argv, gsl_multimin_function_fdf *F
       F->n = FIX2INT(argv[2]);
       rb_ary_store(ary, 2, Qnil);
     } else {
-			rb_ary_store(ary, 2, argv[2]);
-		}
+      rb_ary_store(ary, 2, argv[2]);
+    }
     break;
   case 4:
   case 5:
@@ -316,8 +310,8 @@ static VALUE rb_gsl_multimin_function_fdf_set_procs(int argc, VALUE *argv, VALUE
       F->n = FIX2INT(argv[2]);
       rb_ary_store(ary, 2, Qnil);
     } else {
-			rb_ary_store(ary, 2, argv[2]);
-		}
+      rb_ary_store(ary, 2, argv[2]);
+    }
     break;
   case 4:
   case 5:
@@ -355,7 +349,7 @@ static VALUE rb_gsl_multimin_function_fdf_set_params(int argc, VALUE *argv, VALU
     ary = (VALUE) F->params;
   }
   if (argc == 1) {
-		rb_ary_store(ary, 3, argv[0]);
+    rb_ary_store(ary, 3, argv[0]);
   } else {
     ary2 = rb_ary_new2(argc);
     for (i = 0; (int) i < argc; i++) rb_ary_store(ary2, i, argv[i]);
@@ -384,8 +378,8 @@ double rb_gsl_multimin_function_fdf_f(const gsl_vector *x, void *p)
   return NUM2DBL(result);
 }
 
-void rb_gsl_multimin_function_fdf_df(const gsl_vector *x, void *p, 
-				     gsl_vector *g)
+void rb_gsl_multimin_function_fdf_df(const gsl_vector *x, void *p,
+                                     gsl_vector *g)
 {
   VALUE vx, vg, proc, vp, ary;
   vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x);
@@ -400,8 +394,8 @@ void rb_gsl_multimin_function_fdf_df(const gsl_vector *x, void *p,
   }
 }
 
-void rb_gsl_multimin_function_fdf_fdf(const gsl_vector *x, void *p, 
-				      double *f, gsl_vector *g)
+void rb_gsl_multimin_function_fdf_fdf(const gsl_vector *x, void *p,
+                                      double *f, gsl_vector *g)
 {
   VALUE vx, vg, proc_f, proc_df, vp, ary, result;
   vx = Data_Wrap_Struct(cgsl_vector, 0, NULL, (gsl_vector *) x);
@@ -431,26 +425,20 @@ static VALUE rb_gsl_multimin_function_fdf_params(VALUE obj)
 
 static void define_const(VALUE klass1, VALUE klass2)
 {
-  rb_define_const(klass1, 
-		  "CONJUGATE_FR", INT2FIX(GSL_FDFMINIMIZER_CONJUGATE_FR));
-  rb_define_const(klass1, 
-		  "CONJUGATE_PR", INT2FIX(GSL_FDFMINIMIZER_CONJUGATE_PR));
-  rb_define_const(klass1, 
-		  "VECTOR_BFGS", INT2FIX(GSL_FDFMINIMIZER_VECTOR_BFGS));  
-  rb_define_const(klass1, 
-		  "STEEPEST_DESCENT", INT2FIX(GSL_FDFMINIMIZER_STEEPEST_DESCENT));
-#ifdef GSL_1_3_LATER
-  rb_define_const(klass2, 
-		  "NMSIMPLEX", INT2FIX(GSL_FMINIMIZER_NMSIMPLEX));
-#endif
-#ifdef GSL_1_9_LATER
-  rb_define_const(klass1, 
-		  "VECTOR_BFGS2", INT2FIX(GSL_FDFMINIMIZER_VECTOR_BFGS2));
-#endif
-#ifdef GSL_1_13_LATER
-  rb_define_const(klass2, 
-		  "NMSIMPLEX2RAND", INT2FIX(GSL_FMINIMIZER_NMSIMPLEX2RAND));
-#endif
+  rb_define_const(klass1,
+                  "CONJUGATE_FR", INT2FIX(GSL_FDFMINIMIZER_CONJUGATE_FR));
+  rb_define_const(klass1,
+                  "CONJUGATE_PR", INT2FIX(GSL_FDFMINIMIZER_CONJUGATE_PR));
+  rb_define_const(klass1,
+                  "VECTOR_BFGS", INT2FIX(GSL_FDFMINIMIZER_VECTOR_BFGS));
+  rb_define_const(klass1,
+                  "STEEPEST_DESCENT", INT2FIX(GSL_FDFMINIMIZER_STEEPEST_DESCENT));
+  rb_define_const(klass2,
+                  "NMSIMPLEX", INT2FIX(GSL_FMINIMIZER_NMSIMPLEX));
+  rb_define_const(klass1,
+                  "VECTOR_BFGS2", INT2FIX(GSL_FDFMINIMIZER_VECTOR_BFGS2));
+  rb_define_const(klass2,
+                  "NMSIMPLEX2RAND", INT2FIX(GSL_FMINIMIZER_NMSIMPLEX2RAND));
 }
 
 static const gsl_multimin_fdfminimizer_type* get_fdfminimizer_type(VALUE t)
@@ -459,18 +447,16 @@ static const gsl_multimin_fdfminimizer_type* get_fdfminimizer_type(VALUE t)
   switch (TYPE(t)) {
   case T_STRING:
     strcpy(name, STR2CSTR(t));
-    if (str_tail_grep(name, "conjugate_fr") == 0) 
+    if (str_tail_grep(name, "conjugate_fr") == 0)
       return gsl_multimin_fdfminimizer_conjugate_fr;
-    else if (str_tail_grep(name, "conjugate_pr") == 0) 
+    else if (str_tail_grep(name, "conjugate_pr") == 0)
       return gsl_multimin_fdfminimizer_conjugate_pr;
-    else if (str_tail_grep(name, "vector_bfgs") == 0) 
+    else if (str_tail_grep(name, "vector_bfgs") == 0)
       return gsl_multimin_fdfminimizer_vector_bfgs;
-    else if (str_tail_grep(name, "steepest_descent") == 0) 
+    else if (str_tail_grep(name, "steepest_descent") == 0)
       return gsl_multimin_fdfminimizer_steepest_descent;
-#ifdef GSL_1_9_LATER
-    else if (str_tail_grep(name, "vector_bfgs2") == 0) 
+    else if (str_tail_grep(name, "vector_bfgs2") == 0)
       return gsl_multimin_fdfminimizer_vector_bfgs2;
-#endif
     else
       rb_raise(rb_eTypeError, "%s: unknown minimizer type", name);
     break;
@@ -484,10 +470,8 @@ static const gsl_multimin_fdfminimizer_type* get_fdfminimizer_type(VALUE t)
       return gsl_multimin_fdfminimizer_vector_bfgs; break;
     case GSL_FDFMINIMIZER_STEEPEST_DESCENT:
       return gsl_multimin_fdfminimizer_steepest_descent; break;
-#ifdef GSL_1_9_LATER
     case GSL_FDFMINIMIZER_VECTOR_BFGS2:
       return gsl_multimin_fdfminimizer_vector_bfgs2; break;
-#endif      
     default:
       rb_raise(rb_eTypeError, "%d: unknown type", FIX2INT(t));
       break;
@@ -508,8 +492,8 @@ static VALUE rb_gsl_fdfminimizer_new(VALUE klass, VALUE t, VALUE n)
   return Data_Wrap_Struct(klass, 0, gsl_multimin_fdfminimizer_free, gmf);
 }
 
-static VALUE rb_gsl_fdfminimizer_set(VALUE obj, VALUE ff, VALUE xx, VALUE ss, 
-				     VALUE tt)
+static VALUE rb_gsl_fdfminimizer_set(VALUE obj, VALUE ff, VALUE xx, VALUE ss,
+                                     VALUE tt)
 {
   gsl_multimin_fdfminimizer *gmf = NULL;
   gsl_multimin_function_fdf *F = NULL;
@@ -601,7 +585,6 @@ static VALUE rb_gsl_multimin_test_gradient(VALUE obj, VALUE gg, VALUE ea)
 }
 
 /*****/
-#ifdef GSL_1_3_LATER
 static const gsl_multimin_fminimizer_type* get_fminimizer_type(VALUE t)
 {
   char name[64];
@@ -609,12 +592,10 @@ static const gsl_multimin_fminimizer_type* get_fminimizer_type(VALUE t)
   switch (TYPE(t)) {
   case T_STRING:
     strcpy(name, STR2CSTR(t));
-    if (str_tail_grep(name, "nmsimplex") == 0) 
+    if (str_tail_grep(name, "nmsimplex") == 0)
       return gsl_multimin_fminimizer_nmsimplex;
-#ifdef GSL_1_13_LATER
-    if (str_tail_grep(name, "nmsimplex2rand") == 0) 
+    if (str_tail_grep(name, "nmsimplex2rand") == 0)
       return gsl_multimin_fminimizer_nmsimplex2rand;
-#endif
     else
       rb_raise(rb_eTypeError, "unknown type %s (nmsimplex and nmsimplex2rand supported)", name);
     break;
@@ -622,10 +603,8 @@ static const gsl_multimin_fminimizer_type* get_fminimizer_type(VALUE t)
     switch (FIX2INT(t)) {
     case GSL_FMINIMIZER_NMSIMPLEX:
       return gsl_multimin_fminimizer_nmsimplex; break;
-#ifdef GSL_1_13_LATER
     case GSL_FMINIMIZER_NMSIMPLEX2RAND:
       return gsl_multimin_fminimizer_nmsimplex2rand; break;
-#endif
     default:
       rb_raise(rb_eTypeError, "%d: unknown type (not supported)", FIX2INT(t));
       break;
@@ -633,7 +612,7 @@ static const gsl_multimin_fminimizer_type* get_fminimizer_type(VALUE t)
     break;
   default:
     rb_raise(rb_eTypeError, "wrong argument type %s (String or Fixnum expected)",
-	     rb_class2name(CLASS_OF(t)));
+             rb_class2name(CLASS_OF(t)));
     break;
   }
 }
@@ -720,8 +699,6 @@ static VALUE rb_gsl_multimin_test_size(VALUE obj, VALUE ss, VALUE ea)
   return INT2FIX(gsl_multimin_test_size(NUM2DBL(ss), NUM2DBL(ea)));
 }
 
-#endif
-
 #ifdef HAVE_GSL_GSL_MULTIMIN_FSDF_H
 void Init_multimin_fsdf(VALUE module);
 #endif
@@ -735,18 +712,16 @@ void Init_gsl_multimin(VALUE module)
 
   mgsl_multimin = rb_define_module_under(module, "MultiMin");
   rb_define_singleton_method(mgsl_multimin, "test_gradient", rb_gsl_multimin_test_gradient, 2);
-#ifdef GSL_1_3_LATER
   rb_define_singleton_method(mgsl_multimin, "test_size", rb_gsl_multimin_test_size, 2);
-#endif
 
   cgsl_multimin_fdfminimizer = rb_define_class_under(mgsl_multimin, "FdfMinimizer", cGSL_Object);
   cgsl_multimin_fminimizer = rb_define_class_under(mgsl_multimin, "FMinimizer", cGSL_Object);
   define_const(cgsl_multimin_fdfminimizer, cgsl_multimin_fminimizer);
 
   cgsl_multimin_function = rb_define_class_under(mgsl_multimin, "Function",
-						  cgsl_function);
+                                                 cgsl_function);
   rb_define_singleton_method(cgsl_multimin_function, "alloc",
-			     rb_gsl_multimin_function_new, -1);
+                             rb_gsl_multimin_function_new, -1);
   rb_define_method(cgsl_multimin_function, "eval", rb_gsl_multimin_function_eval, 1);
   rb_define_alias(cgsl_multimin_function, "call", "eval");
   rb_define_method(cgsl_multimin_function, "set_proc", rb_gsl_multimin_function_set_f, -1);
@@ -756,9 +731,9 @@ void Init_gsl_multimin(VALUE module)
   rb_define_method(cgsl_multimin_function, "n", rb_gsl_multimin_function_n, 0);
 
   cgsl_multimin_function_fdf = rb_define_class_under(mgsl_multimin, "Function_fdf",
-						     cGSL_Object);
+                                                     cGSL_Object);
   rb_define_singleton_method(cgsl_multimin_function_fdf, "alloc",
-			     rb_gsl_multimin_function_fdf_new, -1);
+                             rb_gsl_multimin_function_fdf_new, -1);
 
   rb_define_method(cgsl_multimin_function_fdf, "set", rb_gsl_multimin_function_fdf_set, -1);
   rb_define_method(cgsl_multimin_function_fdf, "set_params", rb_gsl_multimin_function_fdf_set_params, -1);
@@ -779,7 +754,6 @@ void Init_gsl_multimin(VALUE module)
   rb_define_method(cgsl_multimin_fdfminimizer, "test_gradient", rb_gsl_fdfminimizer_test_gradient, 1);
 
   /*****/
-#ifdef GSL_1_3_LATER
   rb_define_singleton_method(cgsl_multimin_fminimizer, "alloc", rb_gsl_fminimizer_new, 2);
 
   rb_define_method(cgsl_multimin_fminimizer, "set", rb_gsl_fminimizer_set, 3);
@@ -787,14 +761,12 @@ void Init_gsl_multimin(VALUE module)
   rb_define_method(cgsl_multimin_fminimizer, "iterate", rb_gsl_fminimizer_iterate, 0);
   rb_define_method(cgsl_multimin_fminimizer, "x", rb_gsl_fminimizer_x, 0);
   rb_define_method(cgsl_multimin_fminimizer, "fval", rb_gsl_fminimizer_fval, 0);
-  rb_define_method(cgsl_multimin_fminimizer, "minimum", rb_gsl_fminimizer_minimum, 0);  
-    rb_define_method(cgsl_multimin_fminimizer, "size", rb_gsl_fminimizer_size, 0);
+  rb_define_method(cgsl_multimin_fminimizer, "minimum", rb_gsl_fminimizer_minimum, 0);
+  rb_define_method(cgsl_multimin_fminimizer, "size", rb_gsl_fminimizer_size, 0);
   rb_define_method(cgsl_multimin_fminimizer, "test_size", rb_gsl_fminimizer_test_size, 1);
-#endif
-
 
 #ifdef HAVE_GSL_GSL_MULTIMIN_FSDF_H
-	Init_multimin_fsdf(mgsl_multimin);
+  Init_multimin_fsdf(mgsl_multimin);
 #endif
 }
 #ifdef CHECK_MULTIMIN_FUNCTION

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

@@ -4,10 +4,10 @@
 
 static VALUE cfsdf;
 #ifndef CHECK_MULTIMIN_FUNCTION_FSDF
-#define CHECK_MULTIMIN_FUNCTION_FSDF(x) if(CLASS_OF(x)!=cfsdf)\
-      rb_raise(rb_eTypeError,\
-      "wrong argument type %s (GSL::MultiMin::Function_fsdf expected)",\
-      rb_class2name(CLASS_OF(x)));
+#define CHECK_MULTIMIN_FUNCTION_FSDF(x) if(CLASS_OF(x)!=cfsdf) \
+    rb_raise(rb_eTypeError, \
+             "wrong argument type %s (GSL::MultiMin::Function_fsdf expected)", \
+             rb_class2name(CLASS_OF(x)));
 #endif
 extern VALUE cgsl_multimin_function_fdf;
 
@@ -17,7 +17,7 @@ static const gsl_multimin_fsdfminimizer_type* get_fsdfminimizer_type(VALUE t)
   switch (TYPE(t)) {
   case T_STRING:
     strcpy(name, STR2CSTR(t));
-    if (strcmp(name, "bundle") == 0 || strcmp(name, "bundle_method") == 0) 
+    if (strcmp(name, "bundle") == 0 || strcmp(name, "bundle_method") == 0)
       return gsl_multimin_fsdfminimizer_bundle_method;
     else
       rb_raise(rb_eTypeError, "%s: unknown minimizer type", name);
@@ -42,13 +42,13 @@ static VALUE rb_gsl_fsdfminimizer_set(VALUE obj, VALUE ff, VALUE xx, VALUE ss)
   gsl_multimin_fsdfminimizer *gmf = NULL;
   gsl_multimin_function_fsdf *F = NULL;
   gsl_vector *x;
-	size_t bundle_size;
+  size_t bundle_size;
   int status;
   CHECK_MULTIMIN_FUNCTION_FSDF(ff);
   Data_Get_Struct(obj, gsl_multimin_fsdfminimizer, gmf);
   Data_Get_Struct(ff, gsl_multimin_function_fsdf, F);
   Data_Get_Vector(xx, x);
-	bundle_size = (size_t) FIX2INT(ss);
+  bundle_size = (size_t) FIX2INT(ss);
   status = gsl_multimin_fsdfminimizer_set(gmf, F, x, bundle_size);
   return INT2FIX(status);
 }
@@ -134,12 +134,12 @@ static VALUE rb_gsl_fsdfminimizer_eps(VALUE obj)
 
 void Init_multimin_fsdf(VALUE module)
 {
-	VALUE cmin;
-	
-	cmin = rb_define_class_under(module, "FsdfMinimizer",  cGSL_Object);
-	cfsdf = rb_define_class_under(module, "Function_fsdf", cgsl_multimin_function_fdf);
-	
-	rb_define_singleton_method(cmin, "alloc", rb_gsl_fsdfminimizer_alloc, 2);
+  VALUE cmin;
+
+  cmin = rb_define_class_under(module, "FsdfMinimizer",  cGSL_Object);
+  cfsdf = rb_define_class_under(module, "Function_fsdf", cgsl_multimin_function_fdf);
+
+  rb_define_singleton_method(cmin, "alloc", rb_gsl_fsdfminimizer_alloc, 2);
   rb_define_method(cmin, "set", rb_gsl_fsdfminimizer_set, 3);
   rb_define_method(cmin, "name", rb_gsl_fsdfminimizer_name, 0);
   rb_define_method(cmin, "iterate", rb_gsl_fsdfminimizer_iterate, 0);
@@ -149,8 +149,8 @@ void Init_multimin_fsdf(VALUE module)
   rb_define_method(cmin, "minimum", rb_gsl_fsdfminimizer_minimum, 0);
   rb_define_method(cmin, "restart", rb_gsl_fsdfminimizer_restart, 0);
   rb_define_method(cmin, "test_gradient", rb_gsl_fsdfminimizer_test_gradient, 1);
-  rb_define_method(cmin, "test_convergence", rb_gsl_fsdfminimizer_test_convergence, 1);  
-  rb_define_method(cmin, "eps", rb_gsl_fsdfminimizer_eps, 0);	
+  rb_define_method(cmin, "test_convergence", rb_gsl_fsdfminimizer_test_convergence, 1);
+  rb_define_method(cmin, "eps", rb_gsl_fsdfminimizer_eps, 0);
 }
 
 #endif

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

@@ -15,17 +15,17 @@
 #include <gsl/gsl_multiroots.h>
 
 #ifndef CHECK_MULTIROOT_FUNCTION
-#define CHECK_MULTIROOT_FUNCTION(x) if(CLASS_OF(x)!=cgsl_multiroot_function)\
-      rb_raise(rb_eTypeError,\
-      "wrong argument type %s (GSL::MultiRoot::Function expected)",\
-      rb_class2name(CLASS_OF(x)));
+#define CHECK_MULTIROOT_FUNCTION(x) if(CLASS_OF(x)!=cgsl_multiroot_function) \
+    rb_raise(rb_eTypeError, \
+             "wrong argument type %s (GSL::MultiRoot::Function expected)", \
+             rb_class2name(CLASS_OF(x)));
 #endif
 
 #ifndef CHECK_MULTIROOT_FUNCTION_FDF
-#define CHECK_MULTIROOT_FUNCTION_FDF(x) if(CLASS_OF(x)!=cgsl_multiroot_function_fdf)\
-      rb_raise(rb_eTypeError,\
-      "wrong argument type %s (GSL::MultiRoot::Function_fdf expected)",\
-      rb_class2name(CLASS_OF(x)));
+#define CHECK_MULTIROOT_FUNCTION_FDF(x) if(CLASS_OF(x)!=cgsl_multiroot_function_fdf) \
+    rb_raise(rb_eTypeError, \
+             "wrong argument type %s (GSL::MultiRoot::Function_fdf expected)", \
+             rb_class2name(CLASS_OF(x)));
 #endif
 
 static VALUE cgsl_multiroot_function;
@@ -49,12 +49,12 @@ static int rb_gsl_multiroot_function_f(const gsl_vector *x, void *p, gsl_vector
 static void set_function(int i, VALUE *argv, gsl_multiroot_function *F);
 
 static void gsl_multiroot_function_fdf_free(gsl_multiroot_function_fdf *f);
-static int rb_gsl_multiroot_function_fdf_f(const gsl_vector *x, void *p, 
-					   gsl_vector *f);
-static int rb_gsl_multiroot_function_fdf_df(const gsl_vector *x, void *p, 
-					    gsl_matrix *J);
-static int rb_gsl_multiroot_function_fdf_fdf(const gsl_vector *x, void *p, 
-					     gsl_vector *f, gsl_matrix *J);
+static int rb_gsl_multiroot_function_fdf_f(const gsl_vector *x, void *p,
+                                           gsl_vector *f);
+static int rb_gsl_multiroot_function_fdf_df(const gsl_vector *x, void *p,
+                                            gsl_matrix *J);
+static int rb_gsl_multiroot_function_fdf_fdf(const gsl_vector *x, void *p,
+                                             gsl_vector *f, gsl_matrix *J);
 static void set_function_fdf(int i, VALUE *argv, gsl_multiroot_function_fdf *F);
 static const gsl_multiroot_fsolver_type* get_fsolver_type(VALUE t);
 static const gsl_multiroot_fdfsolver_type* get_fdfsolver_type(VALUE t);
@@ -98,8 +98,8 @@ static void gsl_multiroot_function_mark(gsl_multiroot_function *f)
 {
   size_t i;
   rb_gc_mark((VALUE) f->params);
-  //  for (i = 0; i < RARRAY(f->params)->len; i++) 
-  for (i = 0; (int) i < RARRAY_LEN(f->params); i++) 
+  //  for (i = 0; i < RARRAY(f->params)->len; i++)
+  for (i = 0; (int) i < RARRAY_LEN(f->params); i++)
     rb_gc_mark(rb_ary_entry((VALUE) f->params, i));
 }
 
@@ -137,10 +137,10 @@ static void set_function(int i, VALUE *argv, gsl_multiroot_function *F)
   VALUE ary;
   ary = (VALUE) F->params;
   if (TYPE(argv[i]) == T_FIXNUM) F->n = FIX2INT(argv[i]);
-  else if (rb_obj_is_kind_of(argv[i], rb_cProc)) 
+  else if (rb_obj_is_kind_of(argv[i], rb_cProc))
     rb_ary_store(ary, 0, argv[i]);
   else if (TYPE(argv[i]) == T_ARRAY || rb_obj_is_kind_of(argv[i], cgsl_vector)
-		|| TYPE(argv[i]) == T_FIXNUM || TYPE(argv[i]) == T_FLOAT) {
+           || TYPE(argv[i]) == T_FIXNUM || TYPE(argv[i]) == T_FLOAT) {
     rb_ary_store(ary, 1, argv[i]);
   } else {
     rb_raise(rb_eTypeError, "wrong type of argument %d (Fixnum or Proc)", i);
@@ -235,8 +235,8 @@ static void gsl_multiroot_function_fdf_mark(gsl_multiroot_function_fdf *f)
 {
   size_t i;
   rb_gc_mark((VALUE) f->params);
-  //  for (i = 0; i < RARRAY(f->params)->len; i++) 
-  for (i = 0; (int) i < RARRAY_LEN(f->params); i++) 
+  //  for (i = 0; i < RARRAY(f->params)->len; i++)
+  for (i = 0; (int) i < RARRAY_LEN(f->params); i++)
     rb_gc_mark(rb_ary_entry((VALUE) f->params, i));
 }
 
@@ -336,8 +336,8 @@ static VALUE rb_gsl_multiroot_function_fdf_set(int argc, VALUE *argv, VALUE obj)
   return obj;
 }
 
-static int rb_gsl_multiroot_function_fdf_f(const gsl_vector *x, void *p, 
-					   gsl_vector *f)
+static int rb_gsl_multiroot_function_fdf_f(const gsl_vector *x, void *p,
+                                           gsl_vector *f)
 {
   VALUE vx, vf, ary;
   VALUE proc, vp;
@@ -351,8 +351,8 @@ static int rb_gsl_multiroot_function_fdf_f(const gsl_vector *x, void *p,
   return GSL_SUCCESS;
 }
 
-static int rb_gsl_multiroot_function_fdf_df(const gsl_vector *x, void *p, 
-					    gsl_matrix *J)
+static int rb_gsl_multiroot_function_fdf_df(const gsl_vector *x, void *p,
+                                            gsl_matrix *J)
 {
   VALUE vx, vJ, ary;
   VALUE proc, vp;
@@ -366,8 +366,8 @@ static int rb_gsl_multiroot_function_fdf_df(const gsl_vector *x, void *p,
   return GSL_SUCCESS;
 }
 
-static int rb_gsl_multiroot_function_fdf_fdf(const gsl_vector *x, void *p, 
-					     gsl_vector *f, gsl_matrix *J)
+static int rb_gsl_multiroot_function_fdf_fdf(const gsl_vector *x, void *p,
+                                             gsl_vector *f, gsl_matrix *J)
 {
   VALUE vx, vf, vJ, ary;
   VALUE proc_f, proc_df, proc_fdf, vp;
@@ -671,8 +671,8 @@ static VALUE rb_gsl_multiroot_fdfsolver_test_residual(VALUE obj, VALUE ea)
   return INT2FIX(gsl_multiroot_test_residual(s->f, NUM2DBL(ea)));
 }
 
-static VALUE rb_gsl_multiroot_test_delta(VALUE obj, VALUE vdx, VALUE vx, 
-					 VALUE ea, VALUE er)
+static VALUE rb_gsl_multiroot_test_delta(VALUE obj, VALUE vdx, VALUE vx,
+                                         VALUE ea, VALUE er)
 {
   gsl_vector *dx = NULL, *x = NULL;
   Need_Float(ea); Need_Float(er);
@@ -717,22 +717,21 @@ static VALUE rb_gsl_multiroot_fsolver_fsolve(int argc, VALUE *argv, VALUE obj)
       break;
     default:
       rb_raise(rb_eTypeError, "wrong type of argument %s (Fixnum or Float expected)",
-	       rb_class2name(CLASS_OF(argv[i])));
+               rb_class2name(CLASS_OF(argv[i])));
       break;
     }
   }
-  
   do {
-    iter ++;
+    iter++;
     status = gsl_multiroot_fsolver_iterate (s);
     if (status) break;
     status = gsl_multiroot_test_residual(s->f, eps);
   } while (status == GSL_CONTINUE && iter < max_iter);
   xnew = gsl_vector_alloc(s->x->size);
   gsl_vector_memcpy(xnew, gsl_multiroot_fsolver_root(s));
-  return rb_ary_new3(3, 
-		     Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, xnew),
-		     INT2FIX(iter), INT2FIX(status));
+  return rb_ary_new3(3,
+                     Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, xnew),
+                     INT2FIX(iter), INT2FIX(status));
 }
 
 /* singleton */
@@ -746,7 +745,6 @@ static VALUE rb_gsl_multiroot_fdjacobian(int argc, VALUE *argv, VALUE obj)
   int status;
   if (argc != 4 && argc != 5)
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 4 or 5)", argc);
-
   if (rb_obj_is_kind_of(argv[0], cgsl_multiroot_function_fdf)) {
     Data_Get_Struct(argv[0], gsl_multiroot_function_fdf, fdf);
     func.f = fdf->f;
@@ -758,7 +756,6 @@ static VALUE rb_gsl_multiroot_fdjacobian(int argc, VALUE *argv, VALUE obj)
   } else {
     rb_raise(rb_eArgError, "wrong argument type %s (MultiRoot::Function or MultiRoot::Function_fdf expected)", rb_class2name(CLASS_OF(argv[0])));
   }
-
   Need_Float(argv[3]);
   Data_Get_Vector(argv[1], x);
   Data_Get_Vector(argv[2], f);
@@ -767,7 +764,7 @@ static VALUE rb_gsl_multiroot_fdjacobian(int argc, VALUE *argv, VALUE obj)
     J = gsl_matrix_alloc(F->n, F->n);
     status = gsl_multiroot_fdjacobian(F, x, f, eps, J);
     return rb_ary_new3(2, Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, J),
-		       INT2FIX(status));
+                       INT2FIX(status));
   } else {
     Data_Get_Struct(argv[4], gsl_matrix, J);
     status = gsl_multiroot_fdjacobian(F, x, f, eps, J);
@@ -803,7 +800,7 @@ static VALUE rb_gsl_multiroot_function_solve(int argc, VALUE *argv, VALUE obj)
   int flag = 0;
   double epsabs = 1e-7;
   size_t max_iter = 10000, iter = 0, i;
-  gsl_multiroot_fsolver_type *T 
+  gsl_multiroot_fsolver_type *T
     = (gsl_multiroot_fsolver_type *) gsl_multiroot_fsolver_hybrids;
   gsl_multiroot_fsolver *s = NULL;
   int status;
@@ -816,25 +813,25 @@ static VALUE rb_gsl_multiroot_function_solve(int argc, VALUE *argv, VALUE obj)
     for (i = 1; (int) i < argc; i++) {
       switch (TYPE(argv[i])) {
       case T_STRING:
-	T = (gsl_multiroot_fsolver_type *) get_fsolver_type(argv[i]);
-	break;
+        T = (gsl_multiroot_fsolver_type *) get_fsolver_type(argv[i]);
+        break;
       case T_FLOAT:
-	epsabs = NUM2DBL(argv[i]);
-	break;	
+        epsabs = NUM2DBL(argv[i]);
+        break;
       case T_FIXNUM:
-	max_iter = FIX2INT(argv[i]);
-	break;
+        max_iter = FIX2INT(argv[i]);
+        break;
       }
     }
-    /* no break */
+  /* no break */
   case 1:
     if (TYPE(argv[0]) == T_ARRAY) {
       //      if (RARRAY(argv[0])->len != F->n)
       if (RARRAY_LEN(argv[0]) != (int) F->n)
-	rb_raise(rb_eRangeError, "array size are different.");
+        rb_raise(rb_eRangeError, "array size are different.");
       x0 = gsl_vector_alloc(F->n);
-      for (i = 0; i < x0->size; i++) 
-	gsl_vector_set(x0, i, NUM2DBL(rb_ary_entry(argv[0], i)));
+      for (i = 0; i < x0->size; i++)
+        gsl_vector_set(x0, i, NUM2DBL(rb_ary_entry(argv[0], i)));
       flag = 1;
     } else {
       Data_Get_Vector(argv[0], x0);
@@ -858,7 +855,7 @@ static VALUE rb_gsl_multiroot_function_solve(int argc, VALUE *argv, VALUE obj)
   gsl_multiroot_fsolver_free (s);
   if (flag == 1) gsl_vector_free(x0);
   return rb_ary_new3(3, Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, xnew),
-		     INT2FIX(iter), INT2FIX(status));
+                     INT2FIX(iter), INT2FIX(status));
 }
 
 void Init_gsl_multiroot(VALUE module)
@@ -868,19 +865,19 @@ void Init_gsl_multiroot(VALUE module)
 
   mgsl_multiroot = rb_define_module_under(module, "MultiRoot");
 
-  rb_define_singleton_method(mgsl_multiroot, "test_delta", 
-			     rb_gsl_multiroot_test_delta, 4);
-  rb_define_singleton_method(mgsl_multiroot, "test_residual", 
-			     rb_gsl_multiroot_test_residual, 2);
+  rb_define_singleton_method(mgsl_multiroot, "test_delta",
+                             rb_gsl_multiroot_test_delta, 4);
+  rb_define_singleton_method(mgsl_multiroot, "test_residual",
+                             rb_gsl_multiroot_test_residual, 2);
 
-  rb_define_singleton_method(mgsl_multiroot, "fdjacobian", 
-			     rb_gsl_multiroot_fdjacobian, -1);
+  rb_define_singleton_method(mgsl_multiroot, "fdjacobian",
+                             rb_gsl_multiroot_fdjacobian, -1);
 
   /* multiroot_function */
   cgsl_multiroot_function = rb_define_class_under(mgsl_multiroot, "Function",
-						  cgsl_function);
+                                                  cgsl_function);
   rb_define_singleton_method(cgsl_multiroot_function, "alloc",
-			     rb_gsl_multiroot_function_new, -1);
+                             rb_gsl_multiroot_function_new, -1);
   rb_define_method(cgsl_multiroot_function, "eval", rb_gsl_multiroot_function_eval, 1);
   rb_define_alias(cgsl_multiroot_function, "call", "eval");
   rb_define_method(cgsl_multiroot_function, "set", rb_gsl_multiroot_function_set_f, -1);
@@ -891,9 +888,9 @@ void Init_gsl_multiroot(VALUE module)
 
   /* multiroot_function_fdf */
   cgsl_multiroot_function_fdf = rb_define_class_under(mgsl_multiroot, "Function_fdf",
-						  cgsl_multiroot_function);
+                                                      cgsl_multiroot_function);
   rb_define_singleton_method(cgsl_multiroot_function_fdf, "alloc",
-			     rb_gsl_multiroot_function_fdf_new, -1);
+                             rb_gsl_multiroot_function_fdf_new, -1);
   rb_define_method(cgsl_multiroot_function_fdf, "set", rb_gsl_multiroot_function_fdf_set, -1);
   rb_define_method(cgsl_multiroot_function_fdf, "set_params", rb_gsl_multiroot_function_fdf_set_params, -1);
   rb_define_method(cgsl_multiroot_function_fdf, "params", rb_gsl_multiroot_function_fdf_params, 0);
@@ -905,10 +902,10 @@ void Init_gsl_multiroot(VALUE module)
   cgsl_multiroot_fsolver = rb_define_class_under(mgsl_multiroot, "FSolver", cGSL_Object);
   cgsl_multiroot_fdfsolver = rb_define_class_under(mgsl_multiroot, "FdfSolver", cgsl_multiroot_fsolver);
 
-  rb_define_singleton_method(cgsl_multiroot_fsolver, "alloc", 
-			     rb_gsl_multiroot_fsolver_new, 2);
-  rb_define_singleton_method(cgsl_multiroot_fdfsolver, "alloc", 
-			     rb_gsl_multiroot_fdfsolver_new, 2);
+  rb_define_singleton_method(cgsl_multiroot_fsolver, "alloc",
+                             rb_gsl_multiroot_fsolver_new, 2);
+  rb_define_singleton_method(cgsl_multiroot_fdfsolver, "alloc",
+                             rb_gsl_multiroot_fdfsolver_new, 2);
 
   rb_define_method(cgsl_multiroot_fsolver, "set", rb_gsl_multiroot_fsolver_set, 2);
   rb_define_method(cgsl_multiroot_fsolver, "name", rb_gsl_multiroot_fsolver_name, 0);
@@ -935,7 +932,7 @@ void Init_gsl_multiroot(VALUE module)
   rb_define_method(cgsl_multiroot_fdfsolver, "test_residual", rb_gsl_multiroot_fdfsolver_test_residual, 1);
 
 
-  multiroot_define_const(cgsl_multiroot_fdfsolver, cgsl_multiroot_fsolver);  
+  multiroot_define_const(cgsl_multiroot_fdfsolver, cgsl_multiroot_fsolver);
 
   rb_define_method(cgsl_multiroot_fsolver, "fsolve", rb_gsl_multiroot_fsolver_fsolve, -1);
   rb_define_alias(cgsl_multiroot_fsolver, "solve", "fsolve");