Use broadcast syntax for all special functions

Author: dlfivefifty

src/ChebyshevJacobiPlan.jl

@@ -142,7 +142,7 @@ function ForwardChebyshevJacobiPlan{T}(c_jac::AbstractVector{T},α::T,β::T,M::I
     @inbounds for i=1:N+1 tempcosβsinα[i] = tempcos[i]^(β+1/2)*tempsin[i]^(α+1/2) end
 
     # Initialize normalizing constant
-    cnαβ = Cnαβ(0:N,α,β)
+    cnαβ = Cnαβ.(0:N,α,β)
     cnmαβ = zero(cnαβ)
 
     # Get indices
@@ -184,11 +184,11 @@ function BackwardChebyshevJacobiPlan{T}(c_cheb::AbstractVector{T},α::T,β::T,M:
     @inbounds for i=1:2N+1 tempcosβsinα[i] = tempcos[i]^(β+1/2)*tempsin[i]^(α+1/2) end
 
     # Initialize normalizing constant
-    cnαβ = Cnαβ(0:2N,α,β)
+    cnαβ = Cnαβ.(0:2N,α,β)
     cnmαβ = zero(cnαβ)
 
     # Initialize orthonormality constants
-    anαβ = Anαβ(0:N,α,β)
+    anαβ = Anαβ.(0:N,α,β)
 
     # Get indices
     CJI = ChebyshevJacobiIndices(α,β,CJC,tempmindices,cfs,tempcos,tempsin,tempcosβsinα)

src/ChebyshevUltrasphericalPlan.jl

@@ -184,7 +184,7 @@ function BackwardChebyshevUltrasphericalPlan{T}(c_ultra::AbstractVector{T},λ::T
     cnmλ = similar(cnλ)
 
     # Initialize orthonormality constants
-    anλ = Anαβ(0:N,λ-half(λ),λ-half(λ))
+    anλ = Anαβ.(0:N,λ-half(λ),λ-half(λ))
 
     # Get indices
     CUI = ChebyshevUltrasphericalIndices(λ,CUC,tempmindices,tempsin,tempsinλ)

src/nufft.jl

@@ -64,9 +64,9 @@ function plan_nufft3{T<:AbstractFloat}(x::AbstractVector{T}, ω::AbstractVector{
 
     p = plan_nufft1(ω, ϵ)
 
-    D1 = Diagonal(1-(s-t+1)/N)
-    D2 = Diagonal((s-t+1)/N)
-    D3 = Diagonal(exp.(-2*im*T(π)*ω))
+    D1 = Diagonal(1 .- (s .- t .+ 1)./N)
+    D2 = Diagonal((s .- t .+ 1)./N)
+    D3 = Diagonal(exp.(-2 .* im .* T(π) .* ω ))
     U = hcat(D1*u, D2*u)
     V = hcat(v, D3*v)
 

src/specialfunctions.jl

@@ -103,15 +103,12 @@ end
 
 
 stirlingremainder(z::Number,N::Int) = (1+zeta(N))*gamma(N)/((2π)^(N+1)*z^N)/stirlingseries(z)
-stirlingremainder{T<:Number}(z::AbstractVector{T},N::Int) = (1+zeta(N))*gamma(N)/(2π)^(N+1)./z.^N./stirlingseries(z)
 
 Aratio(n::Int,α::Float64,β::Float64) = exp((n/2+α+1/4)*log1p(-β/(n+α+β+1))+(n/2+β+1/4)*log1p(-α/(n+α+β+1))+(n/2+1/4)*log1p(α/(n+1))+(n/2+1/4)*log1p(β/(n+1)))
 Aratio(n::Number,α::Number,β::Number) = (1+(α+1)/n)^(n+α+1/2)*(1+(β+1)/n)^(n+β+1/2)/(1+(α+β+1)/n)^(n+α+β+1/2)/(1+(zero(α)+zero(β))/n)^(n+1/2)
-Aratio(n::AbstractVector,α::Number,β::Number) = [ Aratio(n[i],α,β) for i=1:length(n) ]
 
 Cratio(n::Int,α::Float64,β::Float64) = exp((n+α+1/2)*log1p((α-β)/(2n+α+β+2))+(n+β+1/2)*log1p((β-α)/(2n+α+β+2))-log1p((α+β+2)/2n)/2)/sqrt(n)
 Cratio(n::Number,α::Number,β::Number) = n^(-1/2)*(1+(α+1)/n)^(n+α+1/2)*(1+(β+1)/n)^(n+β+1/2)/(1+(α+β+2)/2n)^(2n+α+β+3/2)
-Cratio(n::AbstractVector,α::Number,β::Number) = [ Cratio(n[i],α,β) for i=1:length(n) ]
 
 
 Anαβ(n::Number,α::Number,β::Number) = 2^(α+β+1)/(2n+α+β+1)*exp(lgamma(n+α+1)-lgamma(n+α+β+1)+lgamma(n+β+1)-lgamma(n+1))
@@ -135,9 +132,6 @@ function Anαβ(n::Integer,α::Float64,β::Float64)
     end
 end
 
-Anαβ{T<:Integer}(n::AbstractVector{T},α::Number,β::Number) = [ Anαβ(n[i],α,β) for i=1:length(n) ]
-Anαβ{T<:Integer}(n::AbstractMatrix{T},α::Number,β::Number) = [ Anαβ(n[i,j],α,β) for i=1:size(n,1), j=1:size(n,2) ]
-
 
 doc"""
 The Lambda function ``\Lambda(z) = \frac{\Gamma(z+\frac{1}{2})}{\Gamma(z+1)}`` for the ratio of gamma functions.
@@ -168,7 +162,6 @@ function Λ(x::Float64,λ₁::Float64,λ₂::Float64)
         (x+λ₂)/(x+λ₁)*Λ(x+1.,λ₁,λ₂)
     end
 end
-Λ{T<:Number}(x::AbstractArray{T},λ₁::Number,λ₂::Number) = promote_type(T,typeof(λ₁),typeof(λ₂))[ Λ(x[i],λ₁,λ₂) for i in eachindex(x) ]
 
 ## TODO: deprecate when Lambert-W is supported in a mainstream repository such as SpecialFunctions.jl
 doc"""
@@ -210,9 +203,6 @@ function Cnλ{T<:Integer}(n::UnitRange{T},λ::Number)
     ret
 end
 
-Cnλ{T<:Integer}(n::AbstractVector{T},λ::Number) = [ Cnλ(n[i],λ) for i=1:length(n) ]
-Cnλ{T<:Integer}(n::AbstractMatrix{T},λ::Number) = [ Cnλ(n[i,j],λ) for i=1:size(n,1), j=1:size(n,2) ]
-
 function Cnmλ(n::Integer,m::Integer,λ::Number)
     if m == 0
         Cnλ(n,λ)
@@ -221,8 +211,6 @@ function Cnmλ(n::Integer,m::Integer,λ::Number)
     end
 end
 
-Cnmλ{T<:Integer}(n::AbstractVector{T},m::Integer,λ::Number) = [ Cnmλ(n[i],m,λ) for i=1:length(n) ]
-
 
 function Cnαβ(n::Integer,α::Number,β::Number)
     if n==0
@@ -244,9 +232,6 @@ function Cnαβ(n::Integer,α::Float64,β::Float64)
     end
 end
 
-Cnαβ{T<:Integer}(n::AbstractVector{T},α::Number,β::Number) = [ Cnαβ(n[i],α,β) for i=1:length(n) ]
-Cnαβ{T<:Integer}(n::AbstractMatrix{T},α::Number,β::Number) = [ Cnαβ(n[i,j],α,β) for i=1:size(n,1), j=1:size(n,2) ]
-
 function Cnmαβ(n::Integer,m::Integer,α::Number,β::Number)
     if m == 0
         Cnαβ(n,α,β)
@@ -255,8 +240,6 @@ function Cnmαβ(n::Integer,m::Integer,α::Number,β::Number)
     end
 end
 
-Cnmαβ{T<:Integer}(n::AbstractVector{T},m::Integer,α::Number,β::Number) = [ Cnmαβ(n[i],m,α,β) for i=1:length(n) ]
-Cnmαβ{T<:Integer}(n::AbstractMatrix{T},m::Integer,α::Number,β::Number) = [ Cnmαβ(n[i,j],m,α,β) for i=1:size(n,1), j=1:size(n,2) ]
 
 function Cnmαβ{T<:Number}(n::Integer,m::Integer,α::AbstractArray{T},β::AbstractArray{T})
     shp = promote_shape(size(α),size(β))

src/toeplitzhankel.jl

@@ -126,7 +126,7 @@ function leg2chebuTH{S}(::Type{S},n)
     t = zeros(S,n)
     t[1:2:end] = λ[1:2:n]./(((1:2:n).-2))
     T = TriangularToeplitz(-2t/π,:U)
-    H = Hankel(λ[1:n]./((1:n)+1),λ[n:end]./((n:2n-1)+1))
+    H = Hankel(λ[1:n]./((1:n).+1),λ[n:end]./((n:2n-1).+1))
     T,H
 end
 
@@ -135,9 +135,9 @@ function ultra2ultraTH{S}(::Type{S},n,λ₁,λ₂)
     DL = (zero(S):n-one(S)) .+ λ₂
     jk = 0:half(S):n-1
     t = zeros(S,n)
-    t[1:2:n] = Λ(jk,λ₁-λ₂,one(S))[1:2:n]
+    t[1:2:n] = Λ.(jk,λ₁-λ₂,one(S))[1:2:n]
     T = TriangularToeplitz(scale!(inv(gamma(λ₁-λ₂)),t),:U)
-    h = Λ(jk,λ₁,λ₂+one(S))
+    h = Λ.(jk,λ₁,λ₂+one(S))
     scale!(gamma(λ₂)/gamma(λ₁),h)
     H = Hankel(h[1:n],h[n:end])
     DR = ones(S,n)
@@ -149,10 +149,10 @@ function jac2jacTH{S}(::Type{S},n,α,β,γ,δ)
     @assert abs(α-γ) < 1
     @assert α+β > -1
     jk = zero(S):n-one(S)
-    DL = (2jk+γ+β+one(S)).*Λ(jk,γ+β+one(S),β+one(S))
-    T = TriangularToeplitz(Λ(jk,α-γ,one(S)),:U)
-    H = Hankel(Λ(jk,α+β+one(S),γ+β+two(S)),Λ(jk+n-one(S),α+β+one(S),γ+β+two(S)))
-    DR = Λ(jk,β+one(S),α+β+one(S))/gamma(α-γ)
+    DL = (2jk .+ γ .+ β .+ one(S)).*Λ.(jk,γ+β+one(S),β+one(S))
+    T = TriangularToeplitz(Λ.(jk,α-γ,one(S)),:U)
+    H = Hankel(Λ.(jk,α+β+one(S),γ+β+two(S)),Λ.(jk.+n.-one(S),α+β+one(S),γ+β+two(S)))
+    DR = Λ.(jk,β+one(S),α+β+one(S))./gamma(α-γ)
     T,H,DL,DR
 end
 

test/basictests.jl

@@ -1,11 +1,5 @@
-using FastTransforms, LowRankApprox
-
-if VERSION < v"0.7-"
-    using Base.Test
-else
-    using Test
-end
-
+using Compat, FastTransforms, LowRankApprox
+using Compat.Test
 import FastTransforms: Cnλ, Λ, lambertw, Cnαβ, Anαβ, fejer1, fejer2, clenshawcurtis
 
 @testset "Special functions" begin
@@ -28,11 +22,11 @@ import FastTransforms: Cnλ, Λ, lambertw, Cnαβ, Anαβ, fejer1, fejer2, clens
     α = 0.125
     β = 0.375
 
-    @time FastTransforms.Cnαβ(n,α,β);
-    @test norm(FastTransforms.Cnαβ(n,α,β) ./ FastTransforms.Cnαβ(n,big(α),big(β)) .- 1,Inf) < 3eps()
+    @time FastTransforms.Cnαβ.(n,α,β);
+    @test norm(FastTransforms.Cnαβ.(n,α,β) ./ FastTransforms.Cnαβ.(n,big(α),big(β)) .- 1,Inf) < 3eps()
 
-    @time FastTransforms.Anαβ(n,α,β);
-    @test norm(FastTransforms.Anαβ(n,α,β) ./ FastTransforms.Anαβ(n,big(α),big(β)) .- 1,Inf) < 4eps()
+    @time FastTransforms.Anαβ.(n,α,β);
+    @test norm(FastTransforms.Anαβ.(n,α,β) ./ FastTransforms.Anαβ.(n,big(α),big(β)) .- 1,Inf) < 4eps()
 end
 
 @testset "Fejer and Clenshaw--Curtis quadrature" begin

test/butterflytests.jl

@@ -1,5 +1,5 @@
-using FastTransforms, LowRankApprox
-using Base.Test
+using FastTransforms, LowRankApprox, Compat
+using Compat.Test
 
 import FastTransforms: Butterfly
 

test/chebyshevjacobitests.jl

@@ -1,4 +1,5 @@
-using FastTransforms, Base.Test
+using FastTransforms, Compat
+using Compat.Test
 
 @testset "Chebyshev--Jacobi transform" begin
     println("Testing the accuracy of asymptotics")

test/chebyshevlegendretests.jl

@@ -1,4 +1,5 @@
-using FastTransforms, Base.Test
+using FastTransforms, Compat
+using Compat.Test
 
 @testset "Chebyshev--Legendre transform" begin
     for k in round.([Int],logspace(1,4,20))

test/fftBigFloattests.jl

@@ -1,8 +1,7 @@
-using FastTransforms
-if VERSION < v"0.7-"
-    using Base.Test, Base.FFTW
-else
-    using Test, FFTW
+using FastTransforms, Compat
+using Compat.Test
+if VERSION ≥ v"0.7-"
+    using FFTW
 end
 
 @testset "BigFloat FFT and DCT" begin