Merge pull request #7 from SymbolicML/equality-operator

Add equality operator

Author: MilesCranmer

Project.toml

@@ -1,7 +1,7 @@
 name = "DynamicExpressions"
 uuid = "a40a106e-89c9-4ca8-8020-a735e8728b6b"
 authors = ["MilesCranmer <miles.cranmer@gmail.com>"]
-version = "0.2.3"
+version = "0.3.0"
 
 [deps]
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"

src/DynamicExpressions.jl

@@ -31,4 +31,11 @@ using Reexport
 @reexport import .InterfaceSymbolicUtilsModule: node_to_symbolic, symbolic_to_node
 @reexport import .SimplifyEquationModule: combine_operators, simplify_tree
 
+import TOML: parsefile
+
+const PACKAGE_VERSION = let
+    project = parsefile(joinpath(pkgdir(@__MODULE__), "Project.toml"))
+    VersionNumber(project["version"])
+end
+
 end

src/Equation.jl

@@ -396,4 +396,34 @@ function Base.hash(tree::Node{T})::UInt where {T}
     end
 end
 
+function is_equal(a::Node{T}, b::Node{T})::Bool where {T}
+    if a.degree == 0
+        b.degree != 0 && return false
+        if a.constant
+            !(b.constant) && return false
+            return a.val::T == b.val::T
+        else
+            b.constant && return false
+            return a.feature == b.feature
+        end
+    elseif a.degree == 1
+        b.degree != 1 && return false
+        a.op != b.op && return false
+        return is_equal(a.l, b.l)
+    else
+        b.degree != 2 && return false
+        a.op != b.op && return false
+        return is_equal(a.l, b.l) && is_equal(a.r, b.r)
+    end
+end
+
+function Base.:(==)(a::Node{T}, b::Node{T})::Bool where {T}
+    return is_equal(a, b)
+end
+
+function Base.:(==)(a::Node{T1}, b::Node{T2})::Bool where {T1,T2}
+    T = promote_type(T1, T2)
+    return is_equal(convert(Node{T}, a), convert(Node{T}, b))
+end
+
 end

test/test_equality.jl

@@ -0,0 +1,44 @@
+using DynamicExpressions
+using Test
+
+operators = OperatorEnum(;
+    binary_operators=[+, *, -, /], unary_operators=[sin, cos, exp, log]
+)
+
+# Create a big expression, using those operators:
+x1 = Node(; feature=1)
+x2 = Node(; feature=2)
+x3 = Node(; feature=3)
+
+tree = x1 + x2 * x3 - log(x2 * 3.2) + 1.5 * cos(x2 / x1)
+same_tree = x1 + x2 * x3 - log(x2 * 3.2) + 1.5 * cos(x2 / x1)
+@test tree == same_tree
+
+copied_tree = copy_node(tree; preserve_topology=true)
+@test tree == copied_tree
+
+copied_tree2 = copy_node(tree; preserve_topology=false)
+@test tree == copied_tree2
+
+modifed_tree = x1 + x2 * x1 - log(x2 * 3.2) + 1.5 * cos(x2 / x1)
+@test tree != modifed_tree
+modifed_tree2 = x1 + x2 * x3 - log(x2 * 3.1) + 1.5 * cos(x2 / x1)
+@test tree != modifed_tree2
+modifed_tree3 = x1 + x2 * x3 - exp(x2 * 3.2) + 1.5 * cos(x2 / x1)
+@test tree != modifed_tree3
+modified_tree4 = x1 + x2 * x3 - log(x2 * 3.2) + 1.5 * cos(x2 * x1)
+@test tree != modified_tree4
+
+# Order matters!
+modified_tree5 = 1.5 * cos(x2 * x1) + x1 + x2 * x3 - log(x2 * 3.2)
+@test tree != modified_tree5
+
+# Type should not matter if equivalent in the promoted type:
+f64_tree = x1 + x2 * x3 - log(x2 * 3.0) + 1.5 * cos(x2 / x1)
+f32_tree = x1 + x2 * x3 - log(x2 * 3.0f0) + 1.5f0 * cos(x2 / x1)
+@test typeof(f64_tree) == Node{Float64}
+@test typeof(f32_tree) == Node{Float32}
+
+@test convert(Node{Float64}, f32_tree) == f64_tree
+
+@test f64_tree == f32_tree

test/unittest.jl

@@ -55,3 +55,7 @@ end
 @safetestset "Test error handling" begin
     include("test_error_handling.jl")
 end
+
+@safetestset "Test equality operator" begin
+    include("test_equality.jl")
+end