internal API change to parameters: AbstractVector -> NTuple

What a great idea!

Author: MikaelSlevinsky

src/confluent.jl

@@ -23,15 +23,15 @@ function _₁F₁(a, b, z; kwds...)
 end
 
 function _₁F₁general(a, b, z; kwds...)
-    if abs(z) > 10 # TODO: check this algorithmic parameter cutoff
+    if abs(z) > 10 # TODO: check this algorithmic parameter cutoff, determine when to use rational algorithms
         if isreal(z)
             if real(z) ≥ 0 # 13.7.1
-                return gamma(b)/gamma(a)*exp(z)*z^(a-b)*drummond2F0(1-a, b-a, inv(z); kwds...)
+                return gamma(b)/gamma(a)*exp(z)*z^(a-b)*pFqdrummond((1-a, b-a), (), inv(z); kwds...)
             else # 13.7.1 + 13.2.39
-                return gamma(b)/gamma(b-a)*(-z)^-a*drummond2F0(a, a-b+1, -inv(z); kwds...)
+                return gamma(b)/gamma(b-a)*(-z)^-a*pFqdrummond((a, a-b+1), (), -inv(z); kwds...)
             end
         else # 13.7.2
-            return gamma(b)/gamma(a)*exp(z)*z^(a-b)*drummond2F0(1-a, b-a, inv(z); kwds...) + gamma(b)/gamma(b-a)*(-z)^-a*drummond2F0(a, a-b+1, -inv(z); kwds...)
+            return gamma(b)/gamma(a)*exp(z)*z^(a-b)*pFqdrummond((1-a, b-a), (), inv(z); kwds...) + gamma(b)/gamma(b-a)*(-z)^-a*pFqdrummond((a, a-b+1), (), -inv(z); kwds...)
         end
     elseif real(z) ≥ 0
         return _₁F₁maclaurin(a, b, z; kwds...)
@@ -49,5 +49,5 @@ const M = _₁F₁
 Compute Tricomi's confluent hypergeometric function `U(a, b, z) ∼ z⁻ᵃ ₂F₀([a, a-b+1]; []; -z⁻¹)`.
 """
 function U(a, b, z; kwds...)
-    return z^-a*drummond2F0(a, a-b+1, -inv(z); kwds...)
+    return z^-a*pFqdrummond((a, a-b+1), (), -inv(z); kwds...)
 end

src/drummond.jl

@@ -2,7 +2,7 @@
 # using Drummond's sequence transformation
 
 # ₀F₀(;z)
-function drummond0F0(z::T; kmax::Int = 10_000) where T
+function pFqdrummond(::Tuple{}, ::Tuple{}, z::T; kmax::Int = 10_000) where T
     if norm(z) < eps(real(T))
         return one(T)
     end
@@ -28,7 +28,8 @@ function drummond0F0(z::T; kmax::Int = 10_000) where T
 end
 
 # ₁F₀(α;z)
-function drummond1F0(α::T1, z::T2; kmax::Int = 10_000) where {T1, T2}
+function pFqdrummond(α::Tuple{T1}, ::Tuple{}, z::T2; kmax::Int = 10_000) where {T1, T2}
+    α = α[1]
     T = promote_type(T1, T2)
     absα = abs(T(α))
     if norm(z) < eps(real(T)) || norm(α) < eps(absα)
@@ -71,7 +72,8 @@ function drummond1F0(α::T1, z::T2; kmax::Int = 10_000) where {T1, T2}
 end
 
 # ₀F₁(β;z)
-function drummond0F1(β::T1, z::T2; kmax::Int = 10_000) where {T1, T2}
+function pFqdrummond(::Tuple{}, β::Tuple{T1}, z::T2; kmax::Int = 10_000) where {T1, T2}
+    β = β[1]
     T = promote_type(T1, T2)
     if norm(z) < eps(real(T))
         return one(T)
@@ -101,8 +103,9 @@ function drummond0F1(β::T1, z::T2; kmax::Int = 10_000) where {T1, T2}
 end
 
 # ₂F₀(α,β;z)
-function drummond2F0(α::T1, β::T2, z::T3; kmax::Int = 10_000) where {T1, T2, T3}
-    T = promote_type(T1, T2, T3)
+function pFqdrummond(α::Tuple{T1, T1}, ::Tuple{}, z::T2; kmax::Int = 10_000) where {T1, T2}
+    (α, β) = α
+    T = promote_type(T1, T2)
     absα = abs(T(α))
     absβ = abs(T(β))
     if norm(z) < eps(real(T)) || norm(α*β) < eps(absα*absβ)
@@ -144,7 +147,9 @@ function drummond2F0(α::T1, β::T2, z::T3; kmax::Int = 10_000) where {T1, T2, T
 end
 
 # ₁F₁(α,β;z)
-function drummond1F1(α::T1, β::T2, z::T3; kmax::Int = 10_000) where {T1, T2, T3}
+function pFqdrummond(α::Tuple{T1}, β::Tuple{T2}, z::T3; kmax::Int = 10_000) where {T1, T2, T3}
+    α = α[1]
+    β = β[1]
     T = promote_type(T1, T2, T3)
     absα = abs(T(α))
     if norm(z) < eps(real(T)) || norm(α) < eps(absα)
@@ -195,8 +200,9 @@ function drummond1F1(α::T1, β::T2, z::T3; kmax::Int = 10_000) where {T1, T2, T
 end
 
 # ₀F₂(α,β;z)
-function drummond0F2(α::T1, β::T2, z::T3; kmax::Int = 10_000) where {T1, T2, T3}
-    T = promote_type(T1, T2, T3)
+function pFqdrummond(::Tuple{}, β::Tuple{T1, T1}, z::T2; kmax::Int = 10_000) where {T1, T2}
+    (α, β) = β
+    T = promote_type(T1, T2)
     if norm(z) < eps(real(T)) || norm(α) < eps(real(T)) || norm(β) < eps(real(T))
         return one(T)
     end
@@ -231,8 +237,10 @@ function drummond0F2(α::T1, β::T2, z::T3; kmax::Int = 10_000) where {T1, T2, T
 end
 
 # ₂F₁(α,β,γ;z)
-function drummond2F1(α::T1, β::T2, γ::T3, z::T4; kmax::Int = 10_000) where {T1, T2, T3, T4}
-    T = promote_type(T1, T2, T3, T4)
+function pFqdrummond(α::Tuple{T1, T1}, β::Tuple{T2}, z::T3; kmax::Int = 10_000) where {T1, T2, T3}
+    γ = β[1]
+    (α, β) = α
+    T = promote_type(T1, T2, T3)
     absα = abs(T(α))
     absβ = abs(T(β))
     if norm(z) < eps(real(T)) || norm(α*β) < eps(absα*absβ)
@@ -283,15 +291,21 @@ function drummond2F1(α::T1, β::T2, γ::T3, z::T4; kmax::Int = 10_000) where {T
 end
 
 # ₘFₙ(α;β;z)
-function pFqdrummond(α::AbstractVector{T1}, β::AbstractVector{T2}, z::T3; kmax::Int = 10_000) where {T1, T2, T3}
-    T = promote_type(T1, T2, T3)
+function pFqdrummond(α::AbstractVector{T1}, β::AbstractVector{T2}, z::T3; kwds...) where {T1, T2, T3}
+    pFqdrummond(Tuple(α), Tuple(β), z; kwds...)
+end
+function pFqdrummond(α::NTuple{p, Any}, β::NTuple{q, Any}, z; kwds...) where {p, q}
+    T1 = mapreduce(typeof, promote_type, α)
+    T2 = mapreduce(typeof, promote_type, β)
+    pFqdrummond(T1.(α), T2.(β), z; kwds...)
+end
+function pFqdrummond(α::NTuple{p, T1}, β::NTuple{q, T2}, z::T3; kmax::Int = 10_000) where {p, q, T1, T2, T3}
+    T = promote_type(eltype(α), eltype(β), T3)
     absα = abs.(T.(α))
     if norm(z) < eps(real(T)) || norm(prod(α)) < eps(prod(absα))
         return one(T)
     end
     ζ = inv(z)
-    p = length(α)
-    q = length(β)
     r = max(p+1, q+2)
     err = one(real(T))
     for j in 1:p
@@ -380,3 +394,11 @@ function pFqdrummond(α::AbstractVector{T1}, β::AbstractVector{T2}, z::T3; kmax
     end
     return isfinite(R[r+1]) ? R[r+1] : R[r]
 end
+
+@deprecate drummond0F0(x; kwds...) pFqdrummond((), (), x; kwds...) false
+@deprecate drummond1F0(α, x; kwds...) pFqdrummond((α, ), (), x; kwds...) false
+@deprecate drummond0F1(β, x; kwds...) pFqdrummond((), (β, ), x; kwds...) false
+@deprecate drummond2F0(α, β, x; kwds...) pFqdrummond((α, β), (), x; kwds...) false
+@deprecate drummond1F1(α, β, x; kwds...) pFqdrummond((α, ), (β, ), x; kwds...) false
+@deprecate drummond0F2(α, β, x; kwds...) pFqdrummond((), (α, β), x; kwds...) false
+@deprecate drummond2F1(α, β, γ, x; kwds...) pFqdrummond((α, β), (γ, ), x; kwds...) false

src/gauss.jl

@@ -92,7 +92,7 @@ function _₂F₁general(a, b, c, z)
     elseif abs(inv(1-z)) ≤ ρ
         return exp(-a*log1p(-z))*_₂F₁one(a, c-b, c, z/(z-1))
     else
-        return pFqweniger([a, b], [c], z) # _₂F₁taylor(a, b, c, z)
+        return pFqweniger((a, b), (c, ), z) # _₂F₁taylor(a, b, c, z)
     end
 end
 
@@ -150,7 +150,7 @@ function _₂F₁general2(a, b, c, z)
             return gamma(c)*(gamma(b-a)/gamma(b)/gamma(c-a)*(0.5-z)^(-a)*_₂F₁continuation(a, a+b, c, 0.5, z) + gamma(a-b)/gamma(a)/gamma(c-b)*(0.5-z)^(-b)*_₂F₁continuation(b, a+b, c, 0.5, z))
         end
     end
-    return pFqweniger([a, b], [c], z)
+    return pFqweniger((a, b), (c, ), z)
 end
 
 # Special case of (-x)^a*_₂F₁ to handle LogNumber correctly in RiemannHilbert.jl

src/generalized.jl

@@ -50,7 +50,7 @@ function _₃F₂(a₁, a₂, a₃, b₁, b₂, z; kwds...)
     if abs(z) ≤ ρ
         _₃F₂maclaurin(a₁, a₂, a₃, b₁, b₂, float(z); kwds...)
     else
-        pFqweniger([a₁, a₂, a₃], [b₁, b₂], float(z); kwds...)
+        pFqweniger((a₁, a₂, a₃), (b₁, b₂), float(z); kwds...)
     end
 end
 _₃F₂(a₁, b₁, z; kwds...) = _₃F₂(1, 1, a₁, 2, b₁, z; kwds...)

src/weniger.jl

@@ -3,16 +3,22 @@
 
 # ₘFₙ(α;β;z)
 # γ ∉ ℕ
-function pFqweniger(α::AbstractVector{T1}, β::AbstractVector{T2}, z::T3; kmax::Int = 10_000) where {T1, T2, T3}
-    T = promote_type(T1, T2, T3)
+function pFqweniger(α::AbstractVector{T1}, β::AbstractVector{T2}, z::T3; kwds...) where {T1, T2, T3}
+    pFqweniger(Tuple(α), Tuple(β), z; kwds...)
+end
+function pFqweniger(α::NTuple{p, Any}, β::NTuple{q, Any}, z; kwds...) where {p, q}
+    T1 = mapreduce(typeof, promote_type, α)
+    T2 = mapreduce(typeof, promote_type, β)
+    pFqweniger(T1.(α), T2.(β), z; kwds...)
+end
+function pFqweniger(α::NTuple{p, T1}, β::NTuple{q, T2}, z::T3; kmax::Int = 10_000) where {p, q, T1, T2, T3}
+    T = promote_type(eltype(α), eltype(β), T3)
     absα = abs.(T.(α))
-    if norm(z) < eps(real(T)) || norm(prod(α)) < eps(prod(absα))
+    if norm(z) < eps(real(T)) || norm(prod(α)) < eps(real(T)(prod(absα)))
         return one(T)
     end
     γ = T(3)/2
     ζ = inv(z)
-    p = length(α)
-    q = length(β)
     r = max(p, q)+3
     ρ = max(p, q)+1
     C = zeros(T, r)