Method VehicleType

pyvrp/cpp/ProblemData.cpp:284–373

}

ProblemData::VehicleType::VehicleType(size_t numAvailable,
                                      std::vector<Load> capacity,
                                      size_t startDepot,
                                      size_t endDepot,
                                      Cost fixedCost,
                                      Duration twEarly,
                                      Duration twLate,
                                      Duration shiftDuration,
                                      Distance maxDistance,
                                      Cost unitDistanceCost,
                                      Cost unitDurationCost,
                                      size_t profile,
                                      std::optional<Duration> startLate,
                                      std::vector<Load> initialLoad,
                                      std::vector<size_t> reloadDepots,
                                      size_t maxReloads,
                                      Duration maxOvertime,
                                      Cost unitOvertimeCost,
                                      std::string name)
    : numAvailable(numAvailable),
      startDepot(startDepot),
      endDepot(endDepot),
      capacity(pad(capacity, initialLoad)),
      twEarly(twEarly),
      twLate(twLate),
      shiftDuration(shiftDuration),
      maxDistance(maxDistance),
      fixedCost(fixedCost),
      unitDistanceCost(unitDistanceCost),
      unitDurationCost(unitDurationCost),
      profile(profile),
      startLate(startLate.value_or(twLate)),
      initialLoad(pad(initialLoad, capacity)),
      reloadDepots(reloadDepots),
      maxReloads(maxReloads),
      maxOvertime(maxOvertime),
      unitOvertimeCost(unitOvertimeCost),
      // We need to check >= 0 here to avoid overflow. If the arguments are
      // negative the validation checks further below will raise, so it doesn't
      // matter what we set as long as we get to those checks.
      maxDuration(shiftDuration >= 0 && maxOvertime >= 0
                          && maxOvertime < std::numeric_limits<Duration>::max()
                                               - shiftDuration
                      ? shiftDuration + maxOvertime
                      : std::numeric_limits<Duration>::max()),
      name(duplicate(name.data()))
{
    if (numAvailable == 0)
        throw std::invalid_argument("num_available must be > 0.");

    if (std::any_of(capacity.begin(), capacity.end(), isNegative<Load>))
        throw std::invalid_argument("capacity amounts must be >= 0.");

    if (twEarly > this->startLate)
        throw std::invalid_argument("tw_early must be <= start_late.");

    if (this->startLate > twLate)
        throw std::invalid_argument("start_late must be <= tw_late.");