How to construct an expression manually from python

[unary-code]

When I run this line in my ipynb notebook:

jl.eval("""
my_arr = [3.4 3; 2 4]
println(typeof(my_arr))

num_rectangles = 1000

println("BEFORE node")

x1, x2, x3 = [Node(; feature=i) for i=1:3]
println("AFTER node")
println(typeof(x1))
println(typeof(x1))

x1 = convert(Node{Float64}, x1)
x2 = convert(Node{Float64}, x2)
x3 = convert(Node{Float64}, x3)


tree = cos(x1 - 3.2 * x2) - x1^3.2
""")

The outputted error (which refers to the very last line of code so "tree = cos(x1 - 3.2 * x2) - x1^3.2") is:

JuliaError: Exception 'MethodError: no method matching *(::Float64, ::Node{Float64})

Closest candidates are:
  *(::Any, ::Any, !Matched::Any, !Matched::Any...)
   @ Base operators.jl:578
  *(::T, !Matched::T) where T<:Union{Float16, Float32, Float64}
   @ Base float.jl:410
  *(::Union{Float16, Float32, Float64}, !Matched::BigFloat)
   @ Base mpfr.jl:423
  ...
' occurred while calling julia code:

Any ideas why?
How do I construct a basic tree in Julia (with the SymbolicRegression Julia package)?

[MilesCranmer]

One thing to keep in mind is that the Node type does not know what operators you are using. It only stores an index (integer) that references an operator in a list. The reason for this is speed and low memory usage (rather than needing to store function pointers in every node).

So, the reason

tree = cos(x1 - 3.2 * x2) - x1^3.2

works in other instances is because you would have already called

options = SymbolicRegression.Options(
    binary_operators=[+, *, /, -, ^],
    unary_operators=[cos],
)

beforehand. Whenever you create Options with the operators you want to use, SymbolicRegression will generate some convenience operations so it's easier to create expressions – those convenience operations, like + defined on Node, would know about what index + is stored at (here, 1).

However, if you want to be more robust or want it to work without needing the Options, then you need to call one of the Node constructors, from here: https://astroautomata.com/SymbolicRegression.jl/dev/types/#DynamicExpressions.EquationModule.Node.

For example, if I know that + will be the first operator of my binary operators, I could call:

Node(1, x1, x2)

to create the expression x1 + x2. That expression uses this constructor: https://astroautomata.com/SymbolicRegression.jl/dev/types/#DynamicExpressions.EquationModule.Node-Tuple{Int64,%20Node,%20Node}

Likewise, if I know that cos will be the first unary operator, I would call

Node(1, x1)

to create cos(x1).

But again, if you've initiated an Options object already, the + operator will automatically call Node(1, x1, x2) (assuming + is the first operator).

---

(Note if + is the second operator in the list, you would instead have

Node(2, x1, x2)

to create x1 + x2. )