type assertion in convert (#87)

jishnub · web-flow · commit bb345cbe8683 · 2022-08-14T18:41:12.000+04:00
diff --git a/src/ApproxFunOrthogonalPolynomials.jl b/src/ApproxFunOrthogonalPolynomials.jl
@@ -97,6 +97,8 @@ points(d::IntervalOrSegmentDomain{T},n::Integer) where {T} =
     fromcanonical.(Ref(d), chebyshevpoints(float(real(eltype(T))), n))  # eltype to handle point
 bary(v::AbstractVector{Float64},d::IntervalOrSegmentDomain,x::Float64) = bary(v,tocanonical(d,x))
 
+strictconvert(T::Type, x) = convert(T, x)::T
+
 include("bary.jl")
 
 
diff --git a/src/Domains/Arc.jl b/src/Domains/Arc.jl
@@ -16,7 +16,7 @@ struct Arc{T,V<:Real,TT} <: SegmentDomain{TT}
     center::T
     radius::V
     angles::Tuple{V,V}
-    Arc{T,V,TT}(c,r,a) where {T,V,TT} = new{T,V,TT}(convert(T,c),convert(V,r),Tuple{V,V}(a))
+    Arc{T,V,TT}(c,r,a) where {T,V,TT} = new{T,V,TT}(strictconvert(T,c),strictconvert(V,r),Tuple{V,V}(a))
 end
 
 
diff --git a/src/Domains/Ray.jl b/src/Domains/Ray.jl
@@ -45,7 +45,7 @@ function convert(::Type{Ray}, d::AbstractInterval)
         Ray(b,angle(a),one(typeof(a)),false)
     end
 end
-Ray(d::AbstractInterval) = convert(Ray, d)
+Ray(d::AbstractInterval) = strictconvert(Ray, d)
 
 
 isambiguous(d::Ray)=isnan(d.center)
diff --git a/src/Spaces/Chebyshev/Chebyshev.jl b/src/Spaces/Chebyshev/Chebyshev.jl
@@ -16,7 +16,7 @@ struct Chebyshev{D<:Domain,R} <: PolynomialSpace{D,R}
         isempty(d) && throw(ArgumentError("Domain cannot be empty"))
         new(d)
     end
-    Chebyshev{D,R}() where {D,R} = new(convert(D, ChebyshevInterval()))
+    Chebyshev{D,R}() where {D,R} = new(strictconvert(D, ChebyshevInterval()))
 end
 
 Chebyshev(d::Domain) = Chebyshev{typeof(d),real(prectype(d))}(d)
diff --git a/src/Spaces/Chebyshev/ChebyshevOperators.jl b/src/Spaces/Chebyshev/ChebyshevOperators.jl
@@ -65,7 +65,7 @@ function getindex(op::ConcreteEvaluation{<:Chebyshev{DD,RR},typeof(leftendpoint)
     x = op.x
     d = domain(op)
     p = op.order
-    cst = convert(T,(2/complexlength(d))^p)
+    cst = strictconvert(T,(2/complexlength(d))^p)
     n=length(k)
 
     ret = Array{T}(undef, n)
@@ -79,7 +79,7 @@ function getindex(op::ConcreteEvaluation{<:Chebyshev{DD,RR},typeof(leftendpoint)
         @simd for j=k
             @inbounds ret[j+k1] *= (j-1)^2-m^2
         end
-        scal!(convert(T,1/(2m+1)), ret)
+        scal!(strictconvert(T,1/(2m+1)), ret)
     end
 
     scal!(cst,ret)
@@ -91,7 +91,7 @@ function getindex(op::ConcreteEvaluation{<:Chebyshev{DD,RR},typeof(rightendpoint
     x = op.x
     d = domain(op)
     p = op.order
-    cst = convert(T,(2/complexlength(d))^p)
+    cst = strictconvert(T,(2/complexlength(d))^p)
     n=length(k)
 
     ret = fill(one(T),n)
@@ -101,7 +101,7 @@ function getindex(op::ConcreteEvaluation{<:Chebyshev{DD,RR},typeof(rightendpoint
         @simd for j=k
             @inbounds ret[j+k1] *= (j-1)^2-m^2
         end
-        scal!(convert(T,1/(2m+1)), ret)
+        scal!(strictconvert(T,1/(2m+1)), ret)
     end
 
     scal!(cst,ret)
@@ -110,7 +110,7 @@ end
 function getindex(op::ConcreteEvaluation{Chebyshev{DD,RR},M,OT,T},
                 j::Integer) where {DD<:IntervalOrSegment,RR,M<:Real,OT,T}
     if op.order == 0
-        convert(T,evaluatechebyshev(j,tocanonical(domain(op),op.x))[end])
+        strictconvert(T,evaluatechebyshev(j,tocanonical(domain(op),op.x))[end])
     else
         error("Only zero–second order implemented")
     end
@@ -223,8 +223,8 @@ function getindex(D::ConcreteDerivative{Chebyshev{DD,RR},K,T},k::Integer,j::Inte
     d=domain(D)
 
     if j==k+m
-        C=convert(T,pochhammer(one(T),m-1)/2*(4/complexlength(d))^m)
-        convert(T,C*(m+k-one(T)))
+        C=strictconvert(T,pochhammer(one(T),m-1)/2*(4/complexlength(d))^m)
+        strictconvert(T,C*(m+k-one(T)))
     else
         zero(T)
     end
@@ -238,14 +238,14 @@ linesum(f::Fun{Chebyshev{DD,RR}}) where {DD<:IntervalOrSegment,RR} =
 ## Clenshaw-Curtis functional
 
 for (Func,Len) in ((:DefiniteIntegral,:complexlength),(:DefiniteLineIntegral,:arclength))
-    ConcFunc = Meta.parse("Concrete"*string(Func))
+    ConcFunc = Symbol(:Concrete, Func)
     @eval begin
         $Func(S::Chebyshev{D}) where {D<:IntervalOrSegment} = $ConcFunc(S)
         function getindex(Σ::$ConcFunc{Chebyshev{D,R},T},k::Integer) where {D<:IntervalOrSegment,R,T}
             d = domain(Σ)
             C = $Len(d)/2
 
-            isodd(k) ? convert(T,2C/(k*(2-k))) : zero(T)
+            isodd(k) ? strictconvert(T,2C/(k*(2-k))) : zero(T)
         end
     end
 end
diff --git a/src/Spaces/CurveSpace.jl b/src/Spaces/CurveSpace.jl
@@ -24,7 +24,7 @@ export Bernstein, Bézier
 struct Bernstein{order,D,R} <: Space{D,R}
     domain::D
     Bernstein{order,D,R}(d) where {order,D,R} = new(d)
-    Bernstein{order,D,R}() where {order,D,R} = new(convert(D, ChebyshevInterval()))
+    Bernstein{order,D,R}() where {order,D,R} = new(strictconvert(D, ChebyshevInterval()))
 end
 
 const Bézier = Bernstein # option+e e gives é
diff --git a/src/Spaces/Hermite/Hermite.jl b/src/Spaces/Hermite/Hermite.jl
@@ -103,7 +103,7 @@ weight(H::GaussWeight,x) = exp(-H.L * x^2)
 
 function Base.sum(f::Fun{GaussWeight{H,T}}) where {H<:Hermite,T}
     @assert space(f).space.L==space(f).L  # only implemented with matching weight
-    f.coefficients[1]*sqrt(convert(T,π))/sqrt(space(f).L)
+    f.coefficients[1]*sqrt(strictconvert(T,π))/sqrt(space(f).L)
 end
 
 include("hermitetransform.jl")
diff --git a/src/Spaces/Jacobi/JacobiOperators.jl b/src/Spaces/Jacobi/JacobiOperators.jl
@@ -35,7 +35,7 @@ function getindex(op::ConcreteEvaluation{<:Jacobi,typeof(leftendpoint)},kr::Abst
     sp=op.space
     T=eltype(op)
     RT=real(T)
-    a=convert(RT,sp.a);b=convert(RT,sp.b)
+    a=strictconvert(RT,sp.a);b=strictconvert(RT,sp.b)
 
     if op.order == 0
         jacobip(T,kr.-1,a,b,-one(T))
@@ -67,7 +67,7 @@ function getindex(op::ConcreteEvaluation{<:Jacobi,typeof(rightendpoint)},kr::Abs
     sp=op.space
     T=eltype(op)
     RT=real(T)
-    a=convert(RT,sp.a);b=convert(RT,sp.b)
+    a=strictconvert(RT,sp.a);b=strictconvert(RT,sp.b)
 
 
     if op.order == 0
@@ -169,7 +169,7 @@ end
 
 
 for (Func,Len,Sum) in ((:DefiniteIntegral,:complexlength,:sum),(:DefiniteLineIntegral,:arclength,:linesum))
-    ConcFunc = Meta.parse("Concrete"*string(Func))
+    ConcFunc = Symbol(:Concrete, Func)
 
     @eval begin
         $Func(S::Jacobi{<:IntervalOrSegment}) = $ConcFunc(S)
@@ -179,9 +179,9 @@ for (Func,Len,Sum) in ((:DefiniteIntegral,:complexlength,:sum),(:DefiniteLineInt
 
             if dsp.b == dsp.a == 0
                 # TODO: copy and paste
-                k == 1 ? convert(T,$Sum(Fun(dsp,[one(T)]))) : zero(T)
+                k == 1 ? strictconvert(T,$Sum(Fun(dsp,[one(T)]))) : zero(T)
             else
-                convert(T,$Sum(Fun(dsp,[zeros(T,k-1);1])))
+                strictconvert(T,$Sum(Fun(dsp,[zeros(T,k-1);1])))
             end
         end
 
@@ -239,17 +239,17 @@ function Base.getindex(C::ConcreteConversion{J1,J2,T},k::Integer,j::Integer) whe
     L=C.domainspace
     if L.b+1==C.rangespace.b
         if j==k
-            k==1 ? convert(T,1) : convert(T,(L.a+L.b+k)/(L.a+L.b+2k-1))
+            k==1 ? strictconvert(T,1) : strictconvert(T,(L.a+L.b+k)/(L.a+L.b+2k-1))
         elseif j==k+1
-            convert(T,(L.a+k)./(L.a+L.b+2k+1))
+            strictconvert(T,(L.a+k)./(L.a+L.b+2k+1))
         else
             zero(T)
         end
     elseif L.a+1==C.rangespace.a
         if j==k
-            k==1 ? convert(T,1) : convert(T,(L.a+L.b+k)/(L.a+L.b+2k-1))
+            k==1 ? strictconvert(T,1) : strictconvert(T,(L.a+L.b+k)/(L.a+L.b+2k-1))
         elseif j==k+1
-            convert(T,-(L.b+k)./(L.a+L.b+2k+1))
+            strictconvert(T,-(L.b+k)./(L.a+L.b+2k+1))
         else
             zero(T)
         end
@@ -416,7 +416,7 @@ function getindex(C::ConcreteConversion{US,J,T},k::Integer,j::Integer) where {US
     if j==k
         S=rangespace(C)
         jp=jacobip(T,k-1,S.a,S.b,one(T))
-        um=convert(Operator{T}, Evaluation(setcanonicaldomain(domainspace(C)),rightendpoint,0))[k]::T
+        um=strictconvert(Operator{T}, Evaluation(setcanonicaldomain(domainspace(C)),rightendpoint,0))[k]::T
         (um/jp)::T
     else
         zero(T)
diff --git a/src/Spaces/Jacobi/jacobitransform.jl b/src/Spaces/Jacobi/jacobitransform.jl
@@ -40,15 +40,15 @@ end
 
 function coefficients(f::AbstractVector{T}, a::Jacobi, b::Chebyshev) where T
     if domain(a) == domain(b) && (!isapproxinteger(a.a-0.5) || !isapproxinteger(a.b-0.5))
-        jac2cheb(f, convert(T,a.a), convert(T,a.b))
+        jac2cheb(f, strictconvert(T,a.a), strictconvert(T,a.b))
     else
         defaultcoefficients(f,a,b)
     end
 end
 function coefficients(f::AbstractVector{T}, a::Chebyshev, b::Jacobi) where T
     isempty(f) && return f
     if domain(a) == domain(b) && (!isapproxinteger(b.a-0.5) || !isapproxinteger(b.b-0.5))
-        cheb2jac(f, convert(T,b.a), convert(T,b.b))
+        cheb2jac(f, strictconvert(T,b.a), strictconvert(T,b.b))
     else
         defaultcoefficients(f,a,b)
     end
diff --git a/src/Spaces/Laguerre/Laguerre.jl b/src/Spaces/Laguerre/Laguerre.jl
@@ -43,14 +43,14 @@ tocanonical(d::Laguerre,x) = mappoint(domain(d),Ray(),x)
 fromcanonical(d::Laguerre,x) = mappoint(Ray(),domain(d),x)
 
 
-@inline laguerrerecα(::Type{T},α,k) where {T} = convert(T,2k+α-1)
-@inline laguerrerecβ(::Type{T},_,k) where {T} = convert(T,-k)
-@inline laguerrerecγ(::Type{T},α,k) where {T} = convert(T,-(k-1+α))
+@inline laguerrerecα(::Type{T},α,k) where {T} = strictconvert(T,2k+α-1)
+@inline laguerrerecβ(::Type{T},_,k) where {T} = strictconvert(T,-k)
+@inline laguerrerecγ(::Type{T},α,k) where {T} = strictconvert(T,-(k-1+α))
 
 
-@inline laguerrerecA(::Type{T},_,k) where {T} = convert(T,-1/(k+1))
-@inline laguerrerecB(::Type{T},α,k) where {T} = convert(T,(2k+α+1)/(k+1))
-@inline laguerrerecC(::Type{T},α,k) where {T} = convert(T,(k+α)/(k+1))
+@inline laguerrerecA(::Type{T},_,k) where {T} = strictconvert(T,-1/(k+1))
+@inline laguerrerecB(::Type{T},α,k) where {T} = strictconvert(T,(2k+α+1)/(k+1))
+@inline laguerrerecC(::Type{T},α,k) where {T} = strictconvert(T,(k+α)/(k+1))
 
 for (REC,JREC) in ((:recα,:laguerrerecα),(:recβ,:laguerrerecβ),(:recγ,:laguerrerecγ),
                    (:recA,:laguerrerecA),(:recB,:laguerrerecB),(:recC,:laguerrerecC))
diff --git a/src/Spaces/PolynomialSpace.jl b/src/Spaces/PolynomialSpace.jl
@@ -90,7 +90,7 @@ struct JacobiZ{S<:Space,T} <: TridiagonalOperator{T}
 end
 
 JacobiZ(sp::PolynomialSpace,z) =
-    (T = promote_type(prectype(sp),typeof(z)); JacobiZ{typeof(sp),T}(sp,convert(T,z)))
+    (T = promote_type(prectype(sp),typeof(z)); JacobiZ{typeof(sp),T}(sp,strictconvert(T,z)))
 
 convert(::Type{Operator{T}},J::JacobiZ{S}) where {T,S} = JacobiZ{S,T}(J.space,J.z)
 
diff --git a/src/Spaces/Ultraspherical/ContinuousSpace.jl b/src/Spaces/Ultraspherical/ContinuousSpace.jl
@@ -411,7 +411,7 @@ function BlockBandedMatrix(S::SubOperator{T,<:ConcreteDirichlet{<:TensorChebyshe
 end
 
 
-union_rule(A::PiecewiseSpace, B::ContinuousSpace) = union(A, convert(PiecewiseSpace, B))
+union_rule(A::PiecewiseSpace, B::ContinuousSpace) = union(A, strictconvert(PiecewiseSpace, B))
 union_rule(A::ConstantSpace, B::ContinuousSpace) = B
 union_rule(A::ContinuousSpace, B::PolynomialSpace{<:IntervalOrSegment}) =
     Space(domain(A) ∪ domain(B))
diff --git a/src/Spaces/Ultraspherical/DirichletSpace.jl b/src/Spaces/Ultraspherical/DirichletSpace.jl
@@ -6,7 +6,7 @@ export ChebyshevDirichlet
 struct ChebyshevDirichlet{left,right,D,R} <: PolynomialSpace{D,R}
     domain::D
     ChebyshevDirichlet{left,right,D,R}(d) where {left,right,D,R} = new(d)
-    ChebyshevDirichlet{left,right,D,R}() where {left,right,D,R} = new(convert(D, ChebyshevInterval()))
+    ChebyshevDirichlet{left,right,D,R}() where {left,right,D,R} = new(strictconvert(D, ChebyshevInterval()))
 end
 
 for TYP in (:Number,:AbstractArray,:Vec,:Fun)
diff --git a/src/Spaces/Ultraspherical/Ultraspherical.jl b/src/Spaces/Ultraspherical/Ultraspherical.jl
@@ -18,9 +18,9 @@ struct Ultraspherical{T,D<:Domain,R} <: PolynomialSpace{D,R}
     order::T
     domain::D
     Ultraspherical{T,D,R}(m::T,d::D) where {T,D,R} = (@assert m ≠ 0; new(m,d))
-    Ultraspherical{T,D,R}(m::Number,d::Domain) where {T,D,R} = (@assert m ≠ 0; new(convert(T,m),convert(D,d)))
-    Ultraspherical{T,D,R}(d::Domain) where {T,D,R} = new(one(T),convert(D,d))
-    Ultraspherical{T,D,R}(m::Number) where {T,D,R} = (@assert m ≠ 0; new(convert(T,m),D()))
+    Ultraspherical{T,D,R}(m::Number,d::Domain) where {T,D,R} = (@assert m ≠ 0; new(strictconvert(T,m),strictconvert(D,d)))
+    Ultraspherical{T,D,R}(d::Domain) where {T,D,R} = new(one(T),strictconvert(D,d))
+    Ultraspherical{T,D,R}(m::Number) where {T,D,R} = (@assert m ≠ 0; new(strictconvert(T,m),D()))
 end
 
 Ultraspherical(m::Number,d::Domain) = Ultraspherical{typeof(m),typeof(d),real(prectype(d))}(m,d)
diff --git a/src/Spaces/Ultraspherical/UltrasphericalOperators.jl b/src/Spaces/Ultraspherical/UltrasphericalOperators.jl
@@ -79,7 +79,7 @@ function getindex(D::ConcreteDerivative{Ultraspherical{TT,DD,RR},K,T},
     λ=order(domainspace(D))
 
     if j==k+m
-        convert(T,(pochhammer(one(T)*λ,m)*(4/complexlength(d)).^m))
+        strictconvert(T,(pochhammer(one(T)*λ,m)*(4/complexlength(d)).^m))
     else
         zero(T)
     end
@@ -104,9 +104,9 @@ function getindex(Q::ConcreteIntegral{Ultraspherical{LT,DD,RR}},k::Integer,j::In
 
     if λ == 1 && k==j+1
         C = complexlength(d)/2
-        convert(T,C./(k-1))
+        strictconvert(T,C./(k-1))
     elseif λ > 1 && k==j+m
-        convert(T,pochhammer(one(T)*λ,-m)*(complexlength(d)/4)^m)
+        strictconvert(T,pochhammer(one(T)*λ,-m)*(complexlength(d)/4)^m)
     else
         zero(T)
     end
@@ -285,9 +285,9 @@ function getindex(M::ConcreteConversion{C,Ultraspherical{LT,DD,RR},T},
         if j==k==1
             one(T)
         elseif j==k
-            convert(T,sqrt(π)/(2FastTransforms.Λ(k-1)))
+            strictconvert(T,sqrt(π)/(2FastTransforms.Λ(k-1)))
         elseif k < j && iseven(k-j)
-            convert(T,-(j-1)*(k-0.5)*(FastTransforms.Λ((j-k-2)/2)/(j-k))*
+            strictconvert(T,-(j-1)*(k-0.5)*(FastTransforms.Λ((j-k-2)/2)/(j-k))*
                             (FastTransforms.Λ((j+k-3)/2)/(j+k-1)))
         else
             zero(T)
@@ -314,9 +314,9 @@ function getindex(M::ConcreteConversion{Ultraspherical{LT,DD,RR},C,T},
         end
     elseif λ == 0.5
         if k==1 && isodd(j)
-            convert(T,FastTransforms.Λ((j-1)/2)^2/π)
+            strictconvert(T,FastTransforms.Λ((j-1)/2)^2/π)
         elseif k ≤ j && iseven(k-j)
-            convert(T,FastTransforms.Λ((j-k)/2)*FastTransforms.Λ((k+j-2)/2)*2/π)
+            strictconvert(T,FastTransforms.Λ((j-k)/2)*FastTransforms.Λ((k+j-2)/2)*2/π)
         else
             zero(T)
         end
@@ -334,7 +334,7 @@ function getindex(M::ConcreteConversion{Ultraspherical{LT,DD,RR},
     λ2 = order(rangespace(M))
     if abs(λ1-λ2) < 1
         if j ≥ k && iseven(k-j)
-            convert(T,(λ1 < λ2 && k ≠ j ? -1 : 1) *  # fix sign for lgamma
+            strictconvert(T,(λ1 < λ2 && k ≠ j ? -1 : 1) *  # fix sign for lgamma
                 exp(lgamma(λ2)+log(k-1+λ2)-lgamma(λ1)-lgamma(λ1-λ2) + lgamma((j-k)/2+λ1-λ2)-
                 lgamma((j-k)/2+1)+lgamma((k+j-2)/2+λ1)-lgamma((k+j-2)/2+λ2+1)))
         else
diff --git a/src/fastops.jl b/src/fastops.jl
@@ -77,7 +77,7 @@ function BandedMatrix(S::SubOperator{T,ConcreteDerivative{Chebyshev{DD,RR},K,T},
     k = D.order
     d = domain(D)
 
-    C=convert(T,pochhammer(one(T),k-1)/2*(4/(complexlength(d)))^k)
+    C=strictconvert(T,pochhammer(one(T),k-1)/2*(4/(complexlength(d)))^k)
 
 
     # need to drop columns
@@ -103,7 +103,7 @@ function BandedMatrix(S::SubOperator{T,ConcreteDerivative{Ultraspherical{LT,DD,R
     λ = order(domainspace(D))
     d = domain(D)
 
-    C = convert(T,pochhammer(one(T)*λ,k)*(4/(complexlength(d)))^k)
+    C = strictconvert(T,pochhammer(one(T)*λ,k)*(4/(complexlength(d)))^k)
     ret[band(dg+k)] .= C
 
     ret
diff --git a/src/roots.jl b/src/roots.jl
@@ -81,7 +81,7 @@ for (BF,FF) in ((BigFloat,Float64),(Complex{BigFloat},ComplexF64))
         htol = eps(2000.)*max(hscale, 1)  # TODO: choose tolerance better
 
         # calculate Flaot64 roots
-        r = Array{$BF}(rootsunit_coeffs(convert(Vector{$FF},c./vscale), Float64(htol)))
+        r = Array{$BF}(rootsunit_coeffs(strictconvert(Vector{$FF},c./vscale), Float64(htol)))
         # Map roots from [-1,1] to domain of f:
         rts = fromcanonical.(Ref(d),r)
         fp = differentiate(f)
