Merge pull request #508 from JuliaOpt/bl/renamebridges

Rename bridges

Author: blegat

docs/src/apireference.md

@@ -326,7 +326,7 @@ Bridges.AbstractBridge
 Bridges.AbstractBridgeOptimizer
 Bridges.SingleBridgeOptimizer
 Bridges.LazyBridgeOptimizer
-Bridges.addbridge!
+Bridges.add_bridge
 ```
 
 Below is the list of bridges implemented in this package.

src/Bridges/Bridges.jl

@@ -32,14 +32,14 @@ Returns a `LazyBridgeOptimizer` bridging `model` for every bridge defined in thi
 """
 function fullbridgeoptimizer(model::MOI.ModelLike, ::Type{T}) where T
     bridgedmodel = MOIB.LazyBridgeOptimizer(model, AllBridgedConstraints{T}())
-    addbridge!(bridgedmodel, MOIB.SplitIntervalBridge{T})
-    addbridge!(bridgedmodel, MOIB.GeoMeanBridge{T})
-    addbridge!(bridgedmodel, MOIB.SquarePSDBridge{T})
-    addbridge!(bridgedmodel, MOIB.LogDetBridge{T})
-    addbridge!(bridgedmodel, MOIB.RootDetBridge{T})
-    addbridge!(bridgedmodel, MOIB.RSOCBridge{T})
-    addbridge!(bridgedmodel, MOIB.RSOCtoPSDBridge{T})
-    addbridge!(bridgedmodel, MOIB.SOCtoPSDBridge{T})
+    add_bridge(bridgedmodel, MOIB.SplitIntervalBridge{T})
+    add_bridge(bridgedmodel, MOIB.GeoMeanBridge{T})
+    add_bridge(bridgedmodel, MOIB.SquarePSDBridge{T})
+    add_bridge(bridgedmodel, MOIB.LogDetBridge{T})
+    add_bridge(bridgedmodel, MOIB.RootDetBridge{T})
+    add_bridge(bridgedmodel, MOIB.RSOCBridge{T})
+    add_bridge(bridgedmodel, MOIB.RSOCtoPSDBridge{T})
+    add_bridge(bridgedmodel, MOIB.SOCtoPSDBridge{T})
     bridgedmodel
 end
 

src/Bridges/bridge.jl

@@ -38,20 +38,20 @@ Return a `Bool` indicating whether the bridges of type `BT` support bridging `F`
 MOI.supports_constraint(::Type{<:AbstractBridge}, ::Type{<:MOI.AbstractFunction}, ::Type{<:MOI.AbstractSet}) = false
 
 """
-    addedconstrainttypes(BT::Type{<:AbstractBridge}, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet})::Bool
+    added_constraint_types(BT::Type{<:AbstractBridge}, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet})::Bool
 
 Return a list of the types of constraints that bridges of type `BT` add for
 bridging an `F`-in-`S` constraints.
 
-    addedconstrainttypes(BT::Type{<:AbstractBridge})::Bool
+    added_constraint_types(BT::Type{<:AbstractBridge})::Bool
 
 Return a list of the types of constraints that bridges of concrete type `BT` add
 for `F`-in-`S` constraints.
 """
-function addedconstrainttypes(BT::Type{<:AbstractBridge},
+function added_constraint_types(BT::Type{<:AbstractBridge},
                               F::Type{<:MOI.AbstractFunction},
                               S::Type{<:MOI.AbstractSet})
-    addedconstrainttypes(concrete_bridge_type(BT, F, S))
+    added_constraint_types(concrete_bridge_type(BT, F, S))
 end
 
 

src/Bridges/bridgeoptimizer.jl

@@ -16,28 +16,28 @@ abstract type AbstractBridgeOptimizer <: MOI.AbstractOptimizer end
 # AbstractBridgeOptimizer interface
 
 """
-    isbridged(b::AbstractBridgeOptimizer, F::Type{<:MOI.AbstractFunction},
+    is_bridged(b::AbstractBridgeOptimizer, F::Type{<:MOI.AbstractFunction},
               S::Type{<:MOI.AbstractSet})::Bool
 
 Return a `Bool` indicating whether `b` tries to bridge `F`-in-`S` constraints
 instead of passing it as is to its internal model.
 """
-function isbridged end
+function is_bridged end
 # Syntactic sugar
-function isbridged(b::AbstractBridgeOptimizer, ::Type{CI{F, S}}) where {F, S}
-    return isbridged(b, F, S)
+function is_bridged(b::AbstractBridgeOptimizer, ::Type{CI{F, S}}) where {F, S}
+    return is_bridged(b, F, S)
 end
 # We don't bridge variables.
-isbridged(b::AbstractBridgeOptimizer, ::Type{VI}) = false
+is_bridged(b::AbstractBridgeOptimizer, ::Type{VI}) = false
 
 """
-    supportsbridgingconstraint(b::AbstractBridgeOptimizer,
+    supports_bridging_constraint(b::AbstractBridgeOptimizer,
                                F::Type{<:MOI.AbstractFunction},
                                S::Type{<:MOI.AbstractSet})::Bool
 
 Return a `Bool` indicating whether `b` supports bridging `F`-in-`S` constraints.
 """
-function supportsbridgingconstraint(::AbstractBridgeOptimizer,
+function supports_bridging_constraint(::AbstractBridgeOptimizer,
                                     ::Type{<:MOI.AbstractFunction},
                                     ::Type{<:MOI.AbstractSet})
     return false
@@ -49,7 +49,7 @@ end
                 S::Type{<:MOI.AbstractSet})
 
 Return the `AbstractBridge` type to be used to bridge `F`-in-`S` constraints.
-This function should only be called if `isbridged(b, F, S)`.
+This function should only be called if `is_bridged(b, F, S)`.
 """
 function bridge_type end
 
@@ -94,15 +94,15 @@ end
 # References
 MOI.is_valid(b::AbstractBridgeOptimizer, vi::VI) = MOI.is_valid(b.model, vi)
 function MOI.is_valid(b::AbstractBridgeOptimizer, ci::CI)
-    if isbridged(b, typeof(ci))
+    if is_bridged(b, typeof(ci))
         return MOI.is_valid(b.bridged, ci)
     else
         return MOI.is_valid(b.model, ci)
     end
 end
 MOI.delete(b::AbstractBridgeOptimizer, vi::VI) = MOI.delete(b.model, vi)
 function MOI.delete(b::AbstractBridgeOptimizer, ci::CI)
-    if isbridged(b, typeof(ci))
+    if is_bridged(b, typeof(ci))
         if !MOI.is_valid(b, ci)
             throw(MOI.InvalidIndex(ci))
         end
@@ -117,7 +117,7 @@ end
 # Attributes
 function MOI.get(b::AbstractBridgeOptimizer,
                  attr::MOI.ListOfConstraintIndices{F, S}) where {F, S}
-    if isbridged(b, F, S)
+    if is_bridged(b, F, S)
         list = MOI.get(b.bridged, attr)
     else
         list = MOI.get(b.model, attr)
@@ -145,7 +145,7 @@ function MOI.get(b::AbstractBridgeOptimizer, attr::MOI.NumberOfVariables)
 end
 function MOI.get(b::AbstractBridgeOptimizer,
                  attr::MOI.NumberOfConstraints{F, S}) where {F, S}
-    if isbridged(b, F, S)
+    if is_bridged(b, F, S)
         # The constraints contained in `b.bridged` may have been added by
         # bridges
         return _numberof(b, b.bridged, attr)
@@ -209,7 +209,7 @@ end
 function MOI.get(b::AbstractBridgeOptimizer,
                  attr::MOI.AbstractConstraintAttribute,
                  ci::CI)
-    if isbridged(b, typeof(ci))
+    if is_bridged(b, typeof(ci))
         if MOIU.is_result_attribute(attr)
             MOI.get(b, attr, bridge(b, ci))
         else
@@ -222,15 +222,15 @@ end
 ## Setting names
 function MOI.supports(b::AbstractBridgeOptimizer, attr::MOI.ConstraintName,
                       Index::Type{<:CI})
-    if isbridged(b, Index)
+    if is_bridged(b, Index)
         return MOI.supports(b.bridged, attr, Index)
     else
         return MOI.supports(b.model, attr, Index)
     end
 end
 function MOI.set(b::AbstractBridgeOptimizer, attr::MOI.ConstraintName,
                   constraint_index::CI, name::String)
-    if isbridged(b, typeof(constraint_index))
+    if is_bridged(b, typeof(constraint_index))
         MOI.set(b.bridged, attr, constraint_index, name)
     else
         MOI.set(b.model, attr, constraint_index, name)
@@ -240,7 +240,7 @@ end
 function MOI.supports(b::AbstractBridgeOptimizer,
                       attr::Union{MOI.ConstraintFunction, MOI.ConstraintSet},
                       ::Type{CI{F, S}}) where {F, S}
-    if isbridged(b, CI{F, S})
+    if is_bridged(b, CI{F, S})
         return MOI.supports(b.bridged, attr, CI{F, S}) &&
             MOI.supports(b, attr, concrete_bridge_type(b, F, S))
     else
@@ -249,7 +249,7 @@ function MOI.supports(b::AbstractBridgeOptimizer,
 end
 function MOI.set(b::AbstractBridgeOptimizer, ::MOI.ConstraintSet,
                   constraint_index::CI{F, S}, set::S) where {F, S}
-    if isbridged(b, typeof(constraint_index))
+    if is_bridged(b, typeof(constraint_index))
         MOI.set(b, MOI.ConstraintSet(), bridge(b, constraint_index), set)
         MOI.set(b.bridged, MOI.ConstraintSet(), constraint_index, set)
     else
@@ -258,7 +258,7 @@ function MOI.set(b::AbstractBridgeOptimizer, ::MOI.ConstraintSet,
 end
 function MOI.set(b::AbstractBridgeOptimizer, ::MOI.ConstraintFunction,
                   constraint_index::CI{F, S}, func::F) where {F, S}
-    if isbridged(b, typeof(constraint_index))
+    if is_bridged(b, typeof(constraint_index))
         MOI.set(b, MOI.ConstraintFunction(), bridge(b, constraint_index), func)
         MOI.set(b.bridged, MOI.ConstraintFunction(), constraint_index, func)
     else
@@ -269,7 +269,7 @@ end
 # Name
 function MOI.get(b::AbstractBridgeOptimizer, IdxT::Type{<:MOI.Index},
                  name::String)
-    if isbridged(b, IdxT)
+    if is_bridged(b, IdxT)
         return MOI.get(b.bridged, IdxT, name)
     else
         return MOI.get(b.model, IdxT, name)
@@ -292,16 +292,16 @@ end
 function MOI.supports_constraint(b::AbstractBridgeOptimizer,
                                 F::Type{<:MOI.AbstractFunction},
                                 S::Type{<:MOI.AbstractSet})
-    if isbridged(b, F, S)
-        return supportsbridgingconstraint(b, F, S) &&
+    if is_bridged(b, F, S)
+        return supports_bridging_constraint(b, F, S) &&
             MOI.supports_constraint(b.bridged, F, S)
     else
         return MOI.supports_constraint(b.model, F, S)
     end
 end
 function MOI.add_constraint(b::AbstractBridgeOptimizer, f::MOI.AbstractFunction,
                             s::MOI.AbstractSet)
-    if isbridged(b, typeof(f), typeof(s))
+    if is_bridged(b, typeof(f), typeof(s))
         ci = MOI.add_constraint(b.bridged, f, s)
         @assert !haskey(b.bridges, ci)
         b.bridges[ci] = concrete_bridge_type(b, typeof(f), typeof(s))(b, f, s)
@@ -312,7 +312,7 @@ function MOI.add_constraint(b::AbstractBridgeOptimizer, f::MOI.AbstractFunction,
 end
 function MOI.modify(b::AbstractBridgeOptimizer, ci::CI,
                      change::MOI.AbstractFunctionModification)
-    if isbridged(b, typeof(ci))
+    if is_bridged(b, typeof(ci))
         MOI.modify(b, bridge(b, ci), change)
         MOI.modify(b.bridged, ci, change)
     else

src/Bridges/detbridge.jl

@@ -87,7 +87,7 @@ function LogDetBridge{T}(model, f::MOI.VectorAffineFunction{T}, s::MOI.LogDetCon
 end
 
 MOI.supports_constraint(::Type{LogDetBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.LogDetConeTriangle}) where T = true
-addedconstrainttypes(::Type{LogDetBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.LogDetConeTriangle}) where T = [(MOI.VectorAffineFunction{T}, MOI.PositiveSemidefiniteConeTriangle), (MOI.VectorAffineFunction{T}, MOI.ExponentialCone), (MOI.ScalarAffineFunction{T}, MOI.LessThan{T})]
+added_constraint_types(::Type{LogDetBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.LogDetConeTriangle}) where T = [(MOI.VectorAffineFunction{T}, MOI.PositiveSemidefiniteConeTriangle), (MOI.VectorAffineFunction{T}, MOI.ExponentialCone), (MOI.ScalarAffineFunction{T}, MOI.LessThan{T})]
 
 """
     sublog(model, x::MOI.VariableIndex, z::MOI.VariableIndex, ::Type{T}) where T
@@ -179,7 +179,7 @@ function RootDetBridge{T}(model, f::MOI.VectorAffineFunction{T}, s::MOI.RootDetC
 end
 
 MOI.supports_constraint(::Type{RootDetBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.RootDetConeTriangle}) where T = true
-addedconstrainttypes(::Type{RootDetBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.RootDetConeTriangle}) where T = [(MOI.VectorAffineFunction{T}, MOI.PositiveSemidefiniteConeTriangle), (MOI.VectorAffineFunction{T}, MOI.GeometricMeanCone)]
+added_constraint_types(::Type{RootDetBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.RootDetConeTriangle}) where T = [(MOI.VectorAffineFunction{T}, MOI.PositiveSemidefiniteConeTriangle), (MOI.VectorAffineFunction{T}, MOI.GeometricMeanCone)]
 
 # Attributes, Bridge acting as an model
 MOI.get(b::RootDetBridge, ::MOI.NumberOfVariables) = length(b.Δ)

src/Bridges/geomeanbridge.jl

@@ -100,7 +100,7 @@ function MOI.supports_constraint(::Type{GeoMeanBridge{T}},
                                 ::Type{MOI.GeometricMeanCone}) where T
     return true
 end
-function addedconstrainttypes(::Type{GeoMeanBridge{T, F, G}}) where {T, F, G}
+function added_constraint_types(::Type{GeoMeanBridge{T, F, G}}) where {T, F, G}
     return [(F, MOI.LessThan{T}), (G, MOI.RotatedSecondOrderCone)]
 end
 function concrete_bridge_type(::Type{<:GeoMeanBridge{T}},

src/Bridges/intervalbridge.jl

@@ -14,7 +14,7 @@ function SplitIntervalBridge{T, F}(model, f::F, s::MOI.Interval{T}) where {T, F}
 end
 
 MOI.supports_constraint(::Type{SplitIntervalBridge{T}}, ::Type{<:MOI.AbstractScalarFunction}, ::Type{MOI.Interval{T}}) where T = true
-function addedconstrainttypes(::Type{SplitIntervalBridge{T, F}}) where {T, F}
+function added_constraint_types(::Type{SplitIntervalBridge{T, F}}) where {T, F}
     return [(F, MOI.GreaterThan{T}), (F, MOI.LessThan{T})]
 end
 function concrete_bridge_type(::Type{<:SplitIntervalBridge},

src/Bridges/lazybridgeoptimizer.jl

@@ -2,7 +2,7 @@
 """
     LazyBridgeOptimizer{OT<:MOI.ModelLike, MT<:MOI.ModelLike} <: AbstractBridgeOptimizer
 
-The `LazyBridgeOptimizer` combines several bridges, which are added using the [`addbridge!`](@ref) function.
+The `LazyBridgeOptimizer` combines several bridges, which are added using the [`add_bridge`](@ref) function.
 Whenever a constraint is added, it only attempts to bridge it if it is not supported by the internal model (hence its name `Lazy`).
 When bridging a constraint, it selects the minimal number of bridges needed.
 For instance, a constraint `F`-in-`S` can be bridged into a constraint `F1`-in-`S1` (supported by the internal model) using bridge 1 or
@@ -43,9 +43,9 @@ function update_dist!(b::LazyBridgeOptimizer, constraints)
         changed = false
         for BT in b.bridgetypes
             for (F, S) in constraints
-                if MOI.supports_constraint(BT, F, S) && all(C -> MOI.supports_constraint(b, C[1], C[2]), addedconstrainttypes(BT, F, S))
+                if MOI.supports_constraint(BT, F, S) && all(C -> MOI.supports_constraint(b, C[1], C[2]), added_constraint_types(BT, F, S))
                     # Number of bridges needed using BT
-                    dist = 1 + sum(C -> _dist(b, C[1], C[2]), addedconstrainttypes(BT, F, S))
+                    dist = 1 + sum(C -> _dist(b, C[1], C[2]), added_constraint_types(BT, F, S))
                     # Is it better that what can currently be done ?
                     if dist < _dist(b, F, S)
                         b.dist[(F, S)] = dist
@@ -69,7 +69,7 @@ function fill_required_constraints!(required::Set{Tuple{DataType, DataType}}, b:
     push!(required, (F, S))
     for BT in b.bridgetypes
         if MOI.supports_constraint(BT, F, S)
-            for C in addedconstrainttypes(BT, F, S)
+            for C in added_constraint_types(BT, F, S)
                 fill_required_constraints!(required, b, C[1], C[2])
             end
         end
@@ -84,22 +84,22 @@ function update_constraint!(b::LazyBridgeOptimizer, F::Type{<:MOI.AbstractFuncti
 end
 
 """
-    addbridge!(b::LazyBridgeOptimizer, BT::Type{<:AbstractBridge})
+    add_bridge(b::LazyBridgeOptimizer, BT::Type{<:AbstractBridge})
 
 Enable the use of the bridges of type `BT` by `b`.
 """
-function addbridge!(b::LazyBridgeOptimizer, BT::Type{<:AbstractBridge})
+function add_bridge(b::LazyBridgeOptimizer, BT::Type{<:AbstractBridge})
     push!(b.bridgetypes, BT)
     # Some constraints (F, S) in keys(b.best) may now be bridged
     # with a less briges than `b.dist[(F, S)] using `BT`
     update_dist!(b, keys(b.best))
 end
 
 # It only bridges when the constraint is not supporting, hence the name "Lazy"
-function isbridged(b::LazyBridgeOptimizer, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet})
+function is_bridged(b::LazyBridgeOptimizer, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet})
     !MOI.supports_constraint(b.model, F, S)
 end
-function supportsbridgingconstraint(b::LazyBridgeOptimizer, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet})
+function supports_bridging_constraint(b::LazyBridgeOptimizer, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet})
     update_constraint!(b, F, S)
     (F, S) in keys(b.best)
 end

src/Bridges/rsocbridge.jl

@@ -42,7 +42,7 @@ function MOI.supports_constraint(::Type{RSOCBridge{T}},
                                 ::Type{MOI.RotatedSecondOrderCone}) where T
     return true
 end
-function addedconstrainttypes(::Type{RSOCBridge{T, F}}) where {T, F}
+function added_constraint_types(::Type{RSOCBridge{T, F}}) where {T, F}
     return [(F, MOI.SecondOrderCone)]
 end
 function concrete_bridge_type(::Type{<:RSOCBridge{T}},

src/Bridges/singlebridgeoptimizer.jl

@@ -13,7 +13,7 @@ function SingleBridgeOptimizer{BT, MT}(model::OT) where {BT, MT, OT <: MOI.Model
     SingleBridgeOptimizer{BT, MT, OT}(model, MT(), Dict{CI, BT}())
 end
 
-isbridged(b::SingleBridgeOptimizer, ::Type{<:MOI.AbstractFunction}, ::Type{<:MOI.AbstractSet}) = false
+is_bridged(b::SingleBridgeOptimizer, ::Type{<:MOI.AbstractFunction}, ::Type{<:MOI.AbstractSet}) = false
 bridge_type(b::SingleBridgeOptimizer{BT}, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet}) where BT = BT
 
 # :((Zeros, SecondOrderCone)) -> (:(MOI.Zeros), :(MOI.SecondOrderCone))
@@ -38,14 +38,14 @@ bridgedmodel = SplitInterval(model)
 will additionally support `ScalarAffineFunction`-in-`Interval`.
 """
 macro bridge(modelname, bridge, ss, sst, vs, vst, sf, sft, vf, vft)
-    bridgedmodelname = Symbol(string(modelname) * "Instance")
-    bridgedfuns = :(Union{$(_tuple_prefix_moi(sf)...), $(_tuple_prefix_moi(sft)...), $(_tuple_prefix_moi(vf)...), $(_tuple_prefix_moi(vft)...)})
-    bridgedsets = :(Union{$(_tuple_prefix_moi(ss)...), $(_tuple_prefix_moi(sst)...), $(_tuple_prefix_moi(vs)...), $(_tuple_prefix_moi(vst)...)})
+    bridged_model_name = Symbol(string(modelname) * "Instance")
+    bridged_funs = :(Union{$(_tuple_prefix_moi(sf)...), $(_tuple_prefix_moi(sft)...), $(_tuple_prefix_moi(vf)...), $(_tuple_prefix_moi(vft)...)})
+    bridged_sets = :(Union{$(_tuple_prefix_moi(ss)...), $(_tuple_prefix_moi(sst)...), $(_tuple_prefix_moi(vs)...), $(_tuple_prefix_moi(vst)...)})
 
     esc(quote
-        $MOIU.@model $bridgedmodelname $ss $sst $vs $vst $sf $sft $vf $vft
-        const $modelname{T, OT<:MOI.ModelLike} = $MOIB.SingleBridgeOptimizer{$bridge{T}, $bridgedmodelname{T}, OT}
-        isbridged(::$modelname, ::Type{<:$bridgedfuns}, ::Type{<:$bridgedsets}) = true
-        supportsbridgingconstraint(::$modelname, ::Type{<:$bridgedfuns}, ::Type{<:$bridgedsets}) = true
+        $MOIU.@model $bridged_model_name $ss $sst $vs $vst $sf $sft $vf $vft
+        const $modelname{T, OT<:MOI.ModelLike} = $MOIB.SingleBridgeOptimizer{$bridge{T}, $bridged_model_name{T}, OT}
+        is_bridged(::$modelname, ::Type{<:$bridged_funs}, ::Type{<:$bridged_sets}) = true
+        supports_bridging_constraint(::$modelname, ::Type{<:$bridged_funs}, ::Type{<:$bridged_sets}) = true
     end)
 end

src/Bridges/soctopsdbridge.jl

@@ -65,7 +65,7 @@ _SOCtoPSDaff(f::MOI.VectorOfVariables, ::Type{T}) where T = _SOCtoPSDaff(MOI.Vec
 _SOCtoPSDaff(f::MOI.VectorAffineFunction, ::Type) = _SOCtoPSDaff(f, MOIU.eachscalar(f)[1])
 
 MOI.supports_constraint(::Type{SOCtoPSDBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.SecondOrderCone}) where T = true
-addedconstrainttypes(::Type{SOCtoPSDBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.SecondOrderCone}) where T = [(MOI.VectorAffineFunction{T}, MOI.PositiveSemidefiniteConeTriangle)]
+added_constraint_types(::Type{SOCtoPSDBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.SecondOrderCone}) where T = [(MOI.VectorAffineFunction{T}, MOI.PositiveSemidefiniteConeTriangle)]
 
 function MOI.get(instance::MOI.AbstractOptimizer, a::MOI.ConstraintPrimal, c::SOCtoPSDBridge)
     MOI.get(instance, a, c.cr)[trimap.(1:c.dim, 1)]
@@ -115,7 +115,7 @@ struct RSOCtoPSDBridge{T} <: AbstractBridge
 end
 
 MOI.supports_constraint(::Type{RSOCtoPSDBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.RotatedSecondOrderCone}) where T = true
-addedconstrainttypes(::Type{RSOCtoPSDBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.RotatedSecondOrderCone}) where T = [(MOI.VectorAffineFunction{T}, MOI.PositiveSemidefiniteConeTriangle)]
+added_constraint_types(::Type{RSOCtoPSDBridge{T}}, ::Type{<:Union{MOI.VectorOfVariables, MOI.VectorAffineFunction{T}}}, ::Type{MOI.RotatedSecondOrderCone}) where T = [(MOI.VectorAffineFunction{T}, MOI.PositiveSemidefiniteConeTriangle)]
 
 function RSOCtoPSDBridge{T}(instance, f, s::MOI.RotatedSecondOrderCone) where T
     d = MOI.dimension(s)-1