Fixes

Author: blegat

src/constraints/GreaterThanConstraint.jl

@@ -2,7 +2,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")
+head(io::IO, ::MOI.Nonnegatives) = print(io, "≥")
 
 function is_feasible(f, ::MOI.Nonnegatives, tol)
     return all(f .>= tol)

src/constraints/LessThanConstraint.jl

@@ -2,7 +2,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")
+head(io::IO, ::MOI.Nonpositives) = print(io, "≤")
 
 function is_feasible(f, ::MOI.Nonpositives, tol)
     return all(f .<= -tol)

src/constraints/PositiveSemidefiniteConeConstraint.jl

@@ -1,20 +1,20 @@
-function set_with_size(::Type{MOI.PositiveSemidefiniteConeTriangle}, sz::Tuple{Int,Int})
+function set_with_size(::Type{MOI.PositiveSemidefiniteConeSquare}, sz::Tuple{Int,Int})
     if sz[1] != sz[2]
         error("Positive semidefinite expressions must be square")
     end
-    return MOI.PositiveSemidefiniteConeTriangle(sz[1])
+    return MOI.PositiveSemidefiniteConeSquare(sz[1])
 end
 
-head(io::IO, ::MOI.PositiveSemidefiniteConeTriangle) = print(io, "sdp")
+head(io::IO, ::MOI.PositiveSemidefiniteConeSquare) = print(io, "sdp")
 
-function vexity(vex, ::MOI.PositiveSemidefiniteConeTriangle)
+function vexity(vex, ::MOI.PositiveSemidefiniteConeSquare)
     if !(vex in (AffineVexity(), ConstVexity()))
         return NotDcp()
     end
     return AffineVexity()
 end
 
-function is_feasible(x, ::MOI.PositiveSemidefiniteConeTriangle, tol)
+function is_feasible(x, ::MOI.PositiveSemidefiniteConeSquare, tol)
     if !(x ≈ transpose(x))
         @warn "constant SDP constraint is violated"
         return false
@@ -27,11 +27,11 @@ end
 
 function LinearAlgebra.isposdef(x::AbstractExpr)
     if iscomplex(x)
-        return GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}(
+        return GenericConstraint{MOI.PositiveSemidefiniteConeSquare}(
             [real(x) -imag(x); imag(x) real(x)],
         )
     end
-    return GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}(x)
+    return GenericConstraint{MOI.PositiveSemidefiniteConeSquare}(x)
 end
 
 ⪰(x::AbstractExpr, y::AbstractExpr) = isposdef(x - y)

src/expressions.jl

@@ -32,7 +32,7 @@ abstract type AbstractExpr end
 
 abstract type Constraint end
 
-struct GenericConstraint{S<:MOI.AbstractSet} <: Constraint
+mutable struct GenericConstraint{S<:MOI.AbstractSet} <: Constraint
     child::AbstractExpr
     set::S
     dual::Union{Value,Nothing}
@@ -49,7 +49,7 @@ 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)
+    return vexity(vexity(c.child), c.set)
 end
 
 function _add_constraint!(
@@ -71,7 +71,7 @@ end
 
 function populate_dual!(model::MOI.ModelLike, c::GenericConstraint, indices)
     ret = MOI.get(model, MOI.ConstraintDual(), indices)
-    c.dual = output(reshape(ret, c.size))
+    c.dual = output(reshape(ret, c.child.size))
     return
 end
 

test/test_constraints.jl

@@ -183,30 +183,30 @@ function test_LessThanConstraint_dual_maximize()
     return
 end
 
-### constraints/GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}
+### constraints/GenericConstraint{MOI.PositiveSemidefiniteConeSquare}
 
-function test_GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}()
+function test_GenericConstraint{MOI.PositiveSemidefiniteConeSquare}()
     @test_throws(
         ErrorException("Positive semidefinite expressions must be square"),
-        Convex.GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}(Variable(2, 3)),
+        Convex.GenericConstraint{MOI.PositiveSemidefiniteConeSquare}(Variable(2, 3)),
     )
     X = Variable(2, 2)
-    c = Convex.GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}(X)
+    c = Convex.GenericConstraint{MOI.PositiveSemidefiniteConeSquare}(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.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 (0 ⪯ X) isa Convex.GenericConstraint{MOI.PositiveSemidefiniteConeSquare}
+    @test (-X ⪯ 0) isa Convex.GenericConstraint{MOI.PositiveSemidefiniteConeSquare}
+    @test (-X ⪯ constant(0)) isa Convex.GenericConstraint{MOI.PositiveSemidefiniteConeSquare}
+    @test (constant(0) ⪯ X) isa Convex.GenericConstraint{MOI.PositiveSemidefiniteConeSquare}
     @test_throws(ErrorException("Set PSD not understood"), X in :PSD)
     @test vexity(X ⪯ square(Variable())) == Convex.NotDcp()
     return
 end
 
-function test_GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}_violated()
+function test_GenericConstraint{MOI.PositiveSemidefiniteConeSquare}_violated()
     X = constant([1 2; 3 4])
     p = satisfy([X ⪰ 0])
     @test_logs (:warn,) (:warn,) solve!(p, SCS.Optimizer)

test/test_utilities.jl

@@ -171,11 +171,13 @@ function test_show()
        └─ real variable ($(Convex.show_id(x)))
     subject to
     ├─ ≥ constraint (affine)
-    │  ├─ real variable ($(Convex.show_id(x)))
-    │  └─ $(reshape([1], 1, 1))
+    |  └─ + (affine; real)
+    │     ├─ real variable ($(Convex.show_id(x)))
+    │     └─ $(reshape([-1], 1, 1))
     └─ ≤ constraint (affine)
-       ├─ real variable ($(Convex.show_id(x)))
-       └─ $(reshape([3], 1, 1))
+       └─ + (affine; real)
+          ├─ real variable ($(Convex.show_id(x)))
+          └─ $(reshape([-3], 1, 1))
 
     status: `solve!` not called yet"""
 
@@ -258,8 +260,9 @@ function test_show()
             └─ nothing
             subject to
             └─ ≥ constraint (affine)
-               ├─ real variable ($(Convex.show_id(x)))
-               └─ $(reshape([0], 1, 1))
+               └─ + (affine; real)
+                  ├─ real variable ($(Convex.show_id(x)))
+                  └─ $(reshape([0], 1, 1))
 
             termination status: OPTIMAL
             primal status: FEASIBLE_POINT
@@ -403,7 +406,7 @@ function test_Constructors()
         Semidefinite(2),
     ]
         @test length(get_constraints(x)) == 1
-        @test get_constraints(x)[] isa Convex.GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}
+        @test get_constraints(x)[] isa Convex.GenericConstraint{MOI.PositiveSemidefiniteConeSquare}
     end
 
     @test_throws ErrorException HermitianSemidefinite(2, 3)
@@ -953,7 +956,7 @@ end
 function test_deprecation_in_symbol()
     x = Variable(2, 2)
     @test_logs (:warn,) (x in :SDP)
-    @test in(x, :semidefinite) isa Convex.GenericConstraint{MOI.PositiveSemidefiniteConeTriangle}
+    @test in(x, :semidefinite) isa Convex.GenericConstraint{MOI.PositiveSemidefiniteConeSquare}
     return
 end