fix tests and cleanup

Author: BatyLeo

src/DynamicVehicleScheduling/anticipative_solver.jl

@@ -92,14 +92,14 @@ function anticipative_solver(
     job_indices = 2:nb_nodes
     epoch_indices = T
 
-    @variable(model, y[i=1:nb_nodes, j=1:nb_nodes, t=epoch_indices]; binary=true)
+    @variable(model, y[i = 1:nb_nodes, j = 1:nb_nodes, t = epoch_indices]; binary=true)
 
     @objective(
         model,
         Max,
         sum(
-            -duration[i, j] * y[i, j, t] for i in 1:nb_nodes, j in 1:nb_nodes,
-            t in epoch_indices
+            -duration[i, j] * y[i, j, t] for
+            i in 1:nb_nodes, j in 1:nb_nodes, t in epoch_indices
         )
     )
 
@@ -171,14 +171,12 @@ function anticipative_solver(
         routes = epoch_routes[i]
         epoch_customers = epoch_indices[i]
 
-        y_true =
-            VSPSolution(
-                Vector{Int}[
-                    map(idx -> findfirst(==(idx), epoch_customers), route) for
-                    route in routes
-                ];
-                max_index=length(epoch_customers),
-            ).edge_matrix
+        y_true = VSPSolution(
+            Vector{Int}[
+                map(idx -> findfirst(==(idx), epoch_customers), route) for route in routes
+            ];
+            max_index=length(epoch_customers),
+        ).edge_matrix
 
         location_indices = customer_index[epoch_customers]
         new_coordinates = env.instance.static_instance.coordinate[location_indices]
@@ -202,7 +200,8 @@ function anticipative_solver(
             is_must_dispatch[2:end] .= true
         else
             is_must_dispatch[2:end] .=
-                planning_start_time .+ epoch_duration .+ @view(new_duration[1, 2:end]) .> new_start_time[2:end]
+                planning_start_time .+ epoch_duration .+ @view(new_duration[1, 2:end]) .>
+                new_start_time[2:end]
         end
         is_postponable[2:end] .= .!is_must_dispatch[2:end]
         # TODO: avoid code duplication with add_new_customers!

src/DynamicVehicleScheduling/plot.jl

@@ -1,26 +1,3 @@
-"""
-Typed container for plot-ready data.
-"""
-struct PlotData
-    n_epochs::Int
-    coordinates::Vector{Vector{Tuple{Float64,Float64}}}
-    start_times::Vector{Vector{Float64}}
-    node_types::Vector{Vector{Symbol}}
-    routes::Vector{Vector{Vector{Int}}}
-    epoch_costs::Vector{Float64}
-end
-
-function PlotData(d::Dict)
-    return PlotData(
-        d[:n_epochs],
-        d[:coordinates],
-        d[:start_times],
-        d[:node_types],
-        d[:routes],
-        d[:epoch_costs],
-    )
-end
-
 function plot_instance(env::DVSPEnv; kwargs...)
     return plot_instance(env.instance.static_instance; kwargs...)
 end
@@ -461,7 +438,7 @@ function animate_epochs(
                 xlims=xlims,
                 ylims=ylims,
                 clims=clims,
-                title="Epoch $(state.current_epoch) - Available Requests",
+                title="Epoch $(state.current_epoch) - Available Customers",
                 titlefontsize=titlefontsize,
                 guidefontsize=guidefontsize,
                 legendfontsize=legendfontsize,
@@ -592,268 +569,3 @@ function animate_epochs(
 
     return anim
 end
-
-"""
-Animate multiple solutions where each solution is provided as its own vector of
-`DataSample` objects (one per epoch). This treats each solution's `DataSample`
-as the canonical source for that column in the side-by-side animation.
-"""
-function animate_solutions_side_by_side(
-    solutions_data_samples::AbstractVector;
-    solution_names=nothing,
-    filename="dvsp_solutions_side_by_side.gif",
-    fps=1,
-    figsize=(1200, 600),
-    margin=0.1,
-    legend_margin_factor=0.15,
-    titlefontsize=14,
-    guidefontsize=12,
-    legendfontsize=11,
-    tickfontsize=10,
-    show_axis_labels=true,
-    show_cost_bar=true,
-    cost_bar_width=0.05,
-    cost_bar_margin=0.02,
-    cost_bar_color_palette=:turbo,
-    kwargs...,
-)
-    n_solutions = length(solutions_data_samples)
-    if n_solutions == 0
-        error("No solutions provided")
-    end
-
-    # Ensure all solution sequences have the same number of epochs
-    n_epochs = length(solutions_data_samples[1])
-    for (i, s) in enumerate(solutions_data_samples)
-        if length(s) != n_epochs
-            error(
-                "All solution DataSample vectors must have the same length. Solution $i has length $(length(s)) but expected $n_epochs",
-            )
-        end
-    end
-
-    if isnothing(solution_names)
-        solution_names = ["Solution $(i)" for i in 1:n_solutions]
-    end
-
-    # Collect global coordinates and start times across all solutions/epochs
-    all_coordinates = []
-    all_start_times = []
-    epoch_costs_per_solution = [Float64[] for _ in 1:n_solutions]
-
-    for j in 1:n_solutions
-        samples = solutions_data_samples[j]
-        for (t, sample) in enumerate(samples)
-            if !isnothing(sample.instance.state)
-                append!(all_coordinates, coordinate(sample.instance.state))
-                append!(all_start_times, start_time(sample.instance.state))
-
-                if sample.y_true isa BitMatrix
-                    routes = decode_bitmatrix_to_routes(sample.y_true)
-                else
-                    routes = sample.y_true isa Vector{Int} ? [sample.y_true] : sample.y_true
-                end
-                c = isnothing(routes) ? 0.0 : cost(sample.instance.state, routes)
-                push!(epoch_costs_per_solution[j], c)
-            else
-                push!(epoch_costs_per_solution[j], NaN)
-            end
-        end
-    end
-
-    if isempty(all_coordinates)
-        error("No valid coordinates found in solution data samples")
-    end
-
-    # Global limits
-    xlims = (
-        minimum(p.x for p in all_coordinates) - margin,
-        maximum(p.x for p in all_coordinates) + margin,
-    )
-
-    y_min = minimum(p.y for p in all_coordinates) - margin
-    y_max = maximum(p.y for p in all_coordinates) + margin
-    y_range = y_max - y_min
-    legend_margin = y_range * legend_margin_factor
-    ylims = (y_min, y_max + legend_margin)
-
-    clims = if !isempty(all_start_times)
-        (minimum(all_start_times), maximum(all_start_times))
-    else
-        (0.0, 1.0)
-    end
-
-    # Robust cumulative costs per solution
-    robust_cumulative = Vector{Vector{Float64}}(undef, n_solutions)
-    for j in 1:n_solutions
-        robust = Float64[]
-        s = 0.0
-        for c in epoch_costs_per_solution[j]
-            if !isnan(c)
-                s += c
-            end
-            push!(robust, s)
-        end
-        robust_cumulative[j] = robust
-    end
-
-    function has_routes_local(routes)
-        if isnothing(routes)
-            return false
-        elseif routes isa Vector{Vector{Int}}
-            return any(!isempty(route) for route in routes)
-        elseif routes isa Vector{Int}
-            return !isempty(routes)
-        elseif routes isa BitMatrix
-            return any(routes)
-        else
-            return false
-        end
-    end
-
-    anim = @animate for t in 1:n_epochs
-        col_plots = []
-        for j in 1:n_solutions
-            sample = solutions_data_samples[j][t]
-            state = sample.instance.state
-            routes = sample.y_true
-
-            if isnothing(state)
-                fig = plot(;
-                    xlims=xlims,
-                    ylims=ylims,
-                    title="$(solution_names[j]) - Epoch $t (No Data)",
-                    titlefontsize=titlefontsize,
-                    guidefontsize=guidefontsize,
-                    tickfontsize=tickfontsize,
-                    legend=false,
-                    kwargs...,
-                )
-            else
-                if has_routes_local(routes)
-                    fig = plot_routes(
-                        state,
-                        routes;
-                        xlims=xlims,
-                        ylims=ylims,
-                        clims=clims,
-                        title="$(solution_names[j]) - Epoch $(state.current_epoch)",
-                        titlefontsize=titlefontsize,
-                        guidefontsize=guidefontsize,
-                        legendfontsize=legendfontsize,
-                        tickfontsize=tickfontsize,
-                        show_axis_labels=show_axis_labels,
-                        markerstrokewidth=0.5,
-                        show_route_labels=false,
-                        show_colorbar=false,
-                        size=(floor(Int, figsize[1] / n_solutions), figsize[2]),
-                        kwargs...,
-                    )
-                else
-                    fig = plot_state(
-                        state;
-                        xlims=xlims,
-                        ylims=ylims,
-                        clims=clims,
-                        title="$(solution_names[j]) - Epoch $(state.current_epoch)",
-                        titlefontsize=titlefontsize,
-                        guidefontsize=guidefontsize,
-                        legendfontsize=legendfontsize,
-                        tickfontsize=tickfontsize,
-                        show_axis_labels=show_axis_labels,
-                        show_colorbar=false,
-                        markerstrokewidth=0.5,
-                        size=(floor(Int, figsize[1] / n_solutions), figsize[2]),
-                        kwargs...,
-                    )
-                end
-            end
-
-            # cost bar
-            if show_cost_bar
-                current_cost = robust_cumulative[j][t]
-                max_cost = maximum([robust_cumulative[k][end] for k in 1:n_solutions])
-
-                x_min, x_max = xlims
-                x_range = x_max - x_min
-                bar_x_start = x_max - cost_bar_width * x_range
-                bar_x_end = x_max - cost_bar_margin * x_range
-
-                y_min, y_max = ylims
-                y_range = y_max - y_min
-                bar_y_start = y_min + 0.1 * y_range
-                bar_y_end = y_max - 0.1 * y_range
-                bar_height = bar_y_end - bar_y_start
-
-                if max_cost > 0
-                    filled_height = (current_cost / max_cost) * bar_height
-                else
-                    filled_height = 0.0
-                end
-
-                plot!(
-                    fig,
-                    [bar_x_start, bar_x_end, bar_x_end, bar_x_start, bar_x_start],
-                    [bar_y_start, bar_y_start, bar_y_end, bar_y_end, bar_y_start];
-                    seriestype=:shape,
-                    color=:white,
-                    alpha=0.8,
-                    linecolor=:black,
-                    linewidth=2,
-                    label="",
-                )
-
-                if filled_height > 0
-                    cmap = Plots.cgrad(cost_bar_color_palette)
-                    ratio = max_cost > 0 ? current_cost / max_cost : 0.0
-                    color_at_val = Plots.get(cmap, ratio)
-                    plot!(
-                        fig,
-                        [bar_x_start, bar_x_end, bar_x_end, bar_x_start, bar_x_start],
-                        [
-                            bar_y_start,
-                            bar_y_start,
-                            bar_y_start + filled_height,
-                            bar_y_start + filled_height,
-                            bar_y_start,
-                        ];
-                        seriestype=:shape,
-                        color=color_at_val,
-                        alpha=0.7,
-                        linecolor=:darkred,
-                        linewidth=1,
-                        label="",
-                    )
-                end
-
-                cost_text_y = bar_y_start + filled_height + 0.02 * y_range
-                if cost_text_y > bar_y_end
-                    cost_text_y = bar_y_end
-                end
-                plot!(
-                    fig,
-                    [bar_x_start + (bar_x_end - bar_x_start) / 2],
-                    [cost_text_y];
-                    seriestype=:scatter,
-                    markersize=0,
-                    label="",
-                    annotations=(
-                        bar_x_start - 0.04 * x_range,
-                        cost_text_y,
-                        (@sprintf("%.1f", current_cost), :center, guidefontsize),
-                    ),
-                )
-            end
-
-            push!(col_plots, fig)
-        end
-
-        combined = plot(
-            col_plots...; layout=(1, n_solutions), size=figsize, link=:both, clims=clims
-        )
-        combined
-    end
-
-    gif(anim, filename; fps=fps)
-    return anim
-end

test/dynamic_vsp_plots.jl

@@ -10,7 +10,7 @@
     env = environments[1]
 
     # Test basic plotting functions
-    fig1 = DVSP.plot_instancee(env)
+    fig1 = DVSP.plot_instance(env)
     @test fig1 isa Plots.Plot
 
     instance = dataset[1].instance
@@ -23,7 +23,7 @@
     policies = generate_policies(b)
     lazy = policies[1]
     _, d = evaluate_policy!(lazy, env)
-    fig3 = DVSP.plot_routes(d[1].instance, d[1].y_true)
+    fig3 = DVSP.plot_routes(d[1].instance.state, d[1].y_true)
     @test fig3 isa Plots.Plot
 
     # Test animation