Edit on GitHub

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

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_invertible(A::AbstractOperator)

Test whether A is easily invertible.

julia> is_invertible(DFT(10))
true

julia> is_invertible(MatrixOp(randn(3,4)))
false
source
AbstractOperators.is_full_row_rank — Function

is_full_row_rank(A::AbstractOperator)

Test whether A is easily invertible.

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 invertible.

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

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