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

PyDiffGame/LQR.py

@@ -1,73 +0,0 @@
-import numpy as np
-from typing import Sequence, Optional
-from abc import ABC
-
-from PyDiffGame.PyDiffGame import PyDiffGame
-from PyDiffGame.ContinuousPyDiffGame import ContinuousPyDiffGame
-from PyDiffGame.DiscretePyDiffGame import DiscretePyDiffGame
-from PyDiffGame.Objective import LQRObjective
-
-
-class LQR(PyDiffGame, ABC):
-    """
-    LQR abstract base class
-
-
-    Considers a differential game with only one objective
-    """
-
-    def __init__(self,
-                 A: np.array,
-                 B: np.array,
-                 objective: LQRObjective,
-                 x_0: Optional[np.array] = None,
-                 x_T: Optional[np.array] = None,
-                 T_f: Optional[float] = None,
-                 P_f: Optional[np.array] = None,
-                 show_legend: Optional[bool] = True,
-                 state_variables_names: Optional[Sequence[str]] = None,
-                 epsilon_x: Optional[float] = PyDiffGame._epsilon_x_default,
-                 L: Optional[int] = PyDiffGame._L_default,
-                 eta: Optional[int] = PyDiffGame._eta_default,
-                 debug: Optional[bool] = False):
-        super().__init__(A=A,
-                         B=B,
-                         objectives=[objective],
-                         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,
-                         L=L,
-                         eta=eta,
-                         debug=debug)
-
-
-class ContinuousLQR(LQR, ContinuousPyDiffGame):
-    """
-    Continuous LQR marker class
-
-
-    Considers control design according to the system:
-    dx(t)/dt = A x(t) + B u(t)
-    """
-
-    pass
-
-
-class DiscreteLQR(LQR, DiscretePyDiffGame):
-    """
-    Discrete LQR marker class
-
-
-    Considers control design according to the system:
-    x[k+1] = A_tilda x[k] +  B_tilda u[k]
-
-    where A_tilda and B_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) +  B u(t)
-    """
-
-    pass

PyDiffGame/Objective.py

@@ -1,62 +0,0 @@
-import numpy as np
-from abc import ABC
-
-
-class Objective(ABC):
-    """
-    Objective abstract base class
-
-
-    Parameters
-    ----------
-    Q: 2-d np.array of shape(n, n)
-        Cost function state weights for the objective
-    R_ii: 2-d np.array of shape(m_i, m_i)
-        Cost function input weights for the objective with regard to the i'th input
-    """
-
-    def __init__(self,
-                 Q: np.array,
-                 R_ii: np.array):
-        self._Q = Q
-        self._R_ii = R_ii
-
-    @property
-    def Q(self) -> np.array:
-        return self._Q
-
-    @property
-    def R(self) -> np.array:
-        return self._R_ii
-
-
-class LQRObjective(Objective):
-    """
-    LQR objective marker class
-    """
-
-    pass
-
-
-class GameObjective(Objective):
-    """
-    Game objective class
-
-
-    Parameters
-    ----------
-    M_i: 2-d np.array of shape(m_i, m)
-        Division matrix for the i'th virtual input
-    """
-
-    def __init__(self,
-                 Q: np.array,
-                 R_ii: np.array,
-                 M_i: np.array):
-        self.__M_i = M_i
-        super().__init__(Q=Q,
-                         R_ii=R_ii)
-
-    @property
-    def M_i(self) -> np.array:
-        return self.__M_i