Extend add_to_expression! for NonlinearExpr

[hdavid16]

Hi, it would be nice to use add_to_expression! with NonlinearExpr. The following currently errors on master:

(@v1.9) pkg> st JuMP
Status `~/.julia/environments/v1.9/Project.toml`
  [4076af6c] JuMP v1.14.1 `https://github.com/jump-dev/JuMP.jl.git#master`

using JuMP
m=Model(); @variable(m,x);
ex = zeros(NonlinearExpr)
add_to_expression!(ex, exp(x))
ERROR: MethodError: no method matching add_to_expression!(::Array{NonlinearExpr, 0}, ::NonlinearExpr)

Closest candidates are:
  add_to_expression!(::GenericQuadExpr{C, V}, ::Union{GenericAffExpr{C, V}, V}, ::Union{Number, LinearAlgebra.UniformScaling}) where {C, V}
   @ JuMP ~/.julia/packages/JuMP/8MuvO/src/quad_expr.jl:364
  add_to_expression!(::GenericQuadExpr{C, V}, ::V) where {C, V}
   @ JuMP ~/.julia/packages/JuMP/8MuvO/src/quad_expr.jl:323
  add_to_expression!(::GenericQuadExpr{C, V}, ::V, ::GenericAffExpr{C, V}) where {C, V}
   @ JuMP ~/.julia/packages/JuMP/8MuvO/src/quad_expr.jl:417
  ...

[odow]

So one problem with this is that add_to_expression! modifies in-place. So this only makes sense if the expression is a :+ node.

Should we try and throw an error if not?

When is add_to_expression! useful for you?

[hdavid16]

I see. I am incrementally building a nonlinear expression to reformulate a disjunct constraint in DisjunctiveProgramming.jl. I notice that when I initialize the expression with zero(NonlinearExpr), the resulting expression has :+ as the head. Would you suggest I just do expr += ...? Or would it make sense to extend add_to_expression! for the case when :+ is the head so it can be modified in place and throw an error when the head is different?

[odow]

Are you just adding a sum of terms? += will work. Do have a larger example?

I'd just do:

julia> model = Model();

julia> @variable(model, x)
x

julia> y = 0
0

julia> for _ in 1:3
           y += exp(x)
       end

julia> y
((0.0 + exp(x)) + exp(x)) + exp(x)

julia> flatten!(y)
0.0 + exp(x) + exp(x) + exp(x)

[hdavid16]

Yes, I'm currently using += and will continue doing so then. Thanks.

Perhaps a better error message could be provided telling the user that the in-place modification is not supported for nonlinear expressions if you want. However, the stack trace points to the issue anyways.

[odow]

See #3506

[blegat]

I think MA.add_mul!! does work though. It will modify in-place if the head is :+ and return a new instance otherwise.