pybounds 0.0.6__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,10 +9,12 @@ 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, 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  that has a method y = simulator.simulate(x0, u, **kwargs)
@@ -21,6 +23,12 @@ class EmpiricalObservabilityMatrix:
         :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
@@ -81,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.
         """
@@ -150,7 +171,8 @@ 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)
@@ -160,7 +182,6 @@ class SlidingEmpiricalObservabilityMatrix:
         :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
@@ -170,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)
@@ -267,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, u_win, eps=self.eps,
-                                           parallel=self.parallel_perturbation)
+                                           parallel=self.parallel_perturbation,
+                                           z_function=self.z_function,
+                                           z_state_names=self.z_state_names)
         self.EOM = EOM
 
         # Store data
@@ -292,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
         """
 
@@ -315,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:
@@ -324,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
@@ -353,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.
         """
 
@@ -361,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
@@ -382,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)
@@ -400,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
@@ -427,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]
@@ -457,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]
@@ -469,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
@@ -478,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.
@@ -638,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

@@ -374,7 +374,7 @@ class Simulator(object):
             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.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pybounds
-Version: 0.0.6
+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

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/drone_simulator.py

@@ -1,422 +0,0 @@
-
-import warnings
-import numpy as np
-import matplotlib.pyplot as plt
-import do_mpc
-from .util import FixedKeysDict, SetDict
-
-
-class Simulator(object):
-    def __init__(self, f, h, dt=0.01, n=None, m=None,
-                 state_names=None, input_names=None, measurement_names=None,
-                 params_simulator=None, mpc_horizon=10):
-
-        """ Simulator.
-
-        :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 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:  # 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 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:  # 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)
-        self.p = len(y)  # number of measurements
-
-        # Set measurement names
-        if measurement_names is None:  # default measurement names
-            self.measurement_names = ['y_' + str(p) for p in range(self.p)]
-        else:
-            self.measurement_names = measurement_names
-            if len(self.measurement_names) != self.p:
-                raise ValueError('measurement_names must have length equal to y')
-
-        # Initialize time vector
-        self.w = 11  # initialize for w time-steps, but this can change later
-        self.time = np.arange(0, self.w * self.dt, step=self.dt)  # time vector
-
-        # Define initial states & initialize state time-series
-        self.x0 = {}
-        self.x = {}
-        for n, state_name in enumerate(self.state_names):
-            self.x0[state_name] = x0[n]
-            self.x[state_name] = x0[n] * np.ones(self.w)
-
-        self.x0 = FixedKeysDict(self.x0)
-        self.x = FixedKeysDict(self.x)
-
-        # Initialize input time-series
-        self.u = {}
-        for m, input_name in enumerate(self.input_names):
-            self.u[input_name] = u0[m] * np.ones(self.w)
-
-        self.u = FixedKeysDict(self.u)
-
-        # Initialize measurement time-series
-        self.y = {}
-        for p, measurement_name in enumerate(self.measurement_names):
-            self.y[measurement_name] = 0.0 * np.ones(self.w)
-
-        self.y = FixedKeysDict(self.y)
-
-        # Initialize state set-points
-        self.setpoint = {}
-        for n, state_name in enumerate(self.state_names):
-            self.setpoint[state_name] = 0.0 * np.ones(self.w)
-
-        self.setpoint = FixedKeysDict(self.setpoint)
-
-        # Define continuous-time MPC model
-        self.model = do_mpc.model.Model('continuous')
-
-        # Define state variables
-        X = []
-        for n, state_name in enumerate(self.state_names):
-            x = self.model.set_variable(var_type='_x', var_name=state_name, shape=(1, 1))
-            X.append(x)
-
-        # Define input variables
-        U = []
-        for m, input_name in enumerate(self.input_names):
-            u = self.model.set_variable(var_type='_u', var_name=input_name, shape=(1, 1))
-            U.append(u)
-
-        # Define dynamics
-        Xdot = self.f(X, U)
-        for n, state_name in enumerate(self.state_names):
-            self.model.set_rhs(state_name, Xdot[n])
-
-        # Add time-varying set-point variables for later use with MPC
-        for n, state_name in enumerate(self.state_names):
-            x = self.model.set_variable(var_type='_tvp', var_name=state_name + str('_set'), shape=(1, 1))
-
-        # Build model
-        self.model.setup()
-
-        # Define simulator & simulator parameters
-        self.simulator = do_mpc.simulator.Simulator(self.model)
-
-        # Set simulation parameters
-        if params_simulator is None:
-            self.params_simulator = {
-                'integration_tool': 'idas',  # cvodes, idas
-                'abstol': 1e-8,
-                'reltol': 1e-8,
-                't_step': self.dt
-            }
-        else:
-            self.params_simulator = params_simulator
-
-        self.simulator.set_param(**self.params_simulator)
-
-        # Setup MPC
-        self.mpc = do_mpc.controller.MPC(self.model)
-        self.mpc_horizon = mpc_horizon
-        setup_mpc = {
-            'n_horizon': self.mpc_horizon,
-            'n_robust': 0,
-            'open_loop': 0,
-            't_step': self.dt,
-            'state_discretization': 'collocation',
-            'collocation_type': 'radau',
-            'collocation_deg': 2,
-            'collocation_ni': 1,
-            'store_full_solution': False,
-
-            # Use MA27 linear solver in ipopt for faster calculations:
-            'nlpsol_opts': {'ipopt.linear_solver': 'mumps',  # mumps, MA27
-                            'ipopt.print_level': 0,
-                            'ipopt.sb': 'yes',
-                            'print_time': 0,
-                            }
-        }
-
-        self.mpc.set_param(**setup_mpc)
-
-        # Get template's for MPC time-varying parameters
-        self.mpc_tvp_template = self.mpc.get_tvp_template()
-        self.simulator_tvp_template = self.simulator.get_tvp_template()
-
-        # Set time-varying set-point functions
-        self.mpc.set_tvp_fun(self.mpc_tvp_function)
-        self.simulator.set_tvp_fun(self.simulator_tvp_function)
-
-        # Setup simulator
-        self.simulator.setup()
-
-    def simulator_tvp_function(self, t):
-        """ Set the set-point function for MPC simulator.
-        :param t: current time
-        """
-
-        mpc_horizon = self.mpc._settings.n_horizon
-
-        # Set current step index
-        k_step = int(np.round(t / self.dt))
-        if k_step >= mpc_horizon:  # point is beyond end of input data
-            k_step = mpc_horizon - 1  # set point beyond input data to last point
-
-        # Update current set-point
-        for n, state_name in enumerate(self.state_names):
-            self.simulator_tvp_template[state_name + '_set'] = self.setpoint[state_name][k_step]
-
-        return self.simulator_tvp_template
-
-    def mpc_tvp_function(self, t):
-        """ Set the set-point function for MPC optimizer.
-        """
-
-        mpc_horizon = self.mpc._settings.n_horizon
-
-        # Set current step index
-        k_step = int(np.round(t / self.dt))
-
-        # Update set-point time horizon
-        for k in range(mpc_horizon + 1):
-            k_set = k_step + k
-            if k_set >= self.w:  # horizon is beyond end of input data
-                k_set = self.w - 1  # set part of horizon beyond input data to last point
-
-            # Update each set-point over time horizon
-            for n, state_name in enumerate(self.state_names):
-                self.mpc_tvp_template['_tvp', k, state_name + '_set'] = self.setpoint[state_name][k_set]
-
-        return self.mpc_tvp_template
-
-    def set_initial_state(self, x0):
-        """ Update the initial state.
-        """
-
-        if x0 is not None:  # initial state given
-            if isinstance(x0, dict):  # in dict format
-                SetDict().set_dict_with_overwrite(self.x0, x0)  # update only the states in the dict given
-            elif isinstance(x0, list) or isinstance(x0, tuple) or (
-            x0, np.ndarray):  # list, tuple,  or numpy array format
-                x0 = np.array(x0).squeeze()
-                for n, key in enumerate(self.x0.keys()):  # each state
-                    self.x0[key] = x0[n]
-            else:
-                raise Exception('x0 must be either a dict, tuple, list, or numpy array')
-
-    def update_dict(self, data=None, name=None):
-        """ Update.
-        """
-
-        update = getattr(self, name)
-
-        if data is not None:  # data given
-            if isinstance(data, dict):  # in dict format
-                SetDict().set_dict_with_overwrite(update, data)  # update only the inputs in the dict given
-            elif isinstance(data, list) or isinstance(data, tuple):  # list or tuple format, each input vector in each element
-                for n, k in enumerate(update.keys()):  # each state
-                    update[k] = data[n]
-            elif isinstance(data, np.ndarray):  # numpy array format given as matrix where columns are the different inputs
-                if len(data.shape) <= 1:  # given as 1d array, so convert to column vector
-                    data = np.atleast_2d(data).T
-
-                for n, key in enumerate(update.keys()):  # each input
-                    update[key] = data[:, n]
-
-            else:
-                raise Exception(name + ' must be either a dict, tuple, list, or numpy array')
-
-        # Make sure inputs are the same size
-        points = np.array([update[key].shape[0] for key in update.keys()])
-        points_check = points == points[0]
-        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):
-        """
-        Simulate the system.
-
-        :params x0: initial state dict or array
-        :params u: input dict or array
-        :params return_full_output: boolean to run (time, x, u, y) instead of y
-        """
-
-        if (mpc is True) and (u is not None):
-            raise Exception('u must be None if running MPC')
-
-        if (mpc is False) and (u is None):
-            warnings.warn('not running MPC or setting u directly')
-
-        # Update the initial state
-        if x0 is None:
-            if mpc:  # set the initial state to start at set-point if running MPC
-                x0 = {}
-                for state_name in self.state_names:
-                    x0[state_name] = self.setpoint[state_name][0]
-
-                self.set_initial_state(x0=x0)
-        else:
-            self.set_initial_state(x0=x0)
-
-        # Update the inputs
-        self.update_dict(u, name='u')
-
-        # Concatenate the inputs, where rows are individual inputs and columns are time-steps
-        if mpc:
-            self.w = np.vstack(list(self.setpoint.values())).shape[1]
-            u_sim = np.zeros((self.w, self.m))  # preallocate input array
-        else:
-            self.w = np.vstack(list(self.u.values())).shape[1]
-            u_sim = np.vstack(list(self.u.values())).T
-
-        # Update time vector
-        T = (self.w - 1) * self.dt
-        self.time = np.linspace(0, T, num=self.w)
-
-        # Set array to store simulated states, where rows are individual states and columns are time-steps
-        x_step = np.array(list(self.x0.values()))  # initialize state
-        x = np.nan * np.zeros((self.w, self.n))
-        x[0, :] = x_step.copy()
-
-        # Initialize the simulator
-        self.simulator.t0 = self.time[0]
-        self.simulator.x0 = x_step.copy()
-        self.simulator.set_initial_guess()
-
-        # Initialize MPC
-        if mpc:
-            self.mpc.setup()
-            self.mpc.t0 = self.time[0]
-            self.mpc.x0 = x_step.copy()
-            self.mpc.u0 = np.zeros((self.m, 1))
-            self.mpc.set_initial_guess()
-
-        # Run simulation
-        for k in range(1, self.w):
-            # Set input
-            if mpc:  # run MPC step
-                u_step = self.mpc.make_step(x_step)
-            else:  # use inputs directly
-                u_step = u_sim[k - 1:k, :].T
-
-            # Store inputs
-            u_sim[k - 1, :] = u_step.squeeze()
-
-            # Simulate one time step given current inputs
-            x_step = self.simulator.make_step(u_step)
-
-            # Store new states
-            x[k, :] = x_step.squeeze()
-
-        # Last input has no effect, so keep it the same as previous time-step
-        if mpc:
-            u_sim[-1, :] = u_sim[-2, :]
-
-        # Update the inputs
-        self.update_dict(u_sim, name='u')
-
-        # Update state trajectory
-        self.update_dict(x, name='x')
-
-        # Calculate measurements
-        x_list = list(self.x.values())
-        u_list = list(self.u.values())
-        y = self.h(x_list, u_list)
-
-        # Set measurements
-        self.update_dict(y, name='y')
-
-        # Return the measurements in array format
-        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()
-        else:
-            return y_array
-
-    def get_time_states_inputs_measurements(self):
-        return self.time.copy(), self.x.copy(), self.u.copy(), self.u.copy()
-
-    def plot(self, name='x', dpi=150, plot_kwargs=None):
-        """ Plot states, inputs.
-        """
-
-        if plot_kwargs is None:
-            plot_kwargs = {
-                'color': 'black',
-                'linewidth': 2.0,
-                'linestyle': '-',
-                'marker': '.',
-                'markersize': 0
-            }
-
-            if name == 'x':
-                plot_kwargs['color'] = 'firebrick'
-            elif name == 'u':
-                plot_kwargs['color'] = 'royalblue'
-            elif name == 'y':
-                plot_kwargs['color'] = 'seagreen'
-            elif name == 'setpoint':
-                plot_kwargs['color'] = 'gray'
-
-        plot_dict = getattr(self, name)
-        plot_data = np.array(list(plot_dict.values()))
-        n = plot_data.shape[0]
-
-        fig, ax = plt.subplots(n, 1, figsize=(4, n * 1.5), dpi=dpi, sharex=True)
-        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].set_ylabel(key, fontsize=7)
-
-            # Also plot the states if plotting setpoint
-            if name == 'setpoint':
-                ax[n].plot(self.time, self.x[key], label=key, color='firebrick', linestyle='-', linewidth=0.5)
-                ax[n].legend(fontsize=6)
-
-        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-0.0.6.dist-info/RECORD

@@ -1,10 +0,0 @@
-pybounds/__init__.py,sha256=so9LuRNw2V8MGsDs-RPstGGgJtBFp2YGolQbS0rVfhw,348
-pybounds/drone_simulator.py,sha256=-CrQVpNfiBDFECd6H7FU5has4sYGW1gyS2RhOgXUqZg,15858
-pybounds/observability.py,sha256=4tdK6AK678zoorbkQ2psvzMRLY32CIj2QwVb-0w-GXk,27541
-pybounds/simulator.py,sha256=ReaCRHA-DjiE1EbmCStw2Top9EyJeg41S_lO-iqnjv4,16194
-pybounds/util.py,sha256=Gs0UgqgLXTJI9FZww90iJhqU02iJ31bXBURjGiq3YzM,7401
-pybounds-0.0.6.dist-info/LICENSE,sha256=kqeyRXtRGgBVZdXYeIX4zR9l2KZ2rqIBVEiPMTjxjcI,1093
-pybounds-0.0.6.dist-info/METADATA,sha256=MAp33xdjWLOfB17N32E-GdKRZnaCHtIwBc65XmFQXb4,2155
-pybounds-0.0.6.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-pybounds-0.0.6.dist-info/top_level.txt,sha256=V-ofnWE3m_UkXTXJwNRD07n14m5R6sc6l4NadaCCP_A,9
-pybounds-0.0.6.dist-info/RECORD,,