Properties

Properties

Size and Domains

Base.sizeFunction.

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

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

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

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

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

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

remove_displacement(A::AbstractOperator)

Removes the displacement of the operator.

source

Properties

is_linear(A::AbstractOperator)

Test whether A is a LinearOperator

julia> is_linear(Eye(2))
true

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

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

is_null(A::AbstractOperator)

Test whether A is null.

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

julia> is_null(Eye(10))
false
source

is_diagonal(A::AbstractOperator)

Test whether A is diagonal.

julia> is_diagonal(Eye(10))
true

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

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

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

is_orthogonal(A::AbstractOperator)

Test whether A is orthogonal.

julia> is_orthogonal(DCT(10))
true

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

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

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

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

is_sliced(A::AbstractOperator)

Test whether A is a sliced operator.

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