gsl 1.15.3 → 1.16.0.6

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

@@ -8,11 +8,11 @@
   This library is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY.
 */
-#include "rb_gsl.h"
+#include "include/rb_gsl.h"
 #include <gsl/gsl_errno.h>
-#include "rb_gsl_array.h"
-#include "rb_gsl_common.h"
-#include "rb_gsl_function.h"
+#include "include/rb_gsl_array.h"
+#include "include/rb_gsl_common.h"
+#include "include/rb_gsl_function.h"
 
 static VALUE eHandler;
 static VALUE cgsl_error[35];
@@ -20,21 +20,21 @@ static VALUE *pgsl_error;
 
 static void Init_rb_gsl_define_GSL_CONST(VALUE module);
 void rb_gsl_error_handler(const char *reason, const char *file,
-			  int line, int gsl_errno);
+                          int line, int gsl_errno);
 static void rb_gsl_my_error_handler(const char *reason, const char *file,
-				    int line, int gsl_errno);
+                                    int line, int gsl_errno);
 
 void rb_gsl_error_handler(const char *reason, const char *file,
-			  int line, int gsl_errno)
+                          int line, int gsl_errno)
 {
   const char *emessage = gsl_strerror(gsl_errno);
-  rb_raise(pgsl_error[gsl_errno], 
-	   "Ruby/GSL error code %d, %s (file %s, line %d), %s",
-	   gsl_errno, reason, file, line, emessage);
+  rb_raise(pgsl_error[gsl_errno],
+           "Ruby/GSL error code %d, %s (file %s, line %d), %s",
+           gsl_errno, reason, file, line, emessage);
 }
 
 static void rb_gsl_my_error_handler(const char *reason, const char *file,
-				    int line, int gsl_errno)
+                                    int line, int gsl_errno)
 {
   VALUE vreason, vfile;
   VALUE vline, verrno;
@@ -48,7 +48,7 @@ static void rb_gsl_my_error_handler(const char *reason, const char *file,
 static VALUE rb_gsl_set_error_handler(int argc, VALUE *argv, VALUE module)
 {
   if (rb_block_given_p()) {
-    eHandler = RB_GSL_MAKE_PROC;
+    eHandler = rb_block_proc();
     gsl_set_error_handler(&rb_gsl_my_error_handler);
     return Qtrue;
   }
@@ -166,14 +166,14 @@ static void define_module_functions(VALUE module);
 static VALUE rb_gsl_strerror(VALUE obj, VALUE errn);
 static void define_module_functions(VALUE module)
 {
-  rb_define_module_function(module, "set_error_handler_off", 
-			    rb_gsl_set_error_handler_off, 0);
-  rb_define_module_function(module, "strerror", 
-			    rb_gsl_strerror, 1);
+  rb_define_module_function(module, "set_error_handler_off",
+                            rb_gsl_set_error_handler_off, 0);
+  rb_define_module_function(module, "strerror",
+                            rb_gsl_strerror, 1);
   rb_define_module_function(module, "set_error_handler",
-			    rb_gsl_set_error_handler, -1);
+                            rb_gsl_set_error_handler, -1);
   rb_define_module_function(module, "set_default_error_handler",
-			    rb_gsl_set_default_error_handler, 0);
+                            rb_gsl_set_default_error_handler, 0);
 }
 
 static VALUE rb_gsl_strerror(VALUE obj, VALUE errn)

data/ext/gsl_native/extconf.rb

@@ -0,0 +1,118 @@
+require 'mkmf'
+
+def gsl_config_arg(arg)
+  yield arg_config("--with-gsl-#{arg}") {
+    sh = 'sh ' if RUBY_PLATFORM =~ /mingw/
+    IO.popen("#{sh}gsl-config --#{arg}") { |f| f.gets.chomp }
+  }, lambda { |val| puts "checking gsl #{arg}... #{val}"; val }
+rescue => err
+  abort "*** ERROR: missing required library to compile this module: #{err}"
+end
+
+def gsl_def(const, value = nil)
+  value = "=#{value}" if value
+  $defs << "-D#{const}#{value}"
+end
+
+def gsl_have_header(library, header)
+  have_library(library) if have_header(header)
+end
+
+def gsl_have_library(func)
+  have_func(func) if have_library('gsl', func)
+end
+
+def gsl_dir_config(target, idir = nil, ldir = idir)
+  dir_config(target, idir || $sitearchdir, ldir || $sitearchdir)
+end
+
+def gsl_gem_config(target, dir = 'ext')
+  path = begin
+    require 'rubygems'
+
+    spec = Gem::Specification.find_by_path("#{target}.h")
+    File.join(spec.full_gem_path, dir) if spec
+  rescue LoadError
+  end
+
+  gsl_dir_config(target, path)
+
+  $LOCAL_LIBS += " -l:#{target}.so" if arg_config("--force-link-#{target}")   ||
+                                       $CFLAGS.include?('-Wl,--no-undefined') ||
+                                       $LDFLAGS.include?('-Wl,--no-undefined')
+end
+
+$CFLAGS += ' -Wall -Iinclude'
+
+gsl_config_arg(:version) { |version, check|
+  gsl_def(:GSL_VERSION, check[version])
+
+  ver = version.split('.').map { |x| x.to_i }
+
+  later = lambda { |other|
+    ary = other.split('.').map { |x| x.to_i }
+
+    gte = ver[0] > ary[0] ? true  :
+          ver[0] < ary[0] ? false :
+          ver[1] > ary[1] ? true  :
+          ver[1] < ary[1] ? false :
+          ver.size < ary.size ? false :
+          ver.size == 3 && ary.size == 3 ? ver[2] >= ary[2] : true
+
+    ary.pop && ary[-1] += 1 if ary.last == 90
+
+    gte && gsl_def("GSL_#{ary.join('_')}_LATER")
+  }
+
+  raise 'Ruby/GSL requires gsl-1.15 or later.' unless later['1.15']
+
+  %w[1.15 1.16].each { |v| later[v] }
+}
+
+gsl_config_arg(:cflags) { |cflags, check|
+  $CFLAGS += ' ' + check[cflags]
+}
+
+gsl_config_arg(:libs) { |libs, check|
+  libs.tr!(File::PATH_SEPARATOR, ' ')
+
+  if enable_config('atlas')
+    dir_config('cblas')
+    dir_config('atlas')
+
+    if have_library('cblas') && have_library('atlas')
+      libs.gsub!('-lgslcblas', '-lcblas -latlas')
+    end
+  end
+
+  $LOCAL_LIBS += ' ' + check[libs]
+}
+
+have_func('round')
+
+%w[alf qrngextra rngextra tensor].each { |library|
+  gsl_have_header(library, "#{library}/#{library}.h")
+}
+
+gsl_have_header('bundle_method', 'gsl/gsl_multimin_fsdf.h')
+gsl_have_header('cqp',           'gsl/gsl_cqp.h')
+gsl_have_header('jacobi',        'jacobi.h')
+gsl_have_header('ndlinear',      'ndlinear/gsl_multifit_ndlinear.h')
+gsl_have_header('ool',           'ool/ool_version.h')
+
+gsl_have_library('gsl_eigen_francis')
+gsl_have_library('gsl_poly_solve_quartic')
+
+gsl_def(:HAVE_GNU_GRAPH) if find_executable('graph')
+
+gsl_gem_config('narray', 'src')
+
+have_header('narray.h')
+have_library('narray') if RUBY_PLATFORM =~ /cygwin|mingw/
+
+unless arg_config('--disable-tamu-anova')
+  gsl_dir_config('tamu_anova')
+  gsl_have_header('tamuanova', 'tamu_anova/tamu_anova.h')
+end
+
+create_makefile('gsl_native')

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

@@ -9,8 +9,7 @@
   WITHOUT ANY WARRANTY.
 */
 
-#include "rb_gsl_config.h"
-#include "rb_gsl_fft.h"
+#include "include/rb_gsl_fft.h"
 
 VALUE mgsl_fft;
 VALUE cgsl_fft_wavetable;
@@ -26,24 +25,24 @@ static void GSL_FFT_Workspace_free(GSL_FFT_Workspace *space);
 static VALUE rb_gsl_fft_complex_wavetable_new(VALUE klass, VALUE n)
 {
   CHECK_FIXNUM(n);
-  return Data_Wrap_Struct(cgsl_fft_complex_wavetable, 0, 
-			  gsl_fft_complex_wavetable_free,
-			  gsl_fft_complex_wavetable_alloc(FIX2INT(n)));
+  return Data_Wrap_Struct(cgsl_fft_complex_wavetable, 0,
+                          gsl_fft_complex_wavetable_free,
+                          gsl_fft_complex_wavetable_alloc(FIX2INT(n)));
 }
 
 static VALUE rb_gsl_fft_real_wavetable_new(VALUE klass, VALUE n)
 {
   CHECK_FIXNUM(n);
   return Data_Wrap_Struct(klass, 0, gsl_fft_real_wavetable_free,
-			  gsl_fft_real_wavetable_alloc(FIX2INT(n)));
+                          gsl_fft_real_wavetable_alloc(FIX2INT(n)));
 }
 
 static VALUE rb_gsl_fft_halfcomplex_wavetable_new(VALUE klass, VALUE n)
 {
   CHECK_FIXNUM(n);
   return Data_Wrap_Struct(klass, 0, gsl_fft_halfcomplex_wavetable_free,
-			  gsl_fft_halfcomplex_wavetable_alloc(FIX2INT(n)));
-  
+                          gsl_fft_halfcomplex_wavetable_alloc(FIX2INT(n)));
+
 }
 
 static void GSL_FFT_Wavetable_free(GSL_FFT_Wavetable *table)
@@ -55,21 +54,21 @@ static VALUE rb_gsl_fft_complex_workspace_new(VALUE klass, VALUE n)
 {
   CHECK_FIXNUM(n);
   return Data_Wrap_Struct(klass, 0, gsl_fft_complex_workspace_free,
-			  gsl_fft_complex_workspace_alloc(FIX2INT(n)));
+                          gsl_fft_complex_workspace_alloc(FIX2INT(n)));
 }
 
 static VALUE rb_gsl_fft_real_workspace_new(VALUE klass, VALUE n)
 {
   CHECK_FIXNUM(n);
   return Data_Wrap_Struct(klass, 0, gsl_fft_real_workspace_free,
-			  gsl_fft_real_workspace_alloc(FIX2INT(n)));
+                          gsl_fft_real_workspace_alloc(FIX2INT(n)));
 }
 
 static void GSL_FFT_Workspace_free(GSL_FFT_Workspace *space)
 {
   gsl_fft_complex_workspace_free((gsl_fft_complex_workspace *) space);
 }
-  
+
 // The FFT methods used to allow passing stride and n values as optional
 // parameters to control which elements get transformed.  This created problems
 // for Views which can have their own stride, so support for stride and n
@@ -80,8 +79,8 @@ static void GSL_FFT_Workspace_free(GSL_FFT_Workspace *space)
 // refactoring, it has been left in place for the time being.  Eventually it
 // can be refactored away completely.
 static VALUE get_complex_stride_n(VALUE obj,
-			       gsl_vector_complex **vin,
-			       gsl_complex_packed_array *data, size_t *stride, size_t *n)
+                                  gsl_vector_complex **vin,
+                                  gsl_complex_packed_array *data, size_t *stride, size_t *n)
 {
   gsl_vector_complex *v = NULL;
 
@@ -97,8 +96,8 @@ static VALUE get_complex_stride_n(VALUE obj,
 }
 
 static VALUE rb_fft_complex_radix2(VALUE obj,
-				   int (*trans)(gsl_complex_packed_array, 
-						size_t, size_t), int flag)
+                                   int (*trans)(gsl_complex_packed_array,
+                                                size_t, size_t), int flag)
 {
   size_t stride, n;
   gsl_complex_packed_array data;
@@ -107,7 +106,7 @@ static VALUE rb_fft_complex_radix2(VALUE obj,
   ary = get_complex_stride_n(obj, &vin, &data, &stride, &n);
   if (flag == RB_GSL_FFT_COPY) {
     vout = gsl_vector_complex_alloc(n);
-    gsl_vector_complex_memcpy(vout, vin); 
+    gsl_vector_complex_memcpy(vout, vin);
     (*trans)(vout->data, vout->stride /*1*/, vout->size /*n*/);
     return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vout);
   } else { /* in-place */
@@ -119,13 +118,13 @@ static VALUE rb_fft_complex_radix2(VALUE obj,
 static VALUE rb_gsl_fft_complex_radix2_forward(VALUE obj)
 {
   return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_forward,
-			       RB_GSL_FFT_COPY);
+                               RB_GSL_FFT_COPY);
 }
 
 static VALUE rb_gsl_fft_complex_radix2_forward2(VALUE obj)
 {
   return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_forward,
-			       RB_GSL_FFT_INPLACE);
+                               RB_GSL_FFT_INPLACE);
 }
 
 static VALUE rb_gsl_fft_complex_radix2_transform(VALUE obj, VALUE val_sign)
@@ -137,7 +136,7 @@ static VALUE rb_gsl_fft_complex_radix2_transform(VALUE obj, VALUE val_sign)
   sign = NUM2INT(val_sign);
   get_complex_stride_n(obj, &vin, &data, &stride, &n);
   vout = gsl_vector_complex_alloc(n);
-  gsl_vector_complex_memcpy(vout, vin); 
+  gsl_vector_complex_memcpy(vout, vin);
   gsl_fft_complex_radix2_transform(vout->data, vout->stride /*1*/, vout->size /*n*/, sign);
   return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vout);
 }
@@ -157,40 +156,40 @@ static VALUE rb_gsl_fft_complex_radix2_transform2(VALUE obj, VALUE val_sign)
 static VALUE rb_gsl_fft_complex_radix2_backward(VALUE obj)
 {
   return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_backward,
-			       RB_GSL_FFT_COPY);
+                               RB_GSL_FFT_COPY);
 }
 
 static VALUE rb_gsl_fft_complex_radix2_inverse(VALUE obj)
 {
   return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_inverse,
-			       RB_GSL_FFT_COPY);
+                               RB_GSL_FFT_COPY);
 }
 
 static VALUE rb_gsl_fft_complex_radix2_dif_forward(VALUE obj)
 {
-  return rb_fft_complex_radix2(obj, 
-			       gsl_fft_complex_radix2_dif_forward,
-			       RB_GSL_FFT_COPY);
+  return rb_fft_complex_radix2(obj,
+                               gsl_fft_complex_radix2_dif_forward,
+                               RB_GSL_FFT_COPY);
 }
 
 static VALUE rb_gsl_fft_complex_radix2_backward2(VALUE obj)
 {
   return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_backward,
-			       RB_GSL_FFT_INPLACE);
+                               RB_GSL_FFT_INPLACE);
 }
 
 static VALUE rb_gsl_fft_complex_radix2_inverse2(VALUE obj)
 {
   return rb_fft_complex_radix2(obj, gsl_fft_complex_radix2_inverse,
-			       RB_GSL_FFT_INPLACE);
+                               RB_GSL_FFT_INPLACE);
 }
 
 
 static VALUE rb_gsl_fft_complex_radix2_dif_forward2(VALUE obj)
 {
-  return rb_fft_complex_radix2(obj, 
-			       gsl_fft_complex_radix2_dif_forward,
-			       RB_GSL_FFT_INPLACE);
+  return rb_fft_complex_radix2(obj,
+                               gsl_fft_complex_radix2_dif_forward,
+                               RB_GSL_FFT_INPLACE);
 }
 
 static VALUE rb_gsl_fft_complex_radix2_dif_transform(VALUE obj, VALUE val_sign)
@@ -202,7 +201,7 @@ static VALUE rb_gsl_fft_complex_radix2_dif_transform(VALUE obj, VALUE val_sign)
   sign = NUM2INT(val_sign);
   get_complex_stride_n(obj, &vin, &data, &stride, &n);
   vout = gsl_vector_complex_alloc(n);
-  gsl_vector_complex_memcpy(vout, vin); 
+  gsl_vector_complex_memcpy(vout, vin);
   gsl_fft_complex_radix2_dif_transform(vout->data, vout->stride /*1*/, vout->size /*n*/, sign);
   return Data_Wrap_Struct(cgsl_vector_complex, 0, gsl_vector_complex_free, vout);
 }
@@ -222,28 +221,28 @@ static VALUE rb_gsl_fft_complex_radix2_dif_transform2(VALUE obj, VALUE val_sign)
 
 static VALUE rb_gsl_fft_complex_radix2_dif_backward(VALUE obj)
 {
-  return rb_fft_complex_radix2(obj, 
-			       gsl_fft_complex_radix2_dif_backward,
-			       RB_GSL_FFT_COPY);
+  return rb_fft_complex_radix2(obj,
+                               gsl_fft_complex_radix2_dif_backward,
+                               RB_GSL_FFT_COPY);
 }
 static VALUE rb_gsl_fft_complex_radix2_dif_inverse(VALUE obj)
 {
-  return rb_fft_complex_radix2(obj, 
-			       gsl_fft_complex_radix2_dif_inverse,
-			       RB_GSL_FFT_COPY);
+  return rb_fft_complex_radix2(obj,
+                               gsl_fft_complex_radix2_dif_inverse,
+                               RB_GSL_FFT_COPY);
 }
 
 static VALUE rb_gsl_fft_complex_radix2_dif_backward2(VALUE obj)
 {
-  return rb_fft_complex_radix2(obj, 
-			       gsl_fft_complex_radix2_dif_backward,
-			       RB_GSL_FFT_INPLACE);
+  return rb_fft_complex_radix2(obj,
+                               gsl_fft_complex_radix2_dif_backward,
+                               RB_GSL_FFT_INPLACE);
 }
 static VALUE rb_gsl_fft_complex_radix2_dif_inverse2(VALUE obj)
 {
-  return rb_fft_complex_radix2(obj, 
-			       gsl_fft_complex_radix2_dif_inverse,
-			       RB_GSL_FFT_INPLACE);
+  return rb_fft_complex_radix2(obj,
+                               gsl_fft_complex_radix2_dif_inverse,
+                               RB_GSL_FFT_INPLACE);
 }
 
 static VALUE rb_GSL_FFT_Wavetable_n(VALUE obj)
@@ -279,16 +278,16 @@ enum {
 } FFTComplexStructAllocFlag;
 
 static void gsl_fft_free(int flag, GSL_FFT_Wavetable *table,
-			 GSL_FFT_Workspace *space);
+                         GSL_FFT_Workspace *space);
 
 // Parse argc, argv.  obj must be GSL::Vector::Complex.
 // This can be simplified at some point.
 // See comments preceding get_complex_stride_n()
 static int gsl_fft_get_argv_complex(int argc, VALUE *argv, VALUE obj,
-			    gsl_vector_complex ** vin,
-			    gsl_complex_packed_array *data, size_t *stride,
-			    size_t *n, gsl_fft_complex_wavetable **table,
-			    gsl_fft_complex_workspace **space)
+                                    gsl_vector_complex ** vin,
+                                    gsl_complex_packed_array *data, size_t *stride,
+                                    size_t *n, gsl_fft_complex_wavetable **table,
+                                    gsl_fft_complex_workspace **space)
 {
   int flag = NONE_OF_TWO, flagtmp, i, itmp = argc, itmp2 = 0, ccc;
   int flagw = 0;
@@ -337,9 +336,9 @@ static int gsl_fft_get_argv_complex(int argc, VALUE *argv, VALUE obj,
 
 // Parse argc, argv.  obj must be GSL::Vector of real data
 static int gsl_fft_get_argv_real(int argc, VALUE *argv, VALUE obj,
-			     double **ptr, size_t *stride,
-			     size_t *n, gsl_fft_real_wavetable **table,
-			     gsl_fft_real_workspace **space, int *naflag)
+                                 double **ptr, size_t *stride,
+                                 size_t *n, gsl_fft_real_wavetable **table,
+                                 gsl_fft_real_workspace **space, int *naflag)
 {
   int flag = NONE_OF_TWO, flagtmp, i, itmp = argc, itmp2 = 0, ccc;
   int flagw = 0;
@@ -388,9 +387,9 @@ static int gsl_fft_get_argv_real(int argc, VALUE *argv, VALUE obj,
 
 // Parse argc, argv.  obj must be GSL::Vector of halfcomplex data
 static int gsl_fft_get_argv_halfcomplex(int argc, VALUE *argv, VALUE obj,
-			   double **ptr, size_t *stride,
-			    size_t *n, gsl_fft_halfcomplex_wavetable **table,
-			    gsl_fft_real_workspace **space, int *naflag)
+                                        double **ptr, size_t *stride,
+                                        size_t *n, gsl_fft_halfcomplex_wavetable **table,
+                                        gsl_fft_real_workspace **space, int *naflag)
 {
   int flag = NONE_OF_TWO, flagtmp, i, itmp = argc, itmp2 = 0, ccc;
   int flagw = 0;
@@ -437,7 +436,7 @@ static int gsl_fft_get_argv_halfcomplex(int argc, VALUE *argv, VALUE obj,
 }
 
 static void gsl_fft_free(int flag, GSL_FFT_Wavetable *table,
-			 GSL_FFT_Workspace *space)
+                         GSL_FFT_Workspace *space)
 {
   switch (flag) {
   case ALLOC_TABLE:
@@ -457,11 +456,11 @@ static void gsl_fft_free(int flag, GSL_FFT_Wavetable *table,
 }
 
 static VALUE rb_fft_complex_trans(int argc, VALUE *argv, VALUE obj,
-				  int (*transform)(gsl_complex_packed_array, 
-						   size_t, size_t, 
-						   const gsl_fft_complex_wavetable *,
-						   gsl_fft_complex_workspace *),
-				  int sss)
+                                  int (*transform)(gsl_complex_packed_array,
+                                                   size_t, size_t,
+                                                   const gsl_fft_complex_wavetable *,
+                                                   gsl_fft_complex_workspace *),
+                                  int sss)
 {
   int flag = 0;
   // local variable "status" was defined and set, but never used
@@ -488,13 +487,13 @@ static VALUE rb_fft_complex_trans(int argc, VALUE *argv, VALUE obj,
 static VALUE rb_gsl_fft_complex_forward(int argc, VALUE *argv, VALUE obj)
 {
   return rb_fft_complex_trans(argc, argv, obj, gsl_fft_complex_forward,
-			      RB_GSL_FFT_COPY);
+                              RB_GSL_FFT_COPY);
 }
 
 static VALUE rb_gsl_fft_complex_forward2(int argc, VALUE *argv, VALUE obj)
 {
   return rb_fft_complex_trans(argc, argv, obj, gsl_fft_complex_forward,
-			      RB_GSL_FFT_INPLACE);
+                              RB_GSL_FFT_INPLACE);
 }
 
 static VALUE rb_gsl_fft_complex_transform(int argc, VALUE *argv, VALUE obj)
@@ -540,25 +539,25 @@ static VALUE rb_gsl_fft_complex_transform2(int argc, VALUE *argv, VALUE obj)
 static VALUE rb_gsl_fft_complex_backward(int argc, VALUE *argv, VALUE obj)
 {
   return rb_fft_complex_trans(argc, argv, obj, gsl_fft_complex_backward,
-			      RB_GSL_FFT_COPY);
+                              RB_GSL_FFT_COPY);
 }
 
 static VALUE rb_gsl_fft_complex_backward2(int argc, VALUE *argv, VALUE obj)
 {
   return rb_fft_complex_trans(argc, argv, obj, gsl_fft_complex_backward,
-			      RB_GSL_FFT_INPLACE);
+                              RB_GSL_FFT_INPLACE);
 }
 
 static VALUE rb_gsl_fft_complex_inverse(int argc, VALUE *argv, VALUE obj)
 {
   return rb_fft_complex_trans(argc, argv, obj, gsl_fft_complex_inverse,
-			      RB_GSL_FFT_COPY);
+                              RB_GSL_FFT_COPY);
 }
 
 static VALUE rb_gsl_fft_complex_inverse2(int argc, VALUE *argv, VALUE obj)
 {
   return rb_fft_complex_trans(argc, argv, obj, gsl_fft_complex_inverse,
-			      RB_GSL_FFT_INPLACE);
+                              RB_GSL_FFT_INPLACE);
 }
 
 // The FFT methods used to allow passing stride and n values as optional
@@ -573,7 +572,7 @@ static VALUE rb_gsl_fft_complex_inverse2(int argc, VALUE *argv, VALUE obj)
 //
 // obj must be GSL::Vector of real or halfcomplex data
 static VALUE get_ptr_stride_n(VALUE obj,
-			     double **ptr, size_t *stride, size_t *n, int *flag)
+                              double **ptr, size_t *stride, size_t *n, int *flag)
 {
   *flag = 0;
   *ptr = get_ptr_double3(obj, n, stride, flag);
@@ -581,17 +580,14 @@ static VALUE get_ptr_stride_n(VALUE obj,
 }
 
 static VALUE rb_fft_radix2(VALUE obj,
-			   int (*trans)(double [], size_t, size_t),
-			   int sss)
+                           int (*trans)(double [], size_t, size_t),
+                           int sss)
 {
   size_t stride, n;
   gsl_vector *vnew;
   gsl_vector_view vv;
   double *ptr1, *ptr2;
   int flag;
-#ifdef HAVE_NARRAY_H
-  int shape[1];
-#endif
   VALUE ary;
   get_ptr_stride_n(obj, &ptr1, &stride, &n, &flag);
   if (flag == 0) {
@@ -611,6 +607,7 @@ static VALUE rb_fft_radix2(VALUE obj,
 #ifdef HAVE_NARRAY_H
   } else if (flag == 1) {
     if (sss == RB_GSL_FFT_COPY) {
+      int shape[1];
       shape[0] = n;
       ary = na_make_object(NA_DFLOAT, 1, shape, cNArray);
       ptr2 = NA_PTR_TYPE(ary, double*);
@@ -631,46 +628,46 @@ static VALUE rb_fft_radix2(VALUE obj,
 static VALUE rb_gsl_fft_real_radix2_transform(VALUE obj)
 {
   return rb_fft_radix2(obj, gsl_fft_real_radix2_transform,
-		       RB_GSL_FFT_COPY);
+                       RB_GSL_FFT_COPY);
 }
 
 static VALUE rb_gsl_fft_real_radix2_transform2(VALUE obj)
 {
   return rb_fft_radix2(obj, gsl_fft_real_radix2_transform,
-		       RB_GSL_FFT_INPLACE);
+                       RB_GSL_FFT_INPLACE);
 }
 
 static VALUE rb_gsl_fft_halfcomplex_radix2_inverse(VALUE obj)
 {
   return rb_fft_radix2(obj, gsl_fft_halfcomplex_radix2_inverse,
-		       RB_GSL_FFT_COPY);
+                       RB_GSL_FFT_COPY);
 }
 
 static VALUE rb_gsl_fft_halfcomplex_radix2_inverse2(VALUE obj)
 {
   return rb_fft_radix2(obj, gsl_fft_halfcomplex_radix2_inverse,
-		       RB_GSL_FFT_INPLACE);
+                       RB_GSL_FFT_INPLACE);
 }
 
 static VALUE rb_gsl_fft_halfcomplex_radix2_backward(VALUE obj)
 {
   return rb_fft_radix2(obj, gsl_fft_halfcomplex_radix2_backward,
-		       RB_GSL_FFT_COPY);
+                       RB_GSL_FFT_COPY);
 }
 
 static VALUE rb_gsl_fft_halfcomplex_radix2_backward2(VALUE obj)
 {
   return rb_fft_radix2(obj, gsl_fft_halfcomplex_radix2_backward,
-		       RB_GSL_FFT_INPLACE);
+                       RB_GSL_FFT_INPLACE);
 }
 
 /*****/
 
 static VALUE rb_fft_real_trans(int argc, VALUE *argv, VALUE obj,
-			       int (*trans)(double [], size_t, size_t, 
-					    const gsl_fft_real_wavetable *, 
-					    gsl_fft_real_workspace *),
-			       int sss)
+                               int (*trans)(double [], size_t, size_t,
+                                            const gsl_fft_real_wavetable *,
+                                            gsl_fft_real_workspace *),
+                               int sss)
 {
   int flag = 0, naflag = 0;
   // local variable "status" was defined and set, but never used
@@ -679,9 +676,6 @@ static VALUE rb_fft_real_trans(int argc, VALUE *argv, VALUE obj,
   gsl_vector *vnew;
   gsl_vector_view vv;
   double *ptr1, *ptr2;
-#ifdef HAVE_NARRAY_H
-  int shape[1];
-#endif
   gsl_fft_real_wavetable *table = NULL;
   gsl_fft_real_workspace *space = NULL;
   VALUE ary;
@@ -703,6 +697,7 @@ static VALUE rb_fft_real_trans(int argc, VALUE *argv, VALUE obj,
 #ifdef HAVE_NARRAY_H
   } else if (naflag == 1) {
     if (sss == RB_GSL_FFT_COPY) {
+      int shape[1];
       shape[0] = n;
       ary = na_make_object(NA_DFLOAT, 1, shape, cNArray);
       ptr2 = NA_PTR_TYPE(ary, double*);
@@ -724,19 +719,19 @@ static VALUE rb_fft_real_trans(int argc, VALUE *argv, VALUE obj,
 static VALUE rb_gsl_fft_real_transform(int argc, VALUE *argv, VALUE obj)
 {
   return rb_fft_real_trans(argc, argv, obj, gsl_fft_real_transform,
-			   RB_GSL_FFT_COPY);
+                           RB_GSL_FFT_COPY);
 }
 
 static VALUE rb_gsl_fft_real_transform2(int argc, VALUE *argv, VALUE obj)
 {
   return rb_fft_real_trans(argc, argv, obj, gsl_fft_real_transform,
-			   RB_GSL_FFT_INPLACE);
+                           RB_GSL_FFT_INPLACE);
 }
 
 static VALUE rb_fft_halfcomplex_trans(int argc, VALUE *argv, VALUE obj,
-				      int (*trans)(double [], size_t, size_t, 
-						   const gsl_fft_halfcomplex_wavetable *, gsl_fft_real_workspace *),
-				      int sss)
+                                      int (*trans)(double [], size_t, size_t,
+                                                   const gsl_fft_halfcomplex_wavetable *, gsl_fft_real_workspace *),
+                                      int sss)
 {
   int flag = 0, naflag = 0;
   // local variable "status" was defined and set, but never used
@@ -745,14 +740,11 @@ static VALUE rb_fft_halfcomplex_trans(int argc, VALUE *argv, VALUE obj,
   gsl_vector *vnew;
   gsl_vector_view vv;
   double *ptr1, *ptr2;
-#ifdef HAVE_NARRAY_H
-  int shape[1];
-#endif
   gsl_fft_halfcomplex_wavetable *table = NULL;
   gsl_fft_real_workspace *space = NULL;
   VALUE ary;
-  flag = gsl_fft_get_argv_halfcomplex(argc, argv, obj, &ptr1, &stride, &n, 
-			   &table, &space, &naflag);
+  flag = gsl_fft_get_argv_halfcomplex(argc, argv, obj, &ptr1, &stride, &n,
+                                      &table, &space, &naflag);
   if (naflag == 0) {
     if (sss == RB_GSL_FFT_COPY) {
       vnew = gsl_vector_alloc(n);
@@ -770,6 +762,7 @@ static VALUE rb_fft_halfcomplex_trans(int argc, VALUE *argv, VALUE obj,
 #ifdef HAVE_NARRAY_H
   } else if (naflag == 1) {
     if (sss == RB_GSL_FFT_COPY) {
+      int shape[1];
       shape[0] = n;
       ary = na_make_object(NA_DFLOAT, 1, shape, cNArray);
       ptr2 = NA_PTR_TYPE(ary, double*);
@@ -790,44 +783,44 @@ static VALUE rb_fft_halfcomplex_trans(int argc, VALUE *argv, VALUE obj,
 
 static VALUE rb_gsl_fft_halfcomplex_transform(int argc, VALUE *argv, VALUE obj)
 {
-  return rb_fft_halfcomplex_trans(argc, argv, obj, 
-				  gsl_fft_halfcomplex_transform,
-				  RB_GSL_FFT_COPY);
+  return rb_fft_halfcomplex_trans(argc, argv, obj,
+                                  gsl_fft_halfcomplex_transform,
+                                  RB_GSL_FFT_COPY);
 }
 
 static VALUE rb_gsl_fft_halfcomplex_transform2(int argc, VALUE *argv, VALUE obj)
 {
-  return rb_fft_halfcomplex_trans(argc, argv, obj, 
-				  gsl_fft_halfcomplex_transform,
-				  RB_GSL_FFT_INPLACE);
+  return rb_fft_halfcomplex_trans(argc, argv, obj,
+                                  gsl_fft_halfcomplex_transform,
+                                  RB_GSL_FFT_INPLACE);
 }
 
 static VALUE rb_gsl_fft_halfcomplex_backward(int argc, VALUE *argv, VALUE obj)
 {
-  return rb_fft_halfcomplex_trans(argc, argv, obj, 
-				  gsl_fft_halfcomplex_backward,
-				  RB_GSL_FFT_COPY);
+  return rb_fft_halfcomplex_trans(argc, argv, obj,
+                                  gsl_fft_halfcomplex_backward,
+                                  RB_GSL_FFT_COPY);
 }
 
 static VALUE rb_gsl_fft_halfcomplex_backward2(int argc, VALUE *argv, VALUE obj)
 {
-  return rb_fft_halfcomplex_trans(argc, argv, obj, 
-				  gsl_fft_halfcomplex_backward,
-				  RB_GSL_FFT_INPLACE);
+  return rb_fft_halfcomplex_trans(argc, argv, obj,
+                                  gsl_fft_halfcomplex_backward,
+                                  RB_GSL_FFT_INPLACE);
 }
 
 static VALUE rb_gsl_fft_halfcomplex_inverse(int argc, VALUE *argv, VALUE obj)
 {
-  return rb_fft_halfcomplex_trans(argc, argv, obj, 
-				  gsl_fft_halfcomplex_inverse,
-				  RB_GSL_FFT_COPY);
+  return rb_fft_halfcomplex_trans(argc, argv, obj,
+                                  gsl_fft_halfcomplex_inverse,
+                                  RB_GSL_FFT_COPY);
 }
 
 static VALUE rb_gsl_fft_halfcomplex_inverse2(int argc, VALUE *argv, VALUE obj)
 {
-  return rb_fft_halfcomplex_trans(argc, argv, obj, 
-				  gsl_fft_halfcomplex_inverse,
-				  RB_GSL_FFT_INPLACE);
+  return rb_fft_halfcomplex_trans(argc, argv, obj,
+                                  gsl_fft_halfcomplex_inverse,
+                                  RB_GSL_FFT_INPLACE);
 }
 
 static VALUE rb_gsl_fft_real_unpack(VALUE obj)
@@ -868,7 +861,7 @@ static VALUE rb_gsl_fft_halfcomplex_to_nrc(VALUE obj)
   vnew = gsl_vector_alloc(v->size);
   gsl_vector_set(vnew, 0, gsl_vector_get(v, 0));  /* DC */
   gsl_vector_set(vnew, 1, gsl_vector_get(v, v->size/2));  /* Nyquist freq */
-  for (i = 2, k = 1; i < vnew->size; i+=2, k++) {
+  for (i = 2, k = 1; i < vnew->size; i += 2, k++) {
     gsl_vector_set(vnew, i, gsl_vector_get(v, k));
     gsl_vector_set(vnew, i+1, -gsl_vector_get(v, v->size-k));
   }
@@ -887,12 +880,12 @@ static VALUE rb_gsl_fft_halfcomplex_amp_phase(VALUE obj)
   amp = gsl_vector_alloc(v->size/2);
   phase = gsl_vector_alloc(v->size/2);
   gsl_vector_set(amp, 0, gsl_vector_get(v, 0));
-  gsl_vector_set(phase, 0, 0);  
+  gsl_vector_set(phase, 0, 0);
   gsl_vector_set(amp, amp->size-1, gsl_vector_get(v, v->size-1));
-  gsl_vector_set(phase, phase->size-1, 0);    
-  for (i = 1; i < v->size-1; i+=2) {
+  gsl_vector_set(phase, phase->size-1, 0);
+  for (i = 1; i < v->size-1; i += 2) {
     re = gsl_vector_get(v, i);
-    im = gsl_vector_get(v, i+1);    
+    im = gsl_vector_get(v, i+1);
     gsl_vector_set(amp, i/2+1, sqrt(re*re + im*im));
     gsl_vector_set(phase, i/2+1, atan2(im, re));
   }
@@ -907,46 +900,46 @@ void Init_gsl_fft(VALUE module)
 
   /*****/
 
-  rb_define_const(mgsl_fft, "Forward", INT2FIX(forward));
-  rb_define_const(mgsl_fft, "FORWARD", INT2FIX(forward));
-  rb_define_const(mgsl_fft, "Backward", INT2FIX(backward));
-  rb_define_const(mgsl_fft, "BACKWARD", INT2FIX(backward));
+  rb_define_const(mgsl_fft, "Forward", INT2FIX(gsl_fft_forward));
+  rb_define_const(mgsl_fft, "FORWARD", INT2FIX(gsl_fft_forward));
+  rb_define_const(mgsl_fft, "Backward", INT2FIX(gsl_fft_backward));
+  rb_define_const(mgsl_fft, "BACKWARD", INT2FIX(gsl_fft_backward));
 
   /* Transforms for complex vectors */
-  rb_define_method(cgsl_vector_complex, "radix2_forward", 
-		   rb_gsl_fft_complex_radix2_forward, 0);
-  rb_define_method(cgsl_vector_complex, "radix2_transform", 
-		   rb_gsl_fft_complex_radix2_transform, 1);
-  rb_define_method(cgsl_vector_complex, "radix2_backward", 
-		   rb_gsl_fft_complex_radix2_backward, 0);
-  rb_define_method(cgsl_vector_complex, "radix2_inverse", 
-		   rb_gsl_fft_complex_radix2_inverse, 0);
-  rb_define_method(cgsl_vector_complex, "radix2_dif_forward", 
-		   rb_gsl_fft_complex_radix2_dif_forward, 0);
-  rb_define_method(cgsl_vector_complex, "radix2_dif_transform", 
-		   rb_gsl_fft_complex_radix2_dif_transform, 1);
-  rb_define_method(cgsl_vector_complex, "radix2_dif_backward", 
-		   rb_gsl_fft_complex_radix2_dif_backward, 0);
-  rb_define_method(cgsl_vector_complex, "radix2_dif_inverse", 
-		   rb_gsl_fft_complex_radix2_dif_inverse, 0);
+  rb_define_method(cgsl_vector_complex, "radix2_forward",
+                   rb_gsl_fft_complex_radix2_forward, 0);
+  rb_define_method(cgsl_vector_complex, "radix2_transform",
+                   rb_gsl_fft_complex_radix2_transform, 1);
+  rb_define_method(cgsl_vector_complex, "radix2_backward",
+                   rb_gsl_fft_complex_radix2_backward, 0);
+  rb_define_method(cgsl_vector_complex, "radix2_inverse",
+                   rb_gsl_fft_complex_radix2_inverse, 0);
+  rb_define_method(cgsl_vector_complex, "radix2_dif_forward",
+                   rb_gsl_fft_complex_radix2_dif_forward, 0);
+  rb_define_method(cgsl_vector_complex, "radix2_dif_transform",
+                   rb_gsl_fft_complex_radix2_dif_transform, 1);
+  rb_define_method(cgsl_vector_complex, "radix2_dif_backward",
+                   rb_gsl_fft_complex_radix2_dif_backward, 0);
+  rb_define_method(cgsl_vector_complex, "radix2_dif_inverse",
+                   rb_gsl_fft_complex_radix2_dif_inverse, 0);
 
   /* In-place radix-2 transforms for complex vectors */
-  rb_define_method(cgsl_vector_complex, "radix2_forward!", 
-		   rb_gsl_fft_complex_radix2_forward2, 0);
+  rb_define_method(cgsl_vector_complex, "radix2_forward!",
+                   rb_gsl_fft_complex_radix2_forward2, 0);
   rb_define_method(cgsl_vector_complex, "radix2_transform!",
-		   rb_gsl_fft_complex_radix2_transform2, 1);
-  rb_define_method(cgsl_vector_complex, "radix2_backward!", 
-		   rb_gsl_fft_complex_radix2_backward2, 0);
-  rb_define_method(cgsl_vector_complex, "radix2_inverse!", 
-		   rb_gsl_fft_complex_radix2_inverse2, 0);
-  rb_define_method(cgsl_vector_complex, "radix2_dif_forward!", 
-		   rb_gsl_fft_complex_radix2_dif_forward2, 0);
+                   rb_gsl_fft_complex_radix2_transform2, 1);
+  rb_define_method(cgsl_vector_complex, "radix2_backward!",
+                   rb_gsl_fft_complex_radix2_backward2, 0);
+  rb_define_method(cgsl_vector_complex, "radix2_inverse!",
+                   rb_gsl_fft_complex_radix2_inverse2, 0);
+  rb_define_method(cgsl_vector_complex, "radix2_dif_forward!",
+                   rb_gsl_fft_complex_radix2_dif_forward2, 0);
   rb_define_method(cgsl_vector_complex, "radix2_dif_transform!",
-		   rb_gsl_fft_complex_radix2_dif_transform2, 1);
-  rb_define_method(cgsl_vector_complex, "radix2_dif_backward!", 
-		   rb_gsl_fft_complex_radix2_dif_backward2, 0);
-  rb_define_method(cgsl_vector_complex, "radix2_dif_inverse!", 
-		   rb_gsl_fft_complex_radix2_dif_inverse2, 0);
+                   rb_gsl_fft_complex_radix2_dif_transform2, 1);
+  rb_define_method(cgsl_vector_complex, "radix2_dif_backward!",
+                   rb_gsl_fft_complex_radix2_dif_backward2, 0);
+  rb_define_method(cgsl_vector_complex, "radix2_dif_inverse!",
+                   rb_gsl_fft_complex_radix2_dif_inverse2, 0);
 
   // class GSL::FFT::Wavetable < GSL::Object
   //
@@ -958,23 +951,23 @@ void Init_gsl_fft(VALUE module)
   // No alloc
   // TODO Make GSL::FFT::Wavetable#initialize private?
   rb_define_method(cgsl_fft_wavetable, "n",
-			     rb_GSL_FFT_Wavetable_n, 0);
+                   rb_GSL_FFT_Wavetable_n, 0);
   rb_define_method(cgsl_fft_wavetable, "nf",
-			     rb_GSL_FFT_Wavetable_nf, 0);
+                   rb_GSL_FFT_Wavetable_nf, 0);
   rb_define_method(cgsl_fft_wavetable, "factor",
-		   rb_GSL_FFT_Wavetable_factor, 0);
+                   rb_GSL_FFT_Wavetable_factor, 0);
 
   // class GSL::FFT::ComplexWavetable < GSL::FFT::Wavetable
   cgsl_fft_complex_wavetable = rb_define_class_under(mgsl_fft, "ComplexWavetable",
-						     cgsl_fft_wavetable);
+                                                     cgsl_fft_wavetable);
   rb_define_singleton_method(cgsl_fft_complex_wavetable, "alloc",
-			     rb_gsl_fft_complex_wavetable_new, 1);
+                             rb_gsl_fft_complex_wavetable_new, 1);
 
   // class GSL::FFT::ComplexWorkspace < GSL::Object
-  cgsl_fft_complex_workspace = rb_define_class_under(mgsl_fft, "ComplexWorkspace", 
-						     cGSL_Object);
+  cgsl_fft_complex_workspace = rb_define_class_under(mgsl_fft, "ComplexWorkspace",
+                                                     cGSL_Object);
   rb_define_singleton_method(cgsl_fft_complex_workspace, "alloc",
-			     rb_gsl_fft_complex_workspace_new, 1);
+                             rb_gsl_fft_complex_workspace_new, 1);
 
   rb_define_method(cgsl_vector_complex, "forward", rb_gsl_fft_complex_forward, -1);
   rb_define_method(cgsl_vector_complex, "transform", rb_gsl_fft_complex_transform, -1);
@@ -989,58 +982,58 @@ void Init_gsl_fft(VALUE module)
   /*****/
 
   // TODO Do these method names need the "real_" and "halfcomplex_" prefixes?
-  rb_define_method(cgsl_vector, "real_radix2_transform", 
-		   rb_gsl_fft_real_radix2_transform, 0);
+  rb_define_method(cgsl_vector, "real_radix2_transform",
+                   rb_gsl_fft_real_radix2_transform, 0);
   rb_define_alias(cgsl_vector, "radix2_transform", "real_radix2_transform");
   rb_define_alias(cgsl_vector, "radix2_forward", "real_radix2_transform");
-  rb_define_method(cgsl_vector, "real_radix2_inverse", 
-		   rb_gsl_fft_halfcomplex_radix2_inverse, 0);
+  rb_define_method(cgsl_vector, "real_radix2_inverse",
+                   rb_gsl_fft_halfcomplex_radix2_inverse, 0);
   rb_define_alias(cgsl_vector, "radix2_inverse", "real_radix2_inverse");
-  rb_define_alias(cgsl_vector, "halfcomplex_radix2_inverse", 
-		  "real_radix2_inverse");
-  rb_define_method(cgsl_vector, "real_radix2_backward", 
-		   rb_gsl_fft_halfcomplex_radix2_backward, 0);
+  rb_define_alias(cgsl_vector, "halfcomplex_radix2_inverse",
+                  "real_radix2_inverse");
+  rb_define_method(cgsl_vector, "real_radix2_backward",
+                   rb_gsl_fft_halfcomplex_radix2_backward, 0);
   rb_define_alias(cgsl_vector, "radix2_backward", "real_radix2_backward");
-  rb_define_alias(cgsl_vector, "halfcomplex_radix2_backward", 
-		  "real_radix2_backward");
+  rb_define_alias(cgsl_vector, "halfcomplex_radix2_backward",
+                  "real_radix2_backward");
 
   // TODO Do these method names need the "real_" and "halfcomplex_" prefixes?
-  rb_define_method(cgsl_vector, "real_radix2_transform!", 
-		   rb_gsl_fft_real_radix2_transform2, 0);
+  rb_define_method(cgsl_vector, "real_radix2_transform!",
+                   rb_gsl_fft_real_radix2_transform2, 0);
   rb_define_alias(cgsl_vector, "radix2_transform!", "real_radix2_transform!");
   rb_define_alias(cgsl_vector, "radix2_forward!", "real_radix2_transform!");
-  rb_define_method(cgsl_vector, "real_radix2_inverse!", 
-		   rb_gsl_fft_halfcomplex_radix2_inverse2, 0);
+  rb_define_method(cgsl_vector, "real_radix2_inverse!",
+                   rb_gsl_fft_halfcomplex_radix2_inverse2, 0);
   rb_define_alias(cgsl_vector, "radix2_inverse!", "real_radix2_inverse!");
-  rb_define_alias(cgsl_vector, "halfcomplex_radix2_inverse!", 
-		  "real_radix2_inverse!");
-  rb_define_method(cgsl_vector, "real_radix2_backward!", 
-		   rb_gsl_fft_halfcomplex_radix2_backward2, 0);
+  rb_define_alias(cgsl_vector, "halfcomplex_radix2_inverse!",
+                  "real_radix2_inverse!");
+  rb_define_method(cgsl_vector, "real_radix2_backward!",
+                   rb_gsl_fft_halfcomplex_radix2_backward2, 0);
   rb_define_alias(cgsl_vector, "radix2_backward!", "real_radix2_backward!");
-  rb_define_alias(cgsl_vector, "halfcomplex_radix2_backward!", 
-		  "real_radix2_backward!");
+  rb_define_alias(cgsl_vector, "halfcomplex_radix2_backward!",
+                  "real_radix2_backward!");
 
   /*****/
 
   // class GSL::FFT::RealWavetable < GSL::FFT::Wavetable
-  cgsl_fft_real_wavetable = rb_define_class_under(mgsl_fft, "RealWavetable", 
-						  cgsl_fft_wavetable);
+  cgsl_fft_real_wavetable = rb_define_class_under(mgsl_fft, "RealWavetable",
+                                                  cgsl_fft_wavetable);
   rb_define_singleton_method(cgsl_fft_real_wavetable, "alloc",
-			     rb_gsl_fft_real_wavetable_new, 1);
+                             rb_gsl_fft_real_wavetable_new, 1);
 
   // class GSL::FFT::HalfComplexWavetable < GSL::FFT::Wavetable
-  cgsl_fft_halfcomplex_wavetable = rb_define_class_under(mgsl_fft, 
-							 "HalfComplexWavetable", cgsl_fft_wavetable);
+  cgsl_fft_halfcomplex_wavetable = rb_define_class_under(mgsl_fft,
+                                                         "HalfComplexWavetable", cgsl_fft_wavetable);
   rb_define_singleton_method(cgsl_fft_halfcomplex_wavetable, "alloc",
-			     rb_gsl_fft_halfcomplex_wavetable_new, 1);
+                             rb_gsl_fft_halfcomplex_wavetable_new, 1);
 
   /*****/
 
   // class GSL::FFT::RealWorkspace < GSL::Object
-  cgsl_fft_real_workspace = rb_define_class_under(mgsl_fft, "RealWorkspace", 
-						  cGSL_Object);
+  cgsl_fft_real_workspace = rb_define_class_under(mgsl_fft, "RealWorkspace",
+                                                  cGSL_Object);
   rb_define_singleton_method(cgsl_fft_real_workspace, "alloc",
-			     rb_gsl_fft_real_workspace_new, 1);
+                             rb_gsl_fft_real_workspace_new, 1);
 
   /*****/
 
@@ -1050,14 +1043,14 @@ void Init_gsl_fft(VALUE module)
   rb_define_alias(cgsl_vector, "forward", "real_transform");
   rb_define_alias(cgsl_vector, "fft_forward", "real_transform");
   rb_define_alias(cgsl_vector, "fft", "real_transform");
-  rb_define_method(cgsl_vector, "halfcomplex_transform", 
-		   rb_gsl_fft_halfcomplex_transform, -1);
-  rb_define_method(cgsl_vector, "halfcomplex_backward", 
-		   rb_gsl_fft_halfcomplex_backward, -1);
+  rb_define_method(cgsl_vector, "halfcomplex_transform",
+                   rb_gsl_fft_halfcomplex_transform, -1);
+  rb_define_method(cgsl_vector, "halfcomplex_backward",
+                   rb_gsl_fft_halfcomplex_backward, -1);
   rb_define_alias(cgsl_vector, "backward", "halfcomplex_backward");
   rb_define_alias(cgsl_vector, "fft_backward", "halfcomplex_backward");
-  rb_define_method(cgsl_vector, "halfcomplex_inverse", 
-		   rb_gsl_fft_halfcomplex_inverse, -1); 
+  rb_define_method(cgsl_vector, "halfcomplex_inverse",
+                   rb_gsl_fft_halfcomplex_inverse, -1);
   rb_define_alias(cgsl_vector, "fft_inverse", "halfcomplex_inverse");
   rb_define_alias(cgsl_vector, "ifft", "halfcomplex_inverse");
   rb_define_alias(cgsl_vector, "inverse", "halfcomplex_inverse");
@@ -1067,14 +1060,14 @@ void Init_gsl_fft(VALUE module)
   rb_define_alias(cgsl_vector, "forward!", "real_transform!");
   rb_define_alias(cgsl_vector, "fft_forward!", "real_transform!");
   rb_define_alias(cgsl_vector, "fft!", "real_transform!");
-  rb_define_method(cgsl_vector, "halfcomplex_transform!", 
-		   rb_gsl_fft_halfcomplex_transform2, -1);
+  rb_define_method(cgsl_vector, "halfcomplex_transform!",
+                   rb_gsl_fft_halfcomplex_transform2, -1);
   rb_define_method(cgsl_vector, "halfcomplex_backward!",
-		   rb_gsl_fft_halfcomplex_backward2, -1);
+                   rb_gsl_fft_halfcomplex_backward2, -1);
   rb_define_alias(cgsl_vector, "backward!", "halfcomplex_backward!");
   rb_define_alias(cgsl_vector, "fft_backward!", "halfcomplex_backward!");
-  rb_define_method(cgsl_vector, "halfcomplex_inverse!", 
-		   rb_gsl_fft_halfcomplex_inverse2, -1); 
+  rb_define_method(cgsl_vector, "halfcomplex_inverse!",
+                   rb_gsl_fft_halfcomplex_inverse2, -1);
   rb_define_alias(cgsl_vector, "fft_inverse!", "halfcomplex_inverse!");
   rb_define_alias(cgsl_vector, "ifft!", "halfcomplex_inverse!");
   rb_define_alias(cgsl_vector, "inverse!", "halfcomplex_inverse!");
@@ -1085,8 +1078,8 @@ void Init_gsl_fft(VALUE module)
   rb_define_alias(cgsl_vector, "real_to_complex", "fft_real_unpack");
   rb_define_alias(cgsl_vector, "r_to_c", "fft_real_unpack");
 
-  rb_define_method(cgsl_vector, "fft_halfcomplex_unpack", 
-		   rb_gsl_fft_halfcomplex_unpack, 0);
+  rb_define_method(cgsl_vector, "fft_halfcomplex_unpack",
+                   rb_gsl_fft_halfcomplex_unpack, 0);
   rb_define_alias(cgsl_vector, "halfcomplex_unpack", "fft_halfcomplex_unpack");
   rb_define_alias(cgsl_vector, "halfcomplex_to_complex", "fft_halfcomplex_unpack");
   rb_define_alias(cgsl_vector, "hc_to_c", "fft_halfcomplex_unpack");
@@ -1094,9 +1087,9 @@ void Init_gsl_fft(VALUE module)
   /*****/
 
   rb_define_method(cgsl_vector, "to_nrc_order",
-			     rb_gsl_fft_halfcomplex_to_nrc, 0);
-			     
+                   rb_gsl_fft_halfcomplex_to_nrc, 0);
+
   rb_define_method(cgsl_vector, "halfcomplex_amp_phase",
-			     rb_gsl_fft_halfcomplex_amp_phase, 0);
+                   rb_gsl_fft_halfcomplex_amp_phase, 0);
   rb_define_alias(cgsl_vector, "hc_amp_phase", "halfcomplex_amp_phase");
 }