Update

Author: odow

ext/MathOptInterfaceLDLFactorizationsExt.jl

@@ -14,7 +14,7 @@ import SparseArrays
 # The type signature of this function is not important, so long as it is more
 # specific than the (untyped) generic fallback with the error pointing to
 # LDLFactorizations.jl
-function MOI.Bridges.Constraint.compute_sparse_sqrt_root_fallback(
+function MOI.Bridges.Constraint.compute_sparse_sqrt_fallback(
     Q::AbstractMatrix,
     ::F,
     ::S,

src/Bridges/Constraint/bridges/QuadtoSOCBridge.jl

@@ -60,7 +60,7 @@ end
 const QuadtoSOC{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{QuadtoSOCBridge{T},OT}
 
-function compute_sparse_sqrt_root_fallback(Q, ::F, ::S) where {F,S}
+function compute_sparse_sqrt_fallback(Q, ::F, ::S) where {F,S}
     msg = """
     Unable to transform a quadratic constraint into a SecondOrderCone
     constraint because the quadratic constraint is not strongly convex and
@@ -79,10 +79,10 @@ function compute_sparse_sqrt_root_fallback(Q, ::F, ::S) where {F,S}
     return throw(MOI.AddConstraintNotAllowed{F,S}(msg))
 end
 
-function compute_sparse_sqrt_root(Q, func, set)
+function compute_sparse_sqrt(Q, func, set)
     factor = LinearAlgebra.cholesky(Q; check = false)
     if !LinearAlgebra.issuccess(factor)
-        return compute_sparse_sqrt_root_fallback(Q, func, set)
+        return compute_sparse_sqrt_fallback(Q, func, set)
     end
     L, p = SparseArrays.sparse(factor.L), factor.p
     # We have Q = P' * L * L' * P. We want to find Q = U' * U, so U = L' * P
@@ -117,7 +117,7 @@ function bridge_constraint(
             MOI.ScalarAffineTerm(scale * term.coefficient, term.variable),
         ) for term in func.affine_terms
     ]
-    I, J, V = compute_sparse_sqrt_root(LinearAlgebra.Symmetric(Q), func, set)
+    I, J, V = compute_sparse_sqrt(LinearAlgebra.Symmetric(Q), func, set)
     for (i, j, v) in zip(I, J, V)
         push!(
             vector_terms,

test/Bridges/Constraint/QuadtoSOCBridge.jl

@@ -355,7 +355,7 @@ function test_semidefinite_cholesky_fail()
     return
 end
 
-function test_compute_sparse_U_edge_cases()
+function test_compute_sparse_sqrt_edge_cases()
     f = zero(MOI.ScalarQuadraticFunction{Float64})
     s = MOI.GreaterThan(0.0)
     for A in [
@@ -371,7 +371,7 @@ function test_compute_sparse_U_edge_cases()
         [2.0 0.0; 0.0 0.0],
     ]
         B = SparseArrays.sparse(A)
-        I, J, V = MOI.Bridges.Constraint.compute_sparse_sqrt_root(B, f, s)
+        I, J, V = MOI.Bridges.Constraint.compute_sparse_sqrt(B, f, s)
         U = zeros(size(A))
         for (i, j, v) in zip(I, J, V)
             U[i, j] += v
@@ -382,7 +382,21 @@ function test_compute_sparse_U_edge_cases()
     B = SparseArrays.sparse(A)
     @test_throws(
         MOI.UnsupportedConstraint{typeof(f),typeof(s)},
-        MOI.Bridges.Constraint.compute_sparse_sqrt_root(B, f, s),
+        MOI.Bridges.Constraint.compute_sparse_sqrt(B, f, s),
+    )
+    return
+end
+
+function test_compute_sparse_sqrt_fallback()
+    # Test the default fallback that is hit when LDLFactorizations isn't loaded.
+    # We could put the test somewhere else so it runs before this file is
+    # loaded, but that's pretty flakey for a long-term solution. Instead, we're
+    # going to abuse the lack of a strong type signature to hit it:
+    f = zero(MOI.ScalarAffineFunction{Float64})
+    A = SparseArrays.sparse([-1.0 0.0; 0.0 1.0])
+    @test_throws(
+        MOI.AddConstraintNotAllowed{typeof(f),MOI.GreaterThan{Float64}},
+        MOI.Bridges.Constraint.compute_sparse_sqrt(A, f, MOI.GreaterThan(0.0)),
     )
     return
 end