|
| 1 | +# Copyright (c) 2017: Miles Lubin and contributors |
| 2 | +# Copyright (c) 2017: Google Inc. |
| 3 | +# |
| 4 | +# Use of this source code is governed by an MIT-style license that can be found |
| 5 | +# in the LICENSE.md file or at https://opensource.org/licenses/MIT. |
| 6 | + |
| 7 | +""" |
| 8 | + NormToPowerBridge{T,F} <: Bridges.Constraint.AbstractBridge |
| 9 | +
|
| 10 | +`NormToPowerBridge` implements the following reformulation: |
| 11 | +
|
| 12 | + * ``(t, x) \\in NormCone(p, 1+d)`` into ``(r_i, t, x_i) \\in PowerCone(1 / p)`` |
| 13 | + for all ``i``, and ``\\sum\\limits_i r_i == t``. |
| 14 | +
|
| 15 | +For details, see Alizadeh, F., and Goldfarb, D. (2001). "Second-order cone |
| 16 | +programming." Mathematical Programming, Series B, 95:3-51. |
| 17 | +
|
| 18 | +## Source node |
| 19 | +
|
| 20 | +`NormToPowerBridge` supports: |
| 21 | +
|
| 22 | + * `F` in [`MOI.NormCone`](@ref) |
| 23 | +
|
| 24 | +## Target nodes |
| 25 | +
|
| 26 | +`NormToPowerBridge` creates: |
| 27 | +
|
| 28 | + * `F` in [`MOI.PowerCone{T}`](@ref) |
| 29 | + * [`MOI.ScalarAffineFunction`](@ref) in [`MOI.EqualTo`](@ref) |
| 30 | +""" |
| 31 | +struct NormToPowerBridge{T,F} <: AbstractBridge |
| 32 | + power::Vector{MOI.ConstraintIndex{F,MOI.PowerCone{T}}} |
| 33 | + r::Vector{MOI.VariableIndex} |
| 34 | + equal::MOI.ConstraintIndex{MOI.ScalarAffineFunction{T},MOI.EqualTo{T}} |
| 35 | + set::MOI.NormCone |
| 36 | +end |
| 37 | + |
| 38 | +const NormToPower{T,OT<:MOI.ModelLike} = |
| 39 | + SingleBridgeOptimizer{NormToPowerBridge{T},OT} |
| 40 | + |
| 41 | +function bridge_constraint( |
| 42 | + ::Type{NormToPowerBridge{T,F}}, |
| 43 | + model::MOI.ModelLike, |
| 44 | + f::F, |
| 45 | + s::MOI.NormCone, |
| 46 | +) where {T,F} |
| 47 | + d = MOI.dimension(s) |
| 48 | + fi_s = MOI.Utilities.eachscalar(f) |
| 49 | + r = MOI.add_variables(model, d - 1) |
| 50 | + power_ci = MOI.ConstraintIndex{F,MOI.PowerCone{T}}[ |
| 51 | + MOI.add_constraint( |
| 52 | + model, |
| 53 | + MOI.Utilities.operate(vcat, T, r[i], fi_s[1], fi_s[i+1]), |
| 54 | + MOI.PowerCone(T(1 / s.p)), |
| 55 | + ) for i in 1:length(r) |
| 56 | + ] |
| 57 | + f = zero(MOI.ScalarAffineFunction{T}) |
| 58 | + for ri in r |
| 59 | + f = MOI.Utilities.operate!(+, T, f, ri) |
| 60 | + end |
| 61 | + MOI.Utilities.operate!(-, T, f, fi_s[1]) |
| 62 | + equal_ci = MOI.add_constraint(model, f, MOI.EqualTo(zero(T))) |
| 63 | + return NormToPowerBridge{T,F}(power_ci, r, equal_ci, s) |
| 64 | +end |
| 65 | + |
| 66 | +function MOI.supports_constraint( |
| 67 | + ::Type{<:NormToPowerBridge{T}}, |
| 68 | + ::Type{<:MOI.AbstractVectorFunction}, |
| 69 | + ::Type{MOI.NormCone}, |
| 70 | +) where {T} |
| 71 | + return true |
| 72 | +end |
| 73 | + |
| 74 | +function MOI.Bridges.added_constrained_variable_types( |
| 75 | + ::Type{<:NormToPowerBridge}, |
| 76 | +) |
| 77 | + return Tuple{Type}[(MOI.Reals,)] |
| 78 | +end |
| 79 | + |
| 80 | +function MOI.Bridges.added_constraint_types( |
| 81 | + ::Type{<:NormToPowerBridge{T,F}}, |
| 82 | +) where {T,F} |
| 83 | + return Tuple{Type,Type}[ |
| 84 | + (F, MOI.PowerCone{T}), |
| 85 | + (MOI.ScalarAffineFunction{T}, MOI.EqualTo{T}), |
| 86 | + ] |
| 87 | +end |
| 88 | + |
| 89 | +function concrete_bridge_type( |
| 90 | + ::Type{<:NormToPowerBridge{T}}, |
| 91 | + F::Type{<:MOI.AbstractVectorFunction}, |
| 92 | + ::Type{MOI.NormCone}, |
| 93 | +) where {T} |
| 94 | + return NormToPowerBridge{T,F} |
| 95 | +end |
| 96 | + |
| 97 | +function MOI.get(bridge::NormToPowerBridge, ::MOI.NumberOfVariables)::Int64 |
| 98 | + return length(bridge.r) |
| 99 | +end |
| 100 | + |
| 101 | +function MOI.get(bridge::NormToPowerBridge, ::MOI.ListOfVariableIndices) |
| 102 | + return copy(bridge.r) |
| 103 | +end |
| 104 | + |
| 105 | +function MOI.get( |
| 106 | + bridge::NormToPowerBridge{T,F}, |
| 107 | + ::MOI.NumberOfConstraints{F,MOI.PowerCone{T}}, |
| 108 | +)::Int64 where {T,F} |
| 109 | + return length(bridge.power) |
| 110 | +end |
| 111 | + |
| 112 | +function MOI.get( |
| 113 | + bridge::NormToPowerBridge{T,F}, |
| 114 | + ::MOI.ListOfConstraintIndices{F,MOI.PowerCone{T}}, |
| 115 | +) where {T,F} |
| 116 | + return copy(bridge.power) |
| 117 | +end |
| 118 | + |
| 119 | +function MOI.get( |
| 120 | + bridge::NormToPowerBridge{T}, |
| 121 | + ::MOI.NumberOfConstraints{MOI.ScalarAffineFunction{T},MOI.EqualTo{T}}, |
| 122 | +)::Int64 where {T} |
| 123 | + return 1 |
| 124 | +end |
| 125 | + |
| 126 | +function MOI.get( |
| 127 | + bridge::NormToPowerBridge{T}, |
| 128 | + ::MOI.ListOfConstraintIndices{MOI.ScalarAffineFunction{T},MOI.EqualTo{T}}, |
| 129 | +) where {T} |
| 130 | + return [bridge.equal] |
| 131 | +end |
| 132 | + |
| 133 | +function MOI.delete(model::MOI.ModelLike, bridge::NormToPowerBridge) |
| 134 | + MOI.delete(model, bridge.power) |
| 135 | + MOI.delete(model, bridge.equal) |
| 136 | + MOI.delete(model, bridge.r) |
| 137 | + return |
| 138 | +end |
| 139 | + |
| 140 | +function MOI.get( |
| 141 | + model::MOI.ModelLike, |
| 142 | + ::MOI.ConstraintFunction, |
| 143 | + bridge::NormToPowerBridge{T,F}, |
| 144 | +) where {T,F} |
| 145 | + elements = MOI.Utilities.scalar_type(F)[] |
| 146 | + for ci in bridge.power |
| 147 | + f = MOI.get(model, MOI.ConstraintFunction(), ci) |
| 148 | + fi_s = MOI.Utilities.eachscalar(f) |
| 149 | + if isempty(elements) |
| 150 | + push!(elements, fi_s[2]) |
| 151 | + end |
| 152 | + push!(elements, fi_s[3]) |
| 153 | + end |
| 154 | + return MOI.Utilities.operate(vcat, T, elements...) |
| 155 | +end |
| 156 | + |
| 157 | +function MOI.get( |
| 158 | + ::MOI.ModelLike, |
| 159 | + ::MOI.ConstraintSet, |
| 160 | + bridge::NormToPowerBridge, |
| 161 | +) |
| 162 | + return bridge.set |
| 163 | +end |
0 commit comments