[breaking] Rename RSOCBridge and SOCRBridge

docs/src/submodules/Bridges/reference.md

@@ -43,8 +43,8 @@ Bridges.Constraint.add_all_bridges
 
 ```@docs
 Bridges.Constraint.GreaterToIntervalBridge
-Bridges.Constraint.LessToIntervalBridge
 Bridges.Constraint.GreaterToLessBridge
+Bridges.Constraint.LessToIntervalBridge
 Bridges.Constraint.LessToGreaterBridge
 Bridges.Constraint.NonnegToNonposBridge
 Bridges.Constraint.NonposToNonnegBridge
@@ -55,11 +55,13 @@ Bridges.Constraint.VectorSlackBridge
 Bridges.Constraint.ScalarFunctionizeBridge
 Bridges.Constraint.VectorFunctionizeBridge
 Bridges.Constraint.SplitIntervalBridge
-Bridges.Constraint.RSOCBridge
-Bridges.Constraint.SOCRBridge
-Bridges.Constraint.QuadtoSOCBridge
+Bridges.Constraint.SOCtoRSOCBridge
+Bridges.Constraint.RSOCtoSOCBridge
 Bridges.Constraint.SOCtoNonConvexQuadBridge
 Bridges.Constraint.RSOCtoNonConvexQuadBridge
+Bridges.Constraint.QuadtoSOCBridge
+Bridges.Constraint.SOCtoPSDBridge
+Bridges.Constraint.RSOCtoPSDBridge
 Bridges.Constraint.NormInfinityBridge
 Bridges.Constraint.NormOneBridge
 Bridges.Constraint.GeoMeantoRelEntrBridge
@@ -70,8 +72,6 @@ Bridges.Constraint.NormNuclearBridge
 Bridges.Constraint.SquareBridge
 Bridges.Constraint.RootDetBridge
 Bridges.Constraint.LogDetBridge
-Bridges.Constraint.SOCtoPSDBridge
-Bridges.Constraint.RSOCtoPSDBridge
 Bridges.Constraint.IndicatorActiveOnFalseBridge
 Bridges.Constraint.IndicatorSOS1Bridge
 Bridges.Constraint.SemiToBinaryBridge

src/Bridges/Constraint/Constraint.jl

@@ -128,8 +128,8 @@ function add_all_bridges(bridged_model, ::Type{T}) where {T}
     MOIB.add_bridge(bridged_model, SquareBridge{T})
     MOIB.add_bridge(bridged_model, LogDetBridge{T})
     MOIB.add_bridge(bridged_model, RootDetBridge{T})
-    MOIB.add_bridge(bridged_model, RSOCBridge{T})
-    MOIB.add_bridge(bridged_model, SOCRBridge{T})
+    MOIB.add_bridge(bridged_model, RSOCtoSOCBridge{T})
+    MOIB.add_bridge(bridged_model, SOCtoRSOCBridge{T})
     # We do not add `SOCtoPSDBridge` as transforming the `SOC` to `RSOC` and
     # then to `PSD` produces a smaller SDP constraint.
     MOIB.add_bridge(bridged_model, RSOCtoPSDBridge{T})

src/Bridges/Constraint/rsoc.jl

@@ -1,5 +1,5 @@
 """
-    RSOCBridge{T, F, G}
+    RSOCtoSOCBridge{T, F, G}
 
 The `RotatedSecondOrderCone` is `SecondOrderCone` representable; see [1, p. 104].
 Indeed, we have ``2tu = (t/√2 + u/√2)^2 - (t/√2 - u/√2)^2`` hence
@@ -16,7 +16,7 @@ That means in particular that the norm is of constraint primal and duals are pre
 
 [1] Ben-Tal, Aharon, and Arkadi Nemirovski. *Lectures on modern convex optimization: analysis, algorithms, and engineering applications*. Society for Industrial and Applied Mathematics, 2001.
 """
-struct RSOCBridge{T,F,G} <:
+struct RSOCtoSOCBridge{T,F,G} <:
        SetMapBridge{T,MOI.SecondOrderCone,MOI.RotatedSecondOrderCone,F,G}
     constraint::CI{F,MOI.SecondOrderCone}
 end
@@ -29,48 +29,51 @@ function rotate_function_type(G::Type{<:MOI.AbstractVectorFunction}, T::Type)
 end
 
 function concrete_bridge_type(
-    ::Type{<:RSOCBridge{T}},
+    ::Type{<:RSOCtoSOCBridge{T}},
     G::Type{<:MOI.AbstractVectorFunction},
     ::Type{MOI.RotatedSecondOrderCone},
 ) where {T}
-    return RSOCBridge{T,rotate_function_type(G, T),G}
+    return RSOCtoSOCBridge{T,rotate_function_type(G, T),G}
 end
 
-function map_set(::Type{<:RSOCBridge}, set::MOI.RotatedSecondOrderCone)
+function map_set(::Type{<:RSOCtoSOCBridge}, set::MOI.RotatedSecondOrderCone)
     return MOI.SecondOrderCone(MOI.dimension(set))
 end
-function inverse_map_set(::Type{<:RSOCBridge}, set::MOI.SecondOrderCone)
+function inverse_map_set(::Type{<:RSOCtoSOCBridge}, set::MOI.SecondOrderCone)
     return MOI.RotatedSecondOrderCone(MOI.dimension(set))
 end
 
 """
-    SOCRBridge{T, F, G}
+    SOCtoRSOCBridge{T, F, G}
 
-We simply do the inverse transformation of [`RSOCBridge`](@ref). In fact, as the
+We simply do the inverse transformation of [`RSOCtoSOCBridge`](@ref). In fact, as the
 transformation is an involution, we do the same transformation.
 """
-struct SOCRBridge{T,F,G} <:
+struct SOCtoRSOCBridge{T,F,G} <:
        SetMapBridge{T,MOI.RotatedSecondOrderCone,MOI.SecondOrderCone,F,G}
     constraint::CI{F,MOI.RotatedSecondOrderCone}
 end
 
 function concrete_bridge_type(
-    ::Type{<:SOCRBridge{T}},
+    ::Type{<:SOCtoRSOCBridge{T}},
     G::Type{<:MOI.AbstractVectorFunction},
     ::Type{MOI.SecondOrderCone},
 ) where {T}
-    return SOCRBridge{T,rotate_function_type(G, T),G}
+    return SOCtoRSOCBridge{T,rotate_function_type(G, T),G}
 end
 
-function map_set(::Type{<:SOCRBridge}, set::MOI.SecondOrderCone)
+function map_set(::Type{<:SOCtoRSOCBridge}, set::MOI.SecondOrderCone)
     return MOI.RotatedSecondOrderCone(MOI.dimension(set))
 end
-function inverse_map_set(::Type{<:SOCRBridge}, set::MOI.RotatedSecondOrderCone)
+function inverse_map_set(
+    ::Type{<:SOCtoRSOCBridge},
+    set::MOI.RotatedSecondOrderCone,
+)
     return MOI.SecondOrderCone(MOI.dimension(set))
 end
 
 function map_function(
-    ::Type{<:Union{RSOCBridge{T},SOCRBridge{T}}},
+    ::Type{<:Union{RSOCtoSOCBridge{T},SOCtoRSOCBridge{T}}},
     func,
 ) where {T}
     scalars = MOIU.eachscalar(func)
@@ -87,16 +90,22 @@ function map_function(
     return MOIU.operate(vcat, T, z, y, x)
 end
 # The map is an involution
-function inverse_map_function(BT::Type{<:Union{RSOCBridge,SOCRBridge}}, func)
+function inverse_map_function(
+    BT::Type{<:Union{RSOCtoSOCBridge,SOCtoRSOCBridge}},
+    func,
+)
     return map_function(BT, func)
 end
 # The map is symmetric
-function adjoint_map_function(BT::Type{<:Union{RSOCBridge,SOCRBridge}}, func)
+function adjoint_map_function(
+    BT::Type{<:Union{RSOCtoSOCBridge,SOCtoRSOCBridge}},
+    func,
+)
     return map_function(BT, func)
 end
 # The map is a symmetric involution
 function inverse_adjoint_map_function(
-    BT::Type{<:Union{RSOCBridge,SOCRBridge}},
+    BT::Type{<:Union{RSOCtoSOCBridge,SOCtoRSOCBridge}},
     func,
 )
     return map_function(BT, func)

src/Bridges/Constraint/set_map.jl

@@ -151,8 +151,8 @@ const NonnegToNonpos{T,OT<:MOI.ModelLike} =
 const NonposToNonneg{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{NonposToNonnegBridge{T},OT}
 include("rsoc.jl")
-const RSOC{T,OT<:MOI.ModelLike} = SingleBridgeOptimizer{RSOCBridge{T},OT}
-const SOCR{T,OT<:MOI.ModelLike} = SingleBridgeOptimizer{SOCRBridge{T},OT}
+const RSOC{T,OT<:MOI.ModelLike} = SingleBridgeOptimizer{RSOCtoSOCBridge{T},OT}
+const SOCR{T,OT<:MOI.ModelLike} = SingleBridgeOptimizer{SOCtoRSOCBridge{T},OT}
 include("ltgt_to_interval.jl")
 const GreaterToInterval{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{GreaterToIntervalBridge{T},OT}

src/Bridges/Constraint/soc_to_psd.jl

@@ -47,7 +47,7 @@ which is equivalent to
 ```
 This bridge is not added by default by [`MOI.Bridges.full_bridge_optimizer`](@ref)
 as bridging second order cone constraints to semidefinite constraints can be
-achieved by the [`SOCRBridge`](@ref) followed by the [`RSOCtoPSDBridge`](@ref)
+achieved by the [`SOCtoRSOCBridge`](@ref) followed by the [`RSOCtoPSDBridge`](@ref)
 while creating a smaller semidefinite constraint.
 """
 struct SOCtoPSDBridge{T,F,G} <: SetMapBridge{

src/Bridges/Variable/rsoc_to_soc.jl

@@ -69,7 +69,7 @@ end
 """
     RSOCtoSOCBridge{T} <: Bridges.Variable.AbstractBridge
 
-Same transformation as [`MOI.Bridges.Constraint.RSOCBridge`](@ref).
+Same transformation as [`MOI.Bridges.Constraint.RSOCtoSOCBridge`](@ref).
 """
 struct RSOCtoSOCBridge{T} <: AbstractBridge
     variables::Vector{MOI.VariableIndex}

src/Bridges/Variable/soc_to_rsoc.jl

@@ -1,7 +1,7 @@
 """
     SOCtoRSOCBridge{T} <: Bridges.Variable.AbstractBridge
 
-Same transformation as [`MOI.Bridges.Constraint.SOCRBridge`](@ref).
+Same transformation as [`MOI.Bridges.Constraint.SOCtoRSOCBridge`](@ref).
 """
 struct SOCtoRSOCBridge{T} <: AbstractBridge
     variables::Vector{MOI.VariableIndex}

test/Bridges/lazy_bridge_optimizer.jl

@@ -1276,7 +1276,7 @@ end
         MOI.add_constrained_variables(bridged, MOI.RotatedSecondOrderCone(4))
     @test !any(v -> MOIB.is_bridged(bridged, v), y)
     @test !MOIB.is_variable_bridged(bridged, cy)
-    @test MOIB.bridge(bridged, cy) isa MOIB.Constraint.RSOCBridge{T}
+    @test MOIB.bridge(bridged, cy) isa MOIB.Constraint.RSOCtoSOCBridge{T}
     @test sprint(MOIB.print_graph, bridged) == MOI.Utilities.replace_acronym(
         """
 Bridge graph with 5 variable nodes, 11 constraint nodes and 0 objective nodes.
@@ -1286,8 +1286,8 @@ Bridge graph with 5 variable nodes, 11 constraint nodes and 0 objective nodes.
  [4] constrained variables in `MOI.Nonnegatives` are supported (distance 2) by adding free variables and then constrain them, see (6).
  [5] constrained variables in `MOI.Interval{$T}` are supported (distance 3) by adding free variables and then constrain them, see (8).
  (1) `MOI.VectorOfVariables`-in-`MOI.SecondOrderCone` constraints are bridged (distance 1) by $(MOIB.Constraint.VectorFunctionizeBridge{T,MOI.SecondOrderCone}).
- (2) `MOI.VectorAffineFunction{$T}`-in-`MOI.RotatedSecondOrderCone` constraints are bridged (distance 1) by $(MOIB.Constraint.RSOCBridge{T,MOI.VectorAffineFunction{T},MOI.VectorAffineFunction{T}}).
- (3) `MOI.VectorOfVariables`-in-`MOI.RotatedSecondOrderCone` constraints are bridged (distance 1) by $(MOIB.Constraint.RSOCBridge{T,MOI.VectorAffineFunction{T},MOI.VectorOfVariables}).
+ (2) `MOI.VectorAffineFunction{$T}`-in-`MOI.RotatedSecondOrderCone` constraints are bridged (distance 1) by $(MOIB.Constraint.RSOCtoSOCBridge{T,MOI.VectorAffineFunction{T},MOI.VectorAffineFunction{T}}).
+ (3) `MOI.VectorOfVariables`-in-`MOI.RotatedSecondOrderCone` constraints are bridged (distance 1) by $(MOIB.Constraint.RSOCtoSOCBridge{T,MOI.VectorAffineFunction{T},MOI.VectorOfVariables}).
  (4) `MOI.VectorAffineFunction{$T}`-in-`MOI.PositiveSemidefiniteConeTriangle` constraints are not supported
  (5) `MOI.VectorOfVariables`-in-`MOI.PositiveSemidefiniteConeTriangle` constraints are not supported
  (6) `MOI.VectorOfVariables`-in-`MOI.Nonnegatives` constraints are bridged (distance 1) by $(MOIB.Constraint.NonnegToNonposBridge{T,MOI.VectorAffineFunction{T},MOI.VectorOfVariables}).
@@ -1662,7 +1662,7 @@ end
 MOIB.add_bridge(bridged_mock, MOIB.Constraint.SplitIntervalBridge{Float64})
 MOIB.add_bridge(bridged_mock, MOIB.Constraint.RSOCtoPSDBridge{Float64})
 MOIB.add_bridge(bridged_mock, MOIB.Constraint.SOCtoPSDBridge{Float64})
-MOIB.add_bridge(bridged_mock, MOIB.Constraint.RSOCBridge{Float64})
+MOIB.add_bridge(bridged_mock, MOIB.Constraint.RSOCtoSOCBridge{Float64})
 
 @testset "Name test" begin
     MOIT.nametest(bridged_mock)