Fix up other uses of old types

Author: MilesCranmer

docs/src/eval.md

@@ -90,7 +90,7 @@ all variables (or, all constants). Both use forward-mode automatic, but use
 `Zygote.jl` to compute derivatives of each operator, so this is very efficient.
 
 ```@docs
-eval_diff_tree_array(tree::Node{T}, cX::AbstractMatrix{T}, operators::OperatorEnum, direction::Int) where {T<:Number}
+eval_diff_tree_array(tree::Node{T}, cX::AbstractMatrix{T}, operators::OperatorEnum, direction::Integer) where {T<:Number}
 eval_grad_tree_array(tree::Node{T}, cX::AbstractMatrix{T}, operators::OperatorEnum; turbo::Bool=false, variable::Bool=false) where {T<:Number}
 ```
 

docs/src/types.md

@@ -55,8 +55,8 @@ There are a variety of constructors for `Node` objects, including:
 
 ```@docs
 Node(::Type{T}; val=nothing, feature::Integer=nothing) where {T}
-Node(op::Int, l::Node)
-Node(op::Int, l::Node, r::Node)
+Node(op::Integer, l::Node)
+Node(op::Integer, l::Node, r::Node)
 Node(var_string::String)
 ```
 

ext/DynamicExpressionsSymbolicUtilsExt.jl

@@ -228,7 +228,7 @@ function multiply_powers(
         @return_on_false complete eqn
         @return_on_false isgood(l) eqn
         n = args[2]
-        if typeof(n) <: Int
+        if typeof(n) <: Integer
             if n == 1
                 return l, true
             elseif n == -1

src/Equation.jl

@@ -16,16 +16,16 @@ nodes, you can evaluate or print a given expression.
 
 # Fields
 
-- `degree::Int`: Degree of the node. 0 for constants, 1 for
+- `degree::Int8`: Degree of the node. 0 for constants, 1 for
     unary operators, 2 for binary operators.
 - `constant::Bool`: Whether the node is a constant.
 - `val::T`: Value of the node. If `degree==0`, and `constant==true`,
     this is the value of the constant. It has a type specified by the
     overall type of the `Node` (e.g., `Float64`).
-- `feature::Int` (optional): Index of the feature to use in the
+- `feature::Int16` (optional): Index of the feature to use in the
     case of a feature node. Only used if `degree==0` and `constant==false`. 
     Only defined if `degree == 0 && constant == false`.
-- `op::Int`: If `degree==1`, this is the index of the operator
+- `op::Int8`: If `degree==1`, this is the index of the operator
     in `operators.unaops`. If `degree==2`, this is the index of the
     operator in `operators.binops`. In other words, this is an enum
     of the operators, and is dependent on the specific `OperatorEnum`
@@ -62,7 +62,7 @@ end
 include("base.jl")
 
 """
-    Node([::Type{T}]; val=nothing, feature::Int=nothing) where {T}
+    Node([::Type{T}]; val=nothing, feature::Union{Integer,Nothing}=nothing) where {T}
 
 Create a leaf node: either a constant, or a variable.
 
@@ -112,14 +112,14 @@ function Node(
 end
 
 """
-    Node(op::Int, l::Node)
+    Node(op::Integer, l::Node)
 
 Apply unary operator `op` (enumerating over the order given) to `Node` `l`
 """
 Node(op::Integer, l::Node{T}) where {T} = Node(1, false, nothing, 0, op, l)
 
 """
-    Node(op::Int, l::Node, r::Node)
+    Node(op::Integer, l::Node, r::Node)
 
 Apply binary operator `op` (enumerating over the order given) to `Node`s `l` and `r`
 """
@@ -138,7 +138,7 @@ end
 
 Create a variable node, using the format `"x1"` to mean feature 1
 """
-Node(var_string::String) = Node(; feature=parse(Int, var_string[2:end]))
+Node(var_string::String) = Node(; feature=parse(Int16, var_string[2:end]))
 
 """
     Node(var_string::String, variable_names::Array{String, 1})
@@ -258,7 +258,7 @@ Convert an equation to a string.
 
 # Keyword Arguments
 - `bracketed`: (optional) whether to put brackets around the outside.
-- `f_variable`: (optional) function to convert a variable to a string, of the form `(feature::Int, variable_names)`.
+- `f_variable`: (optional) function to convert a variable to a string, of the form `(feature::Int8, variable_names)`.
 - `f_constant`: (optional) function to convert a constant to a string, of the form `(val, bracketed::Bool)`
 - `variable_names::Union{Array{String, 1}, Nothing}=nothing`: (optional) what variables to print for each feature.
 """

src/EquationUtils.jl

@@ -92,7 +92,7 @@ end
 # This will mirror a Node struct, rather
 # than adding a new attribute to Node.
 mutable struct NodeIndex
-    constant_index::Int  # Index of this constant (if a constant exists here)
+    constant_index::Int16  # Index of this constant (if a constant exists here)
     l::NodeIndex
     r::NodeIndex
 
@@ -103,14 +103,14 @@ function index_constants(tree::Node)::NodeIndex
     return index_constants(tree, 0)
 end
 
-function index_constants(tree::Node, left_index::Int)::NodeIndex
+function index_constants(tree::Node, left_index::Int16)::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::Int)
+function index_constants!(tree::Node, index_tree::NodeIndex, left_index::Int16)
     if tree.degree == 0
         if tree.constant
             index_tree.constant_index = left_index + 1

src/EvaluateEquationDerivative.jl

@@ -18,7 +18,7 @@ function assert_autodiff_enabled(operators::OperatorEnum)
 end
 
 """
-    eval_diff_tree_array(tree::Node{T}, cX::AbstractMatrix{T}, operators::OperatorEnum, direction::Int; turbo::Bool=false)
+    eval_diff_tree_array(tree::Node{T}, cX::AbstractMatrix{T}, operators::OperatorEnum, direction::Integer; turbo::Bool=false)
 
 Compute the forward derivative of an expression, using a similar
 structure and optimization to eval_tree_array. `direction` is the index of a particular
@@ -31,7 +31,7 @@ respect to `x1`.
 - `cX::AbstractMatrix{T}`: The data matrix, with each column being a data point.
 - `operators::OperatorEnum`: The operators used to create the `tree`. Note that `operators.enable_autodiff`
     must be `true`. This is needed to create the derivative operations.
-- `direction::Int`: The index of the variable to take the derivative with respect to.
+- `direction::Integer`: The index of the variable to take the derivative with respect to.
 - `turbo::Bool`: Use `LoopVectorization.@turbo` for faster evaluation.
 
 # Returns
@@ -43,7 +43,7 @@ function eval_diff_tree_array(
     tree::Node{T},
     cX::AbstractMatrix{T},
     operators::OperatorEnum,
-    direction::Int;
+    direction::Integer;
     turbo::Bool=false,
 )::Tuple{AbstractVector{T},AbstractVector{T},Bool} where {T<:Number}
     assert_autodiff_enabled(operators)
@@ -57,7 +57,7 @@ function eval_diff_tree_array(
     tree::Node{T1},
     cX::AbstractMatrix{T2},
     operators::OperatorEnum,
-    direction::Int;
+    direction::Integer;
     turbo::Bool=false,
 ) where {T1<:Number,T2<:Number}
     T = promote_type(T1, T2)
@@ -71,7 +71,7 @@ function _eval_diff_tree_array(
     tree::Node{T},
     cX::AbstractMatrix{T},
     operators::OperatorEnum,
-    direction::Int,
+    direction::Integer,
     ::Val{turbo},
 )::Tuple{AbstractVector{T},AbstractVector{T},Bool} where {T<:Number,turbo}
     evaluation, derivative, complete = if tree.degree == 0
@@ -102,7 +102,7 @@ function _eval_diff_tree_array(
 end
 
 function diff_deg0_eval(
-    tree::Node{T}, cX::AbstractMatrix{T}, direction::Int
+    tree::Node{T}, cX::AbstractMatrix{T}, direction::Integer
 )::Tuple{AbstractVector{T},AbstractVector{T},Bool} where {T<:Number}
     const_part = deg0_eval(tree, cX)[1]
     derivative_part = if ((!tree.constant) && tree.feature == direction)
@@ -119,7 +119,7 @@ function diff_deg1_eval(
     op::F,
     diff_op::dF,
     operators::OperatorEnum,
-    direction::Int,
+    direction::Integer,
     ::Val{turbo},
 )::Tuple{AbstractVector{T},AbstractVector{T},Bool} where {T<:Number,F,dF,turbo}
     (cumulator, dcumulator, complete) = _eval_diff_tree_array(
@@ -144,7 +144,7 @@ function diff_deg2_eval(
     op::F,
     diff_op::dF,
     operators::OperatorEnum,
-    direction::Int,
+    direction::Integer,
     ::Val{turbo},
 )::Tuple{AbstractVector{T},AbstractVector{T},Bool} where {T<:Number,F,dF,turbo}
     (cumulator, dcumulator, complete) = _eval_diff_tree_array(

src/OperatorEnumConstruction.jl

@@ -19,8 +19,8 @@ end
 
 const LATEST_OPERATORS = Ref{Union{Nothing,AbstractOperatorEnum}}(nothing)
 const LATEST_OPERATORS_TYPE = Ref{AvailableOperatorTypes}(IsNothing)
-const LATEST_UNARY_OPERATOR_MAPPING = Dict{Function,Int}()
-const LATEST_BINARY_OPERATOR_MAPPING = Dict{Function,Int}()
+const LATEST_UNARY_OPERATOR_MAPPING = Dict{Function,Int8}()
+const LATEST_BINARY_OPERATOR_MAPPING = Dict{Function,Int8}()
 const ALREADY_DEFINED_UNARY_OPERATORS = (;
     operator_enum=Dict{Function,Bool}(), generic_operator_enum=Dict{Function,Bool}()
 )

src/base.jl

@@ -52,9 +52,9 @@ julia> tree_mapreduce(t -> 1, (p, c...) -> p + max(c...), tree)  # compute depth
 5
 
 julia> tree_mapreduce(vcat, tree) do t
-    t.degree == 2 ? [t.op] : Int[]
+    t.degree == 2 ? [t.op] : Int8[]
 end  # Get list of binary operators used. (regular mapreduce also works)
-2-element Vector{Int64}:
+2-element Vector{Int8}:
  1
  2
 

test/test_base.jl

@@ -114,8 +114,8 @@ end
     @test length(unique(map(objectid, copy_node(tree; preserve_sharing=true)))) == 24 - 3
     map(t -> (t.degree == 0 && t.constant) ? (t.val *= 2) : nothing, ctree)
     @test sum(t -> t.val, filter(t -> t.degree == 0 && t.constant, ctree)) == 11.6 * 2
-    @test typeof(map(t -> t.degree, ctree, Int)) == Vector{Int}
-    @test first(map(t -> t.degree, ctree, Int)) == 2
+    @test typeof(map(t -> t.degree, ctree, Int8)) == Vector{Int8}
+    @test first(map(t -> t.degree, ctree, Int8)) == 2
 end
 
 @testset "in" begin