def _build_route_3(cls, vehicle: jit.Vehicle,
surface: jit.Surface) -> jit.Route:
route = jit.Route(vehicle)
trip = jit.Trip(
identifier="TEST_3",
origin=jit.Service(
position=surface.get_or_create_position([0, 0]),
earliest=1.0,
latest=20.0,
),
destination=jit.Service(position=surface.get_or_create_position(
[10, 10]), ),
timeout=1.0,
)
pickup_stop = jit.Stop(vehicle, surface.get_or_create_position([0, 0]),
route.current_stop)
delivery_stop = jit.Stop(vehicle,
surface.get_or_create_position([10, 10]),
pickup_stop)
planned_trip = jit.PlannedTrip(
vehicle=vehicle,
trip=trip,
pickup=pickup_stop,
delivery=delivery_stop,
)
route.append_planned_trip(planned_trip)
return route
def setUp(self) -> None:
self.vehicle = generate_one_vehicle()
self.position = generate_one_position()
stop0 = jit.Stop(self.vehicle, self.position, None)
stop1 = jit.Stop(self.vehicle, generate_one_position(), stop0)
stop0.following = stop1
stop2 = jit.Stop(self.vehicle, generate_one_position(), stop1)
stop1.following = stop2
stop3 = jit.Stop(self.vehicle, generate_one_position(), stop2)
stop2.following = stop3
stop4 = jit.Stop(self.vehicle, generate_one_position(), stop3)
stop3.following = stop4
stops = [stop0, stop1, stop2, stop3, stop4]
self.stops = stops
self.route = jit.Route(self.vehicle, self.stops)
self.planning = jit.Planning({self.route})
self.job = jit.Job(generate_trips(10), objective_cls=jit.DialARideObjective)
self.fleet = jit.Fleet(generate_vehicles(10))
self.algorithm = jit.NaiveAlgorithm(self.fleet, self.job)
self.result = jit.Result(self.algorithm, self.planning, computation_time=float(0.0))
def setUpClass(cls) -> None:
surface = jit.GeometricSurface(jit.DistanceMetric.MANHATTAN)
origin = jit.Service(surface.get_or_create_position([0, 0]))
vehicle = jit.Vehicle(
identifier="TEST",
origin=origin,
)
fleet = jit.Fleet({vehicle})
trips = [
jit.Trip(
identifier="TEST_1",
origin=jit.Service(
position=surface.get_or_create_position([0, 0]),
earliest=0.0,
latest=10.0,
),
destination=jit.Service(
position=surface.get_or_create_position([1, 1]), ),
),
jit.Trip(
identifier="TEST_2",
origin=jit.Service(
position=surface.get_or_create_position([1, 1]),
earliest=0.0,
latest=20.0,
),
destination=jit.Service(
position=surface.get_or_create_position([10, 10]), ),
),
]
job = jit.Job(set(trips), jit.DialARideObjective)
route = jit.Route(vehicle)
pickup_stop = jit.Stop(vehicle, surface.get_or_create_position([0, 0]),
route.current_stop)
delivery_stop = jit.Stop(vehicle,
surface.get_or_create_position([1, 1]),
pickup_stop)
cls.planned_trip = jit.PlannedTrip(
vehicle=vehicle,
trip=trips[0],
pickup=pickup_stop,
delivery=delivery_stop,
)
route.append_planned_trip(cls.planned_trip)
cls.stop = route.stops[1]
conjecture = jit.TailInsertionStrategy()
cls.route = conjecture.compute(route, trips[1])[0]
cls.planning = jit.Planning({cls.route})
cls.algorithm = jit.NaiveAlgorithm(fleet, job)
cls.result = jit.Result(cls.algorithm, cls.planning, 0.0)
def generate_one_planned_trip(
feasible: bool,
vehicle: jit.Vehicle = None,
previous_stop: jit.Stop = None,
pickup_stop: jit.Stop = None,
delivery_stop: jit.Stop = None,
origin_position: jit.Position = None,
destination_position: jit.Position = None,
*args,
**kwargs,
) -> jit.PlannedTrip:
if vehicle is None:
vehicle = generate_one_vehicle()
if previous_stop is None:
previous_stop = jit.Stop(vehicle, vehicle.origin_position,
previous_stop)
if feasible:
kwargs["earliest"] = 0.0
kwargs["timeout"] = float("inf")
kwargs["capacity"] = vehicle.capacity
else:
previous_stop.starting_time = jit.MAX_FLOAT
if origin_position is None:
origin_position = generate_one_position()
if destination_position is None:
destination_position = generate_one_position()
if pickup_stop is None:
pickup_stop = jit.Stop(vehicle, origin_position, previous_stop)
else:
origin_position = pickup_stop.position
if delivery_stop is None:
delivery_stop = jit.Stop(vehicle, destination_position, pickup_stop)
else:
destination_position = delivery_stop.position
trip = generate_one_trip(
origin_position=origin_position,
destination_position=destination_position,
*args,
**kwargs,
)
return jit.PlannedTrip(
vehicle=vehicle,
trip=trip,
pickup=pickup_stop,
delivery=delivery_stop,
)
def test_with_planned_trip(self):
stop = jit.Stop(self.vehicle, self.position, self.stops[0])
delivery_planned_trip = generate_one_planned_trip(
feasible=True,
vehicle=self.vehicle,
pickup_stop=self.stops[0],
delivery_stop=stop,
)
pickup_planned_trip = generate_one_planned_trip(
feasible=True,
vehicle=self.vehicle,
pickup_stop=stop,
)
self.assertIn(delivery_planned_trip, stop.delivery_planned_trips)
self.assertNotIn(delivery_planned_trip, stop.pickup_planned_trips)
self.assertNotIn(pickup_planned_trip, stop.delivery_planned_trips)
self.assertIn(pickup_planned_trip, stop.pickup_planned_trips)
self.assertIsInstance(stop.identifier, str)
iterable = it.chain(
(f'P{planned_trip.trip_identifier}' for planned_trip in stop.pickup_planned_trips),
(f'D{planned_trip.trip_identifier}' for planned_trip in stop.delivery_planned_trips),
)
identifier = '|'.join(iterable)
identifier = f'[{identifier}]'
self.assertEqual(identifier, stop.identifier)
def setUp(self) -> None:
stop0 = jit.Stop(self.vehicle, self.position, None)
stop1 = jit.Stop(self.vehicle, generate_one_position(), stop0)
stop0.following = stop1
stop2 = jit.Stop(self.vehicle, generate_one_position(), stop1)
stop1.following = stop2
stop3 = jit.Stop(self.vehicle, generate_one_position(), stop2)
stop2.following = stop3
stop4 = jit.Stop(self.vehicle, generate_one_position(), stop3)
stop3.following = stop4
stops = [stop0, stop1, stop2, stop3, stop4]
self.stops = stops
def test_creation_with_previous(self):
previous_position = generate_one_position()
previous_stop = jit.Stop(self.vehicle, previous_position, None)
stop = jit.Stop(self.vehicle, self.position, previous_stop)
previous_stop.following = stop
self.assertEqual(previous_stop.following, stop)
self.assertEqual(self.vehicle, stop.vehicle)
self.assertEqual(self.position, stop.position)
self.assertEqual(previous_stop, stop.previous)
self.assertEqual(stop.position.distance_to(previous_stop.position), stop.distance)
self.assertEqual(previous_stop.position, stop.previous_position)
self.assertEqual(previous_stop.departure_time, stop.previous_departure_time)
self.assertEqual(
stop.position.time_to(previous_stop.position, stop.previous_departure_time),
stop.transit_time,
)
def test_flush(self):
stop = jit.Stop(self.vehicle, self.position, None)
self.assertNotIn('arrival_time', stop.__dict__)
self.assertNotIn('departure_time', stop.__dict__)
self.assertIsInstance(stop.departure_time, float)
self.assertIn('arrival_time', stop.__dict__)
self.assertIn('departure_time', stop.__dict__)
stop.flush()
self.assertNotIn('arrival_time', stop.__dict__)
self.assertNotIn('departure_time', stop.__dict__)
def test_creation(self):
stop = jit.Stop(self.vehicle, self.position, None)
self.assertNotIn('arrival_time', stop.__dict__)
self.assertNotIn('departure_time', stop.__dict__)
self.assertEqual(self.vehicle, stop.vehicle)
self.assertEqual(self.position, stop.position)
self.assertIsNone(stop.previous)
self.assertEqual(self.vehicle.origin_position, stop.previous_position)
self.assertEqual(self.vehicle.origin_earliest, stop.previous_departure_time)
self.assertEqual(
stop.position.time_to(self.vehicle.origin_position, stop.previous_departure_time),
stop.transit_time,
)
self.assertEqual(0, stop.waiting_time)
self.assertEqual(0, stop.load_time)
self.assertEqual(0, len(tuple(stop.planned_trips)))
self.assertEqual(0, len(tuple(stop.trips)))
