backports for v0.5 (#238)

jishnub · web-flow · commit 9a4a12f9ae8d · 2022-10-15T10:19:27.000+04:00
* remove unnecessary conversion to Any (#138) * Simplify union for spaces (#139) * Simplify union for spaces * Add ambiguous union tests * ambiguity in empty/any domain unions * export inplace transform (#140) * plus for a single Fun (#144) * coefficient conversion bugfix (#146) * backport #157 use libblastrampoline instead of libblas/liblapack * backport reduce Meta.parse calls (#158) * version bump to v0.5.18 Co-authored-by: Jishnu Bhattacharya <jishnub@users.noreply.github.com>
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -1,4 +1,9 @@
 name: CI
+
+concurrency:
+  group: build-${{ github.event.pull_request.number || github.ref }}
+  cancel-in-progress: true
+
 on:
   create:
     tags:
@@ -25,7 +30,6 @@ jobs:
         version:
           - '1.5'
           - '1'
-          - '^1.8.0-0'
         os:
           - ubuntu-latest
           - macOS-latest
diff --git a/Project.toml b/Project.toml
@@ -1,6 +1,6 @@
 name = "ApproxFunBase"
 uuid = "fbd15aa5-315a-5a7d-a8a4-24992e37be05"
-version = "0.5.17"
+version = "0.5.18"
 
 [deps]
 AbstractFFTs = "621f4979-c628-5d54-868e-fcf4e3e8185c"
diff --git a/src/Domain.jl b/src/Domain.jl
@@ -1,5 +1,3 @@
-
-
 export Domain, SegmentDomain, tocanonical, fromcanonical, fromcanonicalD, ∂
 export chebyshevpoints, fourierpoints, isambiguous, arclength
 export components, component, ncomponents
@@ -21,6 +19,8 @@ struct EmptyDomain <: Domain{Nothing} end
 ==(::AnyDomain, ::AnyDomain) = true
 ==(::EmptyDomain, ::EmptyDomain) = true
 
+const AnyOrEmptyDomain = Union{AnyDomain, EmptyDomain}
+
 isambiguous(::AnyDomain) = true
 dimension(::AnyDomain) = 1
 dimension(::EmptyDomain) = 0
@@ -32,21 +32,21 @@ arclength(::DomainSets.EmptySpace) = false
 
 isempty(::AnyDomain) = false
 
-reverseorientation(a::Union{AnyDomain,EmptyDomain}) = a
+reverseorientation(a::AnyOrEmptyDomain) = a
 
-canonicaldomain(a::Union{AnyDomain,EmptyDomain}) = a
+canonicaldomain(a::AnyOrEmptyDomain) = a
 
 indomain(x::Domain,::EmptyDomain) = false
 
 convert(::Type{Domain{T}}, ::AnyDomain) where T = Domain(T)
 
+# empty domain should have priority over over any domain
+_promoteanyemptydomain(::AnyDomain, ::AnyDomain) = AnyDomain()
+_promoteanyemptydomain(::AnyOrEmptyDomain, ::AnyOrEmptyDomain) = EmptyDomain()
 
-union(::AnyDomain, d::Domain) = d
-union(d::Domain, ::AnyDomain) = d
-
-union(::EmptyDomain, ::EmptyDomain) = EmptyDomain()
-union(::EmptyDomain, a::Domain) = a
-union(a::Domain, ::EmptyDomain) = a
+union(a::AnyOrEmptyDomain, b::AnyOrEmptyDomain) = _promoteanyemptydomain(a, b)
+union(::AnyOrEmptyDomain, a::Domain) = a
+union(a::Domain, ::AnyOrEmptyDomain) = a
 
 ##General routines
 isempty(::EmptyDomain) = true
diff --git a/src/Fun.jl b/src/Fun.jl
@@ -20,7 +20,7 @@ end
 const VFun{S,T} = Fun{S,T,Vector{T}}
 
 Fun(sp::Space,coeff::AbstractVector) = Fun{typeof(sp),eltype(coeff),typeof(coeff)}(sp,coeff)
-Fun() = Fun(identity)
+Fun() = Fun(identity, ChebyshevInterval())
 Fun(d::Domain) = Fun(identity,d)
 Fun(d::Space) = Fun(identity,d)
 
@@ -167,10 +167,6 @@ iterate(A::ArrayFun, i=1) = (@_inline_meta; (i % UInt) - 1 < length(A) ? (@inbou
 
 in(x::ScalarFun, y::ScalarFun) = x == y
 
-
-
-
-
 setspace(v::AbstractVector,s::Space) = Fun(s,v)
 setspace(f::Fun,s::Space) = Fun(s,f.coefficients)
 
@@ -341,7 +337,7 @@ function axpy!(a,xcfs::AbstractVector,Y::Fun)
 end
 
 
-
++(a::Fun) = copy(a)
 -(f::Fun) = Fun(f.space,-f.coefficients)
 -(c::Number,f::Fun) = -(f-c)
 
diff --git a/src/LinearAlgebra/blas.jl b/src/LinearAlgebra/blas.jl
@@ -1,5 +1,7 @@
-import LinearAlgebra.BLAS: @blasfunc, libblas
-import LinearAlgebra.LAPACK: liblapack
+import LinearAlgebra.BLAS: @blasfunc
+const libblas = VERSION < v"1.8" ? LinearAlgebra.BLAS.libblas : "libblastrampoline"
+const liblapack = VERSION < v"1.8" ? LinearAlgebra.LAPACK.liblapack : "libblastrampoline"
+
 # Level 2
 ## mv
 ### gemv
diff --git a/src/LinearAlgebra/hesseneigs.jl b/src/LinearAlgebra/hesseneigs.jl
@@ -22,7 +22,7 @@ for (hseqr,elty) in ((:zhseqr_,:ComplexF64),)
 
         Ec='E'
         Nc='N'
-        ccall((@blasfunc($hseqr),LAPACK.liblapack),
+        ccall((@blasfunc($hseqr),liblapack),
             Nothing,
             (Ref{UInt8}, Ref{UInt8},
         Ref{BlasInt}, Ref{BlasInt}, Ref{BlasInt}, Ptr{$elty}, #A
@@ -59,7 +59,7 @@ for (hseqr,elty) in ((:dhseqr_,:Float64),)
         Ec='E'
         Nc='N'
         for i=1:2
-            ccall((@blasfunc($hseqr),LAPACK.liblapack),
+            ccall((@blasfunc($hseqr),liblapack),
                 Nothing,
                 (Ref{UInt8},Ref{UInt8},
             Ref{BlasInt},Ref{BlasInt},Ref{BlasInt},Ptr{$elty}, #A
diff --git a/src/Operators/Operator.jl b/src/Operators/Operator.jl
@@ -371,7 +371,7 @@ end
 
 
 for OP in (:colstart,:colstop,:rowstart,:rowstop)
-    defOP = Meta.parse("default_"*string(OP))
+    defOP = Symbol(:default_, OP)
     @eval begin
         $OP(A::Operator, i::Integer) = $defOP(A,i)
         $OP(A::Operator, i::PosInfinity) = ℵ₀
diff --git a/src/Operators/banded/CalculusOperator.jl b/src/Operators/banded/CalculusOperator.jl
@@ -7,9 +7,9 @@ abstract type CalculusOperator{S,OT,T}<:Operator{T} end
 ## Note that all functions called in calculus_operator must be exported
 
 macro calculus_operator(Op)
-    ConcOp=Meta.parse("Concrete"*string(Op))
-    WrappOp=Meta.parse(string(Op)*"Wrapper")
-    DefaultOp=Meta.parse("Default"*string(Op))
+    ConcOp = Symbol(:Concrete, Op)
+    WrappOp = Symbol(Op, :Wrapper)
+    DefaultOp = Symbol(:Default, Op)
     return esc(quote
         # The SSS, TTT are to work around #9312
         abstract type $Op{SSS,OT,TTT} <: CalculusOperator{SSS,OT,TTT} end
diff --git a/src/Operators/banded/Conversion.jl b/src/Operators/banded/Conversion.jl
@@ -26,7 +26,7 @@ rangespace(C::ConcreteConversion)=C.rangespace
 
 
 
-function defaultConversion(a::Space,b::Space)::Any
+function defaultConversion(a::Space,b::Space)
     if a==b
         Conversion(a)
     elseif conversion_type(a,b)==NoSpace()
diff --git a/src/Operators/banded/Reverse.jl b/src/Operators/banded/Reverse.jl
@@ -1,7 +1,7 @@
 
 
 for TYP in (:ReverseOrientation,:Reverse)
-    WRAP = Meta.parse(string(TYP)*"Wrapper")
+    WRAP = Symbol(TYP, :Wrapper)
     @eval begin
         abstract type $TYP{T} <: Operator{T} end
 
diff --git a/src/Operators/functionals/CalculusFunctional.jl b/src/Operators/functionals/CalculusFunctional.jl
@@ -7,8 +7,8 @@ abstract type CalculusFunctional{S,T} <: Operator{T} end
 ##TODO: Add ConcreteOp
 
 macro calculus_functional(Op)
-    ConcOp=Meta.parse("Concrete"*string(Op))
-    WrappOp=Meta.parse(string(Op)*"Wrapper")
+    ConcOp = Symbol(:Concrete, Op)
+    WrappOp = Symbol(Op, :Wrapper)
     return esc(quote
         abstract type $Op{SSS,TTT} <: CalculusFunctional{SSS,TTT} end
         struct $ConcOp{S,T} <: $Op{S,T}
diff --git a/src/Operators/general/algebra.jl b/src/Operators/general/algebra.jl
@@ -28,7 +28,7 @@ bandwidths(P::PlusOperator) = P.bandwidths
 israggedbelow(P::PlusOperator) = isbandedbelow(P) || all(israggedbelow,P.ops)
 
 for (OP,mn) in ((:colstart,:min),(:colstop,:max),(:rowstart,:min),(:rowstop,:max))
-    defOP = Meta.parse("default_"*string(OP))
+    defOP = Symbol(:default_, OP)
     @eval function $OP(P::PlusOperator,k::Integer)
         if isbanded(P)
             $defOP(P,k)
@@ -308,7 +308,7 @@ israggedbelow(P::TimesOperator) = isbandedbelow(P) || all(israggedbelow,P.ops)
 Base.stride(P::TimesOperator) = mapreduce(stride,gcd,P.ops)
 
 for OP in (:rowstart,:rowstop)
-    defOP=Meta.parse("default_"*string(OP))
+    defOP = Symbol(:default_, OP)
     @eval function $OP(P::TimesOperator,k::Integer)
         if isbanded(P)
             return $defOP(P,k)
@@ -321,7 +321,7 @@ for OP in (:rowstart,:rowstop)
 end
 
 for OP in (:colstart,:colstop)
-    defOP=Meta.parse("default_"*string(OP))
+    defOP = Symbol(:default_, OP)
     @eval function $OP(P::TimesOperator, k::Integer)
         if isbanded(P)
             return $defOP(P, k)
diff --git a/src/Operators/spacepromotion.jl b/src/Operators/spacepromotion.jl
@@ -122,7 +122,7 @@ choosedomainspace(A::Operator,_) = choosedomainspace(A)
 
 choosedomainspace(A) = choosedomainspace(A,UnsetSpace())
 
-function choosedomainspace(ops::AbstractVector,spin)::Any
+function choosedomainspace(ops::AbstractVector,spin)
     sp = UnsetSpace()
 
     for op in ops
diff --git a/src/Space.jl b/src/Space.jl
@@ -1,7 +1,5 @@
-
-
 export Space, domainspace, rangespace, maxspace,Space,conversion_type, transform,
-            itransform, SequenceSpace, ConstantSpace
+            itransform, transform!, itransform!, SequenceSpace, ConstantSpace
 
 
 
@@ -145,22 +143,14 @@ for op in (:tocanonical,:fromcanonical,:tocanonicalD,:fromcanonicalD,:invfromcan
     @eval ($op)(sp::Space,x...)=$op(domain(sp),x...)
 end
 
-mappoint(a::Space,b::Space,x)=mappoint(domain(a),domain(b),x)
-mappoint(a::Space,b::Domain,x)=mappoint(domain(a),b,x)
-mappoint(a::Domain,b::Space,x)=mappoint(a,domain(b),x)
-
+_domain(s::Space) = domain(s)
+_domain(s) = s
+mappoint(a, b, x) = mappoint(map(_domain, (a, b, x))...)
 
+_conversion_rule(a, b) = spacescompatible(a, b) ? a : NoSpace()
 
 for FUNC in (:conversion_rule,:maxspace_rule,:union_rule)
-    @eval begin
-        function $FUNC(a,b)::Any
-            if spacescompatible(a,b)
-                a
-            else
-                NoSpace()
-            end
-        end
-    end
+    @eval $FUNC(a, b) = _conversion_rule(a, b)
 end
 
 
@@ -175,7 +165,7 @@ end
 
 
 # gives a space c that has a banded conversion operator TO a and b
-function conversion_type(a,b)::Any
+function conversion_type(a,b)
     if spacescompatible(a,b)
         a
     elseif !domainscompatible(a,b)
@@ -194,7 +184,7 @@ end
 
 # gives a space c that has a banded conversion operator FROM a and b
 maxspace(a,b) = NoSpace()  # TODO: this fixes weird bug with Nothing
-function maxspace(a::Space, b::Space)::Any
+function maxspace(a::Space, b::Space)
     if spacescompatible(a,b)
         return a
     elseif !domainscompatible(a,b)
@@ -250,11 +240,11 @@ end
 # this is used primarily for addition of two funs
 # that may be incompatible
 union(a::AmbiguousSpace, b::AmbiguousSpace) = b
-union(a::AmbiguousSpace, b::Space) = b
-union(a::Space, b::AmbiguousSpace) = a
+union_by_union_rule(a::AmbiguousSpace, b::Space) = b
+union_by_union_rule(a::Space, b::AmbiguousSpace) = a
 
 
-function union_by_union_rule(a::Space,b::Space)::Any
+function union_by_union_rule(a::Space,b::Space)
     if spacescompatible(a,b)
         if isambiguous(domain(a))
             return b
@@ -269,7 +259,7 @@ function union_by_union_rule(a::Space,b::Space)::Any
     union_rule(b,a)
 end
 
-function union(a::Space, b::Space)::Any
+function union(a::Space, b::Space)
     cr = union_by_union_rule(a,b)
     cr isa NoSpace || return cr
 
@@ -287,12 +277,7 @@ function union(a::Space, b::Space)::Any
     a ⊕ b
 end
 
-union(a::Space) = a
-
-union(a::Space,b::Space,c::Space) = union(union(a,b),c)
-union(a::Space,b::Space,c::Space,d::Space...) =
-    union(union(a,b),c,d...)
-
+union(a::Space, bs::Space...) = foldl(union, bs, init = a)
 
 # tests whether a Conversion operator exists
 hasconversion(a,b) = maxspace(a,b) == b
@@ -319,6 +304,8 @@ coefficients(f::AbstractVector,sp1::Space,::Type{T2}) where {T2<:Space} = coeffi
 ## coefficients defaults to calling Conversion, otherwise it tries to pipe through Chebyshev
 
 
+_Fun(v::AbstractVector, sp) = Fun(sp, v)
+_Fun(v, sp) = Fun(v, sp)
 function defaultcoefficients(f,a,b)
     ct=conversion_type(a,b) # gives a space that has a banded conversion to both a and b
 
@@ -336,7 +323,7 @@ function defaultcoefficients(f,a,b)
         end
         if spacescompatible(a,csp) || spacescompatible(b,csp)
             # b is csp too, so we are stuck, try Fun constructor
-            coefficients(default_Fun(Fun(a,f),b))
+            coefficients(default_Fun(_Fun(f,a),b))
         else
             coefficients(f,a,csp,b)
         end
diff --git a/src/Spaces/ProductSpaceOperators.jl b/src/Spaces/ProductSpaceOperators.jl
@@ -5,14 +5,14 @@ export continuity
 
 for TYP in (:PiecewiseSpace,:ArraySpace)
     @eval begin
-        function promotedomainspace(A::InterlaceOperator{T,2},sp::$TYP)::Any where T
+        function promotedomainspace(A::InterlaceOperator{T,2},sp::$TYP) where T
             if domainspace(A) == sp
                 return A
             end
             @assert size(A.ops,2) == length(sp)
             InterlaceOperator([promotedomainspace(A.ops[k,j],sp[j]) for k=1:size(A.ops,1),j=1:size(A.ops,2)],$TYP)
         end
-        function interlace_choosedomainspace(ops,rs::$TYP)::Any
+        function interlace_choosedomainspace(ops,rs::$TYP)
             @assert length(ops) == length(rs)
             # this ensures correct dispatch for unino
             sps = Array{Space}(
@@ -93,7 +93,7 @@ end
 
 # Sum Space and PiecewiseSpace need to allow permutation of space orders
 for TYP in (:SumSpace,:PiecewiseSpace)
-    @eval function Conversion(S1::$TYP,S2::$TYP)::Any
+    @eval function Conversion(S1::$TYP,S2::$TYP)
         v1 = collect(S1.spaces)
         v2 = collect(S2.spaces)
 
@@ -180,7 +180,7 @@ end
 for (OPrule,OP) in ((:conversion_rule,:conversion_type),(:maxspace_rule,:maxspace),
                         (:union_rule,:union))
     for TYP in (:SumSpace,:PiecewiseSpace)
-        @eval function $OPrule(S1sp::$TYP,S2sp::$TYP)::Any
+        @eval function $OPrule(S1sp::$TYP,S2sp::$TYP)
             S1 = components(S1sp)
             S2 = components(S2sp)
             cs1,cs2=map(canonicalspace,S1),map(canonicalspace,S2)
@@ -239,7 +239,7 @@ for (Op,OpWrap) in ((:Derivative,:DerivativeWrapper),(:Integral,:IntegralWrapper
     end
 end
 
-function Derivative(S::SumSpace,k::Integer)::Any
+function Derivative(S::SumSpace,k::Integer)
     # we want to map before we decompose, as the map may introduce
     # mixed bases.
     if typeof(canonicaldomain(S))==typeof(domain(S))
diff --git a/src/Spaces/Spaces.jl b/src/Spaces/Spaces.jl
@@ -8,7 +8,7 @@ include("SubSpace.jl")
 include("QuotientSpace.jl")
 
 
-⊕(A::Space,B::Space)::Any = domainscompatible(A,B) ? SumSpace(A,B) : PiecewiseSpace(A,B)
+⊕(A::Space,B::Space) = domainscompatible(A,B) ? SumSpace(A,B) : PiecewiseSpace(A,B)
 ⊕(f::Fun,g::Fun) = Fun(space(f) ⊕ space(g), interlace(coefficients(f),coefficients(g)))
 
 ⊕(f::Fun,g::Fun,h::Fun...) = ⊕((f ⊕ g), h...)
diff --git a/src/Spaces/SumSpace.jl b/src/Spaces/SumSpace.jl
@@ -182,7 +182,7 @@ end
 
 
 # avoids default ConstantSpace
-function union_rule(B::ConstantSpace,A::SumSpace)::Any
+function union_rule(B::ConstantSpace,A::SumSpace)
     if !domainscompatible(A,B)
         NoSpace()
     else
@@ -195,7 +195,7 @@ function union_rule(B::ConstantSpace,A::SumSpace)::Any
     end
 end
 
-function union_rule(A::SumSpace, B::Space)::Any
+function union_rule(A::SumSpace, B::Space)
     if !domainscompatible(A,B)
         NoSpace()
     else
diff --git a/src/constructors.jl b/src/constructors.jl
diff --git a/src/testing.jl b/src/testing.jl
diff --git a/test/SpacesTest.jl b/test/SpacesTest.jl
diff --git a/test/runtests.jl b/test/runtests.jl
