Move SparseArrays and Statistics to extensions

Author: jishnub

Project.toml

@@ -24,6 +24,14 @@ SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b"
 StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 
+[weakdeps]
+SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+
+[extensions]
+ApproxFunBaseSparseArraysExt = "SparseArrays"
+ApproxFunBaseStatisticsExt = "Statistics"
+
 [compat]
 AbstractFFTs = "0.5, 1"
 Aqua = "0.8"

ext/ApproxFunBaseSparseArraysExt.jl

@@ -0,0 +1,36 @@
+module ApproxFunBaseSparseArraysExt
+
+using SparseArrays
+import SparseArrays: blockdiag
+using ApproxFunBase
+using ApproxFunBase: promote_eltypeof
+
+##TODO: unify with other blockdiag
+function blockdiag(d1::AbstractVector{T}, d2::AbstractVector{T}) where T<:Operator
+    if isempty(d1) && isempty(d2)
+        error("Empty blockdiag")
+    end
+    if isempty(d1)
+        TT=promote_eltypeof(d2)
+    elseif isempty(d2)
+        TT=promote_eltypeof(d1)
+    else
+        TT=promote_type(promote_eltypeof(d1),
+                        promote_eltypeof(d2))
+    end
+
+      D=zeros(Operator{TT},length(d1)+length(d2),2)
+      D[1:length(d1),1]=d1
+      D[length(d1)+1:end,2]=d2
+      D
+end
+
+function blockdiag(a::Operator, b::Operator)
+	blockdiag(Operator{promote_type(eltype(a),eltype(b))}[a],
+			Operator{promote_type(eltype(a),eltype(b))}[b])
+end
+
+blockdiag(A::PlusOperator) = mapreduce(blockdiag, +, A.ops)
+blockdiag(A::TimesOperator) = mapreduce(blockdiag, .*, A.ops)
+
+end

ext/ApproxFunBaseStatisticsExt.jl

@@ -0,0 +1,9 @@
+module ApproxFunBaseStatisticsExt
+
+import Statistics: mean
+using ApproxFunBase
+using ApproxFunBase: IntervalOrSegment
+
+mean(d::IntervalOrSegment) = ApproxFunBase.mean(d)
+
+end

src/ApproxFunBase.jl

@@ -15,10 +15,8 @@ using InfiniteArrays
 using IntervalSets
 using LinearAlgebra
 using LowRankMatrices
-using SparseArrays
 using SpecialFunctions
 using StaticArrays: SVector, @SArray, SArray
-import Statistics: mean
 
 import DomainSets: Domain, indomain, UnionDomain, ProductDomain, Point, ∂,
               SetdiffDomain, Interval, ChebyshevInterval, boundary,
@@ -58,10 +56,6 @@ import LinearAlgebra: BlasInt, BlasFloat, norm, ldiv!, mul!, det, cross,
               nullspace, Hermitian, Symmetric, adjoint, transpose, char_uplo,
               axpy!, eigvals
 
-import SparseArrays: blockdiag
-
-# import Arpack: eigs
-
 # we need to import all special functions to use Calculus.symbolic_derivatives_1arg
 # we can't do importall Base as we replace some Base definitions
 import SpecialFunctions: airy, besselh,
@@ -160,4 +154,9 @@ include("hacks.jl")
 include("specialfunctions.jl")
 include("show.jl")
 
+if !isdefined(Base, :get_extension)
+    include("../ext/ApproxFunBaseSparseArraysExt.jl")
+    include("../ext/ApproxFunBaseStatisticsExt.jl")
+end
+
 end #module

src/Domains/Segment.jl

@@ -68,6 +68,7 @@ issubset(a::Segment,b::Segment) = leftendpoint(a)∈b && rightendpoint(a)∈b
 arclength(d::AbstractInterval) = width(d)
 arclength(d::Segment) = norm(complexlength(d))
 complexlength(d::IntervalOrSegment) = rightendpoint(d)-leftendpoint(d)
+# ApproxFunBase.mean != Statistics.mean, as the latter is defined in the Statistics extension
 mean(d::IntervalOrSegment) = (rightendpoint(d)+leftendpoint(d))/2
 angle(d::IntervalOrSegment) = angle(complexlength(d))
 sign(d::IntervalOrSegment) = sign(complexlength(d))

src/Operators/Operator.jl

@@ -332,13 +332,6 @@ istril(A::Operator) = bandwidth(A, 2) <= 0
 
 include("SubOperator.jl")
 
-
-#
-# sparse(B::Operator,n::Integer)=sparse(BandedMatrix(B,n))
-# sparse(B::Operator,n::AbstractRange,m::AbstractRange)=sparse(BandedMatrix(B,n,m))
-# sparse(B::Operator,n::Colon,m::AbstractRange)=sparse(BandedMatrix(B,n,m))
-# sparse(B::Operator,n::AbstractRange,m::Colon)=sparse(BandedMatrix(B,n,m))
-
 ## getindex
 
 

src/Operators/systems.jl

@@ -33,29 +33,6 @@ function diagm_container(size, kv::Pair{<:Integer,<:AbstractVector{<:Operator}}.
     zeros(Operator{T}, n, n)
 end
 
-##TODO: unify with other blockdiag
-function blockdiag(d1::AbstractVector{T},d2::AbstractVector{T}) where T<:Operator
-    if isempty(d1)&&isempty(d2)
-        error("Empty blockdiag")
-    end
-    if isempty(d1)
-        TT=promote_eltypeof(d2)
-    elseif isempty(d2)
-        TT=promote_eltypeof(d1)
-    else
-        TT=promote_type(promote_eltypeof(d1),
-                        promote_eltypeof(d2))
-    end
-
-      D=zeros(Operator{TT},length(d1)+length(d2),2)
-      D[1:length(d1),1]=d1
-      D[length(d1)+1:end,2]=d2
-      D
-end
-
-blockdiag(a::Operator,b::Operator) = blockdiag(Operator{promote_type(eltype(a),eltype(b))}[a],
-                                                Operator{promote_type(eltype(a),eltype(b))}[b])
-
 ## broadcase
 
 broadcast(::typeof(*),A::AbstractArray{N},D::Operator) where {N<:Number} =

src/Spaces/ProductSpaceOperators.jl

@@ -55,9 +55,6 @@ end
 continuity(d::UnionDomain,k) = continuity(Space(d),k)
 continuity(d) = continuity(d,0)
 
-blockdiag(A::PlusOperator) = mapreduce(blockdiag, +, A.ops)
-blockdiag(A::TimesOperator) = mapreduce(blockdiag, .*, A.ops)
-
 # TODO: general wrappers
 
 Evaluation(S::SumSpace,x,order) =