Reset base to working commit

Author: SimonBradley1993

CHANGELOG.md

@@ -6,12 +6,13 @@
 
 #### Features
 
-- Ability to set different tasks setup/service time per vehicle type (#336)
+- Ability to set different task times per vehicle type (#336)
+- Task times can be included in the cost used internally for optimization (#1130)
+- Support for cost per hour spent on tasks on a vehicle basis (#1130)
 
 #### Internals
 
 - Apply heuristics to partial solutions provided in input (#977)
-- LOG_LS flag to generate debug info on the internal solving process (#1124)
 
 ### Changed
 
@@ -31,6 +32,10 @@
 - Remove heuristic synchronisation (#1188)
 - Refactor gain evaluation in operators to ease code maintenance and extension (#1266)
 - Remove `LOG_LS_OPERATORS` (#1263)
+- Update README to clarify high-level purpose and usage of the project (#1264)
+- Remove unused `breaks_travel_margin` members from TWRoute and associated code (#1295)
+- Run routing requests in parallel (#1218)
+- Refactor parallel solving (#1305)
 
 #### CI
 
@@ -44,6 +49,7 @@
 #### Dependency
 
 - Update `LibosrmWrapper` to breaking change introduced in OSRM v6 (#1234)
+- Update `asio` usage for deprecated `io_service` and `query` (#1279)
 
 ### Fixed
 
@@ -60,6 +66,9 @@
 - Solution "shadowing" when only comparing indicators (#1199)
 - Too loose `max_tasks` bound derived from TW (#1243)
 - Wrong evaluation in `ReverseTwoOpt` (#1271)
+- Misleading error with custom distance matrix (#1281)
+- Wrong distance-based optimization with only custom durations (#1298)
+- Break positioning heuristic shortcoming (#1251)
 
 #### Internals
 

README.md

@@ -1,23 +1,46 @@
-# Vehicle Routing Open-source Optimization Machine
+# Complex Route Optimization in Milliseconds
 
 _Good solutions, fast._
 
 ---
 
 ## About
 
-VROOM is an open-source optimization engine written in C++20 that aim
-at providing good solutions to various real-life [vehicle routing
+Vroom is an open-source route optimization engine written in C++20
+that solves complex [vehicle routing
 problems](https://en.wikipedia.org/wiki/Vehicle_routing_problem) (VRP)
-within a small computing time.
-
-The project has been initiated by [Verso](https://verso-optim.com/) to
-power its [route optimization
-API](https://blog.verso-optim.com/category/route-optimization/api/).
+in milliseconds.
+
+The project is maintained by [Verso](https://verso-optim.com). If you
+want to get started as quickly as possible with route optimization,
+you want white-glove support to increase the ROI from your
+optimization project and/or you need access to the best possible data
+for even more accurate route timing, you should use the [Vroom Premium
+API](https://verso-optim.com/api/).
+
+## Why use Vroom?
+
+Vroom is ideally suited to situations in which route optimization has
+to be done quickly, both to react to changes and new requests and to
+iterate on your routes to find the solution that works best for all
+stakeholders.
+
+Vroom doesn't replace domain expertise. It allows fleet managers and
+business owners to apply their domain knowledge and understanding of
+the company culture to larger, more complex optimization problems than
+they could manage manually.
+
+The open source project is ideal for companies who want to control
+their own infrastructure, have the technical expertise to do so and
+can manage their own data integration. If you would rather not manage
+your own infrastructure, if you want access to expertise around route
+optimization or if you want more accurate ETA relying on enhanced
+speed estimates, consider using the [Vroom Premium
+API](https://verso-optim.com/api/).
 
 ## Supported problem types
 
-VROOM can solve several well-known types of vehicle routing problems
+Vroom solves several well-known types of vehicle routing problems
 (VRP).
 
 - TSP (travelling salesman problem)
@@ -26,11 +49,13 @@ VROOM can solve several well-known types of vehicle routing problems
 - MDHVRPTW (multi-depot heterogeneous vehicle VRPTW)
 - PDPTW (pickup-and-delivery problem with TW)
 
-VROOM can also solve any mix of the above problem types.
+Vroom solves all of the above routing problems at the same time — and
+delivers the optimized route in milliseconds, even when complex
+variables are involved.
 
-## Features
+## How it works
 
-VROOM models a VRP with a description of resources (`vehicles`),
+Vroom models a VRP with a description of resources (`vehicles`),
 single-location pickup and/or delivery tasks (`jobs`) and
 pickup-and-delivery tasks that should happen within the same route
 (`shipments`).
@@ -55,14 +80,14 @@ pickup-and-delivery tasks that should happen within the same route
 
 ## Supported routing engines
 
-VROOM works out-of-the-box on top of several open-source routing
+Vroom works out-of-the-box on top of several open-source routing
 engines.
 
 - [OSRM](http://project-osrm.org/)
 - [Openrouteservice](https://openrouteservice.org/)
 - [Valhalla](https://github.com/valhalla/valhalla)
 
-VROOM can also use a custom cost matrix computed from any other
+Vroom can also use a custom cost matrix computed from any other
 source.
 
 ## Getting started
@@ -72,54 +97,54 @@ source.
 - The [demo frontend](http://map.vroom-project.org/) provides a simple
 user interface for quick tests.
 - The [demo
-server](https://github.com/VROOM-Project/vroom/wiki/Demo-server) makes
+server](https://github.com/Vroom-Project/vroom/wiki/Demo-server) makes
 it easy to send sample optimization requests for testing purposes.
 
-### Setup your own VROOM stack
+### Setup your own Vroom stack
 
 #### Solving engine
 
 Several options are available to get `vroom` running on command-line.
 
 1. Build from source following [the wiki
-instructions](https://github.com/VROOM-Project/vroom/wiki/Building).
+instructions](https://github.com/Vroom-Project/vroom/wiki/Building).
 2. Use
-[`vroom-docker`](https://github.com/VROOM-Project/vroom-docker).
+[`vroom-docker`](https://github.com/Vroom-Project/vroom-docker).
 
 ### Command-line usage
 
 Refer to [this wiki
-page](https://github.com/VROOM-Project/vroom/wiki/Usage)
+page](https://github.com/Vroom-Project/vroom/wiki/Usage)
 
 #### Http wrapper
 
-[`vroom-express`](https://github.com/VROOM-Project/vroom-express) is a
+[`vroom-express`](https://github.com/Vroom-Project/vroom-express) is a
 simple wrapper to use `vroom` with http requests. It's already bundled
 in the `vroom-docker` setup.
 
 #### Using libvroom from C++
 
 The project can also used as a library from any C++ project, refer to
 [this wiki
-page](https://github.com/VROOM-Project/vroom/wiki/Using-libvroom).
+page](https://github.com/Vroom-Project/vroom/wiki/Using-libvroom).
 
 ## Tests
 
 ### CI builds
 
-[![vroom](https://github.com/VROOM-Project/vroom/actions/workflows/vroom.yml/badge.svg)](https://github.com/VROOM-Project/vroom/actions/workflows/vroom.yml)
+[![vroom](https://github.com/Vroom-Project/vroom/actions/workflows/vroom.yml/badge.svg)](https://github.com/Vroom-Project/vroom/actions/workflows/vroom.yml)
 
-[![vroom + libosrm](https://github.com/VROOM-Project/vroom/actions/workflows/vroom_libosrm.yml/badge.svg?branch=master)](https://github.com/VROOM-Project/vroom/actions/workflows/vroom_libosrm.yml)
+[![vroom + libosrm](https://github.com/Vroom-Project/vroom/actions/workflows/vroom_libosrm.yml/badge.svg?branch=master)](https://github.com/Vroom-Project/vroom/actions/workflows/vroom_libosrm.yml)
 
-[Github Actions](https://github.com/VROOM-Project/vroom/actions) are
+[Github Actions](https://github.com/Vroom-Project/vroom/actions) are
 used to check the build across various compilers and settings.
 
 ### Functional tests
 
 Several sets of instances are used.
 
 1. Benchmark instances from papers (see [wiki page with
-results](https://github.com/VROOM-Project/vroom/wiki/Benchmarks)).
+results](https://github.com/Vroom-Project/vroom/wiki/Benchmarks)).
 2. Custom random instances generated to target typical use-cases and
 constraints settings.
 3. Real-life instances.
@@ -131,11 +156,11 @@ solution quality and computing times.
 
 ## Reference in publications
 
-To cite VROOM in publications, please use:
+To cite Vroom in publications, please use:
 
 ```bibtex
 @manual{vroom_v1.14,
-   title = {{VROOM v1.14, Vehicle Routing Open-source Optimization Machine}},
+   title = {{Vroom v1.14, Vehicle Routing Open-source Optimization Machine}},
    author = {Coupey, Julien and Nicod, Jean-Marc and Varnier, Christophe},
    year = 2024,
    organization = {Verso (\url{https://verso-optim.com/})},

docs/API.md

@@ -132,6 +132,7 @@ A `cost` object has the following properties:
 | ----------- | ----------- |
 | [`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`) |
+| [`per_task_hour`] | integer defining the cost for one hour of task time (setup + service) with this vehicle (defaults to `0`) |
 | [`per_km`] | integer defining the cost for one km of travel time with this vehicle (defaults to `0`) |
 
 Using a non-default `per-hour` value means defining travel costs based
@@ -310,12 +311,14 @@ integers filed under the `profile` key, then under:
 
 - `durations` for a custom travel-time matrix that will be used for
   all checks against timing constraints;
-- `distances` for a custom distance matrix;
+- `distances` for a custom distance matrix (requires also providing
+  custom `durations`);
 - `costs` for a custom cost matrix that will be used within all route
   cost evaluations.
 
-If only the `durations` matrix is provided, internal costs are derived from
-durations based on vehicles `costs` properties.
+If `durations` are provided without `distances` and distances are
+required (either by `-g` or a non-zero `per_km` cost), then a call to
+the routing engine is generated to fetch distances.
 
 Example of describing different matrices for different vehicle
 profiles:

src/algorithms/heuristics/heuristics.cpp

@@ -153,31 +153,38 @@ template <class Route> struct UnassignedCosts {
       min_unassigned_to_route(input.jobs.size(),
                               std::numeric_limits<Cost>::max()) {
     for (const auto job_rank : unassigned) {
-      const auto unassigned_job_index = input.jobs[job_rank].index();
+      const auto& unassigned_job = input.jobs[job_rank];
+      const auto unassigned_job_index = unassigned_job.index();
+
+      // The purpose here is to generate insertion lower bounds so we
+      // only account for service times (no setup) which are
+      // independent of insertion rank.
+      const auto added_service = unassigned_job.services[vehicle.type];
+      const auto service_cost = vehicle.task_eval(added_service).cost;
 
       if (vehicle.has_start()) {
         const auto start_to_job =
           vehicle.eval(vehicle.start.value().index(), unassigned_job_index)
             .cost;
-        min_route_to_unassigned[job_rank] = start_to_job;
+        min_route_to_unassigned[job_rank] = start_to_job + service_cost;
       }
 
       if (vehicle.has_end()) {
         const auto job_to_end =
           vehicle.eval(unassigned_job_index, vehicle.end.value().index()).cost;
-        min_unassigned_to_route[job_rank] = job_to_end;
+        min_unassigned_to_route[job_rank] = job_to_end + service_cost;
       }
 
       for (const auto j : route.route) {
         const auto job_index = input.jobs[j].index();
 
         const auto job_to_unassigned =
-          vehicle.eval(job_index, unassigned_job_index).cost;
+          vehicle.eval(job_index, unassigned_job_index).cost + service_cost;
         min_route_to_unassigned[job_rank] =
           std::min(min_route_to_unassigned[job_rank], job_to_unassigned);
 
         const auto unassigned_to_job =
-          vehicle.eval(unassigned_job_index, job_index).cost;
+          vehicle.eval(unassigned_job_index, job_index).cost + service_cost;
         min_unassigned_to_route[job_rank] =
           std::min(min_unassigned_to_route[job_rank], unassigned_to_job);
       }
@@ -215,15 +222,19 @@ template <class Route> struct UnassignedCosts {
                         const std::set<Index>& unassigned,
                         Index inserted_index) {
     for (const auto j : unassigned) {
-      const auto unassigned_job_index = input.jobs[j].index();
+      const auto& unassigned_job = input.jobs[j];
+      const auto unassigned_job_index = unassigned_job.index();
+
+      const auto added_service = unassigned_job.services[vehicle.type];
+      const auto service_cost = vehicle.task_eval(added_service).cost;
 
       const auto to_unassigned =
-        vehicle.eval(inserted_index, unassigned_job_index).cost;
+        vehicle.eval(inserted_index, unassigned_job_index).cost + service_cost;
       min_route_to_unassigned[j] =
         std::min(min_route_to_unassigned[j], to_unassigned);
 
       const auto from_unassigned =
-        vehicle.eval(unassigned_job_index, inserted_index).cost;
+        vehicle.eval(unassigned_job_index, inserted_index).cost + service_cost;
       min_unassigned_to_route[j] =
         std::min(min_unassigned_to_route[j], from_unassigned);
     }
@@ -279,7 +290,7 @@ inline Eval fill_route(const Input& input,
 
         for (Index r = 0; r <= route.size(); ++r) {
           const auto current_eval =
-            utils::addition_cost(input, job_rank, vehicle, route.route, r);
+            utils::addition_eval(input, job_rank, vehicle, route.route, r);
 
           const double current_cost =
             static_cast<double>(current_eval.cost) -
@@ -317,7 +328,7 @@ inline Eval fill_route(const Input& input,
           route.route.size() + 1);
 
         for (unsigned d_rank = 0; d_rank <= route.route.size(); ++d_rank) {
-          d_adds[d_rank] = utils::addition_cost(input,
+          d_adds[d_rank] = utils::addition_eval(input,
                                                 job_rank + 1,
                                                 vehicle,
                                                 route.route,
@@ -329,7 +340,7 @@ inline Eval fill_route(const Input& input,
         }
 
         for (Index pickup_r = 0; pickup_r <= route.size(); ++pickup_r) {
-          const auto p_add = utils::addition_cost(input,
+          const auto p_add = utils::addition_eval(input,
                                                   job_rank,
                                                   vehicle,
                                                   route.route,
@@ -370,7 +381,7 @@ inline Eval fill_route(const Input& input,
 
             Eval current_eval;
             if (pickup_r == delivery_r) {
-              current_eval = utils::addition_cost(input,
+              current_eval = utils::addition_eval(input,
                                                   job_rank,
                                                   vehicle,
                                                   route.route,

src/algorithms/local_search/insertion_search.h

@@ -44,7 +44,7 @@ compute_best_insertion_single(const Input& input,
          rank < sol_state.insertion_ranks_end[v][j];
          ++rank) {
       const Eval current_eval =
-        utils::addition_cost(input, j, v_target, route.route, rank);
+        utils::addition_eval(input, j, v_target, route.route, rank);
       if (current_eval.cost < result.eval.cost &&
           v_target.ok_for_range_bounds(sol_state.route_evals[v] +
                                        current_eval) &&
@@ -113,7 +113,7 @@ RouteInsertion compute_best_insertion_pd(const Input& input,
   bool found_valid = false;
   for (unsigned d_rank = begin_d_rank; d_rank < end_d_rank; ++d_rank) {
     d_adds[d_rank] =
-      utils::addition_cost(input, j + 1, v_target, route.route, d_rank);
+      utils::addition_eval(input, j + 1, v_target, route.route, d_rank);
     if (result.eval < d_adds[d_rank]) {
       valid_delivery_insertions[d_rank] = false;
     } else {
@@ -132,7 +132,7 @@ RouteInsertion compute_best_insertion_pd(const Input& input,
        pickup_r < sol_state.insertion_ranks_end[v][j];
        ++pickup_r) {
     const Eval p_add =
-      utils::addition_cost(input, j, v_target, route.route, pickup_r);
+      utils::addition_eval(input, j, v_target, route.route, pickup_r);
     if (result.eval < p_add) {
       // Even without delivery insertion more expensive than current best.
       continue;
@@ -173,7 +173,7 @@ RouteInsertion compute_best_insertion_pd(const Input& input,
 
       Eval pd_eval;
       if (pickup_r == delivery_r) {
-        pd_eval = utils::addition_cost(input,
+        pd_eval = utils::addition_eval(input,
                                        j,
                                        v_target,
                                        route.route,