Rename GenericConstraint into Constraint and remove abstract type (#665)

Author: blegat

docs/src/changelog.md

@@ -30,7 +30,7 @@ changes.
     * The structs `LtConstraint`, `GtConstraint`, `EqConstraint`
       `SOCConstraint`, `ExpConstraint`, `GeoMeanEpiConeConstraint`,
       `GeoMeanHypoConeConstraint`, and `SDPConstraint` have been replaced by
-      `GenericConstraint{S}` where `S<:MOI.AbstractSet` (#590), (#597), (#598),
+      `Constraint{S}` where `S<:MOI.AbstractSet` (#590), (#597), (#598),
       (#599), (#601), (#602), (#604), (#623), (#632), (#648)
     * The set `GeomMeanEpiCone` has been renamed to `GeometricMeanEpiConeSquare`
       and `GeomMeanHypoCone` has been renamed to `GeometricMeanHypoConeSquare`

docs/src/manual/operations.md

@@ -116,14 +116,14 @@ solver (including SCS and Mosek).
 | `rootdet(X)`                      | n-th root-determinant of the $n$-by-$n$ matrix X, that is $det(X)^{1/n}$ | concave      | not monotonic |                        |
 | `matrixfrac(x, P)`                | $x^TP^{-1}x$                       | convex       | not monotonic | IC: P is positive semidefinite |
 | `sumlargesteigs(x, k)`            | sum of top $k$ eigenvalues of $x$  | convex       | not monotonic | IC: P symmetric        |
-| `Convex.GenericConstraint((T, A, B), GeometricMeanHypoConeSquare(t, size(T, 1)))`  | $T \preceq A \#_t B = A^{1/2} (A^{-1/2} B A^{-1/2})^t A^{1/2}$ | concave | increasing    | IC: $A \succeq 0$, $B \succeq 0$, $t \in [0,1]$ |
-| `Convex.GenericConstraint((T, A, B), GeometricMeanEpiConeSquare(t, size(T, 1)))`   | $T \succeq A \#_t B = A^{1/2} (A^{-1/2} B A^{-1/2})^t A^{1/2}$ | convex  | not monotonic | IC: $A \succeq 0$, $B \succeq 0$, $t \in [-1, 0] \cup [1, 2]$ |
+| `Convex.Constraint((T, A, B), GeometricMeanHypoConeSquare(t, size(T, 1)))`  | $T \preceq A \#_t B = A^{1/2} (A^{-1/2} B A^{-1/2})^t A^{1/2}$ | concave | increasing    | IC: $A \succeq 0$, $B \succeq 0$, $t \in [0,1]$ |
+| `Convex.Constraint((T, A, B), GeometricMeanEpiConeSquare(t, size(T, 1)))`   | $T \succeq A \#_t B = A^{1/2} (A^{-1/2} B A^{-1/2})^t A^{1/2}$ | convex  | not monotonic | IC: $A \succeq 0$, $B \succeq 0$, $t \in [-1, 0] \cup [1, 2]$ |
 | `quantum_entropy(X)`              | $-\textrm{Tr}(X \log X)$           | concave      | not monotonic | IC: $X \succeq 0$; uses natural log |
 | `quantum_relative_entropy(A, B)`  | $\textrm{Tr}(A \log A - A \log B)$ | convex       | not monotonic | IC: $A \succeq 0$, $B \succeq 0$; uses natural log |
 | `trace_logm(X, C)`                | $\textrm{Tr}(C \log X)$            | concave in X | not monotonic | IC: $X \succeq 0$, $C \succeq 0$, $C$ constant; uses natural log |
 | `trace_mpower(A, t, C)`           | $\textrm{Tr}(C A^t)$ | concave in A for $t \in [0,1]$, convex for $t \in [-1,0] \cup [1,2]$   | not monotonic | IC: $X \succeq 0$, $C \succeq 0$, $C$ constant, $t \in [-1, 2]$ |
 | `lieb_ando(A, B, K, t)`           | $\textrm{Tr}(K' A^{1-t} K B^t)$    | concave in A,B for $t \in [0,1]$, convex for $t \in [-1,0] \cup [1,2]$ | not monotonic | IC: $A \succeq 0$, $B \succeq 0$, $K$ constant, $t \in [-1, 2]$ |
-| `Convex.GenericConstraint((T, X, Y), RelativeEntropyEpiConeSquare(size(X, 1), m, k, e))` | $T \succeq e' X^{1/2} \log(X^{1/2} Y^{-1} X^{1/2}) X^{1/2} e$ | convex | not monotonic | IC: $e$ constant; uses natural log |
+| `Convex.Constraint((T, X, Y), RelativeEntropyEpiConeSquare(size(X, 1), m, k, e))` | $T \succeq e' X^{1/2} \log(X^{1/2} Y^{-1} X^{1/2}) X^{1/2} e$ | convex | not monotonic | IC: $e$ constant; uses natural log |
 
 ## Exponential + SDP representable Functions
 

src/constraints/GenericConstraint.jl renamed to src/Constraint.jl

@@ -3,21 +3,21 @@
 # Use of this source code is governed by a BSD-style license that can be found
 # in the LICENSE file or at https://opensource.org/license/bsd-2-clause
 
-mutable struct GenericConstraint{S<:MOI.AbstractSet} <: Constraint
+mutable struct Constraint{S<:MOI.AbstractSet}
     child::AbstractExpr
     set::S
     dual::Union{Value,Nothing}
 
-    function GenericConstraint(child::AbstractExpr, set::MOI.AbstractSet)
+    function Constraint(child::AbstractExpr, set::MOI.AbstractSet)
         return new{typeof(set)}(child, set, nothing)
     end
 end
 
-function GenericConstraint{S}(child::AbstractExpr) where {S<:MOI.AbstractSet}
-    return GenericConstraint(child, set_with_size(S, size(child)))
+function Constraint{S}(child::AbstractExpr) where {S<:MOI.AbstractSet}
+    return Constraint(child, set_with_size(S, size(child)))
 end
 
-iscomplex(c::GenericConstraint) = iscomplex(c.child)
+iscomplex(c::Constraint) = iscomplex(c.child)
 
 function set_with_size(
     ::Type{S},
@@ -32,13 +32,13 @@ function set_with_size(
     return MOI.Utilities.set_with_dimension(S, sz[1])
 end
 
-head(io::IO, c::GenericConstraint) = head(io, c.set)
+head(io::IO, c::Constraint) = head(io, c.set)
 
 function head(io::IO, set::MOI.AbstractSet)
     return print(io, replace("$(typeof(set))", "MathOptInterface" => "MOI"))
 end
 
-AbstractTrees.children(c::GenericConstraint) = (c.child,)
+AbstractTrees.children(c::Constraint) = (c.child,)
 
 # A fallback. Define a new method if `MOI.Utilities.distance_to_set`
 # is not defined.
@@ -50,7 +50,7 @@ function is_feasible(x::Number, set::MOI.AbstractVectorSet, tol)
     return is_feasible([x], set, tol)
 end
 
-vexity(c::GenericConstraint) = vexity(vexity(c.child), c.set)
+vexity(c::Constraint) = vexity(vexity(c.child), c.set)
 
 function vexity(
     vex,
@@ -86,7 +86,7 @@ function vexity(::Any, set::MOI.AbstractSet)
     )
 end
 
-function _add_constraint!(context::Context, c::GenericConstraint)
+function _add_constraint!(context::Context, c::Constraint)
     if vexity(c.child) == ConstVexity()
         # This `evaluate` call is safe, since even if it refers to a `fix!`'d variable,
         # it happens when we are formulating the problem (not at expression-time), so there
@@ -103,19 +103,15 @@ end
 
 function populate_dual!(
     model::MOI.ModelLike,
-    c::GenericConstraint,
+    c::Constraint,
     indices::MOI.ConstraintIndex,
 )
     ret = MOI.get(model, MOI.ConstraintDual(), indices)
     c.dual = output(reshape(ret, c.child.size))
     return
 end
 
-function populate_dual!(
-    model::MOI.ModelLike,
-    c::GenericConstraint,
-    indices::NTuple{2},
-)
+function populate_dual!(model::MOI.ModelLike, c::Constraint, indices::NTuple{2})
     re = MOI.get(model, MOI.ConstraintDual(), indices[1])
     imag = MOI.get(model, MOI.ConstraintDual(), indices[2])
     c.dual = output(reshape(re + im * imag, c.child.size))
@@ -169,7 +165,7 @@ function Base.:>=(lhs::AbstractExpr, rhs::AbstractExpr)
         )
     end
     lhs, rhs = _promote_size(lhs, rhs)
-    return GenericConstraint{MOI.Nonnegatives}(lhs - rhs)
+    return Constraint{MOI.Nonnegatives}(lhs - rhs)
 end
 
 Base.:>=(lhs::AbstractExpr, rhs::Value) = >=(lhs, constant(rhs))
@@ -201,7 +197,7 @@ function Base.:<=(lhs::AbstractExpr, rhs::AbstractExpr)
         )
     end
     lhs, rhs = _promote_size(lhs, rhs)
-    return GenericConstraint{MOI.Nonpositives}(lhs - rhs)
+    return Constraint{MOI.Nonpositives}(lhs - rhs)
 end
 
 Base.:<=(lhs::AbstractExpr, rhs::Value) = <=(lhs, constant(rhs))
@@ -227,7 +223,7 @@ end
 
 function Base.:(==)(lhs::AbstractExpr, rhs::AbstractExpr)
     lhs, rhs = _promote_size(lhs, rhs)
-    return GenericConstraint{MOI.Zeros}(lhs - rhs)
+    return Constraint{MOI.Zeros}(lhs - rhs)
 end
 
 Base.:(==)(lhs::AbstractExpr, rhs::Value) = ==(lhs, constant(rhs))
@@ -260,11 +256,11 @@ end
 
 function LinearAlgebra.isposdef(x::AbstractExpr)
     if iscomplex(x)
-        return GenericConstraint{MOI.PositiveSemidefiniteConeSquare}(
+        return Constraint{MOI.PositiveSemidefiniteConeSquare}(
             [real(x) -imag(x); imag(x) real(x)],
         )
     end
-    return GenericConstraint{MOI.PositiveSemidefiniteConeSquare}(x)
+    return Constraint{MOI.PositiveSemidefiniteConeSquare}(x)
 end
 
 ⪰(x::AbstractExpr, y::AbstractExpr) = isposdef(x - y)

src/Convex.jl

@@ -57,7 +57,6 @@ export conv,
     Constraint,
     ⪰,
     ⪯,
-    Constraint, # useful for making abstractly-typed vectors via `Constraint[]`
     # Variables
     constant,
     ComplexVariable,
@@ -213,11 +212,12 @@ include("Context.jl")
 ### modeling framework
 include("dcp.jl")
 include("expressions.jl")
+include("Constraint.jl")
 include("variable.jl")
 include("variable_template.jl")
 include("constant.jl")
 
-for (root, _, files) in walkdir(joinpath(@__DIR__, "constraints"))
+for (root, _, files) in walkdir(joinpath(@__DIR__, "sets"))
     for file in files
         include(joinpath(root, file))
     end

src/atoms/ExpAtom.jl

@@ -60,7 +60,7 @@ A naive implementation of this method is:
     t = Variable(m, n)
     for i in 1:m, j in 1:n
         f = vcat(x[i, j], 1, t[i, j])[collect(permutation)]
-        add_constraint!(context, GenericConstraint{MOI.ExponentialCone}(f))
+        add_constraint!(context, Constraint{MOI.ExponentialCone}(f))
     end
     return conic_form!(context, t)
 end

src/atoms/QuadOverLinAtom.jl

@@ -36,7 +36,7 @@ function new_conic_form!(context::Context{T}, q::QuadOverLinAtom) where {T}
     t = Variable()
     x, y = q.children
     f = vcat(t, (1 / T(2)) * y, x)
-    add_constraint!(context, GenericConstraint{MOI.RotatedSecondOrderCone}(f))
+    add_constraint!(context, Constraint{MOI.RotatedSecondOrderCone}(f))
     return conic_form!(context, t)
 end
 

src/atoms/QuantumEntropyAtom.jl

@@ -82,7 +82,7 @@ function new_conic_form!(
     end
     I = Matrix(one(T) * LinearAlgebra.I(size(X, 1)))
     set = RelativeEntropyEpiConeSquare(size(X, 1), atom.m, atom.k)
-    add_constraint!(context, GenericConstraint((τ, X, I), set))
+    add_constraint!(context, Constraint((τ, X, I), set))
     # It's already a real mathematically, but need to make it a real type.
     return conic_form!(context, real(-LinearAlgebra.tr(τ)))
 end

src/atoms/QuantumRelativeEntropyAtom.jl

@@ -95,7 +95,7 @@ function new_conic_form!(
     I = Matrix(one(T) * LinearAlgebra.I(size(A, 1)))
     τ, X, Y = Variable(), kron(A, I), kron(I, conj(B))
     set = RelativeEntropyEpiConeSquare(size(X, 1), atom.m, atom.k, vec(I))
-    add_constraint!(context, GenericConstraint((τ, X, Y), set))
+    add_constraint!(context, Constraint((τ, X, Y), set))
     return conic_form!(context, τ)
 end
 

src/atoms/RelativeEntropyAtom.jl

@@ -46,7 +46,7 @@ function new_conic_form!(context::Context{T}, e::RelativeEntropyAtom) where {T}
     # But MOI has the reversed convention:
     #   MOI.RelativeEntropyCone has the order (u, y, x)
     f = vcat(u, y, x)
-    add_constraint!(context, GenericConstraint{MOI.RelativeEntropyCone}(f))
+    add_constraint!(context, Constraint{MOI.RelativeEntropyCone}(f))
     return conic_form!(context, u)
 end
 

src/atoms/TraceLogmAtom.jl

@@ -103,7 +103,7 @@ function new_conic_form!(context::Context{T}, atom::TraceLogmAtom) where {T}
     end
     I = Matrix(one(T) * LinearAlgebra.I(size(X, 1)))
     set = RelativeEntropyEpiConeSquare(size(X, 1), atom.m, atom.k)
-    add_constraint!(context, GenericConstraint((τ, I, X), set))
+    add_constraint!(context, Constraint((τ, I, X), set))
     # It's already a real mathematically, but need to make it a real type.
     return conic_form!(context, real(-LinearAlgebra.tr(atom.C * τ)))
 end