pybounds 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

pybounds/observability.py

@@ -11,20 +11,20 @@ from util import LatexStates
 
 
 class EmpiricalObservabilityMatrix:
-    def __init__(self, simulator, x0, t_sim, u_sim, eps=1e-5, parallel=False):
+    def __init__(self, simulator, x0, time, u, eps=1e-5, parallel=False):
         """ Construct an empirical observability matrix O.
 
-        Inputs
-            simulator:          simulator object: y = simulator(x0, t_sim, u_sim)
-            x0:                 initial state
-            t_sim:              simulation time
-            u_sim:              simulation inputs
-            eps:                amount to perturb initial states
+        :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 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
         """
 
         # Store inputs
         self.simulator = simulator
-        self.t_sim = t_sim.copy()
+        self.time = time.copy()
         self.eps = eps
         self.parallel = parallel
 
@@ -33,35 +33,49 @@ class EmpiricalObservabilityMatrix:
         else:
             self.x0 = np.array(x0).squeeze()
 
-        if isinstance(u_sim, dict):
-            self.u_sim = np.vstack(list(u_sim.values())).T
+        if isinstance(u, dict):
+            self.u = np.vstack(list(u.values())).T
         else:
-            self.u_sim = np.array(u_sim)
+            self.u = np.array(u)
+
+        # Number of states
+        self.n = self.x0.shape[0]
 
         # Simulate once for nominal trajectory
-        self.y_nominal = self.simulator.simulate(self.x0, self.u_sim)
-        self.x_nominal = self.simulator.x.copy()
-        self.u_nominal = self.simulator.u.copy()
-        # self.sim_data_nominal = self.simulator.sim_data.copy()
+        self.y_nominal = self.simulator.simulate(self.x0, self.u)
+
+        # Number of outputs
+        self.p = self.y_nominal.shape[1]
+
+        # Check for state/measurement names
+        if hasattr(self.simulator, 'state_names'):
+            self.state_names = self.simulator.state_names
+        else:
+            self.state_names = ['x_' + str(n) for n in range(self.n)]
+
+        if hasattr(self.simulator, 'measurement_names'):
+            self.measurement_names = self.simulator.measurement_names
+        else:
+            self.measurement_names = ['y_' + str(p) for p in range(self.p)]
 
         # Perturbation amounts
-        self.w = len(t_sim)  # of points in time window
-        self.delta_x = eps * np.eye(self.simulator.n)  # perturbation amount for each state
-        self.delta_y = np.zeros((self.simulator.p, self.simulator.n, self.w))  # preallocate delta_y
-        self.y_plus = np.zeros((self.w, self.simulator.n, self.simulator.p))
-        self.y_minus = np.zeros((self.w, self.simulator.n, self.simulator.p))
+        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))
+        self.y_minus = np.zeros((self.w, self.n, self.p))
 
         # Observability matrix
-        self.O = np.nan * np.zeros((self.simulator.p * self.w, self.simulator.n))
+        self.O = np.nan * np.zeros((self.p * self.w, self.n))
         self.O_df = pd.DataFrame(self.O)
 
         # Set measurement names
         self.measurement_labels = []
         self.time_labels = []
         for w in range(self.w):
-            tl = (w * np.ones(self.simulator.p)).astype(int)
+            tl = (w * np.ones(self.p)).astype(int)
             self.time_labels.append(tl)
-            self.measurement_labels = self.measurement_labels + list(self.simulator.output_mode)
+            self.measurement_labels = self.measurement_labels + list(self.measurement_names)
 
         self.time_labels = np.hstack(self.time_labels)
 
@@ -76,7 +90,7 @@ class EmpiricalObservabilityMatrix:
             self.parallel = parallel
 
         # Run simulations for perturbed initial conditions
-        state_index = np.arange(0, self.simulator.n).tolist()
+        state_index = np.arange(0, self.n).tolist()
         if self.parallel:  # multiprocessing
             with Pool(4) as pool:
                 results = pool.map(self.simulate, state_index)
@@ -95,18 +109,18 @@ class EmpiricalObservabilityMatrix:
                 self.y_minus[:, n, :] = y_minus
 
         # Construct O by stacking the 3rd dimension of delta_y along the 1st dimension, O is a (p*w x n) matrix
-        self.O = np.zeros((self.simulator.p * self.w, self.simulator.n))
+        self.O = np.zeros((self.p * self.w, self.n))
         for w in range(self.w):
             if w == 0:
                 start_index = 0
             else:
-                start_index = int(w * self.simulator.p)
+                start_index = int(w * self.p)
 
-            end_index = start_index + self.simulator.p
+            end_index = start_index + self.p
             self.O[start_index:end_index] = self.delta_y[:, :, w]
 
         # Make O into a data-frame for interpretability
-        self.O_df = pd.DataFrame(self.O, columns=self.simulator.state_names, index=self.measurement_labels)
+        self.O_df = pd.DataFrame(self.O, columns=self.state_names, index=self.measurement_labels)
         self.O_df['time_step'] = self.time_labels
         self.O_df = self.O_df.set_index('time_step', append=True)
         self.O_df.index.names = ['sensor', 'time_step']
@@ -120,8 +134,8 @@ class EmpiricalObservabilityMatrix:
         x0_minus = self.x0 - self.delta_x[:, n]
 
         # Simulate measurements from perturbed initial conditions
-        y_plus = self.simulator.simulate(x0=x0_plus, u=self.u_sim)
-        y_minus = self.simulator.simulate(x0=x0_minus, u=self.u_sim)
+        y_plus = self.simulator.simulate(x0=x0_plus, u=self.u)
+        y_minus = self.simulator.simulate(x0=x0_minus, u=self.u)
 
         # Calculate the numerical Jacobian & normalize by 2x the perturbation amount
         delta_y = np.array(y_plus - y_minus).T / (2 * self.eps)
@@ -130,23 +144,35 @@ class EmpiricalObservabilityMatrix:
 
 
 class SlidingEmpiricalObservabilityMatrix:
-    def __init__(self, simulator, t_sim, x_sim, u_sim, w=None, eps=1e-5, parallel=False):
-        """ Construct an empirical observability matrix O in sliding windows along a trajectory.
-
-            Inputs
-                simulator:          simulator object
-                t_sim:              simulation time along trajectory
-                u_sim:              simulation inputs along trajectory
-                x_sim:              state trajectory
-                w:                  simulation window size for each calculation of O
-                eps:                amount to perturb initial state
+    def __init__(self, simulator, t_sim, x_sim, u_sim, w=None, eps=1e-5,
+                 parallel_sliding=False, parallel_perturbation=False):
+        """ 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 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
         """
 
         self.simulator = simulator
-        self.t_sim = t_sim.copy()
         self.eps = eps
-        self.parallel = parallel
+        self.parallel_sliding = parallel_sliding
+        self.parallel_perturbation = parallel_perturbation
+
+        # Set time vector
+        self.t_sim = np.array(t_sim)
 
+        # Number of points
+        self.N = self.t_sim.shape[0]
+
+        # Make x_sim & u_sim arrays
         if isinstance(x_sim, dict):
             self.x_sim = np.vstack((list(x_sim.values()))).T
         else:
@@ -157,16 +183,22 @@ class SlidingEmpiricalObservabilityMatrix:
         else:
             self.u_sim = np.array(u_sim).squeeze()
 
-        # self.dt = np.round(np.mean(np.diff(self.t_sim)), 6)
-        self.N = self.t_sim.shape[0]
+        # Check sizes
+        if self.N != self.x_sim.shape[0]:
+            raise ValueError('t_sim & x_sim must have same number of rows')
+        elif self.N != self.u_sim.shape[0]:
+            raise ValueError('t_sim & u_sim must have same number of rows')
+        elif self.x_sim.shape[0] != self.u_sim.shape[0]:
+            raise ValueError('x_sim & u_sim must have same number of rows')
 
+        # Set time-window to calculate O's
         if w is None:  # set window size to full time-series size
             self.w = self.N
         else:
             self.w = w
 
         if self.w > self.N:
-            raise ValueError('Window size must be smaller than trajectory length')
+            raise ValueError('window size must be smaller than trajectory length')
 
         # All the indices to calculate O
         self.O_index = np.arange(0, self.N - self.w + 1,  step=1)  # indices to compute O
@@ -174,7 +206,7 @@ class SlidingEmpiricalObservabilityMatrix:
         self.n_point = len(self.O_index)  # # of times to calculate O
 
         # Where to store sliding window trajectory data & O's
-        self.window_data = {'t': [], 'u': [], 'x': [], 'y': [], 'y_plus': [], 'y_minus': []}
+        self.window_data = {}
         self.O_sliding = []
         self.O_df_sliding = []
 
@@ -182,21 +214,21 @@ class SlidingEmpiricalObservabilityMatrix:
         self.EOM = None
         self.run()
 
-    def run(self, parallel=None):
+    def run(self, parallel_sliding=None):
         """ Run.
         """
 
-        if parallel is not None:
-            self.parallel = parallel
+        if parallel_sliding is not None:
+            self.parallel_sliding = parallel_sliding
 
         # Where to store sliding window trajectory data & O's
-        self.window_data = {'t': [], 'u': [], 'x': [], 'y': [], 'y_plus': [], 'y_minus': []}
+        self.window_data = {'t': [], 'u': [], 'y': [], 'y_plus': [], 'y_minus': []}
         self.O_sliding = []
         self.O_df_sliding = []
 
         # Construct O's
         n_point_range = np.arange(0, self.n_point).astype(int)
-        if self.parallel:  # multiprocessing
+        if self.parallel_sliding:  # multiprocessing
             with Pool(4) as pool:
                 results = pool.map(self.construct, n_point_range)
                 for r in results:
@@ -230,7 +262,7 @@ class SlidingEmpiricalObservabilityMatrix:
         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=False)
+        EOM = EmpiricalObservabilityMatrix(self.simulator, x0, t_win0, u_win, eps=self.eps, parallel=self.parallel_perturbation)
         self.EOM = EOM
 
         # Store data
@@ -239,23 +271,30 @@ class SlidingEmpiricalObservabilityMatrix:
 
         window_data = {'t': t_win.copy(),
                        'u': u_win.copy(),
-                       'x': EOM.x_nominal.copy(),
                        'y': EOM.y_nominal.copy(),
                        'y_plus': EOM.y_plus.copy(),
                        'y_minus': EOM.y_minus.copy()}
 
         return O_sliding, O_df_sliding, window_data
 
+    def get_observability_matrix(self):
+        return self.O_df_sliding.copy()
+
 
 class FisherObservability:
-    def __init__(self, O, R=None, sensor_noise_dict=None, sigma=None):
+    def __init__(self, O, R=None, sensor_noise_dict=None, lam=None):
         """ Evaluate the observability of a state variable(s) using the Fisher Information Matrix.
 
-            Inputs
-                O: observability matrix. Can be numpy array or pandas data-frame (pxw x n)
-                R: measurement noise covariance matrix (p x p)
-                beta: reconstruction error bound for binary observability
-                epsilon: F = F + epsilon*I if not None
+        :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)
+            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 float lam: lamda parameter, if lam='limit' compute F^-1 symbolically, otherwise use Chernoff inverse
         """
 
         # Make O a data-frame
@@ -282,21 +321,21 @@ class FisherObservability:
         self.F = pd.DataFrame(self.F, index=O.columns, columns=O.columns)
 
         # Set sigma
-        if sigma is None:
+        if lam is None:
             # np.linalg.eig(self.F)
-            self.sigma = 0.0
+            self.lam = 0.0
         else:
-            self.sigma = sigma
+            self.lam = lam
 
         # Invert F
-        if self.sigma == 'limit':  # calculate limit with symbolic sigma
+        if self.lam == 'limit':  # calculate limit with symbolic sigma
             sigma_sym = sp.symbols('sigma')
             F_hat = self.F.values + sp.Matrix(sigma_sym * np.eye(self.n))
             F_hat_inv = F_hat.inv()
             F_hat_inv_limit = F_hat_inv.applyfunc(lambda elem: sp.limit(elem, sigma_sym, 0))
             self.F_inv = np.array(F_hat_inv_limit, dtype=np.float64)
         else:  # numeric sigma
-            F_epsilon = self.F.values + (self.sigma * np.eye(self.n))
+            F_epsilon = self.F.values + (self.lam * np.eye(self.n))
             self.F_inv = np.linalg.inv(F_epsilon)
 
         self.F_inv = pd.DataFrame(self.F_inv, index=O.columns, columns=O.columns)
@@ -346,17 +385,27 @@ class FisherObservability:
 
         self.R_inv = pd.DataFrame(self.R_inv, index=self.R.index, columns=self.R.index)
 
+    def get_fisher_information(self):
+        return self.F.copy(), self.F_inv.copy(), self.R.copy()
+
 
 class SlidingFisherObservability:
-    def __init__(self, O_list, time=None, sigma=1e6, R=None, sensor_noise_dict=None,
+    def __init__(self, O_list, time=None, lam=1e6, R=None, sensor_noise_dict=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 O_list: list of observability matrices O
-        :param time: time vector the same size as O_list
-        :param states: list of states to use from O's
-        :param sensors: list of sensors to use from O's
-        :param time_steps: list of time steps to use from O's
+        :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)
+            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
         """
 
         self.O_list = O_list
@@ -366,7 +415,7 @@ class SlidingFisherObservability:
         if time is None:
             self.time = np.arange(0, self.n_window, step=1)
         else:
-            self.time = time
+            self.time = np.array(time)
 
         self.dt = np.mean(np.diff(self.time))
 
@@ -395,7 +444,7 @@ class SlidingFisherObservability:
         if time_steps is None:
             self.time_steps = O.index.get_level_values('time_step')
         else:
-            self.time_steps = time_steps
+            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
@@ -410,7 +459,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, sigma=sigma)
+            FO = FisherObservability(O_subset, sensor_noise_dict=sensor_noise_dict, R=R, lam=lam)
             self.FO.append(FO)
 
             # Collect error variance data
@@ -424,6 +473,9 @@ class SlidingFisherObservability:
         time_df = pd.DataFrame(np.atleast_2d(self.time).T, columns=['time'])
         self.EV_aligned = pd.concat((time_df, self.EV), axis=1)
 
+    def get_minimum_error_variance(self):
+        return self.EV_aligned.copy()
+
 
 class ObservabilityMatrixImage:
     def __init__(self, O, state_names=None, sensor_names=None, vmax_percentile=100, vmin_ratio=1.0, cmap='bwr'):

pybounds/simulator.py

@@ -7,42 +7,66 @@ from util import FixedKeysDict, SetDict
 
 
 class Simulator(object):
-    def __init__(self, f, h, x0, u0, dt=0.01,
+    def __init__(self, f, h, dt=0.01, n=None, m=None,
                  state_names=None, input_names=None, measurement_names=None,
                  params_simulator=None):
+
         """ Simulator.
-        :param float f: callable dynamics function f(X, U, t)
-        :param float h: callable measurement function h(X, U, t)
+
+        :param callable f: dynamics function f(X, U, t)
+        :param callable h: measurement function h(X, U, t)
         :param float dt: sampling time in seconds
+        :param int n: number of states, optional but cannot be set if state_names is set
+        :param int m: number of inputs, optional but cannot be set if input_names is set
+        :param list state_names: names of states, optional but cannot be set if n is set
+        :param list input_names: names of inputs, optional but cannot be set if m is set
+        :param list measurement_names: names of measurements, optional
+        :param dict params_simulator: simulation parameters, optional
         """
 
         self.f = f
         self.h = h
         self.dt = dt
 
-        # Set state & input sizes
-        self.n = len(x0)  # number of states
-        self.m = len(u0)  # number of inputs
-
-        # Run measurement function to get measurement size
-        y = self.h(x0, u0, 0)
-        self.p = len(y)  # number of measurements
-
         # Set state names
         if state_names is None:  # default state names
+            if n is None:
+                raise ValueError('must set state_names or n')
+            else:
+                self.n = int(n)
+
             self.state_names = ['x_' + str(n) for n in range(self.n)]
-        else:
-            self.state_names = state_names
-            if len(self.state_names) != self.n:
-                raise ValueError('state_names must have length equal to x0')
+        else:  # state names given
+            if n is not None:
+                raise ValueError('cannot set state_names and n')
+
+            self.state_names = list(state_names)
+            self.n = len(self.state_names)
+            # if len(self.state_names) != self.n:
+            #     raise ValueError('state_names must have length equal to x0')
 
         # Set input names
-        if input_names is None:  # default measurement names
+        if input_names is None:  # default input names
+            if m is None:
+                raise ValueError('must set input_names or m')
+            else:
+                self.m = int(m)
+
             self.input_names = ['u_' + str(m) for m in range(self.m)]
-        else:
-            self.input_names = input_names
-            if len(self.input_names) != self.m:
-                raise ValueError('input_names must have length equal to u0')
+        else:  # input names given
+            if m is not None:
+                raise ValueError('cannot set in and n')
+
+            self.input_names = list(input_names)
+            self.m = len(self.input_names)
+            # if len(self.input_names) != self.m:
+            #     raise ValueError('input_names must have length equal to u0')
+
+        # Run measurement function to get measurement size
+        x0 = np.ones(self.n)
+        u0 = np.ones(self.m)
+        y = self.h(x0, u0, 0)
+        self.p = len(y)  # number of measurements
 
         # Set measurement names
         if measurement_names is None:  # default measurement names
@@ -52,8 +76,6 @@ class Simulator(object):
             if len(self.measurement_names) != self.p:
                 raise ValueError('measurement_names must have length equal to y')
 
-        self.output_mode = self.measurement_names
-
         # Initialize time vector
         w = 10  # initialize for w time-steps, but this can change later
         self.time = np.arange(0, w * self.dt + self.dt / 2, step=self.dt)  # time vector
@@ -168,8 +190,7 @@ class Simulator(object):
 
         :params x0: initial state dict or array
         :params u: input dict or array
-        :params output_mode: array of strings containing variable names of outputs
-        :params run_mpc: boolean to run MPC controller
+        :params return_full_output: boolean to run (time, x, u, y) instead of y
         """
 
         # Update the initial state

pybounds-0.0.2.dist-info/METADATA

@@ -0,0 +1,60 @@
+Metadata-Version: 2.1
+Name: pybounds
+Version: 0.0.2
+Summary: Bounding Observability for Uncertain Nonlinear Dynamics Systems (BOUNDS)
+Home-page: https://pypi.org/project/pybounds/
+Author: Ben Cellini, Burak Boyacioglu, Floris van Breugel
+Author-email: bcellini00@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# pybounds
+
+Python implementation of BOUNDS: Bounding Observability for Uncertain Nonlinear Dynamic Systems.
+
+<p align="center">
+  <a href="https://pynumdiff.readthedocs.io/en/master/" target="_blank" >
+
+[//]: # (    <img alt="Python for Numerical Differentiation of noisy time series data" src="docs/source/_static/logo_PyNumDiff.png" width="300" height="200" />)
+  </a>
+</p>
+
+<p align="center">
+    <a href="https://pypi.org/project/pybounds/">
+        <img src="https://badge.fury.io/py/pynumdiff.svg" alt="PyPI version" height="18"></a>
+</p>
+
+## Introduction
+
+This repository provides a minimal working example demonstrating how to empirically calculate the observability level of individual states for a nonlinear (partially observable) system, and accounts for sensor noise.
+
+## Installing
+
+The package can be installed by cloning the repo and running python setup.py install from inside the home pybounds directory.
+
+Alternatively using pip
+```bash
+pip install pybounds
+```
+
+## Notebook examples
+There is currently one simple example notebook. More to come.
+*  Monocular camera with optic fow measurements: [mono_camera_example.ipynb](examples%2Fmono_camera_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.
+
+## 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.
+
+## License
+
+This project utilizes the [MIT LICENSE](LICENSE.txt).
+100% open-source, feel free to utilize the code however you like. 

pybounds-0.0.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+pybounds/__init__.py,sha256=so9LuRNw2V8MGsDs-RPstGGgJtBFp2YGolQbS0rVfhw,348
+pybounds/observability.py,sha256=_A6HEy6wMEMhRoxXojMZYeximhz3PPR3MdLTaihJR7U,27057
+pybounds/simulator.py,sha256=p1O17cvbr_otjGTsDTreuugeF3lEI7NpwII6uaoCkaQ,9780
+pybounds/util.py,sha256=xxmXmpLR3yK923X6wAPKp_5w814cO3m9OqF1XIt9S8c,5818
+pybounds-0.0.2.dist-info/LICENSE,sha256=kqeyRXtRGgBVZdXYeIX4zR9l2KZ2rqIBVEiPMTjxjcI,1093
+pybounds-0.0.2.dist-info/METADATA,sha256=Zeh9auhV9fqq0Le2paSPD1-hrMN0AsWJ_zKZd5Symc4,2376
+pybounds-0.0.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+pybounds-0.0.2.dist-info/top_level.txt,sha256=V-ofnWE3m_UkXTXJwNRD07n14m5R6sc6l4NadaCCP_A,9
+pybounds-0.0.2.dist-info/RECORD,,

{pybounds-0.0.1.dist-info → pybounds-0.0.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

pybounds-0.0.1.dist-info/METADATA

@@ -1,15 +0,0 @@
-Metadata-Version: 2.1
-Name: pybounds
-Version: 0.0.1
-Summary: Bounding Observability for Uncertain Nonlinear Dynamics Systems (BOUNDS)
-Home-page: https://github.com/vanbreugel-lab/pybounds
-Author: Ben Cellini, Burak Boyacioglu, Floris van Breugel
-Author-email: bcellini00@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-License-File: LICENSE
-
-# pybounds

pybounds-0.0.1.dist-info/RECORD

@@ -1,9 +0,0 @@
-pybounds/__init__.py,sha256=so9LuRNw2V8MGsDs-RPstGGgJtBFp2YGolQbS0rVfhw,348
-pybounds/observability.py,sha256=tiJdR5tS72SGn1df8Vnz303nDPzhOFaQWSYJoY1o8Qg,24055
-pybounds/simulator.py,sha256=-XpPKQUcwNubw40wNfoqSfqmohbGpBjSQSNWctyfRkQ,8837
-pybounds/util.py,sha256=xxmXmpLR3yK923X6wAPKp_5w814cO3m9OqF1XIt9S8c,5818
-pybounds-0.0.1.dist-info/LICENSE,sha256=kqeyRXtRGgBVZdXYeIX4zR9l2KZ2rqIBVEiPMTjxjcI,1093
-pybounds-0.0.1.dist-info/METADATA,sha256=Il4j0WbOUWga2nq69YD-fjh3OtElrZ-XA4TBSKMUUMs,539
-pybounds-0.0.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-pybounds-0.0.1.dist-info/top_level.txt,sha256=V-ofnWE3m_UkXTXJwNRD07n14m5R6sc6l4NadaCCP_A,9
-pybounds-0.0.1.dist-info/RECORD,,