Concrete namespaces in macros (#465)

* Concrete namespaces in macros

* bump version to v0.8.26

Author: jishnub

Project.toml

@@ -1,6 +1,6 @@
 name = "ApproxFunBase"
 uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
-version = "0.8.25"
+version = "0.8.26"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"

src/Operators/Operator.jl

@@ -539,7 +539,7 @@ end
 #
 macro wrappergetindex(Wrap, forwardsize = true)
     v = map((:(ApproxFunBase.BandedMatrix),:(ApproxFunBase.RaggedMatrix),
-                :Matrix,:Vector,:AbstractVector)) do TYP
+                :(Base.Matrix),:(Base.Vector),:(Base.AbstractVector))) do TYP
         quote
             $TYP(P::ApproxFunBase.SubOperator{T,OP}) where {T,OP<:$Wrap} =
                 $TYP(view(parent(P).op,P.indexes[1],P.indexes[2]))
@@ -560,7 +560,7 @@ macro wrappergetindex(Wrap, forwardsize = true)
         Base.getindex(OP::$Wrap,k::Colon, j::ApproxFunBase.InfRanges) = view(OP, k, j)
         Base.getindex(OP::$Wrap,k::Colon, j::Colon) = view(OP, k, j)
 
-        axpy!(α,P::ApproxFunBase.SubOperator{T,OP},A::AbstractMatrix) where {T,OP<:$Wrap} =
+        LinearAlgebra.axpy!(α,P::ApproxFunBase.SubOperator{T,OP},A::AbstractMatrix) where {T,OP<:$Wrap} =
             ApproxFunBase.unwrap_axpy!(α,P,A)
 
         ApproxFunBase.mul_coefficients(A::$Wrap,b) = ApproxFunBase.mul_coefficients(A.op,b)
@@ -569,7 +569,7 @@ macro wrappergetindex(Wrap, forwardsize = true)
         ApproxFunBase.mul_coefficients(A::ApproxFunBase.SubOperator{T,OP},b) where {T,OP<:$Wrap} =
             ApproxFunBase.mul_coefficients(view(parent(A).op,S.indexes[1],S.indexes[2]),b)
 
-        isdiag(W::$Wrap) = isdiag(W.op)
+        LinearAlgebra.isdiag(W::$Wrap) = isdiag(W.op)
 
         # fast converts to banded matrices would be based on indices, not blocks
         function ApproxFunBase.BandedMatrix(S::ApproxFunBase.SubOperator{T,OP,NTuple{2,ApproxFunBase.BlockRange1}}) where {T,OP<:$Wrap}

src/Operators/banded/CalculusOperator.jl

@@ -30,71 +30,71 @@ macro calculus_operator(Op)
         ApproxFunBase.rangespace(A::$WrappOp) = A.rangespace
 
         ## Constructors
-        $ConcOp(sp::Space,k) = $ConcOp{typeof(sp),typeof(k),ApproxFunBase.prectype(sp)}(sp,k)
+        $ConcOp(sp::ApproxFunBase.Space,k) = $ConcOp{typeof(sp),typeof(k),ApproxFunBase.prectype(sp)}(sp,k)
 
         $Op(sp::ApproxFunBase.UnsetSpace,k) = $ConcOp(sp,k)
         $Op(sp::ApproxFunBase.UnsetSpace,k::Number) = $ConcOp(sp,k)
         $Op(sp::ApproxFunBase.UnsetSpace,k::Real) = $ConcOp(sp,k)
         $Op(sp::ApproxFunBase.UnsetSpace,k::Integer) = $ConcOp(sp,k)
 
-        function $DefaultOp(sp::Space, k)
+        function $DefaultOp(sp::ApproxFunBase.Space, k)
             csp=ApproxFunBase.canonicalspace(sp)
             if ApproxFunBase.conversion_type(csp,sp)==csp   # Conversion(sp,csp) is not banded, or sp==csp
                error("Implement $(string($Op))($(string(sp)),$k)")
             end
             O = $Op(csp,k)
-            C = Conversion_maybeconcrete(sp, csp, Val(:forward))
+            C = ApproxFunBase.Conversion_maybeconcrete(sp, csp, Val(:forward))
             Top = ApproxFunBase.TimesOperator([O,C])
-            $WrappOp(Top, sp, k, rangespace(O))
+            $WrappOp(Top, sp, k, ApproxFunBase.rangespace(O))
         end
 
-        $DefaultOp(d,k) = $Op(Space(d),k)
+        $DefaultOp(d,k) = $Op(ApproxFunBase.Space(d),k)
 
         $DefaultOp(sp) = $Op(sp,1)
-        $DefaultOp() = $Op(UnsetSpace())
-        $DefaultOp(k::Number) = $Op(UnsetSpace(),k)
-        $DefaultOp(k::Vector) = $Op(UnsetSpace(),k)
+        $DefaultOp() = $Op(ApproxFunBase.UnsetSpace())
+        $DefaultOp(k::Number) = $Op(ApproxFunBase.UnsetSpace(),k)
+        $DefaultOp(k::AbstractVector) = $Op(ApproxFunBase.UnsetSpace(),k)
 
         $Op(x...) = $DefaultOp(x...)
-        $ConcOp(S::Space) = $ConcOp(S,1)
+        $ConcOp(S::ApproxFunBase.Space) = $ConcOp(S,1)
 
-        function Base.convert(::Type{Operator{T}},D::$ConcOp) where T
+        function Base.convert(::Type{ApproxFunBase.Operator{T}},D::$ConcOp) where T
             if T==eltype(D)
                 D
             else
                 $ConcOp{typeof(D.space),typeof(D.order),T}(D.space, D.order)
             end
         end
 
-        $WrappOp(op::Operator, order = 1, d = domainspace(op), r = rangespace(op)) =
+        $WrappOp(op::ApproxFunBase.Operator, order = 1, d = domainspace(op), r = rangespace(op)) =
             $WrappOp{typeof(op),typeof(d),typeof(r),typeof(order),eltype(op)}(op,order,d,r)
 
-        function Base.convert(::Type{Operator{T}},D::$WrappOp) where T
+        function Base.convert(::Type{ApproxFunBase.Operator{T}},D::$WrappOp) where T
             if T==eltype(D)
                 D
             else
-                op=ApproxFunBase.strictconvert(Operator{T},D.op)
-                S = domainspace(D)
-                R = rangespace(D)
-                $WrappOp(op,D.order,S,R)::Operator{T}
+                op=ApproxFunBase.strictconvert(ApproxFunBase.Operator{T},D.op)
+                S = ApproxFunBase.domainspace(D)
+                R = ApproxFunBase.rangespace(D)
+                $WrappOp(op,D.order,S,R)::ApproxFunBase.Operator{T}
             end
         end
 
         ## Routines
         ApproxFunBase.domainspace(D::$ConcOp) = D.space
 
-        Base.getindex(::$ConcOp{UnsetSpace,OT,T},k::Integer,j::Integer) where {OT,T} =
+        Base.getindex(::$ConcOp{ApproxFunBase.UnsetSpace,OT,T},k::Integer,j::Integer) where {OT,T} =
             error("Spaces cannot be inferred for operator")
 
-        ApproxFunBase.rangespace(D::$ConcOp{UnsetSpace,T}) where {T} = UnsetSpace()
+        ApproxFunBase.rangespace(D::$ConcOp{ApproxFunBase.UnsetSpace,T}) where {T} = UnsetSpace()
 
         #promoting domain space is allowed to change range space
         # for integration, we fall back on existing conversion for now
-        ApproxFunBase.promotedomainspace(D::$Op,sp::UnsetSpace) = D
+        ApproxFunBase.promotedomainspace(D::$Op, sp::ApproxFunBase.UnsetSpace) = D
 
 
-        function ApproxFunBase.promotedomainspace(D::$Op,sp::Space)
-            if isambiguous(domain(sp))
+        function ApproxFunBase.promotedomainspace(D::$Op, sp::ApproxFunBase.Space)
+            if ApproxFunBase.isambiguous(domain(sp))
                 $Op(typeof(sp)(domain(D)),D.order)
             else
                 $Op(sp,D.order)