assert in conversions (#161)

jishnub · web-flow · commit 45f91ff53cd6 · 2022-08-14T16:44:25.000+04:00
diff --git a/src/ApproxFunBase.jl b/src/ApproxFunBase.jl
@@ -102,6 +102,8 @@ else
 	import Base: oneto
 end
 
+# assert that the conversion succeeds. This helps with inference as well as sanity
+strictconvert(T::Type, x) = convert(T, x)::T
 
 include("LinearAlgebra/LinearAlgebra.jl")
 include("Fun.jl")
diff --git a/src/Domains/Grids.jl b/src/Domains/Grids.jl
@@ -4,7 +4,7 @@
 struct FourierGrid{T} <: AbstractVector{T}
     n::Int
     π_over_n::T
-    FourierGrid{T}(n::Int) where T = new{T}(n, convert(T,π)/n)
+    FourierGrid{T}(n::Int) where T = new{T}(n, strictconvert(T,π)/n)
 end
 
 size(g::FourierGrid) = (g.n,)
@@ -26,4 +26,4 @@ fp(n) = collect(FourierGrid{Float64}(n))
 
 n=10
 T=Float64
-    convert(T,π)*(0:2:2n-2)/n - [convert(T,π)*(2k-2)/n for k=1:n]
+    strictconvert(T,π)*(0:2:2n-2)/n - [strictconvert(T,π)*(2k-2)/n for k=1:n]
diff --git a/src/Domains/Segment.jl b/src/Domains/Segment.jl
@@ -32,11 +32,11 @@ convert(::Type{Domain{T}}, d::Segment) where {T<:Number} = Segment{T}(leftendpoi
 convert(::Type{Domain{T}}, d::Segment) where {T<:SVector} = Segment{T}(leftendpoint(d),rightendpoint(d))
 convert(::Type{Segment{T}}, d::Segment) where {T<:Number} = Segment{T}(leftendpoint(d),rightendpoint(d))
 convert(::Type{Segment}, d::AbstractInterval) = Segment(leftendpoint(d), rightendpoint(d))
-convert(::Type{Segment{T}}, d::AbstractInterval) where T =convert(Segment{T}, convert(Segment, d))
+convert(::Type{Segment{T}}, d::AbstractInterval) where T =strictconvert(Segment{T}, strictconvert(Segment, d))
 
 
 
-Segment(d::AbstractInterval) = convert(Segment, d)
+Segment(d::AbstractInterval) = strictconvert(Segment, d)
 
 
 
@@ -48,7 +48,7 @@ convert(::Type{Segment},::AnyDomain) = AnySegment()
 convert(::Type{Interval}, d::Segment{<:Real}) = d.a < d.b ? d.a .. d.b : d.b .. d.a
 convert(::Type{ClosedInterval}, ::AnyDomain) = NaN..NaN
 convert(::Type{ClosedInterval{T}}, ::AnyDomain) where T = T(NaN)..T(NaN)
-Interval(d::Segment) = convert(Interval, d)
+Interval(d::Segment) = strictconvert(Interval, d)
 
 
 ## Information
diff --git a/src/Fun.jl b/src/Fun.jl
@@ -76,14 +76,14 @@ coefficient(f::Fun,::Colon) = coefficient(f,1:dimension(space(f)))
 
 
 convert(::Type{Fun{S,T,VT}},f::Fun{S}) where {T,S,VT} =
-    Fun{S,T,VT}(f.space, convert(VT,f.coefficients)::VT)
+    Fun{S,T,VT}(f.space, strictconvert(VT,f.coefficients))
 function convert(::Type{Fun{S,T,VT}},f::Fun) where {T,S,VT}
-    g = Fun(Fun(f.space, convert(VT,f.coefficients)::VT), convert(S,space(f))::S)
+    g = Fun(Fun(f.space, strictconvert(VT,f.coefficients)), strictconvert(S,space(f)))
     Fun{S,T,VT}(g.space, g.coefficients)
 end
 
 function convert(::Type{Fun{S,T}},f::Fun{S}) where {T,S}
-    coeff = convert(AbstractVector{T},f.coefficients)::AbstractVector{T}
+    coeff = strictconvert(AbstractVector{T},f.coefficients)
     Fun{S, T, typeof(coeff)}(f.space, coeff)
 end
 
@@ -92,11 +92,11 @@ convert(::Type{VFun{S,T}},x::Number) where {T,S} =
     (x==0 ? zeros(T,S(AnyDomain())) : x*ones(T,S(AnyDomain())))::VFun{S,T}
 convert(::Type{Fun{S}},x::Number) where {S} =
     (x==0 ? zeros(S(AnyDomain())) : x*ones(S(AnyDomain())))::Fun{S}
-convert(::Type{IF},x::Number) where {IF<:Fun} = convert(IF,Fun(x))::IF
+convert(::Type{IF},x::Number) where {IF<:Fun} = strictconvert(IF,Fun(x))
 
-Fun{S,T,VT}(f::Fun) where {S,T,VT} = convert(Fun{S,T,VT}, f)
-Fun{S,T}(f::Fun) where {S,T} = convert(Fun{S,T}, f)
-Fun{S}(f::Fun) where {S} = convert(Fun{S}, f)
+Fun{S,T,VT}(f::Fun) where {S,T,VT} = strictconvert(Fun{S,T,VT}, f)
+Fun{S,T}(f::Fun) where {S,T} = strictconvert(Fun{S,T}, f)
+Fun{S}(f::Fun) where {S} = strictconvert(Fun{S}, f)
 
 # if we are promoting, we need to change to a VFun
 Base.promote_rule(::Type{Fun{S,T,VT1}},::Type{Fun{S,V,VT2}}) where {T,V,S,VT1,VT2} =
diff --git a/src/LinearAlgebra/RaggedMatrix.jl b/src/LinearAlgebra/RaggedMatrix.jl
@@ -101,8 +101,8 @@ end
 
 convert(::Type{RaggedMatrix}, B::AbstractMatrix) = RaggedMatrix{eltype(B)}(B)
 
-RaggedMatrix(B::AbstractMatrix) = convert(RaggedMatrix, B)
-RaggedMatrix{T}(B::AbstractMatrix) where T = convert(RaggedMatrix{T}, B)
+RaggedMatrix(B::AbstractMatrix) = strictconvert(RaggedMatrix, B)
+RaggedMatrix{T}(B::AbstractMatrix) where T = strictconvert(RaggedMatrix{T}, B)
 
 Base.similar(B::RaggedMatrix,::Type{T}) where {T} = RaggedMatrix(Vector{T}(length(B.data)),copy(B.cols),B.m)
 
diff --git a/src/LinearAlgebra/helper.jl b/src/LinearAlgebra/helper.jl
@@ -106,7 +106,7 @@ end
 
 
 scal!(n::Integer,cst::BlasFloat,ret::DenseArray{T},k::Integer) where {T<:BlasFloat} =
-    BLAS.scal!(n,convert(T,cst),ret,k)
+    BLAS.scal!(n,strictconvert(T,cst),ret,k)
 
 function scal!(n::Integer,cst::Number,ret::AbstractArray,k::Integer)
     @assert k*n ≤ length(ret)
@@ -162,8 +162,6 @@ const alternatesign! = negateeven!
 
 alternatesign(v::AbstractVector) = alternatesign!(copy(v))
 
-alternatingvector(n::Integer) = 2*mod([1:n],2) .- 1
-
 function alternatingsum(v::AbstractVector)
     ret = zero(eltype(v))
     s = 1
@@ -664,7 +662,7 @@ conv(x::AbstractVector, y::AbstractVector) = DSP.conv(x, y)
 @generated function conv(x::SVector{N}, y::SVector{M}) where {N,M}
     NM = N+M-1
     quote
-        convert(SVector{$NM}, DSP.conv(Vector(x), Vector(y)))
+        strictconvert(SVector{$NM}, DSP.conv(Vector(x), Vector(y)))
     end
 end
 
diff --git a/src/LinearAlgebra/rowvector.jl b/src/LinearAlgebra/rowvector.jl
@@ -40,7 +40,7 @@ end
 
 # Conversion of underlying storage
 convert(::Type{RowVector{T,V}}, rowvec::RowVector) where {T,V<:AbstractVector} =
-    RowVector{T,V}(convert(V,rowvec.vec))
+    RowVector{T,V}(strictconvert(V,rowvec.vec))
 
 # similar tries to maintain the RowVector wrapper and the parent type
 @inline similar(rowvec::RowVector) = RowVector(similar(parent(rowvec)))
diff --git a/src/Multivariate/LowRankFun.jl b/src/Multivariate/LowRankFun.jl
@@ -27,8 +27,8 @@ LowRankFun(A::Vector{VFun{S,T}},B::Vector{VFun{M,T}},space::SS) where {S,M,SS,T}
 LowRankFun(A::Vector{VFun{S,T}},B::Vector{VFun{M,T}}) where {S,M,T} =
     LowRankFun(A,B,space(first(A))⊗space(first(B)))
 LowRankFun(A::Vector{VFun{S,T}},B::Vector{VFun{M,V}}) where {S,M,T,V} =
-    LowRankFun(convert(Vector{VFun{S,promote_type(T,V)}},A),
-               convert(Vector{VFun{M,promote_type(T,V)}},B),
+    LowRankFun(strictconvert(Vector{VFun{S,promote_type(T,V)}},A),
+               strictconvert(Vector{VFun{M,promote_type(T,V)}},B),
                space(first(A))⊗space(first(B)))
 rank(f::LowRankFun) = length(f.A)
 size(f::LowRankFun,k::Integer) = k==1 ? mapreduce(length,max,f.A) : mapreduce(length,max,f.B)
diff --git a/src/Multivariate/VectorFun.jl b/src/Multivariate/VectorFun.jl
@@ -2,7 +2,7 @@
 
 
 convert(::Type{Array}, f::ArrayFun) = reshape(vec(f), size(space(f))...)
-Array(f::ArrayFun) = convert(Array, f)
+Array(f::ArrayFun) = strictconvert(Array, f)
 Vector(f::VectorFun) = Array(f)
 Matrix(f::MatrixFun) = Array(f)
 
diff --git a/src/Operators/Operator.jl b/src/Operators/Operator.jl
@@ -628,12 +628,12 @@ Operator(L::UniformScaling{Bool}, s::Space) = L.λ ? IdentityOperator(s) : ZeroO
 Operator(L::UniformScaling, d::Domain) = Operator(L, Space(d))
 
 Operator{T}(f::Fun) where {T} =
-    norm(f.coefficients)==0 ? zero(Operator{T}) : convert(Operator{T}, Multiplication(f))
+    norm(f.coefficients)==0 ? zero(Operator{T}) : strictconvert(Operator{T}, Multiplication(f))
 
 Operator(f::Fun) = norm(f.coefficients)==0 ? ZeroOperator() : Multiplication(f)
 
 convert(::Type{O}, f::Fun) where O<:Operator = O(f)
-Operator{T}(A::Operator) where T = convert(Operator{T}, A)
+Operator{T}(A::Operator) where T = strictconvert(Operator{T}, A)
 
 
 ## Promotion
diff --git a/src/Operators/almostbanded/LowRankOperator.jl b/src/Operators/almostbanded/LowRankOperator.jl
@@ -27,21 +27,21 @@ end
 
 LowRankOperator(U::Vector{VFun{S,T}},V::Vector{Operator{T}}) where {S,T} = LowRankOperator{S,T}(U,V)
 LowRankOperator(U::Vector{VFun{S,T1}},V::Vector{Operator{T2}}) where {S,T1,T2} =
-    LowRankOperator(convert(Vector{VFun{S,promote_type(T1,T2)}},U),
-                    convert(Vector{Operator{promote_type(T1,T2)}},V))
+    LowRankOperator(strictconvert(Vector{VFun{S,promote_type(T1,T2)}},U),
+                    strictconvert(Vector{Operator{promote_type(T1,T2)}},V))
 LowRankOperator(U::Vector{FF},V::Vector{FT}) where {FF<:Fun,FT<:Operator} =
-    LowRankOperator(U,convert(Vector{Operator{eltype(FT)}},V))
+    LowRankOperator(U,strictconvert(Vector{Operator{eltype(FT)}},V))
 
 
 
-LowRankOperator(B::AbstractVector,S...) = LowRankOperator(convert(Vector{Operator{Float64}},B),S...)
+LowRankOperator(B::AbstractVector,S...) = LowRankOperator(strictconvert(Vector{Operator{Float64}},B),S...)
 
 LowRankOperator(A::Fun,B::Operator) = LowRankOperator([A],[B])
 
 
 convert(::Type{Operator{T}},L::LowRankOperator{S}) where {S,T} =
-    LowRankOperator{S,T}(convert(Vector{VFun{S,T}},L.U),
-                         convert(Vector{Operator{T}},L.V))
+    LowRankOperator{S,T}(strictconvert(Vector{VFun{S,T}},L.U),
+                         strictconvert(Vector{Operator{T}},L.V))
 
 
 datasize(L::LowRankOperator,k) =
diff --git a/src/Operators/banded/CalculusOperator.jl b/src/Operators/banded/CalculusOperator.jl
@@ -68,7 +68,7 @@ macro calculus_operator(Op)
                 D
             else
                 # work around typeinfernece bug
-                op=convert(Operator{T},D.op)
+                op=ApproxFunBase.strictconvert(Operator{T},D.op)
                 $WrappOp{typeof(op),typeof(domainspace(op)),typeof(D.order),T}(op,D.order)
             end
         end
diff --git a/src/Operators/banded/ConstantOperator.jl b/src/Operators/banded/ConstantOperator.jl
@@ -3,8 +3,8 @@ export ConstantOperator, IdentityOperator, BasisFunctional
 struct ConstantOperator{T,DS} <: Operator{T}
     λ::T
     space::DS
-    ConstantOperator{T,DS}(c::Number,sp::DS) where {T,DS} = new{T,DS}(convert(T,c),sp)
-    ConstantOperator{T,DS}(L::UniformScaling,sp::DS) where {T,DS} = new{T,DS}(convert(T,L.λ),sp)
+    ConstantOperator{T,DS}(c::Number,sp::DS) where {T,DS} = new{T,DS}(strictconvert(T,c),sp)
+    ConstantOperator{T,DS}(L::UniformScaling,sp::DS) where {T,DS} = new{T,DS}(strictconvert(T,L.λ),sp)
 end
 
 
@@ -47,11 +47,11 @@ end
 # zero needs to be different since it can take a space to
 # a ConstantSpace, in creating functionals
 convert(::Type{Operator{T}}, x::Number) where {T} =
-    x==0 ? ZeroOperator(T) : Multiplication(convert(T,x))
+    x==0 ? ZeroOperator(T) : Multiplication(strictconvert(T,x))
 convert(::Type{Operator{T}}, L::UniformScaling) where {T} =
     ConstantOperator(T,L.λ)
 
-convert(::Type{Operator},n::Number) = convert(Operator{typeof(n)}, n)
+convert(::Type{Operator},n::Number) = strictconvert(Operator{typeof(n)}, n)
 convert(::Type{Operator},L::UniformScaling) = ConstantOperator(L.λ)
 
 ## Algebra
@@ -79,7 +79,7 @@ domainspace(B::BasisFunctional) = B.space
 convert(::Type{Operator{T}},B::BasisFunctional) where {T} = BasisFunctional{T,typeof(B.space)}(B.k,B.space)
 
 Base.getindex(op::BasisFunctional{T},k::Integer) where {T} = (k==op.k) ? one(T) : zero(T)
-Base.getindex(op::BasisFunctional{T},k::AbstractRange) where {T} = convert(Vector{T},k.==op.k)
+Base.getindex(op::BasisFunctional{T},k::AbstractRange) where {T} = strictconvert(Vector{T},k.==op.k)
 
 struct FillFunctional{T} <: Operator{T}
     λ::T
@@ -144,8 +144,8 @@ iszeroop(A::ConstantOperator) = A.λ==0.0
 iszeroop(A) = false
 
 convert(::Type{T},::ZeroOperator) where {T<:Number} = zero(T)
-convert(::Type{T},C::ConstantOperator) where {T<:Number} = convert(T,C.λ)
-convert(::Type{T},S::SpaceOperator) where {T<:Number} = convert(T,S.op)
+convert(::Type{T},C::ConstantOperator) where {T<:Number} = strictconvert(T,C.λ)
+convert(::Type{T},S::SpaceOperator) where {T<:Number} = strictconvert(T,S.op)
 
 
 
diff --git a/src/Operators/banded/Conversion.jl b/src/Operators/banded/Conversion.jl
@@ -86,7 +86,7 @@ function convert(::Type{Operator{T}},D::ConversionWrapper) where T
     if T==eltype(D)
         D
     else
-        BO=convert(Operator{T},D.op)
+        BO=strictconvert(Operator{T},D.op)
         ConversionWrapper{typeof(BO),T}(BO)
     end
 end
diff --git a/src/Operators/banded/Multiplication.jl b/src/Operators/banded/Multiplication.jl
@@ -14,7 +14,7 @@ function ConcreteMultiplication(::Type{V},f::Fun{D,T},sp::Space) where {V,D,T}
         error("Domain mismatch: cannot multiply function on $(domain(f)) to function on $(domain(sp))")
     end
     ConcreteMultiplication{D,typeof(sp),V}(
-        convert(Fun{D,V},chop(f,40*eps(cfstype(f)))),sp)
+        strictconvert(Fun{D,V},chop(f,40*eps(cfstype(f)))),sp)
 end
 
 
@@ -23,7 +23,7 @@ function ConcreteMultiplication(f::Fun{D,T},sp::Space) where {D,T}
         error("Domain mismatch: cannot multiply function on $(domain(f)) to function on $(domain(sp))")
     end
     V = promote_type(T,rangetype(sp))
-    ConcreteMultiplication{D,typeof(sp),V}(convert(Fun{D,V},chop(f,40*eps(cfstype(f)))),sp)
+    ConcreteMultiplication{D,typeof(sp),V}(strictconvert(Fun{D,V},chop(f,40*eps(cfstype(f)))),sp)
 end
 
 ==(A::ConcreteMultiplication, B::ConcreteMultiplication) = (A.f == B.f) && (A.space == B.space)
diff --git a/src/Operators/banded/PermutationOperator.jl b/src/Operators/banded/PermutationOperator.jl
@@ -27,7 +27,7 @@ function getindex(P::PermutationOperator{T},k::Integer,j::Integer) where T
     if (k-1)÷n == (j-1)÷n  # diagonal blocks
         k=mod(k-1,n)+1
         j=mod(j-1,n)+1
-        convert(T,P.perm[k]==j)
+        strictconvert(T,P.perm[k]==j)
     else
         zero(T)
     end
diff --git a/src/Operators/banded/ToeplitzOperator.jl b/src/Operators/banded/ToeplitzOperator.jl
@@ -13,7 +13,7 @@ ToeplitzOperator(V::AbstractVector,W::AbstractVector) =
     ToeplitzOperator(collect(V),collect(W))
 
 convert(::Type{Operator{TT}},T::ToeplitzOperator) where {TT} =
-    ToeplitzOperator(convert(Vector{TT},T.negative),convert(Vector{TT},T.nonnegative))
+    ToeplitzOperator(strictconvert(Vector{TT},T.negative),strictconvert(Vector{TT},T.nonnegative))
 
 for op in (:(Base.real), :(Base.imag))
     @eval $op(T::ToeplitzOperator) = ToeplitzOperator($op(T.negative), $op(T.nonnegative))
@@ -105,7 +105,7 @@ HankelOperator(f::Fun)=HankelOperator(f.coefficients)
 
 
 
-@eval convert(::Type{Operator{TT}},T::HankelOperator) where {TT}=HankelOperator(convert(Vector{TT},T.coefficients))
+@eval convert(::Type{Operator{TT}},T::HankelOperator) where {TT}=HankelOperator(strictconvert(Vector{TT},T.coefficients))
 
 function hankel_getindex(v::AbstractVector,k::Integer,j::Integer)
    if k+j-1 ≤ length(v)
diff --git a/src/Operators/functionals/CalculusFunctional.jl b/src/Operators/functionals/CalculusFunctional.jl
@@ -45,7 +45,7 @@ macro calculus_functional(Op)
 
 
         Base.convert(::Type{Operator{T}},Σ::$WrappOp) where {T} =
-            (T==eltype(Σ) ? Σ : $WrappOp(convert(Operator{T},Σ.op)))::Operator{T}
+            (T==eltype(Σ) ? Σ : $WrappOp(strictconvert(Operator{T},Σ.op)))::Operator{T}
     end)
 end
 
diff --git a/src/Operators/functionals/Evaluation.jl b/src/Operators/functionals/Evaluation.jl
@@ -106,7 +106,7 @@ function convert(::Type{Operator{T}},E::EvaluationWrapper) where T
     if T == eltype(E)
         E
     else
-        EvaluationWrapper(E.space,E.x,E.order,convert(Operator{T},E.op))::Operator{T}
+        EvaluationWrapper(E.space,E.x,E.order,strictconvert(Operator{T},E.op))::Operator{T}
     end
 end
 
diff --git a/src/Operators/general/CachedOperator.jl b/src/Operators/general/CachedOperator.jl
@@ -57,7 +57,7 @@ cache(::Type{MT},O::Operator;kwds...) where {MT<:AbstractMatrix} = CachedOperato
 
 convert(::Type{Operator{T}},S::CachedOperator{T}) where {T} = S
 convert(::Type{Operator{T}},S::CachedOperator) where {T} =
-    CachedOperator(convert(Operator{T}, S.op),convert(AbstractMatrix{T}, S.data),
+    CachedOperator(strictconvert(Operator{T}, S.op),strictconvert(AbstractMatrix{T}, S.data),
                     S.datasize,S.domainspace,S.rangespace,S.bandwidths)
 
 
diff --git a/src/Operators/general/FiniteOperator.jl b/src/Operators/general/FiniteOperator.jl
@@ -17,7 +17,7 @@ FiniteOperator(M::AbstractMatrix{<:Number}) =
     FiniteOperator(M,EuclideanSpace(size(M,2)),EuclideanSpace(size(M,1)))
 
 convert(::Type{Operator{T}},F::FiniteOperator) where {T} =
-    FiniteOperator(convert(AbstractMatrix{T},F.matrix),F.domainspace,F.rangespace)::Operator{T}
+    FiniteOperator(strictconvert(AbstractMatrix{T},F.matrix),F.domainspace,F.rangespace)::Operator{T}
 
 ==(A::FiniteOperator, B::FiniteOperator) = A.matrix == B.matrix && A.domainspace == B.domainspace && A.rangespace == B.rangespace
 
diff --git a/src/Operators/general/InterlaceOperator.jl b/src/Operators/general/InterlaceOperator.jl
@@ -474,7 +474,7 @@ function _hvcat(rows::Tuple{Vararg{Int}},as::OperatorTypes...)
     rs = Array{Any,1}(undef, nbr)
     a = 1
     for i = 1:nbr
-        rs[i] = hcat(map(op -> convert(Operator,op),as[a:a-1+rows[i]])...)
+        rs[i] = hcat(map(op -> strictconvert(Operator,op),as[a:a-1+rows[i]])...)
         a += rows[i]
     end
     vcat(rs...)
diff --git a/src/Operators/general/OperatorLayout.jl b/src/Operators/general/OperatorLayout.jl
@@ -9,7 +9,7 @@ struct HermitianOperator{T<:Number,B<:Operator} <: Operator{T}
 end
 
 HermitianOperator(B::Operator{T}, uplo::Symbol=:U) where {T<:Number} = HermitianOperator{T,typeof(B)}(B, char_uplo(uplo))
-convert(::Type{Operator{T}},A::HermitianOperator) where {T}=HermitianOperator(convert(Operator{T},A.op), A.uplo)
+convert(::Type{Operator{T}},A::HermitianOperator) where {T}=HermitianOperator(strictconvert(Operator{T},A.op), A.uplo)
 
 domainspace(P::HermitianOperator)=domainspace(P.op)
 rangespace(P::HermitianOperator)=rangespace(P.op)
@@ -42,7 +42,7 @@ struct SymmetricOperator{T<:Number,B<:Operator} <: Operator{T}
 end
 
 SymmetricOperator(B::Operator{T}, uplo::Symbol=:U) where {T<:Number} = SymmetricOperator{T,typeof(B)}(B, char_uplo(uplo))
-convert(::Type{Operator{T}},A::SymmetricOperator) where {T}=SymmetricOperator(convert(Operator{T},A.op), A.uplo)
+convert(::Type{Operator{T}},A::SymmetricOperator) where {T}=SymmetricOperator(strictconvert(Operator{T},A.op), A.uplo)
 
 domainspace(P::SymmetricOperator)=domainspace(P.op)
 rangespace(P::SymmetricOperator)=rangespace(P.op)
@@ -74,7 +74,7 @@ struct AdjointOperator{T<:Number,B<:Operator} <: Operator{T}
 end
 
 AdjointOperator(B::Operator{T}) where {T<:Number}=AdjointOperator{T,typeof(B)}(B)
-convert(::Type{Operator{T}},A::AdjointOperator) where {T}=AdjointOperator(convert(Operator{T},A.op))
+convert(::Type{Operator{T}},A::AdjointOperator) where {T}=AdjointOperator(strictconvert(Operator{T},A.op))
 
 domainspace(P::AdjointOperator)=rangespace(P.op)
 rangespace(P::AdjointOperator)=domainspace(P.op)
@@ -96,7 +96,7 @@ struct TransposeOperator{T<:Number,B<:Operator} <: Operator{T}
 end
 
 TransposeOperator(B::Operator{T}) where {T<:Number}=TransposeOperator{T,typeof(B)}(B)
-convert(::Type{Operator{T}},A::TransposeOperator) where {T}=TransposeOperator(convert(Operator{T},A.op))
+convert(::Type{Operator{T}},A::TransposeOperator) where {T}=TransposeOperator(strictconvert(Operator{T},A.op))
 
 domainspace(P::TransposeOperator)=rangespace(P.op)
 rangespace(P::TransposeOperator)=domainspace(P.op)
diff --git a/src/Operators/general/PartialInverseOperator.jl b/src/Operators/general/PartialInverseOperator.jl
@@ -16,7 +16,7 @@ end
 PartialInverseOperator(B::Operator, bandwidths) = PartialInverseOperator(cache(B), bandwidths)
 PartialInverseOperator(B::Operator) = PartialInverseOperator(B, bandwidths(B))
 
-convert(::Type{Operator{T}},A::PartialInverseOperator) where {T}=PartialInverseOperator(convert(Operator{T},A.cache), A.bandwidths)
+convert(::Type{Operator{T}},A::PartialInverseOperator) where {T}=PartialInverseOperator(strictconvert(Operator{T},A.cache), A.bandwidths)
 
 domainspace(P::PartialInverseOperator)=rangespace(P.cache)
 rangespace(P::PartialInverseOperator)=domainspace(P.cache)
diff --git a/src/Operators/general/algebra.jl b/src/Operators/general/algebra.jl
diff --git a/src/Operators/qr.jl b/src/Operators/qr.jl
diff --git a/src/Operators/spacepromotion.jl b/src/Operators/spacepromotion.jl
diff --git a/src/PDE/KroneckerOperator.jl b/src/PDE/KroneckerOperator.jl
diff --git a/src/Space.jl b/src/Space.jl
diff --git a/src/Spaces/ConstantSpace.jl b/src/Spaces/ConstantSpace.jl
diff --git a/src/constructors.jl b/src/constructors.jl
diff --git a/src/show.jl b/src/show.jl
diff --git a/src/specialfunctions.jl b/src/specialfunctions.jl
diff --git a/src/testing.jl b/src/testing.jl
