PyDiffGame 0.1.1__py3-none-any.whl → 1.0.0__py3-none-any.whl

PyDiffGame/ContinuousPyDiffGame.py

@@ -4,7 +4,7 @@ import sys
 import numpy as np
 from scipy.integrate import odeint
 from numpy.linalg import eigvals, inv
-from typing import Sequence, Optional
+from typing import Sequence, Optional, Union
 
 from PyDiffGame.PyDiffGame import PyDiffGame
 from PyDiffGame.Objective import Objective
@@ -30,7 +30,7 @@ class ContinuousPyDiffGame(PyDiffGame):
                  x_0: Optional[np.array] = None,
                  x_T: Optional[np.array] = None,
                  T_f: Optional[float] = None,
-                 P_f: Optional[Sequence[np.array] | np.array] = 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,

PyDiffGame/DiscretePyDiffGame.py

@@ -1,7 +1,7 @@
 import numpy as np
 import scipy as sp
-import quadpy
-from typing import Sequence, Optional
+
+from typing import Sequence, Optional, Union
 
 from PyDiffGame.PyDiffGame import PyDiffGame
 from PyDiffGame.Objective import Objective
@@ -37,14 +37,13 @@ class DiscretePyDiffGame(PyDiffGame):
                  x_0: Optional[np.array] = None,
                  x_T: Optional[np.array] = None,
                  T_f: Optional[float] = None,
-                 P_f: Optional[Sequence[np.array] | np.array] = 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,
-                 force_finite_horizon: Optional[bool] = False,
                  debug: Optional[bool] = False):
 
         super().__init__(A=A,
@@ -64,7 +63,6 @@ class DiscretePyDiffGame(PyDiffGame):
                          epsilon_P=epsilon_P,
                          L=L,
                          eta=eta,
-                         force_finite_horizon=force_finite_horizon,
                          debug=debug
                          )
 
@@ -134,12 +132,13 @@ class DiscretePyDiffGame(PyDiffGame):
         """
 
         A_tilda = np.exp(self._A * self._delta)
-        e_AT = quadpy.quad(f=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]
+        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 = e_AT
+        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]

PyDiffGame/PyDiffGame.py

@@ -9,7 +9,7 @@ import matplotlib.pyplot as plt
 import scipy as sp
 import sympy
 import warnings
-from typing import Callable, Final, ClassVar, Optional, Sequence
+from typing import Callable, Final, ClassVar, Optional, Sequence, Union
 from abc import ABC, abstractmethod
 
 from PyDiffGame.Objective import Objective, GameObjective, LQRObjective
@@ -122,7 +122,7 @@ class PyDiffGame(ABC, Callable, Sequence):
                  x_0: Optional[np.array] = None,
                  x_T: Optional[np.array] = None,
                  T_f: Optional[float] = None,
-                 P_f: Optional[Sequence[np.array] | np.array] = 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] = _epsilon_x_default,
@@ -162,7 +162,6 @@ class PyDiffGame(ABC, Callable, Sequence):
                     self._M_inv = np.linalg.inv(self._M)
                 except np.linalg.LinAlgError:
                     self._M_inv = np.linalg.pinv(self._M)
-                    print(np.linalg.matrix_rank(self._M_inv))
                 l = 0
                 self._Bs = []
 
@@ -445,7 +444,15 @@ class PyDiffGame(ABC, Callable, Sequence):
         self._fig = plt.figure(dpi=150)
         self._fig.set_size_inches(8, 6)
         plt.plot(t[:temporal_variables.shape[0]], temporal_variables)
-        plt.xlabel('Time $[s]$')
+        plt.xlabel('Time $[s]$', fontsize=18)
+        plt.xticks(fontsize=18)
+        plt.yticks(fontsize=18)
+        plt.subplots_adjust(wspace=0)
+
+        if not is_P and max(np.max(temporal_variables, axis=0)) > 1e3:
+            plt.ticklabel_format(style='sci', axis='y', scilimits=(0, 0))
+            plt.gca().yaxis.get_offset_text().set_size(18)
+
 
         if title:
             plt.title(title)
@@ -467,10 +474,10 @@ class PyDiffGame(ABC, Callable, Sequence):
 
             plt.legend(labels=labels,
                        loc='upper left' if is_P else 'right',
-                       ncol=2,
-                       prop={'size': 14},
-                       bbox_to_anchor=(1, 0.75),
-                       # framealpha=0.3
+                       ncol=4 if self._n > 8 else 2,
+                       prop={'size': 26},
+                       bbox_to_anchor=(1, 0.55),
+                       framealpha=0.3
                        )
 
         plt.grid()
@@ -529,7 +536,7 @@ class PyDiffGame(ABC, Callable, Sequence):
         self.__plot_temporal_variables(t=self._forward_time,
                                        temporal_variables=state_variables,
                                        is_P=False,
-                                       title=self.__get_temporal_state_variables_title(linear_system=linear_system),
+                                       # title=self.__get_temporal_state_variables_title(linear_system=linear_system),
                                        output_variables_names=output_variables_names)
 
     def __plot_x(self):
@@ -543,7 +550,7 @@ class PyDiffGame(ABC, Callable, Sequence):
                C: np.array,
                output_variables_names: Optional[Sequence[str]] = None,
                save_figure: Optional[bool] = False,
-               figure_path: Optional[str | Path] = _default_figures_filename,
+               figure_path: Optional[Union[str, Path]] = _default_figures_filename,
                figure_filename: Optional[str] = _default_figures_filename):
         """
         Plots an output vector y = C x^T wth respect to time
@@ -572,7 +579,7 @@ class PyDiffGame(ABC, Callable, Sequence):
 
     @_post_convergence
     def __save_figure(self,
-                      figure_path: Optional[str | Path] = _default_figures_filename,
+                      figure_path: Optional[Union[str, Path]] = _default_figures_filename,
                       figure_filename: Optional[str] = _default_figures_filename):
         """
         Saves the current figure
@@ -1150,7 +1157,7 @@ class PyDiffGame(ABC, Callable, Sequence):
                  M: Optional[np.array] = None,
                  output_variables_names: Optional[Sequence[str]] = None,
                  save_figure: Optional[bool] = False,
-                 figure_path: Optional[str | Path] = _default_figures_path,
+                 figure_path: Optional[Union[str, Path]] = _default_figures_path,
                  figure_filename: Optional[str] = _default_figures_filename,
                  print_characteristic_polynomials: Optional[bool] = False,
                  print_eigenvalues: Optional[bool] = False):

PyDiffGame/PyDiffGameLQRComparison.py

@@ -1,13 +1,12 @@
 import numpy as np
 from tqdm import tqdm
 from time import time
-from termcolor import colored
 from pathlib import Path
 import itertools
 from concurrent.futures import ProcessPoolExecutor
 
 import inspect
-from typing import Sequence, Any, Optional, Callable
+from typing import Sequence, Any, Optional, Callable, Union
 from abc import ABC
 
 from PyDiffGame.PyDiffGame import PyDiffGame
@@ -35,9 +34,9 @@ class PyDiffGameLQRComparison(ABC, Callable, Sequence):
     def __init__(self,
                  args: dict[str, Any],
                  games_objectives: Sequence[Sequence[GameObjective]],
-                 M: np.array,
+                 M: np.array = None,
                  continuous: bool = True):
-        GameClass = ContinuousPyDiffGame if continuous else DiscretePyDiffGame
+        game_class = ContinuousPyDiffGame if continuous else DiscretePyDiffGame
 
         self.__args = args
         self.__verify_input()
@@ -47,7 +46,7 @@ class PyDiffGameLQRComparison(ABC, Callable, Sequence):
         self.__M = M
 
         for i, game_i_objectives in enumerate(games_objectives):
-            game_i = GameClass(**self.__args | {'objectives': [o for o in game_i_objectives]})
+            game_i = game_class(**self.__args | {'objectives': [o for o in game_i_objectives]})
             self._games[i] = game_i
 
             if game_i.is_LQR():
@@ -110,8 +109,9 @@ class PyDiffGameLQRComparison(ABC, Callable, Sequence):
                  plot_Mx: Optional[bool] = False,
                  output_variables_names: Optional[Sequence[str]] = None,
                  save_figure: Optional[bool] = False,
-                 figure_path: Optional[str | Path] = PyDiffGame.default_figures_path,
-                 figure_filename: Optional[str | Callable[[PyDiffGame], str]] = PyDiffGame.default_figures_filename,
+                 figure_path: Optional[Union[str, Path]] = PyDiffGame.default_figures_path,
+                 figure_filename: Optional[Union[str, Callable[[PyDiffGame], str]]] =
+                 PyDiffGame.default_figures_filename,
                  run_animations: Optional[bool] = True,
                  print_characteristic_polynomials: Optional[bool] = False,
                  print_eigenvalues: Optional[bool] = False):
@@ -134,7 +134,7 @@ class PyDiffGameLQRComparison(ABC, Callable, Sequence):
                 self.__run_animation(i=i)
 
     @staticmethod
-    def run_multiprocess(multiprocess_worker_function: Callable[[Any], None],
+    def run_multiprocess(multiprocess_worker_function: Callable,
                          values: Sequence[Sequence]):
         t_start = time()
         combos = list(itertools.product(*values))
@@ -147,8 +147,7 @@ class PyDiffGameLQRComparison(ABC, Callable, Sequence):
 
             for combo, submittal in tqdm(iterable=submittals.items(), total=len(submittals)):
                 values = combo[1:-1].split(delimiter)
-                print_str = f"""{colored(text=f"{delimiter.join([f'{n}={v}' for n, v in zip(names, values)])}", 
-                                            color='blue')}"""
+                print_str = f"{delimiter.join([f'{n}={v}' for n, v in zip(names, values)])}"
                 print(print_str)
                 submittal.result()
 

PyDiffGame/examples/InvertedPendulumComparison.py

@@ -0,0 +1,257 @@
+from __future__ import annotations
+
+import numpy as np
+import scipy as sp
+from time import time
+import matplotlib
+import matplotlib.pyplot as plt
+
+from typing import Optional
+
+from PyDiffGame.PyDiffGame import PyDiffGame
+from PyDiffGame.PyDiffGameLQRComparison import PyDiffGameLQRComparison
+from PyDiffGame.Objective import GameObjective, LQRObjective
+
+
+class InvertedPendulumComparison(PyDiffGameLQRComparison):
+    def __init__(self,
+                 m_c: float,
+                 m_p: float,
+                 p_L: float,
+                 q: float,
+                 r: Optional[float] = 1,
+                 x_0: Optional[np.array] = None,
+                 x_T: Optional[np.array] = None,
+                 T_f: Optional[float] = 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):
+        self.__m_c = m_c
+        self.__m_p = m_p
+        self.__p_L = p_L
+        self.__l = self.__p_L / 2  # CoM of uniform rod
+        self.__I = 1 / 12 * self.__m_p * self.__p_L ** 2  # center mass moment of inertia of uniform rod
+
+        # # original linear system
+        linearized_D = self.__m_c * self.__m_p * self.__l ** 2 + self.__I * (self.__m_c + self.__m_p)
+        a32 = self.__m_p * PyDiffGame.g * self.__l ** 2 / linearized_D
+        a42 = self.__m_p * PyDiffGame.g * self.__l * (self.__m_c + self.__m_p) / linearized_D
+        A = np.array([[0, 0, 1, 0],
+                      [0, 0, 0, 1],
+                      [0, a32, 0, 0],
+                      [0, a42, 0, 0]])
+
+        b21 = (m_p * self.__l ** 2 + self.__I) / linearized_D
+        b31 = m_p * self.__l / linearized_D
+        b22 = b31
+        b32 = (m_c + m_p) / linearized_D
+        B = np.array([[0, 0],
+                      [0, 0],
+                      [b21, b22],
+                      [b31, b32]])
+
+        M1 = B[2, :].reshape(1, 2)
+        M2 = B[3, :].reshape(1, 2)
+        Ms = [M1, M2]
+
+        Q_x = q * np.array([[1, 0, 2, 0],
+                            [0, 0, 0, 0],
+                            [2, 0, 4, 0],
+                            [0, 0, 0, 0]])
+        Q_theta = q * np.array([[0, 0, 0, 0],
+                                [0, 1, 0, 2],
+                                [0, 0, 0, 0],
+                                [0, 2, 0, 4]])
+        Q_lqr = Q_theta + Q_x
+        Qs = [Q_x, Q_theta]
+
+        R_lqr = np.diag([r] * 2)
+        Rs = [np.array([r])] * 2
+
+        self.__origin = (0.0, 0.0)
+
+        state_variables_names = ['x',
+                                 '\\theta',
+                                 '\\dot{x}',
+                                 '\\dot{\\theta}']
+
+        args = {'A': A,
+                'B': B,
+                'x_0': x_0,
+                'x_T': x_T,
+                'T_f': T_f,
+                'state_variables_names': state_variables_names,
+                'epsilon_x': epsilon_x,
+                'epsilon_P': epsilon_P,
+                'L': L,
+                'eta': eta,
+                'force_finite_horizon': T_f is not None}
+
+        lqr_objective = [LQRObjective(Q=Q_lqr, R_ii=R_lqr)]
+        game_objectives = [GameObjective(Q=Q, R_ii=R, M_i=M_i) for Q, R, M_i in zip(Qs, Rs, Ms)]
+        games_objectives = [lqr_objective, game_objectives]
+
+        super().__init__(args=args,
+                         games_objectives=games_objectives,
+                         continuous=True)
+
+    def __simulate_non_linear_system(self,
+                                     i: int,
+                                     plot: bool = False) -> np.array:
+        game = self._games[i]
+        K = game.K
+        x_T = game.x_T
+
+        def nonlinear_state_space(_, x_t: np.array) -> np.array:
+            x_t = x_t - x_T
+
+            if game.is_LQR():
+                u_t = - K[0] @ x_t
+                F_t, M_t = u_t.T
+            else:
+                K_x, K_theta = K
+                v_x = - K_x @ x_t
+                v_theta = - K_theta @ x_t
+                v = np.array([v_x, v_theta])
+                F_t, M_t = game.M_inv @ v
+
+            x, theta, x_dot, theta_dot = x_t
+
+            theta_ddot = 1 / (
+                    self.__m_p * self.__l ** 2 + self.__I - (self.__m_p * self.__l) ** 2 * np.cos(theta) ** 2 /
+                    (self.__m_p + self.__m_c)) * (M_t - self.__m_p * self.__l *
+                                                  (np.cos(theta) / (self.__m_p + self.__m_c) *
+                                                   (F_t + self.__m_p * self.__l * np.sin(theta)
+                                                    * theta_dot ** 2) + PyDiffGame.g * np.sin(theta)))
+            x_ddot = 1 / (self.__m_p + self.__m_c) * (F_t + self.__m_p * self.__l * (np.sin(theta) * theta_dot ** 2 -
+                                                                                     np.cos(theta) * theta_ddot))
+            if isinstance(theta_ddot, np.ndarray):
+                theta_ddot = theta_ddot[0]
+                x_ddot = x_ddot[0]
+
+            non_linear_x = np.array([x_dot, theta_dot, x_ddot, theta_ddot],
+                                    dtype=float)
+
+            return non_linear_x
+
+        pendulum_state = sp.integrate.solve_ivp(fun=nonlinear_state_space,
+                                                t_span=[0.0, game.T_f],
+                                                y0=game.x_0,
+                                                t_eval=game.forward_time,
+                                                rtol=game.epsilon)
+
+        Y = pendulum_state.y
+
+        if plot:
+            game.plot_state_variables(state_variables=Y.T,
+                                      linear_system=False)
+
+        return Y
+
+    def __run_animation(self,
+                        i: int) -> (matplotlib.lines.Line2D, matplotlib.patches.Rectangle):
+        game = self._games[i]
+        game._x_non_linear = self.__simulate_non_linear_system(i=i,
+                                                               plot=True)
+        x_t, theta_t, x_dot_t, theta_dot_t = game._x_non_linear
+
+        pendulumArm = matplotlib.lines.Line2D(xdata=self.__origin,
+                                              ydata=self.__origin,
+                                              color='r')
+        cart = matplotlib.patches.Rectangle(xy=self.__origin,
+                                            width=0.5,
+                                            height=0.15,
+                                            color='b')
+
+        fig = plt.figure()
+        x_max = max(abs(max(x_t)), abs(min(x_t)))
+        square_side = 1.1 * min(max(self.__p_L, x_max), 3 * self.__p_L)
+
+        ax = fig.add_subplot(111,
+                             aspect='equal',
+                             xlim=(-square_side, square_side),
+                             ylim=(-square_side, square_side),
+                             title=f"Inverted Pendulum {'LQR' if game.is_LQR() else 'Game'} Simulation")
+
+        def init() -> (matplotlib.lines.Line2D, matplotlib.patches.Rectangle):
+            ax.add_patch(cart)
+            ax.add_line(pendulumArm)
+
+            return pendulumArm, cart
+
+        def animate(i: int) -> (matplotlib.lines.Line2D, matplotlib.patches.Rectangle):
+            x_i, theta_i = x_t[i], theta_t[i]
+            pendulum_x_coordinates = [x_i, x_i + self.__p_L * np.sin(theta_i)]
+            pendulum_y_coordinates = [0, - self.__p_L * np.cos(theta_i)]
+            pendulumArm.set_xdata(x=pendulum_x_coordinates)
+            pendulumArm.set_ydata(y=pendulum_y_coordinates)
+
+            cart_x_y = [x_i - cart.get_width() / 2, - cart.get_height()]
+            cart.set_xy(xy=cart_x_y)
+
+            return pendulumArm, cart
+
+        ax.grid()
+        t0 = time()
+        animate(0)
+        t1 = time()
+
+        frames = game.L
+        interval = game.T_f - (t1 - t0)
+
+        anim = matplotlib.animationFuncAnimation(fig=fig,
+                                                 func=animate,
+                                                 init_func=init,
+                                                 frames=frames,
+                                                 interval=interval,
+                                                 blit=True)
+        plt.show()
+
+
+def multiprocess_worker_function(x_T: float,
+                                 theta_0: float,
+                                 m_c: float,
+                                 m_p: float,
+                                 p_L: float,
+                                 q: float,
+                                 epsilon_x: float,
+                                 epsilon_P: float) -> int:
+    x_T = np.array([x_T,  # x
+                    theta_0,  # theta
+                    0,  # x_dot
+                    0]  # theta_dot
+                   )
+    x_0 = np.zeros_like(x_T)
+
+    inverted_pendulum_comparison = \
+        InvertedPendulumComparison(m_c=m_c,
+                                   m_p=m_p,
+                                   p_L=p_L,
+                                   q=q,
+                                   x_0=x_0,
+                                   x_T=x_T,
+                                   epsilon_x=epsilon_x,
+                                   epsilon_P=epsilon_P)  # game class
+    is_max_lqr = \
+        inverted_pendulum_comparison(plot_state_spaces=False,
+                                     run_animations=False
+                                     )
+
+    # inverted_pendulum_comparison.plot_two_state_spaces(non_linear=True)
+    return int(is_max_lqr)
+
+
+if __name__ == '__main__':
+    x_Ts = [10 ** p for p in [2]]
+    theta_Ts = [np.pi / 2 + np.pi / n for n in [10]]
+    m_cs = [10 ** p for p in [1, 2]]
+    m_ps = [10 ** p for p in [0, 1, 2]]
+    p_Ls = [10 ** p for p in [0, 1]]
+    qs = [10 ** p for p in [-2, -1, 0, 1]]
+    epsilon_xs = [10 ** (-7)]
+    epsilon_Ps = [10 ** (-3)]
+    params = [x_Ts, theta_Ts, m_cs, m_ps, p_Ls, qs, epsilon_xs, epsilon_Ps]
+
+    PyDiffGameLQRComparison.run_multiprocess(multiprocess_worker_function=multiprocess_worker_function,
+                                             values=params)