Rename "topology" to "sharing"

Author: MilesCranmer

benchmark/benchmarks.jl

@@ -85,19 +85,19 @@ function benchmark_utilities()
     options = Options(; binary_operators=[+, -, /, *], unary_operators=[cos, exp])
     for func_k in ("copy", "convert", "simplify_tree", "combine_operators")
         suite[func_k] = let s = BenchmarkGroup()
-            for k in ("break_topology", "preserve_topology")
-                k == "preserve_topology" &&
+            for k in ("break_sharing", "preserve_sharing")
+                k == "preserve_sharing" &&
                     func_k in ("simplify_tree", "combine_operators") &&
                     continue
 
                 f = if func_k == "copy"
-                    tree -> copy_node(tree; preserve_topology=(k == "preserve_topology"))
+                    tree -> copy_node(tree; preserve_sharing=(k == "preserve_sharing"))
                 elseif func_k == "convert"
                     if v_PACKAGE_VERSION >= v"0.6.1"
                         tree -> convert(
                             Node{Float64},
                             tree;
-                            preserve_topology=(k == "preserve_topology"),
+                            preserve_sharing=(k == "preserve_sharing"),
                         )
                     else
                         tree -> convert(Node{Float64}, tree)

src/Equation.jl

@@ -74,12 +74,12 @@ using `convert(T1, tree.val)` at constant nodes.
 - `tree::Node{T2}`: Node to convert.
 """
 function Base.convert(
-    ::Type{Node{T1}}, tree::Node{T2}; preserve_topology::Bool=false
+    ::Type{Node{T1}}, tree::Node{T2}; preserve_sharing::Bool=false
 ) where {T1,T2}
     if T1 == T2
         return tree
     end
-    if preserve_topology
+    if preserve_sharing
         @use_idmap(_convert(Node{T1}, tree), IdDict{Node{T2},Node{T1}}())
     else
         _convert(Node{T1}, tree)
@@ -225,11 +225,11 @@ function set_node!(tree::Node{T}, new_tree::Node{T}) where {T}
 end
 
 """
-    copy_node(tree::Node; preserve_topology::Bool=false)
+    copy_node(tree::Node; preserve_sharing::Bool=false)
 
 Copy a node, recursively copying all children nodes.
 This is more efficient than the built-in copy.
-With `preserve_topology=true`, this will also
+With `preserve_sharing=true`, this will also
 preserve linkage between a node and
 multiple parents, whereas without, this would create
 duplicate child node copies.
@@ -241,8 +241,8 @@ we can simply reference the existing copy.
 
 Note that this will *not* preserve loops in graphs.
 """
-function copy_node(tree::Node{T}; preserve_topology::Bool=false)::Node{T} where {T}
-    if preserve_topology
+function copy_node(tree::Node{T}; preserve_sharing::Bool=false)::Node{T} where {T}
+    if preserve_sharing
         @use_idmap(_copy_node(tree), IdDict{Node{T},Node{T}}())
     else
         _copy_node(tree)
@@ -406,7 +406,7 @@ end
 
 function Base.:(==)(a::Node{T1}, b::Node{T2})::Bool where {T1,T2}
     T = promote_type(T1, T2)
-    # TODO: Should also have preserve_topology check...
+    # TODO: Should also have preserve_sharing check...
     return is_equal(convert(Node{T}, a), convert(Node{T}, b))
 end
 

src/precompile.jl

@@ -144,9 +144,9 @@ function test_functions_on_trees(::Type{T}, operators) where {T}
         tree = Node(i_bin, a8, a7)
     end
     tree = convert(Node{T}, tree)
-    for preserve_topology in [true, false]
-        tree = copy_node(tree; preserve_topology)
-        set_node!(tree, copy_node(tree; preserve_topology))
+    for preserve_sharing in [true, false]
+        tree = copy_node(tree; preserve_sharing)
+        set_node!(tree, copy_node(tree; preserve_sharing))
     end
 
     string_tree(tree, operators)

test/test_equality.jl

@@ -14,10 +14,10 @@ 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)
+copied_tree = copy_node(tree; preserve_sharing=true)
 @test tree == copied_tree
 
-copied_tree2 = copy_node(tree; preserve_topology=false)
+copied_tree2 = copy_node(tree; preserve_sharing=false)
 @test tree == copied_tree2
 
 modifed_tree = x1 + x2 * x1 - log(x2 * 3.2) + 1.5 * cos(x2 / x1)

test/test_preserve_multiple_parents.jl

@@ -26,42 +26,42 @@ include("test_params.jl")
     @test tree.l.l === tree.r
     @test hash(tree.l.l) == hash(tree.r)
 
-    # When we copy with the normal copy, the topology breaks:
-    copy_without_topology = copy_node(tree)
-    @test !(copy_without_topology.l.l === copy_without_topology.r)
+    # When we copy with the normal copy, the sharing breaks:
+    copy_without_sharing = copy_node(tree)
+    @test !(copy_without_sharing.l.l === copy_without_sharing.r)
 
-    # But with the topology preserved in the copy, it should be the same:
-    copy_with_topology = copy_node(tree; preserve_topology=true)
-    @test copy_with_topology.l.l === copy_with_topology.r
+    # But with the sharing preserved in the copy, it should be the same:
+    copy_with_sharing = copy_node(tree; preserve_sharing=true)
+    @test copy_with_sharing.l.l === copy_with_sharing.r
 
     # We can also tweak the new tree, and the edits should be propagated:
-    copied_base_tree = copy_with_topology.l.l
+    copied_base_tree = copy_with_sharing.l.l
     # (First, assert that it is the same as the old base tree)
     @test string_tree(copied_base_tree, operators) == string_tree(base_tree, operators)
 
     # Now, let's tweak the new tree's base tree:
     copied_base_tree.l.l = x1 * x2 * 5.2 - exp(x3)
     # "exp" should appear *twice* now:
-    copy_with_topology
-    @test length(collect(eachmatch(r"exp", string_tree(copy_with_topology, operators)))) ==
+    copy_with_sharing
+    @test length(collect(eachmatch(r"exp", string_tree(copy_with_sharing, operators)))) ==
         2
-    @test copy_with_topology.l.l === copy_with_topology.r
-    @test hash(copy_with_topology.l.l) == hash(copy_with_topology.r)
-    @test string_tree(copy_with_topology.l.l, operators) !=
+    @test copy_with_sharing.l.l === copy_with_sharing.r
+    @test hash(copy_with_sharing.l.l) == hash(copy_with_sharing.r)
+    @test string_tree(copy_with_sharing.l.l, operators) !=
         string_tree(base_tree, operators)
 
     # We also test whether `convert` breaks shared children.
     # The node type here should be Float64.
     @test typeof(tree).parameters[1] == Float64
     # Let's convert to Float32:
-    float32_tree = convert(Node{Float32}, tree; preserve_topology=true)
+    float32_tree = convert(Node{Float32}, tree; preserve_sharing=true)
     @test typeof(float32_tree).parameters[1] == Float32
     # The linkage should be kept:
     @test float32_tree.l.l === float32_tree.r
 end
 
 # We also do tests of the macros related to generating functions that preserve
-# topology:
+# sharing:
 expr_eql(x::LineNumberNode, y::LineNumberNode) = true  # Ignore line numbers
 expr_eql(x::QuoteNode, y::QuoteNode) = x == y
 expr_eql(x::Number, y::Number) = x == y

test/test_simplification.jl

@@ -94,13 +94,13 @@ output3, flag3 = eval_tree_array(tree_copy2, X, operators)
 operators = OperatorEnum(; binary_operators=(+, -, *, /))
 base_tree = Node(1, Node(; val=0.3), Node(; val=0.2))
 tree = x1 * base_tree + base_tree
-simplify_tree(tree, operators; preserve_topology=true)
+simplify_tree(tree, operators; preserve_sharing=true)
 @test tree.l.r === tree.r
 
 base_tree = (x1 + Node(; val=0.3)) + Node(; val=0.2)
 true_simplification_value = 0.5
 tree = x2 * base_tree + base_tree
-combine_operators(tree, operators; preserve_topology=true)
+combine_operators(tree, operators; preserve_sharing=true)
 # Should not combine twice!
 @test tree.l.r.r.val == true_simplification_value
 

test/unittest.jl

@@ -62,7 +62,7 @@ end
     include("test_hash.jl")
 end
 
-@safetestset "Test topology-preserving copy" begin
+@safetestset "Test sharing-preserving copy" begin
     include("test_preserve_multiple_parents.jl")
 end