Better costs modelling at vehicle level

CHANGELOG.md

@@ -5,6 +5,9 @@
 ### Added
 
 - Support for `max_travel_time` at vehicle level (#273)
+- Support for vehicle fixed costs (#528)
+- Support for cost per hour for vehicles (#732)
+- `RouteSplit` local search operator (#788)
 - Advertise `libvroom` in README and wiki (#42)
 
 ### Changed

docs/API.md

@@ -110,6 +110,7 @@ A `vehicle` object has the following properties:
 | [`end`] | coordinates array |
 | [`end_index`] | index of relevant row and column in custom matrices |
 | [`capacity`] | an array of integers describing multidimensional quantities |
+| [`costs`] | a `cost` object defining costs for this vehicle |
 | [`skills`] | an array of integers defining skills |
 | [`time_window`] | a `time_window` object describing working hours |
 | [`breaks`] | an array of `break` objects |
@@ -118,6 +119,18 @@ A `vehicle` object has the following properties:
 | [`max_travel_time`] | an integer defining the maximum travel time for this vehicle |
 | [`steps`] | an array of `vehicle_step` objects describing a custom route for this vehicle |
 
+A `cost` object has the following properties:
+
+| Key         | Description |
+| ----------- | ----------- |
+| [`fixed`] | integer defining the cost of using this vehicle in the solution (defaults to `0`) |
+| [`per_hour`] | integer defining the cost for one hour of travel time with this vehicle (defaults to `3600`) |
+
+Using a non-default `per-hour` value means defining travel costs based
+on travel times with a multiplicative factor. So in particular
+providing a custom costs matrix for the vehicle is inconsistent and
+will raise an error.
+
 A `break` object has the following properties:
 
 | Key         | Description |

src/algorithms/heuristics/heuristics.cpp

@@ -61,7 +61,8 @@ std::vector<std::vector<Eval>> get_jobs_vehicles_evals(const Input& input) {
   return evals;
 }
 
-template <class T> T basic(const Input& input, INIT init, double lambda) {
+template <class T>
+T basic(const Input& input, INIT init, double lambda, SORT sort) {
   const auto nb_vehicles = input.vehicles.size();
   T routes;
   for (Index v = 0; v < nb_vehicles; ++v) {
@@ -77,19 +78,40 @@ template <class T> T basic(const Input& input, INIT init, double lambda) {
   // within the heuristic.
   std::vector<Index> vehicles_ranks(nb_vehicles);
   std::iota(vehicles_ranks.begin(), vehicles_ranks.end(), 0);
-  // Sort vehicles by decreasing max number of tasks allowed, then
-  // capacity (not a total order), then working hours length.
-  std::stable_sort(vehicles_ranks.begin(),
-                   vehicles_ranks.end(),
-                   [&](const auto lhs, const auto rhs) {
-                     auto& v_lhs = input.vehicles[lhs];
-                     auto& v_rhs = input.vehicles[rhs];
-                     return v_lhs.max_tasks > v_rhs.max_tasks or
-                            (v_lhs.max_tasks == v_rhs.max_tasks and
-                             (v_rhs.capacity << v_lhs.capacity or
-                              (v_lhs.capacity == v_rhs.capacity and
-                               v_lhs.tw.length > v_rhs.tw.length)));
-                   });
+
+  switch (sort) {
+  case SORT::CAPACITY:
+    // Sort vehicles by decreasing max number of tasks allowed, then
+    // capacity (not a total order), then working hours length.
+    std::stable_sort(vehicles_ranks.begin(),
+                     vehicles_ranks.end(),
+                     [&](const auto lhs, const auto rhs) {
+                       auto& v_lhs = input.vehicles[lhs];
+                       auto& v_rhs = input.vehicles[rhs];
+                       return v_lhs.max_tasks > v_rhs.max_tasks or
+                              (v_lhs.max_tasks == v_rhs.max_tasks and
+                               (v_rhs.capacity << v_lhs.capacity or
+                                (v_lhs.capacity == v_rhs.capacity and
+                                 v_lhs.tw.length > v_rhs.tw.length)));
+                     });
+    break;
+  case SORT::COST:
+    // Sort vehicles by increasing fixed cost, then same as above.
+    std::stable_sort(vehicles_ranks.begin(),
+                     vehicles_ranks.end(),
+                     [&](const auto lhs, const auto rhs) {
+                       auto& v_lhs = input.vehicles[lhs];
+                       auto& v_rhs = input.vehicles[rhs];
+                       return v_lhs.costs < v_rhs.costs or
+                              (v_lhs.costs == v_rhs.costs and
+                               (v_lhs.max_tasks > v_rhs.max_tasks or
+                                (v_lhs.max_tasks == v_rhs.max_tasks and
+                                 (v_rhs.capacity << v_lhs.capacity or
+                                  (v_lhs.capacity == v_rhs.capacity and
+                                   v_lhs.tw.length > v_rhs.tw.length)))));
+                     });
+    break;
+  }
 
   auto evals = get_jobs_vehicles_evals(input);
 
@@ -426,7 +448,10 @@ template <class T> T basic(const Input& input, INIT init, double lambda) {
 }
 
 template <class T>
-T dynamic_vehicle_choice(const Input& input, INIT init, double lambda) {
+T dynamic_vehicle_choice(const Input& input,
+                         INIT init,
+                         double lambda,
+                         SORT sort) {
   const auto nb_vehicles = input.vehicles.size();
   T routes;
   for (Index v = 0; v < nb_vehicles; ++v) {
@@ -476,22 +501,47 @@ T dynamic_vehicle_choice(const Input& input, INIT init, double lambda) {
       }
     }
 
-    const auto chosen_vehicle =
-      std::min_element(vehicles_ranks.begin(),
-                       vehicles_ranks.end(),
-                       [&](const auto lhs, const auto rhs) {
-                         auto& v_lhs = input.vehicles[lhs];
-                         auto& v_rhs = input.vehicles[rhs];
-                         return closest_jobs_count[lhs] >
-                                  closest_jobs_count[rhs] or
-                                (closest_jobs_count[lhs] ==
-                                   closest_jobs_count[rhs] and
-                                 (v_rhs.capacity << v_lhs.capacity or
-                                  (v_lhs.capacity == v_rhs.capacity and
-                                   v_lhs.tw.length > v_rhs.tw.length)));
-                       });
-    auto v_rank = *chosen_vehicle;
-    vehicles_ranks.erase(chosen_vehicle);
+    Index v_rank;
+
+    if (sort == SORT::CAPACITY) {
+      const auto chosen_vehicle =
+        std::min_element(vehicles_ranks.begin(),
+                         vehicles_ranks.end(),
+                         [&](const auto lhs, const auto rhs) {
+                           auto& v_lhs = input.vehicles[lhs];
+                           auto& v_rhs = input.vehicles[rhs];
+                           return closest_jobs_count[lhs] >
+                                    closest_jobs_count[rhs] or
+                                  (closest_jobs_count[lhs] ==
+                                     closest_jobs_count[rhs] and
+                                   (v_rhs.capacity << v_lhs.capacity or
+                                    (v_lhs.capacity == v_rhs.capacity and
+                                     v_lhs.tw.length > v_rhs.tw.length)));
+                         });
+      v_rank = *chosen_vehicle;
+      vehicles_ranks.erase(chosen_vehicle);
+    } else {
+      assert(sort == SORT::COST);
+
+      const auto chosen_vehicle =
+        std::min_element(vehicles_ranks.begin(),
+                         vehicles_ranks.end(),
+                         [&](const auto lhs, const auto rhs) {
+                           auto& v_lhs = input.vehicles[lhs];
+                           auto& v_rhs = input.vehicles[rhs];
+                           return closest_jobs_count[lhs] >
+                                    closest_jobs_count[rhs] or
+                                  (closest_jobs_count[lhs] ==
+                                     closest_jobs_count[rhs] and
+                                   (v_lhs.costs < v_rhs.costs or
+                                    (v_lhs.costs == v_rhs.costs and
+                                     (v_rhs.capacity << v_lhs.capacity or
+                                      (v_lhs.capacity == v_rhs.capacity and
+                                       v_lhs.tw.length > v_rhs.tw.length)))));
+                         });
+      v_rank = *chosen_vehicle;
+      vehicles_ranks.erase(chosen_vehicle);
+    }
 
     // Once current vehicle is decided, regrets[j] holds the min cost
     // of picking the job in an empty route for other remaining
@@ -915,19 +965,19 @@ template <class T> T initial_routes(const Input& input) {
 using RawSolution = std::vector<RawRoute>;
 using TWSolution = std::vector<TWRoute>;
 
-template RawSolution basic(const Input& input, INIT init, double lambda);
+template RawSolution
+basic(const Input& input, INIT init, double lambda, SORT sort);
 
-template RawSolution dynamic_vehicle_choice(const Input& input,
-                                            INIT init,
-                                            double lambda);
+template RawSolution
+dynamic_vehicle_choice(const Input& input, INIT init, double lambda, SORT sort);
 
 template RawSolution initial_routes(const Input& input);
 
-template TWSolution basic(const Input& input, INIT init, double lambda);
+template TWSolution
+basic(const Input& input, INIT init, double lambda, SORT sort);
 
-template TWSolution dynamic_vehicle_choice(const Input& input,
-                                           INIT init,
-                                           double lambda);
+template TWSolution
+dynamic_vehicle_choice(const Input& input, INIT init, double lambda, SORT sort);
 
 template TWSolution initial_routes(const Input& input);
 

src/algorithms/heuristics/heuristics.h

@@ -16,11 +16,15 @@ namespace vroom {
 namespace heuristics {
 
 // Implementation of a variant of the Solomon I1 heuristic.
-template <class T> T basic(const Input& input, INIT init, double lambda);
+template <class T>
+T basic(const Input& input, INIT init, double lambda, SORT sort);
 
 // Adjusting the above for situation with heterogeneous fleet.
 template <class T>
-T dynamic_vehicle_choice(const Input& input, INIT init, double lambda);
+T dynamic_vehicle_choice(const Input& input,
+                         INIT init,
+                         double lambda,
+                         SORT sort);
 
 // Populate routes with user-defined vehicle steps.
 template <class T> T initial_routes(const Input& input);