increase cov

Author: dlfivefifty

src/ClassicalOrthogonalPolynomials.jl

@@ -213,10 +213,6 @@ singularities(w) = singularities_layout(MemoryLayout(w), w)
 
 struct NoSingularities end
 
-singularitiesview(w, ::Inclusion) = w # for now just assume it doesn't change
-singularitiesview(w, ind) = view(w, ind)
-singularitiesview(::NoSingularities, ind) = NoSingularities()
-singularitiesview(::NoSingularities, ::Inclusion) = NoSingularities()
 
 
 basis_axes(ax::Inclusion{<:Any,<:AbstractInterval}, v) = convert(AbstractQuasiMatrix{eltype(v)}, basis_singularities(ax, singularities(v)))

src/classical/chebyshev.jl

@@ -49,10 +49,12 @@ broadcasted(::LazyQuasiArrayStyle{2}, ::typeof(*), ::ChebyshevWeight{kind,T}, ::
 
 chebyshevt() = ChebyshevT()
 chebyshevt(d::AbstractInterval{T}) where T = ChebyshevT{float(T)}()[affine(d, ChebyshevInterval{T}()), :]
+chebyshevt(d::ChebyshevInterval{T}) where T = ChebyshevT{float(T)}()
 chebyshevt(d::Inclusion) = chebyshevt(d.domain)
 chebyshevt(S::AbstractQuasiMatrix) = chebyshevt(axes(S,1))
 chebyshevu() = ChebyshevU()
 chebyshevu(d::AbstractInterval{T}) where T = ChebyshevU{float(T)}()[affine(d, ChebyshevInterval{T}()), :]
+chebyshevu(d::ChebyshevInterval{T}) where T = ChebyshevU{float(T)}()
 chebyshevu(d::Inclusion) = chebyshevu(d.domain)
 chebyshevu(S::AbstractQuasiMatrix) = chebyshevu(axes(S,1))
 

src/classical/jacobi.jl

@@ -103,7 +103,6 @@ for op in (:+, :*)
     @eval singularitiesbroadcast(::typeof($op), ::NoSingularities, ::NoSingularities, ::NoSingularities) = NoSingularities()
 end
 
-singularitiesbroadcast(::typeof(*), V::SubQuasiArray...) = singularitiesbroadcast(*, map(parent,V)...)[parentindices(V...)...]
 singularitiesbroadcast(::typeof(*), ::NoSingularities, b) = b
 singularitiesbroadcast(::typeof(*), a, ::NoSingularities) = a
 

src/classical/ultraspherical.jl

@@ -56,6 +56,7 @@ orthogonalityweight(C::Ultraspherical) = UltrasphericalWeight(C.λ)
 
 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}()), :]
+ultraspherical(λ, d::ChebyshevInterval{T}) where T = Ultraspherical{float(promote_type(eltype(λ),T))}(λ)
 
 ==(a::Ultraspherical, b::Ultraspherical) = a.λ == b.λ
 ==(::Ultraspherical, ::ChebyshevT) = false

test/test_chebyshev.jl

@@ -582,6 +582,11 @@ import BandedMatrices: isbanded
     @testset "diff of truncation" begin
         @test MemoryLayout(diff(ChebyshevT()[:,1:5]) * randn(5)) isa ExpansionLayout
     end
+
+    @testset "ChebyshevInterval constructior" begin
+        @test chebyshevt(ChebyshevInterval()) ≡ ChebyshevT()
+        @test chebyshevu(ChebyshevInterval()) ≡ ChebyshevU()
+    end
 end
 
 struct QuadraticMap{T} <: Map{T} end

test/test_jacobi.jl

@@ -557,4 +557,8 @@ import ClassicalOrthogonalPolynomials: recurrencecoefficients, basis, MulQuasiMa
         @test singularities(JacobiWeight(1,2) .* Jacobi(2,3)) == JacobiWeight(1,2)
         @test singularities(jacobiweight(1,2,1..2) .* jacobi(2,3,1..2)) == singularities(view(JacobiWeight(1,2) .* Jacobi(2,3), affine(1..2, -1..1),:)) == jacobiweight(1,2,1..2) 
     end
+
+    @testset "ChebyshevInterval constructior" begin
+        @test jacobi(1,2,ChebyshevInterval()) ≡ Jacobi(1,2)
+    end
 end

test/test_legendre.jl

@@ -222,4 +222,7 @@ import QuasiArrays: MulQuasiArray
     @testset "fill" begin
         @test basis(expand(fill(2, Inclusion(1..2)))) == legendre(1..2)
     end
+    @testset "ChebyshevInterval constructior" begin
+        @test legendre(ChebyshevInterval()) ≡ Legendre()
+    end
 end

test/test_ultraspherical.jl

@@ -204,4 +204,7 @@ using ClassicalOrthogonalPolynomials: grammatrix
         @test (C \ diff(U,1))[1:10,1:10] == (C \ diff(U))[1:10,1:10]
         @test (C³ \ diff(U,2))[1:10,1:10] == (C³ \ diff(diff(U)))[1:10,1:10]
     end
+    @testset "ChebyshevInterval constructior" begin
+        @test ultraspherical(2,ChebyshevInterval()) ≡ Ultraspherical(2)
+    end
 end