Minor polish

Author: dkarrasch

docs/src/index.md

@@ -50,17 +50,17 @@ import Arpack, IterativeSolvers, KrylovKit, TSVD, ArnoldiMethod
 # Example 1, 1-dimensional Laplacian with periodic boundary conditions
 function leftdiff!(y::AbstractVector, x::AbstractVector) # left difference assuming periodic boundary conditions
     N = length(x)
-    length(y) == N || throw(DimensionMismatch())
-    @inbounds for i=1:N
+    axes(y) == axes(x) || throw(DimensionMismatch())
+    @inbounds for i in eachindex(x, y)
         y[i] = x[i] - x[mod1(i-1, N)]
     end
     return y
 end
 
 function mrightdiff!(y::AbstractVector, x::AbstractVector) # minus right difference
     N = length(x)
-    length(y) == N || throw(DimensionMismatch())
-    @inbounds for i=1:N
+    axes(y) == axes(x) || throw(DimensionMismatch())
+    @inbounds for i in eachindex(x, y)
         y[i] = x[i] - x[mod1(i+1, N)]
     end
     return y

docs/src/related.md

@@ -8,6 +8,7 @@ The following open-source packages provide similar or even extended functionalit
   [`LinearOperators.jl`](https://github.com/JuliaSmoothOptimizers/LinearOperators.jl)
   and the Python package [`PyLops`](https://github.com/equinor/pylops)
 * [`fastmat`: fast linear transforms in Python](https://pypi.org/project/fastmat/)
+* [`JOLI.jl`: Julia Operators LIbrary](https://github.com/slimgroup/JOLI.jl)
 * [`FunctionOperators.jl`](https://github.com/hakkelt/FunctionOperators.jl)
   and [`LinearMapsAA.jl`](https://github.com/JeffFessler/LinearMapsAA.jl)
   also support mappings between `Array`s, inspired by the `fatrix` object type in the
@@ -19,8 +20,10 @@ there exist further related packages in the Julia ecosystem:
 * [`LazyArrays.jl`](https://github.com/JuliaArrays/LazyArrays.jl)
 * [`BlockArrays.jl`](https://github.com/JuliaArrays/BlockArrays.jl)
 * [`BlockDiagonals.jl`](https://github.com/invenia/BlockDiagonals.jl)
+* [`BlockFactorizations.jl`](https://github.com/SebastianAment/BlockFactorizations.jl)
 * [`Kronecker.jl`](https://github.com/MichielStock/Kronecker.jl)
 * [`FillArrays.jl`](https://github.com/JuliaArrays/FillArrays.jl)
+* [`LiftedMaps.jl](https://github.com/krcools/LiftedMaps.jl)
 
 Since these packages provide types that are subtypes of Julia `Base`'s `AbstractMatrix` type,
 objects of those types can be wrapped by a `LinearMap` and freely mixed with, for instance,

src/blockmap.jl

@@ -26,7 +26,7 @@ MulStyle(A::BlockMap) = MulStyle(A.maps...)
 function _getranges(maps, dim, inds=1:length(maps))
     ends = map(i -> size(maps[i], dim)::Int, inds)
     cumsum!(ends, ends)
-    starts = vcat(1, 1 .+ @views ends[1:end-1])
+    starts = vcat(1, 1 .+ @views ends[firstindex(ends):lastindex(ends)-1])
     return UnitRange.(starts, ends)
 end
 
@@ -172,7 +172,7 @@ function Base.hvcat(rows::Tuple{Vararg{Int}},
         throw(ArgumentError("mismatch between row sizes and number of arguments"))
     n = fill(-1, length(As))
     j = 0
-    for i in 1:nr # infer UniformScaling sizes from row counts, if possible:
+    for i in eachindex(rows) # infer UniformScaling sizes from row counts, if possible:
         ni = -1 # number of rows in this block-row, -1 indicates unknown
         for k in 1:rows[i]
             if !isa(As[j+k], UniformScaling)
@@ -190,10 +190,10 @@ function Base.hvcat(rows::Tuple{Vararg{Int}},
     # check for consistent total column number
     nc = -1
     j = 0
-    for i in 1:nr
+    for i in eachindex(rows)
         nci = 0
         rows[i] > 0 && n[j+1] == -1 && (j += rows[i]; continue)
-        for k = 1:rows[i]
+        for k in 1:rows[i]
             nci += isa(As[j+k], UniformScaling) ? n[j+k] : size(As[j+k], 2)::Int
         end
         nc >= 0 && nc != nci && throw(DimensionMismatch("mismatch in number of columns"))
@@ -202,11 +202,11 @@ function Base.hvcat(rows::Tuple{Vararg{Int}},
     end
     nc == -1 && throw(ArgumentError("sizes of UniformScalings could not be inferred"))
     j = 0
-    for i in 1:nr
+    for i in eachindex(rows)
         if rows[i] > 0 && n[j+1] == -1 # this row consists entirely of UniformScalings
             nci, r = divrem(nc, rows[i])
             r != 0 && throw(DimensionMismatch("indivisible UniformScaling sizes"))
-            for k = 1:rows[i]
+            for k in 1:rows[i]
                 n[j+k] = nci
             end
         end

src/conversion.jl

@@ -28,7 +28,7 @@ function SparseArrays.sparse(A::LinearMap{T}) where {T}
     v = fill(zero(T), N)
     Av = Vector{T}(undef, M)
 
-    @inbounds for i in 1:N
+    @inbounds for i in eachindex(v, colptr)
         v[i] = one(T)
         _unsafe_mul!(Av, A, v)
         js = findall(!iszero, Av)