Types

Node{T<:Real}

Node defines a symbolic expression stored in a binary tree. A single Node instance is one "node" of this tree, and has references to its children. By tracing through the children nodes, you can evaluate or print a given expression.

Fields

• degree::Int: 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 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 in options.unaops. If degree==2, this is the index of the operator in options.binops. In other words, this is an enum of the operators, and is dependent on the specific Options object. Only defined if degree >= 1
• l::Node{T}: Left child of the node. Only defined if degree >= 1. Same type as the parent node.
• r::Node{T}: Right child of the node. Only defined if degree == 2. Same type as the parent node. This is to be passed as the right argument to the binary operator.

Node(; val::Real=nothing, feature::Integer=nothing)

Create a leaf node: either a constant, or a variable.

Arguments:

• val::Real, if you are specifying a constant, pass the value of the constant here.
• feature::Integer, if you are specifying a variable, pass the index of the variable here.

Node(op::Int, l::Node)

Apply unary operator op (enumerating over the order given) to Node l

Node(op::Int, l::Node, r::Node)

Apply binary operator op (enumerating over the order given) to Nodes l and r

Node(var_string::String)

Create a variable node, using the format "x1" to mean feature 1

convert(::Type{Node{T1}}, n::Node{T2}) where {T1,T2}

Convert a Node{T2} to a Node{T1}. This will recursively convert all children nodes to Node{T1}, using convert(T1, tree.val) at constant nodes.

Population(pop::Array{PopMember{T}, 1})

Create population from list of PopMembers.

Population(dataset::Dataset{T}, baseline::T;
           npop::Int, nlength::Int=3, options::Options,
           nfeatures::Int)

Create random population and score them on the dataset.

Population(X::AbstractMatrix{T}, y::AbstractVector{T},
           baseline::T; npop::Int, nlength::Int=3,
           options::Options, nfeatures::Int)

Create random population and score them on the dataset.

PopMember(t::Node, score::T, loss::T)

Create a population member with a birth date at the current time.

Arguments

• t::Node: The tree for the population member.
• score::T: The score (normalized to a baseline, and offset by a complexity penalty)
• loss::T: The raw loss to assign.

PopMember(dataset::Dataset{T}, baseline::T,
          t::Node, options::Options)

Create a population member with a birth date at the current time. Automatically compute the score for this tree.

Arguments

• dataset::Dataset{T}: The dataset to evaluate the tree on.
• baseline::T: The baseline loss.
• t::Node: The tree for the population member.
• options::Options: What options to use.

HallOfFame(options::Options, ::Type{T}) where {T<:Real}

Create empty HallOfFame. The HallOfFame stores a list of PopMember objects in .members, which is enumerated by size (i.e., .members[1] is the constant solution). .exists is used to determine whether the particular member has been instantiated or not.

Arguments:

• options: Options containing specification about deterministic.
• T: Type of Nodes to use in the population. e.g., Float64.

Dataset(X::AbstractMatrix{T}, y::AbstractVector{T};
        weights::Union{AbstractVector{T}, Nothing}=nothing,
        varMap::Union{Array{String, 1}, Nothing}=nothing)

Construct a dataset to pass between internal functions.