Add constraint programming sets

Author: odow

docs/src/reference/standard_form.md

@@ -101,9 +101,13 @@ Complements
 ```@docs
 AllDifferent
 Among
+BinPacking
 CountAtLeast
 CountDistinct
 CountGreaterThan
+Circuit
+Cumulative
+Table
 ```
 
 ## Matrix sets

src/Test/test_basic_constraint.jl

@@ -114,6 +114,16 @@ _set(::Type{MOI.CountDistinct}) = MOI.CountDistinct(4)
 _set(::Type{MOI.Among}) = MOI.Among(4, Set([3, 4]))
 _set(::Type{MOI.CountAtLeast}) = MOI.CountAtLeast(1, [2, 2], Set([3]))
 _set(::Type{MOI.CountGreaterThan}) = MOI.CountGreaterThan(5)
+_set(::Type{MOI.Circuit}) = MOI.Circuit(3)
+_set(::Type{MOI.Cumulative}) = MOI.Cumulative(7)
+
+function _set(::Type{T}, ::Type{MOI.BinPacking}) where {T}
+    return MOI.BinPacking(T(2), T[1, 2])
+end
+
+function _set(::Type{T}, ::Type{MOI.Table}) where {T}
+    return MOI.Table(T[0 1 1; 1 0 1; 1 1 0])
+end
 
 function _set(
     ::Type{MOI.Indicator{MOI.ACTIVATE_ON_ONE,MOI.LessThan{T}}},
@@ -282,6 +292,10 @@ for s in [
     :Among,
     :CountAtLeast,
     :CountGreaterThan,
+    :BinPacking,
+    :Circuit,
+    :Cumulative,
+    :Table,
 ]
     S = getfield(MOI, s)
     functions = if S <: MOI.AbstractScalarSet

src/Test/test_cpsat.jl

@@ -220,3 +220,175 @@ function setup_test(
     )
     return
 end
+
+"""
+    test_cpsat_BinPacking(model::MOI.ModelLike, config::Config)
+
+Add a VectorOfVariables-in-BinPacking constraint.
+"""
+function test_cpsat_BinPacking(
+    model::MOI.ModelLike,
+    config::Config{T},
+) where {T}
+    @requires MOI.supports_constraint(
+        model,
+        MOI.VectorOfVariables,
+        MOI.BinPacking{T},
+    )
+    @requires MOI.supports_add_constrained_variable(model, MOI.Integer)
+    @requires _supports(config, MOI.optimize!)
+    x = [MOI.add_constrained_variable(model, MOI.Integer())[1] for _ in 1:3]
+    MOI.add_constraint(
+        model,
+        MOI.VectorOfVariables(x),
+        MOI.BinPacking(T(2), T[1, 2]),
+    )
+    MOI.optimize!(model)
+    x_val = round.(Int, MOI.get.(model, MOI.VariablePrimal(), x))
+    @test 1 * x_val[1] + 2 * x_val[2] <= T(2)
+    return
+end
+
+function setup_test(
+    ::typeof(test_cpsat_BinPacking),
+    model::MOIU.MockOptimizer,
+    ::Config{T},
+) where {T}
+    MOIU.set_mock_optimize!(
+        model,
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(
+            mock,
+            MOI.OPTIMAL,
+            (MOI.FEASIBLE_POINT, T[2, 0]),
+        ),
+    )
+    return
+end
+
+"""
+    test_cpsat_Cumulative(model::MOI.ModelLike, config::Config)
+
+Add a VectorOfVariables-in-Cumulative constraint.
+"""
+function test_cpsat_Cumulative(
+    model::MOI.ModelLike,
+    config::Config{T},
+) where {T}
+    @requires MOI.supports_constraint(
+        model,
+        MOI.VectorOfVariables,
+        MOI.Cumulative,
+    )
+    @requires MOI.supports_add_constrained_variable(model, MOI.Integer)
+    @requires _supports(config, MOI.optimize!)
+    s = [MOI.add_constrained_variable(model, MOI.Integer())[1] for _ in 1:3]
+    d = [MOI.add_constrained_variable(model, MOI.Integer())[1] for _ in 1:3]
+    r = [MOI.add_constrained_variable(model, MOI.Integer())[1] for _ in 1:3]
+    b, _ = MOI.add_constrained_variable(model, MOI.Integer())
+    MOI.add_constraint(
+        model,
+        MOI.VectorOfVariables([s; d; r; b]),
+        MOI.Cumulative(10),
+    )
+    MOI.optimize!(model)
+    s_val = round.(Int, MOI.get.(model, MOI.VariablePrimal(), s))
+    d_val = round.(Int, MOI.get.(model, MOI.VariablePrimal(), d))
+    r_val = round.(Int, MOI.get.(model, MOI.VariablePrimal(), r))
+    b_val = round(Int, MOI.get(model, MOI.VariablePrimal(), b))
+    times = zeros(maximum(s_val) + maximum(d_val))
+    for i in 1:3
+        for j in 0:(d_val[i]-1)
+            t = s_val[i] + j
+            times[t] += r_val[i]
+        end
+    end
+    @test all(times .<= b_val)
+    return
+end
+
+function setup_test(
+    ::typeof(test_cpsat_Cumulative),
+    model::MOIU.MockOptimizer,
+    ::Config{T},
+) where {T}
+    MOIU.set_mock_optimize!(
+        model,
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(
+            mock,
+            MOI.OPTIMAL,
+            (MOI.FEASIBLE_POINT, T[0, 1, 2, 2, 2, 2, 3, 2, 1, 5]),
+        ),
+    )
+    return
+end
+
+"""
+    test_cpsat_Table(model::MOI.ModelLike, config::Config)
+
+Add a VectorOfVariables-in-Table constraint.
+"""
+function test_cpsat_Table(model::MOI.ModelLike, config::Config{T}) where {T}
+    @requires MOI.supports_constraint(
+        model,
+        MOI.VectorOfVariables,
+        MOI.Table{T},
+    )
+    @requires MOI.supports_add_constrained_variable(model, MOI.Integer)
+    @requires _supports(config, MOI.optimize!)
+    x = [MOI.add_constrained_variable(model, MOI.Integer())[1] for _ in 1:3]
+    table = T[1 1 0; 0 1 1]
+    MOI.add_constraint(model, MOI.VectorOfVariables(x), MOI.Table(table))
+    MOI.optimize!(model)
+    x_val = round.(Int, MOI.get.(model, MOI.VariablePrimal(), x))
+    @test x_val == [1, 1, 0] || x_val == [0, 1, 1]
+    return
+end
+
+function setup_test(
+    ::typeof(test_cpsat_Table),
+    model::MOIU.MockOptimizer,
+    ::Config{T},
+) where {T}
+    MOIU.set_mock_optimize!(
+        model,
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(
+            mock,
+            MOI.OPTIMAL,
+            (MOI.FEASIBLE_POINT, T[1, 1, 0]),
+        ),
+    )
+    return
+end
+
+"""
+    test_cpsat_Circuit(model::MOI.ModelLike, config::Config)
+
+Add a VectorOfVariables-in-Circuit constraint.
+"""
+function test_cpsat_Circuit(model::MOI.ModelLike, config::Config{T}) where {T}
+    @requires MOI.supports_constraint(model, MOI.VectorOfVariables, MOI.Circuit)
+    @requires MOI.supports_add_constrained_variable(model, MOI.Integer)
+    @requires _supports(config, MOI.optimize!)
+    x = [MOI.add_constrained_variable(model, MOI.Integer())[1] for _ in 1:3]
+    MOI.add_constraint(model, MOI.VectorOfVariables(x), MOI.Circuit(3))
+    MOI.optimize!(model)
+    x_val = round.(Int, MOI.get.(model, MOI.VariablePrimal(), x))
+    @test x_val == [3, 1, 2] || x_val == [2, 3, 1]
+    return
+end
+
+function setup_test(
+    ::typeof(test_cpsat_Circuit),
+    model::MOIU.MockOptimizer,
+    ::Config{T},
+) where {T}
+    MOIU.set_mock_optimize!(
+        model,
+        (mock::MOIU.MockOptimizer) -> MOIU.mock_optimize!(
+            mock,
+            MOI.OPTIMAL,
+            (MOI.FEASIBLE_POINT, T[3, 1, 2]),
+        ),
+    )
+    return
+end

src/Utilities/functions.jl

@@ -3160,7 +3160,7 @@ function convert_approx(
        any(
            j -> j != i && abs(f.terms[j].coefficient) > tol,
            eachindex(f.terms),
-       )
+        )
         throw(InexactError(:convert_approx, MOI.VariableIndex, func))
     end
     return f.terms[i].variable

src/Utilities/model.jl

@@ -792,6 +792,8 @@ const LessThanIndicatorZero{T} =
         MOI.Among,
         MOI.CountAtLeast,
         MOI.CountGreaterThan,
+        MOI.Circuit,
+        MOI.Cumulative,
     ),
     (
         MOI.PowerCone,
@@ -800,6 +802,8 @@ const LessThanIndicatorZero{T} =
         MOI.SOS2,
         LessThanIndicatorOne,
         LessThanIndicatorZero,
+        MOI.Table,
+        MOI.BinPacking,
     ),
     (),
     (MOI.ScalarAffineFunction, MOI.ScalarQuadraticFunction),

src/sets.jl

@@ -1297,6 +1297,131 @@ struct CountGreaterThan <: AbstractVectorSet
     end
 end
 
+"""
+    BinPacking(capacity::T, weights::Vector{T}) where {T}
+
+The set ``\\{x \\in \\mathbb{R}^d\\}`` such that
+``\\sum\\limits_{i=1}^d w_i x_i \\le c``.
+
+This constraint is sometimes called `bin_packing`.
+
+## Example
+
+```julia
+model = Utilities.Model{Float64}()
+x = [add_constrained_variable(model, MOI.Integer())[1] for _ in 1:3]
+add_constraint(model, VectorOfVariables(x), BinPacking(0.5, rand(3)))
+```
+"""
+struct BinPacking{T} <: AbstractVectorSet
+    capacity::T
+    weights::Vector{T}
+    function BinPacking(capacity::T, weights::Vector{T}) where {T}
+        if capacity < zero(T)
+            throw(DomainError(capacity, "capacity must be non-negative"))
+        end
+        if any(w -> w < zero(T), weights)
+            throw(DomainError(weights, "weights must be non-negative"))
+        end
+        return new{T}(capacity, weights)
+    end
+end
+
+dimension(set::BinPacking) = length(set.weights)
+
+function Base.copy(set::BinPacking{T}) where {T}
+    return BinPacking{T}(set.capacity, copy(set.weights))
+end
+
+function Base.:(==)(x::BinPacking{T}, y::BinPacking{T}) where {T}
+    return x.capacity == y.capacity && x.weights == y.weights
+end
+
+"""
+    Cumulative(dimension::Int)
+
+The set ``\\{(s, d, r, b) \\in \\mathbb{R}^{s+d+r+1}\\}`` representing the
+``cumulative`` global constraint. It requires that a set of tasks given by start
+times ``s``, durations ``d``, and resource requirements ``r``, never requires
+more than the global resource bound ``b`` at any one time.
+
+This constraint is sometimes called `cumulative`.
+
+## Example
+
+```julia
+model = Utilities.Model{Float64}()
+s = [add_constrained_variable(model, MOI.Integer())[1] for _ in 1:3]
+d = [add_constrained_variable(model, MOI.Integer())[1] for _ in 1:3]
+r = [add_constrained_variable(model, MOI.Integer())[1] for _ in 1:3]
+b, _ = add_constrained_variable(model, MOI.Integer())
+add_constraint(model, VectorOfVariables([s; d; r; b]), Cumulative(10))
+```
+"""
+struct Cumulative <: AbstractVectorSet
+    dimension::Int
+    function Cumulative(dimension::Base.Integer)
+        if dimension < 1
+            throw(DimensionMismatch("Dimension of Cumulative must be >= 1."))
+        end
+        return new(dimension)
+    end
+end
+
+"""
+    Table(table::Matrix{T}) where {T}
+
+The set ``\\{x \\in \\mathbb{R}^d\\}`` such that `x` belongs to one row of
+`table`. That is, there exists some `j` in `1:size(table, 1)`, such that
+`x[i] = table[j, i]`.
+
+This constraint is sometimes called `table`.
+
+## Example
+
+```julia
+model = Utilities.Model{Float64}()
+x = [add_constrained_variable(model, MOI.Integer())[1] for _ in 1:3]
+table = [1 1 0; 0 1 1; 1 0 1; 1 1 1]
+add_constraint(model, VectorOfVariables(x), Table(table))
+```
+"""
+struct Table{T} <: AbstractVectorSet
+    table::Matrix{T}
+end
+
+dimension(set::Table) = size(set.table, 2)
+
+Base.copy(set::Table) = Table(copy(set.table))
+
+Base.:(==)(x::Table{T}, y::Table{T}) where {T} = x.table == y.table
+
+"""
+    Circuit(dimension::Int)
+
+The set ``\\{x \\in \\mathbb{R}^d\\}`` that constraints ``x`` to be a circuit,
+such that ``x_i = j`` means that ``j`` is the successor of ``i``.
+
+This constraint is sometimes called `circuit`.
+
+## Example
+
+```julia
+model = Utilities.Model{Float64}()
+x = [add_constrained_variable(model, MOI.Integer())[1] for _ in 1:3]
+add_constraint(model, VectorOfVariables(x), Circuit(3))
+```
+"""
+struct Circuit <: AbstractVectorSet
+    dimension::Int
+    function Circuit(dimension::Base.Integer)
+        if dimension < 0
+            throw(DimensionMismatch("Dimension of Circuit must be >= 0."))
+        end
+        return new(dimension)
+    end
+end
+
 # isbits types, nothing to copy
 function Base.copy(
     set::Union{
@@ -1336,6 +1461,8 @@ function Base.copy(
         Among,
         CountAtLeast,
         CountGreaterThan,
+        Circuit,
+        Cumulative,
     },
 )
     return set