Use L2 norm, not L1

perf/maxcut.jl

@@ -66,29 +66,36 @@ end
 
 function bench_plus(args...; kws...)
     C = maxcut_objective(weights(args...; kws...))
-    As = [SymLowRankMatrix(Diagonal(ones(1)), e_i(Float64, i, n, sparse = false, vector = false)) for i in 1:n]
+    As = [
+        SymLowRankMatrix(
+            Diagonal(ones(1)),
+            e_i(Float64, i, n, sparse = false, vector = false),
+        ) for i in 1:n
+    ]
     b = ones(n)
     d = SDPLRPlus.SDPData(C, As, b)
     var = SDPLRPlus.SolverVars(d, 1)
     aux = SDPLRPlus.SolverAuxiliary(d)
     bench(aux, var)
-    bench_lmul(aux.symlowrank_As[1]);
+    return bench_lmul(aux.symlowrank_As[1]);
 end
 
 function bench_lro(args...; vector, kws...)
     println("vector ? $vector")
-    model = maxcut(weights(args...; kws...), dual_optimizer(LRO.Optimizer); vector)
+    model =
+        maxcut(weights(args...; kws...), dual_optimizer(LRO.Optimizer); vector)
     set_attribute(model, "solver", LRO.BurerMonteiro.Solver)
     set_attribute(model, "sub_solver", SDPLRPlus.Solver)
     set_attribute(model, "ranks", [1])
     set_attribute(model, "maxmajoriter", 0)
     set_attribute(model, "printlevel", 3)
     @time optimize!(model)
-    solver = unsafe_backend(model).dual_problem.dual_model.model.optimizer.solver
+    solver =
+        unsafe_backend(model).dual_problem.dual_model.model.optimizer.solver
     aux = solver.model
     var = solver.solver.var
     bench(aux, var)
-    bench_rmul(aux.model.A[1])
+    return bench_rmul(aux.model.A[1])
 end
 
 n = 500

src/Bridges/Constraint/bridges/LinearCombinationBridge.jl

@@ -88,7 +88,7 @@ function MOI.Bridges.adjoint_map_function(bridge::LinearCombinationBridge, func)
 end
 
 function MOI.Bridges.inverse_map_function(::LinearCombinationBridge, _)
-    throw(
+    return throw(
         MOI.Bridges.MapNotInvertible(
             "The linear map is not always invertible for `LinearCombinationBridge`, use a `CachingOptimizer` layer",
         ),

src/errors.jl

@@ -13,12 +13,15 @@ function errors(
     pobj = NLPModels.obj(model, x),
     dobj = dual_obj(model, y),
 )
-    b_den = 1 + LinearAlgebra.norm(cons_constant(model), 1)
+    # The DIMACS spec writes these as `‖·‖₁`, but defines that as the largest
+    # component; in practice CSDP/SDPT3 (and Loraine) use the 2-norm for `b` and
+    # the Frobenius norm for `C`, so we match that here (`norm` defaults to 2).
+    b_den = 1 + LinearAlgebra.norm(cons_constant(model))
     C_den =
         1 +
-        LinearAlgebra.norm(grad(model, ScalarIndex), 1) +
+        LinearAlgebra.norm(grad(model, ScalarIndex)) +
         sum(matrix_indices(model), init = zero(b_den)) do i
-            return LinearAlgebra.norm(grad(model, i), 1)
+            return LinearAlgebra.norm(grad(model, i))
         end
     obj_den = 1 + abs(pobj) + abs(dobj)
     return (

test/maxcut.jl

@@ -126,10 +126,10 @@ end;
     for xx in [x, X]
         err = LRO.errors(b.solver.model, xx; y, dual_slack = xx, dual_err = xx)
         @test length(err) == 6
-        @test err[1] ≈ 4.155017729878046
-        @test err[2] ≈ 0.318237296391563
-        @test err[3] ≈ 70/9
-        @test err[4] ≈ 70/9
+        @test err[1] ≈ 10.089041685524935
+        @test err[2] ≈ 0.7727306013872245 rtol = 1e-6
+        @test err[3] ≈ 18.2842712474619
+        @test err[4] ≈ 18.2842712474619
         @test err[5] ≈ 0.92
         @test err[6] ≈ 392.0
     end