Fix tests

Author: blegat

src/constraints/GreaterThanConstraint.jl

@@ -1,3 +1,7 @@
+function set_with_size(::Type{MOI.Nonnegatives}, sz::Tuple{Int,Int})
+    return MOI.Nonnegatives(prod(sz))
+end
+
 head(io::IO, ::MOI.Nonnegatives) = print(io, "nonneg")
 
 function is_feasible(f, ::MOI.Nonnegatives, tol)

src/constraints/LessThanConstraint.jl

@@ -1,3 +1,7 @@
+function set_with_size(::Type{MOI.Nonpositives}, sz::Tuple{Int,Int})
+    return MOI.Nonpositives(prod(sz))
+end
+
 head(io::IO, ::MOI.Nonpositives) = print(io, "nonpos")
 
 function is_feasible(f, ::MOI.Nonpositives, tol)

src/constraints/PositiveSemidefiniteConeConstraint.jl

@@ -27,11 +27,11 @@ end
 
 function LinearAlgebra.isposdef(x::AbstractExpr)
     if iscomplex(x)
-        return PositiveSemidefiniteConeConstraint(
+        return GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}(
             [real(x) -imag(x); imag(x) real(x)],
         )
     end
-    return PositiveSemidefiniteConeConstraint(x)
+    return GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}(x)
 end
 
 ⪰(x::AbstractExpr, y::AbstractExpr) = isposdef(x - y)

src/expressions.jl

@@ -26,26 +26,32 @@
 #
 #############################################################################
 
+const Value = Union{Number,AbstractArray}
+
 abstract type AbstractExpr end
 
 abstract type Constraint end
 
-struct GenericConstraint{S<:MOI.AbstractSet}
+struct GenericConstraint{S<:MOI.AbstractSet} <: Constraint
     child::AbstractExpr
     set::S
-    dual::ValueOrNothing
-    function Constraint(child, set::MOI.AbstractSet)
+    dual::Union{Value,Nothing}
+    function GenericConstraint(child, set::MOI.AbstractSet)
         return new{typeof(set)}(child, set)
     end
-    function Constraint{S}(child) where {S<:MOI.AbstractSet}
-        return Constraint(child, set_with_size(S, size(child)))
+    function GenericConstraint{S}(child) where {S<:MOI.AbstractSet}
+        return GenericConstraint(child, set_with_size(S, size(child)))
     end
 end
 
 head(io::IO, c::GenericConstraint) = head(io, c.set)
 
 AbstractTrees.children(c::GenericConstraint) = (c.child,)
 
+function vexity(c::GenericConstraint)
+    return vexity(c.child, c.set)
+end
+
 function _add_constraint!(
     context::Context,
     c::GenericConstraint,
@@ -58,8 +64,7 @@ function _add_constraint!(
         return
     end
     f = conic_form!(context, c.child)
-    set = MOI.PositiveSemidefiniteConeSquare(c.size[1])
-    context.constr_to_moi_inds[c] = MOI_add_constraint(context.model, f, set)
+    context.constr_to_moi_inds[c] = MOI_add_constraint(context.model, f, c.set)
     return
 end
 
@@ -70,8 +75,6 @@ function populate_dual!(model::MOI.ModelLike, c::GenericConstraint, indices)
     return
 end
 
-const Value = Union{Number,AbstractArray}
-
 # We commandeer `==` to create a constraint.
 # Therefore we define `isequal` to still have a notion of equality
 # (Normally `isequal` falls back to `==`, so we need to provide a method).

test/test_constraints.jl

@@ -183,30 +183,30 @@ function test_LessThanConstraint_dual_maximize()
     return
 end
 
-### constraints/PositiveSemidefiniteConeConstraint
+### constraints/GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}
 
-function test_PositiveSemidefiniteConeConstraint()
+function test_GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}()
     @test_throws(
         ErrorException("Positive semidefinite expressions must be square"),
-        Convex.PositiveSemidefiniteConeConstraint(Variable(2, 3)),
+        Convex.GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}(Variable(2, 3)),
     )
     X = Variable(2, 2)
-    c = Convex.PositiveSemidefiniteConeConstraint(X)
+    c = Convex.GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}(X)
     p = minimize(tr(X), [c, X >= [1 2; 3 4]])
     solve!(p, SCS.Optimizer; silent_solver = true)
     @test isapprox(X.value, [2.25 3; 3 4]; atol = 1e-3)
     y = (c.dual + c.dual') / 2
     @test isapprox(y[1], 1; atol = 1e-3)
-    @test (0 ⪯ X) isa Convex.PositiveSemidefiniteConeConstraint
-    @test (-X ⪯ 0) isa Convex.PositiveSemidefiniteConeConstraint
-    @test (-X ⪯ constant(0)) isa Convex.PositiveSemidefiniteConeConstraint
-    @test (constant(0) ⪯ X) isa Convex.PositiveSemidefiniteConeConstraint
+    @test (0 ⪯ X) isa Convex.GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}
+    @test (-X ⪯ 0) isa Convex.GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}
+    @test (-X ⪯ constant(0)) isa Convex.GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}
+    @test (constant(0) ⪯ X) isa Convex.GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}
     @test_throws(ErrorException("Set PSD not understood"), X in :PSD)
     @test vexity(X ⪯ square(Variable())) == Convex.NotDcp()
     return
 end
 
-function test_PositiveSemidefiniteConeConstraint_violated()
+function test_GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}_violated()
     X = constant([1 2; 3 4])
     p = satisfy([X ⪰ 0])
     @test_logs (:warn,) (:warn,) solve!(p, SCS.Optimizer)

test/test_utilities.jl

@@ -403,7 +403,7 @@ function test_Constructors()
         Semidefinite(2),
     ]
         @test length(get_constraints(x)) == 1
-        @test get_constraints(x)[] isa Convex.PositiveSemidefiniteConeConstraint
+        @test get_constraints(x)[] isa Convex.GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}
     end
 
     @test_throws ErrorException HermitianSemidefinite(2, 3)
@@ -953,7 +953,7 @@ end
 function test_deprecation_in_symbol()
     x = Variable(2, 2)
     @test_logs (:warn,) (x in :SDP)
-    @test in(x, :semidefinite) isa Convex.PositiveSemidefiniteConeConstraint
+    @test in(x, :semidefinite) isa Convex.GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}
     return
 end