added is_sliced

Author: nantonel

docs/src/properties.md

@@ -23,4 +23,5 @@ is_orthogonal
 is_invertible
 is_full_row_rank
 is_full_column_rank
+is_sliced
 ```

src/calculus/Compose.jl

@@ -104,9 +104,15 @@ domainType(L::Compose)   = domainType(L.A[1])
 codomainType(L::Compose) = codomainType(L.A[end])
 
 is_linear(L::Compose) = all(is_linear.(L.A))
-is_diagonal(L::Compose) = all(is_diagonal.(L.A))
+is_diagonal(L::Compose) = is_sliced(L) ? (length(L.A) == 2 && is_diagonal(L.A[2])) : all(is_diagonal.(L.A))
 is_invertible(L::Compose) = all(is_invertible.(L.A))
 
+is_sliced(L::Compose) = typeof(L.A[1]) <: GetIndex
+is_AAc_diagonal(L::Compose)  = is_sliced(L) && length(L.A) == 2 && is_AAc_diagonal(L.A[2])
+
+diag(L::Compose) = is_sliced(L) ? diag(L.A[2]) : prod(diag.(L.A))
+diag_AAc(L::Compose) = is_AAc_diagonal(L) ? diag_AAc(L.A[2]) : error("is_AAc_diagonal( $(typeof(L) ) ) == false")
+
 # utils
 import Base: permute
 function permute(C::Compose{N,M,L,T}, p::AbstractVector{Int}) where {N,M,L,T}

src/linearoperators/DFT.jl

@@ -186,8 +186,8 @@ is_invertible(L::FourierTransform)       = true
 is_full_row_rank(L::FourierTransform)    = true
 is_full_column_rank(L::FourierTransform) = true
 
-diag_AcA(L::DFT) = prod(size(L,1))
-diag_AAc(L::DFT) = prod(size(L,1))
+diag_AcA(L::DFT) = float(prod(size(L,1)))
+diag_AAc(L::DFT) = float(prod(size(L,1)))
 
 diag_AcA(L::IDFT) = 1/prod(size(L,1))
 diag_AAc(L::IDFT) = 1/prod(size(L,1))

src/linearoperators/GetIndex.jl

@@ -73,7 +73,7 @@ fun_name(L::GetIndex) = "↓"
 
 is_AAc_diagonal(L::GetIndex)   = true
 is_full_row_rank(L::GetIndex)  = true
-
+is_sliced(L::GetIndex)   = true
 
 # Utils
 

src/linearoperators/MIMOFilt.jl

@@ -7,9 +7,12 @@ export MIMOFilt
 
 Creates a `LinearOperator` which, when multiplied with a matrix `X`, returns a matrix `Y`. Here a Multiple Input Multiple Output system is evaluated: the columns of `X` and `Y` represent the input signals and output signals respectively. 
 
-`Y[:,i] = ∑j h_{i,j} ⋆ X[:,j]`
+```math
+\\mathbf{y}_i = \\sum_{j = 1}^{M} \\mathbf{h}_{i,j} * \\mathbf{x}_j 
+```
+where ``\\mathbf{y}_i`` and ``\\mathbf{x}_j`` are the ``i``-th and ``j``-th columns of the output `Y` and input `X` matrices respectively.
 
-The filters `h` can be represented either by providing coefficients `B` and `A` (IIR) or `B` alone (FIR). These coefficients must be given in a `Vector` of `Vector`s. 
+The filters ``\\mathbf{h}_{i,j}`` can be represented either by providing coefficients `B` and `A` (IIR) or `B` alone (FIR). These coefficients must be given in a `Vector` of `Vector`s. 
 
 For example for a `3` by `2` MIMO system (i.e. `size(X,2) == 3` inputs and `size(Y,2) == 2` outputs) `B` must be:
 

src/properties.jl

@@ -14,6 +14,7 @@ export ndoms,
        is_invertible,
        is_full_row_rank,
        is_full_column_rank,
+       is_sliced,
        diag_AcA, 
        diag_AAc
 
@@ -253,6 +254,19 @@ false
 """
 is_full_column_rank(L::AbstractOperator) = false
 
+"""
+`is_sliced(A::AbstractOperator)`
+
+Test whether `A` is a sliced operator.
+
+```julia
+julia> is_sliced(GetIndex((10,), 1:5))
+true
+
+```
+"""
+is_sliced(L::AbstractOperator) = false
+
 
 import Base: convert
 function convert(::Type{T}, dom::Type, dim_in::Tuple, L::T) where {T <: AbstractOperator}

test/test_linear_operators.jl

@@ -482,6 +482,7 @@ op = GetIndex(Float64,(n,m),(1:n,1:m))
 op = GetIndex(Float64,(n,),(1:k,))
 
 ##properties
+@test is_sliced(op)           == true
 @test is_linear(op)           == true
 @test is_null(op)             == false
 @test is_eye(op)              == false

test/test_linear_operators_calculus.jl

@@ -45,6 +45,7 @@ opS2 = Scale(pi,opA2)
 @test typeof(opS2*opS1) <: Scale
 
 #properties
+@test is_sliced(opC)            == false
 @test is_linear(opC1)           == true
 @test is_null(opC1)             == false
 @test is_eye(opC1)              == false
@@ -56,6 +57,18 @@ opS2 = Scale(pi,opA2)
 @test is_full_row_rank(opC1)    == false
 @test is_full_column_rank(opC1) == false
 
+# properties special case
+opC = DCT((5,))*GetIndex((10,), 1:5)
+@test is_sliced(opC)           == true
+@test is_AAc_diagonal(opC)     == true
+@test diag_AAc(opC)            == 1.0
+
+d = randn(5)
+opC = DiagOp(d)*GetIndex((10,), 1:5)
+@test is_sliced(opC)           == true
+@test is_diagonal(opC)         == true
+@test diag(opC)                == d
+
 ###########################
 ###### test DCAT    #######
 ###########################