Initialize speed and position with float constants

Ensure that speed and position are initialized using floating-point values.
This prevents vectorized environment wrappers from inferring an integer dtype
when a single environment resets, which could otherwise cause loss of precision.

Author: risteon

highway_env/envs/exit_env.py

@@ -107,7 +107,7 @@ def _create_vehicles(self) -> None:
         for _ in range(self.config["controlled_vehicles"]):
             vehicle = Vehicle.create_random(
                 self.road,
-                speed=25,
+                speed=25.0,
                 lane_from="0",
                 lane_to="1",
                 lane_id=0,

highway_env/envs/highway_env.py

@@ -76,7 +76,7 @@ def _create_vehicles(self) -> None:
         for others in other_per_controlled:
             vehicle = Vehicle.create_random(
                 self.road,
-                speed=25,
+                speed=25.0,
                 lane_id=self.config["initial_lane_id"],
                 spacing=self.config["ego_spacing"],
             )

highway_env/envs/intersection_env.py

@@ -177,7 +177,7 @@ def _make_road(self) -> None:
                 "o" + str(corner),
                 "ir" + str(corner),
                 StraightLane(
-                    start, end, line_types=[s, c], priority=priority, speed_limit=10
+                    start, end, line_types=[s, c], priority=priority, speed_limit=10.0
                 ),
             )
             # Right turn
@@ -192,7 +192,7 @@ def _make_road(self) -> None:
                     angle + np.radians(270),
                     line_types=[n, c],
                     priority=priority,
-                    speed_limit=10,
+                    speed_limit=10.0,
                 ),
             )
             # Left turn
@@ -215,7 +215,7 @@ def _make_road(self) -> None:
                     clockwise=False,
                     line_types=[n, n],
                     priority=priority - 1,
-                    speed_limit=10,
+                    speed_limit=10.0,
                 ),
             )
             # Straight
@@ -225,7 +225,7 @@ def _make_road(self) -> None:
                 "ir" + str(corner),
                 "il" + str((corner + 2) % 4),
                 StraightLane(
-                    start, end, line_types=[s, n], priority=priority, speed_limit=10
+                    start, end, line_types=[s, n], priority=priority, speed_limit=10.0
                 ),
             )
             # Exit
@@ -237,7 +237,7 @@ def _make_road(self) -> None:
                 "il" + str((corner - 1) % 4),
                 "o" + str((corner - 1) % 4),
                 StraightLane(
-                    end, start, line_types=[n, c], priority=priority, speed_limit=10
+                    end, start, line_types=[n, c], priority=priority, speed_limit=10.0
                 ),
             )
 
@@ -276,10 +276,10 @@ def _make_vehicles(self, n_vehicles: int = 10) -> None:
         # Challenger vehicle
         self._spawn_vehicle(
             60,
-            spawn_probability=1,
+            spawn_probability=1.0,
             go_straight=True,
             position_deviation=0.1,
-            speed_deviation=0,
+            speed_deviation=0.0,
         )
 
         # Controlled vehicles
@@ -293,9 +293,9 @@ def _make_vehicles(self, n_vehicles: int = 10) -> None:
             )
             ego_vehicle = self.action_type.vehicle_class(
                 self.road,
-                ego_lane.position(60 + 5 * self.np_random.normal(1), 0),
+                ego_lane.position(60.0 + 5.0 * self.np_random.normal(1.0), 0.0),
                 speed=ego_lane.speed_limit,
-                heading=ego_lane.heading_at(60),
+                heading=ego_lane.heading_at(60.0),
             )
             try:
                 ego_vehicle.plan_route_to(destination)
@@ -335,9 +335,9 @@ def _spawn_vehicle(
             self.road,
             ("o" + str(route[0]), "ir" + str(route[0]), 0),
             longitudinal=(
-                longitudinal + 5 + self.np_random.normal() * position_deviation
+                longitudinal + 5.0 + self.np_random.normal() * position_deviation
             ),
-            speed=8 + self.np_random.normal() * speed_deviation,
+            speed=8.0 + self.np_random.normal() * speed_deviation,
         )
         for v in self.road.vehicles:
             if np.linalg.norm(v.position - vehicle.position) < 15:

highway_env/envs/merge_env.py

@@ -160,21 +160,21 @@ def _make_vehicles(self) -> None:
         """
         road = self.road
         ego_vehicle = self.action_type.vehicle_class(
-            road, road.network.get_lane(("a", "b", 1)).position(30, 0), speed=30
+            road, road.network.get_lane(("a", "b", 1)).position(30.0, 0.0), speed=30.0
         )
         road.vehicles.append(ego_vehicle)
 
         other_vehicles_type = utils.class_from_path(self.config["other_vehicles_type"])
 
-        for position, speed in [(90, 29), (70, 31), (5, 31.5)]:
+        for position, speed in [(90.0, 29.0), (70.0, 31.0), (5.0, 31.5)]:
             lane = road.network.get_lane(("a", "b", self.np_random.integers(2)))
-            position = lane.position(position + self.np_random.uniform(-5, 5), 0)
-            speed += self.np_random.uniform(-1, 1)
+            position = lane.position(position + self.np_random.uniform(-5.0, 5.0), 0.0)
+            speed += self.np_random.uniform(-1.0, 1.0)
             road.vehicles.append(other_vehicles_type(road, position, speed=speed))
 
         merging_v = other_vehicles_type(
-            road, road.network.get_lane(("j", "k", 0)).position(110, 0), speed=20
+            road, road.network.get_lane(("j", "k", 0)).position(110.0, 0.0), speed=20.0
         )
-        merging_v.target_speed = 30
+        merging_v.target_speed = 30.0
         road.vehicles.append(merging_v)
         self.vehicle = ego_vehicle

highway_env/envs/parking_env.py

@@ -180,9 +180,9 @@ def _create_vehicles(self) -> None:
         # Controlled vehicles
         self.controlled_vehicles = []
         for i in range(self.config["controlled_vehicles"]):
-            x0 = (i - self.config["controlled_vehicles"] // 2) * 10
+            x0 = float(i - self.config["controlled_vehicles"] // 2) * 10.0
             vehicle = self.action_type.vehicle_class(
-                self.road, [x0, 0], 2 * np.pi * self.np_random.uniform(), 0
+                self.road, [x0, 0.0], 2.0 * np.pi * self.np_random.uniform(), 0.0
             )
             vehicle.color = VehicleGraphics.EGO_COLOR
             self.road.vehicles.append(vehicle)
@@ -204,7 +204,7 @@ def _create_vehicles(self) -> None:
             if not empty_spots:
                 continue
             lane_index = empty_spots[self.np_random.choice(np.arange(len(empty_spots)))]
-            v = Vehicle.make_on_lane(self.road, lane_index, 4, speed=0)
+            v = Vehicle.make_on_lane(self.road, lane_index, longitudinal=4.0, speed=0.0)
             self.road.vehicles.append(v)
             empty_spots.remove(lane_index)
 

highway_env/envs/racetrack_env.py

@@ -96,7 +96,7 @@ def _make_road(self) -> None:
 
         # Set Speed Limits for Road Sections - Straight, Turn20, Straight,
         # Turn 15, Turn15, Straight, Turn25x2, Turn18
-        speedlimits = [None, 10, 10, 10, 10, 10, 10, 10, 10]
+        speedlimits = [None, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0]
 
         # Initialise First Lane
         lane = StraightLane(
@@ -393,9 +393,9 @@ def _make_vehicles(self) -> None:
                 self.road,
                 ("b", "c", lane_index[-1]),
                 longitudinal=rng.uniform(
-                    low=0, high=self.road.network.get_lane(("b", "c", 0)).length
+                    low=0.0, high=self.road.network.get_lane(("b", "c", 0)).length
                 ),
-                speed=6 + rng.uniform(high=3),
+                speed=6.0 + rng.uniform(high=3.0),
             )
             self.road.vehicles.append(vehicle)
 
@@ -407,9 +407,9 @@ def _make_vehicles(self) -> None:
                     self.road,
                     rand_lane_index,
                     longitudinal=rng.uniform(
-                        low=0, high=self.road.network.get_lane(rand_lane_index).length
+                        low=0.0, high=self.road.network.get_lane(rand_lane_index).length
                     ),
-                    speed=6 + rng.uniform(high=3),
+                    speed=6.0 + rng.uniform(high=3.0),
                 )
                 # Prevent early collisions
                 for v in self.road.vehicles:
@@ -1304,13 +1304,13 @@ def _make_road(self) -> None:
 
         # Scenario to force a "binary" decision
         if self.config["block_lane"]:
-            for i in [40, 43, 46, 49]:
+            for i in [40.0, 43.0, 46.0, 49.0]:
                 road.objects.append(Obstacle(road, [length - i, 3.75]))
                 road.objects.append(Obstacle(road, [length - i, 6.25]))
 
         if self.config["force_decision"]:
             for i in [-1.25, 1.25, 8.85, 11.25]:
-                road.objects.append(Obstacle(road, [length - 90, i]))
+                road.objects.append(Obstacle(road, [length - 90.0, i]))
 
         self.road = road
 
@@ -1333,7 +1333,7 @@ def _make_vehicles(self) -> None:
                 else self.road.network.random_lane_index(rng)
             )
             controlled_vehicle = self.action_type.vehicle_class.make_on_lane(
-                self.road, lane_index, speed=None, longitudinal=rng.uniform(20, 50)
+                self.road, lane_index, speed=None, longitudinal=rng.uniform(20.0, 50.0)
             )
 
             self.controlled_vehicles.append(controlled_vehicle)
@@ -1345,9 +1345,9 @@ def _make_vehicles(self) -> None:
                 self.road,
                 ("b", "c", lane_index[-1]),
                 longitudinal=rng.uniform(
-                    low=0, high=self.road.network.get_lane(("b", "c", 0)).length
+                    low=0.0, high=self.road.network.get_lane(("b", "c", 0)).length
                 ),
-                speed=6 + rng.uniform(high=3),
+                speed=6.0 + rng.uniform(high=3.0),
             )
             self.road.vehicles.append(vehicle)
 
@@ -1358,13 +1358,13 @@ def _make_vehicles(self) -> None:
                     self.road,
                     rand_lane_index,
                     longitudinal=rng.uniform(
-                        low=0, high=self.road.network.get_lane(rand_lane_index).length
+                        low=0.0, high=self.road.network.get_lane(rand_lane_index).length
                     ),
-                    speed=6 + rng.uniform(high=3),
+                    speed=6.0 + rng.uniform(high=3.0),
                 )
                 # Prevent early collisions
                 for v in self.road.vehicles:
-                    if np.linalg.norm(vehicle.position - v.position) < 20:
+                    if np.linalg.norm(vehicle.position - v.position) < 20.0:
                         break
                 else:
                     self.road.vehicles.append(vehicle)

highway_env/envs/roundabout_env.py

@@ -326,16 +326,16 @@ def _make_vehicles(self) -> None:
 
         :return: the ego-vehicle
         """
-        position_deviation = 2
-        speed_deviation = 2
+        position_deviation = 2.0
+        speed_deviation = 2.0
 
         # Ego-vehicle
         ego_lane = self.road.network.get_lane(("ser", "ses", 0))
         ego_vehicle = self.action_type.vehicle_class(
             self.road,
-            ego_lane.position(125, 0),
-            speed=8,
-            heading=ego_lane.heading_at(140),
+            ego_lane.position(125.0, 0.0),
+            speed=8.0,
+            heading=ego_lane.heading_at(140.0),
         )
         try:
             ego_vehicle.plan_route_to("nxs")
@@ -350,7 +350,7 @@ def _make_vehicles(self) -> None:
         vehicle = other_vehicles_type.make_on_lane(
             self.road,
             ("we", "sx", 1),
-            longitudinal=5 + self.np_random.normal() * position_deviation,
+            longitudinal=5.0 + self.np_random.normal() * position_deviation,
             speed=16 + self.np_random.normal() * speed_deviation,
         )
 
@@ -367,8 +367,9 @@ def _make_vehicles(self) -> None:
             vehicle = other_vehicles_type.make_on_lane(
                 self.road,
                 ("we", "sx", 0),
-                longitudinal=20 * i + self.np_random.normal() * position_deviation,
-                speed=16 + self.np_random.normal() * speed_deviation,
+                longitudinal=20.0 * float(i)
+                + self.np_random.normal() * position_deviation,
+                speed=16.0 + self.np_random.normal() * speed_deviation,
             )
             vehicle.plan_route_to(self.np_random.choice(destinations))
             vehicle.randomize_behavior()
@@ -378,8 +379,8 @@ def _make_vehicles(self) -> None:
         vehicle = other_vehicles_type.make_on_lane(
             self.road,
             ("eer", "ees", 0),
-            longitudinal=50 + self.np_random.normal() * position_deviation,
-            speed=16 + self.np_random.normal() * speed_deviation,
+            longitudinal=50.0 + self.np_random.normal() * position_deviation,
+            speed=16.0 + self.np_random.normal() * speed_deviation,
         )
         vehicle.plan_route_to(self.np_random.choice(destinations))
         vehicle.randomize_behavior()

highway_env/envs/two_way_env.py

@@ -118,7 +118,7 @@ def _make_vehicles(self) -> None:
         """
         road = self.road
         ego_vehicle = self.action_type.vehicle_class(
-            road, road.network.get_lane(("a", "b", 1)).position(30, 0), speed=30
+            road, road.network.get_lane(("a", "b", 1)).position(30.0, 0.0), speed=30.0
         )
         road.vehicles.append(ego_vehicle)
         self.vehicle = ego_vehicle
@@ -129,23 +129,25 @@ def _make_vehicles(self) -> None:
                 vehicles_type(
                     road,
                     position=road.network.get_lane(("a", "b", 1)).position(
-                        70 + 40 * i + 10 * self.np_random.normal(), 0
+                        70.0 + 40.0 * float(i) + 10.0 * self.np_random.normal(), 0.00
                     ),
                     heading=road.network.get_lane(("a", "b", 1)).heading_at(
-                        70 + 40 * i
+                        70.0 + 40.0 * float(i)
                     ),
-                    speed=24 + 2 * self.np_random.normal(),
+                    speed=24.0 + 2.0 * self.np_random.normal(),
                     enable_lane_change=False,
                 )
             )
         for i in range(2):
             v = vehicles_type(
                 road,
                 position=road.network.get_lane(("b", "a", 0)).position(
-                    200 + 100 * i + 10 * self.np_random.normal(), 0
+                    200.0 + 100.0 * float(i) + 10.0 * self.np_random.normal(), 0
                 ),
-                heading=road.network.get_lane(("b", "a", 0)).heading_at(200 + 100 * i),
-                speed=20 + 5 * self.np_random.normal(),
+                heading=road.network.get_lane(("b", "a", 0)).heading_at(
+                    200.0 + 100.0 * float(i)
+                ),
+                speed=20.0 + 5.0 * self.np_random.normal(),
                 enable_lane_change=False,
             )
             v.target_lane_index = ("b", "a", 0)

highway_env/envs/u_turn_env.py

@@ -181,12 +181,12 @@ def _make_vehicles(self) -> None:
         """
 
         # These variables add small variations to the driving behavior.
-        position_deviation = 2
-        speed_deviation = 2
+        position_deviation = 2.0
+        speed_deviation = 2.0
 
         ego_lane = self.road.network.get_lane(("a", "b", 0))
         ego_vehicle = self.action_type.vehicle_class(
-            self.road, ego_lane.position(0, 0), speed=16
+            self.road, ego_lane.position(0, 0), speed=16.0
         )
         # Stronger anticipation for the turn
         ego_vehicle.PURSUIT_TAU = MDPVehicle.TAU_HEADING
@@ -207,7 +207,7 @@ def _make_vehicles(self) -> None:
         vehicle = vehicles_type.make_on_lane(
             self.road,
             ("a", "b", 0),
-            longitudinal=25 + self.np_random.normal() * position_deviation,
+            longitudinal=25.0 + self.np_random.normal() * position_deviation,
             speed=13.5 + self.np_random.normal() * speed_deviation,
         )
         vehicle.plan_route_to("d")
@@ -218,7 +218,7 @@ def _make_vehicles(self) -> None:
         vehicle = vehicles_type.make_on_lane(
             self.road,
             ("a", "b", 1),
-            longitudinal=56 + self.np_random.normal() * position_deviation,
+            longitudinal=56.0 + self.np_random.normal() * position_deviation,
             speed=14.5 + self.np_random.normal() * speed_deviation,
         )
         vehicle.plan_route_to("d")
@@ -251,7 +251,7 @@ def _make_vehicles(self) -> None:
         vehicle = vehicles_type.make_on_lane(
             self.road,
             ("c", "d", 0),
-            longitudinal=1 + self.np_random.normal() * position_deviation,
+            longitudinal=1.0 + self.np_random.normal() * position_deviation,
             speed=3.5 + self.np_random.normal() * speed_deviation,
         )
         vehicle.plan_route_to("d")
@@ -262,7 +262,7 @@ def _make_vehicles(self) -> None:
         vehicle = vehicles_type.make_on_lane(
             self.road,
             ("c", "d", 1),
-            longitudinal=30 + self.np_random.normal() * position_deviation,
+            longitudinal=30.0 + self.np_random.normal() * position_deviation,
             speed=5.5 + self.np_random.normal() * speed_deviation,
         )
         vehicle.plan_route_to("d")

highway_env/road/road.py

@@ -291,10 +291,10 @@ def lanes_dict(self) -> dict[str, AbstractLane]:
     @staticmethod
     def straight_road_network(
         lanes: int = 4,
-        start: float = 0,
-        length: float = 10000,
-        angle: float = 0,
-        speed_limit: float = 30,
+        start: float = 0.0,
+        length: float = 10000.0,
+        angle: float = 0.0,
+        speed_limit: float = 30.0,
         nodes_str: tuple[str, str] | None = None,
         net: RoadNetwork | None = None,
     ) -> RoadNetwork: