rb-gsl 1.16.0.4 → 1.16.0.5

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

@@ -13,7 +13,7 @@
 
 static VALUE rb_gsl_sf_sin(VALUE obj, VALUE x)
 {
-  if (COMPLEX_P(x) || VECTOR_COMPLEX_P(x) || MATRIX_COMPLEX_P(x)) 
+  if (COMPLEX_P(x) || VECTOR_COMPLEX_P(x) || MATRIX_COMPLEX_P(x))
     return rb_gsl_math_complex_eval(gsl_complex_sin, x);
   return rb_gsl_sf_eval1(gsl_sf_sin, x);
 }
@@ -25,7 +25,7 @@ static VALUE rb_gsl_sf_sin_e(VALUE obj, VALUE x)
 
 static VALUE rb_gsl_sf_cos(VALUE obj, VALUE x)
 {
-  if (COMPLEX_P(x) || VECTOR_COMPLEX_P(x) || MATRIX_COMPLEX_P(x)) 
+  if (COMPLEX_P(x) || VECTOR_COMPLEX_P(x) || MATRIX_COMPLEX_P(x))
     return rb_gsl_math_complex_eval(gsl_complex_cos, x);
   return rb_gsl_sf_eval1(gsl_sf_cos, x);
 }
@@ -57,7 +57,7 @@ static VALUE rb_gsl_sf_sinc_e(VALUE obj, VALUE x)
 }
 
 static VALUE rb_gsl_sf_complex_XXX_e(int argc, VALUE *argv, VALUE obj,
-				     int (*f)(double, double, gsl_sf_result*, gsl_sf_result*))
+                                     int (*f)(double, double, gsl_sf_result*, gsl_sf_result*))
 {
   gsl_sf_result *r1, *r2;
   gsl_complex *z;

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

@@ -68,7 +68,6 @@ static VALUE rb_gsl_sf_eta_e(VALUE obj, VALUE x)
   return rb_gsl_sf_eval_e(gsl_sf_eta_e, x);
 }
 
-#ifdef GSL_1_4_9_LATER
 static VALUE rb_gsl_sf_zetam1_int(VALUE obj, VALUE n)
 {
   VALUE nn;
@@ -94,7 +93,6 @@ static VALUE rb_gsl_sf_zetam1_e(VALUE obj, VALUE x)
 {
   return rb_gsl_sf_eval_e(gsl_sf_zetam1_e, x);
 }
-#endif
 
 void Init_gsl_sf_zeta(VALUE module)
 {
@@ -110,10 +108,8 @@ void Init_gsl_sf_zeta(VALUE module)
   rb_define_module_function(module, "eta",  rb_gsl_sf_eta, 1);
   rb_define_module_function(module, "eta_e",  rb_gsl_sf_eta_e, 1);
 
-#ifdef GSL_1_4_9_LATER
   rb_define_module_function(module, "zetam1_int",  rb_gsl_sf_zetam1_int, 1);
   rb_define_module_function(module, "zetam1_int_e",  rb_gsl_sf_zetam1_int_e, 1);
   rb_define_module_function(module, "zetam1",  rb_gsl_sf_zetam1, 1);
   rb_define_module_function(module, "zetam1_e",  rb_gsl_sf_zetam1_e, 1);
-#endif
 }

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

@@ -16,43 +16,43 @@ enum FFT_CONV_CORR {
   RB_GSL_FFT_CORRELATE = 1,
   RB_GSL_FFT_REAL = 2,
   RB_GSL_FFT_HALFCOMPLEX = 3,
-  RB_GSL_FFT_DECONVOLVE = 4,  
+  RB_GSL_FFT_DECONVOLVE = 4,
 };
 
 #ifndef WAVETABLE_P
-#define WAVETABLE_P(x) (rb_obj_is_kind_of(x,cgsl_fft_halfcomplex_wavetable)?1:0)
+#define WAVETABLE_P(x) (rb_obj_is_kind_of(x,cgsl_fft_halfcomplex_wavetable) ? 1 : 0)
 #endif
 
 #ifndef CHECK_WAVETABLE
-#define CHECK_WAVETABLE(x) if(!rb_obj_is_kind_of(x,cgsl_fft_halfcomplex_wavetable))\
+#define CHECK_WAVETABLE(x) if(!rb_obj_is_kind_of(x,cgsl_fft_halfcomplex_wavetable)) \
     rb_raise(rb_eTypeError, "wrong argument type (FFT::HalfComplex::Wavetable expected)");
 #endif
 
 #ifndef WORKSPACE_P
-#define WORKSPACE_P(x) (rb_obj_is_kind_of(x,cgsl_fft_real_workspace)?1:0)
+#define WORKSPACE_P(x) (rb_obj_is_kind_of(x,cgsl_fft_real_workspace) ? 1 : 0)
 #endif
 
 #ifndef CHECK_WORKSPACE
-#define CHECK_WORKSPACE(x) if(!rb_obj_is_kind_of(x,cgsl_fft_real_workspace))\
+#define CHECK_WORKSPACE(x) if(!rb_obj_is_kind_of(x,cgsl_fft_real_workspace)) \
     rb_raise(rb_eTypeError, "wrong argument type (FFT::Real::Workspace expected)");
 #endif
 
 static void complex_mul(double re1, double im1, double re2, double im2,
-      double *re, double *im)
+                        double *re, double *im)
 {
   *re = re1*re2 - im1*im2;
   *im = re1*im2 + im1*re2;
 }
 
 static void complex_conj_mul(double re1, double im1, double re2, double im2,
-      double *re, double *im)
+                             double *re, double *im)
 {
   *re = re1*re2 + im1*im2;
   *im = -re1*im2 + im1*re2;
 }
 
 static void complex_div(double re1, double im1, double re2, double im2,
-      double *re, double *im)
+                        double *re, double *im)
 {
   double factor = re2*re2 + im2*im2;
   complex_conj_mul(re1, im1, re2, im2, re, im);
@@ -61,55 +61,50 @@ static void complex_div(double re1, double im1, double re2, double im2,
 }
 
 /* data1, data2: FFTed data */
-static void rbgsl_calc_conv_corr_c(const double *data1, const double *data2, 
-     double *data3, size_t size,
-     gsl_fft_halfcomplex_wavetable *table,
-     gsl_fft_real_workspace *space, enum FFT_CONV_CORR calcflag)
+static void rbgsl_calc_conv_corr_c(const double *data1, const double *data2,
+                                   double *data3, size_t size,
+                                   gsl_fft_halfcomplex_wavetable *table,
+                                   gsl_fft_real_workspace *space, enum FFT_CONV_CORR calcflag)
 {
   size_t i;
   double re1, re2, im1, im2;
   void (*complex_cal)(double, double, double, double, double*, double*);
-  
+
   switch (calcflag) {
   case RB_GSL_FFT_CONVOLVE:
     complex_cal = complex_mul;
     data3[0] = data1[0]*data2[0];
-    data3[size-1] = data1[size-1]*data2[size-1];    
+    data3[size-1] = data1[size-1]*data2[size-1];
     break;
-  case RB_GSL_FFT_CORRELATE:  
-    data3[0] = data1[0]*data2[0];  
-    data3[size-1] = data1[size-1]*data2[size-1];        
+  case RB_GSL_FFT_CORRELATE:
+    data3[0] = data1[0]*data2[0];
+    data3[size-1] = data1[size-1]*data2[size-1];
     complex_cal = complex_conj_mul;
     break;
   case RB_GSL_FFT_DECONVOLVE:
     complex_cal = complex_div;
     data3[0] = data1[0]/data2[0];
-    data3[size-1] = data1[size-1]/data2[size-1];       
+    data3[size-1] = data1[size-1]/data2[size-1];
     break;
   default:
     rb_raise(rb_eArgError, "Wrong flag.");
     break;
   }
-  
-  for (i = 1; i < size-1; i+=2) {
+
+  for (i = 1; i < size-1; i += 2) {
     re1 = data1[i];    im1 = data1[i+1];
     re2 = data2[i];    im2 = data2[i+1];
     (*complex_cal)(re1, im1, re2, im2, &data3[i], &data3[i+1]);
   }
-
 }
 
 static VALUE rb_gsl_fft_conv_corr(int argc, VALUE *argv, VALUE obj,
-        enum FFT_CONV_CORR flag1,
-        enum FFT_CONV_CORR flag2)
+                                  enum FFT_CONV_CORR flag1,
+                                  enum FFT_CONV_CORR flag2)
 {
   double *data1, *data2, *data3 = NULL;
   size_t stride1, stride2, size1, size2;
-#ifdef HAVE_NARRAY_H
-  int naflag1, naflag2, shape;
-#else
   int naflag1, naflag2;
-#endif
   gsl_vector *v = NULL;
   gsl_fft_halfcomplex_wavetable *table = NULL;
   gsl_fft_real_wavetable *rtable = NULL;
@@ -139,10 +134,10 @@ static VALUE rb_gsl_fft_conv_corr(int argc, VALUE *argv, VALUE obj,
       table = gsl_fft_halfcomplex_wavetable_alloc(size1);
       flagt = 1;
     } else {
-      rb_raise(rb_eTypeError, 
-         "wrong argument type %s "
-         "(FFT::HalfComplex::Wavetable or FFT::Real::Workspace expected)", 
-         rb_class2name(CLASS_OF(argv[2])));
+      rb_raise(rb_eTypeError,
+               "wrong argument type %s "
+               "(FFT::HalfComplex::Wavetable or FFT::Real::Workspace expected)",
+               rb_class2name(CLASS_OF(argv[2])));
     }
     break;
   case 1:
@@ -164,7 +159,7 @@ static VALUE rb_gsl_fft_conv_corr(int argc, VALUE *argv, VALUE obj,
     case RB_GSL_FFT_REAL:
       ary = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v);
       break;
-    default:      
+    default:
       ary = Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v);
       break;
     }
@@ -172,9 +167,11 @@ static VALUE rb_gsl_fft_conv_corr(int argc, VALUE *argv, VALUE obj,
     break;
   case 1:
 #ifdef HAVE_NARRAY_H
-    shape = (int) size1;
-    ary = na_make_object(NA_DFLOAT, 1, &shape, cNArray);
-    data3 = NA_PTR_TYPE(ary, double*);
+    {
+      int shape = (int) size1;
+      ary = na_make_object(NA_DFLOAT, 1, &shape, cNArray);
+      data3 = NA_PTR_TYPE(ary, double*);
+    }
 #endif
     break;
   default:
@@ -190,10 +187,10 @@ static VALUE rb_gsl_fft_conv_corr(int argc, VALUE *argv, VALUE obj,
     data2 = vtmp2->data;
     rtable = gsl_fft_real_wavetable_alloc(size1);
     if (size1 == space->n) {
-      gsl_fft_real_transform(data1, stride1, size1, rtable, space); 
+      gsl_fft_real_transform(data1, stride1, size1, rtable, space);
     } else {
       space2 = gsl_fft_real_workspace_alloc(size1);
-      gsl_fft_real_transform(data1, stride1, size1, rtable, space2); 
+      gsl_fft_real_transform(data1, stride1, size1, rtable, space2);
       /* no freeing space2 here */
     }
     if (size1 != size2) {
@@ -201,14 +198,14 @@ static VALUE rb_gsl_fft_conv_corr(int argc, VALUE *argv, VALUE obj,
       rtable = gsl_fft_real_wavetable_alloc(size2);
     }
     if (size2 == space->n) {
-      gsl_fft_real_transform(data2, stride2, size2, rtable, space); 
+      gsl_fft_real_transform(data2, stride2, size2, rtable, space);
     } else if (size2 == size1) {
-      gsl_fft_real_transform(data2, stride2, size2, rtable, space2); 
+      gsl_fft_real_transform(data2, stride2, size2, rtable, space2);
       gsl_fft_real_workspace_free(space2);
     } else {
       if (space2) gsl_fft_real_workspace_free(space2);
       space2 = gsl_fft_real_workspace_alloc(size2);
-      gsl_fft_real_transform(data2, stride2, size2, rtable, space2); 
+      gsl_fft_real_transform(data2, stride2, size2, rtable, space2);
       gsl_fft_real_workspace_free(space2);
     }
     gsl_fft_real_wavetable_free(rtable);
@@ -222,14 +219,13 @@ static VALUE rb_gsl_fft_conv_corr(int argc, VALUE *argv, VALUE obj,
     /* not occur */
     break;
   }
-  
+
   rbgsl_calc_conv_corr_c(data1, data2, data3, size1, table, space, flag2);
 
   if (flag1 == RB_GSL_FFT_REAL) {
     gsl_fft_halfcomplex_inverse(data3, 1, size1, table, space);
 //    for (i = 0; i < size1; i++) data3[i] /= size1;
   }
-  
   if (flagt == 1) gsl_fft_halfcomplex_wavetable_free(table);
   if (flagw == 1) gsl_fft_real_workspace_free(space);
   if (vtmp1) gsl_vector_free(vtmp1);
@@ -240,61 +236,61 @@ static VALUE rb_gsl_fft_conv_corr(int argc, VALUE *argv, VALUE obj,
 /* GSL::Vector#convolve */
 static VALUE rb_gsl_fft_real_convolve(int argc, VALUE *argv, VALUE obj)
 {
-  return rb_gsl_fft_conv_corr(argc, argv, obj, 
-          RB_GSL_FFT_REAL,
-          RB_GSL_FFT_CONVOLVE);
+  return rb_gsl_fft_conv_corr(argc, argv, obj,
+                              RB_GSL_FFT_REAL,
+                              RB_GSL_FFT_CONVOLVE);
 }
 /* GSL::Vector#deconvolve */
 static VALUE rb_gsl_fft_real_deconvolve(int argc, VALUE *argv, VALUE obj)
 {
-  return rb_gsl_fft_conv_corr(argc, argv, obj, 
-            RB_GSL_FFT_REAL,
-            RB_GSL_FFT_DECONVOLVE);
+  return rb_gsl_fft_conv_corr(argc, argv, obj,
+                              RB_GSL_FFT_REAL,
+                              RB_GSL_FFT_DECONVOLVE);
 }
 
 /* GSL::Vector#correlate */
 static VALUE rb_gsl_fft_real_correlate(int argc, VALUE *argv, VALUE obj)
 {
-  return rb_gsl_fft_conv_corr(argc, argv, obj, 
-            RB_GSL_FFT_REAL,
-            RB_GSL_FFT_CORRELATE);
+  return rb_gsl_fft_conv_corr(argc, argv, obj,
+                              RB_GSL_FFT_REAL,
+                              RB_GSL_FFT_CORRELATE);
 }
 
 /* GSL::Vector#halfcomplex_convolve */
 static VALUE rb_gsl_fft_halfcomplex_convolve(int argc, VALUE *argv, VALUE obj)
 {
-  return rb_gsl_fft_conv_corr(argc, argv, obj, 
-          RB_GSL_FFT_HALFCOMPLEX,
-          RB_GSL_FFT_CONVOLVE);
+  return rb_gsl_fft_conv_corr(argc, argv, obj,
+                              RB_GSL_FFT_HALFCOMPLEX,
+                              RB_GSL_FFT_CONVOLVE);
 }
 /* GSL::Vector#halfcomplex_deconvolve */
 static VALUE rb_gsl_fft_halfcomplex_deconvolve(int argc, VALUE *argv, VALUE obj)
 {
-  return rb_gsl_fft_conv_corr(argc, argv, obj, 
-            RB_GSL_FFT_HALFCOMPLEX,
-            RB_GSL_FFT_DECONVOLVE);
+  return rb_gsl_fft_conv_corr(argc, argv, obj,
+                              RB_GSL_FFT_HALFCOMPLEX,
+                              RB_GSL_FFT_DECONVOLVE);
 }
 /* GSL::Vector#halfcomplex_correlate */
 static VALUE rb_gsl_fft_halfcomplex_correlate(int argc, VALUE *argv, VALUE obj)
 {
-  return rb_gsl_fft_conv_corr(argc, argv, obj, 
-            RB_GSL_FFT_HALFCOMPLEX,
-            RB_GSL_FFT_CORRELATE);
+  return rb_gsl_fft_conv_corr(argc, argv, obj,
+                              RB_GSL_FFT_HALFCOMPLEX,
+                              RB_GSL_FFT_CORRELATE);
 }
 
 void Init_gsl_signal(VALUE module)
 {
   rb_define_method(cgsl_vector, "real_convolve", rb_gsl_fft_real_convolve, -1);
-  rb_define_method(cgsl_vector, "real_deconvolve", rb_gsl_fft_real_deconvolve, -1);			     
-  rb_define_method(cgsl_vector, "real_correlate", rb_gsl_fft_real_correlate, -1);	
+  rb_define_method(cgsl_vector, "real_deconvolve", rb_gsl_fft_real_deconvolve, -1);
+  rb_define_method(cgsl_vector, "real_correlate", rb_gsl_fft_real_correlate, -1);
 
   rb_define_alias(cgsl_vector, "convolve", "real_convolve");
   rb_define_alias(cgsl_vector, "deconvolve", "real_deconvolve");
   rb_define_alias(cgsl_vector, "correlate", "real_correlate");
 
   rb_define_method(cgsl_vector, "halfcomplex_convolve", rb_gsl_fft_halfcomplex_convolve, -1);
-  rb_define_method(cgsl_vector, "halfcomplex_deconvolve", rb_gsl_fft_halfcomplex_deconvolve, -1);			     
-  rb_define_method(cgsl_vector, "halfcomplex_correlate", rb_gsl_fft_halfcomplex_correlate, -1);			     
+  rb_define_method(cgsl_vector, "halfcomplex_deconvolve", rb_gsl_fft_halfcomplex_deconvolve, -1);
+  rb_define_method(cgsl_vector, "halfcomplex_correlate", rb_gsl_fft_halfcomplex_correlate, -1);
 
   rb_define_alias(cgsl_vector, "hc_convolve", "halfcomplex_convolve");
   rb_define_alias(cgsl_vector, "hc_deconvolve", "halfcomplex_deconvolve");

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

@@ -331,7 +331,7 @@ static siman_metric* siman_metric_alloc()
   se = ALLOC(siman_metric);
   if (se == NULL) rb_raise(rb_eRuntimeError, "ALLOC failed");
   se->siman_metric_t = &rb_gsl_siman_metric_t;
-   return se;
+  return se;
 }
 
 static void siman_metric_mark(siman_metric *se)
@@ -419,22 +419,22 @@ static VALUE rb_gsl_siman_params_set(int argc, VALUE *argv, VALUE obj)
   switch (argc) {
   case 7:
     params->t_min = NUM2DBL(argv[6]);
-    /* no break */
+  /* no break */
   case 6:
     params->mu_t = NUM2DBL(argv[5]);
-    /* no break */
+  /* no break */
   case 5:
     params->t_initial = NUM2DBL(argv[4]);
-    /* no break */
+  /* no break */
   case 4:
     params->k = NUM2DBL(argv[3]);
-    /* no break */
+  /* no break */
   case 3:
     params->step_size = NUM2DBL(argv[2]);
-    /* no break */
+  /* no break */
   case 2:
     params->iters_fixed_T = NUM2INT(argv[1]);
-    /* no break */
+  /* no break */
   case 1:
     params->n_tries = NUM2INT(argv[0]);
   }
@@ -551,16 +551,16 @@ static VALUE rb_gsl_siman_params_params(VALUE obj)
   gsl_siman_params_t *params = NULL;
   Data_Get_Struct(obj, gsl_siman_params_t, params);
   return rb_ary_new3(7, INT2FIX(params->n_tries), INT2FIX(params->iters_fixed_T),
-		     rb_float_new(params->step_size), rb_float_new(params->k),
-		     rb_float_new(params->t_initial), rb_float_new(params->mu_t),
-		     rb_float_new(params->t_min));
+                     rb_float_new(params->step_size), rb_float_new(params->k),
+                     rb_float_new(params->t_initial), rb_float_new(params->mu_t),
+                     rb_float_new(params->t_min));
 }
 
 /***** solver *****/
 static VALUE rb_gsl_siman_solver_solve(VALUE obj, VALUE rng,
-				       VALUE vx0p, VALUE vefunc,
-				       VALUE vstep, VALUE vmetric, VALUE vprint,
-				       VALUE vparams)
+                                       VALUE vx0p, VALUE vefunc,
+                                       VALUE vstep, VALUE vmetric, VALUE vprint,
+                                       VALUE vparams)
 {
   gsl_rng *r = NULL;
   siman_solver *ss = NULL;
@@ -587,17 +587,16 @@ static VALUE rb_gsl_siman_solver_solve(VALUE obj, VALUE rng,
   }
   if (!rb_obj_is_kind_of(rng, cgsl_rng))
     rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Rng expected)",
-	     rb_class2name(CLASS_OF(rng)));
+             rb_class2name(CLASS_OF(rng)));
   if (!rb_obj_is_kind_of(vefunc, cgsl_siman_Efunc))
     rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Siman::Efunc expected)",
-	     rb_class2name(CLASS_OF(vefunc)));
+             rb_class2name(CLASS_OF(vefunc)));
   if (!rb_obj_is_kind_of(vstep, cgsl_siman_step))
     rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Siman::Step expected)",
-	     rb_class2name(CLASS_OF(vstep)));
+             rb_class2name(CLASS_OF(vstep)));
   if (!rb_obj_is_kind_of(vmetric, cgsl_siman_metric))
     rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Siman::Metric expected)",
-	     rb_class2name(CLASS_OF(vmetric)));
-
+             rb_class2name(CLASS_OF(vmetric)));
   Data_Get_Struct(rng, gsl_rng, r);
   Data_Get_Struct(vefunc, siman_Efunc, efunc);
   Data_Get_Struct(vstep, siman_step, step);
@@ -607,14 +606,13 @@ static VALUE rb_gsl_siman_solver_solve(VALUE obj, VALUE rng,
   } else {
     if (!rb_obj_is_kind_of(vprint, cgsl_siman_print))
       rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Siman::Print expected)",
-	       rb_class2name(CLASS_OF(vprint)));
+               rb_class2name(CLASS_OF(vprint)));
     Data_Get_Struct(vprint, siman_print, print);
     ss->proc_print   = print->proc;
   }
   if (!rb_obj_is_kind_of(vparams, cgsl_siman_params))
     rb_raise(rb_eTypeError, "wrong argument type %s (GSL::Siman::Params expected)",
-	     rb_class2name(CLASS_OF(vparams)));
-
+             rb_class2name(CLASS_OF(vparams)));
   Data_Get_Struct(vparams, gsl_siman_params_t, params);
 
   ss->proc_efunc   = efunc->proc;
@@ -624,30 +622,28 @@ static VALUE rb_gsl_siman_solver_solve(VALUE obj, VALUE rng,
   gsl_vector_memcpy(ss->vx, vtmp);
 
   if (NIL_P(vprint)) {
-    gsl_siman_solve(r, ss, rb_gsl_siman_Efunc_t, 
-		    rb_gsl_siman_step_t, 
-		    rb_gsl_siman_metric_t, 
-		    NULL,
-		    rb_gsl_siman_copy_t, 
-		    rb_gsl_siman_copy_construct_t,
-		    rb_gsl_siman_destroy_t, 0,
-		    *params);
+    gsl_siman_solve(r, ss, rb_gsl_siman_Efunc_t,
+                    rb_gsl_siman_step_t,
+                    rb_gsl_siman_metric_t,
+                    NULL,
+                    rb_gsl_siman_copy_t,
+                    rb_gsl_siman_copy_construct_t,
+                    rb_gsl_siman_destroy_t, 0,
+                    *params);
 
   } else {
-    gsl_siman_solve(r, ss, rb_gsl_siman_Efunc_t, 
-		    rb_gsl_siman_step_t, 
-		    rb_gsl_siman_metric_t, 
-		    rb_gsl_siman_print_t, 
-		    rb_gsl_siman_copy_t, 
-		    rb_gsl_siman_copy_construct_t,
-		    rb_gsl_siman_destroy_t, 0,
-		    *params);
+    gsl_siman_solve(r, ss, rb_gsl_siman_Efunc_t,
+                    rb_gsl_siman_step_t,
+                    rb_gsl_siman_metric_t,
+                    rb_gsl_siman_print_t,
+                    rb_gsl_siman_copy_t,
+                    rb_gsl_siman_copy_construct_t,
+                    rb_gsl_siman_destroy_t, 0,
+                    *params);
   }
-
   gsl_vector_memcpy(vtmp, ss->vx);
 
   if (flag == 1) gsl_siman_solver_free(ss);
-
   return obj;
 }
 
@@ -681,7 +677,7 @@ void Init_gsl_siman(VALUE module)
   rb_define_singleton_method(cgsl_siman_metric, "alloc", rb_gsl_siman_metric_new, -1);
   rb_define_method(cgsl_siman_metric, "set", rb_gsl_siman_metric_set, -1);
   rb_define_alias(cgsl_siman_metric, "set_proc", "set");
-  
+
   /***** params *****/
   rb_define_singleton_method(cgsl_siman_params, "alloc", rb_gsl_siman_params_new, -1);
   rb_define_method(cgsl_siman_params, "set", rb_gsl_siman_params_set, -1);