Added bridge for List -> Partition conversion (#10)

* Added bridge for List -> Partition conversion

* Added SetConversionBridge

* removed bridge in test_tsp

* Identity map

* Simplify

* simplify

* Don't +1/-1

* Add test

* Fix tests

* Fix

* Fix

* Fix

---------

Co-authored-by: Benoît Legat <benoit.legat@gmail.com>

Author: Sutekinaa

src/MathOptVRP.jl

@@ -21,6 +21,7 @@ import MathOptInterface as MOI
 import JuMP
 
 include("sets.jl")
+include("bridges.jl")
 include("operators.jl")
 include("Tests.jl")
 

src/bridges.jl

@@ -0,0 +1,59 @@
+# `SetConversionBridge{T,S2,S1}` lets a solver backend that only
+# implements `MOI.add_constrained_variables(model, ::S2)` transparently
+# also support `@variable(model, x[1:n] in S1(...))`, for any pair of
+# vector sets connected by a linear map (`S2` is the set actually added to
+# the underlying model, `S1` is the set exposed to the user). A new `S1 => S2` pair
+# only has to supply `map_set` / `inverse_map_set` (how the sets relate — generic here, via
+# `Base.convert`) and `map_function` / `inverse_map_function` (how the
+# *variables* relate — necessarily specific to the pair, since `S1` and
+# `S2` need not even share a dimension).
+#
+
+"""
+    SetConversionBridge{T,S2,S1} <: MOI.Bridges.Variable.SetMapBridge{T,S2,S1}
+
+Bridges `MOI.VectorOfVariables`-in-`S1` (what the user asks for) to
+`MOI.VectorOfVariables`-in-`S2` (what gets added to the underlying model).
+"""
+struct SetConversionBridge{T,S2,S1} <: MOI.Bridges.Variable.SetMapBridge{T,S2,S1}
+    variables::Vector{MOI.VariableIndex}
+    constraint::MOI.ConstraintIndex{MOI.VectorOfVariables,S2}
+end
+
+function MOI.Bridges.map_set(
+    ::Type{<:SetConversionBridge{T,S2,S1}},
+    set::S2,
+) where {T,S2,S1}
+    return convert(S1, set)
+end
+
+function MOI.Bridges.inverse_map_set(
+    ::Type{<:SetConversionBridge{T,S2,S1}},
+    set::S1,
+) where {T,S2,S1}
+    return convert(S2, set)
+end
+
+MOI.Bridges.map_function(::Type{<:SetConversionBridge}, func) = func
+
+MOI.Bridges.inverse_map_function(::Type{<:SetConversionBridge}, func) = func
+
+# The map is the identity so it is its own adjoint; without these, setting
+# `MOI.ConstraintDualStart` (or getting `MOI.ConstraintDual`) on a bridged
+# constraint errors.
+MOI.Bridges.adjoint_map_function(::Type{<:SetConversionBridge}, func) = func
+
+function MOI.Bridges.inverse_adjoint_map_function(
+    ::Type{<:SetConversionBridge},
+    func,
+)
+    return func
+end
+
+"""
+    ListToPartitionBridge{T} = SetConversionBridge{T,Partition,List}
+
+Bridges `List(n)` to `Partition(n, 1)`, for backends that support
+`Partition` but not `List`.
+"""
+const ListToPartitionBridge{T} = SetConversionBridge{T,Partition,List}

src/sets.jl

@@ -46,6 +46,30 @@ function JuMP.build_variable(
     )
 end
 
+"""
+    Base.convert(::Type{Partition}, s::List)
+
+`List(n)` and `Partition(n, 1)` have the same flat dimension (`n`) and, for
+a single truck, the same "permutation of `0:n-1`" semantics, so this
+conversion always succeeds.
+"""
+Base.convert(::Type{Partition}, s::List) = Partition(s.dimension, 1)
+
+"""
+    Base.convert(::Type{List}, s::Partition)
+
+Only defined when `s.num_trucks == 1`: a multi-truck `Partition` has no
+`List` equivalent.
+"""
+function Base.convert(::Type{List}, s::Partition)
+    if s.num_trucks != 1
+        # Julia v1.10's `InexactError` only accepts `(func, T, val)`; the
+        # variadic constructor that takes a message is v1.11 or later.
+        throw(InexactError(:convert, List, s))
+    end
+    return List(s.num_clients)
+end
+
 """
     PartitionPD(num_services::Int, num_pickup_deliveries::Int, num_trucks::Int)
 

test/Bridges/set_conversion.jl

@@ -0,0 +1,87 @@
+module TestSetConversion
+
+using Test
+
+import MathOptInterface as MOI
+import MathOptVRP
+
+function runtests()
+    for name in names(@__MODULE__; all = true)
+        if startswith("$(name)", "test_")
+            @testset "$(name)" begin
+                getfield(@__MODULE__, name)()
+            end
+        end
+    end
+    return
+end
+
+function test_runtests_ListToPartition()
+    MOI.Bridges.runtests(
+        MathOptVRP.ListToPartitionBridge,
+        model -> MOI.add_constrained_variables(model, MathOptVRP.List(3)),
+        model ->
+            MOI.add_constrained_variables(model, MathOptVRP.Partition(3, 1)),
+    )
+    return
+end
+
+function _set_objective(model, x)
+    MOI.set(model, MOI.ObjectiveSense(), MOI.MIN_SENSE)
+    f = sum(Float64(i) * x[i] for i in eachindex(x))
+    MOI.set(model, MOI.ObjectiveFunction{typeof(f)}(), f)
+    return
+end
+
+# The variables are mapped through the bridge with the identity so the
+# objective must come out of the bridged model unchanged.
+function test_runtests_ListToPartition_objective()
+    for n in (1, 4)
+        MOI.Bridges.runtests(
+            MathOptVRP.ListToPartitionBridge,
+            model -> begin
+                x, _ = MOI.add_constrained_variables(model, MathOptVRP.List(n))
+                _set_objective(model, x)
+            end,
+            model -> begin
+                x, _ = MOI.add_constrained_variables(
+                    model,
+                    MathOptVRP.Partition(n, 1),
+                )
+                _set_objective(model, x)
+            end,
+        )
+    end
+    return
+end
+
+function test_supports_constrained_variable()
+    BT = MathOptVRP.ListToPartitionBridge{Float64}
+    @test MOI.Bridges.Variable.supports_constrained_variable(
+        BT,
+        MathOptVRP.List,
+    )
+    @test !MOI.Bridges.Variable.supports_constrained_variable(
+        BT,
+        MathOptVRP.Partition,
+    )
+    @test MOI.Bridges.added_constrained_variable_types(BT) ==
+          [(MathOptVRP.Partition,)]
+    @test isempty(MOI.Bridges.added_constraint_types(BT))
+    return
+end
+
+# `map_set` (bridge → user) and `inverse_map_set` (user → bridge) are the
+# `Base.convert` methods of `src/sets.jl`.
+function test_map_set()
+    BT = MathOptVRP.ListToPartitionBridge{Float64}
+    @test MOI.Bridges.inverse_map_set(BT, MathOptVRP.List(3)) ==
+          MathOptVRP.Partition(3, 1)
+    @test MOI.Bridges.map_set(BT, MathOptVRP.Partition(3, 1)) ==
+          MathOptVRP.List(3)
+    return
+end
+
+end # module TestSetConversion
+
+TestSetConversion.runtests()

test/runtests.jl

@@ -29,6 +29,17 @@ import MathOptInterface as MOI
         )
     end
 
+    @testset "List <=> Partition conversion" begin
+        @test convert(MathOptVRP.Partition, MathOptVRP.List(5)) ==
+              MathOptVRP.Partition(5, 1)
+        @test convert(MathOptVRP.List, MathOptVRP.Partition(5, 1)) ==
+              MathOptVRP.List(5)
+        @test_throws InexactError convert(
+            MathOptVRP.List,
+            MathOptVRP.Partition(5, 2),
+        )
+    end
+
     @testset "PartitionPD" begin
         s = MathOptVRP.PartitionPD(2, 3, 4)  # 2 services + 2*3 pd = 8 rows, 4 trucks
         @test s.num_services == 2
@@ -107,6 +118,8 @@ import MathOptInterface as MOI
         @test expr.args[2] === nodes
     end
 
+    include("Bridges/set_conversion.jl")
+
     include("test_ortools.jl")
 
     @testset "JuMP overrides (type piracy)" begin