gsl 1.15.3 → 1.16.0.6

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

@@ -9,8 +9,7 @@
   WITHOUT ANY WARRANTY.
 */
 
-#include "rb_gsl_config.h"
-#include "rb_gsl_fit.h"
+#include "include/rb_gsl_fit.h"
 
 /* linear fit without weights: y = c0 + c1 x */
 /* This returns 7 elements array */
@@ -36,10 +35,10 @@ static VALUE rb_gsl_fit_linear(int argc, VALUE *argv, VALUE obj)
     break;
   }
   status = gsl_fit_linear(ptrx, stridex, ptry, stridey, n, &c0, &c1, &cov00,
-			  &cov01, &cov11, &sumsq);
+                          &cov01, &cov11, &sumsq);
   return rb_ary_new3(7, rb_float_new(c0), rb_float_new(c1), rb_float_new(cov00),
-		     rb_float_new(cov01), rb_float_new(cov11), rb_float_new(sumsq),
-		     INT2FIX(status));
+                     rb_float_new(cov01), rb_float_new(cov11), rb_float_new(sumsq),
+                     INT2FIX(status));
 }
 
 /* linear fit with weights: y = c0 + c1 x */
@@ -55,7 +54,7 @@ static VALUE rb_gsl_fit_wlinear(int argc, VALUE *argv, VALUE obj)
     ptrw = get_vector_ptr(argv[1], &stridew, &n);
     ptry = get_vector_ptr(argv[2], &stridey, &n);
     break;
-  case 4:   
+  case 4:
     CHECK_FIXNUM(argv[3]);
     ptrx = get_vector_ptr(argv[0], &stridex, &n);
     ptrw = get_vector_ptr(argv[1], &stridew, &n);
@@ -67,11 +66,11 @@ static VALUE rb_gsl_fit_wlinear(int argc, VALUE *argv, VALUE obj)
     break;
   }
   status = gsl_fit_wlinear(ptrx, stridex, ptrw, stridew, ptry, stridey,
-			   n,
-			   &c0, &c1, &cov00, &cov01, &cov11, &sumsq);
+                           n,
+                           &c0, &c1, &cov00, &cov01, &cov11, &sumsq);
   return rb_ary_new3(7, rb_float_new(c0), rb_float_new(c1), rb_float_new(cov00),
-		     rb_float_new(cov01), rb_float_new(cov11), rb_float_new(sumsq),
-		     INT2FIX(status));
+                     rb_float_new(cov01), rb_float_new(cov11), rb_float_new(sumsq),
+                     INT2FIX(status));
 }
 
 static VALUE rb_gsl_fit_linear_est(int argc, VALUE *argv, VALUE obj)
@@ -130,8 +129,8 @@ static VALUE rb_gsl_fit_mul(int argc, VALUE *argv, VALUE obj)
     break;
   }
   status = gsl_fit_mul(ptrx, stridex, ptry, stridey, n, &c1, &cov11, &sumsq);
-  return rb_ary_new3(4, rb_float_new(c1), 
-		     rb_float_new(cov11), rb_float_new(sumsq), INT2FIX(status));
+  return rb_ary_new3(4, rb_float_new(c1),
+                     rb_float_new(cov11), rb_float_new(sumsq), INT2FIX(status));
 }
 
 static VALUE rb_gsl_fit_wmul(int argc, VALUE *argv, VALUE obj)
@@ -146,7 +145,7 @@ static VALUE rb_gsl_fit_wmul(int argc, VALUE *argv, VALUE obj)
     ptrw = get_vector_ptr(argv[1], &stridew, &n);
     ptry = get_vector_ptr(argv[2], &stridey, &n);
     break;
-  case 4:   
+  case 4:
     CHECK_FIXNUM(argv[3]);
     ptrx = get_vector_ptr(argv[0], &stridex, &n);
     ptrw = get_vector_ptr(argv[1], &stridew, &n);
@@ -157,10 +156,10 @@ static VALUE rb_gsl_fit_wmul(int argc, VALUE *argv, VALUE obj)
     rb_raise(rb_eArgError, "wrong number of arguments (%d for 2 or 3)", argc);
     break;
   }
-  status = gsl_fit_wmul(ptrx, stridex, ptrw, stridew, ptry, stridey, 
-			n, &c1, &cov11, &sumsq);
-  return rb_ary_new3(4, rb_float_new(c1), 
-		     rb_float_new(cov11), rb_float_new(sumsq), INT2FIX(status));
+  status = gsl_fit_wmul(ptrx, stridex, ptrw, stridew, ptry, stridey,
+                        n, &c1, &cov11, &sumsq);
+  return rb_ary_new3(4, rb_float_new(c1),
+                     rb_float_new(cov11), rb_float_new(sumsq), INT2FIX(status));
 }
 
 static VALUE rb_gsl_fit_mul_est(int argc, VALUE *argv, VALUE obj)
@@ -195,7 +194,7 @@ static VALUE rb_gsl_fit_mul_est(int argc, VALUE *argv, VALUE obj)
 void Init_gsl_fit(VALUE module)
 {
   VALUE mgsl_fit;
-  mgsl_fit = rb_define_module_under(module, "Fit"); 
+  mgsl_fit = rb_define_module_under(module, "Fit");
   rb_define_module_function(mgsl_fit, "linear", rb_gsl_fit_linear, -1);
   rb_define_module_function(mgsl_fit, "wlinear", rb_gsl_fit_wlinear, -1);
   rb_define_module_function(mgsl_fit, "linear_est", rb_gsl_fit_linear_est, -1);

data/ext/gsl_native/fresnel.c

@@ -0,0 +1,312 @@
+/****************************************************************************
+ *              fresnel.c -
+ *  Calculation of Fresnel integrals by expansion to Chebyshev series
+ *  Expansions are taken from the book
+ *  Y.L. Luke. Mathematical functions and their approximations.
+ *  Moscow, "Mir", 1980. PP. 145-149 (Russian edition)
+ ****************************************************************************
+ */
+/*
+  Modified for Ruby bindings
+          2006/Dec/24 Y. TSUNESADA
+*/
+#include <math.h>
+#include "include/rb_gsl.h"
+#include "include/rb_gsl_sf.h"
+
+static const double sqrt_pi_2   = 1.2533141373155002512078826424; /* sqrt(pi/2) */
+static const double sqrt_2_pi   = 0.7978845608028653558798921199; /* sqrt(2/pi) */
+static const double _1_sqrt_2pi = 0.3989422804014326779399460599; /* 1/sqrt(2*pi) */
+static const double pi_2        = 1.5707963267948966192313216916; /* pi/2 */
+
+static double f_data_a[18] =
+{
+  0.76435138664186000189,
+  -0.43135547547660179313,
+  0.43288199979726653054,
+  -0.26973310338387111029,
+  0.08416045320876935378,
+  -0.01546524484461381958,
+  0.00187855423439822018,
+  -0.00016264977618887547,
+  0.00001057397656383260,
+  -0.00000053609339889243,
+  0.00000002181658454933,
+  -0.00000000072901621186,
+  0.00000000002037332546,
+  -0.00000000000048344033,
+  0.00000000000000986533,
+  -0.00000000000000017502,
+  0.00000000000000000272,
+  -0.00000000000000000004
+};
+
+static double f_data_b[17] =
+{
+  0.63041404314570539241,
+  -0.42344511405705333544,
+  0.37617172643343656625,
+  -0.16249489154509567415,
+  0.03822255778633008694,
+  -0.00564563477132190899,
+  0.00057454951976897367,
+  -0.00004287071532102004,
+  0.00000245120749923299,
+  -0.00000011098841840868,
+  0.00000000408249731696,
+  -0.00000000012449830219,
+  0.00000000000320048425,
+  -0.00000000000007032416,
+  0.00000000000000133638,
+  -0.00000000000000002219,
+  0.00000000000000000032
+};
+
+static double fresnel_cos_0_8(double x)
+{
+  double x_8 = x/8.0;
+  double xx = 2.0*x_8*x_8 - 1.0;
+
+  double t0 = 1.0;
+  double t1 = xx;
+  double sumC = f_data_a[0] + f_data_a[1]*t1;
+  double t2;
+  int n;
+  for (n = 2; n < 18; n++)
+  {
+    t2 = 2.0*xx*t1 - t0;
+    sumC += f_data_a[n]*t2;
+    t0 = t1; t1 = t2;
+  }
+  return _1_sqrt_2pi*sqrt(x)*sumC;
+}
+
+static double fresnel_sin_0_8(double x)
+{
+  double x_8 = x/8.0;
+  double xx = 2.0*x_8*x_8 - 1.0;
+  double t0 = 1.;
+  double t1 = xx;
+  double ot1 = x_8;
+  double ot2 = 2.0*x_8*t1 - ot1;
+  double sumS = f_data_b[0]*ot1 + f_data_b[1]*ot2;
+  int n;
+  double t2;
+  for (n = 2; n < 17; n++)
+  {
+    t2 = 2.0*xx*t1 - t0;
+    ot1 = ot2;
+    ot2 = 2.0*x_8*t2 - ot1;
+    sumS += f_data_b[n]*ot2;
+    t0 = t1; t1 = t2;
+  }
+  return _1_sqrt_2pi*sqrt(x)*sumS;
+}
+
+static double f_data_e[41] =
+{
+  0.97462779093296822410,
+  -0.02424701873969321371,
+  0.00103400906842977317,
+  -0.00008052450246908016,
+  0.00000905962481966582,
+  -0.00000131016996757743,
+  0.00000022770820391497,
+  -0.00000004558623552026,
+  0.00000001021567537083,
+  -0.00000000251114508133,
+  0.00000000066704761275,
+  -0.00000000018931512852,
+  0.00000000005689898935,
+  -0.00000000001798219359,
+  0.00000000000594162963,
+  -0.00000000000204285065,
+  0.00000000000072797580,
+  -0.00000000000026797428,
+  0.00000000000010160694,
+  -0.00000000000003958559,
+  0.00000000000001581262,
+  -0.00000000000000646411,
+  0.00000000000000269981,
+  -0.00000000000000115038,
+  0.00000000000000049942,
+  -0.00000000000000022064,
+  0.00000000000000009910,
+  -0.00000000000000004520,
+  0.00000000000000002092,
+  -0.00000000000000000982,
+  0.00000000000000000467,
+  -0.00000000000000000225,
+  0.00000000000000000110,
+  -0.00000000000000000054,
+  0.00000000000000000027,
+  -0.00000000000000000014,
+  0.00000000000000000007,
+  -0.00000000000000000004,
+  0.00000000000000000002,
+  -0.00000000000000000001,
+  0.00000000000000000001
+};
+
+static double f_data_f[35] =
+{
+  0.99461545179407928910,
+  -0.00524276766084297210,
+  0.00013325864229883909,
+  -0.00000770856452642713,
+  0.00000070848077032045,
+  -0.00000008812517411602,
+  0.00000001359784717148,
+  -0.00000000246858295747,
+  0.00000000050925789921,
+  -0.00000000011653400634,
+  0.00000000002906578309,
+  -0.00000000000779847361,
+  0.00000000000222802542,
+  -0.00000000000067239338,
+  0.00000000000021296411,
+  -0.00000000000007041482,
+  0.00000000000002419805,
+  -0.00000000000000861080,
+  0.00000000000000316287,
+  -0.00000000000000119596,
+  0.00000000000000046444,
+  -0.00000000000000018485,
+  0.00000000000000007527,
+  -0.00000000000000003131,
+  0.00000000000000001328,
+  -0.00000000000000000574,
+  0.00000000000000000252,
+  -0.00000000000000000113,
+  0.00000000000000000051,
+  -0.00000000000000000024,
+  0.00000000000000000011,
+  -0.00000000000000000005,
+  0.00000000000000000002,
+  -0.00000000000000000001,
+  0.00000000000000000001
+};
+
+static double fresnel_cos_8_inf(double x)
+{
+  double xx = 128.0/(x*x) - 1.0;  /* 2.0*(8/x)^2 - 1 */
+  double t0 = 1.0;
+  double t1 = xx;
+  double sumP = f_data_e[0] + f_data_e[1]*t1;
+  double sumQ = f_data_f[0] + f_data_f[1]*t1;
+  double t2;
+  int n;
+  for(n = 2; n < 35; n++)
+  {
+    t2 = 2.0*xx*t1 - t0;
+    sumP += f_data_e[n]*t2; /*  sumP += f_data_e[n]*ChebyshevT(n,xx) */
+    sumQ += f_data_f[n]*t2; /*  sumQ += f_data_f[n]*ChebyshevT(n,xx) */
+    t0 = t1; t1 = t2;
+  }
+  for(n = 35; n < 41; n++)
+  {
+    t2 = 2.0*xx*t1 - t0;
+    sumP += f_data_e[n]*t2; /*  sumP += f_data_e[n]*ChebyshevT(n,xx) */
+    t0 = t1; t1 = t2;
+  }
+  return 0.5 - _1_sqrt_2pi*(0.5*sumP*cos(x)/x - sumQ*sin(x))/sqrt(x);
+}
+
+static double fresnel_sin_8_inf(double x)
+{
+  double xx = 128.0/(x*x) - 1.0;  /* 2.0*(8/x)^2 - 1 */
+  double t0 = 1.0;
+  double t1 = xx;
+  double sumP = f_data_e[0] + f_data_e[1]*t1;
+  double sumQ = f_data_f[0] + f_data_f[1]*t1;
+  double t2;
+  int n;
+  for(n = 2; n < 35; n++)
+  {
+    t2 = 2.0*xx*t1 - t0;
+    sumP += f_data_e[n]*t2; /*  sumP += f_data_e[n]*ChebyshevT(n,xx) */
+    sumQ += f_data_f[n]*t2; /*  sumQ += f_data_f[n]*ChebyshevT(n,xx) */
+    t0 = t1; t1 = t2;
+  }
+  for(n = 35; n < 41; n++)
+  {
+    t2 = 2.0*xx*t1 - t0;
+    sumP += f_data_e[n]*t2; /*  sumQ += f_data_f[n]*ChebyshevT(n,xx) */
+    t0 = t1; t1 = t2;
+  }
+  return 0.5 - _1_sqrt_2pi*(0.5*sumP*sin(x)/x + sumQ*cos(x))/sqrt(x);
+}
+
+
+double fresnel_c(double x)
+{
+  double xx = x*x*pi_2;
+  double ret_val;
+  if(xx<=8.0)
+    ret_val = fresnel_cos_0_8(xx);
+  else
+    ret_val = fresnel_cos_8_inf(xx);
+  return (x<0.0) ? -ret_val : ret_val;
+}
+
+double fresnel_s(double x)
+{
+  double xx = x*x*pi_2;
+  double ret_val;
+  if(xx<=8.0)
+    ret_val = fresnel_sin_0_8(xx);
+  else
+    ret_val = fresnel_sin_8_inf(xx);
+  return (x<0.0) ? -ret_val : ret_val;
+}
+
+double fresnel_c1(double x)
+{
+  return fresnel_c(x*sqrt_2_pi);
+}
+
+double fresnel_s1(double x)
+{
+  return fresnel_s(x*sqrt_2_pi);
+}
+
+static VALUE rb_fresnel_c(VALUE obj, VALUE x)
+{
+  return rb_gsl_sf_eval1(fresnel_c, x);
+}
+static VALUE rb_fresnel_s(VALUE obj, VALUE x)
+{
+  return rb_gsl_sf_eval1(fresnel_s, x);
+}
+static VALUE rb_fresnel_c1(VALUE obj, VALUE x)
+{
+  return rb_gsl_sf_eval1(fresnel_c1, x);
+}
+static VALUE rb_fresnel_s1(VALUE obj, VALUE x)
+{
+  return rb_gsl_sf_eval1(fresnel_s1, x);
+}
+void Init_fresnel(VALUE module)
+{
+  VALUE mfresnel;
+  mfresnel = rb_define_module_under(module, "Fresnel");
+  rb_define_module_function(module, "fresnel_c", rb_fresnel_c, 1);
+  rb_define_module_function(module, "fresnel_s", rb_fresnel_s, 1);
+  rb_define_module_function(module, "fresnel_c1", rb_fresnel_c1, 1);
+  rb_define_module_function(module, "fresnel_s1", rb_fresnel_s1, 1);
+  rb_define_module_function(mfresnel, "c", rb_fresnel_c, 1);
+  rb_define_module_function(mfresnel, "s", rb_fresnel_s, 1);
+  rb_define_module_function(mfresnel, "c1", rb_fresnel_c1, 1);
+  rb_define_module_function(mfresnel, "s1", rb_fresnel_s1, 1);
+}
+
+
+
+
+
+
+
+
+
+
+

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

@@ -8,17 +8,14 @@
   This library is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY.
 */
-#include "rb_gsl_config.h"
-#include "rb_gsl_function.h"
-#ifdef HAVE_NARRAY_H
-#include "narray.h"
-#endif
+
+#include "include/rb_gsl_function.h"
 
 VALUE cgsl_function;
 VALUE cgsl_function_fdf;
 
 void gsl_function_free(gsl_function *f);
-double rb_gsl_function_f(double x, void *p); 
+double rb_gsl_function_f(double x, void *p);
 ID RBGSL_ID_call, RBGSL_ID_arity;
 
 static VALUE rb_gsl_function_set_f(int argc, VALUE *argv, VALUE obj)
@@ -52,11 +49,11 @@ static VALUE rb_gsl_function_set_f(int argc, VALUE *argv, VALUE obj)
     CHECK_PROC(argv[0]);
     rb_ary_store(ary, 0, argv[0]);
     ary2 = rb_ary_new2(argc-1);
-    for (i = 1; i < argc; i++) rb_ary_store(ary2, i-1, argv[i]);
+    for (i = 1; (int) i < argc; i++) rb_ary_store(ary2, i-1, argv[i]);
     rb_ary_store(ary, 1, ary2);
     break;
   }
-  if (rb_block_given_p()) rb_ary_store(ary, 0, RB_GSL_MAKE_PROC);
+  if (rb_block_given_p()) rb_ary_store(ary, 0, rb_block_proc());
   return obj;
 }
 
@@ -85,7 +82,7 @@ static VALUE rb_gsl_function_alloc(int argc, VALUE *argv, VALUE klass)
   obj = Data_Wrap_Struct(klass, gsl_function_mark, gsl_function_free, f);
   rb_gsl_function_set_f(argc, argv, obj);
   return obj;
-}			    
+}
 
 double rb_gsl_function_f(double x, void *p)
 {
@@ -108,10 +105,6 @@ static VALUE rb_gsl_function_eval(VALUE obj, VALUE x)
   gsl_vector *v = NULL, *vnew = NULL;
   gsl_matrix *m = NULL, *mnew = NULL;
   size_t i, j, n;
-#ifdef HAVE_NARRAY_H
-  double *ptr1, *ptr2;
-  struct NARRAY *na;
-#endif
   Data_Get_Struct(obj, gsl_function, F);
   ary = (VALUE) F->params;
   proc = rb_ary_entry(ary, 0);
@@ -141,16 +134,18 @@ static VALUE rb_gsl_function_eval(VALUE obj, VALUE x)
   default:
 #ifdef HAVE_NARRAY_H
     if (NA_IsNArray(x)) {
+      double *ptr1, *ptr2;
+      struct NARRAY *na;
       GetNArray(x, na);
       ptr1 = (double *) na->ptr;
       n = na->total;
       ary = na_make_object(NA_DFLOAT, na->rank, na->shape, CLASS_OF(x));
       ptr2 = NA_PTR_TYPE(ary, double*);
       for (i = 0; i < n; i++) {
-	x2 = rb_float_new(ptr1[i]);
-	if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2);
-	else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params);
-	ptr2[i] = NUM2DBL(result);
+        x2 = rb_float_new(ptr1[i]);
+        if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2);
+        else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params);
+        ptr2[i] = NUM2DBL(result);
       }
       return ary;
     }
@@ -159,22 +154,22 @@ static VALUE rb_gsl_function_eval(VALUE obj, VALUE x)
       Data_Get_Struct(x, gsl_vector, v);
       vnew = gsl_vector_alloc(v->size);
       for (i = 0; i < v->size; i++) {
-	x2 = rb_float_new(gsl_vector_get(v, i));
-	if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2);
-	else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params);
-	gsl_vector_set(vnew, i, NUM2DBL(result));
+        x2 = rb_float_new(gsl_vector_get(v, i));
+        if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2);
+        else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params);
+        gsl_vector_set(vnew, i, NUM2DBL(result));
       }
       return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, vnew);
     } else if (MATRIX_P(x)) {
       Data_Get_Struct(x, 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++) {
-	  x2 = rb_float_new(gsl_matrix_get(m, i, j));
-	  if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2);
-	  else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params);
-	  gsl_matrix_set(mnew, i, j, NUM2DBL(result));
-	}
+        for (j = 0; j < m->size2; j++) {
+          x2 = rb_float_new(gsl_matrix_get(m, i, j));
+          if (NIL_P(params)) result = rb_funcall(proc, RBGSL_ID_call, 1, x2);
+          else result = rb_funcall(proc, RBGSL_ID_call, 2, x2, params);
+          gsl_matrix_set(mnew, i, j, NUM2DBL(result));
+        }
       }
       return Data_Wrap_Struct(cgsl_matrix, 0, gsl_matrix_free, mnew);
     } else {
@@ -221,7 +216,7 @@ static VALUE rb_gsl_function_set_params(int argc, VALUE *argv, VALUE obj)
     rb_ary_store(ary, 1, argv[0]);
   } else {
     ary2 = rb_ary_new2(argc);
-    for (i = 0; i < argc; i++) rb_ary_store(ary2, i, argv[i]);
+    for (i = 0; (int) i < argc; i++) rb_ary_store(ary2, i, argv[i]);
     rb_ary_store(ary, 1, ary2);
   }
   return obj;
@@ -242,7 +237,7 @@ static VALUE rb_gsl_function_graph(int argc, VALUE *argv, VALUE obj)
   case 2:
     Check_Type(argv[1], T_STRING);
     strcpy(opt, STR2CSTR(argv[1]));
-    /* no break, do next */
+  /* no break, do next */
   case 1:
     if (CLASS_OF(argv[0]) == rb_cRange) argv[0] = rb_gsl_range2ary(argv[0]);
     if (TYPE(argv[0]) == T_ARRAY) {
@@ -250,16 +245,16 @@ static VALUE rb_gsl_function_graph(int argc, VALUE *argv, VALUE obj)
       n = RARRAY_LEN(argv[0]);
       v = gsl_vector_alloc(n);
       flag = 1;
-      for (i = 0; i < n; i++) 
-	gsl_vector_set(v, i, NUM2DBL(rb_ary_entry(argv[0], i)));
+      for (i = 0; i < n; i++)
+        gsl_vector_set(v, i, NUM2DBL(rb_ary_entry(argv[0], i)));
     } else if (rb_obj_is_kind_of(argv[0], cgsl_vector)) {
       Data_Get_Struct(argv[0], gsl_vector, v);
       n = v->size;
       flag = 0;
     } else {
-      rb_raise(rb_eTypeError, 
-	       "wrong argument type %s (Array or GSL::Vector expected)", 
-	       rb_class2name(CLASS_OF(argv[0])));
+      rb_raise(rb_eTypeError,
+               "wrong argument type %s (Array or GSL::Vector expected)",
+               rb_class2name(CLASS_OF(argv[0])));
     }
     break;
   default:
@@ -281,7 +276,7 @@ static VALUE rb_gsl_function_graph(int argc, VALUE *argv, VALUE obj)
     fprintf(fp, "%e %e\n", x, y);
   }
   fflush(fp);
- pclose(fp);
+  pclose(fp);
   fp = NULL;
   if (flag == 1) gsl_vector_free(v);
   return Qtrue;
@@ -310,15 +305,14 @@ static void setfunc(int i, VALUE *argv, gsl_function_fdf *F)
   } else {
     ary = (VALUE) F->params;
   }
-
   if (rb_obj_is_kind_of(argv[i], rb_cProc)) {
     rb_ary_store(ary, i, 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) {
+  } 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) {
     rb_ary_store(ary, 3, argv[i]);
   } else {
-    rb_raise(rb_eArgError, 
-	     "wrong type argument (Proc, Array, GSL::Vector or a number)");
+    rb_raise(rb_eArgError,
+             "wrong type argument (Proc, Array, GSL::Vector or a number)");
   }
 }
 
@@ -337,7 +331,7 @@ static VALUE rb_gsl_function_fdf_new(int argc, VALUE *argv, VALUE klass)
   F->params = (void *) ary;
   rb_ary_store(ary, 2, Qnil);
   rb_ary_store(ary, 3, Qnil);
-  for (i = 0; i < argc; i++) setfunc(i, argv, F);
+  for (i = 0; (int) i < argc; i++) setfunc(i, argv, F);
   return Data_Wrap_Struct(klass, gsl_function_fdf_mark, gsl_function_fdf_free, F);
 }
 
@@ -360,7 +354,7 @@ static VALUE rb_gsl_function_fdf_set(int argc, VALUE *argv, VALUE obj)
   ary = (VALUE) F->params;
   rb_ary_store(ary, 2, Qnil);
   rb_ary_store(ary, 3, Qnil);
-  for (i = 0; i < argc; i++) setfunc(i, argv, F);
+  for (i = 0; (int) i < argc; i++) setfunc(i, argv, F);
   return obj;
 }
 
@@ -427,7 +421,7 @@ static VALUE rb_gsl_function_fdf_set_params(int argc, VALUE *argv, VALUE obj)
     rb_ary_store(ary, 3, argv[0]);
   } else {
     ary2 = rb_ary_new2(argc);
-    for (i = 0; i < argc; i++) rb_ary_store(ary2, i, argv[i]);
+    for (i = 0; (int) i < argc; i++) rb_ary_store(ary2, i, argv[i]);
     rb_ary_store(ary, 3, ary2);
   }
   return obj;