Fix issue due to assumption of node.constant == false

Author: MilesCranmer

src/Equation.jl

@@ -221,8 +221,8 @@ end
     T = node_factory_type(N, T1, T2)
     n = allocator(N, T)
     n.degree = 0
-    n.val = convert(T, val)
     n.constant = true
+    n.val = convert(T, val)
     return n
 end
 """Create a variable leaf, to store data."""
@@ -328,7 +328,7 @@ function Base.promote_rule(::Type{GraphNode{T1}}, ::Type{GraphNode{T2}}) where {
 end
 
 # TODO: Verify using this helps with garbage collection
-create_dummy_node(::Type{N}) where {N<:AbstractExpressionNode} = N(; feature=zero(UInt16))
+create_dummy_node(::Type{N}) where {N<:AbstractExpressionNode} = N()
 
 """
     set_node!(tree::AbstractExpressionNode{T}, new_tree::AbstractExpressionNode{T}) where {T}

src/EquationUtils.jl

@@ -91,7 +91,7 @@ function set_constants!(
     Base.require_one_based_indexing(constants)
     i = Ref(0)
     foreach(tree) do node
-        if node.degree == 0 && node.constant
+        if is_node_constant(node)
             @inbounds node.val = constants[i[] += 1]
         end
     end

src/SimplifyEquation.jl

@@ -33,12 +33,13 @@ function combine_operators(tree::Node{T}, operators::AbstractOperatorEnum) where
         tree.r = combine_operators(tree.r, operators)
     end
 
-    top_level_constant = tree.degree == 2 && (tree.l.constant || tree.r.constant)
+    top_level_constant =
+        tree.degree == 2 && (is_node_constant(tree.l) || is_node_constant(tree.r))
     if tree.degree == 2 && is_commutative(operators.binops[tree.op]) && top_level_constant
         # TODO: Does this break SymbolicRegression.jl due to the different names of operators?
         op = tree.op
         # Put the constant in r. Need to assume var in left for simplification assumption.
-        if tree.l.constant
+        if is_node_constant(tree.l)
             tmp = tree.r
             tree.r = tree.l
             tree.l = tmp
@@ -47,12 +48,12 @@ function combine_operators(tree::Node{T}, operators::AbstractOperatorEnum) where
         # Simplify down first
         below = tree.l
         if below.degree == 2 && below.op == op
-            if below.l.constant
+            if is_node_constant(below.l)
                 tree = below
                 tree.l.val = _bin_op_kernel(
                     operators.binops[op], tree.l.val::T, topconstant
                 )
-            elseif below.r.constant
+            elseif is_node_constant(below.r)
                 tree = below
                 tree.r.val = _bin_op_kernel(
                     operators.binops[op], tree.r.val::T, topconstant
@@ -65,17 +66,17 @@ function combine_operators(tree::Node{T}, operators::AbstractOperatorEnum) where
 
         # Currently just simplifies subtraction. (can't assume both plus and sub are operators)
         # Not commutative, so use different op.
-        if tree.l.constant
+        if is_node_constant(tree.l)
             if tree.r.degree == 2 && tree.op == tree.r.op
-                if tree.r.l.constant
+                if is_node_constant(tree.r.l)
                     #(const - (const - var)) => (var - const)
                     l = tree.l
                     r = tree.r
                     simplified_const = (r.l.val::T - l.val::T) #neg(sub(l.val, r.l.val))
                     tree.l = tree.r.r
                     tree.r = l
                     tree.r.val = simplified_const
-                elseif tree.r.r.constant
+                elseif is_node_constant(tree.r.r)
                     #(const - (var - const)) => (const - var)
                     l = tree.l
                     r = tree.r
@@ -84,17 +85,17 @@ function combine_operators(tree::Node{T}, operators::AbstractOperatorEnum) where
                     tree.l.val = simplified_const
                 end
             end
-        else #tree.r.constant is true
+        else #tree.r is a constant
             if tree.l.degree == 2 && tree.op == tree.l.op
-                if tree.l.l.constant
+                if is_node_constant(tree.l.l)
                     #((const - var) - const) => (const - var)
                     l = tree.l
                     r = tree.r
                     simplified_const = l.l.val::T - r.val::T#sub(l.l.val, r.val)
                     tree.r = tree.l.r
                     tree.l = r
                     tree.l.val = simplified_const
-                elseif tree.l.r.constant
+                elseif is_node_constant(tree.l.r)
                     #((var - const) - const) => (var - const)
                     l = tree.l
                     r = tree.r