add besselk0, besseli0, cheb

Author: heltonmc

src/constants.jl

@@ -9,4 +9,4 @@ const TWOOPI(::Type{Float64}) = 0.6366197723675814
 
 const PIO4(::Type{Float32}) = 0.78539816339744830962f0
 const TWOOPI(::Type{Float32}) = 0.636619772367581343075535f0
-const THPIO4(::Type{Float32}) = 2.35619449019234492885f0
+const THPIO4(::Type{Float32}) = 2.35619449019234492885f0

src/i0.jl

@@ -0,0 +1,75 @@
+function chbevl(x, coeff)
+    b0 = coeff[1]
+    b1 = zero(x)
+    b2 = zero(x)
+
+    for i in 2:length(coeff)
+        b2 = b1
+        b1 = b0
+        b0 = x * b1 - b2 + coeff[i]
+    end
+
+    return 0.5 * (b0 - b2)
+end
+
+const A_i0 = (
+    -4.41534164647933937950E-18, 3.33079451882223809783E-17, -2.43127984654795469359E-16, 
+    1.71539128555513303061E-15, -1.16853328779934516808E-14, 7.67618549860493561688E-14,
+    -4.85644678311192946090E-13, 2.95505266312963983461E-12, -1.72682629144155570723E-11,
+    9.67580903537323691224E-11, -5.18979560163526290666E-10, 2.65982372468238665035E-9,
+    -1.30002500998624804212E-8, 6.04699502254191894932E-8, -2.67079385394061173391E-7,
+    1.11738753912010371815E-6, -4.41673835845875056359E-6, 1.64484480707288970893E-5,
+    -5.75419501008210370398E-5, 1.88502885095841655729E-4, -5.76375574538582365885E-4,
+    1.63947561694133579842E-3, -4.32430999505057594430E-3, 1.05464603945949983183E-2, 
+    -2.37374148058994688156E-2, 4.93052842396707084878E-2, -9.49010970480476444210E-2,
+    1.71620901522208775349E-1, -3.04682672343198398683E-1, 6.76795274409476084995E-1
+)
+
+const B_i0 = (
+    -7.23318048787475395456E-18,
+-4.83050448594418207126E-18,
+ 4.46562142029675999901E-17,
+ 3.46122286769746109310E-17,
+-2.82762398051658348494E-16,
+-3.42548561967721913462E-16,
+ 1.77256013305652638360E-15,
+ 3.81168066935262242075E-15,
+-9.55484669882830764870E-15,
+-4.15056934728722208663E-14,
+ 1.54008621752140982691E-14,
+ 3.85277838274214270114E-13,
+ 7.18012445138366623367E-13,
+-1.79417853150680611778E-12,
+-1.32158118404477131188E-11,
+-3.14991652796324136454E-11,
+ 1.18891471078464383424E-11,
+ 4.94060238822496958910E-10,
+ 3.39623202570838634515E-9,
+ 2.26666899049817806459E-8,
+ 2.04891858946906374183E-7,
+ 2.89137052083475648297E-6,
+ 6.88975834691682398426E-5,
+ 3.36911647825569408990E-3,
+ 8.04490411014108831608E-1
+)
+
+
+function besseli0(x)
+    x = abs(x)
+    if x <= 8.0
+        y = x / 2.0 - 2.0
+        return exp(x) * chbevl(y, A_i0)
+    else
+        return exp(x) * chbevl(32.0 / x - 2.0, B_i0) / sqrt(x)
+    end
+end
+
+function besseli0e(x)
+    x = abs(x)
+    if x <= 8.0
+        y = x / 2.0 - 2.0
+        return chbevl(y, A_i0)
+    else
+        return chbevl(32.0 / x - 2.0, B_i0) / sqrt(x)
+    end
+end

src/j1.jl

@@ -1,7 +1,7 @@
 function besselj1(x::Float32)
     x = abs(x)
     if iszero(x)
-        return one(x)
+        return zero(x)
     elseif isinf(x)
         return zero(x)
     end
@@ -25,7 +25,7 @@ end
 function besselj1(x::Float64)
     x = abs(x)
     if iszero(x)
-        return one(x)
+        return zero(x)
     elseif isinf(x)
         return zero(x)
     end

src/k0.jl

@@ -0,0 +1,71 @@
+function besselk0(x)
+    if x <= zero(x)
+        return throw(DomainError(x, "NaN result for non-NaN input."))
+    end
+
+    if x <= 2.0
+        y = x * x - 2.0
+        y = chbevl(y, A_k0) - log(0.5 * x) * besseli0(x)
+        return y
+    else
+        z = 8.0 / x - 2.0
+        y = exp(-x) * chbevl(z, B_k0) / sqrt(x)
+        return y
+    end
+end
+
+function besselk0e(x)
+    if x <= zero(x)
+        return throw(DomainError(x, "NaN result for non-NaN input."))
+    end
+    if x <= 2.0
+        y = x * x - 2.0
+        y = chbevl(y, A_k0) - log(0.5 * x) * besseli0(x)
+        return y * exp(x)
+    else
+        z = 8.0 / x - 2.0
+        y = chbevl(z, B_k0) / sqrt(x)
+        return y
+    end
+end
+
+const A_k0 = (
+    1.37446543561352307156E-16,
+ 4.25981614279661018399E-14,
+ 1.03496952576338420167E-11,
+ 1.90451637722020886025E-9,
+ 2.53479107902614945675E-7,
+ 2.28621210311945178607E-5,
+ 1.26461541144692592338E-3,
+ 3.59799365153615016266E-2,
+ 3.44289899924628486886E-1,
+-5.35327393233902768720E-1
+)
+
+const B_k0 = (
+    5.30043377268626276149E-18,
+-1.64758043015242134646E-17,
+ 5.21039150503902756861E-17,
+-1.67823109680541210385E-16,
+ 5.51205597852431940784E-16,
+-1.84859337734377901440E-15,
+ 6.34007647740507060557E-15,
+-2.22751332699166985548E-14,
+ 8.03289077536357521100E-14,
+-2.98009692317273043925E-13,
+ 1.14034058820847496303E-12,
+-4.51459788337394416547E-12,
+ 1.85594911495471785253E-11,
+-7.95748924447710747776E-11,
+ 3.57739728140030116597E-10,
+-1.69753450938905987466E-9,
+ 8.57403401741422608519E-9,
+-4.66048989768794782956E-8,
+ 2.76681363944501510342E-7,
+-1.83175552271911948767E-6,
+ 1.39498137188764993662E-5,
+-1.28495495816278026384E-4,
+ 1.56988388573005337491E-3,
+-3.14481013119645005427E-2,
+ 2.44030308206595545468E0
+)

test/besselj_test.jl

@@ -1,39 +1,60 @@
-@test besselj0(0.0) ≈ 1.0
-
+# general array for testing input to SpecialFunctions.jl
 x = 0.01:0.01:100.0
 
-j0_SpecialFunctions = SpecialFunctions.besselj0.(big.(x))
-@assert j0_SpecialFunctions[1] isa BigFloat
+### Tests for besselj0
+j0_SpecialFunctions = SpecialFunctions.besselj0.(big.(x)) # array to be tested against computed in BigFloats
+@assert j0_SpecialFunctions[1] isa BigFloat               # just double check the higher precision
 
 j0_64 = besselj0.(Float64.(x))
 j0_32 = besselj0.(Float32.(x))
 j0_big = besselj0.(big.(x))
 
+# make sure output types match input types
 @test j0_64[1] isa Float64
 @test j0_32[1] isa Float32
 @test j0_big[1] isa BigFloat
 
-
+# test against SpecialFunctions.jl
 @test j0_64 ≈ j0_SpecialFunctions
 @test j0_32 ≈ j0_SpecialFunctions
 
+# BigFloat precision only computed to 128 bits
 @test isapprox(j0_big, j0_SpecialFunctions, atol=1.5e-34)
 
+# NaN should return NaN
+@test isnan(besselj0(NaN))
 
+# zero should return one
+@test isone(besselj0(zero(Float32)))
+@test isone(besselj0(zero(Float64)))
+@test isone(besselj0(zero(BigFloat)))
 
-j1_SpecialFunctions = SpecialFunctions.besselj1.(big.(x))
-@assert j1_SpecialFunctions[1] isa BigFloat
+# test that Inf inputs go to zero
+@test besselj0(Inf32) == zero(Float32)
+@test besselj0(Inf64) == zero(Float64)
+
+### Tests for besselj1
+j1_SpecialFunctions = SpecialFunctions.besselj1.(big.(x)) # array to be tested against computed in BigFloats
+@assert j1_SpecialFunctions[1] isa BigFloat               # just double check the higher precision
 
 j1_64 = besselj1.(Float64.(x))
 j1_32 = besselj1.(Float32.(x))
 
-
-
+# make sure output types match input types
 @test j1_64[1] isa Float64
 @test j1_32[1] isa Float32
 
-
+# test against SpecialFunctions.jl
 @test j1_64 ≈ j1_SpecialFunctions
 @test j1_32 ≈ j1_SpecialFunctions
 
+# NaN should return NaN
+@test isnan(besselj1(NaN))
+
+# zero should return zero
+@test iszero(besselj1(zero(Float32)))
+@test iszero(besselj1(zero(Float64)))
 
+# test that Inf inputs go to zero
+@test besselj1(Inf32) == zero(Float32)
+@test besselj1(Inf64) == zero(Float64)

test/bessely_test.jl

@@ -1,49 +1,66 @@
+# general array for testing input to SpecialFunctions.jl
 x = 0.01:0.01:100.0
 
-y0_SpecialFunctions = SpecialFunctions.bessely0.(big.(x))
-@assert y0_SpecialFunctions[1] isa BigFloat
+### Tests for bessely0
+y0_SpecialFunctions = SpecialFunctions.bessely0.(big.(x))  # array to be tested against computed in BigFloats
+@assert y0_SpecialFunctions[1] isa BigFloat                # just double check the higher precision
 
 y0_64 = bessely0.(Float64.(x))
 y0_32 = bessely0.(Float32.(x))
 y0_big = bessely0.(big.(x))
 
+# make sure output types match input types
 @test y0_64[1] isa Float64
 @test y0_32[1] isa Float32
 @test y0_big[1] isa BigFloat
 
+# test against SpecialFunctions.jl
 @test y0_SpecialFunctions ≈ y0_64
 @test y0_SpecialFunctions ≈ y0_32
 
+# BigFloat precision only computed to 128 bits
 @test isapprox(y0_big, y0_SpecialFunctions, atol=1.5e-34)
 
+# negative numbers should result in a domain error
 @test_throws DomainError bessely0(-1.0)
 
+# NaN should return NaN
+@test isnan(bessely0(NaN))
+
+# test that zero inputs go to -Inf
 @test bessely0(zero(Float32)) == -Inf32
 @test bessely0(zero(Float64)) == -Inf64
 @test bessely0(zero(BigFloat)) == -Inf
 
+# test that Inf inputs go to zero
 @test bessely0(Inf32) == zero(Float32)
 @test bessely0(Inf64) == zero(Float64)
 
+### tests for bessely1
 y1_SpecialFunctions = SpecialFunctions.bessely1.(big.(x))
 @assert y1_SpecialFunctions[1] isa BigFloat
 
 y1_64 = bessely1.(Float64.(x))
 y1_32 = bessely1.(Float32.(x))
 
-
+# make sure output types match input types
 @test y1_64[1] isa Float64
 @test y1_32[1] isa Float32
 
-
+# test against SpecialFunctions.jl
 @test y1_64 ≈ y1_SpecialFunctions
 @test y1_32 ≈ y1_SpecialFunctions
 
+# negative numbers should result in a domain error
 @test_throws DomainError bessely1(-1.0)
 
+# NaN should return NaN
+@test isnan(bessely1(NaN))
+
+# test that zero inputs go to -Inf
 @test bessely1(zero(Float32)) == -Inf32
 @test bessely1(zero(Float64)) == -Inf64
 
+# test that Inf inputs go to zero
 @test bessely1(Inf32) == zero(Float32)
 @test bessely1(Inf64) == zero(Float64)
-