GitHub

Methods list

Methods usage

LinearMapsAA.LinearMapAX — Type
struct LinearMapAX{T,Do,Di,LM,P}

Union of LinearMapAM and LinearMapAO because most operations apply to both AM and AO types.

  • T : eltype
  • Do : output dimensionality
  • Di : input dimensionality
  • LM : LinearMap type
  • P : NamedTuple type
source
LinearMapsAA.LinearMapAM — Type
struct LinearMapAM{T,Do,Di,LM,P} <: AbstractMatrix{T}

"matrix" version that is quite akin to a matrix in its behavior

source
LinearMapsAA.LinearMapAO — Type
struct LinearMapAO{T,Do,Di,LM,P}

"Tensor" version that can map from arrays to arrays. (It is not a subtype of AbstractArray.)

source
LinearMapsAA.LinearMapAO — Method
B = LinearMapAO(A::LinearMapAX)

Make an AO from an AM, despite idim and odim being 1D, for expert users who want B*X to be an Array. Somewhat an opposite of undim.

source
Base.:* — Method
*(I, X) = X
*(J, X) = J.λ * X

Extends the effect of I::UniformScaling and scaled versions thereof to also apply to X::AbstractArray instead of just to Vector and Matrix types.

source
Base.:* — Method
*(A::LinearMapAO, xv::AbstractVector{<:AbstractArray}) = [A * x for x in xv]

Fancy multiply when xv is a Vector of AbstractArrays of appropriate size.

source
Base.hcat — Method
hcat(As::LinearMapAO... ; tryop::Bool=true)

hcat with (by default) attempt to append nblock to idim if consistent blocks.

source
Base.hvcat — Method
hvcat(rows, As::LinearMapAO...)

hvcat that discards special idim and odim information (too hard!) # todo?

source
Base.kron — Method
kron(A::LinearMapAX, M::AbstractMatrix)
kron(M::AbstractMatrix, A::LinearMapAX)
kron(A::LinearMapAX, B::LinearMapAX)

Kronecker products

Returns a LinearMapAO with appropriate idim and odim if either argument is a LinearMapAO else returns a LinearMapAM

source
Base.show — Method
show(io::IO, A::LinearMapAX)
show(io::IO, ::MIME"text/plain", A::LinearMapAX)

Pretty printing for display

source
Base.vcat — Method
vcat(As::LinearMapAO... ; tryop::Bool=true)

vcat with (by default) attempt to append nblock to odim if consistent blocks.

source
LinearAlgebra.mul! — Method
 mul!(yv, AO::LinearMapAO, xv, α, β)

Fancy 5-arg multiply when yv and xv are each a Vector of AbstractArrays. Basically does mul!(yv[i], A, xv[i], α, β) for i in 1:length(xv).

source
LinearMapsAA.LinearMapAA — Method
A = LinearMapAA(f::Function, fc::Function, D::Dims{2} [, prop::NamedTuple)]
; T::Type = Float32, idim::Dims, odim::Dims)

Constructor given forward f and adjoint function fc.

source
LinearMapsAA.LinearMapAA — Method
A = LinearMapAA(f::Function, D::Dims{2} [, prop::NamedTuple]; kwargs...)

Constructor given just forward function f.

source
LinearMapsAA.LinearMapAA — Method
A = LinearMapAA(L::LinearMap ; ...)

Constructor for LinearMapAM or LinearMapAO given a LinearMap.

Options

  • prop::NamedTuple = NamedTuple(); cannot include the fields _lmap, _prop, _idim, _odim
  • T::Type = eltype(L)
  • idim::Dims = (size(L,2),)
  • odim::Dims = (size(L,1),)
  • operator::Bool by default: false if both idim & odim are 1D.

Output A is LinearMapAO if operator is true, else LinearMapAM.

source
LinearMapsAA.block_diag — Method
B = block_diag(As::LinearMapAX... ; tryop::Bool)

Make block diagonal LinearMapAX object from blocks.

Return a LinearMapAM unless tryop and all blocks have same idim and odim.

Default for tryop is true if all blocks are type LinearMapAO.

source
LinearMapsAA.lmao_mul! — Method
 lmao_mul!(Y, A, X, α, β ; idim, odim)

Core routine for 5-arg multiply. If A._idim = (2,3,4) and A._odim = (5,6) and if input X has size (2,3,4, 7,8) then output Y will have size (5,6, 7,8)

source
LinearMapsAA.redim — Method
redim(A::LinearMapAX ; idim::Dims=A._idim, odim::Dims=A._odim)

"Reinterpret" the idim and odim of A

source