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 test_as_tuple(self):
vehicles = generate_vehicles(3)
fleet = jit.Fleet(vehicles)
expected = (('vehicle_identifiers',
tuple(vehicle.identifier for vehicle in vehicles)), )
self.assertEqual(expected, tuple(fleet))
def test_flush(self):
job = jit.Job(generate_trips(10), objective_cls=jit.DialARideObjective)
fleet = jit.Fleet(generate_vehicles(10))
dispatcher = jit.StatelessInsertionIterator(job=job, fleet=fleet,)
self.assertNotIn("iterator", dispatcher.__dict__)
list(dispatcher.iterator)
self.assertIn("iterator", dispatcher.__dict__)
dispatcher.flush()
self.assertNotIn("iterator", dispatcher.__dict__)
def test_creation(self):
job = jit.Job(generate_trips(10), objective_cls=jit.DialARideObjective)
fleet = jit.Fleet(generate_vehicles(10))
dispatcher = jit.StatelessInsertionIterator(
job=job, fleet=fleet, strategy_cls=partial(jit.TailInsertionStrategy, only_feasible=False)
)
self.assertEqual(job, dispatcher.job)
self.assertEqual(fleet, dispatcher.fleet)
self.assertEqual(len(job.trips), len(list(dispatcher.iterator)))
def setUpClass(cls) -> None:
cls.job = jit.Job(generate_trips(10),
objective_cls=jit.DialARideObjective)
cls.fleet = jit.Fleet(generate_vehicles(10))
algorithm = jit.InsertionAlgorithm(
job=cls.job,
fleet=cls.fleet,
)
cls.initial = algorithm.optimize()
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 test_flush(self):
job = jit.Job(generate_trips(10), objective_cls=jit.DialARideObjective)
fleet = jit.Fleet(generate_vehicles(10))
randomized_size = 2
dispatcher = jit.BestStatelessInsertionIterator(
randomized_size=randomized_size,
job=job,
fleet=fleet,
)
self.assertNotIn('iterator', dispatcher.__dict__)
list(dispatcher.iterator)
self.assertIn('iterator', dispatcher.__dict__)
dispatcher.flush()
self.assertNotIn('iterator', dispatcher.__dict__)
def test_creation(self):
surface = generate_one_surface()
job = jit.Job(
trips=generate_trips(10, surface=surface),
objective_cls=jit.DialARideObjective,
)
fleet = jit.Fleet(generate_vehicles(10, surface=surface))
randomized_size = 2
dispatcher = jit.RankingInsertionIterator(
randomized_size=randomized_size,
job=job,
fleet=fleet,
)
self.assertEqual(dispatcher.randomized_size, randomized_size)
self.assertEqual(dispatcher.job, job)
self.assertEqual(dispatcher.fleet, fleet)
def setUpClass(cls) -> None:
cls.job = jit.Job(generate_trips(10),
objective_cls=jit.DialARideObjective)
cls.fleet = jit.Fleet(generate_vehicles(10))
def setUpClass(cls) -> None:
cls.planning = generate_one_planning()
cls.fleet = jit.Fleet(set(cls.planning.vehicles))
cls.job = jit.Job(set(cls.planning.trips), jit.DialARideObjective)
cls.algorithm = jit.NaiveAlgorithm(cls.fleet, cls.job)
cls.computation_time = 1
def test_construction(self):
vehicles = generate_vehicles(3)
fleet = jit.Fleet(vehicles)
self.assertIsInstance(fleet, jit.Fleet)
self.assertEqual(fleet.vehicles, vehicles)
