Update

Author: odow

docs/src/submodules/Nonlinear/reference.md

@@ -72,6 +72,7 @@ Nonlinear.Evaluator
 Nonlinear.AbstractAutomaticDifferentiation
 Nonlinear.ExprGraphOnly
 Nonlinear.SparseReverseMode
+Nonlinear.SymbolicMode
 ```
 
 ## Data-structure
@@ -86,3 +87,13 @@ Nonlinear.parse_expression
 Nonlinear.convert_to_expr
 Nonlinear.ordinal_index
 ```
+
+## SymbolicAD
+
+```@docs
+Nonlinear.SymbolicAD.simplify
+Nonlinear.SymbolicAD.simplify!
+Nonlinear.SymbolicAD.variables
+Nonlinear.SymbolicAD.derivative
+Nonlinear.SymbolicAD.gradient_and_hessian
+```

src/Nonlinear/Nonlinear.jl

@@ -48,5 +48,6 @@ include("model.jl")
 include("evaluator.jl")
 
 include("ReverseAD/ReverseAD.jl")
+include("SymbolicAD/SymbolicAD.jl")
 
 end  # module

src/Nonlinear/SymbolicAD/SymbolicAD.jl

@@ -22,7 +22,7 @@ Return a simplified copy of the function `f`.
 simplify(f) = simplify!(copy(f))
 
 ###
-### simplify!
+### `simplify!`
 ###
 
 """
@@ -468,7 +468,7 @@ end
 """
     __DERIVATIVE__ = "__DERIVATIVE__"
 
-This constant is is prefixed to the name of univariate operators to indicate
+This constant is prefixed to the name of univariate operators to indicate
 that we should compute their derivative.
 
 If `f.head` is itself a __DERIVATIVE__, then this will create a second
@@ -1129,14 +1129,6 @@ end
 ### MOI.AbstractNLPEvaluator
 ###
 
-"""
-    SymbolicMode() <: MOI.Nonlinear.AbstractAutomaticDifferentiation
-
-A type for setting as the value of the `MOI.AutomaticDifferentiationBackend()`
-attribute to enable symbolic automatic differentiation.
-"""
-struct SymbolicMode <: MOI.Nonlinear.AbstractAutomaticDifferentiation end
-
 struct Evaluator <: MOI.AbstractNLPEvaluator
     dag::Dict{UInt64,_DAG}
     H::Dict{UInt64,Vector{Tuple{Int64,Int64}}}
@@ -1252,9 +1244,8 @@ function _to_symbolic_form(
     )
 end
 
-function MOI.Nonlinear.Evaluator(
+function Evaluator(
     model::MOI.Nonlinear.Model,
-    ::SymbolicMode,
     ordered_variables::Vector{MOI.VariableIndex},
 )
     variable_to_column =
@@ -1308,15 +1299,14 @@ function MOI.Nonlinear.Evaluator(
             push!(constraint_index_by_hash[c_sym.hash], length(constraints))
         end
     end
-    backend = Evaluator(
+    return Evaluator(
         hash_to_dag,
         hash_to_H,
         objective,
         constraints,
         constraint_index_by_hash,
         Float64[],
     )
-    return MOI.Nonlinear.Evaluator(model, backend)
 end
 
 function _evaluate!(model::Evaluator, x)
@@ -1428,7 +1418,7 @@ function MOI.eval_hessian_lagrangian(model::Evaluator, H, x, σ, μ)
     Threads.@threads for i in eachindex(model.constraints)
         c = model.constraints[i]
         # It is important that `offset_c` does not shadow `offset` from the
-        # objective block! If we use the same name, Julia creates a Core.Box
+        # objective block. If we use the same name, Julia creates a Core.Box
         offset_c = c.hess_offset - length(c.x) - 1
         for j in (2+length(c.x)):length(c.result)
             H[offset_c+j] = μ[i] * c.result[j]

src/Nonlinear/types.jl

@@ -291,3 +291,19 @@ function Evaluator(
 )
     return Evaluator(model, ReverseAD.NLPEvaluator(model, ordered_variables))
 end
+
+"""
+    SymbolicMode() <: AbstractAutomaticDifferentiation
+
+A type for setting as the value of the `MOI.AutomaticDifferentiationBackend()`
+attribute to enable symbolic automatic differentiation.
+"""
+struct SymbolicMode <: AbstractAutomaticDifferentiation end
+
+function Evaluator(
+    model::Model,
+    ::SymbolicMode,
+    ordered_variables::Vector{MOI.VariableIndex},
+)
+    return Evaluator(model, SymbolicAD.Evaluator(model, ordered_variables))
+end

test/Nonlinear/SymbolicAD.jl

@@ -8,7 +8,9 @@ module TestMathOptSymbolicAD
 using Test
 
 import MathOptInterface as MOI
-import MathOptInterface.Nonlinear: SymbolicAD
+import MathOptInterface: Nonlinear
+
+const SymbolicAD = Nonlinear.SymbolicAD
 
 function runtests()
     for name in names(@__MODULE__; all = true)
@@ -503,7 +505,7 @@ function test_SymbolicAD_Evaluator()
     end
     MOI.Nonlinear.add_constraint(model, :($(x[1]) * $(x[2])), MOI.LessThan(2.0))
     MOI.Nonlinear.set_objective(model, :($(x[1]) * $(x[2])))
-    evaluator = MOI.Nonlinear.Evaluator(model, SymbolicAD.SymbolicMode(), x)
+    evaluator = MOI.Nonlinear.Evaluator(model, Nonlinear.SymbolicMode(), x)
     @test MOI.features_available(evaluator) == [:Grad, :Jac, :Hess, :ExprGraph]
     @test_throws AssertionError MOI.initialize(evaluator, [:Foo])
     MOI.initialize(evaluator, [:Grad, :Jac, :Hess])
@@ -542,7 +544,7 @@ function test_SymbolicAD_Evaluator_squared()
     x = MOI.VariableIndex(1)
     model = MOI.Nonlinear.Model()
     MOI.Nonlinear.set_objective(model, :($x^2))
-    evaluator = MOI.Nonlinear.Evaluator(model, SymbolicAD.SymbolicMode(), [x])
+    evaluator = MOI.Nonlinear.Evaluator(model, Nonlinear.SymbolicMode(), [x])
     @test MOI.features_available(evaluator) == [:Grad, :Jac, :Hess, :ExprGraph]
     MOI.initialize(evaluator, [:Grad, :Jac, :Hess])
     x = [3.0]
@@ -563,7 +565,7 @@ function test_SymbolicAD_Evaluator_ifelse()
     x = MOI.VariableIndex(1)
     model = MOI.Nonlinear.Model()
     MOI.Nonlinear.set_objective(model, :(ifelse($x > 0, $x, -$x)))
-    evaluator = MOI.Nonlinear.Evaluator(model, SymbolicAD.SymbolicMode(), [x])
+    evaluator = MOI.Nonlinear.Evaluator(model, Nonlinear.SymbolicMode(), [x])
     @test MOI.features_available(evaluator) == [:Grad, :Jac, :Hess, :ExprGraph]
     MOI.initialize(evaluator, [:Grad, :Jac, :Hess])
     x = [3.0]
@@ -584,7 +586,7 @@ function test_SymbolicAD_Evaluator_comparison()
     x = MOI.VariableIndex(1)
     model = MOI.Nonlinear.Model()
     MOI.Nonlinear.set_objective(model, :(ifelse(($x < -1) || ($x > 1), $x, 0)))
-    evaluator = MOI.Nonlinear.Evaluator(model, SymbolicAD.SymbolicMode(), [x])
+    evaluator = MOI.Nonlinear.Evaluator(model, Nonlinear.SymbolicMode(), [x])
     @test MOI.features_available(evaluator) == [:Grad, :Jac, :Hess, :ExprGraph]
     MOI.initialize(evaluator, [:Grad, :Jac, :Hess])
     x = zeros(1)
@@ -663,7 +665,7 @@ function test_SymbolicAD_show()
             MOI.LessThan(2.0),
         )
     end
-    evaluator = MOI.Nonlinear.Evaluator(model, SymbolicAD.SymbolicMode(), x)
+    evaluator = MOI.Nonlinear.Evaluator(model, Nonlinear.SymbolicMode(), x)
     _, dag = only(evaluator.backend.dag)
     contents = sprint(show, dag)
     @test occursin("# x[1]", contents)
@@ -680,7 +682,7 @@ function test_SymbolicAD_subexpressions()
     MOI.Nonlinear.add_constraint(model, expr, MOI.LessThan(2.0))
     @test_throws(
         ErrorException("Subexpressions not supported"),
-        MOI.Nonlinear.Evaluator(model, SymbolicAD.SymbolicMode(), x),
+        MOI.Nonlinear.Evaluator(model, Nonlinear.SymbolicMode(), x),
     )
     return
 end
@@ -692,7 +694,7 @@ function test_SymbolicAD_parameters()
     MOI.Nonlinear.add_constraint(model, :($x * $p), MOI.LessThan(2.0))
     @test_throws(
         ErrorException("Parameters not supported"),
-        MOI.Nonlinear.Evaluator(model, SymbolicAD.SymbolicMode(), [x]),
+        MOI.Nonlinear.Evaluator(model, Nonlinear.SymbolicMode(), [x]),
     )
     return
 end
@@ -745,7 +747,7 @@ function test_SymbolicAD_univariate_registered()
     model = MOI.Nonlinear.Model()
     MOI.Nonlinear.register_operator(model, :op_foo, 1, x -> x^2)
     MOI.Nonlinear.set_objective(model, :(op_foo($x - 0.5)))
-    evaluator = MOI.Nonlinear.Evaluator(model, SymbolicAD.SymbolicMode(), [x])
+    evaluator = MOI.Nonlinear.Evaluator(model, Nonlinear.SymbolicMode(), [x])
     MOI.initialize(evaluator, [:Grad, :Jac, :Hess])
     x = [1.0]
     @test MOI.eval_objective(evaluator, x) == 0.25