More updates from matbesancon

Author: odow

Diff for: docs/src/submodules/Nonlinear/reference.md

@@ -81,4 +81,5 @@ Nonlinear.NonlinearExpression
 Nonlinear.NonlinearConstraint
 Nonlinear.adjacency_matrix
 Nonlinear.parse_expression
+Nonlinear.convert_to_expr
 ```

Diff for: src/Nonlinear/Nonlinear.jl

@@ -272,7 +272,11 @@ function MOI.initialize(data::NonlinearData, features::Vector{Symbol})
         for i in 1:length(data.expressions)
             push!(
                 data.julia_expressions,
-                _to_expr(data, data.expressions[i]; use_x_ref = true),
+                convert_to_expr(
+                    data,
+                    data.expressions[i];
+                    moi_output_format = true,
+                ),
             )
         end
         filter!(f -> f != :ExprGraph, features)
@@ -285,12 +289,12 @@ end
 
 function MOI.objective_expr(data::NonlinearData)
     @assert data.objective !== nothing
-    return _to_expr(data, data.objective; use_x_ref = true)
+    return convert_to_expr(data, data.objective; moi_output_format = true)
 end
 
 function MOI.constraint_expr(data::NonlinearData, i::Int)
     constraint = data[data.ordered_constraints[i]]
-    f = _to_expr(data, constraint.expression; use_x_ref = true)
+    f = convert_to_expr(data, constraint.expression; moi_output_format = true)
     if constraint.set isa MOI.LessThan
         return :($f <= $(constraint.set.upper))
     elseif constraint.set isa MOI.GreaterThan

Diff for: src/Nonlinear/ReverseAD/Coloring/Coloring.jl

@@ -433,7 +433,8 @@ end
         seen_idx = IndexedSet(0),
     )
 
-edgelist is nonzeros in hessian, *including* nonzeros on the diagonal
+`edgelist` contains the nonzeros in the Hessian, *including* nonzeros on the
+diagonal.
 """
 function hessian_color_preprocess(
     edgelist,

Diff for: src/Nonlinear/ReverseAD/types.jl

@@ -135,8 +135,11 @@ end
         ordered_variables::Vector{MOI.VariableIndex},
     )
 
-Return an `MOI.AbstractNLPEvaluator`. Before using, you must initialize the
-evaluator using `MOI.initialize`.
+Return an `NLPEvaluator` object that implements the `MOI.AbstractNLPEvaluator`
+interface.
+
+!!! warning
+    Before using, you must initialize the evaluator using `MOI.initialize`.
 """
 mutable struct NLPEvaluator <: MOI.AbstractNLPEvaluator
     data::Nonlinear.NonlinearData

Diff for: src/Nonlinear/operators.jl

@@ -16,26 +16,30 @@ function _create_binary_switch(ids, exprs)
     end
 end
 
+# We use a let block here for `expr` to create a local variable that does not
+# persist in the scope of the module. All we care about is the _eval_univariate
+# function that is eval'd as a result.
 let exprs = map(SYMBOLIC_UNIVARIATE_EXPRESSIONS) do arg
         return :(return $(arg[1])(x), $(arg[2]))
     end
-    expr = _create_binary_switch(1:length(exprs), exprs)
     @eval @inline function _eval_univariate(id, x::T) where {T}
-        $(expr)
+        $(_create_binary_switch(1:length(exprs), exprs))
         return error("Invalid operator_id")
     end
 end
 
+# We use a let block here for `expr` to create a local variable that does not
+# persist in the scope of the module. All we care about is the
+# _eval_univariate_2nd_deriv function that is eval'd as a result.
 let exprs = map(SYMBOLIC_UNIVARIATE_EXPRESSIONS) do arg
         if arg === :(nothing)  # f''(x) isn't defined
             :(error("Invalid operator_id"))
         else
             :(return $(arg[3]))
         end
     end
-    expr = _create_binary_switch(1:length(exprs), exprs)
     @eval @inline function _eval_univariate_2nd_deriv(id, x::T) where {T}
-        $(expr)
+        $(_create_binary_switch(1:length(exprs), exprs))
         return error("Invalid operator_id")
     end
 end

Diff for: src/Nonlinear/parse.jl

@@ -257,11 +257,34 @@ function _expr_to_constraint(expr::Expr)
     end
 end
 
-function _to_expr(
+"""
+    convert_to_expr(
+        data::NonlinearData,
+        expr::NonlinearExpression;
+        moi_output_format::Bool,
+    )
+
+Convert the [`NonlinearExpression`](@ref) `expr` into a Julia `Expr`.
+
+If `moi_output_format = true`:
+ * subexpressions will be converted to Julia `Expr` and substituted into the
+   output expression.
+ * the current value of each parameter will be interpolated into the expression
+ * variables will be represented in the form `x[MOI.VariableIndex(i)]`
+
+If `moi_output_format = false`:
+ * subexpressions will be represented by a [`ExpressionIndex`](@ref) object.
+ * parameters will be represented by a [`ParameterIndex`](@ref) object.
+ * variables will be represennted by an [`MOI.VariableIndex`](@ref) object.
+
+!!! warning
+    To use `moi_output_format = true`, you must have first called
+    [`MOI.initialize`](@ref) with `:ExprGraph` as a requested feature.
+"""
+function convert_to_expr(
     data::NonlinearData,
     expr::NonlinearExpression;
-    expand_subexpressions::Bool = true,
-    use_x_ref::Bool = false,
+    moi_output_format::Bool,
 )
     tree = Any[]
     for node in expr.nodes
@@ -274,16 +297,19 @@ function _to_expr(
         elseif node.type == NODE_LOGIC
             Expr(data.operators.logic_operators[node.index])
         elseif node.type == NODE_MOI_VARIABLE
-            x = MOI.VariableIndex(node.index)
-            use_x_ref ? :(x[$x]) : x
+            if moi_output_format
+                :(x[$(MOI.VariableIndex(node.index))])
+            else
+                MOI.VariableIndex(node.index)
+            end
         elseif node.type == NODE_PARAMETER
-            if expand_subexpressions
+            if moi_output_format
                 data.parameters[node.index]
             else
                 ParameterIndex(node.index)
             end
         elseif node.type == NODE_SUBEXPRESSION
-            if expand_subexpressions
+            if moi_output_format
                 data.julia_expressions[node.index]
             else
                 ExpressionIndex(node.index)