ToFunctionTypeBridge

Author: blegat

docs/src/submodules/Utilities/reference.md

@@ -154,6 +154,7 @@ Utilities.get_fallback
 The following utilities are available for functions:
 
 ```@docs
+supports_convert
 Utilities.eval_variables
 Utilities.map_indices
 Utilities.substitute_variables

src/Bridges/Constraint/bridges/functionize.jl

@@ -103,15 +103,6 @@ function MOI.delete(model::MOI.ModelLike, c::AbstractFunctionConversionBridge)
     return
 end
 
-function MOI.get(
-    model::MOI.ModelLike,
-    attr::MOI.CanonicalConstraintFunction,
-    b::AbstractFunctionConversionBridge,
-)
-    f = MOI.get(model, MOI.ConstraintFunction(), b)
-    return MOI.Utilities.canonical(f)
-end
-
 function MOI.set(
     model::MOI.ModelLike,
     ::MOI.ConstraintFunction,
@@ -166,250 +157,148 @@ function invariant_under_function_conversion(
 end
 
 """
-    ScalarFunctionizeBridge{T,S} <: Bridges.Constraint.AbstractBridge
+    FunctionConversionBridge{T,F,G,S} <: AbstractFunctionConversionBridge{G,S}
 
-`ScalarFunctionizeBridge` implements the following reformulations:
+`FunctionConversionBridge` implements the following reformulations:
 
-  * ``x \\in S`` into ``1x + 0 \\in S``
+  * ``g(x) \\in S`` into ``f(x) \\in S``
+
+for these pairs of functions:
+
+ * [`MOI.ScalarAffineFunction`](@ref)` to [`MOI.ScalarQuadraticFunction`](@ref)
+ * [`MOI.ScalarQuadraticFunction`](@ref)  to [`MOI.ScalarNonlinearFunction`](@ref)
+ * [`MOI.VectorAffineFunction`](@ref) to [`MOI.VectorQuadraticFunction`](@ref)
 
 ## Source node
 
-`ScalarFunctionizeBridge` supports:
+`FunctionConversionBridge` supports:
 
-  * [`MOI.VariableIndex`](@ref) in `S`
+  * `G` in `S`
 
 ## Target nodes
 
-`ScalarFunctionizeBridge` creates:
+`FunctionConversionBridge` creates:
 
-  * [`MOI.ScalarAffineFunction{T}`](@ref) in `S`
+  * `F` in `S`
 """
-struct ScalarFunctionizeBridge{T,S} <:
-       AbstractFunctionConversionBridge{MOI.ScalarAffineFunction{T},S}
-    constraint::MOI.ConstraintIndex{MOI.ScalarAffineFunction{T},S}
+mutable struct FunctionConversionBridge{T,F,G,S} <:
+       AbstractFunctionConversionBridge{F,S}
+    constraint::MOI.ConstraintIndex{F,S}
 end
-
-const ScalarFunctionize{T,OT<:MOI.ModelLike} =
-    SingleBridgeOptimizer{ScalarFunctionizeBridge{T},OT}
+# The `struct` needs to be mutable if `F <: AbstractVectorFunction`
+# in case one row is deleted. See `MOI.delete` above.
 
 function bridge_constraint(
-    ::Type{ScalarFunctionizeBridge{T,S}},
-    model,
-    f::MOI.VariableIndex,
+    ::Type{FunctionConversionBridge{T,F,G,S}},
+    model::MOI.ModelLike,
+    f::G,
     s::S,
-) where {T,S}
-    ci = MOI.add_constraint(model, convert(MOI.ScalarAffineFunction{T}, f), s)
-    return ScalarFunctionizeBridge{T,S}(ci)
+) where {T,F,G,S}
+    ci = MOI.add_constraint(model, convert(F, f), s)
+    return FunctionConversionBridge{T,F,G,S}(ci)
 end
 
 function MOI.supports_constraint(
-    ::Type{ScalarFunctionizeBridge{T}},
-    ::Type{<:MOI.VariableIndex},
-    ::Type{<:MOI.AbstractScalarSet},
-) where {T}
-    return true
+    ::Type{<:FunctionConversionBridge{T,F}},
+    ::Type{G},
+    ::Type{<:MOI.AbstractSet},
+) where {T,F,G<:MOI.AbstractFunction}
+    return MOI.supports_convert(F, G)
 end
 
 function concrete_bridge_type(
-    ::Type{<:ScalarFunctionizeBridge{T}},
-    ::Type{MOI.VariableIndex},
-    S::Type{<:MOI.AbstractScalarSet},
-) where {T}
-    return ScalarFunctionizeBridge{T,S}
+    ::Type{<:FunctionConversionBridge{T,F}},
+    G::Type{<:MOI.AbstractFunction},
+    S::Type{<:MOI.AbstractSet},
+) where {T,F}
+    return FunctionConversionBridge{T,F,G,S}
 end
 
 function MOI.get(
     model::MOI.ModelLike,
     ::MOI.ConstraintFunction,
-    b::ScalarFunctionizeBridge,
-)
+    b::FunctionConversionBridge{T,F,G},
+) where {T,F,G}
     f = MOI.get(model, MOI.ConstraintFunction(), b.constraint)
-    return convert(MOI.VariableIndex, f)
+    return convert(G, f)
 end
 
 """
-    VectorFunctionizeBridge{T,S} <: Bridges.Constraint.AbstractBridge
 
-`VectorFunctionizeBridge` implements the following reformulations:
+    ScalarFunctionizeBridge{T,S} = FunctionConversionBridge{T,MOI.ScalarAffineFunction{T},MOI.VariableIndex,S}
 
-  * ``x \\in S`` into ``Ix + 0 \\in S``
+`ScalarFunctionizeBridge` implements the following reformulations:
+
+  * ``x \\in S`` into ``1x + 0 \\in S``
 
 ## Source node
 
-`VectorFunctionizeBridge` supports:
+`ScalarFunctionizeBridge` supports:
 
-  * [`MOI.VectorOfVariables`](@ref) in `S`
+  * [`MOI.VariableIndex`](@ref) in `S`
 
 ## Target nodes
 
-`VectorFunctionizeBridge` creates:
+`ScalarFunctionizeBridge` creates:
 
-  * [`MOI.VectorAffineFunction{T}`](@ref) in `S`
+  * [`MOI.ScalarAffineFunction{T}`](@ref) in `S`
 """
-mutable struct VectorFunctionizeBridge{T,S} <:
-               AbstractFunctionConversionBridge{MOI.VectorAffineFunction{T},S}
-    constraint::MOI.ConstraintIndex{MOI.VectorAffineFunction{T},S}
-end
-
-const VectorFunctionize{T,OT<:MOI.ModelLike} =
-    SingleBridgeOptimizer{VectorFunctionizeBridge{T},OT}
-
-function bridge_constraint(
-    ::Type{VectorFunctionizeBridge{T,S}},
-    model,
-    f::MOI.VectorOfVariables,
-    s::S,
-) where {T,S}
-    ci = MOI.add_constraint(model, convert(MOI.VectorAffineFunction{T}, f), s)
-    return VectorFunctionizeBridge{T,S}(ci)
-end
-
-function MOI.supports_constraint(
-    ::Type{VectorFunctionizeBridge{T}},
-    ::Type{MOI.VectorOfVariables},
-    ::Type{<:MOI.AbstractVectorSet},
-) where {T}
-    return true
-end
-
-function concrete_bridge_type(
-    ::Type{<:VectorFunctionizeBridge{T}},
-    ::Type{MOI.VectorOfVariables},
-    S::Type{<:MOI.AbstractVectorSet},
-) where {T}
-    return VectorFunctionizeBridge{T,S}
-end
+const ScalarFunctionizeBridge{T,S} =
+    FunctionConversionBridge{T,MOI.ScalarAffineFunction{T},MOI.VariableIndex,S}
+const ScalarFunctionize{T,OT<:MOI.ModelLike} =
+    SingleBridgeOptimizer{ScalarFunctionizeBridge{T},OT}
 
-function MOI.get(
-    model::MOI.ModelLike,
-    ::MOI.ConstraintFunction,
-    b::VectorFunctionizeBridge,
-)
-    f = MOI.get(model, MOI.ConstraintFunction(), b.constraint)
-    return MOI.Utilities.convert_approx(MOI.VectorOfVariables, f)
-end
+# VectorOfVariables -> VectorAffineFunction  # Handled by VectorFunctionizeBridge
 
 """
-    FunctionConversionBridge{T,F,G,S} <: AbstractFunctionConversionBridge{G,S}
-
-`FunctionConversionBridge` implements the following reformulations:
+    VectorFunctionizeBridge{T,S} = FunctionConversionBridge{T,MOI.VectorAffineFunction{T},S}
 
-  * ``f(x) \\in S`` into ``g(x) \\in S``
-
-for these pairs of functions:
+`VectorFunctionizeBridge` implements the following reformulations:
 
- * [`MOI.ScalarAffineFunction`](@ref)` to [`MOI.ScalarQuadraticFunction`](@ref)
- * [`MOI.ScalarQuadraticFunction`](@ref)  to [`MOI.ScalarNonlinearFunction`](@ref)
- * [`MOI.VectorAffineFunction`](@ref) to [`MOI.VectorQuadraticFunction`](@ref)
+  * ``x \\in S`` into ``Ix + 0 \\in S``
 
 ## Source node
 
-`FunctionConversionBridge` supports:
+`VectorFunctionizeBridge` supports:
 
-  * `F` in `S`
+  * [`MOI.VectorOfVariables`](@ref) in `S`
 
 ## Target nodes
 
-`FunctionConversionBridge` creates:
+`VectorFunctionizeBridge` creates:
 
-  * `G` in `S`
+  * [`MOI.VectorAffineFunction{T}`](@ref) in `S`
 """
-struct FunctionConversionBridge{T,F,G,S} <:
-       AbstractFunctionConversionBridge{G,S}
-    constraint::MOI.ConstraintIndex{G,S}
-end
-
-const FunctionConversion{T,OT<:MOI.ModelLike} =
-    SingleBridgeOptimizer{FunctionConversionBridge{T},OT}
-
-function bridge_constraint(
-    ::Type{FunctionConversionBridge{T,F,G,S}},
-    model::MOI.ModelLike,
-    f::F,
-    s::S,
-) where {T,F,G,S}
-    ci = MOI.add_constraint(model, convert(G, f), s)
-    return FunctionConversionBridge{T,F,G,S}(ci)
-end
+const VectorFunctionizeBridge{T,S} = FunctionConversionBridge{
+    T,
+    MOI.VectorAffineFunction{T},
+    MOI.VectorOfVariables,
+    S,
+}
 
-function MOI.get(
-    model::MOI.ModelLike,
-    ::MOI.ConstraintFunction,
-    b::FunctionConversionBridge{T,F},
-) where {T,F}
-    g = MOI.get(model, MOI.ConstraintFunction(), b.constraint)
-    return convert(F, g)
-end
+const VectorFunctionize{T,OT<:MOI.ModelLike} =
+    SingleBridgeOptimizer{VectorFunctionizeBridge{T},OT}
 
-# VariableIndex -> ScalarAffineFunction  # Handled by ScalarFunctionizeBridge
+# AbstractScalarFunction -> ScalarQuadraticFunction
 
-# ScalarAffineFunction -> ScalarQuadraticFunction
+const ToScalarQuadraticBridge{T,G,S} =
+    FunctionConversionBridge{T,MOI.ScalarQuadraticFunction{T},G,S}
 
-function MOI.supports_constraint(
-    ::Type{<:FunctionConversionBridge{T}},
-    ::Type{MOI.ScalarAffineFunction{T}},
-    ::Type{<:MOI.AbstractScalarSet},
-) where {T}
-    return true
-end
+const ToScalarQuadratic{T,OT<:MOI.ModelLike} =
+    SingleBridgeOptimizer{ToScalarQuadraticBridge{T},OT}
 
-function concrete_bridge_type(
-    ::Type{<:FunctionConversionBridge{T}},
-    ::Type{MOI.ScalarAffineFunction{T}},
-    S::Type{<:MOI.AbstractScalarSet},
-) where {T}
-    return FunctionConversionBridge{
-        T,
-        MOI.ScalarAffineFunction{T},
-        MOI.ScalarQuadraticFunction{T},
-        S,
-    }
-end
+# AbstractVectorFunction -> VectorQuadraticFunction
 
-# ScalarQuadraticFunction -> ScalarNonlinearFunction
+const ToVectorQuadraticBridge{T,G,S} =
+    FunctionConversionBridge{T,MOI.VectorQuadraticFunction{T},G,S}
 
-function MOI.supports_constraint(
-    ::Type{<:FunctionConversionBridge{T}},
-    ::Type{MOI.ScalarQuadraticFunction{T}},
-    ::Type{<:MOI.AbstractScalarSet},
-) where {T}
-    return true
-end
+const ToVectorQuadratic{T,OT<:MOI.ModelLike} =
+    SingleBridgeOptimizer{ToVectorQuadraticBridge{T},OT}
 
-function concrete_bridge_type(
-    ::Type{<:FunctionConversionBridge{T}},
-    ::Type{MOI.ScalarQuadraticFunction{T}},
-    S::Type{<:MOI.AbstractScalarSet},
-) where {T}
-    return FunctionConversionBridge{
-        T,
-        MOI.ScalarQuadraticFunction{T},
-        MOI.ScalarNonlinearFunction,
-        S,
-    }
-end
+# AbstractScalarFunction -> ScalarNonlinearFunction
 
-# VectorOfVariables -> VectorAffineFunction  # Handled by VectorFunctionizeBridge
+const ToScalarNonlinearBridge{T,G,S} =
+    FunctionConversionBridge{T,MOI.ScalarNonlinearFunction,G,S}
 
-# VectorAffineFunction -> VectorQuadraticFunction
-
-function MOI.supports_constraint(
-    ::Type{<:FunctionConversionBridge{T}},
-    ::Type{MOI.VectorAffineFunction{T}},
-    ::Type{<:MOI.AbstractVectorSet},
-) where {T}
-    return true
-end
-
-function concrete_bridge_type(
-    ::Type{<:FunctionConversionBridge{T}},
-    ::Type{MOI.VectorAffineFunction{T}},
-    S::Type{<:MOI.AbstractVectorSet},
-) where {T}
-    return FunctionConversionBridge{
-        T,
-        MOI.VectorAffineFunction{T},
-        MOI.VectorQuadraticFunction{T},
-        S,
-    }
-end
+const ToScalarNonlinear{T,OT<:MOI.ModelLike} =
+    SingleBridgeOptimizer{ToScalarNonlinearBridge{T},OT}