Add normalized OP functions

Project.toml

@@ -1,7 +1,7 @@
 name = "ClassicalOrthogonalPolynomials"
 uuid = "b30e2e7b-c4ee-47da-9d5f-2c5c27239acd"
 authors = ["Sheehan Olver <[email protected]>"]
-version = "0.15"
+version = "0.15.1"
 
 
 [deps]

src/ClassicalOrthogonalPolynomials.jl

@@ -54,7 +54,8 @@ export OrthogonalPolynomial, Normalized, LanczosPolynomial,
             WeightedUltraspherical, WeightedChebyshev, WeightedChebyshevT, WeightedChebyshevU, WeightedJacobi,
             ∞, Derivative, .., Inclusion,
             chebyshevt, chebyshevu, legendre, jacobi, ultraspherical,
-            legendrep, jacobip, ultrasphericalc, laguerrel,hermiteh, normalizedjacobip,
+            legendrep, jacobip, ultrasphericalc, laguerrel,hermiteh,
+            normalizedlegendrep, normalizedjacobip, normalizedultrasphericalc, normalizedlaguerrel, normalizedhermiteh,
             jacobimatrix, jacobiweight, legendreweight, chebyshevtweight, chebyshevuweight, Weighted, PiecewiseInterlace, plan_transform,
             expand, transform
 

src/classical/hermite.jl

@@ -48,6 +48,14 @@
 """
 hermiteh(n::Integer, z) = Base.unsafe_getindex(Hermite{polynomialtype(typeof(z))}(), z, n+1)
 
+"""
+     normalizedhermiteh(n, z)
+
+computes the normalized `n`-th Hermite polynomial, orthogonal with 
+respec to `exp(-x^2)`, at `z`.
+"""
+normalizedhermiteh(n::Integer, z) = Base.unsafe_getindex(Normalized(Hermite{polynomialtype(typeof(z))}()), z, n+1)
+
 broadcasted(::LazyQuasiArrayStyle{2}, ::typeof(*), ::HermiteWeight{T}, ::Hermite{V}) where {T,V} = Weighted(Hermite{promote_type(T,V)}())
 
 # H_{n+1} = 2x H_n - 2n H_{n-1}

src/classical/laguerre.jl

@@ -55,6 +55,22 @@
 """
 laguerrel(n::Integer, z::Number) = laguerrel(n, 0, z)
 
+"""
+     normalizedlaguerrel(n, α, z)
+
+computes the normalized `n`-th generalized Laguerre polynomial, orthogonal with 
+respec to `x^α * exp(-x)`, at `z`.
+"""
+normalizedlaguerrel(n::Integer, α, z::Number) = Base.unsafe_getindex(Normalized(Laguerre{polynomialtype(typeof(α), typeof(z))}(α)), z, n+1)
+
+"""
+     normalizedlaguerrel(n, z)
+
+computes the normalized `n`-th Laguerre polynomial, orthogonal with 
+respec to `exp(-x)`, at `z`.
+"""
+normalizedlaguerrel(n::Integer, z::Number) = normalizedlaguerrel(n, 0, z)
+
 
 # L_{n+1} = (-1/(n+1) x + (2n+α+1)/(n+1)) L_n - (n+α)/(n+1) L_{n-1}
 # - (n+α) L_{n-1} + (2n+α+1)* L_n -(n+1) L_{n+1} = x  L_n

src/classical/legendre.jl

@@ -167,6 +167,15 @@
 """
 legendrep(n::Integer, z) = Base.unsafe_getindex(Legendre{typeof(z)}(), z, n+1)
 
+"""
+     normalizedlegendrep(n, z)
+
+computes the normalized `n`-th Legendre polynomial at `z`.
+"""
+normalizedlegendrep(n::Integer, z) = Base.unsafe_getindex(Normalized(Legendre{typeof(z)}()), z, n+1)
+
+
+
 
 show(io::IO, w::Legendre{Float64}) = summary(io, w)
 summary(io::IO, ::Legendre{Float64}) = print(io, "Legendre()")

src/classical/ultraspherical.jl

@@ -54,6 +54,7 @@
 
 orthogonalityweight(C::Ultraspherical) = UltrasphericalWeight(C.λ)
 
+normalizedultrasphericalc(n::Integer, λ, z) = Base.unsafe_getindex(Normalized(Ultraspherical{polynomialtype(typeof(λ),typeof(z))}(λ)), z, n+1)
 ultrasphericalc(n::Integer, λ, z) = Base.unsafe_getindex(Ultraspherical{polynomialtype(typeof(λ),typeof(z))}(λ), z, n+1)
 ultraspherical(λ, d::AbstractInterval{T}) where T = Ultraspherical{float(promote_type(eltype(λ),T))}(λ)[affine(d,ChebyshevInterval{T}()), :]