format

Author: andrewrosemberg

src/NonLinearProgram/NonLinearProgram.jl

@@ -125,7 +125,11 @@ function MOI.supports_constraint(
     return true
 end
 
-function _add_leq_geq(form::Form, idx::MOI.ConstraintIndex, set::MOI.GreaterThan)
+function _add_leq_geq(
+    form::Form,
+    idx::MOI.ConstraintIndex,
+    set::MOI.GreaterThan,
+)
     form.geq_values[idx] = set.lower
     return
 end
@@ -434,10 +438,7 @@ function _cache_evaluator!(model::Model)
     return model.cache
 end
 
-function DiffOpt.forward_differentiate!(
-    model::Model;
-    tol = 1e-6,
-)
+function DiffOpt.forward_differentiate!(model::Model; tol = 1e-6)
     model.diff_time = @elapsed begin
         cache = _cache_evaluator!(model)
         form = model.model
@@ -451,10 +452,7 @@ function DiffOpt.forward_differentiate!(
         end
 
         # Compute Jacobian
-        Δs = _compute_sensitivity(
-            model;
-            tol = tol,
-        )
+        Δs = _compute_sensitivity(model; tol = tol)
 
         # Extract primal and dual sensitivities
         primal_Δs = Δs[1:length(model.cache.primal_vars), :] * Δp # Exclude slacks
@@ -468,19 +466,13 @@ function DiffOpt.forward_differentiate!(
     return nothing
 end
 
-function DiffOpt.reverse_differentiate!(
-    model::Model;
-    tol = 1e-6,
-)
+function DiffOpt.reverse_differentiate!(model::Model; tol = 1e-6)
     model.diff_time = @elapsed begin
         cache = _cache_evaluator!(model)
         form = model.model
 
         # Compute Jacobian
-        Δs = _compute_sensitivity(
-            model;
-            tol = tol,
-        )
+        Δs = _compute_sensitivity(model; tol = tol)
         num_primal = length(cache.primal_vars)
         # Fetch primal sensitivities
         Δx = zeros(num_primal)

src/NonLinearProgram/nlp_utilities.jl

@@ -434,11 +434,7 @@ function _compute_derivatives_no_relax(
     num_vars = _get_num_primal_vars(model)
     num_cons = _get_num_constraints(model)
     num_ineq = length(ineq_locations)
-    K = model.input_cache.factorization(
-        M,
-        num_vars + num_ineq,
-        num_cons
-    ) # Factorization
+    K = model.input_cache.factorization(M, num_vars + num_ineq, num_cons) # Factorization
     if isnothing(K)
         return zeros(size(M, 1), size(N, 2)), K, N
     end
@@ -457,10 +453,7 @@ _sense_mult(model::Model) = objective_sense(model) == MOI.MIN_SENSE ? 1.0 : -1.0
 
 Compute the sensitivity of the solution given sensitivity of the parameters (Δp).
 """
-function _compute_sensitivity(
-    model::Model;
-    tol = 1e-6,
-)
+function _compute_sensitivity(model::Model; tol = 1e-6)
     # Solution and bounds
     X,
     V_L,
@@ -487,7 +480,7 @@ function _compute_sensitivity(
         geq_locations,
         ineq_locations,
         has_up,
-        has_low
+        has_low,
     )
     ## Adjust signs based on JuMP convention
     num_vars = _get_num_primal_vars(model)

src/diff_opt.jl

@@ -19,17 +19,20 @@ Lu-factorization. If no inertia correction is needed, it only performs the LU
 factorization.
 """
 struct LuFactorizationWithInertiaCorrection{T<:Real} <: Function
-    st::T 
+    st::T
     max_corrections::Int
 end
-function LuFactorizationWithInertiaCorrection(; st::T = 1e-6, max_corrections::Int = 50) where T
+function LuFactorizationWithInertiaCorrection(;
+    st::T = 1e-6,
+    max_corrections::Int = 50,
+) where {T}
     return LuFactorizationWithInertiaCorrection{T}(st, max_corrections)
 end
 
 function (lu_struct::LuFactorizationWithInertiaCorrection)(
     M::SparseArrays.SparseMatrixCSC,
     num_w,
-    num_cons
+    num_cons,
 )
     # Factorization
     K = SparseArrays.lu(M; check = false)

src/moi_wrapper.jl

@@ -769,11 +769,7 @@ function MOI.set(
     return
 end
 
-function MOI.set(
-    model::Optimizer,
-    ::MFactorization,
-    factorization,
-)
+function MOI.set(model::Optimizer, ::MFactorization, factorization)
     model.input_cache.factorization = factorization
     return
 end

test/nlp_program.jl

@@ -720,25 +720,25 @@ function test_changing_factorization()
     @test_throws MethodError DiffOpt.forward_differentiate!(m)
 
     # correct type and correct number of arguments
-    MOI.set(m, DiffOpt.MFactorization(), (M, num_w, num_constraints) -> SparseArrays.lu(M))
+    MOI.set(
+        m,
+        DiffOpt.MFactorization(),
+        (M, num_w, num_constraints) -> SparseArrays.lu(M),
+    )
 
     # Compute derivatives
     DiffOpt.forward_differentiate!(m)
 
     # Test sensitivities
     @test all(
         isapprox(
-            [
-                MOI.get(m, DiffOpt.ForwardVariablePrimal(), x[i]) for
-                i in 1:P
-            ],
+            [MOI.get(m, DiffOpt.ForwardVariablePrimal(), x[i]) for i in 1:P],
             [0.1 for _ in 1:P];
             atol = 1e-8,
         ),
     )
 end
 
-
 end # module
 
 TestNLPProgram.runtests()