Version history

What's new in v3.2

In-place left-multiplication mul!(Y, X, A::LinearMap) is now allowed for X::AbstractMatrix and implemented via the adjoint equation Y' = A'X'.

In Julia v1.3 and above, LinearMap-typed objects are callable on AbstractVectors: For L::LinearMap and x::AbstractVector, L(x) = L*x.

BREAKING change: Internally, any dependence on former A*_mul_B! methods is abandonned. For custom LinearMap subtypes, there are now two options:
1. In case your type is invariant under adjoint/transposition (i.e., adjoint(L::MyLinearMap)::MyLinearMap similar to, for instance, LinearCombinations or CompositeMaps, At_mul_B! and Ac_mul_B! do not require any replacement! Rather, multiplication by L' is, in this case, handled by mul!(y, L::MyLinearMap, x[, α, β]).
2. Otherwise, you will need to define mul! methods with the signature mul!(y, L::TransposeMap{<:Any,MyLinearMap}, x[, α, β]) and mul!(y, L::AdjointMap{<:Any,MyLinearMap}, x[, α, β]).
Left multiplying by a transpose or adjoint vector (e.g., y'*A) produces a transpose or adjoint vector output, rather than a composite LinearMap.
Block concatenation now handles matrices and vectors directly by internal promotion to LinearMaps. For [h/v/hc]cat it suffices to have a LinearMap object anywhere in the list of arguments. For the block-diagonal concatenation via SparseArrays.blockdiag, a LinearMap object has to appear among the first 8 arguments. This restriction, however, does not apply to block-diagonal concatenation via Base.cat(As...; dims=(1,2)).
Introduction of more expressive and visually appealing show methods, replacing the fallback to the generic show.

Potential reduction of memory allocations in multiplication of LinearCombinations, BlockMaps, and real- or complex-scaled LinearMaps. For the latter, a new internal type ScaledMap has been introduced.
Multiplication code for CompositeMaps has been refactored to facilitate to provide memory for storage of intermediate results by directly calling helper functions.

New feature: "lazy" Kronecker product, Kronecker sums, and powers thereof for LinearMaps. AbstractMatrix objects are promoted to LinearMaps if one of the first 8 Kronecker factors is a LinearMap object.
Compatibility with the generic multiply-and-add interface (a.k.a. 5-arg mul!) introduced in julia v1.3

New feature: concatenation of LinearMaps objects with UniformScalings, consistent with (h-, v-, and hc-)concatenation of matrices. Note, matrices A must be wrapped as LinearMap(A), UniformScalings are promoted to LinearMaps automatically.

Fully Julia v0.7/v1.0 compatible.
A convert(SparseMatrixCSC, A::LinearMap) function, that calls the sparse matrix generating function.

Fully Julia v0.7 compatible; dropped compatibility for previous versions of Julia from LinearMaps.jl v2.0.0 on.
A 5-argument version for mul!(y, A::LinearMap, x, α=1, β=0), which computes y := α * A * x + β * y and implements the usual 3-argument mul!(y, A, x) for the default α and β.
Synonymous convert(Matrix, A::LinearMap) and convert(Array, A::LinearMap) functions, that call the Matrix constructor and return the matrix representation of A.
Multiplication with matrices, interpreted as a block row vector of vectors:
- mul!(Y::AbstractArray, A::LinearMap, X::AbstractArray, α=1, β=0): applies A to each column of X and stores the result in-place in the corresponding column of Y;
- for the out-of-place multiplication, the approach is to compute convert(Matrix, A * X); this is equivalent to applying A to each column of X. In generic code which handles both A::AbstractMatrix and A::LinearMap, the additional call to convert is a noop when A is a matrix.
Full compatibility with Arpack.jl's eigs and svds; previously only eigs was working. For more, nicely collaborating packages see the Example section.