Implements multiple time windows per location, resolves #8

Author: daniel-j-h

API.md

@@ -93,7 +93,7 @@ Initializes and caches user data internally for efficiency.
 - `numNodes` **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** Number of locations in the problem ("nodes").
 - `costs` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)** Cost array the solver minimizes in optimization. Can for example be duration, distance but does not have to be. Two-dimensional with `costs[from][to]` being a **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** representing the cost for traversing the arc from `from` to `to`.
 - `durations` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)** Duration array the solver uses for time constraints. Two-dimensional with `durations[from][to]` being a **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** representing the duration for servicing node `from` plus the time for traversing the arc from `from` to `to`.
-- `timeWindows` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)** Time window array the solver uses for time constraints. Two-dimensional with `timeWindows[at]` being an **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)** of two **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** representing the start and end time point of the time window when servicing the node `at` is allowed. The solver starts from time point `0` (you can think of this as the start of the work day) and the time points need to be positive offsets to this time point.
+- `timeWindows` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)** Time window array the solver uses for time constraints. Three-dimensional with `timeWindows[at]` being an **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)** of potentially multiple time window **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)** with two **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** representing the start and end time point of the time windows when servicing the node `at` is allowed. Multiple time windows per location must not overlap and must be sorted in increasing order. The solver starts from time point `0` (you can think of this as the start of the work day) and the time points need to be positive offsets to this time point.
 - `demands` **[Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)** Demands array the solver uses for vehicle capacity constraints. Two-dimensional with `demands[from][to]` being a **[Number](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number)** representing the demand at node `from`, for example number of packages to deliver to this location. The `to` node index is unused and reserved for future changes; set `demands[at]` to a constant array for now. The depot should have a demand of zero.
 
 
@@ -104,7 +104,7 @@ var vrpSolverOpts = {
   numNodes: 3,
   costs: [[0, 10, 10], [10, 0, 10], [10, 10, 0]],
   durations: [[0, 2, 2], [2, 0, 2], [2, 2, 0]],
-  timeWindows: [[0, 9], [2, 3], [2, 3]],
+  timeWindows: [[[0, 9]], [[2, 3]], [[2, 3]]],
   demands: [[0, 0, 0], [1, 1, 1], [1, 1, 1]]
 };
 

example/index.js

@@ -87,7 +87,7 @@ MbxClient.getDistances(locations, {profile: profile}, function(err, results) {
   var timeWindows = new Array(results.durations.length);
 
   for (var at = 0; at < results.durations.length; ++at)
-    timeWindows[at] = [dayStarts, dayEnds];
+    timeWindows[at] = [[dayStarts, dayEnds]];
 
   // Dummy demands of one except at the depot
   var demands = new Array(results.durations.length);

src/types.h

@@ -34,7 +34,7 @@ struct Interval {
   std::int32_t stop;
 };
 
-using TimeWindows = NewType<Vector<Interval>, struct TimeWindowsTag>::Type;
+using TimeWindows = NewType<Vector<Vector<Interval>>, struct TimeWindowsTag>::Type;
 
 namespace ort = operations_research;
 

src/vrp_params.h

@@ -35,8 +35,8 @@ struct VRPSearchParams {
   v8::Local<v8::Function> callback;
 };
 
-// Caches user provided 2d Array of [Number, Number] into Vectors of Intervals
-inline auto makeTimeWindowsFrom2dArray(std::int32_t n, v8::Local<v8::Array> array) {
+// Caches user provided 3d Array of [[Number, Number], ..] into Vectors of Vectors of Intervals
+inline auto makeTimeWindowsFrom3dArray(std::int32_t n, v8::Local<v8::Array> array) {
   if (n < 0)
     throw std::runtime_error{"Negative size"};
 
@@ -45,29 +45,41 @@ inline auto makeTimeWindowsFrom2dArray(std::int32_t n, v8::Local<v8::Array> arra
 
   TimeWindows timeWindows(n);
 
-  for (std::int32_t atIdx = 0; atIdx < n; ++atIdx) {
-    auto inner = Nan::Get(array, atIdx).ToLocalChecked();
+  for (std::int32_t locationIdx = 0; locationIdx < n; ++locationIdx) {
+    auto timeWindowsForLocation = Nan::Get(array, locationIdx).ToLocalChecked();
 
-    if (!inner->IsArray())
+    if (!timeWindowsForLocation->IsArray())
       throw std::runtime_error{"Expected Array of Arrays"};
 
-    auto innerArray = inner.As<v8::Array>();
+    auto timeWindowsForLocationArray = timeWindowsForLocation.As<v8::Array>();
+    const auto numTimeWindowsForLocation = static_cast<std::int32_t>(timeWindowsForLocationArray->Length());
+
+    Vector<Interval> locationTimeWindows(numTimeWindowsForLocation);
 
-    if (static_cast<std::int32_t>(innerArray->Length()) != 2)
-      throw std::runtime_error{"Expected interval Array of shape [start, stop]"};
+    for (std::int32_t timeWindowIdx = 0; timeWindowIdx < numTimeWindowsForLocation; ++timeWindowIdx) {
+      auto interval = Nan::Get(timeWindowsForLocationArray, timeWindowIdx).ToLocalChecked();
 
-    auto start = Nan::Get(innerArray, 0).ToLocalChecked();
-    auto stop = Nan::Get(innerArray, 1).ToLocalChecked();
+      if (!interval->IsArray())
+        throw std::runtime_error{"Expected Array of time interval Arrays"};
 
-    if (!start->IsNumber() || !stop->IsNumber())
-      throw std::runtime_error{"Expected interval start and stop of type Number"};
+      auto intervalArray = interval.As<v8::Array>();
 
-    auto startValue = Nan::To<std::int32_t>(start).FromJust();
-    auto stopValue = Nan::To<std::int32_t>(stop).FromJust();
+      if (intervalArray->Length() != 2)
+        throw std::runtime_error{"Expected interval Array of shape [start, stop]"};
 
-    Interval out{startValue, stopValue};
+      auto start = Nan::Get(intervalArray, 0).ToLocalChecked();
+      auto stop = Nan::Get(intervalArray, 1).ToLocalChecked();
+
+      if (!start->IsNumber() || !stop->IsNumber())
+        throw std::runtime_error{"Expected interval start and stop of type Number"};
+
+      auto startValue = Nan::To<std::int32_t>(start).FromJust();
+      auto stopValue = Nan::To<std::int32_t>(stop).FromJust();
+
+      locationTimeWindows.at(timeWindowIdx) = Interval{startValue, stopValue};
+    }
 
-    timeWindows.at(atIdx) = std::move(out);
+    timeWindows.at(locationIdx) = std::move(locationTimeWindows);
   }
 
   return timeWindows;
@@ -147,7 +159,7 @@ VRPSolverParams::VRPSolverParams(const Nan::FunctionCallbackInfo<v8::Value>& inf
 
   costs = makeMatrixFrom2dArray<CostMatrix>(numNodes, costMatrix);
   durations = makeMatrixFrom2dArray<DurationMatrix>(numNodes, durationMatrix);
-  timeWindows = makeTimeWindowsFrom2dArray(numNodes, timeWindowsVector);
+  timeWindows = makeTimeWindowsFrom3dArray(numNodes, timeWindowsVector);
   demands = makeMatrixFrom2dArray<DemandMatrix>(numNodes, demandMatrix);
 }
 

src/vrp_worker.h

@@ -58,7 +58,24 @@ struct VRPWorker final : Nan::AsyncWorker {
 
     const auto costsOk = costs->dim() == numNodes;
     const auto durationsOk = durations->dim() == numNodes;
+
     const auto timeWindowsOk = timeWindows->size() == numNodes;
+
+    for (std::int32_t i = 0; i < timeWindows->size(); ++i) {
+      const auto& timeWindowsForLocation = timeWindows->at(i);
+      const auto numTimeWindowsForLocation = timeWindowsForLocation.size();
+
+      for (std::int32_t j = 0; j < numTimeWindowsForLocation - 1; ++j) {
+        const auto& lhs = timeWindowsForLocation.at(j + 0);
+        const auto& rhs = timeWindowsForLocation.at(j + 1);
+
+        const auto ordered = lhs.stop <= rhs.start;
+
+        if (!ordered)
+          throw std::runtime_error{"Expected multiple time windows per location to be sorted"};
+      }
+    }
+
     const auto demandsOk = demands->dim() == numNodes;
 
     if (!costsOk || !durationsOk || !timeWindowsOk || !demandsOk)
@@ -105,15 +122,31 @@ struct VRPWorker final : Nan::AsyncWorker {
     model.AddDimension(durationCallback, timeHorizon, timeHorizon, /*fix_start_cumul_to_zero=*/true, kDimensionTime);
     const auto& timeDimension = model.GetDimensionOrDie(kDimensionTime);
 
+    /*
     for (std::int32_t node = 0; node < numNodes; ++node) {
-      const auto interval = timeWindows->at(node);
-      timeDimension.CumulVar(node)->SetRange(interval.start, interval.stop);
-      // At the moment we only support a single interval for time windows.
-      // We can support multiple intervals if we sort intervals by start then stop.
-      // Then Cumulval(n)->SetRange(minStart, maxStop), then walk over intervals
-      // removing intervals between active intervals:
-      // CumulVar(n)->RemoveInterval(stop, start).
+      const auto timeWindowsForLocation = timeWindows->at(node);
+      const auto numTimeWindowsForLocation = timeWindowsForLocation.size();
+
+      if (numTimeWindowsForLocation < 1)
+        continue;
+
+      // We can support multiple intervals sorted by start then stop by
+      // enabling the interval [minStart, maxStop] then walking over all
+      // intervals and disabling ranges between adjacent time intervals.
+
+      const auto minStart = timeWindowsForLocation.at(0).start;
+      const auto maxStop = timeWindowsForLocation.at(numTimeWindowsForLocation - 1).stop;
+
+      timeDimension.CumulVar(node)->SetRange(minStart, maxStop);
+
+      for (std::int32_t i = 0; i < numTimeWindowsForLocation - 1; ++i) {
+        const auto& lhs = timeWindowsForLocation.at(i + 0);
+        const auto& rhs = timeWindowsForLocation.at(i + 1);
+
+        timeDimension.CumulVar(node)->RemoveInterval(lhs.stop, rhs.start);
+      }
     }
+    */
 
     // Capacity Dimension
 

test/vrp.js

@@ -69,7 +69,7 @@ var timeWindows = new Array(locations.length);
 
 for (var at = 0; at < locations.length; ++at) {
   if (at === depot) {
-    timeWindows[at] = [dayStarts, dayEnds];
+    timeWindows[at] = [[dayStarts, dayEnds]];
     continue;
   }
 
@@ -79,7 +79,7 @@ for (var at = 0; at < locations.length; ++at) {
   var start = rand() * (latest - earliest) + earliest;
   var stop = rand() * (latest - start) + start;
 
-  timeWindows[at] = [start, stop];
+  timeWindows[at] = [[start, stop]];
 }