PyDiffGame 0.1.2__py3-none-any.whl → 2.0.0__py3-none-any.whl

{pydiffgame-0.1.2.dist-info → pydiffgame-2.0.0.dist-info}/RECORD

@@ -1,15 +1,17 @@
-PyDiffGame/ContinuousPyDiffGame.py,sha256=31Rf7zUMQOWxVT23x1hR_LXqcrpI25W-IugRA4a3E6c,10462
-PyDiffGame/DiscretePyDiffGame.py,sha256=86cCk91ogzQsEMaE9aM5VBEhZ_09RdJjmiJgR9_y_H0,12952
-PyDiffGame/LQR.py,sha256=bIUDt9frlX2GNXrX1XfJarwqrjrVCm4AAAv6zrKumHA,2267
-PyDiffGame/Objective.py,sha256=Q6En2czCtJFHG3vRNUbsxb7V5ADIO-b03qqlq9Fy2fc,1201
-PyDiffGame/PyDiffGame.py,sha256=JsqY33WdPbiNIpN3m_xj8aooStf815XG2gEA67J3fFg,45084
-PyDiffGame/PyDiffGameLQRComparison.py,sha256=b2eobj3AyY42uElAp5abs7iI0rMy4op0jYybjBG0ad4,5850
-PyDiffGame/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-PyDiffGame/examples/InvertedPendulumComparison.py,sha256=z72VznBkml5Xv69kt8RizVsevj05tlmttd3CJYoaJUQ,10151
-PyDiffGame/examples/MassesWithSpringsComparison.py,sha256=saT6g7T4ZDlXYAPw5ApwKFCaxzvXixOPfXyzMX2p6v4,8647
-PyDiffGame/examples/PVTOL.py,sha256=eHi8nYnkSGgAtH5CVR_Cxakhapd8pDYYpsn6jkIwsN4,6649
-PyDiffGame/examples/PVTOLComparison.py,sha256=uFPVry2lfyWKOk8OR5harsqiV1X6Z2jVtkEtWGQYZ1Q,3567
-PyDiffGame/examples/QuadRotorControl.py,sha256=uAIWx25KQm8RemL5Wi0Zcvnbv-6umQp4Q1VAIeLdYfM,17909
+PyDiffGame/__init__.py,sha256=qvv_2OcKgr_pXiHeqPBnoYTH_qsggEmKsF7mJ_2wMrE,1657
+PyDiffGame/_typing.py,sha256=HErUHmfzvkWLPWT1YJl_gpFYZctjkPqsnw3TeHuuggs,912
+PyDiffGame/base.py,sha256=hurrmsjCRQ049rHQGDa78JUBkCbLs-ZufDF8eHW5oNk,17287
+PyDiffGame/comparison.py,sha256=lJVhceZE7FqaNUGu8q1mA6GS0dbBwYFF1mHn0hzKuwM,4145
+PyDiffGame/continuous.py,sha256=W0ZhLX5UT9MFdAKridf5jWsApkTo3WxfGw_l_t2reQk,8924
+PyDiffGame/discrete.py,sha256=s62Fhx6H4okfalsopOwW2kp9onnnArHK7tkLnAUd3Zc,8127
+PyDiffGame/lqr.py,sha256=tcmL2wY_PtNon0XxdWehPJRvLdc44UqzJY9fC-ZnaJ0,1057
+PyDiffGame/objective.py,sha256=mnUPEauTZJl5HE3PScXdzDX5W0pm4fU-Jfi7Lvzgz1o,3910
+PyDiffGame/plotting.py,sha256=gvcgd-T0Y5uTcq15lJX3V4l39YqjpA0jFJsP-RzWTR0,2777
+PyDiffGame/examples/InvertedPendulumComparison.py,sha256=6jhtrHariZAblaWxfnrvOwjuGKKfTVhTyxDI5k3jam8,8615
+PyDiffGame/examples/MassesWithSpringsComparison.py,sha256=JKUyaDfxKnK_N3DEUjWBIntijquZ59fEHLfmNPxSWPk,4626
+PyDiffGame/examples/PVTOL.py,sha256=AQz_CFYw6oi9Qc2SXNFx1OIdtQTSDhqNSK02nPCDwuk,6542
+PyDiffGame/examples/PVTOLComparison.py,sha256=6zbV2uVWdGdH3bksCmDKHkrFl0nU3CxslsGH3YsTqPU,3763
+PyDiffGame/examples/QuadRotorControl.py,sha256=C5ihfYsp_6v8mIw1985W2_BCX4TlONDwR1y6iAAZu10,20440
 PyDiffGame/examples/figures/PVTOL0001.png,sha256=hvXu1bRjOEACZ-b3DpHCukzxlqV9ziwg-8sBxgCPV6w,79438
 PyDiffGame/examples/figures/PVTOL001.png,sha256=SThECsj1qoBJkhwGC4vTfM9jX9viJ1XxcfqWxTVrOps,77507
 PyDiffGame/examples/figures/PVTOL01.png,sha256=q_FR9yMxRooXisIVN_ZWzAu3tNAYagvbUU4c94f6NtE,79290
@@ -31,7 +33,7 @@ PyDiffGame/examples/figures/PVTOL/PVTOL1.png,sha256=FBgKQSal5ZNyBsGz4RaVye0HBBQU
 PyDiffGame/examples/figures/PVTOL/PVTOL10.png,sha256=XyoLMz5WKfg3ny2JxVxVd1Mxjz9WQQn7N87-8YDLisY,77894
 PyDiffGame/examples/figures/PVTOL/PVTOL100.png,sha256=wkMdqrn9hSsIdU-Yhiki3X2fQ7dRRkfLyvBCFx5cMWI,75698
 PyDiffGame/examples/figures/PVTOL/PVTOL1000.png,sha256=Hg_hsf9gnc1HqC4JVjATVay7uDlnIqBRkG8lzpcfiZ0,77630
-pydiffgame-0.1.2.dist-info/METADATA,sha256=2Ojsxsj5rdulRMJ_SgjP_wfooBdDoYH7jry2ZRIszXU,14281
-pydiffgame-0.1.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-pydiffgame-0.1.2.dist-info/licenses/LICENSE,sha256=IYfdsBdqL9SmCEWsXUBTYh303LOWQQRCOUOfZI7PWz8,1139
-pydiffgame-0.1.2.dist-info/RECORD,,
+pydiffgame-2.0.0.dist-info/METADATA,sha256=ZIqiy-9etdpsJTmpB_K3dfzs97q1NuLQmSQzG2iVuwE,19783
+pydiffgame-2.0.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+pydiffgame-2.0.0.dist-info/licenses/LICENSE,sha256=IYfdsBdqL9SmCEWsXUBTYh303LOWQQRCOUOfZI7PWz8,1139
+pydiffgame-2.0.0.dist-info/RECORD,,

{pydiffgame-0.1.2.dist-info → pydiffgame-2.0.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.30.1
 Root-Is-Purelib: true
 Tag: py3-none-any

PyDiffGame/ContinuousPyDiffGame.py

@@ -1,275 +0,0 @@
-import contextlib
-import os
-import sys
-import numpy as np
-from scipy.integrate import odeint
-from numpy.linalg import eigvals, inv
-from typing import Sequence, Optional, Union
-
-from PyDiffGame.PyDiffGame import PyDiffGame
-from PyDiffGame.Objective import Objective
-
-
-class ContinuousPyDiffGame(PyDiffGame):
-    """
-    Continuous differential game base class
-
-
-    Considers control design according to the system:
-    dx(t)/dt = A x(t) + sum_{j=1}^N B_j v_j(t)
-    """
-
-    def __init__(self,
-                 A: np.array,
-                 B: Optional[np.array] = None,
-                 Bs: Optional[Sequence[np.array]] = None,
-                 Qs: Optional[Sequence[np.array]] = None,
-                 Rs: Optional[Sequence[np.array]] = None,
-                 Ms: Optional[Sequence[np.array]] = None,
-                 objectives: Optional[Sequence[Objective]] = None,
-                 x_0: Optional[np.array] = None,
-                 x_T: Optional[np.array] = None,
-                 T_f: Optional[float] = None,
-                 P_f: Optional[Union[Sequence[np.array], np.array]] = None,
-                 show_legend: Optional[bool] = True,
-                 state_variables_names: Optional[Sequence[str]] = None,
-                 epsilon_x: Optional[float] = PyDiffGame._epsilon_x_default,
-                 epsilon_P: Optional[float] = PyDiffGame._epsilon_P_default,
-                 L: Optional[int] = PyDiffGame._L_default,
-                 eta: Optional[int] = PyDiffGame._eta_default,
-                 debug: Optional[bool] = False):
-
-        super().__init__(A=A,
-                         B=B,
-                         Bs=Bs,
-                         Qs=Qs,
-                         Rs=Rs,
-                         Ms=Ms,
-                         objectives=objectives,
-                         x_0=x_0,
-                         x_T=x_T,
-                         T_f=T_f,
-                         P_f=P_f,
-                         show_legend=show_legend,
-                         state_variables_names=state_variables_names,
-                         epsilon_x=epsilon_x,
-                         epsilon_P=epsilon_P,
-                         L=L,
-                         eta=eta,
-                         debug=debug)
-
-        self.__dx_dt = None
-
-        def __solve_N_coupled_diff_riccati(_: float, P_t: np.array) -> np.array:
-            """
-            odeint Coupled Differential Matrix Riccati Equations Solver function
-
-            Parameters
-            ----------
-            _: float
-                Integration point in time
-            P_t: numpy array of numpy 2-d arrays, of len(N), of shape(n, n)
-                Current integrated solution
-
-            Returns
-            ----------
-            dP_tdt: numpy array of numpy 2-d arrays, of len(N), of shape(n, n)
-                Current calculated value for the time-derivative of the matrices P_t
-            """
-            P_t = [(P_t[i * self._P_size:(i + 1) * self._P_size]).reshape(self._n, self._n) for i in range(self._N)]
-            dP_tdt = np.zeros((self._P_size,))
-            A_cl_t = self._A - sum([(B_j @ inv(R_j) if R_j.ndim > 1 else B_j / R_j) @ B_j.T @ P_t_j
-                                    for B_j, R_j, P_t_j in zip(self._Bs, self._Rs, P_t)])
-
-            for i in range(self._N):
-                P_t_i = P_t[i]
-                B_i = self._Bs[i]
-                R_ii = self._Rs[i]
-                Q_i = self._Qs[i]
-
-                dP_t_idt = - A_cl_t.T @ P_t_i - P_t_i @ A_cl_t - Q_i - P_t_i @ (B_i @ inv(R_ii)
-                                                                                if R_ii.ndim > 1
-                                                                                else B_i / R_ii) @ B_i.T @ P_t_i
-
-                dP_t_idt = dP_t_idt.reshape(self._P_size)
-                dP_tdt = dP_t_idt if not i else np.concatenate((dP_tdt, dP_t_idt), axis=0)
-
-            dP_tdt = np.ravel(dP_tdt)
-
-            return dP_tdt
-
-        self._ode_func = __solve_N_coupled_diff_riccati
-
-    def _update_K_from_last_state(self, t: int):
-        """
-        After the matrices P_i are obtained, this method updates the controllers at time t by the rule:
-        K_i(t) = R^{-1}_ii B^T_i P_i(t)
-
-        Parameters
-        ----------
-        t: int
-            Current point in time
-        """
-
-        P_t = [(self._P[t][i * self._P_size:(i + 1) * self._P_size]).reshape(self._n, self._n) for i in range(self._N)]
-        self._K = [(inv(R_ii) @ B_i.T if R_ii.ndim > 1 else 1 / R_ii * B_i.T) @ P_i
-                   for R_ii, B_i, P_i in zip(self._Rs, self._Bs, P_t)]
-
-    def _get_K_i(self, i: int) -> np.array:
-        return self._K[i]
-
-    def _get_P_f_i(self, i: int) -> np.array:
-        if len(self._P_f) == self._N:
-            return self._P_f[i]
-
-        return self._P_f[i * self._P_size:(i + 1) * self._P_size].reshape(self._n, self._n)
-
-    def _update_Ps_from_last_state(self):
-        """
-        With P_f as the terminal condition, evaluates the matrices P_i by backwards-solving this set of
-        coupled time-continuous Riccati differential equations:
-
-        dP_idt = - A^T P_i(t) - P_i(t) A - Q_i + P_i(t) sum_{j=1}^N B_j R^{-1}_{jj} B^T_j P_j(t) +
-                    [sum_{j=1, j!=i}^N P_j(t) B_j R^{-1}_{jj} B^T_j] P_i(t)
-        """
-
-        with stdout_redirected():
-            self._P = odeint(func=self._ode_func,
-                             y0=np.ravel(self._P_f),
-                             t=self._backward_time,
-                             tfirst=True)
-
-    def _solve_finite_horizon(self):
-        """
-        Considers the following set of finite-horizon cost functions:
-        J_i = x(T_f)^T F_i(T_f) x(T_f) + int_{t=0}^T_f [x(t)^T Q_i x(t) + sum_{j=1}^N u_j(t)^T R_{ij} u_j(t)] dt
-
-        In the continuous-time case, the matrices P_i can be solved for, unrelated to the controllers K_i.
-        Then when simulating the state space progression, the controllers K_i can be computed as functions of P_i
-        for each time interval
-        """
-
-        self._update_Ps_from_last_state()
-        self._converged = True
-
-    def _solve_infinite_horizon(self):
-        """
-        Considers the following finite-horizon cost functions:
-        J_i = int_{t=0}^infty [x(t)^T Q_i x(t) + sum_{j=1}^N u_j(t)^T R_{ij} u_j(t)] dt
-        """
-
-        self._converge_DREs_to_AREs()
-
-    def is_A_cl_stable(self) -> bool:
-        """
-        Tests Lyapunov stability of the closed loop:
-        A continuous dynamic system governed by the matrix A_cl has Lyapunov stability iff:
-        Re(eig) <= 0 forall eigenvalues of A_cl and there is at most one real eigenvalue at the origin
-        """
-
-        closed_loop_eigenvalues = eigvals(self._A_cl)
-        closed_loop_eigenvalues_real_values = [eig.real for eig in closed_loop_eigenvalues]
-        num_of_zeros = [int(v) for v in closed_loop_eigenvalues_real_values].count(0)
-        non_positive_eigenvalues = all([eig_real_value <= 0 for eig_real_value in closed_loop_eigenvalues_real_values])
-        at_most_one_zero_eigenvalue = num_of_zeros <= 1
-        stability = non_positive_eigenvalues and at_most_one_zero_eigenvalue
-
-        return stability
-
-    @PyDiffGame._post_convergence
-    def _solve_state_space(self):
-        """
-        Propagates the game forward through time and solves for it by solving the continuous differential equation:
-        dx(t)/dt = A_cl(t) x(t)
-        In each step, the controllers K_i are calculated with the values of P_i evaluated beforehand.
-        """
-
-        t = 0
-
-        def state_diff_eqn(x_t: np.array,
-                           _: float) -> np.array:
-            """
-            Scipy's odeint State Variables Solver function
-
-            Parameters
-            ----------
-            x_t: numpy 1-d array of shape(n)
-                Current integrated state variables
-            _: float
-                Current time
-
-            Returns
-            ----------
-            dx_t_dt: numpy 1-d array of shape(n)
-                Current calculated value for the time-derivative of the state variable vector x_t
-            """
-
-            nonlocal t
-
-            self._update_K_from_last_state(t=t)
-            self._update_A_cl_from_last_state()
-            dx_t_dt = self._A_cl @ ((x_t - self._x_T) if self._x_T is not None else x_t)
-            dx_t_dt = dx_t_dt.ravel()
-
-            if t < self._L - 1:
-                t += 1
-
-            return dx_t_dt
-
-        with stdout_redirected():
-            self._x = odeint(func=state_diff_eqn,
-                             y0=self._x_0,
-                             t=self._forward_time)
-
-    def _simulate_curr_x_T(self) -> np.array:
-
-        def state_diff_eqn(x_t: np.array,
-                           _: float) -> np.array:
-            self._update_K_from_last_state(t=-1)
-            self._update_A_cl_from_last_state()
-            dx_t_dt = self._A_cl @ ((x_t - self._x_T) if self._x_T is not None else x_t)
-
-            return dx_t_dt.ravel()
-
-        with stdout_redirected():
-            simulated_x_T = odeint(func=state_diff_eqn,
-                                   y0=self._x_0,
-                                   t=self._forward_time)[-1]
-
-        return simulated_x_T
-
-
-def fileno(file_or_fd):
-    fd = getattr(file_or_fd, 'fileno', lambda: file_or_fd)()
-    if not isinstance(fd, int):
-        raise ValueError("Expected a file (`.fileno()`) or a file descriptor")
-
-    return fd
-
-
-@contextlib.contextmanager
-def stdout_redirected(to=os.devnull,
-                      stdout=None):
-    """
-    https://stackoverflow.com/a/22434262/190597 (J.F. Sebastian)
-    """
-    if stdout is None:
-        stdout = sys.stdout
-
-    stdout_fd = fileno(stdout)
-    # copy stdout_fd before it is overwritten
-    # NOTE: `copied` is inheritable on Windows when duplicating a standard stream
-    with os.fdopen(os.dup(stdout_fd), 'wb') as copied:
-        stdout.flush()  # flush library buffers that dup2 knows nothing about
-        try:
-            os.dup2(fileno(to), stdout_fd)  # $ exec >&to
-        except ValueError:  # filename
-            with open(to, 'wb') as to_file:
-                os.dup2(to_file.fileno(), stdout_fd)  # $ exec > to
-        try:
-            yield stdout  # allow code to be run with the redirected stdout
-        finally:
-            # restore stdout to its previous value
-            # NOTE: dup2 makes stdout_fd inheritable unconditionally
-            stdout.flush()
-            os.dup2(copied.fileno(), stdout_fd)  # $ exec >&copied

PyDiffGame/DiscretePyDiffGame.py

@@ -1,359 +0,0 @@
-import numpy as np
-import scipy as sp
-
-from typing import Sequence, Optional, Union
-
-from PyDiffGame.PyDiffGame import PyDiffGame
-from PyDiffGame.Objective import Objective
-
-
-class DiscretePyDiffGame(PyDiffGame):
-    """
-    Discrete differential game base class
-
-
-    Considers control design according to the system:
-    x[k+1] = A_tilda x[k] + sum_{j=1}^N B_j_tilda v_j[k]
-
-    where A_tilda and each B_j_tilda are in discrete form, meaning they correlate to a discrete system,
-    which, at the sampling points, is assumed to be equal to some equivalent continuous system of the form:
-    dx(t)/dt = A x(t) + sum_{j=1}^N B_j v_j(t)
-
-    Parameters
-    ----------
-    is_input_discrete: boolean, optional, default = False
-        Indicates whether the input matrices A, B, Q, R are in discrete form or whether they need to be discretized
-    """
-
-    def __init__(self,
-                 A: np.array,
-                 B: Optional[np.array] = None,
-                 Bs: Optional[Sequence[np.array]] = None,
-                 Qs: Optional[Sequence[np.array]] = None,
-                 Rs: Optional[Sequence[np.array]] = None,
-                 Ms: Optional[Sequence[np.array]] = None,
-                 objectives: Optional[Sequence[Objective]] = None,
-                 is_input_discrete: Optional[bool] = False,
-                 x_0: Optional[np.array] = None,
-                 x_T: Optional[np.array] = None,
-                 T_f: Optional[float] = None,
-                 P_f: Optional[Union[Sequence[np.array], np.array]] = None,
-                 show_legend: Optional[bool] = True,
-                 state_variables_names: Optional[Sequence] = None,
-                 epsilon_x: Optional[float] = PyDiffGame._epsilon_x_default,
-                 epsilon_P: Optional[float] = PyDiffGame._epsilon_P_default,
-                 L: Optional[int] = PyDiffGame._L_default,
-                 eta: Optional[int] = PyDiffGame._eta_default,
-                 debug: Optional[bool] = False):
-
-        super().__init__(A=A,
-                         B=B,
-                         Bs=Bs,
-                         Qs=Qs,
-                         Rs=Rs,
-                         Ms=Ms,
-                         objectives=objectives,
-                         x_0=x_0,
-                         x_T=x_T,
-                         T_f=T_f,
-                         P_f=P_f,
-                         show_legend=show_legend,
-                         state_variables_names=state_variables_names,
-                         epsilon_x=epsilon_x,
-                         epsilon_P=epsilon_P,
-                         L=L,
-                         eta=eta,
-                         debug=debug
-                         )
-
-        if not is_input_discrete:
-            self.__discretize_game()
-
-        self.__K_rows_num = sum([B_i.shape[1] for B_i in self._Bs])
-
-        def __solve_for_K_k(K_k_previous: np.array,
-                            k_1: int) -> np.array:
-            """
-            fsolve Controllers Solver function
-
-            Parameters
-            ----------
-            K_k_previous: numpy array
-                The previous estimation for the controllers at the k'th sample point
-            k_1: int
-                The k+1 index
-
-            Returns
-            ----------
-            dP_tdt: list of numpy 2-d arrays, of len(N), of shape(n, n)
-                Current calculated value for the time-derivative of the matrices P_t
-            """
-
-            K_k_previous = K_k_previous.reshape((self._N,
-                                                 self.__K_rows_num,
-                                                 self._n))
-            P_k_1 = self._P[k_1]
-            K_k = np.zeros_like(K_k_previous)
-
-            for i in range(self._N):
-                i_indices = self.__get_indices_tuple(i)
-                K_k_previous_i = K_k_previous[i_indices]
-                P_k_1_i = P_k_1[i]
-                R_ii = self._R[i]
-                B_i = self._Bs[i]
-                B_i_T = B_i.T
-
-                A_cl_k_i = self._A
-
-                for j in range(self._N):
-                    if j != i:
-                        B_j = self._Bs[j]
-                        j_indices = self.__get_indices_tuple(j)
-                        K_k_previous_j = K_k_previous[j_indices]
-                        A_cl_k_i = A_cl_k_i - B_j @ K_k_previous_j
-
-                K_k_i = K_k_previous_i - np.linalg.inv(R_ii + B_i_T @ P_k_1_i @ B_i) @ B_i_T @ P_k_1_i @ A_cl_k_i
-                K_k[i_indices] = K_k_i
-
-            return K_k.ravel()
-
-        self.f_solve_func = __solve_for_K_k
-
-    def __discretize_game(self):
-        """
-        The input to the discrete game can either be given in continuous or discrete form.
-        If it is not in discrete form, the model gets discretized using this method in the following manner:
-        A = exp(delta_T A)
-        B_i = int_{t=0}^delta_T exp(tA) dt B_i
-
-        The performance index gets discretized in the following manner:
-        Q_i = Q_i * delta_T
-        R_i = Q_i / delta_T
-        """
-
-        A_tilda = np.exp(self._A * self._delta)
-        e_AT = sp.integrate.quad(lambda T: np.array([
-            np.exp(t * self._A) for t in T]).swapaxes(0, 2).swapaxes(0, 1),
-                                 a=0,
-                                 b=self._delta)[0]
-
-        self._A = A_tilda
-        B_tilda = np.array(e_AT)
-        self._Bs = [B_tilda @ B_i for B_i in self._Bs]
-        self._Q = [Q_i * self._delta for Q_i in self._Q]
-        self._R = [R_i / self._delta for R_i in self._Rs]
-
-    def __simpson_integrate_Q(self):
-        """
-        Use Simpson's approximation for the definite integral of the state cost function term:
-        x(t) ^T Q_f_i x(t) + int_{t=0}^T_f x(t) ^T Q_i x(t) ~ sum_{k=0)^K  x(t) ^T Q_i_k x(t)
-
-        where:
-        Q_i_0 = 1 / 3 * Q_i
-        Q_i_1, ..., Q_i_K-1 = 4 / 3 * Q_i
-        Q_i_2, ..., Q_i_K-2 = 2 / 3 * Q_i
-        """
-        Q = np.array(self._Q)
-        self._Q = np.zeros((self._L,
-                            self._N,
-                            self._n,
-                            self._n))
-        self._Q[0] = 1 / 3 * Q
-        self._Q[1::2] = 4 / 3 * Q
-        self._Q[::2] = 2 / 3 * Q
-
-    def __initialize_finite_horizon(self):
-        """
-        Initializes the calculated parameters for the finite horizon case by the following steps:
-            - The matrices P_i and controllers K_i are initialized randomly for all sample points
-            - The closed-loop dynamics matrix A_cl is first set to zero for all sample points
-            - The terminal conditions P_f_i are set to Q_i
-            - The resulting closed-loop dynamics matrix A_cl for the last sampling point is updated
-            - The state is initialized with its initial value, if given
-         """
-
-        self._P = np.random.rand(self._L,
-                                 self._N,
-                                 self._n,
-                                 self._n)
-        self._K = np.random.rand(self._L,
-                                 self._N,
-                                 self.__K_rows_num,
-                                 self._n)
-        self._A_cl = np.zeros((self._L,
-                               self._n,
-                               self._n))
-
-        self._P[-1] = np.array(self._Q).reshape((self._N,
-                                                 self._n,
-                                                 self._n))
-        self._update_A_cl_from_last_state(k=-1)
-        self._x = np.zeros((self._L,
-                            self._n))
-        self._x[0] = self._x_0
-
-    def __get_K_i_shape(self,
-                        i: int) -> range:
-        """
-        Returns the i'th controller shape indices
-
-        Parameters
-        ----------
-        i: int
-            The desired controller index
-        """
-
-        K_i_offset = sum([self._Bs[j].shape[1] for j in range(i)]) if i else 0
-        first_K_i_index = K_i_offset
-        second_K_i_index = first_K_i_index + self._Bs[i].shape[1]
-
-        return range(first_K_i_index, second_K_i_index)
-
-    def __get_indices_tuple(self, i: int):
-        return i, self.__get_K_i_shape(i)
-
-    def _update_K_from_last_state(self,
-                                  k_1: int):
-        """
-        After initializing, in order to solve for the controllers K_i and matrices P_i,
-        we start by solving for the controllers by the update rule:
-        K_i[k] = [ R_ii + B_i^T P_i[k+1] B_i ] ^ {-1} B_i^T P_i[k+1] [ A - sum_{j=1, j!=i}^N B_j K_j[k] ]
-
-        Parameters
-        ----------
-        k_1: int
-            The current k+1 sample index
-        """
-
-        K_k_1 = self._K[k_1]
-        K_k_0 = np.random.rand(*K_k_1.shape)
-        K_k = sp.optimize.fsolve(func=self.f_solve_func,
-                                 x0=K_k_0,
-                                 args=tuple([k_1]))
-        K_k_reshaped = np.array(K_k).reshape((self._N,
-                                              self.__K_rows_num,
-                                              self._n))
-
-        k = k_1 - 1
-
-        if self._debug:
-            f_K_k = self.f_solve_func(K_k_previous=K_k, k_1=k)
-            close_to_zero_array = np.isclose(f_K_k, np.zeros_like(K_k))
-            is_close_to_zero = all(close_to_zero_array)
-            print(f"The current solution is {'NOT ' if not is_close_to_zero else ''}close to zero"
-                  f"\nK_k:\n{K_k_reshaped}\nf_K_k:\n{f_K_k}")
-
-        self._K[k] = K_k_reshaped
-
-    def _get_K_i(self,
-                 i: int,
-                 k: int) -> np.array:
-        return self._K[k][self.__get_indices_tuple(i)]
-
-    def _get_P_f_i(self,
-                   i: int) -> np.array:
-        return self._P_f[i]
-
-    def _update_Ps_from_last_state(self,
-                                   k_1: int):
-        """
-        Updates the matrices P_i with
-        A_cl[k] = A - sum_{i=1}^N B_i K_i[k]
-
-        Parameters
-        ----------
-        k_1: int
-            The current k'th sample index
-        """
-
-        k = k_1 - 1
-        P_k_1 = self._P[k_1]
-        K_k = self._K[k]
-        A_cl_k = self._A_cl[k]
-        P_k = np.zeros_like(P_k_1)
-
-        for i in range(self._N):
-            i_indices = self.__get_indices_tuple(i)
-            K_k_i = K_k[i_indices]
-            K_k_i_T = K_k_i.T
-            P_k_1_i = P_k_1[i]
-            R_ii = self._R[i]
-            Q_i = self._Q[i]
-
-            P_k[i] = A_cl_k.T @ P_k_1_i @ A_cl_k + (K_k_i_T @ R_ii if R_ii.ndim > 1 else K_k_i_T * R_ii) @ K_k_i + Q_i
-
-        self._P[k] = P_k
-
-    def is_A_cl_stable(self,
-                       k: int) -> bool:
-        """
-        Tests Lyapunov stability of the closed loop:
-        A discrete dynamic system governed by the matrix A_cl has Lyapunov stability iff:
-        |eig| <= 1 forall eigenvalues of A_cl
-        """
-
-        A_cl_k = self._A_cl[k]
-        A_cl_k_eigenvalues = np.linalg.eigvals(A_cl_k)
-        A_cl_k_eigenvalues_absolute_values = [abs(eig) for eig in A_cl_k_eigenvalues]
-
-        if self._debug:
-            print(A_cl_k_eigenvalues_absolute_values)
-
-        stability = all([eig_norm < 1 for eig_norm in A_cl_k_eigenvalues_absolute_values])
-
-        return stability
-
-    def _solve_finite_horizon(self):
-        """
-        Solves the system with the finite-horizon cost functions:
-        J_i = sum_{k=1}^T_f [ x[k]^T Q_i x[k] + sum_{j=1}^N u_j[k]^T R_{ij} u_j[k] ]
-
-        In the discrete-time case, the matrices P_i have to be solved simultaneously with the controllers K_i
-        """
-
-        pass
-
-    def _solve_infinite_horizon(self):
-        """
-        Solves the system with the infinite-horizon cost functions:
-        J_i = sum_{k=1}^infty [ x[k]^T Q_i x[k] + sum_{j=1}^N u_j[k]^T R_{ij} u_j[k] ]
-        """
-
-        self.__initialize_finite_horizon()
-
-        for backwards_index, t in enumerate(self._backward_time[:-1]):
-            k_1 = self._L - 1 - backwards_index
-            k = k_1 - 1
-
-            if self._debug:
-                print('#' * 30 + f' t = {round(t, 3)} ' + '#' * 30)
-
-            self._update_K_from_last_state(k_1=k_1)
-
-            if self._debug:
-                print(f'K_k+1:\n{self._K[k_1]}')
-
-            self._update_A_cl_from_last_state(k=k)
-
-            if self._debug:
-                print(f'A_cl_k:\n{self._A_cl[k]}')
-                stable_k = self.is_A_cl_stable(k)
-                print(f"The system is {'NOT ' if not stable_k else ''}stable")
-
-            self._update_Ps_from_last_state(k_1=k_1)
-
-    @PyDiffGame._post_convergence
-    def _solve_state_space(self):
-        """
-        Propagates the game through time and solves for it by solving the discrete difference equation:
-        x[k+1] = A_cl[k] x[k]
-        In each step, the controllers K_i are calculated with the values of P_i evaluated beforehand.
-        """
-
-        x_1_k = self._x_0
-
-        for k in range(1, self._L - 1):
-            A_cl_k = self._A_cl[k]
-            x_k = A_cl_k @ x_1_k
-            self._x[k] = x_k
-            x_1_k = x_k