gsl 1.15.3 → 1.16.0.6

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

@@ -9,18 +9,18 @@
   WITHOUT ANY WARRANTY.
 */
 
-#include "rb_gsl_sf.h"
+#include "include/rb_gsl_sf.h"
 
 static VALUE rb_gsl_sf_log(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_log, x);
   return rb_gsl_sf_eval1(gsl_sf_log, x);
 }
 
 static VALUE rb_gsl_sf_log10(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_log10, x);
   return rb_gsl_sf_eval1(log10, x);
 }
@@ -93,7 +93,7 @@ static VALUE rb_gsl_sf_log_1plusx_mx_e(VALUE obj, VALUE x)
 void Init_gsl_sf_log(VALUE module)
 {
   rb_define_module_function(module, "log",  rb_gsl_sf_log, 1);
-  rb_define_module_function(module, "log10",  rb_gsl_sf_log10, 1);  
+  rb_define_module_function(module, "log10",  rb_gsl_sf_log10, 1);
   rb_define_module_function(module, "log_e",  rb_gsl_sf_log_e, 1);
   rb_define_module_function(module, "log_abs",  rb_gsl_sf_log_abs, 1);
   rb_define_module_function(module, "log_abs_e",  rb_gsl_sf_log_abs_e, 1);

data/ext/gsl_native/sf_mathieu.c

@@ -0,0 +1,235 @@
+#include "include/rb_gsl.h"
+
+static VALUE cWorkspace;
+
+static VALUE rb_gsl_sf_mathieu_alloc(VALUE klass, VALUE n, VALUE q)
+{
+  gsl_sf_mathieu_workspace *w;
+  w = gsl_sf_mathieu_alloc((size_t) FIX2INT(n), NUM2DBL(q));
+  return Data_Wrap_Struct(klass, 0, gsl_sf_mathieu_free, w);
+}
+
+static VALUE sf_mathieu_eval(VALUE order, VALUE qq,
+                             int (*f)(int, double, gsl_sf_result*))
+{
+  gsl_sf_result r;
+  (*f)(FIX2INT(order), NUM2DBL(qq), &r);
+  return rb_float_new(r.val);
+}
+
+static VALUE sf_mathieu_eval2(VALUE n1, VALUE n2, VALUE q, VALUE x,
+                              int (*f)(int, int, double, double, gsl_sf_result*))
+{
+  gsl_sf_result r;
+  (*f)(FIX2INT(n1),FIX2INT(n2),  NUM2DBL(q), NUM2DBL(x), &r);
+  return rb_float_new(r.val);
+}
+
+static VALUE sf_mathieu_array_eval(int argc, VALUE *argv,
+                                   int (*f)(int, int, double, gsl_sf_mathieu_workspace*, double[]))
+{
+  gsl_sf_mathieu_workspace *w;
+  gsl_vector *v;
+  int n1, n2;
+  double q;
+  switch (argc) {
+  case 4:
+    if (!rb_obj_is_kind_of(argv[3], cWorkspace)) {
+      rb_raise(rb_eTypeError, "Wrong argument type 3 (%s detected, %s expected)",
+               rb_class2name(CLASS_OF(argv[3])), rb_class2name(cWorkspace));
+    }
+    n1 = FIX2INT(argv[0]);
+    n2 = FIX2INT(argv[1]);
+    q = NUM2DBL(argv[2]);
+    Data_Get_Struct(argv[3], gsl_sf_mathieu_workspace, w);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Wrong number of arguments. (%d for 4)", argc);
+  }
+  v = gsl_vector_alloc(n2 - n1 + 1);
+  (*f)(n1, n2, q, w, v->data);
+  return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v);
+}
+
+static VALUE sf_mathieu_array_eval2(int argc, VALUE *argv,
+                                    int (*f)(int, int,  double, double, gsl_sf_mathieu_workspace*, double[]))
+{
+  gsl_sf_mathieu_workspace *w;
+  gsl_vector *v;
+  int n1, n2;
+  double q, x;
+  switch (argc) {
+  case 5:
+    if (!rb_obj_is_kind_of(argv[4], cWorkspace)) {
+      rb_raise(rb_eTypeError, "Wrong argument type 4 (%s detected, %s expected)",
+               rb_class2name(CLASS_OF(argv[4])), rb_class2name(cWorkspace));
+    }
+    n1 = FIX2INT(argv[0]);
+    n2 = FIX2INT(argv[1]);
+    q = NUM2DBL(argv[2]);
+    x = NUM2DBL(argv[3]);
+    Data_Get_Struct(argv[4], gsl_sf_mathieu_workspace, w);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Wrong number of arguments. (%d for 5)", argc);
+  }
+  v = gsl_vector_alloc(n2 - n1 + 1);
+  (*f)(n1, n2, q, x, w, v->data);
+  return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v);
+}
+static VALUE sf_mathieu_array_eval3(int argc, VALUE *argv,
+                                    int (*f)(int, int, int, double, double, gsl_sf_mathieu_workspace*, double[]))
+{
+  gsl_sf_mathieu_workspace *w;
+  gsl_vector *v;
+  int n1, n2, n3;
+  double q, x;
+  switch (argc) {
+  case 6:
+    if (!rb_obj_is_kind_of(argv[5], cWorkspace)) {
+      rb_raise(rb_eTypeError, "Wrong argument type 5 (%s detected, %s expected)",
+               rb_class2name(CLASS_OF(argv[5])), rb_class2name(cWorkspace));
+    }
+    n1 = FIX2INT(argv[0]);
+    n2 = FIX2INT(argv[1]);
+    n3 = FIX2INT(argv[2]);
+    q = NUM2DBL(argv[3]);
+    x = NUM2DBL(argv[4]);
+    Data_Get_Struct(argv[5], gsl_sf_mathieu_workspace, w);
+    break;
+  default:
+    rb_raise(rb_eArgError, "Wrong number of arguments. (%d for 6)", argc);
+  }
+  v = gsl_vector_alloc(n3 - n2 + 1);
+  (*f)(n1, n2, n3, q, x, w, v->data);
+  return Data_Wrap_Struct(cgsl_vector, 0, gsl_vector_free, v);
+}
+static VALUE sf_mathieu_eval_int_double2(VALUE order, VALUE qq, VALUE zz,
+                                         int (*f)(int, double, double, gsl_sf_result*))
+{
+  gsl_sf_result r;
+  (*f)(FIX2INT(order), NUM2DBL(qq), NUM2DBL(zz), &r);
+  return rb_float_new(r.val);
+}
+static VALUE sf_mathieu_eval_e_int_double2(VALUE order, VALUE qq, VALUE zz,
+                                           int (*f)(int, double, double, gsl_sf_result*))
+{
+  gsl_sf_result *r;
+  VALUE val;
+  val = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, r);
+  (*f)(FIX2INT(order), NUM2DBL(qq), NUM2DBL(zz), r);
+  return val;
+}
+
+static VALUE sf_mathieu_eval_e_int2_double2(VALUE n1, VALUE n2, VALUE qq, VALUE zz,
+                                            int (*f)(int, int, double, double, gsl_sf_result*))
+{
+  gsl_sf_result *r;
+  VALUE val;
+  val = Data_Make_Struct(cgsl_sf_result, gsl_sf_result, 0, free, r);
+  (*f)(FIX2INT(n1), FIX2INT(n2), NUM2DBL(qq), NUM2DBL(zz), r);
+  return val;
+}
+/**********/
+static VALUE rb_gsl_sf_mathieu_a_e(VALUE module, VALUE order, VALUE qq)
+{
+  return rb_gsl_sf_eval_e_int_double(gsl_sf_mathieu_a, order, qq);
+}
+static VALUE rb_gsl_sf_mathieu_a(VALUE module, VALUE order, VALUE qq)
+{
+  return sf_mathieu_eval(order, qq, gsl_sf_mathieu_a);
+}
+static VALUE rb_gsl_sf_mathieu_a_array(VALUE module, int argc, VALUE *argv)
+{
+  return sf_mathieu_array_eval(argc, argv, gsl_sf_mathieu_a_array);
+}
+static VALUE rb_gsl_sf_mathieu_b_e(VALUE module, VALUE order, VALUE qq)
+{
+  return rb_gsl_sf_eval_e_int_double(gsl_sf_mathieu_b, order, qq);
+}
+static VALUE rb_gsl_sf_mathieu_b(VALUE module, VALUE order, VALUE qq)
+{
+  return sf_mathieu_eval(order, qq, gsl_sf_mathieu_b);
+}
+static VALUE rb_gsl_sf_mathieu_b_array(VALUE module, int argc, VALUE *argv)
+{
+  return sf_mathieu_array_eval(argc, argv, gsl_sf_mathieu_b_array);
+}
+static VALUE rb_gsl_sf_mathieu_ce_e(VALUE module, VALUE order, VALUE qq, VALUE zz)
+{
+  return sf_mathieu_eval_e_int_double2(order, qq, zz, gsl_sf_mathieu_ce);
+}
+static VALUE rb_gsl_sf_mathieu_ce(VALUE module, VALUE order, VALUE qq, VALUE zz)
+{
+  return sf_mathieu_eval_int_double2(order, qq, zz, gsl_sf_mathieu_ce);
+}
+static VALUE rb_gsl_sf_mathieu_ce_array(VALUE module, int argc, VALUE *argv)
+{
+  return sf_mathieu_array_eval2(argc, argv, gsl_sf_mathieu_ce_array);
+}
+static VALUE rb_gsl_sf_mathieu_se_e(VALUE module, VALUE order, VALUE qq, VALUE zz)
+{
+  return sf_mathieu_eval_e_int_double2(order, qq, zz, gsl_sf_mathieu_se);
+}
+static VALUE rb_gsl_sf_mathieu_se(VALUE module, VALUE order, VALUE qq, VALUE zz)
+{
+  return sf_mathieu_eval_int_double2(order, qq, zz, gsl_sf_mathieu_se);
+}
+static VALUE rb_gsl_sf_mathieu_se_array(VALUE module, int argc, VALUE *argv)
+{
+  return sf_mathieu_array_eval2(argc, argv, gsl_sf_mathieu_se_array);
+}
+
+/*****/
+static VALUE rb_gsl_sf_mathieu_Mc_e(VALUE module, VALUE n1, VALUE n2, VALUE q, VALUE x)
+{
+  return sf_mathieu_eval_e_int2_double2(n1, n2, q, x, gsl_sf_mathieu_Mc);
+}
+static VALUE rb_gsl_sf_mathieu_Mc(VALUE module, VALUE n1, VALUE n2, VALUE q, VALUE x)
+{
+  return sf_mathieu_eval2(n1, n2, q, x, gsl_sf_mathieu_Mc);
+}
+static VALUE rb_gsl_sf_mathieu_Mc_array(VALUE module, int argc, VALUE *argv)
+{
+  return sf_mathieu_array_eval3(argc, argv, gsl_sf_mathieu_Mc_array);
+}
+static VALUE rb_gsl_sf_mathieu_Ms_e(VALUE module, VALUE n1, VALUE n2, VALUE q, VALUE x)
+{
+  return sf_mathieu_eval_e_int2_double2(n1, n2, q, x, gsl_sf_mathieu_Ms);
+}
+static VALUE rb_gsl_sf_mathieu_Ms(VALUE module, VALUE n1, VALUE n2, VALUE q, VALUE x)
+{
+  return sf_mathieu_eval2(n1, n2, q, x, gsl_sf_mathieu_Ms);
+}
+static VALUE rb_gsl_sf_mathieu_Ms_array(VALUE module, int argc, VALUE *argv)
+{
+  return sf_mathieu_array_eval3(argc, argv, gsl_sf_mathieu_Ms_array);
+}
+/*****/
+void Init_sf_mathieu(VALUE module)
+{
+  VALUE mMathieu;
+
+  mMathieu = rb_define_module_under(module, "Mathieu");
+  cWorkspace = rb_define_class_under(mMathieu, "Workspace", cGSL_Object);
+  rb_define_singleton_method(cWorkspace, "alloc", rb_gsl_sf_mathieu_alloc, 2);
+
+  rb_define_module_function(module, "mathieu_a", rb_gsl_sf_mathieu_a, 2);
+  rb_define_module_function(module, "mathieu_a_e", rb_gsl_sf_mathieu_a_e, 2);
+  rb_define_module_function(module, "mathieu_a_array", rb_gsl_sf_mathieu_a_array, -1);
+  rb_define_module_function(module, "mathieu_b", rb_gsl_sf_mathieu_b, 2);
+  rb_define_module_function(module, "mathieu_b_e", rb_gsl_sf_mathieu_b_e, 2);
+  rb_define_module_function(module, "mathieu_b_array", rb_gsl_sf_mathieu_b_array, -1);
+  rb_define_module_function(module, "mathieu_ce", rb_gsl_sf_mathieu_ce, 3);
+  rb_define_module_function(module, "mathieu_ce_e", rb_gsl_sf_mathieu_ce_e, 3);
+  rb_define_module_function(module, "mathieu_ce_array", rb_gsl_sf_mathieu_ce_array, -1);
+  rb_define_module_function(module, "mathieu_se", rb_gsl_sf_mathieu_se, 3);
+  rb_define_module_function(module, "mathieu_se_e", rb_gsl_sf_mathieu_se_e, 3);
+  rb_define_module_function(module, "mathieu_se_array", rb_gsl_sf_mathieu_se_array, -1);
+  rb_define_module_function(module, "mathieu_Mc", rb_gsl_sf_mathieu_Mc, 4);
+  rb_define_module_function(module, "mathieu_Mc_e", rb_gsl_sf_mathieu_Mc_e, 4);
+  rb_define_module_function(module, "mathieu_Mc_array", rb_gsl_sf_mathieu_Mc_array, -1);
+  rb_define_module_function(module, "mathieu_Ms", rb_gsl_sf_mathieu_Ms, 4);
+  rb_define_module_function(module, "mathieu_Ms_e", rb_gsl_sf_mathieu_Ms_e, 4);
+  rb_define_module_function(module, "mathieu_Ms_array", rb_gsl_sf_mathieu_Ms_array, -1);
+}

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

@@ -9,7 +9,7 @@
   WITHOUT ANY WARRANTY.
 */
 
-#include "rb_gsl_sf.h"
+#include "include/rb_gsl_sf.h"
 
 VALUE rb_gsl_complex_pow(int argc, VALUE *argv, VALUE obj);
 static VALUE rb_gsl_sf_pow_int(VALUE obj, VALUE x, VALUE n)

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

@@ -9,7 +9,7 @@
   WITHOUT ANY WARRANTY.
 */
 
-#include "rb_gsl_sf.h"
+#include "include/rb_gsl_sf.h"
 
 static VALUE rb_gsl_sf_psi_int(VALUE obj, VALUE n)
 {
@@ -31,19 +31,15 @@ static VALUE rb_gsl_sf_psi_e(VALUE obj, VALUE x)
   return rb_gsl_sf_eval_e(gsl_sf_psi_e, x);
 }
 
-#ifdef GSL_1_6_LATER
 static VALUE rb_gsl_sf_psi_1(VALUE obj, VALUE x)
 {
   return rb_gsl_sf_eval1(gsl_sf_psi_1, x);
 }
-#endif
 
-#ifdef GSL_1_4_9_LATER
 static VALUE rb_gsl_sf_psi_1_e(VALUE obj, VALUE x)
 {
   return rb_gsl_sf_eval_e(gsl_sf_psi_1_e, x);
 }
-#endif
 
 static VALUE rb_gsl_sf_psi_1piy(VALUE obj, VALUE x)
 {
@@ -88,11 +84,6 @@ void Init_gsl_sf_psi(VALUE module)
 
   rb_define_module_function(module, "psi",  rb_gsl_sf_psi, 1);
   rb_define_module_function(module, "psi_e",  rb_gsl_sf_psi_e, 1);
-
-#ifdef GSL_1_6_LATER
-    rb_define_module_function(module, "psi_1",  rb_gsl_sf_psi_1, 1);
-#endif
-#ifdef GSL_1_4_9_LATER
-    rb_define_module_function(module, "psi_1_e",  rb_gsl_sf_psi_1_e, 1);
-#endif
+  rb_define_module_function(module, "psi_1",  rb_gsl_sf_psi_1, 1);
+  rb_define_module_function(module, "psi_1_e",  rb_gsl_sf_psi_1_e, 1);
 }

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

@@ -9,7 +9,7 @@
   WITHOUT ANY WARRANTY.
 */
 
-#include "rb_gsl_sf.h"
+#include "include/rb_gsl_sf.h"
 
 static VALUE rb_gsl_sf_synchrotron_1(VALUE obj, VALUE x)
 {

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

@@ -9,7 +9,7 @@
   WITHOUT ANY WARRANTY.
 */
 
-#include "rb_gsl_sf.h"
+#include "include/rb_gsl_sf.h"
 
 static VALUE rb_gsl_sf_transport_2(VALUE obj, VALUE x)
 {

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

@@ -9,11 +9,11 @@
   WITHOUT ANY WARRANTY.
 */
 
-#include "rb_gsl_sf.h"
+#include "include/rb_gsl_sf.h"
 
 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/{sf_zeta.c → gsl_native/sf_zeta.c}

@@ -9,7 +9,7 @@
   WITHOUT ANY WARRANTY.
 */
 
-#include "rb_gsl_sf.h"
+#include "include/rb_gsl_sf.h"
 
 static VALUE rb_gsl_sf_zeta_int(VALUE obj, VALUE n)
 {
@@ -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/{signal.c → gsl_native/signal.c}

@@ -9,51 +9,50 @@
   WITHOUT ANY WARRANTY.
 */
 
-#include "rb_gsl_config.h"
-#include "rb_gsl_fft.h"
+#include "include/rb_gsl_fft.h"
 
 enum FFT_CONV_CORR {
   RB_GSL_FFT_CONVOLVE = 0,
   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);
@@ -62,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;
+  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;
@@ -118,7 +112,7 @@ static VALUE rb_gsl_fft_conv_corr(int argc, VALUE *argv, VALUE obj,
   int flagt = 0, flagw = 0;
   //  size_t i;
   gsl_vector *vtmp1 = NULL, *vtmp2 = NULL;
-  VALUE ary;
+  VALUE ary = Qnil;
   switch (argc) {
   case 3:
     data1 = get_ptr_double3(obj, &size1, &stride1, &naflag1);
@@ -140,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:
@@ -165,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;
     }
@@ -173,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:
@@ -191,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) {
@@ -202,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);
@@ -223,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);
@@ -241,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");