Add HyperRectangle set (#1961)

Author: odow

docs/src/manual/standard_form.md

@@ -79,6 +79,7 @@ The vector-valued set types implemented in MathOptInterface.jl are:
 | [`NormOneCone(d)`](@ref MathOptInterface.NormOneCone)                 | ``\{ (t,x) \in \mathbb{R}^{d} : t \ge \sum_i \lvert x_i \rvert \}`` |
 | [`NormInfinityCone(d)`](@ref MathOptInterface.NormInfinityCone)       | ``\{ (t,x) \in \mathbb{R}^{d} : t \ge \max_i \lvert x_i \rvert \}`` |
 | [`RelativeEntropyCone(d)`](@ref MathOptInterface.RelativeEntropyCone) | ``\{ (u, v, w) \in \mathbb{R}^{d} : u \ge \sum_i w_i \log (\frac{w_i}{v_i}), v_i \ge 0, w_i \ge 0 \}`` |
+| [`HyperRectangle(l, u)`](@ref MathOptInterface.HyperRectangle)        | ``\{x \in \bar{\mathbb{R}}^d: x_i \in [l_i, u_i] \forall i=1,\ldots,d\}`` |
 
 ## Matrix cones
 

docs/src/reference/standard_form.md

@@ -94,6 +94,7 @@ SOS1
 SOS2
 Indicator
 Complements
+HyperRectangle
 ```
 
 ## Constraint programming sets

docs/src/submodules/Bridges/list_of_bridges.md

@@ -31,6 +31,7 @@ Bridges.Constraint.ScalarFunctionizeBridge
 Bridges.Constraint.VectorFunctionizeBridge
 Bridges.Constraint.SplitComplexEqualToBridge
 Bridges.Constraint.SplitComplexZerosBridge
+Bridges.Constraint.SplitHyperRectangleBridge
 Bridges.Constraint.SplitIntervalBridge
 Bridges.Constraint.SOCtoRSOCBridge
 Bridges.Constraint.RSOCtoSOCBridge

src/Bridges/Constraint/Constraint.jl

@@ -51,6 +51,7 @@ include("bridges/soc_to_nonconvex_quad.jl") # do not add these bridges by defaul
 include("bridges/soc_to_psd.jl")
 include("bridges/split_complex_equalto.jl")
 include("bridges/split_complex_zeros.jl")
+include("bridges/split_hyperrectangle.jl")
 include("bridges/hermitian.jl")
 include("bridges/square.jl")
 include("bridges/table.jl")
@@ -78,6 +79,7 @@ function add_all_bridges(bridged_model, ::Type{T}) where {T}
     MOI.Bridges.add_bridge(bridged_model, VectorSlackBridge{T})
     MOI.Bridges.add_bridge(bridged_model, ScalarFunctionizeBridge{T})
     MOI.Bridges.add_bridge(bridged_model, VectorFunctionizeBridge{T})
+    MOI.Bridges.add_bridge(bridged_model, SplitHyperRectangleBridge{T})
     MOI.Bridges.add_bridge(bridged_model, SplitIntervalBridge{T})
     MOI.Bridges.add_bridge(bridged_model, SplitComplexEqualToBridge{T})
     MOI.Bridges.add_bridge(bridged_model, SplitComplexZerosBridge{T})

src/Bridges/Constraint/bridges/split_hyperrectangle.jl

@@ -0,0 +1,253 @@
+# Copyright (c) 2017: Miles Lubin and contributors
+# Copyright (c) 2017: Google Inc.
+#
+# Use of this source code is governed by an MIT-style license that can be found
+# in the LICENSE.md file or at https://opensource.org/licenses/MIT.
+
+"""
+    SplitHyperRectangleBridge{T,G,F} <: Bridges.Constraint.AbstractBridge
+
+`SplitHyperRectangleBridge` implements the following reformulation:
+
+  * ``f(x) \\in \\textsf{HyperRectangle}(l, u)`` to
+    ``[f(x) - l; u - f(x)] \\in \\mathbb{R}_+``.
+
+## Source node
+
+`SplitHyperRectangleBridge` supports:
+
+  * `F` in [`MOI.HyperRectangle`](@ref)
+
+## Target nodes
+
+`SplitHyperRectangleBridge` creates:
+
+  * `G` in [`MOI.Nonnegatives`](@ref)
+"""
+mutable struct SplitHyperRectangleBridge{T,G,F} <: AbstractBridge
+    ci::MOI.ConstraintIndex{G,MOI.Nonnegatives}
+    set::MOI.HyperRectangle{T}
+    free_rows::F
+end
+
+const SplitHyperRectangle{T,OT<:MOI.ModelLike} =
+    SingleBridgeOptimizer{SplitHyperRectangleBridge{T},OT}
+
+function bridge_constraint(
+    ::Type{SplitHyperRectangleBridge{T,G,F}},
+    model::MOI.ModelLike,
+    f::F,
+    s::MOI.HyperRectangle,
+) where {T,G,F}
+    lower = MOI.Utilities.operate(-, T, f, s.lower)
+    upper = MOI.Utilities.operate(-, T, s.upper, f)
+    if any(!isfinite, s.lower)
+        indices = [i for (i, l) in enumerate(s.lower) if isfinite(l)]
+        lower = MOI.Utilities.eachscalar(lower)[indices]
+    end
+    if any(!isfinite, s.upper)
+        indices = [i for (i, u) in enumerate(s.upper) if isfinite(u)]
+        upper = MOI.Utilities.eachscalar(upper)[indices]
+    end
+    free_indices = Int[]
+    for (i, (l, u)) in enumerate(zip(s.lower, s.upper))
+        if !isfinite(l) && !isfinite(u)
+            push!(free_indices, i)
+        end
+    end
+    free_rows = MOI.Utilities.eachscalar(f)[free_indices]
+    g = MOI.Utilities.operate(vcat, T, lower, upper)
+    ci = MOI.add_constraint(model, g, MOI.Nonnegatives(MOI.output_dimension(g)))
+    return SplitHyperRectangleBridge{T,G,F}(ci, s, free_rows)
+end
+
+function MOI.supports_constraint(
+    ::Type{<:SplitHyperRectangleBridge{T}},
+    ::Type{<:MOI.AbstractVectorFunction},
+    ::Type{MOI.HyperRectangle{T}},
+) where {T}
+    return true
+end
+
+function MOI.Bridges.added_constrained_variable_types(
+    ::Type{<:SplitHyperRectangleBridge},
+)
+    return Tuple{Type}[]
+end
+
+function MOI.Bridges.added_constraint_types(
+    ::Type{<:SplitHyperRectangleBridge{T,G}},
+) where {T,G}
+    return Tuple{Type,Type}[(G, MOI.Nonnegatives),]
+end
+
+function concrete_bridge_type(
+    ::Type{<:SplitHyperRectangleBridge{T}},
+    ::Type{F},
+    ::Type{MOI.HyperRectangle{T}},
+) where {T,F<:MOI.AbstractVectorFunction}
+    G = MOI.Utilities.promote_operation(-, T, F, Vector{T})
+    return SplitHyperRectangleBridge{T,G,F}
+end
+
+function MOI.get(
+    model::MOI.ModelLike,
+    ::MOI.ConstraintFunction,
+    bridge::SplitHyperRectangleBridge{T,G,F},
+) where {T,G,F}
+    f = MOI.get(model, MOI.ConstraintFunction(), bridge.ci)
+    f_s = MOI.Utilities.eachscalar(f)
+    s = bridge.set
+    func = Vector{eltype(f_s)}(undef, MOI.dimension(s))
+
+    lower_indices = [i for (i, l) in enumerate(s.lower) if isfinite(l)]
+    for (i, index) in enumerate(lower_indices)
+        func[index] = MOI.Utilities.operate(+, T, f_s[i], s.lower[index])
+    end
+
+    upper_indices = [i for (i, u) in enumerate(s.upper) if isfinite(u)]
+    for (j, index) in enumerate(upper_indices)
+        i = length(lower_indices) + j
+        if !(index in lower_indices)
+            func[index] = MOI.Utilities.operate(-, T, s.upper[index], f_s[i])
+        end
+    end
+    free_s = MOI.Utilities.eachscalar(bridge.free_rows)
+    free_indices = Int[]
+    for (i, (l, u)) in enumerate(zip(s.lower, s.upper))
+        if !isfinite(l) && !isfinite(u)
+            push!(free_indices, i)
+        end
+    end
+    for (i, index) in enumerate(free_indices)
+        func[index] = free_s[i]
+    end
+    g = MOI.Utilities.operate(vcat, T, func...)
+    return MOI.Utilities.convert_approx(F, g)
+end
+
+function MOI.get(
+    ::MOI.ModelLike,
+    ::MOI.ConstraintSet,
+    bridge::SplitHyperRectangleBridge,
+)
+    return bridge.set
+end
+
+function MOI.delete(model::MOI.ModelLike, bridge::SplitHyperRectangleBridge)
+    MOI.delete(model, bridge.ci)
+    return
+end
+
+function MOI.get(
+    ::SplitHyperRectangleBridge{T,G},
+    ::MOI.NumberOfConstraints{G,MOI.Nonnegatives},
+)::Int64 where {T,G}
+    return 1
+end
+
+function MOI.get(
+    bridge::SplitHyperRectangleBridge{T,G},
+    ::MOI.ListOfConstraintIndices{G,MOI.Nonnegatives},
+) where {T,G}
+    return [bridge.ci]
+end
+
+function MOI.supports(
+    ::MOI.ModelLike,
+    ::Union{MOI.ConstraintPrimalStart,MOI.ConstraintDualStart},
+    ::Type{<:SplitHyperRectangleBridge},
+)
+    return true
+end
+
+function MOI.set(
+    model::MOI.ModelLike,
+    attr::MOI.ConstraintPrimalStart,
+    bridge::SplitHyperRectangleBridge{T},
+    value::AbstractVector{T},
+) where {T}
+    new_values = vcat(
+        T[v - l for (v, l) in zip(value, bridge.set.lower) if isfinite(l)],
+        T[u - v for (v, u) in zip(value, bridge.set.upper) if isfinite(u)],
+    )
+    MOI.set(model, attr, bridge.ci, new_values)
+    return
+end
+
+function MOI.get(
+    model::MOI.ModelLike,
+    attr::Union{MOI.ConstraintPrimal,MOI.ConstraintPrimalStart},
+    bridge::SplitHyperRectangleBridge{T},
+) where {T}
+    values = MOI.get(model, attr, bridge.ci)
+    if values === nothing
+        return nothing
+    end
+    ret = zeros(T, MOI.dimension(bridge.set))
+    row = 0
+    for (i, l) in enumerate(bridge.set.lower)
+        if isfinite(l)
+            row += 1
+            ret[i] = l + values[row]
+        end
+    end
+    for (i, u) in enumerate(bridge.set.upper)
+        if isfinite(u)
+            row += 1
+            ret[i] = u - values[row]
+        end
+    end
+    return ret
+end
+
+function MOI.set(
+    model::MOI.ModelLike,
+    attr::MOI.ConstraintDualStart,
+    bridge::SplitHyperRectangleBridge{T},
+    values::AbstractVector{T},
+) where {T}
+    set = bridge.set
+    new_values = vcat(
+        T[max(T(0), v) for (v, l) in zip(values, set.lower) if isfinite(l)],
+        T[min(T(0), v) for (v, u) in zip(values, set.upper) if isfinite(u)],
+    )
+    MOI.set(model, attr, bridge.ci, new_values)
+    return
+end
+
+function MOI.get(
+    model::MOI.ModelLike,
+    attr::Union{MOI.ConstraintDual,MOI.ConstraintDualStart},
+    bridge::SplitHyperRectangleBridge{T},
+) where {T}
+    values = MOI.get(model, attr, bridge.ci)
+    if values === nothing
+        return nothing
+    end
+    ret = zeros(T, MOI.dimension(bridge.set))
+    row = 0
+    for (i, l) in enumerate(bridge.set.lower)
+        if isfinite(l)
+            row += 1
+            ret[i] += values[row]
+        end
+    end
+    for (i, u) in enumerate(bridge.set.upper)
+        if isfinite(u)
+            row += 1
+            ret[i] += values[row]
+        end
+    end
+    return ret
+end
+
+function MOI.set(
+    model::MOI.ModelLike,
+    attr::Union{MOI.ConstraintPrimalStart,MOI.ConstraintDualStart},
+    bridge::SplitHyperRectangleBridge{T},
+    ::Nothing,
+) where {T}
+    MOI.set(model, attr, bridge.ci, nothing)
+    return
+end

src/Test/test_basic_constraint.jl

@@ -138,6 +138,10 @@ function _set(
     return MOI.Indicator{MOI.ACTIVATE_ON_ONE}(MOI.GreaterThan(convert(T, 3)))
 end
 
+function _set(::Type{T}, ::Type{MOI.HyperRectangle}) where {T}
+    return MOI.HyperRectangle(zeros(T, 3), ones(T, 3))
+end
+
 function _basic_constraint_test_helper(
     model::MOI.ModelLike,
     config::Config{T},
@@ -298,6 +302,7 @@ for s in [
     :Cumulative,
     :Table,
     :Path,
+    :HyperRectangle,
 ]
     S = getfield(MOI, s)
     functions = if S <: MOI.AbstractScalarSet