pybounds 0.0.5__py3-none-any.whl → 0.0.7__py3-none-any.whl

pybounds/__init__.py

@@ -6,6 +6,8 @@ from .observability import SlidingEmpiricalObservabilityMatrix
 from .observability import FisherObservability
 from .observability import SlidingFisherObservability
 from .observability import ObservabilityMatrixImage
+from .observability import transform_states
+from .observability import SymbolicJacobian
 
 from .util import colorline
 

pybounds/jacobian.py

@@ -0,0 +1,46 @@
+import sympy as sp
+import numpy as np
+
+
+class SymbolicJacobian:
+    def __init__(self, func, state_vars):
+        """
+        Initialize the Jacobian calculator with a function or symbolic expression for f(x).
+
+        :param func: A Python function or sympy Matrix representing f(x).
+                     If func is a Python function, it should take in x and u (e.g., f(x))
+                     and return a sympy Matrix for xdot.
+                     If func is a sympy Matrix, it directly represents xdot.
+        :param state_vars: List of sympy symbols for variables (e.g., [x1, x2]).
+        """
+
+        self.state_vars = sp.Matrix(state_vars)  # state variables as sympy Matrix
+
+        # Detect if func is symbolic (sympy.Matrix) or a Python function
+        if isinstance(func, sp.Matrix):
+            # If func is a symbolic Matrix, use it directly as xdot
+            self.z_sym = func
+        else:
+            # If func is a Python function, call it with symbolic state and control variables
+            x_sym = self.state_vars
+            self.z_sym = func(x_sym)  # get the symbolic expression from the function
+
+        # Calculate the Jacobian of xdot_sym with respect to the state variables
+        self.jacobian_symbolic = self.z_sym.jacobian(self.state_vars)
+        self.jacobian_symbolic = sp.simplify(self.jacobian_symbolic)
+
+    def get_jacobian_function(self):
+        """
+        Returns a numerical function to evaluate the Jacobian at specific values of x and u.
+
+        :return: A function that calculates the Jacobian matrix given values of x and u.
+                 The function takes numpy arrays x and u as inputs.
+        """
+        # Convert the symbolic Jacobian to a numerical function using lambdify
+        jacobian_func = sp.lambdify(self.state_vars, self.jacobian_symbolic, 'numpy')
+
+        # Return a wrapper function that accepts x as numpy array
+        def jacobian_numerical(x):
+            return jacobian_func(*np.array(x))
+
+        return jacobian_numerical

pybounds/observability.py

@@ -9,23 +9,30 @@ import matplotlib.pyplot as plt
 from mpl_toolkits.axes_grid1.inset_locator import inset_axes
 import sympy as sp
 from .util import LatexStates
+from jacobian import SymbolicJacobian
 
 
 class EmpiricalObservabilityMatrix:
-    def __init__(self, simulator, x0, time, u, eps=1e-5, parallel=False):
+    def __init__(self, simulator, x0, u, eps=1e-5, parallel=False,
+                 z_function=None, z_state_names=None):
         """ Construct an empirical observability matrix O.
 
-        :param callable Simulator: Simulator object : y = simulator(x0, u, **kwargs)
+        :param callable simulator: simulator object  that has a method y = simulator.simulate(x0, u, **kwargs)
             y is (w x p) array. w is the number of time-steps and p is the number of measurements
         :param dict/list/np.array x0: initial state for Simulator
         :param dict/np.array u: inputs array
         :param float eps: epsilon value for perturbations to construct O, should be small number
         :param bool parallel: if True, run the perturbations in parallel
+        :param callable z_function: function that transforms coordinates from original to new states
+            must be of the form z = z_function(x), where x & z are the same size
+            should use sympy functions wherever possible
+            leave as None to maintain original coordinates
+        :param list | tuple z_state_names: (optional) names of states in new coordinates.
+            will only have an effect if O is a data-frame & z_function is not None
         """
 
         # Store inputs
         self.simulator = simulator
-        self.time = time.copy()
         self.eps = eps
         self.parallel = parallel
 
@@ -48,6 +55,9 @@ class EmpiricalObservabilityMatrix:
         # Number of outputs
         self.p = self.y_nominal.shape[1]
 
+        # Number of time-steps
+        self.w = self.y_nominal.shape[0]  # of points in time window
+
         # Check for state/measurement names
         if hasattr(self.simulator, 'state_names'):
             self.state_names = self.simulator.state_names
@@ -60,7 +70,6 @@ class EmpiricalObservabilityMatrix:
             self.measurement_names = ['y_' + str(p) for p in range(self.p)]
 
         # Perturbation amounts
-        self.w = len(self.time)  # of points in time window
         self.delta_x = eps * np.eye(self.n)  # perturbation amount for each state
         self.delta_y = np.zeros((self.p, self.n, self.w))  # preallocate delta_y
         self.y_plus = np.zeros((self.w, self.n, self.p))
@@ -80,9 +89,22 @@ class EmpiricalObservabilityMatrix:
 
         self.time_labels = np.hstack(self.time_labels)
 
-        # Run
+        # Run simulations to construct O
         self.run()
 
+        # Perform coordinate transformation on O, if specified
+        if z_function is not None:
+            self.O_df, self.dzdx, self.dxdz_sym = transform_states(O=self.O_df,
+                                                                   square_flag=False,
+                                                                   z_function=z_function,
+                                                                   x0=self.x0,
+                                                                   z_state_names=z_state_names)
+            self.state_names = tuple(self.O_df.columns)
+            self.O = self.O_df.values
+        else:
+            self.dzdx = None
+            self.dxdz_sym = None
+
     def run(self, parallel=None):
         """ Construct empirical observability matrix.
         """
@@ -149,17 +171,17 @@ class EmpiricalObservabilityMatrix:
 
 class SlidingEmpiricalObservabilityMatrix:
     def __init__(self, simulator, t_sim, x_sim, u_sim, w=None, eps=1e-5,
-                 parallel_sliding=False, parallel_perturbation=False):
+                 parallel_sliding=False, parallel_perturbation=False,
+                 z_function=None, z_state_names=None):
         """ Construct empirical observability matrix O in sliding windows along a trajectory.
 
         :param callable simulator: Simulator object : y = simulator(x0, u, **kwargs)
             y is (w x p) array. w is the number of time-steps and p is the number of measurements
-        :param np.array t_sim: time vector size N
+        :param np.array t_sim: time values along state trajectory array (N, 1)
         :param np.array x_sim: state trajectory array (N, n), can also be dict
         :param np.array u_sim: input array (N, m), can also be dict
         :param np.array w: window size for O calculations, will automatically set how many windows to compute
         :params float eps: tolerance for sliding windows
-        :param dict/np.array u: inputs array
         :param float eps: epsilon value for perturbations to construct O's, should be small number
         :param bool parallel_sliding: if True, run the sliding windows in parallel
         :param bool parallel_perturbation: if True, run the perturbations in parallel
@@ -169,6 +191,8 @@ class SlidingEmpiricalObservabilityMatrix:
         self.eps = eps
         self.parallel_sliding = parallel_sliding
         self.parallel_perturbation = parallel_perturbation
+        self.z_function = z_function
+        self.z_state_names = z_state_names
 
         # Set time vector
         self.t_sim = np.array(t_sim)
@@ -266,12 +290,14 @@ class SlidingEmpiricalObservabilityMatrix:
 
         # Pull out time & control inputs in window
         t_win = self.t_sim[win]  # time in window
-        t_win0 = t_win - t_win[0]  # start at 0
+        # t_win0 = t_win - t_win[0]  # start at 0
         u_win = self.u_sim[win, :]  # inputs in window
 
         # Calculate O for window
-        EOM = EmpiricalObservabilityMatrix(self.simulator, x0, t_win0, u_win, eps=self.eps,
-                                           parallel=self.parallel_perturbation)
+        EOM = EmpiricalObservabilityMatrix(self.simulator, x0, u_win, eps=self.eps,
+                                           parallel=self.parallel_perturbation,
+                                           z_function=self.z_function,
+                                           z_state_names=self.z_state_names)
         self.EOM = EOM
 
         # Store data
@@ -291,18 +317,18 @@ class SlidingEmpiricalObservabilityMatrix:
 
 
 class FisherObservability:
-    def __init__(self, O, R=None, sensor_noise_dict=None, lam=None):
+    def __init__(self, O, R=None, lam=None):
         """ Evaluate the observability of a state variable(s) using the Fisher Information Matrix.
 
         :param np.array O: observability matrix (w*p, n)
             w is the number of time-steps, p is the number of measurements, and n in the number of states
             can also be set as pd.DataFrame where columns set the state names & a multilevel index sets the
             measurement names: O.index names must be ('sensor', 'time_step')
-        :param np.array R: measurement noise covariance matrix (w*p x w*p)
+        :param None | np.array | float| dict  R: measurement noise covariance matrix (w*p x w*p)
             can also be set as pd.DataFrame where R.index = R.columns = O.index
-            can also be a scaler where R = R * I
-        :param dict sensor_noise_dict: constructs R by setting the noise levels for each sensor across time-steps
-            keys must correspond to the 'sensor' index in O data-frame, can only be set if R is None
+            can also be a scaler where R = R * I_(nxn)
+            can also be dict where keys must correspond to the 'sensor' index in O data-frame
+            if None, then R = I_(nxn)
         :param float lam: lamda parameter, if lam='limit' compute F^-1 symbolically, otherwise use Chernoff inverse
         """
 
@@ -314,7 +340,7 @@ class FisherObservability:
             self.sensor_names = tuple(O.index.get_level_values('sensor'))
             self.state_names = tuple(O.columns)
         elif isinstance(O, np.ndarray):  # array given
-            self.sensor_names = tuple(['y' for n in range(self.pw)])
+            self.sensor_names = tuple(['y' for _ in range(self.pw)])
             self.state_names = tuple(['x_' + str(n) for n in range(self.n)])
             self.O = pd.DataFrame(O, index=self.sensor_names, columns=self.state_names)
         else:
@@ -323,7 +349,7 @@ class FisherObservability:
         # Set measurement noise covariance matrix
         self.R = pd.DataFrame(np.eye(self.pw), index=self.O.index, columns=self.O.index)
         self.R_inv = pd.DataFrame(np.eye(self.pw), index=self.O.index, columns=self.O.index)
-        self.set_noise_covariance(R=R, sensor_noise_dict=sensor_noise_dict)
+        self.set_noise_covariance(R=R)
 
         # Calculate Fisher Information Matrix
         self.F = self.O.values.T @ self.R_inv.values @ self.O.values
@@ -352,7 +378,7 @@ class FisherObservability:
         # Pull out diagonal elements
         self.error_variance = pd.DataFrame(np.diag(self.F_inv), index=self.O.columns).T
 
-    def set_noise_covariance(self, R=None, sensor_noise_dict=None):
+    def set_noise_covariance(self, R=None):
         """ Set the measurement noise covariance matrix.
         """
 
@@ -360,19 +386,15 @@ class FisherObservability:
         self.R = pd.DataFrame(np.eye(self.pw), index=self.O.index, columns=self.O.index)
 
         # Set R based on values in dict
-        if sensor_noise_dict is not None:  # set each distinct sensor's noise level
-            if R is not None:
-                raise Exception('R can not be set directly if sensor_noise_dict is set')
-            else:
-                # for s in self.R.index.levels[0]:
-                for s in pd.unique(self.R.index.get_level_values('sensor')):
-                    R_sensor = self.R.loc[[s], [s]]
-                    for r in range(R_sensor.shape[0]):
-                        R_sensor.iloc[r, r] = sensor_noise_dict[s]
+        if isinstance(R, dict):  # set each distinct sensor's noise level
+            for s in pd.unique(self.R.index.get_level_values('sensor')):
+                R_sensor = self.R.loc[[s], [s]]
+                for r in range(R_sensor.shape[0]):
+                    R_sensor.iloc[r, r] = R[s]
 
-                    self.R.loc[[s], [s]] = R_sensor.values
+                self.R.loc[[s], [s]] = R_sensor.values
         else:
-            if R is None:
+            if R is None:  # set R as identity matrix
                 warnings.warn('R not set, defaulting to identity matrix')
             else:  # set R directly
                 if np.atleast_1d(R).shape[0] == 1:  # given scalar
@@ -381,8 +403,10 @@ class FisherObservability:
                     self.R = R.copy()
                 elif isinstance(R, np.ndarray):  # matrix in array
                     self.R = pd.DataFrame(R, index=self.R.index, columns=self.R.columns)
+                elif isinstance(R, float) or isinstance(R, int):  # set as scalar multiplied by identity matrix
+                    self.R = R * self.R
                 else:
-                    raise Exception('R must be a numpy array, pandas data-frame, or scalar value')
+                    raise Exception('R must be a dict, numpy array, pandas data-frame, or scalar value')
 
         # Inverse of R
         R_diagonal = np.diag(self.R.values)
@@ -399,22 +423,23 @@ class FisherObservability:
 
 
 class SlidingFisherObservability:
-    def __init__(self, O_list, time=None, lam=1e6, R=None, sensor_noise_dict=None,
+    def __init__(self, O_list, time=None, lam=1e6, R=None,
                  states=None, sensors=None, time_steps=None, w=None):
 
         """ Compute the Fisher information matrix & inverse in sliding windows and pull put the minimum error variance.
         :param list O_list: list of observability matrices O (stored as pd.DataFrame)
-        :param np.array time: time vector the same size as O_list
-        :param np.array lam: lamda parameter, if lam='limit' compute F^-1 symbolically, otherwise use Chernoff inverse
-        :param np.array R: measurement noise covariance matrix (w*p x w*p)
+        :param None | np.array time: time vector the same size as O_list
+        :param float | np.array lam: lamda parameter, if lam='limit' compute F^-1 symbolically, otherwise use Chernoff inverse
+        :param None | np.array | float| dict  R: measurement noise covariance matrix (w*p x w*p)
             can also be set as pd.DataFrame where R.index = R.columns = O.index
-            can also be a scaler where R = R * I
-        :param dict sensor_noise_dict: constructs R by setting the noise levels for each sensor across time-steps
-            keys must correspond to the 'sensor' index in O data-frame, can only be set if R is None
-        :param list states: list of states to use from O's. ex: ['g', 'd']
-        :param list sensors: list of sensors to use from O's, ex: ['r']
-        :param np.array time_steps: array of time steps to use from O's, ex: np.array([0, 1, 2])
-        :param np.array w: window size to use from O's, if None then just grab it from O
+            can also be a scaler where R = R * I_(nxn)
+            can also be dict where keys must correspond to the 'sensor' index in O data-frame
+            if None, then R = I_(nxn)
+        :param None | tuple | list states: list of states to use from O's. ex: ['g', 'd']
+        :param None | tuple | list sensors: list of sensors to use from O's, ex: ['r']
+        :param None | tuple | list | np.array time_steps: array of time steps to use from O's, ex: np.array([0, 1, 2])
+        :param None | tuple | list | np.array w: window size to use from O's,
+            if None then just grab it from O as the maximum window size
         """
 
         self.O_list = O_list
@@ -426,7 +451,14 @@ class SlidingFisherObservability:
         else:
             self.time = np.array(time)
 
-        self.dt = np.mean(np.diff(self.time))
+        # Set time-step
+        if time is not None:
+            if self.n_window > 1:  # compute time-step from vector
+                self.dt = np.mean(np.diff(self.time))
+            else:
+                self.dt = 0.0
+        else:  # default is time-step of 1
+            self.dt = 1
 
         # Get single O
         O = O_list[0]
@@ -456,10 +488,8 @@ class SlidingFisherObservability:
             self.time_steps = np.array(time_steps)
 
         # Compute Fisher information matrix & inverse for each sliding window
-        self.EV = []  # collect error variance data for each state over time
-        self.FO = []
-        self.shift_index = int(np.round((1 / 2) * self.w))
-        self.shift_time = self.shift_index * self.dt  # shift the time forward by half the window size
+        self.EV = []  # collect error variance data for each state over windows
+        self.FO = []  # collect FisherObservability objects over windows
         for k in range(self.n_window):  # each window
             # Get full O
             O = self.O_list[k]
@@ -468,7 +498,7 @@ class SlidingFisherObservability:
             O_subset = O.loc[(self.sensors, self.time_steps), self.states].sort_values(['time_step', 'sensor'])
 
             # Compute Fisher information & inverse
-            FO = FisherObservability(O_subset, sensor_noise_dict=sensor_noise_dict, R=R, lam=lam)
+            FO = FisherObservability(O_subset, R=R, lam=lam)
             self.FO.append(FO)
 
             # Collect error variance data
@@ -477,15 +507,75 @@ class SlidingFisherObservability:
             self.EV.append(ev)
 
         # Concatenate error variance & make same size as simulation data
+        self.shift_index = int(np.round((1 / 2) * self.w))
+        self.shift_time = self.shift_index * self.dt  # shift the time forward by half the window size
         self.EV = pd.concat(self.EV, axis=0, ignore_index=True)
-        self.EV.index = np.arange(self.shift_index, self.EV.shape[0] + self.shift_index, step=1, dtype=int)
-        time_df = pd.DataFrame(np.atleast_2d(self.time).T, columns=['time'])
-        self.EV_aligned = pd.concat((time_df, self.EV), axis=1)
+        if self.n_window > 1:  # more than 1 window
+            self.EV.index = np.arange(self.shift_index, self.EV.shape[0] + self.shift_index, step=1, dtype=int)
+            time_df = pd.DataFrame(np.atleast_2d(self.time).T, columns=['time'])
+            self.EV_aligned = pd.concat((time_df, self.EV), axis=1)
+        else:
+            self.EV_aligned = self.EV.copy()
 
     def get_minimum_error_variance(self):
         return self.EV_aligned.copy()
 
 
+def transform_states(O=None, square_flag=False, z_function=None, x0=None, z_state_names=None):
+    """ Transform the coordinates of an observability matrix (O) or Fisher information matrix (F)
+        from the original coordinates (x) to new user defined coordinates (z).
+
+        :param O: observability matrix or Fisher information matrix
+        :param boolean square_flag: whether to square the transform Jacobian or not
+            should be set to False if passing squared an observability matrix as O
+            should be set to True if passing squared a Fisher information matrix as O
+        :param callable z_function: function that transforms coordinates from original to new states
+            must be of the form z = z_function(x), where x & z are the same size
+            should use sympy functions wherever possible
+        :param np.array x0: initial state in original coordinates
+        :param list | tuple z_state_names: (optional) names of states in new coordinates.
+            will only have an effect if O or F is a data-frame
+
+        :return:
+            Z: observability matrix or Fisher information matrix in transformed coordinates
+            dzdx: numerical Jacobian dz/dx (inverse of dx/dz) evaluated at x0
+            dxdz_sym: symbolic Jacobian dx/dz
+    """
+
+    # Symbolic vector of original states
+    x_sym = sp.symbols('x_0:%d' % O.shape[1])
+
+    # Initialize the Jacobian calculator with a Python function
+    jacobian_calculator_func = SymbolicJacobian(func=z_function, state_vars=x_sym)
+
+    # Get the symbolic Jacobian dx/dz
+    dxdz_sym = jacobian_calculator_func.jacobian_symbolic
+
+    # Get the Jacobian calculator function
+    dxdz_function = jacobian_calculator_func.get_jacobian_function()
+
+    # Evaluate the Jacobian at x0
+    dxdz = dxdz_function(np.array(x0))
+
+    # Take the inverse
+    dzdx = np.linalg.inv(dxdz)
+
+    # Compute the new O or F
+    if square_flag:  # F
+        O_z = dzdx.T @ O @ dzdx
+    else:  # O
+        O_z = O @ dzdx
+
+    # Set column/index names if data-frame was passed
+    if isinstance(O_z, pd.DataFrame):
+        if z_state_names is not None:
+            O_z.columns = z_state_names
+            if square_flag:
+                O_z.index = z_state_names
+
+    return O_z, dzdx, dxdz_sym
+
+
 class ObservabilityMatrixImage:
     def __init__(self, O, state_names=None, sensor_names=None, vmax_percentile=100, vmin_ratio=1.0, cmap='bwr'):
         """ Display an image of an observability matrix.
@@ -637,4 +727,4 @@ class ObservabilityMatrixImage:
         # Store figure & axis
         self.fig = fig
         self.ax = ax
-        self.cbar = cbar
+        self.cbar = cbar

pybounds/observability_transform.py

@@ -0,0 +1,11 @@
+
+# from .observability import EmpiricalObservabilityMatrix
+#
+#
+# class DroneSimulator(EmpiricalObservabilityMatrix):
+#     def __init__(self, dt=0.1, mpc_horizon=10, r_u=1e-2, input_mode='direct', control_mode='velocity_body_level'):
+#         self.dynamics = DroneModel()
+#         super().__init__(self.dynamics.f, self.dynamics.h, dt=dt, mpc_horizon=mpc_horizon,
+#                          state_names=self.dynamics.state_names,
+#                          input_names=self.dynamics.input_names,
+#                          measurement_names=self.dynamics.measurement_names)

pybounds/simulator.py

@@ -369,12 +369,12 @@ class Simulator(object):
         y_array = np.vstack(list(self.y.values())).T
 
         if return_full_output:
-            return self.time.copy(), self.x.copy(), self.u.copy(), self.u.copy()
+            return self.time.copy(), self.x.copy(), self.u.copy(), self.y.copy()
         else:
             return y_array
 
     def get_time_states_inputs_measurements(self):
-        return self.time.copy(), self.x.copy(), self.u.copy(), self.u.copy()
+        return self.time.copy(), self.x.copy(), self.u.copy(), self.y.copy()
 
     def plot(self, name='x', dpi=150, plot_kwargs=None):
         """ Plot states, inputs.
@@ -406,7 +406,7 @@ class Simulator(object):
         ax = np.atleast_1d(ax)
 
         for n, key in enumerate(plot_dict.keys()):
-            ax[n].plot(self.time, plot_dict[key], label='set-point', **plot_kwargs)
+            ax[n].plot(self.time, plot_dict[key], label=name, **plot_kwargs)
             ax[n].set_ylabel(key, fontsize=7)
 
             # Also plot the states if plotting setpoint
@@ -414,9 +414,18 @@ class Simulator(object):
                 ax[n].plot(self.time, self.x[key], label=key, color='firebrick', linestyle='-', linewidth=0.5)
                 ax[n].legend(fontsize=6)
 
+                y = self.x[key]
+                y_min = np.min(y)
+                y_max = np.max(y)
+                delta = y_max - y_min
+                if np.abs(delta) < 0.01:
+                    margin = 0.1
+                    ax[n].set_ylim(y_min - margin, y_max + margin)
+                else:
+                    margin = 0.0
+
         ax[-1].set_xlabel('time', fontsize=7)
         ax[0].set_title(name, fontsize=8, fontweight='bold')
 
-
         for a in ax.flat:
             a.tick_params(axis='both', labelsize=6)

pybounds/util.py

@@ -1,9 +1,9 @@
-
 import numpy as np
 import matplotlib.pyplot as plt
 import matplotlib.collections as mcoll
 import matplotlib.patheffects as path_effects
 
+
 class FixedKeysDict(dict):
     def __init__(self, *args, **kwargs):
         super(FixedKeysDict, self).__init__(*args, **kwargs)
@@ -96,11 +96,46 @@ class LatexStates:
                      'v_para_dot': r'$\dot{v_{\parallel}}$',
                      'v_perp_dot': r'$\dot{v_{\perp}}$',
                      'v_para_dot_ratio': r'$\frac{\Delta v_{\parallel}}{v_{\parallel}}$',
-                     'sigma': r'$\sigma$',
-                     'rho': r'$\rho$',
-                     'beta': r'$\beta$',
-                     'lambda': r'$\lambda',
-                     'delta': r'$\delta'
+                     'x':  r'$x$',
+                     'y':  r'$y$',
+                     'v_x': r'$v_{x}$',
+                     'v_y': r'$v_{y}$',
+                     'v_z': r'$v_{z}$',
+                     'w_x': r'$w_{x}$',
+                     'w_y': r'$w_{y}$',
+                     'w_z': r'$w_{z}$',
+                     'a_x': r'$a_{x}$',
+                     'a_y': r'$a_{y}$',
+                     'vx': r'$v_x$',
+                     'vy': r'$v_y$',
+                     'vz': r'$v_z$',
+                     'wx': r'$w_x$',
+                     'wy': r'$w_y$',
+                     'wz': r'$w_z$',
+                     'ax': r'$ax$',
+                     'ay': r'$ay$',
+                     'beta': r'$\beta',
+                     'thetadot': r'$\dot{\theta}$',
+                     'theta_dot': r'$\dot{\theta}$',
+                     'psidot': r'$\dot{\psi}$',
+                     'psi_dot': r'$\dot{\psi}$',
+                     'theta': r'$\theta$',
+                     'Yaw': r'$\psi$',
+                     'R': r'$\phi$',
+                     'P': r'$\theta$',
+                     'dYaw': r'$\dot{\psi}$',
+                     'dP': r'$\dot{\theta}$',
+                     'dR': r'$\dot{\phi}$',
+                     'acc_x': r'$\dot{v}x$',
+                     'acc_y': r'$\dot{v}y$',
+                     'acc_z': r'$\dot{v}z$',
+                     'Psi': r'$\Psi$',
+                     'Ix': r'$I_x$',
+                     'Iy': r'$I_y$',
+                     'Iz': r'$I_z$',
+                     'Jr': r'$J_r$',
+                     'Dl': r'$D_l$',
+                     'Dr': r'$D_r$',
                      }
 
         if dict is not None:
@@ -162,4 +197,4 @@ def colorline(x, y, z, ax=None, cmap=plt.get_cmap('copper'), norm=None, linewidt
 
     ax.add_collection(lc)
 
-    return lc
+    return lc

{pybounds-0.0.5.dist-info → pybounds-0.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pybounds
-Version: 0.0.5
+Version: 0.0.7
 Summary: Bounding Observability for Uncertain Nonlinear Dynamics Systems (BOUNDS)
 Home-page: https://pypi.org/project/pybounds/
 Author: Ben Cellini, Burak Boyacioglu, Floris van Breugel
@@ -39,13 +39,13 @@ For a simple system
 *  Monocular camera with optic fow measurements: [mono_camera_example.ipynb](examples%2Fmono_camera_example.ipynb)
 
 For a more complex system
-*  Fly-wind: [fly_wind_example.ipynb](examples%2Ffly_wind_example.ipynb)[mono_camera_example.ipynb](examples%2Fmono_camera_example.ipynb)
+*  Fly-wind: [fly_wind_example.ipynb](examples%2Ffly_wind_example.ipynb)
 
 ## Citation
 
 If you use the code or methods from this package, please cite the following paper:
 
-Benjamin Cellini, Burak Boyacıoğlu, Stanley David Stupski, and Floris van Breugel. Discovering and exploiting active sensing motifs for estimation with empirical observability. (2024) bioRxiv.
+Benjamin Cellini, Burak Boyacioglu, Stanley David Stupski, and Floris van Breugel. Discovering and exploiting active sensing motifs for estimation with empirical observability. (2024) bioRxiv.
 
 ## Related packages
 This repository is the evolution of the EISO repo (https://github.com/BenCellini/EISO), and is intended as a companion to the repository directly associated with the paper above.

pybounds-0.0.7.dist-info/RECORD

@@ -0,0 +1,11 @@
+pybounds/__init__.py,sha256=0MZnwxcaT4ERtEUgcKpkwZVwQ8vVkSIQbYEqSnEQw6Y,438
+pybounds/jacobian.py,sha256=hqDOwwqZMdnlTECz0Rx6txCd4VuZ4iZHPaj62PTkKvA,2057
+pybounds/observability.py,sha256=F3tKpOgf-Ltx_jmNsrdSw5YL99OOkjZCwMZdnj7n9II,31675
+pybounds/observability_transform.py,sha256=YibApe7OzwrZT44BmlZwetJ1JLHOIgMkpVYggWz5Myo,585
+pybounds/simulator.py,sha256=MhK7NjYHdRMToGzwVEuwEnu5Aa6MguF1KE7fAbWCiUA,16194
+pybounds/util.py,sha256=Gs0UgqgLXTJI9FZww90iJhqU02iJ31bXBURjGiq3YzM,7401
+pybounds-0.0.7.dist-info/LICENSE,sha256=kqeyRXtRGgBVZdXYeIX4zR9l2KZ2rqIBVEiPMTjxjcI,1093
+pybounds-0.0.7.dist-info/METADATA,sha256=zi7w4FqcUvDxvYqcVrcdWK3Yxsozc2F6pNibEBDcz4Q,2155
+pybounds-0.0.7.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+pybounds-0.0.7.dist-info/top_level.txt,sha256=V-ofnWE3m_UkXTXJwNRD07n14m5R6sc6l4NadaCCP_A,9
+pybounds-0.0.7.dist-info/RECORD,,

pybounds-0.0.5.dist-info/RECORD

@@ -1,9 +0,0 @@
-pybounds/__init__.py,sha256=so9LuRNw2V8MGsDs-RPstGGgJtBFp2YGolQbS0rVfhw,348
-pybounds/observability.py,sha256=MUdwufFf200SYseP42JCP978O4F7GbeBVtm0yGjGzOE,27490
-pybounds/simulator.py,sha256=-CrQVpNfiBDFECd6H7FU5has4sYGW1gyS2RhOgXUqZg,15858
-pybounds/util.py,sha256=l6S9G88S-OZO9mi7F_58bVAPSr3PGQKcbHUghgni4JY,5956
-pybounds-0.0.5.dist-info/LICENSE,sha256=kqeyRXtRGgBVZdXYeIX4zR9l2KZ2rqIBVEiPMTjxjcI,1093
-pybounds-0.0.5.dist-info/METADATA,sha256=sQnyiQHrQHFzXHh_mr4ymujDAh7MZved-QnSKC08JTM,2226
-pybounds-0.0.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-pybounds-0.0.5.dist-info/top_level.txt,sha256=V-ofnWE3m_UkXTXJwNRD07n14m5R6sc6l4NadaCCP_A,9
-pybounds-0.0.5.dist-info/RECORD,,