tests

Author: vpuri3

test/basic.jl

@@ -33,6 +33,7 @@ K = 12
 
     @test size(Id) == (N, N)
     @test Id' isa IdentityOperator{N}
+    @test isconstant(Id)
 
     for op in (
                *, \,
@@ -62,6 +63,7 @@ end
     Z = NullOperator{N}()
 
     @test NullOperator(u) isa NullOperator{N}
+    @test isconstant(Z)
     @test zero(A) isa NullOperator{N}
     @test convert(AbstractMatrix, Z) == zeros(size(Z))
 
@@ -99,13 +101,15 @@ end
     op = ScaledOperator(α, MatrixOperator(A))
 
     @test op isa ScaledOperator
+    @test isconstant(op)
 
     @test α * A * u ≈ op * u
     @test (β * op) * u ≈ β * α * A * u
 
     opF = factorize(op)
 
     @test opF isa ScaledOperator
+    @test isconstant(opF)
 
     @test α * A  ≈ convert(AbstractMatrix, op) ≈ convert(AbstractMatrix, opF)
 
@@ -138,6 +142,11 @@ end
         @test op3 isa AddedOperator
         @test op4 isa AddedOperator
 
+        @test isconstant(op1)
+        @test isconstant(op2)
+        @test isconstant(op3)
+        @test isconstant(op4)
+
         @test op1 * u ≈ op(  A*u,   B*u)
         @test op2 * u ≈ op(α*A*u,   B*u)
         @test op3 * u ≈ op(  A*u, β*B*u)
@@ -163,11 +172,14 @@ end
     op = ∘(MatrixOperator.((A, B, C))...)
 
     @test op isa ComposedOperator
+    @test isconstant(op)
+
     @test *(op.ops...) isa ComposedOperator
 
     opF = factorize(op)
 
     @test opF isa ComposedOperator
+    @test isconstant(opF)
 
     @test ABCmulu ≈ op * u
     @test ABCdivu ≈ op \ u ≈ opF \ u
@@ -223,6 +235,9 @@ end
         AAt = LType(AA)
         DDt = LType(DD)
 
+        @test isconstant(AAt)
+        @test isconstant(DDt)
+
         @test AAt.L === AA
         @test op(u) isa VType
 
@@ -247,6 +262,8 @@ end
 
     Di = cache_operator(Di, u)
 
+    @test isconstant(Di)
+
     @test Di * u ≈ u ./ s
     v=rand(N); @test mul!(v, Di, u) ≈ u ./ s
     v=rand(N); w=copy(v); @test mul!(v, Di, u, α, β) ≈ α *(u ./ s) + β*w

test/matrix.jl

@@ -24,12 +24,18 @@ K = 19
     @test AA  isa MatrixOperator
     @test AAt isa MatrixOperator
 
+    @test isconstant(AA)
+    @test isconstant(AAt)
+
     FF  = factorize(AA)
     FFt = FF'
 
     @test FF  isa InvertibleOperator
     @test FFt isa InvertibleOperator
 
+    @test isconstant(FF)
+    @test isconstant(FFt)
+
     @test eachindex(A)  === eachindex(AA)
     @test eachindex(A') === eachindex(AAt) === eachindex(MatrixOperator(At))
 
@@ -55,9 +61,11 @@ end
     t = rand()
 
     L = MatrixOperator(zeros(N,N);
-                       update_func= (A,u,p,t) -> (A .= p*p'; nothing)
+                       update_func = (A,u,p,t) -> (A .= p*p'; nothing)
                       )
 
+    @test !isconstant(L)
+
     A = p*p'
     ans = A * u
     @test L(u,p,t) ≈ ans
@@ -70,9 +78,11 @@ end
     t = rand()
 
     D = DiagonalOperator(zeros(N);
-                         update_func= (diag,u,p,t) -> (diag .= p*t; nothing)
+                         update_func = (diag,u,p,t) -> (diag .= p*t; nothing)
                         )
 
+    @test !isconstant(D)
+
     ans = Diagonal(p*t) * u
     @test D(u,p,t) ≈ ans
     v=copy(u); @test D(v,u,p,t) ≈ ans
@@ -85,6 +95,7 @@ end
     β = rand()
 
     L = DiagonalOperator(d)
+    @test isconstant(L)
 
     @test L * u ≈ d .* u
     v=rand(N,K); @test mul!(v, L, u) ≈ d .* u
@@ -105,6 +116,7 @@ end
     β = rand()
 
     L = AffineOperator(MatrixOperator(A), MatrixOperator(B), b)
+    @test isconstant(L)
 
     @test L * u ≈ A * u + B*b
     v=rand(N,K); @test mul!(v, L, u) ≈ A*u + B*b
@@ -141,9 +153,11 @@ end
     t = rand()
 
     L = AffineOperator(A, B, b;
-                       update_func= (b,u,p,t) -> (b .= Diagonal(p*t)*b; nothing)
+                       update_func = (b,u,p,t) -> (b .= Diagonal(p*t)*b; nothing)
                       )
 
+    @test !isconstant(L)
+
     b = Diagonal(p*t)*b
     ans = A * u + B * b
     @test L(u,p,t) ≈ ans
@@ -188,13 +202,19 @@ for square in [false, true] #for K in [1, K]
     @test opAB  isa TensorProductOperator
     @test opABC isa TensorProductOperator
 
+    @test isconstant(opAB)
+    @test isconstant(opABC)
+
     @test AB ≈ convert(AbstractMatrix, opAB)
     @test ABC ≈ convert(AbstractMatrix, opABC)
 
     # factorization tests
     opAB_F = factorize(opAB)
     opABC_F = factorize(opABC)
 
+    @test isconstant(opAB_F)
+    @test isconstant(opABC_F)
+
     @test opAB_F isa TensorProductOperator
     @test opABC_F isa TensorProductOperator
 

test/scalar.jl

@@ -18,6 +18,7 @@ K = 12
     @test convert(ScalarOperator, a) isa ScalarOperator
 
     @test size(α) == ()
+    @test isconstant(α)
 
     v=copy(u); @test lmul!(α, u) ≈ v * x
     v=copy(u); @test rmul!(u, α) ≈ x * v
@@ -64,6 +65,9 @@ end
     α = ScalarOperator(0.0; update_func=(a,u,p,t) -> p)
     β = ScalarOperator(0.0; update_func=(a,u,p,t) -> t)
 
+    @test !isconstant(α)
+    @test !isconstant(β)
+
     @test α(u,p,t)   ≈ p * u
     @test α(v,u,p,t) ≈ p * u