implement Instance

BatyLeo · BatyLeo · commit 649c94e48eb2 · 2024-11-28T19:13:00.000+01:00
diff --git a/src/StochasticVehicleScheduling/StochasticVehicleScheduling.jl b/src/StochasticVehicleScheduling/StochasticVehicleScheduling.jl
@@ -15,10 +15,49 @@ include("instance/task.jl")
 include("instance/district.jl")
 include("instance/city.jl")
 include("instance/features.jl")
+include("instance/instance.jl")
 
-struct StochasticVehicleSchedulingBenchmark <: AbstractBenchmark end
+"""
+$TYPEDFIELDS
+
+Data structure for a stochastic vehicle scheduling benchmark.
+
+# Fields
+$TYPEDFIELDS
+"""
+@kwdef struct StochasticVehicleSchedulingBenchmark <: AbstractBenchmark
+    "number of tasks in each instance"
+    nb_tasks::Int = 25
+    "number of scenarios in each instance"
+    nb_scenarios::Int = 10
+end
+
+"""
+$TYPEDSIGNATURES
+
+Create a dataset of `dataset_size` instances for the given `StochasticVehicleSchedulingBenchmark`.
+"""
+function Utils.generate_dataset(
+    benchmark::StochasticVehicleSchedulingBenchmark,
+    dataset_size::Int;
+    seed=nothing,
+    rng=MersenneTwister(0),
+)
+    (; nb_tasks, nb_scenarios) = benchmark
+    Random.seed!(rng, seed)
+    instances = [Instance(; nb_tasks, nb_scenarios, rng=rng) for _ in 1:dataset_size]
+    features = get_features.(instances)
+    return [
+        DataSample(; x=feature, instance) for
+        (instance, feature) in zip(instances, features)
+    ]
+end
+
+function Utils.generate_maximizer(bench::StochasticVehicleSchedulingBenchmark) end
+function Utils.generate_statistical_model(bench::StochasticVehicleSchedulingBenchmark) end
 
 export StochasticVehicleSchedulingBenchmark
-export create_random_city, compute_features
+
+export create_random_city, compute_features, Instance
 
 end
diff --git a/src/StochasticVehicleScheduling/instance/city.jl b/src/StochasticVehicleScheduling/instance/city.jl
@@ -70,7 +70,7 @@ $TYPEDSIGNATURES
     and one `destination` task ending at time=end at depot
 - Roll every scenario.
 """
-function create_random_city(;  # TODO: use an rng here
+function create_random_city(;
     αᵥ_low=default_αᵥ_low,
     αᵥ_high=default_αᵥ_high,
     first_begin_time=default_first_begin_time,
@@ -80,10 +80,10 @@ function create_random_city(;  # TODO: use an rng here
     task_μ=default_task_μ,
     task_σ=default_task_σ,
     seed=nothing,
-    rng=MersenneTwister(0),
+    rng=Random.default_rng(),
     city_kwargs...,
 )
-    Random.seed!(rng, seed)
+    isnothing(seed) || Random.seed!(rng, seed)
     city = City(; city_kwargs...)
     init_districts!(city, district_μ, district_σ; rng=rng)
     init_tasks!(
diff --git a/src/StochasticVehicleScheduling/instance/features.jl b/src/StochasticVehicleScheduling/instance/features.jl
@@ -26,48 +26,6 @@ end
 """
 $TYPEDSIGNATURES
 
-Return a `MetaDiGraph` computed from `city`.
-Each vertex represents a task. Vertices are ordered by start time of corresponding task.
-There is an edge from task u to task v the (end time of u + tie distance between u and v <= start time of v).
-Every (u, v) edge has a :travel_time property, corresponding to time istance between u and v.
-"""
-function create_VSP_graph(city::City)
-    # Initialize directed graph
-    nb_vertices = city.nb_tasks + 2
-    graph = SimpleDiGraph(nb_vertices)
-    starting_task = 1
-    end_task = nb_vertices
-    job_tasks = 2:(city.nb_tasks + 1)
-
-    travel_times = [
-        distance(task1.end_point, task2.start_point) for task1 in city.tasks,
-        task2 in city.tasks
-    ]
-
-    # Create existing edges
-    for iorigin in job_tasks
-        # link every task to base
-        add_edge!(graph, starting_task, iorigin)
-        add_edge!(graph, iorigin, end_task)
-
-        for idestination in (iorigin + 1):(city.nb_tasks + 1)
-            travel_time = travel_times[iorigin, idestination]
-            origin_end_time = city.tasks[iorigin].end_time
-            destination_begin_time = city.tasks[idestination].start_time # get_prop(graph, idestination, :task).start_time
-
-            # there is an edge only if we can reach destination from origin before start of task
-            if origin_end_time + travel_time <= destination_begin_time
-                add_edge!(graph, iorigin, idestination)
-            end
-        end
-    end
-
-    return graph
-end
-
-"""
-$TYPEDSIGNATURES
-
 Compute slack for features.
 """
 function compute_slacks(city::City, old_task_index::Int, new_task_index::Int)
diff --git a/src/StochasticVehicleScheduling/instance/instance.jl b/src/StochasticVehicleScheduling/instance/instance.jl
@@ -1,8 +1,3 @@
-"""
-$TYPEDEF
-"""
-abstract type AbstractInstance end
-
 """
 $TYPEDEF
 
@@ -11,86 +6,85 @@ Instance of the stochastic VSP problem.
 # Fields
 $TYPEDFIELDS
 """
-struct Instance{G<:AbstractGraph,M1<:AbstractMatrix,M2<:AbstractMatrix,F,C} <:
-       AbstractInstance
-    "associated city"
-    city::City
-    "graph computed from `city` with the `create_VSP_graph(city::City)` method."
-    graph::G
-    "features matrix computed from `city`"
-    features::Matrix{F}
-    ""
-    slacks::M1
-    ""
-    delays::M2
-    ""
-    vehicle_cost::C
-    ""
-    delay_cost::C
-end
-
-"""
-$TYPEDEF
-
-Instance of the stochastic VSP problem.
-
-# Fields
-$TYPEDFIELDS
-"""
-struct CompactInstance{G<:AbstractGraph,M1<:AbstractMatrix,M2<:AbstractMatrix,F,C} <:
-       AbstractInstance
+struct Instance{G<:AbstractGraph,M1<:AbstractMatrix,M2<:AbstractMatrix,F,C}
     "graph computed from `city` with the `create_VSP_graph(city::City)` method"
     graph::G
     "features matrix computed from `city`"
     features::Matrix{F}
-    ""
+    "slack matrix"
     slacks::M1
-    ""
+    "intrinsic delays scenario matrix"
     delays::M2
-    ""
+    "cost of a vehicle"
     vehicle_cost::C
-    ""
+    "cost of one minute delay"
     delay_cost::C
 end
 
 """
 $TYPEDSIGNATURES
 
-Constructor for [`Instance`](@ref).
-Build an `Instance` from a `City`, by computing its graph, features, slacks and delays.
-"""
-function Instance(city::City)
-    graph = create_VSP_graph(city)
-    features = compute_features(city)
-    slacks = compute_slacks(city, graph)
-    delays = compute_delays(city)
-    return Instance(
-        city, graph, features, slacks, delays, city.vehicle_cost, city.delay_cost
-    )
+Return the acyclic directed graph corresponding to `city`.
+Each vertex represents a task. Vertices are ordered by start time of corresponding task.
+There is an edge from task u to task v the (end time of u + tie distance between u and v <= start time of v).
+"""
+function create_VSP_graph(city::City)
+    # Initialize directed graph
+    nb_vertices = city.nb_tasks + 2
+    graph = SimpleDiGraph(nb_vertices)
+    starting_task = 1
+    end_task = nb_vertices
+    job_tasks = 2:(city.nb_tasks + 1)
+
+    travel_times = [
+        distance(task1.end_point, task2.start_point) for task1 in city.tasks,
+        task2 in city.tasks
+    ]
+
+    # Create existing edges
+    for iorigin in job_tasks
+        # link every task to base
+        add_edge!(graph, starting_task, iorigin)
+        add_edge!(graph, iorigin, end_task)
+
+        for idestination in (iorigin + 1):(city.nb_tasks + 1)
+            travel_time = travel_times[iorigin, idestination]
+            origin_end_time = city.tasks[iorigin].end_time
+            destination_begin_time = city.tasks[idestination].start_time # get_prop(graph, idestination, :task).start_time
+
+            # there is an edge only if we can reach destination from origin before start of task
+            if origin_end_time + travel_time <= destination_begin_time
+                add_edge!(graph, iorigin, idestination)
+            end
+        end
+    end
+
+    return graph
 end
 
 """
 $TYPEDSIGNATURES
 
-Constructor for [`CompactInstance`](@ref).
-Build a `CompactInstance` from a `City`, by computing its graph, features, slacks and delays.
+Constructor for [`Instance`](@ref).
+Build an `Instance` for the stochatsic vehicle scheduling problem, with `nb_tasks` tasks and `nb_scenarios` scenarios.
 """
-function CompactInstance(city::City)
+function Instance(;
+    nb_tasks::Int, nb_scenarios::Int, rng::AbstractRNG=Random.default_rng(), kwargs...
+)
+    city = create_random_city(; rng=rng, nb_tasks, nb_scenarios, kwargs...)
     graph = create_VSP_graph(city)
     features = compute_features(city)
     slacks = compute_slacks(city, graph)
     delays = compute_delays(city)
-    return CompactInstance(
-        graph, features, slacks, delays, city.vehicle_cost, city.delay_cost
-    )
+    return Instance(graph, features, slacks, delays, city.vehicle_cost, city.delay_cost)
 end
 
 """
 $TYPEDSIGNATURES
 
 Returns the number of scenarios in instance.
 """
-function get_nb_scenarios(instance::AbstractInstance)
+function get_nb_scenarios(instance::Instance)
     return size(instance.delays, 2)
 end
 
@@ -99,22 +93,11 @@ $TYPEDSIGNATURES
 
 Returns the number of tasks in `instance`.
 """
-get_nb_tasks(instance::AbstractInstance) = nv(instance.graph) - 2
-
-"""
-$TYPEDSIGNATURES
-
-Returns a random instance created with city_kwargs.
-"""
-function create_random_instance(; city_kwargs...)
-    return Instance(create_random_city(; city_kwargs...))
-end
+get_nb_tasks(instance::Instance) = nv(instance.graph) - 2
 
 """
 $TYPEDSIGNATURES
 
-Returns a random instance created with city_kwargs.
+Returns the feature matrix associated to `instance`.
 """
-function create_random_compact_instance(; city_kwargs...)
-    return CompactInstance(create_random_city(; city_kwargs...))
-end
+get_features(instance::Instance) = instance.features
