Properties

Size and Domains

Base.size — Function.

size(A::AbstractOperator, [dom,])

Returns the size of an AbstractOperator. Type size(A,1) for the size of the codomain and size(A,2) for the size of the codomain.

source

Base.ndims — Function.

ndims(A::AbstractOperator, [dom,])

Returns a Tuple with the number of dimensions of the codomain and domain of an AbstractOperator. Type ndims(A,1) for the number of dimensions of the codomain and ndims(A,2) for the number of dimensions of the codomain.

source

AbstractOperators.ndoms — Function.

ndoms(L::AbstractOperator, [dom::Int]) -> (number of codomains, number of domains)

Returns the number of codomains and domains of a AbstractOperator. Optionally you can specify the codomain (with dom = 1) or the domain (with dom = 2)

julia > ndoms(DFT(10,10))
(1,1)

julia> ndoms(hcat(DFT(10,10),DFT(10,10)))
(1, 2)

julia> ndoms(hcat(DFT(10,10),DFT(10,10)),2)
2

julia> ndoms(DCAT(DFT(10,10),DFT(10,10)))
(2,2)

source

AbstractOperators.domainType — Function.

domainType(A::AbstractOperator)

Returns the type of the domain.

julia> domainType(DFT(10))
Float64

julia> domainType(hcat(Eye(Complex{Float64},(10,)),DFT(Complex{Float64},10)))
(Complex{Float64}, Complex{Float64})

source

AbstractOperators.codomainType — Function.

codomainType(A::AbstractOperator)

Returns the type of the codomain.

julia> codomainType(DFT(10))
Complex{Float64}

julia> codomainType(vcat(Eye(Complex{Float64},(10,)),DFT(Complex{Float64},10)))
(Complex{Float64}, Complex{Float64})

source

AbstractOperators.displacement — Function.

displacement(A::AbstractOperator)

Returns the displacement of the operator.

julia> A = AffineAdd(Eye(4),[1.;2.;3.;4.])
I+d  ℝ^4 -> ℝ^4

julia> displacement(A)
4-element Array{Float64,1}:
 1.0
 2.0
 3.0
 4.0

source

AbstractOperators.remove_displacement — Function.

remove_displacement(A::AbstractOperator)

Removes the displacement of the operator.

source

Properties

AbstractOperators.is_linear — Function.

is_linear(A::AbstractOperator)

Test whether A is a LinearOperator

julia> is_linear(Eye(2))
true

julia> is_linear(Sigmoid(Float64,(2,)))
false

source

AbstractOperators.is_eye — Function.

is_eye(A::AbstractOperator)

Test whether A is an Identity operator

julia> is_eye(Eye(10))
true

julia> is_eye(Zeros(Float64,(10,),(10,)))
false

source

AbstractOperators.is_null — Function.

is_null(A::AbstractOperator)

Test whether A is null.

julia> is_null(Zeros(Float64,(10,),(10,)))
true

julia> is_null(Eye(10))
false

source

AbstractOperators.is_diagonal — Function.

is_diagonal(A::AbstractOperator)

Test whether A is diagonal.

julia> is_diagonal(Eye(10))
true

julia> is_diagonal(FiniteDiff((10,)))
false

source

AbstractOperators.is_AcA_diagonal — Function.

is_AcA_diagonal(A::AbstractOperator)

Test whether A'*A is diagonal.

julia> is_AcA_diagonal(Eye(10))
true

julia> is_AcA_diagonal(GetIndex((10,),1:3))
false

source

AbstractOperators.is_AAc_diagonal — Function.

is_AAc_diagonal(A::AbstractOperator)

Test whether A*A' is diagonal.

julia> is_AAc_diagonal(Eye(10))
true

julia> is_AAc_diagonal(GetIndex((10,),1:3))
false

source

AbstractOperators.is_orthogonal — Function.

is_orthogonal(A::AbstractOperator)

Test whether A is orthogonal.

julia> is_orthogonal(DCT(10))
true

julia> is_orthogonal(MatrixOp(randn(3,4)))
false

source

AbstractOperators.is_invertible — Function.

is_invertable(A::AbstractOperator)

Test whether A is easily invertable.

julia> is_invertible(DFT(10))
true

julia> is_invertable(MatrixOp(randn(3,4)))
false

source

AbstractOperators.is_full_row_rank — Function.

is_full_row_rank(A::AbstractOperator)

Test whether A is easily invertable.

julia> is_full_row_rank(MatrixOp(randn(3,4)))
true

julia> is_full_row_rank(MatrixOp(randn(4,3)))
false

source

AbstractOperators.is_full_column_rank — Function.

is_full_row_rank(A::AbstractOperator)

Test whether A is easily invertable.

julia> is_full_column_rank(MatrixOp(randn(4,3)))
true

julia> is_full_column_rank(MatrixOp(randn(3,4)))
false

source

AbstractOperators.is_sliced — Function.

is_sliced(A::AbstractOperator)

Test whether A is a sliced operator.

julia> is_sliced(GetIndex((10,), 1:5))
true

source