Remove 'evaluate' calls that are now superfluous

Author: asterycs

test/ForwardTest.jl

@@ -706,11 +706,7 @@ end
 
     expected = dc.BinaryOperation{dc.Mult}(Variable("y", Lower(1)), Variable("x", Lower(1)))
 
-    # TODO: simplify should be sufficient here - remove evaluate
-    @test equivalent(
-        dc.simplify(dc.evaluate(dc.diff(e, Variable("z", Upper(9))))),
-        expected,
-    )
+    @test equivalent(dc.simplify(dc.diff(e, Variable("z", Upper(9)))), expected)
 
     expected = dc.BinaryOperation{dc.Mult}(Variable("y", Upper(1)), Variable("x", Upper(1)))
     @test equivalent(dc.simplify(dc.diff(e, Variable("z", Upper(9)))'), expected)

test/RicciTest.jl

@@ -6,7 +6,6 @@ using DiffMatic
 using Test
 
 using DiffMatic: Variable, Literal, KrD, Zero
-using DiffMatic: evaluate
 using DiffMatic: Upper, Lower
 
 dc = DiffMatic
@@ -273,10 +272,10 @@ end
     A = Variable("A", Upper(1), Lower(2))
     B = Variable("B", Upper(1), Lower(2))
 
-    p1 = dc.evaluate(A * B)
-    p2 = dc.evaluate(A' * B)
-    p3 = dc.evaluate(A * B')
-    p4 = dc.evaluate(A' * B')
+    p1 = A * B
+    p2 = A' * B
+    p3 = A * B'
+    p4 = A' * B'
 
     @test length(dc.get_free_indices(p1)) == 2
     @test p1.arg1.indices[2].letter == p1.arg2.indices[1].letter
@@ -355,20 +354,20 @@ end
     op1 = A .* A
 
     @test typeof(op1) == dc.BinaryOperation{dc.Mult}
-    @test equivalent(evaluate(op1.arg1), Variable("A", Upper(1), Lower(2)))
-    @test equivalent(evaluate(op1.arg2), Variable("A", Upper(1), Lower(2)))
+    @test equivalent(op1.arg1, Variable("A", Upper(1), Lower(2)))
+    @test equivalent(op1.arg2, Variable("A", Upper(1), Lower(2)))
 
     op2 = A .* B
 
     @test typeof(op2) == dc.BinaryOperation{dc.Mult}
-    @test equivalent(evaluate(op2.arg1), Variable("A", Upper(3), Lower(4)))
-    @test equivalent(evaluate(op2.arg2), Variable("B", Upper(3), Lower(4)))
+    @test equivalent(op2.arg1, Variable("A", Upper(3), Lower(4)))
+    @test equivalent(op2.arg2, Variable("B", Upper(3), Lower(4)))
 
     op3 = A' .* B'
 
     @test typeof(op3) == dc.BinaryOperation{dc.Mult}
-    @test equivalent(evaluate(op3.arg1), Variable("A", Lower(1), Upper(2)))
-    @test equivalent(evaluate(op3.arg2), Variable("B", Lower(3), Upper(4)))
+    @test equivalent(op3.arg1, Variable("A", Lower(1), Upper(2)))
+    @test equivalent(op3.arg2, Variable("B", Lower(3), Upper(4)))
 end
 
 @testset "elementwise multiplication vector-vector" begin
@@ -378,20 +377,20 @@ end
     op1 = x .* x
 
     @test typeof(op1) == dc.BinaryOperation{dc.Mult}
-    @test equivalent(evaluate(op1.arg1), Variable("x", Upper(1)))
-    @test equivalent(evaluate(op1.arg2), Variable("x", Upper(1)))
+    @test equivalent(op1.arg1, Variable("x", Upper(1)))
+    @test equivalent(op1.arg2, Variable("x", Upper(1)))
 
     op2 = x .* y
 
     @test typeof(op2) == dc.BinaryOperation{dc.Mult}
-    @test equivalent(evaluate(op2.arg1), Variable("x", Upper(2)))
-    @test equivalent(evaluate(op2.arg2), Variable("y", Upper(2)))
+    @test equivalent(op2.arg1, Variable("x", Upper(2)))
+    @test equivalent(op2.arg2, Variable("y", Upper(2)))
 
     op3 = x' .* y'
 
     @test typeof(op3) == dc.BinaryOperation{dc.Mult}
-    @test equivalent(evaluate(op3.arg1), Variable("x", Lower(2)))
-    @test equivalent(evaluate(op3.arg2), Variable("y", Lower(2)))
+    @test equivalent(op3.arg1, Variable("x", Lower(2)))
+    @test equivalent(op3.arg2, Variable("y", Lower(2)))
 end
 
 @testset "elementwise multiplication with ambiguous input fails" begin
@@ -439,22 +438,22 @@ end
     x = Variable("x", Upper(1))
     y = Variable("y", Lower(1))
 
-    @test equivalent(evaluate(x'), Variable("x", Lower(1)))
-    @test equivalent(evaluate(y'), Variable("y", Upper(1)))
+    @test equivalent(x', Variable("x", Lower(1)))
+    @test equivalent(y', Variable("y", Upper(1)))
 end
 
 @testset "transpose KrD" begin
     d = KrD(Upper(1), Lower(2))
 
-    @test equivalent(evaluate(d'), KrD(Lower(1), Upper(2)))
+    @test equivalent(d', KrD(Lower(1), Upper(2)))
 end
 
 @testset "combined update_index and transpose vector" begin
     x = Variable("x", Upper(2))
 
     xt = x'
     x_indices = dc.get_free_indices(xt)
-    updated_transpose = evaluate(dc.update_index(xt, x_indices[1], Lower(1)))
+    updated_transpose = dc.update_index(xt, x_indices[1], Lower(1))
 
     @test equivalent(updated_transpose, Variable("x", Lower(1)))
 end
@@ -491,17 +490,16 @@ end
 @testset "transpose matrix" begin
     A = Variable("A", Upper(1), Lower(2))
 
-    At = evaluate(A')
-    @test equivalent(At, Variable("A", Lower(1), Upper(2)))
+    @test equivalent(A', Variable("A", Lower(1), Upper(2)))
 end
 
 @testset "transpose BinaryOperation{dc.Mult}" begin
     A = Variable("A", Upper(1), Lower(2))
     x = Variable("x", Upper(2))
 
-    op_t = evaluate((A * x)')
+    op_t = (A * x)'
     @test equivalent(
-        evaluate(op_t),
+        op_t,
         dc.BinaryOperation{dc.Mult}(
             Variable("A", Lower(1), Lower(2)),
             Variable("x", Upper(2)),
@@ -534,7 +532,7 @@ end
     B = Variable("B", Upper(2), Lower(3))
 
     @test equivalent(
-        evaluate(A + B),
+        A + B,
         dc.BinaryOperation{dc.Add}(
             Variable("A", Upper(1), Lower(2)),
             Variable("B", Upper(1), Lower(2)),
@@ -552,7 +550,7 @@ end
 
     for op ∈ (+, -)
         for args ∈ ((x, y), (A, B))
-            e = evaluate((op(args[1], args[2])))
+            e = op(args[1], args[2])
             @test e.arg1.indices == e.arg2.indices
         end
     end
@@ -565,7 +563,7 @@ end
 
     for op ∈ (+, -)
         for ags ∈ ((x, y), (x, z))
-            op_t = evaluate((op(x, y))')
+            op_t = op(x, y)'
             @test op_t.arg1.indices == op_t.arg2.indices
         end
     end

test/StdTest.jl

@@ -5,7 +5,6 @@ using DiffMatic
 using Test
 
 using DiffMatic: Variable, KrD, Zero
-using DiffMatic: evaluate
 using DiffMatic: Upper, Lower
 
 dc = DiffMatic
@@ -64,7 +63,7 @@ end
     b = Variable("b")
 
     function mult(l, r)
-        return evaluate(dc.BinaryOperation{dc.Mult}(l, r))
+        return dc.BinaryOperation{dc.Mult}(l, r)
     end
 
     @test to_std(mult(A, a)) == "aA"
@@ -87,7 +86,7 @@ end
     yt = Variable("y", Lower(1))
 
     function contract(l, r)
-        return evaluate(dc.BinaryOperation{dc.Mult}(l, r))
+        return dc.BinaryOperation{dc.Mult}(l, r)
     end
 
     @test to_std(contract(A, x)) == "Ax"
@@ -141,7 +140,7 @@ end
     y = Variable("y", Upper(1))
 
     function contract(l, r)
-        return evaluate(dc.BinaryOperation{dc.Mult}(l, r))
+        return dc.BinaryOperation{dc.Mult}(l, r)
     end
 
     @test to_std(contract(A, x)) == "xᵀAᵀ"
@@ -156,7 +155,7 @@ end
     y = Variable("y", Lower(1))
 
     function contract(l, r)
-        return evaluate(dc.BinaryOperation{dc.Mult}(l, r))
+        return dc.BinaryOperation{dc.Mult}(l, r)
     end
 
     @test to_std(contract(A, x)) == "Ax"
@@ -172,7 +171,7 @@ end
     D = Variable("D", Lower(3), Upper(2))
 
     function contract(l, r)
-        return evaluate(dc.BinaryOperation{dc.Mult}(l, r))
+        return dc.BinaryOperation{dc.Mult}(l, r)
     end
 
     @test to_std(contract(A, B)) == "AB"
@@ -191,10 +190,10 @@ end
 
     @test to_std(A .* B) == "A ⊙ B"
     @test to_std(A .* A) == "A ⊙ A"
-    @test to_std(dc.evaluate(A * (A .* B))) == "A(A ⊙ B)"
-    @test to_std(dc.evaluate((A .* B) * A)) == "(A ⊙ B)A"
-    @test to_std(dc.evaluate(A .* (A * B))) == "AB ⊙ A"
-    @test to_std(dc.evaluate((A * B) .* A)) == "AB ⊙ A"
+    @test to_std(A * (A .* B)) == "A(A ⊙ B)"
+    @test to_std((A .* B) * A) == "(A ⊙ B)A"
+    @test to_std(A .* (A * B)) == "AB ⊙ A"
+    @test to_std((A * B) .* A) == "AB ⊙ A"
 end
 
 @testset "to_std output is correct with matrix-matrix sum" begin
@@ -203,7 +202,7 @@ end
     C = Variable("C", Lower(2), Upper(1))
 
     function sum(l, r)
-        return evaluate(dc.BinaryOperation{dc.Add}(l, r))
+        return dc.BinaryOperation{dc.Add}(l, r)
     end
 
     @test to_std(sum(A, B)) == "A + B"
@@ -324,16 +323,16 @@ end
     y = Variable("y", Upper(2))
     a = Variable("a")
 
-    @test to_std(evaluate(a * sin.(x)' * y)) == "asin(xᵀ)y"
-    @test to_std(evaluate(sin.(x)' * a * y)) == "asin(xᵀ)y"
-    @test to_std(evaluate(sin.(x)' * y * a)) == "asin(xᵀ)y"
+    @test to_std(a * sin.(x)' * y) == "asin(xᵀ)y"
+    @test to_std(sin.(x)' * a * y) == "asin(xᵀ)y"
+    @test to_std(sin.(x)' * y * a) == "asin(xᵀ)y"
 end
 
 @testset "derivative interface checks" begin
     @matrix A
     @vector x
 
-    @test equivalent(derivative(x' * A * x, A), evaluate(x * x')) # scalar input works
+    @test equivalent(derivative(x' * A * x, A), x * x') # scalar input works
     @test equivalent(derivative(A * x, x), A) # vector input works
 end