pybounds 0.0.11__py3-none-any.whl → 0.0.13__py3-none-any.whl

pybounds/__init__.py

@@ -10,4 +10,4 @@ from .observability import transform_states
 
 from .jacobian import SymbolicJacobian
 
-from .util import colorline
+from .util import colorline, plot_heatmap_log_timeseries

pybounds/observability.py

@@ -11,7 +11,7 @@ from .jacobian import SymbolicJacobian
 
 
 class EmpiricalObservabilityMatrix:
-    def __init__(self, simulator, x0, u, eps=1e-5, parallel=False,
+    def __init__(self, simulator, x0, u, aux=None, eps=1e-5, parallel=False,
                  z_function=None, z_state_names=None):
         """ Construct an empirical observability matrix O.
 
@@ -19,18 +19,20 @@ class EmpiricalObservabilityMatrix:
             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 aux: auxiliary input that can be passed to Simulator class
         :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.
+        :param list | tuple | None 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.aux = aux
         self.eps = eps
         self.parallel = parallel
 
@@ -48,7 +50,7 @@ class EmpiricalObservabilityMatrix:
         self.n = self.x0.shape[0]
 
         # Simulate once for nominal trajectory
-        self.y_nominal = self.simulator.simulate(self.x0, self.u)
+        self.y_nominal = self.simulator.simulate(x0=self.x0, u=self.u, aux=self.aux)
 
         # Number of outputs
         self.p = self.y_nominal.shape[1]
@@ -158,8 +160,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)
-        y_minus = self.simulator.simulate(x0=x0_minus, u=self.u)
+        y_plus = self.simulator.simulate(x0=x0_plus, u=self.u, aux=self.aux)
+        y_minus = self.simulator.simulate(x0=x0_minus, u=self.u, aux=self.aux)
 
         # Calculate the numerical Jacobian & normalize by 2x the perturbation amount
         delta_y = np.array(y_plus - y_minus).T / (2 * self.eps)
@@ -168,7 +170,7 @@ class EmpiricalObservabilityMatrix:
 
 
 class SlidingEmpiricalObservabilityMatrix:
-    def __init__(self, simulator, t_sim, x_sim, u_sim, w=None, eps=1e-5,
+    def __init__(self, simulator, t_sim, x_sim, u_sim, aux_list=None, w=None, eps=1e-5,
                  parallel_sliding=False, parallel_perturbation=False,
                  z_function=None, z_state_names=None):
         """ Construct empirical observability matrix O in sliding windows along a trajectory.
@@ -178,6 +180,7 @@ class SlidingEmpiricalObservabilityMatrix:
         :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 aux_list: auxiliary input that can be passed to Simulator class
         :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 float eps: epsilon value for perturbations to construct O's, should be small number
@@ -207,7 +210,7 @@ class SlidingEmpiricalObservabilityMatrix:
         if isinstance(u_sim, dict):
             self.u_sim = np.vstack(list(u_sim.values())).T
         else:
-            self.u_sim = np.array(u_sim).squeeze()
+            self.u_sim = np.array(u_sim)
 
         # Check sizes
         if self.N != self.x_sim.shape[0]:
@@ -217,6 +220,15 @@ class SlidingEmpiricalObservabilityMatrix:
         elif self.x_sim.shape[0] != self.u_sim.shape[0]:
             raise ValueError('x_sim & u_sim must have same number of rows')
 
+        # Set aux inputs
+        if aux_list is None:
+            self.aux_list = [None for k in range(self.N)]
+        else:
+            self.aux_list = aux_list
+
+        if len(self.aux_list) != self.N:
+            raise ValueError('aux_list must have same number of elements as t_sim')
+
         # Set time-window to calculate O's
         if w is None:  # set window size to full time-series size
             self.w = self.N
@@ -292,7 +304,9 @@ class SlidingEmpiricalObservabilityMatrix:
         u_win = self.u_sim[win, :]  # inputs in window
 
         # Calculate O for window
-        EOM = EmpiricalObservabilityMatrix(self.simulator, x0, u_win, eps=self.eps,
+        EOM = EmpiricalObservabilityMatrix(self.simulator, x0, u_win,
+                                           aux=self.aux_list[n],
+                                           eps=self.eps,
                                            parallel=self.parallel_perturbation,
                                            z_function=self.z_function,
                                            z_state_names=self.z_state_names)
@@ -315,20 +329,26 @@ class SlidingEmpiricalObservabilityMatrix:
 
 
 class FisherObservability:
-    def __init__(self, O, R=None, lam=None):
+    def __init__(self, O, R=None, lam=None, force_R_scalar=False,
+                 states=None, sensors=None, time_steps=None, w=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 None | np.array | float| dict  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_(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
-        """
+        :param bool force_R_scalar: force R to be a scalar, useful when the resulting R matrix is too big to fit in memory
+        :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        """
 
         # Make O a data-frame
         self.pw = O.shape[0]  # number of sensors * time-steps
@@ -344,14 +364,57 @@ class FisherObservability:
         else:
             raise TypeError('O is not a pandas data-frame or numpy array')
 
-        # 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)
+        # Set window size
+        if w is None:  # set automatically
+            self.w = np.max(np.array(self.O.index.get_level_values('time_step'))) + 1
+        else:
+            self.w = w
+
+        # Set the states to use
+        if states is None:
+            self.states = self.O.columns
+        else:
+            self.states = states
+
+        # Set the sensors to use
+        if sensors is None:
+            self.sensors = self.O.index.get_level_values('sensor')
+        else:
+            self.sensors = sensors
+
+        # Set the time-steps to use
+        if time_steps is None:
+            self.time_steps = self.O.index.get_level_values('time_step')
+        else:
+            self.time_steps = np.array(time_steps)
+
+        # Get subset of O
+        self.O = O.loc[(self.sensors, self.time_steps), self.states].sort_values(['time_step', 'sensor'])
+
+        # Reset the size of O
+        self.pw = self.O.shape[0]  # number of sensors * time-steps
+        self.n = self.O.shape[1]  # number of states
 
-        # Calculate Fisher Information Matrix
-        self.F = self.O.values.T @ self.R_inv.values @ self.O.values
-        self.F = pd.DataFrame(self.F, index=O.columns, columns=O.columns)
+        # Set measurement noise covariance matrix & calculate Fisher Information Matrix
+        if force_R_scalar and np.isscalar(R):  # scalar R
+            self.R = pd.DataFrame({'R': {'index': float(R)}})
+            self.R_inv = pd.DataFrame({'R_inv': {'index': 1 / self.R.values.squeeze()}})
+
+            # Calculate Fisher Information Matrix for scalar R
+            self.F = self.R_inv.values.squeeze() * (self.O.values.T @ self.O.values)
+
+        elif force_R_scalar and not np.isscalar(R):
+            raise Exception('R must be a scalar')
+
+        else:  # non-scalar R
+            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)
+
+            # Calculate Fisher Information Matrix for non-scalar R
+            self.F = self.O.values.T @ self.R_inv.values.squeeze() @ self.O.values
+
+        self.F = pd.DataFrame(self.F, index=self.O.columns, columns=self.O.columns)
 
         # Set sigma
         if lam is None:
@@ -371,7 +434,7 @@ class FisherObservability:
             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)
+        self.F_inv = pd.DataFrame(self.F_inv, index=self.O.columns, columns=self.O.columns)
 
         # Pull out diagonal elements
         self.error_variance = pd.DataFrame(np.diag(self.F_inv), index=self.O.columns).T
@@ -421,18 +484,19 @@ class FisherObservability:
 
 
 class SlidingFisherObservability:
-    def __init__(self, O_list, time=None, lam=1e6, R=None,
+    def __init__(self, O_list, R=None, lam=1e6, time=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 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_(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 | np.array lam: lamda parameter, if lam='limit' compute F^-1 symbolically, otherwise use Chernoff inverse
+        :param None | np.array time: time vector the same size as O_list
         :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])
@@ -458,33 +522,6 @@ class SlidingFisherObservability:
         else:  # default is time-step of 1
             self.dt = 1
 
-        # Get single O
-        O = O_list[0]
-
-        # Set window size
-        if w is None:  # set automatically
-            self.w = np.max(np.array(O.index.get_level_values('time_step'))) + 1
-        else:
-            self.w = w
-
-        # Set the states to use
-        if states is None:
-            self.states = O.columns
-        else:
-            self.states = states
-
-        # Set the sensors to use
-        if sensors is None:
-            self.sensors = O.index.get_level_values('sensor')
-        else:
-            self.sensors = sensors
-
-        # Set the time-steps to use
-        if time_steps is None:
-            self.time_steps = O.index.get_level_values('time_step')
-        else:
-            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 windows
         self.FO = []  # collect FisherObservability objects over windows
@@ -492,11 +529,8 @@ class SlidingFisherObservability:
             # Get full O
             O = self.O_list[k]
 
-            # Get subset of O
-            O_subset = O.loc[(self.sensors, self.time_steps), self.states].sort_values(['time_step', 'sensor'])
-
             # Compute Fisher information & inverse
-            FO = FisherObservability(O_subset, R=R, lam=lam)
+            FO = FisherObservability(O, R=R, lam=lam, states=states, sensors=sensors, time_steps=time_steps, w=w)
             self.FO.append(FO)
 
             # Collect error variance data
@@ -505,7 +539,7 @@ 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_index = int(np.round((1 / 2) * float(FO.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)
         if self.n_window > 1:  # more than 1 window
@@ -598,8 +632,10 @@ class ObservabilityMatrixImage:
 
             # Default sensor names based on data-frame 'sensor' index
             sensor_names_all = list(np.unique(O.index.get_level_values('sensor')))
-            self.sensor_names_default = list(O.index.get_level_values('sensor')[0:len(sensor_names_all)])
-
+            self.sensors = list(O.index.get_level_values('sensor'))
+            self.time_steps = np.array(O.index.get_level_values('time_step'))
+            self.sensor_names_default = self.sensors[0:len(sensor_names_all)]
+            self.time_steps_default = np.unique(self.time_steps)
         else:  # numpy matrix
             raise TypeError('n-sensor must be an integer value when O is given as a numpy matrix')
 
@@ -629,7 +665,7 @@ class ObservabilityMatrixImage:
                 self.measurement_names = []
                 for w in range(self.n_time_step):
                     for p in range(self.n_sensor):
-                        m = '$' + self.sensor_names[p] + ',_{' + 'k=' + str(w) + '}$'
+                        m = '$' + self.sensor_names[p] + ',_{' + 'k=' + str(self.time_steps_default[w]) + '}$'
                         self.measurement_names.append(m)
 
             elif len(sensor_names) == 1:
@@ -638,7 +674,7 @@ class ObservabilityMatrixImage:
                 self.measurement_names = []
                 for w in range(self.n_time_step):
                     for p in range(self.n_sensor):
-                        m = '$' + sensor_names[0] + '_{' + str(p) + ',k=' + str(w) + '}$'
+                        m = '$' + sensor_names[0] + '_{' + str(p) + ',k=' + str(self.time_steps_default[w]) + '}$'
                         self.measurement_names.append(m)
             else:
                 raise TypeError('sensor_names must be of length p or length 1')
@@ -649,7 +685,7 @@ class ObservabilityMatrixImage:
             self.measurement_names = []
             for w in range(self.n_time_step):
                 for p in range(self.n_sensor):
-                    m = '$' + self.sensor_names[p] + '_{' + ',k=' + str(w) + '}$'
+                    m = '$' + self.sensor_names[p] + '_{' + ',k=' + str(self.time_steps_default[w]) + '}$'
                     self.measurement_names.append(m)
 
     def plot(self, vmax_percentile=100, vmin_ratio=0.0, vmax_override=None, cmap='bwr', grid=True, scale=1.0, dpi=150,

pybounds/simulator.py

@@ -2,6 +2,7 @@
 import warnings
 import numpy as np
 import matplotlib.pyplot as plt
+import casadi
 import do_mpc
 from .util import FixedKeysDict, SetDict
 
@@ -129,7 +130,7 @@ class Simulator(object):
         # Define dynamics
         Xdot = self.f(X, U)
         for n, state_name in enumerate(self.state_names):
-            self.model.set_rhs(state_name, Xdot[n])
+            self.model.set_rhs(state_name, casadi.SX(Xdot[n]))
 
         # Add time-varying set-point variables for later use with MPC
         for n, state_name in enumerate(self.state_names):
@@ -271,12 +272,14 @@ class Simulator(object):
         if not np.all(points_check):
             raise Exception(name + ' not the same size')
 
-    def simulate(self, x0=None, u=None, mpc=False, return_full_output=False):
+    def simulate(self, x0=None, u=None, aux=None, mpc=False, return_full_output=False):
         """
         Simulate the system.
 
         :params x0: initial state dict or array
-        :params u: input dict or array
+        :params u: input dict or array, if True then mpc must be None
+        :params aux: auxiliary input
+        :params mpc: boolean to run MPC, if True then u must be None
         :params return_full_output: boolean to run (time, x, u, y) instead of y
         """
 
@@ -420,14 +423,16 @@ class Simulator(object):
                 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
+            else:
+                y = plot_dict[key]
+
+            # Set y-axis limits
+            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)
 
         ax[-1].set_xlabel('time', fontsize=7)
         ax[0].set_title(name, fontsize=8, fontweight='bold')

pybounds/util.py

@@ -1,4 +1,6 @@
 import numpy as np
+import scipy
+import matplotlib as mpl
 import matplotlib.pyplot as plt
 import matplotlib.collections as mcoll
 import matplotlib.patheffects as path_effects
@@ -198,3 +200,80 @@ def colorline(x, y, z, ax=None, cmap=plt.get_cmap('copper'), norm=None, linewidt
     ax.add_collection(lc)
 
     return lc
+
+def plot_heatmap_log_timeseries(data, ax=None, log_ticks=None, data_labels=None,
+                                cmap='inferno_r', y_label=None,
+                                aspect=0.25, interpolation=False):
+    """ Plot log-scale time-series as heatmap.
+    """
+
+    n_label = data.shape[1]
+
+    # Set ticks
+    if log_ticks is None:
+        log_tick_low = int(np.floor(np.log10(np.min(data))))
+        log_tick_high = int(np.ceil(np.log10(np.max(data))))
+    else:
+        log_tick_low = log_ticks[0]
+        log_tick_high = log_ticks[1]
+
+    log_ticks = np.logspace(log_tick_low, log_tick_high, log_tick_high - log_tick_low + 1)
+
+    # Set color normalization
+    cnorm = mpl.colors.LogNorm(10 ** log_tick_low, 10 ** log_tick_high)
+
+    # Set labels
+    if data_labels is None:
+        data_labels = np.arange(0, n_label).tolist()
+        data_labels = [str(x) for x in data_labels]
+
+    # Make figure/axis
+    if ax is None:
+        fig, ax = plt.subplots(1, 1, figsize=(5 * 1, 4 * 1), dpi=150)
+    else:
+        # ax = plt.gca()
+        fig = plt.gcf()
+
+    # Plot heatmap
+    if interpolation:
+        data = 10**scipy.ndimage.zoom(np.log10(data), (interpolation, 1), order=1)
+        aspect = aspect / interpolation
+
+    ax.imshow(data, norm=cnorm, aspect=aspect, cmap=cmap, interpolation='none')
+
+    # Set axis properties
+    ax.grid(True, axis='x')
+    ax.tick_params(axis='both', which='both', labelsize=6, top=False, labeltop=True, bottom=False, labelbottom=False,
+                   color='gray')
+
+    # Set x-ticks
+    LatexConverter = LatexStates()
+    data_labels_latex = LatexConverter.convert_to_latex(data_labels)
+    ax.set_xticks(np.arange(0, len(data_labels)) - 0.5)
+    ax.set_xticklabels(data_labels_latex)
+
+    # Set labels
+    ax.set_ylabel('time steps', fontsize=7, fontweight='bold')
+    ax.set_xlabel('states', fontsize=7, fontweight='bold')
+    ax.xaxis.set_label_position('top')
+
+    # Set x-ticks
+    xticks = ax.get_xticklabels()
+    for tick in xticks:
+        tick.set_ha('left')
+        tick.set_va('center')
+    #     tick.set_rotation(0)
+    #     tick.set_transform(tick.get_transform() + transforms.ScaledTranslation(6 / 72, 0, ax.figure.dpi_scale_trans))
+
+    # Colorbar
+    if y_label is None:
+        y_label = 'values'
+
+    cax = ax.inset_axes((1.03, 0.0, 0.04, 1.0))
+    cbar = fig.colorbar(mpl.cm.ScalarMappable(norm=cnorm, cmap=cmap), cax=cax, ticks=log_ticks)
+    cbar.set_label(y_label, rotation=270, fontsize=7, labelpad=8)
+    cbar.ax.tick_params(labelsize=6)
+
+    ax.spines[['bottom', 'top', 'left', 'right']].set_color('gray')
+
+    return cnorm, cmap, log_ticks

{pybounds-0.0.11.dist-info → pybounds-0.0.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pybounds
-Version: 0.0.11
+Version: 0.0.13
 Summary: Bounding Observability for Uncertain Nonlinear Dynamics Systems (BOUNDS)
 Home-page: https://pypi.org/project/pybounds/
 Author: Ben Cellini, Burak Boyacioglu, Floris van Breugel
@@ -41,6 +41,9 @@ For a simple system
 For a more complex system
 *  Fly-wind: [fly_wind_example.ipynb](examples%2Ffly_wind_example.ipynb)
 
+## Guides
+* Creating a custom simulator: 
+
 ## Citation
 
 If you use the code or methods from this package, please cite the following paper:

pybounds-0.0.13.dist-info/RECORD

@@ -0,0 +1,10 @@
+pybounds/__init__.py,sha256=mGTxRNwJmvRhRG5M8pVX2QmPV9a6L-bP0DAAM6pAX-A,462
+pybounds/jacobian.py,sha256=hqDOwwqZMdnlTECz0Rx6txCd4VuZ4iZHPaj62PTkKvA,2057
+pybounds/observability.py,sha256=IIC-iaHIZSmKBnxcYKhn5Q18bBX9rwebz0F1twQHE0Y,33922
+pybounds/simulator.py,sha256=Qx9QGFYuuFnyuq1z5dcub5T_Lz8ISWcKLLrHup9UY0A,16702
+pybounds/util.py,sha256=_nWwDLY07Aj8UlzK-xjy-hO_8btUwqDjsiwQmNTkRug,10136
+pybounds-0.0.13.dist-info/LICENSE,sha256=kqeyRXtRGgBVZdXYeIX4zR9l2KZ2rqIBVEiPMTjxjcI,1093
+pybounds-0.0.13.dist-info/METADATA,sha256=fEdYfbP1PU3V2aKA-ce4nt-D5uWWGr3StZR0osVBgz4,2202
+pybounds-0.0.13.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+pybounds-0.0.13.dist-info/top_level.txt,sha256=V-ofnWE3m_UkXTXJwNRD07n14m5R6sc6l4NadaCCP_A,9
+pybounds-0.0.13.dist-info/RECORD,,

pybounds/observability_transform.py

@@ -1,11 +0,0 @@
-
-# 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-0.0.11.dist-info/RECORD

@@ -1,11 +0,0 @@
-pybounds/__init__.py,sha256=e4SQdDBQzqr7_x5lcQsuSoWqfBg258i7CDrhhvnmCe4,433
-pybounds/jacobian.py,sha256=hqDOwwqZMdnlTECz0Rx6txCd4VuZ4iZHPaj62PTkKvA,2057
-pybounds/observability.py,sha256=GmWrPADr-vCbBJIv0Cjk3Gj9JJoCuOizKrF8lzX3ncs,31553
-pybounds/observability_transform.py,sha256=YibApe7OzwrZT44BmlZwetJ1JLHOIgMkpVYggWz5Myo,585
-pybounds/simulator.py,sha256=nKLtMQs_HgNYKIJ1YIg63lW2v-r7sT7WxLyouOV07wA,16518
-pybounds/util.py,sha256=Gs0UgqgLXTJI9FZww90iJhqU02iJ31bXBURjGiq3YzM,7401
-pybounds-0.0.11.dist-info/LICENSE,sha256=kqeyRXtRGgBVZdXYeIX4zR9l2KZ2rqIBVEiPMTjxjcI,1093
-pybounds-0.0.11.dist-info/METADATA,sha256=Evpk9-4sk6w_czjxjX-CYC1Y9eFuRGuYRcYrNlMQqjg,2156
-pybounds-0.0.11.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-pybounds-0.0.11.dist-info/top_level.txt,sha256=V-ofnWE3m_UkXTXJwNRD07n14m5R6sc6l4NadaCCP_A,9
-pybounds-0.0.11.dist-info/RECORD,,