Base Operator Overloading - Question

[maxreiss123]

Hi,

Thanks for such an incredible package; I am currently experimenting with the vector capabilities. According to the example you gave, is there a reason for not overloading the base operators, e.g. doing some like:

import Base: +, *
using DynamicExpressions
using DynamicExpressions: @declare_expression_operator


T = Union{Float64,Vector{Float64}}

+(x::AbstractVector, y::AbstractVector) = x .+ y
+(x::AbstractFloat, y::AbstractVector) = y .+ x
+(x::AbstractVector, y::AbstractFloat) = x .+ y

*(x::AbstractVector, y::AbstractVector) = x .* y


@declare_expression_operator(+, 2)
@declare_expression_operator(*, 2)

operators = GenericOperatorEnum(
    binary_operators=[+, *])

variable_names = ["x1"]


c1 = Expression(Node{T}(val=0.0); operators, variable_names)
c2 = Expression(Node{T}(val=[1.0, 2.0, 3.0]); operators, variable_names)
x1 = Expression(Node{T}(feature=1); operators, variable_names )

expression = ((x1 * x1) + c2) + c1

X = [[-1.0, 5.2, 0.1], [0.0, 0.0, 0.0]]

result = expression(X)
println(result)

Best wishes

[MilesCranmer]

Thanks!

Should already work without overloading, no?

julia> import Base: +, *

julia> using DynamicExpressions

julia> using DynamicExpressions: @declare_expression_operator

julia> T = Union{Float64,Vector{Float64}}
Union{Float64, Vector{Float64}}

julia> operators = GenericOperatorEnum(
           binary_operators=[+, *])
GenericOperatorEnum{Tuple{typeof(+), typeof(*)}, Tuple{}}((+, *), ())

julia> variable_names = ["x1"]
1-element Vector{String}:
 "x1"

julia> c1 = Expression(Node{T}(val=0.0); operators, variable_names)
0.0

julia> c2 = Expression(Node{T}(val=[1.0, 2.0, 3.0]); operators, variable_names)
[1.0, 2.0, 3.0]

julia> x1 = Expression(Node{T}(feature=1); operators, variable_names )
x1

julia> expression = ((x1 * x1) + c2) + c1
((x1 * x1) + [1.0, 2.0, 3.0]) + 0.0

These operators are all overloaded automatically:

DynamicExpressions.jl/src/ExpressionAlgebra.jl

Lines 140 to 160 in b3660ae

	for op in (
	:sin, :cos, :tan, :sinh, :cosh, :tanh, :asin, :acos,
	:asinh, :acosh, :atanh, :sec, :csc, :cot, :asec, :acsc, :acot, :sech, :csch,
	:coth, :asech, :acsch, :acoth, :sinc, :cosc, :cosd, :cotd, :cscd, :secd,
	:sinpi, :cospi, :sind, :tand, :acosd, :acotd, :acscd, :asecd, :asind,
	:log, :log2, :log10, :log1p, :exp, :exp2, :exp10, :expm1, :frexp, :exponent,
	:float, :abs, :real, :imag, :conj, :unsigned,
	:nextfloat, :prevfloat, :transpose, :significand,
	:modf, :rem, :floor, :ceil, :round, :trunc,
	:inv, :sqrt, :cbrt, :abs2, :angle, :factorial,
	:(!), :-, :+, :sign, :identity,
	)
	@eval @declare_expression_operator Base.$(op) 1
	end
	for op in (
	:*, :/, :+, :-, :^, :÷, :mod, :log,
	:atan, :atand, :copysign, :flipsign,
	:&, :|, :⊻, ://, :\,
	)
	@eval @declare_expression_operator Base.$(op) 2
	end

for op in (
    :sin, :cos, :tan, :sinh, :cosh, :tanh, :asin, :acos,
    :asinh, :acosh, :atanh, :sec, :csc, :cot, :asec, :acsc, :acot, :sech, :csch,
    :coth, :asech, :acsch, :acoth, :sinc, :cosc, :cosd, :cotd, :cscd, :secd,
    :sinpi, :cospi, :sind, :tand, :acosd, :acotd, :acscd, :asecd, :asind,
    :log, :log2, :log10, :log1p, :exp, :exp2, :exp10, :expm1, :frexp, :exponent,
    :float, :abs, :real, :imag, :conj, :unsigned,
    :nextfloat, :prevfloat, :transpose, :significand,
    :modf, :rem, :floor, :ceil, :round, :trunc,
    :inv, :sqrt, :cbrt, :abs2, :angle, :factorial,
    :(!), :-, :+, :sign, :identity,
)
    @eval @declare_expression_operator Base.$(op) 1
end
for op in (
    :*, :/, :+, :-, :^, :÷, :mod, :log,
    :atan, :atand, :copysign, :flipsign,
    :&, :|, :⊻, ://, :\,
)
    @eval @declare_expression_operator Base.$(op) 2
end

[MilesCranmer]

Oh sorry you mean specifically the evaluation? I think this is just tricky to do in a generic way. Perhaps someone else could assume it means + (non-vectorized), since that is how all the other operators are used. But I'm open to it for sure!

@gca30 @grezde has looked at this for a project, maybe he can comment?

[maxreiss123]

Thanks for the quick reply. I will just give it a try.

[MilesCranmer]

Also it's tricky because some operators are ambiguous about this, like * for vectors & matrices is valid but differs from the vectorized one:

julia> [1.0 2.0; 3.0 4.0] * [1.0, 2.0]
2-element Vector{Float64}:
  5.0
 11.0

julia> [1.0 2.0; 3.0 4.0] .* [1.0, 2.0]
2×2 Matrix{Float64}:
 1.0  2.0
 6.0  8.0

[maxreiss123]

Ah, right; because of the ambiguity, it may cause issues.

[maxreiss123]

Hi,

After further research, I tried a different approach: I transformed the expression utilizing Flux.jl. After performing some benchmarks, Flux works more efficiently in dealing with higher-dimensional data. I will further investigate what may produce that.

Benchmark example:
https://github.com/maxreiss123/GeneExpressionProgramming.jl/blob/feature/modular_error/benchmark/benchmark_djl_nn.jl

[MilesCranmer]

Very interesting, thanks! Yes it would be great if we can figure out how to make DE.jl more competitive for high-dim datasets so that we don't need to compile to other formats. Let me know what you find :)