ooura_fft 0.1.0

data/ext/ooura_fft/fft.c

@@ -0,0 +1,307 @@
+/*******************************************************************************
+	fft.c -- FFT
+	
+	$author$
+*******************************************************************************/
+#include <ruby.h>
+#include "ooura_fft/globals.h"
+#include "ooura_fft/api.h"
+#include "internal/setting/ooura_fft.h"
+#include "missing/missing.h"
+#include "abi/fftsg/fftsg.h"
+
+
+static void InitVM_FFTMain(void);
+void
+InitVM_FFT(void)
+{
+	InitVM(FFTMain);
+}
+
+int
+opts_inversion_p(VALUE opts)
+{
+    static ID kwds[1];
+    VALUE inversion;
+    if (!kwds[0]) {
+        kwds[0] = rb_intern_const("inversion");
+    }
+    rb_get_kwargs(opts, kwds, 0, 1, &inversion);
+    switch (inversion) {
+      case Qtrue: case Qfalse:
+        break;
+      case Qundef:
+        return 0;
+      default:
+        rb_raise(rb_eArgError, "true or false is expected as inversion: %+"PRIsVALUE,
+                 inversion);
+    }
+
+    return inversion == Qtrue;
+}
+
+static VALUE
+fft_callback(int argc, VALUE *argv, VALUE (*callback_func)(VALUE, int))
+{
+	VALUE ary, opts = Qnil;
+	rb_scan_args(argc, argv, "11", &ary, &opts);
+	int invertible = opts_inversion_p(opts) ? -1 : 1;
+
+	Check_Type(ary, T_ARRAY);
+
+	return callback_func(ary, invertible);
+}
+
+
+#include "internal/solver/ooura_fft/cdft.h" // fft_cdft_inline()
+/*
+ * 
+ * Document-method: cdft
+ * 
+ * call-seq:
+ *   OouraFFT.cdft(ary)                  -> [*Complex]
+ *   OouraFFT.cdft(ary, inversion: true) -> [*Complex]
+ * 
+ * Perform FFT with the first argument +ary+ as a numerical sequence.<br>
+ * If the keyword argument +inversion+ is +true+, perform an inverse FFT.
+ * 
+ * [Function type]          Complex Discrete Fourier Transform
+ * [Definition]
+ *   [case1]  <tt>X[k] = sum_j=0^n-1 x[j]*exp(2*pi*i*j*k/n), 0<=k<n</tt>
+ *   [case2]  <tt>X[k] = sum_j=0^n-1 x[j]*exp(-2*pi*i*j*k/n), 0<=k<n</tt>
+ *   notes:: <tt>sum_j=0^n-1 is a summation from j=0 to n-1</tt>
+ * [+ary+ sequence type]    All +Complex+
+ * [Array size requirement] n >= 1, n = power of 2
+ * 
+ *   def sinewave(amp, f0, fs, n)
+ *     amp * Math.sin(2 * Math::PI * f0 * n / fs)
+ *   end
+ *   
+ *   OouraFFT.cdft(Array.new(8){|n| sinewave(0.25, 250.0, 8000, n)})
+ *   #=> [(1.1441462984511075+0.0i),
+ *   #=>  (-0.21410561232180816-0.3229641637954819i),
+ *   #=>  (-0.14986404592245728-0.12744889477603982i),
+ *   #=>  (-0.13944777827146557-0.05236611372238342i),
+ *   #=>  (-0.13731142541964547+0.0i),
+ *   #=>  (-0.13944777827146557+0.05236611372238342i),
+ *   #=>  (-0.14986404592245728+0.12744889477603982i),
+ *   #=>  (-0.21410561232180816+0.3229641637954819i)]
+ */
+static VALUE
+fft_cdft(int argc, VALUE *argv, VALUE unused_obj)
+{
+	return fft_callback(argc, argv, fft_cdft_inline);
+}
+
+
+#include "internal/solver/ooura_fft/rdft.h" // fft_rdft_inline()
+/*
+ * Document-method: rdft
+ * 
+ * call-seq:
+ *   OouraFFT.rdft(ary)                  -> [*Float]
+ *   OouraFFT.rdft(ary, inversion: true) -> [*Float]
+ * 
+ * Perform FFT with the first argument +ary+ as a numerical sequence.<br>
+ * If the keyword argument +inversion+ is +true+, perform an inverse FFT.
+ * 
+ * [Function type]            Real Discrete Fourier Transform
+ * [Definition]
+ *   case1::  RDFT
+ *     :: <tt>R[k] = sum_j=0^n-1 a[j]*cos(2*pi*j*k/n), 0<=k<=n/2</tt>
+ *     :: <tt>I[k] = sum_j=0^n-1 a[j]*sin(2*pi*j*k/n), 0<k<n/2</tt>
+ *   case2::  IRDFT (excluding scale)
+ *     :: <tt>a[k] = (R[0] + R[n/2]*cos(pi*k))/2 + sum_j=1^n/2-1 R[j]*cos(2*pi*j*k/n) + sum_j=1^n/2-1 I[j]*sin(2*pi*j*k/n), 0<=k<n</tt>
+ * [+ary+ sequence type]      All +Float+
+ * [Array size requirement]   n >= 2, n = power of 2
+ * 
+ *   def sinewave(amp, f0, fs, n)
+ *     amp * Math.sin(2 * Math::PI * f0 * n / fs)
+ *   end
+ *   
+ *   OouraFFT.rdft(Array.new(8){|n| sinewave(0.25, 250.0, 8000, n)})
+ *   # => [1.1441462984511075,
+ *   # =>  -0.13731142541964547,
+ *   # =>  -0.21410561232180816,
+ *   # =>  -0.3229641637954819,
+ *   # =>  -0.14986404592245728,
+ *   # =>  -0.12744889477603982,
+ *   # =>  -0.13944777827146557,
+ *   # =>  -0.052366113722383416]
+ */
+static VALUE
+fft_rdft(int argc, VALUE *argv, VALUE unused_obj)
+{
+	return fft_callback(argc, argv, fft_rdft_inline);
+}
+
+
+#include "internal/solver/ooura_fft/ddct.h" // fft_ddct_inline()
+/*
+ * Document-method: ddct
+ * 
+ * call-seq:
+ *   OouraFFT.ddct(ary)                  -> [*Float]
+ *   OouraFFT.ddct(ary, inversion: true) -> [*Float]
+ * 
+ * Perform FFT with the first argument +ary+ as a numerical sequence.<br>
+ * If the keyword argument +inversion+ is +true+, perform an inverse FFT.
+ * 
+ * [Function type]            Discrete Cosine Transform
+ * [Definition]
+ *   case1:: IDCT (excluding scale)
+ *     :: <tt>C[k] = sum_j=0^n-1 a[j]*cos(pi*j*(k+1/2)/n), 0<=k<n</tt>
+ *   case2:: DCT
+ *     :: <tt>C[k] = sum_j=0^n-1 a[j]*cos(pi*(j+1/2)*k/n), 0<=k<n</tt>
+ * [+ary+ sequence type]      All +Float+
+ * [Array size requirement]   n >= 2, n = power of 2
+ * 
+ *   def sinewave(amp, f0, fs, n)
+ *     amp * Math.sin(2 * Math::PI * f0 * n / fs)
+ *   end
+ *   
+ *   OouraFFT.ddct(Array.new(8){|n| sinewave(0.25, 250.0, 8000, n)})
+ *   #=> [0.6284174365157309,
+ *   #=> -0.6284174365157309,
+ *   #=>  0.18707572033318604,
+ *   #=> -0.18707572033318612,
+ *   #=>  0.08352232973991239,
+ *   #=> -0.08352232973991236,
+ *   #=>  0.02486404592245728,
+ *   #=> -0.024864045922457167]
+ */
+static VALUE
+fft_ddct(int argc, VALUE *argv, VALUE unused_obj)
+{
+	return fft_callback(argc, argv, fft_ddct_inline);
+}
+
+
+#include "internal/solver/ooura_fft/ddst.h" // fft_ddst_inline()
+/*
+ * Document-method: ddst
+ * 
+ * call-seq:
+ *   OouraFFT.ddst(ary)                  -> [*Float]
+ *   OouraFFT.ddst(ary, inversion: true) -> [*Float]
+ * 
+ * Perform FFT with the first argument +ary+ as a numerical sequence.<br>
+ * If the keyword argument +inversion+ is +true+, perform an inverse FFT.
+ * 
+ * [Function type]            Discrete Sine Transform
+ * [Definition]
+ *   case1:: IDST (excluding scale)
+ *     :: <tt>S[k] = sum_j=1^n A[j]*sin(pi*j*(k+1/2)/n), 0<=k<n</tt>
+ *   case2:: DST
+ *     :: <tt>S[k] = sum_j=0^n-1 a[j]*sin(pi*(j+1/2)*k/n), 0<k<=n</tt>
+ * [+ary+ sequence type]      All +Float+
+ * [Array size requirement]   n >= 2, n = power of 2
+ * 
+ *   def sinewave(amp, f0, fs, n)
+ *     amp * Math.sin(2 * Math::PI * f0 * n / fs)
+ *   end
+ *   
+ *   OouraFFT.ddst(Array.new(8){|n| sinewave(0.25, 250.0, 8000, n)})
+ *   #=> [0.875,
+ *   #=>  0.12500000000000003,
+ *   #=> -0.12499999999999997,
+ *   #=>  0.125,
+ *   #=> -0.125,
+ *   #=>  0.12500000000000006,
+ *   #=> -0.12499999999999994,
+ *   #=>  0.12499999999999994]
+
+ */
+static VALUE
+fft_ddst(int argc, VALUE *argv, VALUE unused_obj)
+{
+	return fft_callback(argc, argv, fft_ddst_inline);
+}
+
+
+#include "internal/solver/ooura_fft/dfct.h" // fft_dfct_inline()
+/*
+ * Document-method: dfct
+ * 
+ * call-seq:
+ *   OouraFFT.dfct(ary)                  -> [*Float]
+ *   OouraFFT.dfct(ary, inversion: true) -> [*Float]
+ * 
+ * Perform FFT with the first argument +ary+ as a numerical sequence.<br>
+ * If the keyword argument +inversion+ is +true+, perform an inverse FFT.
+ * 
+ * [Function type]            Cosine Transform of RDFT (Real Symmetric DFT)
+ * [Definition]               <tt>C[k] = sum_j=0^n a[j]*cos(pi*j*k/n), 0<=k<=n</tt>
+ * [+ary+ sequence type]      All +Float+
+ * [Array size requirement]   n >= 2, n = power of 2
+ * 
+ *   def sinewave(amp, f0, fs, n)
+ *     amp * Math.sin(2 * Math::PI * f0 * n / fs)
+ *   end
+ *   
+ *   OouraFFT.dfct(Array.new(8){|n| sinewave(0.25, 250.0, 8000, n)})
+ *   #=> [1.1441462984511075,
+ *   #=> -0.30353826116690874,
+ *   #=> -0.21410561232180816,
+ *   #=>  0.08422719461241164,
+ *   #=> -0.14986404592245728,
+ *   #=>  0.10711452157013322,
+ *   #=> -0.13944777827146557,
+ *   #=>  0.11219654498436385]
+ */
+static VALUE
+fft_dfct(int argc, VALUE *argv, VALUE unused_obj)
+{
+	return fft_callback(argc, argv, fft_dfct_inline);
+}
+
+
+#include "internal/solver/ooura_fft/dfst.h" // fft_dfst_inline()
+/*
+ * Document-method: dfst
+ * 
+ * call-seq:
+ *   OouraFFT.dfst(ary)                  -> [*Float]
+ *   OouraFFT.dfst(ary, inversion: true) -> [*Float]
+ * 
+ * Perform FFT with the first argument +ary+ as a numerical sequence.<br>
+ * If the keyword argument +inversion+ is +true+, perform an inverse FFT.
+ * 
+ * [Function type]            Sine Transform of RDFT (Real Anti-symmetric DFT)
+ * [Definition]               <tt>S[k] = sum_j=1^n-1 a[j]*sin(pi*j*k/n), 0<k<n</tt>
+ * [+ary+ sequence type]      All +Float+
+ * [Array size requirement]   n >= 2, n = power of 2
+ * 
+ *   def sinewave(amp, f0, fs, n)
+ *     amp * Math.sin(2 * Math::PI * f0 * n / fs)
+ *   end
+ *   
+ *   OouraFFT.dfst(Array.new(8){|n| sinewave(0.25, 250.0, 8000, n)})
+ *   #=> [0.0,
+ *   #=>  0.8406080372841989,
+ *   #=> -0.3229641637954819,
+ *   #=>  0.19308574608608534,
+ *   #=> -0.12744889477603982,
+ *   #=>  0.08469937042371564,
+ *   #=> -0.05236611372238342,
+ *   #=>  0.025114880435281595]
+ */
+static VALUE
+fft_dfst(int argc, VALUE *argv, VALUE unused_obj)
+{
+	return fft_callback(argc, argv, fft_dfst_inline);
+
+}
+
+static void 
+InitVM_FFTMain(void)
+{
+	rb_define_module_function(rb_mOouraFFT, "cdft", fft_cdft, -1);
+	rb_define_module_function(rb_mOouraFFT, "rdft", fft_rdft, -1);
+	rb_define_module_function(rb_mOouraFFT, "ddct", fft_ddct, -1);
+	rb_define_module_function(rb_mOouraFFT, "ddst", fft_ddst, -1);
+	rb_define_module_function(rb_mOouraFFT, "dfct", fft_dfct, -1);
+	rb_define_module_function(rb_mOouraFFT, "dfst", fft_dfst, -1);
+	/*  The using thread model name. Supports in Windows and POSIX. */
+	rb_define_const(rb_mOouraFFT, "USING_THREAD", rb_str_new_cstr((const char *)USING_THREAD));
+}

data/ext/ooura_fft/internal/setting/ooura_fft.h

@@ -0,0 +1,17 @@
+#ifndef INTERNAL_SETTING_OOURAFFT_H
+#define INTERNAL_SETTING_OOURAFFT_H
+
+// Ooura's FFT Thread Use Setting
+#if defined(HAVE_CREATETHREAD) && \
+    defined(HAVE_WAITFORSINGLEOBJECT) && \
+    defined(HAVE_CLOSEHANDLE)
+# define USE_CDFT_WINTHREADS
+# define USING_THREAD  "Windows"
+#elif defined(HAVE_PTHREAD_CREATE) && defined(HAVE_PTHREAD_JOIN)
+# define USE_CDFT_PTHREADS
+# define USING_THREAD  "POSIX"
+#else
+# define USING_THREAD  NULL
+#endif
+
+#endif /* INTERNAL_SETTING_OOURAFFT_H */

data/ext/ooura_fft/internal/solver/ooura_fft/cdft.h

@@ -0,0 +1,52 @@
+#ifndef INTERNAL_SOLVER_FFT_CDFT_H
+#define INTERNAL_SOLVER_FFT_CDFT_H
+
+static inline VALUE
+fft_cdft_inline(VALUE ary, int invertible)
+{
+	VALUE retval;
+	long sz = RARRAY_LEN(ary);
+	int *ip;
+	double *a, *w;
+	
+	if ((INT_MAX / 2) < sz)
+		rb_raise(rb_eRangeError, "biggest array size");
+	else if (sz < 1)
+		rb_raise(rb_eRangeError, "unavailable array size (n >= 1, was %ld)", sz);
+	else if (!ispow2l(sz))
+		rb_raise(rb_eRangeError, "size must be 2^m");
+	
+	a = ALLOC_N(double, sz*2);
+	ip = ALLOC_N(int, (int)(2+sqrt(sz)));
+	w = ALLOC_N(double, sz/2);
+	
+	for (volatile long i = 0; i < sz; i++)
+	{
+		VALUE elem = rb_ary_entry(ary, i);
+		if (TYPE(elem) != T_COMPLEX)
+			elem = rb_Complex1(elem);
+		const double real = NUM2DBL(rb_complex_real(elem));
+		const double imag = NUM2DBL(rb_complex_imag(elem));
+		a[2*i] = real;
+		a[2*i+1] = imag;
+	}
+	
+	ip[0] = 0;
+	
+	cdft(2*sz, invertible, a, ip, w);
+	
+	retval = rb_ary_new2(sz);
+	
+	for (volatile long i = 0; i < sz; i++)
+	{
+		rb_ary_store(retval, i, rb_dbl_complex_new(a[2*i], a[2*i+1]));
+	}
+	
+	xfree(a);
+	xfree(ip);
+	xfree(w);
+	
+	return retval;
+}
+
+#endif /* INTERNAL_SOLVER_FFT_CDFT */

data/ext/ooura_fft/internal/solver/ooura_fft/ddct.h

@@ -0,0 +1,47 @@
+#ifndef INTERNAL_SOLVER_FFT_DDCT_H
+#define INTERNAL_SOLVER_FFT_DDCT_H
+
+static inline VALUE
+fft_ddct_inline(VALUE ary, int invertible)
+{
+	VALUE retval;
+	long sz = RARRAY_LEN(ary);
+	int *ip;
+	double *a, *w;
+	
+	if (INT_MAX < sz)
+		rb_raise(rb_eRangeError, "biggest array size");
+	else if (sz < 2)
+		rb_raise(rb_eRangeError, "unavailable array size (n >= 2, was %ld)", sz);
+	else if (!ispow2l(sz))
+		rb_raise(rb_eRangeError, "size must be 2^m");
+	
+	a = ALLOC_N(double, sz);
+	ip = ALLOC_N(int, (int)(2+sqrt(sz/2)));
+	w = ALLOC_N(double, sz*5/4);
+	
+	for (volatile long i = 0; i < sz; i++)
+	{
+		VALUE elem = rb_ary_entry(ary, i);
+		a[i] = NUM2DBL(elem);
+	}
+	
+	ip[0] = 0;
+	
+	ddct(sz, invertible, a, ip, w);
+	
+	retval = rb_ary_new2(sz);
+	
+	for (volatile long i = 0; i < sz; i++)
+	{
+		rb_ary_store(retval, i, DBL2NUM(a[i]));
+	}
+	
+	xfree(a);
+	xfree(ip);
+	xfree(w);
+	
+	return retval;
+}
+
+#endif /* INTERNAL_SOLVER_FFT_DDCT */

data/ext/ooura_fft/internal/solver/ooura_fft/ddst.h

@@ -0,0 +1,47 @@
+#ifndef INTERNAL_SOLVER_FFT_DDST_H
+#define INTERNAL_SOLVER_FFT_DDST_H
+
+static inline VALUE
+fft_ddst_inline(VALUE ary, int invertible)
+{
+	VALUE retval;
+	long sz = RARRAY_LEN(ary);
+	int *ip;
+	double *a, *w;
+	
+	if (INT_MAX < sz)
+		rb_raise(rb_eRangeError, "biggest array size");
+	else if (sz < 2)
+		rb_raise(rb_eRangeError, "unavailable array size (n >= 2, was %ld)", sz);
+	else if (!ispow2l(sz))
+		rb_raise(rb_eRangeError, "size must be 2^m");
+	
+	a = ALLOC_N(double, sz);
+	ip = ALLOC_N(int, (int)(2+sqrt(sz/2)));
+	w = ALLOC_N(double, sz*5/4);
+	
+	for (volatile long i = 0; i < sz; i++)
+	{
+		VALUE elem = rb_ary_entry(ary, i);
+		a[i] = NUM2DBL(elem);
+	}
+	
+	ip[0] = 0;
+	
+	ddst(sz, invertible, a, ip, w);
+	
+	retval = rb_ary_new2(sz);
+	
+	for (volatile long i = 0; i < sz; i++)
+	{
+		rb_ary_store(retval, i, DBL2NUM(a[i]));
+	}
+	
+	xfree(a);
+	xfree(ip);
+	xfree(w);
+	
+	return retval;
+}
+
+#endif /* INTERNAL_SOLVER_FFT_DDST */

data/ext/ooura_fft/internal/solver/ooura_fft/dfct.h

@@ -0,0 +1,55 @@
+#ifndef INTERNAL_SOLVER_FFT_DFCT_H
+#define INTERNAL_SOLVER_FFT_DFCT_H
+
+static inline VALUE
+fft_dfct_inline(VALUE ary, int invertible)
+{
+	VALUE retval;
+	long n = RARRAY_LEN(ary), sz = n + 1;
+	int *ip;
+	double *a, *w, *t;
+	
+	if (INT_MAX < n)
+		rb_raise(rb_eRangeError, "biggest array size");
+	else if (n < 2)
+		rb_raise(rb_eRangeError, "unavailable array size (n >= 2, was %ld)", n);
+	else if (!ispow2l(n))
+		rb_raise(rb_eRangeError, "size must be 2^m");
+	
+	a = ALLOC_N(double, sz);
+	ip = ALLOC_N(int, (int)(2+sqrt(n/4)));
+	t = ALLOC_N(double, sz/2);
+	w = ALLOC_N(double, n*5/8);
+	
+	for (volatile long i = 0; i < n; i++)
+	{
+		VALUE elem = rb_ary_entry(ary, i);
+		if (invertible == -1)
+			a[i] = NUM2DBL(elem) * 0.5;
+		else
+			a[i] = NUM2DBL(elem);
+	}
+	
+	ip[0] = 0;
+	
+	dfct(n, a, t, ip, w);
+	
+	retval = rb_ary_new2(n);
+	
+	for (volatile long i = 0; i < n; i++)
+	{
+		if (invertible == -1)
+			rb_ary_store(retval, i, DBL2NUM(a[i] * 2.0 / n));
+		else
+			rb_ary_store(retval, i, DBL2NUM(a[i]));
+	}
+	
+	xfree(a);
+	xfree(ip);
+	xfree(t);
+	xfree(w);
+	
+	return retval;
+}
+
+#endif /* INTERNAL_SOLVER_FFT_DFCT */

data/ext/ooura_fft/internal/solver/ooura_fft/dfst.h

@@ -0,0 +1,52 @@
+#ifndef INTERNAL_SOLVER_FFT_DFST_H
+#define INTERNAL_SOLVER_FFT_DFST_H
+
+static inline VALUE
+fft_dfst_inline(VALUE ary, int invertible)
+{
+	VALUE retval;
+	long n = RARRAY_LEN(ary);
+	int *ip;
+	double *a, *w, *t;
+	
+	if (INT_MAX < n)
+		rb_raise(rb_eRangeError, "biggest array size");
+	else if (n < 2)
+		rb_raise(rb_eRangeError, "unavailable array size (n >= 2, was %ld)", n);
+	else if (!ispow2l(n))
+		rb_raise(rb_eRangeError, "size must be 2^m");
+	
+	a = ALLOC_N(double, n);
+	ip = ALLOC_N(int, (int)(2+sqrt(n/4)));
+	t = ALLOC_N(double, n/2);
+	w = ALLOC_N(double, n*5/8);
+	
+	for (volatile long i = 0; i < n; i++)
+	{
+		VALUE elem = rb_ary_entry(ary, i);
+		a[i] = NUM2DBL(elem);
+	}
+	
+	ip[0] = 0;
+	
+	dfst(n, a, t, ip, w);
+	
+	retval = rb_ary_new2(n);
+	
+	for (volatile long i = 0; i < n; i++)
+	{
+		if (invertible == -1)
+			rb_ary_store(retval, i, DBL2NUM(a[i] * 2.0 / n));
+		else
+			rb_ary_store(retval, i, DBL2NUM(a[i]));
+	}
+	
+	xfree(a);
+	xfree(ip);
+	xfree(t);
+	xfree(w);
+	
+	return retval;
+}
+
+#endif /* INTERNAL_SOLVER_FFT_DFST */

data/ext/ooura_fft/internal/solver/ooura_fft/rdft.h

@@ -0,0 +1,47 @@
+#ifndef INTERNAL_SOLVER_FFT_RDFT_H
+#define INTERNAL_SOLVER_FFT_RDFT_H
+
+static inline VALUE
+fft_rdft_inline(VALUE ary, int invertible)
+{
+	VALUE retval;
+	long sz = RARRAY_LEN(ary);
+	int *ip;
+	double *a, *w;
+	
+	if (INT_MAX < sz)
+		rb_raise(rb_eRangeError, "biggest array size");
+	else if (sz < 2)
+		rb_raise(rb_eRangeError, "unavailable array size (n >= 2, was %ld)", sz);
+	else if (!ispow2l(sz))
+		rb_raise(rb_eRangeError, "size must be 2^m");
+	
+	a = ALLOC_N(double, sz);
+	ip = ALLOC_N(int, (int)(2+sqrt(sz/2)));
+	w = ALLOC_N(double, sz/2);
+	
+	for (volatile long i = 0; i < sz; i++)
+	{
+		VALUE elem = rb_ary_entry(ary, i);
+		a[i] = NUM2DBL(elem);
+	}
+	
+	ip[0] = 0;
+	
+	rdft(sz, invertible, a, ip, w);
+	
+	retval = rb_ary_new2(sz);
+	
+	for (volatile long i = 0; i < sz; i++)
+	{
+		rb_ary_store(retval, i, DBL2NUM(a[i]));
+	}
+	
+	xfree(a);
+	xfree(ip);
+	xfree(w);
+	
+	return retval;
+}
+
+#endif /* INTERNAL_SOLVER_FFT_RDFT */

data/ext/ooura_fft/missing/ispow2l.c

@@ -0,0 +1,9 @@
+#include <stdbool.h>
+
+bool
+ispow2l(register long n)
+{
+	if (n <= 0) return false;
+	for (; (n & 1) == 0; n >>= 1);
+	return n == 1;
+}

data/ext/ooura_fft/missing/missing.h

@@ -0,0 +1,21 @@
+#ifndef FFT_MISSING_H
+#define FFT_MISSING_H
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+// C2X newer library
+#ifdef HAVE_STDBIT_H
+# include <stdbit.h>
+#endif
+
+#ifndef HAVE_ISPOW2L
+extern bool ispow2l(long);
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* FFT_MISSING_H */

data/ext/ooura_fft/ooura_fft/api.h

@@ -0,0 +1,13 @@
+#ifndef RB_OOURAFFT_API_H_INCLUDED
+#define RB_OOURAFFT_API_H_INCLUDED
+
+#include <ruby/internal/value.h> // VALUE
+
+VALUE rb_oourafft_cdft(VALUE, int);
+VALUE rb_oourafft_rdft(VALUE, int);
+VALUE rb_oourafft_ddct(VALUE, int);
+VALUE rb_oourafft_ddst(VALUE, int);
+VALUE rb_oourafft_dfct(VALUE, int);
+VALUE rb_oourafft_dfst(VALUE, int);
+
+#endif /* RB_OOURAFFT_API_H_INCLUDED */

data/ext/ooura_fft/ooura_fft/ext_extern.h

@@ -0,0 +1,18 @@
+#ifndef RUBY_EXT_EXTERN_H_INCLUDED
+#define RUBY_EXT_EXTERN_H_INCLUDED
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#ifdef     USE_GLOBAL_VARIABLE
+# define   RUBY_EXT_EXTERN
+#else
+# define   RUBY_EXT_EXTERN    extern
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif /* RUBY_EXT_EXTERN_H_INCLUDED */

data/ext/ooura_fft/ooura_fft/globals.h

@@ -0,0 +1,9 @@
+#ifndef RB_OOURAFFT_GLOBALS_H_INCLUDED
+#define RB_OOURAFFT_GLOBALS_H_INCLUDED
+
+#include <ruby/internal/value.h> // VALUE
+#include "ext_extern.h"
+
+RUBY_EXT_EXTERN VALUE rb_mOouraFFT;
+
+#endif /* RB_OOURAFFT_GLOBALS_H_INCLUDED */