add OP syntax

Author: dlfivefifty

Project.toml

@@ -24,7 +24,7 @@ SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 
 [compat]
 ArrayLayouts = "0.5.3"
-BandedMatrices = "0.16.1"
+BandedMatrices = "0.16.2"
 BlockArrays = "0.14.1"
 BlockBandedMatrices = "0.10"
 ContinuumArrays = "0.5"

README.md

@@ -5,10 +5,23 @@ A Julia package for classical orthogonal polynomials and expansions
 [![codecov](https://codecov.io/gh/JuliaApproximation/ClassicalOrthogonalPolynomials.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/JuliaApproximation/ClassicalOrthogonalPolynomials.jl)
 
 
-This package implements classical orthogonal polynomials as quasi-arrays where one one axes is continuous and the other axis is discrete (countably infinite), as implemented in [QuasiArrays.jl](https://github.com/JuliaApproximation/QuasiArrays.jl) and  [ContinuumArrays.jl](https://github.com/JuliaApproximation/ContinuumArrays.jl).  
+This package implements classical orthogonal polynomials.
 ```julia
 julia> using ClassicalOrthogonalPolynomials, ContinuumArrays
 
+julia> chebyshevt.(0:5,0.1)
+6-element Array{Float64,1}:
+  1.0
+  0.1
+ -0.98
+ -0.296
+  0.9208
+  0.48016
+```
+Other examples include `chebyshevu`, `legendrep`, `jacobip`, and `ultrasphericalp`.
+
+For expansion, it supports usafe as quasi-arrays where one one axes is continuous and the other axis is discrete (countably infinite), as implemented in [QuasiArrays.jl](https://github.com/JuliaApproximation/QuasiArrays.jl) and  [ContinuumArrays.jl](https://github.com/JuliaApproximation/ContinuumArrays.jl).  
+```julia
 julia> P = Legendre(); # Legendre polynomials
 
 julia> size(P) # uncountable ∞ x countable ∞

src/ClassicalOrthogonalPolynomials.jl

@@ -38,7 +38,7 @@ import BandedMatrices: bandwidths
 export OrthogonalPolynomial, Normalized, orthonormalpolynomial, LanczosPolynomial, Hermite, Jacobi, Legendre, Chebyshev, ChebyshevT, ChebyshevU, ChebyshevInterval, Ultraspherical, Fourier,
             HermiteWeight, JacobiWeight, ChebyshevWeight, ChebyshevGrid, ChebyshevTWeight, ChebyshevUWeight, UltrasphericalWeight, LegendreWeight,
             WeightedUltraspherical, WeightedChebyshev, WeightedChebyshevT, WeightedChebyshevU, WeightedJacobi,
-            ∞, Derivative, .., Inclusion, chebyshevt, chebyshevu, legendre, jacobi, jacobimatrix, jacobiweight, legendreweight, chebyshevtweight, chebyshevuweight
+            ∞, Derivative, .., Inclusion, chebyshevt, chebyshevu, legendre, jacobi, legendrep, jacobip, jacobimatrix, jacobiweight, legendreweight, chebyshevtweight, chebyshevuweight
 
 
 include("interlace.jl")

src/chebyshev.jl

@@ -44,6 +44,19 @@ chebyshevt(d::AbstractInterval{T}) where T = ChebyshevT{float(T)}()[affine(d, Ch
 chebyshevu() = ChebyshevU()
 chebyshevu(d::AbstractInterval{T}) where T = ChebyshevU{float(T)}()[affine(d, ChebyshevInterval{T}()), :]
 
+"""
+     chebyshevt(n, z)
+
+computes the `n`-th Chebyshev polynomial of the first kind at `z`.
+"""
+chebyshevt(n::Integer, z::Number) = Base.unsafe_getindex(ChebyshevT{typeof(z)}(), z, n+1)
+"""
+     chebyshevt(n, z)
+
+computes the `n`-th Chebyshev polynomial of the second kind at `z`.
+"""
+chebyshevu(n::Integer, z::Number) = Base.unsafe_getindex(ChebyshevU{typeof(z)}(), z, n+1)
+
 chebysevtweight(d::AbstractInterval{T}) where T = ChebyshevTWeight{float(T)}[affine(d,ChebyshevInterval{T}())]
 chebysevuweight(d::AbstractInterval{T}) where T = ChebyshevUWeight{float(T)}[affine(d,ChebyshevInterval{T}())]
 

src/jacobi.jl

@@ -93,6 +93,14 @@ Legendre() = Legendre{Float64}()
 legendre() = Legendre()
 legendre(d::AbstractInterval{T}) where T = Legendre{float(T)}()[affine(d,ChebyshevInterval{T}()), :]
 
+"""
+     legendrep(n, z)
+
+computes the `n`-th Legendre polynomial at `z`.
+"""
+legendrep(n::Integer, z::Number) = Base.unsafe_getindex(Legendre{typeof(z)}(), z, n+1)
+
+
 ==(::Legendre, ::Legendre) = true
 
 OrthogonalPolynomial(w::LegendreWeight{T}) where {T} = Legendre{T}()
@@ -116,6 +124,14 @@ jacobi(a,b, d::AbstractInterval{T}) where T = Jacobi(a,b)[affine(d,ChebyshevInte
 
 Jacobi(P::Legendre{T}) where T = Jacobi(zero(T), zero(T))
 
+"""
+     jacobip(n, a, b, z)
+
+computes the `n`-th Jacobi polynomial, orthogonal with 
+respec to `(1-x)^a*(1+x)^b`, at `z`.
+"""
+jacobip(n::Integer, a, b, z::Number) = Base.unsafe_getindex(Jacobi{promote_type(typeof(a), typeof(b), typeof(z))}(a,b), z, n+1)
+
 OrthogonalPolynomial(w::JacobiWeight) = Jacobi(w.a, w.b)
 orthogonalityweight(P::Jacobi) = JacobiWeight(P.a, P.b)
 

src/ultraspherical.jl

@@ -40,6 +40,8 @@ WeightedUltraspherical(λ) = UltrasphericalWeight(λ) .* Ultraspherical(λ)
 WeightedUltraspherical{T}(λ) where T = UltrasphericalWeight{T}(λ) .* Ultraspherical{T}(λ)
 
 
+ultrasphericalp(n::Integer, λ, z::Number) = Base.unsafe_getindex(Ultraspherical{promote_type(typeof(λ),typeof(z))}(λ), z, n+1
+
 ==(a::Ultraspherical, b::Ultraspherical) = a.λ == b.λ
 ==(::Ultraspherical, ::ChebyshevT) = false
 ==(::ChebyshevT, ::Ultraspherical) = false

test/test_chebyshev.jl

@@ -319,6 +319,16 @@ import ContinuumArrays: MappedWeightedBasisLayout, Map
         @test Base.BroadcastStyle(typeof(v)) isa LazyArrays.LazyArrayStyle{1}
         @test (v./v)[1:10] == ones(10)
     end
+
+    @testset "special syntax" begin
+        @test chebyshevt.(0:5, 0.1) == ChebyshevT()[0.1, 1:6]
+        @test chebyshevt.(0:5, BigFloat(1)/10) == ChebyshevT{BigFloat}()[BigFloat(1)/10, 1:6]
+        @test chebyshevt.(0:5, 2) == Base.unsafe_getindex(ChebyshevT(), 2, 1:6)
+
+        @test chebyshevu.(0:5, 0.1) == ChebyshevU()[0.1, 1:6]
+        @test chebyshevu.(0:5, BigFloat(1)/10) == ChebyshevU{BigFloat}()[BigFloat(1)/10, 1:6]
+        @test chebyshevu.(0:5, 2) == Base.unsafe_getindex(ChebyshevU(), 2, 1:6)
+    end
 end
 
 struct QuadraticMap{T} <: Map{T} end

test/test_jacobi.jl

@@ -338,4 +338,8 @@ import ClassicalOrthogonalPolynomials: recurrencecoefficients, basis, MulQuasiMa
             @test (x-y) * P[x,1:n]'Mi[1:n,1:n]*Base.unsafe_getindex(P,y,1:n) ≈ P[x,n:n+1]' * [0 -β; β 0] * Base.unsafe_getindex(P,y,n:n+1)
         end
     end
+
+    @testset "special syntax" begin
+        @test jacobip.(0:5, 0.1, 0.2, 0.3) == Jacobi(0.1, 0.2)[0.3, 1:6]
+    end
 end

test/test_legendre.jl

@@ -129,4 +129,8 @@ import QuasiArrays: MulQuasiArray
         β = X[n,n+1]*Mi[n+1,n+1]
         @test (x-y) * P[x,1:n]'Mi[1:n,1:n]*P[y,1:n] ≈ P[x,n:n+1]' * [0 -β; β 0] * P[y,n:n+1]
     end
+
+    @testset "special syntax" begin
+        @test legendrep.(0:5, 0.3) == Legendre()[0.3, 1:6]
+    end
 end

test/test_ultraspherical.jl

@@ -82,4 +82,7 @@ using ClassicalOrthogonalPolynomials, BandedMatrices, LazyArrays, Test
         @test @inferred(C[0.1,Base.OneTo(3)]) == [1.0,0.4,-1.88]
     end
 
+    @testset "special syntax" begin
+        @test ultrasphericalp.(0:5, 2, 0.3) == Ultraspherical(2)[0.3, 1:6]
+    end
 end