Loosen other type requirements

Author: MilesCranmer

benchmark/benchmark_utils.jl

@@ -25,7 +25,7 @@ function random_node(tree::Node{T})::Node{T} where {T}
     return random_node(tree.r)
 end
 
-function make_random_leaf(nfeatures::Int, ::Type{T})::Node{T} where {T}
+function make_random_leaf(nfeatures::Integer, ::Type{T})::Node{T} where {T}
     if rand() > 0.5
         return Node(; val=randn(T))
     else
@@ -35,7 +35,7 @@ end
 
 # Add a random unary/binary operation to the end of a tree
 function append_random_op(
-    tree::Node{T}, operators, nfeatures::Int; makeNewBinOp::Union{Bool,Nothing}=nothing
+    tree::Node{T}, operators, nfeatures::Integer; makeNewBinOp::Union{Bool,Nothing}=nothing
 )::Node{T} where {T}
     nuna = length(operators.unaops)
     nbin = length(operators.binops)
@@ -64,7 +64,7 @@ function append_random_op(
 end
 
 function gen_random_tree_fixed_size(
-    node_count::Int, operators, nfeatures::Int, ::Type{T}
+    node_count::Integer, operators, nfeatures::Integer, ::Type{T}
 )::Node{T} where {T}
     tree = make_random_leaf(nfeatures, T)
     cur_size = count_nodes(tree)

ext/DynamicExpressionsSymbolicUtilsExt.jl

@@ -27,9 +27,9 @@ function parse_tree_to_eqs(
         return SymbolicUtils.Sym{LiteralReal}(Symbol("x$(tree.feature)"))
     end
     # Collect the next children
-    children = tree.degree >= 2 ? (tree.l, tree.r) : (tree.l,)
+    children = tree.degree == 2 ? (tree.l, tree.r) : (tree.l,)
     # Get the operation
-    op = tree.degree > 1 ? operators.binops[tree.op] : operators.unaops[tree.op]
+    op = tree.degree == 2 ? operators.binops[tree.op] : operators.unaops[tree.op]
     # Create an N tuple of Numbers for each argument
     dtypes = map(x -> Number, 1:(tree.degree))
     #

src/EquationUtils.jl

@@ -92,25 +92,25 @@ end
 # This will mirror a Node struct, rather
 # than adding a new attribute to Node.
 mutable struct NodeIndex
-    constant_index::Int16  # Index of this constant (if a constant exists here)
+    constant_index::UInt16  # Index of this constant (if a constant exists here)
     l::NodeIndex
     r::NodeIndex
 
     NodeIndex() = new()
 end
 
 function index_constants(tree::Node)::NodeIndex
-    return index_constants(tree, Int16(0))
+    return index_constants(tree, UInt16(0))
 end
 
-function index_constants(tree::Node, left_index::Int16)::NodeIndex
+function index_constants(tree::Node, left_index)::NodeIndex
     index_tree = NodeIndex()
     index_constants!(tree, index_tree, left_index)
     return index_tree
 end
 
 # Count how many constants to the left of this node, and put them in a tree
-function index_constants!(tree::Node, index_tree::NodeIndex, left_index::Int16)
+function index_constants!(tree::Node, index_tree::NodeIndex, left_index)
     if tree.degree == 0
         if tree.constant
             index_tree.constant_index = left_index + 1

src/EvaluateEquationDerivative.jl

@@ -200,7 +200,7 @@ function eval_grad_tree_array(
 )::Tuple{AbstractVector{T},AbstractMatrix{T},Bool} where {T<:Number}
     assert_autodiff_enabled(operators)
     n_gradients = variable ? size(cX, 1) : count_constants(tree)
-    index_tree = index_constants(tree, Int16(0))
+    index_tree = index_constants(tree, UInt16(0))
     return eval_grad_tree_array(
         tree,
         Val(n_gradients),