adopt to v1.6+ syntax and features

Author: dkarrasch

src/LinearMaps.jl

@@ -8,12 +8,7 @@ using LinearAlgebra
 import LinearAlgebra: mul!
 using SparseArrays
 
-if VERSION < v"1.2-"
-    import Base: has_offset_axes
-    require_one_based_indexing(A...) = !has_offset_axes(A...) || throw(ArgumentError("offset arrays are not supported but got an array with index other than 1"))
-else
-    import Base: require_one_based_indexing
-end
+using Base: require_one_based_indexing
 
 abstract type LinearMap{T} end
 
@@ -33,11 +28,7 @@ MulStyle(::ThreeArg, ::FiveArg) = ThreeArg()
 MulStyle(::FiveArg, ::ThreeArg) = ThreeArg()
 MulStyle(::ThreeArg, ::ThreeArg) = ThreeArg()
 MulStyle(::LinearMap) = ThreeArg() # default
-@static if VERSION ≥ v"1.3.0-alpha.115"
-    MulStyle(::AbstractVecOrMat) = FiveArg()
-else
-    MulStyle(::AbstractVecOrMat) = ThreeArg()
-end
+MulStyle(::AbstractVecOrMat) = FiveArg()
 MulStyle(A::LinearMap, As::LinearMap...) = MulStyle(MulStyle(A), MulStyle(As...))
 
 Base.isreal(A::LinearMap) = eltype(A) <: Real
@@ -115,9 +106,8 @@ function Base.:(*)(A::LinearMap, x::AbstractVector)
     y = similar(x, T, axes(A)[1])
     return mul!(y, A, x)
 end
-if VERSION ≥ v"1.3"
-    (L::LinearMap)(x::AbstractVector) = L*x
-end
+
+(L::LinearMap)(x::AbstractVector) = L*x
 
 """
     mul!(Y::AbstractVecOrMat, A::LinearMap, B::AbstractVector) -> Y
@@ -223,13 +213,9 @@ function mul!(Y::AbstractMatrix, A::LinearMap, X::AbstractMatrix, α::Number, β
 end
 
 function _generic_mapmat_mul!(Y, A, X, α=true, β=false)
-    @views for i in 1:size(X, 2)
-        _unsafe_mul!(Y[:, i], A, X[:, i], α, β)
+    for (Xi, Yi) in zip(eachcol(X), eachcol(Y))
+        mul!(Yi, A, Xi, α, β)
     end
-    # starting from Julia v1.1, we could use the `eachcol` iterator
-    # for (Xi, Yi) in zip(eachcol(X), eachcol(Y))
-    #     mul!(Yi, A, Xi, α, β)
-    # end
     return Y
 end
 

src/composition.jl

@@ -5,8 +5,7 @@ struct CompositeMap{T, As<:LinearMapTuple} <: LinearMap{T}
         for n in 2:N
             check_dim_mul(maps[n], maps[n-1])
         end
-        for TA in Base.Generator(eltype, maps)
-            # like lazy map; could use Base.Iterators.map in Julia >= 1.6
+        for TA in Base.Iterators.map(eltype, maps)
             promote_type(T, TA) == T ||
                 error("eltype $TA cannot be promoted to $T in CompositeMap constructor")
         end

src/kronecker.jl

@@ -1,7 +1,7 @@
 struct KroneckerMap{T, As<:LinearMapTuple} <: LinearMap{T}
     maps::As
     function KroneckerMap{T}(maps::LinearMapTuple) where {T}
-        for TA in Base.Generator(eltype, maps)
+        for TA in Base.Iterators.map(eltype, maps)
             promote_type(T, TA) == T ||
                 error("eltype $TA cannot be promoted to $T in KroneckerMap constructor")
         end
@@ -221,7 +221,7 @@ struct KroneckerSumMap{T, As<:Tuple{LinearMap, LinearMap}} <: LinearMap{T}
         A1, A2 = maps
         (size(A1, 1) == size(A1, 2) && size(A2, 1) == size(A2, 2)) ||
             throw(ArgumentError("operators need to be square in Kronecker sums"))
-        for TA in Base.Generator(eltype, maps)
+        for TA in Base.Iterators.map(eltype, maps)
             promote_type(T, TA) == T ||
                 error("eltype $TA cannot be promoted to $T in KroneckerSumMap constructor")
         end

src/linearcombination.jl

@@ -18,7 +18,7 @@ MulStyle(A::LinearCombination) = MulStyle(A.maps...)
 
 # basic methods
 Base.size(A::LinearCombination) = size(A.maps[1])
-Base.axes(A::LinearMaps.LinearCombination) = axes(A.maps[1])
+Base.axes(A::LinearCombination) = axes(A.maps[1])
 # following conditions are sufficient but not necessary
 LinearAlgebra.issymmetric(A::LinearCombination) = all(issymmetric, A.maps)
 LinearAlgebra.ishermitian(A::LinearCombination) = all(ishermitian, A.maps)

src/wrappedmap.jl

@@ -87,40 +87,38 @@ mul!(Y::AbstractMatrix, X::AbstractMatrix, A::VecOrMatMap) = mul!(Y, X, A.lmap)
 # the following method is needed for disambiguation with left-multiplication
 mul!(Y::AbstractMatrix, X::TransposeAbsVecOrMat, A::VecOrMatMap) = mul!(Y, X, A.lmap)
 
-if VERSION ≥ v"1.3.0-alpha.115"
-    for (In, Out) in ((AbstractVector, AbstractVecOrMat), (AbstractMatrix, AbstractMatrix))
-        @eval begin
-            function _unsafe_mul!(y::$Out, A::WrappedMap, x::$In, α::Number, β::Number)
-                return _unsafe_mul!(y, A.lmap, x, α, β)
-            end
-            function _unsafe_mul!(y::$Out, At::TransposeMap{<:Any,<:WrappedMap}, x::$In,
-                                    α::Number, β::Number)
-                A = At.lmap
-                return (issymmetric(A) || (isreal(A) && ishermitian(A))) ?
-                    _unsafe_mul!(y, A.lmap, x, α, β) :
-                    _unsafe_mul!(y, transpose(A.lmap), x, α, β)
-            end
-            function _unsafe_mul!(y::$Out, Ac::AdjointMap{<:Any,<:WrappedMap}, x::$In, α::Number, β::Number)
-                A = Ac.lmap
-                return ishermitian(A) ?
-                    _unsafe_mul!(y, A.lmap, x, α, β) :
-                    _unsafe_mul!(y, adjoint(A.lmap), x, α, β)
-            end
+for (In, Out) in ((AbstractVector, AbstractVecOrMat), (AbstractMatrix, AbstractMatrix))
+    @eval begin
+        function _unsafe_mul!(y::$Out, A::WrappedMap, x::$In, α::Number, β::Number)
+            return _unsafe_mul!(y, A.lmap, x, α, β)
+        end
+        function _unsafe_mul!(y::$Out, At::TransposeMap{<:Any,<:WrappedMap}, x::$In,
+                                α::Number, β::Number)
+            A = At.lmap
+            return (issymmetric(A) || (isreal(A) && ishermitian(A))) ?
+                _unsafe_mul!(y, A.lmap, x, α, β) :
+                _unsafe_mul!(y, transpose(A.lmap), x, α, β)
+        end
+        function _unsafe_mul!(y::$Out, Ac::AdjointMap{<:Any,<:WrappedMap}, x::$In, α::Number, β::Number)
+            A = Ac.lmap
+            return ishermitian(A) ?
+                _unsafe_mul!(y, A.lmap, x, α, β) :
+                _unsafe_mul!(y, adjoint(A.lmap), x, α, β)
         end
     end
+end
 
-    mul!(X::AbstractMatrix, Y::AbstractMatrix, A::VecOrMatMap, α::Number, β::Number) =
-        mul!(X, Y, A.lmap, α, β)
-    # the following method is needed for disambiguation with left-multiplication
-    function mul!(Y::AbstractMatrix{<:RealOrComplex}, X::AbstractMatrix{<:RealOrComplex}, A::VecOrMatMap{<:RealOrComplex},
-                    α::RealOrComplex, β::RealOrComplex)
-        return mul!(Y, X, A.lmap, α, β)
-    end
-    function mul!(Y::AbstractMatrix{<:RealOrComplex}, X::TransposeAbsVecOrMat{<:RealOrComplex}, A::VecOrMatMap{<:RealOrComplex},
-                    α::RealOrComplex, β::RealOrComplex)
-        return mul!(Y, X, A.lmap, α, β)
-    end
-end # VERSION
+mul!(X::AbstractMatrix, Y::AbstractMatrix, A::VecOrMatMap, α::Number, β::Number) =
+    mul!(X, Y, A.lmap, α, β)
+# the following 2 methods are needed for disambiguation with left-multiplication
+function mul!(Y::AbstractMatrix{<:RealOrComplex}, X::AbstractMatrix{<:RealOrComplex}, A::VecOrMatMap{<:RealOrComplex},
+                α::RealOrComplex, β::RealOrComplex)
+    return mul!(Y, X, A.lmap, α, β)
+end
+function mul!(Y::AbstractMatrix{<:RealOrComplex}, X::TransposeAbsVecOrMat{<:RealOrComplex}, A::VecOrMatMap{<:RealOrComplex},
+                α::RealOrComplex, β::RealOrComplex)
+    return mul!(Y, X, A.lmap, α, β)
+end
 
 # combine LinearMap and Matrix objects: linear combinations and map composition
 Base.:(+)(A₁::LinearMap, A₂::AbstractMatrix) = +(A₁, WrappedMap(A₂))

test/linearcombination.jl

@@ -38,33 +38,29 @@ using Test, LinearMaps, LinearAlgebra, SparseArrays, BenchmarkTools
     B = rand(ComplexF64, size(A)...)
     M = @inferred LinearMap(A)
     N = @inferred LinearMap(B)
-    @test @inferred(LinearMaps.MulStyle(M)) === matrixstyle
-    @test @inferred(LinearMaps.MulStyle(N)) === matrixstyle
+    @test @inferred(LinearMaps.MulStyle(M)) === FiveArg()
+    @test @inferred(LinearMaps.MulStyle(N)) === FiveArg()
     LC = @inferred M + N
-    @test @inferred(LinearMaps.MulStyle(LC)) === matrixstyle
-    @test @inferred(LinearMaps.MulStyle(LC + I)) === matrixstyle
-    @test @inferred(LinearMaps.MulStyle(LC + 2.0*I)) === matrixstyle
+    @test @inferred(LinearMaps.MulStyle(LC)) === FiveArg()
+    @test @inferred(LinearMaps.MulStyle(LC + I)) === FiveArg()
+    @test @inferred(LinearMaps.MulStyle(LC + 2.0*I)) === FiveArg()
     @test sparse(LC) == Matrix(LC) == A+B
     v = rand(ComplexF64, 10)
     w = similar(v)
     b = @benchmarkable mul!($w, $M, $v)
     @test run(b, samples=3).allocs == 0
-    if VERSION >= v"1.3.0-alpha.115"
-        b = @benchmarkable mul!($w, $LC, $v)
+    b = @benchmarkable mul!($w, $LC, $v)
+    @test run(b, samples=3).allocs == 0
+    for α in (false, true, rand(ComplexF64)), β in (false, true, rand(ComplexF64))
+        b = @benchmarkable mul!($w, $LC, $v, $α, $β)
         @test run(b, samples=3).allocs == 0
-        for α in (false, true, rand(ComplexF64)), β in (false, true, rand(ComplexF64))
-            if testallocs
-                b = @benchmarkable mul!($w, $LC, $v, $α, $β)
-                @test run(b, samples=3).allocs == 0
-                b = @benchmarkable mul!($w, $(I + LC), $v, $α, $β)
-                @test run(b, samples=3).allocs == 0
-                b = @benchmarkable mul!($w, $(LC + I), $v, $α, $β)
-                @test run(b, samples=3).allocs == 0
-            end
-            y = rand(ComplexF64, size(v))
-            @test mul!(copy(y), LC, v, α, β) ≈ Matrix(LC)*v*α + y*β
-            @test mul!(copy(y), LC+I, v, α, β) ≈ Matrix(LC + I)*v*α + y*β
-        end
+        b = @benchmarkable mul!($w, $(I + LC), $v, $α, $β)
+        @test run(b, samples=3).allocs == 0
+        b = @benchmarkable mul!($w, $(LC + I), $v, $α, $β)
+        @test run(b, samples=3).allocs == 0
+        y = rand(ComplexF64, size(v))
+        @test mul!(copy(y), LC, v, α, β) ≈ Matrix(LC)*v*α + y*β
+        @test mul!(copy(y), LC+I, v, α, β) ≈ Matrix(LC + I)*v*α + y*β
     end
     # @test_throws ErrorException LinearMaps.LinearCombination{ComplexF64}((M, N), (1, 2, 3))
     @test @inferred size(3M + 2.0N) == size(A)

test/linearmaps.jl

@@ -61,9 +61,7 @@ LinearAlgebra.mul!(y::AbstractVector, A::Union{SimpleFunctionMap,SimpleComplexFu
     α = rand(ComplexF64); β = rand(ComplexF64)
     v = rand(ComplexF64, 10); V = rand(ComplexF64, 10, 3)
     w = rand(ComplexF64, 10); W = rand(ComplexF64, 10, 3)
-    if VERSION ≥ v"1.3"
-        F(v) == F*v
-    end    
+    F(v) == F*v
     @test mul!(w, F, v) === w == F * v
     @test_throws ErrorException F' * v
     @test_throws ErrorException transpose(F) * v

test/runtests.jl

@@ -1,9 +1,5 @@
 using Test, LinearMaps, Aqua
-import LinearMaps: FiveArg, ThreeArg
-
-const matrixstyle = VERSION ≥ v"1.3.0-alpha.115" ? FiveArg() : ThreeArg()
-
-const testallocs = VERSION ≥ v"1.4-"
+using LinearMaps: FiveArg, ThreeArg
 
 @testset "code quality" begin
     Aqua.test_all(LinearMaps)
@@ -37,6 +33,4 @@ include("left.jl")
 
 include("fillmap.jl")
 
-if VERSION ≥ v"1.1"
-    include("nontradaxes.jl")
-end
+include("nontradaxes.jl")

test/uniformscalingmap.jl

@@ -30,10 +30,8 @@ using Test, LinearMaps, LinearAlgebra, BenchmarkTools
         Λ = @inferred LinearMap(λ*I, 10)
         x = rand(Float64, sz)
         y = rand(Float64, sz)
-        if testallocs
-            b = @benchmarkable mul!($y, $Λ, $x, $α, $β)
-            @test run(b, samples=3).allocs == 0
-        end
+        b = @benchmarkable mul!($y, $Λ, $x, $α, $β)
+        @test run(b, samples=3).allocs == 0
         y = deepcopy(x)
         @inferred mul!(y, Λ, x, α, β)
         @test y ≈ λ * x * α + β * x