Add Bridges.Constraint.NormSpecialCaseBridge

Author: odow

docs/src/submodules/Bridges/list_of_bridges.md

@@ -42,6 +42,7 @@ Bridges.Constraint.RSOCtoPSDBridge
 Bridges.Constraint.NormInfinityBridge
 Bridges.Constraint.NormOneBridge
 Bridges.Constraint.NormToPowerBridge
+Bridges.Constraint.NormSpecialCaseBridge
 Bridges.Constraint.GeoMeantoRelEntrBridge
 Bridges.Constraint.GeoMeanToPowerBridge
 Bridges.Constraint.GeoMeanBridge

src/Bridges/Constraint/Constraint.jl

@@ -40,6 +40,7 @@ include("bridges/ltgt_to_interval.jl")
 include("bridges/norm_infinity.jl")
 include("bridges/norm_one.jl")
 include("bridges/norm_to_power.jl")
+include("bridges/norm_special_case.jl")
 include("bridges/norm_spec_nuc_to_psd.jl")
 include("bridges/number_conversion.jl")
 include("bridges/quad_to_soc.jl")
@@ -95,6 +96,7 @@ function add_all_bridges(bridged_model, ::Type{T}) where {T}
     MOI.Bridges.add_bridge(bridged_model, GeoMeanBridge{T})
     MOI.Bridges.add_bridge(bridged_model, GeoMeanToPowerBridge{T})
     MOI.Bridges.add_bridge(bridged_model, NormToPowerBridge{T})
+    MOI.Bridges.add_bridge(bridged_model, NormSpecialCaseBridge{T})
     MOI.Bridges.add_bridge(bridged_model, RelativeEntropyBridge{T})
     MOI.Bridges.add_bridge(bridged_model, NormSpectralBridge{T})
     MOI.Bridges.add_bridge(bridged_model, NormNuclearBridge{T})

src/Bridges/Constraint/bridges/norm_special_case.jl

@@ -0,0 +1,123 @@
+# 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.
+
+"""
+    NormSpecialCaseBridge{T,F} <: Bridges.Constraint.AbstractBridge
+
+`NormSpecialCaseBridge` implements the following reformulations:
+
+  * ``(t, x) in NormOneCone(d)`` into ``(t, x) in NormCone(1, d)``
+  * ``(t, x) in SecondOrderCone(d)`` into ``(t, x) in NormCone(2, d)``
+  * ``(t, x) in NormInfinityCone(d)`` into ``(t, x) in NormCone(Inf, d)``
+
+## Source node
+
+`NormSpecialCaseBridge` supports:
+
+  * `F` in [`MOI.NormOneCone`](@ref)
+  * `F` in [`MOI.NormInfinityCone`](@ref)
+  * `F` in [`MOI.SecondOrderCone`](@ref)
+
+## Target nodes
+
+`NormSpecialCaseBridge` creates:
+
+  * `F` in [`MOI.NormCone`](@ref)
+"""
+struct NormSpecialCaseBridge{T,F} <: AbstractBridge
+    constraint::MOI.ConstraintIndex{F,MOI.NormCone}
+end
+
+const NormSpecialCase{T,OT<:MOI.ModelLike} =
+    SingleBridgeOptimizer{NormSpecialCaseBridge{T},OT}
+
+function bridge_constraint(
+    ::Type{NormSpecialCaseBridge{T,F}},
+    model::MOI.ModelLike,
+    f::F,
+    s::Union{MOI.NormOneCone,MOI.SecondOrderCone,MOI.NormInfinityCone},
+) where {T,F}
+    ci = MOI.add_constraint(model, f, MOI.NormCone(s))
+    return NormSpecialCaseBridge{T,F}(ci)
+end
+
+function MOI.supports_constraint(
+    ::Type{NormSpecialCaseBridge{T}},
+    ::Type{<:MOI.AbstractVectorFunction},
+    ::Type{<:Union{MOI.NormOneCone,MOI.SecondOrderCone,MOI.NormInfinityCone}},
+) where {T}
+    return true
+end
+
+function concrete_bridge_type(
+    ::Type{<:NormSpecialCaseBridge{T}},
+    F::Type{<:MOI.AbstractVectorFunction},
+    ::Type{<:Union{MOI.NormOneCone,MOI.SecondOrderCone,MOI.NormInfinityCone}},
+) where {T}
+    return NormSpecialCaseBridge{T,F}
+end
+
+function MOI.Bridges.added_constrained_variable_types(
+    ::Type{<:NormSpecialCaseBridge},
+)
+    return Tuple{Type}[]
+end
+
+function MOI.Bridges.added_constraint_types(
+    ::Type{NormSpecialCaseBridge{T,F}},
+) where {T,F}
+    return Tuple{Type,Type}[(F, MOI.NormCone)]
+end
+
+MOI.get(::NormSpecialCaseBridge, ::MOI.NumberOfVariables)::Int64 = 0
+
+function MOI.get(::NormSpecialCaseBridge, ::MOI.ListOfVariableIndices)
+    return MOI.VariableIndex[]
+end
+
+function MOI.get(
+    bridge::NormSpecialCaseBridge{T,F},
+    ::MOI.NumberOfConstraints{F,MOI.NormCone},
+)::Int64 where {T,F}
+    return 1
+end
+
+function MOI.get(
+    bridge::NormSpecialCaseBridge{T,F},
+    ::MOI.ListOfConstraintIndices{F,MOI.NormCone},
+) where {T,F}
+    return [bridge.constraint]
+end
+
+function MOI.delete(model::MOI.ModelLike, bridge::NormSpecialCaseBridge)
+    MOI.delete(model, bridge.constraint)
+    return
+end
+
+function MOI.get(
+    model::MOI.ModelLike,
+    ::MOI.ConstraintFunction,
+    bridge::NormSpecialCaseBridge,
+)
+    return MOI.get(model, MOI.ConstraintFunction(), bridge.constraint)
+end
+
+function MOI.get(
+    model::MOI.ModelLike,
+    ::MOI.ConstraintSet,
+    bridge::NormSpecialCaseBridge,
+)
+    set = MOI.get(model, MOI.ConstraintSet(), bridge.constraint)
+    d = MOI.dimension(set)
+    if set.p == 1
+        return MOI.NormOneCone(d)
+    elseif set.p == 2
+        return MOI.SecondOrderCone(d)
+    else
+        @assert set.p == Inf
+        return MOI.NormInfinityCone(d)
+    end
+end

src/sets.jl

@@ -668,48 +668,6 @@ end
 dual_set(s::NormOneCone) = NormInfinityCone(dimension(s))
 dual_set_type(::Type{NormOneCone}) = NormInfinityCone
 
-"""
-    NormCone(p::Float64, dimension::Int)
-
-The ``\\ell_p``-norm cone ``\\{ (t,x) \\in \\mathbb{R}^{dimension} : t \\ge \\left(\\sum\\limits_i |x_i|^p\\right)^{\\frac{1}{p}} \\}``
-of dimension `dimension`.
-
-The `dimension` must be at least `1`.
-
-## Example
-
-```jldoctest
-julia> import MathOptInterface as MOI
-
-julia> model = MOI.Utilities.Model{Float64}()
-MOIU.Model{Float64}
-
-julia> t = MOI.add_variable(model)
-MOI.VariableIndex(1)
-
-julia> x = MOI.add_variables(model, 3);
-
-julia> MOI.add_constraint(model, MOI.VectorOfVariables([t; x]), MOI.NormCone(3, 4))
-MathOptInterface.ConstraintIndex{MathOptInterface.VectorOfVariables, MathOptInterface.NormCone}(1)
-```
-"""
-struct NormCone <: AbstractVectorSet
-    p::Float64
-    dimension::Int
-
-    function NormCone(p::Real, dimension::Base.Integer)
-        if !(dimension >= 1)
-            throw(
-                DimensionMismatch(
-                    "Dimension of NormCone must be >= 1, not " *
-                    "$(dimension).",
-                ),
-            )
-        end
-        return new(convert(Float64, p), dimension)
-    end
-end
-
 """
     SecondOrderCone(dimension::Int)
 
@@ -804,6 +762,54 @@ end
 dual_set(s::RotatedSecondOrderCone) = copy(s)
 dual_set_type(::Type{RotatedSecondOrderCone}) = RotatedSecondOrderCone
 
+"""
+    NormCone(p::Float64, dimension::Int)
+
+The ``\\ell_p``-norm cone ``\\{ (t,x) \\in \\mathbb{R}^{dimension} : t \\ge \\left(\\sum\\limits_i |x_i|^p\\right)^{\\frac{1}{p}} \\}``
+of dimension `dimension`.
+
+The `dimension` must be at least `1`.
+
+## Example
+
+```jldoctest
+julia> import MathOptInterface as MOI
+
+julia> model = MOI.Utilities.Model{Float64}()
+MOIU.Model{Float64}
+
+julia> t = MOI.add_variable(model)
+MOI.VariableIndex(1)
+
+julia> x = MOI.add_variables(model, 3);
+
+julia> MOI.add_constraint(model, MOI.VectorOfVariables([t; x]), MOI.NormCone(3, 4))
+MathOptInterface.ConstraintIndex{MathOptInterface.VectorOfVariables, MathOptInterface.NormCone}(1)
+```
+"""
+struct NormCone <: AbstractVectorSet
+    p::Float64
+    dimension::Int
+
+    function NormCone(p::Real, dimension::Base.Integer)
+        if !(dimension >= 1)
+            throw(
+                DimensionMismatch(
+                    "Dimension of NormCone must be >= 1, not " *
+                    "$(dimension).",
+                ),
+            )
+        elseif !(p >= 1)
+            throw(ArgumentError("The p- argument to `NormCone` must be `>= 1`"))
+        end
+        return new(convert(Float64, p), dimension)
+    end
+end
+
+NormCone(set::NormOneCone) = NormCone(1, set.dimension)
+NormCone(set::SecondOrderCone) = NormCone(2, set.dimension)
+NormCone(set::NormInfinityCone) = NormCone(Inf, set.dimension)
+
 """
     GeometricMeanCone(dimension::Int)
 

test/Bridges/Constraint/norm_special_case.jl

@@ -0,0 +1,70 @@
+# 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.
+
+module TestConstraintNormSpecialCase
+
+using Test
+
+import MathOptInterface as MOI
+
+function runtests()
+    for name in names(@__MODULE__; all = true)
+        if startswith("$(name)", "test_")
+            @testset "$(name)" begin
+                getfield(@__MODULE__, name)()
+            end
+        end
+    end
+    return
+end
+
+function test_runtests_norm_1()
+    MOI.Bridges.runtests(
+        MOI.Bridges.Constraint.NormSpecialCaseBridge,
+        """
+        variables: t, x1, x2, x3, x4
+        [t, x1, x2, x3, x4] in NormOneCone(5)
+        """,
+        """
+        variables: t, x1, x2, x3, x4
+        [t, x1, x2, x3, x4] in NormCone(1.0, 5)
+        """,
+    )
+    return
+end
+
+function test_runtests_norm_2()
+    MOI.Bridges.runtests(
+        MOI.Bridges.Constraint.NormSpecialCaseBridge,
+        """
+        variables: t, x1, x2, x3, x4
+        [t, x1, x2, x3, x4] in SecondOrderCone(5)
+        """,
+        """
+        variables: t, x1, x2, x3, x4
+        [t, x1, x2, x3, x4] in NormCone(2.0, 5)
+        """,
+    )
+    return
+end
+
+function test_runtests_norm_inf()
+    MOI.Bridges.runtests(
+        MOI.Bridges.Constraint.NormSpecialCaseBridge,
+        """
+        variables: t, x1, x2, x3, x4
+        [t, x1, x2, x3, x4] in NormInfinityCone(5)
+        """,
+        """
+        variables: t, x1, x2, x3, x4
+        [t, x1, x2, x3, x4] in NormCone(Inf, 5)
+        """,
+    )
+    return
+end
+end  # module
+
+TestConstraintNormSpecialCase.runtests()

test/sets.jl

@@ -167,6 +167,9 @@ function test_sets_DimensionMismatch()
     @test_throws DimensionMismatch MOI.CountAtLeast(1, [-1, 2], Set([1, 2]))
     @test_throws DimensionMismatch MOI.NormCone(4, 0)
     @test MOI.NormCone(4, 1) isa MOI.NormCone
+    @test_throws ArgumentError MOI.NormCone(0.99, 0)
+    @test_throws ArgumentError MOI.NormCone(0.5, 0)
+    @test_throws ArgumentError MOI.NormCone(-2, 0)
     return
 end