Fix FFTW warning, tests pass in 0.7

Author: dlfivefifty

REQUIRE

@@ -3,4 +3,5 @@ ToeplitzMatrices 0.2
 HierarchicalMatrices 0.0.2
 LowRankApprox 0.0.2
 ProgressMeter 0.3.4
+SpecialFunctions 0.3.4
 Compat 0.17

src/ChebyshevJacobiPlan.jl

@@ -1,4 +1,4 @@
-immutable ChebyshevJacobiConstants{D,T}
+struct ChebyshevJacobiConstants{D,T}
     α::T
     β::T
     M::Int
@@ -23,7 +23,7 @@ function ChebyshevJacobiConstants{T}(c::AbstractVector{T},α::T,β::T;M::Int=7,D
     ChebyshevJacobiConstants{D,T}(α,β,M,N,nM₀,αN,K)
 end
 
-immutable ChebyshevJacobiIndices
+struct ChebyshevJacobiIndices
     i₁::Vector{Int}
     i₂::Vector{Int}
     j₁::Vector{Int}
@@ -53,7 +53,7 @@ function ChebyshevJacobiIndices{D,T}(α::T,β::T,CJC::ChebyshevJacobiConstants{D
     ChebyshevJacobiIndices(i₁,i₂,j₁,j₂)
 end
 
-type ChebyshevJacobiPlan{D,T,DCT,DST,SA} <: FastTransformPlan{D,T}
+mutable struct ChebyshevJacobiPlan{D,T,DCT,DST,SA} <: FastTransformPlan{D,T}
     CJC::ChebyshevJacobiConstants{D,T}
     CJI::ChebyshevJacobiIndices
     p₁::DCT

src/ChebyshevUltrasphericalPlan.jl

@@ -1,4 +1,4 @@
-immutable ChebyshevUltrasphericalConstants{D,T}
+struct ChebyshevUltrasphericalConstants{D,T}
     λ::T
     M::Int
     N::Int
@@ -23,7 +23,7 @@ function ChebyshevUltrasphericalConstants{T}(c::AbstractVector{T},λ::T;M::Int=7
     ChebyshevUltrasphericalConstants{D,T}(λ,M,N,nM₀,αN,K)
 end
 
-immutable ChebyshevUltrasphericalIndices
+struct ChebyshevUltrasphericalIndices
     i₁::Vector{Int}
     i₂::Vector{Int}
     j₁::Vector{Int}
@@ -53,7 +53,7 @@ function ChebyshevUltrasphericalIndices{D,T}(λ::T,CUC::ChebyshevUltrasphericalC
     ChebyshevUltrasphericalIndices(i₁,i₂,j₁,j₂)
 end
 
-type ChebyshevUltrasphericalPlan{D,T,DCT,DST,SA} <: FastTransformPlan{D,T}
+mutable struct ChebyshevUltrasphericalPlan{D,T,DCT,DST,SA} <: FastTransformPlan{D,T}
     CUC::ChebyshevUltrasphericalConstants{D,T}
     CUI::ChebyshevUltrasphericalIndices
     p₁::DCT

src/FastTransforms.jl

@@ -2,7 +2,17 @@ __precompile__()
 module FastTransforms
 
 using ToeplitzMatrices, HierarchicalMatrices, LowRankApprox, ProgressMeter, Compat,
-        FFTW, AbstractFFTs
+        AbstractFFTs, SpecialFunctions
+
+if VERSION < v"0.7-"
+    using Base.FFTW
+    import Base.FFTW: r2rFFTWPlan, unsafe_execute!, fftwSingle, fftwDouble, fftwNumber
+    import Base.FFTW: libfftw, libfftwf, PlanPtr, r2rFFTWPlan
+else
+    using FFTW
+    import FFTW: r2rFFTWPlan, unsafe_execute!, fftwSingle, fftwDouble, fftwNumber
+    import FFTW: libfftw, libfftwf, PlanPtr, r2rFFTWPlan
+end
 
 import Base: *, \, size, view
 import Base: getindex, setindex!, Factorization, length
@@ -11,8 +21,6 @@ import HierarchicalMatrices: HierarchicalMatrix, unsafe_broadcasttimes!
 import HierarchicalMatrices: A_mul_B!, At_mul_B!, Ac_mul_B!
 import LowRankApprox: ColPerm
 import AbstractFFTs: Plan
-import FFTW: r2rFFTWPlan, unsafe_execute!, fftwSingle, fftwDouble, fftwNumber
-import FFTW: libfftw, libfftwf, PlanPtr, r2rFFTWPlan
 
 
 export cjt, icjt, jjt, plan_cjt, plan_icjt
@@ -50,7 +58,7 @@ include("fejer.jl")
 include("recurrence.jl")
 include("PaduaTransform.jl")
 
-@compat abstract type FastTransformPlan{D,T} end
+abstract type FastTransformPlan{D,T} end
 
 include("ChebyshevJacobiPlan.jl")
 include("jac2cheb.jl")

src/PaduaTransform.jl

@@ -2,7 +2,7 @@ doc"""
 Pre-plan an Inverse Padua Transform.
 """
 # lex indicates if its lexigraphical (i.e., x, y) or reverse (y, x)
-immutable IPaduaTransformPlan{lex,IDCTPLAN,T}
+struct IPaduaTransformPlan{lex,IDCTPLAN,T}
     cfsmat::Matrix{T}
     idctplan::IDCTPLAN
 end
@@ -103,7 +103,7 @@ end
 doc"""
 Pre-plan a Padua Transform.
 """
-immutable PaduaTransformPlan{lex,DCTPLAN,T}
+struct PaduaTransformPlan{lex,DCTPLAN,T}
     vals::Matrix{T}
     dctplan::DCTPLAN
 end

src/SphericalHarmonics/Butterfly.jl

@@ -1,4 +1,4 @@
-immutable Butterfly{T} <: Factorization{T}
+struct Butterfly{T} <: Factorization{T}
     columns::Vector{Matrix{T}}
     factors::Vector{Vector{IDPackedV{T}}}
     permutations::Vector{Vector{ColumnPermutation}}
@@ -60,7 +60,7 @@ function Butterfly{T}(A::AbstractMatrix{T}, L::Int; isorthogonal::Bool = false,
         end
         permutations[1][j] = factors[1][j][:P]
         indices[1][j+1] = indices[1][j] + size(factors[1][j], 1)
-        cs[1][j] = factors[1][j].sk+nl-1
+        cs[1][j] = factors[1][j].sk .+ nl .- 1
     end
 
     ii, jj = 2, (tL>>1)
@@ -276,7 +276,7 @@ function A_mul_B_col_J!{T}(u::VecOrMat{T}, B::Butterfly{T}, b::VecOrMat{T}, J::I
 end
 
 for f! in (:At_mul_B!,:Ac_mul_B!)
-    f_col_J! = parse(string(f!)[1:end-1]*"_col_J!")
+    f_col_J! = Meta.parse(string(f!)[1:end-1]*"_col_J!")
     @eval begin
         function $f_col_J!{T}(u::VecOrMat{T}, B::Butterfly{T}, b::VecOrMat{T}, J::Int)
             L = length(B.factors) - 1

src/SphericalHarmonics/fastplan.jl

@@ -1,4 +1,4 @@
-immutable FastSphericalHarmonicPlan{T} <: SphericalHarmonicPlan{T}
+struct FastSphericalHarmonicPlan{T} <: SphericalHarmonicPlan{T}
     RP::RotationPlan{T}
     BF::Vector{Butterfly{T}}
     p1::NormalizedLegendreToChebyshevPlan{T}

src/SphericalHarmonics/slowplan.jl

@@ -41,7 +41,7 @@ function A_mul_B!{T<:Real}(A::AbstractMatrix, G::Givens{T})
     return A
 end
 
-immutable Pnmp2toPlm{T} <: AbstractRotation{T}
+struct Pnmp2toPlm{T} <: AbstractRotation{T}
     rotations::Vector{Givens{T}}
 end
 
@@ -73,7 +73,7 @@ function Base.A_mul_B!(A::AbstractMatrix, C::Pnmp2toPlm)
 end
 
 
-immutable RotationPlan{T} <: AbstractRotation{T}
+struct RotationPlan{T} <: AbstractRotation{T}
     layers::Vector{Pnmp2toPlm{T}}
 end
 
@@ -126,7 +126,7 @@ end
 Base.Ac_mul_B!(P::RotationPlan, A::AbstractMatrix) = At_mul_B!(P, A)
 
 
-immutable SlowSphericalHarmonicPlan{T} <: SphericalHarmonicPlan{T}
+struct SlowSphericalHarmonicPlan{T} <: SphericalHarmonicPlan{T}
     RP::RotationPlan{T}
     p1::NormalizedLegendreToChebyshevPlan{T}
     p2::NormalizedLegendre1ToChebyshev2Plan{T}

src/SphericalHarmonics/synthesisanalysis.jl

@@ -1,4 +1,4 @@
-immutable SynthesisPlan{T, P1, P2}
+struct SynthesisPlan{T, P1, P2}
     planθ::P1
     planφ::P2
     C::ColumnPermutation
@@ -15,7 +15,7 @@ function plan_synthesis{T<:fftwNumber}(A::Matrix{T})
     SynthesisPlan(planθ, planφ, C, zeros(T, n))
 end
 
-immutable AnalysisPlan{T, P1, P2}
+struct AnalysisPlan{T, P1, P2}
     planθ::P1
     planφ::P2
     C::ColumnPermutation

src/SphericalHarmonics/thinplan.jl

@@ -2,7 +2,7 @@ const LAYERSKELETON = 64
 
 checklayer(j::Int) = j÷LAYERSKELETON == j/LAYERSKELETON
 
-immutable ThinSphericalHarmonicPlan{T} <: SphericalHarmonicPlan{T}
+struct ThinSphericalHarmonicPlan{T} <: SphericalHarmonicPlan{T}
     RP::RotationPlan{T}
     BF::Vector{Butterfly{T}}
     p1::NormalizedLegendreToChebyshevPlan{T}

src/fftBigFloat.jl

@@ -1,43 +1,49 @@
 const BigFloats = Union{BigFloat,Complex{BigFloat}}
 
-real(x...)=Base.real(x...)
-real{T<:Real}(::Type{T})=T
-real{T<:Real}(::Type{Complex{T}})=T
+if VERSION < v"0.7-"
+    import Base.FFTW: fft, fft!, rfft, irfft, ifft, conv, dct, idct, dct!, idct!,
+                        plan_fft!, plan_ifft!, plan_dct!, plan_idct!,
+                        plan_fft, plan_ifft, plan_rfft, plan_irfft, plan_dct, plan_idct
+else
+    import FFTW: fft, fft!, rfft, irfft, ifft, conv, dct, idct, dct!, idct!,
+                        plan_fft!, plan_ifft!, plan_dct!, plan_idct!,
+                        plan_fft, plan_ifft, plan_rfft, plan_irfft, plan_dct, plan_idct
+end
 
 # The following implements Bluestein's algorithm, following http://www.dsprelated.com/dspbooks/mdft/Bluestein_s_FFT_Algorithm.html
 # To add more types, add them in the union of the function's signature.
-function Base.fft{T<:BigFloats}(x::Vector{T})
+function fft{T<:BigFloats}(x::Vector{T})
     n = length(x)
     ispow2(n) && return fft_pow2(x)
     ks = linspace(zero(real(T)),n-one(real(T)),n)
-    Wks = exp.((-im).*convert(T,π).*ks.^2./n)
-    xq,wq = x.*Wks,conj([exp(-im*convert(T,π)*n);reverse(Wks);Wks[2:end]])
+    Wks = exp.((-im).*convert(T,π).*ks.^2 ./ n)
+    xq, wq = x.*Wks, conj([exp(-im*convert(T,π)*n);reverse(Wks);Wks[2:end]])
     return Wks.*conv(xq,wq)[n+1:2n]
 end
 
-function Base.fft!{T<:BigFloats}(x::Vector{T})
+function fft!{T<:BigFloats}(x::Vector{T})
     x[:] = fft(x)
     return x
 end
 
 # add rfft for BigFloat, by calling fft
-#  this creates ToeplitzMatrices.rfft, so avoids changing Base.rfft
-Base.rfft{T<:BigFloats}(v::Vector{T})=fft(v)[1:div(length(v),2)+1]
-function Base.irfft{T<:BigFloats}(v::Vector{T},n::Integer)
+#  this creates ToeplitzMatrices.rfft, so avoids changing rfft
+rfft{T<:BigFloats}(v::Vector{T})=fft(v)[1:div(length(v),2)+1]
+function irfft{T<:BigFloats}(v::Vector{T},n::Integer)
     @assert n==2length(v)-1
     r = Vector{Complex{BigFloat}}(n)
     r[1:length(v)]=v
     r[length(v)+1:end]=reverse(conj(v[2:end]))
     real(ifft(r))
 end
 
-Base.ifft{T<:BigFloats}(x::Vector{T}) = conj!(fft(conj(x)))/length(x)
-function Base.ifft!{T<:BigFloats}(x::Vector{T})
+ifft{T<:BigFloats}(x::Vector{T}) = conj!(fft(conj(x)))/length(x)
+function ifft!{T<:BigFloats}(x::Vector{T})
     x[:] = ifft(x)
     return x
 end
 
-function Base.conv{T<:BigFloats}(u::StridedVector{T}, v::StridedVector{T})
+function conv{T<:BigFloats}(u::StridedVector{T}, v::StridedVector{T})
     nu,nv = length(u),length(v)
     n = nu + nv - 1
     np2 = nextpow2(n)
@@ -101,7 +107,7 @@ function ifft_pow2{T<:BigFloat}(x::Vector{Complex{T}})
 end
 
 
-function Base.dct(a::AbstractArray{Complex{BigFloat}})
+function dct(a::AbstractArray{Complex{BigFloat}})
 	N = big(length(a))
     c = fft([a; flipdim(a,1)])
     d = c[1:N]
@@ -110,9 +116,9 @@ function Base.dct(a::AbstractArray{Complex{BigFloat}})
     scale!(inv(sqrt(2N)), d)
 end
 
-Base.dct(a::AbstractArray{BigFloat}) = real(dct(complex(a)))
+dct(a::AbstractArray{BigFloat}) = real(dct(complex(a)))
 
-function Base.idct(a::AbstractArray{Complex{BigFloat}})
+function idct(a::AbstractArray{Complex{BigFloat}})
     N = big(length(a))
     b = a * sqrt(2*N)
     b[1] = b[1] * sqrt(big(2))
@@ -122,18 +128,18 @@ function Base.idct(a::AbstractArray{Complex{BigFloat}})
     c[1:N]
 end
 
-Base.idct(a::AbstractArray{BigFloat}) = real(idct(complex(a)))
+idct(a::AbstractArray{BigFloat}) = real(idct(complex(a)))
 
-Base.dct!{T<:BigFloats}(a::AbstractArray{T}) = (b = dct(a); a[:] = b)
-Base.idct!{T<:BigFloats}(a::AbstractArray{T}) = (b = idct(a); a[:] = b)
+dct!{T<:BigFloats}(a::AbstractArray{T}) = (b = dct(a); a[:] = b)
+idct!{T<:BigFloats}(a::AbstractArray{T}) = (b = idct(a); a[:] = b)
 
 # dummy plans
-type DummyFFTPlan{T,inplace} <: Plan{T} end
-type DummyiFFTPlan{T,inplace} <: Plan{T} end
-type DummyrFFTPlan{T,inplace} <: Plan{T} end
-type DummyirFFTPlan{T,inplace} <: Plan{T} end
-type DummyDCTPlan{T,inplace} <: Plan{T} end
-type DummyiDCTPlan{T,inplace} <: Plan{T} end
+struct DummyFFTPlan{T,inplace} <: Plan{T} end
+struct DummyiFFTPlan{T,inplace} <: Plan{T} end
+struct DummyrFFTPlan{T,inplace} <: Plan{T} end
+struct DummyirFFTPlan{T,inplace} <: Plan{T} end
+struct DummyDCTPlan{T,inplace} <: Plan{T} end
+struct DummyiDCTPlan{T,inplace} <: Plan{T} end
 
 for (Plan,iPlan) in ((:DummyFFTPlan,:DummyiFFTPlan),
                      (:DummyrFFTPlan,:DummyirFFTPlan),
@@ -164,19 +170,19 @@ end
 
 
 
-Base.plan_fft!{T<:BigFloats}(x::Vector{T}) = DummyFFTPlan{Complex{BigFloat},true}()
-Base.plan_ifft!{T<:BigFloats}(x::Vector{T}) = DummyiFFTPlan{Complex{BigFloat},true}()
-#Base.plan_rfft!{T<:BigFloats}(x::Vector{T}) = DummyrFFTPlan{Complex{BigFloat},true}()
-#Base.plan_irfft!{T<:BigFloats}(x::Vector{T},n::Integer) = DummyirFFTPlan{Complex{BigFloat},true}()
-Base.plan_dct!{T<:BigFloats}(x::Vector{T}) = DummyDCTPlan{T,true}()
-Base.plan_idct!{T<:BigFloats}(x::Vector{T}) = DummyiDCTPlan{T,true}()
+plan_fft!{T<:BigFloats}(x::Vector{T}) = DummyFFTPlan{Complex{BigFloat},true}()
+plan_ifft!{T<:BigFloats}(x::Vector{T}) = DummyiFFTPlan{Complex{BigFloat},true}()
+#plan_rfft!{T<:BigFloats}(x::Vector{T}) = DummyrFFTPlan{Complex{BigFloat},true}()
+#plan_irfft!{T<:BigFloats}(x::Vector{T},n::Integer) = DummyirFFTPlan{Complex{BigFloat},true}()
+plan_dct!{T<:BigFloats}(x::Vector{T}) = DummyDCTPlan{T,true}()
+plan_idct!{T<:BigFloats}(x::Vector{T}) = DummyiDCTPlan{T,true}()
 
-Base.plan_fft{T<:BigFloats}(x::Vector{T}) = DummyFFTPlan{Complex{BigFloat},false}()
-Base.plan_ifft{T<:BigFloats}(x::Vector{T}) = DummyiFFTPlan{Complex{BigFloat},false}()
-Base.plan_rfft{T<:BigFloats}(x::Vector{T}) = DummyrFFTPlan{Complex{BigFloat},false}()
-Base.plan_irfft{T<:BigFloats}(x::Vector{T},n::Integer) = DummyirFFTPlan{Complex{BigFloat},false}()
-Base.plan_dct{T<:BigFloats}(x::Vector{T}) = DummyDCTPlan{T,false}()
-Base.plan_idct{T<:BigFloats}(x::Vector{T}) = DummyiDCTPlan{T,false}()
+plan_fft{T<:BigFloats}(x::Vector{T}) = DummyFFTPlan{Complex{BigFloat},false}()
+plan_ifft{T<:BigFloats}(x::Vector{T}) = DummyiFFTPlan{Complex{BigFloat},false}()
+plan_rfft{T<:BigFloats}(x::Vector{T}) = DummyrFFTPlan{Complex{BigFloat},false}()
+plan_irfft{T<:BigFloats}(x::Vector{T},n::Integer) = DummyirFFTPlan{Complex{BigFloat},false}()
+plan_dct{T<:BigFloats}(x::Vector{T}) = DummyDCTPlan{T,false}()
+plan_idct{T<:BigFloats}(x::Vector{T}) = DummyiDCTPlan{T,false}()
 
 
 function interlace{S<:Number,V<:Number}(a::Vector{S},b::Vector{V})