ruby-fftw3 0.4.2 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12c13d848d56ccf4b757876d37f1fa98c9104014
-  data.tar.gz: be570dca5edbb4a73f186f70f1db3b68194bedde
+  metadata.gz: d047492085717f1d43edf5ed933ede4c3bfbc6d4
+  data.tar.gz: ad2fc2f85587f9cf41174a9926df784bfd2ab8ba
 SHA512:
-  metadata.gz: 2abb3ea036c9b2aecbdd3d12e888b7f3d75887860a3b6f0f57d25daa4e9649460d8fe0d301e7a381e6915a9b0261d6725cfce99221bbb4712069f874d5b11a27
-  data.tar.gz: 12df2c95fc26b9bb524d66386cf7cf87980168b10d81605475f2b77abf7f1653e9a10b64094637b259c19797bcf1d45a9359c602c4175031171ec9a1e78d3109
+  metadata.gz: 3afac8add19a71908a500e2eabe95ee3ec2ccebc9d442d384d50a7d195d5735f23225999a5361c229979fde51eb074695b183faa69f8956bd36bfdd593e0ce02
+  data.tar.gz: b53efbcb4a4577f6de1994bf50f695b6f7633d446218181f776781aff64b20eaaf15e5fe2c104f06548fc3c60c640b1de3c19e3c8acbed19e0092736fd45e6c5

data/.gitignore

@@ -1,8 +1,7 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
+*.[oa]
+*~
+*.so
+Makefile
+ChangeLog
 /pkg/
-/spec/reports/
 /tmp/

data/LICENSE.txt

@@ -1,7 +1,7 @@
 Ruby-FFTW3 is copyrighted free software by Takeshi Horinouchi and GFD
 Dennou Club (http://www.gfd-dennou.org/).
 
-Copyright 2001 (C) Takeshi Horinouchi and GFD Dennou Club
+Copyright 2001-2016 (C) Takeshi Horinouchi and GFD Dennou Club
 (http://www.gfd-dennou.org/) All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/Rakefile

@@ -1,2 +1,36 @@
-require "bundler/gem_tasks"
+# -* coding: utf-8 -*-
+require 'rake/testtask'
+require 'rake/extensiontask'
+require 'rake/packagetask'
+begin
+  require 'bundler/gem_helper'  # instead of 'bundler/gem_tasks' -> need manual
+                                # calls of install_tasks (see below)
+rescue LoadError
+  puts 'If you want to create gem, You must install Bundler'
+end
 
+Bundler::GemHelper.install_tasks(name: "ruby-fftw3")
+##Bundler::GemHelper.install_tasks(name: "ruby-fftw3-bigmem")
+
+require './lib/numru/fftw3/version.rb'
+def version
+  NumRu::FFTW3::VERSION
+end
+
+task :default => :test
+task :test => :compile
+Rake::TestTask.new do |t|
+  t.libs << 'lib' << 'test'
+  t.test_files = FileList['test/*.rb']
+end
+
+Rake::ExtensionTask.new do |ext|
+  ext.name = 'fftw3'
+  ext.ext_dir = 'ext/numru/fftw3'
+  ext.lib_dir = 'lib/numru/fftw3'
+end
+
+Rake::PackageTask.new('ruby-fftw3', "#{version}") do |t|
+  t.need_tar_gz = true
+  t.package_files.include `git ls-files`.split("\n")
+end

data/{extconf.rb → ext/numru/fftw3/extconf.rb}

@@ -1,12 +1,38 @@
 require "mkmf"
+require "rubygems" unless defined?(Gem)
 
-gem_narray_path=File::dirname(`gem which narray`)
-narray_include=gem_narray_path
-narray_lib=gem_narray_path
-dir_config('narray',narray_include,narray_lib)
- 
 dir_config('fftw3','/usr/local')
 
+require "rbconfig"
+so = RbConfig::CONFIG["DLEXT"]
+
+raise("Your gem is too old") unless Gem.respond_to?(:find_files) 
+
+env = ENV['NARRAY_TYPE']
+if env == "NArray" || env == "narray"
+  na_type = "narray"
+elsif env == "NumRu::NArray" || env == "numru-narray"
+  na_type = "numru-narray"
+elsif !env.nil?
+  raise "Unsupported value for the environment variable NARRAY_TYPE: #{env}"
+else
+  if Gem.find_files("narray.h").length > 0
+    na_type = "narray"
+  elsif Gem.find_files("numru/narray/narray.h").length > 0
+    na_type = "numru-narray"
+  end
+end
+
+case na_type
+when "narray"
+  narray_include = File.expand_path(File.dirname(Gem.find_files("narray.h")[0]))
+  narray_lib = File.expand_path(File.dirname(Gem.find_files("narray." + so)[0]))
+when "numru-narray"
+  narray_include = File.expand_path(File.dirname(Gem.find_files("numru/narray/narray.h")[0]))
+  narray_lib = File.expand_path(File.dirname(Gem.find_files("numru/narray/narray." + so)[0]))
+end
+
+dir_config('narray', narray_include, narray_lib)
 if ( ! ( have_header("narray.h") && have_header("narray_config.h") ) ) then
    print <<-EOS
    ** configure error **  
@@ -43,4 +69,4 @@ if /cygwin|mingw/ =~ RUBY_PLATFORM
    have_library("narray") || raise("ERROR: narray library is not found")
 end
 
-create_makefile("numru/fftw3")
+create_makefile("numru/fftw3/fftw3")

data/ext/numru/fftw3/na_fftw3.c

@@ -0,0 +1,690 @@
+/*
+  na_fftw3.c
+
+  FFT using FFTW Ver.3 (www.fftw.org)
+
+    (C) Takeshi Horinouchi
+    NO WARRANTY.
+
+*/
+
+#include <ruby.h>
+#include "narray.h"
+#include <fftw3.h>
+
+VALUE rb_mFFTW3;
+VALUE mNumRu;
+
+static VALUE
+#ifdef FFTW3_HAS_SINGLE_SUPPORT
+na_fftw3_double(int argc, VALUE *argv, VALUE self)
+  /* to be called by na_fftw3 */
+#else
+na_fftw3(int argc, VALUE *argv, VALUE self)
+  /* to be called directly */
+#endif
+{
+  VALUE val, vdir;
+  struct NARRAY *a1, *a2;
+  int i, dir, *shape, *bucket;
+  fftw_plan p;
+  fftw_complex *in, *out;
+  volatile VALUE v1, v2;
+
+  if (argc<2){
+    rb_raise(rb_eArgError, "Usage: fft(narray, direction [,dim0,dim1,...])");
+  }
+  val = argv[0];
+  vdir = argv[1];
+
+  dir = NUM2INT(vdir);
+  if ( dir != 1 && dir != -1 ){
+    rb_raise(rb_eArgError, "direction should be 1 or -1");
+  }
+  v1 = na_cast_object(val, NA_DCOMPLEX);
+  GetNArray(v1,a1);
+  v2 = na_make_object( NA_DCOMPLEX, a1->rank, a1->shape, CLASS_OF(v1) );
+  GetNArray(v2,a2);
+
+  shape = ALLOCA_N(int, a2->rank);
+  for (i=0; i<a2->rank; i++){
+      shape[i] = a2->shape[a2->rank-1-i];
+  }
+  in = (fftw_complex*)a1->ptr;
+  out = (fftw_complex*)a2->ptr;
+
+  if (argc==2) {
+      /* apply FFT to all dimensions */
+      p = fftw_plan_dft( a2->rank, shape, 
+			 in, out, dir, FFTW_ESTIMATE );
+  } else {
+      /* apply FFT to selected dimensions (by using the Guru interface) */
+      { /* introduce a new scope for additonal local variables */
+	  int fft_rank, howmany_rank, j, jf, je, dim;
+	  fftw_iodim *fft_dims, *howmany_dims;
+	  int *dimids;
+	  fft_rank = argc - 2;
+	  fft_dims = ALLOCA_N(fftw_iodim, fft_rank);
+	  dimids = ALLOCA_N(int, fft_rank);
+	  howmany_rank = fft_rank + 1;
+	  howmany_dims = ALLOCA_N(fftw_iodim, howmany_rank);
+	  
+	  for (i=2;i<argc;i++){
+	      dim = NUM2INT(argv[i]);
+	      if (dim<0) dim += a2->rank;  /* negative: count from the end */
+	      if (dim<0 || dim>=a2->rank){
+		  rb_raise(rb_eArgError, "dimension < 0 or >= rank");
+	      }
+	      dimids[i-2] = a2->rank - 1 - dim;
+	      if ( i>2 && dimids[i-2] == dimids[i-3] ){
+		  rb_raise(rb_eArgError, "redundant -- a same dimension is reppeated");
+	      }
+	  }
+	  
+	  /* bukcet sort in increasing order */
+	  bucket = ALLOCA_N(int,a2->rank);
+	  for(j=0; j<a2->rank; j++) bucket[j] = 0; /* initialize */
+	  for(i=0; i<fft_rank; i++) bucket[ dimids[i] ] = 1;
+	  for(j=0,i=0; j<a2->rank; j++) {
+	      if (bucket[j]==1){
+		  dimids[i] = j;
+		  i++;
+	      }
+	  }
+
+	  for(j=0; j<fft_rank; j++){
+	      fft_dims[j].n = shape[ dimids[j] ];
+	      fft_dims[j].is = 1;
+	      for (i=dimids[j]+1 ; i<a2->rank ; i++){
+		  fft_dims[j].is *= shape[i];
+	      }
+	      fft_dims[j].os = fft_dims[j].is;
+	      /* printf("fft_ %d  n:%d  is:%d\n",j,
+		       fft_dims[j].n,fft_dims[j].is);*/
+	  }
+	  for(j=0; j<=fft_rank; j++){
+	      howmany_dims[j].n = 1;
+	      jf = (j==0) ? 0 : (dimids[j-1]+1) ;
+	      je = (j==fft_rank) ? a2->rank : (dimids[j]) ;
+	      for (i=jf; i<je; i++){
+		  howmany_dims[j].n *= shape[i];
+	      }
+	      howmany_dims[j].is = 1;
+	      if (j<fft_rank){
+		  for (i=dimids[j]; i<a2->rank; i++){
+		      howmany_dims[j].is *= shape[i];
+		  }
+	      }
+	      howmany_dims[j].os = howmany_dims[j].is;
+	      /* printf("how_ %d  n:%d  is:%d\n",j,
+		        howmany_dims[j].n,howmany_dims[j].is); */
+	  }
+
+	  p = fftw_plan_guru_dft( fft_rank, fft_dims, 
+				  howmany_rank, howmany_dims,
+				  in, out, dir, FFTW_ESTIMATE );
+
+      }
+  }
+
+  fftw_execute(p);
+  fftw_destroy_plan(p);
+
+  return v2;
+}
+
+#ifdef FFTW3_HAS_SINGLE_SUPPORT
+
+/* sourse code generation of na_fftw3_float:
+  Copy na_fftw3_double, and replace 
+     fftw --> fftwf
+     DCOMPLEX --> SCOMPLEX
+ */
+static VALUE
+na_fftw3_float(int argc, VALUE *argv, VALUE self)
+{
+  VALUE val, vdir;
+  struct NARRAY *a1, *a2;
+  int i, dir, *shape, *bucket;
+  fftwf_plan p;
+  fftwf_complex *in, *out;
+  volatile VALUE v1, v2;
+
+  if (argc<2){
+    rb_raise(rb_eArgError, "Usage: fft(narray, direction [,dim0,dim1,...])");
+  }
+  val = argv[0];
+  vdir = argv[1];
+
+  dir = NUM2INT(vdir);
+  if ( dir != 1 && dir != -1 ){
+    rb_raise(rb_eArgError, "direction should be 1 or -1");
+  }
+  v1 = na_cast_object(val, NA_SCOMPLEX);
+  GetNArray(v1,a1);
+  v2 = na_make_object( NA_SCOMPLEX, a1->rank, a1->shape, CLASS_OF(v1) );
+  GetNArray(v2,a2);
+
+  shape = ALLOCA_N(int, a2->rank);
+  for (i=0; i<a2->rank; i++){
+      shape[i] = a2->shape[a2->rank-1-i];
+  }
+  in = (fftwf_complex*)a1->ptr;
+  out = (fftwf_complex*)a2->ptr;
+
+  if (argc==2) {
+      /* apply FFT to all dimensions */
+      p = fftwf_plan_dft( a2->rank, shape, 
+			 in, out, dir, FFTW_ESTIMATE );
+  } else {
+      /* apply FFT to selected dimensions (by using the Guru interface) */
+      { /* introduce a new scope for additonal local variables */
+	  int fft_rank, howmany_rank, j, jf, je, dim;
+	  fftw_iodim *fft_dims, *howmany_dims;
+	  int *dimids;
+	  fft_rank = argc - 2;
+	  fft_dims = ALLOCA_N(fftw_iodim, fft_rank);
+	  dimids = ALLOCA_N(int, fft_rank);
+	  howmany_rank = fft_rank + 1;
+	  howmany_dims = ALLOCA_N(fftw_iodim, howmany_rank);
+	  
+	  for (i=2;i<argc;i++){
+	      dim = NUM2INT(argv[i]);
+	      if (dim<0) dim += a2->rank;  /* negative: count from the end */
+	      if (dim<0 || dim>=a2->rank){
+		  rb_raise(rb_eArgError, "dimension < 0 or >= rank");
+	      }
+	      dimids[i-2] = a2->rank - 1 - dim;
+	      if ( i>2 && dimids[i-2] == dimids[i-3] ){
+		  rb_raise(rb_eArgError, "redundant -- a same dimension is reppeated");
+	      }
+	  }
+	  
+	  /* bukcet sort in increasing order */
+	  bucket = ALLOCA_N(int,a2->rank);
+	  for(j=0; j<a2->rank; j++) bucket[j] = 0; /* initialize */
+	  for(i=0; i<fft_rank; i++) bucket[ dimids[i] ] = 1;
+	  for(j=0,i=0; j<a2->rank; j++) {
+	      if (bucket[j]==1){
+		  dimids[i] = j;
+		  i++;
+	      }
+	  }
+
+	  for(j=0; j<fft_rank; j++){
+	      fft_dims[j].n = shape[ dimids[j] ];
+	      fft_dims[j].is = 1;
+	      for (i=dimids[j]+1 ; i<a2->rank ; i++){
+		  fft_dims[j].is *= shape[i];
+	      }
+	      fft_dims[j].os = fft_dims[j].is;
+	      /* printf("fft_ %d  n:%d  is:%d\n",j,
+		       fft_dims[j].n,fft_dims[j].is);*/
+	  }
+	  for(j=0; j<=fft_rank; j++){
+	      howmany_dims[j].n = 1;
+	      jf = (j==0) ? 0 : (dimids[j-1]+1) ;
+	      je = (j==fft_rank) ? a2->rank : (dimids[j]) ;
+	      for (i=jf; i<je; i++){
+		  howmany_dims[j].n *= shape[i];
+	      }
+	      howmany_dims[j].is = 1;
+	      if (j<fft_rank){
+		  for (i=dimids[j]; i<a2->rank; i++){
+		      howmany_dims[j].is *= shape[i];
+		  }
+	      }
+	      howmany_dims[j].os = howmany_dims[j].is;
+	      /* printf("how_ %d  n:%d  is:%d\n",j,
+		        howmany_dims[j].n,howmany_dims[j].is); */
+	  }
+
+	  p = fftwf_plan_guru_dft( fft_rank, fft_dims, 
+				  howmany_rank, howmany_dims,
+				  in, out, dir, FFTW_ESTIMATE );
+
+      }
+  }
+
+  fftwf_execute(p);
+  fftwf_destroy_plan(p);
+
+  return v2;
+}
+
+/*
+ * call-seq:
+ *   FFTW3.fft(narray, dir [, dim, dim, ...])
+ * 
+ * Conducts complex FFT (unnormalized). You can use more user-friendly wrappers
+ * fft_fw and fft_bk.
+ * 
+ * ARGUMENTS
+ * * narray (NArray or NArray-compatible Array) : array to be
+ *   transformed. If real, coerced to complex before transformation.
+ *   If narray is single-precision and the single-precision
+ *   version of FFTW3 is installed (before installing this module),
+ *   this method does a single-precision transform. 
+ *   Otherwise, a double-precision transform is used.
+ * * dir (FORWARD (which is simply equal to -1; 
+ *   referable as NumRu::FFTW3::FORWARD) or BACKWARD
+ *   (which is simply 1) ) : the direction of FFT,
+ *   forward if FORWARD and backward if BACKWARD.
+ * * optional 3rd, 4th,... arguments (Integer) : Specifies dimensions 
+ *   to apply FFT. For example, if 0, the first dimension is
+ *   transformed (1D FFT); If -1, the last dimension is used (1D FFT);
+ *   If 0,2,4, the first, third, and fifth dimensions
+ *   are transformed (3D FFT); If entirely omitted, ALL DIMENSIONS
+ *   ARE SUBJECT TO FFT, so 3D FFT is done with a 3D array.
+ * 
+ * RETURN VALUE
+ * * a complex NArray
+ * 
+ * NOTE
+ * * As in FFTW, return value is NOT normalized. Thus, a consecutive
+ *   forward and backward transform would multiply the size of
+ *   data used for transform. You can normalize, for example,
+ *   the forward transform FFTW.fft(narray, -1, 0, 1)
+ *   (FFT regarding the first (dim 0) & second (dim 1) dimensions) by
+ *   dividing with (narray.shape[0]*narray.shape[1]). Likewise,
+ *   the result of FFTW.fft(narray, -1) (FFT for all dimensions)
+ *   can be normalized by narray.length.
+ */
+static VALUE
+na_fftw3(int argc, VALUE *argv, VALUE self)
+{
+  VALUE val;
+  volatile VALUE v1;
+  struct NARRAY *a1;
+
+  if (argc<2){
+    rb_raise(rb_eArgError, "Usage: fft(narray, direction [,dim0,dim1,...])");
+  }
+  val = argv[0];
+  v1 = na_to_narray(val);
+  GetNArray(v1,a1);
+  if(a1->type <= NA_SFLOAT || a1->type == NA_SCOMPLEX ){
+      return( na_fftw3_float(argc, argv, self) );
+  } else {
+      return( na_fftw3_double(argc, argv, self) );
+  }
+
+}
+
+#endif
+
+static VALUE
+#ifdef FFTW3_HAS_SINGLE_SUPPORT
+na_fftw3_r2r_double(int argc, VALUE *argv, VALUE self)
+  /* to be called by na_fftw3_r2r */
+#else
+na_fftw3_r2r(int argc, VALUE *argv, VALUE self)
+  /* to be called directly */
+#endif
+{
+  VALUE val, vkinds;
+  struct NARRAY *a1, *a2;
+  int i, *shape, *bucket, len;
+  fftw_r2r_kind *kinds;
+  fftw_plan p;
+  double *in, *out;
+  volatile VALUE v1, v2;
+
+  if (argc<2){
+    rb_raise(rb_eArgError, "Usage: fft_r2r(narray, kinds [,dim0,dim1,...])");
+  }
+  val = argv[0];
+  vkinds = argv[1];
+
+  v1 = na_cast_object(val, NA_DFLOAT);
+  GetNArray(v1,a1);
+  v2 = na_make_object( NA_DFLOAT, a1->rank, a1->shape, CLASS_OF(v1) );
+  GetNArray(v2,a2);
+
+  shape = ALLOCA_N(int, a2->rank);
+  for (i=0; i<a2->rank; i++){
+      shape[i] = a2->shape[a2->rank-1-i];
+  }
+  in = (double*)a1->ptr;
+  out = (double*)a2->ptr;
+
+  switch (TYPE(vkinds)) {
+  case T_ARRAY:
+      len = RARRAY_LEN(vkinds);
+      kinds = ALLOCA_N(fftw_r2r_kind, len);
+      for (i = 0; i < len; i++) {
+	  kinds[i] = NUM2INT(RARRAY_PTR(vkinds)[len-1-i]);//column- to row-major
+      }
+      break;
+  case T_FIXNUM:
+      if (argc == 2) {
+	  len = a1->rank;
+      } else {
+	  len = argc-2;
+      }
+      kinds = ALLOCA_N(fftw_r2r_kind, len);
+      for (i = 0; i < len; i++) {
+	  kinds[i] = NUM2INT(vkinds);
+      }
+      break;
+  default:
+      rb_raise(rb_eTypeError, "unsupported kinds type");
+      break;
+  }
+
+  for (i = 0; i < len; i++) {
+      if ( kinds[i] < FFTW_R2HC || kinds[i] > FFTW_RODFT11 ){
+	  rb_raise(rb_eArgError, "unsupported kind (%d).", kinds[i]);
+      }
+  }
+
+  if (argc==2) {
+      /* apply FFT to all dimensions */
+      p = fftw_plan_r2r( a2->rank, shape,
+			 in, out, kinds, FFTW_ESTIMATE );
+  } else {
+      /* apply FFT to selected dimensions (by using the Guru interface) */
+      { /* introduce a new scope for additonal local variables */
+	  int fft_rank, howmany_rank, j, jf, je, dim;
+	  fftw_iodim *fft_dims, *howmany_dims;
+	  int *dimids;
+	  fft_rank = argc - 2;
+	  fft_dims = ALLOCA_N(fftw_iodim, fft_rank);
+	  dimids = ALLOCA_N(int, fft_rank);
+	  howmany_rank = fft_rank + 1;
+	  howmany_dims = ALLOCA_N(fftw_iodim, howmany_rank);
+
+	  for (i=2;i<argc;i++){
+	      dim = NUM2INT(argv[i]);
+	      if (dim<0) dim += a2->rank;  /* negative: count from the end */
+	      if (dim<0 || dim>=a2->rank){
+		  rb_raise(rb_eArgError, "dimension < 0 or >= rank");
+	      }
+	      dimids[i-2] = a2->rank - 1 - dim;
+	      if ( i>2 && dimids[i-2] == dimids[i-3] ){
+		  rb_raise(rb_eArgError, "redundant -- a same dimension is reppeated");
+	      }
+	  }
+
+	  /* bukcet sort in increasing order */
+	  bucket = ALLOCA_N(int,a2->rank);
+	  for(j=0; j<a2->rank; j++) bucket[j] = 0; /* initialize */
+	  for(i=0; i<fft_rank; i++) bucket[ dimids[i] ] = 1;
+	  for(j=0,i=0; j<a2->rank; j++) {
+	      if (bucket[j]==1){
+		  dimids[i] = j;
+		  i++;
+	      }
+	  }
+
+	  for(j=0; j<fft_rank; j++){
+	      fft_dims[j].n = shape[ dimids[j] ];
+	      fft_dims[j].is = 1;
+	      for (i=dimids[j]+1 ; i<a2->rank ; i++){
+		  fft_dims[j].is *= shape[i];
+	      }
+	      fft_dims[j].os = fft_dims[j].is;
+	      /* printf("fft_ %d  n:%d  is:%d\n",j,
+		       fft_dims[j].n,fft_dims[j].is);*/
+	  }
+	  for(j=0; j<=fft_rank; j++){
+	      howmany_dims[j].n = 1;
+	      jf = (j==0) ? 0 : (dimids[j-1]+1) ;
+	      je = (j==fft_rank) ? a2->rank : (dimids[j]) ;
+	      for (i=jf; i<je; i++){
+		  howmany_dims[j].n *= shape[i];
+	      }
+	      howmany_dims[j].is = 1;
+	      if (j<fft_rank){
+		  for (i=dimids[j]; i<a2->rank; i++){
+		      howmany_dims[j].is *= shape[i];
+		  }
+	      }
+	      howmany_dims[j].os = howmany_dims[j].is;
+	      /* printf("how_ %d  n:%d  is:%d\n",j,
+		        howmany_dims[j].n,howmany_dims[j].is); */
+	  }
+
+	  p = fftw_plan_guru_r2r( fft_rank, fft_dims,
+				  howmany_rank, howmany_dims,
+				  in, out, kinds, FFTW_ESTIMATE );
+
+      }
+  }
+
+  fftw_execute(p);
+  fftw_destroy_plan(p);
+
+  return v2;
+}
+
+static VALUE
+#ifdef FFTW3_HAS_SINGLE_SUPPORT
+na_fftw3_r2r_float(int argc, VALUE *argv, VALUE self)
+  /* to be called by na_fftw3_r2r */
+{
+  VALUE val, vkinds;
+  struct NARRAY *a1, *a2;
+  int i, *shape, *bucket, len;
+  fftwf_r2r_kind *kinds;
+  fftwf_plan p;
+  float *in, *out;
+  volatile VALUE v1, v2;
+
+  if (argc<2){
+    rb_raise(rb_eArgError, "Usage: fft_r2r(narray, kinds [,dim0,dim1,...])");
+  }
+  val = argv[0];
+  vkinds = argv[1];
+
+  v1 = na_cast_object(val, NA_SFLOAT);
+  GetNArray(v1,a1);
+  v2 = na_make_object( NA_SFLOAT, a1->rank, a1->shape, CLASS_OF(v1) );
+  GetNArray(v2,a2);
+
+  shape = ALLOCA_N(int, a2->rank);
+  for (i=0; i<a2->rank; i++){
+      shape[i] = a2->shape[a2->rank-1-i];
+  }
+  in = (float*)a1->ptr;
+  out = (float*)a2->ptr;
+
+  switch (TYPE(vkinds)) {
+  case T_ARRAY:
+      len = RARRAY_LEN(vkinds);
+      kinds = ALLOCA_N(fftwf_r2r_kind, len);
+      for (i = 0; i < len; i++) {
+	  kinds[i] = NUM2INT(RARRAY_PTR(vkinds)[len-1-i]);//column- to row-major
+      }
+      break;
+  case T_FIXNUM:
+      if (argc == 2) {
+	  len = a1->rank;
+      } else {
+	  len = argc-2;
+      }
+      kinds = ALLOCA_N(fftwf_r2r_kind, len);
+      for (i = 0; i < len; i++) {
+	  kinds[i] = NUM2INT(vkinds);
+      }
+      break;
+  default:
+      rb_raise(rb_eTypeError, "unsupported kinds type");
+      break;
+  }
+
+  for (i = 0; i < len; i++) {
+      if ( kinds[i] < FFTW_R2HC || kinds[i] > FFTW_RODFT11 ){
+	  rb_raise(rb_eArgError, "unsupported kind (%d).", kinds[i]);
+      }
+  }
+
+  if (argc==2) {
+      /* apply FFT to all dimensions */
+      p = fftwf_plan_r2r( a2->rank, shape,
+			 in, out, kinds, FFTW_ESTIMATE );
+  } else {
+      /* apply FFT to selected dimensions (by using the Guru interface) */
+      { /* introduce a new scope for additonal local variables */
+	  int fft_rank, howmany_rank, j, jf, je, dim;
+	  fftwf_iodim *fft_dims, *howmany_dims;
+	  int *dimids;
+	  fft_rank = argc - 2;
+	  fft_dims = ALLOCA_N(fftwf_iodim, fft_rank);
+	  dimids = ALLOCA_N(int, fft_rank);
+	  howmany_rank = fft_rank + 1;
+	  howmany_dims = ALLOCA_N(fftwf_iodim, howmany_rank);
+
+	  for (i=2;i<argc;i++){
+	      dim = NUM2INT(argv[i]);
+	      if (dim<0) dim += a2->rank;  /* negative: count from the end */
+	      if (dim<0 || dim>=a2->rank){
+		  rb_raise(rb_eArgError, "dimension < 0 or >= rank");
+	      }
+	      dimids[i-2] = a2->rank - 1 - dim;
+	      if ( i>2 && dimids[i-2] == dimids[i-3] ){
+		  rb_raise(rb_eArgError, "redundant -- a same dimension is reppeated");
+	      }
+	  }
+
+	  /* bukcet sort in increasing order */
+	  bucket = ALLOCA_N(int,a2->rank);
+	  for(j=0; j<a2->rank; j++) bucket[j] = 0; /* initialize */
+	  for(i=0; i<fft_rank; i++) bucket[ dimids[i] ] = 1;
+	  for(j=0,i=0; j<a2->rank; j++) {
+	      if (bucket[j]==1){
+		  dimids[i] = j;
+		  i++;
+	      }
+	  }
+
+	  for(j=0; j<fft_rank; j++){
+	      fft_dims[j].n = shape[ dimids[j] ];
+	      fft_dims[j].is = 1;
+	      for (i=dimids[j]+1 ; i<a2->rank ; i++){
+		  fft_dims[j].is *= shape[i];
+	      }
+	      fft_dims[j].os = fft_dims[j].is;
+	      /* printf("fft_ %d  n:%d  is:%d\n",j,
+		       fft_dims[j].n,fft_dims[j].is);*/
+	  }
+	  for(j=0; j<=fft_rank; j++){
+	      howmany_dims[j].n = 1;
+	      jf = (j==0) ? 0 : (dimids[j-1]+1) ;
+	      je = (j==fft_rank) ? a2->rank : (dimids[j]) ;
+	      for (i=jf; i<je; i++){
+		  howmany_dims[j].n *= shape[i];
+	      }
+	      howmany_dims[j].is = 1;
+	      if (j<fft_rank){
+		  for (i=dimids[j]; i<a2->rank; i++){
+		      howmany_dims[j].is *= shape[i];
+		  }
+	      }
+	      howmany_dims[j].os = howmany_dims[j].is;
+	      /* printf("how_ %d  n:%d  is:%d\n",j,
+		        howmany_dims[j].n,howmany_dims[j].is); */
+	  }
+
+	  p = fftwf_plan_guru_r2r( fft_rank, fft_dims,
+				  howmany_rank, howmany_dims,
+				  in, out, kinds, FFTW_ESTIMATE );
+
+      }
+  }
+
+  fftwf_execute(p);
+  fftwf_destroy_plan(p);
+
+  return v2;
+}
+
+/*
+ * call-seq:
+ *   FFTW3.fft_r2r(narray, kind [, dim, dim, ...])
+ * 
+ * Conducts real FFT (unnormalized).
+ * 
+ * ARGUMENTS
+ * * narray (NArray or NArray-compatible Array) : array to be
+ *   transformed. Cannot be complex.
+ * * kind : specifies the kind of FFT. One of the following:
+ *   R2HC, HC2R, DHT, REDFT00, REDFT01, REDFT10, REDFT11, RODFT00, RODFT01, 
+ *   RODFT10, or RODFT11 (referable as NumRu::FFTW3::REDFT10). See Ch.2 of
+ *   http://www.fftw.org/fftw3_doc/ (http://www.fftw.org/fftw3.pdf).
+ * * optional 3rd, 4th,... arguments (Integer) : See FFTW3.fft.
+ *   
+ * 
+ * RETURN VALUE
+ * * a real NArray
+ * 
+ * NOTE
+ * * As in FFTW, return value is NOT normalized, and the length needed
+ *   normalize is different for each kind.
+ */
+static VALUE
+na_fftw3_r2r(int argc, VALUE *argv, VALUE self)
+{
+  VALUE val;
+  volatile VALUE v1;
+  struct NARRAY *a1;
+
+  if (argc<2){
+    rb_raise(rb_eArgError, "Usage: fft_r2r(narray, kinds [,dim0,dim1,...])");
+  }
+  val = argv[0];
+  v1 = na_to_narray(val);
+  GetNArray(v1,a1);
+  if(a1->type <= NA_SFLOAT || a1->type == NA_SCOMPLEX ){
+      return( na_fftw3_r2r_float(argc, argv, self) );
+  } else {
+      return( na_fftw3_r2r_double(argc, argv, self) );
+  }
+
+}
+
+#endif
+
+void
+ Init_fftw3()
+{
+  rb_require("narray");
+  mNumRu = rb_define_module("NumRu");
+  rb_mFFTW3 = rb_define_module_under(mNumRu, "FFTW3");
+  rb_define_module_function(rb_mFFTW3, "fft", na_fftw3, -1);
+  rb_define_module_function(rb_mFFTW3, "fft_r2r", na_fftw3_r2r, -1);
+  /* Specifier of forward complex FFT. Integer equal to -1. */
+  rb_define_const(rb_mFFTW3, "FORWARD",  INT2NUM(FFTW_FORWARD));
+  /* Specifier of backward complex FFT. Integer equal to 1. */
+  rb_define_const(rb_mFFTW3, "BACKWARD", INT2NUM(FFTW_BACKWARD));
+  /* Specifier of real FFT kind. real to "halfcomplex" */
+  rb_define_const(rb_mFFTW3, "R2HC", INT2NUM(FFTW_R2HC));
+  /* Specifier of real FFT kind. "halfcomplex" to real */
+  rb_define_const(rb_mFFTW3, "HC2R", INT2NUM(FFTW_HC2R));
+  /* Specifier of real FFT kind. Discrete Hartley Transform */
+  rb_define_const(rb_mFFTW3, "DHT", INT2NUM(FFTW_DHT));
+  /* Specifier of real FFT kind. cosine (even) transform; 
+     logical data length 2*(n-1); inverse is itself  */
+  rb_define_const(rb_mFFTW3, "REDFT00", INT2NUM(FFTW_REDFT00));
+  /* Specifier of real FFT kind. cosine (even) transform;
+   * logical data length 2*n; inverse is REDFT10 */
+  rb_define_const(rb_mFFTW3, "REDFT01", INT2NUM(FFTW_REDFT01));
+  /* Specifier of real FFT kind. cosine (even) transform;
+   * logical data length 2*n; inverse is REDFT01 */
+  rb_define_const(rb_mFFTW3, "REDFT10", INT2NUM(FFTW_REDFT10));
+  /* Specifier of real FFT kind. cosine (even) transform;
+   * logical data length 2*n; inverse is itself */
+  rb_define_const(rb_mFFTW3, "REDFT11", INT2NUM(FFTW_REDFT11));
+  /* Specifier of real FFT kind. sine (odd) transform;
+   * logical data length 2*(n+1); inverse is itself */
+  rb_define_const(rb_mFFTW3, "RODFT00", INT2NUM(FFTW_RODFT00));
+  /* Specifier of real FFT kind. sine (odd) transform;
+   * logical data length 2*n; inverse is RODFT10 */
+  rb_define_const(rb_mFFTW3, "RODFT01", INT2NUM(FFTW_RODFT01));
+  /* Specifier of real FFT kind. sine (odd) transform;
+   * logical data length 2*n; inverse is RODFT01 */
+  rb_define_const(rb_mFFTW3, "RODFT10", INT2NUM(FFTW_RODFT10));
+  /* Specifier of real FFT kind. sine (odd) transform;
+   * logical data length 2*n; inverse is itself */
+  rb_define_const(rb_mFFTW3, "RODFT11", INT2NUM(FFTW_RODFT11));
+}