region(p) -> fftdims(p)

Author: stevengj

README.md

@@ -23,7 +23,7 @@ To define a new FFT implementation in your own module, you should
   inverse plan.
 
 * Define a new method `AbstractFFTs.plan_fft(x, region; kws...)` that returns a `MyPlan` for at least some types of
-  `x` and some set of dimensions `region`.   The `region` (or a copy thereof) should be accessible via `region(p::MyPlan)` (which defaults to `p.region`).
+  `x` and some set of dimensions `region`.   The `region` (or a copy thereof) should be accessible via `fftdims(p::MyPlan)` (which defaults to `p.region`).
 
 * Define a method of `LinearAlgebra.mul!(y, p::MyPlan, x)` (or `A_mul_B!(y, p::MyPlan, x)` on Julia prior to
   0.7.0-DEV.3204) that computes the transform `p` of `x` and stores the result in `y`.

docs/src/api.md

@@ -19,7 +19,7 @@ AbstractFFTs.brfft
 AbstractFFTs.plan_rfft
 AbstractFFTs.plan_brfft
 AbstractFFTs.plan_irfft
-AbstractFFTs.region
+AbstractFFTs.fftdims
 AbstractFFTs.fftshift
 AbstractFFTs.ifftshift
 AbstractFFTs.fftfreq

src/AbstractFFTs.jl

@@ -5,7 +5,7 @@ import ChainRulesCore
 export fft, ifft, bfft, fft!, ifft!, bfft!,
        plan_fft, plan_ifft, plan_bfft, plan_fft!, plan_ifft!, plan_bfft!,
        rfft, irfft, brfft, plan_rfft, plan_irfft, plan_brfft,
-       fftshift, ifftshift, fftshift!, ifftshift!, Frequencies, fftfreq, rfftfreq
+       fftdims, fftshift, ifftshift, fftshift!, ifftshift!, Frequencies, fftfreq, rfftfreq
 
 include("definitions.jl")
 include("chainrules.jl")

src/definitions.jl

@@ -16,16 +16,16 @@ ndims(p::Plan) = length(size(p))
 length(p::Plan) = prod(size(p))::Int
 
 """
-    region(p::Plan)
+    fftdims(p::Plan)
 
 Return an iterable of the dimensions that are transformed by the FFT plan `p`.
 
 # Implementation
 
-The default definition of `region` returns `p.region`.
-Hence this method should be implemented only for types of `Plan`s that do not store the transformed region in a field of name `region`.
+For legacy reasons, the default definition of `fftdims` returns `p.region`.
+Hence this method should be implemented only for `Plan` subtypes that do not store the transformed dimensions in a field named `region`.
 """
-region(p::Plan) = p.region
+fftdims(p::Plan) = p.region
 
 fftfloat(x) = _fftfloat(float(x))
 _fftfloat(::Type{T}) where {T<:BlasReal} = T
@@ -255,7 +255,7 @@ ScaledPlan(p::ScaledPlan, α::Number) = ScaledPlan(p.p, p.scale * α)
 
 size(p::ScaledPlan) = size(p.p)
 
-region(p::ScaledPlan) = region(p.p)
+fftdims(p::ScaledPlan) = fftdims(p.p)
 
 show(io::IO, p::ScaledPlan) = print(io, p.scale, " * ", p.p)
 summary(p::ScaledPlan) = string(p.scale, " * ", summary(p.p))

test/runtests.jl

@@ -60,21 +60,21 @@ end
         @test eltype(P) === ComplexF64
         @test P * x ≈ fftw_fft
         @test P \ (P * x) ≈ x
-        @test AbstractFFTs.region(P) == dims
+        @test fftdims(P) == dims
 
         fftw_bfft = complex.(size(x, dims) .* x)
         @test AbstractFFTs.bfft(y, dims) ≈ fftw_bfft
         P = plan_bfft(x, dims)
         @test P * y ≈ fftw_bfft
         @test P \ (P * y) ≈ y
-        @test AbstractFFTs.region(P) == dims
+        @test fftdims(P) == dims
 
         fftw_ifft = complex.(x)
         @test AbstractFFTs.ifft(y, dims) ≈ fftw_ifft
         P = plan_ifft(x, dims)
         @test P * y ≈ fftw_ifft
         @test P \ (P * y) ≈ y
-        @test AbstractFFTs.region(P) == dims
+        @test fftdims(P) == dims
 
         # real FFT
         fftw_rfft = fftw_fft[
@@ -87,21 +87,21 @@ end
         @test eltype(P) === Int
         @test P * x ≈ fftw_rfft
         @test P \ (P * x) ≈ x
-        @test AbstractFFTs.region(P) == dims
+        @test fftdims(P) == dims
 
         fftw_brfft = complex.(size(x, dims) .* x)
         @test AbstractFFTs.brfft(ry, size(x, dims), dims) ≈ fftw_brfft
         P = plan_brfft(ry, size(x, dims), dims)
         @test P * ry ≈ fftw_brfft
         @test P \ (P * ry) ≈ ry
-        @test AbstractFFTs.region(P) == dims
-        
+        @test fftdims(P) == dims
+
         fftw_irfft = complex.(x)
         @test AbstractFFTs.irfft(ry, size(x, dims), dims) ≈ fftw_irfft
         P = plan_irfft(ry, size(x, dims), dims)
         @test P * ry ≈ fftw_irfft
         @test P \ (P * ry) ≈ ry
-        @test AbstractFFTs.region(P) == dims
+        @test fftdims(P) == dims
     end
 end
 
@@ -193,7 +193,7 @@ end
     # normalization should be inferable even if region is only inferred as ::Any,
     # need to wrap in another function to test this (note that p.region::Any for
     # p::TestPlan)
-    f9(p::Plan{T}, sz) where {T} = AbstractFFTs.normalization(real(T), sz, AbstractFFTs.region(p))
+    f9(p::Plan{T}, sz) where {T} = AbstractFFTs.normalization(real(T), sz, fftdims(p))
     @test @inferred(f9(plan_fft(zeros(10), 1), 10)) == 1/10
 end