Merge pull request #10 from martinholters/fixes_0.7

Fixes for Julia 0.7 (and drop support for a range of DEV versions)

Author: ararslan

README.md

@@ -25,9 +25,10 @@ To define a new FFT implementation in your own module, you should
 * 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`.
 
-* Define a method of `A_mul_B!(y, p::MyPlan, x)` that computes the transform `p` of `x` and stores the result in `y`.
+* 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`.
 
-* Define a method of `*(p::MyPlan, x)`, which can simply call your `A_mul_B!` method.
+* Define a method of `*(p::MyPlan, x)`, which can simply call your `mul!` (or `A_mul_B!`) method.
   This is not defined generically in this package due to subtleties that arise for in-place and real-input FFTs.
 
 * If the inverse transform is implemented, you should also define `plan_inv(p::MyPlan)`, which should construct the

REQUIRE

@@ -1 +1 @@
-julia 0.6
+julia 0.6 0.7.0-DEV.602 0.7.0-DEV.3449

docs/src/implementations.md

@@ -9,12 +9,13 @@ The following packages extend the functionality provided by AbstractFFTs:
 
 ## Defining a new implementation
 
-Implementations should implement `Base.A_mul_B!(Y, plan, X)` so as to support
+Implementations should implement `LinearAlgebra.mul!(Y, plan, X)` (or
+`A_mul_B!(y, p::MyPlan, x)` on Julia prior to 0.7.0-DEV.3204) so as to support
 pre-allocated output arrays.
-We don't define `*` in terms of `A_mul_B!` generically here, however, because
+We don't define `*` in terms of `mul!` generically here, however, because
 of subtleties for in-place and real FFT plans.
 
-To support `inv`, `\`, and `A_ldiv_B!(y, plan, x)`, we require `Plan` subtypes
+To support `inv`, `\`, and `ldiv!(y, plan, x)`, we require `Plan` subtypes
 to have a `pinv::Plan` field, which caches the inverse plan, and which should be
 initially undefined.
 They should also implement `plan_inv(p)` to construct the inverse of a plan `p`.

src/AbstractFFTs.jl

@@ -3,24 +3,20 @@ module AbstractFFTs
 
 # After this version, the bindings can overwrite deprecated bindings in Base safely, but
 # prior to it we want to extend/reexport the Base definitions
-if VERSION < v"0.7.0-DEV.986"
+if VERSION < v"0.7.0-DEV.602"
     import Base: 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
-    if VERSION < v"0.7.0-DEV.602"
-        import Base.DFT: Plan, ScaledPlan, plan_inv, pinv_type, normalization,
-                         rfft_output_size, brfft_output_size, realfloat, complexfloat
-    end
+    import Base.DFT: Plan, ScaledPlan, plan_inv, pinv_type, normalization,
+                     rfft_output_size, brfft_output_size, realfloat, complexfloat
 end
 # Reexport the Base bindings unchanged for versions before FFTW was removed, or export the
 # new definitions after overwritable deprecation bindings were introduced
-if VERSION < v"0.7.0-DEV.602" || VERSION >= v"0.7.0-DEV.986"
-    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
-end
+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
 
 # Only define things if we aren't using the existing Base bindings
 VERSION >= v"0.7.0-DEV.602" && include("definitions.jl")

src/definitions.jl

@@ -1,8 +1,9 @@
 # This file was formerly a part of Julia. License is MIT: https://julialang.org/license
 
-using Base.LinAlg: BlasReal
+using LinearAlgebra
+using LinearAlgebra: BlasReal
 import Base: show, summary, size, ndims, length, eltype,
-             *, A_mul_B!, inv, \, A_ldiv_B!
+             *, inv, \
 
 # DFT plan where the inputs are an array of eltype T
 abstract type Plan{T} end
@@ -33,11 +34,11 @@ realfloat(x::AbstractArray{T}) where {T<:Real} = copy1(typeof(fftfloat(zero(T)))
 
 # copy to a 1-based array, using circular permutation
 function copy1(::Type{T}, x) where T
-    y = Array{T}(map(length, indices(x)))
+    y = Array{T}(uninitialized, map(length, axes(x)))
     Base.circcopy!(y, x)
 end
 
-to1(x::AbstractArray) = _to1(indices(x), x)
+to1(x::AbstractArray) = _to1(axes(x), x)
 _to1(::Tuple{Base.OneTo,Vararg{Base.OneTo}}, x) = x
 _to1(::Tuple, x) = copy1(eltype(x), x)
 
@@ -93,11 +94,11 @@ contains all of the information needed to compute `fft(A, dims)` quickly.
 To apply `P` to an array `A`, use `P * A`; in general, the syntax for applying plans is much
 like that of matrices.  (A plan can only be applied to arrays of the same size as the `A`
 for which the plan was created.)  You can also apply a plan with a preallocated output array `Â`
-by calling `A_mul_B!(Â, plan, A)`.  (For `A_mul_B!`, however, the input array `A` must
+by calling `mul!(Â, plan, A)`.  (For `mul!`, however, the input array `A` must
 be a complex floating-point array like the output `Â`.) You can compute the inverse-transform plan by `inv(P)`
 and apply the inverse plan with `P \\ Â` (the inverse plan is cached and reused for
 subsequent calls to `inv` or `\\`), and apply the inverse plan to a pre-allocated output
-array `A` with `A_ldiv_B!(A, P, Â)`.
+array `A` with `ldiv!(A, P, Â)`.
 
 The `flags` argument is a bitwise-or of FFTW planner flags, defaulting to `FFTW.ESTIMATE`.
 e.g. passing `FFTW.MEASURE` or `FFTW.PATIENT` will instead spend several seconds (or more)
@@ -206,12 +207,12 @@ plan_rfft(x::AbstractArray, region; kws...) = plan_rfft(realfloat(x), region; kw
 # only require implementation to provide *(::Plan{T}, ::Array{T})
 *(p::Plan{T}, x::AbstractArray) where {T} = p * copy1(T, x)
 
-# Implementations should also implement A_mul_B!(Y, plan, X) so as to support
-# pre-allocated output arrays.  We don't define * in terms of A_mul_B!
+# Implementations should also implement mul!(Y, plan, X) so as to support
+# pre-allocated output arrays.  We don't define * in terms of mul!
 # generically here, however, because of subtleties for in-place and rfft plans.
 
 ##############################################################################
-# To support inv, \, and A_ldiv_B!(y, p, x), we require Plan subtypes
+# To support inv, \, and ldiv!(y, p, x), we require Plan subtypes
 # to have a pinv::Plan field, which caches the inverse plan, and which
 # should be initially undefined.  They should also implement
 # plan_inv(p) to construct the inverse of a plan p.
@@ -224,7 +225,7 @@ pinv_type(p::Plan) = eltype(_pinv_type(p))
 inv(p::Plan) =
     isdefined(p, :pinv) ? p.pinv::pinv_type(p) : (p.pinv = plan_inv(p))
 \(p::Plan, x::AbstractArray) = inv(p) * x
-A_ldiv_B!(y::AbstractArray, p::Plan, x::AbstractArray) = A_mul_B!(y, inv(p), x)
+LinearAlgebra.ldiv!(y::AbstractArray, p::Plan, x::AbstractArray) = LinearAlgebra.mul!(y, inv(p), x)
 
 ##############################################################################
 # implementations only need to provide the unnormalized backwards FFT,
@@ -245,7 +246,13 @@ size(p::ScaledPlan) = size(p.p)
 show(io::IO, p::ScaledPlan) = print(io, p.scale, " * ", p.p)
 summary(p::ScaledPlan) = string(p.scale, " * ", summary(p.p))
 
-*(p::ScaledPlan, x::AbstractArray) = scale!(p.p * x, p.scale)
+if VERSION >= v"0.7.0-DEV.3665"
+    *(p::ScaledPlan, x::AbstractArray) = LinearAlgebra.rmul!(p.p * x, p.scale)
+elseif VERSION >= v"0.7.0-DEV.3563"
+    *(p::ScaledPlan, x::AbstractArray) = LinearAlgebra.mul1!(p.p * x, p.scale)
+else
+    *(p::ScaledPlan, x::AbstractArray) = scale!(p.p * x, p.scale)
+end
 
 *(α::Number, p::Plan) = ScaledPlan(p, α)
 *(p::Plan, α::Number) = ScaledPlan(p, α)
@@ -265,8 +272,16 @@ plan_ifft!(x::AbstractArray, region; kws...) =
 
 plan_inv(p::ScaledPlan) = ScaledPlan(plan_inv(p.p), inv(p.scale))
 
-A_mul_B!(y::AbstractArray, p::ScaledPlan, x::AbstractArray) =
-    scale!(p.scale, A_mul_B!(y, p.p, x))
+if VERSION >= v"0.7.0-DEV.3665"
+    LinearAlgebra.mul!(y::AbstractArray, p::ScaledPlan, x::AbstractArray) =
+        LinearAlgebra.lmul!(p.scale, LinearAlgebra.mul!(y, p.p, x))
+elseif VERSION >= v"0.7.0-DEV.3563"
+    LinearAlgebra.mul!(y::AbstractArray, p::ScaledPlan, x::AbstractArray) =
+        LinearAlgebra.mul2!(p.scale, LinearAlgebra.mul!(y, p.p, x))
+else
+    LinearAlgebra.mul!(y::AbstractArray, p::ScaledPlan, x::AbstractArray) =
+        scale!(p.scale, LinearAlgebra.mul!(y, p.p, x))
+end
 
 ##############################################################################
 # Real-input DFTs are annoying because the output has a different size

test/REQUIRE

@@ -0,0 +1 @@
+Compat 0.48

test/runtests.jl

@@ -1,10 +1,15 @@
 # This file contains code that was formerly part of Julia. License is MIT: https://julialang.org/license
 
 using AbstractFFTs
-using Base.Test
-
-import AbstractFFTs: Plan, plan_fft, plan_inv, plan_bfft
-import Base: A_mul_B!, *
+using AbstractFFTs: Plan
+using Compat.LinearAlgebra
+using Compat.Test
+
+if VERSION < v"0.7.0-DEV.3204"
+    const mul! = Base.A_mul_B!
+else
+    const mul! = LinearAlgebra.mul!
+end
 
 mutable struct TestPlan{T} <: Plan{T}
     region
@@ -34,11 +39,11 @@ function dft!(y::Vector, x::Vector, sign::Int)
     return y
 end
 
-Base.A_mul_B!(y::Vector, p::TestPlan, x::Vector) = dft!(y, x, -1)
-Base.A_mul_B!(y::Vector, p::InverseTestPlan, x::Vector) = dft!(y, x, 1)
+mul!(y::Vector, p::TestPlan, x::Vector) = dft!(y, x, -1)
+mul!(y::Vector, p::InverseTestPlan, x::Vector) = dft!(y, x, 1)
 
-Base.:*(p::TestPlan, x::Vector) = A_mul_B!(copy(x), p, x)
-Base.:*(p::InverseTestPlan, x::Vector) = A_mul_B!(copy(x), p, x)
+Base.:*(p::TestPlan, x::Vector) = mul!(copy(x), p, x)
+Base.:*(p::InverseTestPlan, x::Vector) = mul!(copy(x), p, x)
 
 @testset "Custom Plan" begin
     x = AbstractFFTs.fft(collect(1:8))