Define Normalized type aliases (#175)

Author: jishnub

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunOrthogonalPolynomials"
 uuid = "b70543e2-c0d9-56b8-a290-0d4d6d4de211"
-version = "0.6.4"
+version = "0.6.5"
 
 [deps]
 ApproxFunBase = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"

src/Spaces/Chebyshev/Chebyshev.jl

@@ -22,6 +22,7 @@ end
 Chebyshev(d::Domain) = Chebyshev{typeof(d),real(prectype(d))}(d)
 Chebyshev() = Chebyshev(ChebyshevInterval())
 Chebyshev(d) = Chebyshev(Domain(d))
+const NormalizedChebyshev{D<:Domain,R} = NormalizedPolynomialSpace{Chebyshev{D, R}, D, R}
 NormalizedChebyshev() = NormalizedPolynomialSpace(Chebyshev())
 NormalizedChebyshev(d) = NormalizedPolynomialSpace(Chebyshev(d))
 

src/Spaces/Hermite/Hermite.jl

@@ -11,6 +11,7 @@ struct Hermite{T} <: PolynomialSpace{Line{false,Float64},Float64}
 end
 Hermite() = Hermite(1.0)
 
+const NormalizedHermite{T} = NormalizedPolynomialSpace{Hermite{T},Line{false,Float64},Float64}
 NormalizedHermite() = NormalizedPolynomialSpace(Hermite())
 NormalizedHermite(L) = NormalizedPolynomialSpace(Hermite(L))
 

src/Spaces/Jacobi/Jacobi.jl

@@ -21,6 +21,7 @@ Jacobi(b,a) = Jacobi(b,a,ChebyshevInterval())
 Jacobi(A::Ultraspherical) = Jacobi(order(A)-0.5,order(A)-0.5,domain(A))
 Jacobi(A::Chebyshev) = Jacobi(-0.5,-0.5,domain(A))
 
+const NormalizedJacobi{D<:Domain,R,T} = NormalizedPolynomialSpace{Jacobi{D,R,T},D,R}
 NormalizedJacobi(s...) = NormalizedPolynomialSpace(Jacobi(s...))
 NormalizedLegendre(d...) = NormalizedPolynomialSpace(Legendre(d...))
 
@@ -46,9 +47,8 @@ convert(::Type{Jacobi{D,R1,T1}},J::Jacobi{D,R2,T2}) where {D,R1,R2,T1,T2} =
 
 spacescompatible(a::Jacobi,b::Jacobi) = a.a ≈ b.a && a.b ≈ b.b && domainscompatible(a,b)
 
-isapproxinteger_addhalf(a) = isapproxinteger(a+0.5)
+isapproxinteger_addhalf(a) = !isapproxinteger(a) && isapproxinteger(a+0.5)
 isapproxinteger_addhalf(::Integer) = false
-isapproxinteger_addhalf(@nospecialize ::StaticInt) = false
 function canonicalspace(S::Jacobi)
     if isapproxinteger_addhalf(S.a) && isapproxinteger_addhalf(S.b)
         Chebyshev(domain(S))

src/Spaces/Jacobi/JacobiOperators.jl

@@ -143,19 +143,19 @@ function Conversion(L::Jacobi,M::Jacobi)
         dm=domain(M)
         if isapprox(M.a,L.a) && isapprox(M.b,L.b)
             ConversionWrapper(Operator(I,L))
-        elseif (isapprox(M.b,L.b+static(1)) && isapprox(M.a,L.a)) ||
-            (isapprox(M.b,L.b) && isapprox(M.a,L.a+static(1)))
+        elseif (isapprox(M.b,L.b+1) && isapprox(M.a,L.a)) ||
+            (isapprox(M.b,L.b) && isapprox(M.a,L.a+1))
             ConcreteConversion(L,M)
-        elseif M.b > L.b+static(1)
+        elseif M.b > L.b+1
             ConversionWrapper(
                 TimesOperator(
-                    Conversion(Jacobi(M.b-static(1),M.a,dm),M),
-                    Conversion(L,Jacobi(M.b-static(1),M.a,dm))))
+                    Conversion(Jacobi(M.b-1,M.a,dm),M),
+                    Conversion(L,Jacobi(M.b-1,M.a,dm))))
         else  #if M.a >= L.a+1
             ConversionWrapper(
                 TimesOperator(
-                    Conversion(Jacobi(M.b,M.a-static(1),dm),M),
-                    Conversion(L,Jacobi(M.b,M.a-static(1),dm))))
+                    Conversion(Jacobi(M.b,M.a-1,dm),M),
+                    Conversion(L,Jacobi(M.b,M.a-1,dm))))
         end
     elseif L.a ≈ L.b ≈ 0 && M.a ≈ M.b ≈ 0.5
         Conversion(L,Ultraspherical(L),Ultraspherical(M),M)
@@ -225,7 +225,6 @@ end
 
 isequalminhalf(x) = x == -0.5
 isequalminhalf(@nospecialize ::Integer) = false
-isequalminhalf(@nospecialize ::StaticInt) = false
 
 function Conversion(A::Jacobi,B::Chebyshev)
     if isequalminhalf(A.a) && isequalminhalf(A.b)
@@ -408,7 +407,6 @@ end
 
 isapproxminhalf(a) = a ≈ -0.5
 isapproxminhalf(::Integer) = false
-isapproxminhalf(@nospecialize ::StaticInt) = false
 
 function union_rule(A::Jacobi,B::Jacobi)
     if domainscompatible(A,B)

src/Spaces/Laguerre/Laguerre.jl

@@ -31,6 +31,7 @@ end
 Laguerre(α) = Laguerre(α,Ray())
 Laguerre() = Laguerre(0)
 
+const NormalizedLaguerre{T<:Real,D<:Ray} = NormalizedPolynomialSpace{Laguerre{T,D},D,T}
 NormalizedLaguerre(α) = NormalizedPolynomialSpace(Laguerre(α))
 NormalizedLaguerre() = NormalizedLaguerre(0)
 

src/Spaces/Ultraspherical/Ultraspherical.jl

@@ -25,6 +25,7 @@ end
 Ultraspherical(m::Number,d::Domain) = Ultraspherical{typeof(m),typeof(d),real(prectype(d))}(m,d)
 Ultraspherical(m::Number,d) = Ultraspherical(m,Domain(d))
 Ultraspherical(m::Number) = Ultraspherical(m,ChebyshevInterval())
+const NormalizedUltraspherical{T,D<:Domain,R} = NormalizedPolynomialSpace{Ultraspherical{T,D,R},D,R}
 NormalizedUltraspherical(m) = NormalizedPolynomialSpace(Ultraspherical(m))
 NormalizedUltraspherical(m,d) = NormalizedPolynomialSpace(Ultraspherical(m,d))
 

test/ChebyshevTest.jl

@@ -253,6 +253,7 @@ using ApproxFunOrthogonalPolynomials: forwardrecurrence
     end
 
     @testset "Normalized space" begin
+        @test NormalizedChebyshev() isa NormalizedChebyshev
         for f in (x -> 3x^3 + 5x^2 + 2, x->x, identity)
             for dt in ((), (0..1,))
                 S = Chebyshev(dt...)

test/JacobiTest.jl

@@ -447,6 +447,7 @@ using Static
     end
 
     @testset "Normalized space" begin
+        @test NormalizedJacobi(1,1) isa NormalizedJacobi
         for f in Any[x -> 3x^3 + 5x^2 + 2, x->x, identity]
             for dt in Any[(), (0..1,)],
                     S in Any[Jacobi(1,1,dt...),

test/UltrasphericalTest.jl

@@ -43,6 +43,7 @@ using LinearAlgebra
     end
 
     @testset "Normalized space" begin
+        @test NormalizedUltraspherical(1) isa NormalizedUltraspherical
         for f in (x -> 3x^3 + 5x^2 + 2, x->x, identity)
             for dt in ((), (0..1,)),
                     S in (Ultraspherical(1, dt...),