Support long double buffer IO

Author: ydah

fftw3.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.authors = ["Yudai Takada"]
   spec.email = ["t.yudai92@gmail.com"]
 
-  spec.summary = "Complete Ruby FFI bindings for FFTW3"
-  spec.description = "Full-featured Ruby bindings for libfftw3 via FFI. " \
+  spec.summary = "Comprehensive Ruby FFI bindings for FFTW3"
+  spec.description = "Comprehensive Ruby bindings for libfftw3 via FFI. " \
                      "Supports double/float/long_double/quad precision, " \
                      "Basic/Advanced/Guru/Guru64 interfaces, Wisdom, and threading."
   spec.homepage = "https://github.com/ydah/fftw3"
@@ -31,5 +31,6 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "bigdecimal"
   spec.add_dependency "ffi", "~> 1.15"
 end

lib/fftw3/aligned_memory.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "bigdecimal"
+
 module FFTW3
   class AlignedMemory
     attr_reader :pointer, :size, :precision, :type
@@ -62,37 +64,74 @@ def free!
     private
 
     def write_real(data)
-      case @precision
-      when :double then @pointer.put_array_of_double(0, data)
-      when :float  then @pointer.put_array_of_float(0, data)
-      end
+      write_numeric_values(data)
     end
 
     def read_real
-      case @precision
-      when :double then @pointer.get_array_of_double(0, @count)
-      when :float  then @pointer.get_array_of_float(0, @count)
-      end
+      read_numeric_values(@count)
     end
 
     def write_complex(data)
       flat = data.flat_map { |c|
         c.is_a?(Complex) ? [c.real, c.imaginary] : c
       }
-      case @precision
-      when :double then @pointer.put_array_of_double(0, flat)
-      when :float  then @pointer.put_array_of_float(0, flat)
-      end
+      write_numeric_values(flat)
     end
 
     def read_complex
-      flat = case @precision
-             when :double then @pointer.get_array_of_double(0, @count * 2)
-             when :float  then @pointer.get_array_of_float(0, @count * 2)
-             end
+      flat = read_numeric_values(@count * 2)
       flat.each_slice(2).map { |re, im| Complex(re, im) }
     end
 
+    def write_numeric_values(data)
+      case @precision
+      when :double
+        @pointer.put_array_of_double(0, data)
+      when :float
+        @pointer.put_array_of_float(0, data)
+      when :long_double
+        write_generic_values(data, type: :long_double)
+      else
+        raise_unsupported_precision!(:write)
+      end
+    end
+
+    def read_numeric_values(count)
+      case @precision
+      when :double
+        @pointer.get_array_of_double(0, count)
+      when :float
+        @pointer.get_array_of_float(0, count)
+      when :long_double
+        read_generic_values(count, type: :long_double)
+      else
+        raise_unsupported_precision!(:read)
+      end
+    end
+
+    def write_generic_values(data, type:)
+      value_size = ::FFI.type_size(type)
+      data.each_with_index do |value, index|
+        @pointer.put(type, index * value_size, value)
+      end
+    rescue TypeError
+      raise_unsupported_precision!(:write)
+    end
+
+    def read_generic_values(count, type:)
+      value_size = ::FFI.type_size(type)
+      Array.new(count) do |index|
+        @pointer.get(type, index * value_size)
+      end
+    rescue LoadError, TypeError
+      raise_unsupported_precision!(:read)
+    end
+
+    def raise_unsupported_precision!(action)
+      raise FFTW3::Error::InvalidArgument,
+            "FFI does not support #{action}ing #{@precision} buffers on this platform"
+    end
+
     def self.release(ptr, free_func, freed_flag)
       proc {
         unless freed_flag[0] || ptr.null?

spec/fftw3/aligned_memory_spec.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "bigdecimal"
+
 RSpec.describe FFTW3::AlignedMemory do
   describe "real memory" do
     it "allocates and reads/writes double real data" do
@@ -25,6 +27,19 @@
       end
       mem.free!
     end
+
+    it "allocates and reads/writes long double real data", skip: !FFTW3.long_double_available? do
+      n = 8
+      mem = FFTW3::AlignedMemory.new(n, type: :real, precision: :long_double)
+      data = n.times.map { |i| BigDecimal((i.to_f / 3).to_s) }
+      mem.write(data)
+
+      result = mem.read
+      result.each_with_index do |value, index|
+        expect(value.to_f).to be_within(1e-15).of(data[index].to_f)
+      end
+      mem.free!
+    end
   end
 
   describe "complex memory" do
@@ -52,6 +67,24 @@
       end
       mem.free!
     end
+
+    it "allocates and reads/writes long double complex data", skip: !FFTW3.long_double_available? do
+      n = 4
+      mem = FFTW3::AlignedMemory.new(n, type: :complex, precision: :long_double)
+      data = [
+        Complex(BigDecimal("1.0"), BigDecimal("2.0")),
+        Complex(BigDecimal("3.0"), BigDecimal("4.0")),
+        Complex(BigDecimal("5.0"), BigDecimal("6.0")),
+        Complex(BigDecimal("7.0"), BigDecimal("8.0"))
+      ]
+      mem.write(data)
+
+      result = mem.read
+      expect(result.map { |value| [value.real.to_s("F"), value.imaginary.to_s("F")] }).to eq(
+        data.map { |value| [value.real.to_s("F"), value.imaginary.to_s("F")] }
+      )
+      mem.free!
+    end
   end
 
   describe "#free!" do

spec/fftw3/precision/long_double_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "bigdecimal"
+
+RSpec.describe "Long double precision", skip: !FFTW3.long_double_available? do
+  it "performs DFT roundtrip with long double precision" do
+    n = 16
+    input = FFTW3::AlignedMemory.new(n, type: :complex, precision: :long_double)
+    freq_domain = FFTW3::AlignedMemory.new(n, type: :complex, precision: :long_double)
+    output = FFTW3::AlignedMemory.new(n, type: :complex, precision: :long_double)
+
+    original = n.times.map do |i|
+      real = BigDecimal(Math.sin(2 * Math::PI * i / n).to_s)
+      Complex(real, BigDecimal("0"))
+    end
+    input.write(original)
+
+    forward = FFTW3::Plan.dft_1d(n, input, freq_domain, direction: :forward, precision: :long_double)
+    forward.execute
+    forward.destroy!
+
+    backward = FFTW3::Plan.dft_1d(n, freq_domain, output, direction: :backward, precision: :long_double)
+    backward.execute
+    backward.destroy!
+
+    result = output.read
+    result.each_with_index do |value, index|
+      expect((value.real / n).to_f).to be_within(1e-12).of(original[index].real.to_f)
+      expect((value.imaginary / n).to_f).to be_within(1e-12).of(original[index].imaginary.to_f)
+    end
+  end
+end