fftw3-ruby 0.1.0

data/lib/fftw3/plan.rb

@@ -0,0 +1,513 @@
+# frozen_string_literal: true
+
+module FFTW3
+  class Plan
+    attr_reader :ptr, :precision
+
+    def initialize(ptr, precision:, input_buffer: nil, output_buffer: nil, **_metadata)
+      raise FFTW3::Error::PlanError, "FFTW returned NULL plan" if ptr.null?
+
+      @ptr = ptr
+      @precision = precision
+      @input_buffer = input_buffer
+      @output_buffer = output_buffer
+      @destroyed_flag = [false]
+
+      destructor = ffi_module.method(:"#{prefix}destroy_plan")
+      ObjectSpace.define_finalizer(self, self.class.release(ptr, destructor, @destroyed_flag))
+    end
+
+    def execute
+      ffi_module.send(:"#{prefix}execute", @ptr)
+    end
+
+    def execute_dft(input, output)
+      ffi_module.send(:"#{prefix}execute_dft", @ptr, input.pointer, output.pointer)
+    end
+
+    def execute_dft_r2c(input, output)
+      ffi_module.send(:"#{prefix}execute_dft_r2c", @ptr, input.pointer, output.pointer)
+    end
+
+    def execute_dft_c2r(input, output)
+      ffi_module.send(:"#{prefix}execute_dft_c2r", @ptr, input.pointer, output.pointer)
+    end
+
+    def execute_r2r(input, output)
+      ffi_module.send(:"#{prefix}execute_r2r", @ptr, input.pointer, output.pointer)
+    end
+
+    def execute_split_dft(ri, ii, ro, io)
+      ffi_module.send(:"#{prefix}execute_split_dft", @ptr, ri.pointer, ii.pointer, ro.pointer, io.pointer)
+    end
+
+    def execute_split_dft_r2c(input, ro, io)
+      ffi_module.send(:"#{prefix}execute_split_dft_r2c", @ptr, input.pointer, ro.pointer, io.pointer)
+    end
+
+    def execute_split_dft_c2r(ri, ii, output)
+      ffi_module.send(:"#{prefix}execute_split_dft_c2r", @ptr, ri.pointer, ii.pointer, output.pointer)
+    end
+
+    def to_s
+      description_ptr = ffi_module.send(:"#{prefix}sprint_plan", @ptr)
+      return "" if description_ptr.null?
+
+      description = description_ptr.read_string
+      ffi_module.send(:"#{prefix}free", description_ptr)
+      description
+    end
+
+    alias description to_s
+
+    def print(io = $stdout)
+      io.write(to_s)
+      io
+    end
+
+    def flops
+      add = ::FFI::MemoryPointer.new(:double)
+      mul = ::FFI::MemoryPointer.new(:double)
+      fma = ::FFI::MemoryPointer.new(:double)
+      ffi_module.send(:"#{prefix}flops", @ptr, add, mul, fma)
+      { add: add.read_double, mul: mul.read_double, fma: fma.read_double }
+    end
+
+    def cost
+      ffi_module.send(:"#{prefix}cost", @ptr)
+    end
+
+    def estimate_cost
+      ffi_module.send(:"#{prefix}estimate_cost", @ptr)
+    end
+
+    def destroy!
+      return if @destroyed_flag[0]
+
+      ffi_module.send(:"#{prefix}destroy_plan", @ptr)
+      @destroyed_flag[0] = true
+    end
+
+    class << self
+      # ---- Basic Complex DFT ----
+      def dft_1d(n, input, output, direction:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        ptr = ffi.send(:"#{pfx}plan_dft_1d", n, input.pointer, output.pointer,
+                       resolve_direction(direction), resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def dft_2d(n0, n1, input, output, direction:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        ptr = ffi.send(:"#{pfx}plan_dft_2d", n0, n1, input.pointer, output.pointer,
+                       resolve_direction(direction), resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def dft_3d(n0, n1, n2, input, output, direction:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        ptr = ffi.send(:"#{pfx}plan_dft_3d", n0, n1, n2, input.pointer, output.pointer,
+                       resolve_direction(direction), resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def dft(dims, input, output, direction:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        n_ptr = ::FFI::MemoryPointer.new(:int, dims.length)
+        n_ptr.put_array_of_int(0, dims)
+        ptr = ffi.send(:"#{pfx}plan_dft", dims.length, n_ptr, input.pointer, output.pointer,
+                       resolve_direction(direction), resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      # ---- Basic R2C ----
+      def dft_r2c_1d(n, input, output, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        ptr = ffi.send(:"#{pfx}plan_dft_r2c_1d", n, input.pointer, output.pointer, resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def dft_r2c_2d(n0, n1, input, output, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        ptr = ffi.send(:"#{pfx}plan_dft_r2c_2d", n0, n1, input.pointer, output.pointer, resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def dft_r2c_3d(n0, n1, n2, input, output, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        ptr = ffi.send(:"#{pfx}plan_dft_r2c_3d", n0, n1, n2, input.pointer, output.pointer, resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def dft_r2c(dims, input, output, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        n_ptr = ::FFI::MemoryPointer.new(:int, dims.length)
+        n_ptr.put_array_of_int(0, dims)
+        ptr = ffi.send(:"#{pfx}plan_dft_r2c", dims.length, n_ptr, input.pointer, output.pointer,
+                       resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      # ---- Basic C2R ----
+      def dft_c2r_1d(n, input, output, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        ptr = ffi.send(:"#{pfx}plan_dft_c2r_1d", n, input.pointer, output.pointer, resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def dft_c2r_2d(n0, n1, input, output, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        ptr = ffi.send(:"#{pfx}plan_dft_c2r_2d", n0, n1, input.pointer, output.pointer, resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def dft_c2r_3d(n0, n1, n2, input, output, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        ptr = ffi.send(:"#{pfx}plan_dft_c2r_3d", n0, n1, n2, input.pointer, output.pointer, resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def dft_c2r(dims, input, output, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        n_ptr = ::FFI::MemoryPointer.new(:int, dims.length)
+        n_ptr.put_array_of_int(0, dims)
+        ptr = ffi.send(:"#{pfx}plan_dft_c2r", dims.length, n_ptr, input.pointer, output.pointer,
+                       resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      # ---- Basic R2R ----
+      def r2r_1d(n, input, output, kind:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        ptr = ffi.send(:"#{pfx}plan_r2r_1d", n, input.pointer, output.pointer, kind, resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def r2r_2d(n0, n1, input, output, kind0:, kind1:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        ptr = ffi.send(:"#{pfx}plan_r2r_2d", n0, n1, input.pointer, output.pointer, kind0, kind1,
+                       resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def r2r_3d(n0, n1, n2, input, output, kind0:, kind1:, kind2:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        ptr = ffi.send(:"#{pfx}plan_r2r_3d", n0, n1, n2, input.pointer, output.pointer,
+                       kind0, kind1, kind2, resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def r2r(dims, input, output, kinds:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        n_ptr = ::FFI::MemoryPointer.new(:int, dims.length)
+        n_ptr.put_array_of_int(0, dims)
+        kind_ptr = ::FFI::MemoryPointer.new(:int, kinds.length)
+        kind_ptr.put_array_of_int(0, kinds)
+        ptr = ffi.send(:"#{pfx}plan_r2r", dims.length, n_ptr, input.pointer, output.pointer,
+                       kind_ptr, resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      # ---- Advanced (many) ----
+      def many_dft(rank:, n:, howmany:, input:, inembed:, istride:, idist:,
+                   output:, onembed:, ostride:, odist:, direction:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        n_ptr = ::FFI::MemoryPointer.new(:int, n.length)
+        n_ptr.put_array_of_int(0, n)
+        inembed_ptr = array_to_int_ptr(inembed)
+        onembed_ptr = array_to_int_ptr(onembed)
+        ptr = ffi.send(:"#{pfx}plan_many_dft", rank, n_ptr, howmany,
+                       input.pointer, inembed_ptr, istride, idist,
+                       output.pointer, onembed_ptr, ostride, odist,
+                       resolve_direction(direction), resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def many_dft_r2c(rank:, n:, howmany:, input:, inembed:, istride:, idist:,
+                       output:, onembed:, ostride:, odist:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        n_ptr = ::FFI::MemoryPointer.new(:int, n.length)
+        n_ptr.put_array_of_int(0, n)
+        inembed_ptr = array_to_int_ptr(inembed)
+        onembed_ptr = array_to_int_ptr(onembed)
+        ptr = ffi.send(:"#{pfx}plan_many_dft_r2c", rank, n_ptr, howmany,
+                       input.pointer, inembed_ptr, istride, idist,
+                       output.pointer, onembed_ptr, ostride, odist,
+                       resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def many_dft_c2r(rank:, n:, howmany:, input:, inembed:, istride:, idist:,
+                       output:, onembed:, ostride:, odist:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        n_ptr = ::FFI::MemoryPointer.new(:int, n.length)
+        n_ptr.put_array_of_int(0, n)
+        inembed_ptr = array_to_int_ptr(inembed)
+        onembed_ptr = array_to_int_ptr(onembed)
+        ptr = ffi.send(:"#{pfx}plan_many_dft_c2r", rank, n_ptr, howmany,
+                       input.pointer, inembed_ptr, istride, idist,
+                       output.pointer, onembed_ptr, ostride, odist,
+                       resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def many_r2r(rank:, n:, howmany:, input:, inembed:, istride:, idist:,
+                   output:, onembed:, ostride:, odist:, kinds:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        n_ptr = ::FFI::MemoryPointer.new(:int, n.length)
+        n_ptr.put_array_of_int(0, n)
+        inembed_ptr = array_to_int_ptr(inembed)
+        onembed_ptr = array_to_int_ptr(onembed)
+        kind_ptr = ::FFI::MemoryPointer.new(:int, kinds.length)
+        kind_ptr.put_array_of_int(0, kinds)
+        ptr = ffi.send(:"#{pfx}plan_many_r2r", rank, n_ptr, howmany,
+                       input.pointer, inembed_ptr, istride, idist,
+                       output.pointer, onembed_ptr, ostride, odist,
+                       kind_ptr, resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      # ---- Guru ----
+      def guru_dft(dims, howmany_dims, input, output, sign:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        dims_ptr = IODim.to_ffi(dims)
+        howmany_ptr = IODim.to_ffi(howmany_dims)
+        ptr = ffi.send(:"#{pfx}plan_guru_dft", dims.length, dims_ptr,
+                       howmany_dims.length, howmany_ptr,
+                       input.pointer, output.pointer,
+                       resolve_direction(sign), resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def guru_split_dft(dims, howmany_dims, ri, ii, ro, io, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        dims_ptr = IODim.to_ffi(dims)
+        howmany_ptr = IODim.to_ffi(howmany_dims)
+        ptr = ffi.send(:"#{pfx}plan_guru_split_dft", dims.length, dims_ptr,
+                       howmany_dims.length, howmany_ptr,
+                       ri.pointer, ii.pointer, ro.pointer, io.pointer,
+                       resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: [ri, ii], output_buffer: [ro, io])
+      end
+
+      def guru_dft_r2c(dims, howmany_dims, input, output, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        dims_ptr = IODim.to_ffi(dims)
+        howmany_ptr = IODim.to_ffi(howmany_dims)
+        ptr = ffi.send(:"#{pfx}plan_guru_dft_r2c", dims.length, dims_ptr,
+                       howmany_dims.length, howmany_ptr,
+                       input.pointer, output.pointer,
+                       resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def guru_split_dft_r2c(dims, howmany_dims, input, ro, io, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        dims_ptr = IODim.to_ffi(dims)
+        howmany_ptr = IODim.to_ffi(howmany_dims)
+        ptr = ffi.send(:"#{pfx}plan_guru_split_dft_r2c", dims.length, dims_ptr,
+                       howmany_dims.length, howmany_ptr,
+                       input.pointer, ro.pointer, io.pointer,
+                       resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: [ro, io])
+      end
+
+      def guru_dft_c2r(dims, howmany_dims, input, output, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        dims_ptr = IODim.to_ffi(dims)
+        howmany_ptr = IODim.to_ffi(howmany_dims)
+        ptr = ffi.send(:"#{pfx}plan_guru_dft_c2r", dims.length, dims_ptr,
+                       howmany_dims.length, howmany_ptr,
+                       input.pointer, output.pointer,
+                       resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def guru_split_dft_c2r(dims, howmany_dims, ri, ii, output, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        dims_ptr = IODim.to_ffi(dims)
+        howmany_ptr = IODim.to_ffi(howmany_dims)
+        ptr = ffi.send(:"#{pfx}plan_guru_split_dft_c2r", dims.length, dims_ptr,
+                       howmany_dims.length, howmany_ptr,
+                       ri.pointer, ii.pointer, output.pointer,
+                       resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: [ri, ii], output_buffer: output)
+      end
+
+      def guru_r2r(dims, howmany_dims, input, output, kinds:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        dims_ptr = IODim.to_ffi(dims)
+        howmany_ptr = IODim.to_ffi(howmany_dims)
+        kind_ptr = ::FFI::MemoryPointer.new(:int, kinds.length)
+        kind_ptr.put_array_of_int(0, kinds)
+        ptr = ffi.send(:"#{pfx}plan_guru_r2r", dims.length, dims_ptr,
+                       howmany_dims.length, howmany_ptr,
+                       input.pointer, output.pointer,
+                       kind_ptr, resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      # ---- Guru64 ----
+      def guru64_dft(dims, howmany_dims, input, output, sign:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        dims_ptr = IODim64.to_ffi(dims)
+        howmany_ptr = IODim64.to_ffi(howmany_dims)
+        ptr = ffi.send(:"#{pfx}plan_guru64_dft", dims.length, dims_ptr,
+                       howmany_dims.length, howmany_ptr,
+                       input.pointer, output.pointer,
+                       resolve_direction(sign), resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def guru64_split_dft(dims, howmany_dims, ri, ii, ro, io, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        dims_ptr = IODim64.to_ffi(dims)
+        howmany_ptr = IODim64.to_ffi(howmany_dims)
+        ptr = ffi.send(:"#{pfx}plan_guru64_split_dft", dims.length, dims_ptr,
+                       howmany_dims.length, howmany_ptr,
+                       ri.pointer, ii.pointer, ro.pointer, io.pointer,
+                       resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: [ri, ii], output_buffer: [ro, io])
+      end
+
+      def guru64_dft_r2c(dims, howmany_dims, input, output, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        dims_ptr = IODim64.to_ffi(dims)
+        howmany_ptr = IODim64.to_ffi(howmany_dims)
+        ptr = ffi.send(:"#{pfx}plan_guru64_dft_r2c", dims.length, dims_ptr,
+                       howmany_dims.length, howmany_ptr,
+                       input.pointer, output.pointer,
+                       resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def guru64_split_dft_r2c(dims, howmany_dims, input, ro, io, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        dims_ptr = IODim64.to_ffi(dims)
+        howmany_ptr = IODim64.to_ffi(howmany_dims)
+        ptr = ffi.send(:"#{pfx}plan_guru64_split_dft_r2c", dims.length, dims_ptr,
+                       howmany_dims.length, howmany_ptr,
+                       input.pointer, ro.pointer, io.pointer,
+                       resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: [ro, io])
+      end
+
+      def guru64_dft_c2r(dims, howmany_dims, input, output, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        dims_ptr = IODim64.to_ffi(dims)
+        howmany_ptr = IODim64.to_ffi(howmany_dims)
+        ptr = ffi.send(:"#{pfx}plan_guru64_dft_c2r", dims.length, dims_ptr,
+                       howmany_dims.length, howmany_ptr,
+                       input.pointer, output.pointer,
+                       resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      def guru64_split_dft_c2r(dims, howmany_dims, ri, ii, output, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        dims_ptr = IODim64.to_ffi(dims)
+        howmany_ptr = IODim64.to_ffi(howmany_dims)
+        ptr = ffi.send(:"#{pfx}plan_guru64_split_dft_c2r", dims.length, dims_ptr,
+                       howmany_dims.length, howmany_ptr,
+                       ri.pointer, ii.pointer, output.pointer,
+                       resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: [ri, ii], output_buffer: output)
+      end
+
+      def guru64_r2r(dims, howmany_dims, input, output, kinds:, flags: [:estimate], precision: :double)
+        ffi = FFTW3::FFI.module_for(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        dims_ptr = IODim64.to_ffi(dims)
+        howmany_ptr = IODim64.to_ffi(howmany_dims)
+        kind_ptr = ::FFI::MemoryPointer.new(:int, kinds.length)
+        kind_ptr.put_array_of_int(0, kinds)
+        ptr = ffi.send(:"#{pfx}plan_guru64_r2r", dims.length, dims_ptr,
+                       howmany_dims.length, howmany_ptr,
+                       input.pointer, output.pointer,
+                       kind_ptr, resolve_flags(flags))
+        new(ptr, precision: precision, input_buffer: input, output_buffer: output)
+      end
+
+      private
+
+      def resolve_flags(flags)
+        flags.reduce(0) { |mask, f|
+          case f
+          when Symbol then mask | FFTW3.const_get(f.to_s.upcase)
+          when Integer then mask | f
+          else raise FFTW3::Error::InvalidArgument, "Invalid flag: #{f}"
+          end
+        }
+      end
+
+      def resolve_direction(direction)
+        case direction
+        when :forward  then FFTW3::FORWARD
+        when :backward then FFTW3::BACKWARD
+        when Integer   then direction
+        else raise FFTW3::Error::InvalidArgument, "Invalid direction: #{direction}"
+        end
+      end
+
+      def array_to_int_ptr(arr)
+        return nil if arr.nil?
+
+        ptr = ::FFI::MemoryPointer.new(:int, arr.length)
+        ptr.put_array_of_int(0, arr)
+        ptr
+      end
+    end
+
+    private
+
+    def ffi_module
+      FFTW3::FFI.module_for(@precision)
+    end
+
+    def prefix
+      FFTW3::FFI.prefix_for(@precision)
+    end
+
+    def self.release(ptr, destructor, destroyed_flag)
+      proc {
+        unless destroyed_flag[0] || ptr.null?
+          destructor.call(ptr)
+          destroyed_flag[0] = true
+        end
+      }
+    end
+  end
+end

data/lib/fftw3/threads.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module FFTW3
+  module Threads
+    @initialized = {}
+    @thread_modules = {}
+    @callback_state = {}
+
+    def self.init(precision: :double)
+      return if @initialized[precision]
+
+      pfx = FFTW3::FFI.prefix_for(precision)
+      result = thread_module_for(precision).send(:"#{pfx}init_threads")
+      raise FFTW3::Error::PlanError, "Failed to init FFTW threads" if result == 0
+
+      @initialized[precision] = true
+    end
+
+    def self.plan_with_nthreads(nthreads, precision: :double)
+      init(precision: precision) unless @initialized[precision]
+      pfx = FFTW3::FFI.prefix_for(precision)
+      thread_module_for(precision).send(:"#{pfx}plan_with_nthreads", nthreads)
+    end
+
+    def self.cleanup(precision: :double)
+      return unless @initialized[precision]
+
+      pfx = FFTW3::FFI.prefix_for(precision)
+      thread_module_for(precision).send(:"#{pfx}cleanup_threads")
+      @initialized[precision] = false
+    end
+
+    def self.planner_nthreads(precision: :double)
+      init(precision: precision) unless @initialized[precision]
+      return nil unless thread_module_for(precision).planner_nthreads_supported?
+
+      pfx = FFTW3::FFI.prefix_for(precision)
+      thread_module_for(precision).send(:"#{pfx}planner_nthreads")
+    end
+
+    def self.make_planner_thread_safe(precision: :double)
+      init(precision: precision) unless @initialized[precision]
+      return nil unless thread_module_for(precision).make_planner_thread_safe_supported?
+
+      pfx = FFTW3::FFI.prefix_for(precision)
+      thread_module_for(precision).send(:"#{pfx}make_planner_thread_safe")
+    end
+
+    def self.set_callback_supported?(precision: :double)
+      thread_module_for(precision).threads_set_callback_supported?
+    end
+
+    def self.set_callback(callback = nil, data: nil, precision: :double, &block)
+      callback ||= block
+      validate_callback!(callback)
+
+      thread_mod = thread_module_for(precision)
+      return nil unless thread_mod.threads_set_callback_supported?
+
+      pfx = FFTW3::FFI.prefix_for(precision)
+      function = build_parallel_loop_function(callback)
+      data_ptr = normalize_data_pointer(data)
+
+      thread_mod.send(:"#{pfx}threads_set_callback", function, data_ptr)
+      @callback_state[precision] = { callback: callback, function: function, data: data }
+      true
+    end
+
+    class << self
+      private
+
+      def thread_module_for(precision)
+        @thread_modules[precision] ||= build_thread_module(precision)
+      end
+
+      def build_thread_module(precision)
+        pfx = FFTW3::FFI.prefix_for(precision)
+        threads_lib = FFTW3::FFI::LibraryLoader.find_threads(precision)
+
+        Module.new do
+          extend ::FFI::Library
+          ffi_lib threads_lib
+
+          attach_function :"#{pfx}init_threads", [], :int
+          attach_function :"#{pfx}plan_with_nthreads", [:int], :void
+          attach_function :"#{pfx}cleanup_threads", [], :void
+
+          begin
+            attach_function :"#{pfx}planner_nthreads", [], :int
+            @planner_nthreads_supported = true
+          rescue ::FFI::NotFoundError
+            @planner_nthreads_supported = false
+          end
+
+          begin
+            attach_function :"#{pfx}make_planner_thread_safe", [], :void
+            @make_planner_thread_safe_supported = true
+          rescue ::FFI::NotFoundError
+            @make_planner_thread_safe_supported = false
+          end
+
+          begin
+            attach_function :"#{pfx}threads_set_callback", [:pointer, :pointer], :void
+            @threads_set_callback_supported = true
+          rescue ::FFI::NotFoundError
+            @threads_set_callback_supported = false
+          end
+
+          def self.planner_nthreads_supported?
+            @planner_nthreads_supported
+          end
+
+          def self.make_planner_thread_safe_supported?
+            @make_planner_thread_safe_supported
+          end
+
+          def self.threads_set_callback_supported?
+            @threads_set_callback_supported
+          end
+        end
+      end
+
+      def validate_callback!(callback)
+        return if callback.nil? || callback.respond_to?(:call)
+
+        raise FFTW3::Error::InvalidArgument, "callback must respond to #call"
+      end
+
+      def build_parallel_loop_function(callback)
+        return nil if callback.nil?
+
+        ::FFI::Function.new(:void, %i[pointer pointer size_t int pointer]) do |work_ptr, jobdata, elsize, njobs, data_ptr|
+          work = ::FFI::Function.new(:pointer, [:pointer], work_ptr)
+          callback.call(work, jobdata, elsize, njobs, data_ptr)
+          nil
+        end
+      end
+
+      def normalize_data_pointer(data)
+        case data
+        when nil
+          nil
+        when ::FFI::Pointer
+          data
+        else
+          return data.to_ptr if data.respond_to?(:to_ptr)
+
+          raise FFTW3::Error::InvalidArgument,
+                "data must be an FFI::Pointer or respond to #to_ptr"
+        end
+      end
+    end
+  end
+end

data/lib/fftw3/utils.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module FFTW3
+  module Utils
+    def self.cleanup(precision: :double)
+      ffi = FFTW3::FFI.module_for(precision)
+      pfx = FFTW3::FFI.prefix_for(precision)
+      ffi.send(:"#{pfx}cleanup")
+    end
+
+    def self.set_timelimit(seconds, precision: :double)
+      ffi = FFTW3::FFI.module_for(precision)
+      pfx = FFTW3::FFI.prefix_for(precision)
+      ffi.send(:"#{pfx}set_timelimit", seconds.to_f)
+    end
+
+    def self.alignment_of(pointer, precision: :double)
+      ffi = FFTW3::FFI.module_for(precision)
+      pfx = FFTW3::FFI.prefix_for(precision)
+      ffi.send(:"#{pfx}alignment_of", pointer)
+    end
+  end
+end

data/lib/fftw3/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FFTW3
+  VERSION = "0.1.0"
+end