Add complex transforms

soften typing of parameterized transforms (@dlfivefifty), since they get converted at the `ccall`

Author: MikaelSlevinsky

src/libfasttransforms.jl

@@ -219,6 +219,7 @@ for f in (:leg2cheb, :cheb2leg, :ultra2ultra, :jac2jac,
     plan_f = Symbol("plan_", f)
     @eval begin
         $plan_f(x::AbstractArray{T}, y...; z...) where T = $plan_f(T, size(x, 1), y...; z...)
+        $plan_f(x::AbstractArray{Complex{T}}, y...; z...) where T <: Real = $plan_f(T, size(x, 1), y...; z...)
         $f(x::AbstractArray, y...; z...) = $plan_f(x, y...; z...)*x
     end
 end
@@ -242,47 +243,47 @@ function plan_cheb2leg(::Type{Float32}, n::Integer; normcheb::Bool=false, normle
     return FTPlan{Float32, 1, CHEB2LEG}(plan, n)
 end
 
-function plan_ultra2ultra(::Type{Float32}, n::Integer, λ::Float32, μ::Float32; norm1::Bool=false, norm2::Bool=false)
+function plan_ultra2ultra(::Type{Float32}, n::Integer, λ, μ; norm1::Bool=false, norm2::Bool=false)
     plan = ccall((:ft_plan_ultraspherical_to_ultrasphericalf, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float32, Float32), norm1, norm2, n, λ, μ)
     return FTPlan{Float32, 1, ULTRA2ULTRA}(plan, n)
 end
 
-function plan_jac2jac(::Type{Float32}, n::Integer, α::Float32, β::Float32, γ::Float32, δ::Float32; norm1::Bool=false, norm2::Bool=false)
+function plan_jac2jac(::Type{Float32}, n::Integer, α, β, γ, δ; norm1::Bool=false, norm2::Bool=false)
     plan = ccall((:ft_plan_jacobi_to_jacobif, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float32, Float32, Float32, Float32), norm1, norm2, n, α, β, γ, δ)
     return FTPlan{Float32, 1, JAC2JAC}(plan, n)
 end
 
-function plan_lag2lag(::Type{Float32}, n::Integer, α::Float32, β::Float32; norm1::Bool=false, norm2::Bool=false)
+function plan_lag2lag(::Type{Float32}, n::Integer, α, β; norm1::Bool=false, norm2::Bool=false)
     plan = ccall((:ft_plan_laguerre_to_laguerref, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float32, Float32), norm1, norm2, n, α, β)
     return FTPlan{Float32, 1, LAG2LAG}(plan, n)
 end
 
-function plan_jac2ultra(::Type{Float32}, n::Integer, α::Float32, β::Float32, λ::Float32; normjac::Bool=false, normultra::Bool=false)
+function plan_jac2ultra(::Type{Float32}, n::Integer, α, β, λ; normjac::Bool=false, normultra::Bool=false)
     plan = ccall((:ft_plan_jacobi_to_ultrasphericalf, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float32, Float32, Float32), normjac, normultra, n, α, β, λ)
     return FTPlan{Float32, 1, JAC2ULTRA}(plan, n)
 end
 
-function plan_ultra2jac(::Type{Float32}, n::Integer, λ::Float32, α::Float32, β::Float32; normultra::Bool=false, normjac::Bool=false)
+function plan_ultra2jac(::Type{Float32}, n::Integer, λ, α, β; normultra::Bool=false, normjac::Bool=false)
     plan = ccall((:ft_plan_ultraspherical_to_jacobif, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float32, Float32, Float32), normultra, normjac, n, λ, α, β)
     return FTPlan{Float32, 1, ULTRA2JAC}(plan, n)
 end
 
-function plan_jac2cheb(::Type{Float32}, n::Integer, α::Float32, β::Float32; normjac::Bool=false, normcheb::Bool=false)
+function plan_jac2cheb(::Type{Float32}, n::Integer, α, β; normjac::Bool=false, normcheb::Bool=false)
     plan = ccall((:ft_plan_jacobi_to_chebyshevf, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float32, Float32), normjac, normcheb, n, α, β)
     return FTPlan{Float32, 1, JAC2CHEB}(plan, n)
 end
 
-function plan_cheb2jac(::Type{Float32}, n::Integer, α::Float32, β::Float32; normcheb::Bool=false, normjac::Bool=false)
+function plan_cheb2jac(::Type{Float32}, n::Integer, α, β; normcheb::Bool=false, normjac::Bool=false)
     plan = ccall((:ft_plan_chebyshev_to_jacobif, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float32, Float32), normcheb, normjac, n, α, β)
     return FTPlan{Float32, 1, CHEB2JAC}(plan, n)
 end
 
-function plan_ultra2cheb(::Type{Float32}, n::Integer, λ::Float32; normultra::Bool=false, normcheb::Bool=false)
+function plan_ultra2cheb(::Type{Float32}, n::Integer, λ; normultra::Bool=false, normcheb::Bool=false)
     plan = ccall((:ft_plan_ultraspherical_to_chebyshevf, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float32), normultra, normcheb, n, λ)
     return FTPlan{Float32, 1, ULTRA2CHEB}(plan, n)
 end
 
-function plan_cheb2ultra(::Type{Float32}, n::Integer, λ::Float32; normcheb::Bool=false, normultra::Bool=false)
+function plan_cheb2ultra(::Type{Float32}, n::Integer, λ; normcheb::Bool=false, normultra::Bool=false)
     plan = ccall((:ft_plan_chebyshev_to_ultrasphericalf, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float32), normcheb, normultra, n, λ)
     return FTPlan{Float32, 1, CHEB2ULTRA}(plan, n)
 end
@@ -298,47 +299,47 @@ function plan_cheb2leg(::Type{Float64}, n::Integer; normcheb::Bool=false, normle
     return FTPlan{Float64, 1, CHEB2LEG}(plan, n)
 end
 
-function plan_ultra2ultra(::Type{Float64}, n::Integer, λ::Float64, μ::Float64; norm1::Bool=false, norm2::Bool=false)
+function plan_ultra2ultra(::Type{Float64}, n::Integer, λ, μ; norm1::Bool=false, norm2::Bool=false)
     plan = ccall((:ft_plan_ultraspherical_to_ultraspherical, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float64, Float64), norm1, norm2, n, λ, μ)
     return FTPlan{Float64, 1, ULTRA2ULTRA}(plan, n)
 end
 
-function plan_jac2jac(::Type{Float64}, n::Integer, α::Float64, β::Float64, γ::Float64, δ::Float64; norm1::Bool=false, norm2::Bool=false)
+function plan_jac2jac(::Type{Float64}, n::Integer, α, β, γ, δ; norm1::Bool=false, norm2::Bool=false)
     plan = ccall((:ft_plan_jacobi_to_jacobi, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float64, Float64, Float64, Float64), norm1, norm2, n, α, β, γ, δ)
     return FTPlan{Float64, 1, JAC2JAC}(plan, n)
 end
 
-function plan_lag2lag(::Type{Float64}, n::Integer, α::Float64, β::Float64; norm1::Bool=false, norm2::Bool=false)
+function plan_lag2lag(::Type{Float64}, n::Integer, α, β; norm1::Bool=false, norm2::Bool=false)
     plan = ccall((:ft_plan_laguerre_to_laguerre, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float64, Float64), norm1, norm2, n, α, β)
     return FTPlan{Float64, 1, LAG2LAG}(plan, n)
 end
 
-function plan_jac2ultra(::Type{Float64}, n::Integer, α::Float64, β::Float64, λ::Float64; normjac::Bool=false, normultra::Bool=false)
+function plan_jac2ultra(::Type{Float64}, n::Integer, α, β, λ; normjac::Bool=false, normultra::Bool=false)
     plan = ccall((:ft_plan_jacobi_to_ultraspherical, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float64, Float64, Float64), normjac, normultra, n, α, β, λ)
     return FTPlan{Float64, 1, JAC2ULTRA}(plan, n)
 end
 
-function plan_ultra2jac(::Type{Float64}, n::Integer, λ::Float64, α::Float64, β::Float64; normultra::Bool=false, normjac::Bool=false)
+function plan_ultra2jac(::Type{Float64}, n::Integer, λ, α, β; normultra::Bool=false, normjac::Bool=false)
     plan = ccall((:ft_plan_ultraspherical_to_jacobi, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float64, Float64, Float64), normultra, normjac, n, λ, α, β)
     return FTPlan{Float64, 1, ULTRA2JAC}(plan, n)
 end
 
-function plan_jac2cheb(::Type{Float64}, n::Integer, α::Float64, β::Float64; normjac::Bool=false, normcheb::Bool=false)
+function plan_jac2cheb(::Type{Float64}, n::Integer, α, β; normjac::Bool=false, normcheb::Bool=false)
     plan = ccall((:ft_plan_jacobi_to_chebyshev, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float64, Float64), normjac, normcheb, n, α, β)
     return FTPlan{Float64, 1, JAC2CHEB}(plan, n)
 end
 
-function plan_cheb2jac(::Type{Float64}, n::Integer, α::Float64, β::Float64; normcheb::Bool=false, normjac::Bool=false)
+function plan_cheb2jac(::Type{Float64}, n::Integer, α, β; normcheb::Bool=false, normjac::Bool=false)
     plan = ccall((:ft_plan_chebyshev_to_jacobi, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float64, Float64), normcheb, normjac, n, α, β)
     return FTPlan{Float64, 1, CHEB2JAC}(plan, n)
 end
 
-function plan_ultra2cheb(::Type{Float64}, n::Integer, λ::Float64; normultra::Bool=false, normcheb::Bool=false)
+function plan_ultra2cheb(::Type{Float64}, n::Integer, λ; normultra::Bool=false, normcheb::Bool=false)
     plan = ccall((:ft_plan_ultraspherical_to_chebyshev, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float64), normultra, normcheb, n, λ)
     return FTPlan{Float64, 1, ULTRA2CHEB}(plan, n)
 end
 
-function plan_cheb2ultra(::Type{Float64}, n::Integer, λ::Float64; normcheb::Bool=false, normultra::Bool=false)
+function plan_cheb2ultra(::Type{Float64}, n::Integer, λ; normcheb::Bool=false, normultra::Bool=false)
     plan = ccall((:ft_plan_chebyshev_to_ultraspherical, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Float64), normcheb, normultra, n, λ)
     return FTPlan{Float64, 1, CHEB2ULTRA}(plan, n)
 end
@@ -354,47 +355,47 @@ function plan_cheb2leg(::Type{BigFloat}, n::Integer; normcheb::Bool=false, norml
     return FTPlan{BigFloat, 1, CHEB2LEG}(plan, n)
 end
 
-function plan_ultra2ultra(::Type{BigFloat}, n::Integer, λ::BigFloat, μ::BigFloat; norm1::Bool=false, norm2::Bool=false)
+function plan_ultra2ultra(::Type{BigFloat}, n::Integer, λ, μ; norm1::Bool=false, norm2::Bool=false)
     plan = ccall((:ft_mpfr_plan_ultraspherical_to_ultraspherical, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Ref{BigFloat}, Ref{BigFloat}, Clong, Int32), norm1, norm2, n, λ, μ, precision(BigFloat), Base.MPFR.ROUNDING_MODE[])
     return FTPlan{BigFloat, 1, ULTRA2ULTRA}(plan, n)
 end
 
-function plan_jac2jac(::Type{BigFloat}, n::Integer, α::BigFloat, β::BigFloat, γ::BigFloat, δ::BigFloat; norm1::Bool=false, norm2::Bool=false)
+function plan_jac2jac(::Type{BigFloat}, n::Integer, α, β, γ, δ; norm1::Bool=false, norm2::Bool=false)
     plan = ccall((:ft_mpfr_plan_jacobi_to_jacobi, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, Clong, Int32), norm1, norm2, n, α, β, γ, δ, precision(BigFloat), Base.MPFR.ROUNDING_MODE[])
     return FTPlan{BigFloat, 1, JAC2JAC}(plan, n)
 end
 
-function plan_lag2lag(::Type{BigFloat}, n::Integer, α::BigFloat, β::BigFloat; norm1::Bool=false, norm2::Bool=false)
+function plan_lag2lag(::Type{BigFloat}, n::Integer, α, β; norm1::Bool=false, norm2::Bool=false)
     plan = ccall((:ft_mpfr_plan_laguerre_to_laguerre, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Ref{BigFloat}, Ref{BigFloat}, Clong, Int32), norm1, norm2, n, α, β, precision(BigFloat), Base.MPFR.ROUNDING_MODE[])
     return FTPlan{BigFloat, 1, LAG2LAG}(plan, n)
 end
 
-function plan_jac2ultra(::Type{BigFloat}, n::Integer, α::BigFloat, β::BigFloat, λ::BigFloat; normjac::Bool=false, normultra::Bool=false)
+function plan_jac2ultra(::Type{BigFloat}, n::Integer, α, β, λ; normjac::Bool=false, normultra::Bool=false)
     plan = ccall((:ft_mpfr_plan_jacobi_to_ultraspherical, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, Clong, Int32), normjac, normultra, n, α, β, λ, precision(BigFloat), Base.MPFR.ROUNDING_MODE[])
     return FTPlan{BigFloat, 1, JAC2ULTRA}(plan, n)
 end
 
-function plan_ultra2jac(::Type{BigFloat}, n::Integer, λ::BigFloat, α::BigFloat, β::BigFloat; normultra::Bool=false, normjac::Bool=false)
+function plan_ultra2jac(::Type{BigFloat}, n::Integer, λ, α, β; normultra::Bool=false, normjac::Bool=false)
     plan = ccall((:ft_mpfr_plan_ultraspherical_to_jacobi, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Ref{BigFloat}, Ref{BigFloat}, Ref{BigFloat}, Clong, Int32), normultra, normjac, n, λ, α, β, precision(BigFloat), Base.MPFR.ROUNDING_MODE[])
     return FTPlan{BigFloat, 1, ULTRA2JAC}(plan, n)
 end
 
-function plan_jac2cheb(::Type{BigFloat}, n::Integer, α::BigFloat, β::BigFloat; normjac::Bool=false, normcheb::Bool=false)
+function plan_jac2cheb(::Type{BigFloat}, n::Integer, α, β; normjac::Bool=false, normcheb::Bool=false)
     plan = ccall((:ft_mpfr_plan_jacobi_to_chebyshev, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Ref{BigFloat}, Ref{BigFloat}, Clong, Int32), normjac, normcheb, n, α, β, precision(BigFloat), Base.MPFR.ROUNDING_MODE[])
     return FTPlan{BigFloat, 1, JAC2CHEB}(plan, n)
 end
 
-function plan_cheb2jac(::Type{BigFloat}, n::Integer, α::BigFloat, β::BigFloat; normcheb::Bool=false, normjac::Bool=false)
+function plan_cheb2jac(::Type{BigFloat}, n::Integer, α, β; normcheb::Bool=false, normjac::Bool=false)
     plan = ccall((:ft_mpfr_plan_chebyshev_to_jacobi, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Ref{BigFloat}, Ref{BigFloat}, Clong, Int32), normcheb, normjac, n, α, β, precision(BigFloat), Base.MPFR.ROUNDING_MODE[])
     return FTPlan{BigFloat, 1, CHEB2JAC}(plan, n)
 end
 
-function plan_ultra2cheb(::Type{BigFloat}, n::Integer, λ::BigFloat; normultra::Bool=false, normcheb::Bool=false)
+function plan_ultra2cheb(::Type{BigFloat}, n::Integer, λ; normultra::Bool=false, normcheb::Bool=false)
     plan = ccall((:ft_mpfr_plan_ultraspherical_to_chebyshev, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Ref{BigFloat}, Clong, Int32), normultra, normcheb, n, λ, precision(BigFloat), Base.MPFR.ROUNDING_MODE[])
     return FTPlan{BigFloat, 1, ULTRA2CHEB}(plan, n)
 end
 
-function plan_cheb2ultra(::Type{BigFloat}, n::Integer, λ::BigFloat; normcheb::Bool=false, normultra::Bool=false)
+function plan_cheb2ultra(::Type{BigFloat}, n::Integer, λ; normcheb::Bool=false, normultra::Bool=false)
     plan = ccall((:ft_mpfr_plan_chebyshev_to_ultraspherical, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Cint, Cint, Ref{BigFloat}, Clong, Int32), normcheb, normultra, n, λ, precision(BigFloat), Base.MPFR.ROUNDING_MODE[])
     return FTPlan{BigFloat, 1, CHEB2ULTRA}(plan, n)
 end
@@ -415,12 +416,12 @@ function plan_disk2cxf(::Type{Float64}, n::Integer)
     return FTPlan{Float64, 2, DISK}(plan, n)
 end
 
-function plan_tri2cheb(::Type{Float64}, n::Integer, α::Float64, β::Float64, γ::Float64)
+function plan_tri2cheb(::Type{Float64}, n::Integer, α, β, γ)
     plan = ccall((:ft_plan_tri2cheb, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Float64, Float64, Float64), n, α, β, γ)
     return FTPlan{Float64, 2, TRIANGLE}(plan, n)
 end
 
-function plan_tet2cheb(::Type{Float64}, n::Integer, α::Float64, β::Float64, γ::Float64, δ::Float64)
+function plan_tet2cheb(::Type{Float64}, n::Integer, α, β, γ, δ)
     plan = ccall((:ft_plan_tet2cheb, libfasttransforms), Ptr{ft_plan_struct}, (Cint, Float64, Float64, Float64, Float64), n, α, β, γ, δ)
     return FTPlan{Float64, 3, TETRAHEDRON}(plan, n)
 end
@@ -621,3 +622,27 @@ function ldiv!(p::FTPlan{Float64, 3, TETRAHEDRON}, x::Array{Float64, 3})
     ccall((:ft_execute_cheb2tet, libfasttransforms), Cvoid, (Ptr{ft_plan_struct}, Ptr{Float64}, Cint, Cint, Cint), p, x, size(x, 1), size(x, 2), size(x, 3))
     return x
 end
+
+*(p::FTPlan{T}, x::Array{Complex{T}}) where T = lmul!(p, deepcopy(x))
+*(p::AdjointFTPlan{T}, x::Array{Complex{T}}) where T = lmul!(p, deepcopy(x))
+*(p::TransposeFTPlan{T}, x::Array{Complex{T}}) where T = lmul!(p, deepcopy(x))
+\(p::FTPlan{T}, x::Array{Complex{T}}) where T = ldiv!(p, deepcopy(x))
+\(p::AdjointFTPlan{T}, x::Array{Complex{T}}) where T = ldiv!(p, deepcopy(x))
+\(p::TransposeFTPlan{T}, x::Array{Complex{T}}) where T = ldiv!(p, deepcopy(x))
+
+for fJ in (:lmul!, :ldiv!)
+    @eval begin
+        function $fJ(p::FTPlan{T}, x::AbstractArray{Complex{T}}) where T
+            x .= complex.($fJ(p, real(x)), $fJ(p, imag(x)))
+            return x
+        end
+        function $fJ(p::AdjointFTPlan{T, FTPlan{T, N, K}}, x::AbstractArray{Complex{T}}) where {T, N, K}
+            x .= complex.($fJ(p, real(x)), $fJ(p, imag(x)))
+            return x
+        end
+        function $fJ(p::TransposeFTPlan{T, FTPlan{T, N, K}}, x::AbstractArray{Complex{T}}) where {T, N, K}
+            x .= complex.($fJ(p, real(x)), $fJ(p, imag(x)))
+            return x
+        end
+    end
+end

test/libfasttransformstests.jl

@@ -5,16 +5,16 @@ FastTransforms.set_num_threads(ceil(Int, Base.Sys.CPU_THREADS/2))
 @testset "libfasttransforms" begin
     n = 64
     α, β, γ, δ, λ, μ = 0.1, 0.2, 0.3, 0.4, 0.5, 0.6
-    for T in (Float32, Float64, BigFloat)
+    for T in (Float32, Float64, BigFloat, Complex{Float32}, Complex{Float64}), Complex{BigFloat})
         x = T(1)./(1:n)
         Id = Matrix{T}(I, n, n)
         for (p1, p2) in ((plan_leg2cheb(Id), plan_cheb2leg(Id)),
-                          (plan_ultra2ultra(Id, T(λ), T(μ)), plan_ultra2ultra(Id, T(μ), T(λ))),
-                          (plan_jac2jac(Id, T(α), T(β), T(γ), T(δ)), plan_jac2jac(Id, T(γ), T(δ), T(α), T(β))),
-                          (plan_lag2lag(Id, T(α), T(β)), plan_lag2lag(Id, T(β), T(α))),
-                          (plan_jac2ultra(Id, T(α), T(β), T(λ)), plan_ultra2jac(Id, T(λ), T(α), T(β))),
-                          (plan_jac2cheb(Id, T(α), T(β)), plan_cheb2jac(Id, T(α), T(β))),
-                          (plan_ultra2cheb(Id, T(λ)), plan_cheb2ultra(Id, T(λ))))
+                          (plan_ultra2ultra(Id, λ, μ), plan_ultra2ultra(Id, μ, λ)),
+                          (plan_jac2jac(Id, α, β, γ, δ), plan_jac2jac(Id, γ, δ, α, β)),
+                          (plan_lag2lag(Id, α, β), plan_lag2lag(Id, β, α)),
+                          (plan_jac2ultra(Id, α, β, λ), plan_ultra2jac(Id, λ, α, β)),
+                          (plan_jac2cheb(Id, α, β), plan_cheb2jac(Id, α, β)),
+                          (plan_ultra2cheb(Id, λ), plan_cheb2ultra(Id, λ)))
             y = p1*x
             z = p2*y
             @test z ≈ x
@@ -53,48 +53,50 @@ FastTransforms.set_num_threads(ceil(Int, Base.Sys.CPU_THREADS/2))
         end
     end
 
-    A = sphones(Float64, n, 2n-1)
-    p = plan_sph2fourier(A)
-    ps = plan_sph_synthesis(A)
-    pa = plan_sph_analysis(A)
-    B = copy(A)
-    C = ps*(p*A)
-    A = p\(pa*C)
-    @test A ≈ B
+    for T in (Float64, Complex{Float64})
+        A = sphones(T, n, 2n-1)
+        p = plan_sph2fourier(A)
+        ps = plan_sph_synthesis(A)
+        pa = plan_sph_analysis(A)
+        B = copy(A)
+        C = ps*(p*A)
+        A = p\(pa*C)
+        @test A ≈ B
 
-    A = sphvones(Float64, n, 2n-1)
-    p = plan_sphv2fourier(A)
-    ps = plan_sphv_synthesis(A)
-    pa = plan_sphv_analysis(A)
-    B = copy(A)
-    C = ps*(p*A)
-    A = p\(pa*C)
-    @test A ≈ B
+        A = sphvones(T, n, 2n-1)
+        p = plan_sphv2fourier(A)
+        ps = plan_sphv_synthesis(A)
+        pa = plan_sphv_analysis(A)
+        B = copy(A)
+        C = ps*(p*A)
+        A = p\(pa*C)
+        @test A ≈ B
 
-    A = diskones(Float64, n, 4n-3)
-    p = plan_disk2cxf(A)
-    ps = plan_disk_synthesis(A)
-    pa = plan_disk_analysis(A)
-    B = copy(A)
-    C = ps*(p*A)
-    A = p\(pa*C)
-    @test A ≈ B
+        A = diskones(T, n, 4n-3)
+        p = plan_disk2cxf(A)
+        ps = plan_disk_synthesis(A)
+        pa = plan_disk_analysis(A)
+        B = copy(A)
+        C = ps*(p*A)
+        A = p\(pa*C)
+        @test A ≈ B
 
-    A = triones(Float64, n, n)
-    p = plan_tri2cheb(A, α, β, γ)
-    ps = plan_tri_synthesis(A)
-    pa = plan_tri_analysis(A)
-    B = copy(A)
-    C = ps*(p*A)
-    A = p\(pa*C)
-    @test A ≈ B
+        A = triones(T, n, n)
+        p = plan_tri2cheb(A, α, β, γ)
+        ps = plan_tri_synthesis(A)
+        pa = plan_tri_analysis(A)
+        B = copy(A)
+        C = ps*(p*A)
+        A = p\(pa*C)
+        @test A ≈ B
 
-    A = tetones(Float64, n, n, n)
-    p = plan_tet2cheb(A, α, β, γ, δ)
-    ps = plan_tet_synthesis(A)
-    pa = plan_tet_analysis(A)
-    B = copy(A)
-    C = ps*(p*A)
-    A = p\(pa*C)
-    @test A ≈ B
+        A = tetones(T, n, n, n)
+        p = plan_tet2cheb(A, α, β, γ, δ)
+        ps = plan_tet_synthesis(A)
+        pa = plan_tet_analysis(A)
+        B = copy(A)
+        C = ps*(p*A)
+        A = p\(pa*C)
+        @test A ≈ B
+    end
 end