Style fixes for Bridges

docs/src/submodules/Bridges/overview.md

@@ -167,10 +167,8 @@ with inner model MOIU.GenericModel{Float64,MOIU.ModelFunctionConstraints{Float64
 Then use [`Bridges.add_bridge`](@ref) to add individual bridges:
 ```jldoctest lazy_bridge_optimizer
 julia> MOI.Bridges.add_bridge(optimizer, MOI.Bridges.Constraint.SplitIntervalBridge{Float64})
-Dict{Any,DataType} with 0 entries
 
 julia> MOI.Bridges.add_bridge(optimizer, MOI.Bridges.Objective.FunctionizeBridge{Float64})
-Dict{Any,DataType} with 0 entries
 ```
 
 Now the constraints will be bridged only if needed:

src/Bridges/Bridges.jl

@@ -9,11 +9,8 @@ const CI = MOI.ConstraintIndex
 include("bridge.jl")
 include("bridge_optimizer.jl")
 
-# Variable bridges
 include("Variable/Variable.jl")
-# Constraint bridges
 include("Constraint/Constraint.jl")
-# Objective bridges
 include("Objective/Objective.jl")
 
 include("lazy_bridge_optimizer.jl")
@@ -34,25 +31,33 @@ function full_bridge_optimizer(model::MOI.ModelLike, ::Type{T}) where {T}
 end
 
 print_num_bridges(io::IO, ::Variable.EmptyMap) = nothing
+
 print_num_bridges(io::IO, ::Constraint.EmptyMap) = nothing
+
 print_num_bridges(io::IO, ::Objective.EmptyMap) = nothing
+
 function print_num_bridges(io::IO, B::Variable.Map)
     s(n) = n == 1 ? "" : "s"
     indent = " "^get(io, :indent, 0)
     n = length(B)
-    return print(io, "\n$(indent)with $(n) variable bridge$(s(n))")
+    print(io, "\n$(indent)with $(n) variable bridge$(s(n))")
+    return
 end
+
 function print_num_bridges(io::IO, B::Constraint.Map)
     s(n) = n == 1 ? "" : "s"
     indent = " "^get(io, :indent, 0)
     n = length(B)
-    return print(io, "\n$(indent)with $(n) constraint bridge$(s(n))")
+    print(io, "\n$(indent)with $(n) constraint bridge$(s(n))")
+    return
 end
+
 function print_num_bridges(io::IO, B::Objective.Map)
     s(n) = n == 1 ? "" : "s"
     indent = " "^get(io, :indent, 0)
     n = length(B)
-    return print(io, "\n$(indent)with $(n) objective bridge$(s(n))")
+    print(io, "\n$(indent)with $(n) objective bridge$(s(n))")
+    return
 end
 
 function Base.show(io::IO, B::AbstractBridgeOptimizer)
@@ -65,6 +70,7 @@ function Base.show(io::IO, B::AbstractBridgeOptimizer)
         print(io, "\n$(indent)with inner model ")
         show(IOContext(io, :indent => get(io, :indent, 0) + 2), B.model)
     end
+    return
 end
 
-end # module
+end

src/Bridges/Constraint/Constraint.jl

@@ -35,59 +35,77 @@ include("set_map.jl")
 include("vectorize.jl")
 const Vectorize{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{VectorizeBridge{T},OT}
+
 include("scalarize.jl")
 const Scalarize{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{ScalarizeBridge{T},OT}
+
 include("slack.jl")
 const ScalarSlack{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{ScalarSlackBridge{T},OT}
 const VectorSlack{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{VectorSlackBridge{T},OT}
+
 include("interval.jl")
 const SplitInterval{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{SplitIntervalBridge{T},OT}
+
 include("quad_to_soc.jl")
 const QuadtoSOC{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{QuadtoSOCBridge{T},OT}
+
 include("soc_to_nonconvex_quad.jl") # do not add these bridges by default
 const SOCtoNonConvexQuad{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{SOCtoNonConvexQuadBridge{T},OT}
 const RSOCtoNonConvexQuad{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{RSOCtoNonConvexQuadBridge{T},OT}
+
 include("norm_to_lp.jl")
 const NormInfinity{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{NormInfinityBridge{T},OT}
 const NormOne{T,OT<:MOI.ModelLike} = SingleBridgeOptimizer{NormOneBridge{T},OT}
+
 include("geomean_to_relentr.jl")
 const GeoMeantoRelEntr{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{GeoMeantoRelEntrBridge{T},OT}
+
 include("geomean.jl")
 const GeoMean{T,OT<:MOI.ModelLike} = SingleBridgeOptimizer{GeoMeanBridge{T},OT}
+
 include("relentr_to_exp.jl")
 const RelativeEntropy{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{RelativeEntropyBridge{T},OT}
+
 include("norm_spec_nuc_to_psd.jl")
 const NormSpectral{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{NormSpectralBridge{T},OT}
 const NormNuclear{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{NormNuclearBridge{T},OT}
+
 include("square.jl")
 const Square{T,OT<:MOI.ModelLike} = SingleBridgeOptimizer{SquareBridge{T},OT}
+
 include("det.jl")
 const LogDet{T,OT<:MOI.ModelLike} = SingleBridgeOptimizer{LogDetBridge{T},OT}
 const RootDet{T,OT<:MOI.ModelLike} = SingleBridgeOptimizer{RootDetBridge{T},OT}
+
 include("soc_to_psd.jl")
 const SOCtoPSD{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{SOCtoPSDBridge{T},OT}
 const RSOCtoPSD{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{RSOCtoPSDBridge{T},OT}
+
 include("indicator_activate_on_zero.jl")
+# TODO(odow): should something go here?
+
 include("indicator_sos.jl")
 const IndicatortoSOS1{T,BC<:MOI.AbstractScalarSet,MaybeBC} =
     SingleBridgeOptimizer{IndicatorSOS1Bridge{T,BC,MaybeBC}}
+
 include("semi_to_binary.jl")
 const SemiToBinary{T,OT<:MOI.ModelLike} =
     SingleBridgeOptimizer{SemiToBinaryBridge{T},OT}
+
 include("zero_one.jl")
 const ZeroOne{T,OT<:MOI.ModelLike} = SingleBridgeOptimizer{ZeroOneBridge{T},OT}
 
@@ -102,7 +120,6 @@ function add_all_bridges(bridged_model, ::Type{T}) where {T}
         MOIB.add_bridge(bridged_model, GreaterToIntervalBridge{T})
         MOIB.add_bridge(bridged_model, LessToIntervalBridge{T})
     end
-
     MOIB.add_bridge(bridged_model, GreaterToLessBridge{T})
     MOIB.add_bridge(bridged_model, LessToGreaterBridge{T})
     MOIB.add_bridge(bridged_model, NonnegToNonposBridge{T})

src/Bridges/Constraint/bridge.jl

@@ -17,8 +17,12 @@ struct IndexInVector
 end
 
 """
-    bridge_constraint(BT::Type{<:AbstractBridge}, model::MOI.ModelLike,
-                      func::AbstractFunction, set::MOI.AbstractSet)
+    bridge_constraint(
+        BT::Type{<:AbstractBridge},
+        model::MOI.ModelLike,
+        func::AbstractFunction,
+        set::MOI.AbstractSet,
+    )
 
 Bridge the constraint `func`-in-`set` using bridge `BT` to `model` and returns
 a bridge object of type `BT`. The bridge type `BT` should be a concrete type,
@@ -43,9 +47,14 @@ The list of variables created by the bridge `b` in the model.
 MOI.get(::AbstractBridge, ::MOI.ListOfVariableIndices) = MOI.VariableIndex[]
 
 """
-    MOI.supports_constraint(BT::Type{<:AbstractBridge}, F::Type{<:MOI.AbstractFunction}, S::Type{<:MOI.AbstractSet})::Bool
+    MOI.supports_constraint(
+        BT::Type{<:AbstractBridge},
+        F::Type{<:MOI.AbstractFunction},
+        S::Type{<:MOI.AbstractSet},
+    )::Bool
 
-Return a `Bool` indicating whether the bridges of type `BT` support bridging `F`-in-`S` constraints.
+Return a `Bool` indicating whether the bridges of type `BT` support bridging
+`F`-in-`S` constraints.
 """
 function MOI.supports_constraint(
     ::Type{<:AbstractBridge},
@@ -56,14 +65,16 @@ function MOI.supports_constraint(
 end
 
 """
-    added_constrained_variable_types(BT::Type{<:MOI.Bridges.Constraint.AbstractBridge},
-                                     F::Type{<:MOI.AbstractFunction},
-                                     S::Type{<:MOI.AbstractSet})
+    added_constrained_variable_types(
+        BT::Type{<:MOI.Bridges.Constraint.AbstractBridge},
+        F::Type{<:MOI.AbstractFunction},
+        S::Type{<:MOI.AbstractSet},
+    )
 
 Return a list of the types of constrained variables that bridges of type `BT`
 add for bridging `F`-in-`S` constraints. This falls back to
-`added_constrained_variable_types(concrete_bridge_type(BT, F, S))`
-so bridges should not implement this method.
+`added_constrained_variable_types(concrete_bridge_type(BT, F, S))` so bridges
+should not implement this method.
 """
 function MOIB.added_constrained_variable_types(
     BT::Type{<:AbstractBridge},
@@ -74,9 +85,11 @@ function MOIB.added_constrained_variable_types(
 end
 
 """
-    added_constraint_types(BT::Type{<:MOI.Bridges.Constraint.AbstractBridge},
-                           F::Type{<:MOI.AbstractFunction},
-                           S::Type{<:MOI.AbstractSet})
+    added_constraint_types(
+        BT::Type{<:MOI.Bridges.Constraint.AbstractBridge},
+        F::Type{<:MOI.AbstractFunction},
+        S::Type{<:MOI.AbstractSet},
+    )
 
 Return a list of the types of constraints that bridges of type `BT` add for
 bridging `F`-in-`S` constraints. This falls back to