⬆️🪝 update pre-commit hooks (#140)

<!--pre-commit.ci start-->
updates:
- [github.com/astral-sh/ruff-pre-commit: v0.9.10 →
v0.11.0](astral-sh/ruff-pre-commit@v0.9.10...v0.11.0)
<!--pre-commit.ci end-->

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: pre-commit-ci[bot]

.pre-commit-config.yaml

@@ -56,7 +56,7 @@ repos:
         types_or: [yaml, markdown, html, css, javascript, json]
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.9.10
+    rev: v0.11.0
     hooks:
       - id: ruff
         args: ["--fix", "--show-fixes"]

resource_estimation/RE_experiments.py

@@ -100,12 +100,12 @@
 def modified_logical_counts(space_factor: float, time_factor: float):
     return LogicalCounts(
         {
-            "numQubits": int(ceil(logical_counts["numQubits"] * space_factor)),
-            "tCount": int(ceil(logical_counts["tCount"] * time_factor)),
-            "rotationCount": int(ceil(logical_counts["rotationCount"] * time_factor)),
-            "rotationDepth": int(ceil(logical_counts["rotationDepth"] * time_factor)),
-            "cczCount": int(ceil(logical_counts["cczCount"] * time_factor)),
-            "measurementCount": int(ceil(logical_counts["measurementCount"] * time_factor)),
+            "numQubits": ceil(logical_counts["numQubits"] * space_factor),
+            "tCount": ceil(logical_counts["tCount"] * time_factor),
+            "rotationCount": ceil(logical_counts["rotationCount"] * time_factor),
+            "rotationDepth": ceil(logical_counts["rotationDepth"] * time_factor),
+            "cczCount": ceil(logical_counts["cczCount"] * time_factor),
+            "measurementCount": ceil(logical_counts["measurementCount"] * time_factor),
         }
     )
 

src/mqt/problemsolver/satellitesolver/ImagingLocation.py

@@ -28,17 +28,17 @@ def get_imaging_attempt(self) -> int:
 
     def get_average_satellite_position(self) -> np.ndarray[Any, np.dtype[np.float64]]:
         longitude = 2 * np.pi / ORBIT_DURATION * self.imaging_attempt
-        return cast(np.ndarray[Any, np.dtype[np.float64]], R_S * np.array([np.cos(longitude), np.sin(longitude), 0]))
+        return cast("np.ndarray[Any, np.dtype[np.float64]]", R_S * np.array([np.cos(longitude), np.sin(longitude), 0]))
 
     def get_longitude_angle(self) -> float:
         # Returns longitude of the acquisition request
         temp = self.position * np.array([1, 1, 0])
         temp /= np.linalg.norm(temp)
-        return cast(float, np.arccos(temp[0]) if temp[1] >= 0 else 2 * np.pi - np.arccos(temp[0]))
+        return cast("float", np.arccos(temp[0]) if temp[1] >= 0 else 2 * np.pi - np.arccos(temp[0]))
 
     def get_latitude_angle(self) -> float:
         # Returns latitude of the acquisition request
-        return cast(float, np.arccos(self.position[2] / R_E))
+        return cast("float", np.arccos(self.position[2] / R_E))
 
     def get_coordinates(self) -> tuple[str, str]:
         # Returns position of the acquisition request as GPS coordinates

src/mqt/problemsolver/satellitesolver/utils.py

@@ -41,7 +41,7 @@ def get_success_ratio(ac_reqs: list[LocationRequest], qubo: QuadraticProgram, so
     # sum over all LocationRequests and sum over their imaging_attempt_score if the respective indicator in sol[index] is 1
     solution_vector = solution_vector[::-1]
     return cast(
-        float,
+        "float",
         (
             sum(
                 [
@@ -71,7 +71,7 @@ def create_acquisition_position(
             np.cos(latitude),
         ]
     )
-    return cast(np.ndarray[Any, np.dtype[np.float64]], res)
+    return cast("np.ndarray[Any, np.dtype[np.float64]]", res)
 
 
 def calc_needed_time_between_acquisition_attempts(
@@ -85,12 +85,12 @@ def calc_needed_time_between_acquisition_attempts(
     theta = np.arccos(delta_r1 @ delta_r2 / (np.linalg.norm(delta_r1) * np.linalg.norm(delta_r2)))
     result = theta / (ROTATION_SPEED_SATELLITE * 2 * np.pi)
 
-    return cast(np.ndarray[Any, np.dtype[np.float64]], result)
+    return cast("np.ndarray[Any, np.dtype[np.float64]]", result)
 
 
 def transition_possible(acq_1: LocationRequest, acq_2: LocationRequest) -> bool:
     """Returns True if transition between acq_1 and acq_2 is possible, False otherwise"""
-    t_maneuver = cast(float, calc_needed_time_between_acquisition_attempts(acq_1, acq_2))
+    t_maneuver = cast("float", calc_needed_time_between_acquisition_attempts(acq_1, acq_2))
     t1 = acq_1.imaging_attempt
     t2 = acq_2.imaging_attempt
     if t1 < t2:
@@ -187,4 +187,4 @@ def convert_docplex_to_qubo(model: Model, penalty: int | None = None) -> Quadrat
 def get_longitude(vector: np.ndarray[Any, np.dtype[np.float64]]) -> float:
     temp = vector * np.array([1, 1, 0])
     temp /= np.linalg.norm(temp)
-    return cast(float, np.arccos(temp[0]) if temp[1] >= 0 else 2 * np.pi - np.arccos(temp[0]))
+    return cast("float", np.arccos(temp[0]) if temp[1] >= 0 else 2 * np.pi - np.arccos(temp[0]))

src/mqt/problemsolver/tsp.py

@@ -216,7 +216,7 @@ def simulate(self, qc: QuantumCircuit) -> str:
         job = execute(qc, backend, shots=1000)
         count = job.result().get_counts()
 
-        return cast(str, count.most_frequent())
+        return cast("str", count.most_frequent())
 
     def get_classical_result(self) -> list[int]:
         distance_matrix = np.array(
@@ -229,7 +229,7 @@ def get_classical_result(self) -> list[int]:
         )
         permutation, distance = solve_tsp_dynamic_programming(distance_matrix)
 
-        return cast(list[int], (np.array(permutation) + 1).T)
+        return cast("list[int]", (np.array(permutation) + 1).T)
 
     def controlled_unitary(
         self, qc: QuantumCircuit, qubits: list[QuantumRegister], phases: list[float]