mpc-control 0.2.0__tar.gz → 0.2.2__tar.gz

{mpc_control-0.2.0/mpc_control.egg-info → mpc_control-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpc-control
-Version: 0.2.0
+Version: 0.2.2
 Summary: A Python library for Model Predictive Control (MPC)
 Author-email: Zhen Ni <z.ni@hotmail.com>
 License-Expression: MIT
@@ -9,7 +9,7 @@ Project-URL: Issues, https://github.com/Zhen-Ni/mpc-control/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.9
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=2.0
@@ -42,7 +42,7 @@ pip install mpc-control
 ```
 
 **Requirements:**
-- Python 3.9+ (Tested with Python 3.12)
+- Python 3.12+
 - NumPy, SciPy, OSQP
 
 ## 🚀 Quick Start
@@ -51,7 +51,7 @@ Here is a basic example of how to define a system and solve an MPC problem:
 
 ```python
 import numpy as np
-import mpc_control as mpc
+import mpc
 
 # 1. Define a discrete LTI system
 # x[n+1] = A x[n] + B u[n]

{mpc_control-0.2.0 → mpc_control-0.2.2}/README.md

@@ -23,7 +23,7 @@ pip install mpc-control
 ```
 
 **Requirements:**
-- Python 3.9+ (Tested with Python 3.12)
+- Python 3.12+
 - NumPy, SciPy, OSQP
 
 ## 🚀 Quick Start
@@ -32,7 +32,7 @@ Here is a basic example of how to define a system and solve an MPC problem:
 
 ```python
 import numpy as np
-import mpc_control as mpc
+import mpc
 
 # 1. Define a discrete LTI system
 # x[n+1] = A x[n] + B u[n]

{mpc_control-0.2.0 → mpc_control-0.2.2}/mpc/kalman.py

@@ -134,14 +134,14 @@ class Ekf:
         """
         if self._linearized is None:
             raise RuntimeError('Should call `predict` before updating.')
-        c = self._linearized.output_matrix
+        c, v = self._system._linearize_output(self._x)
         # Calculate innovation covariance `S`.
         S = c @ self._p @ c.T + r
         # Calculate Kalman gain `k`.
         # k = p @ C.T @ inv(S) is equivalent to k.T = solve(S, C @ p)
         k = np.linalg.solve(S, c @ self._p).T
         # Calculate the updated state vector `x`.
-        x = self._x + k @ (np.asarray(z) - c @ self._x)
+        x = self._x + k @ (np.asarray(z) - c @ self._x - v)
         # Calculate the updated uncertainty `p` for the state vector.
         T = np.eye(k.shape[0]) - k @ c
         p = T @ self._p @ T.T + k @ r @ k.T

{mpc_control-0.2.0 → mpc_control-0.2.2}/mpc/mpc.py

@@ -678,74 +678,54 @@ class Mpc:
 
         self._qp_internal.q = q
 
-    def solve(self,
-              target_output: np.ndarray,
-              initial_state: np.ndarray,
-              previous_control: Optional[np.ndarray] = None,
-              state_ref: Optional[np.ndarray] = None,
-              control_ref: Optional[np.ndarray] = None,
-              max_iter: Optional[int] = None,
-              eps_abs: Optional[float] = None,
-              eps_rel: Optional[float] = None
-              ) -> Optional[np.ndarray]:
-        """Solve the mpc problem.
-
-        Args:
-            initial_state: Initial state (x_0).
-            previous_control: The control input in the previous
-            timestep (u_{-1}).
-            target_output: Reference output sequence Y_ref. Note that
-                this corresponds to the outputs from step 1 to step N
-                (y_1 to y_N), as the output at the current step 0
-                (y_0) cannot be influenced by future controls.
-            state_ref: Reference state for system linearization. This
-                corresponds to the states from step 0 to step N-1 (x_0
-                to x_{N-1}).
-            control_ref: Reference control for system
-                linearization. This corresponds to the controls from
-                step 0 to step N-1 (u_0 to u_{N-1}).
-            max_iter: Maximum iterations for OSQP solver.
-            eps_abs: Absolute convergence tolerance for OSQP solver.
-            eps_rel: Relative convergence tolerance for OSQP solver.
-
-        Returns:
-            The optimal control sequence U with shape (horizon,
-            n_control), corresponding to the controls from step 0 to
-            step N-1 (u_0 to u_{N-1}), or None if the problem is not
-            solved successfully.
-
-        """
-        use_cached_p = (
-            self._qp_internal and
-            isinstance(self._system, AffineTimeInvariant))
-        use_cached_a = (
-            (not self._qp_constraint.modified) and
-            isinstance(self._system, AffineTimeInvariant))
-
-        if previous_control is None:
-            if (self._control_delta_weighting is None and
-                    self._qp_constraint.control_delta_bound is None):
-                # Set to empty because it will not be used anyway.
-                previous_control = np.empty(self._system.n_control)
-            else:
-                raise ValueError(
-                    'previous_control must be provided if '
-                    'control changing rate is involved.')
-
+    def _validate_previous_control(
+            self,
+            previous_control: Optional[np.ndarray]) -> np.ndarray:
+        if previous_control is not None:
+            return previous_control
+        # Use a placeholder for previous control, as it will not be
+        # used in this case.
+        if (self._control_delta_weighting is None and
+                self._qp_constraint.control_delta_bound is None):
+            return np.empty(self._system.n_control)
+        raise ValueError(
+            'previous_control must be provided if '
+            'control changing rate is involved.')
+
+    def _prepare_qp_matrices(
+            self,
+            target_output: np.ndarray,
+            initial_state: np.ndarray,
+            previous_control: np.ndarray,
+            state_ref: Optional[np.ndarray],
+            control_ref: Optional[np.ndarray],
+            use_cached_p: bool) -> None:
         if use_cached_p:
-            self._update_qp(target_output,
-                            initial_state, previous_control)
+            self._update_qp(target_output, initial_state, previous_control)
         else:
-            self._build_qp(target_output,
-                           initial_state, previous_control,
+            self._build_qp(target_output, initial_state, previous_control,
                            state_ref, control_ref)
 
+    def _prepare_constraints(
+            self,
+            initial_state: np.ndarray,
+            previous_control: np.ndarray,
+            use_cached_a: bool) -> None:
         if use_cached_a:
             self._update_constraints(initial_state, previous_control)
         else:
             self._build_constraints(initial_state, previous_control)
 
+    def _setup_and_solve_osqp(
+            self,
+            max_iter: Optional[int],
+            eps_abs: Optional[float],
+            eps_rel: Optional[float],
+            control_ref: Optional[np.ndarray],
+            use_cached_p: bool,
+            use_cached_a: bool) -> Optional[np.ndarray]:
         assert self._qp_internal is not None  # Make mypy happy
+
         p = self._qp_internal.csc_p
         q = self._qp_internal.q
         a = self._qp_constraint.a
@@ -773,9 +753,64 @@ class Mpc:
 
         if control_ref is not None:
             self._osqp.warm_start(x=np.asarray(control_ref).reshape(-1))
+
         res = self._osqp.solve(raise_error=False)
         self._result = res
         if res.info.status == 'solved':
-            u = res.x.reshape(self._horizon, self._system.n_control)
-            return u
+            return res.x.reshape(self._horizon, self._system.n_control)
         return None
+
+    def solve(self,
+              target_output: np.ndarray,
+              initial_state: np.ndarray,
+              previous_control: Optional[np.ndarray] = None,
+              state_ref: Optional[np.ndarray] = None,
+              control_ref: Optional[np.ndarray] = None,
+              max_iter: Optional[int] = None,
+              eps_abs: Optional[float] = None,
+              eps_rel: Optional[float] = None
+              ) -> Optional[np.ndarray]:
+        """Solve the mpc problem.
+
+        Args:
+            initial_state: Initial state (x_0).
+            previous_control: The control input in the previous
+            timestep (u_{-1}).
+            target_output: Reference output sequence Y_ref. Note that
+                this corresponds to the outputs from step 1 to step N
+                (y_1 to y_N), as the output at the current step 0
+                (y_0) cannot be influenced by future controls.
+            state_ref: Reference state for system linearization. This
+                corresponds to the states from step 0 to step N-1 (x_0
+                to x_{N-1}).
+            control_ref: Reference control for system
+                linearization. This corresponds to the controls from
+                step 0 to step N-1 (u_0 to u_{N-1}).
+            max_iter: Maximum iterations for OSQP solver.
+            eps_abs: Absolute convergence tolerance for OSQP solver.
+            eps_rel: Relative convergence tolerance for OSQP solver.
+
+        Returns:
+            The optimal control sequence U with shape (horizon,
+            n_control), corresponding to the controls from step 0 to
+            step N-1 (u_0 to u_{N-1}), or None if the problem is not
+            solved successfully.
+
+        """
+        use_cached_p = bool(self._qp_internal and
+                            isinstance(self._system, AffineTimeInvariant))
+        use_cached_a = bool((not self._qp_constraint.modified) and
+                            isinstance(self._system, AffineTimeInvariant))
+
+        previous_control = self._validate_previous_control(previous_control)
+
+        self._prepare_qp_matrices(
+            target_output, initial_state, previous_control,
+            state_ref, control_ref, use_cached_p)
+
+        self._prepare_constraints(
+            initial_state, previous_control, use_cached_a)
+
+        return self._setup_and_solve_osqp(
+            max_iter, eps_abs, eps_rel, control_ref,
+            use_cached_p, use_cached_a)

{mpc_control-0.2.0 → mpc_control-0.2.2/mpc_control.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mpc-control
-Version: 0.2.0
+Version: 0.2.2
 Summary: A Python library for Model Predictive Control (MPC)
 Author-email: Zhen Ni <z.ni@hotmail.com>
 License-Expression: MIT
@@ -9,7 +9,7 @@ Project-URL: Issues, https://github.com/Zhen-Ni/mpc-control/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Classifier: Topic :: Scientific/Engineering
-Requires-Python: >=3.9
+Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=2.0
@@ -42,7 +42,7 @@ pip install mpc-control
 ```
 
 **Requirements:**
-- Python 3.9+ (Tested with Python 3.12)
+- Python 3.12+
 - NumPy, SciPy, OSQP
 
 ## 🚀 Quick Start
@@ -51,7 +51,7 @@ Here is a basic example of how to define a system and solve an MPC problem:
 
 ```python
 import numpy as np
-import mpc_control as mpc
+import mpc
 
 # 1. Define a discrete LTI system
 # x[n+1] = A x[n] + B u[n]

{mpc_control-0.2.0 → mpc_control-0.2.2}/pyproject.toml

@@ -4,10 +4,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "mpc-control"
-version = "0.2.0"
+version = "0.2.2"
 description = "A Python library for Model Predictive Control (MPC)"
 readme = "README.md"
-requires-python = ">=3.9"
+requires-python = ">=3.12"
 license = "MIT"
 license-files = ["LICENSE"]
 authors = [

{mpc_control-0.2.0 → mpc_control-0.2.2}/test/test_kalman.py

@@ -76,6 +76,7 @@ class TestEKF(unittest.TestCase):
 
     def test_observe_state_noised(self):
         """State observer of a linear system with noise."""
+        np.random.seed(0)
         m1, m2 = 1.0, 1.5
         c1, c2 = 0.2, 0.3
         k1, k2 = 15.0, 20.0
@@ -137,10 +138,12 @@ class TestEKF(unittest.TestCase):
         x_true = np.array(x_true_list)
         x_pred = np.array(x_pred_list)
 
-        self.assertTrue(abs(((x_true - x_pred)[-100:]) < 0.1).all())
+        self.assertTrue((abs((x_true - x_pred)[-100:]) < 0.1).all())
 
     def test_observe_nonlinear_state(self):
         """State observer of a nonlinear system."""
+        np.random.seed(0)
+
         def A_true(x, u):
             return np.array([0.5, 1.,
                              0., 0.48 + np.sin(u[0]+0.02)]).reshape(2, 2)
@@ -256,6 +259,7 @@ class TestUKF(unittest.TestCase):
 
     def test_observe_state_noised(self):
         """State observer of a linear system with noise."""
+        np.random.seed(0)
         m1, m2 = 1.0, 1.5
         c1, c2 = 0.2, 0.3
         k1, k2 = 15.0, 20.0
@@ -317,10 +321,12 @@ class TestUKF(unittest.TestCase):
         x_true = np.array(x_true_list)
         x_pred = np.array(x_pred_list)
 
-        self.assertTrue(abs(((x_true - x_pred)[-100:]) < 0.1).all())
+        self.assertTrue((abs((x_true - x_pred)[-100:]) < 0.1).all())
 
     def test_observe_nonlinear_state(self):
         """State observer of a nonlinear system."""
+        np.random.seed(0)
+
         def A_true(x, u):
             return np.array([0.5, 1., 0.,
                              0.48 + np.sin(u[0]+0.02)]).reshape(2, 2)