From a7f5f1ce47e7504848c8b0bccb3186a27fc57a64 Mon Sep 17 00:00:00 2001 From: Ben Date: Sun, 5 Jan 2020 08:08:13 -0800 Subject: [PATCH 01/67] Copy PR #320 fix for robust_array_test to fix OpenSUSE bug (#365) PR #314 duplicates a lot of code in the test cases by introducing *_array_test.py files. Thus issue #190 addressed in PR #320 resurfaces and needs to be introduced to robust_array_test.pyas well. --- control/tests/robust_array_test.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/control/tests/robust_array_test.py b/control/tests/robust_array_test.py index 51114f879..62cf8c6c5 100644 --- a/control/tests/robust_array_test.py +++ b/control/tests/robust_array_test.py @@ -261,7 +261,7 @@ def testMimoW3(self): @unittest.skipIf(not slycot_check(), "slycot not installed") def testMimoW123(self): """MIMO plant with all weights""" - from control import augw, ss, append + from control import augw, ss, append, minreal g = ss([[-1., -2], [-3, -4]], [[1., 0.], [0., 1.]], [[1., 0.], [0., 1.]], @@ -311,10 +311,10 @@ def testMimoW123(self): self.siso_almost_equal(w2[1, 1], p[3, 3]) # u->z3 should be w3*g w3g = w3 * g; - self.siso_almost_equal(w3g[0, 0], p[4, 2]) - self.siso_almost_equal(w3g[0, 1], p[4, 3]) - self.siso_almost_equal(w3g[1, 0], p[5, 2]) - self.siso_almost_equal(w3g[1, 1], p[5, 3]) + self.siso_almost_equal(w3g[0, 0], minreal(p[4, 2])) + self.siso_almost_equal(w3g[0, 1], minreal(p[4, 3])) + self.siso_almost_equal(w3g[1, 0], minreal(p[5, 2])) + self.siso_almost_equal(w3g[1, 1], minreal(p[5, 3])) # u->v should be -g self.siso_almost_equal(-g[0, 0], p[6, 2]) self.siso_almost_equal(-g[0, 1], p[6, 3]) From 66bee9d31c0e4913aa2bda614794845563a616d6 Mon Sep 17 00:00:00 2001 From: Ben Date: Mon, 6 Jan 2020 17:20:23 -0800 Subject: [PATCH 02/67] ease precision tolerenace for iosys tests (#366) --- control/tests/iosys_test.py | 42 ++++++++++++++++++------------------- 1 file changed, 21 insertions(+), 21 deletions(-) diff --git a/control/tests/iosys_test.py b/control/tests/iosys_test.py index aaf2243c1..9fdac09cf 100644 --- a/control/tests/iosys_test.py +++ b/control/tests/iosys_test.py @@ -60,7 +60,7 @@ def test_linear_iosys(self): lti_t, lti_y, lti_x = ct.forced_response(linsys, T, U, X0) ios_t, ios_y = ios.input_output_response(iosys, T, U, X0) np.testing.assert_array_almost_equal(lti_t, ios_t) - np.testing.assert_array_almost_equal(lti_y, ios_y, decimal=3) + np.testing.assert_allclose(lti_y, ios_y,atol=0.002,rtol=0.) @unittest.skipIf(StrictVersion(sp.__version__) < "1.0", "requires SciPy 1.0 or greater") @@ -75,7 +75,7 @@ def test_tf2io(self): lti_t, lti_y, lti_x = ct.forced_response(linsys, T, U, X0) ios_t, ios_y = ios.input_output_response(iosys, T, U, X0) np.testing.assert_array_almost_equal(lti_t, ios_t) - np.testing.assert_array_almost_equal(lti_y, ios_y, decimal=3) + np.testing.assert_allclose(lti_y, ios_y,atol=0.002,rtol=0.) def test_ss2io(self): # Create an input/output system from the linear system @@ -161,7 +161,7 @@ def test_nonlinear_iosys(self): lti_t, lti_y, lti_x = ct.forced_response(linsys, T, U, X0) ios_t, ios_y = ios.input_output_response(nlsys, T, U, X0) np.testing.assert_array_almost_equal(lti_t, ios_t) - np.testing.assert_array_almost_equal(lti_y, ios_y, decimal=3) + np.testing.assert_allclose(lti_y, ios_y,atol=0.002,rtol=0.) def test_linearize(self): # Create a single input/single output linear system @@ -214,7 +214,7 @@ def test_connect(self): iosys_series, T, U, X0, return_x=True) lti_t, lti_y, lti_x = ct.forced_response(linsys_series, T, U, X0) np.testing.assert_array_almost_equal(lti_t, ios_t) - np.testing.assert_array_almost_equal(lti_y, ios_y, decimal=3) + np.testing.assert_allclose(lti_y, ios_y,atol=0.002,rtol=0.) # Connect systems with different timebases linsys2c = self.siso_linsys @@ -231,7 +231,7 @@ def test_connect(self): iosys_series, T, U, X0, return_x=True) lti_t, lti_y, lti_x = ct.forced_response(linsys_series, T, U, X0) np.testing.assert_array_almost_equal(lti_t, ios_t) - np.testing.assert_array_almost_equal(lti_y, ios_y, decimal=3) + np.testing.assert_allclose(lti_y, ios_y,atol=0.002,rtol=0.) # Feedback interconnection linsys_feedback = ct.feedback(linsys1, linsys2) @@ -246,7 +246,7 @@ def test_connect(self): iosys_feedback, T, U, X0, return_x=True) lti_t, lti_y, lti_x = ct.forced_response(linsys_feedback, T, U, X0) np.testing.assert_array_almost_equal(lti_t, ios_t) - np.testing.assert_array_almost_equal(lti_y, ios_y, decimal=3) + np.testing.assert_allclose(lti_y, ios_y,atol=0.002,rtol=0.) @unittest.skipIf(StrictVersion(sp.__version__) < "1.0", "requires SciPy 1.0 or greater") @@ -357,7 +357,7 @@ def test_summer(self): lin_t, lin_y, lin_x = ct.forced_response(linsys_parallel, T, U, X0) ios_t, ios_y = ios.input_output_response(iosys_parallel, T, U, X0) - np.testing.assert_array_almost_equal(ios_y, lin_y, decimal=3) + np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.) @unittest.skipIf(StrictVersion(sp.__version__) < "1.0", "requires SciPy 1.0 or greater") @@ -420,7 +420,7 @@ def test_feedback(self): ios_t, ios_y = ios.input_output_response(iosys, T, U, X0) lti_t, lti_y, lti_x = ct.forced_response(linsys, T, U, X0) - np.testing.assert_array_almost_equal(ios_y, lti_y, decimal=3) + np.testing.assert_allclose(ios_y, lti_y,atol=0.002,rtol=0.) @unittest.skipIf(StrictVersion(sp.__version__) < "1.0", "requires SciPy 1.0 or greater") @@ -442,7 +442,7 @@ def test_bdalg_functions(self): iosys_series = ct.series(linio1, linio2) lin_t, lin_y, lin_x = ct.forced_response(linsys_series, T, U, X0) ios_t, ios_y = ios.input_output_response(iosys_series, T, U, X0) - np.testing.assert_array_almost_equal(ios_y, lin_y, decimal=3) + np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.) # Make sure that systems don't commute linsys_series = ct.series(linsys2, linsys1) @@ -454,21 +454,21 @@ def test_bdalg_functions(self): iosys_parallel = ct.parallel(linio1, linio2) lin_t, lin_y, lin_x = ct.forced_response(linsys_parallel, T, U, X0) ios_t, ios_y = ios.input_output_response(iosys_parallel, T, U, X0) - np.testing.assert_array_almost_equal(ios_y, lin_y, decimal=3) + np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.) # Negation linsys_negate = ct.negate(linsys1) iosys_negate = ct.negate(linio1) lin_t, lin_y, lin_x = ct.forced_response(linsys_negate, T, U, X0) ios_t, ios_y = ios.input_output_response(iosys_negate, T, U, X0) - np.testing.assert_array_almost_equal(ios_y, lin_y, decimal=3) + np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.) # Feedback interconnection linsys_feedback = ct.feedback(linsys1, linsys2) iosys_feedback = ct.feedback(linio1, linio2) lin_t, lin_y, lin_x = ct.forced_response(linsys_feedback, T, U, X0) ios_t, ios_y = ios.input_output_response(iosys_feedback, T, U, X0) - np.testing.assert_array_almost_equal(ios_y, lin_y, decimal=3) + np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.) @unittest.skipIf(StrictVersion(sp.__version__) < "1.0", "requires SciPy 1.0 or greater") @@ -496,26 +496,26 @@ def test_nonsquare_bdalg(self): iosys_multiply = iosys_3i2o * iosys_2i3o lin_t, lin_y, lin_x = ct.forced_response(linsys_multiply, T, U2, X0) ios_t, ios_y = ios.input_output_response(iosys_multiply, T, U2, X0) - np.testing.assert_array_almost_equal(ios_y, lin_y, decimal=3) + np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.) linsys_multiply = linsys_2i3o * linsys_3i2o iosys_multiply = iosys_2i3o * iosys_3i2o lin_t, lin_y, lin_x = ct.forced_response(linsys_multiply, T, U3, X0) ios_t, ios_y = ios.input_output_response(iosys_multiply, T, U3, X0) - np.testing.assert_array_almost_equal(ios_y, lin_y, decimal=3) + np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.) # Right multiplication # TODO: add real tests once conversion from other types is supported iosys_multiply = ios.InputOutputSystem.__rmul__(iosys_3i2o, iosys_2i3o) ios_t, ios_y = ios.input_output_response(iosys_multiply, T, U3, X0) - np.testing.assert_array_almost_equal(ios_y, lin_y, decimal=3) + np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.) # Feedback linsys_multiply = ct.feedback(linsys_3i2o, linsys_2i3o) iosys_multiply = iosys_3i2o.feedback(iosys_2i3o) lin_t, lin_y, lin_x = ct.forced_response(linsys_multiply, T, U3, X0) ios_t, ios_y = ios.input_output_response(iosys_multiply, T, U3, X0) - np.testing.assert_array_almost_equal(ios_y, lin_y, decimal=3) + np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.) # Mismatch should generate exception args = (iosys_3i2o, iosys_3i2o) @@ -536,8 +536,8 @@ def test_discrete(self): # Simulate and compare to LTI output ios_t, ios_y = ios.input_output_response(lnios, T, U, X0) lin_t, lin_y, lin_x = ct.forced_response(linsys, T, U, X0) - np.testing.assert_array_almost_equal(ios_t, lin_t, decimal=3) - np.testing.assert_array_almost_equal(ios_y, lin_y, decimal=3) + np.testing.assert_allclose(ios_t, lin_t,atol=0.002,rtol=0.) + np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.) # Test MIMO system, converted to discrete time linsys = ct.StateSpace(self.mimo_linsys1) @@ -552,8 +552,8 @@ def test_discrete(self): # Simulate and compare to LTI output ios_t, ios_y = ios.input_output_response(lnios, T, U, X0) lin_t, lin_y, lin_x = ct.forced_response(linsys, T, U, X0) - np.testing.assert_array_almost_equal(ios_t, lin_t, decimal=3) - np.testing.assert_array_almost_equal(ios_y, lin_y, decimal=3) + np.testing.assert_allclose(ios_t, lin_t,atol=0.002,rtol=0.) + np.testing.assert_allclose(ios_y, lin_y,atol=0.002,rtol=0.) def test_find_eqpts(self): """Test find_eqpt function""" @@ -738,7 +738,7 @@ def test_params(self): # Check to make sure results are OK np.testing.assert_array_almost_equal(lti_t, ios_t) - np.testing.assert_array_almost_equal(lti_y, ios_y, decimal=3) + np.testing.assert_allclose(lti_y, ios_y,atol=0.002,rtol=0.) def test_named_signals(self): sys1 = ios.NonlinearIOSystem( From a995655ec55f940f1cd3687ad279067795db78f7 Mon Sep 17 00:00:00 2001 From: Francesco Seccamonte Date: Thu, 20 Feb 2020 18:26:49 -0800 Subject: [PATCH 03/67] Bugfix in matrix multiplication in output computation in iosys.LinearIOSystem --- control/iosys.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/control/iosys.py b/control/iosys.py index 908f407b3..520a6237c 100644 --- a/control/iosys.py +++ b/control/iosys.py @@ -656,8 +656,10 @@ def _rhs(self, t, x, u): return np.array(xdot).reshape((-1,)) def _out(self, t, x, u): - y = self.C * np.reshape(x, (-1, 1)) + self.D * np.reshape(u, (-1, 1)) - return np.array(y).reshape((self.noutputs,)) + # Convert input to column vector and then change output to 1D array + y = np.dot(self.C, np.reshape(x, (-1, 1))) \ + + np.dot(self.D, np.reshape(u, (-1, 1))) + return np.array(y).reshape((-1,)) class NonlinearIOSystem(InputOutputSystem): From 874d52eca13f1644eddad52be3e74a5c79883cfd Mon Sep 17 00:00:00 2001 From: geekonloose <30520900+geekonloose@users.noreply.github.com> Date: Wed, 18 Mar 2020 10:27:50 +0530 Subject: [PATCH 04/67] Arrow head length and head width option is added in nyquist_plot function (#379) Add option to change Nyquist plot arrow size: * Nyquist_plot changed to accommodate arrow size * color option is added --- control/freqplot.py | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/control/freqplot.py b/control/freqplot.py index 1bb1fc7a5..c8b513943 100644 --- a/control/freqplot.py +++ b/control/freqplot.py @@ -433,8 +433,9 @@ def gen_zero_centered_series(val_min, val_max, period): # Nyquist plot # -def nyquist_plot(syslist, omega=None, Plot=True, color=None, - labelFreq=0, *args, **kwargs): +def nyquist_plot(syslist, omega=None, Plot=True, + labelFreq=0, arrowhead_length=0.1, arrowhead_width=0.1, + color=None, *args, **kwargs): """ Nyquist plot for a system @@ -452,6 +453,8 @@ def nyquist_plot(syslist, omega=None, Plot=True, color=None, Used to specify the color of the plot labelFreq : int Label every nth frequency on the plot + arrowhead_width : arrow head width + arrowhead_length : arrow head length *args Additional arguments for :func:`matplotlib.plot` (color, linestyle, etc) **kwargs: @@ -511,12 +514,14 @@ def nyquist_plot(syslist, omega=None, Plot=True, color=None, ax = plt.gca() # Plot arrow to indicate Nyquist encirclement orientation ax.arrow(x[0], y[0], (x[1]-x[0])/2, (y[1]-y[0])/2, fc=c, ec=c, - head_width=0.2, head_length=0.2) + head_width=arrowhead_width, + head_length=arrowhead_length) plt.plot(x, -y, '-', color=c, *args, **kwargs) ax.arrow( x[-1], -y[-1], (x[-1]-x[-2])/2, (y[-1]-y[-2])/2, - fc=c, ec=c, head_width=0.2, head_length=0.2) + fc=c, ec=c, head_width=arrowhead_width, + head_length=arrowhead_length) # Mark the -1 point plt.plot([-1], [0], 'r+') From a09d059e57b060592ed79fc89aac2dfc40064fe0 Mon Sep 17 00:00:00 2001 From: Ben Date: Sat, 21 Mar 2020 20:51:06 +0100 Subject: [PATCH 05/67] handle non proper tf in _common_den() (#370) --- control/tests/xferfcn_test.py | 28 ++++++++++++++++++++++++++++ control/xferfcn.py | 28 ++++++++++++++++++++++++++-- 2 files changed, 54 insertions(+), 2 deletions(-) diff --git a/control/tests/xferfcn_test.py b/control/tests/xferfcn_test.py index 0a1778d1d..338ba4b01 100644 --- a/control/tests/xferfcn_test.py +++ b/control/tests/xferfcn_test.py @@ -546,6 +546,26 @@ def test_common_den(self): np.zeros((3, 5, 6))) np.testing.assert_array_almost_equal(den, denref) + def test_common_den_nonproper(self): + """ Test _common_den with order(num)>order(den) """ + + tf1 = TransferFunction( + [[[1., 2., 3.]], [[1., 2.]]], + [[[1., -2.]], [[1., -3.]]]) + tf2 = TransferFunction( + [[[1., 2.]], [[1., 2., 3.]]], + [[[1., -2.]], [[1., -3.]]]) + + common_den_ref = np.array([[1., -5., 6.]]) + + np.testing.assert_raises(ValueError, tf1._common_den) + np.testing.assert_raises(ValueError, tf2._common_den) + + _, den1, _ = tf1._common_den(allow_nonproper=True) + np.testing.assert_array_almost_equal(den1, common_den_ref) + _, den2, _ = tf2._common_den(allow_nonproper=True) + np.testing.assert_array_almost_equal(den2, common_den_ref) + @unittest.skipIf(not slycot_check(), "slycot not installed") def test_pole_mimo(self): """Test for correct MIMO poles.""" @@ -557,6 +577,14 @@ def test_pole_mimo(self): np.testing.assert_array_almost_equal(p, [-2., -2., -7., -3., -2.]) + # non proper transfer function + sys2 = TransferFunction( + [[[1., 2., 3., 4.], [1.]], [[1.], [1.]]], + [[[1., 2.], [1., 3.]], [[1., 4., 4.], [1., 9., 14.]]]) + p2 = sys2.pole() + + np.testing.assert_array_almost_equal(p2, [-2., -2., -7., -3., -2.]) + def test_double_cancelling_poles_siso(self): H = TransferFunction([1, 1], [1, 2, 1]) diff --git a/control/xferfcn.py b/control/xferfcn.py index 017d90437..cb351de0f 100644 --- a/control/xferfcn.py +++ b/control/xferfcn.py @@ -679,7 +679,7 @@ def freqresp(self, omega): def pole(self): """Compute the poles of a transfer function.""" - num, den, denorder = self._common_den() + _, den, denorder = self._common_den(allow_nonproper=True) rts = [] for d, o in zip(den, denorder): rts.extend(roots(d[:o + 1])) @@ -797,7 +797,7 @@ def returnScipySignalLTI(self): return out - def _common_den(self, imag_tol=None): + def _common_den(self, imag_tol=None, allow_nonproper=False): """ Compute MIMO common denominators; return them and adjusted numerators. @@ -813,6 +813,9 @@ def _common_den(self, imag_tol=None): Threshold for the imaginary part of a root to use in detecting complex poles + allow_nonproper : boolean + Do not enforce proper transfer functions + Returns ------- num: array @@ -822,6 +825,8 @@ def _common_den(self, imag_tol=None): gives the numerator coefficient array for the ith output and jth input; padded for use in td04ad ('C' option); matches the denorder order; highest coefficient starts on the left. + If allow_nonproper=True and the order of a numerator exceeds the + order of the common denominator, num will be returned as None den: array sys.inputs by kd @@ -906,6 +911,8 @@ def _common_den(self, imag_tol=None): dtype=float) denorder = zeros((self.inputs,), dtype=int) + havenonproper = False + for j in range(self.inputs): if not len(poles[j]): # no poles matching this input; only one or more gains @@ -930,11 +937,28 @@ def _common_den(self, imag_tol=None): nwzeros.append(poles[j][ip]) numpoly = poleset[i][j][2] * np.atleast_1d(poly(nwzeros)) + + # td04ad expects a proper transfer function. If the + # numerater has a higher order than the denominator, the + # padding will fail + if len(numpoly) > maxindex + 1: + if allow_nonproper: + havenonproper = True + break + raise ValueError( + self.__str__() + + "is not a proper transfer function. " + "The degree of the numerators must not exceed " + "the degree of the denominators.") + # numerator polynomial should be padded on left and right # ending at maxindex to line up with what td04ad expects. num[i, j, maxindex+1-len(numpoly):maxindex+1] = numpoly # print(num[i, j]) + if havenonproper: + num = None + return num, den, denorder def sample(self, Ts, method='zoh', alpha=None): From 3b19ae93d3403b5cc6460ab4d34d30a07e1c67f2 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Tue, 24 Mar 2020 22:45:44 -0700 Subject: [PATCH 06/67] Fix plot issues (#382) * fix sgrid, zgrid to use existing axes if they exist + PEP8 cleanup * change plot and print_gain keywords to lower case, with deprecation warning + fix bugs in gangof4 using dB + PEP8, docstring cleanup * remove conversion to state space that was giving spurious zero at infinity * change plot and print_gain keywords to lower case, with deprecation warning * PEP8 cleanup * use Hz=False for MATLAB + docstring corrections * labelFreq -> label_freq in nyquist_plot() w/ deprecation warning + remove extraneous docstring text --- control/config.py | 6 +- control/freqplot.py | 109 +++++++++++++++++++-------- control/grid.py | 80 +++++++++++--------- control/nichols.py | 25 +++--- control/pzmap.py | 30 +++++--- control/rlocus.py | 38 +++++++--- control/statesp.py | 2 +- control/tests/config_test.py | 8 +- control/tests/convert_test.py | 8 +- control/tests/matlab_test.py | 8 +- control/tests/rlocus_test.py | 4 +- control/tests/slycot_convert_test.py | 8 +- examples/pvtol-nested.py | 6 +- 13 files changed, 203 insertions(+), 129 deletions(-) diff --git a/control/config.py b/control/config.py index f61469394..02028cfba 100644 --- a/control/config.py +++ b/control/config.py @@ -114,11 +114,11 @@ def use_matlab_defaults(): The following conventions are used: * Bode plots plot gain in dB, phase in degrees, frequency in - Hertz, with grids + rad/sec, with grids * State space class and functions use Numpy matrix objects """ - set_defaults('bode', dB=True, deg=True, Hz=True, grid=True) + set_defaults('bode', dB=True, deg=True, Hz=False, grid=True) set_defaults('statesp', use_numpy_matrix=True) @@ -128,7 +128,7 @@ def use_fbs_defaults(): The following conventions are used: * Bode plots plot gain in powers of ten, phase in degrees, - frequency in Hertz, no grid + frequency in rad/sec, no grid """ set_defaults('bode', dB=False, deg=True, Hz=False, grid=False) diff --git a/control/freqplot.py b/control/freqplot.py index c8b513943..a1772fea7 100644 --- a/control/freqplot.py +++ b/control/freqplot.py @@ -80,7 +80,7 @@ def bode_plot(syslist, omega=None, - Plot=True, omega_limits=None, omega_num=None, + plot=True, omega_limits=None, omega_num=None, margins=None, *args, **kwargs): """Bode plot for a system @@ -100,7 +100,7 @@ def bode_plot(syslist, omega=None, deg : bool If True, plot phase in degrees (else radians). Default value (True) config.defaults['bode.deg'] - Plot : bool + plot : bool If True (default), plot magnitude and phase omega_limits: tuple, list, ... of two values Limits of the to generate frequency vector. @@ -110,9 +110,9 @@ def bode_plot(syslist, omega=None, config.defaults['freqplot.number_of_samples']. margins : bool If True, plot gain and phase margin. - *args - Additional arguments for :func:`matplotlib.plot` (color, linestyle, etc) - **kwargs: + *args : `matplotlib` plot positional properties, optional + Additional arguments for `matplotlib` plots (color, linestyle, etc) + **kwargs : `matplotlib` plot keyword properties, optional Additional keywords (passed to `matplotlib`) Returns @@ -153,12 +153,20 @@ def bode_plot(syslist, omega=None, # Make a copy of the kwargs dictonary since we will modify it kwargs = dict(kwargs) + # Check to see if legacy 'Plot' keyword was used + if 'Plot' in kwargs: + import warnings + warnings.warn("'Plot' keyword is deprecated in bode_plot; use 'plot'", + FutureWarning) + # Map 'Plot' keyword to 'plot' keyword + plot = kwargs.pop('Plot') + # Get values for params (and pop from list to allow keyword use in plot) dB = config._get_param('bode', 'dB', kwargs, _bode_defaults, pop=True) deg = config._get_param('bode', 'deg', kwargs, _bode_defaults, pop=True) Hz = config._get_param('bode', 'Hz', kwargs, _bode_defaults, pop=True) grid = config._get_param('bode', 'grid', kwargs, _bode_defaults, pop=True) - Plot = config._get_param('bode', 'grid', Plot, True) + plot = config._get_param('bode', 'grid', plot, True) margins = config._get_param('bode', 'margins', margins, False) # If argument was a singleton, turn it into a list @@ -211,7 +219,7 @@ def bode_plot(syslist, omega=None, # Get the dimensions of the current axis, which we will divide up # TODO: Not current implemented; just use subplot for now - if Plot: + if plot: nyquistfrq_plot = None if Hz: omega_plot = omega_sys / (2. * math.pi) @@ -429,12 +437,13 @@ def gen_zero_centered_series(val_min, val_max, period): else: return mags, phases, omegas + # # Nyquist plot # -def nyquist_plot(syslist, omega=None, Plot=True, - labelFreq=0, arrowhead_length=0.1, arrowhead_width=0.1, +def nyquist_plot(syslist, omega=None, plot=True, label_freq=0, + arrowhead_length=0.1, arrowhead_width=0.1, color=None, *args, **kwargs): """ Nyquist plot for a system @@ -451,13 +460,13 @@ def nyquist_plot(syslist, omega=None, Plot=True, If True, plot magnitude color : string Used to specify the color of the plot - labelFreq : int + label_freq : int Label every nth frequency on the plot arrowhead_width : arrow head width arrowhead_length : arrow head length - *args - Additional arguments for :func:`matplotlib.plot` (color, linestyle, etc) - **kwargs: + *args : `matplotlib` plot positional properties, optional + Additional arguments for `matplotlib` plots (color, linestyle, etc) + **kwargs : `matplotlib` plot keyword properties, optional Additional keywords (passed to `matplotlib`) Returns @@ -475,6 +484,22 @@ def nyquist_plot(syslist, omega=None, Plot=True, >>> real, imag, freq = nyquist_plot(sys) """ + # Check to see if legacy 'Plot' keyword was used + if 'Plot' in kwargs: + import warnings + warnings.warn("'Plot' keyword is deprecated in nyquist_plot; " + "use 'plot'", FutureWarning) + # Map 'Plot' keyword to 'plot' keyword + plot = kwargs.pop('Plot') + + # Check to see if legacy 'labelFreq' keyword was used + if 'labelFreq' in kwargs: + import warnings + warnings.warn("'labelFreq' keyword is deprecated in nyquist_plot; " + "use 'label_freq'", FutureWarning) + # Map 'labelFreq' keyword to 'label_freq' keyword + label_freq = kwargs.pop('labelFreq') + # If argument was a singleton, turn it into a list if not getattr(syslist, '__iter__', False): syslist = (syslist,) @@ -507,7 +532,7 @@ def nyquist_plot(syslist, omega=None, Plot=True, x = sp.multiply(mag, sp.cos(phase)) y = sp.multiply(mag, sp.sin(phase)) - if Plot: + if plot: # Plot the primary curve and mirror image p = plt.plot(x, y, '-', color=color, *args, **kwargs) c = p[0].get_color() @@ -527,8 +552,8 @@ def nyquist_plot(syslist, omega=None, Plot=True, plt.plot([-1], [0], 'r+') # Label the frequencies of the points - if labelFreq: - ind = slice(None, None, labelFreq) + if label_freq: + ind = slice(None, None, label_freq) for xpt, ypt, omegapt in zip(x[ind], y[ind], omega[ind]): # Convert to Hz f = omegapt / (2 * sp.pi) @@ -550,7 +575,7 @@ def nyquist_plot(syslist, omega=None, Plot=True, str(int(np.round(f / 1000 ** pow1000, 0))) + ' ' + prefix + 'Hz') - if Plot: + if plot: ax = plt.gca() ax.set_xlabel("Real axis") ax.set_ylabel("Imaginary axis") @@ -558,6 +583,7 @@ def nyquist_plot(syslist, omega=None, Plot=True, return x, y, omega + # # Gang of Four plot # @@ -575,6 +601,8 @@ def gangof4_plot(P, C, omega=None, **kwargs): Linear input/output systems (process and control) omega : array Range of frequencies (list or bounds) in rad/sec + **kwargs : `matplotlib` plot keyword properties, optional + Additional keywords (passed to `matplotlib`) Returns ------- @@ -590,16 +618,16 @@ def gangof4_plot(P, C, omega=None, **kwargs): Hz = config._get_param('bode', 'Hz', kwargs, _bode_defaults, pop=True) grid = config._get_param('bode', 'grid', kwargs, _bode_defaults, pop=True) - # Select a default range if none is provided - # TODO: This needs to be made more intelligent - if omega is None: - omega = default_frequency_range((P, C)) - # Compute the senstivity functions L = P * C S = feedback(1, L) T = L * S + # Select a default range if none is provided + # TODO: This needs to be made more intelligent + if omega is None: + omega = default_frequency_range((P, C, S)) + # Set up the axes with labels so that multiple calls to # gangof4_plot will superimpose the data. See details in bode_plot. plot_axes = {'t': None, 's': None, 'ps': None, 'cs': None} @@ -628,36 +656,49 @@ def gangof4_plot(P, C, omega=None, **kwargs): # TODO: Need to add in the mag = 1 lines mag_tmp, phase_tmp, omega = S.freqresp(omega) mag = np.squeeze(mag_tmp) - plot_axes['s'].loglog(omega_plot, 20 * np.log10(mag) if dB else mag) - plot_axes['s'].set_ylabel("$|S|$") + if dB: + plot_axes['s'].semilogx(omega_plot, 20 * np.log10(mag), **kwargs) + else: + plot_axes['s'].loglog(omega_plot, mag, **kwargs) + plot_axes['s'].set_ylabel("$|S|$" + " (dB)" if dB else "") plot_axes['s'].tick_params(labelbottom=False) plot_axes['s'].grid(grid, which='both') mag_tmp, phase_tmp, omega = (P * S).freqresp(omega) mag = np.squeeze(mag_tmp) - plot_axes['ps'].loglog(omega_plot, 20 * np.log10(mag) if dB else mag) + if dB: + plot_axes['ps'].semilogx(omega_plot, 20 * np.log10(mag), **kwargs) + else: + plot_axes['ps'].loglog(omega_plot, mag, **kwargs) plot_axes['ps'].tick_params(labelbottom=False) - plot_axes['ps'].set_ylabel("$|PS|$") + plot_axes['ps'].set_ylabel("$|PS|$" + " (dB)" if dB else "") plot_axes['ps'].grid(grid, which='both') mag_tmp, phase_tmp, omega = (C * S).freqresp(omega) mag = np.squeeze(mag_tmp) - plot_axes['cs'].loglog(omega_plot, 20 * np.log10(mag) if dB else mag) + if dB: + plot_axes['cs'].semilogx(omega_plot, 20 * np.log10(mag), **kwargs) + else: + plot_axes['cs'].loglog(omega_plot, mag, **kwargs) plot_axes['cs'].set_xlabel( "Frequency (Hz)" if Hz else "Frequency (rad/sec)") - plot_axes['cs'].set_ylabel("$|CS|$") + plot_axes['cs'].set_ylabel("$|CS|$" + " (dB)" if dB else "") plot_axes['cs'].grid(grid, which='both') mag_tmp, phase_tmp, omega = T.freqresp(omega) mag = np.squeeze(mag_tmp) - plot_axes['t'].loglog(omega_plot, 20 * np.log10(mag) if dB else mag) + if dB: + plot_axes['t'].semilogx(omega_plot, 20 * np.log10(mag), **kwargs) + else: + plot_axes['t'].loglog(omega_plot, mag, **kwargs) plot_axes['t'].set_xlabel( "Frequency (Hz)" if Hz else "Frequency (rad/sec)") - plot_axes['t'].set_ylabel("$|T|$") + plot_axes['t'].set_ylabel("$|T|$" + " (dB)" if dB else "") plot_axes['t'].grid(grid, which='both') plt.tight_layout() + # # Utility functions # @@ -754,7 +795,7 @@ def default_frequency_range(syslist, Hz=None, number_of_samples=None, # TODO raise NotImplementedError( "type of system in not implemented now") - except: + except NotImplementedError: pass # Make sure there is at least one point in the range @@ -787,15 +828,17 @@ def default_frequency_range(syslist, Hz=None, number_of_samples=None, omega = sp.logspace(lsp_min, lsp_max, endpoint=True) return omega + # -# KLD 5/23/11: Two functions to create nice looking labels +# Utility functions to create nice looking labels (KLD 5/23/11) # def get_pow1000(num): """Determine exponent for which significand of a number is within the range [1, 1000). """ - # Based on algorithm from http://www.mail-archive.com/matplotlib-users@lists.sourceforge.net/msg14433.html, accessed 2010/11/7 + # Based on algorithm from http://www.mail-archive.com/ + # matplotlib-users@lists.sourceforge.net/msg14433.html, accessed 2010/11/7 # by Jason Heeris 2009/11/18 from decimal import Decimal from math import floor diff --git a/control/grid.py b/control/grid.py index ed46ff0f7..8aa583bc0 100644 --- a/control/grid.py +++ b/control/grid.py @@ -2,19 +2,22 @@ from numpy import cos, sin, sqrt, linspace, pi, exp import matplotlib.pyplot as plt from mpl_toolkits.axisartist import SubplotHost -from mpl_toolkits.axisartist.grid_helper_curvelinear import GridHelperCurveLinear +from mpl_toolkits.axisartist.grid_helper_curvelinear \ + import GridHelperCurveLinear import mpl_toolkits.axisartist.angle_helper as angle_helper from matplotlib.projections import PolarAxes from matplotlib.transforms import Affine2D + class FormatterDMS(object): '''Transforms angle ticks to damping ratios''' - def __call__(self,direction,factor,values): + def __call__(self, direction, factor, values): angles_deg = values/factor - damping_ratios = np.cos((180-angles_deg)*np.pi/180) - ret = ["%.2f"%val for val in damping_ratios] + damping_ratios = np.cos((180-angles_deg) * np.pi/180) + ret = ["%.2f" % val for val in damping_ratios] return ret + class ModifiedExtremeFinderCycle(angle_helper.ExtremeFinderCycle): '''Changed to allow only left hand-side polar grid''' def __call__(self, transform_xy, x1, y1, x2, y2): @@ -25,10 +28,14 @@ def __call__(self, transform_xy, x1, y1, x2, y2): with np.errstate(invalid='ignore'): if self.lon_cycle is not None: lon0 = np.nanmin(lon) - lon -= 360. * ((lon - lon0) > 360.) # Changed from 180 to 360 to be able to span only 90-270 (left hand side) + # Changed from 180 to 360 to be able to span only + # 90-270 (left hand side) + lon -= 360. * ((lon - lon0) > 360.) if self.lat_cycle is not None: lat0 = np.nanmin(lat) - lat -= 360. * ((lat - lat0) > 360.) # Changed from 180 to 360 to be able to span only 90-270 (left hand side) + # Changed from 180 to 360 to be able to span only + # 90-270 (left hand side) + lat -= 360. * ((lat - lat0) > 360.) lon_min, lon_max = np.nanmin(lon), np.nanmax(lon) lat_min, lat_max = np.nanmin(lat), np.nanmax(lat) @@ -38,6 +45,7 @@ def __call__(self, transform_xy, x1, y1, x2, y2): return lon_min, lon_max, lat_min, lat_max + def sgrid(): # From matplotlib demos: # https://matplotlib.org/gallery/axisartist/demo_curvelinear_grid.html @@ -52,21 +60,17 @@ def sgrid(): # 20, 20 : number of sampling points along x, y direction sampling_points = 20 - extreme_finder = ModifiedExtremeFinderCycle(sampling_points, sampling_points, - lon_cycle=360, - lat_cycle=None, - lon_minmax=(90,270), - lat_minmax=(0, np.inf),) + extreme_finder = ModifiedExtremeFinderCycle( + sampling_points, sampling_points, lon_cycle=360, lat_cycle=None, + lon_minmax=(90, 270), lat_minmax=(0, np.inf),) grid_locator1 = angle_helper.LocatorDMS(15) tick_formatter1 = FormatterDMS() - grid_helper = GridHelperCurveLinear(tr, - extreme_finder=extreme_finder, - grid_locator1=grid_locator1, - tick_formatter1=tick_formatter1 - ) + grid_helper = GridHelperCurveLinear( + tr, extreme_finder=extreme_finder, grid_locator1=grid_locator1, + tick_formatter1=tick_formatter1) - fig = plt.figure() + fig = plt.gcf() ax = SubplotHost(fig, 1, 1, 1, grid_helper=grid_helper) # make ticklabels of right invisible, and top axis visible. @@ -97,24 +101,25 @@ def sgrid(): fig.add_subplot(ax) - ### RECTANGULAR X Y AXES WITH SCALE - #par2 = ax.twiny() - #par2.axis["top"].toggle(all=False) - #par2.axis["right"].toggle(all=False) - #new_fixed_axis = par2.get_grid_helper().new_fixed_axis - #par2.axis["left"] = new_fixed_axis(loc="left", + # RECTANGULAR X Y AXES WITH SCALE + # par2 = ax.twiny() + # par2.axis["top"].toggle(all=False) + # par2.axis["right"].toggle(all=False) + # new_fixed_axis = par2.get_grid_helper().new_fixed_axis + # par2.axis["left"] = new_fixed_axis(loc="left", # axes=par2, # offset=(0, 0)) - #par2.axis["bottom"] = new_fixed_axis(loc="bottom", + # par2.axis["bottom"] = new_fixed_axis(loc="bottom", # axes=par2, # offset=(0, 0)) - ### FINISH RECTANGULAR + # FINISH RECTANGULAR - ax.grid(True, zorder=0,linestyle='dotted') + ax.grid(True, zorder=0, linestyle='dotted') _final_setup(ax) return ax, fig + def _final_setup(ax): ax.set_xlabel('Real') ax.set_ylabel('Imaginary') @@ -122,17 +127,19 @@ def _final_setup(ax): ax.axvline(x=0, color='black', lw=1) plt.axis('equal') + def nogrid(): - f = plt.figure() + f = plt.gcf() ax = plt.axes() _final_setup(ax) return ax, f + def zgrid(zetas=None, wns=None): '''Draws discrete damping and frequency grid''' - fig = plt.figure() + fig = plt.gcf() ax = fig.gca() # Constant damping lines @@ -141,42 +148,43 @@ def zgrid(zetas=None, wns=None): for zeta in zetas: # Calculate in polar coordinates factor = zeta/sqrt(1-zeta**2) - x = linspace(0, sqrt(1-zeta**2),200) + x = linspace(0, sqrt(1-zeta**2), 200) ang = pi*x mag = exp(-pi*factor*x) # Draw upper part in retangular coordinates xret = mag*cos(ang) yret = mag*sin(ang) - ax.plot(xret,yret, 'k:', lw=1) + ax.plot(xret, yret, 'k:', lw=1) # Draw lower part in retangular coordinates xret = mag*cos(-ang) yret = mag*sin(-ang) - ax.plot(xret,yret,'k:', lw=1) + ax.plot(xret, yret, 'k:', lw=1) # Annotation an_i = int(len(xret)/2.5) an_x = xret[an_i] an_y = yret[an_i] - ax.annotate(str(round(zeta,2)), xy=(an_x, an_y), xytext=(an_x, an_y), size=7) + ax.annotate(str(round(zeta, 2)), xy=(an_x, an_y), + xytext=(an_x, an_y), size=7) # Constant natural frequency lines if wns is None: wns = linspace(0, 1, 10) for a in wns: # Calculate in polar coordinates - x = linspace(-pi/2,pi/2,200) + x = linspace(-pi/2, pi/2, 200) ang = pi*a*sin(x) mag = exp(-pi*a*cos(x)) # Draw in retangular coordinates xret = mag*cos(ang) yret = mag*sin(ang) - ax.plot(xret,yret,'k:', lw=1) + ax.plot(xret, yret, 'k:', lw=1) # Annotation an_i = -1 an_x = xret[an_i] an_y = yret[an_i] num = '{:1.1f}'.format(a) - ax.annotate(r"$\frac{"+num+r"\pi}{T}$", xy=(an_x, an_y), xytext=(an_x, an_y), size=9) + ax.annotate(r"$\frac{"+num+r"\pi}{T}$", xy=(an_x, an_y), + xytext=(an_x, an_y), size=9) _final_setup(ax) return ax, fig - diff --git a/control/nichols.py b/control/nichols.py index 48abffa0a..c8a98ed5e 100644 --- a/control/nichols.py +++ b/control/nichols.py @@ -60,7 +60,7 @@ # Default parameters values for the nichols module _nichols_defaults = { - 'nichols.grid':True, + 'nichols.grid': True, } @@ -156,12 +156,13 @@ def nichols_grid(cl_mags=None, cl_phases=None, line_style='dotted'): # Default chart magnitudes # The key set of magnitudes are always generated, since this # guarantees a recognizable Nichols chart grid. - key_cl_mags = np.array([-40.0, -20.0, -12.0, -6.0, -3.0, -1.0, -0.5, 0.0, - 0.25, 0.5, 1.0, 3.0, 6.0, 12.0]) + key_cl_mags = np.array([-40.0, -20.0, -12.0, -6.0, -3.0, -1.0, -0.5, + 0.0, 0.25, 0.5, 1.0, 3.0, 6.0, 12.0]) + # Extend the range of magnitudes if necessary. The extended arange - # will end up empty if no extension is required. Assumes that closed-loop - # magnitudes are approximately aligned with open-loop magnitudes beyond - # the value of np.min(key_cl_mags) + # will end up empty if no extension is required. Assumes that + # closed-loop magnitudes are approximately aligned with open-loop + # magnitudes beyond the value of np.min(key_cl_mags) cl_mag_step = -20.0 # dB extended_cl_mags = np.arange(np.min(key_cl_mags), ol_mag_min + cl_mag_step, cl_mag_step) @@ -171,7 +172,8 @@ def nichols_grid(cl_mags=None, cl_phases=None, line_style='dotted'): if cl_phases is None: # Choose a reasonable set of default phases (denser if the open-loop # data is restricted to a relatively small range of phases). - key_cl_phases = np.array([-0.25, -45.0, -90.0, -180.0, -270.0, -325.0, -359.75]) + key_cl_phases = np.array([-0.25, -45.0, -90.0, -180.0, -270.0, + -325.0, -359.75]) if np.abs(ol_phase_max - ol_phase_min) < 90.0: other_cl_phases = np.arange(-10.0, -360.0, -10.0) else: @@ -181,7 +183,8 @@ def nichols_grid(cl_mags=None, cl_phases=None, line_style='dotted'): assert ((-360.0 < np.min(cl_phases)) and (np.max(cl_phases) < 0.0)) # Find the M-contours - m = m_circles(cl_mags, phase_min=np.min(cl_phases), phase_max=np.max(cl_phases)) + m = m_circles(cl_mags, phase_min=np.min(cl_phases), + phase_max=np.max(cl_phases)) m_mag = 20*sp.log10(np.abs(m)) m_phase = sp.mod(sp.degrees(sp.angle(m)), -360.0) # Unwrap @@ -208,9 +211,11 @@ def nichols_grid(cl_mags=None, cl_phases=None, line_style='dotted'): linestyle=line_style, zorder=0) # Add magnitude labels - for x, y, m in zip(m_phase[:][-1] + phase_offset, m_mag[:][-1], cl_mags): + for x, y, m in zip(m_phase[:][-1] + phase_offset, m_mag[:][-1], + cl_mags): align = 'right' if m < 0.0 else 'left' - plt.text(x, y, str(m) + ' dB', size='small', ha=align, color='gray') + plt.text(x, y, str(m) + ' dB', size='small', ha=align, + color='gray') # Fit axes to generated chart plt.axis([phase_offset_min - 360.0, phase_offset_max - 360.0, diff --git a/control/pzmap.py b/control/pzmap.py index a8fb990b5..82960270f 100644 --- a/control/pzmap.py +++ b/control/pzmap.py @@ -1,7 +1,7 @@ # pzmap.py - computations involving poles and zeros # # Author: Richard M. Murray -# Date: 7 Sep 09 +# Date: 7 Sep 2009 # # This file contains functions that compute poles, zeros and related # quantities for a linear system. @@ -38,7 +38,6 @@ # OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF # SUCH DAMAGE. # -# $Id:pzmap.py 819 2009-05-29 21:28:07Z murray $ from numpy import real, imag, linspace, exp, cos, sin, sqrt from math import pi @@ -51,15 +50,15 @@ # Define default parameter values for this module _pzmap_defaults = { - 'pzmap.grid':False, # Plot omega-damping grid - 'pzmap.Plot':True, # Generate plot using Matplotlib + 'pzmap.grid': False, # Plot omega-damping grid + 'pzmap.plot': True, # Generate plot using Matplotlib } # TODO: Implement more elegant cross-style axes. See: # http://matplotlib.sourceforge.net/examples/axes_grid/demo_axisline_style.html # http://matplotlib.sourceforge.net/examples/axes_grid/demo_curvelinear_grid.html -def pzmap(sys, Plot=True, grid=False, title='Pole Zero Map'): +def pzmap(sys, plot=True, grid=False, title='Pole Zero Map', **kwargs): """ Plot a pole/zero map for a linear system. @@ -67,7 +66,7 @@ def pzmap(sys, Plot=True, grid=False, title='Pole Zero Map'): ---------- sys: LTI (StateSpace or TransferFunction) Linear system for which poles and zeros are computed. - Plot: bool + plot: bool If ``True`` a graph is generated with Matplotlib, otherwise the poles and zeros are only computed and returned. grid: boolean (default = False) @@ -80,17 +79,24 @@ def pzmap(sys, Plot=True, grid=False, title='Pole Zero Map'): zeros: array The system's zeros. """ + # Check to see if legacy 'Plot' keyword was used + if 'Plot' in kwargs: + import warnings + warnings.warn("'Plot' keyword is deprecated in pzmap; use 'plot'", + FutureWarning) + plot = kwargs['Plot'] + # Get parameter values - Plot = config._get_param('rlocus', 'Plot', Plot, True) + plot = config._get_param('rlocus', 'plot', plot, True) grid = config._get_param('rlocus', 'grid', grid, False) - + if not isinstance(sys, LTI): raise TypeError('Argument ``sys``: must be a linear system.') poles = sys.pole() zeros = sys.zero() - if (Plot): + if (plot): import matplotlib.pyplot as plt if grid: @@ -103,11 +109,11 @@ def pzmap(sys, Plot=True, grid=False, title='Pole Zero Map'): # Plot the locations of the poles and zeros if len(poles) > 0: - ax.scatter(real(poles), imag(poles), s=50, marker='x', facecolors='k') + ax.scatter(real(poles), imag(poles), s=50, marker='x', + facecolors='k') if len(zeros) > 0: ax.scatter(real(zeros), imag(zeros), s=50, marker='o', - facecolors='none', edgecolors='k') - + facecolors='none', edgecolors='k') plt.title(title) diff --git a/control/rlocus.py b/control/rlocus.py index 0c115c26e..955c5c56d 100644 --- a/control/rlocus.py +++ b/control/rlocus.py @@ -62,16 +62,16 @@ # Default values for module parameters _rlocus_defaults = { - 'rlocus.grid':True, - 'rlocus.plotstr':'b' if int(matplotlib.__version__[0]) == 1 else 'C0', - 'rlocus.PrintGain':True, - 'rlocus.Plot':True + 'rlocus.grid': True, + 'rlocus.plotstr': 'b' if int(matplotlib.__version__[0]) == 1 else 'C0', + 'rlocus.print_gain': True, + 'rlocus.plot': True } # Main function: compute a root locus diagram def root_locus(sys, kvect=None, xlim=None, ylim=None, - plotstr=None, Plot=True, PrintGain=None, grid=None, **kwargs): + plotstr=None, plot=True, print_gain=None, grid=None, **kwargs): """Root locus plot @@ -89,9 +89,9 @@ def root_locus(sys, kvect=None, xlim=None, ylim=None, Set limits of x axis, normally with tuple (see matplotlib.axes). ylim : tuple or list, optional Set limits of y axis, normally with tuple (see matplotlib.axes). - Plot : boolean, optional + plot : boolean, optional If True (default), plot root locus diagram. - PrintGain : bool + print_gain : bool If True (default), report mouse clicks when close to the root locus branches, calculate gain, damping and print. grid : bool @@ -104,11 +104,27 @@ def root_locus(sys, kvect=None, xlim=None, ylim=None, klist : ndarray or list Gains used. Same as klist keyword argument if provided. """ + # Check to see if legacy 'Plot' keyword was used + if 'Plot' in kwargs: + import warnings + warnings.warn("'Plot' keyword is deprecated in root_locus; " + "use 'plot'", FutureWarning) + # Map 'Plot' keyword to 'plot' keyword + plot = kwargs.pop('Plot') + + # Check to see if legacy 'PrintGain' keyword was used + if 'PrintGain' in kwargs: + import warnings + warnings.warn("'PrintGain' keyword is deprecated in root_locus; " + "use 'print_gain'", FutureWarning) + # Map 'PrintGain' keyword to 'print_gain' keyword + print_gain = kwargs.pop('PrintGain') + # Get parameter values plotstr = config._get_param('rlocus', 'plotstr', plotstr, _rlocus_defaults) grid = config._get_param('rlocus', 'grid', grid, _rlocus_defaults) - PrintGain = config._get_param( - 'rlocus', 'PrintGain', PrintGain, _rlocus_defaults) + print_gain = config._get_param( + 'rlocus', 'print_gain', print_gain, _rlocus_defaults) # Convert numerator and denominator to polynomials if they aren't (nump, denp) = _systopoly1d(sys) @@ -125,7 +141,7 @@ def root_locus(sys, kvect=None, xlim=None, ylim=None, sisotool = False if 'sisotool' not in kwargs else True # Create the Plot - if Plot: + if plot: if sisotool: f = kwargs['fig'] ax = f.axes[1] @@ -143,7 +159,7 @@ def root_locus(sys, kvect=None, xlim=None, ylim=None, f = pylab.figure(new_figure_name) ax = pylab.axes() - if PrintGain and not sisotool: + if print_gain and not sisotool: f.canvas.mpl_connect( 'button_release_event', partial(_RLClickDispatcher, sys=sys, fig=f, diff --git a/control/statesp.py b/control/statesp.py index 85d48882a..1779dfbfd 100644 --- a/control/statesp.py +++ b/control/statesp.py @@ -70,7 +70,7 @@ # Define module default parameter values _statesp_defaults = { - 'statesp.use_numpy_matrix':True, + 'statesp.use_numpy_matrix': True, } diff --git a/control/tests/config_test.py b/control/tests/config_test.py index c0fc9755b..7b70fdc00 100644 --- a/control/tests/config_test.py +++ b/control/tests/config_test.py @@ -107,8 +107,8 @@ def test_matlab_bode(self): mag_data = mag_line[0].get_data() mag_x, mag_y = mag_data - # Make sure the x-axis is in Hertz and y-axis is in dB - np.testing.assert_almost_equal(mag_x[0], 0.001 / (2*pi), decimal=6) + # Make sure the x-axis is in rad/sec and y-axis is in dB + np.testing.assert_almost_equal(mag_x[0], 0.001, decimal=6) np.testing.assert_almost_equal(mag_y[0], 20*log10(10), decimal=3) # Get the phase line @@ -117,8 +117,8 @@ def test_matlab_bode(self): phase_data = phase_line[0].get_data() phase_x, phase_y = phase_data - # Make sure the x-axis is in Hertz and y-axis is in degrees - np.testing.assert_almost_equal(phase_x[-1], 1000 / (2*pi), decimal=1) + # Make sure the x-axis is in rad/sec and y-axis is in degrees + np.testing.assert_almost_equal(phase_x[-1], 1000, decimal=1) np.testing.assert_almost_equal(phase_y[-1], -180, decimal=0) # Override the defaults and make sure that works as well diff --git a/control/tests/convert_test.py b/control/tests/convert_test.py index 0340fa718..17766b186 100644 --- a/control/tests/convert_test.py +++ b/control/tests/convert_test.py @@ -108,7 +108,7 @@ def testConvert(self): ssorig_mag, ssorig_phase, ssorig_omega = \ bode(_mimo2siso(ssOriginal, \ inputNum, outputNum), \ - deg=False, Plot=False) + deg=False, plot=False) ssorig_real = ssorig_mag * np.cos(ssorig_phase) ssorig_imag = ssorig_mag * np.sin(ssorig_phase) @@ -121,7 +121,7 @@ def testConvert(self): tforig_mag, tforig_phase, tforig_omega = \ bode(tforig, ssorig_omega, \ - deg=False, Plot=False) + deg=False, plot=False) tforig_real = tforig_mag * np.cos(tforig_phase) tforig_imag = tforig_mag * np.sin(tforig_phase) @@ -137,7 +137,7 @@ def testConvert(self): bode(_mimo2siso(ssTransformed, \ inputNum, outputNum), \ ssorig_omega, \ - deg=False, Plot=False) + deg=False, plot=False) ssxfrm_real = ssxfrm_mag * np.cos(ssxfrm_phase) ssxfrm_imag = ssxfrm_mag * np.sin(ssxfrm_phase) np.testing.assert_array_almost_equal( \ @@ -152,7 +152,7 @@ def testConvert(self): tfxfrm = tf(num, den) tfxfrm_mag, tfxfrm_phase, tfxfrm_omega = \ bode(tfxfrm, ssorig_omega, \ - deg=False, Plot=False) + deg=False, plot=False) tfxfrm_real = tfxfrm_mag * np.cos(tfxfrm_phase) tfxfrm_imag = tfxfrm_mag * np.sin(tfxfrm_phase) diff --git a/control/tests/matlab_test.py b/control/tests/matlab_test.py index 0e7060bea..fdbad744e 100644 --- a/control/tests/matlab_test.py +++ b/control/tests/matlab_test.py @@ -132,7 +132,7 @@ def testPZmap(self): # pzmap(self.siso_ss2); not implemented pzmap(self.siso_tf1); pzmap(self.siso_tf2); - pzmap(self.siso_tf2, Plot=False); + pzmap(self.siso_tf2, plot=False); def testStep(self): t = np.linspace(0, 1, 10) @@ -326,7 +326,7 @@ def testBode(self): bode(self.siso_ss1) bode(self.siso_tf1) bode(self.siso_tf2) - (mag, phase, freq) = bode(self.siso_tf2, Plot=False) + (mag, phase, freq) = bode(self.siso_tf2, plot=False) bode(self.siso_tf1, self.siso_tf2) w = logspace(-3, 3); bode(self.siso_ss1, w) @@ -339,7 +339,7 @@ def testRlocus(self): rlocus(self.siso_tf1) rlocus(self.siso_tf2) klist = [1, 10, 100] - rlist, klist_out = rlocus(self.siso_tf2, klist, Plot=False) + rlist, klist_out = rlocus(self.siso_tf2, klist, plot=False) np.testing.assert_equal(len(rlist), len(klist)) np.testing.assert_array_equal(klist, klist_out) @@ -349,7 +349,7 @@ def testNyquist(self): nyquist(self.siso_tf2) w = logspace(-3, 3); nyquist(self.siso_tf2, w) - (real, imag, freq) = nyquist(self.siso_tf2, w, Plot=False) + (real, imag, freq) = nyquist(self.siso_tf2, w, plot=False) def testNichols(self): nichols(self.siso_ss1) diff --git a/control/tests/rlocus_test.py b/control/tests/rlocus_test.py index 464f04066..4b2112ea3 100644 --- a/control/tests/rlocus_test.py +++ b/control/tests/rlocus_test.py @@ -35,14 +35,14 @@ def testRootLocus(self): """Basic root locus plot""" klist = [-1, 0, 1] for sys in self.systems: - roots, k_out = root_locus(sys, klist, Plot=False) + roots, k_out = root_locus(sys, klist, plot=False) np.testing.assert_equal(len(roots), len(klist)) np.testing.assert_array_equal(klist, k_out) self.check_cl_poles(sys, roots, klist) def test_without_gains(self): for sys in self.systems: - roots, kvect = root_locus(sys, Plot=False) + roots, kvect = root_locus(sys, plot=False) self.check_cl_poles(sys, roots, kvect) def test_root_locus_zoom(self): diff --git a/control/tests/slycot_convert_test.py b/control/tests/slycot_convert_test.py index eab178954..1c121b1f6 100644 --- a/control/tests/slycot_convert_test.py +++ b/control/tests/slycot_convert_test.py @@ -154,19 +154,19 @@ def testFreqResp(self): for inputNum in range(inputs): for outputNum in range(outputs): [ssOriginalMag, ssOriginalPhase, freq] =\ - matlab.bode(ssOriginal, Plot=False) + matlab.bode(ssOriginal, plot=False) [tfOriginalMag, tfOriginalPhase, freq] =\ matlab.bode(matlab.tf( numOriginal[outputNum][inputNum], - denOriginal[outputNum]), Plot=False) + denOriginal[outputNum]), plot=False) [ssTransformedMag, ssTransformedPhase, freq] =\ matlab.bode(ssTransformed, - freq, Plot=False) + freq, plot=False) [tfTransformedMag, tfTransformedPhase, freq] =\ matlab.bode(matlab.tf( numTransformed[outputNum][inputNum], denTransformed[outputNum]), - freq, Plot=False) + freq, plot=False) # print('numOrig=', # numOriginal[outputNum][inputNum]) # print('denOrig=', diff --git a/examples/pvtol-nested.py b/examples/pvtol-nested.py index 56685599b..7efce9ccd 100644 --- a/examples/pvtol-nested.py +++ b/examples/pvtol-nested.py @@ -26,10 +26,6 @@ Pi = tf([r], [J, 0, 0]) # inner loop (roll) Po = tf([1], [m, c, 0]) # outer loop (position) -# Use state space versions -Pi = tf2ss(Pi) -Po = tf2ss(Po) - # # Inner loop control design # @@ -170,7 +166,7 @@ plt.figure(10) plt.clf() -P, Z = pzmap(T, Plot=True) +P, Z = pzmap(T, plot=True, grid=True) print("Closed loop poles and zeros: ", P, Z) # Gang of Four From 6b24bb42a8da5b15cb79699e74fb33b30ba7935a Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Tue, 24 Mar 2020 22:46:53 -0700 Subject: [PATCH 07/67] Switch to pytest and add optional Python 3.8 test (#380) * switch Travis to use pytest instead of deprecated setup.py test * fix import error in discrete unit test (for pytest) * add optional Travis test against python3.8 * remove unused (and sometimes incorrect) creation of test suites and run_all.py Co-authored-by: bnavigator --- .travis.yml | 18 +++++-- control/__init__.py | 6 --- control/tests/bdalg_test.py | 6 +-- control/tests/canonical_test.py | 3 -- control/tests/config_test.py | 3 -- control/tests/convert_test.py | 2 - control/tests/ctrlutil_test.py | 3 -- control/tests/discrete_test.py | 7 ++- control/tests/flatsys_test.py | 4 -- control/tests/frd_test.py | 3 -- control/tests/freqresp_test.py | 3 -- control/tests/iosys_test.py | 4 -- control/tests/lti_test.py | 2 - control/tests/margin_test.py | 4 +- control/tests/mateqn_test.py | 3 -- control/tests/matlab_test.py | 2 - control/tests/minreal_test.py | 3 -- control/tests/modelsimp_array_test.py | 3 -- control/tests/modelsimp_test.py | 3 -- control/tests/nichols_test.py | 3 -- control/tests/phaseplot_test.py | 2 - control/tests/rlocus_test.py | 2 - control/tests/robust_array_test.py | 1 + control/tests/run_all.py | 71 --------------------------- control/tests/sisotool_test.py | 2 - control/tests/slycot_convert_test.py | 4 -- control/tests/statefbk_array_test.py | 6 --- control/tests/statefbk_test.py | 3 -- control/tests/statesp_array_test.py | 3 -- control/tests/statesp_test.py | 4 -- control/tests/timeresp_test.py | 3 -- control/tests/xferfcn_input_test.py | 4 -- control/tests/xferfcn_test.py | 4 -- 33 files changed, 21 insertions(+), 173 deletions(-) delete mode 100755 control/tests/run_all.py diff --git a/.travis.yml b/.travis.yml index ddde6f906..62333ead8 100644 --- a/.travis.yml +++ b/.travis.yml @@ -28,7 +28,7 @@ env: - SCIPY=scipy SLYCOT= # default, w/out slycot - SCIPY="scipy==0.19.1" SLYCOT= # legacy support, w/out slycot -# Add optional builds that test against latest version of slycot +# Add optional builds that test against latest version of slycot, python jobs: include: - name: "linux, Python 2.7, slycot=source" @@ -43,8 +43,13 @@ jobs: services: xvfb python: "3.7" env: SCIPY=scipy SLYCOT=source + - name: "linux, Python 3.8, slycot=source" + os: linux + dist: xenial + services: xvfb + python: "3.8" + env: SCIPY=scipy SLYCOT=source -matrix: # Exclude combinations that are very unlikely (and don't work) exclude: - python: "3.7" # python3.7 should use latest scipy @@ -63,6 +68,12 @@ matrix: services: xvfb python: "3.7" env: SCIPY=scipy SLYCOT=source + - name: "linux, Python 3.8, slycot=source" + os: linux + dist: xenial + services: xvfb + python: "3.8" + env: SCIPY=scipy SLYCOT=source # install required system libraries before_install: @@ -97,6 +108,7 @@ before_install: fi # Make sure to look in the right place for python libraries (for slycot) - export LIBRARY_PATH="$HOME/miniconda/envs/test-environment/lib" + - conda install pytest # coveralls not in conda repos => install via pip instead - pip install coveralls @@ -118,7 +130,7 @@ install: # command to run tests script: - 'if [ $SLYCOT != "" ]; then python -c "import slycot"; fi' - - coverage run setup.py test + - coverage run -m pytest --disable-warnings control/tests # only run examples if Slycot is install # set PYTHONPATH for examples diff --git a/control/__init__.py b/control/__init__.py index 3dec2c12f..7daa39b3e 100644 --- a/control/__init__.py +++ b/control/__init__.py @@ -79,11 +79,5 @@ except ImportError: __version__ = "dev" -# The following is to use Numpy's testing framework -# Tests go under directory tests/, benchmarks under directory benchmarks/ -from numpy.testing import Tester -test = Tester().test -bench = Tester().bench - # Initialize default parameter values reset_defaults() diff --git a/control/tests/bdalg_test.py b/control/tests/bdalg_test.py index ae687df35..fde503052 100644 --- a/control/tests/bdalg_test.py +++ b/control/tests/bdalg_test.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# bdalg_test.py - test suit for block diagram algebra +# bdalg_test.py - test suite for block diagram algebra # RMM, 30 Mar 2011 (based on TestBDAlg from v0.4a) import unittest @@ -271,9 +271,5 @@ def test_feedback_args(self): self.assertTrue(isinstance(sys, ctrl.FRD)) -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestFeedback) - - if __name__ == "__main__": unittest.main() diff --git a/control/tests/canonical_test.py b/control/tests/canonical_test.py index 8f0248dc7..3172f13b7 100644 --- a/control/tests/canonical_test.py +++ b/control/tests/canonical_test.py @@ -288,9 +288,6 @@ def test_similarity(self): np.testing.assert_array_almost_equal(mimo_new.C, mimo_ini.C) np.testing.assert_array_almost_equal(mimo_new.D, mimo_ini.D) -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestFeedback) - if __name__ == "__main__": unittest.main() diff --git a/control/tests/config_test.py b/control/tests/config_test.py index 7b70fdc00..1d2a5437b 100644 --- a/control/tests/config_test.py +++ b/control/tests/config_test.py @@ -218,9 +218,6 @@ def tearDown(self): # Reset the configuration defaults ct.config.reset_defaults() -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestTimeresp) - if __name__ == '__main__': unittest.main() diff --git a/control/tests/convert_test.py b/control/tests/convert_test.py index 17766b186..e0b0e0364 100644 --- a/control/tests/convert_test.py +++ b/control/tests/convert_test.py @@ -268,8 +268,6 @@ def test_tf2ss_robustness(self): np.testing.assert_array_almost_equal(np.sort(sys2tf.pole()), np.sort(sys2ss.pole())) -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestConvert) if __name__ == "__main__": unittest.main() diff --git a/control/tests/ctrlutil_test.py b/control/tests/ctrlutil_test.py index 6e0d221f9..03a347154 100644 --- a/control/tests/ctrlutil_test.py +++ b/control/tests/ctrlutil_test.py @@ -58,8 +58,5 @@ def test_mag2db_array(self): np.testing.assert_array_almost_equal(db_array, self.db) -def test_suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestUtils) - if __name__ == "__main__": unittest.main() diff --git a/control/tests/discrete_test.py b/control/tests/discrete_test.py index f08a5fa5e..6598e3a81 100644 --- a/control/tests/discrete_test.py +++ b/control/tests/discrete_test.py @@ -5,7 +5,9 @@ import unittest import numpy as np -from control import * +from control import StateSpace, TransferFunction, feedback, step_response, \ + isdtime, timebase, isctime, sample_system, bode, impulse_response, \ + timebaseEqual, forced_response from control import matlab class TestDiscrete(unittest.TestCase): @@ -382,9 +384,6 @@ def test_discrete_bode(self): np.testing.assert_array_almost_equal(mag_out, np.absolute(H_z)) np.testing.assert_array_almost_equal(phase_out, np.angle(H_z)) -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestDiscrete) - if __name__ == "__main__": unittest.main() diff --git a/control/tests/flatsys_test.py b/control/tests/flatsys_test.py index 040d7365a..0c1d0c92c 100644 --- a/control/tests/flatsys_test.py +++ b/control/tests/flatsys_test.py @@ -127,9 +127,5 @@ def tearDown(self): ct.reset_defaults() -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestFlatSys) - - if __name__ == '__main__': unittest.main() diff --git a/control/tests/frd_test.py b/control/tests/frd_test.py index 1a6a263f3..629d488ea 100644 --- a/control/tests/frd_test.py +++ b/control/tests/frd_test.py @@ -415,8 +415,5 @@ def test_evalfr_deprecated(self): self.assertRaises(PendingDeprecationWarning, frd_tf.evalfr, 1.) -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestFRD) - if __name__ == "__main__": unittest.main() diff --git a/control/tests/freqresp_test.py b/control/tests/freqresp_test.py index 9c1382d8a..7e803a9e6 100644 --- a/control/tests/freqresp_test.py +++ b/control/tests/freqresp_test.py @@ -235,8 +235,5 @@ def test_options(self): ctrl.config.reset_defaults() -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestTimeresp) - if __name__ == '__main__': unittest.main() diff --git a/control/tests/iosys_test.py b/control/tests/iosys_test.py index 9fdac09cf..27651de71 100644 --- a/control/tests/iosys_test.py +++ b/control/tests/iosys_test.py @@ -911,10 +911,6 @@ def test_duplicates(self): self.assertEqual(len(warnval), 0) -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestTimeresp) - - # Predator prey dynamics def predprey(t, x, u, params={}): r = params.get('r', 2) diff --git a/control/tests/lti_test.py b/control/tests/lti_test.py index 65023302a..ed832fb05 100644 --- a/control/tests/lti_test.py +++ b/control/tests/lti_test.py @@ -70,8 +70,6 @@ def test_dcgain(self): np.testing.assert_equal(sys.dcgain(), 42) np.testing.assert_equal(dcgain(sys), 42) -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestUtils) if __name__ == "__main__": unittest.main() diff --git a/control/tests/margin_test.py b/control/tests/margin_test.py index 5162d30bb..85404b449 100644 --- a/control/tests/margin_test.py +++ b/control/tests/margin_test.py @@ -1,6 +1,6 @@ #!/usr/bin/env python # -# margin_test.py - test suit for stability margin commands +# margin_test.py - test suite for stability margin commands # RMM, 15 Jul 2011 from __future__ import print_function @@ -310,8 +310,6 @@ def test_zmore_margin(self): assert_array_almost_equal( res, test['result'], test['digits']) -def test_suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestMargin) if __name__ == "__main__": unittest.main() diff --git a/control/tests/mateqn_test.py b/control/tests/mateqn_test.py index a5b609067..29f31c853 100644 --- a/control/tests/mateqn_test.py +++ b/control/tests/mateqn_test.py @@ -299,8 +299,5 @@ def test_raise(self): assert_raises(ControlArgument, cdare, A, B, Q, R, S) -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestMatrixEquations) - if __name__ == "__main__": unittest.main() diff --git a/control/tests/matlab_test.py b/control/tests/matlab_test.py index fdbad744e..f8b481248 100644 --- a/control/tests/matlab_test.py +++ b/control/tests/matlab_test.py @@ -688,8 +688,6 @@ def test_tf_string_args(self): # for i in range(len(tfdata)): # np.testing.assert_array_almost_equal(tfdata_1[i], tfdata_2[i]) -def test_suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestMatlab) if __name__ == '__main__': unittest.main() diff --git a/control/tests/minreal_test.py b/control/tests/minreal_test.py index 9c20ab5e0..595bb08b0 100644 --- a/control/tests/minreal_test.py +++ b/control/tests/minreal_test.py @@ -108,9 +108,6 @@ def testMinrealtf(self): np.testing.assert_array_almost_equal(hm.num[0][0], hr.num[0][0]) np.testing.assert_array_almost_equal(hm.den[0][0], hr.den[0][0]) -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestMinreal) - if __name__ == "__main__": unittest.main() diff --git a/control/tests/modelsimp_array_test.py b/control/tests/modelsimp_array_test.py index f56f492a8..4a6f591e6 100644 --- a/control/tests/modelsimp_array_test.py +++ b/control/tests/modelsimp_array_test.py @@ -169,9 +169,6 @@ def tearDown(self): # Reset configuration variables to their original settings control.config.reset_defaults() -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestModelsimp) - if __name__ == '__main__': unittest.main() diff --git a/control/tests/modelsimp_test.py b/control/tests/modelsimp_test.py index f79a86357..2368bd92f 100644 --- a/control/tests/modelsimp_test.py +++ b/control/tests/modelsimp_test.py @@ -130,9 +130,6 @@ def testBalredMatchDC(self): np.testing.assert_array_almost_equal(rsys.C, Crtrue,decimal=4) np.testing.assert_array_almost_equal(rsys.D, Drtrue,decimal=4) -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestModelsimp) - if __name__ == '__main__': unittest.main() diff --git a/control/tests/nichols_test.py b/control/tests/nichols_test.py index 297c63f2d..9cf15ae44 100644 --- a/control/tests/nichols_test.py +++ b/control/tests/nichols_test.py @@ -29,9 +29,6 @@ def testNgrid(self): nichols(self.sys, grid=False) ngrid() -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestStateSpace) - if __name__ == "__main__": unittest.main() diff --git a/control/tests/phaseplot_test.py b/control/tests/phaseplot_test.py index 4f93e6d97..a911c1ec1 100644 --- a/control/tests/phaseplot_test.py +++ b/control/tests/phaseplot_test.py @@ -77,8 +77,6 @@ def invpend_ode(self, x, t, m=1., l=1., b=0, g=9.8): def oscillator_ode(self, x, t, m=1., b=1, k=1, extra=None): return (x[1], -k/m*x[0] - b/m*x[1]) -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestPhasePlot) if __name__ == '__main__': unittest.main() diff --git a/control/tests/rlocus_test.py b/control/tests/rlocus_test.py index 4b2112ea3..647ddd202 100644 --- a/control/tests/rlocus_test.py +++ b/control/tests/rlocus_test.py @@ -68,8 +68,6 @@ def test_root_locus_zoom(self): assert_array_almost_equal(zoom_x,zoom_x_valid) assert_array_almost_equal(zoom_y,zoom_y_valid) -def test_suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestRootLocus) if __name__ == "__main__": unittest.main() diff --git a/control/tests/robust_array_test.py b/control/tests/robust_array_test.py index 62cf8c6c5..beb44d2de 100644 --- a/control/tests/robust_array_test.py +++ b/control/tests/robust_array_test.py @@ -388,5 +388,6 @@ def testSiso(self): def tearDown(self): control.config.reset_defaults() + if __name__ == "__main__": unittest.main() diff --git a/control/tests/run_all.py b/control/tests/run_all.py deleted file mode 100755 index b21248432..000000000 --- a/control/tests/run_all.py +++ /dev/null @@ -1,71 +0,0 @@ -#!/usr/bin/env python -# -# test_all.py - test suit for python-control -# RMM, 30 Mar 2011 - -from __future__ import print_function -import unittest # unit test module -import re # regular expressions -import os # operating system commands - -def test_all(verbosity=0): - """ Runs all tests written for python-control. - """ - try: # autodiscovery (python 2.7+) - start_dir = './' - pattern = '*_test.py' - top_level_dir = '../' - testModules = \ - unittest.defaultTestLoader.discover(start_dir, pattern=pattern, \ - top_level_dir=top_level_dir) - - for mod in test_mods: - print('Running tests in', mod) - tests = unittest.defaultTestLoader.loadTestFromModule(mod) - t = unittest.TextTestRunner() - t.run(tests) - print('Completed tests in', mod) - - except: - testModules = findTests('./tests/') - - # Now go through each module and run all of its tests. - for mod in testModules: - print('Running tests in', mod) - suiteList=[] # list of unittest.TestSuite objects - exec('import '+mod+' as currentModule') - - try: - currentSuite = currentModule.suite() - if isinstance(currentSuite, unittest.TestSuite): - suiteList.append(currentModule.suite()) - else: - print(mod + '.suite() doesn\'t return a TestSuite') - except: - print('The test module '+mod+' doesnt have ' + \ - 'a proper suite() function') - - t=unittest.TextTestRunner(verbosity=verbosity) - t.run(unittest.TestSuite(unittest.TestSuite(suiteList))) - print('Completed tests in', mod) - -def findTests(testdir = './', pattern = "[^.#]*_test.py$"): - """Since python <2.7 doesn't have test discovery, this finds tests in the - provided directory. The default is to check the current directory. Any files - that match test* or Test* are considered unittest modules and checked for - a module.suite() function (in tests()).""" - - # Get list of files in test directory - fileList = os.listdir(testdir) - - # Go through the files and look for anything that matches the pattern - testModules= [] - for fileName in fileList: - if (re.match(pattern, fileName)): - testModules.append(fileName[:-len('.py')]) - - # Return all of the modules that we find - return testModules - -if __name__=='__main__': - test_all() diff --git a/control/tests/sisotool_test.py b/control/tests/sisotool_test.py index 40ef0f966..f2cdf9106 100644 --- a/control/tests/sisotool_test.py +++ b/control/tests/sisotool_test.py @@ -62,8 +62,6 @@ def test_sisotool(self): step_response_moved = np.array([[ 0., 0.02458187, 0.16529784 , 0.46602716 , 0.91012035 , 1.43364313, 1.93996334 , 2.3190105 , 2.47041552 , 2.32724853] ]) assert_array_almost_equal(ax_step.lines[0].get_data()[1][:10],step_response_moved) -def test_suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestSisotool) if __name__ == "__main__": unittest.main() diff --git a/control/tests/slycot_convert_test.py b/control/tests/slycot_convert_test.py index 1c121b1f6..e13bcea8f 100644 --- a/control/tests/slycot_convert_test.py +++ b/control/tests/slycot_convert_test.py @@ -192,10 +192,6 @@ def testFreqResp(self): decimal=2) -# These are here for once the above is made into a unittest. -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestSlycot) - if __name__ == '__main__': unittest.main() diff --git a/control/tests/statefbk_array_test.py b/control/tests/statefbk_array_test.py index 941488978..10f450186 100644 --- a/control/tests/statefbk_array_test.py +++ b/control/tests/statefbk_array_test.py @@ -409,11 +409,5 @@ def tearDown(self): reset_defaults() -def test_suite(): - - status1 = unittest.TestLoader().loadTestsFromTestCase(TestStatefbk) - status2 = unittest.TestLoader().loadTestsFromTestCase(TestStatefbk) - return status1 and status2 - if __name__ == '__main__': unittest.main() diff --git a/control/tests/statefbk_test.py b/control/tests/statefbk_test.py index 133631232..fc0ffeffa 100644 --- a/control/tests/statefbk_test.py +++ b/control/tests/statefbk_test.py @@ -344,8 +344,5 @@ def test_dare(self): assert np.all(np.abs(L) > 1) -def test_suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestStatefbk) - if __name__ == '__main__': unittest.main() diff --git a/control/tests/statesp_array_test.py b/control/tests/statesp_array_test.py index a45e008bc..a2d034075 100644 --- a/control/tests/statesp_array_test.py +++ b/control/tests/statesp_array_test.py @@ -629,9 +629,6 @@ def test_copy_constructor(self): def tearDown(self): reset_defaults() # reset configuration defaults -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestStateSpace) - if __name__ == "__main__": unittest.main() diff --git a/control/tests/statesp_test.py b/control/tests/statesp_test.py index 191271da4..9273877af 100644 --- a/control/tests/statesp_test.py +++ b/control/tests/statesp_test.py @@ -612,9 +612,5 @@ def test_copy_constructor(self): np.testing.assert_array_equal(cpysys.A, [[-1]]) # original value -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestStateSpace) - - if __name__ == "__main__": unittest.main() diff --git a/control/tests/timeresp_test.py b/control/tests/timeresp_test.py index 4087f530f..5c58f4d67 100644 --- a/control/tests/timeresp_test.py +++ b/control/tests/timeresp_test.py @@ -562,8 +562,5 @@ def test_time_series_data_convention(self): self.assertTrue(len(t) == len(y)) # Allows direct plotting of output -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestTimeresp) - if __name__ == '__main__': unittest.main() diff --git a/control/tests/xferfcn_input_test.py b/control/tests/xferfcn_input_test.py index 0d6ca56fe..52fb85c29 100644 --- a/control/tests/xferfcn_input_test.py +++ b/control/tests/xferfcn_input_test.py @@ -255,9 +255,5 @@ def test_clean_part_list_list_arrays(self): np.testing.assert_array_equal(num_[1][1], array([4.0, 4.0], dtype=float)) -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestXferFcnInput) - - if __name__ == "__main__": unittest.main() diff --git a/control/tests/xferfcn_test.py b/control/tests/xferfcn_test.py index 338ba4b01..66aa4576e 100644 --- a/control/tests/xferfcn_test.py +++ b/control/tests/xferfcn_test.py @@ -855,9 +855,5 @@ def test_latex_repr(self): self.assertEqual(H._repr_latex_(), ref) -def suite(): - return unittest.TestLoader().loadTestsFromTestCase(TestXferFcn) - - if __name__ == "__main__": unittest.main() From b9dad5e8bbfe084b1ebea1609667b231229c54c0 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Sat, 16 May 2020 19:08:59 -0700 Subject: [PATCH 08/67] fix computation of default response time for constant systems (#383) * fix computation of default response time for constant systems * add single function to compute response times --- control/tests/timeresp_test.py | 14 +++++++++- control/timeresp.py | 50 ++++++++++++++++------------------ 2 files changed, 37 insertions(+), 27 deletions(-) diff --git a/control/tests/timeresp_test.py b/control/tests/timeresp_test.py index 5c58f4d67..b208e70d2 100644 --- a/control/tests/timeresp_test.py +++ b/control/tests/timeresp_test.py @@ -94,9 +94,21 @@ def test_step_response(self): np.testing.assert_array_equal(Tc.shape, Td.shape) np.testing.assert_array_equal(youtc.shape, youtd.shape) + # Recreate issue #374 ("Bug in step_response()") + def test_step_nostates(self): + # Continuous time, constant system + sys = TransferFunction([1], [1]) + t, y = step_response(sys) + np.testing.assert_array_equal(y, np.ones(len(t))) + + # Discrete time, constant system + sys = TransferFunction([1], [1], 1) + t, y = step_response(sys) + np.testing.assert_array_equal(y, np.ones(len(t))) + def test_step_info(self): # From matlab docs: - sys = TransferFunction([1,5,5],[1,1.65,5,6.5,2]) + sys = TransferFunction([1, 5, 5], [1, 1.65, 5, 6.5, 2]) Strue = { 'RiseTime': 3.8456, 'SettlingTime': 27.9762, diff --git a/control/timeresp.py b/control/timeresp.py index 0521fcc74..4c0fbd940 100644 --- a/control/timeresp.py +++ b/control/timeresp.py @@ -512,13 +512,7 @@ def step_response(sys, T=None, X0=0., input=None, output=None, """ sys = _get_ss_simo(sys, input, output) if T is None: - if isctime(sys): - T = _default_response_times(sys.A, 100) - else: - # For discrete time, use integers - tvec = _default_response_times(sys.A, 100) - T = range(int(np.ceil(max(tvec)))) - + T = _get_response_times(sys, N=100) U = np.ones_like(T) T, yout, xout = forced_response(sys, T, U, X0, transpose=transpose, @@ -573,12 +567,7 @@ def step_info(sys, T=None, SettlingTimeThreshold=0.02, ''' sys = _get_ss_simo(sys) if T is None: - if isctime(sys): - T = _default_response_times(sys.A, 1000) - else: - # For discrete time, use integers - tvec = _default_response_times(sys.A, 1000) - T = range(int(np.ceil(max(tvec)))) + T = _get_response_times(sys, N=1000) T, yout = step_response(sys, T) @@ -697,12 +686,8 @@ def initial_response(sys, T=None, X0=0., input=0, output=None, # Create time and input vectors; checking is done in forced_response(...) # The initial vector X0 is created in forced_response(...) if necessary if T is None: - if isctime(sys): - T = _default_response_times(sys.A, 1000) - else: - # For discrete time, use integers - tvec = _default_response_times(sys.A, 1000) - T = range(int(np.ceil(max(tvec)))) + # TODO: default step size inconsistent with step/impulse_response() + T = _get_response_times(sys, N=1000) U = np.zeros_like(T) T, yout, _xout = forced_response(sys, T, U, X0, transpose=transpose, @@ -801,13 +786,7 @@ def impulse_response(sys, T=None, X0=0., input=0, output=None, # Compute T and U, no checks necessary, they will be checked in lsim if T is None: - if isctime(sys): - T = _default_response_times(sys.A, 100) - else: - # For discrete time, use integers - tvec = _default_response_times(sys.A, 100) - T = range(int(np.ceil(max(tvec)))) - + T = _get_response_times(sys, N=100) U = np.zeros_like(T) # Compute new X0 that contains the impulse @@ -828,3 +807,22 @@ def impulse_response(sys, T=None, X0=0., input=0, output=None, return T, yout, _xout return T, yout + + +# Utility function to get response times +def _get_response_times(sys, N=100): + if isctime(sys): + if sys.A.shape == (0, 0): + # No dynamics; use the unit time interval + T = np.linspace(0, 1, N, endpoint=False) + else: + T = _default_response_times(sys.A, N) + else: + # For discrete time, use integers + if sys.A.shape == (0, 0): + # No dynamics; use N time steps + T = range(N) + else: + tvec = _default_response_times(sys.A, N) + T = range(int(np.ceil(max(tvec)))) + return T From 5cb38e04029fe157f364e67a1569fb09f11a43bb Mon Sep 17 00:00:00 2001 From: Samuel Laferriere Date: Sun, 17 May 2020 11:24:58 -0400 Subject: [PATCH 09/67] Improved the Vertical takeoff and landing aircraft notebook (#390) * Fixed typo in PVTOL notebook (forgot to divide by m). Also replaced hardcoded image with latex code. * Removed a lot of the unnecessary decoupling code. Notebook used to say "Since the python-control package only supports SISO systems, in order to compute the closed loop dynamics, we must extract the dynamics for the lateral and altitude dynamics as individual systems." This is not true anymore. So I simplified the code. Also added explanations as to what the code is doing and fixed some typos. --- examples/pvtol-lqr-nested.ipynb | 179 +++++++++++++++----------------- 1 file changed, 85 insertions(+), 94 deletions(-) diff --git a/examples/pvtol-lqr-nested.ipynb b/examples/pvtol-lqr-nested.ipynb index bd55f8abb..9fff756ff 100644 --- a/examples/pvtol-lqr-nested.ipynb +++ b/examples/pvtol-lqr-nested.ipynb @@ -26,12 +26,29 @@ "\n", "The position and orientation of the center of mass of the aircraft is denoted by $(x,y,\\theta)$, $m$ is the mass of the vehicle, $J$ the moment of inertia, $g$ the gravitational constant and $c$ the damping coefficient. The forces generated by the main downward thruster and the maneuvering thrusters are modeled as a pair of forces $F_1$ and $F_2$ acting at a distance $r$ below the aircraft (determined by the geometry of the thrusters).\n", "\n", - "It is convenient to redefine the inputs so that the origin is an equilibrium point of the system with zero input. Letting $u_1 =\n", - "F_1$ and $u_2 = F_2 - mg$, the equations can be written in state space form as:\n", - "![PVTOL state space dynamics](http://www.cds.caltech.edu/~murray/wiki/images/2/21/Pvtol-statespace.png)\n", + "Letting $z=(x,y,\\theta, \\dot x, \\dot y, \\dot\\theta$), the equations can be written in state space form as:\n", + "$$\n", + "\\frac{dz}{dt} = \\begin{bmatrix}\n", + " z_4 \\\\\n", + " z_5 \\\\\n", + " z_6 \\\\\n", + " -\\frac{c}{m} z_4 \\\\\n", + " -g- \\frac{c}{m} z_5 \\\\\n", + " 0\n", + " \\end{bmatrix}\n", + " +\n", + " \\begin{bmatrix}\n", + " 0 \\\\\n", + " 0 \\\\\n", + " 0 \\\\\n", + " \\frac{1}{m} \\cos \\theta F_1 + \\frac{1}{m} \\sin \\theta F_2 \\\\\n", + " \\frac{1}{m} \\sin \\theta F_1 + \\frac{1}{m} \\cos \\theta F_2 \\\\\n", + " \\frac{r}{J} F_1\n", + " \\end{bmatrix}\n", + "$$\n", "\n", "## LQR state feedback controller\n", - "This section demonstrates the design of an LQR state feedback controller for the vectored thrust aircraft example. This example is pulled from Chapter 6 (State Feedback) of [Astrom and Murray](https://fbsbook.org). The python code listed here are contained the the file pvtol-lqr.py.\n", + "This section demonstrates the design of an LQR state feedback controller for the vectored thrust aircraft example. This example is pulled from Chapter 6 (Linear Systems, Example 6.4) and Chapter 7 (State Feedback, Example 7.9) of [Astrom and Murray](https://fbsbook.org). The python code listed here are contained the the file pvtol-lqr.py.\n", "\n", "To execute this example, we first import the libraries for SciPy, MATLAB plotting and the python-control package:" ] @@ -59,37 +76,39 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "m = 4.000000\n", - "J = 0.047500\n", - "r = 0.250000\n", - "g = 9.800000\n", - "c = 0.050000\n" - ] - } - ], + "outputs": [], "source": [ "m = 4 # mass of aircraft\n", "J = 0.0475 # inertia around pitch axis\n", "r = 0.25 # distance to center of force\n", "g = 9.8 # gravitational constant\n", - "c = 0.05 # damping factor (estimated)\n", - "print(\"m = %f\" % m)\n", - "print(\"J = %f\" % J)\n", - "print(\"r = %f\" % r)\n", - "print(\"g = %f\" % g)\n", - "print(\"c = %f\" % c)" + "c = 0.05 # damping factor (estimated)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The linearization of the dynamics near the equilibrium point $x_e = (0, 0, 0, 0, 0, 0)$, $u_e = (0, mg)$ are given by" + "Choosing equilibrium inputs to be $u_e = (0, mg)$, the dynamics of the system $\\frac{dz}{dt}$, and their linearization $A$ about equilibrium point $z_e = (0, 0, 0, 0, 0, 0)$ are given by\n", + "$$\n", + "\\frac{dz}{dt} = \\begin{bmatrix}\n", + " z_4 \\\\\n", + " z_5 \\\\\n", + " z_6 \\\\\n", + " -g \\sin z_3 -\\frac{c}{m} z_4 \\\\\n", + " g(\\cos z_3 - 1)- \\frac{c}{m} z_5 \\\\\n", + " 0\n", + " \\end{bmatrix}\n", + "\\qquad\n", + "A = \\begin{bmatrix}\n", + " 0 & 0 & 0 &1&0&0\\\\\n", + " 0&0&0&0&1&0 \\\\\n", + " 0&0&0&0&0&1 \\\\\n", + " 0&0&-g&-c/m&0&0 \\\\\n", + " 0&0&0&0&-c/m&0 \\\\\n", + " 0&0&0&0&0&0\n", + " \\end{bmatrix}\n", + "$$" ] }, { @@ -110,6 +129,8 @@ "outputs": [], "source": [ "# Dynamics matrix (use matrix type so that * works for multiplication)\n", + "# Note that we write A and B here in full generality in case we want\n", + "# to test different xe and ue.\n", "A = matrix(\n", " [[ 0, 0, 0, 1, 0, 0],\n", " [ 0, 0, 0, 0, 1, 0],\n", @@ -135,9 +156,9 @@ "metadata": {}, "source": [ "To compute a linear quadratic regulator for the system, we write the cost function as\n", - "\n", + "$$ J = \\int_0^\\infty (\\xi^T Q_\\xi \\xi + v^T Q_v v) dt,$$\n", "\n", - "where $z = z - z_e$ and $v = u - u_e$ represent the local coordinates around the desired equilibrium point $(z_e, u_e)$. We begin with diagonal matrices for the state and input costs:" + "where $\\xi = z - z_e$ and $v = u - u_e$ represent the local coordinates around the desired equilibrium point $(z_e, u_e)$. We begin with diagonal matrices for the state and input costs:" ] }, { @@ -155,13 +176,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This gives a control law of the form $v = -K z$, which can then be used to derive the control law in terms of the original variables:\n", + "This gives a control law of the form $v = -K \\xi$, which can then be used to derive the control law in terms of the original variables:\n", + "\n", + "\n", + " $$u = v + u_e = - K(z - z_d) + u_d.$$\n", + "where $u_e = (0, mg)$ and $z_d = (x_d, y_d, 0, 0, 0, 0)$\n", "\n", + "The way we setup the dynamics above, $A$ is already hardcoding $u_d$, so we don't need to include it as an external input. So we just need to cascade the $-K(z-z_d)$ controller with the PVTOL aircraft's dynamics to control it. For didactic purposes, we will cheat in two small ways:\n", "\n", - " $$u = v + u_d = - K(z - z_d) + u_d.$$\n", - "where $u_d = (0, mg)$ and $z_d = (x_d, y_d, 0, 0, 0, 0)$\n", + "- First, we will only interface our controller with the linearized dynamics. Using the nonlinear dynamics would require the `NonlinearIOSystem` functionalities, which we leave to another notebook to introduce.\n", + "2. Second, as written, our controller requires full state feedback ($K$ multiplies full state vectors $z$), which we do not have access to because our system, as written above, only returns $x$ and $y$ (because of $C$ matrix). Hence, we would need a state observer, such as a Kalman Filter, to track the state variables. Instead, we assume that we have access to the full state.\n", "\n", - "Since the `python-control` package only supports SISO systems, in order to compute the closed loop dynamics, we must extract the dynamics for the lateral and altitude dynamics as individual systems. In addition, we simulate the closed loop dynamics using the step command with $K x_d$ as the input vector (assumes that the \"input\" is unit size, with $xd$ corresponding to the desired steady state. The following code performs these operations:" + "The following code implements the closed loop system:" ] }, { @@ -170,44 +196,28 @@ "metadata": {}, "outputs": [], "source": [ - "xd = matrix([[1], [0], [0], [0], [0], [0]]) \n", - "yd = matrix([[0], [1], [0], [0], [0], [0]]) " - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# Indices for the parts of the state that we want\n", - "lat = (0,2,3,5)\n", - "alt = (1,4)\n", + "# Our input to the system will only be (x_d, y_d), so we need to\n", + "# multiply it by this matrix to turn it into z_d.\n", + "Xd = matrix([[1,0,0,0,0,0],\n", + " [0,1,0,0,0,0]]).T\n", "\n", - "# Decoupled dynamics\n", - "Ax = (A[lat, :])[:, lat] #! not sure why I have to do it this way\n", - "Bx, Cx, Dx = B[lat, 0], C[0, lat], D[0, 0]\n", - " \n", - "Ay = (A[alt, :])[:, alt] #! not sure why I have to do it this way\n", - "By, Cy, Dy = B[alt, 1], C[1, alt], D[1, 1]\n", + "# Closed loop dynamics\n", + "H = ss(A-B*K,B*K*Xd,C,D)\n", "\n", "# Step response for the first input\n", - "H1ax = ss(Ax - Bx*K1a[0,lat], Bx*K1a[0,lat]*xd[lat,:], Cx, Dx)\n", - "(Tx, Yx) = step(H1ax, T=linspace(0,10,100))\n", - "\n", + "x,t = step(H,input=0,output=0,T=linspace(0,10,100))\n", "# Step response for the second input\n", - "H1ay = ss(Ay - By*K1a[1,alt], By*K1a[1,alt]*yd[alt,:], Cy, Dy)\n", - "(Ty, Yy) = step(H1ay, T=linspace(0,10,100))" + "y,t = step(H,input=1,output=1,T=linspace(0,10,100))" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -219,7 +229,7 @@ } ], "source": [ - "plot(Yx.T, Tx, '-', Yy.T, Ty, '--')\n", + "plot(t,x,'-',t,y,'--')\n", "plot([0, 10], [1, 1], 'k-')\n", "ylabel('Position')\n", "xlabel('Time (s)')\n", @@ -237,36 +247,36 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ "# Look at different input weightings\n", "Qu1a = diag([1, 1])\n", "K1a, X, E = lqr(A, B, Qx1, Qu1a)\n", - "H1ax = ss(Ax - Bx*K1a[0,lat], Bx*K1a[0,lat]*xd[lat,:], Cx, Dx)\n", + "H1ax = H = ss(A-B*K1a,B*K1a*Xd,C,D)\n", "\n", "Qu1b = (40**2)*diag([1, 1])\n", "K1b, X, E = lqr(A, B, Qx1, Qu1b)\n", - "H1bx = ss(Ax - Bx*K1b[0,lat], Bx*K1b[0,lat]*xd[lat,:],Cx, Dx)\n", + "H1bx = H = ss(A-B*K1b,B*K1b*Xd,C,D)\n", "\n", "Qu1c = (200**2)*diag([1, 1])\n", "K1c, X, E = lqr(A, B, Qx1, Qu1c)\n", - "H1cx = ss(Ax - Bx*K1c[0,lat], Bx*K1c[0,lat]*xd[lat,:],Cx, Dx)\n", + "H1cx = ss(A-B*K1c,B*K1c*Xd,C,D)\n", "\n", - "[T1, Y1] = step(H1ax, T=linspace(0,10,100))\n", - "[T2, Y2] = step(H1bx, T=linspace(0,10,100))\n", - "[T3, Y3] = step(H1cx, T=linspace(0,10,100))" + "[Y1, T1] = step(H1ax, T=linspace(0,10,100), input=0,output=0)\n", + "[Y2, T2] = step(H1bx, T=linspace(0,10,100), input=0,output=0)\n", + "[Y3, T3] = step(H1cx, T=linspace(0,10,100), input=0,output=0)" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEWCAYAAAB8LwAVAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjMsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+AADFEAAAgAElEQVR4nOzdeZzN9f7A8dd7dstYsmeUSQslJW7aI7qWEhUiylbqd9Oq7bbitlzVLSrlSiWUKIQU2qikRJstri0m2xjbYPbz/v3xOcOYDjPDnPmeM/N+Ph7fx9m+5/t9nzN83+ezi6pijDHG5BfhdQDGGGNCkyUIY4wxAVmCMMYYE5AlCGOMMQFZgjDGGBOQJQhjjDEBWYIwJgSJSDkRmSkie0TkA6/jMWWTJQhTIBG5RES+81+sdorIAhH5m/+1PiLybRDPPU9E0kVkn4jsEJGpIlInWOcLIV2AWkA1Ve16vAcTkZYiknT8YRXqXBtEpE1JnMsElyUIc1QiUgn4GHgFOAGoCwwBMkowjIGqWhE4FagIvFCC5/bKycBqVc0u6htFJCoI8ZgyyBKEKcjpAKo6UVVzVDVNVeeq6m8i0ggYBVzo/4W/G0BEYkXkBRHZKCLbRGSUiJTzv9ZSRJJE5BF/iWCDiPQsTCCquhv4CDg39zkRiRCRh0VkrYikiMhkETnB/1qciEzwP79bRH4UkVr+1+aJyLMisshfMpqe+z7/69eIyHL/++b5P2vuaxtE5H4R+c3/3kkiEud/rbqIfOx/304R+UZEIvyvnSgiU0QkWUTWi8hdgT6niAwBngBu8H+v/f2f8zER+UNEtovIOBGp7N+/voiof7+NwJcFfZf+z/Qvf2kwVUTmikj1fMcbICKbRWSLiAzK896xIvJUnscHSyciMh44CZjpj/3Bo/0dTGizBGEKshrIEZF3RKS9iFTNfUFVVwK3AwtVtaKqVvG/NAyXWM7F/eqvi7vg5aoNVPc/3xsYLSJnFBSIiFQDrgPW5Hn6LqAzcDlwIrALGOl/rTdQGagHVPPHmpbnvTcD/fzvywZe9p/ndGAicA9QA/gEd8GLyfPebkA7IBFoAvTxPz8ISPK/rxbwCKD+JDET+NX/uVsD94hI2/yfU1WfBJ4BJvm/1zf9x+8DtAJOwZWkXs331suBRsBfjnkENwJ9gZpADHB/vtdbAacBfwceLky1kareBGwEOvpjf46C/w4mRFmCMEelqnuBSwAF3gCSRWTGkX4BiogAtwL3qupOVU3FXey659v1cVXNUNX5wCzcBfdIXhaRPcAOXGK5M89rtwGPqmqSqmYAg4Eu/mqWLNwF6VR/6WeJ//PkGq+qy1R1P/A40E1EIoEbgFmq+pmqZuGqtMoBF+WNSVU3q+pO3IU/t1STBdQBTlbVLFX9Rt2EZ38DaqjqUFXNVNV1/u8z//dyJD2BF1V1naruA/4JdM9XnTRYVferamEvvm+r6mr//pPzfIZcQ/zHWwq8DfQo5HHzK+jvYEKUJQhTIFVdqap9VDUBaIz7xT38CLvXAMoDS/zVCbuB2f7nc+3yX5Rz/eE/5pHcpaqVcb/UqwIJeV47GZiW51wrgRzcr/fxwBzgfX9VyXMiEp3nvZvyxRCNS0An+h/nfn6ff9+6efbfmuf+AdwveoDncSWcuSKyTkQezhPniblx+mN9xB9nYRwWk/9+VL73b6JojvQZAh2voL/R0RT0dzAhyhKEKRJV/R0Yi0sU4EoWee3AVR+cpapV/FtlfyNzrqoiUiHP45OAzYU491LgKWCkv6QC7iLWPs+5qqhqnKr+6f8FP0RVz8T9+r8aV62Uq16+GLL88W/GXdCBg6WiesCfhYgxVVUHqeopQEfgPhFp7Y9zfb4441W1Q0HH9DssJn+82cC2vKcv5LEKK//3k/s32o/7EZCrdr73HRZHIf4OJkRZgjBHJSINRWSQiCT4H9fDVTV8799lG5CQWz/v/7X9BvCSiNT0v6dugLr2ISISIyKX4i4Yhe3r/w6uzvwa/+NRwNMicrL/XDVEpJP/fisROdtfbbQXlwBy8hyrl4icKSLlgaHAh6qag6tuuUpEWvt/6Q7C9dr6rqDgRORqETnVn1T2+s+XAywC9orIQ+LGOESKSGPxdxcuhInAvSKSKCIVOdRGUeReTkXwuIiUF5GzcG0Vk/zP/wJ0EJETRKQ2rq0mr224dhKgUH8HE6IsQZiCpAItgB9EZD8uMSzDXTTB9ZhZDmwVkR3+5x7CVbN8LyJ7gc+BvI3QW3GNyZuBd4Hb/SWTAqlqJq4x+XH/UyOAGbgqnVR/fC38r9UGPsRdlFYC84EJeQ43Hlca2grE4Rq8UdVVQC9c194duJJAR/+5C3Ka//PuAxYCr6nqPH/i6Yir51/vP+4YXONtYbzlj/dr//vTObwtJhjm4/6OXwAvqOpc//PjcY3tG4C5HEocuZ4FHvNXpd1PwX8HE6LEFgwyJUlEWgIT/O0ZXsYxzx/HGC/jCEUiUh+XhKKDXEIxIc5KEMYYYwIKWoIQkbf8A3qWFbDf30QkR0S6BCsWY4wxRRe0KiYRuQxXDztOVRsfYZ9I4DNcfepbqvphUIIxxhhTZEErQajq18DOAna7E5gCbA9WHMYYY46NZ5N6iUhd4FrgCtwo06PtOwAYAFChQoVmDRs2DH6AxhhTiixZsmSHqtYoeM9DvJz1cTjwkKrmHBrzFJiqjgZGAzRv3lwXL15cAuEZY0zpISJ/FLzX4bxMEM1xQ+/BTW/QQUSyVfUjD2Myxhjj51mCUNXE3PsiMhb42JKDMcaEjqAlCBGZCLQEqvvnin8SNxkaqjoqWOc1xhhTPIKWIFS10FMDq2qfYMVhjDHm2NhIamOMMQFZgjDGGBOQJQhjjDEBWYIwxhgTkCUIY4wxAVmCMMYYE5AlCGOMMQFZgjDGGBOQJQhjjDEBWYIwxhgTkCUIY4wxAVmCMMYYE5AlCGOMMQFZgjDGGBOQJQhjjDEBWYIwxhgTkCUIY4wxAVmCMMYYE5AlCGOMMQFZgjDGGBNQ0BKEiLwlIttFZNkRXu8pIr/5t+9E5JxgxWKMMaboglmCGAu0O8rr64HLVbUJ8C9gdBBjMcYYU0RRwTqwqn4tIvWP8vp3eR5+DyQEKxZjjDFFFyptEP2BT4/0oogMEJHFIrI4OTm5BMMyxpiyy/MEISKtcAnioSPto6qjVbW5qjavUaNGyQVnjDFlWNCqmApDRJoAY4D2qpriZSzGGGMO51kJQkROAqYCN6nqaq/iMMYYE1jQShAiMhFoCVQXkSTgSSAaQFVHAU8A1YDXRAQgW1WbByseY4wxRRPMXkw9Cnj9FuCWYJ3fGGPM8fG8kdoYY0xosgRhjDEmIEsQxhhjArIEYYwxJiBLEMYYYwKyBGGMMSYgSxDGGGMCsgRhjDEmIEsQxhhjArIEYYwxJiBLEMYYYwKyBGGMMSYgSxDGGGMC8nTBIGOMKQpVZU/GHnYc2EHKgRRS0lLYm7GXvRl7Sc1I5UDWAdKz08nIySAjOwOf+sjRHHzqQxAiJIIIiSAqIoqYyBhio2KJi4qjfHR5ykeXp0J0BSrFVjq4VYmrQtVyVakcW5nIiEivP36JswRhjAkZ2b5s1u1ax/9S/seG3RvctmcDSXuT2JK6hS37tpCZk3nUY0RIBOWiyhETGUNkROTBpADgUx8+9ZGVk0VmTiYZOS6JFEQQqsRVoXr56lQvX50aFWpQs3xNalesTa2KtahdsTYnxp/IifEnUqdiHWKjYovl+/CaJQhjTIlTVTbs3sAvW3/ht22/8dv231iRvII1O9eQ7cs+uF9sZCwnVzmZepXqcdnJl1GnYh1qV6xNtfLVqFauGieUO4EqcVWIj40nPiae8tHliY6MLlIsWTlZHMg6wIGsA+zP2k9qRip7MvawN2Mvu9N3syttFzvTdpKSlsKOAzvYcWAHG3ZvYNGfi9i+f3vABFO9fHXqxtcloVICCZUSOKnySdSrVI+TKp/ESZVPIqFSQpHj9IIlCGNM0O3L3MfCTQtZsGkBi/5cxKI/F5GS5pahF4RTTziVxjUb0/mMzjSs3pDTq51OYtVEalaoefDXf7BER0ZTObIyleMqF/m9Ob4cdhzYwdZ9W9mybwubUzfz594/2Zy6maTUJJL2JvF90vcHP2uuCIngxPgTObnyySRWTaR+5frUr+K2xKqJ1KtULyQSiKiq1zEUSfPmzXXx4sVeh2GMOYqM7Ay+3fgtc9fOZd4f81iyeQk5moMgnFXzLM4/8Xz+VvdvnFfnPM6qcRYVYip4HXJQHcg6QNLeJDbu2cjGPRv5Y/cf/LHHbet3rWfT3k2HlUQiJZKESgmcUvUUEqskckrVU9z9qu5+jfI18C/VXGgisqSoyzpbgjDGFIukvUnMXDWTmatnMm/DPNKy04iOiOb8uudz+cmXc9nJl3FhvQupFFvJ61BDTlZOFkl7k9iwewPrd69n/a71bNizgXW71rFu1zq27tt62P4VoiscTBanVDk8edSvUp/y0eX/co5jSRBWxWSMFzIyYMsW2LEDUlLctncv7N/vtvR0yMmB7Gx3GxEBkZEQFQUxMRAXB+XKuS0+/tBWuTJUreq2SpWgiL8yi2rtzrVMWj6JqSunsmTLEgBOPeFUbj3vVv7e4O9cXv9yKsZUDGoMpUF0ZDSJVRNJrJpIK1r95fUDWQdc8ti1nrW71rJ+13rW7V7H2p1r+Xzd5xzIOnDY/rUr1iaxijtebgnkWAStBCEibwFXA9tVtXGA1wUYAXQADgB9VPWngo5rJQgTNjIzYdkyWLkSVq2C33+HdesgKQm2bTv6eyMjITra3UZGgs93KGFkZRXu/JGRUK0aVK/utpo1D221armtdu1DW7lyhTrs1n1beW/pe0xcNpHFm93/xRZ1W9C5YWc6ndGJhtUbFrn6wxw7VSX5QPLB0sb6Xevd7e71rN+9nk17NpGjOTCY0KliEpHLgH3AuCMkiA7AnbgE0QIYoaotCjquJQgTsjZuhHnzYMECWLIEli51SQJcCSAxEU49FerVc1vdulCjhrt4V6vmfvFXqADly7uSwpGouhJIejocOACpqW7buxf27IFdu9y2c6crmezYAcnJbtu2zT0fSKVKLlHUqeO2PPezalZnJqsYu3U2n/zxOTmaQ7M6zejeuDvdzurGSZVPKvav0xSP3OqrU044JXQSBICI1Ac+PkKC+C8wT1Un+h+vAlqq6pajHTM+Pl6bNWsWhGiNKSKfz12Id+yA3bvdBRvcL/e81T4VKrgqoYgQmbhA1ZVCMjMDbxmZkJkBmZlkiI/N8bClImRFQkwO1NoPtdKjKS+xaHQ0Gh3jtqjog7e+qGg0KgaNjEb9nzv3UpP3klPU+0d67miXsSO9VphLX2Evj8V9GS3S8VQR9SHqC3g/93ZZ0q9h1QZRF9iU53GS/7m/JAgRGQAMAIiNLR0DUEyY8vlcQti+3f0SV3UJoUoVSEhwtxUC98hRPVRTlPc2//38W+778t4/2m2g7fDXBNUYVGMOxpW7HRS7B6olQfkdAESlVaJSamUqpsUQSRapZJJOJjFkEsN+YshCCHxV8yFkEU020WQRRTZRZBPtv43030aRQyQ5/udyiMRHJDlE+O9HAKFYbaVE4PNvihy8XxKbO18wvxUvE0SgzxXwX5iqjgZGg6timjdvXhDDMuZwWZlK6qyviXznLSp+NpXIA/vYX60eay/vyfIGHVl+wmXs2h/D3r2Hanr27Tt827//UG3TsYiMhNhY1z4dG+uaJ2Ji3G3u49znoqLc/dzbvPejog61deduuc0cEpnD/yKn8UPkCyTxC+WoSouoh7gw5jZqRice3C8i4lCbee59QYnL3Eu51O3E7Uum3P4dlEtNJnZvMrH7UojZv5PY1BSi9+0kev9uovftInrfLqLS9xf6O/BFRuGLLYfGxuGLjnWllZhYV3KJioaoaDQqCiQCjYyECH+AIoeX3gT3q9rnA/UhPh/iywFfDpLjv83OQrKzITvLf9+/ZWUimZmQlenuF0PRQWNj0dg491ni3OfLv5H3tZhYNM7/XO4WG3vwMbGHvpuD96OiqXnDFUWOzcsEkQTUy/M4AdjsUSymDPH5XNX81q2uI9HWra5qfvt2tyUnu0LC/u37abN1ArdkvMrZLGMPlXibGxjPTXyTcik6LwLmuQtv5cquNqlSJXdbvTrUr+8KExUrutvc5oXc29xOSHm3uLjDt1j3f5zIIE4DlO3LZuLSiTzz7TP8vuN3GlRtwKsXvEqfc/sUYXyCAJX922lFOHm2y6p79hzKrLltKrk9uvbvh7Q0ItLTiUhLc1V5GRmHttyG+6wsd9/ng5wsyEl3xaIcf/Erf8N5boaLEn/WjPlr9sybZXOzcUzMoS3v47x/sHLl3G3uc7l/3Lz3/Y8lIqJkykY3FP0tXiaIGcBAEXkf10i9p6D2B2MKIzUV1q+HP/44tG3a5DoPJSXB5s2BOwLFxbmOPadU3cWd+17m2i0jqJi5i621z+Wr1mNIbtODhNrlGVbF1SRVqeISQ1xc0HuTBkW2L5vxv47nqW+eYt2udTSp1YRJXSZxfaPrS25iuqioQ91yTcgJWoIQkYlAS6C6iCQBTwLRAKo6CvgE14NpDa6ba99gxWJKnwMHXM/RVatg9Wr43//ctm6dKwHkFRvrOg0lJMCll7rOQyeeeHhnnVq1oGLmTuSF52HkSJdlOnWCBx6g9kUXUTscM8AR+NTHlBVTePyrx1mVsopmdZoxvft0Op7e0bqnmsMELUGoao8CXlfgjmCd35QOWVlu+MDSpfDbb+52xQpXKshb/VuvHpx2GnTuDKec4nqUJibCySe7nqRH7UCUkQGvvgpPPeWqOrp1g0cegSZNgv75Stq8DfO4f+79LNmyhLNqnMXUblPp3LCzJQYTkI2kNiEjOxuWL4dFi2DxYvj5Z5cUMjLc69HR0LAhXHAB9O0LjRq5xw0auDr9IlOFqVPhgQdcnVS7dvDcc3D22cX6uULB6pTVPPjZg0xfNZ16leoxrvM4bjz7xjK5xoEpPEsQxjO7d8PChfDtt25bvNhVHYGrkm7aFO680902aQKnn+7aAovFhg1wxx3wySfu4HPnwpVXFtPBQ0dqRipD5w9l+A/DiYuK45krnuGeC+6hXHThRk2bss0ShCkx+/bBN9/Al1+67eef3Y/4qCiXBG65Bc4/H1q0cKWCoNR6ZGfDSy/Bk0+6eqeXXoKBA48+cjkMqSqTlk9i0NxBbE7dTP+m/Xn6iqepVbGW16GZMFK6/leYkKLqpiL69FOYPduVErKyXCngoovcNfrSS11COMLYsuK1di3cdJMrtnTqBK+84hovSpk1O9dw+8e388X6LzivznlM6TaFCxIu8DosE4YsQZhilZ3tpiL66CO3bdjgnj/7bLj3Xvj7311yKOS8cMVDFcaMcQFER8N770GPo/ahCEtZOVm8uPBFBs8fTExkDCM7jOS2ZrdZO4M5ZpYgzHHz+VzpYNIk+OAD1800NhbatHGdgdq3d11MPbF3L/TrB1OmQOvW8PbbpbLU8OvWX+kzvQ+/bP2FaxteyyvtX6Fupbpeh2XCnCUIc8z+9z8YOxbGjXMD0MqVg44doWtX1yGootfLACxdCtdf7wZHPP883Hdf6EyYV0yycrL497f/ZujXQ6lWrhpTu03l2kbXeh2WKSUsQZgiyciAyZNh9GhXaoiIgLZtYdgwuOaaEEgKucaPh9tuc8Odv/rKNXaUMiuTV3LTtJtYsmUJPRr34JX2r1CtfDWvwzKliCUIUyibNsHrr7uq/ORkNyjt2Wddm2/dUKrJ8PlcvdawYdCyJUyc6IZKlyKqyuuLX2fQ3EFUjKnIh10/5Pozr/c6LFMKWYIwR7VsmRs7NnGiu/Z27OiGD7RuHYK1Nfv3u4w1bZorPbzyimuULkW2799O/xn9+Xj1x7Rt0JaxncdSu2LpSoAmdFiCMAEtWQJDhsDMmW6U8h13wD33uBlKQ9KWLXD11fDLLzB8ONx1V3jOoHcUX63/ihun3siutF2MaDeCgecPJEJCLUub0sQShDnMihXwxBOu088JJ7gkcccdbkXMkLV2res/u20bzJgBV13ldUTFKseXw1NfP8XQr4dyerXTmdtrLmfXKn3TgZjQYwnCAG4dhEcecb1AK1Rwg9juu8+tbxDSfv3VtZJnZ7vh2eef73VExWrbvm3cOPVGvlz/JTc1uYnXrnqNijGh0hPAlHaWIMq4rCw3kengwW4epLvvdomienWvIyuEb7911Urx8a6nUqNGXkdUrL5P+p4uk7uQkpbCm9e8Sd9z+9qsq6ZEWYIowxYuhP79YeVKN25h+HA44wyvoyqk+fOhQwc36G3uXDjpJK8jKja5vZTumX0P9SrXY2H/hZxb+1yvwzJlkLVwlUEHDsCgQXDxxa7jz4wZblLTsEkO8+a55HDyyS5RlKLkkJGdQf8Z/bnjkzu4ssGVLL51sSUH4xkrQZQxP/wAvXrBmjXwf//nhgvEx3sdVRHMm+caoevXd20OtUrP7KRb923luknXsTBpIY9f9jiDWw62XkrGU5YgyghVePFFePhhN7Dtyy+hVSuvoyqi774rtclh8ebFdH6/M7vSd/FB1w/ocmYXr0MyxhJEWZCSAn36wMcfw7XXwltvuRkowsqvv7pqpYSEUpccPlzxITdNu4maFWqyoN8Cq1IyIcPKr6Xc8uXQvLlrx335ZTe+IeySw+rVbpxDpUrw2WelJjmoKsO+HUbXD7rStHZTfrz1R0sOJqQENUGISDsRWSUia0Tk4QCvnyQiX4nIzyLym4h0CGY8Zc2cOW7thfR0t5LbnXeG4eDiTZvcvOGqLjmUkgbprJwsbp15Kw9/8TDdG3fny95fUrNCTa/DMuYwQUsQIhIJjATaA2cCPUTkzHy7PQZMVtWmQHfgtWDFU9a89pqrrk9MhEWLwnT82O7dbjGJPXtctgubblZHtzdjL1e9dxVv/vwmj1/2OO9e9y5xUXFeh2XMXwSzDeJ8YI2qrgMQkfeBTsCKPPsokDtWtzKwOYjxlAmqbnqMIUPcGLKJE0NoCu6iyMx0azmsXu3WLG3a1OuIisXm1M1c9d5VLN22lLeueYu+Tft6HZIxRxTMBFEX2JTncRLQIt8+g4G5InInUAFoE+hAIjIAGABwUimpYggGVXjoIbc2Tt++8MYbEBmOq02qwi23uMbocePc1LGlwMrklbR7tx0703Yy68ZZtD21rdchGXNUwWyDCFTbrfke9wDGqmoC0AEYL/LXjt+qOlpVm6tq8xo1agQh1PDn87k2huefd5PrjRkTpskB3ERQ48fDv/7lpu8uBb5P+p6L37qYjOwM5veZb8nBhIVgJogkIO/ivwn8tQqpPzAZQFUXAnFAOMwCFFJU3ezWI0fC/fe7ZRBCbq2GwnrvPZcY+veHRx/1OppiMXvNbFqPa80J5U5gYf+FnFfnPK9DMqZQgnkZ+RE4TUQSRSQG1wg9I98+G4HWACLSCJcgkoMYU6k0dKhLDg884Bb3CbueSrl+/NElhssuc63sYftBDnlv6Xt0nNiR06udzoJ+C0ismuh1SMYUWtAShKpmAwOBOcBKXG+l5SIyVESu8e82CLhVRH4FJgJ9VDV/NZQ5itdeczOx9u3rps0I22vqn39Cp05uedAPP4SYGK8jOm6v//g6Paf25OJ6FzOv9zxqVSwd4zdM2RHUkdSq+gnwSb7nnshzfwVwcTBjKM0mT4aBA90yoKNHh3FySEuDzp0hNdV1Zy0F7UzPLXiOhz5/iKtPv5rJXSZTLrqc1yEZU2SFThAichFQP+97VHVcEGIyhbBoEdx8sxsI9/77EBWuk6aoulb1xYvho4/g7PBeKU1Vefyrx3n6m6fp3rg74zqPIzqydK2LbcqOQl1WRGQ80AD4BcjxP62AJQgPbN0K110Hdeq4a2r58l5HdBxGj3bL2D3+uKtiCmOqyqC5g3jp+5e4pektjLp6FJER4dqVzJjClyCaA2da+4D3MjOhSxfYudMt+BMWK78dyQ8/uL657dq5rq1hzKc+Bn4ykNcXv87dLe7mpbYv2epvJuwVtpF6GVA7mIGYwrn7bliwwM3Ies45XkdzHLZvd5mubl14990wHrQBOb4cBswcwOuLX+fBix605GBKjcKWIKoDK0RkEZCR+6SqXnPkt5jiNn48jBoFDz4I3bt7Hc1xyMmBnj1hxw63xsMJJ3gd0THL8eXQb0Y/xv06jscve5whLYdYcjClRmETxOBgBmEKtn69a8u95BJ45hmvozlOzz4Ln3/u5gIJ4zmWcnw59Jnehwm/TWBoy6E8fvnjXodkTLEqVIJQ1fkiUgv4m/+pRaq6PXhhmbyys90yoSIwYUJY18a4NaSffBJuvNENigtTeZPDv1r9i8cue8zrkIwpdoVqgxCRbsAioCvQDfhBRGxNxBLyzDOuJmbUKDj5ZK+jOQ7bt0OPHnDqqe7DhGlVTN7k8FSrpyw5mFKrsFVMjwJ/yy01iEgN4HPgw2AFZpzvv3dTafTq5a6tYcvncxPv7dzppu+Oj/c6omPiUx/9ZvQ7mBwevax0zBdlTCCFTRAR+aqUUrDlSoMuI8OtJZ2QAK++6nU0x+mll9y6p6+/Hrbdr3zqY8DMAYz7dRxDWw615GBKvcImiNkiMgc3XxLADeSbQsMUv2efhVWr3OwTlSt7Hc1x+Okn+Oc/4dpr4bbbvI7mmKgqd8y6gzd/fpPHLn3MGqRNmSCFHfsmItfj5k0S4GtVnRbMwI6kefPmunjxYi9OXaJWrnQ/tLt1cw3TYWv/fjjvPNi3D377DapV8zqiIlNV7p1zLyN+GMGDFz3Iv9v827qymrAjIktUtXlR3lPoGXxUdQowpchRmSLz+dwP7fh4ePFFr6M5TvfeC//7n+vWGobJAeDRLx9lxA8juLvF3ZYcTJly1AQhIt+q6iUiksrhq8EJoKpa6QhvNcfhzTfhm2/cbc2aXkdzHKZNc2MdHn4YrrjC62iOydNfP82z3z7LgPMG2AhpU+YUuoopVJT2KqYdO+C001z10ldfhW1PUDejYOPGrl/uwoVhub7DSwtf4r6599GrST8RHfYAACAASURBVC/e6fwOEX9dDdeYsHEsVUyFHQcxvjDPmeM3eLBbFiGsF1RThVtuce0P48eHZXIY89MY7pt7H9c3up63O71tycGUSYVtgzgr7wMRiQKaFX84ZdvKlW782G23wZlneh3NcXjjDZg1C4YPD8sPMmnZJAbMHEC7U9vx3vXvERURrottGHN8jvqzSET+6W9/aCIie/1bKrANmF4iEZYhDzwAFSu6UkTYWrsW7rsPWrd2U3mHmVmrZ9FrWi8uOekSpnSbQkxk+JV+jCkuR00QqvqsqsYDz6tqJf8Wr6rVVPWfJRRjmfDZZ+5H92OPhfGKmzk50Lu3W97u7bchIryqZeZvmE+XD7pwTq1zmNljJuWjw3klJmOOX0G9mBqq6u/AByJyXv7XVfWnoEVWhuTkwKBBkJgYlj+6Dxk+3C1WMW4c1KvndTRF8tOWn+g4sSOJVRKZ3Ws2lePCeWSiMcWjoMrV+4ABwH8CvKbAUfsuikg7YAQQCYxR1X8H2KcbbjpxBX5V1RsLDrt0GTsWli6FDz6A2FivozlGv/8Ojz7qlg3t1cvraIpkdcpq2k1oR9VyVZl701yqlw/nZfqMKT5B6+YqIpHAauBKIAn4Eeihqivy7HMaMBm4QlV3iUjNgqYRL23dXDMzXbfW2rXdxHxh2XMpOxsuvti1PyxfDrVqeR1RoW3as4lL3r6EtKw0vu33LadXO93rkIwJimB2c+0qIvH++4+JyFQRKWill/OBNaq6TlUzgfeB/KvS3wqMVNVdAGVxjYm33oKNG+Ff/wrT5ADwwguwaBGMHBlWySHlQAptJ7Rld/pu5vSaY8nBmHwK24r4uKqmisglQFvgHWBUAe+pC2zK8zjJ/1xepwOni8gCEfneXyX1FyIyQEQWi8ji5OTkQoYc+tLT4emn3Y/vK6/0OppjtHy5WwCoa1e44Qavoym0fZn76PBeB9bvXs/MHjNpWid8V7YzJlgKmyBy/LdXAa+r6nSgoP5/gX4P56/PigJOA1oCPYAxIlLlL29SHa2qzVW1eY2w7eLzV2PGQFKSW+8hLEsP2dnQrx9UquRKD2EiMyeT6ydfz5LNS5jUZRKXnXyZ1yEZE5IKmyD+FJH/4laT+0REYgvx3iQgb1eWBGBzgH2mq2qWqq4HVuESRqmXluZWirv8cmjVyutojtHw4a5q6dVXw6Zvrk999P6oN3PXzuWNjm9wzRnXeB2SMSGrsAmiGzAHaKequ4ETgAcKeM+PwGkikigiMUB3YEa+fT4CWgGISHVcldO6QsYU1kaNgi1bYMiQMC09rF4Njz8OnTu7OcnDgKpy96d38/6y9xnWZhh9m/b1OiRjQlqhEoSqHgDWAm1FZCBQU1XnFvCebGAgLrGsBCar6nIRGSoiuT/b5gApIrIC+Ap4QFVTjvGzhI30dHjuOTfB6eWXex3NMfD5XNVSXFxYTRr1zDfP8OqPrzLowkE8ePGDXodjTMgr1CQzInI3rsfRVP9TE0RktKq+crT3qeon5Ft5TlWfyHNfcWMt7itK0OFu3Dg32em773odyTEaOdINiBs7FurU8TqaQhnz0xge++oxejXpxXNXPud1OMaEhUKNgxCR34ALVXW//3EFYKGqNglyfH8R7uMgcnKgYUOoUsVV34fJj+9D/vgDzjoLLrkEPv00LD7A9N+nc93k6/h7g78zo/sMoiOjvQ7JmBIXzBXlhEM9mfDfD/0rQwiaNg3WrHGjpsPg2no41UNrSv/3v2HxAb7d+C3dp3Sn+YnN+aDrB5YcjCmCwiaIt4EfRCR3HerOwJvBCan0UoVhw9zI6Wuv9TqaYzB+PMyZA6+84hYCCnHLty+n48SOnFT5JGbdOIuKMRW9DsmYsFKoBKGqL4rIPOASXMmhr6r+HMzASqOvvoLFi92P78hIr6Mpou3b3frSF10E//iH19EUaNOeTbR7tx3losoxp9ccm1/JmGNQ0GyuccDtwKnAUuA1f+8kcwyGDXMzUdx8s9eRHIO77oJ9+9zovhCfxntn2k7avduOvRl7+abvN9SvUt/rkIwJSwX9T38HaI5LDu2BF4IeUSn1668wdy7cc4/rHRpWZs6ESZPcuIdGjbyO5qjSstK4ZuI1rNm5hundp9OkVon3ozCm1CioiulMVT0bQETeBBYFP6TSacQIKF/+UBtv2Ni711UpnX02PBjaYweyfdn0mNKD7zZ9x6Quk2hZv6XXIRkT1gpKEFm5d1Q1W8Kg10ooSk6G996Dvn2halWvoymiRx6BP/+EDz+EmNBdflNVuWPWHUxfNZ2X271M17O6eh2SMWGvoARxjojs9d8XoJz/seDGuVUKanSlxBtvQEZGGK4Wt2CBGyl9113QooXX0RzV0PlDGf3TaP55yT+5s0W4fdHGhKagLRgULOE2UC4ryy0leuaZrg0ibGRkQNOmsH+/m9K7Yuh2EX1jyRsM+HgAvc/pzdud3sZKusb8VTAHypljNG2aq6EZVdDqGaHm2Wdh5Ur45JOQTg4zVs3g9lm30/7U9rzR8Q1LDsYUo9Dur1gKjBgBDRpAhw5eR1IEK1a4uchvvBHat/c6miP6btN33PDhDTSr08xGSRsTBJYggmjxYvjuO9f2EOJDBw7x+eDWWyE+Hl56yetojmhl8kqufu9q6lWqx6wbZ1EhpoLXIRlT6lgVUxC9+qqrnenTx+tIiuC//3VZbexYqFnT62gCStqbRNsJbYmNimVOrznUqBAeixUZE24sQQTJzp1ubFmfPlC5stfRFNKff8JDD0GbNiE73HtX2i7av9ue3em7md9nPolVE70OyZhSyxJEkIwb5xYGuv12ryMpgoED3TrTo0aF5EytaVlpdHq/E6t2rOLTnp/StE5Tr0MyplSzBBEEqu4ae8EFcM45XkdTSFOnwkcfuQmjGjTwOpq/yPHl0HNqT77Z+A0Tr59I61Naex2SMaWeJYggmD8fVq2Cd97xOpJC2r3blR6aNoX7Qm9xP1XlH7P+wbTfpzGi3Qi6N+7udUjGlAmWIIJg1Cg3pUbXcJnt4aGHYNs2NylfVOj9kxgyf8jBUdJ3tbjL63CMKTPCpfNl2Ni2zdXW9OkD5cp5HU0hfP01jB7t1npo1szraP5i1OJRDJk/hL7n9uXpK572OhxjypSgJggRaSciq0RkjYg8fJT9uoiIikiRhoGHorffdtNrhMWsrenpMGCAmwtkyBCvo/mLD1d8yD9m/YOrT7+a0R1H2yhpY0pY0OoTRCQSGAlcCSQBP4rIDFVdkW+/eOAu4IdgxVJSfD73Y7xVKzjjDK+jKYSnnnKNJXPmQIXQGmj25fov6Tm1JxfVu4hJXSYRFRF6VV/GlHbBLEGcD6xR1XWqmgm8D3QKsN+/gOeA9CDGUiK++ALWr3c/ykPeb7+5Hku9e8Pf/+51NIdZsnkJnd7vxOnVTmdmj5mUjy7vdUjGlEnBTBB1gU15Hif5nztIRJoC9VT146MdSEQGiMhiEVmcnJxc/JEWkzFj4IQT4NprvY6kANnZ0L+/C/Y///E6msOsTllN+3fbU61cNWb3nE3VcuG2gIYxpUcwE0SgCuODc4uLSATwEjCooAOp6mhVba6qzWvUCM1pFXbscDO33nwzxMZ6HU0BXn7ZTRT18stQrZrX0RyUtDeJK8dfCcDcm+ZSt1LdAt5hjAmmYCaIJKBenscJwOY8j+OBxsA8EdkAXADMCNeG6nHjXON0//5eR1KAdevgscegY0fo1s3raA5KOZBC2wlt2ZW2i9m9ZnN6tdO9DsmYMi+YLX8/AqeJSCLwJ9AduDH3RVXdA1TPfSwi84D7VTV8VgPyU3XVSxdcAI0bex3NUai6mVqjotxKcSHSK2hf5j46vNeBtTvXMqfXHM6rc57XIRljCGKC8K9hPRCYA0QCb6nqchEZCixW1RnBOndJW7jQra0zZozXkRRgzBj48ks3Y2tCgtfRAJCenU7n9zuzZPMSpnSbwuX1L/c6JGOMny05Wgz69oUPP4QtW0J48bWkJLfuafPmrrtVCJQesnKy6PpBV6avms74a8fTq0kvr0MyptQ6liVHbST1cdqzByZPhh49Qjg5qLppZXNy4I03QiI5+NRHvxn9mL5qOq+0f8WSgzEhyEYfHaf334cDB0K8cfq992DWLLdCXAjM1Kqq3PnJnUz4bQJPtXqKgecP9DokY0wAVoI4Tm++6Rqmzz/f60iOYOtWuOsuuPBCt/apx1SVhz5/iNcWv8YDFz3AI5c+4nVIxpgjsARxHJYuhR9/dKWHEKi1+avcqqUDB9wkUZGRXkfEU18/xfPfPc8/mv+DYW2G2fxKxoQwq2I6Dm+9BdHR0CtUq8/ffRemT4cXXgiJyaFeXPgiT8x7gt7n9OaVDq9YcjAmxFkJ4hhlZMD48dC5M1SvXvD+JW7LFle1dNFFcM89XkfDyEUjGTR3EF3P7MqYa8YQIfZPz5hQZ/9Lj9GMGZCSAv36eR1JAKpuvvG0tJCoWnpjyRsM/HQgnc7oxLvXvWszsxoTJux/6jF6802oVw+uvNLrSAJ45x23OtyLL8Lp3k5ZMfaXsdz28W10OK0Dk7pMIjoy2tN4jDGFZyWIY7BxI8yd61aNC4F238Nt2OCqli6/HO6+29NQJvw2gX7T+9HmlDZM6TaF2KhQn8XQGJOXJYhj8M47rhanb1+vI8nH53NZC1yQEd79eSf8NoGbp91Mq8RWfNT9I+Ki4jyLxRhzbKyKqYh8Ptd7qXVrt1JnSHnpJZg/37U7nHyyZ2HkTQ624I8x4ctKEEX0+eeuFueWW7yOJJ9ly+CRR6BTJ7dKnEfG/zrekoMxpYQliCIaM8atsRNSq8alp8ONN0Llym5RbI/GF4z5aQy9P+rNFYlXWHIwphSwBFEEycnw0UchuGrcQw+5Yd1jx0LNmp6EMHLRSG6deSttT21rycGYUsLaIIrgnXfcqnEhVb00a5ZbOvSuu6BDB09CeHHhiwyaO4hrzriGyV0mW28lE/aysrJISkoiPT3d61CKLC4ujoSEBKKjj79Lua0HUUiq0KiRq15asKDETx/Y1q3QpAnUrg2LFkFcyfYUUlWGzh/K4PmD6XpmV9697l0b52BKhfXr1xMfH0+1atXCakoYVSUlJYXU1FQS8/WiOZb1IKwEUUjffgurVrkOQiEht0traip89VWJJwef+hg0ZxDDfxhOn3P78EbHN2yEtCk10tPTqV+/flglBwARoVq1aiQnJxfL8ex/dCGNGQOVKkHXrl5H4jdsGMyZ49aWPuusEj11ti+bATMH8PYvb3N3i7t5se2LNreSKXXCLTnkKs64LUEUwu7d8MEHrvdohQpeRwN8/TU89hjccIObzrsEpWWlcePUG/no948YfPlgnrj8ibD9j2SMOTr72VcI77zj5r0bMMDrSIDt26F7d7cyXAl3ad2Vtou2E9oy/ffpjGg3gidbPmnJwZggUFUuueQSPv3004PPTZ48mXbt2tGvXz9q1qxJ48aNgx5HUBOEiLQTkVUiskZEHg7w+n0iskJEfhORL0TEu+G/R6DqanEuvBCaNvU4mJwct/jErl2uSFOpUomd+s+9f3LZ2Mv4Pul7Jl4/kbta3FVi5zamrBERRo0axX333Ud6ejr79+/n0UcfZeTIkfTp04fZs2eXSBxBq2ISkUhgJHAlkAT8KCIzVHVFnt1+Bpqr6gER+T/gOeCGYMV0LL78Elavdms/eG7IEPjsM3jjDTjnnBI77dJtS7nqvavYnb6b2b1mc0XiFSV2bmO8ds898MsvxXvMc8+F4cOPvk/jxo3p2LEjw4YNY//+/dx88800aNCABg0asGHDhuIN6AiC2QZxPrBGVdcBiMj7QCfgYIJQ1a/y7P89EHJrs732mlsQqEsXjwOZNg3+9S+3AEX//iV22rlr59JlchfiY+OZ32c+Tet4XYwypux48sknOe+884iJicGL7v3BTBB1gU15HicBLY6yf3/g00AviMgAYADASSedVFzxFSgpya3Yef/9Jd6L9HArVrjh2+efDyNHlli7w5ifxnD7x7dzVs2zmHXjLBIqJZTIeY0JJQX90g+mChUqcMMNN1CxYkViPZi+IZhtEIGuYgFH5YlIL6A58Hyg11V1tKo2V9XmNWrUKMYQj+6NN9xwg9tuK7FT/tWePW5d0/LlYcqUEslUOb4cHpj7ALfOvJUrG1zJN32/seRgjEciIiKI8Gjq/mCWIJKAenkeJwCb8+8kIm2AR4HLVTUjiPEUSVaW6yTUoYOH03pnZ0OPHrB+vWsMSQj+RXpP+h56TOnBp2s+5Y6/3cHwdsNtAJwxZVQw09KPwGkikigiMUB3YEbeHUSkKfBf4BpV3R7EWIps2jQ3k8U//uFRAKqudezTT1210qWXBv2Ua3au4YI3L+CzdZ8x6qpRvNrhVUsOxoSYHj16cOGFF7Jq1SoSEhJ48803g3auoP3vV9VsERkIzAEigbdUdbmIDAUWq+oMXJVSReADf3/6jap6TbBiKixVt5xzgwbQtq1HQbz8sksM999fIgMwZq6ayU3TbiIqIorPbvqMlvVbBv2cxpiCDR48+LDHEydOLLFzB/Xnoap+AnyS77kn8txvE8zzH6tvv4UffnDXZ0/WnJ4xA+691y06MWxYUE+V48th8LzBPPXNU5xX5zymdJtC/Sr1g3pOY0x4sPqDAJ5/3nVtzV3euUR9/71rd2jeHCZMCOq60sn7k7lp2k3MWTuHfuf2Y+RVI23taGPMQZYg8lm5EmbOhCefdB2HStSyZa5VvE4dV4oIYgDzNsyj59SepBxIYfTVo7m12a1BO5cxJjzZXEz5/Oc/rifpHXeU8InXrYO//x3KlXOjpWvXDsppcquUWo9rTcWYivxwyw+WHIwxAVkJIo8tW9yUGv36QQkOt3AnvvJKyMhwM7UGqV/t2p1rufmjm/lu03fcfM7NjOwwkooxFYNyLmNM+LMEkccrr7jxD/fdV4In/fNPuOIK2LYNvvgiKGs7qCpjfhrDvXPuJSoiignXTqBnk57Ffh5jTOliVUx+O3e6eZeuvRZOO62ETrppE1x+OWzeDLNnQ4ujzURybJL2JtFxYkcGfDyAFgktWPp/Sy05GBPijjTdd+vWrWnVqhWNGjXirLPOYsSIEUGNw0oQfs8+C3v3Qr4ux8Hzxx/QqhWkpLg2hwsuKNbD+9TH6CWjefCzB8nRHIa3Hc6dLe60ld+MCQO503137dqVVq1akZOTw6OPPsrYsWMpV64c5513HqmpqTRr1owrr7ySM888MyhxWILATcr3yitw001w9tklcMLly6F9e7ee9Oefw9/+VqyHX5G8gv+b9X98/cfXtE5szeiOozml6inFeg5jygyP5vsONN33xRdffPD1+Ph4GjVqxJ9//mkJIpgGD3ajp4cMKYGTzZt3aPK9efOKdV2H1IxUhs4fyvAfhhMfE8+b17xJ33P72qpvxoSpo033vWHDBn7++WdaBKFqOleZTxC//w5vvw133gn16wf5ZBMnutF3p57q5lgqpqnLferjvaXv8dDnD7E5dTO3NL2FZ9s8S/Xy1Yvl+MaUaR7O932k6b737dvH9ddfz/Dhw6kUxJUly3yCePRRqFDB3QZNTg488QQ884xrlJ42DapWLZZDf7n+Sx747AF+2vITzeo0Y0q3KVyQULztGcYY7+Sf7jsrK4vrr7+enj17ct111wX13GU6QXzzDUyd6qqWgjbuYccON3XG55/DLbfAq69CMSz8sXjzYp746gk+XfMpJ1U+iQnXTqDH2T2sEdqYUkxV6d+/P40aNeK+EuiPX2YTxP79bkBc/fpBHPewcCHccANs3w5jxhTLUqFLNi9h8PzBfLz6Y04odwLD2gzjrhZ32RxKxpQBCxYsYPz48Zx99tmce+65ADzzzDN06NAhKOcrswnin/+ENWvgq6+gYnEPJs7IcJM5Pf881KsHCxZAs2bHfDhV5Yv1X/D8d88zd+1cqsZV5alWT3FnizupFBu8+kdjjPfyTvd9ySWXoBpwYc6gKJMJYt481631rrugZctiPvhPP0Hv3m7ivf793cISx9iIlJaVxuTlkxn+w3B+2foLtSvW5pkrnuGO8++wxGCMCboylyBSU6FvX9eR6JlnivHAycmuIXr0aKhVC2bNcjOzHoPVKav57+L/MvbXsexM20mj6o0Y03EMvZr0Ijaq5BcuN8aUTWUqQfh8cNttbhDzN9+43kvHLSPDzdExZAjs2+emgR0ypMi9lFIOpDBp+STG/zae75O+JyoiimsbXsvtzW+nVf1WNpbBGFPiykyCUHXX7okT4emnIc+AxGOzb58rLfznP24upbZtXXVSEUY0btu3jRmrZjDt92l8vu5zsnxZNK7ZmH+3/jc3n3MzdeLrHGeQxhhz7MpEglCFBx6AUaPgoYdcA/UxW7vWjawbNcrNo9SqFbzzDrRuDQX8ys/2ZbN482Lmrp3LnLVzWLhpIYpyStVTuLvF3fRs0pNzap1jpQVjTEgo9QnC53NTafznPzBwoJuUr8jX35073TJzY8e6Fu6ICLj6anj4YbjwwiO+LS0rjSVblvDtxm/5duO3LNi0gN3puxGEZic24/HLHue6RtfRpFYTSwrGmJAT1AQhIu2AEUAkMEZV/53v9VhgHNAMSAFuUNUNxXX+Zcvg9ttdL9O+fWHEiEImh8xM+PVX1wf244/dAXw+aNDA1U/dfDMkJBzcXVXZtHcTK5NXsnLHSn7e+jM/bfmJlckrydEcABpWb8j1ja6nzSltaHNKG5sGwxhzRKrKpZdeyqOPPkr79u0BN933W2+9xc6dO8nIyCA7O5suXbowJIiTyAUtQYhIJDASuBJIAn4UkRmquiLPbv2BXap6qoh0B4YBNxzvuZOS3IDl//wHKld2NUK9ewdIDjk5sHUrrF4Nq1a5iZkWL4YlSyA9HQDfueew+5F72dGqBVtPqcnmfVvYvGkyG5dtZP3u9azftZ51u9axP2v/wcPWqlCLZic2o/MZnWl+YnMuqncRNSqU5BJ1xphwdqTpvmfPnk2tWrWoWLEiWVlZXHLJJbRv354Linm5gFzBLEGcD6xR1XUAIvI+0AnImyA6AYP99z8EXhUR0aOMBNn4xxruvL0TkRHugq+4H/c+n5K6V9mxQzmwX4kQHz07Z9MgMYutv2fzzH3pZGemkZORTnb6ATIPpJKZvp/MSEiLggPRkBYXyb5mFdh7RSX2xlVmd0QmuzKX4tNf4Rvc5lc+ujynVD2FxCqJXJF4BQ2rN6RR9UY0qtGImhVqFuf3aIzx0D2z7+GXrcU73fe5tc9leLuiT/fdoEGDg69nZWWRlZUV1OrpYCaIusCmPI+TgPzz0h7cR1WzRWQPUA3YkXcnERkADACgDrxaZ0bgM554lGjKHbob5RNiiSRa4oiJiKZ8TAXKlYunXLl44mPiqRsbT6PYSlSOrUy1ctWoVr4a1cpVo058HepUrMOJ8SdSJa6KtRsYY4Iq0HTfOTk5NGvWjDVr1nDHHXeE7XTfga6e+UsGhdkHVR0NjAZocnYTndbtE9LTITNDiYyC2BiIiYYqJ0QSFRMBEgEREUTExiEREQhCVEQUkRGRNpmdMaZICvqlH0yBpvuOjIzkl19+Yffu3Vx77bUsW7aMxo0bB+X8wUwQSUC9PI8TgM1H2CdJRKKAysDOox00JjaGBo0SjraLMcaUGvmn+85VpUoVWrZsyezZs4OWIIL5c/pH4DQRSRSRGKA7kL9uaAbQ23+/C/Dl0dofjDGmLEtOTmb37t0ApKWl8fnnn9OwYcOgnS9oJQh/m8JAYA6um+tbqrpcRIYCi1V1BvAmMF5E1uBKDt2DFY8xxoS7LVu20Lt3b3JycvD5fHTr1o2rr746aOeTcPvB3rx5c82/NqsxxhSnlStX0qhRI6/DOGaB4heRJaravCjHsRZbY4wxAVmCMMYYE5AlCGOMCSDcqt9zFWfcliCMMSafuLg4UlJSwi5JqCopKSnExRXPGvWlfjZXY4wpqoSEBJKSkkhOTvY6lCKLi4sjIaF4xopZgjDGmHyio6NJTEz0OgzPWRWTMcaYgCxBGGOMCcgShDHGmIDCbiS1iKQCq7yOI0RUJ9/U6GWYfReH2HdxiH0Xh5yhqvFFeUM4NlKvKupw8dJKRBbbd+HYd3GIfReH2HdxiIgUeY4iq2IyxhgTkCUIY4wxAYVjghjtdQAhxL6LQ+y7OMS+i0PsuzikyN9F2DVSG2OMKRnhWIIwxhhTAixBGGOMCSisEoSItBORVSKyRkQe9joer4hIPRH5SkRWishyEbnb65i8JCKRIvKziHzsdSxeE5EqIvKhiPzu//dxodcxeUVE7vX//1gmIhNFpHimOA0DIvKWiGwXkWV5njtBRD4Tkf/5b6sWdJywSRAiEgmMBNoDZwI9RORMb6PyTDYwSFUbARcAd5Th7wLgbmCl10GEiBHAbFVtCJxDGf1eRKQucBfQXFUbA5GUrTXvxwLt8j33MPCFqp4GfOF/fFRhkyCA84E1qrpOVTOB94FOHsfkCVXdoqo/+e+n4i4Cdb2NyhsikgBcBYzxOhaviUgl4DLgTQBVzVTV3d5G5akooJyIRAHlgc0ex1NiVPVrYGe+pzsB7/jvvwN0Lug44ZQg6gKb8jxOooxeFPMSkfpAU+AHbyPxzHDgQcDndSAh4BQgGXjbX+U2RkQqeB2UF1T1T+AFYCOwBdijqnO9jcpztVR1C7gfmUDNgt4QTglCAjxXpvvoikhFYApwj6ru9TqekiYiVwPbVXWJ17GEiCjgPOB1VW0K7KcQ1Qilkb9+vROQCJwIVBCRXt5GFX7CKUEkAfXyPE6gDBUZ8xORaFxyeFdVp3odj0cuBq4RkQ24KscrRGSCtyF5KglIUtXc0uSHuIRRFrUB1qtqsqpmAVOBizyOyWvbRKQOgP92e0FvCKcE8SNwmogkikgMvHGf8wAAAuVJREFUrsFphscxeUJEBFfPvFJVX/Q6Hq+o6j9VNUFV6+P+PXypqmX2V6KqbgU2icgZ/qdaAys8DMlLG4ELRKS8//9La8pog30eM4De/vu9gekFvSFsZnNV1WwRGQjMwfVIeEtVl3scllcuBm4ClorIL/7nHlHVTzyMyYSGO4F3/T+i1gF9PY7HE6r6g4h8CPyE6/X3M2Vo2g0RmQi0BKqLSBLwJPBvYLKI9Mcl0K4FHsem2jDGGBNIOFUxGWOMKUGWIIwxxgRkCcIYY0xAliCMMcYEZAnCGGNMQJYgTJklItVE5Bf/tlVE/szz+LsgnbOpiBxx3igRqSEis4NxbmOKKmzGQRhT3FQ1BTgXQEQGA/tU9YUgn/YR4KmjxJQsIltE5GJVXRDkWIw5KitBGBOAiOzz37YUkfkiMllEVovIv0Wkp4gsEpGlItLAv18NEZkiIj/6t4sDHDMeaKKqv/ofX56nxPKz/3WAj4CeJfRRjTkiSxDGFOwc3JoTZ+NGsJ+uqufjphi/07/PCOAlVf0bcD2Bpx9vDizL8/h+4A5VPRe4FEjzP7/Y/9gYT1kVkzEF+zF3mmQRWQvkThu9FGjlv98GONNN+wNAJRGJ96/XkasObjruXAuAF0XkXWCqqib5n9+Om4HUGE9ZgjCmYBl57vvyPPZx6P9QBHChqqZxZGnAwWUvVfXfIjIL6AB8LyJtVPV3/z5HO44xJcKqmIwpHnOB/2/n7m0QhsEgDN9NQMUEIERJwQJMwBoUCMEYNLRMgujZgB/BGBQM8FHESAlYqZCheJ8u8Ve4O52tZP56sD3KzNwk9WszvYg4R8Ra1bHSMC0N1DyKAn6CgAC+YyFpbPtk+ypp9j6Q2kGndhm9tH2xfVTVGPbp/UTSrsSmgTb8zRUoyPZK0iMi2r6FOEiaRsS93M6ATzQIoKytmncaDba7kjaEA/4BDQIAkEWDAABkERAAgCwCAgCQRUAAALIICABA1hNyIaK7vufOiQAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -278,9 +288,7 @@ } ], "source": [ - "plot(Y1.T, T1, 'b-')\n", - "plot(Y2.T, T2, 'r-')\n", - "plot(Y3.T, T3, 'g-')\n", + "plot(T1, Y1.T, 'b-', T2, Y2.T, 'r-', T3, Y3.T, 'g-')\n", "plot([0 ,10], [1, 1], 'k-')\n", "title('Step Response for Inputs')\n", "ylabel('Position')\n", @@ -311,7 +319,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -323,31 +331,14 @@ "cell_type": "code", "execution_count": 12, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "m = 4.000000\n", - "J = 0.047500\n", - "r = 0.250000\n", - "g = 9.800000\n", - "c = 0.050000\n" - ] - } - ], + "outputs": [], "source": [ "# System parameters\n", "m = 4 # mass of aircraft\n", "J = 0.0475 # inertia around pitch axis\n", "r = 0.25 # distance to center of force\n", "g = 9.8 # gravitational constant\n", - "c = 0.05 # damping factor (estimated)\n", - "print(\"m = %f\" % m)\n", - "print(\"J = %f\" % J)\n", - "print(\"r = %f\" % r)\n", - "print(\"g = %f\" % g)\n", - "print(\"c = %f\" % c)" + "c = 0.05 # damping factor (estimated)" ] }, { @@ -443,7 +434,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -478,7 +469,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -501,7 +492,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -524,7 +515,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -556,7 +547,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.6" + "version": "3.7.7" } }, "nbformat": 4, From 03183d157a5f6cd8a9918498ab8717dc7b91c9cf Mon Sep 17 00:00:00 2001 From: Ben Greiner Date: Sun, 17 May 2020 22:08:41 +0200 Subject: [PATCH 10/67] Fix iosys._find_size to detect inconsistent system definitions (#402) * fix iosys._find_size() * fix and rerun steering example notebook * allow legacy iosys._find_size(1, scalar) --- control/iosys.py | 23 +++++++++----- control/tests/iosys_test.py | 62 +++++++++++++++++++++++++++++++------ examples/steering.ipynb | 50 ++++++++++++++---------------- 3 files changed, 92 insertions(+), 43 deletions(-) diff --git a/control/iosys.py b/control/iosys.py index 520a6237c..1b29b5b01 100644 --- a/control/iosys.py +++ b/control/iosys.py @@ -1745,16 +1745,23 @@ def linearize(sys, xeq, ueq=[], t=0, params={}, **kw): return sys.linearize(xeq, ueq, t=t, params=params, **kw) -# Utility function to find the size of a system parameter def _find_size(sysval, vecval): - if sysval is not None: - return sysval - elif hasattr(vecval, '__len__'): + """Utility function to find the size of a system parameter + + If both parameters are not None, they must be consistent. + """ + if hasattr(vecval, '__len__'): + if sysval is not None and sysval != len(vecval): + raise ValueError("Inconsistend information to determine size " + "of system component") return len(vecval) - elif vecval is None: - return 0 - else: - raise ValueError("Can't determine size of system component.") + # None or 0, which is a valid value for "a (sysval, ) vector of zeros". + if not vecval: + return 0 if sysval is None else sysval + elif sysval == 1: + # (1, scalar) is also a valid combination from legacy code + return 1 + raise ValueError("Can't determine size of system component.") # Convert a state space system into an input/output system (wrapper) diff --git a/control/tests/iosys_test.py b/control/tests/iosys_test.py index 27651de71..0738e8b18 100644 --- a/control/tests/iosys_test.py +++ b/control/tests/iosys_test.py @@ -286,19 +286,19 @@ def test_algebraic_loop(self): # Set up parameters for simulation T, U, X0 = self.T, self.U, self.X0 - # Single nonlinear system - no states - ios_t, ios_y = ios.input_output_response(nlios, T, U, X0) + # Single nonlinear system - no states + ios_t, ios_y = ios.input_output_response(nlios, T, U) np.testing.assert_array_almost_equal(ios_y, U*U, decimal=3) # Composed nonlinear system (series) - ios_t, ios_y = ios.input_output_response(nlios1 * nlios2, T, U, X0) + ios_t, ios_y = ios.input_output_response(nlios1 * nlios2, T, U) np.testing.assert_array_almost_equal(ios_y, U**4, decimal=3) # Composed nonlinear system (parallel) - ios_t, ios_y = ios.input_output_response(nlios1 + nlios2, T, U, X0) + ios_t, ios_y = ios.input_output_response(nlios1 + nlios2, T, U) np.testing.assert_array_almost_equal(ios_y, 2*U**2, decimal=3) - # Nonlinear system composed with LTI system (series) + # Nonlinear system composed with LTI system (series) -- with states ios_t, ios_y = ios.input_output_response( nlios * lnios * nlios, T, U, X0) lti_t, lti_y, lti_x = ct.forced_response(linsys, T, U*U, X0) @@ -323,7 +323,7 @@ def test_algebraic_loop(self): (1, (0, 0, -1))), 0, 0 ) - args = (iosys, T, U, X0) + args = (iosys, T, U) self.assertRaises(RuntimeError, ios.input_output_response, *args) # Algebraic loop due to feedthrough term @@ -392,7 +392,7 @@ def test_neg(self): # Static nonlinear system nlios = ios.NonlinearIOSystem(None, \ lambda t, x, u, params: u*u, inputs=1, outputs=1) - ios_t, ios_y = ios.input_output_response(-nlios, T, U, X0) + ios_t, ios_y = ios.input_output_response(-nlios, T, U) np.testing.assert_array_almost_equal(ios_y, -U*U, decimal=3) # Linear system with input nonlinearity @@ -807,6 +807,50 @@ def test_named_signals(self): np.testing.assert_array_almost_equal(ss_feedback.C, lin_feedback.C) np.testing.assert_array_almost_equal(ss_feedback.D, lin_feedback.D) + def test_named_signals_linearize_inconsistent(self): + """Mare sure that providing inputs or outputs not consistent with + updfcn or outfcn fail + """ + + def updfcn(t, x, u, params): + """2 inputs, 2 states""" + return np.array( + np.dot(self.mimo_linsys1.A, np.reshape(x, (-1, 1))) + + np.dot(self.mimo_linsys1.B, np.reshape(u, (-1, 1))) + ).reshape(-1,) + + def outfcn(t, x, u, params): + """2 states, 2 outputs""" + return np.array( + self.mimo_linsys1.C * np.reshape(x, (-1, 1)) + + self.mimo_linsys1.D * np.reshape(u, (-1, 1)) + ).reshape(-1,) + + for inputs, outputs in [ + (('u[0]'), ('y[0]', 'y[1]')), # not enough u + (('u[0]', 'u[1]', 'u[toomuch]'), ('y[0]', 'y[1]')), + (('u[0]', 'u[1]'), ('y[0]')), # not enough y + (('u[0]', 'u[1]'), ('y[0]', 'y[1]', 'y[toomuch]'))]: + sys1 = ios.NonlinearIOSystem(updfcn=updfcn, + outfcn=outfcn, + inputs=inputs, + outputs=outputs, + states=self.mimo_linsys1.states, + name='sys1') + self.assertRaises(ValueError, sys1.linearize, [0, 0], [0, 0]) + + sys2 = ios.NonlinearIOSystem(updfcn=updfcn, + outfcn=outfcn, + inputs=('u[0]', 'u[1]'), + outputs=('y[0]', 'y[1]'), + states=self.mimo_linsys1.states, + name='sys1') + for x0, u0 in [([0], [0, 0]), + ([0, 0, 0], [0, 0]), + ([0, 0], [0]), + ([0, 0], [0, 0, 0])]: + self.assertRaises(ValueError, sys2.linearize, x0, u0) + def test_lineariosys_statespace(self): """Make sure that a LinearIOSystem is also a StateSpace object""" iosys_siso = ct.LinearIOSystem(self.siso_linsys) @@ -931,7 +975,7 @@ def predprey(t, x, u, params={}): def pvtol(t, x, u, params={}): from math import sin, cos m = params.get('m', 4.) # kg, system mass - J = params.get('J', 0.0475) # kg m^2, system inertia + J = params.get('J', 0.0475) # kg m^2, system inertia r = params.get('r', 0.25) # m, thrust offset g = params.get('g', 9.8) # m/s, gravitational constant c = params.get('c', 0.05) # N s/m, rotational damping @@ -946,7 +990,7 @@ def pvtol(t, x, u, params={}): def pvtol_full(t, x, u, params={}): from math import sin, cos m = params.get('m', 4.) # kg, system mass - J = params.get('J', 0.0475) # kg m^2, system inertia + J = params.get('J', 0.0475) # kg m^2, system inertia r = params.get('r', 0.25) # m, thrust offset g = params.get('g', 9.8) # m/s, gravitational constant c = params.get('c', 0.05) # N s/m, rotational damping diff --git a/examples/steering.ipynb b/examples/steering.ipynb index 544d443c5..c0d277f43 100644 --- a/examples/steering.ipynb +++ b/examples/steering.ipynb @@ -131,7 +131,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -227,10 +227,10 @@ " t, [0., x[0], x[1]], [params.get('velocity', 1), u[0]], params)[1:],\n", " lambda t, x, u, params: vehicle_output(\n", " t, [0., x[0], x[1]], [params.get('velocity', 1), u[0]], params)[1:],\n", - " states=2, name='lateral', inputs=('phi'), outputs=('y', 'theta')\n", + " states=2, name='lateral', inputs=('phi'), outputs=('y')\n", ")\n", "\n", - "# Compute the linearization at velocity 10 m/sec\n", + "# Compute the linearization at velocity v0 = 15 m/sec\n", "lateral_linearized = ct.linearize(lateral, [0, 0], [0], params=vehicle_params)\n", "\n", "# Normalize dynamics using state [x1/b, x2] and timescale v0 t / b\n", @@ -240,7 +240,7 @@ " lateral_linearized, [[1/b, 0], [0, 1]], timescale=v0/b)\n", "\n", "# Set the output to be the normalized state x1/b\n", - "lateral_normalized = lateral_transformed[0,:] * (1/b)\n", + "lateral_normalized = lateral_transformed * (1/b)\n", "print(\"Linearized system dynamics:\\n\")\n", "print(lateral_normalized)\n", "\n", @@ -285,7 +285,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAE8CAYAAABQLQCwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOydd3xUVfbAv3dqeieUJPReQxOkKNhBBOxiVxTrLrrq/qzo6lp2FxUrWBdRwbKKooYuSgcpAZJQkhADIYQU0uvMvPv74w2QkITMpJf79fM+773b3plxODnv3nvOEVJKFAqFQqFQKBRtB0NTC6BQKBQKhUKhaFyUAahQKBQKhULRxlAGoEKhUCgUCkUbQxmACoVCoVAoFG0MZQAqFAqFQqFQtDFMTS1AQxISEiK7du3a1GIoFIpmxs6dOzOllO2aWo76Quk6hUJRHdXpu1ZtAHbt2pUdO3Y0tRgKhaKZIYRIbmoZ6hOl6xQKRXVUp+/UErBCoVAoFApFG0MZgAqFQqFQKBRtDGUAKhQKhUKhULQxWvUeQHeZMGFCpbIbbriBBx98kKKiIiZPnlyp/s477+TOO+8kMzOT6667rlL9Aw88wI033sjRo0e57bbbKtU/9thjXHXVVRw8eJD77ruvUv1TTz9Fx6Ed+XH9j3z00keUaWXYNBua1BAI+t7alx5DemA7bOOP//6Bh8kDD6MHXmYvjMLIvHnziIyMZM2aNfzzn/+sNP4H8+fTJzyIn374jtff+xikA6QEJAjB53OfJqJrd75evpH5n/8PDGYQ4nT///3vf4SEhLBw4UIWLlxYafyoqCi8vLx4//33+eabbyrV//rrOsocGnPnzmVFVBQSPTWhQODp5clPP/+CxWjg5Zf/ydq1ayv0DQ4O5rvvvtO/p6eeYsuWLRXqw8PD+eKLLwB45JFHiI6OrlDfu3dvPvzwQwBmzZrFoUOHKtRHRkYyb948AG699VZSUlIq1J9//vm8+uqrAFx77bVkZWVVqL/44ot57rnnAJg0aRLFxcUV6qdMmcLjjz8ONM/f3rPPPssll1xCdHQ0jzzySKX6V155hTFjxrB582aefvrpSvU1/vY++IA+ffrw008/8frrr1eq//zzz4mIiODrr79m/vz5lerL//buvPPOSvWK1o3NobE5MYvdR7KJS83jyMkiSmwOSmwafp4mQnysRAR6MSjcnyHhAfTv5IfRIGoeWKFoIygDsJlS5igjoziDpzY8he24jeLkYgpsBViNVrxMXhgNRqSUdPXrisVoIakgifSidDSpnR7DarTyxo43uNh8MUXZRWiaHUNZAZTmQ2kB2IpgwVgIdMBBG6SVVRbk+3vB3wAxNjjqrDeYwGgBkwWinoCI3pCcBCW5YLKC0QpCUGbX2JKYSWqhZFVcGgnpBdgcGjaHxK5pODRJ96ejAMjddoji5JMVHi1MVvo+twKAgi2HKDmSjVEIjAaBySDwLjDw2Dd7CPAyszP5JCfySjAbDZiNBkxGgc2uIaVECKX0FYrWwp+ZhXy6KYmf9x7nZGEZQkD3EG+6hfjgbTViMRrIK7GRnl/Kyrg0vt5xFIBgbwsT+oRyxcAOTOjTDrNRLYAp2jZCStnUMjQYI0aMkC3NM67EXsKnMZ/yyb5PsGk2xoSNYVqPaQxvP5xQr9Bz9tWkxvHC4yTmJHLw5EH2n9xPbOY+UgvTADBJSe+yMgaXljHY5M/ggN50DuqNCOwKXsHgGQAWH93AEwbQHOAog7JCKM2F4hwoyoLCDMg/DnnHIS9Vv+bM78iOkWO0409HKMmyPckylBTRgULvLjj8O+Pj40uglxlfDzPeVhOeZiNmo27UGZxv6JomsWuSModGiU2j1OagsMxOUamD/FI7+SU2covt5BXbyC4qo6jMUeV3YjYKgr2ttPN1Hj7lrs8q87aq96G2ghBip5RyRFPLUV+0RF3nLpkFpbyzNp4vtx3BaBBc0r890yPDGNszGC9L1f92pZSkZBez60g26w6ks+5gBrnFNoK9LUyLDOO287vQLcS7kT+JQtG4VKfvGu0vnhDiU2AKkC6lHFhFvQDeAiYDRcCdUspdzrornHVG4GMp5WuNJXdjsi9jH0+sf4JjBceY1G0Ss4fNJswnzOX+BmEgzCeMMJ8wLvAMg+QYOBRHpr2ImOBw9ob2YI+/YFlRKl/Zi6HsAL4njzFADKC/sT/9fbzp4xdKhG8ERoPxnM/SNMnOI9ms3Z/OpoOp5Jz4kwiRQXdjBpE+OfS2ZDFQHmds8VZMtny9UymQDhR3hMCuYOgC3l0hoAv4R0BAZ/DrBEaz299dqd1BTpGNzIJSThaWkVVQRmZBKZkFZWTkl5JZUEpabgkxx3LJLChFq+K9x8tiPG0QhvhYCfG16GcfKyE+FoJ9rAR7Wwj2tuLnaVIziwpFI7HuQDqPfbuH3GIbN42MYPbFvQj186ixnxCCiCAvIoK8mBYZhs2h8fvBDL7blcLnW//k001JTOjTjnvHd2dMj2D1b1rRpmi0GUAhxAVAAbCoGgNwMvAXdANwFPCWlHKUEMIIHAIuBVKAP4AZUsq4mp7Zkt6KV/65kmc2PkOIZwgvjnmR8zqeV7uBsv+EX1+GmP/py7SDroPIW6Hz6NN79xyag8TcRGIyY04f8Tnx2DU7AB5GD7oHdKe7v3509utMhG8E4b7hHMuCb3ek8Mu+VE7klWIyCEZ0DeSC3u0Y1S2YgWF+WE3ljEcpoegkZCfByST9nP2nfp2TrM8gUv43KMC3o24Injp82utlPu3AOxR8QvUZy1oYivrnl2QX6YZhen4pmc7zKUPx9LmglJwiW5VjmAyCQG8LQV4WArzMBHpZCPQ2E+BlIcDTjH+5w8/TjJ+HGV8PEz4eJrX01AxQM4AtA4cm+ffKA3zw+2H6dvDl7RlD6d3et17GTs8vYfG2I3y57QgZ+aUMCffnwYk9ubRf+9MrEQpFa6A6fdeoS8BCiK7Az9UYgB8Av0kplzjvDwITgK7AC1LKy53lTwFIKV+t6XktRSl+FvsZc3fMZWjoUOZNnEeQR5D7g9hKYNNbsPENffl25D1w/sPg296l7mWOMhJyEjh48iDxOfHEZ8eTlJvEiaITFdpJhxVpDyTQGkz3wI4MaB9Oe+9gAjwC8LP44Wvxxcfsg7fZGy+zF1ajFQ+jByZDNTNm9lLITYHco5BzBHKP6dd5qWeOsvyqhfbwB88g8AoCjwA0qx+ahx+ahy+axQfN4q0fJg+k2QvNbEUzWpEmC9JoQTOYkEazfhiMaMKINJhACHQ3GEmZ3UFesY2swjJyi8s4WVhGbrGNnGL9nFdsI6/YTp5zSTq/pAyHVrW4p7CYBF4WM14WA14WI54WE55mA55mE1azEU+TwMMksJoNeBgNWI1gNQusRrAYDZgNBsxGfXnbbACzAJMRjEJgNgiMBonRAEZhwCDAJMAgwIBeLgQIcDr7wGkDvLwuOJdeqLKuYfSIRCJxbguQ0vloeVoEKfU2Qhjo0/Mil8dVBmDzx+bQePTraH7ee5ybR3VmzpT+eJjPvTJRG0psDr7fdYwP1ieSnFVEv45+zL64F5f1V4agonXQ5EvALhAGHC13n+Isq6p8VCPK1aAsS1zG3B1zubTLpbw6/lWsRqv7g6TFwP/ugsxDMOAauOyf4O/60jGAxWihf3B/+gf3P11WVGbn080H+Gz7TrJtaYQGFtCjkx0f73xySrNILd5HzKHfsWlVz5KVRyAwG8yYjWaMwqgbhAgMwnDaMBTOP/QSCR4gPXzQ2vVESg0pHTg0O1JqOKTDeZZoaGhkoGkZUIx+NDYeziNAP7mCDch1HqdxOA+F23hokj96xjS1GIp6otTu4KEvd7Nm/wmentyXWRf0aLBneZiN3DyqMzeMCOenvam8vTaB+7/YyYBOfjx2WW8m9glVS8OKVklzMgCr+hcmz1Fe9SBCzAJmAXTu3Ll+JGsgNqdu5vlNzzOq4yj+Nf5fmN1d0pQSdnwCK57WHThu/Q56XlJnucrsGou3JfPuukQyC0oZ27MPsy6YzAW9QiopQiklhbZCskuzyS/LJ68sj0JbIUW2IopsRZQ4Sih1lFLmKNND2Dj0EDZ2za4bb06vZSlPzfU4jUEhEAiEEBjQjUSDMGAURoQQFc8IjAbj6XZGYURIDaNmx+CwIRw2jE6HFqOmIbQyhObAoDkQmh2haQjpcB4SoelnTt1LCWgI5+yTQOpRcs58C5y+q/D9CP0QzmshKrY7fS+QAn3mllNngQZIKXBIiePUWQNNChzoZfqsmMAhQTt1AJrmPEuJhnDOlOl9T82eaU7JT8+mnb4XznA84tT/5NOzcKc/cbnPWd2fRiEq1ooK5RVa6gFJq/gKRbnz6eFOvzCcwWhoTqpMURc0TfKXxbrx9+K0Adx+ftdGea7JaODqoeFcNbgTP0Sn8tbaQ9y9cAfDOgfw+GV9GNMzpFHkUCgai+akNVOAiHL34UAqYKmmvEqklB8CH4K+LFL/YtYPR/OO8rff/ka3gG68OeFN940/hx2iHoed/4Wel8L0+foeuTqy7mA6L/4UR1JmIaO7B/HBbcMY3qX6JWkhBD4WH3wsPnV+tkKhUPxr5QFWxZ1gzpT+jWb8lcdkNHDd8HCmRXbi2x0pvPNrPDd/vI0xPYJ57LLe59SHCkVLwuXd6EKIC4QQ64UQsUKIxUKIWnopVMsy4HahMxrIlVIeR3f66CWE6CaEsAA3Odu2WByag2c2PYMBA+9d9B6+Fjc3NZcWwFc368bfuEfh5m/qbPyl55Uwa9EO7vrvHwjgv3eNZMm9o5WyUyjK0Qh6sE3z7Y6jfPD7YW4Z1Zm7xnZtUlnMRgM3j+rMuscnMGdKfw6dyOfa+Vu449Pt7Dma06SyKRT1gTszgJ8CDwDRwHBgnhBinpSycnqHKhBCLEF36ggRQqQAzwNmACnlAiAK3QM4AT0MzF3OOrsQ4mFgJXoYmE+llLFuyN3s+CzuM3an7+aVca/Q0aeje51LC+CLayFlO1z5BoycWSdZpJT8EH2MF5bFUWJz8H9X9GXmuG5YTMpTVaGogjrpQUX1xKbm8szSGMb2DOaFqQOazb47D7ORu8d146bzIli0JZkFvycy7b1NTOzTjtmX9CYyIqCpRVQoaoXLXsBCiK1SytHl7n2ArVV59DYX3PWMa4x0XMX2YuKy4giwBtAjoId76bhm/xVOxOoZN9r1Be+QOqXjcmiSLtMeYWOGhU65sWh7f6rkZedOOq7apIL77bffAJg7dy4///xzhTpPT0+WL18OwEsvvaRSwZ2FSgVX+1RwtfUCbq56sDnqurM51+9Nk5LC/lMxhg/hPxf58/xTT1TqXy+/t+5d+Om7r3j97fcqpr1E8PmbzxPRuTNfR61n/qJvzgTEd3Lq97bgo094/b0POZ5bgt2h4e9pJizAkw2/rsLb21vpOqXrKtXXp65buHDh6d+Sq9TaC1gIsQjYBWwUQswBXpFS2tHD+pa4JYWC5LxkjMJIF78u7nV02CB9v9P46wPedduQXFhmJ/5EAUkH03lqxsWE5TmYtz+qTmMqFK0VpQcbliMniyjOLuGbR4fgX3Ss7gNKCafSXpYV6mkvP74MvHP0tJepVaS9/Oa2ymkvhUGPN2q0wHf3QXg3PJJSCDPl0zHUSmaxgZR8O3HH87h+wRbuu7gfjqqizCsUzZAaZwCFEBcCkcAQ5zkIfZm2G/CllHJOQwtZW5pbbKzfj/7Ow78+zLOjnuXGvje63lFK+PlRfc/fVW/D8DvqJMcve4/z2LfRBHhaeHvGUM7rpvb5KdoW7s4ANnc92Nx0nTtsSsjklo+3ccf5XfjHtDpMpBbnwIFfYP8y+HOjbgACeLeD0P569iH/cD2QvIc/WH3BYNZn+qQGmk2PS1paAKV5UJytB7EvyoSCdCg4occlLam4/08KA0XWUBJtQcSXBZFr7kDn7n0ZPmQwgZ166s801SK8l0JRT9R6BlBK+Tvwe7mBjEB/dEU4pD6FbM3YNTtv7nyTrn5duab3Ne513v7hGYePOhh/UkrmrYnnrbXxDO8SyIJbh9POVykmhaIm6ksP1iUlZmuk1O7g2R9i6BrsxZOT+tVukJQdsPV9iFumG3EBnWHwjdDtAj0Dkm+H+hW6rFA3BHOPQs5RRO5RvHOOMijnCL0yD2Mt2owhQdNfD5xIn/YI/3DdGPQLd2Y56gi+nXT5fDuA2bN+5VQoasCVJeDz0fe46FHQpHQA+5zHFw0rXuvhx4QfScxNZN6EeZgNboR8SVwHK56EPlfCRbWfZLA7NJ76fh/f7kzhuuHhvHz1wIop2xQKRbXUox5cCLwLLKqmfhLQy3mMAubTigLfn80nG5NIyixk4V0j8bS4qY/+3ARrX4SjW8HqpzvEDboBwoZVFWyy/rB4Q0gv/SiHADwBHDZSkhP5/Y8dxB/aj3/JcboUZDNQ5hOevw/P4tUIW1Hlca3+Z9Jdeofoh1fwmWxHnoHgEaDPXnr46Z/Z4t2wn7UZoGkSuyb1mKZSoslTcWMrIwCDEAhR8Wx0XjcXx6LmgitewHcA7wkhDgErgBVSyrSGFat1UeYo473o94hsF8lFnV1PV0VBBnw/C0J6wzUfgqF2nrklNgcPL97Fmv3pzL64F49c0kv9Q1Ao3KNe9KCUcr0zJWZ1TEPPly6BrUKIACFER2dIrFZFak4x76xN4NL+7ZnQJ9T1jlmJsPJpOLRCn0Gb9G+IvFlf0m0OGM2Ed+/LLd37YndobIjPZNmeVObEnaCg1I6P1cjlPTy4NNzB8MAS2pGtLy/nn4DCdH25OeMgJG/Sl6DPkWbRgaDU6oPN4k2pxQubxRObyYMykwWbyYLdaMZmMGE3GHEYTNgNBuzCgMNgwCEM2BE4BGgIHEIPPu8ApHCepcSBdAaNl2joRph0hoo/dW2XGnaHhs2hYXM4sDk0HJqG3Xk4NIlD09DkmbMmNWcge31MTp0pl/LR+dlFhe+g6jJxVr3epiL6nz15+lqc3e503P4zweYr1ZXrI8pVngpUXz57Rfm+lS9FZQGrkftsJvW+nasunFVDq5pxZQn4fgAhRF/0t9OFQgh/YB26ItzkfBtWVMMvh38hoziDl8e97LrhpWnww/36XpTbfwRr7QItF5c5mPnZH2w5nMVL0wZwWxMEVlUoWjqNqAerS4lZyQBsSVmPquLlqP1oUjJnSv+aGwNoDti2ANa+pDtmXPICjLq/WS+dmowGJvYNZWLfUEpsDjbEZ7Jmfyq/HkpiaUIOwlhMsJ+dLu3MtA8Iwz+kA17hdmyyyJlNqZCisjyKywopthdSYi+h2FFKqWajVLNhr2AE2YF85+G8tTfs5xNSN7xOTU0IwOAsO/WX7nSdAT2bkkE33ipl+Sk/7lln3aqqmAFIyMrtpfNGVGkzu/a3163UYzWMUalfPfkHDTz5Z72M43IcQCnlAeAA8KYQwhOYCFwPvAG0mqTq9Y2UkkVxi+gd2JvRHUfX3OEU2+ZDwhqYPBfau6ggz6K88ff69UO4Zlh4rcZRKBQ6jaAHXf7701KyHlXFnqM5/LL3OH+9uBcRQV41d8g/oec7T94Eva+AKW/q++iaEVJKMoszSS1MJa0wjbTCNNKL0kkvSiezOJOskiyyirPIK8uDTuDt7FcMHHDAgSwgC6RmQUgrFuGJh8kLT5MnPmY/fCwd6ODrha/FC2+LB95mD7zMHniYrFiNVixGi55v3WDGIMxIaUBqRhyaAZtdUGqD0jIotkFhqUZBiaSw2EZBiZ38ojLyCm3kFdnJLynDbgejcy5LSOfsljTgYzUR4G0hwNNKoJcFf08rAZ4m/L0t+HpY8PMw4edlxdfDjI+HGV8PCz6eZqwmI0IYnFagOJ3u8vS1WpFqElw2AIUQa4DHpJR7pJTF6IGbVdyQGtiUuomEnAT3Zv8y42HNP6DPZBh5T62eW2JzcM8i3fh744YhXD1UGX8KRV1pBD1YXUrMVsXcVQcJ9DJz7/huNTc+uh2+vk0PgTV9PgyZ0aQGQ15ZHodzDpOYk0hSbhLJeckcyT/CsYJjlDpKK7T1MHoQ6hVKiGcIPQN6MqrDKII8ggjwCCDQGoif1Q9/qz9+Fj9KSi0cydQ4lFZEQnoByVmF/JlVxLGC0mok0RECjM7vQ4IzDE3NU39CgK/VRLCPN4FeAXQItNA/3EKQt5UQHwvBPvp1sPepa4vaN97KcCcTyN/R33qTgadb456UhuCz2M9o59mOSV0nudZB0+Cn2WD2gCnzaqXoHJrkka+i2ZSgz/wp40+hqDcaWg8uAx4WQnyF7vyR29p07dbDWWyIz+TpyX3x9ajBIW7f/2Dp/eAfBrd+Bx0aN972yZKTxGTGEJsVS1xWHAdPHuR44Zn/HVajlQjfCLr5d2N82HjCfMPo5N2JDt4d6ODdAT+Ln+sv/r7QKwQu7luxuMyucSKvhMyCUnKKbGQXlVFY5qCo1E6ZXd93Z9fk6T8VJoMBs1FgMRnwtJjwNBvxsRrxtprw8zDj72nGz1M/Gw1q5q0t484S8C7gIiHEtcAKIcT3wL+db8GKKjh48iBbj29l9rDZmI0uev7u+kxf5pj6Dvi2d/uZUkqe/SGGFbFpPDelP9cOV8afQlFf1FUP1jYlZn3TVNkYpkyZwvOLVnHym9f4YksAi8sZR5WyMeQf1x0+PPwh1JdXRuYxpgMNmo3BHGTm9U9e55v/fkOBrYASux7jWyAY+/RYIrtEEnYgjOhfovEweWA1Wsl2/vdK1Cunsx49/83zlcZXmUBUJpCmygRSHe7MAJ6KUXUQPTTBP4F7hRBPSSk/rxdpWhnfHvoWq9HK9b2vd61DfhqsngNdx8PQyj9iV3jn1wSWbD/CgxN6MHOcC8srCoXCLeqiB6WUM2qol8BD9SJoM2RDfCYxx/IIC/DEcK6ZsdwUyP5TD3/Srm+FlGz1iUSSX5ZPbmkud6+8mzRzGrkHcsktzcXH4kOIZwg+Zh+8zF58OflL/Y9w0kKSrEkNIo9C0Zi4kwt4I9AdiAW2AtvQN0PPBqxSyrr7JNczTRkdv9RRykXfXMTYsLH8+4J/u9Zp6QMQ8z94cCsE93D7mT/tSeUvS3Zz9dAw3rhhiAr1olBUQx1yATdLPdhSMoHM+HArSZmFrP/7RCymaoy6Hf+Fnx+BAVfDNR/pHr/1iE2zsSV1Cyv/XMlvR38jrywPi8HCiA4jGNNpDKM7jqZXYC8MDWR0KhSNTa0zgZTjfiBWVrYY/yKE2F8n6Voh646uI68sj+k9prvW4dgu2LMYxs6ulfEXfTSHx7/dw4gugbx27SBl/CkUDYPSg7Vkz9EcthzO4pnJ/ao3/mK+19Ne9rqs3o2/Q9mH+D7+e6IOR5Fdmo2fxY8JERO4uPPFjO44Gi+zC97ICkUrwp09gDHnqL6yHmRpVfyY8CPtvdozqqMLQfylhBVP6Tkrxz/u9rPS80uYtWgH7XytfHDbcOWppVA0EEoP1p4P1ifi62HipvMiqm5wZKse+L7zaLj+s3ox/myajdV/rmbxgcXsydiD2WBmYsREpnSfwriwca7vzVYoWiFu7QGsDinl4foYp7WQXpTO5tTNzBw4E6PBBWMsdqmezuiqt/QUP25gc2g8vHg3eSU2lj44lmAfldtXoWgKlB6snj8zC1kek8YDF/ao2vM3L1UP9eIfDjctBkvdZuOKbEV8c/AbPt//OelF6XT168oTI57gqh5XEegRWKexFYrWQr0YgIqK/JT4E5rUmNpjas2NHTY9n2X7gbVy/Pj3igNsTzrJmzcOoV9H94xHhUKhaAw+2nAYs9HAnWO7Vq60lcBXt4CtCO5Ypjt+1JIiWxGLDyzms9jPyCnNYVSHUTx//vOMCxun9vQpFGfhTiBoK3At0LV8Pynli/UvVsvm58M/E9kukq7+XWtuHL0YspNgxtfgymxhOVbGpvHRhiRuP7+LivWnUDQCSg+6T26xje93HWN6ZCdCfT0qN1j5NKTughu/hNB+tXqGXbOzNGEp70e/T2ZxJuPDxnPfkPsY0m5IHaVXKFov7swA/gjkAjuBc4cmrwYhxBXAW4AR+FhK+dpZ9U8At5STrR/QTkp5UgjxJ3qSQwdgr40HX2NwOPcwCTkJPHnekzU3tpfC+v9A2Ajofblbz0nNKebv/9vLwDA/nrmydkpToVC4TZ31YFvju50pFNsc3F5VHvIDUbDjEzj/Yeg3pVbj7zqxi39u+yfx2fEMDR3KmxPeJDI0sm5CKxRtAHcMwHAp5RW1fZAQwgi8B1yKnu7oDyHEMill3Kk2Usr/AP9xtr8KeFRKebLcMBOllJm1laExWJusB/C8pPMlNTfetQhyj8LUt93K+OHQJI98HY3NofHOjGHK6UOhaDzqpAfbGpom+WJrMsM6BzAwzL9iZX4aLHsYOgyCi+e4PXZuaS7//uPfLEtcRgfvDrx+4etc2uVSFQFBoXARdwzAzUKIQVLKfbV81nlAwqmN0s5UR9OAuGrazwCW1PJZTcbq5NUMbjeY9t41ZPGwFcP6udB5DHSf6NYz3l+XwPakk7x+/RC6hXjX3EGhUNQXddWDbYpNiZkczixk3o1nzchJCT8+BGVFcO0nYHLPee23o7/xjy3/ILskm5kDZzJr8CwVxkWhcBN3DMBxwJ1CiCT0pQ+BHrh+sIv9w4Cj5e5T0HNdVkII4QVcATxcrlgCq4QQEvhASvlhNX1nAbMAOnfu7KJo9cOxgmPsP7mfvw3/W82No7+EgjS49iO3Zv9ijuXy1tp4pg7ppNK8KRSNT131YJti0ZZkgr0tTBrUoWLF3q8hYQ1M+g+06+PyeMX2Yv61/V98F/8dvQN78/7F79MvWG2BUShqgzsG4KQ6PqsqK6e6NCRXAZvOWv4dK6VMFUKEAquFEAeklOsrDagbhh+CHh2/jjK7xZrkNQBc0qWG5V+HHTa/o+/96zre5fFL7Q4e+2YPQd4WXpw2oC6iKhSK2lFXPdhmSM0pZu3+EzwwoUfFbSqFmXrc04hRMPIel8dLyE7gifVPkJiTyMyBM3ko8iEVx0+hqAPuBIJOFkIMAU5ZLBuklHvceFYKUD4CaDiQWk3bmzhr+VdKmeo8pwshlp9vPpIAACAASURBVKIvKVcyAJuSNclr6BvUlwjfagKdniLuBz3P5WUvuzX7N29NPAdP5PPfO0cS4GWpm7AKhcJt6kEPthn+tzMFTcJNI89aiVn5DJTm63FPDa6FZlmdvJpnNj6Dp8mTBZcuYEynMQ0gsULRtnA5MJIQYjbwJRDqPL4QQvzFjWf9AfQSQnQTQljQjbxlVTzHH7gQ3dvuVJm3EML31DVwGXCuiPyNTkZRBtEZ0TU7f0gJm+ZBSG/oM9nl8fem5PDB74ncOCKCiX1D6yitQqGoDfWgB9sEmib5dudRxvYMJiKo3N68w7/D3q9g3KMuhXzRpMZ70e/xt9/+Rq+AXnx71bfK+FMo6gl3loBnAqOklIUAQoh/AVuAd1zpLKW0CyEeBlaih4H5VEoZK4S431m/wNn0amDVqec4aQ8sdXp3mYDFUsoVbsje4KxP0ScjL+p80bkbJq6FtH0w7T2X335tDo3/+24fIT5Wnpmi9rsoFE1InfRgW2FrUhZHTxbz+GXl9vc57LDiSQjoAuMfq3EMm8PGs5ueJSopimk9pvHc+c9hNapMRwpFfeGOASjQY/CdwkHV+/qqRUoZBUSdVbbgrPuFwMKzyg4DzTqi56bUTbT3ak/PgJ7nbrjlPfDtCINucHnsjzYcZv/xPD64bTh+VaVRUigUjUWd9WBb4NsdKfh6mLh8QDnnj92LID0OblgE5ioCQpejoKyAR397lK3HtzJ72GxmDpypwrsoFPWMOwbgf4Ftzv13ANOBT+pfpJaHTbOxJXULl3e9/NxKKuMgJP4KFz0LJtf28CVlFjJvTTyTBnaoqEwVCkVToPRgDeQW24jad5zrR4TjYXY6fxTnwK//hC5jod+5U2TmluZy3+r7OHjyIP8c+0+m9ZzWCFIrFG0Pd5xA3hBC/A6MRX/jvUtKubvBJGtB7M3YS4GtgHFh487dcPuHYLTC8LtcGldKyZwfY7AaDfxjqvL6VSiaGqUHa+anPamU2jVuHFHO+WP9f6DoJFzx6jkd33JKcpi1ehYJOQnMmziPCyMubASJFYq2iTszgEgpd6KnQFKUY9OxTZiEiVEdqwxrqFOSC9FLYOC14B3i0rhR+9LYEJ/JC1f1J9Tv3EsmCoWicVB68Nx8vyuFPu19GRjmpxfkHoPtH0HkzdCx+p08uaW53LPqHpJyk3j7ordrfqFWKBR1okYvBCHERuc5XwiRV+7IF0LkNbyIzZ+NxzYyJHQIvhbf6hvt/hJshTBqlktjFpTaeennOAZ08uPW0V3qSVKFQlEblB50jSNZRew6ksP0oWFntsOs/zdIDS78v2r7FdmKeHDtgxzOPcw7F72jjD+FohGocQZQSjnOeT6HddN2ySzOZP/J/cweNrv6RpqmL/9GjIZOQ10a9+218aTllfD+rcMwGV2O1qNQKBoApQdd48foYwBMjeykF5w8DLu/0Le9BFb9IlvmKOORdY8QkxnDGxPeYEyYCvOiUDQG7sQB/JcrZW2NTcc2ATC209jqGyX9BtlJcN69Lo2ZmFHApxuTuHFEBMM6B9aDlAqFoj5QerB6pJT8EH2M87oFERbgqRf+9hoYzHDB49X2eXbTs2w5voUXx7zIxZ0vbkSJFYq2jTtTS5dWUdbm0yJtSt1EsEcwfYP6Vt9o50LwDIJ+V7k05su/7MfTbOSJK1zPkalQKBoFpQerIeZYHokZhVw9NEwvyDgEe7/RX3x9q45g8P6e91metJzZw2Yrb1+FopGpcQlYCPEA8CDQXQixt1yVL7CpoQRrCUgp2X58O6M6jqo+/EtBOhz4BUbdD6aag5j+djCdXw+k8/TkvoT4qKCnCkVzQOnBmvkh+hgWo4HJAzvqBRvfBJMHjK16e8xPiT+xYM8CpveczsyBMxtRUoVCAa55AS8GlgOvAk+WK8+XUp5sEKlaCEl5SWSVZHFeh/OqbxT9JWh2GH5njePZHBov/RxH12Av7hzTrf4EVSgUdUXpwXPg0CQ/7UllQp92+HuZITsZ9n4N582qMupBbGYsL2x+gZEdRjJn9BwV5FmhaAJccQLJBXKBGQ0vTsvij+N/ADCyw8iqG2ga7PxMD34a0qvG8RZvO0JiRiEf3T4Ci0k5figUzQWlB8/N9qSTpOeXnnH+2PwOCAOMqZwmObskm0d/e5Rgz2Bev/B1zEaV3UihaApqGwYmX4U/gO1p22nv1Z4I34iqG/y5Xnf+cGH2L6/Exltr4xndPYhL+oXWr6AKhaJOKD14bn7Zl4qn2chFfUMh/wTsWgSRM8A/rEI7h+bgyQ1PklmcyZsT3iTQQzm5KRRNhQoDU0uklOw4sYOxncZWv3yx+0vw8K8x9RHAB78ncrKwjGcm91fLIQpFM0PpweqxOzSW70vjon6heFlM8Pv7oNlg7COV2n607yM2p27mhfNfYECIym6kUDQlLmcCEUJcD6yQUuYLIZ4FhgEvtdU0SIk5iZwsOVn98m9JLuz/SY9+X0Pi8+O5xXy8IYlpkZ0YFO7fANIqFIr6QOnBymxLOklWYRlXDe4IpQWw8796xIPgHhXaRadHs2DPAq7sfiXX9r62iaRVtERsNhspKSmUlJQ0tSjNGg8PD8LDwzGbXdtW4U4quOeklN8KIcYBlwNzgQXAOfKftV62p20HzrH/L/YHsBfrBmANvLHqEFLC45epsC+K6lFK0H3cVYguoPTgWfy89zheFiMT+oTCrk/0l9/zH67QJr8snyc3PEkH7w48O+rZJpJU0VJJSUnB19eXrl27qhWyapBSkpWVRUpKCt26ueZE6o4B6HCerwTmSyl/FEK84KaMrYYdJ3bQybsT4b7hVTfYswRCekPY8HOOE38in+92pXD32G5EBHk1gKSK1oJSgu5RG4XoAkoPlsPu0FgRc5xL+rXHwwhsmw9hIyCiYmSEl7e9TFphGp9N+gwfi0/TCKtosZSUlCi9VwNCCIKDg8nIyHC5jzuupseEEB8ANwBRQgirm/1bDZrU+CPtj+pn/7IS4cgWGDIDavjBzl11EG+LiYcm9mwASRWtiZKSEoKDg5USdJFTCrGeZ0yVHizH5sQssotsTBncEQ6t0FO/nf9QhTZrk9fyy+FfuG/IfQxpN6SJJFW0dJTeqxl3vyN3FNcNwErgCillDhAEPOHW01oJh3MOk1Oaw4gOI6pusGeJHgJhyE3nHGf3kWxWxp7g3gu6E+htaQBJFa0NpQTdowG+L6UHy7E85jjeFiMX9G4HW94H/4gKTm/ZJdm8uPVF+gX1455B9zShpAqF4mxcNgCllEVAInC5EOJhIFRKucqdhwkhrhBCHBRCJAghnqyifoIQIlcIEe085rjatzHZlb4LgGGhwypXahrs+Rq6TwC/TtWOIaXk3ysOEuxtYeY4FfRZoWgJ1IcebC04NMmq2BNc1K89Hln7IXmjHvjZeGZn0avbXiWvLI+Xxr6E2aDi/SkUzQmXDUAhxGzgSyDUeXwhhKgc5bP6/kbgPfS8mf2BGUKI/lU03SCljHQeL7rZt1GITo8myCOo6vh/R7dC7hEYfO7Zv82JWWw5nMXDF/XE2+rOVkyFQtFU1FUPtia2O71/Jw3sAH98rKd9G3rr6frfjv7G8j+Xc9/g++gTpBzcFIrmhjtLwDOBUVLKOVLKOcBo4F43+p8HJEgpD0spy4CvAFezf9elb72zO303Q0OHVr28tPcbMHtB3yur7S+lZO6qg3Ty9+DmUZ0bUFKFouWxYsUK+vTpQ8+ePXnttdeqbde1a1cGDRpEZGQkI0ZUsx2j/qmrHmw1rIg5jofZwIQuVl3vDbwOvIIAKLIV8cq2V+gZ0JOZg1SeX0XrYMmSJURGRjJo0CCEEAwdOrTOYzalvnPHABSc8YDDee3OBpsw4Gi5+xRn2dmcL4TYI4RYLoQ4FSnU1b4IIWYJIXYIIXa44w3jKhlFGaQUpDA0tIr/8fYyiPsB+kwGa/Webr8dzGD3kRwevqgXVpOx3mVUKFoqDoeDhx56iOXLlxMXF8eSJUuIi4urtv26deuIjo5mx44djSViXfVgq0DTJCti07iwdzu89n8LtkI478wevwV7FnC88DjPjX5OLf0qWg0zZszg22+/xdfXl5kzZ/LLL7/Uabym1nfuGID/BbYJIV5whj3YCnziRv+qlKQ8634X0EVKOQR4B/jBjb56oZQfSilHSClHtGvXzg3xXGN3uh7vtUoDMGENFGfD4Buq7S+l5PXVB4kI8uT6EdWEkFEomjHLli3juuuuq1A2f/58/vrXv9Z57O3bt9OzZ0+6d++OxWLhpptu4scff6zzuPVIXfVgq2D30RxO5JUyaYBz+TdsOHTSdeKh7EMsilvENb2uYVj7KvZJKxQtlNjYWKZOncqcOXP4+OOP6dSp+n3+rtDU+s7lzWdSyjeEEL8B49ANsrvcjH6fApTfNBcOpJ71jLxy11FCiPeFECGu9G0sdqfvxmq00i+oX+XKfd+AVzD0uKja/itjTxBzLI//XDcYs7HNRo9Q1JF//BRLXGr9pqDt38mP56+qOT3XM888w5IlSyqU9ejRg+++++6c/caPH09+fn6l8rlz53LJJZcAcOzYMSIizvxTDw8PZ9u2bVWOJ4TgsssuQwjBfffdx6xZs2qUva7Ugx5ECHEF8BZgBD6WUr52Vv0E4EcgyVn0/an90M2FFTHHMRsFl3gdhMxDMH0BoL/gvrLtFXwtvjw67NEmllLRGmkq3Wez2bj99tv58MMPGT9+fI1jtgR955b3gZRyF/osXW34A+glhOgGHANuAiqkyRBCdABOSCmlEOI89BnKLCCnpr6NRXR6NANDBmI2nrWsUZIHB5frm6DPrnOiaZK31sbTLcSbq4dWuYKtUDRr9uzZg6ZpDBw4kOTkZKKionjggQew2Ww1hlzZsGFDjeNLWXliv7pxN23aRKdOnUhPT+fSSy+lb9++XHDBBa59kDpQFz1YzqHtUvQX2z+EEMuklGev+2yQUk6pm6QNg5T68u/YniH47HsfPANhwNUArEpexc4TO3lu9HMEeAQ0saQKRf2xYsUKBgwY4JLxBy1D37mTC9gDeBD9zVcCG9Ej4bsUZVVKaXeGTViJ/ub7qZQyVghxv7N+AXAd8IAQwg4UAzdJ/Ruqsq+rstcXRbYi9p/cz90D765ceTAK7CUw6Ppq+6+KO8H+43m8eeMQTGr2T1EHXJmpawiio6MZPlzPbrN69Wri4+MBiIuLY8iQIdjtdv7+978jhKBLly4VloVdeSMODw/n6NEz231TUlKqXWY5VR4aGsrVV1/N9u3bG9wArKsepJxDm3O8Uw5t1W/8aWbEHc/j6Mli/nZ+EKz7Gc67F8welNhLeH3H6/QJ7MO1vVSuX0XD0FS6b/v27UycOLFCWUvXd+7MAC4C8tH35gHMAD4Hqrd4zkJKGQVEnVW2oNz1u8C7rvZtbGIyY3BIB5GhkVVUfqcHQQ0/r3IdZ2b/uod4c9Xguu0bUCiaCk3TKCgowOFw8P333xMWFkZxcTELFy7k888/Z/78+UybNo0LL7ywUl9X3ohHjhxJfHw8SUlJhIWF8dVXX7F48eJK7QoLC9E0DV9fXwoLC1m1ahVz5sypYsR6p656sCqHtqryCJ8vhNiDvtXl8apeeIUQs4BZAJ07N140gVWxJxACLrP/CpoNht0BwMLYhRwvPM7L417GaFDObYrWha+vL1u2bOGuu+46XdbS9Z0701B9pJQzpZTrnMcsoHedJWhBnHIAqZTOqOgkJP4KA6aDoeqv9NTs318u7qlm/xQtlsmTJ3P48GEiIyO5//77iY2NZcSIEcyaNYthw4axa9cuxo4dW+vxTSYT7777Lpdffjn9+vXjhhtuYMCAM2/8kydPJjU1lRMnTjBu3DiGDBnCeeedx5VXXskVV1xRHx+xJuqqB+viDFexUwM7vFXHytg0RnQOwDvmS4gYDaF9SS9K59OYT7m0y6XVp8hUKFow9957LxkZGfTr148pU6aQm5vb4vWdOzOAu4UQo6WUWwGEEKOATXWWoAWxN3Mv3f2742/1r1ix/yfQ7DCw6mUPNfunaC20b9+e6Ojo0/dTp06tUD99+nTuu+8+goKCeOqppwgKCnL7GZMnT2by5MlV1kVFnVkE2LNnj9tj1wN11YO1doaTUmbWQe564UhWEQfS8nl3TCHsSoDxjwHwfvT72DQbjw5Xjh+K1klgYCBLly4F4Morr+TAgQMtXt+5YwCOAm4XQhxx3ncG9gsh9gFSSjm43qVrRkgp2ZexjwsjKk/1Evs9BHWHjlUsDQNr9uuzf2/coPb+KVo306ZNY9q0JovR3hjUVQ/WxRmuyVkZmwbAxMLlYPWH/tM5nHOYpQlLmdF3RtXZkRSKVsSXX35JcHAwI0eOxGAwtGh9544B2CjrK82VlPwUskuzGRQyqGJFQTokrYdxf4MqvHeklLz9azxdg72YOkTN/ikULZw66cE6OsM1OStj0xjR3oB3YhRE3gIWL+ZtnIenyZNZgxs+DI9C0dTccsst3HLLLU0tRr3gThzA5IYUpLmzJ1Offq20/y/uR5Batcu/6w6mn477p2b/FIqWTX3owbo4wzUlGfml7DySzcf990JuCQy7jd3pu1l3dB1/GfoXgjzcX/5SKBRNh7JIXGRfxj48TZ70COhRsSJ2KbTrC+37V+ojpeSttQlEBHkyXcX9UygULZg1+08gJYzJWw6hA5AdhvD2rrcJ9gjm1n63NrV4CoXCTZQB6CJ7M/YyIHgAJkO5SdP8NEjefDoI6tmsj89kz9EcHprQU2X9UCgULZqVsWlcEJCOZ8YeGHor205sZ8eJHdw7+F68zF5NLZ5CoXCTGpeAhRD5VJ13V6Bvevard6maGaWOUg5kH+C2/rdVrIhbBkjoP71SHyklb6+Np5O/B9cMUzl/FYqWTFvXg/klNjYnZLEofBuUmZGDrued9Y/Q3qs91/W+ruYBFApFs6NGA1BK6dsYgjRn9mftx67ZGRJy1v6/2KUQ2h9C+1bqs+VwFjuTs3lp2gAsJjX7p1C0ZNq6Hvz9UAaao4zhuaugzxVsyNnP3oy9PDf6OaxGa1OLp1AoaoGyTFxgX+Y+AAa1K+cBnHccjmypcvYP4N1fEwj1tXL9CBUWQaFQtGxWxp5gqlcM5pIs5JBbeC/6PcJ8wri6Z9XbXxQKRfPHnTAwCCECgV6Ax6kyKeX6+haqubE3Yy8dvDsQ6hV6pnC/c/l3QGUDcGfySTYnZvHslf3wMKuUSApFa6Kt6cFSu4N1B9L5ym8LaKFs8PIgLiuOf4z5B2ajuanFUygUtcRlA1AIcQ8wGz1yfTQwGtgCXNQwojUf9mXuY3DIWfFdY5dC6ABo16dS+7fXJhDkbeHmUY2Xn1OhUDQ8bVEPbj18EnPpSfoXbkWeN4sPYj6mo3dHrup+VVOLplAo6oA7S8CzgZFAspRyIjAUyGgQqZoRWcVZHCs4VjEAdF6qvvxbxezfnqM5/H4og3vGd8PL4tYEq0KhAFasWEGfPn3o2bMnr732WqX6gwcPEhkZefrw8/Nj3rx5jSVem9ODK2PTuM6yFYNmY2vEYPZm7GXmwJlq9k/R5liyZAmRkZEMGjQIIQRDhw6t85hNqe/csVBKpJQlQgiEEFYp5QEhROXpr1ZGbFYsAANDBp4pjFumn6vY//fOrwn4e5q5bXSXxhBPoWhVOBwOHnroIVavXk14eDgjR45k6tSp9O9/Js5mnz59TucjdjgchIWFcfXVjbYXrU3pQYcmWRV7gu89N0HgYBYcWU6oVyhX91J7/xRtjxkzZjBixAjuuOMOZs6cyYsvvlin8Zpa37kzA5gihAgAfgBWCyF+5Kwk5q2RfZn7MAgD/YPLBXqO+8G5/Nu7Qtu41DzW7D/BXWO74uuh3o4VrZNly5Zx3XUVQ3/Mnz+fv/71r3Uee/v27fTs2ZPu3btjsVi46aab+PHHH6ttv3btWnr06EGXLo32wtWm9ODuI9kEFSbQuTSeHb0nsit9F3cPvBuL0dLUoikUjU5sbCxTp05lzpw5fPzxx3TqVLf0rk2t71yaARRCCOCvUsoc4AUhxDrAH1hRL1I0Y/Zl7qNHQI8zgU5PLf9OfKZS23fXxeNjNXHXmG6NLKWizbH8SUjbV79jdhgEkyovQZzNM888w5IlSyqU9ejRg+++++6c/caPH09+fn6l8rlz53LJJZcAcOzYMSIiznjOh4eHs23btmrH/Oqrr5gxY0aNMtcHbVEProhJ4wbTBqTBxCe2VII8grim1zVNLZaiLdNEus9ms3H77bfz4YcfMn78+BqHbAn6ziUDUEophRA/AMOd97/XmwTNGCklsZmxTIyYeKawmuXf+BP5LI9J48EJPfD3UrN/itbJnj170DSNgQMHkpycTFRUFA888AA2mw3dPqqeDRs21Di+lJVjLVc3bllZGcuWLePVV191Tfg60tb0oJSSNbHH+NG8iUM9LmBj2jb+MvQveJo8m1o0haLRWbFiBQMGDHDJ+IOWoe/c2QO4VQgxUkr5R20fJoS4AngLMAIfSylfO6v+FuD/nLcFwANSyj3Ouj+BfMAB2KWUI2orh6ukFKSQU5pz1v6/H/Tgz2ct/77zawKeZiMzx3VvaLEUCpdm6hqC6Ohohg8fDsDq1auJj48HIC4ujiFDhmC32/n73/+OEIIuXbpUWBZ25Y04PDyco0ePnq5LSUmpdpll+fLlDBs2jPbt29fb53OBOuvBlkLc8Ty65m7H35LNy35eeOV5cWOfG5taLEVbp4l03/bt25k4cWKFspau79wxACcC9zsNsULOpEAafM5eToQQRuA94FIgBfhDCLFMShlXrlkScKGUMlsIMQn4EBhVXgYpZaYbMteJmMwYgDMewHmpcGQrTHiqQruE9AJ+2pvKrAu6E+St9sYoWi+aplFQUIDD4eD7778nLCyM4uJiFi5cyOeff878+fOZNm0aF154YaW+rrwRjxw5kvj4eJKSkggLC+Orr75i8eLFVbZdsmRJoy3/lqNOerAlsTImjWuN6zniE8zK7Bju6H8H/lb/phZLoWgSfH192bJlC3fdddfpspau79xxApkEdEePd3UVMMV5dpXzgAQp5WEpZRnwFTCtfAMp5WYpZbbzdit6rK0mIyYzBqvRSs/AnnpBXNXBn99fl4CHyci949Xsn6J1M3nyZA4fPkxkZCT3338/sbGxjBgxglmzZjFs2DB27drF2LFjaz2+yWTi3Xff5fLLL6dfv37ccMMNDBgwoMLzU1NTKSoqYvXq1VxzTaPvR6urHmwxbIxJ5HLjThZF9MUojNza/9amFkmhaDLuvfdeMjIy6NevH1OmTCE3N7fF6zt3ZgCPALcA3aWULwohOgMdgGQX+4cBR8vdp1Bxdu9sZgLLy91LYJUQQgIfSCk/rKqTEGIWMAugc+e6BWKOyYyhb1BfzAbnnr5TuX/LBX9Oyizkh+hjzBzXjRAflRNT0bpp37796ZAEAFOnTq1QP336dO677z6CgoJ46qmnCAoKcvsZkydPZvLkyVXWRUVFnb7Oyspye+x6oK56sEVwOKOAPllryLc6+KEsjak9plbMhKRQtDECAwNZunQpAFdeeSUHDhxo8frOHQPwfUBDf/N9EX0/3nfoQVFdoaqdjZV3QAJCiInoBuC4csVjpZSpQohQ9PALB6pKv+Q0DD8EGDFiRJXju4JdsxOXFcd1vZ3hLnKPwdGtMPHZCu3e/TUBs9HAvReo2T+FYtq0aUybNq3mhi2XuurBFkHUvuNca9zAl+27UKrZuH3A7U0tkkLRLPjyyy8JDg5m5MiRGAyGFq3v3FkCHiWlfAgoAXAu1bqz4S0FiCh3H04V8bOEEIOBj4FpUsrTJq+UMtV5TgeWoi8pNxiJOYmUOErOOIDE/aCfB5wJwJiUWcjS3SncMqoLob4eVYyiUChaGXXVgy2C3dE7GWCM51svExMiJtDdX73gKhQAt9xyC4sWLcJgcMd8ap648wlsTkcOCSCEaIf+JuwqfwC9hBDdhBAW4CZgWfkGzuWU74HbpJSHypV7CyF8T10DlwExbjzbbU45gJw2AGOX6rGCQnqebvPO2ngsJgP3T1DKUaFoI9RVDzZ7kjILiTy5nKU+PuRopdw14K6aOykUihaHOwbg2+gzb6FCiJeBjYDLAWmklHbgYWAlsB/4RkoZK4S4Xwhxv7PZHCAYeF8IES2E2OEsbw9sFELsAbYDv0gpGzT46r7MffhafOns2xlyjkDKHzDgzAbMxIwCfog+xu3nd1WzfwpF26FOerAlsHxvCtON6/ksuB2D2w1maGjd850qFIrmh8t7AKWUXwohdgIXo+/nmy6l3O/Ow6SUUUDUWWULyl3fA9xTRb/DwBB3nlVXYjJjGBSiJ3wmtvLy79tr47GajMxSe/8UijZDfejB5s6x3SuJ8y4mVfjwxIC7agzwrVAoWiYuzwAKIf4lpTwgpXxPSvmulHK/EOJfDSlcU1FsLyYhJ6Hc8u/30GkoBOkp3g6dyGfZnlRuH9NFef4qFG2I1q4Hk7MKGZETxX8DAonwCa+YBUmhULQq3FkCvrSKskn1JUhz4sDJAzikQw8AnZUIqbsrLP/OXXkQH4uJ+y/o0YRSKhSKJqBV68HVuw7R0XMPsVYTtw24HaPB2NQiKRSKBqLGJWAhxAPAg0B3IcTeclW+wOaGEqwp2ZehJ5oeGDIQtn0CCBh4LQC7j2SzKu4Ej13am0CV9UOhaBO0FT1YuOtblgR44W/2ZlqPlhveQqFQ1IwrewAXowdkfhV4slx5vpTyZINI1cTEZMbQ0bsjIR7BsO9b6DoO/MMA+M/Kg4T4WLh7XLcmllKhUDQirV4PHkjLo09ZFJ94eXFP35vxMns1tUgKhaIBqdEAlFLmArnADCFEINAL8AAQQlBVMOaWzr7Mffrs3/E9kBUPYx4GYGN8JpsTs3j+qv54gWaINwAAIABJREFUW92Joa1QKFoybUEPbt74G6kBOZiEPzf3u7mpxVEoFA2MO04g9wDr0cO4/MN5fqFhxGo6skuySSlI0Q3Afd+CwQz9p+HQJK9E7ScswJObR9UtxZxCoaieFStW0KdPH3r27Mlrr71Wbbu7776b0NBQBg4c2GiytVY9qGkSw4FF/ODjw1XdJhHiGdLUIikUzY4lS5YQGRnJoEF6hJChQ+seIqkp9Ngp3HECmY2e7ihZSjkRGApkNIhUTUhsVizw/+zdd5xU9bn48c8zbXuvsI2yS5e6iCL2ChY0lmg0hlwjGk1iyk30XlPUxF+SG2PKTdQQY4zGllwbxhYTGxZA2tJhqbsLC2zvZcr398cZYIEFFubszu7s83695jUzp3znObvswzPnfL/fA6ekjoO1L0LRRRCTwosrKlhf2cg9s8cQ5dKO0Ur1Br/fz5133smbb77J+vXree6551i/fn23286bN4+33urV6UC7E5F5cNmW3dTFraDDIdw88dZwh6NUv3TDDTfw97//nYSEBG655RZef/31kNsMUx4DTqwAbDfGtAOISJQxZiMwunfCCp811WsQhHEtjdBUCadcQ2unj4fe3sSU/GQumzgk3CEqFVYLFy7kmmuuOWTZo48+yje+8Y2Q2166dCmFhYWMGDECj8fD9ddfz6uvvtrttmedddZJ3Xw9RBGZBzcvepqXk6KZlTyekck6u4FS3Vm3bh1XXHEFP/zhD3n88ccZOnRoyG2GKY8BJzARNFAhIsnAK8A7IlIH7OqdsMJnbfVaRiaPJG7tSxCVCKMu4Q8fbGNfUweP3jRNJ0VV/cLPl/6cjbUbbW1zTOoY7j717uNud++99/Lcc88dsmzkyJG8+OKLx9zvzDPPpKmp6YjlDz30EBdccAEAu3btIi/v4C3Dc3NzWbJkSU/C7ysRlwfbvX4q6/+PunQn/3Hqd8IdjlLHFK7c5/V6ufnmm1mwYAFnnnnmcdvsSb4LtxO5E8j+22DcJyLvAUlEwDffrowxrKlaw9lDZ8KHT8Kk6ylvhj98uJVLJw5hWkFKuENUKqxKSkoIBAJMmDCBnTt38sYbb/DVr34Vr9d73C9HixYtOm77xpgjlvWnL12RmAcXffwBHyQ1U+TMoji7ONzhKNUvvfXWW4wfP75HxR/0LN+F20kNZTXGfAAgImXAL2yNKIzKmsqo66hjUocXfG0w5Yvc/9o6HCLcO2dsuMNT6oCenKnrDatWrWLatGkAvPPOO5SWlgKwfv16Jk2ahM/n43vf+x4iQkFBwSGXhXvyjTg3N5fy8vID6yoqKmy5zNIbIiUPlpT8kp3Jbv6n+Ov9qthWqjvhyn1Lly7l3HMPvTNOqPku3EKdyySissXqKmt+10k7l0PGGN5pyOFfG5bz33PGMDQ5JszRKRV+gUCA5uZm/H4/L730Ejk5ObS1tfHkk0/y9NNP8+ijjzJ37lzOPvvsI/btyTfi6dOnU1payvbt28nJyeH555/n2Wef7Y1DsdOAzYPbyitYGr2VrEAcF4266vg7KDVIJSQk8Omnn/LlL3/5wLJQ8124ncggkO4ceb1mACupKiHOFcOIipV0TvwC9722ntFZCXz5DJ30WSmAOXPmsG3bNiZPnsztt9/OunXrKC4uZv78+UydOpUVK1ZwxhlnnHT7LpeL3/3ud1x88cWMHTuW6667jvHjxx/y+bt37wasEXmnn346mzZtIjc3lz/96U8hH99JGrB58M13HmRDtJsvFl2vt31T6hhuvfVWqqqqGDt2LJdddhkNDQ0h5zsIbx7rya3gmug+wQkQUafFSqpKOMURj1OcPLxvKrvqG/nbbafjdoZaJysVGbKysli1atWB91dcccUh66+88kpuu+02UlNT+a//+q+TGt02Z84c5syZ0+26N95448Drwwei9KZIzIMdXi9LOj8kxePk+tNDH8GtVCRLSUnh5ZdfBuDSSy9l48aNtuS7vsxjh+vJnUAS+iKQcGv1trK5bjO3NnVQnXMev/+skXkzh3Hq8PAMz1ZqIJo7dy5z50bePWQjMQ++8tZvWRnj4AsJs4hyRoU7HKUGhGeeeYa0tDSmT5+Ow+EY0PlO72cWtK5mHQETYGJzHT+qm8XIjDjumT0m3GEppZTtTCDAmxVPEx9luOPiH4c7HKUGjBtvvJEbb7wx3GHYQgvAoJJ91mWtDJPN261FvDRvMtFu7ROjlIo8r/x7Actj/XzOPZmkuLRwh6OUCoM+7dwmIpeIyCYR2SIi93SzXkTkt8H1q0Vkak/3DVVJ2fsM6/Tyl6YL+M5FY5iYm2z3RyilVEh50C6vbF1Agt/wjUt/aXfTSqkBos8KQBFxAr8HZgPjgBtEZNxhm80GioKP+cCjJ7DvSTPGsKp6HWM6AvjGX8PtZ4+wq2mlbNXdRMnq6PrbzyuUPGiX1xc9yYoYLxe4x5OWlGVn00r1mv72t9wfnejPqC/PAJ4KbDHGbDPGdALPA4f3npwLPGUsi4FkERnSw31P2sdr3qVe/DgDo/nJtafqZKiqX4qOjqampkYTYQ8ZY6ipqSE6OjrcoXQVSh60xQsbfk+CP8DXLnvYriaV6lWa+47vZPJdX/YBzAHKu7yvAGb0YJucHu4LgIjMx/rWTH5+fo8CS452cWZ7Etde8p/a70/1W7m5uVRUVFBVVRXuUAaM6OhocnNzwx1GV6HkwcquG51Mrgv4/YyMLmKs00NmSs6JRa5UmGju65kTzXd9WQB2d1rt8HL+aNv0ZF9roTELgAUAxcXFPfq6MGHU2Twy6qOebKpU2LjdboYP10nJB7hQ8uChC04i1zmcTn50c7+/s4pSh9Dc1zv6sgCsAPK6vM8FdvdwG08P9lVKqf4ulDyolFK26cs+gJ8BRSIyXEQ8wPXAwsO2WQjcHBwFdxrQYIyp7OG+SinV34WSB5VSyjZ9dgbQGOMTka8BbwNO4AljzDoRuT24/jHgDWAOsAVoBb58rH37KnallLJDKHlQKaXsJJE8qkZEqoCdJ7BLOlDdS+H0N4PpWEGPN9Kd6PEWGGMyeiuYvqa57rj0eCObHu+xdZvvIroAPFEisswYUxzuOPrCYDpW0OONdIPteEM12H5eeryRTY/35PTpnUCUUkoppVT4aQGolFJKKTXIaAF4qAXhDqAPDaZjBT3eSDfYjjdUg+3npccb2fR4T4L2AVRKKaWUGmT0DKBSSiml1CCjBaBSSiml1CCjBSAgIpeIyCYR2SIi94Q7nt4mIjtEZI2IrBKRZeGOx24i8oSI7BORtV2WpYrIOyJSGnxOCWeMdjrK8d4nIruCv+NVIjInnDHaSUTyROQ9EdkgIutE5K7g8oj9HdtlsOU60HwXSX8LmuvszXWDvgAUESfwe2A2MA64QUTGhTeqPnGuMWZyhM6d9CRwyWHL7gH+bYwpAv4dfB8pnuTI4wX4VfB3PNkY80Yfx9SbfMB3jDFjgdOAO4N/s5H8Ow7ZIM51oPkuUv4WnkRznW25btAXgMCpwBZjzDZjTCfwPDA3zDGpEBhjPgRqD1s8F/hL8PVfgCv7NKhedJTjjVjGmEpjzIrg6yZgA5BDBP+ObaK5LgINpnynuc7eXKcFoPXDLO/yviK4LJIZ4J8islxE5oc7mD6SZYypBOuPCsgMczx94Wsisjp42SQiLgEdTkSGAVOAJQzO3/GJGIy5DjTfDYa/Bc11J0ELQJBulkX63DhnGGOmYl0KulNEzgp3QMp2jwIjgclAJfDL8IZjPxGJB14EvmmMaQx3PAPAYMx1oPku0mmuO0laAFrfgvO6vM8Fdocplj5hjNkdfN4HvIx1aSjS7RWRIQDB531hjqdXGWP2GmP8xpgA8Eci7HcsIm6shPiMMeal4OJB9Ts+CYMu14Hmu0j/W9Bcd/K/Xy0A4TOgSESGi4gHuB5YGOaYeo2IxIlIwv7XwEXA2mPvFREWAl8Kvv4S8GoYY+l1+5ND0FVE0O9YRAT4E7DBGPNwl1WD6nd8EgZVrgPNd8HXEf23oLnu5H+/eicQIDhs/NeAE3jCGPNgmEPqNSIyAutbMIALeDbSjldEngPOAdKBvcCPgFeAvwH5QBlwrTEmIjoTH+V4z8G6JGKAHcBt+/uMDHQiMgtYBKwBAsHF/43VNyYif8d2GUy5DjTfEWF/C5rrABtznRaASimllFKDjF4CVkoppZQaZLQAVEoppZQaZLQAVEoppZQaZLQAVEoppZQaZLQAVEoppZQaZLQAVEoppZQaZLQAVEoppZQaZLQAVEoppZQaZLQAVEoppZQaZLQAVEoppZQaZLQAVEoppZQaZFzhDqA3paenm2HDhoU7DKVUP7N8+fJqY0xGuOOwi+Y6pdTRHC3fRXQBOGzYMJYtWxbuMJRS/YyI7Ax3DHbSXKeUOpqj5bt+cQlYRJ4QkX0isvYo60VEfisiW0RktYhM7esYlVJKKaUiRb8oAIEngUuOsX42UBR8zAce7YOYlFJKKaUiUr8oAI0xHwK1x9hkLvCUsSwGkkVkiF2f3+5rZ131Oho6GuxqUiml+qVlG95j0YrXwh2GUirM+kUB2AM5QHmX9xXBZbbYWr+V61+/nhV7V9jVpFJK9Us/WXQXj312X7jDUEqFWUiDQEQktQebBYwx9aF8DiDdLDPdbigyH+syMfn5+T1qPCPWGhxT1VZ1ctEppSJaH+a6XpciceyTRowxiHSXWpVSg0Goo4B3Bx/HyiJOoGeV2NFVAHld3ucGP/cIxpgFwAKA4uLibovEw6VGp+IQB/ta94UYplIqQvVVrut1aVHpbPA3UrGvlrystHCHo5QKk1ALwA3GmCnH2kBEVob4GQALga+JyPPADKDBGFNpQ7sAuBwu0qLT9AygUupo+irX9brclGG01O5g7YYl5GXNCXc4SqkwCbUP4Ol2bCMizwGfAqNFpEJEbhGR20Xk9uAmbwDbgC3AH4E7Tjbgo8mIzdAzgEqpo7El1/UHhUPHA7CjXOcNVGowC+kMoDGm3aZtbjjOegPceQKhnbDMmEwqW2w7qaiUiiB25br+IDd7EqyFuroN4Q5FKRVGoQ4C+fax1htjHg6l/b6UGZtJSVVJuMNQSvVDkZTrspKGAdDeuZtAwOBw6EAQpQajUPsAJgSfRwPTsfrqAVwOfBhi230qIzaDuo46Ov2deJyecIejlOpfIirXOQwEnHVsq26hMDM+3CEppcIg1EvA9wOIyD+BqcaYpuD7+4C/hxxdH8qMzQSguq2aofFDwxyNUqo/iaRc53K4SHNE4XU3sKaiTgtApQYpuyaCzgc6u7zvBIbZ1HafyIix5gLUgSBKqWMY8LkOYEhUMjUu2Lp9W7hDUUqFSaiXgPd7GlgqIi9jTdB8FfCUTW33if1nAHUqGKXUMQz4XAeQHT+ETU0V5FSsB84OdzhKqTCwpQA0xjwoIm8CZwYXfdkYMyDmxNpv/91A9AygUupoIiHXAWQnDefDfSswNZvx+QO4nAPlrqBKKbvY+Ve/HWsuv5VAgoicZWPbvS4lKgWXw0VVq54BVEod04DOdQDZKYW0OxxkUs7mvc3hDkcpFQa2FIAi8hWskXBvA/cHn++zo+2+IiJkxmTqGUCl1FHZketE5BIR2SQiW0TknmNsN11E/CJyTSgxdyc7fggASe7drK7o97cvVkr1ArvOAN6FNTXCTmPMucAUYMCdSsuIzWBfmxaASqmjCinXiYgT+D0wGxgH3CAi446y3c+xCkzbZcdmAxDjqaGkoqE3PkIp1c/ZVQC2758FX0SijDEbsebLGlAyYzP1ErBS6lhCzXWnAluMMduMMZ3A88Dcbrb7OvAi0CvfSLPjrALQ62phQ7l+6VVqMLKrAKwQkWTgFeAdEXkV2G1T230mIyZDC0Cl1LGEmutygPKu7QWXHSAiOVijix87VkMiMl9ElonIsqqqE8tbaTFpuMTBXpeDzn2baff6T2h/pdTAF/IoYBER4BvGmHrgPhF5D0gC3gq17b6WEZtBk7eJVm8rse7YcIejlOpHbMp13d13zRz2/tfA3cYYv/WR3TPGLAAWABQXFx/exjE5xEFWdBp7XE0UmgrW7W5kWkHKiTShlBrgQj4DaIwxWN+G97//wBizMHh5Y0DJis0CrLuBKKVUVzblugogr8v7XI48g1gMPC8iO4BrgEdE5MqTi/rosuJz2eNyUeSooKRcB4IoNdjYdQl4sYhMt6mtsNG5AJVSxxFqrvsMKBKR4SLiAa7n4H2FATDGDDfGDDPGDAP+D7jDGPPKkU2FJjt+CHs80Ux079KRwEoNQnbdCeRc4DYR2Qm0YF3mMMaYiTa13ycyY/RuIEqpYwop1xljfCLyNazRvU7gCWPMOhG5Pbj+mP3+7JQdl80/HTDKuZvVOhJYqUHHrgJwtk3thJWeAVRKHUfIuc4Y8wbwxmHLui38jDHzQv28o8mOy8aHwWn2sLu6loY2L0kx7t76OKVUP2PXreB22tFOuMW744lxxWgBqJTqVqTkOoCceGvw8W6Xk0LZxZqKBmYVpYc5KqVUXwmpD6CIrLBjm/5CRHQqGKXUESIt1wHkJ+QDUOZ2M0oqKNF+gEoNKqGeARwrIquPsV6wpkkYMLListjbujfcYSil+peIy3U58Tk4xEGZJ4pT4/bybx0JrNSgEmoBOKYH2wyoGUaHxA3hsz2fhTsMpVT/EnG5zu10MyRuCGVeB+d1VPLL8nqMMRxr7kGlVOQIqQCMpP4w+2XHZbOvdR++gA+Xw64xMkqpgSwScx1Yl4HLW+vJ9++kqqmDXfVt5KboJPhKDQZ2zQMYMYbGDcVv/DoQRCkV8fIT8ynDS3x7JfG0skovAys1aGgBeJgh8UMAqGypDHMkSinVu/IS8mgMdNLgcDDWVcmqMi0AlRosQh0F/B8iEhV8PVdEbhORmfaEFh5D4qwCcHfzidzfXSkVySIx10GXkcAuF+emVOsZQKUGkVDPAN5ljOkQkfuAbwPDgR+JyCcikh1ydGGwvwDUM4BKqS4iLteBdQkYoCw6jmkxlazZ1YDXHwhzVEqpvhDqKIf9N0GfA5xujPEDiMilwCPA50Jsv89Fu6JJjU7VAlAp1VXE5TqA3IRcBKEsOZvTWrbR4QuwsbKJU3IH1Iw2SqmTEOoZwHIReRLIBGL2LzTGvI71DXlAGhI3hMpmLQCVUgdEZK6LckaRFZdFeUwiKU2bEAKsKq8Ld1hKqT4QagE4D/gAmAu8KCLfEpGLRORuDn5jHnCGxg9ld4v2AVRKHTCPCMx1YPUDLHOCo7OJiXENrNR+gEoNCiEVgMaYRmPMn40xJcC1WJeU5wH5wOdDDy88suOy2dOyB2NMuENRSvUDkZrrwBoJXO5rBuCStL06ElipQcK2mY6NMY3AL+xqL5yGxg2lzddGfUc9KdEp4Q5HKdWPRFKuAyhILKDW20STw8X06Ap+XjaGupZOUuI84Q5NKdWLdB7AbuhcgEqpwWL/VDDlmYWM9G8FYKX2A1Qq4mkB2I0DU8HoQBClVITLS8wDoCw1j+T6jTgdwvKdWgAqFem0AOzG0LihADoQRCkV8XLjcwEoj01CWvZyRrZPC0ClBgFbCkCx3CQiPwy+zxeRU+1oOxySopKIccXoJWCl1CEiLdcBxLpjyYrNYpvTen9x6j5WldfrhNBKRTi7zgA+ApwO3BB83wT83qa2+5yI6FyASqnuRFSu268opYjSzloApnnKafcG2FDZGOaolFK9ya4CcIYx5k6gHcAYUwcM6CFkQ+KH6CVgpdThIi7XgVUAbmvciTelgALvFgC9DKxUhLOrAPSKiBMwACKSAfT4+oGIXCIim0Rki4jc0836c0SkQURWBR8/tCnuoxoaN5Q9LXt6+2OUUgNLSLmuvypKLsIb8FKWOZqY6nUMTYrWAlCpCGdXAfhb4GUgS0QeBD4GftqTHYPJ9PfAbGAccIOIjOtm00XGmMnBxwM2xX1UQ+KGUNteS5uvrbc/Sik1cJx0ruvPRqWMAmBzcibUbeeMXBcrtABUKqLZMhG0MeYZEVkOnB9cdIUxZmMPdz8V2GKM2QYgIs9j3W5pvR2xnayh8dZI4MrmSkYkjwhnKEqpfiLEXNdvDU8ajlOclEZFMxu4ILGCvzcks7u+jaHJMcfdXyk18IRUAIpIE8FLIfsXdVlnjDGJPWgmByjv8r4CmNHNdqeLSAmwG/hPY8y6kwi5e9522LEI8k6F6CTAuj0SQFlTmRaASg1yNuW6fsvj9DAscRil/lZAmCylwHSW7azjCi0AlYpIod4LOMEYk9jlkdDl0dOEKN0sO/wmvCuAAmPMJOB/gVeO2pjIfBFZJiLLqqqqehbBnjXwzDVQ+s6BRQWJBQDsbNzZszaUUhHLplzXrxWlFFHauB0yx5HRsJpYj5NlO2rDHZZSqpf0h4mgK4C8Lu9zsc7yHRC8EXtz8PUbgFtE0rtrzBizwBhTbIwpzsjI6FkEOVMhNu2QAjApKomkqCTKGstO6GCUUupYejDo7UYRWR18fCIik/oirqKUInY176IlZzKOXcspzk9i6XYtAJWKVLb0ARSRb3ezuAFYboxZdZzdPwOKRGQ4sAu4HvjCYe1nA3uNMSY46aoDqAk98iCHEwovgC3vQMBvvce6R2ZZkxaASilLiLmu66C3C7G+/H4mIguNMV37PG8HzjbG1InIbGAB3XeLsVVRchEApal5TG6v56LsZr7/USd1LZ2kxA34mW6UUoex6wxgMXA7Vn++HGA+cA7wRxH53rF2NMb4gK8BbwMbgL8ZY9aJyO0icntws2uAtcE+gL8FrjfGHH6ZODRFF0FrDexeeWBRfmK+ngFUSnV10rku6MCgN2NMJ7B/0NsBxphPgvMLAizGuirS64pSggVgTDwAp0fvAOAzvQysVESyqwBMA6YaY75jjPkOVpLMAM4C5h1vZ2PMG8aYUcaYkcaYB4PLHjPGPBZ8/TtjzHhjzCRjzGnGmE9sivugkeeBOGDz2wcWFSQUUNlSSYe/w/aPU0oNSCHlOrof9JZzjO1vAd7sbsVJ9Xc+hqHxQ4l1xVLqa4SoRIa1rcfjcuhlYKUilF0FYD7Q2eW9F2vQRhswMKqn2FTIPRVKDxaAeYl5GAwVTRVhDEwp1Y+Emut6MujN2lDkXKwC8O7u1p9Uf+djcIiDwpRCSuu3QM5UnLuWMSUvmaV6BlCpiGRXAfgssFhEfiQi9wGfAM+JSBxhns/vhIy6CCpLoMm6A0hBgjUSWC8DK6WCQs11xx30BiAiE4HHgbnGGPv6Ox9HUXIRm+s2Y3KKYe86zsiPYe2uBpo7fH0VglKqj9hSABpjfgzcCtQDdcBtxpgHjDEtxpgb7fiMPlF0kfUcHA2cn5gPoANBlFKALbnuwKA3EfFgDXpb2HUDEckHXgK+aIzZbO8RHNu4tHE0djZSnj4cjJ9zEnYTMHpfYKUikS0FoIhEAaOBOCAJmNMX9+u1XdYESBgKm98CDk4Fo3MBKqUg9FzXw0FvP8Tqa/hI8N7ny2w9iGOYlGHNOFPitmZCGONbh8shLNnWZychlVJ9xJZpYIBXCU6FwEDp89cdERg9G0qeg85W8MRSkFCgl4CVUvuFnOuCc5m+cdiyx7q8/grwlRBiPGmFyYXEueMoadzK5Znj8JR/yim5M1miA0GUijh2FYC5xphLbGorvMZdAcv+BFv+BeOuID8xn+V7l4c7KqVU/xA5ua4bToeTCekTWF21GobNgpXPMHNKEn/4qIyWDh9xUXb9l6GUCje7BoF8IiKn2NRWeBXMgphU2GB1y8lPzGdPyx6dCkYpBZGU645iYvpENtdtpjXvVPC2cHHKbnwBo9PBKBVh7CoAZwHLg7c3Wi0ia0RktU1t9y2nC8bMseYD9HWQn5CPwVDeWH78fZVSkS5yct1RTM6cjN/4WZeQAsDYjtV4XA4+2lId5siUUnay63z+bJva6R/GzoWVf4Vt71OQGpwKpqmMwpTCMAemlAqzyMp13ZiYPhGAkqYdTM8ch7v8Y6YPm8XHWgAqFVHsmgZmJ9AIZAEFXR4D04izISoR1i8kL8GasksHgiilIi7XdSM5OplhicMoqSqx+gGWLWbW8CQ27mmiulm7wigVKeyaBuYrwIdYUxvcH3y+z462w8IVBaMugU2vk+SKJTU6le2N28MdlVIqzCIu1x3FxIyJrK5ajSk4A7ytnJ9kzVX9yVadDkapSGFXH8C7gOnATmPMucAUIPSbU4bT+CuhrQ62vU9hciFb6raEOyKlVPhFXq7rxqSMSdS211KRPgKAwtZVJES7+LhULwMrFSnsKgDbjTHtYE2UaozZiDVZ6sBVeAHEpEDJ8xSlFFFaX0rABMIdlVIqvCIv13Vj/4TQq5p3QuY4HDsWcfqIND7aUo0x3d66WCk1wNhVAFaISDLwCvCOiLxKN/e3HFBcUTD+c7DxdYricmnztbGraVe4o1JKhVfk5bpuFCYXkhyVzOLKxTDiHNj5CWePiGNXfRs7a1rDHZ5SygZ2DQK5yhhTb4y5D/gB8CfgSjvaDqtJ14OvjaJ6K79vru/T23IqpfqZiM11h3E6nMwcOpOPdn1EoPB88HdwftRGAD4sjbgr3koNSnadATzAGPOBMWahMabT7rb7XO50SB1BYen7AJTWlYY3HqVUvxFRua4bs3JmUdtey8bEDHDHkb33Q4alxfLexn3hDk0pZQPbC8CBaHd9G/P+vJSKusMubYjAxOuJ3fEJubHZWgAqpQaN04eeDsDHe5bCyHOh9B3OGZXBJ1traOv0hzk6pVSotAAEOnwBlu+o4/a/Lqfde1him3gdYCjCTWm9FoBKqcEhPSadsalj+WjXR1B0ITSUc+mQBjp8ARZv0+lglBrotAAEhqfH8avPT2btrkZ+8MraQ0e5pQ6HYWdSVFNOWWOZ3hNYKTVozMqZRUlVCY0FMwGY3LaEGLeT9zbpZWClBjpbbgUk8QOOAAAgAElEQVQnIt/uZnEDsNwYs8qOz+htF4zL4hvnFfLbd7cwMS+ZL57WZXL/6bdQ9MYd+GPS2Va/jbFpY8MXqFIqbCIh152IWTmz+OOaP7KkZScXZp+Ce9u/OKPwTN7duI/7rzCISLhDVEqdJLvOABYDtwM5wcd84BzgjyLyPZs+o9fddcEozh2dwf0L1x1638sxlzHKlQigl4GVGtwiItf11MSMiSS4E/h418dQdBGULebikdFU1LWxtao53OEppUJgVwGYBkw1xnzHGPMdrCSZAZwFzLPpM3qd0yH89oYpjMyI5/a/LmfLvmCCc7rJn/RFPAFDaeWy8AaplAqniMh1PeVyuDht6Gm8X/4+vsKLwPg537kSgPc26nQwSg1kdhWA+UDXqRC8QIExpg0YUJ3mEqLd/GleMVEuB//x5GcHbn7umvZlRnq9lFZ8HOYIlVJhFDG5rqfmDJ9DTXsNix1eSMojddtrjMlO4J0Ne8MdmlIqBHYVgM8Ci0XkRyJyH/AJ8JyIxAHrbfqMPpObEssfby5mX1M7X3piKU3tXkjKoSgmi82te6BTZ8JXapCKqFzXE2flnkWiJ5F/7Hgdxl8FW99l7qhoPttRS1VTRNa8Sg0Kdt0J5MfArUA9UAfcZox5wBjTYoy50Y7P6GtT8lN49KZpbNrTxK1PLaPd62f08AuocjqoWvpouMNTSoVBJOa64/E4PVw87GLeLXuX1rGXQcDHldErMAb+uX5PuMNTSp0kWwpAEYnCuiF6HJAEzBGRH9rRdjidOzqTh66dxOJttdz5zArGFV4OQMmqP4EvIif/V0odQ6TmuuO5fOTltPna+FfHHkgrJLvsHwxPj+PNNVoAKjVQ2XUJ+FVgLuADWro8Brwrp+Twkysn8O+N+/j9W224xclqfwusfiHcoSml+l7E5rpjmZwxmZz4HF7b9g+YcDWy4yOuHuXi02011LXol2GlBiJb5gEEco0xl9jUVr9zU3BOwO+/spbsMQWsSgA++hVM/gI4nOENTinVlyI61x2NiHDZiMtYsHoBe8+dR9YHP+cqz2c8FBjFOxv2cl1xXrhDVEqdILsKwE9E5BRjzBqb2ut3bjqtABF44JOhrE7Zibd2K+51L8Mp14Q7NKVU34n4XHc0cwvn8sc1f+SZqiV8O/sUhu54kZyk+3lr7R4tAE+QMYbmDh/VzZ3Ut3bS2umnpcNHwBgCBgRwOx14XA7iopzERblIjHaTEushxqMnHZQ97CoAZwHzRGQ71lQIAhhjzESb2u8XbpxRwI72s3l+x0e8G13A+f+6H9fYy8EVFe7QlFJ9Y1Dkuu7kJeRxUcFF/G3T3/jK5C+S+NZ/85UxNfx0TScNbV6SYtzhDrHfMcZQUdfGml0NrN/dyKa9TZTXtlJW20prp//4DXQj2u0gIyGKjPgospOiyU6MYUhSNEOTYxiaHE1uSizp8R69S4s6LrsKwNk2tdPv3VJ8Ds/veJDfuoq5uOFFKt/5X4bM/s9wh6WU6hsh5zoRuQT4DeAEHjfG/Oyw9RJcPwdoBeYZY1aE+rl2uOWUW3hrx1u84DHc6klgru9N7vdfw+urK/nCjPxwh9cv1LV08v7mfby/qYql22upbGgHrBsNDEuLZXh6HKeNSGNIUjTp8VGkxLmJ87iI9bhwOQWHCAFj8PkNHT4/LZ1+mtt9NLZ7qWvtpLa5k+rmDvY1dbBxTxMfbKqi5bBiMtrtIDcllryUGPJSY8lLiSUvNfg6NZbEaC3WlU0FoDFmpx3tDATZcdlkxmaSd0oyny6ZwrjFD/Nm+hxmTx8X7tCUUr0s1FwnIk7g98CFQAXwmYgsNMZ0nUNwNlAUfMwAHg0+h92Y1DHMypnFX0v/zk0TryFl5TNMTf8cL66oGNQFYEObl7fWVvLKyt0s2V5DwEB6vIcZI9KYMTyVyXnJjMpKINp9EpdvAwEIeCHgB+MHEwBjDq4XoaHdT2VjJ7vqO6ho6KC8vpOK+g7KaltZtrOOpnbfIU0mxbjJTYkhJzmGnP3PyTEMSY45UJg6HXoGMdKFVACKyEfGmFki0gSYrquwLoskhhRdPzUpYxLra9Yz5ou/JuEv51L56v38YNcPuPfSsSf3B66U6tdszHWnAluMMduC7T6PNaq4awE4F3jKGGOwJp1OFpEhxpjK0I8kdF855SvMe2seLw3P40Z/J9/NXMoN609je3ULw9Pjwh1en1q7q4GnPt3Bq6t20+ELMDw9jjvPLeSCsVmckpOEY38R1dEEdaXQtBua90HzXmiphrZaaKuH9gZrm84W8LaCtw187dbDBI4bR1LwMeaQpQJON7hdGI8Tv7jwiQuvceI1DtobnbTXO2jd6qTNOOjESS0u9uDEixPcHpxuNw6XG6fHg8vtweVx43K7cXk8uN1u3B43brcHp9uF0+nEOJwYcWJErGeHA4MD43AAElzuwIiAODEIiFh/UGKtB8EgGCH4OngsB57k4DPWZfYDbRw49P3rjvxZBUyAAAa/n+CzIRAI4DdYfTADhoAJ4A9Y/TGNCeAPABj8xvq8gDHW5xqsbQgQCH7WweXWAmMdJcHF3eh+qSDI4etEEKB49DmcUjil2/1OREgFYDAhCjDeGFMWcjQDxKSMSbyz8x382bmYqV9k3oq/MnfJLK4uq+M310+mMDMh3CEqpWxkY67LAcq7vK/gyLN73W2TAxxSAIrIfGA+QH5+3519m5Y1jWlZ03hs2yvMKTiN6dWv4JJTeWlFBd+5aHSfxREuxhg+2lLN797dwpLttcS4nXxuai6fnzaESTFVyL51sPVlWLIZardD3XZoqzuyIWcUJjaVtphkmqPiaYlLojUpk1aXh1ankzaHkzaBNqAdQzsB2o2fzv3PAT+d5uDDZ/x49z8C1rPPBPARwGsC+E0APwa/CeDD4McQwODDd2Rsx/wBYPV+1ZvAhM0tLdvDXwCC9dVXRF4GpoUczQAxKWMSACX7Sjj/wgdg89s8m/Q059WNYM5vP+I/LxrFLbNG6Cl0pSKITbmuu6Rw+CmAnmyDMWYBsACguLi4+9MIveTeGfdy3WvX8cuM4fxk52K+NWQdz66I41sXjDp41isCLd5Ww8/f2sjKsjomJzTw5yk1zIzZSdTelQSeXkddoJNqp5Nqp5PaxEzq4tOpG34K9e4oGhxOGvDTGPDS6G+nydtMs7eZgAlOJenHehyjsPI4PEQ5o4hyReFxePA4g4/ga7fDTYzThVvcuBwu3A7r2eVw4XQ4cYn12iEOnA4nTjn42L/MIQ6c4kQQnA7r2SEOBAcdvgCtnQHaOgO0dfpp9/pp7/Di8wXo6PTR6fPh8wXweX34AwH8Ph8Bv3VGLeD3Q8BgTAAMmEAA65+1QYx1rs8RfG99msERPOPlcIATQcTgcljLnA7rHJnTCS4RnAIiDlwOcIhY+4jgdFj9Krs+O2X/6/3byoFnp1hnGF0OB4I1BZLDIdazcCAmObCeA9tJ8I0VGQcG4lgnLOXAtkc6dOn+P2ZjTPCs6P6F1pqxw888kX+2R2XXIJDFIjLdGPOZTe31a+PSxhHjimFx5WLOLzgfLvsVCc/fwPszV/GtPRfz/97YyOurK3lg7gQm5SWHO1yllH1CzXUVQNc5U3KB3SexTVgVpRQxb8I8Hl/zOHOzR3Fz8wv8sn48S7bXcvrItHCHZ7st+5p5eOE7dOz6J6fHbubSnN3UmFZeq3HxuMvNXk80NXlZ+A6v0001zvY6kkwSSVFJJHmSyIjKYqQnkQRPAvHueBI8CcS544hzxxHvjifWHUuMK4ZYVyzRrmhiXDFEOaOIdkXjELvu3aCUfQXgucDtIrIDa1b8E5oaYaCNivM4PcwYMoNFuxZhjEHGzIEJ1xC3+Ff84StzWDhxMj95fQNXPvIxny/O49sXjiIzMTpc4Sql7BNSrgM+A4pEZDiwC7ge+MJh2ywEvhbsHzgDaOgv/f+6mj9xPm9tf4sHott5Ye9KrotewrNLcwd0Adjp72Rn4062NmxlR8MOtlauZGPlOqpNA81uYBgsBcBFjKSSHZtJVkIeM+KyyIzNJD0mnfSYdNKi00iNSSUtOo0ET4IWbqpfCvs0MAN1VNyZOWfyfvn7bG/czoikETD7f6DsU+SFm5l72wecN+ZsfvOvUp78ZAevrNrFvJnDue2sEaTEecIZtu2MMZgD3XRF555SkS6kaWCMMT4R+RrwNtYX3ieMMetE5Pbg+seAN7C+7G7B+sL75dBC7h0xrhjum3kf89+Zzz25w/n+vlc5c80M9l46lqx+/oXXGENVWxUbazeysXYjm+s2U1pXys7GnfjNwSlVhvh85Hf6GEsCI7MnMGL4meTkzCQnMZdET6LmOzWg2VUAlgE3AiOMMQ+ISD6QDfRkyoQBOSruzBzrGvyiikVWARiXBtc9BX+eDS9+hYQb/873LxvHF08v4FfvbOYPH27lL5/s4PpT87hl1nByU2LDFfpRBUyAPS172NG4g/LGcva27mVv615q22tp6GigqbOJVm8rbb42OgOdeANeAoeNUBMEpzgP9D9xO914nFa/FbfDbfVfcUYR5fQQJU6icAQfQhQGjxGijMGDwW0MHgNuEwg+G9yAyxhcxvrH60JwBfuMOMHqOyKCEwcOcRx4L+IM9tFwdHk4rRFpOAkAAePEhxCwep/gBQI4CRjBj+DHQQAHfmNt40cIBLcPGCEgQsBYI9gC4giuC45o2z/aLbiNNWotOFKN4Mg3cWD18Tg4Gk6C+xz5H40cGBEmwb4l1uJgnxMJ9k85sMjqfOLo0o5IsH+LMV26oFj9XA4ZbLe/DXNofxe6tn3gaLq03eULwf6PlS6vDzuaQ54Pf921je6WCU6Kx59z5Ab2CyXXAWCMeQOryOu67LEurw1wpz3h9q4ZQ2bwvenf42dLf0ZBbCOXNy/ir4tH9bvBIPXt9aypXsOa6jWsq1nHuup11LTXHFifEzeEUY4YzvdFUVhTxjCvn73tI1kVczbnXvllJo/tX8ejlB3sKgAfAQLAecADQBPwIjC9B/vaNiquLw2JH0JhciGLdi3iS+O/ZC3MLbbOBP7jm/Cv++CiH1OQFsevr5/CHecW8tgHW3n605385ZMdnDs6ky/MyOfsURm4nOG5PFDbXsvyvctZsXcF62vWs7F2I62+1gPrneK0LmfEpJEclUxOfM6B/ikeh+dAx2IHVvzGBPB7Wwm01+Nrr8fb0UhnRxOd3hY62+rp9LXT7rcKxxbjp06EdhE6RegQocNhPXv1W7U6QdEBw2fj1/bFR4WS6yLSjWNvZEfDdp7c9AJ3mJd5YfEM7jy3MGxTYhlj2N6wnRX7VrBq3ypKqkrY0bgDsL6UjEgawRk5ZzAubRxjfMLo0veIX/8a+NpoSRnDnzqu44HWU7n67Gl8/bwindpLRSy7CsAZxpipIrISwBhTJyI9vdZp26g46NupEc7MOZOnNzxNi7eFOHdw/qtp82DPGvjktxCdCGd9F4BRWQk8fN1kvnPRaJ5dspMXPqvg3xuXkRbnYc4pQ5h9SjbTh6Xi7sVi0BjDprpNvFv2Lu+Xv8+G2g2AdSlnTOoYriy8ksKUQoYlDiM/IZ/0mHScjm6SX1s9VG+2HlWlULvVmu6gvgw6Gg/bWCAuA+IzIS4HE5+KNyqZVkciTRJHk4mhPhBNvS+KWq+Lmk43NZ1Q1Q7VnQFqO3zUdvhp9vnwCyABED+IdU7Oeh8AAogjQJQLotwOPC6IcjlwO8HjArdTcAUfbqc1+svlALfDGlXmlAAuB7gEnGJwiMEpBpeAQ8CJsc7/CTjE4DDGGnUWPL9n/ZQCOBBEAogxWDNf7T9DahBz2Dk/E2D/2bP9E1btb4/gfFPW1l3+qZuD2+5vl8Pnl+qyX9dNzSHruu5uDjt/t38zc+i+B9o44qOO+GM0h8d9yPZyxB6Ht2u9PdoXgcOOAXA47EplxxVKrotYd596D7X1O3iEJUxx/JJXS6bx+eJhffLZvoCPjbUbWb53Ocv3LmflvpXUd9QDkBKVwqSMScwtnMvE9ImMTx9PnLhh3Uuw6DHYvRI88QQmfp6/es/hR8vcFKTG8ejNk5mSn9In8SsVLnZlTW+wL19wPkfJAI4/e6XF1lFxfTk1wpm5Z/LndX+2RgPnn28tFIE5D0FnM7z7E3DHwukHr+bkJMfw3YvH8M0LRvHuxn0sLNnN35eX8/TinSREuzirKIPTRlqzxxdmxNsypUJ1WzULty7kta2vsaV+C4IwJXMKd029i+nZ0xmXNg63o5tbAxkDNVuhsgT2rIY9a2HfemjcdXAbhxuTMozOpAKa06dT78mmyplJJWmU+1Io64hlX0uAmuYOaio6qW3ppNPf/T8Nj9NBcqw7+PCQkuCmIMZNUoybxGg3iTHWDdHjo10kRLtIiHKTEO0iLspFfJSLaLdD++So3hZKrotYLoeLX1y8gPyXruNxNrFj1a1MGfF7RqWOsv2zOv2drKtZx/K9y1m2dxmr9q2ixdsCWPcrPjv3bKZlTWNK5hQKEgsO5oTWWvj0EVj6R2si5vRRMOchKgvm8o2Xt/DZjjquK87lR5ePJy6qz75QKBU2dv0r/y3wMpAlIg8C1wDf7+G+A3ZU3OTMycS541hUsehgAQjWpEVzH7Fmc3/7v62Z38//kbU8yO10cPH4bC4en01Lh49FpdW8v2kfH2yu4vU11qElRLmYkJPEhJxECjPjKcyMJz81rsc3+t5Uu4mn1j/Fm9vfxBvwMjljMj847QdcUHABqdGpR+7QWgsVn2HKl+Iv/wypXIWzowGAgLiojR3O7qgJ7Mi4lM2BHNZ1ZLOuNZmq3X7MriOb87hayIj3kR7vITsxmnFDEkmN95AeF0VqnIfUeA9pcR5SYj2kxnmI9Ti1gFP9XSi5LqI5xMFdlz9FzmPT+WV8Jde+di3Xjr6WL43/EnkJecdv4Ciq26pZU7WGkqoSVu5bydrqtXQGOgEYmTSSy0ZcxrSsaUzNnEpWXNaRDdSXWYXfiqfA2wIjz7Py88jz+GBLDd/8w0o6fQF+c/1k5k7OOek4lRpoxBh7TpKJyBjgfKzrO/82xmw4gX3nAL/m4Ki4B7uOigtOA/M74BKCo+KMMcuO125xcbFZtuy4m4Xk2+9/m+V7l/Ova/915Fk0vxfe/B4sewJGz4HPLYCoY98lxBhDeW0bi7fXUFJez9pdDWzY00Sn7+BJhiiX48D9GtPjo0iKsc6ExQbPgjX4d7K07jm2tCzBLdGMTzyfiYmXkuAcSqcvQJvXT1uHj6iWcoY2rCK/uYTC9rXk+a1ulj7jYKPJZ3VgBCVmJGsDwyg1uXTiJtbjJC3eQ3p8FBnxUaQnRAVfW8v2v0+P9xAf5dKCTvVLIrLcGFN8kvuedK7rLX2R63rKt/0j6p++kgdSR/BhYid+42dK5hTOzTuX8WnjGZUyiqSopENygz/gp6a9hr0te9nRuIPtDdsprS9lQ80G9rbuBcAlLsakjmFq1lSmZk5latZUUqKPcZl230b4+New5u/W+wnXwMyvQ/YEAgHD/767hV//ezOjsxJ45MapjMiI780fi1Jhc7R8Z0sBGCzQjhgZZ4xZGnLjIeiLpPhB+Qd87d2v8etzfm1NCn04Y6xLDm/dA4k5cPmvobCb7Y7BHzBU1LWytaqZ8to2dtW3sbu+jermDmqaO2ls99LY5qPd1BCV+SbupBKMP5rO2jPprJ0JgRjAMEz2MMOxkZnO9cxwbCQbaxRck8SzJWo8O+MnUpU0kda0icQlJJIS6yElzk1a8IxdWryHWI9eGlED38kWgIM5152IVS/9ksmrH2Bx0RdZO3Eyr297nS31Ww6sd4rzwPx4Hf4O2nxth8wo4BQn+Yn5jEsbx9jUsUzMmMjY1LFEu3owvUzFMlj0MGx63eqCM20enHYHJFtnIRvavHzrhVW8u3Efn5uSw4NXnUKMRwd6qMjV2wXgowRHxhljxopICvBPY0xYR8b1RVL0BXxc/OLFjE4ZzSMXPHL0DcsWw6tfg5pSOOVaOPseSC+0JYYOfwePr3mcP6/9MwCfH3UT1468kYSm3XgqFuOpWIy74hMczXusHeIyoOAMGDYLCmZCxthDLk8rFelCKAAHba47EX5/gDd/dj2Xed8mMPsXOGbMp7a9lo01G9lSv4X6jnoaOxsxxhDliiLGFUNmTCaZsZkUJBaQl5CH29lNv+SjMQa2/Ns647djEUQnw4zb4NTbrCm6gjbtaeK2p5exq76NH142jptOK9CrFCriHS3f9YdRwAOay+HiysIreXzN4+xp2UN2XHb3G+afBrd/BB/+Aj79Hax9EcZfBVO/ZBVi3Y227YEllUv48eIfs7NxJ7MzivlWzAiGbF0K7/0G2mqtjeKzrUJv2CzrkT6q+0nVlFLHM2hz3YlwOh04Lv0F77xYzYVvfhfaakk9+25m5sxkZs5M+z7I1wFr/g8+/T3sWwcJQ+GiB2Hal47obvP66kq++38lxEW5eO7W0yge1k0/aKUGkf4wCnjAu6rwKhasXsArW17h9km3H31DdzSc/wPrm+mnv4PPnrAKwbgMKLrImkdw6FRIzoeYlCOLNGOgpRoaK2ip3sRDpX/j/5pLyQvAgr37OH37S9Z2qSOtPof5M6wzfakjtOBTyh6DOtediEsm5vOFTx+gde8vmPv+T6GhHC7+qTU9VqgadsHyP8Pyv0DLPsgcbw3sOOVacB1aj/sDhof+uYlH39/K1PxkHr1pWr+/U4lSfcHuUcCZXUbG/cCmtvu93IRcThtyGi+Xvsz8ifOPf9/H+Ey48AHrMvCWd2DtS7DpTVj1zMFtXDHWN1inxyreOpqsh/GzLDqK76ensdvlZF6HcGfCeKJPuwmGToac4kMueSilbDWoc92JcDiEn1w9idm/mU9Mdi4XrXoWtr5nTZM1evaJfyn1tsGmN6DkeetyrwnAqIutL9Qjzu22vbqWTr7x/EoWlVZzw6n53HfFOKJc2t9PKbCpADTGPCMiyzk4Mu7K/jAyri9dXXQ13/3wu7xX9l73g0G644mFcXOthzFQtx0qV0Pjbmuuvc5maySxMRAVj9cdy6MdO3m8ZgW5MZn85YwfMyXn9N49MKXUAZrrTkxhZgJfPbuQ+e/O4ZW5VzJ55Q/h+RusM3bFX7ZyX3xm9zsHAlaf6bLFsPlt2PYeeFutwXRn3GVd5k0ZdtTPXrurgdueXk5VUwc/+9wpXH9q794YQKmBxq5BID83xtx9vGV9rS87RvsCPq5eeDV+4+flK14+sQ7MPVDWWMbdH97N2pq1fK7oc9w9/W5i3f3vfsJKDQQhDAIZ9LnuRLV7/cz5zSLavH5eu+NU0re8BMv+ZE0wD5CYC1njwBMPrmhoq4OmSqjddvDOQom5MPoSGHs5DDvrmIPWjDE8s6SMB/6xnvQ4D4/eNI1Jecl9cKRK9U+9PQp4hTFm6mHLVhtjJobceAj6OikuqljEHf++g7un381N426ypU1jDK9te40HFz+Iy+Hivpn3cWHBhba0rdRgFUIBqLnuJKzd1cDVj37CpLxknvnKDNwOsQrAHR/B7hVQXWpd4vW1WyN4E7Kss3s506xHDweuNbV7uffltSws2c3ZozL41ecnkxqnY3TU4NYro4BF5KvAHcAIEVm9fzEQD3wcStsD0aycWcwcOpNHSx7l8pGXkxSVFFJ7DR0NPLjkQd7c/ibFWcX89MyfHn2UsVKq12iuC82EnCR+dvUpfOuFEh58fQP3XTHe6rM8dLJtn7FsRy3ffGEVu+vb+M+LRnHHOYW23EpTqUgVah/AZ4E3gZ8C93RZ3mSMqQ2x7QFHRPhO8Xe49rVreXj5w9x3+n0nPcfU0sql3PvxvVS3VvP1KV/nlgm34DzJqWKUUiHTXBeiq6bksqaikSc+3k5SjJtvXlBkyxx87V4/v/5XKQs+3EpOSgx/v/10phXoFC9KHU+oBeAooNwYcwOAiNwMXA3sFJH7BmNiHJUyinnj5/HE2icYnjiceRPmndD+zZ3N/Gr5r/jb5r9RkFjA03OeZkL6hN4JVinVU5rrbPDfc8bQ1O7lN/8upaHNyw8vGxfSWbpFpVV8/5W17Kxp5fPFeXz/srEkRNvb/1qpSBVqAfgH4AIAETkL+BnwdWAysABrioRB566pd7GreRe/XP5LsuKymD189nH3CZgAb25/k18t/xVVbVXcPO5m7px8pw70UKp/0FxnA5fTwc+vnkhijJs/fbSd8tpWfnLVBIYkxZxQO2t3NfA/b2/iw81VDE+P49lbZzBzZHovRa1UZAq1AHR2+eb7eWCBMeZF4EURWRVi2wOWQxw8OOtBqtuq+a9F/8X6mvV8ddJXuy3mvAEviyoW8VjJY2yo3cCY1DE8fM7DTMwIa59ypdShNNfZxOEQvn/pWHKSY/iftzdy4cMf8q0LR3Fdce4xz975/AHe3biPvy4p48PNVSTHurl3zli+eHoB0W7tHqPUiQq5ABQRlzHGhzUv1nwb2x7QopxR/O95/8tDyx7iyXVP8sb2N7h8xOWMTh1NSnQKFU0VlNaV8vaOt6lpr2Fo3FD+36z/x6UjLj3+RNJKqb6muc5GIsJ/zBrOBWOzuPeVNfz4H+v5xdsbuXh8NlPzU8hPjSUuykVdayd7GtpZsr2GT7fWUNfqJSsxim9dMIp5ZwwjKUYv9yp1skJNXM8BH4hINdAGLAIQkUKgIcS2B7wETwL3z7yfqwqv4uHlD/OXdX/BZ3wH1rsdbs7KPYu5I+cyK3cWbocmM6X6Kc11vSA/LZan/uNUVpbX8+Lyiv/f3v3HXlXXcRx/vgYiIigigUzMLzoSmOUPllJiwyTTtoa4WrW5zGrmkhkZf1jZZGu1tobZVjbNEGr0wxkitnIm6TQNf8E3fog/GGoqTEwbKioovPvjfL56vdzvF773x/fA+bwe29k953PPPef9vud739/PubztlqAAAAh8SURBVJ9z7+Uva7ZwW/fmPdYbd/hQPjlpLJ+aMpaZk8cweJBPks1a1fL3AEqaBowD7oyI7antQ8DwiFjVeojN29++G2vnrp1s2raJbTu2MX7EeI4adpQ/2WtWgma+B9C1rvMigpde38Fzr7zJGzvf4YhhQxg9/GDGHnZwWz4xbJajjnwPIEBErGzQ9mSr262iIYOGMGnUpLLDMLMmuNZ1niTGjBjKmBFDyw7FrPL8PrqZmZlZZtwBNDMzM8uMO4BmZmZmmWn5QyD7M0kvAc/24yGjgf92KJz9TU65gvOtuv7me2xEfKBTwQw017q9cr7V5nz71rDeVboD2F+SHunvJwMPVDnlCs636nLLt1W5PV/Ot9qcb3M8BGxmZmaWGXcAzczMzDLjDuD73VB2AAMop1zB+VZdbvm2Krfny/lWm/Ntgq8BNDMzM8uM3wE0MzMzy4w7gGZmZmaZcQcQkHSupCckbZR0ZdnxdJqkZyStldQt6cD/Bfk6khZK2ippXU3bKEl/l/RUuj2izBjbqZd850t6IR3jbkmfKTPGdpJ0jKS7JW2QtF7St1J7ZY9xu+RW68D1rkqvBde69ta67DuAkgYBvwTOA6YAX5I0pdyoBsRZEXFyRb87aRFwbl3blcCKiJgIrEjLVbGIPfMF+Fk6xidHxF8HOKZOegf4TkRMBqYBl6XXbJWPccsyrnXgeleV18IiXOvaVuuy7wACpwEbI2JTROwE/gjMKjkma0FE3Au8Utc8C1ic5hcD5w9oUB3US76VFRFbImJVmn8N2AAcTYWPcZu41lVQTvXOta69tc4dwOLJfK5m+fnUVmUB3CnpUUmXlB3MABkbEVugeFEBY0qOZyDMkbQmDZtUYgionqQu4BTgQfI8xv2RY60D17scXguudU1wBxDUoK3q341zRkScSjEUdJmkT5QdkLXdr4DjgZOBLcCCcsNpP0nDgT8DcyPi1bLjOQDkWOvA9a7qXOua5A5gcRZ8TM3yeGBzSbEMiIjYnG63ArdSDA1V3YuSxgGk260lx9NREfFiROyKiN3Ar6nYMZZ0EEVBXBIRS1NzVse4CdnVOnC9q/prwbWu+ePrDiA8DEyUNEHSEOCLwPKSY+oYSYdKGtEzD5wDrOv7UZWwHLgozV8E3FZiLB3XUxyS2VToGEsS8BtgQ0RcU3NXVse4CVnVOnC9S/OVfi241jV/fP1LIED62Pi1wCBgYUT8qOSQOkbScRRnwQCDgd9XLV9JfwBmAKOBF4GrgWXAzcAHgf8An4+ISlxM3Eu+MyiGRAJ4BvhGzzUjBzpJ04H7gLXA7tT8PYprYyp5jNslp1oHrndU7LXgWge0sda5A2hmZmaWGQ8Bm5mZmWXGHUAzMzOzzLgDaGZmZpYZdwDNzMzMMuMOoJmZmVlm3AE0MzMzy4w7gGZmZmaZcQfQ9iApJC2oWZ4naf4Ax/B6zfwDbdjefEnzGrSPlPTNdu6rVZLGS/pCXdv1ks6QNEPS78qKzaxKXOvK5VpXLncArZEdwAWSRvf3gSq09e8qIj7ezu3VGQm8WxQ7vK99dTZwal3b6cBKim+8Xz3gEZlVk2tduVzrSuQOoDXyDnAD8O36OyRdIWldmuamti5JGyRdB6wCzpT0uKQb03pLJM2UdL+kpySdVrO9ZZIelbRe0iWNguk5Q5Z0qaTuND0t6e7UfqGkh1L79ZIGpfbvS3pC0l3ACb3k+hPg+PTYn9bsq6sfOTTcf839U3tiTcsnSvpXL7lOB64BPpe2N0HSZODJiNgFnAQcLelBSZskzeglLzPbO9c617p8RYQnT++bgNeBwyh+V/FwYB4wH5hK8ZuEhwLDgfXAKUAXxe8UTkuP76IorB+mOMl4FFgICJgFLKvZ16h0ewjFj3gf2RNDbTx18R1E8fuInwUmA7cDB6X7rgO+XBPrsJTLRmBeg1y7gHX1+9rXHHrbf90+hgEv1CwvBWb28fzfAZxYs3wF8NU0vxqYn+bPAe4r++/Fk6cDdXKtc63LeRqMWQMR8aqk3wKXA2+m5unArRGxHUDSUuBMYDnwbESsrNnE0xGxNq23HlgRESFpLUXB6XG5pNlp/hhgIvDyXsL7OfCPiLhd0hyKAviwJCiK61ZgVIr1jRTD8v4+B/uYw9m97P9dEfGGpLckjQSOA46IiLskHUpRRHcC90TEkvSQE4AnajbxaeBiSYOBI4Efp/Zuih9FN7Mmudbtcw6udRXjDqD15VqKYY6b0rL6WHd73fKOmvndNcu7SX936S39mcDHUuG4BxjaV0CSvgIcC8ypiWlxRHy3br25QPS1rX2w1xx6238DjwGTgB8AV6W2C4BbUnH/E7BE0pHAtoh4O+UxDBgZEZslfQTYGBE70+NPBf7dfHpmlrjWvce1LhO+BtB6FRGvADcDX0tN9wLnSxqWzuhmUwxPNOtw4H+pIE4CpvW1sqSpFEM0F0bE7tS8guIakjFpnVGSjk2xzpZ0iKQRFEMojbwGjGghh972X289cDGgiLg/tY0Hnkvzu9LtBGBzzePOAnquqTkJmCDpYEnDgasp/nGZWQtc6/aJa13F+B1A25sFpDPQiFglaRHwULrvxohYLamryW3fAVwqaQ3FMMDKvaw/h2K44+40BPFIRHxd0lXAnSo+kfc2cFlErExnmt3As/RSvCPi5XSx8zrgb/1NICIea7T/tM9a64HFwEdr2p6nKIzdvHcy9jgwOsVzCXAecEu67yRgCfAAxfDLD+uGosysea51fXCtqx5FtPrOsZk1I72z8AvgLeCfNdfF1K6zCji9Z5jEzOxA41q3f3IH0MzMzCwzvgbQzMzMLDPuAJqZmZllxh1AMzMzs8y4A2hmZmaWGXcAzczMzDLjDqCZmZlZZtwBNDMzM8uMO4BmZmZmmfk/vNQb7lzAucEAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -469,7 +469,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -567,7 +567,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -724,14 +724,14 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 10, "metadata": { "scrolled": true }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -835,7 +835,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -872,14 +872,14 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 12, "metadata": { "scrolled": true }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEOCAYAAACjJpHCAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAIABJREFUeJzt3XmczfX+wPHXm0aDkmyl0KirUr+EFEJRKUm4pdKuTYtuqdvj3nZSbnLdrpCryJJEixZx221RufasiRITCWVfZ+b9++N9JtOYGYezfM85834+Ht/HnOU75/t2xsz7fLb3R1QV55xz7lCVCDoA55xzyc0TiXPOuYh4InHOORcRTyTOOeci4onEOedcRDyROOeci0hgiUREqovIJBFZIiKLROT+As5pLiKbRWRe6HgyiFidc84V7rAAr50F/FVV54jIkcBsEflUVRfnO+8LVW0TQHzOOefCEFiLRFXXquqc0O2twBLg+KDicc45d2gSYoxERDKAesCMAp5uLCLzReRDETk9roE555w7oCC7tgAQkSOAsUBXVd2S7+k5wAmquk1EWgPvAbUKeI3OQGeAsmXLnnXqqafGOGrnXLLauxeWLLHbtWtDWlqw8SSK2bNnb1DVyofyvRJkrS0RSQPGAx+r6vNhnL8SaKCqGwo7p0GDBjpr1qzoBemcSyk7d8Ldd8Nf/wpnnBF0NIlDRGaraoND+d7AWiQiIsArwJLCkoiIHAusU1UVkXOwrriNcQzTOZci9uyBXbugXDkYPjzoaFJLkF1bTYAbgQUiMi/02KNADQBVHQR0AO4WkSxgJ9BRvVyxc+4gqcLtt8O8eTBjBpQuHXREqSWwRKKq0wA5wDkDgAHxicg5l6oefhhGjoQePTyJxELgg+3xsHfvXjIzM9m1a1fQoSS09PR0qlWrRpqPProU0rcv9O4N99wDjz8edDSpqVgkkszMTI488kgyMjKwoRmXn6qyceNGMjMzqVmzZtDhOBcV77wDDzwAV14J/fqB//rHRkKsI4m1Xbt2UbFiRU8iRRARKlas6K02l1IaNoQ774TXXoOSJYOOJnUVi0QCeBIJg79HLlX88ANkZ8Pxx8OgQZCeHnREqa3YJJJE0K9fP2rXrs31118faBzDhw/n3nvvDTQG52JlxQpo1Ai6dg06kuKjWIyRJIqBAwfy4YcfhjUGkZWVxWGHRf7jUVVUlRIl/DODS33r1sHFF1trxD8rxY//dYmTu+66i++//562bdvyr3/9i/bt21OnTh0aNWrEN998A0D37t3p3LkzF198MTfddBOtW7f+/bl69erRo0cPAJ544gmGDBnCtm3buPDCC6lfvz5nnHEG77//PgArV66kdu3a3HPPPdSvX5/Vq1czbNgwTj75ZM4//3ymT58ezJvgXAxt3QqtW8PPP8OECXDKKUFHVHwUyxZJ8+b7P3b11TY9cMcO+8+YX6dOdmzYAB06/PG5yZMPfM1Bgwbx0UcfMWnSJJ566inq1avHe++9x8SJE7npppuYN8/WZM6ePZtp06ZRunRpevXqxRdffEFGRgaHHXbY7wlg2rRp3HDDDaSnp/Puu+9Srlw5NmzYQKNGjWjbti0A3377LcOGDWPgwIGsXbuWbt26MXv2bI466ihatGhBvXr1wn6/nEsGN9wA8+fDBx/YILuLH2+RBGDatGnceOONAFxwwQVs3LiRzZs3A9C2bVtKh1ZMNWvWjKlTpzJt2jQuu+wytm3bxo4dO1i5ciWnnHIKqsqjjz5KnTp1uOiii/jpp59Yt24dACeccAKNGjUCYMaMGTRv3pzKlStTqlQprrnmmgD+1c7F1iOPwIgRcOmlQUdS/BTLFklRLYgyZYp+vlKl8FogRSmoykvujKmyZcv+/tjZZ5/NrFmzOPHEE2nZsiUbNmxg8ODBnHXWWQCMGjWK9evXM3v2bNLS0sjIyPh9+m7e18n7+s6lElX48kto0sQG2EOfnVyceYskAOeddx6jRo0CYPLkyVSqVIly5crtd16pUqWoXr06b775Jo0aNaJZs2b06dOHZs2aAbB582aqVKlCWloakyZN4scffyzweg0bNmTy5Mls3LiRvXv38tZbb8XuH+dcHPXsCU2bwiefBB1J8VYsWyRB6969O7fccgt16tShTJkyjBgxotBzmzVrxueff06ZMmVo1qwZmZmZvyeS66+/nssvv5wGDRpQt25dCtuHpWrVqnTv3p3GjRtTtWpV6tevT3Z2dkz+bc7Fy4AB8MQTcNNNcNFFQUdTvAW6H0ksFLQfyZIlS6hdu3ZAESUXf69cMhg1ygbX27aFsWMhCjPli71I9iPxri3nXFL54QebQdmiBbzxhieRROA/AudcUqlZE8aMsYWHXvokMXgicc4lhdmzbZ1Xs2ZWzdclDk8kzrmEt3QptGoFlSvDggVeyTfR+BiJcy6hrVoFLVta8hg3zpNIIvIWiXMuYf3yiyWRrVthyhT405+CjsgVxBOJcy5hDRgAq1fDp5/CmWcGHY0rjHdtBUBVycnJifrr+iJDl2q6dYOvv7YSKC5xeSKJk/yl3UeOHEnjxo2pX78+V111Fdu2bePDDz/k6quv/v17Jk+ezOWXXw7AJ598st/5ABkZGfTo0YOmTZvy1ltv0a9fP0477TTq1KlDx44dAdi+fTu33norZ599NvXq1fu93LxziWjnTrjtNmuJlCwJdeoEHZE7kGLXtdW1K4QqtkdN3brQt++Bz8st7d6jRw+uuOIKPvvsM8qWLctzzz3H888/z6OPPsqdd97J9u3bKVu2LG+88QbXXHMNGzZs4Jlnntnv/CeffBKA9PR0pk2bBsBxxx3HDz/8wOGHH86mTZsA6NmzJxdccAFDhw5l06ZNnHPOOVx00UX7FXZ0Lmi7d8MVV8DHH9t2DtWrBx2RC0exSyRByi3tPn78eBYvXkyTUHt9z549NG7cmMMOO4xWrVrxwQcf0KFDByZMmEDv3r2ZMmVKgefnylsWvk6dOlx//fW0b9+e9u3bA9aaGTduHH369AFg165drFq1ykuhuISydy9cey189BEMGeJrRZJJsUsk4bQcYiW3BaCqtGzZktGjR+93zjXXXMOLL75IhQoVOPvssznyyCOLPD/v6wJMmDCBqVOnMm7cOJ5++mkWLVqEqjJ27FhO8S3jXILKzoabb4Z334V+/axryyUPHyMJQKNGjZg+fTrLly8HYMeOHSxbtgyA5s2bM2fOHAYPHvx7S6Oo8/PKyclh9erVtGjRgt69e7Np0ya2bdvGJZdcQv/+/X/fB2Xu3Lnx+Gc6F7atW2HJEujVC/7yl6CjcQer2LVIEkHlypUZPnw41157Lbt37wbgmWee4eSTT6ZkyZK0adOG4cOH/15evqjz88rOzuaGG25g8+bNqCoPPPAA5cuX54knnqBr167UqVMHVSUjI4Px48fH9x/tXAFUISsLypeHr77y2lnJKrAy8iJSHXgVOBbIAV5W1RfynSPAC0BrYAfQSVXnFPW6XkY+Mv5euXhRhYcfhkWL4J13oFSpoCMq3pK1jHwW8FdVrQ00ArqIyGn5zrkUqBU6OgP/iW+IzrlYefpp6N0bTjgB0tKCjsZFIrBEoqprc1sXqroVWAIcn++0dsCrar4GyotI1TiH6pyLst69bbFhp07Qvz+IBB2Ri0RCDLaLSAZQD5iR76njgdV57meyf7JxziWR/v3h73+Hjh1tmm+JhPgr5CIR+I9QRI4AxgJdVXVL/qcL+Jb9BnVEpLOIzBKRWevXry/wOqm2pXAs+Hvk4qFJE+jcGUaO9Eq+qSLQRCIiaVgSGaWq7xRwSiaQd21rNWBN/pNU9WVVbaCqDSpXrrzfi6Snp7Nx40b/Q1kEVWXjxo2k+7QZFyMzZ9rX+vXhpZd8i9xUEtiPMjQj6xVgiao+X8hp44B7RWQM0BDYrKprD/Za1apVIzMzk8JaK86kp6dTrVq1oMNwKWjAAFsf8sYbkKecnEsRQX4maALcCCwQkdzqV48CNQBUdRDwX2zq73Js+u8th3KhtLQ0atasGXHAzrmDN3CgJZH27e1wqSewRKKq0yh4DCTvOQp0iU9EzrloGzQIunSBtm2tNeJrRVJT4IPtzrnU9N13lkTatIE33/Qkksp8uMs5FxO1asGHH8L558PhhwcdjYslb5E456Jq+HDbTwTg4os9iRQHnkicc1EzeDDceqsNsLviwxOJcy4qBg60hYatWtnAuis+PJE45yL2wgs2sH755bY5la9rLV48kTjnIqJqpeCvuALeftvHRIojn7XlnDtkmzbZplSDBtl2uV4OvnjyFolz7qCpQvfuULcu/PyzVfD1JFJ8eSJxzh0UVXj8cXjqKWjRAgqok+qKGe/acs6FTdX2EvnnP+GOO6xLy/cTcf5fwDkXtv79LYl06eJJxO3jLRLnXNhuuglycuD++317XLePf55wzhVp71549lnYudNmaHXt6knE/ZEnEudcoXbtgiuvhEcfhQkTgo7GJSrv2nLOFWjbNmjXDiZOhBdfhA4dgo7IJSpPJM65/fz2G7Rubfusv/oq3Hhj0BG5ROaJxDm3n3XrYNUqeOst+POfg47GJTpPJM653/32mw2on3oqLF8OpUsHHZGLhyFDIvt+H2x3zgGWOOrVg5497b4nkeLhuedscWkkCm2RiEj9ML5/r6ouiCwE51zQFi6Eli1tqm/r1kFH4+Ihb5WCjh1hzJhDf62iuramADOBomaM1wQyDv3yzrmgffkltGlje4hMnQqnnRZ0RC7WsrLgzjth6FC45x6rWBCrRDJTVS8o6ptFZOKhX9o5F7Rff4VLL4VjjrF91mvWDDoiF2u7dsG118J778GTT1oV50gXmBaaSA6URMI9xzmXuCpUgJEjoVEjqFIl6GhcrG3ZAu3bw6RJtqvlffdF53XDmrUlInWwLqzfz1fVd6ITgnMu3p5/3loff/4ztG0bdDQuHtavt9bnvHnw2mtw/fXRe+0DJhIRGQrUARYBOaGHFfBE4lySUYWHH4beveGGG3yNSHGxapVNpli1Ct5/Hy67LLqvH06LpJGq+vCbc0kuKws6d4Zhw+Cuu2DAgKAjcvGweDFccgls3QqffALNmkX/GuGsI/lKRDyROJfE9u614ovDhkG3bjBwIJQsGXRULta++AKaNLEPEVOmxCaJQHiJZASWTL4VkW9EZIGIfBONi4vIUBH5RUQWFvJ8cxHZLCLzQseT0biuc8XNYYfBSSdZKyQas3Rc4hs71rqzqlSxKd5nnhm7a4XTtTUUuBFYwL4xkmgZDgwAXi3inC9UtU2Ur+tcsfDTT7BpE5x+ug2wu+JhwACbkdWwIXzwAVSqFNvrhZNIVqnquFhcXFWnikhGLF7bueJuwQJbpX7kkXbbu7JSn6rtHdOrl83GGz0aypSJ/XXDSSRLReR14ANgd+6DcZz+21hE5gNrgIdUdVH+E0SkM9AZoEaNGnEKy7nENXGizcgqWxZef92TSHGwdy/cdputC+rc2faQOSxOZXnDuUxpLIFcnOexeE3/nQOcoKrbRKQ18B5QK/9Jqvoy8DJAgwYNNA5xOZewRo2CW26BWrXgww/BP1ulvq1bbeOxTz6BHj3g8cfjOw52wESiqrfEI5BCrr0lz+3/ishAEamkqhuCism5RJaTA8OHw7nnwrvvwtFHBx2Ri7Wff7Z1IfPnwyuvwK23xj+GQmdthbqLihTOOZEQkWNFLK+KyDlYvBtjeU3nklFWlg2qlyhhs3U+/tiTSHGwbJl9aFi6FMaNCyaJQNEtkodFpKhP/gLcT6hL6VCIyGigOVBJRDKBbkAagKoOAjoAd4tIFrAT6Kiq3nXlXB7bt1sRvvXrrXpvuXJBR+Ti4YsvrG5WiRJWO+ucc4KL5UBl5C8/wPd/GsnFVfXaAzw/AJse7JwrwC+/WAn42bOhXz9ISws6IhcPo0ZZ66NmTZgwwdYIBamo6r+BjY045w5s2TIrwrd2LbzzDrRrF3RELtZU4emnrTpB8+b2c0+ELkzfs925JKQKN95oZcEnTbKFZy617d5tW+KOHAk33QSDB0OpUkFHZTyROJdkcnKsX3zkSFsncOKJQUfkYu3XX+GKK6xeVhDTew/EE4lzSSInBx55xAbVX3kFTj456IhcPKxYYRUKVq6M/j4i0RLOfiSHA1ey/8ZWPWIXlnMur+3brSvr3XetBHxOjq9WLw6mT7eZWTk58NlnsaveG6lwqv++D7QDsoDteQ7nXBysWQPnn297bP/7314CvrgYMwYuvBDKl4evv07cJALhdW1VU9VWMY/EObef7GwrBf7jj7bgrI3XwU55OTnw1FM2FtK0qX2AqFgx6KiKFk4i+VJEzlDVBTGPxjn3ByVLwgsvQOXKsd1PwiWG7dvh5putOkGnTjBoEBx+eNBRHVg4iaQp0ElEfsCKNwqgqlonppE5V0ypQt++NjPr/vvhoouCjsjFw6pVthZo/nzo0wcefDCxZmYVJZxEcmnMo3DOAbBrlw2mjxgBV11lmxMlyx8Td+i++srK/u/cCePH2yytZHLAwXZV/REoj5VLuRwoH3rMORdFa9faauURI2w73DFjPIkUByNG2M/9iCMsoSRbEoEwEomI3A+MAqqEjtdE5C+xDsy54mT7dludvnCh9Y9362ZdWy51ZWfD3/5mYyFNm8KMGXDaaUFHdWjC6dq6DWioqtsBROQ54CugfywDc644KVsWnnjCkkkdH31MeVu2wHXXWcHFe+6xMbFkLrgZzmceAbLz3M8OPeaci0DuJ9KPP7b7d9zhSaQ4WLECGjeGjz6yNUEvvpjcSQTCa5EMA2aIyLuh++2BV2IXknOp77ffbA+Rjz+2elmXXBJ0RC4ePvrIfu4lSti2uBdcEHRE0RHOVrvPi8hkbBqwALeo6txYB+Zcqlq6FNq2tdpJL79sLRGX2lTh2Wet2GKdOlbqpmbNoKOKnkITiYiUU9UtIlIBWBk6cp+roKq/xj4851LLihU2DpKeDhMn2iCrS21bt9oiw3fftXGRwYOhTJmgo4quolokrwNtgNlA3u1tJXTfi1c7d5BOPNEWmt1yC9SoEXQ0Lta+/dbWhyxbBs8/D127puaU7qJ2SGwT+ppCDTDn4m/jRltk2LOnlX7v1i3oiFw8jBtnFZtLlYJPP4UWLYKOKHbCWUfyeTiPOef2N2cOnHWW/VH55pugo3HxkJNjC0rbtYNatWD27NROIlD0GEk6UAaoJCJHs2/KbznguDjE5lxSGzYM7r4bqlSBL76Ac84JOiIXa5s2WStk/HgbF/nPf6B06aCjir2ixkjuBLpiSWNOnse3AC/GMijnkt1rr8Gtt9p+EqNHW/Vel9rmzIEOHWD1aujfH7p0Sc3xkIIUNUbyAvCCiPxFVX0Vu3NhULU/HldeaWMjXbrYOhGXulRtJtZ999kHhqlTbcFhcVLoGImI5C6V+UlErsh/xCk+55LGp5/CeefB5s3WnXH//Z5EUl3u/iF33mm7WM6dW/ySCBTdtXU+MBGr+JufAu/EJCLnkkx2tu1o98wzcPrp8OuvcNRRQUflYu3bb60ra9EiG1x//PHiuwVyUV1b3UJfb4lfOM4ll59/tkVmkybZ2pABA1JvsZnb35tvwm232cLSjz+27ZCLs7DKyItIOTFDRGSOiFwcj+CcS3T33ANffw3Dh8PQoZ5EUt2ePdZlec01cMYZNsBe3JMIhFf991ZV3QJcjO1HcgvQKxoXF5GhIvKLiCws5HkRkX4islxEvhGR+tG4rnORyM62shcA/frBzJnWT+5S2w8/2BhYv362Qn3yZKhePeioEkO4ZeQBWgPDVHU+0SsjPxxoVcTzlwK1Qkdn4D9Ruq5zh+SXX6BVK7j6alt4Vq2ajYu41PbWW1C3LixZYrf//W9bse5MOIlktoh8giWSj0XkSCAnGhdX1alAUcUf2wGvqvkaKC8iVaNxbecO1pQp9sdk2jQbZC0uawSKs507rbzN1VfDqafCvHn2s3d/FE4iuQ14GDhbVXcApbDurXg4Hlid535m6LE/EJHOIjJLRGatX78+TqG54iIrC5580vaOOOII2xL1tts8kaS6xYutGsFLL9kGZNOmpVbp92g6YCJR1RygGvC4iPQBzlXVeFUNKuhXVfd7QPVlVW2gqg0q+xJiF2VbtsArr8BNN9ngqu9imNpU7efdoAGsWwcffgjPPZf8uxjG0gGXS4lIL+BsYFTooftE5FxVfSSmkZlMIO9wVjVgTRyu6xwffWQlTipUsC4N/4yS+rZsscWFY8ZYC/S116Cqd6YfUDhdW62Blqo6VFWHYoPjl8U2rN+NA24Kzd5qBGxW1bVxurYrprZvt66rSy+1HQzBk0hxMHMm1Ktng+nPPGNb4XoSCU+4BRzKs29QPGprdkVkNNAcqzCcCXQD0gBUdRDwXyyRLQd2EL+xGVdMzZ1re2ovWwaPPgqdOwcdkYu17Gzo1ctWp1etatN6fefKgxNOInkWmCsik7Axi/OAqHRrqeq1B3hegS7RuJZzB/Laa9YSqVQJPv889feQcLY25MYbYfp06NgRBg6Eo48OOqrkc8BEoqqjRWQyNk4C8HdV/TmmUTkXgNNPh7ZtbQ+JSpWCjsbFkiqMHAn33muz7157zUrd+Ey8QxPOGAlAY6wL6vzQbedSwptvwkMP2e3c/nFPIqntt9+s9XHzzXDmmTB/Plx/vSeRSIRTa2sgcBewAFgI3CkivrGVS2qbNsENN1jNpGnTYMeOoCNy8TBxok3ffucd6NnTxkMyMoKOKvmFM0ZyPvB/ofEKRGQEllScS0qffw6dOsHatdCjBzzyiO8bkup277Yy7//6l+2j/tVXtk7ERUc4vz7fAjWAH0P3qwPxWpDoXFRt3my7Fx57rFXt9T8mqW/2bOvGWrTIyp306QNlywYdVWoJZ4ykIrBERCaHBt0XA5VFZJyIjItpdM5FybJlNsB61FG20HDOHE8iqW7PHujWDRo2tM3Gxo+3iRSeRKIvnBbJkzGPwrkY2bMHnn3WFpi99BLceis0ahR0VC7WFiywkjbz5tlYWL9+Pq03lsKZ/jslHoE4F21z59quhfPn2x+T9u2DjsjFWlYW9O5tiwuPPhrefdd/7vEQ7vRf55JKv35WuXXdOnj/fVszUKFC0FG5WFq6FJo0gcces+SxaJEnkXjxROJS0imnWKmTRYtskaFLXdnZ8Pzztg5oxQp44w1bH+TrgeLHJz26lLB7t42DpKXZ3iGXXGKHS20LFsDtt8P//gft2sGgQTYjz8VXoYlERBZQwN4fWL0tVVXflcElhFmzbCxk4UK44w6bneWrlFPb7t22oPDZZ20sZPRoW1zqP/dgFNUiaRO3KJw7BNu3W+ujb1/7FDphArRuHXRULta+/NJaIUuWWMHFf/8bKlYMOqrirdBEoqo/Fvacc4ng+++hf39rhfTqBeXLBx2Ri6Vt26y0/4ABUL267VzYqlXQUTkIr9ZWIxGZKSLbRGSPiGSLyJZ4BOdcfuvWWT84wBln2ODqoEGeRFLdRx9ZdeYBA6xi78KFnkQSSTiztgYA1wLfAaWB24H+sQzKufxUYdgwqF0b7r8fVq60x6tXL/LbXJJbt87WAF16qa1Inz7dpnYfeWTQkbm8wpr+q6rLgZKqmq2qwwDf8sfFzXff2d7pt95qn0rnzfOKrakuJ8damqeealN5n3jCFpg29k0sElI40393iEgpYJ6I9AbWAl6txsXF7t3QrBns2mUlTm6/HUr46qeUNneuFVf83//gggts18JTTgk6KleUcH4lbwyddy+wHav+e2Usg3Luiy/sU+nhh9uq9CVLbP90TyKpa8sW6NrVimmuXGm7Fn72mSeRZFDkr6WIlAR6quouVd2iqk+p6oOhri7nom7VKivzft55MGaMPdayJVStGmxcLnZUbWfK2rVt/OPOO63cie9amDyKTCSqmo2VjC8Vp3hcMbVnj03hrV3bpnX27GkJxaW25ctt7c/VV0OVKrbh1MCBXqk32YQzRrISmB7ae2R77oOq+nysgnLFzxVX2ILC9u1tgeEJJwQdkYulbdvsw8Lzz0OpUvYz79LFd6pMVuH82NaEjhKAT7pzUbN6tVXkLVsWHnwQ7rnHV6anOlV4/XX4299gzRrbM6RXL++6THbh7EfyFICIlFXV7Qc637kD2bED/vlPeO45+4PSvbvNznGpbc4c+MtfrMTJWWfB22/7dN5UEc7K9sYishhYErp/pogMjHlkLuWoWnG9U0+15HH55VZs0aW29ettxl2DBrYm6JVXbGqvJ5HUEc5kyr7AJcBGAFWdD5wXy6BcanrwQbjuOqhcGaZOtX0jfCwkde3da7OwatWyqgRdu8KyZbaw1Kdxp5awhrZUdbX8cR5edmzCcalmzRooWRKOOQY6dbL6WDffbI+51KQK48ZZt+WyZTZ9u29fOO20oCNzsRLO54LVInIuoCJSSkQeItTNFSkRaSUi34rIchF5uIDnO4nIehGZFzpuj8Z1Xezt2AH/+AecfDL8/e/22Jln2qdRTyKpa+ZMaN7cZt+VKGEJ5eOPPYmkunASyV1AF+B4IBOoC9wT6YVDix1fBC4FTgOuFZGC/ru9oap1Q8eQSK/rYis72/rAa9WyvbNbtrQ6SS61rVxpCwjPOceqEPznP7Z74eWX+6LC4iCcrq1TVPX6vA+ISBNgeoTXPgdYrqrfh15zDNAOWBzh67oAPfUUPP00NGpkK9ObNQs6IhdLmzbZLoUvvGAJ47HHrEurXLmgI3PxFE6LpKCS8dEoI388sDrP/czQY/ldKSLfiMjbIuJFwxPQjBnwzTd2+667bFrnl196Ekllu3fbQPqf/mRTuTt2tBlZzzzjSaQ4KmrP9sbAuViJlAfzPFUOiEYvd0EN3vx7xH8AjFbV3SJyFzAC2G/FgYh0BjoD1KhRIwqhuXB8953tWPf227YyfexYOO44L22SyrKzrYhm9+7w44+2/qdPH6hXL+jIXJCKapGUAo7Aks2ReY4tQIcoXDsTqyScqxq2gv53qrpRVXeH7g4GzirohVT1ZVVtoKoNKleuHIXQXFF++slWoZ92mtXF6tYNhg8POioXS6r2QeGMM2ztT+U6U5hvAAATjUlEQVTK8MknVp3Xk4gras/2KcAUERkeo/3bZwK1RKQm8BPQEbgu7wkiUlVV14butiVKs8VcZF59FQYPtr1BunWDY48NOiIXK6rw6afW8pw924pqjh0Lf/6zD6K7fcLd2OqfwOlAeu6DqhpRUQtVzRKRe4GPsa6yoaq6SER6ALNUdRxwn4i0BbKAX4FOkVzTHZqNG637okED67b6y1+sT7xmzaAjc7H01VfwyCMwZYotHB0+3La99enbLr9wBttHAUuBmsBTWDXgmdG4uKr+V1VPVtWTVLVn6LEnQ0kEVX1EVU9X1TNVtYWqLo3GdV14Nm+2FkfNmlYXa/Zse/yIIzyJpLL//Q8uuwzOPdf2BenfH7791heSusKFk0gqquorwF5VnaKqtwKNYhyXC9grr1iy6NEDLr7Y1gT84x9BR+Vi6auvoFUraNjQZuI9+yysWAH33ms7VTpXmHC6tvaGvq4VkcuwAfFqsQvJBWXTJkhLs7Lu6en2ibRHD6hfP+jIXCxNm2Y/508/hUqVrPV5991wpG8a4cIUTovkGRE5Cvgr8BAwBOga06hcXK1fb4OpNWrAiy/aY9ddB+PHexJJZVOnwoUX2nqf+fNtPcjKlbag0JOIOxjh7EcyPnRzM9ACQEQ8kaSANWtsEP2ll2DnTrjqKuvaAJ+Rk6pUbcpuz542iH7ssbZL4Z13QpkyQUfnktWhbmz5IFZe3iWx226z7ozrr7fZOaeeGnRELlaysmza7nPPwdy5tnC0b1/bJ6R06aCjc8nuUHcF8M+rSWjuXJu+uTpUmKZPHyvzPWKEJ5FUtXOnFVA85RSbsr1jBwwZAt9/D/ff70nERcehJpL8pUxcglK11ecXXmjjHe+/D/Pm2XOnnw4nnhhsfC42fvvNuq8yMqwKQeXK8M47sHixtUR9FpaLpqJqbW2l4IQhgH+OSQJ791pZ73nz4PjjoXdvuOMOKF8+6MhcrKxcaes+Xn4Ztm2DSy+1/WDOO8/HvVzsFFUixedtJKFNm6wFcu21NpX38svhgQesW6NUqaCjc7GgalN4+/aF996zhNGxo82+qlMn6OhccXCog+0uwSxaBAMGWGXW7dutJXLSSbY+wKWm3btt3/sXXoA5c6BCBUseXbpANV/p5eLIE0mS++47m7o5aZItIrzuOrjvPksiLjX98gsMGgQDB8K6dVZI8aWXbCKFT+F1QfBEkoQ2bLA1IHXq2CDqunXQq5dV461YMejoXCzkdl8NGmT7v+zZA61bQ9eucNFFPv7hguWJJEmowtdf2yDq6NE242r2bBs4X7jQ/5Ckqs2brbty0CDrvjzqKGuBduliU3qdSwSeSJLA2LG2I93ChVZ595ZbrJBeLk8iqWfOHEser79uY14NGtj6j44drRaac4nEE0kCUoXp063VcfTR9qm0dGlrjXTs6HWQUtXmzTBmDAwdaqXcS5e2Ma+77rJE4lyiOtQFiS4G1q2zukenn26F9EaOtMc7dbI/LHfc4Ukk1eTkwOef20D5scda0ti+Hfr1s3GwIUM8ibjE5y2SBLB3L1xxha3/yM6GRo3sU+nVV9vzJTzdp5yVK23HweHD4ccfbezjllvsaNDAuytdcvFEEgBV20Ro3jwrX5GWZmMfDz1ku9DVrh10hC4WNm+2MiUjR9p0bRGbcfXss9C+vde9csnLE0kcLVtmfeAjR8Ly5fYp9OabbfB09Oigo3OxsGsX/Pe/MGoUTJhgiwhPPNEWit58s+0B41yy80QSY6r2yXPwYCvZDdCiBTz2GFx5pc/ASUXZ2TB5ss24GjvWWiJVqti03euus6oD3nXlUoknkhj46Sd4800rX/HQQ9ChA7RsaQPpV13l5StSUVYWfPGFJY533oG1a21ixBVXWPK44AI4zH/bXIry/9pRkpVlVVfffddWIKtC3br7/nhkZFjxRJc69uyxsY6337ZiiRs22DhHq1ZWNLNNGx/3cMWDJ5JDpArffAMrVtinzpIlbQOh9HR46im45ho4+eSgo3TRtnOn7So5diyMG2fVlo84wpLGlVda2XbvrnTFjSeSg7B3L3z5pX36fO89m8JZsSK0a2eJZOZMG0B3qSUz0wbKx4+3NR87d1ppmrZtLXlcfLF9gHCuuPJEcgBr1lhhxLQ0eOIJ2/P68MNt2uZjj9l+HyVL2rmeRFJDTo59KBg/3o7cHSUzMqwwZps20Ly57+/iXC5PJPns3WtrPD780I75820Gzvnnw4032oybli19hXmqWbPGuqxyj19+sYWgTZrYh4c2bWx9j8+2cm5/xT6R5ORYV0XZsrB0KTRsCFu2WCujaVMrz567t8fpp9vhkt+2bTBlyr7EsXixPV65srU227SxQfMKFYKN07lkEGgiEZFWwAtASWCIqvbK9/zhwKvAWcBG4BpVXRnJNVVtMeDEiXZMmmQtjX/9yxLGddfZH5KLLvKuqlSyY4eV4Z861X7mX31lrc/0dKtr1qmTtTTr1PGSNM4drMASiYiUBF4EWgKZwEwRGaeqi/Ocdhvwm6r+SUQ6As8B1xzMdbKzrduienW7f/bZto8HwHHH2afOFi3sflqazbxyyW/TJqugPHWqHbNm2RTtEiVsWvYDD1jiaNrUB8qdi1SQLZJzgOWq+j2AiIwB2gF5E0k7oHvo9tvAABERVdXCXjQry7oqpk+34+uv4ZhjrBUCNr//9tttgVitWt7nnQpycqz8zIwZdnz1lY1tqdqHg7PPtoWh550H557rLU3noi3IRHI8sDrP/UygYWHnqGqWiGwGKgIbCnvR+fNtOibYCvJWray/O7dUyV//GsV/gQvEL7/sSxozZtgMq82b7bkjj7TE0a2bJY6GDX0fc+diLchEUlBbIH9LI5xzEJHOQOf835aZaauO337b+sBd6tu6dd/4l3MuPoJMJJlA9Tz3qwFrCjknU0QOA44Cfs3/Qqr6MvAyQIMGDXTWrFmo2oLBWbP2HbNn7/vkKgI1a8IZZ/zxqFXLayLFmyr8/LPNmluyxLYUnj/fju3b7ZySJW36bd26djRsCPXre2vDuWiRCPr5g/yTOROoJSI1gZ+AjsB1+c4ZB9wMfAV0ACYWNT6SV26iqFnTCiWC9aV//z0sWGB/rBYssOODD+w5sEVmJ51k5U1OPtkSS+7XqlV9TCUSO3ZYcv/uu31JY+lSO3ITPEC5cpYsbrsNzjzTbp92mg+KO5eoJMy/y7G5uEhroC82/XeoqvYUkR7ALFUdJyLpwEigHtYS6Zg7OF+Y3BbJwdi1y/6Y5SaYZcvsWLHC9o/IdcQR8Kc/WXKqUQNOOOGPXytXLt6JZtcuq3q7apUl7B9++OPXn3/+4/nHHQennmotjbxfjzuueL+PzgVBRGar6iFt7BxoIomFQ0kkhcnOhtWrLal8992+rz/+aEdut0uu9HRLKFWr2v7bxxxT8NcKFZKnKuyePbBx4x+PdetsSvVPP9nX3Nu/5ut0LFHCpl2feKIl39yvJ51kCcNnTzmXOCJJJD4aUISSJa2+UkbGvplguVTht98soaxaZUfu7Z9/hjlz7A/uli0Fv/bhh1vhv/Ll4eij990uX95aPqVL//EoU2bf7bQ0+yOd/yhZ0r5mZ9tiu8KOnTttZfe2bTY4nXs79/6mTfuSxtatBcdfooQlxeOPtwTRtKndPu44my134omWVNPSovkTcc4lIk8kh0jEWhYVKkC9eoWft3OnJZR16yzBrFtnn9w3bbLjt9/s66+/Wlfapk3W0tm505JVrJUubYkr71G5snUzVay476hUad/tKlWsdZVbrNI5V7x5Iomx0qX3tWoOhqqNz+zcaceOHftuZ2XZ5IC8R3b2vq8lS1pLIC3NJg/k3s49cpNH2bKeDJxzkfNEkqBEbMwlPd26vpxzLlF5eTrnnHMR8UTinHMuIp5InHPORcQTiXPOuYh4InHOORcRTyTOOeci4onEOedcRDyROOeci4gnEueccxHxROKccy4inkicc85FxBOJc865iHgicc45FxFPJM455yLiicQ551xEPJE455yLiCcS55xzEfFE4pxzLiKeSJxzzkXEE4lzzrmIeCJxzjkXEU8kzjnnIuKJxDnnXEQ8kTjnnItIIIlERCqIyKci8l3o69GFnJctIvNCx7h4x+mcc+7AgmqRPAx8rqq1gM9D9wuyU1Xrho628QvPOedcuIJKJO2AEaHbI4D2AcXhnHMuQocFdN1jVHUtgKquFZEqhZyXLiKzgCygl6q+V9BJItIZ6By6u1tEFkY94uirBGwIOogweJzR5XFGVzLEmQwxApxyqN8Ys0QiIp8Bxxbw1GMH8TI1VHWNiJwITBSRBaq6Iv9Jqvoy8HLourNUtcEhBR1HHmd0eZzR5XFGTzLECBbnoX5vzBKJql5U2HMisk5EqoZaI1WBXwp5jTWhr9+LyGSgHrBfInHOORecoMZIxgE3h27fDLyf/wQROVpEDg/drgQ0ARbHLULnnHNhCSqR9AJaish3QMvQfUSkgYgMCZ1TG5glIvOBSdgYSTiJ5OVYBBwDHmd0eZzR5XFGTzLECBHEKaoazUCcc84VM76y3TnnXEQ8kTjnnItI0iYSEWklIt+KyHIR2W9lvIgcLiJvhJ6fISIZ8Y8yrDg7icj6PKVgbg8gxqEi8kth62/E9Av9G74RkfrxjjEUx4HibC4im/O8l0/GO8ZQHNVFZJKILBGRRSJyfwHnBPqehhlj4O+niKSLyP9EZH4ozqcKOCfw3/Uw4wz8dz1PLCVFZK6IjC/guYN/P1U16Q6gJDYN+ESgFDAfOC3fOfcAg0K3OwJvJGicnYABAb+f5wH1gYWFPN8a+BAQoBEwI0HjbA6MD/K9DMVRFagfun0ksKyAn3ug72mYMQb+fobenyNCt9OAGUCjfOckwu96OHEG/rueJ5YHgdcL+vkeyvuZrC2Sc4Dlqvq9qu4BxmBlV/LKW4blbeBCEZE4xgjhxRk4VZ0K/FrEKe2AV9V8DZQPrf+JqzDiTAiqulZV54RubwWWAMfnOy3Q9zTMGAMXen+2he6mhY78M4QC/10PM86EICLVgMuAIYWcctDvZ7ImkuOB1XnuZ7L/L8Hv56hqFrAZqBiX6AqIIaSgOAGuDHVvvC0i1eMT2kEJ99+RCBqHuhc+FJHTgw4m1C1QD/uEmlfCvKdFxAgJ8H6GumHmYQuXP1XVQt/LAH/Xw4kTEuN3vS/wNyCnkOcP+v1M1kRSUHbMn/3DOSfWwonhAyBDVesAn7Hvk0AiSYT3MhxzgBNU9UygP1BgbbZ4EZEjgLFAV1Xdkv/pAr4l7u/pAWJMiPdTVbNVtS5QDThHRP4v3ykJ8V6GEWfgv+si0gb4RVVnF3VaAY8V+X4mayLJBPJm82rAmsLOEZHDgKOIf7fIAeNU1Y2qujt0dzBwVpxiOxjhvN+BU9Utud0LqvpfIC1UFSHuRCQN+wM9SlXfKeCUwN/TA8WYSO9nKIZNwGSgVb6nEuF3/XeFxZkgv+tNgLYishLrar9ARF7Ld85Bv5/JmkhmArVEpKaIlMIGhPJvfJW3DEsHYKKGRo/i6IBx5usXb4v1VSeaccBNoZlGjYDNGqrenEhE5NjcvlwROQf7/70xgDgEeAVYoqrPF3JaoO9pODEmwvspIpVFpHzodmngImBpvtMC/10PJ85E+F1X1UdUtZqqZmB/jyaq6g35Tjvo9zOoMvIRUdUsEbkX+BibGTVUVReJSA9glqqOw35JRorIciybdkzQOO8TkbZYqfxfsZkdcSUio7EZOpVEJBPohg0WoqqDgP9is4yWAzuAW+IdY5hxdgDuFpEsYCfQMYAPD2Cf+m4EFoT6zAEeBWrkiTXo9zScGBPh/awKjBCRklgie1NVxyfa73qYcQb+u16YSN9PL5HinHMuIsnateWccy5BeCJxzjkXEU8kzjnnIuKJxDnnXEQ8kTjnnIuIJxLnnHMR8UTiXIiIVMxT4vtnEfkpz/1SIvJljK5bTUSuKeDxDBHZmWedR0HfWzoU354gV5274i0pFyQ6FwuquhGoCyAi3YFtqtonzynnxujSFwKnAW8U8NyKUP2mAqnqTqBuqOSFc4HwFolzYRKRbaFWwlIRGSIiC0VklIhcJCLTReS7UCmR3PNvENvsaJ6IvBRa9Zz/NZsCzwMdQufVLOL6ZUVkQqga78KCWjHOBcETiXMH70/AC0Ad4FTgOqAp8BBWZgQRqQ1cAzQJtSiygevzv5CqTsNqsrVT1bqq+kMR120FrFHVM1X1/4CPovdPcu7QedeWcwfvB1VdACAii4DPVVVFZAGQETrnQqy668xQ3cPS2D4VBTkF+DaM6y4A+ojIc9jOdl8c+j/BuejxROLcwdud53ZOnvs57PudEmCEqj5S1AuJSEWs8u/eA11UVZeJyFlYscdnReQTVe1x0NE7F2XeteVcbHyOjXtUARCRCiJyQgHn1STMfUhE5Dhgh6q+BvTB9q93LnDeInEuBlR1sYg8DnwiIiWAvUAX4Md8py7FyuIvBDqralFTjM8A/ikiOaHXuzsGoTt30LyMvHMJSmwv9fGhgfUDnbsSaKCqG2IclnP78a4t5xJXNnBUOAsSsQ2+cuIWmXN5eIvEOedcRLxF4pxzLiKeSJxzzkXEE4lzzrmIeCJxzjkXEU8kzjnnIuKJxDnnXEQ8kTjnnIuIJxLnnHMR+X953oH761mEWAAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -891,7 +891,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -924,10 +924,8 @@ "# Plot the Bode plots\n", "plt.figure()\n", "plt.subplot(1, 2, 2)\n", - "ct.bode_plot(forward_tf[0, 0], np.logspace(-1, 1, 100), color='b', linestyle='--', \n", - " initial_phase=-180)\n", - "ct.bode_plot(reverse_tf[0, 0], np.logspace(-1, 1, 100), color='b', linestyle='-',\n", - " initial_phase=-180);\n", + "ct.bode_plot(forward_tf[0, 0], np.logspace(-1, 1, 100), color='b', linestyle='--')\n", + "ct.bode_plot(reverse_tf[0, 0], np.logspace(-1, 1, 100), color='b', linestyle='-')\n", "plt.legend(('forward', 'reverse'));\n" ] }, @@ -962,12 +960,12 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1036,7 +1034,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -1054,7 +1052,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1066,7 +1064,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1106,7 +1104,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -1138,12 +1136,12 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdd1RU19rA4d+eoYOggggWREHFLoLdWKKJPSaWxBoTu4npvd3kS26uqfdqTIwaW+w9ttiiRmNX7AUVOyiKgvQ6M/v742BiDChSprGftVgww8w5LywO79nt3UJKiaIoiqJYG52lA1AURVGUvKgEpSiKolgllaAURVEUq6QSlKIoimKVVIJSFEVRrJKDpQO4Hx8fHxkYGGjpMBQlTwcPHrwlpaxg6TgeRF1HirXL71qy6gQVGBhIRESEpcNQlDwJIS5bOob7EUL0BHoGBwer60ixavldS6qLT1HslJRyjZRylJeXl6VDUZRCUQlKUeyUEKKnEGJaUlKSpUNRlEIxWxefEKIG8AHgJaXsa67zKn8npSQ2KZOzN1KIT80my2DC3VlPlXKu1KpYhjIujpYOUSkmUso1wJrw8PCRlo7FliVl5HDyWhIxtzPIMZrwLeNCiF8ZqpZ3s3Rodq9ICUoIMRPoAcRJKevf9XwXYCKgB6ZLKb+QUl4AhgshlhXlnErhnLiaxNKIaDZHxnE1MSPP1+gEhAaUo1sDf/o2qYKXm0pWtuzuMSjl4WTmGFl95BorDsew/2ICpjwqwjWo7MXQVoE8FVoZvU6YP8hSQBSlFp8Qoi2QCsy5k6CEEHrgLPAYEAMcAAZIKU/lfn9ZQVtQ4eHhUg3uFs2e8/H8b/NZ9l9MwNlBxyM1K9Am2Js6/p74ebng7KAnNSuHy/HpHI1OZMvpOE5eS8bFUcfQloGMaRdEOXcnS/8YVkkIcVBKGW7pOB5EXUcFl55tYM6ey0z74wIJadnUqOBO9wb+NA0sT3Ufdxz1OmKTMoi4dJvlh2I4fT2Fuv6eTOzfmJoVy1g6fJuV37VUpASVe+BAYO1dCaol8ImUsnPu4/cApJTjcx/fN0EJIUYBowACAgLCLl+26olSVutqYgafrjnJxpM3qOjpzKi2QQVuFZ28lsT0HRdZeeQqZV0d+bB7XXo3qYwQ6i7xbtaeoO5qQY2MioqydDhWzWSSrDh8la82nCYuJYt2tSowpl0QLWqUz/fv3mSSrDl2jc/WniIty8hXfRvSs1ElM0duH8yZoPoCXaSUI3IfDwGaAx8Dn6O1rKbfSVj3o+78Hp6UksUHovls7SlMEsY9GszwNtVxcdQ/9LFOX0/mg19OcPDybR6vW5Gv+jakrJtqTd1h7QnqDnUd3d+Jq0l8tOoEh68k0qhqWT7sXoemgeUL/P645ExeXHCIiMu3Gf9UA/o3CyjBaO1TftdSSUySyOt2Q0op44ExJXA+JVdSRg7vLDvGhpPXaVnDm6/6NizSQG6InydLR7dkxs6LfLXxNN2/28n0oeHU8fcsxqgVxTLSsgz877ezzNx1kXJuTnzTrxG9Qyuje8jxJF9PF+YOb87ouQd5d8VxXJ309GpcuYSiLl1KYpp5DFD1rsdVgGslcB7lLpGxyfSctJPNkTd4r2sI80c0L5ZZRjqdYGTbGiwd0wqDyUSfH3ezJfJGMUSslDQ1zTx/WyJv8Pj//mD6zov0bxbA1jfa0zesykMnpztcHPVMezaMZtXL89bSYxy4lFDMEZdOJZGgDgA1hRDVhRBOQH9gdQmcR8m1/ngsvSfvJjPHyOLRLRjdLqjQF1p+Glcty5pxbQj29WDU3IMsORBdrMdXip9aqPtP15MyGTvvIMN/jsDdWc/ysS35z1MNimXGqrODnmlDwqhczpUX5h/iVmpWMURcuhUpQQkhFgJ7gNpCiBghxHAppQEYB2wEIoElUsqTRQ9VuZeUkklbohg7/xAh/mVY+1IbwqoVvO/8Yfl6urBwZAtaBXnz9vJjzN51scTOpSjFKcdoYvqOC3T8dhtbT8fxVufarH3pkWK/Xsq6OfHj4CYkZeTw1tKjqB3Li6ZIY1BSygH5PL8OWFeUYyv3l20w8d6K4yw/FMNToZUZ37tBoSZCPCx3ZwemDw1n3ILDfLJGm4gxrE31Ej+vohTWzqhb/N+ak0TFpdK+dgU+faI+Ad4lt8g2xM+TD7vX4V+rTrJwfzQDm6tJE4Vl1cVilbylZOYwdt4hdp67xaudavJKx5pmnQLu7KBn8qAmvLzwMJ+uPYWTg47BLaqZ7fyKUhBnrqfw5YbTbD0dR9Xyrvz0bDid6via5VoZ0qIa649fZ/z6SDrV9cW3jEuJn9MeqVp8NuZGciZPT93L3gvxfNOvEa92qmWR9UmOeh0T+4fSMcSXj1adYPVRNQ/G2pTWSRIXb6Xx+uIjdJn4BwcuJfBu1xB+e60dj9WtaLZrRQjB50/VJyvHxGdrI81yTnukEpQNOX8zld6Td3MlPo2ZzzWlb1gVi8bj5KDjh0FNaFqtPG8sOcLOqFsWjUf5u9I2SeLE1SReWniYjt9uY92JWEY+UoM/3urAmHZBZun+vleNCh6MaR/EmqPXOHj5ttnPbw9UgrIRR6MT6TdlD1kGI4tGtaRtLevYJ8/FUc9PQ8MJquDB2HkHOXsjxdIhKaVIRraRFYdi6PvjbnpM2snvp+MY+UgNdrz9KO93q2PxMl1j2tXAt4wzn/96Sk2YKASVoGzAjqibDPhpL+7OepaNaUWDKtZ1R+zl6siM55ri4qTn+VkH1PRapURl5hjZEnmDN5Ycpennm3l9yVFupWbxUY+67H7vUd7rVocKZZwtHSYAbk4OvPF4LQ5dSWTDieuWDsfmqEkSVu7XY7G8uvgwQRU8mDOsGb6e1jnYWrmsK9OfDefpqXt4cf4h5o1ojqNe3f8oRZdjNBEZm8z+iwnsPh/PnvPxZOQYKePiQLcGfjwVWuW+NfMsrW9YVab9cYEJm6PoXM+v2Nco2jOVoKzY/H2X+XDlCcKrlWP60KZ4uVr39heNqpbliz4NeG3xUT7/NZJPnqhn6ZBKNVvbbiMzx8i1xAwuJ6Rz8WYaUXEpRMamEBmbTJbBBEB1H3eeDq9ChxBfWgX54ORg/TdBep3g5Y41eWXREdafuE73hv6WDslmqARlhaSUTN52nq83nuHREF9+GNgEVyfzD/IWxlOhVTgWk8SsXZdoGlheXYwWVJANC025Gx3Jv97z595HEomUaB9oz5ukRJrAKCVGk8SU+9lglOSYTNpno4lso4lsg4nMHCOZOdrntGwDaVkGUjMNJGXkcDs9h9vp2dxMyeJmShbxadl/i62smyN1/DwZ0qIajaqWpWlgefy8rLMH4UF6NKzEpK3nmLjlLF3rq1ZUQakEZWWklPxnXSQ/7bjIk40r8XW/RpbvKstOg9ijcOMk3L4EqXGQmQSGTJAm0OnBwQWc3MHZkw+dy1LNJ4Udy3YRltMav0pVoYwfuHlrr1Wsxqi5B9ls5tqKQkAZZwfKuTtR1s2JKuVcaVKtHH6eLlQu60o1bzcCfdzxdney2m67h6XXCcZ1CObVxUf4/UwcHetUtHRINkElKCtiMJp4/5fjLImIYWjLanzcs57l7rTSE+D4MohcDVf2gMmgPe/gAh4VwcULHF1B6MCQpb0+Ow0yk9BnJvKcyaBNwVnzw1/HFHpwrwAevtqHuy94VNASl5uP9tm1HLiWBWdPcPEERzftP5pSIp5oXIkGlbVJN3d+zTrB3xKDTgiE0J7XvhbohfZPV6cTOOgEep0OB53AUa/DQS9wctDhnPvh4qjHzckBNyc97s4OuDnqS2ULontDf77eeIap2y+oBFVAKkFZiSyDkVcWHmHDyeu83LEmr3Uyb3WIPyVcgJ0T4OhCMGaDb11oOQ4CWoJ/Qyjj/+CEISVkJbPj6GkmrtzJM3Vd6FfLEdLiIOW61gJLi4O4SEi7qZ0nP0IHTh5aonJyAwdXcHTREqXeKffDEfSOSOGAAT0GKciROgxSYJA6jBIMUmCUAhMCowQTApMUSAkmQCKQUmhdWYjcbi0I6f0+7p4lV9/Q0p5QG+yZjaNex/A21fl07SkOXr5NWLVylg7J6qkEZQXSsgyMnnuQnedu8a8edS1T2y4zCbZ9CfunaUmh8SBoOhz8Gjz8sYQAFy8ead6c366789aey/g0a0qH5r7/fK2UkJUC6fFaKyzzNmQkavFkpWgf2WmYstNIS00mPS2V7Ix0jNnpGHNugzEbYcwGaUQnDThgRI8JPSZ0mHDAhDMmdFoK+tvnOyMvd54DEMi/bWh2K+VFu05Qink907QqEzZre1CpBPVgKkFZWGJ6Ns/PPsCxmCS+6dfIMtUhTq+DX1/XWjdNhkD798GzeCY3vN+tDvsvJvDmkqOse+URKt47TV4IrSvPxRPK/5WYswxGDly8zY5zNzl46TYnryWTkWP88/sezg74e7lQoYwz3h7OlHdzxNPVkTIuDng4O+LmpMfFUY+rkx4nvQ4nBx1Oeh2ODlo3lF4I9DqBg16gv9NtpRMItG4snU7r5vKxQAUCxX65OzvQv1kAM3ZeJDYpA38vV0uHZNVUgrKguORMhszYz8VbaUwe1ITO9fzMG0B2Gmx4Dw79DBXrQ//5UDmsWE/h4qhn0oBQnvh+F2PmHWThyBb5lp2RUrLnQjzLImLYdOoGqVkGHPWC+pW96N+sKnX9PQn29aC6jztero52M4D+sIQQNYAPAC8pZV9Lx6M8nCEtqjF9xwXm773Cm51rWzocq6YSlIVEJ6QzeMY+bqZkMev5prQO9jFvALeiYPEQuHka2rymtZocSqYsTM2KZfjv040YO/8Qby87xjf9Gv1t/UpmjpFfDl9l+o4LnL+ZhmfuAszO9fxoGeSNm5P9/JkKIWYCPYA4KWX9u57vAkwE9MB0KeUX+R1DSnkBGC6EWFbS8SrFr2p5NzrVqciC/VcY92iwReoE2gr7ufJtSNSNFAbP2Edmjon5I5oTGmDmvujT62DFKC0hDVkBQY+W+Cm7NvDn7S61+WrDGWKTMhjTLgg3Jwf+iLrJkgPRxKdlU7+yJ9/2a0T3hv72fNHOBr4H5tx5QgihB34AHgNigANCiNVoyWr8Pe8fJqWMM0+oSkl5tmUgm07dYOPJ6/RqXNnS4VgtlaDM7FhMIkNn7sdBr2PJ6JbU9itjvpNLCTu+ha2fQaVQeGYeeJlvzOuF9sFUKefGu8uPMfznCECbuvxoiC/D2lSnZQ1vu++2k1L+IYQIvOfpZsC53JYRQohFQC8p5Xi01tZDE0KMAkYBBASoDfOsTasgbwK93Zi/94pKUPehEpQZ7Tkfz4ifD1Dew4l5w5tTzdvdfCc3ZMOal7Xp4w36wROTtHVMZvZEo0p0DPHl5LVkUrNyCKtW3upLOJlBZSD6rscxQPP8XiyE8AY+B0KFEO/lJrK/kVJOE0LEAj2dnJyKd2BRKTKdTjCgWQDj15/m7I0UalU0442qDbH+QlZ2YvOpGwydtZ9KZV1ZNqaVeZNTxm2Y11tLTu3fh94/WSQ53eHu7ECz6uV5NKSiSk6avJqN+e7NIKWMl1KOkVIG5ZWc7npdqdoPytb0DauCk17Hgn1XLB2K1VIJygxWHr7K6HkHCfErw5LRLf851bokJUbDzC5wZS88NQ3av6MqM1ifGKDqXY+rAEXeori07qhrK7w9nHmsXkVWHrlKlsH44DeUQipBlbC5ey7x2pIjNAssz4KRLcy7gdqNkzDjMUi+pk2GaPSM+c6tPIwDQE0hRHUhhBPQH1hd1IOqFpT1eya8KonpOWw+pea95EUlqBIipeSH38/x0aqTdAzxZdbzTfFwNuOQ36VdMLOr9vXz66F6W/OdW8mXEGIhsAeoLYSIEUIMl1IagHHARiASWCKlPFkM51ItKCvXOtiHSl4uLI6IfvCLSyE1SaIESCn5Yv1ppv5xgV6NK/GNuSuSR66FZcOgXDUYvBzKqllc1kJKOSCf59cB64r5XA/cbkOxLL1O0De8KpO2RnEtMYNKZVVlibupFlQxM5ok7/9ynKl/XGBwiwD+93Rj8yanQ3NgyRCtht6wjSo5lWKqBWUb+japgpSw8shVS4didVSCKkbZBhOvLDrMwv3RvNghiM961TfvtgI7J8Dql6BGBxi6GtxUkdPSTI1B2YYAbzeaBpZj+cEYpMx38mappBJUMcnINjJqbgRrj8XyXtcQ3uocYr5Fp1LCpo9g88dQvy8MWKRtHqgoik3o3aQK52+mcSxGtXbvZrYEJYSoIYSYYY/1w5Izcxg6cz/bz97kP081YHS7IPOd3GiA1eNg93fQdKS2xqmEauoptkV18dmObg38cXLQsfxQjKVDsSoFSlBCiJlCiDghxIl7nu8ihDgjhDgnhHj3fseQUl6QUg4vSrDWKD41iwHT9nLoym2+6x/KwOZmHPPJyYSlQ+HwPGj3DnT7GnSqUaxoVBef7fBydeSxOhX59VgsOUaTpcOxGgX9bzYb6HL3E3cVuOwK1AUGCCHqCiEaCCHW3vORx051tu9aYgb9pu7hXFwqPz0bTk9z7k6alQoLnobTa6HLF9DhfbUAV1FsWK/GlYhPy2bnuVuWDsVqFGiaubkKXOYexyaKXF68lcbg6ftIzshh7vDmNKtuxgkJ6Qkwvy9cOwJPToHGec5cVko5IURPoGdwcLClQ1EKoF3tCni6OLD6yDU61LbLe/qHVpT+oLwKXOZbllcI4S2EmEJugcv8XielnCalDJdShleoUKEI4ZWcyNhk+k3ZQ0aOkYWjWpg3OSXHwqxucP2EVo1cJSclH6qLz7Y4O+jp3tCfjSevk55tsHQ4VqEoCapEClxau4OXb/PM1D046gVLRrekfmUzXvwJF2Dm45AUDYOXQUg3851bUZQS90SjyqRnG9l6WpU+gqIlqBIpcGnNdkTdZPD0fZR3d2LpmJYE+3qY7+TXT2hFX7NStTVOqnSRotidZtXLU6GMM2uPxlo6FKtQlFJHfxa4BK6iFbgcWCxRWaENJ2J5eeERgnw9mDOsGRXKOJvv5NH7tTEnR3d4fjX4hpjv3IrNUmNQFpKTCTcjIeEimIzgXAYq1IZygQ+cyKTXCbrV92PRgWhSswzmrd9phQr00+cWuGwP+AghYoCPpZQzhBB3ClzqgZnFUeDSGi2NiOad5cdoXLUss55rhpebGfcwOv87LBoIHhXh2VVafT1FKQBVi8+MTEY4u1Fb8nF+Kxgy/vmactWhfm9oNhrKVMz3UD0aVeLnPZfZEnmj1O+2W9BZfGYrcGltZu68yKdrT/FITR+mDgnDzcmMdzSnVsPy4eBdE4b8ct8/akVRLMBkgpMr4Pf/QMJ58PCD0EEQ+Ah4B4ODC6THw/VjcGY97Pwf7P4emo+Gdm9rrat7hAWUw8/ThTVHY1WCsnQA1kpKycQtUUzYHEXX+n5M6N8YZwe9+QI4PF+rEFE5HAYtAddy5ju3oigPdu0w/PomXI2AivWh32wI6QH6e3tYgiGgOTQbCfHnYce3WuWX48vgyckQ1OFvr9bpBF3q+7Fg/5VS382nyg7kwWSSfLY2kgmbo+gXVoVJA0LNm5z2TIZVL0D1dlrLSSUnRbEeORmw6UP46VFIvKKtRRy9A+o9lUdyuod3kJaUhv8Gzh4w90mtjqbx79PKuzXwJ9tgKvWz+VSCuofBaOLt5ceYuesiw1pX58s+DXEw13YZUsLv42Hje1CnJwxcrP0RK0ohqFp8JeDqIZjyCOyeBE2ehXEHtLWID1tirGozGLUdwp7XWlPzntIW4OcKq1YOHw9nNpwo3bP5VIK6S5bByIsLDrHsYAyvdqrJRz3qmG+7DJMJNrwL27+AxoOg72xwMONMQcXuqIW6xchk1LrmZjwGOekwZCX0nAiuZQt/TCc36DkBek2GK3theietCxBtNl/nehX5/fRNMrKNxfRD2B6VoHKlZRkY8XMEG0/e4F896vJqp1rm2y7DaIBVL8K+KdDiBXjie9CX3n5nRbEqybFaV9yWT7WejbG7/jFuVCShg2DoGshM1BJgzEFA6+bLyDGy/ezN4juXjVEJCkhKz2HIjH3sOneLr/s2ZFib6uY7uSFLq0h+dAG0fx86/0dVJFcUaxG1Gaa0gZgI7cax76ySGRMOaKGNSzl5wM894fzvNKteHi9XR347daP4z2cjSv1/wriUTJ6ZtocTV5OZPKgJ/cKrPvhNxeVvFcm/hPbvqIrkimINjDnw28cwv4+2BnHUNmgypGSvT+8gGL5JW9C74GkcozbQMcSXLadvYCilW3CU6gQVczudp6fs4XJ8OjOeC6dLfX/znTzjttZtcHGHNguoxRjznVtRlPwlRsPsHrBrAoQ9ByO3aJUgzKGMHzy3FvwawJIhDPE8TGJ6Dgcu3TbP+a1MqU1Q5+JS6TdlDwlp2cwb0YxHapqxcnrKDZjVHWKPwtM/q4rkimItTq/TuvRunIQ+M7SJEI6u5o3Brbw2CaNyOI33v85TjnvYdOq6eWOwEqUyQZ24msTTU/eQY5QsHt2SsGpm3C7j9mWY2RluX4SBS7RBV0V5CEKIJ4UQPwkhVgkhHrd0PHYhJxPWvQ2LBmjlxEZvhwZ9LRePiycMXo4IaMW3+h/g2BKkzHezCLtV6hLU/osJDJi2F1dHPUvHtKSOv6f5Tn7zjFaRPCMBnl1dvDOBFJsghJgphIgTQpy45/kuQogzQohzQoh373cMKeVKKeVI4DngmRIMt3S4eUab4r1/qjaLdvhv2niQpTl7wKAl3PQO58PsicTunGvpiMyuVCWo38/EMWTGPnw9nVk2tiXVfdzNd/Jrh7XkJI3w/Hqo2tR851asyWygy91PCCH0wA9AV6AuMEAIUVcI0UAIsfaej7u3Wv0w931KYUgJ+3+CqW0hJVbr0egy3rrWHzq5IwYuYr+pDn5bXtHKI5UipWaxzZqj13ht8RFq+5VhzrBmeHuY8Y/w0k5Y0F+bnvrsSuu4O1MsQkr5hxAi8J6nmwHnpJQXAIQQi4BeuRt79rj3GEJboPcFsF5KeSiv8wghRgGjAAICAootfruRHKvVujy3GYI7aYtlrbQYs6+3Ny/6fsbHyZ9Qf8UoEDqtKnopUCpaUAv3X+HlRYdpElCOhaNamDc5nd0I8/qAZyUYvlElJyUvlYHoux7H5D6Xn5eATkBfIUSe0z+llNOklOFSyvAKFcw4AcjaSQlHF8HkFnBpF3T7BgYts9rkdEebOtV4JvU1sis1heUj4NQqS4dkFnafoKZuP897K47TvlYFfh7WDE8XM+7ldHyZtpdThRCtW8+zkvnOrdiSvBbX5DsiLqX8TkoZJqUcI6Wcku9BVS2+v0uM1tYd/jJamzY+ZqdWYdwG1h52qutLmnRhbf2JUDkMlg2D079aOqwSZ7cJSkrJVxtOM379aXo09GfqkHBcncxYkTxipnanU7W5VsbE3dt851ZsTQxw9wrxKsA1C8Vif4w5sOs7+KG51mrqPF67YfSxnZ2G6/p7UsnLhQ1RqTB4Ofg3hiVDtT2m7JhdJiiTSfLRqhNM3naeAc0CmNg/FCcHM/6oO/8Ha1+Dmo9rf0wuZpwpqNiiA0BNIUR1IYQT0B9YXdSDqmKxaGNMP7aG3z6C6m3hxb3Q8gXQmfFmtRgIIXi0ji87om6RqXeHIStyF/M+qw0j2Cm7S1A5RhOvLznCvL1XGN22Bv95qj56c1UklxI2f6J91O8L/eebf5GfYtWEEAuBPUBtIUSMEGK4lNIAjAM2ApHAEinlyWI4V+nt4os9CnOf0sZ/jdkwYBEMXARlbXfCSMc6FcnIMbL3Qjy4eGlJyrcuLB4MUb9ZOrwSYVcJKjPHyNh5B1l55Bpvda7Nu11DzFeR3GSCX9/QWk/hw6D3tAdvXqaUOlLKAVJKfymlo5SyipRyRu7z66SUtaSUQVLKz4vpXKWvBXXtMCwapE0dv3ZYK7784j6o3dXSkRVZyxreuDnp2RKZu4nhnVnBvnW0sW47TFJ2k6BSsww8N2s/myPj+KxXPV7sEGzG7TJyYMVIiJgBrV+F7v+1uS4Exf6UmhaUyaiVKPq5J0xrr9W3bP8evHIUWr5oXeuaisDFUU+bYB82R974q6qEazmtLNKdJHV2k2WDLGZ2kaBup2Uz6Ke9HLh0mwnPNGZIy0DznTwnQ2tin1gGHT+Gx/7PJmYFKfbP7ltQN8/C1n/DhAZaiaL489Dp/+C1E9D+Xa0bzM50rudHbFImR2Puuum4U7vPty4sHmRXEydsfqHujeRMhszYx6X4dKYODqNTXTOuZ8hMhoUD4PIurdXUdLj5zq0opY0xR9uX6dxvWovpZqS2aLVGB60CRO1udt+t3qlORRz1gvXHY2lc9a7dfN3Ka919c5+CxUOg3yy7qPNp0wnqSnw6g2bsJSE1m9nPN6VVkI/5Tp4WD/N6w40T0Ge6ZQtLKkoehBA9gZ7BwbYznfpPJhMkXdGqil87DDEHIPoA5KSB0ENAS20PtXpPaltUlBJebo60DvZh3YnYf46x3+num9dHm4Le5yeo38dywRYDm01QZ66nMGTGPrKNJhaMbEGju+8mSlryNZjzJCRehv4LoFZn851bUQpISrkGWBMeHj7S0rH8SUowZEJmEqQnQHo8pMVBynVIuqolpYRLkHAectK19wi91n0VOggC20D1duBqxuvdynSt78c7y49z8loy9Svf043pWhaG/KItSF4+AgzZNr2dj00mqKPRiQydtR8nvY4lo1tSq2IZ8508/ry20WD6bW2NU2Ab851bUYrbkYVaV9mfWznIv76W8q/H0nTPh1Fr5UijNknBZABTDhgN2rRuYzYYssCQoW1lkZMB2anah8mQdywOrlC2qrajbGAbqFALKjaAivXAyc0Mvwzb8FhdPz745QTLD8X8M0HBn1t1sGggrByjtTqbjjB/oMXAJhOUu7OeQG93vusfSoC3Gf9wb5zUWk4mAwxdDZWbmO/civKQCtTFd2adttBTCP6suHTn6z8/67RvCZ3WmhFC+6zT//VZpwedA+idtHEgvTM4uWtjIw4u2teObtoWEs6e2gQGt/LgWh48fLVt1V3LqQlGBVDe3YnuDf1ZGqiwH38AACAASURBVBHD64/Vokxe5duc3GHAYlj6nLb8JSsV2rxq9liLSphrEywhRB3gFcAH2CKl/PFB7wkPD5cRERF5fk9Kab5p5KD1f8/vqy28HbISfEPMd27FKgkhDkopwy0dx4Pc7zpSbNOR6ESe/GEX/+pRl2Ftquf/QmOOVnvwxHJo8zp0/JdV3gTkdy0VaJp5MW2yFimlHAM8DRT5ojZrcrqwDeb00u7whm1QyUlRFItqXLUsYdXKMWv3RdKz8+kyBa012/snCHsOdv5XK8FmMpotzqIq6Dqo2RTDJmtCiCeAncCWYvsJSlrkWpjfT9sGetgGrX9cURTFwl7rVIuY2xm8ufQoJtN9esJ0eugxQSsicHAWLB+uTZ6wAQUagyqOTdZyj7MaWC2E+BVYkNdrrGqjtSMLYdWLUCkUBi3V+swVxUbY9DRz5YHa1PTh/a51+HxdJIPT99GrcSW83Z1xcdTj6qSjoqcL/l6uWi1SIbQiAm7l4bd/QUYiPDMXnM04wawQijJJIq9N1prn92IhRHugN+AMrMvvdVLKacA00PrOixBf0eybBuvf0qa09l+gDe4qig2xymnmSrEa8Uh1JJLZuy7xzvLj//i+u5OeJtXK8XjdinRt4I9P61fAzQdWv6SVhhq4FDysd0PLoiSoh91kbRuwrQjnMw8p4Y9v4Pd/Q0gP6DMDHF0sHZWiKMo/CCEY1TaIEW1qcDE+jdRMA1kGE+nZBmKTMjl1LZnd52/x0aqTfLY2kh4N/RnT/glq9ffWZvjNfBwGr4Dy95loYUFFSVD2t8malLDpQ9jzPTQaAE98D3qbnImvKEopotMJgirk38tz+noyi/ZHszQiml+OXKVnw0p82HsJvmuehRmPw6Al2lCGlSlKsdgS2WTNYkxGrdm753toNhp6TVbJSVEUuxDi58knT9Rj5zuPMqZdEJtOXafNgjRmh0xD6p1gVndtc0crU9Bp5mbbZM0iDNmwbBgcngvt3oGuX4LOLgq9K4qi/KmcuxPvdAlh6xvt6VLPj0/25NDP8ClpHgEw/2k4PM/SIf5Ngf4Lm3OTNbPLToOFz8CpldrmZh3et8qFbIrysErNflDKQ6tU1pXvBoQyb3hzblCO5rFvcN6jiTZreduXd5W+sqzS3UzISIS5vbWFuE98r21upih2wu73g1KKrE1NHza+2pa+rerS+eZLbHR4FLb9B1aN06pQWFjpHWRJvQnznoK409B3lla2X1EUpZRxc3Lgkyfq0alORd5Y4sZZY1leOjIPmXwV8fTPFt34sXS2oBKjYVYXrTL5wEUqOSmKUuq1qenDhlfbcbzmi7yVMwrjhT8wTu+s/b+0kNKXoG5FwcwuWgtqyC8Q3MnSESmKoliFcu5OTB0SRr1uLzDc8C4Zty6TPfVRuHbEIvGUrgQVe0xLToZMeG4NBLSwdESKoihWRQjBc62r88aYUYx1Gc/NdBM5M7ogz6w3eyylJ0Fd2Quze2h70wzbAP6NLB2RohSKEKKOEGKKEGKZEGKspeNR7FPDKmX5/uVBfFN1MpE5fsiFA8ne9cBdkopV6UhQUZu1jQY9KmjJyaempSNSSilr3LpGUfLj5ebIt8MeZ/cjc9hsDMXpt3dJWfG62bbssP8EdXIlLOwPPsHw/AZtS2lFsZzZlNataxSbpNMJxjzWEOdBC5hDD8ocm0H89D6QlVLy5y7xM1jSobmw7Hlta/aha626aq9SOkgp/wAS7nn6z61rpJTZwJ2ta45LKXvc8xGXe5zVUspWwKC8ziOEGCWEiBBCRNy8ebMkfySllGgX4kf7l37iO9cX8Lq6nVuTHkUmxZToOe03Qe3+HlaPgxodtNl6rmUtHZGi5CevrWsq5/diIUR7IcR3Qoip5LN1jZRympQyXEoZXqGCujFTikeAtxsjXvuMqVXG45wSTfJ3bcm8cqjEzmd/CUpK2Po5bPoA6j4JAxaBk7ulo1KU+3norWuklC9LKUdLKX/I96Cq1JFSAtycHHhhxGjWNp1NqkHAzC7ER6wokXPZV4IymWD9O/DHVxA6BPrOBAcnS0elKA9if1vXKHZNCMGAHl24+OQqzsqqlFs7jOi1xV/Dz34SlNEAK8fC/qnQchw8MQl0ektHpSgFUSJb16hafEpJaxNaH/fR69mub0nViP9wfubwYq3hZx8JKicTlg6FY4vg0Q/h8X+riuSKVTLn1jWqi08xh6BKvjR5fSWrygwgKHo5FyZ0xpB67zygwhHSSsqq5yU8PFxGRETc/0VZqbBoIFzcDl2/huajzBOcUuoJIQ5KKa1+HVKBriNFKSKD0cTaud/S7eJ4bjn6U2bYCspUql2g9+Z3Ldl2Cyo9Aeb0gks74ampKjkpyl1UC0oxJwe9jiefe4sdLafjmpOI6aeOXDu2tUjHtN0ElXIdZneH68fg6TnQqL+lI1IUq6LGoBRL6NilN5efWs1t6UGFFX05u2laoY9lmwnq9mWt6OvtyzBoKdTpYemIFEVRlFyNG4fhMGorJ/T1qLX7LY7PebNQM/xsM0ElX9Uqkg9dDTXaWzoaRbFKqotPsaQqlSoR/PpGtnt05WZKZv4L++7DdidJ5GSCo4t5A1KUu6hJEoryYEajCZOUODrkv+wnv2vJdrd8V8lJURTF6un1Ogq7ItU2u/gURXkg1cWn2DqVoBTFTqlZfIqts+oxKCHETeCypeMoBB/glqWDsCG2+vuqJqW0+lLh6joqVWz1d5bntWTVCcpWCSEibGHw3Fqo35eSF/V38fDs7XemuvgURVEUq6QSlKIoimKVVIIqGYWv7VE6qd+Xkhf1d/Hw7Op3psagFEVRFKukWlCKoiiKVVIJSlEURbFKKkEpiqIoVkklKEVRFMUqqQSlKIqiWCWVoBRFURSrpBKUoiiKYpVUglIURVGsklVvWOjj4yMDAwMtHYai5OngwYO3bKGaubqOFGuX37Vk1QkqMDAQtVW1Yq2EEDaxhYW6jhRrl9+1pLr4FEVRFKukEpSiKIpilay6i08xr2yDiZPXkrh4K4341GyEAE8XRwK83ahXyZMyLo6WDlEBhBA1gA8ALyllX0vHU1plGYxExqZw9kYKyRk5ODvq8fN0oXHVslQo42zp8OyCSlClnJSSnedusfhANFsi48jIMeb5Op2ABpW9eKxuRZ5oVJkAbzczR2rfhBAzgR5AnJSy/l3PdwEmAnpgupTyCynlBWC4EGKZZaIt3Y7FJDJ79yU2nrhOWnbe10vDKl4MaBZA7yaVcXbQmzlC+6ESVCm270I8/1l/mqPRiZRzc6R3k8q0Dvahtl+ZP+8AE9NyuHArlcNXEvkj6ibfbDrLN5vO0rKGN0NbBfJY3YrodcLCP4ldmA18D8y584QQQg/8ADwGxAAHhBCrpZSnLBJhKXc5Po3P1p5ic2QcZZwd6NGwEu1rV6COvyfl3J3IMhiJTkhn38UEVh2+xnsrjvPD7+f4sHsdutT3t3T4Nsmq94MKDw+XavZR8UvLMvDpmlMsjoimcllXxj0aTJ8mVXByePCQ5LXEDFYcimHh/miuJmZQzduN0W2D6BtWsPfbEyHEQSlleDEeLxBYe6cFJYRoCXwipeyc+/g9ACnl+NzHy/Lr4hNCjAJGAQQEBIRdvmwTEw6tkpSSWbsu8eWG0zjqdYxtH8TQVoF4OOd/fy+lZEfULf6zLpLT11PoHVqZT5+sf9/3lGb5XUvqt1XKRN1IYcy8g1y8lcbodjV4tWMtXJ0K3gVRqawr4x6tyZh2QWw6dYMp28/z/i/aneKLHYLpF14FR33pSlQlqDIQfdfjGKC5EMIb+BwIFUK8dydh3U1KOY3c3VXDw8Ot9y7UyiVn5vD64iNsjoyjUx1f/v1kA/y8XB74PiEEbWtVoFWQN9//fo5JW89x8loy04eGU7W86h4vKJWgSpHd524xet5BnB30zBvRnFZBPoU+loNeR7cG/nSt78eOqFv8b/NZ3v/lOFO2n+f1x2rxRKNK6FTXX1Hl9QuUUsp4YMwD3yxET6BncHBwsQdWGly6lcbwnw9wOT6dj3vW5blWgQjxcH/TDnodr3aqRXi18rww/yBPTd7NvBHNCPHzLKGo7Yu61S0lNp+6wdBZ+/H3cmHVuNZFSk53u3OnuGJsK2Y91xQPZwdeXXyEbt/tYNuZOKy5C9kGxABV73pcBbhmoVhKlSPRifT+cTcJadnMG9Gc51tXf+jkdLc2NX1Y8UIrHHSC/tP2cuJqUjFGa79UgioFtp6+wdj5B6nr78nS0a2oXNa12M8hhKBDiC9rX2rDdwNCSc828tysAwyesU9djIV3AKgphKguhHAC+gOrLRyT3dt+9iYDpu3F3VnPihda06KGd7EcN9i3DEtGt8TdyYEhM/YRdSOlWI5rz1SCsnMRlxIYO+8Qdfw9mTO8OV5uJbuWSacTPNGoEptfb8fHPesSGZtCj0k7eW3xEa4mZpTouW2ZEGIhsAeoLYSIEUIMl1IagHHARiASWCKlPFnQY0op10gpR3l5eZVM0HZo/fFYRvx8gEAfd5aPbUV1H/diPX6AtxvzRzTHQa9j8Ix96pp4ADWLz46dv5lK78m7Ke/uxLIxLfH2MP/iweTMHKZsO8+MnReRwPA21RnbPghPO1j0W9yz+IrbXWNQI6OioiwdjtVbfjCGt5YdJTSgHDOfa4qXa8n9jZ6+nky/KXvw93Jh6ZhWJXouW5DftaRaUHYqMT2bET9H4KATzBnWzCLJCbRKFG93CWHrm+3p0cCfH7edp/3X25i75xIGo8kiMZUWqgVVcPP3XebNZUdpGeTN3OHNSjxhhPh5MnVIGBdvpfHC/IPkqGshTypB2SGjSfLSwsPE3E5nypAwq5jWWrmsK/99pjFrxrWhpq8HH606SecJf7Al8oaaSFFChBA9hRDTkpLUGOD9TN9xgQ9+OUGH2r7MGNoUNyfzTG5uFeTD+N4N2XUunk/XqLXXeVEJyg5N2HyWHVG3+LRXfZoGlrd0OH/ToIoXi0a1YNqQMKSE4T9HMGj6Pk5eU/9Ei5tqQd2flJIJm8/y718j6d7AnymDw3BxNG9Zor5hVRjdtgZz915m/j61mPpeKkHZmd/PxDFp6zn6hVWhf9OqD36DBQgheLyeHxtfa8snPetyKjaZHpN28tbSo9xIzrR0eEopYDJJPlsbyYTNUfQLq8LE/o0tVgnl7S4htKtVgU9WnyTiUoJFYrBWKkHZketJmbyx5CghfmX47Mn6RVq3YQ6Oeh3Pta7O9jc7MKJNdVYeuUr7r7cxYfNZ0rMNlg7P5qkuvrxlG0y8sfQoM3ddZFjr6nzZpyEOFqx+otcJvusfSqWyrrww/xBxKeom7Q6VoOyE0SR5ZdFhMnOM/DCoidm7KorCy82RD7rXZfPr7egQUoEJm6Po8M02lh2MwWRS41OFpbr4/iklM4dhsw/wy+GrvPl4LT7qUccqKp54uTkydUgYKZkGxs0/rCZN5FIJyk78uO0c+y4m8Gmv+gRV8LB0OIVSzdudyYPCWDamJX5erry59Cg9v9/JnvPxlg5NsQPRCen0+XE3ey/E83Xfhox7tKZV9TKE+HnyRZ8G7L+UwJfrT1s6HKugEpQdOHzlNv/bHMUTjSrRp0llS4dTZOGB5fllbCsm9m9MYnoOA37ay8g5EVy4mWrp0GyK6uL7y57z8Tz5wy6uJ2Uy+/lm9Au3zvHZXo0rM7RlNabvvMj647GWDsfi1EJdG5eaZaD7dzswGCXrX32k+BbASglxkXBlN8Qeg6RoSI8HQzboHcHZE8pUhHKB4FMb/BuCTy3QFW/XYmaOkRk7LzL593NkGUwMblGNVzrWpJy7U7GepzCsfaHuHaX5OjKZJNN3XuDLDWeo5u3GT8+GW30PQ7bBxNNT93A+LpU1L7UhsJirWVgjtd2GnfpszSmuJKSzeFTL4klOKdfh4M9wdAHcvqQ951oOylUHDz9wcAJjDmQmwdWDcHIlyNxdRZ09oWozqN4OgjuCb10oYheKi6OeFzsE83R4Vf7721nm7LnEikMxvNyxJs+2DCx1e1ApBXcrNYu3lx1j6+k4utTz4+t+DSljAxVMnBx0/DCoCd2/28HY+Yf45YVWNjWmXJxUC8qGbTx5ndFzD/JC+yDe7hJStIOl3IA/voZDP4MxW0sy9Z6CoEehbED+icaQDQnnIfYoRO+HSzvh1hnte14BUKendpwq4UVOVgBnrqfw719PsSPqFtW83Xivawid6/lZZCxBtaCsk5SS9Seu89HKE6RkGfigWx2ebVnNqsabCmLr6RsMmx3BgGYBjO/dwNLhlKj8riWVoGxUXEomXSbsoFJZF1aMbV34loQxB/ZOhu1fgSETGg+E1q+Cd1Dhg0u+BlG/wZl1cH6rlvDKBUKjAdrxywYU/ti5tp2J4z/rIjl7I5VmgeX5sEcdGlYpW+TjPgxrT1ClsRbflfh0Pl17ks2RcTSo7MV/n25EzYplLB1WoX2x/jRTtp9nYv/G9Gps++PL+VEJyo5IKXl+9gH2nI/n15fbEOxbyAsw9hisegGuH4daXaHz50VLTHnJTILItXBsMVzcDggI7gRNR0DNx4o0ZmUwmlgcEc1/N50lPi2b3qGVebNzbSqVwHYiebH2BHVHabiObqdlM2X7eWbtuoReJ3j9sVo83zrQouubioPBaGLAT3s5dS2Z1S+1sfrxs8JSCcqOzN17mY9WnuD/nqjH0FaBD38AkxF2/g+2fQFu5aH7t1pXXEm7fRmOzIdDcyAlVmtVNR8DoYPBufB3uSmZOUzOrZgugFFtazCmXRDuziU7xKoSlOXFJWcya/cl5u25TGq2gadCK/N255ACbctuK2KTMug2cQcVPV1Y+WJruxyPUgnKTpy/mUr373bQrLo3Pz/f9OH71ZNiYPlIbXZevd5acnIzc70+Yw5EroF9UyF6Lzh7QdNh0OIF8PAt9GFjbqfz1YYzrD56jQplnHnjsVr0C6+KvoQWYqoEZRlGk2TP+XgWR0Sz4UQsBpOkW31/Xu5Yk9p+Zu7OM5m0Ga63L2oTjDJug8kAjq7apKKKdbUJRkUc//r9TBzPzzpgt+NRKkHZgRyjid6TdxNzO50Nr7aloudD3iWeXgcrx2oXUPdvoeEzxTJxoUhiDsLuiXBqNeidoMmz0PoVKFv4dSqHr9zm379GcvDybUL8yvBB9zo8UrNCMQatUQnKfDKyjey7GM+WyDg2nrxOXEoWni4O9A2rypCW1Yp9Y8E8GbK0pRexR+DaEbh+THuck37/97n7Qkg3CH0WqoQV+vTj10cydfsFJg0IpWejSoU+jjVSCcoOfLPxDN//fo4pg5vQpb5/wd9oyIbNn8DeH8CvIfSbXfxjTUUVfx52TYAjC7XHoYPgkTcKPaFCSsm649f5YkMk0QkZdKhdgfe71SnWAXNLJSghhDswGcgGtkkp59/v9bZ2HRlNkisJ6UTGJnM0JpFDl29zNDqJbKMJF0cd7Wv50qORP53qVCyZ7i6TUetpuBUFNyPhxim4cRziToMpR3uNs5e29q9iffANgfJB4FlJW5Khc9CSVvJVbXz3wjY4uwly0qBqC+j0CVRr+dBh5RhN9J+2lzPXU1hrZ+ujVIKycfsvJvDMtD30C6vCV30bFfyNty/Dsue1NUvNRsHj/wYHy2xeWCCJ0VqiOjRHWywcOhjavgleVQp1uCyDkZ93X2LS1nOkZxsZ0Kwqr3WqVSwbOBZnghJCzAR6AHFSyvp3Pd8FmAjogelSyi+EEEOARCnlGiHEYinlM/c7trVcRwajidQsA0kZOSRl5JCQlk18ajZxKVlcT8rgamIGVxLSuRSfTrZBq0XnqBfUreRF8+rlaR3sQ/Pq5QuXlEwmLUFkJkNWMqQnaAvP029pSyxSrkHSVUi8AomXtZmnd7j7gl8D7cO/EVRq/PDddlkpcHi+9redEgv1+0CXL8Hj4Vr2VxO18aiq5V1ZPrYVzg72MR6lEpQNS8rIodvEHTjoBetefqTgg/+Ra7VZelJCr++hbq+SDbQ4JV2Fnf/VFg0LAeHDtBZVIceoEtKymbj5LPP2XcHNUc+LjwbzXKvAIt2BF3OCagukAnPuJCghhB44CzwGxAAHgAFAL2C9lPKIEGKBlHLg/Y59v+toz9JvkTdOwZ//BqT2pfzrKe2xREr513NSIiWYyP0swSQlJpP2OqNJYpQSo1FiNJkwmLTnRO4RBJI7/94FEkcHHe5Oejyc9Xi66PF0caCsiwNerg7oBSBN2ofJqC0MNxm1v2uTIfcjRxvbNGZrPQbGLMjJBEMGZKfndsPl979OgHsF8KqstdjLVtN6GHxqaVVS3L3v9+t9ONnpsGsi7PhWmxj05GSo3fWhDvHbqRuMnBPB0JbV+L9e9R/8BhugEpSNklLbHXf9iessG9OS0IByD36TIRs2f6ytb/JvDP1mQfkaJR9sSUi8oq3ROrJAa/m1GAutXgbXwq15OheXwvh1p9lyOo4q5Vx5p0sIPRr6F2oRZ3F38QkhAoG1dyWolsAnUsrOuY/fy31pDHBbSrlWCLFIStk/j2ONAkYBBAQEhF2+nPdmeAf/15fgpD35x3TP4ztp5d5fl7jrC5H7OiFA/Pn63K+EQAiBTmjP6XS63MfirgOI3M+6u74W2pIEoQOhz/1aDzod6By18ls6B20cU++k/a04uGiTFZzcwdENnD20aicuXlpXnJs3uPtoyUlv5goTcadhxQitC7DlOOj0f6Av+KzTT9ecYuaui0wZHEaX+n4lGKh5qARlo5ZGRPPWsmO81bk2L3YIfvAbEi5qXXrXDkOz0fD4Z9bdpVdQt87B75/DyRXgUlZrTTUbBY6Fm06869wtPlt7itPXU2gSUJYPe9SlSUGS/13MkKD6Al2klCNyHw8BmgPvAN8DmcDO/MagSuNCXZtiyIJNH8L+aVrlln6zCzyjNttgou+U3Vy6lcavLz9C1fJuJRtrCcvvWrLtVWx27sLNVD5efZIWNcozpl0BJjWcWA5THoGEC/DMPOj2lX0kJwCfYK0lOPoPrWzSbx/BpCZweJ7W3fOQWgf78OvLj/BVn4ZE386g9+TdjFtwiOiEB8zIMq+8mnVSSpkmpXxeSjn2fhMk1H5QVs7BGbp9DU/+CFf2wIzHtWu3AJwcdHw/oAlSwsuL7Hf/KLMlKCFEDSHEDCHEMnOd05ZlGYy8vOgwTg46JjwTev+1PNlpsOpFWDYMfOvAmJ3mWXhrCf6NYPByGLoGPCpqP/eUNnB2ozYm8RD0OsHTTauy7c32vPxoMJsjb9Dxv9v5Yv1pkjNzSugHeCgxwN3z7asA1wr6ZrXdho1oPBCeXaVN2JjRWatrWQAB3m6M79OAw1cS+WbTmRIO0jKKlKCEEDOFEHFCiBP3PN9FCHFGCHFOCPEugJTygpRyeFHOV5p8sf40J64m83XfRvdfFR97DKa202YIPfImPL++WGrdWb3qbWHkVq1bxJAJC56Gn3vC1UMPfSh3Zwdef7w2v7/Znh4N/Zmy/Twdvt7GvL2XMVj2zvQAUFMIUV0I4QT0B1ZbMiClhFRrBcM2aeNns3vA5d0FeluPhpUY2DyAqdsvsO1MXAkHaX5FbUHNBrrc/UTuzKMfgK5AXWCAEKJuEc9Tqmw6eZ1Zuy7xfOtAHqtbMe8XSQl7p8D0jtoU1mdXQcePHmqg1eYJoVVKf3E/dPtGWzT5UwetJXlnq5CH4O/lyn+fbsyacW0I8vXg49UnuWymLj8hxEJgD1BbCBEjhBgupTQA44CNQCSwREp5sqDHVF18NqZCLRi+SesZmNsbzv9eoLf9q0ddQvzK8PqSo9xIzizhIM2ryJMkCjrzSEo5PvfxMill34IcuzROkohOSKf7dzsI8HbLf51D2i2ta+vsBqjVBXr9oM1GKu0yk7UpvHt+0KYiNxulTaYoRCknKSWnr6dQx98z39dYeyUJNUnCRqXGwZwntW1s+i/Q9lZ7gHNxqfSctJNGVb2YP6JFiZX3KinmnCRRGYi+63EMUFkI4S2EmAKE3jVd9h+EEKOEEBFCiIibN2+WQHjWK9tg4qWFh5ESfhjYJO/kdGEb/Nhau7vq+hUMWKSS0x0unlor8uVD0PBpLVF9Fwq7v9dmTD0EIcR9k5MtUC0oG+Xhq42xeteERQO1a/4Bgn09+LRXPfZeSGDSVvu5GSmJBJXfzKN4KeUYKWXQndZUXqSU06SU4VLK8AoVir9+mjUbvz6SI9GJfNm3IdW87yljYsyBLZ9qd1YunjByCzQfbflaetbIs5LWqhyzEyqHwaYP4IdmcPKXh55IYcvUJAkb5u6tdduXD4KFAwo0JtU3rAq9Qyvz3ZYo9l6IN0OQJa8kElSRZh6VVr8ei/1z3Klbg3vq7CVGw+zu2urz0MEwaptWdkW5P7/6MGQFDF4BTh6w9DmY8Rhc2WfpyMxCtaBsnLs3PLsSPCvD/Ke1ArX3IYTgsyfrE+jtziuLDhOf+nC9BtaoJBKUmnn0kM7FpfD2sqOEBpTlva51/v7NM+u1adQ3TkGfGVrJIif7KRJpFsEdtfVTT3yvJfuZj8OSoQVec2KrVAvKDnj4ai0p13Iwr7dWwPY+3J0dmDQwlNvpObyx9Cgmk233GBR1mnmxzzwqbdKyDIyZdwgXRz2TBzX5a+t2Y462ynxhfyhXDUZvhwYFmlui5EWnhyZD4KWD0O5diNoE3zeDjR9oe/jYIdWCshNelbWWlNDB3Kcg+f4dUvUqefFh9zpsO3OTn3bY9k1YkRKUlHKAlNJfSukopawipZyR+/w6KWWt3PGmz4snVPsjpeTtZce4cDOVSQNC8ffK3ao8OVZb07N7EoQP19ZHWNv2GLbK2QM6vAcvHYJGz/w1kWLvj1oNQ0WxRt5BMGiZdjM1ry9k3r9VPKRFNbrU8+PrjWc4dMV2b8BUqSMLmvbHBX49Hss7XUJoFZw7E+/ybpjaoPBw7wAAF6BJREFUVltN3mcG9PhvoevNKffh6Z87kWKHVp1iw7swubm2028pmkih2JBKjaH/fLh1FhYPvu8NlRCCL/s2pKKnCy8vPExShlVURnloKkFZyI6om3y54TTdGvgxqm0N7Z/i/p+0lpNzGRixRXXpmYNfAxiyEgYu1apiLx6sTUgpREUKa6PGoOxQjfbaOPTFP2D1S/e9mfJydWTSwFCuJ2Xy7vJjWHNh8PyoBGUB0QnpvLTwMDV9y/B130YIYw6seRnWvQlBHbUSPhVV8Q2zEQJqPQ5jd0OP/8HNM1pFihWjtEWTNkqNQdmpRv2hw4dwbBFs//K+L20SUI63Otdm/YnrzNub95Yr1kwlKDNLyzIwck4EJpNk6pAw3A1JMPdJbQfZR96AAQsLvdeRUkR6B21jxJcPQ5vXtcXQwj52LFXsTNs3ofEg2DYeji2970tHPlKD9rUr8NmvkZy8ZlutaZWgzMhkkry59Chnb6Tw/cAmBMqrMP1RiInQxps6/kubbaZYlosndPoYXj1WvLupKkpxEQJ6TIBqbbSyZ9H7832pTif4tl8jyro68tKCw6RlGcwYaNGoBGVG322NYv2J67zXtQ5tnc7CjE7aVhnP/arGm6yRo6ulIygSNQZl5xyc4Jm5WuWURQO1NX758PZwZmL/UC7Gp/HRqhP5vs7aqARlJuuPxzJhcxR9mlRhRLnDWreeR0UYsRmqNrV0eIodUmNQpYDb/7d33+FRVekDx79vGoHQJIDSQaSIAoZmw4IgC5YfahCBtaCCsgp2XRRxVZafupa1ICogYgXBUBR1kRVFluICCb0oIEpQIIL0kJDk/f1xLz9jnIlJptyZ5P08zzzPzOXMuW8uc553zjl3zqkFA9931pqcOsD5wuvH2c2TueOiFsxI30HaiswwBll2lqDCYO2O/dw9bSUpjWvyZIP/IGk3OWvE3TQXTmjqdXjGmGhWpxX0nQS71sGs24q9s++O7i04s1ktRs1ey5asQ2EMsmwsQYXY7gNHGfzmcmpVjuedZvOIn/cQtL4MrptZpm0gjDHmd1pcDD0ehfWzYOEzfovFxggv9E8hMT6W299N5+ix/LCFWBaWoEIoOzefwW8t5+DRHOacMoukr/8JHa6Hfm9F/fyGMSbCnHMHtO0H88fAN3P9FjupRiLPXt2ejTsP8veP14cxwNKzBBUix+/YW79jL/OaTqHW+rfh3Dvh8hftTj0TEBE5WUReF5EPvI7FRBARuPwF58fnaUNgzxa/Rbu1rsuQ85rxztIf+HTNT2EMsnQsQYXIc/O+4bM12/ms4RvU/+FDuGgUXPy47d9UwYnIJBHZLSJrixzvJSKbRGSziIworg5V3aqqN4c2UhOVEqo4yyHFxDp39uX4n2e6/0+tad+oJg+krWb73iNhDLLkLEGFQNqKTMZ/sYHZdV7j5Kz58KcnnB/WGQOTgV6FD4hILPAy0BtoAwwQkTYi0lZE5hR51A1/yCaq1Gzs3DTx8zcw2/9NEwlxMYwdkALAsCkZ5OYVhDPKErEEFWRLt+7hkRnLmVZjLG0OLoJLn4Ozb/M6LBMhVPUrYG+Rw12AzW7PKBeYCvRR1TWqelmRR4nWXhKRW0RkuYgsz8rKCvJfYSJe827uTROzYclYv8Ua1arCU6ntWLV9H898tils4ZWUJagg2pJ1iOFvLeGNxBc4I2eZMx7c2UZizB9qABT+lWWme8wnEUkWkVeBFBF50FcZVR0PPAakJyQkBDNWEy3OuQPa9IF5f4PvFvotdknbelx7VmPGf7WVLzZF1tqTlqCCZO/hXG59YzH/5Fm65Kc7N0N0HOR1WCY6+JqY9PtjFlXdo6pD3f3WniimnP1QtyITcbaUSW4OH9xY7EaHD1/ahtYnVePeaavYuf9oGIMsniWoIDh6LJ+/vLmEhw49SVfSnTWyOt7gdVgmemQCjQq9bggUv21qCdhSR4ZK1aDf25B7BKYPcnbq9iExPpaxAztw9Fg+d72fQX6EbBVvCSpABQXK/dPSGfTTaC6KWQGXPAOdbvQ6LBNdlgEtRKSZiCQA/YEPPY7JlBd1W0Ofl2D71zDvEb/FTqlblcf7nM7SrXt58fNvwxigf5agAvT0v9bTfeMj9I5d5tyt12WI1yGZCCYiU4AlQCsRyRSRm1U1DxgGzAU2ANNUdV2g57IhPvP/Tk+FLrfC0nGwbqbfYn07NuSqlAa8NP9blmzZE8YAfbMEFYB3l35Hk8UPcUXsYrT73+xuPfOHVHWAqtZT1XhVbaiqr7vHP1HVlu680phgnMuG+Mxv9Pw7NOwMs4fBz/57SKOvOJ2myUncOTWDPYdywhjg71mCKqMvNuwid84I+sd9SUHX+5Dz7vE6JGN+w3pQ5jfiEuDqyRCbANOud+alfEiqFMfYgR3Yl32Me6evosDD+ShLUGWwdsd+Nkx9kBvj/sWxzkOJ6f6w1yEZ8zvWgzK/U6MhpE6A3RvgE/+LB7SpX51Rl57Kl5uymLBwaxgD/C1LUKWU+csR/v36KG6TNLJPG0D8JU/a8kUmIlkPyvh0Sg+44AFY+S6kv+232LVnNaH36Sfx9NxNpP/wSxgD/JUlqFLYf+QYU1/7X+4qeJODzS+jcurLlpxMxLIelPHrgr9CswucXtRO3zvsighPprbjpBqJDH8vg/3Zvm9RDyVLUCWUk5fPxPHPc3f2WPbVO49qA96wVclNRLMelPErJhZSJ0JiTWc+Kuegz2I1Ksfz0oAUdh04yoi01WgxmyGGJMywni1KFRQoEyZPYtgvT7I/uT01b3zfmXA0xphoVbWus6jsL9/BR3f6XVQ2pfEJPNCrFZ+u3ck7S78Pa4iWoErgrbQ0btw+kkNVm1JryCxISPI6JGOMCVzTc6HbSFibBssn+S02uOvJXNiqDqM/3sC6H8M3ZGwJ6g/MnjefPmvvJKdSLWrdOgcqn+B1SMaUiM1BmRLpeo9z48S/HoSfVvksEhMjPHt1e06oEs/w9zI4nJMXltAsQRVjwbIMOv1nMDFx8VQf8jFSvZ7XIRlTYjYHZUokJgauHA9VkmHaDXDU9xea5KqVeP6aFLbtOcyo2b5vrAh6aGE5SxRauWkrDeb8mZox2VQaNIu4Os29DskYY0IjKdmZj9r3Q7HzUWc3T+aO7i2Ykb6DtBWZIQ/LEpQP3/24m5gp/Wgku8nr9x6Jjc7wOiRjjAmtJmdD91HOWn3LJvotNvyiFpx1ci0enrWWzbv9bykfDJagisjad4hdE6/hNLawv/er1Di1m9chGVMmNgdlSu2cO+GUi2HuQ37no2JjhBf6p1A5IZZh76Vz9Fh+yMKxBFXI4aO5rH3lWs4qSGfHuWOoe2Zfr0MypsxsDsqUWkwMXPkaVKntzkcd8FnsxOqJPNuvPRt3HmT0nPWhCydkNRchIieLyOsi8kG4zlkaefkFfDXuNrrlfMGW0++i8cW2MrkxpgJKSoa+r//hfFS3VnW55fyTeffrH/h49U8hCaVECUpEJonIbhFZW+R4LxHZJCKbRWREcXWo6lZVvTmQYENFVZk7YSS9D0znm8b9aZ76qNchGWOMd5qcAxeNhHUzYMUbfovd17MV7RvVZETaarbv9b06eiBK2oOaDPQqfEBEYoGXgd5AG2CAiLQRkbYiMqfIo25Qow6yuVNe4NKd49iU3J2Wg8bZ+nrGGHPu3dC8u/P7KD/r9SXExTB2QAoIDJuSQW5eQVBDKFGCUtWvgL1FDncBNrs9o1xgKtBHVdeo6mVFHruDGnUQLfhkKt03Pc7mpBRaDn3P1tczEU9ErhCRCSIyW0R6eh2PKaeOz0cl1oTpN0CO7zv2GtWqwj9S27Fq+z6enrsxuCEE8N4GwPZCrzPdYz6JSLKIvAqkiMiDxZS7RUSWi8jyrKysAML7Y8sXf06nr+/gx4QmNLltJhKfGNLzGROk4fJZqjoEGARcE8JwTUVXtY4zH7V3K3x8j9/5qN5t63HdWU2YsPA75m/cFbTTB5KgfI2D+V3qVlX3qOpQd0vrJ4opN15VO6lqpzp16gQQXvE2rltJs7mDOBhbk9pDPyI+yZYwMmExmeANlz/svs+Y0GnaFS4YAavfh4x3/BYbeempnFqvOvdOW8XO/UeDcupAElQm0KjQ64bAj4GFEx7bt2+j6vR+xIoSf8NMkpIbeh2SqSCCMVwujqeAT1U13dd5wjkSYSqA8++DZufDJ/c7u/H6kBgfy9iBKeTkFXDn1Azyg7BVfCAJahnQQkSaiUgC0B/4MOCIQmzP3j0ceeNKktnHodT3SG5ymtchGVOq4XJgONAD6CsiQ30VUNXxwGNAekKCbQ1jAhQTC1dNhEpVYfogyPV9x17zOlUZ3ed0vv5uLy9+/m3gpy1JIRGZAiwBWolIpojcrKp5wDBgLrABmKaq6wKOKISys7PZ/koqzfO3kdnjFRq2Pd/rkIyB0g+Xv6iqHd0h81dDGJcxv6p2Ilw1AbI2wacP+C2W2rEhV3VowIvzv2Xxlp8DOmVJ7+IboKr1VDVeVRuq6uvu8U9UtaU7rzQmoEhCLC8vj5Vj/8wZxzLY0GUMLbqmeh2SMceFZLjcVpIwQde8G5x3L2S8Daun+S02us/pNKudxF1TV/LzoZwyn65CLHWkqix6bThnH/6cjBbDaXuprRJhIkpIhsttLT4TEhc+CI3PgY/ugp83+yySVCmOlwd2YF/2Me6dtoqCMs5HVYgE9dXbo7kg6z3ST0wlZeBor8MxFVg4h8utB2VCIjYOUidCXCVnPuqY7zv2Tq1XnVGXtWHBN1lMWLi1TKcq9wlq8ewJnLflOVZXO5+UW8bbKhHGU+EcLrcelAmZGg3gyldh1xr4bKTfYtee2ZhL2p7ED3uPoH5+Q1Wccp2gMhZ8SMf0EXxb6TROvX0qEhvndUjGhI31oExItfwTnDPc2Ttq/WyfRUScrTnGXNkWKUPnoNwmqE2rlnDK/FvYGVefBrfNJj4xyeuQjAkr60GZkLvoEWjQCWYPh1+2+SwSH1v2NFMuE1Tmtk2cMHMg2VKFpJtmUbVmba9DMibsrAdlQi4uwdkqHuCDmyAvN6jVl7sEtSdrJ3lvXkVljpLT/31qN2judUjGeMJ6UCYsTmgCfV6CHSvg88eCWnW5SlBHDh9k12tXUr9gJz/1nkSj1p29DskYz1gPyoRNmz7QeTAsGQvfzA1ateUmQeUdO8bGl6+h9bENbDj7GVqe2dvrkIwxpuLoOQZObAszh8L+HUGpslwkKC0oYNkrQ+hwZBEr2vyV9r1u9DokYzxnQ3wmrOIT4erJkJcDaYMhPy/gKstFglr05kjO3juT/9a/js7X+N1qypgKxYb4TNjVPgUufx5+WAxf+t1VqcSiPkEtnfESXb8fx4oaPek8+AWvwzHGmIqtXT8441pY+Cxs+SKgqqI6QWXMn06nVY+wNrED7W5/G7Ht2o0xxnuX/ANqt4QZt8Ch3WWuJmoT1Mb0BbRccDvfxzWl2W1pxCfYdu3GGBMREpKc+aicA06SKigoUzVRmaC2b1lHnQ+v40BMDWoMmU1S9Vpeh2RMxLGbJIynTmwDvZ6ErV/Aon+WqYqoTFCH9/xEtlQhf+AH1D6psdfhGBOR7CYJ47mOg+C0q+DgLijDYrFRuXpq6y49yO+whti4eK9DMcYY44+IswtvGRfqjsoeFGDJyRhjokEAu0hEbYIyxhhTvlmCMsYYE5GkLLschouIZAHfex1HGdQGfvY6iCgSrderiarW8TqIP2LtqEKJ1mvmsy1FdIKKViKyXFU7eR1HtLDrZXyxz0XplbdrZkN8xhhjIpIlKGOMMRHJElRojPc6gChj18v4Yp+L0itX18zmoIwxxkQk60EZY4yJSJagjDHGRCRLUMYYYyKSJShjjDERKSpXM48mIpIEjANygS9V9V2PQ4p4InIFcClQF3hZVT/zOCQTAawtlU55aEfWgyoDEZkkIrtFZG2R471EZJOIbBaREe7hq4APVHUI8D9hDzZClOaaqeos93oNAq7xIFwTJtaWSqeitSNLUGUzGehV+ICIxAIvA72BNsAAEWkDNAS2u8XywxhjpJlMya/ZcQ+7/27Kr8lYWyqNyVSgdmQJqgxU9Stgb5HDXYDNqrpVVXOBqUAfIBOnYUEFvt6luWbieAr4VFXTwx2rCR9rS6VT0dpRhfxPDpEG/PrtDpzG1ACYAaSKyCvAR14EFsH8XbPhQA+gr4gM9SIw4ylrS6VTbtuR3SQRPOLjmKrqYeDGcAcTJfxdsxeBF8MdjIkY1pZKp9y2I+tBBU8m0KjQ64bAjx7FEi3smhlf7HNROuX2elmCCp5lQAsRaSYiCUB/4EOPY4p0ds2ML/a5KJ1ye70sQZWBiEwBlgCtRCRTRG5W1TxgGDAX2ABMU9V1XsYZSeyaGV/sc1E6Fe162WrmxhhjIpL1oIwxxkQkS1DGGGMikiUoY4wxEckSlDHGmIhkCcoYY0xEsgRljDEmIlmCKiERyReRlYUeTb2OKVhEJEVEJgZYx2QR6Vvo9QARGRl4dCAiw0TElrgpJ6wt/WEd1pZcthZfyWWr6hm+/kFEBOc3ZQVhjilYHgL+XvSgiMS5PwIsi14Ebx2wScAi4I0g1We8ZW2pdCpsW7IeVBmJSFMR2SAi44B0oJGI3C8iy0RktYg8VqjsSHczsX+LyBQRuc89/qWIdHKf1xaRbe7zWBF5ulBdt7rHL3Tf84GIbBSRd90GjYh0FpHFIrJKRP4rItVEZKGInFEojkUi0q7I31ENaKeqq9zXj4rIeBH5DHjL/TsXiki6+zjHLSciMlZE1ovIxzi7dh6vU4AzgHQRuaDQN+UM93wUc62ud4+tEpG3AVT1CLBNRLoE5T/PRBRrS9aW/FJVe5TggbNB2kr3MRNoChQAZ7n/3hMYj7OycAwwBzgf6AisAaoA1YHNwH3ue74EOrnPawPb3Oe3AA+7zysBy4FmwIXAfpzFIGNwljzpCiQAW4HO7nuq4/SObwCed4+1BJb7+Lu6AWmFXj8KrAAqu6+rAInu8xbH68DZ3XQeEAvUB/YBfd1/6wC85T7/CDjXfV7VjcvftToN2ATUdsvXKhTXSOBerz8H9rC2ZG0pfA8b4iu53wxLiDNu/r2qLnUP9XQfGe7rqjgfwmrATHW+uSAiJVnEsSfQTn4dh67h1pUL/FdVM926VuI07v3AT6q6DEBVD7j/Ph0YJSL3Azfh7MZZVD0gq8ixD1U1230eD4x1vz3m4zROcBrBFFXNB34UkfmF3t8L+NR9vgh4TkTeBWaoaqaI+LtW7XG29P7Z/TsKb8y2G2jt+3KZKGNtydpSiViCCszhQs8FeEJVXytcQETuAvwteJjHr8OsiUXqGq6qc4vUdSGQU+hQPs7/ofg6h6oeEZF5OLuR9gM6+Yghu8i54bd/193ALpwPfAxwtPApfP1ROA0m1Y3hSXfY4hJgqYj0wP+1uqOYOhPdWE35ZG3JtwrdlmwOKnjmAjeJSFUAEWkgInWBr4ArRaSyO2Z8eaH3bMMZtgDoW6Suv4hIvFtXSxFJKubcG4H6ItLZLV9NRI5/+ZiIM8G6rMi3qOM2AKcUU3cNnG+UBcB1OMMQuH9Xf3eMvx7O8AYiUgOIU9U97uvmqrpGVZ/CGV5pjf9r9TnQT0SS3eO1CsXRElhbTJym/LC2hLUlsB5U0KjqZyJyKrDEnWs9BFyrquki8j7OePv3wMJCb3sGmCYi1wGFu/UTcYYb0t1J0izgimLOnSsi1wAviUhlnG9HPYBDqrpCRA7g564dVd0oIjVEpJqqHvRRZByQJiJXA1/w6zfCmcBFOHMC3wAL3OMXA/8u9P67RKQbzjfU9cCnqprj51qtE5ExwAIRyccZthjk1nMu8Bim3LO2ZG3pONtuI8xE5FGcD/szYTpffZwJ5Nbq59ZdEbkbOKiqAf1+w61rIjCx0HxCwEQkBbhHVa8LVp0m+llbKlOdUdWWbIivHBOR64GvgZH+GpTrFX47Hl9mqjo4mA3KVRsYFeQ6jSkxa0vesB6UMcaYiGQ9KGOMMRHJEpQxxpiIZAnKGGNMRLIEZYwxJiJZgjLGGBOR/g81VpT8+lii+QAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -1184,7 +1182,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.5.6" + "version": "3.8.2" } }, "nbformat": 4, From a9d869e0215b3dfc630ebf67ca1cce8b988a2a53 Mon Sep 17 00:00:00 2001 From: Ben Greiner Date: Fri, 26 Jun 2020 18:23:52 +0200 Subject: [PATCH 11/67] pytest: do not ignore warnings but filter matrix and scipy deprecations (#423) --- .travis.yml | 2 +- setup.cfg | 6 ++++++ 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/.travis.yml b/.travis.yml index 62333ead8..d0201031b 100644 --- a/.travis.yml +++ b/.travis.yml @@ -130,7 +130,7 @@ install: # command to run tests script: - 'if [ $SLYCOT != "" ]; then python -c "import slycot"; fi' - - coverage run -m pytest --disable-warnings control/tests + - coverage run -m pytest control/tests # only run examples if Slycot is install # set PYTHONPATH for examples diff --git a/setup.cfg b/setup.cfg index 3c6e79cf3..ac4f92c75 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,2 +1,8 @@ [bdist_wheel] universal=1 + +[tool:pytest] +filterwarnings = + ignore:.*matrix subclass:PendingDeprecationWarning + ignore:.*scipy:DeprecationWarning + From c7c7b4754dcb30d14e46837b8967cc01abf34adc Mon Sep 17 00:00:00 2001 From: Ben Greiner Date: Sat, 11 Jul 2020 04:27:07 +0200 Subject: [PATCH 12/67] only call np.delete with actual removal (#430) --- control/iosys.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/control/iosys.py b/control/iosys.py index 1b29b5b01..1fe10346f 100644 --- a/control/iosys.py +++ b/control/iosys.py @@ -1645,8 +1645,10 @@ def rootfun(z): # and were processed above. # Get the states and inputs that were not listed as fixed - state_vars = np.delete(np.array(range(nstates)), ix) - input_vars = np.delete(np.array(range(ninputs)), iu) + state_vars = (range(nstates) if not len(ix) + else np.delete(np.array(range(nstates)), ix)) + input_vars = (range(ninputs) if not len(iu) + else np.delete(np.array(range(ninputs)), iu)) # Set the outputs and derivs that will serve as constraints output_vars = np.array(iy) From 2777de3e07099b83da3b9f21c2741107ea784833 Mon Sep 17 00:00:00 2001 From: Ben Greiner Date: Sat, 11 Jul 2020 04:32:38 +0200 Subject: [PATCH 13/67] Fix phase for triv_sigma in examples/robust_mimo.py (#428) * fix issue #406 * more precise docstrings for *.freqresp() --- control/frdata.py | 33 +++++++++++++++++++++++---------- control/lti.py | 26 +++++++++++++++++--------- control/statesp.py | 17 +++++------------ control/xferfcn.py | 33 +++++++++++++++++++++++++-------- examples/robust_mimo.py | 2 +- 5 files changed, 71 insertions(+), 40 deletions(-) diff --git a/control/frdata.py b/control/frdata.py index 14705947e..c57cf09b7 100644 --- a/control/frdata.py +++ b/control/frdata.py @@ -400,17 +400,30 @@ def _evalfr(self, omega): # Method for generating the frequency response of the system def freqresp(self, omega): - """Evaluate a transfer function at a list of angular frequencies. - - mag, phase, omega = self.freqresp(omega) - - reports the value of the magnitude, phase, and angular frequency of - the transfer function matrix evaluated at s = i * omega, where omega - is a list of angular frequencies, and is a sorted version of the input - omega. - + """Evaluate the frequency response at a list of angular frequencies. + + Reports the value of the magnitude, phase, and angular frequency of + the requency response evaluated at omega, where omega is a list of + angular frequencies, and is a sorted version of the input omega. + + Parameters + ---------- + omega : array_like + A list of frequencies in radians/sec at which the system should be + evaluated. The list can be either a python list or a numpy array + and will be sorted before evaluation. + + Returns + ------- + mag : (self.outputs, self.inputs, len(omega)) ndarray + The magnitude (absolute value, not dB or log10) of the system + frequency response. + phase : (self.outputs, self.inputs, len(omega)) ndarray + The wrapped phase in radians of the system frequency response. + omega : ndarray or list or tuple + The list of sorted frequencies at which the response was + evaluated. """ - # Preallocate outputs. numfreq = len(omega) mag = empty((self.outputs, self.inputs, numfreq)) diff --git a/control/lti.py b/control/lti.py index c9a58f9c0..8db14794b 100644 --- a/control/lti.py +++ b/control/lti.py @@ -55,8 +55,8 @@ def isdtime(self, strict=False): Parameters ---------- strict: bool, optional - If strict is True, make sure that timebase is not None. Default - is False. + If strict is True, make sure that timebase is not None. Default + is False. """ # If no timebase is given, answer depends on strict flag @@ -75,8 +75,8 @@ def isctime(self, strict=False): sys : LTI system System to be checked strict: bool, optional - If strict is True, make sure that timebase is not None. Default - is False. + If strict is True, make sure that timebase is not None. Default + is False. """ # If no timebase is given, answer depends on strict flag if self.dt is None: @@ -421,6 +421,7 @@ def evalfr(sys, x): return sys.horner(x)[0][0] return sys.horner(x) + def freqresp(sys, omega): """ Frequency response of an LTI system at multiple angular frequencies. @@ -430,13 +431,20 @@ def freqresp(sys, omega): sys: StateSpace or TransferFunction Linear system omega: array_like - List of frequencies + A list of frequencies in radians/sec at which the system should be + evaluated. The list can be either a python list or a numpy array + and will be sorted before evaluation. Returns ------- - mag: ndarray - phase: ndarray - omega: list, tuple, or ndarray + mag : (self.outputs, self.inputs, len(omega)) ndarray + The magnitude (absolute value, not dB or log10) of the system + frequency response. + phase : (self.outputs, self.inputs, len(omega)) ndarray + The wrapped phase in radians of the system frequency response. + omega : ndarray or list or tuple + The list of sorted frequencies at which the response was + evaluated. See Also -------- @@ -472,9 +480,9 @@ def freqresp(sys, omega): #>>> # frequency response from the 1st input to the 2nd output, for #>>> # s = 0.1i, i, 10i. """ - return sys.freqresp(omega) + def dcgain(sys): """Return the zero-frequency (or DC) gain of the given system diff --git a/control/statesp.py b/control/statesp.py index 1779dfbfd..d176e98c9 100644 --- a/control/statesp.py +++ b/control/statesp.py @@ -462,11 +462,8 @@ def horner(self, s): self.B)) + self.D return array(resp) - # Method for generating the frequency response of the system def freqresp(self, omega): - """Evaluate the system's transfer func. at a list of freqs, omega. - - mag, phase, omega = self.freqresp(omega) + """Evaluate the system's transfer function at a list of frequencies Reports the frequency response of the system, @@ -479,26 +476,22 @@ def freqresp(self, omega): Parameters ---------- - omega : array + omega : array_like A list of frequencies in radians/sec at which the system should be evaluated. The list can be either a python list or a numpy array and will be sorted before evaluation. Returns ------- - mag : float + mag : (self.outputs, self.inputs, len(omega)) ndarray The magnitude (absolute value, not dB or log10) of the system frequency response. - - phase : float + phase : (self.outputs, self.inputs, len(omega)) ndarray The wrapped phase in radians of the system frequency response. - - omega : array + omega : ndarray The list of sorted frequencies at which the response was evaluated. - """ - # In case omega is passed in as a list, rather than a proper array. omega = np.asarray(omega) diff --git a/control/xferfcn.py b/control/xferfcn.py index cb351de0f..96f3b5ca8 100644 --- a/control/xferfcn.py +++ b/control/xferfcn.py @@ -639,19 +639,36 @@ def horner(self, s): return out - # Method for generating the frequency response of the system def freqresp(self, omega): - """Evaluate a transfer function at a list of angular frequencies. + """Evaluate the transfer function at a list of angular frequencies. - mag, phase, omega = self.freqresp(omega) + Reports the frequency response of the system, - reports the value of the magnitude, phase, and angular frequency of - the transfer function matrix evaluated at s = i * omega, where omega - is a list of angular frequencies, and is a sorted version of the input - omega. + G(j*omega) = mag*exp(j*phase) - """ + for continuous time. For discrete time systems, the response is + evaluated around the unit circle such that + + G(exp(j*omega*dt)) = mag*exp(j*phase). + + Parameters + ---------- + omega : array_like + A list of frequencies in radians/sec at which the system should be + evaluated. The list can be either a python list or a numpy array + and will be sorted before evaluation. + Returns + ------- + mag : (self.outputs, self.inputs, len(omega)) ndarray + The magnitude (absolute value, not dB or log10) of the system + frequency response. + phase : (self.outputs, self.inputs, len(omega)) ndarray + The wrapped phase in radians of the system frequency response. + omega : ndarray or list or tuple + The list of sorted frequencies at which the response was + evaluated. + """ # Preallocate outputs. numfreq = len(omega) mag = empty((self.outputs, self.inputs, numfreq)) diff --git a/examples/robust_mimo.py b/examples/robust_mimo.py index 402d91488..d4e1335e6 100644 --- a/examples/robust_mimo.py +++ b/examples/robust_mimo.py @@ -44,7 +44,7 @@ def triv_sigma(g, w): w - frequencies, length m s - (m,n) array of singular values of g(1j*w)""" m, p, _ = g.freqresp(w) - sjw = (m*np.exp(1j*p*np.pi/180)).transpose(2, 0, 1) + sjw = (m*np.exp(1j*p)).transpose(2, 0, 1) sv = np.linalg.svd(sjw, compute_uv=False) return sv From 38c46acd38ffd4b0b650bd35c3c4e7282b631704 Mon Sep 17 00:00:00 2001 From: Ben Greiner Date: Sat, 11 Jul 2020 04:34:41 +0200 Subject: [PATCH 14/67] install cmake from conda (#427) --- .travis.yml | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/.travis.yml b/.travis.yml index d0201031b..022e48c6f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -19,7 +19,7 @@ python: # Test against multiple version of SciPy, with and without slycot # -# Because there were significant changes in SciPy between v0 and v1, we +# Because there were significant changes in SciPy between v0 and v1, we # test against both of these using the Travis CI environment capability # # We also want to test with and without slycot @@ -84,7 +84,6 @@ before_install: sudo apt-get update -qq; sudo apt-get install liblapack-dev libblas-dev; sudo apt-get install gfortran; - sudo apt-get install cmake; fi # use miniconda to install numpy/scipy, to avoid lengthy build from source - if [[ "$TRAVIS_PYTHON_VERSION" == "2.7" ]]; then @@ -104,7 +103,7 @@ before_install: # Install scikit-build for the build process if slycot is being used - if [[ "$SLYCOT" = "source" ]]; then conda install openblas; - conda install -c conda-forge scikit-build; + conda install -c conda-forge cmake scikit-build; fi # Make sure to look in the right place for python libraries (for slycot) - export LIBRARY_PATH="$HOME/miniconda/envs/test-environment/lib" From 711a5128893bae6865c864130530c0ec83c5fbe5 Mon Sep 17 00:00:00 2001 From: Ben Greiner Date: Sat, 11 Jul 2020 17:00:09 +0200 Subject: [PATCH 15/67] Fix margin indexing bug in FRD stability margin computation + code cleanup (#425) * fix #407 (stability_margins Fails for Many FRD Systems at Stab Margins) * clean up indexing * add margin index test * reorganize and clean up margin_test.py --- control/margins.py | 52 ++- control/tests/freqresp_test.py | 8 +- control/tests/margin_test.py | 615 ++++++++++++++++----------------- control/tests/rlocus_test.py | 5 +- control/tests/sisotool_test.py | 61 ++-- 5 files changed, 380 insertions(+), 361 deletions(-) mode change 100644 => 100755 control/tests/margin_test.py diff --git a/control/margins.py b/control/margins.py index 193b6c599..7bdcf6caa 100644 --- a/control/margins.py +++ b/control/margins.py @@ -1,12 +1,12 @@ -"""margin.py +"""margins.py Functions for computing stability margins and related functions. Routines in this module: -margin.stability_margins -margin.phase_crossover_frequencies -margin.margin +margins.stability_margins +margins.phase_crossover_frequencies +margins.margin """ # Python 3 compatibility (needs to go here) @@ -211,41 +211,40 @@ def stability_margins(sysdata, returnall=False, epsw=0.0): else: # a bit coarse, have the interpolated frd evaluated again - def mod(w): - """to give the function to calculate |G(jw)| = 1""" + def _mod(w): + """Calculate |G(jw)| - 1""" return np.abs(sys._evalfr(w)[0][0]) - 1 - def arg(w): - """function to calculate the phase angle at -180 deg""" + def _arg(w): + """Calculate the phase angle at -180 deg""" return np.angle(-sys._evalfr(w)[0][0]) - def dstab(w): - """function to calculate the distance from -1 point""" + def _dstab(w): + """Calculate the distance from -1 point""" return np.abs(sys._evalfr(w)[0][0] + 1.) # Find all crossings, note that this depends on omega having # a correct range - widx = np.where(np.diff(np.sign(mod(sys.omega))))[0] + widx = np.where(np.diff(np.sign(_mod(sys.omega))))[0] wc = np.array( - [ sp.optimize.brentq(mod, sys.omega[i], sys.omega[i+1]) - for i in widx if i+1 < len(sys.omega)]) + [sp.optimize.brentq(_mod, sys.omega[i], sys.omega[i+1]) + for i in widx]) # find the phase crossings ang(H(jw) == -180 - widx = np.where(np.diff(np.sign(arg(sys.omega))))[0] + widx = np.where(np.diff(np.sign(_arg(sys.omega))))[0] widx = widx[np.real(sys._evalfr(sys.omega[widx])[0][0]) <= 0] w_180 = np.array( - [ sp.optimize.brentq(arg, sys.omega[i], sys.omega[i+1]) - for i in widx if i+1 < len(sys.omega) ]) + [sp.optimize.brentq(_arg, sys.omega[i], sys.omega[i+1]) + for i in widx]) # find all stab margins? - widx = np.where(np.diff(np.sign(np.diff(dstab(sys.omega)))))[0] - wstab = np.array([ sp.optimize.minimize_scalar( - dstab, bracket=(sys.omega[i], sys.omega[i+1])).x - for i in widx if i+1 < len(sys.omega) and - np.diff(np.diff(dstab(sys.omega[i-1:i+2])))[0] > 0 ]) - wstab = wstab[(wstab >= sys.omega[0]) * - (wstab <= sys.omega[-1])] - + widx, = np.where(np.diff(np.sign(np.diff(_dstab(sys.omega)))) > 0) + wstab = np.array( + [sp.optimize.minimize_scalar(_dstab, + bracket=(sys.omega[i], sys.omega[i+1]) + ).x + for i in widx]) + wstab = wstab[(wstab >= sys.omega[0]) * (wstab <= sys.omega[-1])] # margins, as iterables, converted frdata and xferfcn calculations to # vector for this @@ -254,13 +253,13 @@ def dstab(w): GM = 1.0/gain_w_180 SM = np.abs(sys._evalfr(wstab)[0][0]+1) PM = np.remainder(np.angle(sys._evalfr(wc)[0][0], deg=True), 360.0) - 180.0 - + if returnall: return GM, PM, SM, w_180, wc, wstab else: if GM.shape[0] and not np.isinf(GM).all(): with np.errstate(all='ignore'): - gmidx = np.where(np.abs(np.log(GM)) == + gmidx = np.where(np.abs(np.log(GM)) == np.min(np.abs(np.log(GM)))) else: gmidx = -1 @@ -276,7 +275,6 @@ def dstab(w): # Contributed by Steffen Waldherr -#! TODO - need to add test functions def phase_crossover_frequencies(sys): """Compute frequencies and gains at intersections with real axis in Nyquist plot. diff --git a/control/tests/freqresp_test.py b/control/tests/freqresp_test.py index 7e803a9e6..9d59a1972 100644 --- a/control/tests/freqresp_test.py +++ b/control/tests/freqresp_test.py @@ -7,14 +7,16 @@ # including bode plots. import unittest +import matplotlib.pyplot as plt import numpy as np +from numpy.testing import assert_array_almost_equal + import control as ctrl from control.statesp import StateSpace from control.xferfcn import TransferFunction from control.matlab import ss, tf, bode, rss from control.exception import slycot_check -from control.tests.margin_test import assert_array_almost_equal -import matplotlib.pyplot as plt + class TestFreqresp(unittest.TestCase): def setUp(self): @@ -51,7 +53,7 @@ def test_superimpose(self): for ax in plt.gcf().axes: # Make sure there are 2 lines in each subplot assert len(ax.get_lines()) == 2 - + # Generate two plots as a list; should be on the same axes plt.figure(2); plt.clf(); ctrl.bode_plot([ctrl.tf([1], [1,2,1]), ctrl.tf([5], [1, 1])]) diff --git a/control/tests/margin_test.py b/control/tests/margin_test.py old mode 100644 new mode 100755 index 85404b449..2f60c7bc6 --- a/control/tests/margin_test.py +++ b/control/tests/margin_test.py @@ -1,315 +1,312 @@ -#!/usr/bin/env python -# -# margin_test.py - test suite for stability margin commands -# RMM, 15 Jul 2011 +#!/usr/bin/env pytest +""" +margin_test.py - test suite for stability margin commands +RMM, 15 Jul 2011 +BG, 30 Juin 2020 -- convert to pytest, gh-425 +""" from __future__ import print_function -import unittest + import numpy as np -from control.xferfcn import TransferFunction -from control.frdata import FRD +from numpy import inf, nan +from numpy.testing import assert_allclose +import pytest + +from control.frdata import FrequencyResponseData +from control.margins import margin, phase_crossover_frequencies, \ + stability_margins from control.statesp import StateSpace -from control.margins import * - -def assert_array_almost_equal(x, y, ndigit=4): - - x = np.array(x) - y = np.array(y) - try: - if np.isfinite(x).any() and \ - np.equal(np.isfinite(x), np.isfinite(y)).all() and \ - np.equal(np.isnan(x), np.isnan(y)).all(): - np.testing.assert_array_almost_equal( - x[np.isfinite(x)], y[np.isfinite(y)], ndigit) - return - except TypeError as e: - print("Error", e, "with", x, "and", y) - #raise e - np.testing.assert_array_almost_equal(x, y, ndigit) - -class TestMargin(unittest.TestCase): - """These are tests for the margin commands in margin.py.""" - - def setUp(self): - # system, gain margin, gm freq, phase margin, pm freq - s = TransferFunction([1, 0], [1]) - self.tsys = ( - (TransferFunction([1, 2], [1, 2, 3]), - [], [], [], []), +from control.xferfcn import TransferFunction + + +s = TransferFunction([1, 0], [1]) + +# (system, stability_margins(sys), stability_margins(sys, returnall=True)) +tsys = [(TransferFunction([1, 2], [1, 2, 3]), + (inf, inf, inf, nan, nan, nan), + ([], [], [], [], [], [])), (TransferFunction([1], [1, 2, 3, 4]), - [2.001], [1.7321], [], []), + (2., inf, 0.4170, 1.7321, nan, 1.6620), + ([2.], [], [1.2500, 0.4170], [1.7321], [], [0.1690, 1.6620])), (StateSpace([[1., 4.], [3., 2.]], [[1.], [-4.]], - [[1., 0.]], [[0.]]), - [], [], [147.0743], [2.5483]), - ((8.75*(4*s**2+0.4*s+1))/((100*s+1)*(s**2+0.22*s+1)) * - 1./(s**2/(10.**2)+2*0.04*s/10.+1), - [2.2716], [10.0053], [97.5941, -157.7904, 134.7359], - [0.0850, 0.9373, 1.0919])) - - - """ - sys1 = tf([1, 2], [1, 2, 3]); - sys2 = tf([1], [1, 2, 3, 4]); - sys3 = ss([1, 4; 3, 2], [1; -4], ... - [1, 0], [0]) - s = tf('s') - sys4 = (8.75*(4*s^2+0.4*s+1))/((100*s+1)*(s^2+0.22*s+1)) * ... - 1.0/(s^2/(10.0^2)+2*0.04*s/10.0+1); - """ - - self.sys1 = TransferFunction([1, 2], [1, 2, 3]) - # alternative - # sys1 = tf([1, 2], [1, 2, 3]) - self.sys2 = TransferFunction([1], [1, 2, 3, 4]) - self.sys3 = StateSpace([[1., 4.], [3., 2.]], [[1.], [-4.]], - [[1., 0.]], [[0.]]) - s = TransferFunction([1, 0], [1]) - self.sys4 = (8.75*(4*s**2+0.4*s+1))/((100*s+1)*(s**2+0.22*s+1)) * \ - 1./(s**2/(10.**2)+2*0.04*s/10.+1) - self.stability_margins4 = \ - [2.2716, 97.5941, 0.5591, 10.0053, 0.0850, 9.9918] - - """ - hm1 = s/(s+1); - h0 = 1/(s+1)^3; - h1 = (s + 0.1)/s/(s+1); - h2 = (s + 0.1)/s^2/(s+1); - h3 = (s + 0.1)*(s+0.1)/s^3/(s+1); - """ - self.types = { - 'typem1': s/(s+1), - 'type0': 1/(s+1)**3, - 'type1': (s + 0.1)/s/(s+1), - 'type2': (s + 0.1)/s**2/(s+1), - 'type3': (s + 0.1)*(s+0.1)/s**3/(s+1) } - self.tmargin = ( self.types, - dict(sys='typem1', K=2.0, digits=3, result=( - float('Inf'), -120.0007, float('NaN'), 0.5774)), - dict(sys='type0', K = 0.8, digits=3, result=( - 10.0014, float('inf'), 1.7322, float('nan'))), - dict(sys='type0', K = 2.0, digits=2, result=( - 4.000, 67.6058, 1.7322, 0.7663)), - dict(sys='type1', K=1.0, digits=4, result=( - float('Inf'), 144.9032, float('NaN'), 0.3162)), - dict(sys='type2', K=1.0, digits=4, result=( - float('Inf'), 44.4594, float('NaN'), 0.7907)), - dict(sys='type3', K=1.0, digits=3, result=( - 0.0626, 37.1748, 0.1119, 0.7951)), - ) - - - # from "A note on the Gain and Phase Margin Concepts - # Journal of Control and Systems Engineering, Yazdan Bavafi-Toosi, - # Dec 2015, vol 3 iss 1, pp 51-59 - # - # A cornucopia of tricky systems for phase / gain margin - # Still have to convert more to tests + fix margin to handle - # also these torture cases - """ - % matlab compatible - s = tf('s'); - h21 = 0.002*(s+0.02)*(s+0.05)*(s+5)*(s+10)/( ... - (s-0.0005)*(s+0.0001)*(s+0.01)*(s+0.2)*(s+1)*(s+100)^2 ); - h23 = ((s+0.1)^2 + 1)*(s-0.1)/( ... - ((s+0.1)^2+4)*(s+1) ); - h25a = s/(s^2+2*s+2)^4; h25b = h25a*100; - h26a = ((s-0.1)^2 + 1)/( ... - (s + 0.1)*((s-0.2)^2 + 4) ) ; - h26b = ((s-0.1)^2 + 1)/( ... - (s - 0.3)*((s-0.2)^2 + 4) ); - """ - self.yazdan = { - 'example21' : - 0.002*(s+0.02)*(s+0.05)*(s+5)*(s+10)/( - (s-0.0005)*(s+0.0001)*(s+0.01)*(s+0.2)*(s+1)*(s+100)**2 ), - - 'example23' : - ((s+0.1)**2 + 1)*(s-0.1)/( - ((s+0.1)**2+4)*(s+1) ), - - 'example25a' : - s/(s**2+2*s+2)**4, - - 'example26a' : - ((s-0.1)**2 + 1)/( - (s + 0.1)*((s-0.2)**2 + 4) ), - - 'example26b': ((s-0.1)**2 + 1)/( - (s - 0.3)*((s-0.2)**2 + 4) ) - } - self.yazdan['example24'] = self.yazdan['example21']*20000 - self.yazdan['example25b'] = self.yazdan['example25a']*100 - self.yazdan['example22'] = self.yazdan['example21']*(s**2 - 2*s + 401) - self.ymargin = ( - dict(sys='example21', K=1.0, digits=2, result=( - 0.0100, -14.5640, 0, 0.0022)), - dict(sys='example21', K=1000.0, digits=2, result=( - 0.1793, 22.5215, 0.0243, 0.0630)), - dict(sys='example21', K=5000.0, digits=4, result=( - 4.5596, 21.2101, 0.4385, 0.1868)), - ) - - self.yallmargin = ( - dict(sys='example21', K=1.0, result=( - [0.01, 179.2931, 2.2798e+4, 1.5946e+07, 7.2477e+08], - [0, 0.0243, 0.4385, 6.8640, 84.9323], - [-14.5640], - [0.0022])) - ) - - - def test_stability_margins(self): - omega = np.logspace(-2, 2, 2000) - for sys,rgm,rwgm,rpm,rwpm in self.tsys: - print(sys) - out = np.array(stability_margins(sys)) - gm, pm, sm, wg, wp, ws = out - outf = np.array(stability_margins(FRD(sys, omega))) - print(out,'\n', outf) - #print(out != np.array(None)) - assert_array_almost_equal( - out, outf, 2) - # final one with fixed values - assert_array_almost_equal( - [gm, pm, sm, wg, wp, ws], - self.stability_margins4, 3) - - def test_margin(self): - gm, pm, wg, wp = margin(self.sys4) - assert_array_almost_equal( - [gm, pm, wg, wp], - self.stability_margins4[:2] + self.stability_margins4[3:5], 3) - - - def test_stability_margins_all(self): - for sys,rgm,rwgm,rpm,rwpm in self.tsys: - out = stability_margins(sys, returnall=True) - gm, pm, sm, wg, wp, ws = out - print(sys) - for res,comp in zip(out, (rgm,rpm,[],rwgm,rwpm,[])): - if comp: - print(res, '\n', comp) - assert_array_almost_equal( - res, comp, 2) - - def test_phase_crossover_frequencies(self): - omega, gain = phase_crossover_frequencies(self.sys2) - assert_array_almost_equal(omega, [1.73205, 0.]) - assert_array_almost_equal(gain, [-0.5, 0.25]) - - tf = TransferFunction([1],[1,1]) - omega, gain = phase_crossover_frequencies(tf) - assert_array_almost_equal(omega, [0.]) - assert_array_almost_equal(gain, [1.]) - - # testing MIMO, only (0,0) element is considered - tf = TransferFunction([[[1],[2]],[[3],[4]]], - [[[1, 2, 3, 4],[1,1]],[[1,1],[1,1]]]) - omega, gain = phase_crossover_frequencies(tf) - assert_array_almost_equal(omega, [1.73205081, 0.]) - assert_array_almost_equal(gain, [-0.5, 0.25]) - - def test_mag_phase_omega(self): - # test for bug reported in gh-58 - sys = TransferFunction(15, [1, 6, 11, 6]) - out = stability_margins(sys) - omega = np.logspace(-2,2,1000) - mag, phase, omega = sys.freqresp(omega) - #print( mag, phase, omega) - out2 = stability_margins((mag, phase*180/np.pi, omega)) - ind = [0,1,3,4] # indices of gm, pm, wg, wp -- ignore sm - marg1 = np.array(out)[ind] - marg2 = np.array(out2)[ind] - assert_array_almost_equal(marg1, marg2, 4) - - def test_frd(self): - f = np.array([0.005, 0.010, 0.020, 0.030, 0.040, - 0.050, 0.060, 0.070, 0.080, 0.090, - 0.100, 0.200, 0.300, 0.400, 0.500, - 0.750, 1.000, 1.250, 1.500, 1.750, - 2.000, 2.250, 2.500, 2.750, 3.000, - 3.250, 3.500, 3.750, 4.000, 4.250, - 4.500, 4.750, 5.000, 6.000, 7.000, - 8.000, 9.000, 10.000 ]) - gain = np.array([ 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.0, 0.0, 0.0, 0.0, - 0.0, 0.1, 0.2, 0.3, 0.5, - 0.5, -0.4, -2.3, -4.8, -7.3, - -9.6, -11.7, -13.6, -15.3, -16.9, - -18.3, -19.6, -20.8, -22.0, -23.1, - -24.1, -25.0, -25.9, -29.1, -31.9, - -34.2, -36.2, -38.1 ]) - phase = np.array([ 0, -1, -2, -3, -4, - -5, -6, -7, -8, -9, - -10, -19, -29, -40, -51, - -81, -114, -144, -168, -187, - -202, -214, -224, -233, -240, - -247, -253, -259, -264, -269, - -273, -277, -280, -292, -301, - -307, -313, -317 ]) - # calculate response as complex number - resp = 10**(gain / 20) * np.exp(1j * phase / (180./np.pi)) - # frequency response data - fresp = FRD(resp, f*2*np.pi, smooth=True) - s=TransferFunction([1,0],[1]) - G=1./(s**2) - K=1. - C=K*(1+1.9*s) - TFopen=fresp*C*G - gm, pm, sm, wg, wp, ws = stability_margins(TFopen) - assert_array_almost_equal( - [pm], [44.55], 2) - - def test_nocross(self): - # what happens when no gain/phase crossover? - s = TransferFunction([1, 0], [1]) - h1 = 1/(1+s) - h2 = 3*(10+s)/(2+s) - h3 = 0.01*(10-s)/(2+s)/(1+s) - gm, pm, wm, wg, wp, ws = stability_margins(h1) - assert_array_almost_equal( - [gm, pm, wg, wp], - [float('Inf'), float('Inf'), float('NaN'), float('NaN')]) - gm, pm, wm, wg, wp, ws = stability_margins(h2) - self.assertEqual(pm, float('Inf')) - gm, pm, wm, wg, wp, ws = stability_margins(h3) - self.assertTrue(np.isnan(wp)) - omega = np.logspace(-2,2, 100) - out1b = stability_margins(FRD(h1, omega)) - out2b = stability_margins(FRD(h2, omega)) - out3b = stability_margins(FRD(h3, omega)) - - def test_zmore_margin(self): - print(""" - warning, Matlab gives different values (0 and 0) for gain - margin of the following system: - {type2!s} - python-control gives inf - difficult to argue which is right? Special case or different - approach? - - edge cases, like - {type0!s} - which approaches a gain of 1 for w -> 0, are also not identically - indicated, Matlab gives phase margin -180, at w = 0. for higher or - lower gains, results match - """.format(**self.types)) - - sdict = self.tmargin[0] - for test in self.tmargin[1:]: - res = margin(sdict[test['sys']]*test['K']) - print("more margin {}\n".format(sdict[test['sys']]), - res, '\n', test['result']) - assert_array_almost_equal( - res, test['result'], test['digits']) - sdict = self.yazdan - for test in self.ymargin: - res = margin(sdict[test['sys']]*test['K']) - print("more margin {}\n".format(sdict[test['sys']]), - res, '\n', test['result']) - assert_array_almost_equal( - res, test['result'], test['digits']) - - -if __name__ == "__main__": - unittest.main() + [[1., 0.]], [[0.]]), + (inf, 147.0743, inf, nan, 2.5483, nan), + ([], [147.0743], [], [], [2.5483], [])), + ((8.75*(4*s**2+0.4*s+1)) / ((100*s+1)*(s**2+0.22*s+1)) + / (s**2/(10.**2)+2*0.04*s/10.+1), + (2.2716, 97.5941, 0.5591, 10.0053, 0.0850, 9.9918), + ([2.2716], [97.5941, -157.7844, 134.7359], [1.0381, 0.5591], + [10.0053], [0.0850, 0.9373, 1.0919], [0.4064, 9.9918])), + (1/(1+s), # no gain/phase crossovers + (inf, inf, inf, nan, nan, nan), + ([], [], [], [], [], [])), + (3*(10+s)/(2+s), # no gain/phase crossovers + (inf, inf, inf, nan, nan, nan), + ([], [], [], [], [], [])), + (0.01*(10-s)/(2+s)/(1+s), # no phase crossovers + (300.0, inf, 0.9917, 5.6569, nan, 2.3171), + ([300.0], [], [0.9917], [5.6569], [], 2.3171))] + + +def compare_allmargins(actual, desired, **kwargs): + """Compare all elements of stability_margins(returnall=True) result""" + assert len(actual) == len(desired) + for a, d in zip(actual, desired): + assert_allclose(a, d, **kwargs) + + +@pytest.mark.parametrize("sys, refout, refoutall", tsys) +def test_stability_margins(sys, refout, refoutall): + """Test stability_margins() function""" + out = stability_margins(sys) + assert_allclose(out, refout, atol=1.5e-2) + out = stability_margins(sys, returnall=True) + compare_allmargins(out, refoutall, atol=1.5e-2) + + +@pytest.mark.parametrize("sys, refout, refoutall", tsys) +def test_stability_margins_omega(sys, refout, refoutall): + """Test stability_margins() with interpolated frequencies""" + omega = np.logspace(-2, 2, 2000) + out = stability_margins(FrequencyResponseData(sys, omega)) + assert_allclose(out, refout, atol=1.5e-3) + + +@pytest.mark.parametrize("sys, refout, refoutall", tsys) +def test_stability_margins_3input(sys, refout, refoutall): + """Test stability_margins() function with mag, phase, omega input""" + omega = np.logspace(-2, 2, 2000) + mag, phase, omega_ = sys.freqresp(omega) + out = stability_margins((mag, phase*180/np.pi, omega_)) + assert_allclose(out, refout, atol=1.5e-3) + + +@pytest.mark.parametrize("sys, refout, refoutall", tsys) +def test_margin_sys(sys, refout, refoutall): + """Test margin() function with system input""" + out = margin(sys) + assert_allclose(out, np.array(refout)[[0, 1, 3, 4]], atol=1.5e-3) + + +@pytest.mark.parametrize("sys, refout, refoutall", tsys) +def test_margin_3input(sys, refout, refoutall): + """Test margin() function with mag, phase, omega input""" + omega = np.logspace(-2, 2, 2000) + mag, phase, omega_ = sys.freqresp(omega) + out = margin((mag, phase*180/np.pi, omega_)) + assert_allclose(out, np.array(refout)[[0, 1, 3, 4]], atol=1.5e-3) + + +def test_phase_crossover_frequencies(): + """Test phase_crossover_frequencies() function""" + omega, gain = phase_crossover_frequencies(tsys[1][0]) + assert_allclose(omega, [1.73205, 0.], atol=1.5e-3) + assert_allclose(gain, [-0.5, 0.25], atol=1.5e-3) + + tf = TransferFunction([1], [1, 1]) + omega, gain = phase_crossover_frequencies(tf) + assert_allclose(omega, [0.], atol=1.5e-3) + assert_allclose(gain, [1.], atol=1.5e-3) + + # testing MIMO, only (0,0) element is considered + tf = TransferFunction([[[1], [2]], + [[3], [4]]], + [[[1, 2, 3, 4], [1, 1]], + [[1, 1], [1, 1]]]) + omega, gain = phase_crossover_frequencies(tf) + assert_allclose(omega, [1.73205, 0.], atol=1.5e-3) + assert_allclose(gain, [-0.5, 0.25], atol=1.5e-3) + + +def test_mag_phase_omega(): + """Test for bug reported in gh-58""" + sys = TransferFunction(15, [1, 6, 11, 6]) + out = stability_margins(sys) + omega = np.logspace(-2, 2, 1000) + mag, phase, omega = sys.freqresp(omega) + out2 = stability_margins((mag, phase*180/np.pi, omega)) + ind = [0, 1, 3, 4] # indices of gm, pm, wg, wp -- ignore sm + marg1 = np.array(out)[ind] + marg2 = np.array(out2)[ind] + assert_allclose(marg1, marg2, atol=1.5e-3) + + +def test_frd(): + """Test FrequencyResonseData margins""" + f = np.array([0.005, 0.010, 0.020, 0.030, 0.040, + 0.050, 0.060, 0.070, 0.080, 0.090, + 0.100, 0.200, 0.300, 0.400, 0.500, + 0.750, 1.000, 1.250, 1.500, 1.750, + 2.000, 2.250, 2.500, 2.750, 3.000, + 3.250, 3.500, 3.750, 4.000, 4.250, + 4.500, 4.750, 5.000, 6.000, 7.000, + 8.000, 9.000, 10.000]) + gain = np.array([ 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.0, 0.0, 0.0, 0.0, + 0.0, 0.1, 0.2, 0.3, 0.5, + 0.5, -0.4, -2.3, -4.8, -7.3, + -9.6, -11.7, -13.6, -15.3, -16.9, + -18.3, -19.6, -20.8, -22.0, -23.1, + -24.1, -25.0, -25.9, -29.1, -31.9, + -34.2, -36.2, -38.1]) + phase = np.array([ 0, -1, -2, -3, -4, + -5, -6, -7, -8, -9, + -10, -19, -29, -40, -51, + -81, -114, -144, -168, -187, + -202, -214, -224, -233, -240, + -247, -253, -259, -264, -269, + -273, -277, -280, -292, -301, + -307, -313, -317]) + # calculate response as complex number + resp = 10**(gain / 20) * np.exp(1j * phase / (180./np.pi)) + # frequency response data + fresp = FrequencyResponseData(resp, f*2*np.pi, smooth=True) + s = TransferFunction([1, 0], [1]) + G = 1./(s**2) + K = 1. + C = K*(1+1.9*s) + TFopen = fresp*C*G + gm, pm, sm, wg, wp, ws = stability_margins(TFopen) + assert_allclose([pm], [44.55], atol=.01) + + +def test_frd_indexing(): + """Test FRD edge cases + + Make sure frd objects with non benign data do not raise exceptions when + the stability criteria evaluate at the first or last frequency point + bug reported in gh-407 + """ + # frequency points just a little under 1. and over 2. + w = np.linspace(.99, 2.01, 11) + + # Note: stability_margins will convert the frd with smooth=True + + # gain margins + # p crosses -180 at w[0]=1. and w[-1]=2. + m = 0.6 + p = -180*(2*w-1) + d = m*np.exp(1J*np.pi/180*p) + frd_gm = FrequencyResponseData(d, w) + gm, _, _, wg, _, _ = stability_margins(frd_gm, returnall=True) + assert_allclose(gm, [1/m, 1/m], atol=0.01) + assert_allclose(wg, [1., 2.], atol=0.01) + + # phase margins + # m crosses 1 at w[0]=1. and w[-1]=2. + m = -(2*w-3)**4 + 2 + p = -90. + d = m*np.exp(1J*np.pi/180*p) + frd_pm = FrequencyResponseData(d, w) + _, pm, _, _, wp, _ = stability_margins(frd_pm, returnall=True) + assert_allclose(pm, [90., 90.], atol=0.01) + assert_allclose(wp, [1., 2.], atol=0.01) + + # stability margins + # minimum abs(d+1)=1-m at w[1]=1. and w[-2]=2., in nyquist plot + w = np.arange(.9, 2.1, 0.1) + m = 0.6 + p = -180*(2*w-1) + d = m*np.exp(1J*np.pi/180*p) + frd_sm = FrequencyResponseData(d, w) + _, _, sm, _, _, ws = stability_margins(frd_sm, returnall=True) + assert_allclose(sm, [1-m, 1-m], atol=0.01) + assert_allclose(ws, [1., 2.], atol=0.01) + + +""" +NOTE: +Matlab gives gain margin 0 for system `type2`, python-control gives inf +Difficult to argue which is right? Special case or different approach? + +Edge cases, like `type0` which approaches a gain of 1 for w -> 0, are also not +identically indicated, Matlab gives phase margin -180, at w = 0. For higher or +lower gains, results match. +""" +tzmore_sys = { + 'typem1': s/(s+1), + 'type0': 1/(s+1)**3, + 'type1': (s + 0.1)/s/(s+1), + 'type2': (s + 0.1)/s**2/(s+1), + 'type3': (s + 0.1)*(s+0.1)/s**3/(s+1)} +tzmore_margin = [ + dict(sys='typem1', K=2.0, atol=1.5e-3, result=( + float('Inf'), -120.0007, float('NaN'), 0.5774)), + dict(sys='type0', K=0.8, atol=1.5e-3, result=( + 10.0014, float('inf'), 1.7322, float('nan'))), + dict(sys='type0', K=2.0, atol=1e-2, result=( + 4.000, 67.6058, 1.7322, 0.7663)), + dict(sys='type1', K=1.0, atol=1e-4, result=( + float('Inf'), 144.9032, float('NaN'), 0.3162)), + dict(sys='type2', K=1.0, atol=1e-4, result=( + float('Inf'), 44.4594, float('NaN'), 0.7907)), + dict(sys='type3', K=1.0, atol=1.5e-3, result=( + 0.0626, 37.1748, 0.1119, 0.7951)), + ] +tzmore_stability_margins = [] + +""" +from "A note on the Gain and Phase Margin Concepts +Journal of Control and Systems Engineering, Yazdan Bavafi-Toosi, +Dec 2015, vol 3 iss 1, pp 51-59 + +A cornucopia of tricky systems for phase / gain margin +TODO: still have to convert more to tests + fix margin to handle +also these torture cases +""" +yazdan = { + 'example21': + 0.002*(s+0.02)*(s+0.05)*(s+5)*(s+10)/( + (s-0.0005)*(s+0.0001)*(s+0.01)*(s+0.2)*(s+1)*(s+100)**2), + 'example23': + ((s+0.1)**2 + 1)*(s-0.1)/( + ((s+0.1)**2+4)*(s+1)), + 'example25a': + s/(s**2+2*s+2)**4, + 'example26a': + ((s-0.1)**2 + 1)/( + (s + 0.1)*((s-0.2)**2 + 4)), + 'example26b': ((s-0.1)**2 + 1)/( + (s - 0.3)*((s-0.2)**2 + 4)) +} +yazdan['example24'] = yazdan['example21']*20000 +yazdan['example25b'] = yazdan['example25a']*100 +yazdan['example22'] = yazdan['example21']*(s**2 - 2*s + 401) +ymargin = [ + dict(sys='example21', K=1.0, atol=1e-2, + result=(0.0100, -14.5640, 0, 0.0022)), + dict(sys='example21', K=1000.0, atol=1e-2, + result=(0.1793, 22.5215, 0.0243, 0.0630)), + dict(sys='example21', K=5000.0, atol=1.5e-3, + result=(4.5596, 21.2101, 0.4385, 0.1868)), + ] +ystability_margins = [ + dict(sys='example21', K=1.0, rtol=1e-3, atol=1e-3, + result=([0.01, 179.2931, 2.2798e+4, 1.5946e+07, 7.2477e+08], + [-14.5640], + [0.2496], + [0, 0.0243, 0.4385, 6.8640, 84.9323], + [0.0022], + [0.0022])), + ] + +tzmore_sys.update(yazdan) +tzmore_margin += ymargin +tzmore_stability_margins += ystability_margins + + +@pytest.mark.parametrize('tmargin', tzmore_margin) +def test_zmore_margin(tmargin): + """Test margins for more tricky systems""" + res = margin(tzmore_sys[tmargin['sys']]*tmargin['K']) + assert_allclose(res, tmargin['result'], atol=tmargin['atol']) + + +@pytest.mark.parametrize('tmarginall', tzmore_stability_margins) +def test_zmore_stability_margins(tmarginall): + """Test stability_margins for more tricky systems with returnall""" + res = stability_margins(tzmore_sys[tmarginall['sys']]*tmarginall['K'], + returnall=True) + compare_allmargins(res, tmarginall['result'], + atol=tmarginall['atol'], + rtol=tmarginall['rtol']) diff --git a/control/tests/rlocus_test.py b/control/tests/rlocus_test.py index 647ddd202..966f700d6 100644 --- a/control/tests/rlocus_test.py +++ b/control/tests/rlocus_test.py @@ -4,13 +4,14 @@ # RMM, 1 Jul 2011 import unittest +import matplotlib.pyplot as plt import numpy as np +from numpy.testing import assert_array_almost_equal + from control.rlocus import root_locus, _RLClickDispatcher from control.xferfcn import TransferFunction from control.statesp import StateSpace from control.bdalg import feedback -import matplotlib.pyplot as plt -from control.tests.margin_test import assert_array_almost_equal class TestRootLocus(unittest.TestCase): diff --git a/control/tests/sisotool_test.py b/control/tests/sisotool_test.py index f2cdf9106..e0012a373 100644 --- a/control/tests/sisotool_test.py +++ b/control/tests/sisotool_test.py @@ -1,34 +1,42 @@ import unittest +import matplotlib.pyplot as plt import numpy as np +from numpy.testing import assert_array_almost_equal + from control.sisotool import sisotool -from control.tests.margin_test import assert_array_almost_equal from control.rlocus import _RLClickDispatcher from control.xferfcn import TransferFunction -import matplotlib.pyplot as plt + class TestSisotool(unittest.TestCase): """These are tests for the sisotool in sisotool.py.""" def setUp(self): # One random SISO system. - self.system = TransferFunction([1000],[1,25,100,0]) + self.system = TransferFunction([1000], [1, 25, 100, 0]) def test_sisotool(self): - sisotool(self.system,Hz=False) + sisotool(self.system, Hz=False) fig = plt.gcf() - ax_mag,ax_rlocus,ax_phase,ax_step = fig.axes[0],fig.axes[1],fig.axes[2],fig.axes[3] + ax_mag, ax_rlocus, ax_phase, ax_step = fig.axes[:4] # Check the initial root locus plot points - initial_point_0 = (np.array([-22.53155977]),np.array([0.])) + initial_point_0 = (np.array([-22.53155977]), np.array([0.])) initial_point_1 = (np.array([-1.23422011]), np.array([-6.54667031])) initial_point_2 = (np.array([-1.23422011]), np.array([06.54667031])) - assert_array_almost_equal(ax_rlocus.lines[0].get_data(),initial_point_0) - assert_array_almost_equal(ax_rlocus.lines[1].get_data(),initial_point_1) - assert_array_almost_equal(ax_rlocus.lines[2].get_data(),initial_point_2) + assert_array_almost_equal(ax_rlocus.lines[0].get_data(), + initial_point_0, 4) + assert_array_almost_equal(ax_rlocus.lines[1].get_data(), + initial_point_1, 4) + assert_array_almost_equal(ax_rlocus.lines[2].get_data(), + initial_point_2, 4) # Check the step response before moving the point - step_response_original = np.array([ 0., 0.02233651, 0.13118374, 0.33078542, 0.5907113, 0.87041549, 1.13038536, 1.33851053, 1.47374666, 1.52757114]) - assert_array_almost_equal(ax_step.lines[0].get_data()[1][:10],step_response_original) + step_response_original = np.array( + [0., 0.02233651, 0.13118374, 0.33078542, 0.5907113, 0.87041549, + 1.13038536, 1.33851053, 1.47374666, 1.52757114]) + assert_array_almost_equal(ax_step.lines[0].get_data()[1][:10], + step_response_original, 4) bode_plot_params = { 'omega': None, @@ -43,24 +51,37 @@ def test_sisotool(self): } # Move the rootlocus to another point - event = type('test', (object,), {'xdata': 2.31206868287,'ydata':15.5983051046, 'inaxes':ax_rlocus.axes})() - _RLClickDispatcher(event=event, sys=self.system, fig=fig,ax_rlocus=ax_rlocus,sisotool=True, plotstr='-' ,bode_plot_params=bode_plot_params, tvect=None) + event = type('test', (object,), {'xdata': 2.31206868287, + 'ydata': 15.5983051046, + 'inaxes': ax_rlocus.axes})() + _RLClickDispatcher(event=event, sys=self.system, fig=fig, + ax_rlocus=ax_rlocus, sisotool=True, plotstr='-', + bode_plot_params=bode_plot_params, tvect=None) # Check the moved root locus plot points moved_point_0 = (np.array([-29.91742755]), np.array([0.])) moved_point_1 = (np.array([2.45871378]), np.array([-15.52647768])) moved_point_2 = (np.array([2.45871378]), np.array([15.52647768])) - assert_array_almost_equal(ax_rlocus.lines[-3].get_data(),moved_point_0) - assert_array_almost_equal(ax_rlocus.lines[-2].get_data(),moved_point_1) - assert_array_almost_equal(ax_rlocus.lines[-1].get_data(),moved_point_2) + assert_array_almost_equal(ax_rlocus.lines[-3].get_data(), + moved_point_0, 4) + assert_array_almost_equal(ax_rlocus.lines[-2].get_data(), + moved_point_1, 4) + assert_array_almost_equal(ax_rlocus.lines[-1].get_data(), + moved_point_2, 4) # Check if the bode_mag line has moved - bode_mag_moved = np.array([ 111.83321224, 92.29238035, 76.02822315, 62.46884113, 51.14108703, 41.6554004, 33.69409534, 27.00237344, 21.38086717, 16.67791585]) - assert_array_almost_equal(ax_mag.lines[0].get_data()[1][10:20],bode_mag_moved) + bode_mag_moved = np.array( + [111.83321224, 92.29238035, 76.02822315, 62.46884113, 51.14108703, + 41.6554004, 33.69409534, 27.00237344, 21.38086717, 16.67791585]) + assert_array_almost_equal(ax_mag.lines[0].get_data()[1][10:20], + bode_mag_moved, 4) # Check if the step response has changed - step_response_moved = np.array([[ 0., 0.02458187, 0.16529784 , 0.46602716 , 0.91012035 , 1.43364313, 1.93996334 , 2.3190105 , 2.47041552 , 2.32724853] ]) - assert_array_almost_equal(ax_step.lines[0].get_data()[1][:10],step_response_moved) + step_response_moved = np.array( + [0., 0.02458187, 0.16529784, 0.46602716, 0.91012035, 1.43364313, + 1.93996334, 2.3190105, 2.47041552, 2.32724853]) + assert_array_almost_equal(ax_step.lines[0].get_data()[1][:10], + step_response_moved, 4) if __name__ == "__main__": From d5666d52d424733854769b46abf32ebe87950e4e Mon Sep 17 00:00:00 2001 From: Ben Greiner Date: Sat, 11 Jul 2020 17:11:36 +0200 Subject: [PATCH 16/67] print(sys) / str(sys) for StateSpace and TransferFunction (#426) * indent StateSpace.__str__() * test StateSpace.__str__() * remove obsolete check for 0000 in %.4g format * test _tf_polynomial_to_string code branches * no f-strings in Python 2.7 :( * int division for python2 and python3 --- control/statesp.py | 18 +++++++++--------- control/tests/statesp_test.py | 23 +++++++++++++++++++++++ control/tests/xferfcn_test.py | 19 +++++++++++++++++++ control/xferfcn.py | 8 ++------ 4 files changed, 53 insertions(+), 15 deletions(-) diff --git a/control/statesp.py b/control/statesp.py index d176e98c9..b6fef447d 100644 --- a/control/statesp.py +++ b/control/statesp.py @@ -267,18 +267,18 @@ def _remove_useless_states(self): self.outputs = self.C.shape[0] def __str__(self): - """String representation of the state space.""" - - str = "A = " + self.A.__str__() + "\n\n" - str += "B = " + self.B.__str__() + "\n\n" - str += "C = " + self.C.__str__() + "\n\n" - str += "D = " + self.D.__str__() + "\n" + """Return string representation of the state space system.""" + string = "\n".join([ + "{} = {}\n".format(Mvar, + "\n ".join(str(M).splitlines())) + for Mvar, M in zip(["A", "B", "C", "D"], + [self.A, self.B, self.C, self.D])]) # TODO: replace with standard calls to lti functions if (type(self.dt) == bool and self.dt is True): - str += "\ndt unspecified\n" + string += "\ndt unspecified\n" elif (not (self.dt is None) and type(self.dt) != bool and self.dt > 0): - str += "\ndt = " + self.dt.__str__() + "\n" - return str + string += "\ndt = " + self.dt.__str__() + "\n" + return string # represent as string, makes display work for IPython __repr__ = __str__ diff --git a/control/tests/statesp_test.py b/control/tests/statesp_test.py index 9273877af..a66a78456 100644 --- a/control/tests/statesp_test.py +++ b/control/tests/statesp_test.py @@ -519,6 +519,29 @@ def test_lft(self): np.testing.assert_allclose(np.array(pk.C).reshape(-1), Cmatlab) np.testing.assert_allclose(np.array(pk.D).reshape(-1), Dmatlab) + def test_str(self): + """Test that printing the system works""" + tsys = self.sys322 + tref = ("A = [[-3. 4. 2.]\n" + " [-1. -3. 0.]\n" + " [ 2. 5. 3.]]\n" + "\n" + "B = [[ 1. 4.]\n" + " [-3. -3.]\n" + " [-2. 1.]]\n" + "\n" + "C = [[ 4. 2. -3.]\n" + " [ 1. 4. 3.]]\n" + "\n" + "D = [[-2. 4.]\n" + " [ 0. 1.]]\n") + assert str(tsys) == tref + tsysdtunspec = StateSpace(tsys.A, tsys.B, tsys.C, tsys.D, True) + assert str(tsysdtunspec) == tref + "\ndt unspecified\n" + sysdt1 = StateSpace(tsys.A, tsys.B, tsys.C, tsys.D, 1.) + assert str(sysdt1) == tref + "\ndt = 1.0\n" + + class TestRss(unittest.TestCase): """These are tests for the proper functionality of statesp.rss.""" diff --git a/control/tests/xferfcn_test.py b/control/tests/xferfcn_test.py index 66aa4576e..25e0ed140 100644 --- a/control/tests/xferfcn_test.py +++ b/control/tests/xferfcn_test.py @@ -806,6 +806,25 @@ def test_printing(self): self.assertTrue(isinstance(str(sys), str)) self.assertTrue(isinstance(sys._repr_latex_(), str)) + def test_printing_polynomial(self): + """Cover all _tf_polynomial_to_string code branches""" + # Note: the assertions below use plain assert statements instead of + # unittest methods so that debugging with pytest is easier + + assert str(TransferFunction([0], [1])) == "\n0\n-\n1\n" + assert str(TransferFunction([1.0001], [-1.1111])) == \ + "\n 1\n------\n-1.111\n" + assert str(TransferFunction([0, 1], [0, 1.])) == "\n1\n-\n1\n" + for var, dt, dtstring in zip(["s", "z", "z"], + [None, True, 1], + ['', '', '\ndt = 1\n']): + assert str(TransferFunction([1, 0], [2, 1], dt)) == \ + "\n {var}\n-------\n2 {var} + 1\n{dtstring}".format( + var=var, dtstring=dtstring) + assert str(TransferFunction([2, 0, -1], [1, 0, 0, 1.2], dt)) == \ + "\n2 {var}^2 - 1\n---------\n{var}^3 + 1.2\n{dtstring}".format( + var=var, dtstring=dtstring) + @unittest.skipIf(not slycot_check(), "slycot not installed") def test_printing_mimo(self): # MIMO, continuous time diff --git a/control/xferfcn.py b/control/xferfcn.py index 96f3b5ca8..107b1fdce 100644 --- a/control/xferfcn.py +++ b/control/xferfcn.py @@ -264,11 +264,9 @@ def __str__(self, var=None): # Center the numerator or denominator if len(numstr) < dashcount: - numstr = (' ' * int(round((dashcount - len(numstr)) / 2)) + - numstr) + numstr = ' ' * ((dashcount - len(numstr)) // 2) + numstr if len(denstr) < dashcount: - denstr = (' ' * int(round((dashcount - len(denstr)) / 2)) + - denstr) + denstr = ' ' * ((dashcount - len(denstr)) // 2) + denstr outstr += "\n" + numstr + "\n" + dashes + "\n" + denstr + "\n" @@ -1104,8 +1102,6 @@ def _tf_polynomial_to_string(coeffs, var='s'): for k in range(len(coeffs)): coefstr = '%.4g' % abs(coeffs[k]) - if coefstr[-4:] == '0000': - coefstr = coefstr[:-5] power = (N - k) if power == 0: if coefstr != '0': From ce3a231e8c93d1f283e85c3cb95ec03243c762c3 Mon Sep 17 00:00:00 2001 From: sawyerbfuller <58706249+sawyerbfuller@users.noreply.github.com> Date: Sat, 11 Jul 2020 08:25:37 -0700 Subject: [PATCH 17/67] add capability to switch to legacy defaults (#424) * add capability to switch to legacy defaults with config.use_legacy_defaults(version) * reverted to using matrix as default in statesp to pass tests * added documentation to statesp, xferfcn, and conventions.rst describing new config parameters default_dt and remove_useless_states --- control/config.py | 18 +++++++++++++++++- control/statesp.py | 13 ++++++++----- control/tests/config_test.py | 21 +++++++++++++++++++-- control/xferfcn.py | 13 ++++++++++--- doc/conventions.rst | 13 +++++++++++-- 5 files changed, 65 insertions(+), 13 deletions(-) diff --git a/control/config.py b/control/config.py index 02028cfba..27a5712a3 100644 --- a/control/config.py +++ b/control/config.py @@ -11,7 +11,7 @@ __all__ = ['defaults', 'set_defaults', 'reset_defaults', 'use_matlab_defaults', 'use_fbs_defaults', - 'use_numpy_matrix'] + 'use_legacy_defaults', 'use_numpy_matrix'] # Package level default values _control_defaults = { @@ -53,6 +53,9 @@ def reset_defaults(): from .rlocus import _rlocus_defaults defaults.update(_rlocus_defaults) + from .xferfcn import _xferfcn_defaults + defaults.update(_xferfcn_defaults) + from .statesp import _statesp_defaults defaults.update(_statesp_defaults) @@ -156,3 +159,16 @@ class and functions. If flat is `False`, then matrices are warnings.warn("Return type numpy.matrix is soon to be deprecated.", stacklevel=2) set_defaults('statesp', use_numpy_matrix=flag) + +def use_legacy_defaults(version): + """ Sets the defaults to whatever they were in a given release. + + Parameters + ---------- + version : string + version number of the defaults desired. Currently only supports `0.8.3`. + """ + if version == '0.8.3': + use_numpy_matrix(True) # alternatively: set_defaults('statesp', use_numpy_matrix=True) + else: + raise ValueError('''version number not recognized. Possible values are: ['0.8.3']''') \ No newline at end of file diff --git a/control/statesp.py b/control/statesp.py index b6fef447d..781973541 100644 --- a/control/statesp.py +++ b/control/statesp.py @@ -71,7 +71,9 @@ # Define module default parameter values _statesp_defaults = { 'statesp.use_numpy_matrix': True, -} + 'statesp.default_dt': None, + 'statesp.remove_useless_states': True, + } def _ssmatrix(data, axis=1): @@ -147,7 +149,8 @@ class StateSpace(LTI): Setting dt = 0 specifies a continuous system, while leaving dt = None means the system timebase is not specified. If 'dt' is set to True, the system will be treated as a discrete time system with unspecified sampling - time. + time. The default value of 'dt' is None and can be changed by changing the + value of ``control.config.defaults['statesp.default_dt']``. """ @@ -171,7 +174,7 @@ def __init__(self, *args, **kw): if len(args) == 4: # The user provided A, B, C, and D matrices. (A, B, C, D) = args - dt = None + dt = config.defaults['statesp.default_dt'] elif len(args) == 5: # Discrete time system (A, B, C, D, dt) = args @@ -187,12 +190,12 @@ def __init__(self, *args, **kw): try: dt = args[0].dt except NameError: - dt = None + dt = config.defaults['statesp.default_dt'] else: raise ValueError("Needs 1 or 4 arguments; received %i." % len(args)) # Process keyword arguments - remove_useless = kw.get('remove_useless', True) + remove_useless = kw.get('remove_useless', config.defaults['statesp.remove_useless_states']) # Convert all matrices to standard form A = _ssmatrix(A) diff --git a/control/tests/config_test.py b/control/tests/config_test.py index 1d2a5437b..2fdae22e4 100644 --- a/control/tests/config_test.py +++ b/control/tests/config_test.py @@ -48,7 +48,7 @@ def test_get_param(self): def test_fbs_bode(self): - ct.use_fbs_defaults(); + ct.use_fbs_defaults() # Generate a Bode plot plt.figure() @@ -94,7 +94,7 @@ def test_fbs_bode(self): ct.reset_defaults() def test_matlab_bode(self): - ct.use_matlab_defaults(); + ct.use_matlab_defaults() # Generate a Bode plot plt.figure() @@ -211,6 +211,23 @@ def test_reset_defaults(self): self.assertEqual( ct.config.defaults['freqplot.feature_periphery_decades'], 1.0) + def test_legacy_defaults(self): + ct.use_legacy_defaults('0.8.3') + assert(isinstance(ct.ss(0,0,0,1).D, np.matrix)) + ct.reset_defaults() + assert(isinstance(ct.ss(0,0,0,1).D, np.ndarray)) + + def test_change_default_dt(self): + ct.set_defaults('statesp', default_dt=0) + self.assertEqual(ct.ss(0,0,0,1).dt, 0) + ct.set_defaults('statesp', default_dt=None) + self.assertEqual(ct.ss(0,0,0,1).dt, None) + ct.set_defaults('xferfcn', default_dt=0) + self.assertEqual(ct.tf(1, 1).dt, 0) + ct.set_defaults('xferfcn', default_dt=None) + self.assertEqual(ct.tf(1, 1).dt, None) + + def tearDown(self): # Get rid of any figures that we created plt.close('all') diff --git a/control/xferfcn.py b/control/xferfcn.py index 107b1fdce..1f6bb627e 100644 --- a/control/xferfcn.py +++ b/control/xferfcn.py @@ -63,10 +63,15 @@ from itertools import chain from re import sub from .lti import LTI, timebaseEqual, timebase, isdtime +from . import config __all__ = ['TransferFunction', 'tf', 'ss2tf', 'tfdata'] +# Define module default parameter values +_xferfcn_defaults = { + 'xferfcn.default_dt': None} + class TransferFunction(LTI): """TransferFunction(num, den[, dt]) @@ -88,7 +93,9 @@ class TransferFunction(LTI): instance variable and setting it to something other than 'None'. If 'dt' has a non-zero value, then it must match whenever two transfer functions are combined. If 'dt' is set to True, the system will be treated as a - discrete time system with unspecified sampling time. + discrete time system with unspecified sampling time. The default value of + 'dt' is None and can be changed by changing the value of + ``control.config.defaults['xferfcn.default_dt']``. The TransferFunction class defines two constants ``s`` and ``z`` that represent the differentiation and delay operators in continuous and @@ -117,7 +124,7 @@ def __init__(self, *args): if len(args) == 2: # The user provided a numerator and a denominator. (num, den) = args - dt = None + dt = config.defaults['xferfcn.default_dt'] elif len(args) == 3: # Discrete time transfer function (num, den, dt) = args @@ -133,7 +140,7 @@ def __init__(self, *args): try: dt = args[0].dt except NameError: # pragma: no coverage - dt = None + dt = config.defaults['xferfcn.default_dt'] else: raise ValueError("Needs 1, 2 or 3 arguments; received %i." % len(args)) diff --git a/doc/conventions.rst b/doc/conventions.rst index c535027be..f07b51238 100644 --- a/doc/conventions.rst +++ b/doc/conventions.rst @@ -98,7 +98,9 @@ the result will be a discrete time system with the sample time of the latter system. For continuous time systems, the :func:`sample_system` function or the :meth:`StateSpace.sample` and :meth:`TransferFunction.sample` methods can be used to create a discrete time system from a continuous time system. -See :ref:`utility-and-conversions`. +See :ref:`utility-and-conversions`. The default value of 'dt' can be changed by +changing the values of ``control.config.defaults['statesp.default_dt']`` and +``control.config.defaults['xferfcn.default_dt']``. Conversion between representations ---------------------------------- @@ -220,9 +222,15 @@ Selected variables that can be configured, along with their default values: * freqplot.feature_periphery_decade (1.0): How many decades to include in the frequency range on both sides of features (poles, zeros). - * statesp.use_numpy_matrix: set the return type for state space matrices to + * statesp.use_numpy_matrix (True): set the return type for state space matrices to `numpy.matrix` (verus numpy.ndarray) + * statesp.default_dt and xferfcn.default_dt (None): set the default value of dt when + constructing new LTI systems + + * statesp.remove_useless_states (True): remove states that have no effect on the + input-output dynamics of the system + Additional parameter variables are documented in individual functions Functions that can be used to set standard configurations: @@ -234,3 +242,4 @@ Functions that can be used to set standard configurations: use_fbs_defaults use_matlab_defaults use_numpy_matrix + use_legacy_defaults From 155d8ebca7f7cd1b2ecf528c75321cd4ef9906fc Mon Sep 17 00:00:00 2001 From: sawyerbfuller <58706249+sawyerbfuller@users.noreply.github.com> Date: Sat, 11 Jul 2020 08:59:53 -0700 Subject: [PATCH 18/67] Improved default time vector and handling for time response functions step, impulse, and initial (#420) * fixed default response time for time response of discrete-time functions step, impulse, and initial * to pass tests, added convenient ability to specify simulation time and number of steps rather than complete time vector in timeresponse functions * eliminated deprecation warnings by importing certain functions from numpy instead of scipy * eliminated deprecation warnings by importing certain functions from numpy instead of scipy * small fix to pass unit tests * adjusted sisotool test so tests pass with new default step response time window * added functionality to automatically choose dt in timeresp.py based on system poles. and unit tests. * removed some leftover code and comments * explanation in docstrings for how time vector T is auto-computed in time response functions --- control/freqplot.py | 4 +- control/matlab/timeresp.py | 31 +++--- control/rlocus.py | 2 +- control/sisotool.py | 2 +- control/tests/sisotool_test.py | 16 +-- control/tests/timeresp_test.py | 71 ++++++++++++- control/timeresp.py | 187 +++++++++++++++++++++------------ 7 files changed, 220 insertions(+), 93 deletions(-) diff --git a/control/freqplot.py b/control/freqplot.py index a1772fea7..7b296c111 100644 --- a/control/freqplot.py +++ b/control/freqplot.py @@ -822,10 +822,10 @@ def default_frequency_range(syslist, Hz=None, number_of_samples=None, # Set the range to be an order of magnitude beyond any features if number_of_samples: - omega = sp.logspace( + omega = np.logspace( lsp_min, lsp_max, num=number_of_samples, endpoint=True) else: - omega = sp.logspace(lsp_min, lsp_max, endpoint=True) + omega = np.logspace(lsp_min, lsp_max, endpoint=True) return omega diff --git a/control/matlab/timeresp.py b/control/matlab/timeresp.py index 647210a9c..b9d4004ca 100644 --- a/control/matlab/timeresp.py +++ b/control/matlab/timeresp.py @@ -21,8 +21,9 @@ def step(sys, T=None, X0=0., input=0, output=None, return_x=False): sys: StateSpace, or TransferFunction LTI system to simulate - T: array-like object, optional - Time vector (argument is autocomputed if not given) + T: array-like or number, optional + Time vector, or simulation time duration if a number (time vector is + autocomputed if not given) X0: array-like or number, optional Initial condition (default = 0) @@ -59,7 +60,7 @@ def step(sys, T=None, X0=0., input=0, output=None, return_x=False): from ..timeresp import step_response T, yout, xout = step_response(sys, T, X0, input, output, - transpose = True, return_x=True) + transpose=True, return_x=True) if return_x: return yout, T, xout @@ -75,8 +76,9 @@ def stepinfo(sys, T=None, SettlingTimeThreshold=0.02, RiseTimeLimits=(0.1,0.9)): sys: StateSpace, or TransferFunction LTI system to simulate - T: array-like object, optional - Time vector (argument is autocomputed if not given) + T: array-like or number, optional + Time vector, or simulation time duration if a number (time vector is + autocomputed if not given) SettlingTimeThreshold: float value, optional Defines the error to compute settling time (default = 0.02) @@ -127,9 +129,10 @@ def impulse(sys, T=None, X0=0., input=0, output=None, return_x=False): sys: StateSpace, TransferFunction LTI system to simulate - T: array-like object, optional - Time vector (argument is autocomputed if not given) - + T: array-like or number, optional + Time vector, or simulation time duration if a number (time vector is + autocomputed if not given) + X0: array-like or number, optional Initial condition (default = 0) @@ -182,9 +185,10 @@ def initial(sys, T=None, X0=0., input=None, output=None, return_x=False): sys: StateSpace, or TransferFunction LTI system to simulate - T: array-like object, optional - Time vector (argument is autocomputed if not given) - + T: array-like or number, optional + Time vector, or simulation time duration if a number (time vector is + autocomputed if not given) + X0: array-like object or number, optional Initial condition (default = 0) @@ -245,9 +249,8 @@ def lsim(sys, U=0., T=None, X0=0.): If `U` is ``None`` or ``0``, a special algorithm is used. This special algorithm is faster than the general algorithm, which is used otherwise. - T: array-like - Time steps at which the input is defined, numbers must be (strictly - monotonic) increasing. + T: array-like, optional for discrete LTI `sys` + Time steps at which the input is defined; values must be evenly spaced. X0: array-like or number, optional Initial condition (default = 0). diff --git a/control/rlocus.py b/control/rlocus.py index 955c5c56d..56e0c55d1 100644 --- a/control/rlocus.py +++ b/control/rlocus.py @@ -50,7 +50,7 @@ import numpy as np import matplotlib import matplotlib.pyplot as plt -from scipy import array, poly1d, row_stack, zeros_like, real, imag +from numpy import array, poly1d, row_stack, zeros_like, real, imag import scipy.signal # signal processing toolbox import pylab # plotting routines from .xferfcn import _convert_to_transfer_function diff --git a/control/sisotool.py b/control/sisotool.py index e700875ca..c2db4b5ab 100644 --- a/control/sisotool.py +++ b/control/sisotool.py @@ -136,7 +136,7 @@ def _SisotoolUpdate(sys,fig,K,bode_plot_params,tvect=None): # Generate the step response and plot it sys_closed = (K*sys).feedback(1) if tvect is None: - tvect, yout = step_response(sys_closed) + tvect, yout = step_response(sys_closed, T_num=100) else: tvect, yout = step_response(sys_closed,tvect) ax_step.plot(tvect, yout) diff --git a/control/tests/sisotool_test.py b/control/tests/sisotool_test.py index e0012a373..f93de54f8 100644 --- a/control/tests/sisotool_test.py +++ b/control/tests/sisotool_test.py @@ -33,10 +33,10 @@ def test_sisotool(self): # Check the step response before moving the point step_response_original = np.array( - [0., 0.02233651, 0.13118374, 0.33078542, 0.5907113, 0.87041549, - 1.13038536, 1.33851053, 1.47374666, 1.52757114]) - assert_array_almost_equal(ax_step.lines[0].get_data()[1][:10], - step_response_original, 4) + [0., 0.0217, 0.1281, 0.3237, 0.5797, 0.8566, 1.116, + 1.3261, 1.4659, 1.526]) + assert_array_almost_equal( + ax_step.lines[0].get_data()[1][:10], step_response_original, 4) bode_plot_params = { 'omega': None, @@ -78,10 +78,10 @@ def test_sisotool(self): # Check if the step response has changed step_response_moved = np.array( - [0., 0.02458187, 0.16529784, 0.46602716, 0.91012035, 1.43364313, - 1.93996334, 2.3190105, 2.47041552, 2.32724853]) - assert_array_almost_equal(ax_step.lines[0].get_data()[1][:10], - step_response_moved, 4) + [0., 0.0239, 0.161 , 0.4547, 0.8903, 1.407, + 1.9121, 2.2989, 2.4686, 2.353]) + assert_array_almost_equal( + ax_step.lines[0].get_data()[1][:10], step_response_moved, 4) if __name__ == "__main__": diff --git a/control/tests/timeresp_test.py b/control/tests/timeresp_test.py index b208e70d2..5549b2a88 100644 --- a/control/tests/timeresp_test.py +++ b/control/tests/timeresp_test.py @@ -11,6 +11,7 @@ import unittest import numpy as np from control.timeresp import * +from control.timeresp import _ideal_tfinal_and_dt, _default_time_vector from control.statesp import * from control.xferfcn import TransferFunction, _convert_to_transfer_function from control.dtime import c2d @@ -94,6 +95,7 @@ def test_step_response(self): np.testing.assert_array_equal(Tc.shape, Td.shape) np.testing.assert_array_equal(youtc.shape, youtd.shape) + # Recreate issue #374 ("Bug in step_response()") def test_step_nostates(self): # Continuous time, constant system @@ -346,10 +348,75 @@ def test_step_robustness(self): sys2 = TransferFunction(num, den2) # Compute step response from input 1 to output 1, 2 - t1, y1 = step_response(sys1, input=0) - t2, y2 = step_response(sys2, input=0) + t1, y1 = step_response(sys1, input=0, T_num=100) + t2, y2 = step_response(sys2, input=0, T_num=100) np.testing.assert_array_almost_equal(y1, y2) + def test_auto_generated_time_vector(self): + # confirm a TF with a pole at p simulates for 7.0/p seconds + p = 0.5 + np.testing.assert_array_almost_equal( + _ideal_tfinal_and_dt(TransferFunction(1, [1, .5]))[0], + (7/p)) + np.testing.assert_array_almost_equal( + _ideal_tfinal_and_dt(TransferFunction(1, [1, .5]).sample(.1))[0], + (7/p)) + # confirm a TF with poles at 0 and p simulates for 7.0/p seconds + np.testing.assert_array_almost_equal( + _ideal_tfinal_and_dt(TransferFunction(1, [1, .5, 0]))[0], + (7/p)) + # confirm a TF with a natural frequency of wn rad/s gets a + # dt of 1/(7.0*wn) + wn = 10 + np.testing.assert_array_almost_equal( + _ideal_tfinal_and_dt(TransferFunction(1, [1, 0, wn**2]))[1], + 1/(7.0*wn)) + zeta = .1 + np.testing.assert_array_almost_equal( + _ideal_tfinal_and_dt(TransferFunction(1, [1, 2*zeta*wn, wn**2]))[1], + 1/(7.0*wn)) + # but a smapled one keeps its dt + np.testing.assert_array_almost_equal( + _ideal_tfinal_and_dt(TransferFunction(1, [1, 2*zeta*wn, wn**2]).sample(.1))[1], + .1) + np.testing.assert_array_almost_equal( + np.diff(initial_response(TransferFunction(1, [1, 2*zeta*wn, wn**2]).sample(.1))[0][0:2]), + .1) + np.testing.assert_array_almost_equal( + _ideal_tfinal_and_dt(TransferFunction(1, [1, 2*zeta*wn, wn**2]))[1], + 1/(7.0*wn)) + # TF with fast oscillations simulates only 5000 time steps even with long tfinal + self.assertEqual(5000, + len(_default_time_vector(TransferFunction(1, [1, 0, wn**2]),tfinal=100))) + # and simulates for 7.0/dt time steps + self.assertEqual( + len(_default_time_vector(TransferFunction(1, [1, 0, wn**2]))), + int(7.0/(1/(7.0*wn)))) + + sys = TransferFunction(1, [1, .5, 0]) + sysdt = TransferFunction(1, [1, .5, 0], .1) + # test impose number of time steps + self.assertEqual(10, len(step_response(sys, T_num=10)[0])) + self.assertEqual(10, len(step_response(sysdt, T_num=10)[0])) + # test impose final time + np.testing.assert_array_almost_equal( + 100, + step_response(sys, 100)[0][-1], + decimal=.5) + np.testing.assert_array_almost_equal( + 100, + step_response(sysdt, 100)[0][-1], + decimal=.5) + np.testing.assert_array_almost_equal( + 100, + impulse_response(sys, 100)[0][-1], + decimal=.5) + np.testing.assert_array_almost_equal( + 100, + initial_response(sys, 100)[0][-1], + decimal=.5) + + def test_time_vector(self): "Unit test: https://github.com/python-control/python-control/issues/239" # Discrete time simulations with specified time vectors diff --git a/control/timeresp.py b/control/timeresp.py index 4c0fbd940..8670c180d 100644 --- a/control/timeresp.py +++ b/control/timeresp.py @@ -60,16 +60,20 @@ Initial Author: Eike Welk Date: 12 May 2011 + +Modified: Sawyer B. Fuller (minster@uw.edu) to add discrete-time +capability and better automatic time vector creation +Date: June 2020 + $Id$ """ # Libraries that we make use of import scipy as sp # SciPy library (used all over) import numpy as np # NumPy library -from scipy.signal.ltisys import _default_response_times import warnings from .lti import LTI # base class of StateSpace, TransferFunction -from .statesp import _convertToStateSpace, _mimo2simo, _mimo2siso +from .statesp import _convertToStateSpace, _mimo2simo, _mimo2siso, ssdata from .lti import isdtime, isctime __all__ = ['forced_response', 'step_response', 'step_info', 'initial_response', @@ -440,7 +444,7 @@ def _get_ss_simo(sys, input=None, output=None): return _mimo2siso(sys_ss, input, output, warn_conversion=warn) -def step_response(sys, T=None, X0=0., input=None, output=None, +def step_response(sys, T=None, X0=0., input=None, output=None, T_num=None, transpose=False, return_x=False, squeeze=True): # pylint: disable=W0622 """Step response of a linear system @@ -458,8 +462,15 @@ def step_response(sys, T=None, X0=0., input=None, output=None, sys: StateSpace, or TransferFunction LTI system to simulate - T: array-like object, optional - Time vector (argument is autocomputed if not given) + T: array-like or number, optional + Time vector, or simulation time duration if a number. If T is not + provided, an attempt is made to create it automatically from the + dynamics of sys. If sys is continuous-time, the time increment dt + is chosen small enough to show the fastest mode, and the simulation + time period tfinal long enough to show the slowest mode, excluding + poles at the origin. If this results in too many time steps (>5000), + dt is reduced. If sys is discrete-time, only tfinal is computed, and + tfinal is reduced if it requires too many simulation steps. X0: array-like or number, optional Initial condition (default = 0) @@ -472,6 +483,10 @@ def step_response(sys, T=None, X0=0., input=None, output=None, output: int Index of the output that will be used in this simulation. Set to None to not trim outputs + + T_num: number, optional + Number of time steps to use in simulation if T is not provided as an + array (autocomputed if not given); ignored if sys is discrete-time. transpose: bool If True, transpose all input and output arrays (for backward @@ -511,8 +526,8 @@ def step_response(sys, T=None, X0=0., input=None, output=None, """ sys = _get_ss_simo(sys, input, output) - if T is None: - T = _get_response_times(sys, N=100) + if T is None or np.asarray(T).size == 1: + T = _default_time_vector(sys, N=T_num, tfinal=T) U = np.ones_like(T) T, yout, xout = forced_response(sys, T, U, X0, transpose=transpose, @@ -524,7 +539,7 @@ def step_response(sys, T=None, X0=0., input=None, output=None, return T, yout -def step_info(sys, T=None, SettlingTimeThreshold=0.02, +def step_info(sys, T=None, T_num=None, SettlingTimeThreshold=0.02, RiseTimeLimits=(0.1, 0.9)): ''' Step response characteristics (Rise time, Settling Time, Peak and others). @@ -534,8 +549,13 @@ def step_info(sys, T=None, SettlingTimeThreshold=0.02, sys: StateSpace, or TransferFunction LTI system to simulate - T: array-like object, optional - Time vector (argument is autocomputed if not given) + T: array-like or number, optional + Time vector, or simulation time duration if a number (time vector is + autocomputed if not given, see :func:`step_response` for more detail) + + T_num: number, optional + Number of time steps to use in simulation if T is not provided as an + array (autocomputed if not given); ignored if sys is discrete-time. SettlingTimeThreshold: float value, optional Defines the error to compute settling time (default = 0.02) @@ -566,9 +586,9 @@ def step_info(sys, T=None, SettlingTimeThreshold=0.02, >>> info = step_info(sys, T) ''' sys = _get_ss_simo(sys) - if T is None: - T = _get_response_times(sys, N=1000) - + if T is None or np.asarray(T).size == 1: + T = _default_time_vector(sys, N=T_num, tfinal=T) + T, yout = step_response(sys, T) # Steady state value @@ -588,33 +608,21 @@ def step_info(sys, T=None, SettlingTimeThreshold=0.02, SettlingTime = T[i + 1] break - # Peak PeakIndex = np.abs(yout).argmax() - PeakValue = yout[PeakIndex] - PeakTime = T[PeakIndex] - SettlingMax = (yout).max() - SettlingMin = (yout[tr_upper_index:]).min() - # I'm really not very confident about UnderShoot: - UnderShoot = yout.min() - OverShoot = 100. * (yout.max() - InfValue) / (InfValue - yout[0]) - - # Return as a dictionary - S = { + return { 'RiseTime': RiseTime, 'SettlingTime': SettlingTime, - 'SettlingMin': SettlingMin, - 'SettlingMax': SettlingMax, - 'Overshoot': OverShoot, - 'Undershoot': UnderShoot, - 'Peak': PeakValue, - 'PeakTime': PeakTime, + 'SettlingMin': yout[tr_upper_index:].min(), + 'SettlingMax': yout.max(), + 'Overshoot': 100. * (yout.max() - InfValue) / (InfValue - yout[0]), + 'Undershoot': yout.min(), # not very confident about this + 'Peak': yout[PeakIndex], + 'PeakTime': T[PeakIndex], 'SteadyStateValue': InfValue - } - - return S + } -def initial_response(sys, T=None, X0=0., input=0, output=None, +def initial_response(sys, T=None, X0=0., input=0, output=None, T_num=None, transpose=False, return_x=False, squeeze=True): # pylint: disable=W0622 """Initial condition response of a linear system @@ -631,10 +639,11 @@ def initial_response(sys, T=None, X0=0., input=0, output=None, sys: StateSpace, or TransferFunction LTI system to simulate - T: array-like object, optional - Time vector (argument is autocomputed if not given) + T: array-like or number, optional + Time vector, or simulation time duration if a number (time vector is + autocomputed if not given; see :func:`step_response` for more detail) - X0: array-like object or number, optional + X0: array-like or number, optional Initial condition (default = 0) Numbers are converted to constant arrays with the correct shape. @@ -646,6 +655,10 @@ def initial_response(sys, T=None, X0=0., input=0, output=None, output: int Index of the output that will be used in this simulation. Set to None to not trim outputs + + T_num: number, optional + Number of time steps to use in simulation if T is not provided as an + array (autocomputed if not given); ignored if sys is discrete-time. transpose: bool If True, transpose all input and output arrays (for backward @@ -685,9 +698,8 @@ def initial_response(sys, T=None, X0=0., input=0, output=None, # Create time and input vectors; checking is done in forced_response(...) # The initial vector X0 is created in forced_response(...) if necessary - if T is None: - # TODO: default step size inconsistent with step/impulse_response() - T = _get_response_times(sys, N=1000) + if T is None or np.asarray(T).size == 1: + T = _default_time_vector(sys, N=T_num, tfinal=T) U = np.zeros_like(T) T, yout, _xout = forced_response(sys, T, U, X0, transpose=transpose, @@ -699,7 +711,7 @@ def initial_response(sys, T=None, X0=0., input=0, output=None, return T, yout -def impulse_response(sys, T=None, X0=0., input=0, output=None, +def impulse_response(sys, T=None, X0=0., input=0, output=None, T_num=None, transpose=False, return_x=False, squeeze=True): # pylint: disable=W0622 """Impulse response of a linear system @@ -717,10 +729,11 @@ def impulse_response(sys, T=None, X0=0., input=0, output=None, sys: StateSpace, TransferFunction LTI system to simulate - T: array-like object, optional - Time vector (argument is autocomputed if not given) + T: array-like or number, optional + Time vector, or simulation time duration if a number (time vector is + autocomputed if not given; see :func:`step_response` for more detail) - X0: array-like object or number, optional + X0: array-like or number, optional Initial condition (default = 0) Numbers are converted to constant arrays with the correct shape. @@ -732,6 +745,10 @@ def impulse_response(sys, T=None, X0=0., input=0, output=None, Index of the output that will be used in this simulation. Set to None to not trim outputs + T_num: number, optional + Number of time steps to use in simulation if T is not provided as an + array (autocomputed if not given); ignored if sys is discrete-time. + transpose: bool If True, transpose all input and output arrays (for backward compatibility with MATLAB and scipy.signal.lsim) @@ -770,7 +787,7 @@ def impulse_response(sys, T=None, X0=0., input=0, output=None, """ sys = _get_ss_simo(sys, input, output) - # System has direct feedthrough, can't simulate impulse response + # if system has direct feedthrough, can't simulate impulse response # numerically if np.any(sys.D != 0) and isctime(sys): warnings.warn("System has direct feedthrough: ``D != 0``. The " @@ -779,14 +796,14 @@ def impulse_response(sys, T=None, X0=0., input=0, output=None, "Results may be meaningless!") # create X0 if not given, test if X0 has correct shape. - # Must be done here because it is used for computations here. + # Must be done here because it is used for computations below. n_states = sys.A.shape[0] X0 = _check_convert_array(X0, [(n_states,), (n_states, 1)], 'Parameter ``X0``: \n', squeeze=True) - # Compute T and U, no checks necessary, they will be checked in lsim - if T is None: - T = _get_response_times(sys, N=100) + # Compute T and U, no checks necessary, will be checked in forced_response + if T is None or np.asarray(T).size == 1: + T = _default_time_vector(sys, N=T_num, tfinal=T) U = np.zeros_like(T) # Compute new X0 that contains the impulse @@ -808,21 +825,61 @@ def impulse_response(sys, T=None, X0=0., input=0, output=None, return T, yout - -# Utility function to get response times -def _get_response_times(sys, N=100): - if isctime(sys): - if sys.A.shape == (0, 0): - # No dynamics; use the unit time interval - T = np.linspace(0, 1, N, endpoint=False) - else: - T = _default_response_times(sys.A, N) +# utility function to find time period and time increment using pole locations +def _ideal_tfinal_and_dt(sys): + constant = 7.0 + tolerance = 1e-10 + A = ssdata(sys)[0] + if A.shape == (0,0): + # no dynamics + tfinal = constant * 1.0 + dt = sys.dt if isdtime(sys, strict=True) else 1.0 else: - # For discrete time, use integers - if sys.A.shape == (0, 0): - # No dynamics; use N time steps - T = range(N) + poles = sp.linalg.eigvals(A) + if isdtime(sys, strict=True): + poles = np.log(poles)/sys.dt # z-poles to s-plane using s=(lnz)/dt + + # calculate ideal dt + if isdtime(sys, strict=True): + dt = sys.dt else: - tvec = _default_response_times(sys.A, N) - T = range(int(np.ceil(max(tvec)))) - return T + fastest_natural_frequency = max(abs(poles)) + dt = 1/constant / fastest_natural_frequency + + # calculate ideal tfinal + poles = poles[abs(poles.real) > tolerance] # ignore poles near im axis + if poles.size == 0: + slowest_decay_rate = 1.0 + else: + slowest_decay_rate = min(abs(poles.real)) + tfinal = constant / slowest_decay_rate + + return tfinal, dt + +# test below: ct with pole at the origin is 7 seconds, ct with pole at .5 is 14 s long, +def _default_time_vector(sys, N=None, tfinal=None): + """Returns a time vector suitable for observing the response of the + both the slowest poles and fastest resonant modes. if system is + discrete-time, N is ignored """ + + N_max = 5000 + N_min_ct = 100 + N_min_dt = 7 # more common to see just a few samples in discrete-time + + ideal_tfinal, ideal_dt = _ideal_tfinal_and_dt(sys) + + if isdtime(sys, strict=True): + if tfinal is None: + # for discrete time, change from ideal_tfinal if N too large/small + N = int(np.clip(ideal_tfinal/sys.dt, N_min_dt, N_max))# [N_min, N_max] + tfinal = sys.dt * N + else: + N = int(tfinal/sys.dt) + else: + if tfinal is None: + # for continuous time, simulate to ideal_tfinal but limit N + tfinal = ideal_tfinal + if N is None: + N = int(np.clip(tfinal/ideal_dt, N_min_ct, N_max)) # N<-[N_min, N_max] + + return np.linspace(0, tfinal, N, endpoint=False) \ No newline at end of file From 8366806bc774d31ab946bb717e10a169f3247fdd Mon Sep 17 00:00:00 2001 From: sawyerbfuller <58706249+sawyerbfuller@users.noreply.github.com> Date: Sat, 11 Jul 2020 09:16:17 -0700 Subject: [PATCH 19/67] added ability to 'prewarp' the conversion of continuous to discrete-time systems (#417) * added ability to 'prewarp' the conversion of continuous to discrete-time systems (in functions sample, sample_system, and c2d) , so that their gain and phase match at a specific desired frequency. --- control/dtime.py | 17 +++++++++++++---- control/statesp.py | 17 ++++++++++++++--- control/tests/statesp_test.py | 18 ++++++++++++++++++ control/tests/xferfcn_test.py | 21 ++++++++++++++++++++- control/xferfcn.py | 17 ++++++++++++++--- 5 files changed, 79 insertions(+), 11 deletions(-) diff --git a/control/dtime.py b/control/dtime.py index 211aa86a1..89f17c4af 100644 --- a/control/dtime.py +++ b/control/dtime.py @@ -52,7 +52,7 @@ __all__ = ['sample_system', 'c2d'] # Sample a continuous time system -def sample_system(sysc, Ts, method='zoh', alpha=None): +def sample_system(sysc, Ts, method='zoh', alpha=None, prewarp_frequency=None): """Convert a continuous time system to discrete time Creates a discrete time system from a continuous time system by @@ -67,6 +67,10 @@ def sample_system(sysc, Ts, method='zoh', alpha=None): method : string Method to use for conversion: 'matched', 'tustin', 'zoh' (default) + prewarp_frequency : float within [0, infinity) + The frequency [rad/s] at which to match with the input continuous- + time system's magnitude and phase + Returns ------- sysd : linsys @@ -87,10 +91,10 @@ def sample_system(sysc, Ts, method='zoh', alpha=None): if not isctime(sysc): raise ValueError("First argument must be continuous time system") - return sysc.sample(Ts, method, alpha) + return sysc.sample(Ts, method, alpha, prewarp_frequency) -def c2d(sysc, Ts, method='zoh'): +def c2d(sysc, Ts, method='zoh', prewarp_frequency=None): ''' Return a discrete-time system @@ -109,9 +113,14 @@ def c2d(sysc, Ts, method='zoh'): 'impulse' Impulse-invariant discretization, currently not implemented 'tustin' Bilinear (Tustin) approximation, only SISO 'matched' Matched pole-zero method, only SISO + + prewarp_frequency : float within [0, infinity) + The frequency [rad/s] at which to match with the input continuous- + time system's magnitude and phase + ''' # Call the sample_system() function to do the work - sysd = sample_system(sysc, Ts, method) + sysd = sample_system(sysc, Ts, method, prewarp_frequency) # TODO: is this check needed? If sysc is StateSpace, sysd is too? if isinstance(sysc, StateSpace) and not isinstance(sysd, StateSpace): diff --git a/control/statesp.py b/control/statesp.py index 781973541..f5bb232a4 100644 --- a/control/statesp.py +++ b/control/statesp.py @@ -837,7 +837,7 @@ def __getitem__(self, indices): j = indices[1] return StateSpace(self.A, self.B[:, j], self.C[i, :], self.D[i, j], self.dt) - def sample(self, Ts, method='zoh', alpha=None): + def sample(self, Ts, method='zoh', alpha=None, prewarp_frequency=None): """Convert a continuous time system to discrete time Creates a discrete-time system from a continuous-time system by @@ -862,6 +862,12 @@ def sample(self, Ts, method='zoh', alpha=None): should only be specified with method="gbt", and is ignored otherwise + prewarp_frequency : float within [0, infinity) + The frequency [rad/s] at which to match with the input continuous- + time system's magnitude and phase (the gain=1 crossover frequency, + for example). Should only be specified with method='bilinear' or + 'gbt' with alpha=0.5 and ignored otherwise. + Returns ------- sysd : StateSpace @@ -881,8 +887,13 @@ def sample(self, Ts, method='zoh', alpha=None): raise ValueError("System must be continuous time system") sys = (self.A, self.B, self.C, self.D) - Ad, Bd, C, D, dt = cont2discrete(sys, Ts, method, alpha) - return StateSpace(Ad, Bd, C, D, dt) + if (method=='bilinear' or (method=='gbt' and alpha==0.5)) and \ + prewarp_frequency is not None: + Twarp = 2*np.tan(prewarp_frequency*Ts/2)/prewarp_frequency + else: + Twarp = Ts + Ad, Bd, C, D, _ = cont2discrete(sys, Twarp, method, alpha) + return StateSpace(Ad, Bd, C, D, Ts) def dcgain(self): """Return the zero-frequency gain diff --git a/control/tests/statesp_test.py b/control/tests/statesp_test.py index a66a78456..740ad308e 100644 --- a/control/tests/statesp_test.py +++ b/control/tests/statesp_test.py @@ -634,6 +634,24 @@ def test_copy_constructor(self): linsys.A[0, 0] = -3 np.testing.assert_array_equal(cpysys.A, [[-1]]) # original value + def test_sample_system_prewarping(self): + """test that prewarping works when converting from cont to discrete time system""" + A = np.array([ + [ 0.00000000e+00, 1.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [-3.81097561e+01, -1.12500000e+00, 0.00000000e+00, 0.00000000e+00], + [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 1.00000000e+00], + [ 0.00000000e+00, 0.00000000e+00, -1.66356135e+04, -1.34748470e+01]]) + B = np.array([ + [ 0. ], [ 38.1097561 ],[ 0. ],[16635.61352143]]) + C = np.array([[0.90909091, 0. , 0.09090909, 0. ],]) + wwarp = 50 + Ts = 0.025 + plant = StateSpace(A,B,C,0) + plant_d_warped = plant.sample(Ts, 'bilinear', prewarp_frequency=wwarp) + np.testing.assert_array_almost_equal( + evalfr(plant, wwarp*1j), + evalfr(plant_d_warped, np.exp(wwarp*1j*Ts)), + decimal=4) if __name__ == "__main__": unittest.main() diff --git a/control/tests/xferfcn_test.py b/control/tests/xferfcn_test.py index 25e0ed140..6e0a2ede6 100644 --- a/control/tests/xferfcn_test.py +++ b/control/tests/xferfcn_test.py @@ -872,7 +872,26 @@ def test_latex_repr(self): r'+ 2.3 ' + expmul + ' 10^{-45}' r'}' + suffix + '$$') self.assertEqual(H._repr_latex_(), ref) - + + def test_sample_system_prewarping(self): + """test that prewarping works when converting from cont to discrete time system""" + A = np.array([ + [ 0.00000000e+00, 1.00000000e+00, 0.00000000e+00, 0.00000000e+00], + [-3.81097561e+01, -1.12500000e+00, 0.00000000e+00, 0.00000000e+00], + [ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00, 1.00000000e+00], + [ 0.00000000e+00, 0.00000000e+00, -1.66356135e+04, -1.34748470e+01]]) + B = np.array([ + [ 0. ], [ 38.1097561 ],[ 0. ],[16635.61352143]]) + C = np.array([[0.90909091, 0. , 0.09090909, 0. ],]) + wwarp = 50 + Ts = 0.025 + plant = StateSpace(A,B,C,0) + plant = ss2tf(plant) + plant_d_warped = plant.sample(Ts, 'bilinear', prewarp_frequency=wwarp) + np.testing.assert_array_almost_equal( + evalfr(plant, wwarp*1j), + evalfr(plant_d_warped, np.exp(wwarp*1j*Ts)), + decimal=4) if __name__ == "__main__": unittest.main() diff --git a/control/xferfcn.py b/control/xferfcn.py index 1f6bb627e..02f39117e 100644 --- a/control/xferfcn.py +++ b/control/xferfcn.py @@ -983,7 +983,7 @@ def _common_den(self, imag_tol=None, allow_nonproper=False): return num, den, denorder - def sample(self, Ts, method='zoh', alpha=None): + def sample(self, Ts, method='zoh', alpha=None, prewarp_frequency=None): """Convert a continuous-time system to discrete time Creates a discrete-time system from a continuous-time system by @@ -1007,6 +1007,12 @@ def sample(self, Ts, method='zoh', alpha=None): The generalized bilinear transformation weighting parameter, which should only be specified with method="gbt", and is ignored otherwise. + + prewarp_frequency : float within [0, infinity) + The frequency [rad/s] at which to match with the input continuous- + time system's magnitude and phase (the gain=1 crossover frequency, + for example). Should only be specified with method='bilinear' or + 'gbt' with alpha=0.5 and ignored otherwise. Returns ------- @@ -1032,8 +1038,13 @@ def sample(self, Ts, method='zoh', alpha=None): if method == "matched": return _c2d_matched(self, Ts) sys = (self.num[0][0], self.den[0][0]) - numd, dend, dt = cont2discrete(sys, Ts, method, alpha) - return TransferFunction(numd[0, :], dend, dt) + if (method=='bilinear' or (method=='gbt' and alpha==0.5)) and \ + prewarp_frequency is not None: + Twarp = 2*np.tan(prewarp_frequency*Ts/2)/prewarp_frequency + else: + Twarp = Ts + numd, dend, _ = cont2discrete(sys, Twarp, method, alpha) + return TransferFunction(numd[0, :], dend, Ts) def dcgain(self): """Return the zero-frequency (or DC) gain From 50051594f81c8a048d1f19180ec9ac0b645f68a5 Mon Sep 17 00:00:00 2001 From: Rene van Paassen Date: Sat, 11 Jul 2020 18:35:57 +0200 Subject: [PATCH 20/67] implement __repr__ for tf, ss, and frd (#416) * implement __repr__ for tf, ss, and frd * use np.matmul for compatibility with python 2.7 --- control/frdata.py | 13 +++++++-- control/statesp.py | 10 +++++-- control/tests/frd_test.py | 54 +++++++++++++++++++++++++++++++++-- control/tests/statesp_test.py | 20 +++++++++++++ control/tests/xferfcn_test.py | 41 ++++++++++++++++++++++++++ control/xferfcn.py | 13 +++++++-- 6 files changed, 143 insertions(+), 8 deletions(-) diff --git a/control/frdata.py b/control/frdata.py index c57cf09b7..8ca9dfd9d 100644 --- a/control/frdata.py +++ b/control/frdata.py @@ -161,14 +161,14 @@ def __str__(self): """String representation of the transfer function.""" mimo = self.inputs > 1 or self.outputs > 1 - outstr = ['frequency response data '] + outstr = ['Frequency response data'] mt, pt, wt = self.freqresp(self.omega) for i in range(self.inputs): for j in range(self.outputs): if mimo: outstr.append("Input %i to output %i:" % (i + 1, j + 1)) - outstr.append('Freq [rad/s] Response ') + outstr.append('Freq [rad/s] Response') outstr.append('------------ ---------------------') outstr.extend( ['%12.3f %10.4g%+10.4gj' % (w, m, p) @@ -177,6 +177,15 @@ def __str__(self): return '\n'.join(outstr) + def __repr__(self): + """Loadable string representation, + + limited for number of data points. + """ + return "FrequencyResponseData({d}, {w}{smooth})".format( + d=repr(self.fresp), w=repr(self.omega), + smooth=(self.ifunc and ", smooth=True") or "") + def __neg__(self): """Negate a transfer function.""" diff --git a/control/statesp.py b/control/statesp.py index f5bb232a4..522d187a9 100644 --- a/control/statesp.py +++ b/control/statesp.py @@ -283,8 +283,14 @@ def __str__(self): string += "\ndt = " + self.dt.__str__() + "\n" return string - # represent as string, makes display work for IPython - __repr__ = __str__ + # represent to implement a re-loadable version + # TODO: remove the conversion to array when matrix is no longer used + def __repr__(self): + """Print state-space system in loadable form.""" + return "StateSpace({A}, {B}, {C}, {D}{dt})".format( + A=asarray(self.A).__repr__(), B=asarray(self.B).__repr__(), + C=asarray(self.C).__repr__(), D=asarray(self.D).__repr__(), + dt=(isdtime(self, strict=True) and ", {}".format(self.dt)) or '') # Negation of a system def __neg__(self): diff --git a/control/tests/frd_test.py b/control/tests/frd_test.py index 629d488ea..fcbc10263 100644 --- a/control/tests/frd_test.py +++ b/control/tests/frd_test.py @@ -10,7 +10,7 @@ import control as ct from control.statesp import StateSpace from control.xferfcn import TransferFunction -from control.frdata import FRD, _convertToFRD +from control.frdata import FRD, _convertToFRD, FrequencyResponseData from control import bdalg from control import freqplot from control.exception import slycot_check @@ -414,6 +414,56 @@ def test_evalfr_deprecated(self): # Make sure that we get a pending deprecation warning self.assertRaises(PendingDeprecationWarning, frd_tf.evalfr, 1.) - + def test_repr_str(self): + # repr printing + array = np.array + sys0 = FrequencyResponseData([1.0, 0.9+0.1j, 0.1+2j, 0.05+3j], + [0.1, 1.0, 10.0, 100.0]) + sys1 = FrequencyResponseData(sys0.fresp, sys0.omega, smooth=True) + ref0 = "FrequencyResponseData(" \ + "array([[[1. +0.j , 0.9 +0.1j, 0.1 +2.j , 0.05+3.j ]]])," \ + " array([ 0.1, 1. , 10. , 100. ]))" + ref1 = ref0[:-1] + ", smooth=True)" + sysm = FrequencyResponseData( + np.matmul(array([[1],[2]]), sys0.fresp), sys0.omega) + + self.assertEqual(repr(sys0), ref0) + self.assertEqual(repr(sys1), ref1) + sys0r = eval(repr(sys0)) + np.testing.assert_array_almost_equal(sys0r.fresp, sys0.fresp) + np.testing.assert_array_almost_equal(sys0r.omega, sys0.omega) + sys1r = eval(repr(sys1)) + np.testing.assert_array_almost_equal(sys1r.fresp, sys1.fresp) + np.testing.assert_array_almost_equal(sys1r.omega, sys1.omega) + assert(sys1.ifunc is not None) + + refs = """Frequency response data +Freq [rad/s] Response +------------ --------------------- + 0.100 1 +0j + 1.000 0.9 +0.1j + 10.000 0.1 +2j + 100.000 0.05 +3j""" + self.assertEqual(str(sys0), refs) + self.assertEqual(str(sys1), refs) + + # print multi-input system + refm = """Frequency response data +Input 1 to output 1: +Freq [rad/s] Response +------------ --------------------- + 0.100 1 +0j + 1.000 0.9 +0.1j + 10.000 0.1 +2j + 100.000 0.05 +3j +Input 2 to output 1: +Freq [rad/s] Response +------------ --------------------- + 0.100 2 +0j + 1.000 1.8 +0.2j + 10.000 0.2 +4j + 100.000 0.1 +6j""" + self.assertEqual(str(sysm), refm) + if __name__ == "__main__": unittest.main() diff --git a/control/tests/statesp_test.py b/control/tests/statesp_test.py index 740ad308e..96404d79f 100644 --- a/control/tests/statesp_test.py +++ b/control/tests/statesp_test.py @@ -519,6 +519,25 @@ def test_lft(self): np.testing.assert_allclose(np.array(pk.C).reshape(-1), Cmatlab) np.testing.assert_allclose(np.array(pk.D).reshape(-1), Dmatlab) + def test_repr(self): + ref322 = """StateSpace(array([[-3., 4., 2.], + [-1., -3., 0.], + [ 2., 5., 3.]]), array([[ 1., 4.], + [-3., -3.], + [-2., 1.]]), array([[ 4., 2., -3.], + [ 1., 4., 3.]]), array([[-2., 4.], + [ 0., 1.]]){dt})""" + self.assertEqual(repr(self.sys322), ref322.format(dt='')) + sysd = StateSpace(self.sys322.A, self.sys322.B, + self.sys322.C, self.sys322.D, 0.4) + self.assertEqual(repr(sysd), ref322.format(dt=", 0.4")) + array = np.array + sysd2 = eval(repr(sysd)) + np.testing.assert_allclose(sysd.A, sysd2.A) + np.testing.assert_allclose(sysd.B, sysd2.B) + np.testing.assert_allclose(sysd.C, sysd2.C) + np.testing.assert_allclose(sysd.D, sysd2.D) + def test_str(self): """Test that printing the system works""" tsys = self.sys322 @@ -653,5 +672,6 @@ def test_sample_system_prewarping(self): evalfr(plant_d_warped, np.exp(wwarp*1j*Ts)), decimal=4) + if __name__ == "__main__": unittest.main() diff --git a/control/tests/xferfcn_test.py b/control/tests/xferfcn_test.py index 6e0a2ede6..02e6c2b37 100644 --- a/control/tests/xferfcn_test.py +++ b/control/tests/xferfcn_test.py @@ -872,6 +872,46 @@ def test_latex_repr(self): r'+ 2.3 ' + expmul + ' 10^{-45}' r'}' + suffix + '$$') self.assertEqual(H._repr_latex_(), ref) + + def test_repr(self): + """Test __repr__ printout.""" + Hc = TransferFunction([-1., 4.], [1., 3., 5.]) + Hd = TransferFunction([2., 3., 0.], [1., -3., 4., 0], 2.0) + Hcm = TransferFunction( + [ [[0, 1], [2, 3]], [[4, 5], [6, 7]] ], + [ [[6, 7], [4, 5]], [[2, 3], [0, 1]] ]) + Hdm = TransferFunction( + [ [[0, 1], [2, 3]], [[4, 5], [6, 7]] ], + [ [[6, 7], [4, 5]], [[2, 3], [0, 1]] ], 0.5) + + refs = [ + "TransferFunction(array([-1., 4.]), array([1., 3., 5.]))", + "TransferFunction(array([2., 3., 0.])," + " array([ 1., -3., 4., 0.]), 2.0)", + "TransferFunction([[array([1]), array([2, 3])]," + " [array([4, 5]), array([6, 7])]]," + " [[array([6, 7]), array([4, 5])]," + " [array([2, 3]), array([1])]])", + "TransferFunction([[array([1]), array([2, 3])]," + " [array([4, 5]), array([6, 7])]]," + " [[array([6, 7]), array([4, 5])]," + " [array([2, 3]), array([1])]], 0.5)" ] + self.assertEqual(repr(Hc), refs[0]) + self.assertEqual(repr(Hd), refs[1]) + self.assertEqual(repr(Hcm), refs[2]) + self.assertEqual(repr(Hdm), refs[3]) + + # and reading back + array = np.array + for H in (Hc, Hd, Hcm, Hdm): + H2 = eval(H.__repr__()) + for p in range(len(H.num)): + for m in range(len(H.num[0])): + np.testing.assert_array_almost_equal( + H.num[p][m], H2.num[p][m]) + np.testing.assert_array_almost_equal( + H.den[p][m], H2.den[p][m]) + self.assertEqual(H.dt, H2.dt) def test_sample_system_prewarping(self): """test that prewarping works when converting from cont to discrete time system""" @@ -893,5 +933,6 @@ def test_sample_system_prewarping(self): evalfr(plant_d_warped, np.exp(wwarp*1j*Ts)), decimal=4) + if __name__ == "__main__": unittest.main() diff --git a/control/xferfcn.py b/control/xferfcn.py index 02f39117e..f50d5141d 100644 --- a/control/xferfcn.py +++ b/control/xferfcn.py @@ -284,8 +284,17 @@ def __str__(self, var=None): return outstr - # represent as string, makes display work for IPython - __repr__ = __str__ + # represent to implement a re-loadable version + def __repr__(self): + """Print transfer function in loadable form""" + if self.issiso(): + return "TransferFunction({num}, {den}{dt})".format( + num=self.num[0][0].__repr__(), den=self.den[0][0].__repr__(), + dt=(isdtime(self, strict=True) and ', {}'.format(self.dt)) or '') + else: + return "TransferFunction({num}, {den}{dt})".format( + num=self.num.__repr__(), den=self.den.__repr__(), + dt=(isdtime(self, strict=True) and ', {}'.format(self.dt)) or '') def _repr_latex_(self, var=None): """LaTeX representation of transfer function, for Jupyter notebook""" From 6e7480eec160b897adfe67def6a00efbf59881ac Mon Sep 17 00:00:00 2001 From: Rene van Paassen Date: Sat, 11 Jul 2020 18:46:28 +0200 Subject: [PATCH 21/67] example file with sisotool use (#415) --- examples/sisotool_example.py | 46 ++++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 examples/sisotool_example.py diff --git a/examples/sisotool_example.py b/examples/sisotool_example.py new file mode 100644 index 000000000..6453bec74 --- /dev/null +++ b/examples/sisotool_example.py @@ -0,0 +1,46 @@ +#!/usr/bin/env python3 +# -*- coding: utf-8 -*- +"""sisotooldemo.py + +Shows some different systems with sisotool. + +All should produce smooth root-locus plots, also zoomable and clickable, +with proper branching +""" + +#%% +import matplotlib.pyplot as plt +from control.matlab import * + +# first example, aircraft attitude equation +s = tf([1,0],[1]) +Kq = -24 +T2 = 1.4 +damping = 2/(13**.5) +omega = 13**.5 +H = (Kq*(1+T2*s))/(s*(s**2+2*damping*omega*s+omega**2)) +plt.close('all') +sisotool(-H) + +#%% + +# a simple RL, with multiple poles in the origin +plt.close('all') +H = (s+0.3)/(s**4 + 4*s**3 + 6.25*s**2) +sisotool(H) + +#%% + +# a branching and emanating example +b0 = 0.2 +b1 = 0.1 +b2 = 0.5 +a0 = 2.3 +a1 = 6.3 +a2 = 3.6 +a3 = 1.0 + +plt.close('all') +H = (b0 + b1*s + b2*s**2) / (a0 + a1*s + a2*s**2 + a3*s**3) + +sisotool(H) From bdf81b12ce5a4455ffb0c38f57adc27f53e7bcab Mon Sep 17 00:00:00 2001 From: sawyerbfuller <58706249+sawyerbfuller@users.noreply.github.com> Date: Sat, 11 Jul 2020 09:56:35 -0700 Subject: [PATCH 22/67] make it so rlocus does not always create a new figure, so it is like matlab and control.sisotool (#413) * rlocus changed to use current plotting axis rather than always creating a new figure, with an option to specify a desired matplotlib axis instead * rlocus: add title to root locus plot axes rather than renaming figure window --- control/rlocus.py | 53 ++++++++++++++++-------------------- control/tests/rlocus_test.py | 1 + 2 files changed, 24 insertions(+), 30 deletions(-) diff --git a/control/rlocus.py b/control/rlocus.py index 56e0c55d1..41494551a 100644 --- a/control/rlocus.py +++ b/control/rlocus.py @@ -48,11 +48,10 @@ # Packages used by this module from functools import partial import numpy as np -import matplotlib +import matplotlib as mpl import matplotlib.pyplot as plt from numpy import array, poly1d, row_stack, zeros_like, real, imag import scipy.signal # signal processing toolbox -import pylab # plotting routines from .xferfcn import _convert_to_transfer_function from .exception import ControlMIMONotImplemented from .sisotool import _SisotoolUpdate @@ -63,7 +62,7 @@ # Default values for module parameters _rlocus_defaults = { 'rlocus.grid': True, - 'rlocus.plotstr': 'b' if int(matplotlib.__version__[0]) == 1 else 'C0', + 'rlocus.plotstr': 'b' if int(mpl.__version__[0]) == 1 else 'C0', 'rlocus.print_gain': True, 'rlocus.plot': True } @@ -71,7 +70,8 @@ # Main function: compute a root locus diagram def root_locus(sys, kvect=None, xlim=None, ylim=None, - plotstr=None, plot=True, print_gain=None, grid=None, **kwargs): + plotstr=None, plot=True, print_gain=None, grid=None, ax=None, + **kwargs): """Root locus plot @@ -96,6 +96,8 @@ def root_locus(sys, kvect=None, xlim=None, ylim=None, branches, calculate gain, damping and print. grid : bool If True plot omega-damping grid. Default is False. + ax : Matplotlib axis + axis on which to create root locus plot Returns ------- @@ -143,42 +145,33 @@ def root_locus(sys, kvect=None, xlim=None, ylim=None, # Create the Plot if plot: if sisotool: - f = kwargs['fig'] - ax = f.axes[1] - + fig = kwargs['fig'] + ax = fig.axes[1] else: - figure_number = pylab.get_fignums() - figure_title = [ - pylab.figure(numb).canvas.get_window_title() - for numb in figure_number] - new_figure_name = "Root Locus" - rloc_num = 1 - while new_figure_name in figure_title: - new_figure_name = "Root Locus " + str(rloc_num) - rloc_num += 1 - f = pylab.figure(new_figure_name) - ax = pylab.axes() + if ax is None: + ax = plt.gca() + fig = ax.figure + ax.set_title('Root Locus') if print_gain and not sisotool: - f.canvas.mpl_connect( + fig.canvas.mpl_connect( 'button_release_event', - partial(_RLClickDispatcher, sys=sys, fig=f, - ax_rlocus=f.axes[0], plotstr=plotstr)) - + partial(_RLClickDispatcher, sys=sys, fig=fig, + ax_rlocus=fig.axes[0], plotstr=plotstr)) elif sisotool: - f.axes[1].plot( + fig.axes[1].plot( [root.real for root in start_mat], [root.imag for root in start_mat], 'm.', marker='s', markersize=8, zorder=20, label='gain_point') - f.suptitle( + fig.suptitle( "Clicked at: %10.4g%+10.4gj gain: %10.4g damp: %10.4g" % (start_mat[0][0].real, start_mat[0][0].imag, 1, -1 * start_mat[0][0].real / abs(start_mat[0][0])), - fontsize=12 if int(matplotlib.__version__[0]) == 1 else 10) - f.canvas.mpl_connect( + fontsize=12 if int(mpl.__version__[0]) == 1 else 10) + fig.canvas.mpl_connect( 'button_release_event', - partial(_RLClickDispatcher, sys=sys, fig=f, - ax_rlocus=f.axes[1], plotstr=plotstr, + partial(_RLClickDispatcher, sys=sys, fig=fig, + ax_rlocus=fig.axes[1], plotstr=plotstr, sisotool=sisotool, bode_plot_params=kwargs['bode_plot_params'], tvect=kwargs['tvect'])) @@ -580,7 +573,7 @@ def _RLFeedbackClicksPoint(event, sys, fig, ax_rlocus, sisotool=False): fig.suptitle( "Clicked at: %10.4g%+10.4gj gain: %10.4g damp: %10.4g" % (s.real, s.imag, K.real, -1 * s.real / abs(s)), - fontsize=12 if int(matplotlib.__version__[0]) == 1 else 10) + fontsize=12 if int(mpl.__version__[0]) == 1 else 10) # Remove the previous line _removeLine(label='gain_point', ax=ax_rlocus) @@ -609,7 +602,7 @@ def _removeLine(label, ax): def _sgrid_func(fig=None, zeta=None, wn=None): if fig is None: - fig = pylab.gcf() + fig = plt.gcf() ax = fig.gca() else: ax = fig.axes[1] diff --git a/control/tests/rlocus_test.py b/control/tests/rlocus_test.py index 966f700d6..d4c03307d 100644 --- a/control/tests/rlocus_test.py +++ b/control/tests/rlocus_test.py @@ -49,6 +49,7 @@ def test_without_gains(self): def test_root_locus_zoom(self): """Check the zooming functionality of the Root locus plot""" system = TransferFunction([1000], [1, 25, 100, 0]) + plt.figure() root_locus(system) fig = plt.gcf() ax_rlocus = fig.axes[0] From 0160990402c6323e34b42be28e8d0324bac537b2 Mon Sep 17 00:00:00 2001 From: sawyerbfuller <58706249+sawyerbfuller@users.noreply.github.com> Date: Sat, 11 Jul 2020 10:03:27 -0700 Subject: [PATCH 23/67] added link to lqe (linear quadratic estimator) function in docs (#405) --- doc/control.rst | 1 + 1 file changed, 1 insertion(+) diff --git a/doc/control.rst b/doc/control.rst index 8fd3db58a..57d64b1eb 100644 --- a/doc/control.rst +++ b/doc/control.rst @@ -117,6 +117,7 @@ Control system synthesis h2syn hinfsyn lqr + lqe mixsyn place From d3142ff24c7af5e2c0843fd16d0e1be82b322bb9 Mon Sep 17 00:00:00 2001 From: sawyerbfuller <58706249+sawyerbfuller@users.noreply.github.com> Date: Mon, 13 Jul 2020 19:52:23 -0700 Subject: [PATCH 24/67] changes to rlocus to be compatible with discrete-time systems (#410) * give correct z-plane damping ratio on mouse click * auto zoom into unit circle * show zgrid with lines of constant damping ratio and natural frequency if desired * sisotool now plots dots instead of a continuous line for discrete-time systems * fixed spelling of variables in a couple of places --- control/grid.py | 11 ++++--- control/rlocus.py | 76 ++++++++++++++++++++++++++++++++------------- control/sisotool.py | 7 +++-- 3 files changed, 65 insertions(+), 29 deletions(-) diff --git a/control/grid.py b/control/grid.py index 8aa583bc0..a383dd27c 100644 --- a/control/grid.py +++ b/control/grid.py @@ -136,11 +136,12 @@ def nogrid(): return ax, f -def zgrid(zetas=None, wns=None): +def zgrid(zetas=None, wns=None, ax=None): '''Draws discrete damping and frequency grid''' fig = plt.gcf() - ax = fig.gca() + if ax is None: + ax = fig.gca() # Constant damping lines if zetas is None: @@ -154,11 +155,11 @@ def zgrid(zetas=None, wns=None): # Draw upper part in retangular coordinates xret = mag*cos(ang) yret = mag*sin(ang) - ax.plot(xret, yret, 'k:', lw=1) + ax.plot(xret, yret, ':', color='grey', lw=0.75) # Draw lower part in retangular coordinates xret = mag*cos(-ang) yret = mag*sin(-ang) - ax.plot(xret, yret, 'k:', lw=1) + ax.plot(xret, yret, ':', color='grey', lw=0.75) # Annotation an_i = int(len(xret)/2.5) an_x = xret[an_i] @@ -177,7 +178,7 @@ def zgrid(zetas=None, wns=None): # Draw in retangular coordinates xret = mag*cos(ang) yret = mag*sin(ang) - ax.plot(xret, yret, 'k:', lw=1) + ax.plot(xret, yret, ':', color='grey', lw=0.75) # Annotation an_i = -1 an_x = xret[an_i] diff --git a/control/rlocus.py b/control/rlocus.py index 41494551a..9f7ff4568 100644 --- a/control/rlocus.py +++ b/control/rlocus.py @@ -43,6 +43,9 @@ # RMM, 2 April 2011: modified to work with new LTI structure (see ChangeLog) # * Not tested: should still work on signal.ltisys objects # +# Sawyer B. Fuller (minster@uw.edu) 21 May 2020: +# * added compatibility with discrete-time systems. +# # $Id$ # Packages used by this module @@ -52,9 +55,11 @@ import matplotlib.pyplot as plt from numpy import array, poly1d, row_stack, zeros_like, real, imag import scipy.signal # signal processing toolbox +from .lti import isdtime from .xferfcn import _convert_to_transfer_function from .exception import ControlMIMONotImplemented from .sisotool import _SisotoolUpdate +from .grid import sgrid, zgrid from . import config __all__ = ['root_locus', 'rlocus'] @@ -131,6 +136,13 @@ def root_locus(sys, kvect=None, xlim=None, ylim=None, # Convert numerator and denominator to polynomials if they aren't (nump, denp) = _systopoly1d(sys) + # if discrete-time system and if xlim and ylim are not given, + # that we a view of the unit circle + if xlim is None and isdtime(sys, strict=True): + xlim = (-1.2, 1.2) + if ylim is None and isdtime(sys, strict=True): + xlim = (-1.3, 1.3) + if kvect is None: start_mat = _RLFindRoots(nump, denp, [1]) kvect, mymat, xlim, ylim = _default_gains(nump, denp, xlim, ylim) @@ -163,10 +175,14 @@ def root_locus(sys, kvect=None, xlim=None, ylim=None, [root.real for root in start_mat], [root.imag for root in start_mat], 'm.', marker='s', markersize=8, zorder=20, label='gain_point') + s = start_mat[0][0] + if isdtime(sys, strict=True): + zeta = -np.cos(np.angle(np.log(s))) + else: + zeta = -1 * s.real / abs(s) fig.suptitle( "Clicked at: %10.4g%+10.4gj gain: %10.4g damp: %10.4g" % - (start_mat[0][0].real, start_mat[0][0].imag, - 1, -1 * start_mat[0][0].real / abs(start_mat[0][0])), + (s.real, s.imag, 1, zeta), fontsize=12 if int(mpl.__version__[0]) == 1 else 10) fig.canvas.mpl_connect( 'button_release_event', @@ -199,20 +215,31 @@ def root_locus(sys, kvect=None, xlim=None, ylim=None, ax.plot(real(col), imag(col), plotstr, label='rootlocus') # Set up plot axes and labels - if xlim: - ax.set_xlim(xlim) - if ylim: - ax.set_ylim(ylim) - ax.set_xlabel('Real') ax.set_ylabel('Imaginary') + if grid and sisotool: - _sgrid_func(f) + if isdtime(sys, strict=True): + zgrid(ax=ax) + else: + _sgrid_func(f) elif grid: - _sgrid_func() + if isdtime(sys, strict=True): + zgrid(ax=ax) + else: + _sgrid_func() else: ax.axhline(0., linestyle=':', color='k', zorder=-20) - ax.axvline(0., linestyle=':', color='k') + ax.axvline(0., linestyle=':', color='k', zorder=-20) + if isdtime(sys, strict=True): + ax.add_patch(plt.Circle((0,0), radius=1.0, + linestyle=':', edgecolor='k', linewidth=1.5, + fill=False, zorder=-20)) + + if xlim: + ax.set_xlim(xlim) + if ylim: + ax.set_ylim(ylim) return mymat, kvect @@ -567,12 +594,17 @@ def _RLFeedbackClicksPoint(event, sys, fig, ax_rlocus, sisotool=False): if abs(K.real) > 1e-8 and abs(K.imag / K.real) < gain_tolerance and \ event.inaxes == ax_rlocus.axes and K.real > 0.: + if isdtime(sys, strict=True): + zeta = -np.cos(np.angle(np.log(s))) + else: + zeta = -1 * s.real / abs(s) + # Display the parameters in the output window and figure print("Clicked at %10.4g%+10.4gj gain %10.4g damp %10.4g" % - (s.real, s.imag, K.real, -1 * s.real / abs(s))) + (s.real, s.imag, K.real, zeta)) fig.suptitle( "Clicked at: %10.4g%+10.4gj gain: %10.4g damp: %10.4g" % - (s.real, s.imag, K.real, -1 * s.real / abs(s)), + (s.real, s.imag, K.real, zeta), fontsize=12 if int(mpl.__version__[0]) == 1 else 10) # Remove the previous line @@ -616,13 +648,13 @@ def _sgrid_func(fig=None, zeta=None, wn=None): if zeta is None: zeta = _default_zetas(xlim, ylim) - angules = [] + angles = [] for z in zeta: if (z >= 1e-4) and (z <= 1): - angules.append(np.pi/2 + np.arcsin(z)) + angles.append(np.pi/2 + np.arcsin(z)) else: zeta.remove(z) - y_over_x = np.tan(angules) + y_over_x = np.tan(angles) # zeta-constant lines @@ -647,14 +679,14 @@ def _sgrid_func(fig=None, zeta=None, wn=None): ax.plot([0, 0], [ylim[0], ylim[1]], color='gray', linestyle='dashed', linewidth=0.5) - angules = np.linspace(-90, 90, 20)*np.pi/180 + angles = np.linspace(-90, 90, 20)*np.pi/180 if wn is None: wn = _default_wn(xlocator(), ylim) for om in wn: if om < 0: - yp = np.sin(angules)*np.abs(om) - xp = -np.cos(angules)*np.abs(om) + yp = np.sin(angles)*np.abs(om) + xp = -np.cos(angles)*np.abs(om) ax.plot(xp, yp, color='gray', linestyle='dashed', linewidth=0.5) an = "%.2f" % -om @@ -662,15 +694,15 @@ def _sgrid_func(fig=None, zeta=None, wn=None): def _default_zetas(xlim, ylim): - """Return default list of dumps coefficients""" + """Return default list of damping coefficients""" sep1 = -xlim[0]/4 ang1 = [np.arctan((sep1*i)/ylim[1]) for i in np.arange(1, 4, 1)] sep2 = ylim[1] / 3 ang2 = [np.arctan(-xlim[0]/(ylim[1]-sep2*i)) for i in np.arange(1, 3, 1)] - angules = np.concatenate((ang1, ang2)) - angules = np.insert(angules, len(angules), np.pi/2) - zeta = np.sin(angules) + angles = np.concatenate((ang1, ang2)) + angles = np.insert(angles, len(angles), np.pi/2) + zeta = np.sin(angles) return zeta.tolist() diff --git a/control/sisotool.py b/control/sisotool.py index c2db4b5ab..8d8459226 100644 --- a/control/sisotool.py +++ b/control/sisotool.py @@ -2,7 +2,7 @@ from .freqplot import bode_plot from .timeresp import step_response -from .lti import issiso +from .lti import issiso, isdtime import matplotlib import matplotlib.pyplot as plt import warnings @@ -139,7 +139,10 @@ def _SisotoolUpdate(sys,fig,K,bode_plot_params,tvect=None): tvect, yout = step_response(sys_closed, T_num=100) else: tvect, yout = step_response(sys_closed,tvect) - ax_step.plot(tvect, yout) + if isdtime(sys_closed, strict=True): + ax_step.plot(tvect, yout, 'o') + else: + ax_step.plot(tvect, yout) ax_step.axhline(1.,linestyle=':',color='k',zorder=-20) # Manually adjust the spacing and draw the canvas From 7e7ae9c6819c3fa26a1cc1b61a58d094eb46c416 Mon Sep 17 00:00:00 2001 From: Sawyer Fuller Date: Wed, 22 Jul 2020 12:55:15 -0700 Subject: [PATCH 25/67] initial commit changing default array type in statespace to be ndarray instead of matrix. two failing unit tests to fix still --- control/statesp.py | 29 +++++++++++----- control/tests/discrete_test.py | 2 +- control/tests/iosys_test.py | 2 +- control/tests/statesp_array_test.py | 9 +++-- control/tests/statesp_test.py | 4 +-- control/tests/test_control_matlab.py | 50 +++++++--------------------- 6 files changed, 44 insertions(+), 52 deletions(-) diff --git a/control/statesp.py b/control/statesp.py index 522d187a9..4f8704d45 100644 --- a/control/statesp.py +++ b/control/statesp.py @@ -70,14 +70,17 @@ # Define module default parameter values _statesp_defaults = { - 'statesp.use_numpy_matrix': True, + 'statesp.use_numpy_matrix': False, 'statesp.default_dt': None, 'statesp.remove_useless_states': True, } def _ssmatrix(data, axis=1): - """Convert argument to a (possibly empty) state space matrix. + """Convert argument to a (possibly empty) 2D state space matrix. + + The axis keyword argument makes it convenient to specify that if the input + is a vector, it is a row (axis=1) or column (axis=0) vector. Parameters ---------- @@ -94,8 +97,10 @@ def _ssmatrix(data, axis=1): """ # Convert the data into an array or matrix, as configured # If data is passed as a string, use (deprecated?) matrix constructor - if config.defaults['statesp.use_numpy_matrix'] or isinstance(data, str): + if config.defaults['statesp.use_numpy_matrix']: arr = np.matrix(data, dtype=float) + elif isinstance(data, str): + arr = np.array(np.matrix(data, dtype=float)) else: arr = np.array(data, dtype=float) ndim = arr.ndim @@ -195,12 +200,20 @@ def __init__(self, *args, **kw): raise ValueError("Needs 1 or 4 arguments; received %i." % len(args)) # Process keyword arguments - remove_useless = kw.get('remove_useless', config.defaults['statesp.remove_useless_states']) + remove_useless = kw.get('remove_useless', + config.defaults['statesp.remove_useless_states']) # Convert all matrices to standard form A = _ssmatrix(A) - B = _ssmatrix(B, axis=0) - C = _ssmatrix(C, axis=1) + # if B is a 1D array, turn it into a column vector if it fits + if np.asarray(B).ndim == 1 and len(B) == A.shape[0]: + B = _ssmatrix(B, axis=0) + else: + B = _ssmatrix(B) + if np.asarray(C).ndim == 1 and len(C) == A.shape[0]: + C = _ssmatrix(C, axis=1) + else: + C = _ssmatrix(C, axis=0) #if this doesn't work, error below if np.isscalar(D) and D == 0 and B.shape[1] > 0 and C.shape[0] > 0: # If D is a scalar zero, broadcast it to the proper size D = np.zeros((C.shape[0], B.shape[1])) @@ -1240,8 +1253,8 @@ def _mimo2simo(sys, input, warn_conversion=False): "Only input {i} is used." .format(i=input)) # $X = A*X + B*U # Y = C*X + D*U - new_B = sys.B[:, input] - new_D = sys.D[:, input] + new_B = sys.B[:, input:input+1] + new_D = sys.D[:, input:input+1] sys = StateSpace(sys.A, new_B, sys.C, new_D, sys.dt) return sys diff --git a/control/tests/discrete_test.py b/control/tests/discrete_test.py index 6598e3a81..9c1928dab 100644 --- a/control/tests/discrete_test.py +++ b/control/tests/discrete_test.py @@ -353,7 +353,7 @@ def test_sample_ss(self): for sys in (sys1, sys2): for h in (0.1, 0.5, 1, 2): Ad = I + h * sys.A - Bd = h * sys.B + 0.5 * h**2 * (sys.A * sys.B) + Bd = h * sys.B + 0.5 * h**2 * np.dot(sys.A, sys.B) sysd = sample_system(sys, h, method='zoh') np.testing.assert_array_almost_equal(sysd.A, Ad) np.testing.assert_array_almost_equal(sysd.B, Bd) diff --git a/control/tests/iosys_test.py b/control/tests/iosys_test.py index 0738e8b18..64f6d350e 100644 --- a/control/tests/iosys_test.py +++ b/control/tests/iosys_test.py @@ -53,7 +53,7 @@ def test_linear_iosys(self): for x, u in (([0, 0], 0), ([1, 0], 0), ([0, 1], 0), ([0, 0], 1)): np.testing.assert_array_almost_equal( np.reshape(iosys._rhs(0, x, u), (-1,1)), - linsys.A * np.reshape(x, (-1, 1)) + linsys.B * u) + np.dot(linsys.A, np.reshape(x, (-1, 1))) + np.dot(linsys.B, u)) # Make sure that simulations also line up T, U, X0 = self.T, self.U, self.X0 diff --git a/control/tests/statesp_array_test.py b/control/tests/statesp_array_test.py index a2d034075..f0574cf24 100644 --- a/control/tests/statesp_array_test.py +++ b/control/tests/statesp_array_test.py @@ -13,6 +13,7 @@ from control.lti import evalfr from control.exception import slycot_check from control.config import use_numpy_matrix, reset_defaults +from control.config import defaults class TestStateSpace(unittest.TestCase): """Tests for the StateSpace class.""" @@ -74,8 +75,12 @@ def test_matlab_style_constructor(self): self.assertEqual(sys.B.shape, (2, 1)) self.assertEqual(sys.C.shape, (1, 2)) self.assertEqual(sys.D.shape, (1, 1)) - for X in [sys.A, sys.B, sys.C, sys.D]: - self.assertTrue(isinstance(X, np.matrix)) + if defaults['statesp.use_numpy_matrix']: + for X in [sys.A, sys.B, sys.C, sys.D]: + self.assertTrue(isinstance(X, np.matrix)) + else: + for X in [sys.A, sys.B, sys.C, sys.D]: + self.assertTrue(isinstance(X, np.ndarray)) def test_pole(self): """Evaluate the poles of a MIMO system.""" diff --git a/control/tests/statesp_test.py b/control/tests/statesp_test.py index 96404d79f..34a17f992 100644 --- a/control/tests/statesp_test.py +++ b/control/tests/statesp_test.py @@ -323,9 +323,9 @@ def test_array_access_ss(self): np.testing.assert_array_almost_equal(sys1_11.A, sys1.A) np.testing.assert_array_almost_equal(sys1_11.B, - sys1.B[:, 1]) + sys1.B[:, 1:2]) np.testing.assert_array_almost_equal(sys1_11.C, - sys1.C[0, :]) + sys1.C[0:1, :]) np.testing.assert_array_almost_equal(sys1_11.D, sys1.D[0, 1]) diff --git a/control/tests/test_control_matlab.py b/control/tests/test_control_matlab.py index e45b52523..aa8633e7c 100644 --- a/control/tests/test_control_matlab.py +++ b/control/tests/test_control_matlab.py @@ -11,7 +11,7 @@ from numpy.testing import assert_array_almost_equal from numpy import array, asarray, matrix, asmatrix, zeros, ones, linspace,\ all, hstack, vstack, c_, r_ -from matplotlib.pylab import show, figure, plot, legend, subplot2grid +from matplotlib.pyplot import show, figure, plot, legend, subplot2grid from control.matlab import ss, step, impulse, initial, lsim, dcgain, \ ss2tf from control.statesp import _mimo2siso @@ -24,29 +24,13 @@ class TestControlMatlab(unittest.TestCase): def setUp(self): pass - def plot_matrix(self): - #Test: can matplotlib correctly plot matrices? - #Yes, but slightly inconvenient - figure() - t = matrix([[ 1.], - [ 2.], - [ 3.], - [ 4.]]) - y = matrix([[ 1., 4.], - [ 4., 5.], - [ 9., 6.], - [16., 7.]]) - plot(t, y) - #plot(asarray(t)[0], asarray(y)[0]) - - def make_SISO_mats(self): """Return matrices for a SISO system""" - A = matrix([[-81.82, -45.45], + A = array([[-81.82, -45.45], [ 10., -1. ]]) - B = matrix([[9.09], + B = array([[9.09], [0. ]]) - C = matrix([[0, 0.159]]) + C = array([[0, 0.159]]) D = zeros((1, 1)) return A, B, C, D @@ -181,7 +165,7 @@ def test_impulse(self): #Test MIMO system A, B, C, D = self.make_MIMO_mats() - sys = ss(A, B, C, D) + sys = ss(A, B, C, D) t, y = impulse(sys) plot(t, y, label='MIMO System') @@ -202,7 +186,7 @@ def test_initial(self): #X0=[1,1] : produces a spike subplot2grid(plot_shape, (0, 1)) - t, y = initial(sys, X0=matrix("1; 1")) + t, y = initial(sys, X0=array(matrix("1; 1"))) plot(t, y) #Test MIMO system @@ -318,21 +302,11 @@ def test_lsim(self): plot(t, y, label='y') legend(loc='best') - #Test with matrices - subplot2grid(plot_shape, (1, 0)) - t = matrix(linspace(0, 1, 100)) - u = matrix(r_[1:1:50j, 0:0:50j]) - x0 = matrix("0.; 0") - y, t_out, _x = lsim(sys, u, t, x0) - plot(t_out, y, label='y') - plot(t_out, asarray(u/10)[0], label='u/10') - legend(loc='best') - #Test with MIMO system subplot2grid(plot_shape, (1, 1)) A, B, C, D = self.make_MIMO_mats() sys = ss(A, B, C, D) - t = matrix(linspace(0, 1, 100)) + t = array(linspace(0, 1, 100)) u = array([r_[1:1:50j, 0:0:50j], r_[0:1:50j, 0:0:50j]]) x0 = [0, 0, 0, 0] @@ -404,12 +378,12 @@ def test_convert_MIMO_to_SISO(self): #Test with additional systems -------------------------------------------- #They have crossed inputs and direct feedthrough #SISO system - As = matrix([[-81.82, -45.45], + As = array([[-81.82, -45.45], [ 10., -1. ]]) - Bs = matrix([[9.09], + Bs = array([[9.09], [0. ]]) - Cs = matrix([[0, 0.159]]) - Ds = matrix([[0.02]]) + Cs = array([[0, 0.159]]) + Ds = array([[0.02]]) sys_siso = ss(As, Bs, Cs, Ds) # t, y = step(sys_siso) # plot(t, y, label='sys_siso d=0.02') @@ -428,7 +402,7 @@ def test_convert_MIMO_to_SISO(self): [0 , 0 ]]) Cm = array([[0, 0, 0, 0.159], [0, 0.159, 0, 0 ]]) - Dm = matrix([[0, 0.02], + Dm = array([[0, 0.02], [0.02, 0 ]]) sys_mimo = ss(Am, Bm, Cm, Dm) From 5ecc543c2fe0fed93859153155d267fd6f3bdd0f Mon Sep 17 00:00:00 2001 From: Sawyer Fuller Date: Thu, 23 Jul 2020 02:10:10 -0700 Subject: [PATCH 26/67] found two remaining unit test bugs! (switch from * to np.dot) --- control/tests/iosys_test.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/control/tests/iosys_test.py b/control/tests/iosys_test.py index 64f6d350e..22f8307d2 100644 --- a/control/tests/iosys_test.py +++ b/control/tests/iosys_test.py @@ -151,9 +151,9 @@ def test_nonlinear_iosys(self): # Create a nonlinear system with the same dynamics nlupd = lambda t, x, u, params: \ - np.reshape(linsys.A * np.reshape(x, (-1, 1)) + linsys.B * u, (-1,)) + np.reshape(np.dot(linsys.A, np.reshape(x, (-1, 1))) + np.dot(linsys.B, u), (-1,)) nlout = lambda t, x, u, params: \ - np.reshape(linsys.C * np.reshape(x, (-1, 1)) + linsys.D * u, (-1,)) + np.reshape(np.dot(linsys.C, np.reshape(x, (-1, 1))) + np.dot(linsys.D, u), (-1,)) nlsys = ios.NonlinearIOSystem(nlupd, nlout) # Make sure that simulations also line up @@ -747,8 +747,8 @@ def test_named_signals(self): + np.dot(self.mimo_linsys1.B, np.reshape(u, (-1, 1))) ).reshape(-1,), outfcn = lambda t, x, u, params: np.array( - self.mimo_linsys1.C * np.reshape(x, (-1, 1)) \ - + self.mimo_linsys1.D * np.reshape(u, (-1, 1)) + np.dot(self.mimo_linsys1.C, np.reshape(x, (-1, 1))) \ + + np.dot(self.mimo_linsys1.D, np.reshape(u, (-1, 1))) ).reshape(-1,), inputs = ('u[0]', 'u[1]'), outputs = ('y[0]', 'y[1]'), From 606fa3fed10bab489d60720c04c7f1da25aa245d Mon Sep 17 00:00:00 2001 From: Sawyer Fuller Date: Thu, 23 Jul 2020 15:02:18 -0700 Subject: [PATCH 27/67] stick with old default for now --- control/statesp.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/control/statesp.py b/control/statesp.py index 4f8704d45..526fc129b 100644 --- a/control/statesp.py +++ b/control/statesp.py @@ -70,7 +70,7 @@ # Define module default parameter values _statesp_defaults = { - 'statesp.use_numpy_matrix': False, + 'statesp.use_numpy_matrix': True, 'statesp.default_dt': None, 'statesp.remove_useless_states': True, } From eda91ca9b203b7663e6f07ebe6845447fe9cbd5e Mon Sep 17 00:00:00 2001 From: bnavigator Date: Fri, 24 Jul 2020 00:53:04 +0200 Subject: [PATCH 28/67] add conftest.py fixture and travis job to check with ndarray --- .travis.yml | 5 +++++ control/tests/conftest.py | 13 +++++++++++++ 2 files changed, 18 insertions(+) create mode 100755 control/tests/conftest.py diff --git a/.travis.yml b/.travis.yml index 022e48c6f..ec615501d 100644 --- a/.travis.yml +++ b/.travis.yml @@ -49,6 +49,11 @@ jobs: services: xvfb python: "3.8" env: SCIPY=scipy SLYCOT=source + - name: "use numpy matrix" + dist: xenial + services: xvfb + python: "3.8" + env: SCIPY=scipy SLYCOT=source PYTHON_CONTROL_STATESPACE_ARRAY=1 # Exclude combinations that are very unlikely (and don't work) exclude: diff --git a/control/tests/conftest.py b/control/tests/conftest.py new file mode 100755 index 000000000..e98bbe1d7 --- /dev/null +++ b/control/tests/conftest.py @@ -0,0 +1,13 @@ +# contest.py - pytest local plugins and fixtures + +import control +import os + +import pytest + + +@pytest.fixture(scope="session", autouse=True) +def use_numpy_ndarray(): + """Switch the config to use ndarray instead of matrix""" + if os.getenv("PYTHON_CONTROL_STATESPACE_ARRAY") == "1": + control.config.defaults['statesp.use_numpy_matrix'] = False From 2b9964ee25bc2b03fbe378639a4300fc1d8cc7b7 Mon Sep 17 00:00:00 2001 From: bnavigator Date: Fri, 24 Jul 2020 12:53:06 +0200 Subject: [PATCH 29/67] remove outdated and unused runtests.py --- runtests.py | 390 ---------------------------------------------------- 1 file changed, 390 deletions(-) delete mode 100644 runtests.py diff --git a/runtests.py b/runtests.py deleted file mode 100644 index 8bf3dfb95..000000000 --- a/runtests.py +++ /dev/null @@ -1,390 +0,0 @@ -#!/usr/bin/env python -""" -runtests.py [OPTIONS] [-- ARGS] - -Run tests, building the project first. - -Examples:: - - $ python runtests.py - $ python runtests.py -s {SAMPLE_SUBMODULE} - $ python runtests.py -t {SAMPLE_TEST} - $ python runtests.py --ipython - $ python runtests.py --python somescript.py - -Run a debugger: - - $ gdb --args python runtests.py [...other args...] - -Generate C code coverage listing under build/lcov/: -(requires http://ltp.sourceforge.net/coverage/lcov.php) - - $ python runtests.py --gcov [...other args...] - $ python runtests.py --lcov-html - -""" - -# -# This is a generic test runner script for projects using Numpy's test -# framework. Change the following values to adapt to your project: -# - -PROJECT_MODULE = "control" -PROJECT_ROOT_FILES = ['control', 'setup.py'] -SAMPLE_TEST = "" -SAMPLE_SUBMODULE = "" - -EXTRA_PATH = ['/usr/lib/ccache', '/usr/lib/f90cache', - '/usr/local/lib/ccache', '/usr/local/lib/f90cache'] - -# --------------------------------------------------------------------- - - -if __doc__ is None: - __doc__ = "Run without -OO if you want usage info" -else: - __doc__ = __doc__.format(**globals()) - - -import sys -import os -import traceback -import warnings - -#warnings.simplefilter("ignore", DeprecationWarning) - -def warn_with_traceback(message, category, filename, lineno, file=None, line=None): - traceback.print_stack() - log = file if hasattr(file, 'write') else sys.stderr - log.write(warnings.formatwarning(message, category, filename, lineno, line)) - -warnings.showwarnings = warn_with_traceback - -# In case we are run from the source directory, we don't want to import the -# project from there: -sys.path.pop(0) - -import shutil -import subprocess -import time -import imp -from argparse import ArgumentParser, REMAINDER - -ROOT_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__))) - -def main(argv): - parser = ArgumentParser(usage=__doc__.lstrip()) - parser.add_argument("--verbose", "-v", action="count", default=1, - help="more verbosity") - parser.add_argument("--no-build", "-n", action="store_true", default=False, - help="do not build the project (use system installed version)") - parser.add_argument("--build-only", "-b", action="store_true", default=False, - help="just build, do not run any tests") - parser.add_argument("--doctests", action="store_true", default=False, - help="Run doctests in module") - parser.add_argument("--coverage_html", action="store_true", default=False, - help=("report coverage of project code. HTML output goes " - "under build/coverage")) - parser.add_argument("--coverage", action="store_true", default=False, - help=("report coverage of project code.")) - parser.add_argument("--gcov", action="store_true", default=False, - help=("enable C code coverage via gcov (requires GCC). " - "gcov output goes to build/**/*.gc*")) - parser.add_argument("--lcov-html", action="store_true", default=False, - help=("produce HTML for C code coverage information " - "from a previous run with --gcov. " - "HTML output goes to build/lcov/")) - parser.add_argument("--mode", "-m", default="fast", - help="'fast', 'full', or something that could be " - "passed to nosetests -A [default: fast]") - parser.add_argument("--submodule", "-s", default=None, - help="Submodule whose tests to run (cluster, constants, ...)") - parser.add_argument("--pythonpath", "-p", default=None, - help="Paths to prepend to PYTHONPATH") - parser.add_argument("--tests", "-t", action='append', - help="Specify tests to run") - parser.add_argument("--python", action="store_true", - help="Start a Python shell with PYTHONPATH set") - parser.add_argument("--ipython", "-i", action="store_true", - help="Start IPython shell with PYTHONPATH set") - parser.add_argument("--shell", action="store_true", - help="Start Unix shell with PYTHONPATH set") - parser.add_argument("--debug", "-g", action="store_true", - help="Debug build") - parser.add_argument("--show-build-log", action="store_true", - help="Show build output rather than using a log file") - parser.add_argument("args", metavar="ARGS", default=[], nargs=REMAINDER, - help="Arguments to pass to Nose, Python or shell") - args = parser.parse_args(argv) - - if args.lcov_html: - # generate C code coverage output - lcov_generate() - sys.exit(0) - - if args.pythonpath: - for p in reversed(args.pythonpath.split(os.pathsep)): - sys.path.insert(0, p) - - if args.gcov: - gcov_reset_counters() - - if not args.no_build: - site_dir = build_project(args) - sys.path.insert(0, site_dir) - os.environ['PYTHONPATH'] = site_dir - - extra_argv = args.args[:] - if extra_argv and extra_argv[0] == '--': - extra_argv = extra_argv[1:] - - if args.python: - if extra_argv: - # Don't use subprocess, since we don't want to include the - # current path in PYTHONPATH. - sys.argv = extra_argv - with open(extra_argv[0], 'r') as f: - script = f.read() - sys.modules['__main__'] = imp.new_module('__main__') - ns = dict(__name__='__main__', - __file__=extra_argv[0]) - exec_(script, ns) - sys.exit(0) - else: - import code - code.interact() - sys.exit(0) - - if args.ipython: - import IPython - IPython.embed(user_ns={}) - sys.exit(0) - - if args.shell: - shell = os.environ.get('SHELL', 'sh') - print("Spawning a Unix shell...") - os.execv(shell, [shell] + extra_argv) - sys.exit(1) - - if args.coverage_html: - dst_dir = os.path.join(ROOT_DIR, 'build', 'coverage') - fn = os.path.join(dst_dir, 'coverage_html.js') - if os.path.isdir(dst_dir) and os.path.isfile(fn): - shutil.rmtree(dst_dir) - extra_argv += ['--cover-html', - '--cover-html-dir='+dst_dir] - - if args.coverage: - extra_argv += ['--cover-erase', '--with-coverage', - '--cover-package=control'] - - test_dir = os.path.join(ROOT_DIR, 'build', 'test') - - if args.build_only: - sys.exit(0) - elif args.submodule: - modname = PROJECT_MODULE + '.' + args.submodule - try: - __import__(modname) - test = sys.modules[modname].test - except (ImportError, KeyError, AttributeError): - print("Cannot run tests for %s" % modname) - sys.exit(2) - elif args.tests: - def fix_test_path(x): - # fix up test path - p = x.split(':') - p[0] = os.path.relpath(os.path.abspath(p[0]), - test_dir) - return ':'.join(p) - - tests = [fix_test_path(x) for x in args.tests] - - def test(*a, **kw): - extra_argv = kw.pop('extra_argv', ()) - extra_argv = extra_argv + tests[1:] - kw['extra_argv'] = extra_argv - from numpy.testing import Tester - return Tester(tests[0]).test(*a, **kw) - else: - __import__(PROJECT_MODULE) - test = sys.modules[PROJECT_MODULE].test - - # Run the tests under build/test - try: - shutil.rmtree(test_dir) - except OSError: - pass - try: - os.makedirs(test_dir) - except OSError: - pass - - cwd = os.getcwd() - try: - os.chdir(test_dir) - result = test(args.mode, - verbose=args.verbose, - extra_argv=extra_argv, - doctests=args.doctests, - coverage=args.coverage) - finally: - os.chdir(cwd) - - if result.wasSuccessful(): - sys.exit(0) - else: - sys.exit(1) - - -def build_project(args): - """ - Build a dev version of the project. - - Returns - ------- - site_dir - site-packages directory where it was installed - - """ - - root_ok = [os.path.exists(os.path.join(ROOT_DIR, fn)) - for fn in PROJECT_ROOT_FILES] - if not all(root_ok): - print("To build the project, run runtests.py in " - "git checkout or unpacked source") - sys.exit(1) - - dst_dir = os.path.join(ROOT_DIR, 'build', 'testenv') - - env = dict(os.environ) - cmd = [sys.executable, 'setup.py'] - - # Always use ccache, if installed - env['PATH'] = os.pathsep.join(EXTRA_PATH + env.get('PATH', '').split(os.pathsep)) - - if args.debug or args.gcov: - # assume everyone uses gcc/gfortran - env['OPT'] = '-O0 -ggdb' - env['FOPT'] = '-O0 -ggdb' - if args.gcov: - import distutils.sysconfig - cvars = distutils.sysconfig.get_config_vars() - env['OPT'] = '-O0 -ggdb' - env['FOPT'] = '-O0 -ggdb' - env['CC'] = cvars['CC'] + ' --coverage' - env['CXX'] = cvars['CXX'] + ' --coverage' - env['F77'] = 'gfortran --coverage ' - env['F90'] = 'gfortran --coverage ' - env['LDSHARED'] = cvars['LDSHARED'] + ' --coverage' - env['LDFLAGS'] = " ".join(cvars['LDSHARED'].split()[1:]) + ' --coverage' - cmd += ["build"] - - cmd += ['install', '--prefix=' + dst_dir] - - log_filename = os.path.join(ROOT_DIR, 'build.log') - - if args.show_build_log: - ret = subprocess.call(cmd, env=env, cwd=ROOT_DIR) - else: - log_filename = os.path.join(ROOT_DIR, 'build.log') - print("Building, see build.log...") - with open(log_filename, 'w') as log: - p = subprocess.Popen(cmd, env=env, stdout=log, stderr=log, - cwd=ROOT_DIR) - - # Wait for it to finish, and print something to indicate the - # process is alive, but only if the log file has grown (to - # allow continuous integration environments kill a hanging - # process accurately if it produces no output) - last_blip = time.time() - last_log_size = os.stat(log_filename).st_size - while p.poll() is None: - time.sleep(0.5) - if time.time() - last_blip > 60: - log_size = os.stat(log_filename).st_size - if log_size > last_log_size: - print(" ... build in progress") - last_blip = time.time() - last_log_size = log_size - - ret = p.wait() - - if ret == 0: - print("Build OK") - else: - if not args.show_build_log: - with open(log_filename, 'r') as f: - print(f.read()) - print("Build failed!") - sys.exit(1) - - from distutils.sysconfig import get_python_lib - site_dir = get_python_lib(prefix=dst_dir, plat_specific=True) - - return site_dir - - -# -# GCOV support -# -def gcov_reset_counters(): - print("Removing previous GCOV .gcda files...") - build_dir = os.path.join(ROOT_DIR, 'build') - for dirpath, dirnames, filenames in os.walk(build_dir): - for fn in filenames: - if fn.endswith('.gcda') or fn.endswith('.da'): - pth = os.path.join(dirpath, fn) - os.unlink(pth) - -# -# LCOV support -# - -LCOV_OUTPUT_FILE = os.path.join(ROOT_DIR, 'build', 'lcov.out') -LCOV_HTML_DIR = os.path.join(ROOT_DIR, 'build', 'lcov') - -def lcov_generate(): - try: os.unlink(LCOV_OUTPUT_FILE) - except OSError: pass - try: shutil.rmtree(LCOV_HTML_DIR) - except OSError: pass - - print("Capturing lcov info...") - subprocess.call(['lcov', '-q', '-c', - '-d', os.path.join(ROOT_DIR, 'build'), - '-b', ROOT_DIR, - '--output-file', LCOV_OUTPUT_FILE]) - - print("Generating lcov HTML output...") - ret = subprocess.call(['genhtml', '-q', LCOV_OUTPUT_FILE, - '--output-directory', LCOV_HTML_DIR, - '--legend', '--highlight']) - if ret != 0: - print("genhtml failed!") - else: - print("HTML output generated under build/lcov/") - - -# -# Python 3 support -# - -if sys.version_info[0] >= 3: - import builtins - exec_ = getattr(builtins, "exec") -else: - def exec_(code, globs=None, locs=None): - """Execute code in a namespace.""" - if globs is None: - frame = sys._getframe(1) - globs = frame.f_globals - if locs is None: - locs = frame.f_locals - del frame - elif locs is None: - locs = globs - exec("""exec code in globs, locs""") - -if __name__ == "__main__": - main(argv=sys.argv[1:]) From 9286831f54d327ab8f8654c78d3c897400d47c66 Mon Sep 17 00:00:00 2001 From: bnavigator Date: Fri, 24 Jul 2020 12:54:54 +0200 Subject: [PATCH 30/67] remove oldstyle and nose references --- README.rst | 12 +++++++++--- setup.py | 6 ++---- 2 files changed, 11 insertions(+), 7 deletions(-) diff --git a/README.rst b/README.rst index 97c1cc96c..d7c1306b5 100644 --- a/README.rst +++ b/README.rst @@ -99,10 +99,16 @@ You can check out the latest version of the source code with the command:: Testing ------- -You can run a set of unit tests to make sure that everything is working -correctly. After installation, run:: +You can run the unit tests with `pytest`_ to make sure that everything is +working correctly. Inside the source directory, run:: - python setup.py test + pytest -v + +or to test the installed package:: + + pytest --pyargs control -v + +.. _pytest: https://docs.pytest.org/ License ------- diff --git a/setup.py b/setup.py index cd4bcbf9f..ea825d471 100644 --- a/setup.py +++ b/setup.py @@ -21,6 +21,8 @@ Programming Language :: Python :: 3 Programming Language :: Python :: 3.5 Programming Language :: Python :: 3.6 +Programming Language :: Python :: 3.7 +Programming Language :: Python :: 3.8 Topic :: Software Development Topic :: Scientific/Engineering Operating System :: Microsoft :: Windows @@ -42,8 +44,4 @@ install_requires=['numpy', 'scipy', 'matplotlib'], - tests_require=['scipy', - 'matplotlib', - 'nose'], - test_suite = 'nose.collector', ) From ebd73c1d22efd121dc908498478bf9a94d0ca92d Mon Sep 17 00:00:00 2001 From: Sawyer Fuller Date: Fri, 24 Jul 2020 10:43:38 -0700 Subject: [PATCH 31/67] fixes in canonical and canonical_test that were assuming numpy.matrix --- control/canonical.py | 30 +++++++++++++----------------- control/tests/canonical_test.py | 24 ++++++++++++------------ 2 files changed, 25 insertions(+), 29 deletions(-) diff --git a/control/canonical.py b/control/canonical.py index b578418bd..bd9ee4a94 100644 --- a/control/canonical.py +++ b/control/canonical.py @@ -6,7 +6,8 @@ from .statesp import StateSpace from .statefbk import ctrb, obsv -from numpy import zeros, shape, poly, iscomplex, hstack, dot, transpose +from numpy import zeros, zeros_like, shape, poly, iscomplex, vstack, hstack, dot, \ + transpose, empty from numpy.linalg import solve, matrix_rank, eig __all__ = ['canonical_form', 'reachable_form', 'observable_form', 'modal_form', @@ -70,9 +71,9 @@ def reachable_form(xsys): zsys = StateSpace(xsys) # Generate the system matrices for the desired canonical form - zsys.B = zeros(shape(xsys.B)) + zsys.B = zeros_like(xsys.B) zsys.B[0, 0] = 1.0 - zsys.A = zeros(shape(xsys.A)) + zsys.A = zeros_like(xsys.A) Apoly = poly(xsys.A) # characteristic polynomial for i in range(0, xsys.states): zsys.A[0, i] = -Apoly[i+1] / Apoly[0] @@ -124,9 +125,9 @@ def observable_form(xsys): zsys = StateSpace(xsys) # Generate the system matrices for the desired canonical form - zsys.C = zeros(shape(xsys.C)) + zsys.C = zeros_like(xsys.C) zsys.C[0, 0] = 1 - zsys.A = zeros(shape(xsys.A)) + zsys.A = zeros_like(xsys.A) Apoly = poly(xsys.A) # characteristic polynomial for i in range(0, xsys.states): zsys.A[i, 0] = -Apoly[i+1] / Apoly[0] @@ -144,7 +145,7 @@ def observable_form(xsys): raise ValueError("Transformation matrix singular to working precision.") # Finally, compute the output matrix - zsys.B = Tzx * xsys.B + zsys.B = Tzx.dot(xsys.B) return zsys, Tzx @@ -174,9 +175,9 @@ def modal_form(xsys): # Calculate eigenvalues and matrix of eigenvectors Tzx, eigval, eigvec = eig(xsys.A) - # Eigenvalues and according eigenvectors are not sorted, + # Eigenvalues and corresponding eigenvectors are not sorted, # thus modal transformation is ambiguous - # Sorting eigenvalues and respective vectors by largest to smallest eigenvalue + # Sort eigenvalues and vectors from largest to smallest eigenvalue idx = eigval.argsort()[::-1] eigval = eigval[idx] eigvec = eigvec[:,idx] @@ -189,23 +190,18 @@ def modal_form(xsys): # Keep track of complex conjugates (need only one) lst_conjugates = [] - Tzx = None + Tzx = empty((0, xsys.A.shape[0])) # empty zero-height row matrix for val, vec in zip(eigval, eigvec.T): if iscomplex(val): if val not in lst_conjugates: lst_conjugates.append(val.conjugate()) - if Tzx is not None: - Tzx = hstack((Tzx, hstack((vec.real.T, vec.imag.T)))) - else: - Tzx = hstack((vec.real.T, vec.imag.T)) + Tzx = vstack((Tzx, vec.real, vec.imag)) else: # if conjugate has already been seen, skip this eigenvalue lst_conjugates.remove(val) else: - if Tzx is not None: - Tzx = hstack((Tzx, vec.real.T)) - else: - Tzx = vec.real.T + Tzx = vstack((Tzx, vec.real)) + Tzx = Tzx.T # Generate the system matrices for the desired canonical form zsys.A = solve(Tzx, xsys.A).dot(Tzx) diff --git a/control/tests/canonical_test.py b/control/tests/canonical_test.py index 3172f13b7..7d4ae4e27 100644 --- a/control/tests/canonical_test.py +++ b/control/tests/canonical_test.py @@ -22,13 +22,13 @@ def test_reachable_form(self): D_true = 42.0 # Perform a coordinate transform with a random invertible matrix - T_true = np.matrix([[-0.27144004, -0.39933167, 0.75634684, 0.44135471], + T_true = np.array([[-0.27144004, -0.39933167, 0.75634684, 0.44135471], [-0.74855725, -0.39136285, -0.18142339, -0.50356997], [-0.40688007, 0.81416369, 0.38002113, -0.16483334], [-0.44769516, 0.15654653, -0.50060858, 0.72419146]]) - A = np.linalg.solve(T_true, A_true)*T_true + A = np.linalg.solve(T_true, A_true).dot(T_true) B = np.linalg.solve(T_true, B_true) - C = C_true*T_true + C = C_true.dot(T_true) D = D_true # Create a state space system and convert it to the reachable canonical form @@ -69,11 +69,11 @@ def test_modal_form(self): D_true = 42.0 # Perform a coordinate transform with a random invertible matrix - T_true = np.matrix([[-0.27144004, -0.39933167, 0.75634684, 0.44135471], + T_true = np.array([[-0.27144004, -0.39933167, 0.75634684, 0.44135471], [-0.74855725, -0.39136285, -0.18142339, -0.50356997], [-0.40688007, 0.81416369, 0.38002113, -0.16483334], [-0.44769516, 0.15654653, -0.50060858, 0.72419146]]) - A = np.linalg.solve(T_true, A_true)*T_true + A = np.linalg.solve(T_true, A_true).dot(T_true) B = np.linalg.solve(T_true, B_true) C = C_true*T_true D = D_true @@ -98,9 +98,9 @@ def test_modal_form(self): C_true = np.array([[1, 0, 0, 1]]) D_true = np.array([[0]]) - A = np.linalg.solve(T_true, A_true) * T_true + A = np.linalg.solve(T_true, A_true).dot(T_true) B = np.linalg.solve(T_true, B_true) - C = C_true * T_true + C = C_true.dot(T_true) D = D_true # Create state space system and convert to modal canonical form @@ -132,9 +132,9 @@ def test_modal_form(self): C_true = np.array([[0, 1, 0, 1]]) D_true = np.array([[0]]) - A = np.linalg.solve(T_true, A_true) * T_true + A = np.linalg.solve(T_true, A_true).dot(T_true) B = np.linalg.solve(T_true, B_true) - C = C_true * T_true + C = C_true.dot(T_true) D = D_true # Create state space system and convert to modal canonical form @@ -173,13 +173,13 @@ def test_observable_form(self): D_true = 42.0 # Perform a coordinate transform with a random invertible matrix - T_true = np.matrix([[-0.27144004, -0.39933167, 0.75634684, 0.44135471], + T_true = np.array([[-0.27144004, -0.39933167, 0.75634684, 0.44135471], [-0.74855725, -0.39136285, -0.18142339, -0.50356997], [-0.40688007, 0.81416369, 0.38002113, -0.16483334], [-0.44769516, 0.15654653, -0.50060858, 0.72419146]]) - A = np.linalg.solve(T_true, A_true)*T_true + A = np.linalg.solve(T_true, A_true).dot(T_true) B = np.linalg.solve(T_true, B_true) - C = C_true*T_true + C = C_true.dot(T_true) D = D_true # Create a state space system and convert it to the observable canonical form From bc650001fd9bde6b2277eb4f49f62323fcb50e97 Mon Sep 17 00:00:00 2001 From: bnavigator Date: Fri, 31 Jul 2020 03:40:42 +0200 Subject: [PATCH 32/67] do not override squeeze parameter in forced_response --- control/timeresp.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/control/timeresp.py b/control/timeresp.py index 8670c180d..bf9dd59b4 100644 --- a/control/timeresp.py +++ b/control/timeresp.py @@ -325,7 +325,7 @@ def forced_response(sys, T=None, U=0., X0=0., transpose=False, # Separate out the discrete and continuous time cases if isctime(sys): # Solve the differential equation, copied from scipy.signal.ltisys. - dot, squeeze, = np.dot, np.squeeze # Faster and shorter code + dot = np.dot # Faster and shorter code # Faster algorithm if U is zero if U is None or (isinstance(U, (int, float)) and U == 0): From 5543fb682d62a660066ad883c8ee7bdb0b2bbe26 Mon Sep 17 00:00:00 2001 From: bnavigator Date: Sat, 1 Aug 2020 15:51:14 +0200 Subject: [PATCH 33/67] fix matlab stepinfo --- control/matlab/timeresp.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/control/matlab/timeresp.py b/control/matlab/timeresp.py index b9d4004ca..1ba7b2a0a 100644 --- a/control/matlab/timeresp.py +++ b/control/matlab/timeresp.py @@ -22,7 +22,7 @@ def step(sys, T=None, X0=0., input=0, output=None, return_x=False): LTI system to simulate T: array-like or number, optional - Time vector, or simulation time duration if a number (time vector is + Time vector, or simulation time duration if a number (time vector is autocomputed if not given) X0: array-like or number, optional @@ -67,7 +67,7 @@ def step(sys, T=None, X0=0., input=0, output=None, return_x=False): return yout, T -def stepinfo(sys, T=None, SettlingTimeThreshold=0.02, RiseTimeLimits=(0.1,0.9)): +def stepinfo(sys, T=None, SettlingTimeThreshold=0.02, RiseTimeLimits=(0.1, 0.9)): ''' Step response characteristics (Rise time, Settling Time, Peak and others). @@ -77,7 +77,7 @@ def stepinfo(sys, T=None, SettlingTimeThreshold=0.02, RiseTimeLimits=(0.1,0.9)): LTI system to simulate T: array-like or number, optional - Time vector, or simulation time duration if a number (time vector is + Time vector, or simulation time duration if a number (time vector is autocomputed if not given) SettlingTimeThreshold: float value, optional @@ -110,7 +110,7 @@ def stepinfo(sys, T=None, SettlingTimeThreshold=0.02, RiseTimeLimits=(0.1,0.9)): ''' from ..timeresp import step_info - S = step_info(sys, T, SettlingTimeThreshold, RiseTimeLimits) + S = step_info(sys, T, None, SettlingTimeThreshold, RiseTimeLimits) return S @@ -130,9 +130,9 @@ def impulse(sys, T=None, X0=0., input=0, output=None, return_x=False): LTI system to simulate T: array-like or number, optional - Time vector, or simulation time duration if a number (time vector is + Time vector, or simulation time duration if a number (time vector is autocomputed if not given) - + X0: array-like or number, optional Initial condition (default = 0) @@ -186,9 +186,9 @@ def initial(sys, T=None, X0=0., input=None, output=None, return_x=False): LTI system to simulate T: array-like or number, optional - Time vector, or simulation time duration if a number (time vector is + Time vector, or simulation time duration if a number (time vector is autocomputed if not given) - + X0: array-like object or number, optional Initial condition (default = 0) From 10ba25ee1c7e21ef294f9219887c22a787bc75f7 Mon Sep 17 00:00:00 2001 From: Laurens Valk Date: Fri, 14 Aug 2020 14:02:17 +0200 Subject: [PATCH 34/67] Fix bullet list in conventions documentation This fixes the following errors, which made the last two bullets display incorrectly. python-control/doc/conventions.rst:229: WARNING: Bullet list ends without a blank line; unexpected unindent. python-control/doc/conventions.rst:232: WARNING: Bullet list ends without a blank line; unexpected unindent. --- doc/conventions.rst | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/conventions.rst b/doc/conventions.rst index f07b51238..99789bc9e 100644 --- a/doc/conventions.rst +++ b/doc/conventions.rst @@ -226,10 +226,10 @@ Selected variables that can be configured, along with their default values: `numpy.matrix` (verus numpy.ndarray) * statesp.default_dt and xferfcn.default_dt (None): set the default value of dt when - constructing new LTI systems + constructing new LTI systems * statesp.remove_useless_states (True): remove states that have no effect on the - input-output dynamics of the system + input-output dynamics of the system Additional parameter variables are documented in individual functions From 1c594cacd13c5c07ecb7e82498796d18972f4774 Mon Sep 17 00:00:00 2001 From: Laurens Valk Date: Fri, 14 Aug 2020 14:15:05 +0200 Subject: [PATCH 35/67] Fix math not displaying correctly in documentation This also fixes the following warnings: python-control/control/statefbk.py:docstring of control.lqe:6: WARNING: Unexpected indentation. python-control/control/statefbk.py:docstring of control.lqe:36: WARNING: Unexpected indentation. --- control/statefbk.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/control/statefbk.py b/control/statefbk.py index c079d9325..957a3d720 100644 --- a/control/statefbk.py +++ b/control/statefbk.py @@ -228,9 +228,11 @@ def lqe(A, G, C, QN, RN, NN=None): systems. Given the system Given the system + .. math:: - x = Ax + Bu + Gw - y = Cx + Du + v + + x &= Ax + Bu + Gw \\\\ + y &= Cx + Du + v with unbiased process noise w and measurement noise v with covariances @@ -260,7 +262,9 @@ def lqe(A, G, C, QN, RN, NN=None): Kalman estimator gain P: 2D array Solution to Riccati equation + .. math:: + A P + P A^T - (P C^T + G N) R^-1 (C P + N^T G^T) + G Q G^T = 0 E: 1D array Eigenvalues of estimator poles eig(A - L C) From 69ce8b48fd1b41b65f6579b7c5345a90fd047f67 Mon Sep 17 00:00:00 2001 From: Laurens Valk Date: Fri, 14 Aug 2020 14:16:11 +0200 Subject: [PATCH 36/67] Remove duplicate "Given the system" --- control/statefbk.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/control/statefbk.py b/control/statefbk.py index 957a3d720..9c784043c 100644 --- a/control/statefbk.py +++ b/control/statefbk.py @@ -227,8 +227,6 @@ def lqe(A, G, C, QN, RN, NN=None): Linear quadratic estimator design (Kalman filter) for continuous-time systems. Given the system - Given the system - .. math:: x &= Ax + Bu + Gw \\\\ From ac9e00eb1fc6af4ec0761ed42dbe093b3bfc8c82 Mon Sep 17 00:00:00 2001 From: Laurens Valk Date: Fri, 14 Aug 2020 14:24:57 +0200 Subject: [PATCH 37/67] Fix broken reference to scipy.signal.dlsim The link to dlsim was broken, producing a warning. The links to lsim were missing. --- control/timeresp.py | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/control/timeresp.py b/control/timeresp.py index 8670c180d..6fd34f973 100644 --- a/control/timeresp.py +++ b/control/timeresp.py @@ -219,7 +219,7 @@ def forced_response(sys, T=None, U=0., X0=0., transpose=False, transpose: bool, optional (default=False) If True, transpose all input and output arrays (for backward - compatibility with MATLAB and scipy.signal.lsim) + compatibility with MATLAB and :func:`scipy.signal.lsim`) interpolate: bool, optional (default=False) If True and system is a discrete time system, the input will @@ -249,7 +249,7 @@ def forced_response(sys, T=None, U=0., X0=0., transpose=False, Notes ----- For discrete time systems, the input/output response is computed using the - :scipy-signal:ref:`scipy.signal.dlsim` function. + :func:`scipy.signal.dlsim` function. For continuous time systems, the output is computed using the matrix exponential `exp(A t)` and assuming linear interpolation of the inputs @@ -490,7 +490,7 @@ def step_response(sys, T=None, X0=0., input=None, output=None, T_num=None, transpose: bool If True, transpose all input and output arrays (for backward - compatibility with MATLAB and scipy.signal.lsim) + compatibility with MATLAB and :func:`scipy.signal.lsim`) return_x: bool If True, return the state vector (default = False). @@ -662,7 +662,7 @@ def initial_response(sys, T=None, X0=0., input=0, output=None, T_num=None, transpose: bool If True, transpose all input and output arrays (for backward - compatibility with MATLAB and scipy.signal.lsim) + compatibility with MATLAB and :func:`scipy.signal.lsim`) return_x: bool If True, return the state vector (default = False). @@ -751,7 +751,7 @@ def impulse_response(sys, T=None, X0=0., input=0, output=None, T_num=None, transpose: bool If True, transpose all input and output arrays (for backward - compatibility with MATLAB and scipy.signal.lsim) + compatibility with MATLAB and :func:`scipy.signal.lsim`) return_x: bool If True, return the state vector (default = False). @@ -882,4 +882,4 @@ def _default_time_vector(sys, N=None, tfinal=None): if N is None: N = int(np.clip(tfinal/ideal_dt, N_min_ct, N_max)) # N<-[N_min, N_max] - return np.linspace(0, tfinal, N, endpoint=False) \ No newline at end of file + return np.linspace(0, tfinal, N, endpoint=False) From 04725efabeb5c735269cad4fa14f12a7b126b0d4 Mon Sep 17 00:00:00 2001 From: Laurens Valk Date: Fri, 14 Aug 2020 15:48:52 +0200 Subject: [PATCH 38/67] Fix typos where Riccati was spelled as Ricatti --- control/robust.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/control/robust.py b/control/robust.py index 75c43001b..2584339ac 100644 --- a/control/robust.py +++ b/control/robust.py @@ -119,8 +119,8 @@ def hinfsyn(P, nmeas, ncon): rcond: 4-vector, reciprocal condition estimates of: 1: control transformation matrix 2: measurement transformation matrix - 3: X-Ricatti equation - 4: Y-Ricatti equation + 3: X-Riccati equation + 4: Y-Riccati equation TODO: document significance of rcond Raises From a1061ecf2b8da4f1b063f90c6d3073ef5e8fd69c Mon Sep 17 00:00:00 2001 From: Laurens Valk Date: Fri, 14 Aug 2020 15:51:20 +0200 Subject: [PATCH 39/67] Fix inverse not written as superscript in math --- control/statefbk.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/control/statefbk.py b/control/statefbk.py index 9c784043c..c2eedcd3f 100644 --- a/control/statefbk.py +++ b/control/statefbk.py @@ -263,7 +263,7 @@ def lqe(A, G, C, QN, RN, NN=None): .. math:: - A P + P A^T - (P C^T + G N) R^-1 (C P + N^T G^T) + G Q G^T = 0 + A P + P A^T - (P C^T + G N) R^{-1} (C P + N^T G^T) + G Q G^T = 0 E: 1D array Eigenvalues of estimator poles eig(A - L C) From 69c33e5e5943b38ba27531833cba58dba2a95cce Mon Sep 17 00:00:00 2001 From: Laurens Valk Date: Fri, 14 Aug 2020 21:40:17 +0200 Subject: [PATCH 40/67] Remove duplicate intersphinx_mapping This left-over example configuration caused the intended intersphinx_mapping not to work, thus breaking links to scipy and numpy. Now the links should work again. --- doc/conf.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/doc/conf.py b/doc/conf.py index f4c260558..eef9ed276 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -194,6 +194,3 @@ # -- Extension configuration ------------------------------------------------- # -- Options for intersphinx extension --------------------------------------- - -# Example configuration for intersphinx: refer to the Python standard library. -intersphinx_mapping = {'https://docs.python.org/': None} From c13cc8066bcf8c3d902fbee4afd03ad04ccaee7f Mon Sep 17 00:00:00 2001 From: bnavigator Date: Fri, 14 Aug 2020 23:46:54 +0200 Subject: [PATCH 41/67] fix and update scipy intersphinx references --- control/freqplot.py | 19 ++++++++++--------- control/iosys.py | 11 ++++++----- control/phaseplot.py | 2 +- control/statefbk.py | 37 +++++++++++++++++++++---------------- control/statesp.py | 23 ++++++++++++----------- control/xferfcn.py | 18 +++++++++--------- doc/conf.py | 24 ++++++++++-------------- 7 files changed, 69 insertions(+), 65 deletions(-) diff --git a/control/freqplot.py b/control/freqplot.py index 7b296c111..08abb5f50 100644 --- a/control/freqplot.py +++ b/control/freqplot.py @@ -128,21 +128,22 @@ def bode_plot(syslist, omega=None, ---------------- grid : bool If True, plot grid lines on gain and phase plots. Default is set by - config.defaults['bode.grid']. + `config.defaults['bode.grid']`. + The default values for Bode plot configuration parameters can be reset using the `config.defaults` dictionary, with module name 'bode'. Notes ----- - 1. Alternatively, you may use the lower-level method (mag, phase, freq) - = sys.freqresp(freq) to generate the frequency response for a system, - but it returns a MIMO response. + 1. Alternatively, you may use the lower-level method + ``(mag, phase, freq) = sys.freqresp(freq)`` to generate the frequency + response for a system, but it returns a MIMO response. 2. If a discrete time model is given, the frequency response is plotted - along the upper branch of the unit circle, using the mapping z = exp(j - \\omega dt) where omega ranges from 0 to pi/dt and dt is the discrete - timebase. If not timebase is specified (dt = True), dt is set to 1. + along the upper branch of the unit circle, using the mapping z = exp(j + \\omega dt) where omega ranges from 0 to pi/dt and dt is the discrete + timebase. If not timebase is specified (dt = True), dt is set to 1. Examples -------- @@ -539,13 +540,13 @@ def nyquist_plot(syslist, omega=None, plot=True, label_freq=0, ax = plt.gca() # Plot arrow to indicate Nyquist encirclement orientation ax.arrow(x[0], y[0], (x[1]-x[0])/2, (y[1]-y[0])/2, fc=c, ec=c, - head_width=arrowhead_width, + head_width=arrowhead_width, head_length=arrowhead_length) plt.plot(x, -y, '-', color=c, *args, **kwargs) ax.arrow( x[-1], -y[-1], (x[-1]-x[-2])/2, (y[-1]-y[-2])/2, - fc=c, ec=c, head_width=arrowhead_width, + fc=c, ec=c, head_width=arrowhead_width, head_length=arrowhead_length) # Mark the -1 point diff --git a/control/iosys.py b/control/iosys.py index 1fe10346f..52ea07f24 100644 --- a/control/iosys.py +++ b/control/iosys.py @@ -1514,8 +1514,9 @@ def find_eqpt(sys, x0, u0=[], y0=None, t=0, params={}, return_y : bool, optional If True, return the value of output at the equilibrium point. return_result : bool, optional - If True, return the `result` option from the scipy root function used - to compute the equilibrium point. + If True, return the `result` option from the + :func:`scipy.optimize.root` function used to compute the equilibrium + point. Returns ------- @@ -1529,9 +1530,9 @@ def find_eqpt(sys, x0, u0=[], y0=None, t=0, params={}, If `return_y` is True, returns the value of the outputs at the equilibrium point, or `None` if no equilibrium point was found and `return_result` was False. - result : scipy root() result object, optional - If `return_result` is True, returns the `result` from the scipy root - function. + result : :class:`scipy.optimize.OptimizeResult`, optional + If `return_result` is True, returns the `result` from the + :func:`scipy.optimize.root` function. """ from scipy.optimize import root diff --git a/control/phaseplot.py b/control/phaseplot.py index 6cac09e6c..83108ec01 100644 --- a/control/phaseplot.py +++ b/control/phaseplot.py @@ -73,7 +73,7 @@ def phase_plot(odefun, X=None, Y=None, scale=1, X0=None, T=None, func : callable(x, t, ...) Computes the time derivative of y (compatible with odeint). The function should be the same for as used for - scipy.integrate. Namely, it should be a function of the form + :mod:`scipy.integrate`. Namely, it should be a function of the form dxdt = F(x, t) that accepts a state x of dimension 2 and returns a derivative dx/dt of dimension 2. diff --git a/control/statefbk.py b/control/statefbk.py index c2eedcd3f..c9e01a52f 100644 --- a/control/statefbk.py +++ b/control/statefbk.py @@ -53,6 +53,7 @@ # Pole placement def place(A, B, p): """Place closed loop eigenvalues + K = place(A, B, p) Parameters @@ -69,21 +70,24 @@ def place(A, B, p): K : 2-d array Gain such that A - B K has eigenvalues given in p - Algorithm - --------- - This is a wrapper function for scipy.signal.place_poles, which - implements the Tits and Yang algorithm [1]. It will handle SISO, - MISO, and MIMO systems. If you want more control over the algorithm, - use scipy.signal.place_poles directly. - [1] A.L. Tits and Y. Yang, "Globally convergent algorithms for robust - pole assignment by state feedback, IEEE Transactions on Automatic - Control, Vol. 41, pp. 1432-1452, 1996. + Notes + ----- + Algorithm + This is a wrapper function for :func:`scipy.signal.place_poles`, which + implements the Tits and Yang algorithm [1]_. It will handle SISO, + MISO, and MIMO systems. If you want more control over the algorithm, + use :func:`scipy.signal.place_poles` directly. Limitations - ----------- - The algorithm will not place poles at the same location more - than rank(B) times. + The algorithm will not place poles at the same location more + than rank(B) times. + + References + ---------- + .. [1] A.L. Tits and Y. Yang, "Globally convergent algorithms for robust + pole assignment by state feedback, IEEE Transactions on Automatic + Control, Vol. 41, pp. 1432-1452, 1996. Examples -------- @@ -228,10 +232,10 @@ def lqe(A, G, C, QN, RN, NN=None): systems. Given the system .. math:: - + x &= Ax + Bu + Gw \\\\ y &= Cx + Du + v - + with unbiased process noise w and measurement noise v with covariances .. math:: E{ww'} = QN, E{vv'} = RN, E{wv'} = NN @@ -264,9 +268,10 @@ def lqe(A, G, C, QN, RN, NN=None): .. math:: A P + P A^T - (P C^T + G N) R^{-1} (C P + N^T G^T) + G Q G^T = 0 + E: 1D array Eigenvalues of estimator poles eig(A - L C) - + Examples -------- @@ -383,7 +388,7 @@ def lqr(*args, **keywords): See Also -------- lqe - + """ # Make sure that SLICOT is installed diff --git a/control/statesp.py b/control/statesp.py index 522d187a9..b94c6826e 100644 --- a/control/statesp.py +++ b/control/statesp.py @@ -72,7 +72,7 @@ _statesp_defaults = { 'statesp.use_numpy_matrix': True, 'statesp.default_dt': None, - 'statesp.remove_useless_states': True, + 'statesp.remove_useless_states': True, } @@ -149,7 +149,7 @@ class StateSpace(LTI): Setting dt = 0 specifies a continuous system, while leaving dt = None means the system timebase is not specified. If 'dt' is set to True, the system will be treated as a discrete time system with unspecified sampling - time. The default value of 'dt' is None and can be changed by changing the + time. The default value of 'dt' is None and can be changed by changing the value of ``control.config.defaults['statesp.default_dt']``. """ @@ -788,15 +788,15 @@ def minreal(self, tol=0.0): # TODO: add discrete time check def returnScipySignalLTI(self): - """Return a list of a list of scipy.signal.lti objects. + """Return a list of a list of :class:`scipy.signal.lti` objects. For instance, >>> out = ssobject.returnScipySignalLTI() >>> out[3][5] - is a signal.scipy.lti object corresponding to the transfer function from - the 6th input to the 4th output.""" + is a :class:`scipy.signal.lti` object corresponding to the transfer + function from the 6th input to the 4th output.""" # Preallocate the output. out = [[[] for _ in range(self.inputs)] for _ in range(self.outputs)] @@ -809,8 +809,9 @@ def returnScipySignalLTI(self): return out def append(self, other): - """Append a second model to the present model. The second - model is converted to state-space if necessary, inputs and + """Append a second model to the present model. + + The second model is converted to state-space if necessary, inputs and outputs are appended and their order is preserved""" if not isinstance(other, StateSpace): other = _convertToStateSpace(other) @@ -870,8 +871,8 @@ def sample(self, Ts, method='zoh', alpha=None, prewarp_frequency=None): prewarp_frequency : float within [0, infinity) The frequency [rad/s] at which to match with the input continuous- - time system's magnitude and phase (the gain=1 crossover frequency, - for example). Should only be specified with method='bilinear' or + time system's magnitude and phase (the gain=1 crossover frequency, + for example). Should only be specified with method='bilinear' or 'gbt' with alpha=0.5 and ignored otherwise. Returns @@ -881,7 +882,7 @@ def sample(self, Ts, method='zoh', alpha=None, prewarp_frequency=None): Notes ----- - Uses the command 'cont2discrete' from scipy.signal + Uses :func:`scipy.signal.cont2discrete` Examples -------- @@ -896,7 +897,7 @@ def sample(self, Ts, method='zoh', alpha=None, prewarp_frequency=None): if (method=='bilinear' or (method=='gbt' and alpha==0.5)) and \ prewarp_frequency is not None: Twarp = 2*np.tan(prewarp_frequency*Ts/2)/prewarp_frequency - else: + else: Twarp = Ts Ad, Bd, C, D, _ = cont2discrete(sys, Twarp, method, alpha) return StateSpace(Ad, Bd, C, D, Ts) diff --git a/control/xferfcn.py b/control/xferfcn.py index f50d5141d..b00edc7d8 100644 --- a/control/xferfcn.py +++ b/control/xferfcn.py @@ -93,8 +93,8 @@ class TransferFunction(LTI): instance variable and setting it to something other than 'None'. If 'dt' has a non-zero value, then it must match whenever two transfer functions are combined. If 'dt' is set to True, the system will be treated as a - discrete time system with unspecified sampling time. The default value of - 'dt' is None and can be changed by changing the value of + discrete time system with unspecified sampling time. The default value of + 'dt' is None and can be changed by changing the value of ``control.config.defaults['xferfcn.default_dt']``. The TransferFunction class defines two constants ``s`` and ``z`` that @@ -802,14 +802,14 @@ def minreal(self, tol=None): return TransferFunction(num, den, self.dt) def returnScipySignalLTI(self): - """Return a list of a list of scipy.signal.lti objects. + """Return a list of a list of :class:`scipy.signal.lti` objects. For instance, >>> out = tfobject.returnScipySignalLTI() >>> out[3][5] - is a signal.scipy.lti object corresponding to the + is a class:`scipy.signal.lti` object corresponding to the transfer function from the 6th input to the 4th output. """ @@ -1016,11 +1016,11 @@ def sample(self, Ts, method='zoh', alpha=None, prewarp_frequency=None): The generalized bilinear transformation weighting parameter, which should only be specified with method="gbt", and is ignored otherwise. - + prewarp_frequency : float within [0, infinity) The frequency [rad/s] at which to match with the input continuous- - time system's magnitude and phase (the gain=1 crossover frequency, - for example). Should only be specified with method='bilinear' or + time system's magnitude and phase (the gain=1 crossover frequency, + for example). Should only be specified with method='bilinear' or 'gbt' with alpha=0.5 and ignored otherwise. Returns @@ -1032,7 +1032,7 @@ def sample(self, Ts, method='zoh', alpha=None, prewarp_frequency=None): ----- 1. Available only for SISO systems - 2. Uses the command `cont2discrete` from `scipy.signal` + 2. Uses :func:`scipy.signal.cont2discrete` Examples -------- @@ -1050,7 +1050,7 @@ def sample(self, Ts, method='zoh', alpha=None, prewarp_frequency=None): if (method=='bilinear' or (method=='gbt' and alpha==0.5)) and \ prewarp_frequency is not None: Twarp = 2*np.tan(prewarp_frequency*Ts/2)/prewarp_frequency - else: + else: Twarp = Ts numd, dend, _ = cont2discrete(sys, Twarp, method, alpha) return TransferFunction(numd[0, :], dend, Ts) diff --git a/doc/conf.py b/doc/conf.py index eef9ed276..de66cc9c9 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -30,7 +30,7 @@ # -- Project information ----------------------------------------------------- project = u'Python Control Systems Library' -copyright = u'2019, python-control.org' +copyright = u'2020, python-control.org' author = u'Python Control Developers' # Version information - read from the source code @@ -55,7 +55,7 @@ # ones. extensions = [ 'sphinx.ext.autodoc', 'sphinx.ext.todo', 'sphinx.ext.napoleon', - 'sphinx.ext.intersphinx', 'sphinx.ext.imgmath', + 'sphinx.ext.intersphinx', 'sphinx.ext.imgmath', 'sphinx.ext.autosummary', 'nbsphinx', ] @@ -64,7 +64,8 @@ # list of autodoc directive flags that should be automatically applied # to all autodoc directives. -autodoc_default_flags = ['members', 'inherited-members'] +autodoc_default_options = {'members': True, + 'inherited-members': True} # Add any paths that contain templates here, relative to this directory. templates_path = ['_templates'] @@ -94,14 +95,14 @@ # The name of the Pygments (syntax highlighting) style to use. pygments_style = 'sphinx' -#This config value contains the locations and names of other projects that -#should be linked to in this documentation. +# This config value contains the locations and names of other projects that +# should be linked to in this documentation. intersphinx_mapping = \ - {'scipy':('https://docs.scipy.org/doc/scipy/reference', None), - 'numpy':('https://docs.scipy.org/doc/numpy', None)} + {'scipy': ('https://docs.scipy.org/doc/scipy/reference', None), + 'numpy': ('https://docs.scipy.org/doc/numpy', None)} -#If this is True, todo and todolist produce output, else they produce nothing. -#The default is False. +# If this is True, todo and todolist produce output, else they produce nothing. +# The default is False. todo_include_todos = True @@ -189,8 +190,3 @@ author, 'PythonControlLibrary', 'One line description of project.', 'Miscellaneous'), ] - - -# -- Extension configuration ------------------------------------------------- - -# -- Options for intersphinx extension --------------------------------------- From c70fbebe533c52a04ccccca7b6321df271f8583c Mon Sep 17 00:00:00 2001 From: bnavigator Date: Fri, 14 Aug 2020 23:39:27 +0200 Subject: [PATCH 42/67] add matplotlib to intersphinx --- control/freqplot.py | 10 +++++----- control/nichols.py | 6 ++---- control/pzmap.py | 2 +- control/rlocus.py | 16 ++++++++++------ control/sisotool.py | 5 +++-- doc/conf.py | 4 +++- doc/control.rst | 1 + 7 files changed, 25 insertions(+), 19 deletions(-) diff --git a/control/freqplot.py b/control/freqplot.py index 08abb5f50..ac658f1da 100644 --- a/control/freqplot.py +++ b/control/freqplot.py @@ -110,9 +110,9 @@ def bode_plot(syslist, omega=None, config.defaults['freqplot.number_of_samples']. margins : bool If True, plot gain and phase margin. - *args : `matplotlib` plot positional properties, optional + *args : :func:`matplotlib.pyplot.plot` positional properties, optional Additional arguments for `matplotlib` plots (color, linestyle, etc) - **kwargs : `matplotlib` plot keyword properties, optional + **kwargs : :func:`matplotlib.pyplot.plot` keyword properties, optional Additional keywords (passed to `matplotlib`) Returns @@ -465,9 +465,9 @@ def nyquist_plot(syslist, omega=None, plot=True, label_freq=0, Label every nth frequency on the plot arrowhead_width : arrow head width arrowhead_length : arrow head length - *args : `matplotlib` plot positional properties, optional + *args : :func:`matplotlib.pyplot.plot` positional properties, optional Additional arguments for `matplotlib` plots (color, linestyle, etc) - **kwargs : `matplotlib` plot keyword properties, optional + **kwargs : :func:`matplotlib.pyplot.plot` keyword properties, optional Additional keywords (passed to `matplotlib`) Returns @@ -602,7 +602,7 @@ def gangof4_plot(P, C, omega=None, **kwargs): Linear input/output systems (process and control) omega : array Range of frequencies (list or bounds) in rad/sec - **kwargs : `matplotlib` plot keyword properties, optional + **kwargs : :func:`matplotlib.pyplot.plot` keyword properties, optional Additional keywords (passed to `matplotlib`) Returns diff --git a/control/nichols.py b/control/nichols.py index c8a98ed5e..6d5364dc0 100644 --- a/control/nichols.py +++ b/control/nichols.py @@ -135,11 +135,9 @@ def nichols_grid(cl_mags=None, cl_phases=None, line_style='dotted'): Array of closed-loop phases defining the iso-phase lines on a custom Nichols chart. Must be in the range -360 < cl_phases < 0 line_style : string, optional - .. seealso:: https://matplotlib.org/gallery/lines_bars_and_markers/linestyles.html + :doc:`Matplotlib linestyle \ + ` - Returns - ------- - None """ # Default chart size ol_phase_min = -359.99 diff --git a/control/pzmap.py b/control/pzmap.py index 82960270f..fe8e551a0 100644 --- a/control/pzmap.py +++ b/control/pzmap.py @@ -66,7 +66,7 @@ def pzmap(sys, plot=True, grid=False, title='Pole Zero Map', **kwargs): ---------- sys: LTI (StateSpace or TransferFunction) Linear system for which poles and zeros are computed. - plot: bool + plot: bool, optional If ``True`` a graph is generated with Matplotlib, otherwise the poles and zeros are only computed and returned. grid: boolean (default = False) diff --git a/control/rlocus.py b/control/rlocus.py index 9f7ff4568..479a833ab 100644 --- a/control/rlocus.py +++ b/control/rlocus.py @@ -75,7 +75,7 @@ # Main function: compute a root locus diagram def root_locus(sys, kvect=None, xlim=None, ylim=None, - plotstr=None, plot=True, print_gain=None, grid=None, ax=None, + plotstr=None, plot=True, print_gain=None, grid=None, ax=None, **kwargs): """Root locus plot @@ -91,9 +91,13 @@ def root_locus(sys, kvect=None, xlim=None, ylim=None, kvect : list or ndarray, optional List of gains to use in computing diagram. xlim : tuple or list, optional - Set limits of x axis, normally with tuple (see matplotlib.axes). + Set limits of x axis, normally with tuple + (see :doc:`matplotlib:api/axes_api`). ylim : tuple or list, optional - Set limits of y axis, normally with tuple (see matplotlib.axes). + Set limits of y axis, normally with tuple + (see :doc:`matplotlib:api/axes_api`). + plotstr : :func:`matplotlib.pyplot.plot` format string, optional + plotting style specification plot : boolean, optional If True (default), plot root locus diagram. print_gain : bool @@ -101,8 +105,8 @@ def root_locus(sys, kvect=None, xlim=None, ylim=None, branches, calculate gain, damping and print. grid : bool If True plot omega-damping grid. Default is False. - ax : Matplotlib axis - axis on which to create root locus plot + ax : :class:`matplotlib.axes.Axes` + Axes on which to create root locus plot Returns ------- @@ -160,7 +164,7 @@ def root_locus(sys, kvect=None, xlim=None, ylim=None, fig = kwargs['fig'] ax = fig.axes[1] else: - if ax is None: + if ax is None: ax = plt.gca() fig = ax.figure ax.set_title('Root Locus') diff --git a/control/sisotool.py b/control/sisotool.py index 8d8459226..32853971a 100644 --- a/control/sisotool.py +++ b/control/sisotool.py @@ -26,10 +26,11 @@ def sisotool(sys, kvect = None, xlim_rlocus = None, ylim_rlocus = None, kvect : list or ndarray, optional List of gains to use for plotting root locus xlim_rlocus : tuple or list, optional - control of x-axis range, normally with tuple (see matplotlib.axes) + control of x-axis range, normally with tuple + (see :doc:`matplotlib:api/axes_api`). ylim_rlocus : tuple or list, optional control of y-axis range - plotstr_rlocus : Additional options to matplotlib + plotstr_rlocus : :func:`matplotlib.pyplot.plot` format string, optional plotting style for the root locus plot(color, linestyle, etc) rlocus_grid: boolean (default = False) If True plot s-plane grid. diff --git a/doc/conf.py b/doc/conf.py index de66cc9c9..ebff50858 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -99,7 +99,9 @@ # should be linked to in this documentation. intersphinx_mapping = \ {'scipy': ('https://docs.scipy.org/doc/scipy/reference', None), - 'numpy': ('https://docs.scipy.org/doc/numpy', None)} + 'numpy': ('https://numpy.org/doc/stable', None), + 'matplotlib': ('https://matplotlib.org/', None), + } # If this is True, todo and todolist produce output, else they produce nothing. # The default is False. diff --git a/doc/control.rst b/doc/control.rst index 57d64b1eb..d44de3f04 100644 --- a/doc/control.rst +++ b/doc/control.rst @@ -45,6 +45,7 @@ Frequency domain plotting nyquist_plot gangof4_plot nichols_plot + nichols_grid Note: For plotting commands that create multiple axes on the same plot, the individual axes can be retrieved using the axes label (retrieved using the From 7e39237e49f55d3946c618fff89cb97940d2f3b9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jo=C3=A3o=20Pinheiro?= Date: Mon, 17 Aug 2020 13:33:12 -0300 Subject: [PATCH 43/67] PEP8 updated semicolons are removed --- control/tests/phaseplot_test.py | 17 ++++++++++------- 1 file changed, 10 insertions(+), 7 deletions(-) diff --git a/control/tests/phaseplot_test.py b/control/tests/phaseplot_test.py index a911c1ec1..5b41615d7 100644 --- a/control/tests/phaseplot_test.py +++ b/control/tests/phaseplot_test.py @@ -18,18 +18,18 @@ class TestPhasePlot(unittest.TestCase): def setUp(self): - pass; + pass def testInvPendNoSims(self): - phase_plot(self.invpend_ode, (-6,6,10), (-6,6,10)); + phase_plot(self.invpend_ode, (-6,6,10), (-6,6,10)) def testInvPendSims(self): phase_plot(self.invpend_ode, (-6,6,10), (-6,6,10), - X0 = ([1,1], [-1,1])); + X0 = ([1,1], [-1,1])) def testInvPendTimePoints(self): phase_plot(self.invpend_ode, (-6,6,10), (-6,6,10), - X0 = ([1,1], [-1,1]), T=np.linspace(0,5,100)); + X0 = ([1,1], [-1,1]), T=np.linspace(0,5,100)) def testInvPendLogtime(self): phase_plot(self.invpend_ode, X0 = @@ -46,12 +46,15 @@ def testInvPendAuto(self): [[-2.3056, 2.1], [2.3056, -2.1]], T=6, verbose=False) def testOscillatorParams(self): - m = 1; b = 1; k = 1; # default values + # default values + m = 1 + b = 1 + k = 1 phase_plot(self.oscillator_ode, timepts = [0.3, 1, 2, 3], X0 = [[-1,1], [-0.3,1], [0,1], [0.25,1], [0.5,1], [0.7,1], [1,1], [1.3,1], [1,-1], [0.3,-1], [0,-1], [-0.25,-1], [-0.5,-1], [-0.7,-1], [-1,-1], [-1.3,-1]], - T = np.linspace(0, 10, 100), parms = (m, b, k)); + T = np.linspace(0, 10, 100), parms = (m, b, k)) def testNoArrows(self): # Test case from aramakrl that was generating a type error @@ -71,7 +74,7 @@ def d1(x1x2,t): # Sample dynamical systems - inverted pendulum def invpend_ode(self, x, t, m=1., l=1., b=0, g=9.8): import numpy as np - return (x[1], -b/m*x[1] + (g*l/m) * np.sin(x[0])) + return (x[1], -b/m*x[1] + (g*l/m)*np.sin(x[0])) # Sample dynamical systems - oscillator def oscillator_ode(self, x, t, m=1., b=1, k=1, extra=None): From 20163863b1a62fe21041a8735f94d51adce35ebf Mon Sep 17 00:00:00 2001 From: bnavigator Date: Sat, 1 Aug 2020 05:03:57 +0200 Subject: [PATCH 44/67] get rid of deprecated scipy calls --- control/freqplot.py | 16 +++++++++------- control/nichols.py | 23 +++++++++++------------ 2 files changed, 20 insertions(+), 19 deletions(-) diff --git a/control/freqplot.py b/control/freqplot.py index ac658f1da..448814a55 100644 --- a/control/freqplot.py +++ b/control/freqplot.py @@ -40,11 +40,13 @@ # SUCH DAMAGE. # # $Id$ + +import math + import matplotlib as mpl import matplotlib.pyplot as plt -import scipy as sp import numpy as np -import math + from .ctrlutil import unwrap from .bdalg import feedback from .margins import stability_margins @@ -184,12 +186,12 @@ def bode_plot(syslist, omega=None, if Hz: omega_limits *= 2. * math.pi if omega_num: - omega = sp.logspace(np.log10(omega_limits[0]), + omega = np.logspace(np.log10(omega_limits[0]), np.log10(omega_limits[1]), num=omega_num, endpoint=True) else: - omega = sp.logspace(np.log10(omega_limits[0]), + omega = np.logspace(np.log10(omega_limits[0]), np.log10(omega_limits[1]), endpoint=True) @@ -530,8 +532,8 @@ def nyquist_plot(syslist, omega=None, plot=True, label_freq=0, phase = np.squeeze(phase_tmp) # Compute the primary curve - x = sp.multiply(mag, sp.cos(phase)) - y = sp.multiply(mag, sp.sin(phase)) + x = np.multiply(mag, np.cos(phase)) + y = np.multiply(mag, np.sin(phase)) if plot: # Plot the primary curve and mirror image @@ -557,7 +559,7 @@ def nyquist_plot(syslist, omega=None, plot=True, label_freq=0, ind = slice(None, None, label_freq) for xpt, ypt, omegapt in zip(x[ind], y[ind], omega[ind]): # Convert to Hz - f = omegapt / (2 * sp.pi) + f = omegapt / (2 * np.pi) # Factor out multiples of 1000 and limit the # result to the range [-8, 8]. diff --git a/control/nichols.py b/control/nichols.py index 6d5364dc0..ca0505957 100644 --- a/control/nichols.py +++ b/control/nichols.py @@ -49,7 +49,6 @@ # # $Id: freqplot.py 139 2011-03-30 16:19:59Z murrayrm $ -import scipy as sp import numpy as np import matplotlib.pyplot as plt from .ctrlutil import unwrap @@ -102,8 +101,8 @@ def nichols_plot(sys_list, omega=None, grid=None): # Convert to Nichols-plot format (phase in degrees, # and magnitude in dB) - x = unwrap(sp.degrees(phase), 360) - y = 20*sp.log10(mag) + x = unwrap(np.degrees(phase), 360) + y = 20*np.log10(mag) # Generate the plot plt.plot(x, y) @@ -183,13 +182,13 @@ def nichols_grid(cl_mags=None, cl_phases=None, line_style='dotted'): # Find the M-contours m = m_circles(cl_mags, phase_min=np.min(cl_phases), phase_max=np.max(cl_phases)) - m_mag = 20*sp.log10(np.abs(m)) - m_phase = sp.mod(sp.degrees(sp.angle(m)), -360.0) # Unwrap + m_mag = 20*np.log10(np.abs(m)) + m_phase = np.mod(np.degrees(np.angle(m)), -360.0) # Unwrap # Find the N-contours n = n_circles(cl_phases, mag_min=np.min(cl_mags), mag_max=np.max(cl_mags)) - n_mag = 20*sp.log10(np.abs(n)) - n_phase = sp.mod(sp.degrees(sp.angle(n)), -360.0) # Unwrap + n_mag = 20*np.log10(np.abs(n)) + n_phase = np.mod(np.degrees(np.angle(n)), -360.0) # Unwrap # Plot the contours behind other plot elements. # The "phase offset" is used to produce copies of the chart that cover @@ -247,7 +246,7 @@ def closed_loop_contours(Gcl_mags, Gcl_phases): # Compute the contours in Gcl-space. Since we're given closed-loop # magnitudes and phases, this is just a case of converting them into # a complex number. - Gcl = Gcl_mags*sp.exp(1.j*Gcl_phases) + Gcl = Gcl_mags*np.exp(1.j*Gcl_phases) # Invert Gcl = Gol/(1+Gol) to map the contours into the open-loop space return Gcl/(1.0 - Gcl) @@ -274,8 +273,8 @@ def m_circles(mags, phase_min=-359.75, phase_max=-0.25): """ # Convert magnitudes and phase range into a grid suitable for # building contours - phases = sp.radians(sp.linspace(phase_min, phase_max, 2000)) - Gcl_mags, Gcl_phases = sp.meshgrid(10.0**(mags/20.0), phases) + phases = np.radians(np.linspace(phase_min, phase_max, 2000)) + Gcl_mags, Gcl_phases = np.meshgrid(10.0**(mags/20.0), phases) return closed_loop_contours(Gcl_mags, Gcl_phases) @@ -300,8 +299,8 @@ def n_circles(phases, mag_min=-40.0, mag_max=12.0): """ # Convert phases and magnitude range into a grid suitable for # building contours - mags = sp.linspace(10**(mag_min/20.0), 10**(mag_max/20.0), 2000) - Gcl_phases, Gcl_mags = sp.meshgrid(sp.radians(phases), mags) + mags = np.linspace(10**(mag_min/20.0), 10**(mag_max/20.0), 2000) + Gcl_phases, Gcl_mags = np.meshgrid(np.radians(phases), mags) return closed_loop_contours(Gcl_mags, Gcl_phases) From 76ec2de6d143597a39abd25f08c67fc1c3c286c0 Mon Sep 17 00:00:00 2001 From: bnavigator Date: Sat, 1 Aug 2020 04:55:49 +0200 Subject: [PATCH 45/67] replace deprecated sp.matrix --- control/tests/matlab_test.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/control/tests/matlab_test.py b/control/tests/matlab_test.py index f8b481248..7d81288e4 100644 --- a/control/tests/matlab_test.py +++ b/control/tests/matlab_test.py @@ -652,7 +652,7 @@ def testCombi01(self): # start with the basic satellite model sat1, and get the # payload attitude response - Hp = tf(sp.matrix([0, 0, 0, 1])*sat1) + Hp = tf(np.array([0, 0, 0, 1])*sat1) # total open loop Hol = Hc*Hno*Hp From 920649b393dc739f6a9dd3302946bf26e279f4bd Mon Sep 17 00:00:00 2001 From: bnavigator Date: Tue, 18 Aug 2020 13:08:35 +0200 Subject: [PATCH 46/67] no log(0) in automatic timevector calculation --- control/timeresp.py | 83 ++++++++++++++++++++++----------------------- 1 file changed, 41 insertions(+), 42 deletions(-) diff --git a/control/timeresp.py b/control/timeresp.py index b472cb2fd..fa4ced2bd 100644 --- a/control/timeresp.py +++ b/control/timeresp.py @@ -61,7 +61,7 @@ Initial Author: Eike Welk Date: 12 May 2011 -Modified: Sawyer B. Fuller (minster@uw.edu) to add discrete-time +Modified: Sawyer B. Fuller (minster@uw.edu) to add discrete-time capability and better automatic time vector creation Date: June 2020 @@ -463,14 +463,14 @@ def step_response(sys, T=None, X0=0., input=None, output=None, T_num=None, LTI system to simulate T: array-like or number, optional - Time vector, or simulation time duration if a number. If T is not - provided, an attempt is made to create it automatically from the - dynamics of sys. If sys is continuous-time, the time increment dt - is chosen small enough to show the fastest mode, and the simulation - time period tfinal long enough to show the slowest mode, excluding + Time vector, or simulation time duration if a number. If T is not + provided, an attempt is made to create it automatically from the + dynamics of sys. If sys is continuous-time, the time increment dt + is chosen small enough to show the fastest mode, and the simulation + time period tfinal long enough to show the slowest mode, excluding poles at the origin. If this results in too many time steps (>5000), - dt is reduced. If sys is discrete-time, only tfinal is computed, and - tfinal is reduced if it requires too many simulation steps. + dt is reduced. If sys is discrete-time, only tfinal is computed, and + tfinal is reduced if it requires too many simulation steps. X0: array-like or number, optional Initial condition (default = 0) @@ -483,10 +483,10 @@ def step_response(sys, T=None, X0=0., input=None, output=None, T_num=None, output: int Index of the output that will be used in this simulation. Set to None to not trim outputs - + T_num: number, optional - Number of time steps to use in simulation if T is not provided as an - array (autocomputed if not given); ignored if sys is discrete-time. + Number of time steps to use in simulation if T is not provided as an + array (autocomputed if not given); ignored if sys is discrete-time. transpose: bool If True, transpose all input and output arrays (for backward @@ -550,12 +550,12 @@ def step_info(sys, T=None, T_num=None, SettlingTimeThreshold=0.02, LTI system to simulate T: array-like or number, optional - Time vector, or simulation time duration if a number (time vector is + Time vector, or simulation time duration if a number (time vector is autocomputed if not given, see :func:`step_response` for more detail) T_num: number, optional - Number of time steps to use in simulation if T is not provided as an - array (autocomputed if not given); ignored if sys is discrete-time. + Number of time steps to use in simulation if T is not provided as an + array (autocomputed if not given); ignored if sys is discrete-time. SettlingTimeThreshold: float value, optional Defines the error to compute settling time (default = 0.02) @@ -588,7 +588,7 @@ def step_info(sys, T=None, T_num=None, SettlingTimeThreshold=0.02, sys = _get_ss_simo(sys) if T is None or np.asarray(T).size == 1: T = _default_time_vector(sys, N=T_num, tfinal=T) - + T, yout = step_response(sys, T) # Steady state value @@ -640,7 +640,7 @@ def initial_response(sys, T=None, X0=0., input=0, output=None, T_num=None, LTI system to simulate T: array-like or number, optional - Time vector, or simulation time duration if a number (time vector is + Time vector, or simulation time duration if a number (time vector is autocomputed if not given; see :func:`step_response` for more detail) X0: array-like or number, optional @@ -655,10 +655,10 @@ def initial_response(sys, T=None, X0=0., input=0, output=None, T_num=None, output: int Index of the output that will be used in this simulation. Set to None to not trim outputs - + T_num: number, optional - Number of time steps to use in simulation if T is not provided as an - array (autocomputed if not given); ignored if sys is discrete-time. + Number of time steps to use in simulation if T is not provided as an + array (autocomputed if not given); ignored if sys is discrete-time. transpose: bool If True, transpose all input and output arrays (for backward @@ -730,7 +730,7 @@ def impulse_response(sys, T=None, X0=0., input=0, output=None, T_num=None, LTI system to simulate T: array-like or number, optional - Time vector, or simulation time duration if a number (time vector is + Time vector, or simulation time duration if a number (time vector is autocomputed if not given; see :func:`step_response` for more detail) X0: array-like or number, optional @@ -746,8 +746,8 @@ def impulse_response(sys, T=None, X0=0., input=0, output=None, T_num=None, to not trim outputs T_num: number, optional - Number of time steps to use in simulation if T is not provided as an - array (autocomputed if not given); ignored if sys is discrete-time. + Number of time steps to use in simulation if T is not provided as an + array (autocomputed if not given); ignored if sys is discrete-time. transpose: bool If True, transpose all input and output arrays (for backward @@ -830,56 +830,55 @@ def _ideal_tfinal_and_dt(sys): constant = 7.0 tolerance = 1e-10 A = ssdata(sys)[0] - if A.shape == (0,0): + if A.shape == (0,0): # no dynamics - tfinal = constant * 1.0 + tfinal = constant * 1.0 dt = sys.dt if isdtime(sys, strict=True) else 1.0 else: poles = sp.linalg.eigvals(A) - if isdtime(sys, strict=True): - poles = np.log(poles)/sys.dt # z-poles to s-plane using s=(lnz)/dt - # calculate ideal dt if isdtime(sys, strict=True): + # z-poles to s-plane using s=(lnz)/dt, no ln(0) + poles = np.log(poles[abs(poles) > 0])/sys.dt dt = sys.dt else: fastest_natural_frequency = max(abs(poles)) dt = 1/constant / fastest_natural_frequency - + # calculate ideal tfinal poles = poles[abs(poles.real) > tolerance] # ignore poles near im axis - if poles.size == 0: + if poles.size == 0: slowest_decay_rate = 1.0 else: slowest_decay_rate = min(abs(poles.real)) - tfinal = constant / slowest_decay_rate + tfinal = constant / slowest_decay_rate return tfinal, dt -# test below: ct with pole at the origin is 7 seconds, ct with pole at .5 is 14 s long, +# test below: ct with pole at the origin is 7 seconds, ct with pole at .5 is 14 s long, def _default_time_vector(sys, N=None, tfinal=None): - """Returns a time vector suitable for observing the response of the - both the slowest poles and fastest resonant modes. if system is + """Returns a time vector suitable for observing the response of the + both the slowest poles and fastest resonant modes. if system is discrete-time, N is ignored """ - + N_max = 5000 N_min_ct = 100 N_min_dt = 7 # more common to see just a few samples in discrete-time - + ideal_tfinal, ideal_dt = _ideal_tfinal_and_dt(sys) - + if isdtime(sys, strict=True): - if tfinal is None: + if tfinal is None: # for discrete time, change from ideal_tfinal if N too large/small N = int(np.clip(ideal_tfinal/sys.dt, N_min_dt, N_max))# [N_min, N_max] tfinal = sys.dt * N - else: + else: N = int(tfinal/sys.dt) - else: - if tfinal is None: + else: + if tfinal is None: # for continuous time, simulate to ideal_tfinal but limit N tfinal = ideal_tfinal - if N is None: + if N is None: N = int(np.clip(tfinal/ideal_dt, N_min_ct, N_max)) # N<-[N_min, N_max] - + return np.linspace(0, tfinal, N, endpoint=False) From f3e503591367f216d265fd0dd9337693923ef72d Mon Sep 17 00:00:00 2001 From: Ben Greiner Date: Tue, 18 Aug 2020 20:49:45 +0200 Subject: [PATCH 47/67] Update doc/index.rst unit test reference Sync doc dir test reference from #436. Same wording as in toplevel README.rst --- doc/index.rst | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/doc/index.rst b/doc/index.rst index 3420789d8..b6c44d387 100644 --- a/doc/index.rst +++ b/doc/index.rst @@ -38,10 +38,16 @@ You can check out the latest version of the source code with the command:: git clone https://github.com/python-control/python-control.git -You can run a set of unit tests to make sure that everything is working -correctly. After installation, run:: +You can run the unit tests with `pytest`_ to make sure that everything is +working correctly. Inside the source directory, run:: - python setup.py test + pytest -v + +or to test the installed package:: + + pytest --pyargs control -v + +.. _pytest: https://docs.pytest.org/ Your contributions are welcome! Simply fork the `GitHub repository `_ and send a `pull request`_. From 08d5e6ce2dfb99aee9d3d51d5689fac24cca7baa Mon Sep 17 00:00:00 2001 From: bnavigator Date: Thu, 20 Aug 2020 02:18:21 +0200 Subject: [PATCH 48/67] replace another deprecated scipy function with numpy --- control/timeresp.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/control/timeresp.py b/control/timeresp.py index fa4ced2bd..b3b8a5f74 100644 --- a/control/timeresp.py +++ b/control/timeresp.py @@ -408,8 +408,8 @@ def forced_response(sys, T=None, U=0., X0=0., transpose=False, xout = xout[::inc, :] # Transpose the output and state vectors to match local convention - xout = sp.transpose(xout) - yout = sp.transpose(yout) + xout = np.transpose(xout) + yout = np.transpose(yout) # Get rid of unneeded dimensions if squeeze: From df0051c2849bc7accf772ee80faeb752b0478002 Mon Sep 17 00:00:00 2001 From: bnavigator Date: Thu, 20 Aug 2020 21:14:48 +0200 Subject: [PATCH 49/67] update mpl_toolkit function --- control/grid.py | 29 +++++++++++++++++++++++++---- 1 file changed, 25 insertions(+), 4 deletions(-) diff --git a/control/grid.py b/control/grid.py index a383dd27c..374b69ead 100644 --- a/control/grid.py +++ b/control/grid.py @@ -19,10 +19,13 @@ def __call__(self, direction, factor, values): class ModifiedExtremeFinderCycle(angle_helper.ExtremeFinderCycle): - '''Changed to allow only left hand-side polar grid''' + '''Changed to allow only left hand-side polar grid + + https://matplotlib.org/_modules/mpl_toolkits/axisartist/angle_helper.html#ExtremeFinderCycle.__call__ + ''' def __call__(self, transform_xy, x1, y1, x2, y2): - x_, y_ = np.linspace(x1, x2, self.nx), np.linspace(y1, y2, self.ny) - x, y = np.meshgrid(x_, y_) + x, y = np.meshgrid( + np.linspace(x1, x2, self.nx), np.linspace(y1, y2, self.ny)) lon, lat = transform_xy(np.ravel(x), np.ravel(y)) with np.errstate(invalid='ignore'): @@ -41,7 +44,25 @@ def __call__(self, transform_xy, x1, y1, x2, y2): lat_min, lat_max = np.nanmin(lat), np.nanmax(lat) lon_min, lon_max, lat_min, lat_max = \ - self._adjust_extremes(lon_min, lon_max, lat_min, lat_max) + self._add_pad(lon_min, lon_max, lat_min, lat_max) + + # check cycle + if self.lon_cycle: + lon_max = min(lon_max, lon_min + self.lon_cycle) + if self.lat_cycle: + lat_max = min(lat_max, lat_min + self.lat_cycle) + + if self.lon_minmax is not None: + min0 = self.lon_minmax[0] + lon_min = max(min0, lon_min) + max0 = self.lon_minmax[1] + lon_max = min(max0, lon_max) + + if self.lat_minmax is not None: + min0 = self.lat_minmax[0] + lat_min = max(min0, lat_min) + max0 = self.lat_minmax[1] + lat_max = min(max0, lat_max) return lon_min, lon_max, lat_min, lat_max From abc0c3c002b485b2a05101a8459628ad9eafe333 Mon Sep 17 00:00:00 2001 From: bnavigator Date: Thu, 20 Aug 2020 21:35:47 +0200 Subject: [PATCH 50/67] fix grid formatter --- control/grid.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/control/grid.py b/control/grid.py index 374b69ead..0d0e8b2ea 100644 --- a/control/grid.py +++ b/control/grid.py @@ -12,7 +12,7 @@ class FormatterDMS(object): '''Transforms angle ticks to damping ratios''' def __call__(self, direction, factor, values): - angles_deg = values/factor + angles_deg = np.asarray(values)/factor damping_ratios = np.cos((180-angles_deg) * np.pi/180) ret = ["%.2f" % val for val in damping_ratios] return ret From bdbd1985bbb07f5877825f956aeb13ab765094f4 Mon Sep 17 00:00:00 2001 From: bnavigator Date: Thu, 20 Aug 2020 23:21:53 +0200 Subject: [PATCH 51/67] fix wrong config read on pzmap --- control/pzmap.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/control/pzmap.py b/control/pzmap.py index fe8e551a0..012fccca3 100644 --- a/control/pzmap.py +++ b/control/pzmap.py @@ -87,8 +87,8 @@ def pzmap(sys, plot=True, grid=False, title='Pole Zero Map', **kwargs): plot = kwargs['Plot'] # Get parameter values - plot = config._get_param('rlocus', 'plot', plot, True) - grid = config._get_param('rlocus', 'grid', grid, False) + plot = config._get_param('pzmap', 'plot', plot, True) + grid = config._get_param('pzmap', 'grid', grid, False) if not isinstance(sys, LTI): raise TypeError('Argument ``sys``: must be a linear system.') From 2ca522083594993c91db98f700ce8c43b86a77fd Mon Sep 17 00:00:00 2001 From: bnavigator Date: Thu, 20 Aug 2020 23:22:15 +0200 Subject: [PATCH 52/67] add pzmap_test --- control/tests/conftest.py | 28 ++++++++++++++- control/tests/pzmap_test.py | 71 +++++++++++++++++++++++++++++++++++++ 2 files changed, 98 insertions(+), 1 deletion(-) create mode 100755 control/tests/pzmap_test.py diff --git a/control/tests/conftest.py b/control/tests/conftest.py index e98bbe1d7..60c3d0de1 100755 --- a/control/tests/conftest.py +++ b/control/tests/conftest.py @@ -1,13 +1,39 @@ # contest.py - pytest local plugins and fixtures -import control import os +import matplotlib as mpl import pytest +import control + @pytest.fixture(scope="session", autouse=True) def use_numpy_ndarray(): """Switch the config to use ndarray instead of matrix""" if os.getenv("PYTHON_CONTROL_STATESPACE_ARRAY") == "1": control.config.defaults['statesp.use_numpy_matrix'] = False + + +@pytest.fixture(scope="function") +def editsdefaults(): + """Make sure any changes to the defaults only last during a test""" + restore = control.config.defaults.copy() + yield + control.config.defaults.update(restore) + + +@pytest.fixture(scope="function") +def mplcleanup(): + """Workaround for python2 + + python 2 does not like to mix the original mpl decorator with pytest + fixtures. So we roll our own. + """ + save = mpl.units.registry.copy() + try: + yield + finally: + mpl.units.registry.clear() + mpl.units.registry.update(save) + mpl.pyplot.close("all") diff --git a/control/tests/pzmap_test.py b/control/tests/pzmap_test.py new file mode 100755 index 000000000..5903999b0 --- /dev/null +++ b/control/tests/pzmap_test.py @@ -0,0 +1,71 @@ +# -*- coding: utf-8 -*- +""" pzmap_test.py - test pzmap() + +Created on Thu Aug 20 20:06:21 2020 + +@author: bnavigator +""" + +import numpy as np +import pytest +from matplotlib import pyplot as plt + +from control import TransferFunction, config, pzmap + + +@pytest.mark.parametrize("kwargs", + [pytest.param(dict(), id="default"), + pytest.param(dict(plot=False), id="plot=False"), + pytest.param(dict(plot=True), id="plot=True"), + pytest.param(dict(grid=True), id="grid=True"), + pytest.param(dict(title="My Title"), id="title")]) +@pytest.mark.parametrize("setdefaults", [False, True], ids=["kw", "config"]) +@pytest.mark.parametrize("dt", [0, 1], ids=["s", "z"]) +def test_pzmap(kwargs, setdefaults, dt, editsdefaults, mplcleanup): + """Test pzmap""" + # T from from pvtol-nested example + T = TransferFunction([-9.0250000e-01, -4.7200750e+01, -8.6812900e+02, + +5.6261850e+03, +2.1258472e+05, +8.4724600e+05, + +1.0192000e+06, +2.3520000e+05], + [9.02500000e-03, 9.92862812e-01, 4.96974094e+01, + 1.35705659e+03, 2.09294163e+04, 1.64898435e+05, + 6.54572220e+05, 1.25274600e+06, 1.02420000e+06, + 2.35200000e+05], + dt) + + Pref = [-23.8877+19.3837j, -23.8877-19.3837j, -23.8349+15.7846j, + -23.8349-15.7846j, -5.2320 +0.4117j, -5.2320 -0.4117j, + -2.2246 +0.0000j, -1.5160 +0.0000j, -0.3627 +0.0000j] + Zref = [-23.8877+19.3837j, -23.8877-19.3837j, +14.3637 +0.0000j, + -14.3637 +0.0000j, -2.2246 +0.0000j, -2.0000 +0.0000j, + -0.3000 +0.0000j] + + pzkwargs = kwargs.copy() + if setdefaults: + for k in ['plot', 'grid']: + if k in pzkwargs: + v = pzkwargs.pop(k) + config.set_defaults('pzmap', **{k: v}) + + P, Z = pzmap(T, **pzkwargs) + + np.testing.assert_allclose(P, Pref, rtol=1e-3) + np.testing.assert_allclose(Z, Zref, rtol=1e-3) + + if kwargs.get('plot', True): + ax = plt.gca() + assert ax.get_title() == kwargs.get('title', 'Pole Zero Map') + if kwargs.get('grid', False): + # TODO: check for correct grid + pass + + +def test_pzmap_warns(): + with pytest.warns(FutureWarning): + pzmap(TransferFunction([1], [1, 2]), Plot=True) + + +def test_pzmap_raises(): + with pytest.raises(TypeError): + # not an LTI system + pzmap(([1], [1,2])) From 5632796bea9d6047b2b5cfdf0df4b54545840905 Mon Sep 17 00:00:00 2001 From: bnavigator Date: Fri, 21 Aug 2020 01:31:11 +0200 Subject: [PATCH 53/67] test for correct grid and no plot. fix pzmap config handling --- control/grid.py | 8 +++----- control/pzmap.py | 2 +- control/tests/pzmap_test.py | 22 ++++++++++++++++++++-- 3 files changed, 24 insertions(+), 8 deletions(-) diff --git a/control/grid.py b/control/grid.py index 0d0e8b2ea..07ca4a59d 100644 --- a/control/grid.py +++ b/control/grid.py @@ -34,11 +34,9 @@ def __call__(self, transform_xy, x1, y1, x2, y2): # Changed from 180 to 360 to be able to span only # 90-270 (left hand side) lon -= 360. * ((lon - lon0) > 360.) - if self.lat_cycle is not None: + if self.lat_cycle is not None: # pragma: no cover lat0 = np.nanmin(lat) - # Changed from 180 to 360 to be able to span only - # 90-270 (left hand side) - lat -= 360. * ((lat - lat0) > 360.) + lat -= 360. * ((lat - lat0) > 180.) lon_min, lon_max = np.nanmin(lon), np.nanmax(lon) lat_min, lat_max = np.nanmin(lat), np.nanmax(lat) @@ -49,7 +47,7 @@ def __call__(self, transform_xy, x1, y1, x2, y2): # check cycle if self.lon_cycle: lon_max = min(lon_max, lon_min + self.lon_cycle) - if self.lat_cycle: + if self.lat_cycle: # pragma: no cover lat_max = min(lat_max, lat_min + self.lat_cycle) if self.lon_minmax is not None: diff --git a/control/pzmap.py b/control/pzmap.py index 012fccca3..a7752e484 100644 --- a/control/pzmap.py +++ b/control/pzmap.py @@ -58,7 +58,7 @@ # TODO: Implement more elegant cross-style axes. See: # http://matplotlib.sourceforge.net/examples/axes_grid/demo_axisline_style.html # http://matplotlib.sourceforge.net/examples/axes_grid/demo_curvelinear_grid.html -def pzmap(sys, plot=True, grid=False, title='Pole Zero Map', **kwargs): +def pzmap(sys, plot=None, grid=None, title='Pole Zero Map', **kwargs): """ Plot a pole/zero map for a linear system. diff --git a/control/tests/pzmap_test.py b/control/tests/pzmap_test.py index 5903999b0..8d41807b8 100755 --- a/control/tests/pzmap_test.py +++ b/control/tests/pzmap_test.py @@ -6,9 +6,11 @@ @author: bnavigator """ +import matplotlib import numpy as np import pytest from matplotlib import pyplot as plt +from mpl_toolkits.axisartist import Axes as mpltAxes from control import TransferFunction, config, pzmap @@ -54,10 +56,26 @@ def test_pzmap(kwargs, setdefaults, dt, editsdefaults, mplcleanup): if kwargs.get('plot', True): ax = plt.gca() + assert ax.get_title() == kwargs.get('title', 'Pole Zero Map') + + # FIXME: This won't work when zgrid and sgrid are unified + children = ax.get_children() + has_zgrid = False + for c in children: + if isinstance(c, matplotlib.text.Annotation): + if r'\pi' in c.get_text(): + has_zgrid = True + has_sgrid = isinstance(ax, mpltAxes) + if kwargs.get('grid', False): - # TODO: check for correct grid - pass + assert dt == has_zgrid + assert dt != has_sgrid + else: + assert not has_zgrid + assert not has_sgrid + else: + assert not plt.get_fignums() def test_pzmap_warns(): From 98ec00ff918fb906fbaacae6fff3d5e092edc3df Mon Sep 17 00:00:00 2001 From: Samuel Laferriere Date: Fri, 16 Oct 2020 22:55:50 -0400 Subject: [PATCH 54/67] Fixed InterconnectedSystems name bugs. (#400) * Made sure interconnectedsystems keeps names of parts. * Fixed signal names for InterconnectedSystems. * Fixed some naming convention problems and added unit tests for naming conventions. * Removed for loops from tests to get better error messages Co-authored-by: Ben Greiner --- control/iosys.py | 204 ++++++++++++++++++++---------------- control/tests/iosys_test.py | 149 +++++++++++++++++++++++--- 2 files changed, 248 insertions(+), 105 deletions(-) diff --git a/control/iosys.py b/control/iosys.py index 52ea07f24..9b5b89bc8 100644 --- a/control/iosys.py +++ b/control/iosys.py @@ -76,7 +76,8 @@ class for a set of subclasses that are used to implement specific Parameter values for the systems. Passed to the evaluation functions for the system as default values, overriding internal defaults. name : string, optional - System name (used for specifying signals) + System name (used for specifying signals). If unspecified, a generic + name is generated with a unique integer id. Attributes ---------- @@ -108,6 +109,14 @@ class for a set of subclasses that are used to implement specific The default is to return the entire system state. """ + + idCounter = 0 + def name_or_default(self, name=None): + if name is None: + name = "sys[{}]".format(InputOutputSystem.idCounter) + InputOutputSystem.idCounter += 1 + return name + def __init__(self, inputs=None, outputs=None, states=None, params={}, dt=None, name=None): """Create an input/output system. @@ -143,7 +152,8 @@ def __init__(self, inputs=None, outputs=None, states=None, params={}, functions for the system as default values, overriding internal defaults. name : string, optional - System name (used for specifying signals) + System name (used for specifying signals). If unspecified, a generic + name is generated with a unique integer id. Returns ------- @@ -152,9 +162,9 @@ def __init__(self, inputs=None, outputs=None, states=None, params={}, """ # Store the input arguments - self.params = params.copy() # default parameters - self.dt = dt # timebase - self.name = name # system name + self.params = params.copy() # default parameters + self.dt = dt # timebase + self.name = self.name_or_default(name) # system name # Parse and store the number of inputs, outputs, and states self.set_inputs(inputs) @@ -204,10 +214,12 @@ def __mul__(sys2, sys1): if dt is False: raise ValueError("System timebases are not compabile") + inplist = [(0,i) for i in range(sys1.ninputs)] + outlist = [(1,i) for i in range(sys2.noutputs)] # Return the series interconnection between the systems - newsys = InterconnectedSystem((sys1, sys2)) + newsys = InterconnectedSystem((sys1, sys2), inplist=inplist, outlist=outlist) - # Set up the connecton map + # Set up the connection map manually newsys.set_connect_map(np.block( [[np.zeros((sys1.ninputs, sys1.noutputs)), np.zeros((sys1.ninputs, sys2.noutputs))], @@ -215,18 +227,6 @@ def __mul__(sys2, sys1): np.zeros((sys2.ninputs, sys2.noutputs))]] )) - # Set up the input map - newsys.set_input_map(np.concatenate( - (np.eye(sys1.ninputs), np.zeros((sys2.ninputs, sys1.ninputs))), - axis=0)) - # TODO: set up input names - - # Set up the output map - newsys.set_output_map(np.concatenate( - (np.zeros((sys2.noutputs, sys1.noutputs)), np.eye(sys2.noutputs)), - axis=1)) - # TODO: set up output names - # Return the newly created system return newsys @@ -271,18 +271,10 @@ def __add__(sys1, sys2): ninputs = sys1.ninputs noutputs = sys1.noutputs + inplist = [[(0,i),(1,i)] for i in range(ninputs)] + outlist = [[(0,i),(1,i)] for i in range(noutputs)] # Create a new system to handle the composition - newsys = InterconnectedSystem((sys1, sys2)) - - # Set up the input map - newsys.set_input_map(np.concatenate( - (np.eye(ninputs), np.eye(ninputs)), axis=0)) - # TODO: set up input names - - # Set up the output map - newsys.set_output_map(np.concatenate( - (np.eye(noutputs), np.eye(noutputs)), axis=1)) - # TODO: set up output names + newsys = InterconnectedSystem((sys1, sys2), inplist=inplist, outlist=outlist) # Return the newly created system return newsys @@ -301,16 +293,10 @@ def __neg__(sys): if sys.ninputs is None or sys.noutputs is None: raise ValueError("Can't determine number of inputs or outputs") + inplist = [(0,i) for i in range(sys.ninputs)] + outlist = [(0,i,-1) for i in range(sys.noutputs)] # Create a new system to hold the negation - newsys = InterconnectedSystem((sys,), dt=sys.dt) - - # Set up the input map (identity) - newsys.set_input_map(np.eye(sys.ninputs)) - # TODO: set up input names - - # Set up the output map (negate the output) - newsys.set_output_map(-np.eye(sys.noutputs)) - # TODO: set up output names + newsys = InterconnectedSystem((sys,), dt=sys.dt, inplist=inplist, outlist=outlist) # Return the newly created system return newsys @@ -482,10 +468,13 @@ def feedback(self, other=1, sign=-1, params={}): if dt is False: raise ValueError("System timebases are not compabile") + inplist = [(0,i) for i in range(self.ninputs)] + outlist = [(0,i) for i in range(self.noutputs)] # Return the series interconnection between the systems - newsys = InterconnectedSystem((self, other), params=params, dt=dt) + newsys = InterconnectedSystem((self, other), inplist=inplist, outlist=outlist, + params=params, dt=dt) - # Set up the connecton map + # Set up the connecton map manually newsys.set_connect_map(np.block( [[np.zeros((self.ninputs, self.noutputs)), sign * np.eye(self.ninputs, other.noutputs)], @@ -493,18 +482,6 @@ def feedback(self, other=1, sign=-1, params={}): np.zeros((other.ninputs, other.noutputs))]] )) - # Set up the input map - newsys.set_input_map(np.concatenate( - (np.eye(self.ninputs), np.zeros((other.ninputs, self.ninputs))), - axis=0)) - # TODO: set up input names - - # Set up the output map - newsys.set_output_map(np.concatenate( - (np.eye(self.noutputs), np.zeros((self.noutputs, other.noutputs))), - axis=1)) - # TODO: set up output names - # Return the newly created system return newsys @@ -564,9 +541,11 @@ def linearize(self, x0, u0, t=0, params={}, eps=1e-6): linsys = StateSpace(A, B, C, D, self.dt, remove_useless=False) return LinearIOSystem(linsys) - def copy(self): + def copy(self, newname=None): """Make a copy of an input/output system.""" - return copy.copy(self) + newsys = copy.copy(self) + newsys.name = self.name_or_default("copy of " + self.name if not newname else newname) + return newsys class LinearIOSystem(InputOutputSystem, StateSpace): @@ -610,7 +589,8 @@ def __init__(self, linsys, inputs=None, outputs=None, states=None, functions for the system as default values, overriding internal defaults. name : string, optional - System name (used for specifying signals) + System name (used for specifying signals). If unspecified, a generic + name is generated with a unique integer id. Returns ------- @@ -728,7 +708,8 @@ def __init__(self, updfcn, outfcn=None, inputs=None, outputs=None, * dt = True Discrete time with unspecified sampling time name : string, optional - System name (used for specifying signals). + System name (used for specifying signals). If unspecified, a generic + name is generated with a unique integer id. Returns ------- @@ -808,10 +789,13 @@ def __init__(self, syslist, connections=[], inplist=[], outlist=[], syslist : array_like of InputOutputSystems The list of input/output systems to be connected - connections : tuple of connection specifications, optional + connections : list of tuple of connection specifications, optional Description of the internal connections between the subsystems. - Each element of the tuple describes an input to one of the - subsystems. The entries are are of the form: + + [connection1, connection2, ...] + + Each connection is a tuple that describes an input to one of the + subsystems. The entries are of the form: (input-spec, output-spec1, output-spec2, ...) @@ -835,10 +819,15 @@ def __init__(self, syslist, connections=[], inplist=[], outlist=[], If omitted, the connection map (matrix) can be specified using the :func:`~control.InterconnectedSystem.set_connect_map` method. - inplist : tuple of input specifications, optional + inplist : List of tuple of input specifications, optional List of specifications for how the inputs for the overall system are mapped to the subsystem inputs. The input specification is - the same as the form defined in the connection specification. + similar to the form defined in the connection specification, except + that connections do not specify an input-spec, since these are + the system inputs. The entries are thus of the form: + + (output-spec1, output-spec2, ...) + Each system input is added to the input for the listed subsystem. If omitted, the input map can be specified using the @@ -847,7 +836,7 @@ def __init__(self, syslist, connections=[], inplist=[], outlist=[], outlist : tuple of output specifications, optional List of specifications for how the outputs for the subsystems are mapped to overall system outputs. The output specification is the - same as the form defined in the connection specification + same as the form defined in the inplist specification (including the optional gain term). Numbered outputs must be chosen from the list of subsystem outputs, but named outputs can also be contained in the list of subsystem inputs. @@ -855,6 +844,23 @@ def __init__(self, syslist, connections=[], inplist=[], outlist=[], If omitted, the output map can be specified using the `set_output_map` method. + inputs : int, list of str or None, optional + Description of the system inputs. This can be given as an integer + count or as a list of strings that name the individual signals. + If an integer count is specified, the names of the signal will be + of the form `s[i]` (where `s` is one of `u`, `y`, or `x`). If + this parameter is not given or given as `None`, the relevant + quantity will be determined when possible based on other + information provided to functions using the system. + + outputs : int, list of str or None, optional + Description of the system outputs. Same format as `inputs`. + + states : int, list of str, or None, optional + Description of the system states. Same format as `inputs`, except + the state names will be of the form '.', + for each subsys in syslist and each state_name of each subsys. + params : dict, optional Parameter values for the systems. Passed to the evaluation functions for the system as default values, overriding internal @@ -871,7 +877,8 @@ def __init__(self, syslist, connections=[], inplist=[], outlist=[], * dt = True Discrete time with unspecified sampling time name : string, optional - System name (used for specifying signals). + System name (used for specifying signals). If unspecified, a generic + name is generated with a unique integer id. """ # Convert input and output names to lists if they aren't already @@ -885,8 +892,9 @@ def __init__(self, syslist, connections=[], inplist=[], outlist=[], nstates = 0; self.state_offset = [] ninputs = 0; self.input_offset = [] noutputs = 0; self.output_offset = [] - system_count = 0 - for sys in syslist: + sysobj_name_dct = {} + sysname_count_dct = {} + for sysidx, sys in enumerate(syslist): # Make sure time bases are consistent # TODO: Use lti._find_timebase() instead? if dt is None and sys.dt is not None: @@ -912,36 +920,44 @@ def __init__(self, syslist, connections=[], inplist=[], outlist=[], ninputs += sys.ninputs noutputs += sys.noutputs - # Store the index to the system for later retrieval - # TODO: look for duplicated system names - self.syslist_index[sys.name] = system_count - system_count += 1 - - # Check for duplicate systems or duplicate names - sysobj_list = [] - sysname_list = [] - for sys in syslist: - if sys in sysobj_list: - warn("Duplicate object found in system list: %s" % str(sys)) - elif sys.name is not None and sys.name in sysname_list: - warn("Duplicate name found in system list: %s" % sys.name) - sysobj_list.append(sys) - sysname_list.append(sys.name) + # Check for duplicate systems or duplicate names + # Duplicates are renamed sysname_1, sysname_2, etc. + if sys in sysobj_name_dct: + sys = sys.copy() + warn("Duplicate object found in system list: %s. Making a copy" % str(sys)) + if sys.name is not None and sys.name in sysname_count_dct: + count = sysname_count_dct[sys.name] + sysname_count_dct[sys.name] += 1 + sysname = sys.name + "_" + str(count) + sysobj_name_dct[sys] = sysname + self.syslist_index[sysname] = sysidx + warn("Duplicate name found in system list. Renamed to {}".format(sysname)) + else: + sysname_count_dct[sys.name] = 1 + sysobj_name_dct[sys] = sys.name + self.syslist_index[sys.name] = sysidx + + if states is None: + states = [] + for sys, sysname in sysobj_name_dct.items(): + states += [sysname + '.' + statename for statename in sys.state_index.keys()] # Create the I/O system super(InterconnectedSystem, self).__init__( inputs=len(inplist), outputs=len(outlist), - states=nstates, params=params, dt=dt) + states=states, params=params, dt=dt, name=name) # If input or output list was specified, update it - nsignals, self.input_index = \ - self._process_signal_list(inputs, prefix='u') - if nsignals is not None and len(inplist) != nsignals: - raise ValueError("Wrong number/type of inputs given.") - nsignals, self.output_index = \ - self._process_signal_list(outputs, prefix='y') - if nsignals is not None and len(outlist) != nsignals: - raise ValueError("Wrong number/type of outputs given.") + if inputs is not None: + nsignals, self.input_index = \ + self._process_signal_list(inputs, prefix='u') + if nsignals is not None and len(inplist) != nsignals: + raise ValueError("Wrong number/type of inputs given.") + if outputs is not None: + nsignals, self.output_index = \ + self._process_signal_list(outputs, prefix='y') + if nsignals is not None and len(outlist) != nsignals: + raise ValueError("Wrong number/type of outputs given.") # Convert the list of interconnections to a connection map (matrix) self.connect_map = np.zeros((ninputs, noutputs)) @@ -960,9 +976,11 @@ def __init__(self, syslist, connections=[], inplist=[], outlist=[], # Convert the output list to a matrix: maps subsystems to system self.output_map = np.zeros((self.noutputs, noutputs + ninputs)) - for index in range(len(outlist)): - ylist_index, gain = self._parse_output_spec(outlist[index]) - self.output_map[index, ylist_index] = gain + for index, outspec in enumerate(outlist): + if isinstance(outspec, (int, str, tuple)): outspec = [outspec] + for spec in outspec: + ylist_index, gain = self._parse_output_spec(spec) + self.output_map[index, ylist_index] = gain # Save the parameters for the system self.params = params.copy() diff --git a/control/tests/iosys_test.py b/control/tests/iosys_test.py index 22f8307d2..20f289d8c 100644 --- a/control/tests/iosys_test.py +++ b/control/tests/iosys_test.py @@ -763,17 +763,19 @@ def test_named_signals(self): ios_mul = sys1 * sys2 ss_series = self.mimo_linsys1 * self.mimo_linsys2 lin_series = ct.linearize(ios_mul, 0, 0) - for M, N in ((ss_series.A, lin_series.A), (ss_series.B, lin_series.B), - (ss_series.C, lin_series.C), (ss_series.D, lin_series.D)): - np.testing.assert_array_almost_equal(M, N) + np.testing.assert_array_almost_equal(ss_series.A, lin_series.A) + np.testing.assert_array_almost_equal(ss_series.B, lin_series.B) + np.testing.assert_array_almost_equal(ss_series.C, lin_series.C) + np.testing.assert_array_almost_equal(ss_series.D, lin_series.D) # Series interconnection (sys1 * sys2) using series ios_series = ct.series(sys2, sys1) ss_series = ct.series(self.mimo_linsys2, self.mimo_linsys1) lin_series = ct.linearize(ios_series, 0, 0) - for M, N in ((ss_series.A, lin_series.A), (ss_series.B, lin_series.B), - (ss_series.C, lin_series.C), (ss_series.D, lin_series.D)): - np.testing.assert_array_almost_equal(M, N) + np.testing.assert_array_almost_equal(ss_series.A, lin_series.A) + np.testing.assert_array_almost_equal(ss_series.B, lin_series.B) + np.testing.assert_array_almost_equal(ss_series.C, lin_series.C) + np.testing.assert_array_almost_equal(ss_series.D, lin_series.D) # Series interconnection (sys1 * sys2) using named + mixed signals ios_connect = ios.InterconnectedSystem( @@ -786,9 +788,10 @@ def test_named_signals(self): outlist=((1, 'y[0]'), 'sys1.y[1]') ) lin_series = ct.linearize(ios_connect, 0, 0) - for M, N in ((ss_series.A, lin_series.A), (ss_series.B, lin_series.B), - (ss_series.C, lin_series.C), (ss_series.D, lin_series.D)): - np.testing.assert_array_almost_equal(M, N) + np.testing.assert_array_almost_equal(ss_series.A, lin_series.A) + np.testing.assert_array_almost_equal(ss_series.B, lin_series.B) + np.testing.assert_array_almost_equal(ss_series.C, lin_series.C) + np.testing.assert_array_almost_equal(ss_series.D, lin_series.D) # Make sure that we can use input signal names as system outputs ios_connect = ios.InterconnectedSystem( @@ -807,6 +810,123 @@ def test_named_signals(self): np.testing.assert_array_almost_equal(ss_feedback.C, lin_feedback.C) np.testing.assert_array_almost_equal(ss_feedback.D, lin_feedback.D) + def test_sys_naming_convention(self): + """Enforce generic system names 'sys[i]' to be present when systems are created + without explicit names.""" + + ct.InputOutputSystem.idCounter = 0 + sys = ct.LinearIOSystem(self.mimo_linsys1) + self.assertEquals(sys.name, "sys[0]") + self.assertEquals(sys.copy().name, "copy of sys[0]") + + namedsys = ios.NonlinearIOSystem( + updfcn = lambda t, x, u, params: x, + outfcn = lambda t, x, u, params: u, + inputs = ('u[0]', 'u[1]'), + outputs = ('y[0]', 'y[1]'), + states = self.mimo_linsys1.states, + name = 'namedsys') + unnamedsys1 = ct.NonlinearIOSystem( + lambda t,x,u,params: x, inputs=2, outputs=2, states=2 + ) + unnamedsys2 = ct.NonlinearIOSystem( + None, lambda t,x,u,params: u, inputs=2, outputs=2 + ) + self.assertEquals(unnamedsys2.name, "sys[2]") + + # Unnamed/unnamed connections + uu_series = unnamedsys1 * unnamedsys2 + uu_parallel = unnamedsys1 + unnamedsys2 + u_neg = - unnamedsys1 + uu_feedback = unnamedsys2.feedback(unnamedsys1) + uu_dup = unnamedsys1 * unnamedsys1.copy() + uu_hierarchical = uu_series*unnamedsys1 + + self.assertEquals(uu_series.name, "sys[3]") + self.assertEquals(uu_parallel.name, "sys[4]") + self.assertEquals(u_neg.name, "sys[5]") + self.assertEquals(uu_feedback.name, "sys[6]") + self.assertEquals(uu_dup.name, "sys[7]") + self.assertEquals(uu_hierarchical.name, "sys[8]") + + # Unnamed/named connections + un_series = unnamedsys1 * namedsys + un_parallel = unnamedsys1 + namedsys + un_feedback = unnamedsys2.feedback(namedsys) + un_dup = unnamedsys1 * namedsys.copy() + un_hierarchical = uu_series*unnamedsys1 + + self.assertEquals(un_series.name, "sys[9]") + self.assertEquals(un_parallel.name, "sys[10]") + self.assertEquals(un_feedback.name, "sys[11]") + self.assertEquals(un_dup.name, "sys[12]") + self.assertEquals(un_hierarchical.name, "sys[13]") + + # Same system conflict + with warnings.catch_warnings(record=True) as warnval: + unnamedsys1 * unnamedsys1 + self.assertEqual(len(warnval), 1) + + def test_signals_naming_convention(self): + """Enforce generic names to be present when systems are created + without explicit signal names: + input: 'u[i]' + state: 'x[i]' + output: 'y[i]' + """ + ct.InputOutputSystem.idCounter = 0 + sys = ct.LinearIOSystem(self.mimo_linsys1) + for statename in ["x[0]", "x[1]"]: + self.assertTrue(statename in sys.state_index) + for inputname in ["u[0]", "u[1]"]: + self.assertTrue(inputname in sys.input_index) + for outputname in ["y[0]", "y[1]"]: + self.assertTrue(outputname in sys.output_index) + self.assertEqual(len(sys.state_index), sys.nstates) + self.assertEqual(len(sys.input_index), sys.ninputs) + self.assertEqual(len(sys.output_index), sys.noutputs) + + namedsys = ios.NonlinearIOSystem( + updfcn = lambda t, x, u, params: x, + outfcn = lambda t, x, u, params: u, + inputs = ('u0'), + outputs = ('y0'), + states = ('x0'), + name = 'namedsys') + unnamedsys = ct.NonlinearIOSystem( + lambda t,x,u,params: x, inputs=1, outputs=1, states=1 + ) + self.assertTrue('u0' in namedsys.input_index) + self.assertTrue('y0' in namedsys.output_index) + self.assertTrue('x0' in namedsys.state_index) + + # Unnamed/named connections + un_series = unnamedsys * namedsys + un_parallel = unnamedsys + namedsys + un_feedback = unnamedsys.feedback(namedsys) + un_dup = unnamedsys * namedsys.copy() + un_hierarchical = un_series*unnamedsys + u_neg = - unnamedsys + + self.assertTrue("sys[1].x[0]" in un_series.state_index) + self.assertTrue("namedsys.x0" in un_series.state_index) + self.assertTrue("sys[1].x[0]" in un_parallel.state_index) + self.assertTrue("namedsys.x0" in un_series.state_index) + self.assertTrue("sys[1].x[0]" in un_feedback.state_index) + self.assertTrue("namedsys.x0" in un_feedback.state_index) + self.assertTrue("sys[1].x[0]" in un_dup.state_index) + self.assertTrue("copy of namedsys.x0" in un_dup.state_index) + self.assertTrue("sys[1].x[0]" in un_hierarchical.state_index) + self.assertTrue("sys[2].sys[1].x[0]" in un_hierarchical.state_index) + self.assertTrue("sys[1].x[0]" in u_neg.state_index) + + # Same system conflict + with warnings.catch_warnings(record=True) as warnval: + same_name_series = unnamedsys * unnamedsys + self.assertEquals(len(warnval), 1) + self.assertTrue("sys[1].x[0]" in same_name_series.state_index) + self.assertTrue("copy of sys[1].x[0]" in same_name_series.state_index) + def test_named_signals_linearize_inconsistent(self): """Mare sure that providing inputs or outputs not consistent with updfcn or outfcn fail @@ -904,8 +1024,9 @@ def test_lineariosys_statespace(self): np.testing.assert_array_equal(io_feedback.D, ss_feedback.D) def test_duplicates(self): - nlios = ios.NonlinearIOSystem(None, \ - lambda t, x, u, params: u*u, inputs=1, outputs=1) + nlios = ios.NonlinearIOSystem(lambda t,x,u,params: x, \ + lambda t, x, u, params: u*u, \ + inputs=1, outputs=1, states=1, name="sys") # Turn off deprecation warnings warnings.simplefilter("ignore", category=DeprecationWarning) @@ -926,7 +1047,11 @@ def test_duplicates(self): nlios2 = nlios.copy() with warnings.catch_warnings(record=True) as warnval: ios_series = nlios1 * nlios2 - self.assertEqual(len(warnval), 0) + self.assertEquals(len(warnval), 1) + # when subsystems have the same name, duplicates are + # renamed + self.assertTrue("copy of sys_1.x[0]" in ios_series.state_index.keys()) + self.assertTrue("copy of sys.x[0]" in ios_series.state_index.keys()) # Duplicate names iosys_siso = ct.LinearIOSystem(self.siso_linsys) From 7a62428c5703594b0f53c01fe8f6111bca043168 Mon Sep 17 00:00:00 2001 From: sawyerbfuller <58706249+sawyerbfuller@users.noreply.github.com> Date: Fri, 16 Oct 2020 23:11:59 -0700 Subject: [PATCH 55/67] quick and dirty parser for version number in legacy-defaults (#435) * quick and dirty parser for version number in legacy-defaults * refinement to accomodate multi-digit version numbers --- control/config.py | 14 +++++++++++--- control/tests/config_test.py | 6 ++++++ 2 files changed, 17 insertions(+), 3 deletions(-) diff --git a/control/config.py b/control/config.py index 27a5712a3..c06d38b6e 100644 --- a/control/config.py +++ b/control/config.py @@ -166,9 +166,17 @@ def use_legacy_defaults(version): Parameters ---------- version : string - version number of the defaults desired. Currently only supports `0.8.3`. + version number of the defaults desired. ranges from '0.1' to '0.8.4'. """ - if version == '0.8.3': + numbers_list = version.split(".") + first_digit = int(numbers_list[0]) + second_digit = int(numbers_list[1].strip('abcdef')) # remove trailing letters + if second_digit < 8: + # TODO: anything for 0.7 and below if needed + pass + elif second_digit == 8: + if len(version) > 4: + third_digit = int(version[4]) use_numpy_matrix(True) # alternatively: set_defaults('statesp', use_numpy_matrix=True) else: - raise ValueError('''version number not recognized. Possible values are: ['0.8.3']''') \ No newline at end of file + raise ValueError('''version number not recognized. Possible values range from '0.1' to '0.8.4'.''') \ No newline at end of file diff --git a/control/tests/config_test.py b/control/tests/config_test.py index 2fdae22e4..667a7e3c4 100644 --- a/control/tests/config_test.py +++ b/control/tests/config_test.py @@ -216,6 +216,12 @@ def test_legacy_defaults(self): assert(isinstance(ct.ss(0,0,0,1).D, np.matrix)) ct.reset_defaults() assert(isinstance(ct.ss(0,0,0,1).D, np.ndarray)) + # test that old versions don't raise a problem + ct.use_legacy_defaults('0.6c') + ct.use_legacy_defaults('0.8.2') + ct.use_legacy_defaults('0.1') + ct.config.reset_defaults() + def test_change_default_dt(self): ct.set_defaults('statesp', default_dt=0) From 2d7aad0d98eda40f416a42ee96b638a6b409bc99 Mon Sep 17 00:00:00 2001 From: sawyerbfuller <58706249+sawyerbfuller@users.noreply.github.com> Date: Sat, 17 Oct 2020 07:25:30 -0700 Subject: [PATCH 56/67] improved default time vector for time response functions that takes zeros into account. (#454) * add default time for step code from Ilhan Polat (@ilayn) * beginnings of code starts with a docstring * removed unicode in code to make python 2 happy Co-authored-by: Ben Greiner Co-authored-by: Naman Gera --- control/statesp.py | 4 + control/tests/sisotool_test.py | 14 +- control/tests/timeresp_test.py | 65 +++++--- control/timeresp.py | 294 ++++++++++++++++++++++++--------- control/xferfcn.py | 12 +- 5 files changed, 281 insertions(+), 108 deletions(-) diff --git a/control/statesp.py b/control/statesp.py index ca68fc22b..dd0ea6f5e 100644 --- a/control/statesp.py +++ b/control/statesp.py @@ -944,6 +944,10 @@ def dcgain(self): gain = np.tile(np.nan, (self.outputs, self.inputs)) return np.squeeze(gain) + def is_static_gain(self): + """True if and only if the system has no dynamics, that is, + if A and B are zero. """ + return not np.any(self.A) and not np.any(self.B) # TODO: add discrete time check def _convertToStateSpace(sys, **kw): diff --git a/control/tests/sisotool_test.py b/control/tests/sisotool_test.py index f93de54f8..5b627c22d 100644 --- a/control/tests/sisotool_test.py +++ b/control/tests/sisotool_test.py @@ -32,9 +32,12 @@ def test_sisotool(self): initial_point_2, 4) # Check the step response before moving the point + # new array needed because change in compute step response default time step_response_original = np.array( - [0., 0.0217, 0.1281, 0.3237, 0.5797, 0.8566, 1.116, - 1.3261, 1.4659, 1.526]) + [0. , 0.0069, 0.0448, 0.124 , 0.2427, 0.3933, 0.5653, 0.7473, + 0.928 , 1.0969]) + #old: np.array([0., 0.0217, 0.1281, 0.3237, 0.5797, 0.8566, 1.116, + # 1.3261, 1.4659, 1.526]) assert_array_almost_equal( ax_step.lines[0].get_data()[1][:10], step_response_original, 4) @@ -77,9 +80,12 @@ def test_sisotool(self): bode_mag_moved, 4) # Check if the step response has changed + # new array needed because change in compute step response default time step_response_moved = np.array( - [0., 0.0239, 0.161 , 0.4547, 0.8903, 1.407, - 1.9121, 2.2989, 2.4686, 2.353]) + [0. , 0.0072, 0.0516, 0.1554, 0.3281, 0.5681, 0.8646, 1.1987, + 1.5452, 1.875 ]) + #old: array([0., 0.0239, 0.161 , 0.4547, 0.8903, 1.407, + # 1.9121, 2.2989, 2.4686, 2.353]) assert_array_almost_equal( ax_step.lines[0].get_data()[1][:10], step_response_moved, 4) diff --git a/control/tests/timeresp_test.py b/control/tests/timeresp_test.py index 5549b2a88..b33dd5969 100644 --- a/control/tests/timeresp_test.py +++ b/control/tests/timeresp_test.py @@ -29,6 +29,12 @@ def setUp(self): # Create some transfer functions self.siso_tf1 = TransferFunction([1], [1, 2, 1]) self.siso_tf2 = _convert_to_transfer_function(self.siso_ss1) + + # tests for pole cancellation + self.pole_cancellation = TransferFunction([1.067e+05, 5.791e+04], + [10.67, 1.067e+05, 5.791e+04]) + self.no_pole_cancellation = TransferFunction([1.881e+06], + [188.1, 1.881e+06]) # Create MIMO system, contains ``siso_ss1`` twice A = np.matrix("1. -2. 0. 0.;" @@ -167,6 +173,14 @@ def test_step_info(self): 2.50, rtol=rtol) + # confirm that pole-zero cancellation doesn't perturb results + # https://github.com/python-control/python-control/issues/440 + step_info_no_cancellation = step_info(self.no_pole_cancellation) + step_info_cancellation = step_info(self.pole_cancellation) + for key in step_info_no_cancellation: + np.testing.assert_allclose(step_info_no_cancellation[key], + step_info_cancellation[key], rtol=1e-4) + def test_impulse_response(self): # Test SISO system sys = self.siso_ss1 @@ -348,33 +362,41 @@ def test_step_robustness(self): sys2 = TransferFunction(num, den2) # Compute step response from input 1 to output 1, 2 - t1, y1 = step_response(sys1, input=0, T_num=100) - t2, y2 = step_response(sys2, input=0, T_num=100) + t1, y1 = step_response(sys1, input=0, T=2, T_num=100) + t2, y2 = step_response(sys2, input=0, T=2, T_num=100) np.testing.assert_array_almost_equal(y1, y2) def test_auto_generated_time_vector(self): - # confirm a TF with a pole at p simulates for 7.0/p seconds + # confirm a TF with a pole at p simulates for ratio/p seconds p = 0.5 + ratio = 9.21034*p # taken from code + ratio2 = 25*p np.testing.assert_array_almost_equal( _ideal_tfinal_and_dt(TransferFunction(1, [1, .5]))[0], - (7/p)) + (ratio/p)) np.testing.assert_array_almost_equal( _ideal_tfinal_and_dt(TransferFunction(1, [1, .5]).sample(.1))[0], - (7/p)) - # confirm a TF with poles at 0 and p simulates for 7.0/p seconds + (ratio2/p)) + # confirm a TF with poles at 0 and p simulates for ratio/p seconds np.testing.assert_array_almost_equal( _ideal_tfinal_and_dt(TransferFunction(1, [1, .5, 0]))[0], - (7/p)) + (ratio2/p)) + # confirm a TF with a natural frequency of wn rad/s gets a - # dt of 1/(7.0*wn) + # dt of 1/(ratio*wn) wn = 10 + ratio_dt = 1/(0.025133 * ratio * wn) np.testing.assert_array_almost_equal( _ideal_tfinal_and_dt(TransferFunction(1, [1, 0, wn**2]))[1], - 1/(7.0*wn)) + 1/(ratio_dt*ratio*wn)) + wn = 100 + np.testing.assert_array_almost_equal( + _ideal_tfinal_and_dt(TransferFunction(1, [1, 0, wn**2]))[1], + 1/(ratio_dt*ratio*wn)) zeta = .1 np.testing.assert_array_almost_equal( _ideal_tfinal_and_dt(TransferFunction(1, [1, 2*zeta*wn, wn**2]))[1], - 1/(7.0*wn)) + 1/(ratio_dt*ratio*wn)) # but a smapled one keeps its dt np.testing.assert_array_almost_equal( _ideal_tfinal_and_dt(TransferFunction(1, [1, 2*zeta*wn, wn**2]).sample(.1))[1], @@ -384,37 +406,32 @@ def test_auto_generated_time_vector(self): .1) np.testing.assert_array_almost_equal( _ideal_tfinal_and_dt(TransferFunction(1, [1, 2*zeta*wn, wn**2]))[1], - 1/(7.0*wn)) + 1/(ratio_dt*ratio*wn)) + + # TF with fast oscillations simulates only 5000 time steps even with long tfinal self.assertEqual(5000, len(_default_time_vector(TransferFunction(1, [1, 0, wn**2]),tfinal=100))) - # and simulates for 7.0/dt time steps - self.assertEqual( - len(_default_time_vector(TransferFunction(1, [1, 0, wn**2]))), - int(7.0/(1/(7.0*wn)))) sys = TransferFunction(1, [1, .5, 0]) sysdt = TransferFunction(1, [1, .5, 0], .1) # test impose number of time steps self.assertEqual(10, len(step_response(sys, T_num=10)[0])) - self.assertEqual(10, len(step_response(sysdt, T_num=10)[0])) + # test that discrete ignores T_num + self.assertNotEqual(15, len(step_response(sysdt, T_num=15)[0])) # test impose final time np.testing.assert_array_almost_equal( 100, - step_response(sys, 100)[0][-1], - decimal=.5) + np.ceil(step_response(sys, 100)[0][-1])) np.testing.assert_array_almost_equal( 100, - step_response(sysdt, 100)[0][-1], - decimal=.5) + np.ceil(step_response(sysdt, 100)[0][-1])) np.testing.assert_array_almost_equal( 100, - impulse_response(sys, 100)[0][-1], - decimal=.5) + np.ceil(impulse_response(sys, 100)[0][-1])) np.testing.assert_array_almost_equal( 100, - initial_response(sys, 100)[0][-1], - decimal=.5) + np.ceil(initial_response(sys, 100)[0][-1])) def test_time_vector(self): diff --git a/control/timeresp.py b/control/timeresp.py index b3b8a5f74..8b0010c1c 100644 --- a/control/timeresp.py +++ b/control/timeresp.py @@ -65,12 +65,18 @@ capability and better automatic time vector creation Date: June 2020 +Modified by Ilhan Polat to improve automatic time vector creation +Date: August 17, 2020 + $Id$ """ # Libraries that we make use of import scipy as sp # SciPy library (used all over) import numpy as np # NumPy library +from scipy.linalg import eig, eigvals, matrix_balance, norm +from numpy import (einsum, maximum, minimum, + atleast_1d) import warnings from .lti import LTI # base class of StateSpace, TransferFunction from .statesp import _convertToStateSpace, _mimo2simo, _mimo2siso, ssdata @@ -84,7 +90,7 @@ def _check_convert_array(in_obj, legal_shapes, err_msg_start, squeeze=False, transpose=False): """ - Helper function for checking array-like parameters. + Helper function for checking array_like parameters. * Check type and shape of ``in_obj``. * Convert ``in_obj`` to an array if necessary. @@ -201,20 +207,20 @@ def forced_response(sys, T=None, U=0., X0=0., transpose=False, Parameters ---------- - sys: LTI (StateSpace, or TransferFunction) + sys: LTI (StateSpace or TransferFunction) LTI system to simulate - T: array-like, optional for discrete LTI `sys` + T: array_like, optional for discrete LTI `sys` Time steps at which the input is defined; values must be evenly spaced. - U: array-like or number, optional + U: array_like or float, optional Input array giving input at each time `T` (default = 0). If `U` is ``None`` or ``0``, a special algorithm is used. This special algorithm is faster than the general algorithm, which is used otherwise. - X0: array-like or number, optional + X0: array_like or float, optional Initial condition (default = 0). transpose: bool, optional (default=False) @@ -459,20 +465,21 @@ def step_response(sys, T=None, X0=0., input=None, output=None, T_num=None, Parameters ---------- - sys: StateSpace, or TransferFunction + sys: StateSpace or TransferFunction LTI system to simulate - T: array-like or number, optional + T: array_like or float, optional Time vector, or simulation time duration if a number. If T is not provided, an attempt is made to create it automatically from the dynamics of sys. If sys is continuous-time, the time increment dt is chosen small enough to show the fastest mode, and the simulation time period tfinal long enough to show the slowest mode, excluding - poles at the origin. If this results in too many time steps (>5000), - dt is reduced. If sys is discrete-time, only tfinal is computed, and - tfinal is reduced if it requires too many simulation steps. + poles at the origin and pole-zero cancellations. If this results in + too many time steps (>5000), dt is reduced. If sys is discrete-time, + only tfinal is computed, and final is reduced if it requires too + many simulation steps. - X0: array-like or number, optional + X0: array_like or float, optional Initial condition (default = 0) Numbers are converted to constant arrays with the correct shape. @@ -484,7 +491,7 @@ def step_response(sys, T=None, X0=0., input=None, output=None, T_num=None, Index of the output that will be used in this simulation. Set to None to not trim outputs - T_num: number, optional + T_num: int, optional Number of time steps to use in simulation if T is not provided as an array (autocomputed if not given); ignored if sys is discrete-time. @@ -527,7 +534,7 @@ def step_response(sys, T=None, X0=0., input=None, output=None, T_num=None, """ sys = _get_ss_simo(sys, input, output) if T is None or np.asarray(T).size == 1: - T = _default_time_vector(sys, N=T_num, tfinal=T) + T = _default_time_vector(sys, N=T_num, tfinal=T, is_step=True) U = np.ones_like(T) T, yout, xout = forced_response(sys, T, U, X0, transpose=transpose, @@ -546,21 +553,21 @@ def step_info(sys, T=None, T_num=None, SettlingTimeThreshold=0.02, Parameters ---------- - sys: StateSpace, or TransferFunction + sys : StateSpace or TransferFunction LTI system to simulate - T: array-like or number, optional + T : array_like or float, optional Time vector, or simulation time duration if a number (time vector is autocomputed if not given, see :func:`step_response` for more detail) - T_num: number, optional + T_num : int, optional Number of time steps to use in simulation if T is not provided as an array (autocomputed if not given); ignored if sys is discrete-time. - SettlingTimeThreshold: float value, optional + SettlingTimeThreshold : float value, optional Defines the error to compute settling time (default = 0.02) - RiseTimeLimits: tuple (lower_threshold, upper_theshold) + RiseTimeLimits : tuple (lower_threshold, upper_theshold) Defines the lower and upper threshold for RiseTime computation Returns @@ -587,7 +594,7 @@ def step_info(sys, T=None, T_num=None, SettlingTimeThreshold=0.02, ''' sys = _get_ss_simo(sys) if T is None or np.asarray(T).size == 1: - T = _default_time_vector(sys, N=T_num, tfinal=T) + T = _default_time_vector(sys, N=T_num, tfinal=T, is_step=True) T, yout = step_response(sys, T) @@ -636,49 +643,49 @@ def initial_response(sys, T=None, X0=0., input=0, output=None, T_num=None, Parameters ---------- - sys: StateSpace, or TransferFunction + sys : StateSpace or TransferFunction LTI system to simulate - T: array-like or number, optional + T : array_like or float, optional Time vector, or simulation time duration if a number (time vector is autocomputed if not given; see :func:`step_response` for more detail) - X0: array-like or number, optional + X0 : array_like or float, optional Initial condition (default = 0) Numbers are converted to constant arrays with the correct shape. - input: int + input : int Ignored, has no meaning in initial condition calculation. Parameter ensures compatibility with step_response and impulse_response - output: int + output : int Index of the output that will be used in this simulation. Set to None to not trim outputs - T_num: number, optional + T_num : int, optional Number of time steps to use in simulation if T is not provided as an array (autocomputed if not given); ignored if sys is discrete-time. - transpose: bool + transpose : bool If True, transpose all input and output arrays (for backward compatibility with MATLAB and :func:`scipy.signal.lsim`) - return_x: bool + return_x : bool If True, return the state vector (default = False). - squeeze: bool, optional (default=True) + squeeze : bool, optional (default=True) If True, remove single-dimensional entries from the shape of the output. For single output systems, this converts the output response to a 1D array. Returns ------- - T: array + T : array Time values of the output - yout: array + yout : array Response of the system - xout: array + xout : array Individual response of each x variable See Also @@ -699,7 +706,7 @@ def initial_response(sys, T=None, X0=0., input=0, output=None, T_num=None, # Create time and input vectors; checking is done in forced_response(...) # The initial vector X0 is created in forced_response(...) if necessary if T is None or np.asarray(T).size == 1: - T = _default_time_vector(sys, N=T_num, tfinal=T) + T = _default_time_vector(sys, N=T_num, tfinal=T, is_step=False) U = np.zeros_like(T) T, yout, _xout = forced_response(sys, T, U, X0, transpose=transpose, @@ -726,48 +733,48 @@ def impulse_response(sys, T=None, X0=0., input=0, output=None, T_num=None, Parameters ---------- - sys: StateSpace, TransferFunction + sys : StateSpace, TransferFunction LTI system to simulate - T: array-like or number, optional - Time vector, or simulation time duration if a number (time vector is + T : array_like or float, optional + Time vector, or simulation time duration if a scalar (time vector is autocomputed if not given; see :func:`step_response` for more detail) - X0: array-like or number, optional + X0 : array_like or float, optional Initial condition (default = 0) Numbers are converted to constant arrays with the correct shape. - input: int + input : int Index of the input that will be used in this simulation. - output: int + output : int Index of the output that will be used in this simulation. Set to None to not trim outputs - T_num: number, optional + T_num : int, optional Number of time steps to use in simulation if T is not provided as an array (autocomputed if not given); ignored if sys is discrete-time. - transpose: bool + transpose : bool If True, transpose all input and output arrays (for backward compatibility with MATLAB and :func:`scipy.signal.lsim`) - return_x: bool + return_x : bool If True, return the state vector (default = False). - squeeze: bool, optional (default=True) + squeeze : bool, optional (default=True) If True, remove single-dimensional entries from the shape of the output. For single output systems, this converts the output response to a 1D array. Returns ------- - T: array + T : array Time values of the output - yout: array + yout : array Response of the system - xout: array + xout : array Individual response of each x variable See Also @@ -803,7 +810,7 @@ def impulse_response(sys, T=None, X0=0., input=0, output=None, T_num=None, # Compute T and U, no checks necessary, will be checked in forced_response if T is None or np.asarray(T).size == 1: - T = _default_time_vector(sys, N=T_num, tfinal=T) + T = _default_time_vector(sys, N=T_num, tfinal=T, is_step=False) U = np.zeros_like(T) # Compute new X0 that contains the impulse @@ -826,54 +833,183 @@ def impulse_response(sys, T=None, X0=0., input=0, output=None, T_num=None, return T, yout # utility function to find time period and time increment using pole locations -def _ideal_tfinal_and_dt(sys): - constant = 7.0 - tolerance = 1e-10 - A = ssdata(sys)[0] - if A.shape == (0,0): - # no dynamics - tfinal = constant * 1.0 - dt = sys.dt if isdtime(sys, strict=True) else 1.0 - else: - poles = sp.linalg.eigvals(A) - # calculate ideal dt - if isdtime(sys, strict=True): - # z-poles to s-plane using s=(lnz)/dt, no ln(0) - poles = np.log(poles[abs(poles) > 0])/sys.dt - dt = sys.dt - else: - fastest_natural_frequency = max(abs(poles)) - dt = 1/constant / fastest_natural_frequency +def _ideal_tfinal_and_dt(sys, is_step=True): + """helper function to compute ideal simulation duration tfinal and dt, the + time increment. Usually called by _default_time_vector, whose job it is to + choose a realistic time vector. Considers both poles and zeros. - # calculate ideal tfinal - poles = poles[abs(poles.real) > tolerance] # ignore poles near im axis - if poles.size == 0: - slowest_decay_rate = 1.0 - else: - slowest_decay_rate = min(abs(poles.real)) - tfinal = constant / slowest_decay_rate + For discrete-time models, dt is inherent and only tfinal is computed. + + Parameters + ---------- + sys : StateSpace or TransferFunction + The system whose time response is to be computed + is_step : bool + Scales the dc value by the magnitude of the nonzero mode since + integrating the impulse response gives + :math:`\int e^{-\lambda t} = -e^{-\lambda t}/ \lambda` + Default is True. + + Returns + ------- + tfinal : float + The final time instance for which the simulation will be performed. + dt : float + The estimated sampling period for the simulation. + + Notes + ----- + Just by evaluating the fastest mode for dt and slowest for tfinal often + leads to unnecessary, bloated sampling (e.g., Transfer(1,[1,1001,1000])) + since dt will be very small and tfinal will be too large though the fast + mode hardly ever contributes. Similarly, change the numerator to [1, 2, 0] + and the simulation would be unnecessarily long and the plot is virtually + an L shape since the decay is so fast. + + Instead, a modal decomposition in time domain hence a truncated ZIR and ZSR + can be used such that only the modes that have significant effect on the + time response are taken. But the sensitivity of the eigenvalues complicate + the matter since dlambda = with = 1. Hence we can only work + with simple poles with this formulation. See Golub, Van Loan Section 7.2.2 + for simple eigenvalue sensitivity about the nonunity of . The size of + the response is dependent on the size of the eigenshapes rather than the + eigenvalues themselves. + + By Ilhan Polat, with modifications by Sawyer Fuller to integrate into + python-control 2020.08.17 + """ + + sqrt_eps = np.sqrt(np.spacing(1.)) + default_tfinal = 5 # Default simulation horizon + default_dt = 0.1 + total_cycles = 5 # number of cycles for oscillating modes + pts_per_cycle = 25 # Number of points divide a period of oscillation + log_decay_percent = np.log(100) # Factor of reduction for real pole decays + + if sys.is_static_gain(): + tfinal = default_tfinal + dt = sys.dt if isdtime(sys, strict=True) else default_dt + elif isdtime(sys, strict=True): + dt = sys.dt + A = _convertToStateSpace(sys).A + tfinal = default_tfinal + p = eigvals(A) + # Array Masks + # unstable + m_u = (np.abs(p) >= 1 + sqrt_eps) + p_u, p = p[m_u], p[~m_u] + if p_u.size > 0: + m_u = (p_u.real < 0) & (np.abs(p_u.imag) < sqrt_eps) + t_emp = np.max(log_decay_percent / np.abs(np.log(p_u[~m_u])/dt)) + tfinal = max(tfinal, t_emp) + + # zero - negligible effect on tfinal + m_z = np.abs(p) < sqrt_eps + p = p[~m_z] + # Negative reals- treated as oscillary mode + m_nr = (p.real < 0) & (np.abs(p.imag) < sqrt_eps) + p_nr, p = p[m_nr], p[~m_nr] + if p_nr.size > 0: + t_emp = np.max(log_decay_percent / np.abs((np.log(p_nr)/dt).real)) + tfinal = max(tfinal, t_emp) + # discrete integrators + m_int = (p.real - 1 < sqrt_eps) & (np.abs(p.imag) < sqrt_eps) + p_int, p = p[m_int], p[~m_int] + # pure oscillatory modes + m_w = (np.abs(np.abs(p) - 1) < sqrt_eps) + p_w, p = p[m_w], p[~m_w] + if p_w.size > 0: + t_emp = total_cycles * 2 * np.pi / np.abs(np.log(p_w)/dt).min() + tfinal = max(tfinal, t_emp) + + if p.size > 0: + t_emp = log_decay_percent / np.abs((np.log(p)/dt).real).min() + tfinal = max(tfinal, t_emp) + + if p_int.size > 0: + tfinal = tfinal * 5 + else: # cont time + sys_ss = _convertToStateSpace(sys) + # Improve conditioning via balancing and zeroing tiny entries + # See for [[1,2,0], [9,1,0.01], [1,2,10*np.pi]] before/after balance + b, (sca, perm) = matrix_balance(sys_ss.A, separate=True) + p, l, r = eig(b, left=True, right=True) + # Reciprocal of inner product for each eigval, (bound the ~infs by 1e12) + # G = Transfer([1], [1,0,1]) gives zero sensitivity (bound by 1e-12) + eig_sens = np.reciprocal(maximum(1e-12, einsum('ij,ij->j', l, r).real)) + eig_sens = minimum(1e12, eig_sens) + # Tolerances + p[np.abs(p) < np.spacing(eig_sens * norm(b, 1))] = 0. + # Incorporate balancing to outer factors + l[perm, :] *= np.reciprocal(sca)[:, None] + r[perm, :] *= sca[:, None] + w, v = sys_ss.C.dot(r), l.T.conj().dot(sys_ss.B) + + origin = False + # Computing the "size" of the response of each simple mode + wn = np.abs(p) + if np.any(wn == 0.): + origin = True + + dc = np.zeros_like(p, dtype=float) + # well-conditioned nonzero poles, np.abs just in case + ok = np.abs(eig_sens) <= 1/sqrt_eps + # the averaged t->inf response of each simple eigval on each i/o channel + # See, A = [[-1, k], [0, -2]], response sizes are k-dependent (that is + # R/L eigenvector dependent) + dc[ok] = norm(v[ok, :], axis=1)*norm(w[:, ok], axis=0)*eig_sens[ok] + dc[wn != 0.] /= wn[wn != 0] if is_step else 1. + dc[wn == 0.] = 0. + # double the oscillating mode magnitude for the conjugate + dc[p.imag != 0.] *= 2 + + # Now get rid of noncontributing integrators and simple modes if any + relevance = (dc > 0.1*dc.max()) | ~ok + psub = p[relevance] + wnsub = wn[relevance] + + tfinal, dt = [], [] + ints = wnsub == 0. + iw = (psub.imag != 0.) & (np.abs(psub.real) <= sqrt_eps) + + # Pure imaginary? + if np.any(iw): + tfinal += (total_cycles * 2 * np.pi / wnsub[iw]).tolist() + dt += (2 * np.pi / pts_per_cycle / wnsub[iw]).tolist() + # The rest ~ts = log(%ss value) / exp(Re(eigval)t) + texp_mode = log_decay_percent / np.abs(psub[~iw & ~ints].real) + tfinal += texp_mode.tolist() + dt += minimum(texp_mode / 50, + (2 * np.pi / pts_per_cycle / wnsub[~iw & ~ints])).tolist() + + # All integrators? + if len(tfinal) == 0: + return default_tfinal*5, default_dt*5 + + tfinal = np.max(tfinal)*(5 if origin else 1) + dt = np.min(dt) return tfinal, dt -# test below: ct with pole at the origin is 7 seconds, ct with pole at .5 is 14 s long, -def _default_time_vector(sys, N=None, tfinal=None): - """Returns a time vector suitable for observing the response of the - both the slowest poles and fastest resonant modes. if system is - discrete-time, N is ignored """ +def _default_time_vector(sys, N=None, tfinal=None, is_step=True): + """Returns a time vector that has a reasonable number of points. + if system is discrete-time, N is ignored """ N_max = 5000 - N_min_ct = 100 - N_min_dt = 7 # more common to see just a few samples in discrete-time + N_min_ct = 100 # min points for cont time systems + N_min_dt = 20 # more common to see just a few samples in discrete-time - ideal_tfinal, ideal_dt = _ideal_tfinal_and_dt(sys) + ideal_tfinal, ideal_dt = _ideal_tfinal_and_dt(sys, is_step=is_step) if isdtime(sys, strict=True): + # only need to use default_tfinal if not given; N is ignored. if tfinal is None: # for discrete time, change from ideal_tfinal if N too large/small N = int(np.clip(ideal_tfinal/sys.dt, N_min_dt, N_max))# [N_min, N_max] tfinal = sys.dt * N else: N = int(tfinal/sys.dt) + tfinal = N * sys.dt # make tfinal an integer multiple of sys.dt else: if tfinal is None: # for continuous time, simulate to ideal_tfinal but limit N diff --git a/control/xferfcn.py b/control/xferfcn.py index b00edc7d8..1cba50bd7 100644 --- a/control/xferfcn.py +++ b/control/xferfcn.py @@ -1091,7 +1091,17 @@ def _dcgain_cont(self): gain[i][j] = np.nan return np.squeeze(gain) - + def is_static_gain(self): + """returns True if and only if all of the numerator and denominator + polynomials of the (possibly MIMO) transfer function are zeroth order, + that is, if the system has no dynamics. """ + for list_of_polys in self.num, self.den: + for row in list_of_polys: + for poly in row: + if len(poly) > 1: + return False + return True + # c2d function contributed by Benjamin White, Oct 2012 def _c2d_matched(sysC, Ts): # Pole-zero match method of continuous to discrete time conversion From 2e988813ec9381f8048c9665bea99bc6e71da1fa Mon Sep 17 00:00:00 2001 From: bnavigator Date: Tue, 10 Nov 2020 00:43:24 +0100 Subject: [PATCH 57/67] refactor stability_margins and add routines for discrete time --- control/margins.py | 342 ++++++++++++++++++++++++----------- control/tests/margin_test.py | 9 +- 2 files changed, 240 insertions(+), 111 deletions(-) diff --git a/control/margins.py b/control/margins.py index 7bdcf6caa..299b1c493 100644 --- a/control/margins.py +++ b/control/margins.py @@ -54,26 +54,157 @@ import numpy as np import scipy as sp from . import xferfcn -from .lti import issiso +from .lti import issiso, evalfr from . import frdata +from .exception import ControlMIMONotImplemented __all__ = ['stability_margins', 'phase_crossover_frequencies', 'margin'] -# helper functions for stability_margins -def _polyimsplit(pol): - """split a polynomial with (iw) applied into a real and an - imaginary part with w applied""" - rpencil = np.zeros_like(pol) - ipencil = np.zeros_like(pol) - rpencil[-1::-4] = 1. - rpencil[-3::-4] = -1. - ipencil[-2::-4] = 1. - ipencil[-4::-4] = -1. - return pol * rpencil, pol*ipencil - -def _polysqr(pol): - """return a polynomial squared""" - return np.polymul(pol, pol) + +# private helper functions +def _poly_iw(sys): + """Apply s = iw to G(s)=num(s)/den(s) + + Splits the num and den polynomials with (iw) applied into real and + imaginary parts with w applied + """ + num = sys.num[0][0] + den = sys.den[0][0] + num_iw = (1J)**np.arange(len(num) - 1, -1, -1) * num + den_iw = (1J)**np.arange(len(den) - 1, -1, -1) * den + return num_iw, den_iw + + +def _poly_iw_sqr(pol_iw): + return np.real(np.polymul(pol_iw, pol_iw.conj())) + + +def _poly_iw_real_crossing(num_iw, den_iw, epsw): + # Return w where imag(H(iw)) == 0 + test_w = np.polysub(np.polymul(num_iw.imag, den_iw.real), + np.polymul(num_iw.real, den_iw.imag)) + w = np.roots(test_w) + w = np.real(w[np.isreal(w)]) + w = w[w >= epsw] + return w + + +def _poly_iw_mag1_crossing(num_iw, den_iw, epsw): + # Return w where |H(iw)| == 1, |num(iw)| - |den(iw)| == 0 + w = np.roots(np.polysub(_poly_iw_sqr(num_iw), _poly_iw_sqr(den_iw))) + w = np.real(w[np.isreal(w)]) + w = w[w > epsw] + return w + + +def _poly_iw_wstab(num_iw, den_iw, epsw): + # Stability margin: minimum distance to point -1 + # find zero derivative. Second derivative needs to be >0 + # to have a minimum + test_wstabn = _poly_iw_sqr(np.polyadd(num_iw, den_iw)) + test_wstabd = _poly_iw_sqr(den_iw) + test_wstab = np.polysub( + np.polymul(np.polyder(test_wstabn), test_wstabd), + np.polymul(np.polyder(test_wstabd), test_wstabn)) + + # find the solutions, for positive omega, and only real ones + wstab = np.roots(test_wstab) + wstab = np.real(wstab[np.isreal(wstab)]) + wstab = wstab[wstab > epsw] + + # and find the value of the 2nd derivative there, needs to be positive + wstabplus = np.polyval(np.polyder(test_wstab), wstab) + wstab = wstab[wstabplus > 0.] + return wstab + + +def _poly_z_invz(sys): + num = sys.num[0][0] # num(z) = a_p * z^p + a_(p-1) * z^(p-1) + ... + a_0 + den = sys.den[0][0] # num(z) = b_q * z^p + b_(q-1) * z^(q-1) + ... + b_0 + p_q = len(num) - len(den) + if p_q > 0: + raise ValueError("Not a proper transfer function: Denominator must " + "have equal or higher order than numerator.") + num_inv_zp = num[::-1] # num(1/z) * z^p + den_inv_zq = den[::-1] # den(1/z) * z^q + return num, den, num_inv_zp, den_inv_zq, p_q, sys.dt + + +def _z_filter(z, dt, eps): + # z = exp(1J w dt) + # |z| == 1 with some float precision tolerance + z = z[np.abs(np.abs(z) - 1.) < eps] + zarg = np.angle(z) + zidx = (0 <= zarg) * (zarg < np.pi) + omega = zarg[zidx] / dt + return z[zidx], omega + + +def _poly_z_real_crossing(num, den, num_inv_zp, den_inv_zq, p_q, dt, epsw): + # H(z)==H(1/z), num(z)*den(1/z) == num(1/z)*den(z) + p1 = np.polymul(num, den_inv_zq) + p2 = np.polymul(num_inv_zp, den) + if p_q < 0: + # Future: numpy >= 1.5.0 defines np.polymulx() + x = [1] + [0] * (-p_q) + p2 = np.polymul(p2, x) + z = np.roots(np.polysub(p1, p2)) + eps = np.finfo(float).eps**(1 / len(p2)) + z, w = _z_filter(z, dt, eps) + z = z[w >= epsw] + w = w[w >= epsw] + return z, w + + +def _poly_z_mag1_crossing(num, den, num_inv, den_inv, p_q, dt, epsw): + # |H(z)| = 1, H(z)*H(1/z)=1, num(z)*num(1/z) == den(z)*den(1/z) + p1 = np.polymul(num, num_inv) + p2 = np.polymul(den, den_inv) + if p_q < 0: + x = [1] + [0] * (-p_q) + p2 = np.polymul(p2, x) + z = np.roots(np.polysub(p1, p2)) + eps = np.finfo(float).eps**(1 / len(p2)) + z, w = _z_filter(z, dt, eps) + z = z[w > epsw] + w = w[w > epsw] + return z, w + + +def _poly_z_wstab(num, den, num_inv, den_inv, p_q, dt, epsw): + # Stability margin: Minimum distance to -1 + + # TODO: Find a way to solve for z or omega analytically with given + # polynomials + # d|1 + H(z)|/dz = 0, or d|1 + H(exp(iwdt))|/dw = 0 + + # optimization function to minimize + def fun(wdt): + with np.errstate(all='ignore'): # den=0 is okay + return np.abs(1 + (np.polyval(num, np.exp(1J * wdt)) / + np.polyval(den, np.exp(1J * wdt)))) + + # find initial guess + wdt_v = np.geomspace(1e-4, 2 * np.pi, num=100) + wdt0 = wdt_v[np.argmin(fun(wdt_v))] + + # Use `minimize` instead of univariate `minimize_scalars` because we want + # to provide some initial value in order to not converge on frequencies + # with extremely low gradients. + res = sp.optimize.minimize( + fun=fun, + x0=[wdt0], + bounds=[(0, 2 * np.pi)]) + if res.success: + wdt = res.x + z = np.exp(1J * wdt) + w = wdt / dt + else: + z = np.array([]) + w = np.array([]) + + return z, w + # Took the framework for the old function by # Sawyer B. Fuller , removed a lot of the innards @@ -98,6 +229,9 @@ def _polysqr(pol): # issue 1, pp 51-59, closer to Matlab behavior, but # not completely identical in edge cases, which don't # cross but touch gain=1 +# BG, Nov 9, 2020, removed duplicate implementations of the same code +# for crossover frequencies and enhanced to handle discrete +# systems def stability_margins(sysdata, returnall=False, epsw=0.0): """Calculate stability margins and associated crossover frequencies. @@ -133,7 +267,6 @@ def stability_margins(sysdata, returnall=False, epsw=0.0): ws: float or array_like Frequency for stability margin (complex gain closest to -1) """ - try: if isinstance(sysdata, frdata.FRD): sys = frdata.FRD(sysdata, smooth=True) @@ -141,73 +274,66 @@ def stability_margins(sysdata, returnall=False, epsw=0.0): sys = sysdata elif getattr(sysdata, '__iter__', False) and len(sysdata) == 3: mag, phase, omega = sysdata - sys = frdata.FRD(mag * np.exp(1j * phase * math.pi/180), + sys = frdata.FRD(mag * np.exp(1j * phase * math.pi / 180.), omega, smooth=True) else: sys = xferfcn._convert_to_transfer_function(sysdata) except Exception as e: - print (e) + print(e) raise ValueError("Margin sysdata must be either a linear system or " "a 3-sequence of mag, phase, omega.") - # calculate gain of system - if isinstance(sys, xferfcn.TransferFunction): - - # check for siso - if not issiso(sys): - raise ValueError("Can only do margins for SISO system") + # check for siso + if not issiso(sys): + raise ControlMIMONotImplemented( + "Can only do margins for SISO system") - # real and imaginary part polynomials in omega: - rnum, inum = _polyimsplit(sys.num[0][0]) - rden, iden = _polyimsplit(sys.den[0][0]) + if isinstance(sys, xferfcn.TransferFunction): + if sys.isctime(): + num_iw, den_iw = _poly_iw(sys) + # frequency for gain margin: phase crosses -180 degrees + w_180 = _poly_iw_real_crossing(num_iw, den_iw, epsw) + with np.errstate(all='ignore'): # den=0 is okay + w180_resp = evalfr(sys, 1J * w_180) + + # frequency for phase margin : gain crosses magnitude 1 + wc = _poly_iw_mag1_crossing(num_iw, den_iw, epsw) + wc_resp = evalfr(sys, 1J * wc) + + # stability margin + wstab = _poly_iw_wstab(num_iw, den_iw, epsw) + ws_resp = evalfr(sys, 1J * wstab) + + else: # Discrete Time + zargs = _poly_z_invz(sys) + # gain margin + z, w_180 = _poly_z_real_crossing(*zargs, epsw=epsw) + w180_resp = evalfr(sys, z) + + # phase margin + z, wc = _poly_z_mag1_crossing(*zargs, epsw=epsw) + wc_resp = evalfr(sys, z) + + # stability margin + z, wstab = _poly_z_wstab(*zargs, epsw=epsw) + ws_resp = evalfr(sys, z) - # test (imaginary part of tf) == 0, for phase crossover/gain margins - test_w_180 = np.polyadd(np.polymul(inum, rden), np.polymul(rnum, -iden)) - w_180 = np.roots(test_w_180) + # only keep frequencies where the negative real axis is crossed + w_180 = w_180[w180_resp <= 0.] + w180_resp = w180_resp[w180_resp <= 0.] - # first remove imaginary and negative frequencies, epsw removes the - # "0" frequency for type-2 systems - w_180 = np.real(w_180[(np.imag(w_180) == 0) * (w_180 >= epsw)]) + # sort + idx = np.argsort(w_180) + w_180 = w_180[idx] + w180_resp = w180_resp[idx] - # evaluate response at remaining frequencies, to test for phase 180 vs 0 - with np.errstate(all='ignore'): - resp_w_180 = np.real( - np.polyval(sys.num[0][0], 1.j*w_180) / - np.polyval(sys.den[0][0], 1.j*w_180)) + idx = np.argsort(wc) + wc = wc[idx] + wc_resp = wc_resp[idx] - # only keep frequencies where the negative real axis is crossed - w_180 = w_180[np.real(resp_w_180) <= 0.0] - - # and sort - w_180.sort() - - # test magnitude is 1 for gain crossover/phase margins - test_wc = np.polysub(np.polyadd(_polysqr(rnum), _polysqr(inum)), - np.polyadd(_polysqr(rden), _polysqr(iden))) - wc = np.roots(test_wc) - wc = np.real(wc[(np.imag(wc) == 0) * (wc > epsw)]) - wc.sort() - - # stability margin was a bitch to elaborate, relies on magnitude to - # point -1, then take the derivative. Second derivative needs to be >0 - # to have a minimum - test_wstabd = np.polyadd(_polysqr(rden), _polysqr(iden)) - test_wstabn = np.polyadd(_polysqr(np.polyadd(rnum,rden)), - _polysqr(np.polyadd(inum,iden))) - test_wstab = np.polysub( - np.polymul(np.polyder(test_wstabn),test_wstabd), - np.polymul(np.polyder(test_wstabd),test_wstabn)) - - # find the solutions, for positive omega, and only real ones - wstab = np.roots(test_wstab) - wstab = np.real(wstab[(np.imag(wstab) == 0) * - (np.real(wstab) >= 0)]) - - # and find the value of the 2nd derivative there, needs to be positive - wstabplus = np.polyval(np.polyder(test_wstab), wstab) - wstab = np.real(wstab[(np.imag(wstab) == 0) * (wstab > epsw) * - (wstabplus > 0.)]) - wstab.sort() + idx = np.argsort(wstab) + wstab = wstab[idx] + ws_resp = ws_resp[idx] else: # a bit coarse, have the interpolated frd evaluated again @@ -223,19 +349,22 @@ def _dstab(w): """Calculate the distance from -1 point""" return np.abs(sys._evalfr(w)[0][0] + 1.) - # Find all crossings, note that this depends on omega having - # a correct range - widx = np.where(np.diff(np.sign(_mod(sys.omega))))[0] - wc = np.array( - [sp.optimize.brentq(_mod, sys.omega[i], sys.omega[i+1]) - for i in widx]) - # find the phase crossings ang(H(jw) == -180 widx = np.where(np.diff(np.sign(_arg(sys.omega))))[0] widx = widx[np.real(sys._evalfr(sys.omega[widx])[0][0]) <= 0] w_180 = np.array( [sp.optimize.brentq(_arg, sys.omega[i], sys.omega[i+1]) for i in widx]) + # TODO: replace by evalfr(sys, 1J*w) or sys(1J*w), (needs gh-449) + w180_resp = sys._evalfr(w_180)[0][0] + + # Find all crossings, note that this depends on omega having + # a correct range + widx = np.where(np.diff(np.sign(_mod(sys.omega))))[0] + wc = np.array( + [sp.optimize.brentq(_mod, sys.omega[i], sys.omega[i+1]) + for i in widx]) + wc_resp = sys._evalfr(wc)[0][0] # find all stab margins? widx, = np.where(np.diff(np.sign(np.diff(_dstab(sys.omega)))) > 0) @@ -245,14 +374,12 @@ def _dstab(w): ).x for i in widx]) wstab = wstab[(wstab >= sys.omega[0]) * (wstab <= sys.omega[-1])] + ws_resp = sys._evalfr(wstab)[0][0] - # margins, as iterables, converted frdata and xferfcn calculations to - # vector for this - with np.errstate(all='ignore'): - gain_w_180 = np.abs(sys._evalfr(w_180)[0][0]) - GM = 1.0/gain_w_180 - SM = np.abs(sys._evalfr(wstab)[0][0]+1) - PM = np.remainder(np.angle(sys._evalfr(wc)[0][0], deg=True), 360.0) - 180.0 + with np.errstate(all='ignore'): # |G|=0 is okay and yields inf + GM = 1. / np.abs(w180_resp) + PM = np.remainder(np.angle(wc_resp, deg=True), 360.) - 180. + SM = np.abs(ws_resp + 1.) if returnall: return GM, PM, SM, w_180, wc, wstab @@ -279,43 +406,44 @@ def phase_crossover_frequencies(sys): """Compute frequencies and gains at intersections with real axis in Nyquist plot. - Call as: - omega, gain = phase_crossover_frequencies() + Parameters + ---------- + sys : SISO LTI system Returns ------- - omega: 1d array of (non-negative) frequencies where Nyquist plot - intersects the real axis - - gain: 1d array of corresponding gains + omega : ndarray + 1d array of (non-negative) frequencies where Nyquist plot + intersects the real axis + gain : ndarray + 1d array of corresponding gains Examples -------- >>> tf = TransferFunction([1], [1, 2, 3, 4]) - >>> PhaseCrossoverFrequenies(tf) + >>> phase_crossover_frequencies(tf) (array([ 1.73205081, 0. ]), array([-0.5 , 0.25])) """ - # Convert to a transfer function tf = xferfcn._convert_to_transfer_function(sys) - # if not siso, fall back to (0,0) element - #! TODO: should add a check and warning here - num = tf.num[0][0] - den = tf.den[0][0] + if not issiso(tf): + raise ControlMIMONotImplemented( + "Can only calculate crossovers for SISO system") # Compute frequencies that we cross over the real axis - numj = (1.j)**np.arange(len(num)-1,-1,-1)*num - denj = (-1.j)**np.arange(len(den)-1,-1,-1)*den - allfreq = np.roots(np.imag(np.polymul(numj,denj))) - realfreq = np.real(allfreq[np.isreal(allfreq)]) - realposfreq = realfreq[realfreq >= 0.] + if sys.isctime(): + num_iw, den_iw = _poly_iw(tf) + omega = _poly_iw_real_crossing(num_iw, den_iw, 0.) - # using real() to avoid rounding errors and results like 1+0j - # it would be nice to have a vectorized version of self.evalfr here - gain = np.real(np.asarray([tf._evalfr(f)[0][0] for f in realposfreq])) + # using real() to avoid rounding errors and results like 1+0j + gain = np.real(evalfr(sys, 1J * omega)) + else: + zargs = _poly_z_invz(sys) + z, omega = _poly_z_real_crossing(*zargs, epsw=0.) + gain = np.real(evalfr(sys, z)) - return realposfreq, gain + return omega, gain def margin(*args): diff --git a/control/tests/margin_test.py b/control/tests/margin_test.py index 2f60c7bc6..7ce8c3302 100755 --- a/control/tests/margin_test.py +++ b/control/tests/margin_test.py @@ -17,6 +17,7 @@ stability_margins from control.statesp import StateSpace from control.xferfcn import TransferFunction +from control.exception import ControlMIMONotImplemented s = TransferFunction([1, 0], [1]) @@ -108,14 +109,14 @@ def test_phase_crossover_frequencies(): assert_allclose(omega, [0.], atol=1.5e-3) assert_allclose(gain, [1.], atol=1.5e-3) - # testing MIMO, only (0,0) element is considered + # MIMO tf = TransferFunction([[[1], [2]], [[3], [4]]], [[[1, 2, 3, 4], [1, 1]], [[1, 1], [1, 1]]]) - omega, gain = phase_crossover_frequencies(tf) - assert_allclose(omega, [1.73205, 0.], atol=1.5e-3) - assert_allclose(gain, [-0.5, 0.25], atol=1.5e-3) + with pytest.raises(ControlMIMONotImplemented): + omega, gain = phase_crossover_frequencies(tf) + def test_mag_phase_omega(): From 199858b1610a857ce6fbd47c05bf20126d664b32 Mon Sep 17 00:00:00 2001 From: bnavigator Date: Mon, 16 Nov 2020 17:28:23 +0100 Subject: [PATCH 58/67] pick margin_test.py from #438 --- control/tests/margin_test.py | 286 ++++++++++++++++++----------------- 1 file changed, 151 insertions(+), 135 deletions(-) diff --git a/control/tests/margin_test.py b/control/tests/margin_test.py index 7ce8c3302..7b513a9f5 100755 --- a/control/tests/margin_test.py +++ b/control/tests/margin_test.py @@ -3,51 +3,65 @@ margin_test.py - test suite for stability margin commands RMM, 15 Jul 2011 -BG, 30 Juin 2020 -- convert to pytest, gh-425 +BG, 30 June 2020 -- convert to pytest, gh-425 """ from __future__ import print_function import numpy as np +import pytest from numpy import inf, nan from numpy.testing import assert_allclose -import pytest from control.frdata import FrequencyResponseData -from control.margins import margin, phase_crossover_frequencies, \ - stability_margins +from control.margins import (margin, phase_crossover_frequencies, + stability_margins) from control.statesp import StateSpace from control.xferfcn import TransferFunction from control.exception import ControlMIMONotImplemented - -s = TransferFunction([1, 0], [1]) - -# (system, stability_margins(sys), stability_margins(sys, returnall=True)) -tsys = [(TransferFunction([1, 2], [1, 2, 3]), - (inf, inf, inf, nan, nan, nan), - ([], [], [], [], [], [])), - (TransferFunction([1], [1, 2, 3, 4]), - (2., inf, 0.4170, 1.7321, nan, 1.6620), - ([2.], [], [1.2500, 0.4170], [1.7321], [], [0.1690, 1.6620])), - (StateSpace([[1., 4.], [3., 2.]], [[1.], [-4.]], - [[1., 0.]], [[0.]]), - (inf, 147.0743, inf, nan, 2.5483, nan), - ([], [147.0743], [], [], [2.5483], [])), - ((8.75*(4*s**2+0.4*s+1)) / ((100*s+1)*(s**2+0.22*s+1)) - / (s**2/(10.**2)+2*0.04*s/10.+1), - (2.2716, 97.5941, 0.5591, 10.0053, 0.0850, 9.9918), - ([2.2716], [97.5941, -157.7844, 134.7359], [1.0381, 0.5591], - [10.0053], [0.0850, 0.9373, 1.0919], [0.4064, 9.9918])), - (1/(1+s), # no gain/phase crossovers - (inf, inf, inf, nan, nan, nan), - ([], [], [], [], [], [])), - (3*(10+s)/(2+s), # no gain/phase crossovers - (inf, inf, inf, nan, nan, nan), - ([], [], [], [], [], [])), - (0.01*(10-s)/(2+s)/(1+s), # no phase crossovers - (300.0, inf, 0.9917, 5.6569, nan, 2.3171), - ([300.0], [], [0.9917], [5.6569], [], 2.3171))] - +s = TransferFunction.s + +@pytest.fixture(params=[ + # sysfn, args, + # stability_margins(sys), + # stability_margins(sys, returnall=True) + (TransferFunction, ([1, 2], [1, 2, 3]), + (inf, inf, inf, nan, nan, nan), + ([], [], [], [], [], [])), + (TransferFunction, ([1], [1, 2, 3, 4]), + (2., inf, 0.4170, 1.7321, nan, 1.6620), + ([2.], [], [1.2500, 0.4170], [1.7321], [], [0.1690, 1.6620])), + (StateSpace, ([[1., 4.], + [3., 2.]], + [[1.], [-4.]], + [[1., 0.]], + [[0.]]), + (inf, 147.0743, inf, nan, 2.5483, nan), + ([], [147.0743], [], [], [2.5483], [])), + (None, ((8.75 * (4 * s**2 + 0.4 * s + 1)) + / ((100 * s + 1) * (s**2 + 0.22 * s + 1)) + / (s**2 / 10.**2 + 2 * 0.04 * s / 10. + 1)), + (2.2716, 97.5941, 0.5591, 10.0053, 0.0850, 9.9918), + ([2.2716], [97.5941, -157.7844, 134.7359], [1.0381, 0.5591], + [10.0053], [0.0850, 0.9373, 1.0919], [0.4064, 9.9918])), + (None, (1 / (1 + s)), # no gain/phase crossovers + (inf, inf, inf, nan, nan, nan), + ([], [], [], [], [], [])), + (None, (3 * (10 + s) / (2 + s)), # no gain/phase crossovers + (inf, inf, inf, nan, nan, nan), + ([], [], [], [], [], [])), + (None, 0.01 * (10 - s) / (2 + s) / (1 + s), # no phase crossovers + (300.0, inf, 0.9917, 5.6569, nan, 2.3171), + ([300.0], [], [0.9917], [5.6569], [], 2.3171)), +]) +def tsys(request): + """Return test systems and reference data""" + sysfn, args = request.param[:2] + if sysfn: + sys = sysfn(*args) + else: + sys = args + return (sys,) + request.param[2:] def compare_allmargins(actual, desired, **kwargs): """Compare all elements of stability_margins(returnall=True) result""" @@ -56,8 +70,8 @@ def compare_allmargins(actual, desired, **kwargs): assert_allclose(a, d, **kwargs) -@pytest.mark.parametrize("sys, refout, refoutall", tsys) -def test_stability_margins(sys, refout, refoutall): +def test_stability_margins(tsys): + sys, refout, refoutall = tsys """Test stability_margins() function""" out = stability_margins(sys) assert_allclose(out, refout, atol=1.5e-2) @@ -65,16 +79,17 @@ def test_stability_margins(sys, refout, refoutall): compare_allmargins(out, refoutall, atol=1.5e-2) -@pytest.mark.parametrize("sys, refout, refoutall", tsys) -def test_stability_margins_omega(sys, refout, refoutall): + +def test_stability_margins_omega(tsys): + sys, refout, refoutall = tsys """Test stability_margins() with interpolated frequencies""" omega = np.logspace(-2, 2, 2000) out = stability_margins(FrequencyResponseData(sys, omega)) assert_allclose(out, refout, atol=1.5e-3) -@pytest.mark.parametrize("sys, refout, refoutall", tsys) -def test_stability_margins_3input(sys, refout, refoutall): +def test_stability_margins_3input(tsys): + sys, refout, refoutall = tsys """Test stability_margins() function with mag, phase, omega input""" omega = np.logspace(-2, 2, 2000) mag, phase, omega_ = sys.freqresp(omega) @@ -82,15 +97,15 @@ def test_stability_margins_3input(sys, refout, refoutall): assert_allclose(out, refout, atol=1.5e-3) -@pytest.mark.parametrize("sys, refout, refoutall", tsys) -def test_margin_sys(sys, refout, refoutall): +def test_margin_sys(tsys): + sys, refout, refoutall = tsys """Test margin() function with system input""" out = margin(sys) assert_allclose(out, np.array(refout)[[0, 1, 3, 4]], atol=1.5e-3) -@pytest.mark.parametrize("sys, refout, refoutall", tsys) -def test_margin_3input(sys, refout, refoutall): +def test_margin_3input(tsys): + sys, refout, refoutall = tsys """Test margin() function with mag, phase, omega input""" omega = np.logspace(-2, 2, 2000) mag, phase, omega_ = sys.freqresp(omega) @@ -100,7 +115,8 @@ def test_margin_3input(sys, refout, refoutall): def test_phase_crossover_frequencies(): """Test phase_crossover_frequencies() function""" - omega, gain = phase_crossover_frequencies(tsys[1][0]) + sys = TransferFunction([1], [1, 2, 3, 4]) + omega, gain = phase_crossover_frequencies(sys) assert_allclose(omega, [1.73205, 0.], atol=1.5e-3) assert_allclose(gain, [-0.5, 0.25], atol=1.5e-3) @@ -215,99 +231,99 @@ def test_frd_indexing(): assert_allclose(ws, [1., 2.], atol=0.01) -""" -NOTE: -Matlab gives gain margin 0 for system `type2`, python-control gives inf -Difficult to argue which is right? Special case or different approach? +@pytest.fixture +def tsys_zmoresystems(): + """A cornucopia of tricky systems for phase / gain margin -Edge cases, like `type0` which approaches a gain of 1 for w -> 0, are also not -identically indicated, Matlab gives phase margin -180, at w = 0. For higher or -lower gains, results match. -""" -tzmore_sys = { - 'typem1': s/(s+1), - 'type0': 1/(s+1)**3, - 'type1': (s + 0.1)/s/(s+1), - 'type2': (s + 0.1)/s**2/(s+1), - 'type3': (s + 0.1)*(s+0.1)/s**3/(s+1)} -tzmore_margin = [ - dict(sys='typem1', K=2.0, atol=1.5e-3, result=( - float('Inf'), -120.0007, float('NaN'), 0.5774)), - dict(sys='type0', K=0.8, atol=1.5e-3, result=( - 10.0014, float('inf'), 1.7322, float('nan'))), - dict(sys='type0', K=2.0, atol=1e-2, result=( - 4.000, 67.6058, 1.7322, 0.7663)), - dict(sys='type1', K=1.0, atol=1e-4, result=( - float('Inf'), 144.9032, float('NaN'), 0.3162)), - dict(sys='type2', K=1.0, atol=1e-4, result=( - float('Inf'), 44.4594, float('NaN'), 0.7907)), - dict(sys='type3', K=1.0, atol=1.5e-3, result=( - 0.0626, 37.1748, 0.1119, 0.7951)), - ] -tzmore_stability_margins = [] + `example*` from "A note on the Gain and Phase Margin Concepts + Journal of Control and Systems Engineering, Yazdan Bavafi-Toosi, + Dec 2015, vol 3 iss 1, pp 51-59 -""" -from "A note on the Gain and Phase Margin Concepts -Journal of Control and Systems Engineering, Yazdan Bavafi-Toosi, -Dec 2015, vol 3 iss 1, pp 51-59 + TODO: still have to convert more to tests + fix margin to handle + also these torture cases + """ -A cornucopia of tricky systems for phase / gain margin -TODO: still have to convert more to tests + fix margin to handle -also these torture cases -""" -yazdan = { - 'example21': - 0.002*(s+0.02)*(s+0.05)*(s+5)*(s+10)/( - (s-0.0005)*(s+0.0001)*(s+0.01)*(s+0.2)*(s+1)*(s+100)**2), - 'example23': - ((s+0.1)**2 + 1)*(s-0.1)/( - ((s+0.1)**2+4)*(s+1)), - 'example25a': - s/(s**2+2*s+2)**4, - 'example26a': - ((s-0.1)**2 + 1)/( - (s + 0.1)*((s-0.2)**2 + 4)), - 'example26b': ((s-0.1)**2 + 1)/( - (s - 0.3)*((s-0.2)**2 + 4)) -} -yazdan['example24'] = yazdan['example21']*20000 -yazdan['example25b'] = yazdan['example25a']*100 -yazdan['example22'] = yazdan['example21']*(s**2 - 2*s + 401) -ymargin = [ - dict(sys='example21', K=1.0, atol=1e-2, - result=(0.0100, -14.5640, 0, 0.0022)), - dict(sys='example21', K=1000.0, atol=1e-2, - result=(0.1793, 22.5215, 0.0243, 0.0630)), - dict(sys='example21', K=5000.0, atol=1.5e-3, - result=(4.5596, 21.2101, 0.4385, 0.1868)), - ] -ystability_margins = [ - dict(sys='example21', K=1.0, rtol=1e-3, atol=1e-3, - result=([0.01, 179.2931, 2.2798e+4, 1.5946e+07, 7.2477e+08], - [-14.5640], - [0.2496], - [0, 0.0243, 0.4385, 6.8640, 84.9323], - [0.0022], - [0.0022])), - ] - -tzmore_sys.update(yazdan) -tzmore_margin += ymargin -tzmore_stability_margins += ystability_margins - - -@pytest.mark.parametrize('tmargin', tzmore_margin) -def test_zmore_margin(tmargin): - """Test margins for more tricky systems""" - res = margin(tzmore_sys[tmargin['sys']]*tmargin['K']) - assert_allclose(res, tmargin['result'], atol=tmargin['atol']) - - -@pytest.mark.parametrize('tmarginall', tzmore_stability_margins) -def test_zmore_stability_margins(tmarginall): + systems = { + 'typem1': s/(s+1), + 'type0': 1/(s+1)**3, + 'type1': (s + 0.1)/s/(s+1), + 'type2': (s + 0.1)/s**2/(s+1), + 'type3': (s + 0.1)*(s+0.1)/s**3/(s+1), + 'example21': 0.002*(s+0.02)*(s+0.05)*(s+5)*(s+10) / ( + (s-0.0005)*(s+0.0001)*(s+0.01)*(s+0.2)*(s+1)*(s+100)**2), + 'example23': ((s+0.1)**2 + 1)*(s-0.1)/(((s+0.1)**2+4)*(s+1)), + 'example25a': s/(s**2+2*s+2)**4, + 'example26a': ((s-0.1)**2 + 1)/((s + 0.1)*((s-0.2)**2 + 4)), + 'example26b': ((s-0.1)**2 + 1)/((s - 0.3)*((s-0.2)**2 + 4)) + } + systems['example24'] = systems['example21'] * 20000 + systems['example25b'] = systems['example25a'] * 100 + systems['example22'] = systems['example21'] * (s**2 - 2*s + 401) + return systems + + +@pytest.fixture +def tsys_zmore(request, tsys_zmoresystems): + tsys = request.param + tsys['sys'] = tsys_zmoresystems[tsys['sysname']] + return tsys + + +@pytest.mark.parametrize( + 'tsys_zmore', + [dict(sysname='typem1', K=2.0, atol=1.5e-3, + result=(float('Inf'), -120.0007, float('NaN'), 0.5774)), + dict(sysname='type0', K=0.8, atol=1.5e-3, + result=(10.0014, float('inf'), 1.7322, float('nan'))), + dict(sysname='type0', K=2.0, atol=1e-2, + result=(4.000, 67.6058, 1.7322, 0.7663)), + dict(sysname='type1', K=1.0, atol=1e-4, + result=(float('Inf'), 144.9032, float('NaN'), 0.3162)), + dict(sysname='type2', K=1.0, atol=1e-4, + result=(float('Inf'), 44.4594, float('NaN'), 0.7907)), + dict(sysname='type3', K=1.0, atol=1.5e-3, + result=(0.0626, 37.1748, 0.1119, 0.7951)), + dict(sysname='example21', K=1.0, atol=1e-2, + result=(0.0100, -14.5640, 0, 0.0022)), + dict(sysname='example21', K=1000.0, atol=1e-2, + result=(0.1793, 22.5215, 0.0243, 0.0630)), + dict(sysname='example21', K=5000.0, atol=1.5e-3, + result=(4.5596, 21.2101, 0.4385, 0.1868)), + ], + indirect=True) +def test_zmore_margin(tsys_zmore): + """Test margins for more tricky systems + + Note + ---- + Matlab gives gain margin 0 for system `type2`, python-control gives inf + Difficult to argue which is right? Special case or different approach? + + Edge cases, like `type0` which approaches a gain of 1 for w -> 0, are also + not identically indicated, Matlab gives phase margin -180, at w = 0. For + higher or lower gains, results match. + """ + + res = margin(tsys_zmore['sys'] * tsys_zmore['K']) + assert_allclose(res, tsys_zmore['result'], atol=tsys_zmore['atol']) + + +@pytest.mark.parametrize( + 'tsys_zmore', + [dict(sysname='example21', K=1.0, rtol=1e-3, atol=1e-3, + result=([0.01, 179.2931, 2.2798e+4, 1.5946e+07, 7.2477e+08], + [-14.5640], + [0.2496], + [0, 0.0243, 0.4385, 6.8640, 84.9323], + [0.0022], + [0.0022])), + ], + indirect=True) +def test_zmore_stability_margins(tsys_zmore): """Test stability_margins for more tricky systems with returnall""" - res = stability_margins(tzmore_sys[tmarginall['sys']]*tmarginall['K'], + res = stability_margins(tsys_zmore['sys'] * tsys_zmore['K'], returnall=True) - compare_allmargins(res, tmarginall['result'], - atol=tmarginall['atol'], - rtol=tmarginall['rtol']) + compare_allmargins(res, + tsys_zmore['result'], + atol=tsys_zmore['atol'], + rtol=tsys_zmore['rtol']) From ad0a22549f9ad5e0f84e7f81f28ee4ad405cca65 Mon Sep 17 00:00:00 2001 From: bnavigator Date: Mon, 16 Nov 2020 22:23:00 +0100 Subject: [PATCH 59/67] Tests for stability_margin and phase_crossover_frequencies with discrete TF --- control/tests/margin_test.py | 45 +++++++++++++++++++++++++++--------- 1 file changed, 34 insertions(+), 11 deletions(-) diff --git a/control/tests/margin_test.py b/control/tests/margin_test.py index 7b513a9f5..80916da1b 100755 --- a/control/tests/margin_test.py +++ b/control/tests/margin_test.py @@ -3,7 +3,8 @@ margin_test.py - test suite for stability margin commands RMM, 15 Jul 2011 -BG, 30 June 2020 -- convert to pytest, gh-425 +BG, 30 Jun 2020 -- convert to pytest, gh-425 +BG, 16 Nov 2020 -- pick from gh-438 and add discrete test """ from __future__ import print_function @@ -113,19 +114,24 @@ def test_margin_3input(tsys): assert_allclose(out, np.array(refout)[[0, 1, 3, 4]], atol=1.5e-3) -def test_phase_crossover_frequencies(): +@pytest.mark.parametrize( + 'tfargs, omega_ref, gain_ref', + [(([1], [1, 2, 3, 4]), [1.7325, 0.], [-0.5, 0.25]), + (([1], [1, 1]), [0.], [1.]), + (([2], [1, 3, 3, 1]), [1.732, 0.], [-0.25, 2.]), + ((np.array([3, 11, 3]) * 1e-4, [1., -2.7145, 2.4562, -0.7408], .1), + [1.6235, 0.], [-0.28598, 1.88889]), + ]) +def test_phase_crossover_frequencies(tfargs, omega_ref, gain_ref): """Test phase_crossover_frequencies() function""" - sys = TransferFunction([1], [1, 2, 3, 4]) + sys = TransferFunction(*tfargs) omega, gain = phase_crossover_frequencies(sys) - assert_allclose(omega, [1.73205, 0.], atol=1.5e-3) - assert_allclose(gain, [-0.5, 0.25], atol=1.5e-3) + assert_allclose(omega, omega_ref, atol=1.5e-3) + assert_allclose(gain, gain_ref, atol=1.5e-3) - tf = TransferFunction([1], [1, 1]) - omega, gain = phase_crossover_frequencies(tf) - assert_allclose(omega, [0.], atol=1.5e-3) - assert_allclose(gain, [1.], atol=1.5e-3) - # MIMO +def test_phase_crossover_frequencies_mimo(): + """Test MIMO exception""" tf = TransferFunction([[[1], [2]], [[3], [4]]], [[[1, 2, 3, 4], [1, 1]], @@ -134,7 +140,6 @@ def test_phase_crossover_frequencies(): omega, gain = phase_crossover_frequencies(tf) - def test_mag_phase_omega(): """Test for bug reported in gh-58""" sys = TransferFunction(15, [1, 6, 11, 6]) @@ -327,3 +332,21 @@ def test_zmore_stability_margins(tsys_zmore): tsys_zmore['result'], atol=tsys_zmore['atol'], rtol=tsys_zmore['rtol']) + + +@pytest.mark.parametrize( + 'cnum, cden, dt,' + 'ref,' + 'rtol', + [([2], [1, 3, 2, 0], 1e-2, # gh-465 + (2.9558, 32.8170, 0.43584, 1.4037, 0.74953, 0.97079), + 0.1 # very crude tolerance, because the gradients are not great + ), + ([2], [1, 3, 3, 1], .1, # 2/(s+1)**3 + [3.4927, 69.9996, 0.5763, 1.6283, 0.7631, 1.2019], + 1e-3)]) +def test_stability_margins_discrete(cnum, cden, dt, ref, rtol): + """Test stability_margins with discrete TF input""" + tf = TransferFunction(cnum, cden).sample(dt) + out = stability_margins(tf) + assert_allclose(out, ref, rtol=rtol) From d0f333e823bc10b268d64254c54c1a1f240c8d5b Mon Sep 17 00:00:00 2001 From: Ben Greiner Date: Wed, 18 Nov 2020 13:18:40 +0100 Subject: [PATCH 60/67] remove misguided comment about polymulx --- control/margins.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/control/margins.py b/control/margins.py index 299b1c493..03e78352f 100644 --- a/control/margins.py +++ b/control/margins.py @@ -145,7 +145,7 @@ def _poly_z_real_crossing(num, den, num_inv_zp, den_inv_zq, p_q, dt, epsw): p1 = np.polymul(num, den_inv_zq) p2 = np.polymul(num_inv_zp, den) if p_q < 0: - # Future: numpy >= 1.5.0 defines np.polymulx() + # * z**(-p_q) x = [1] + [0] * (-p_q) p2 = np.polymul(p2, x) z = np.roots(np.polysub(p1, p2)) From 1fc4cc12826ddd05061397509618db064f9ff307 Mon Sep 17 00:00:00 2001 From: Sawyer Fuller Date: Thu, 17 Dec 2020 15:10:35 -0800 Subject: [PATCH 61/67] added test needed to pass --- control/tests/bdalg_test.py | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/control/tests/bdalg_test.py b/control/tests/bdalg_test.py index fde503052..d33007310 100644 --- a/control/tests/bdalg_test.py +++ b/control/tests/bdalg_test.py @@ -9,7 +9,7 @@ import control as ctrl from control.xferfcn import TransferFunction from control.statesp import StateSpace -from control.bdalg import feedback +from control.bdalg import feedback, append, connect from control.lti import zero, pole class TestFeedback(unittest.TestCase): @@ -23,7 +23,9 @@ def setUp(self): # Two random SISO systems. self.sys1 = TransferFunction([1, 2], [1, 2, 3]) self.sys2 = StateSpace([[1., 4.], [3., 2.]], [[1.], [-4.]], - [[1., 0.]], [[0.]]) + [[1., 0.]], [[0.]]) # 2 states, SISO + self.sys3 = StateSpace([[-1.]], [[1.]], [[1.]], [[0.]]) # 1 state, SISO + # Two random scalars. self.x1 = 2.5 self.x2 = -3. @@ -270,6 +272,13 @@ def test_feedback_args(self): sys = ctrl.feedback(1, frd) self.assertTrue(isinstance(sys, ctrl.FRD)) + def testConnect(self): + sys = append(self.sys2, self.sys3) # two siso systems + + # feedback interconnection -3 is out of bounds + Q1 = [[1, 2], [2, -3]] + self.assertRaises(IndexError, connect(sys, Q1, [2], [1, 2])) + if __name__ == "__main__": unittest.main() From 85cc6ca9a7c1fed21202e6e15d462529012cda1b Mon Sep 17 00:00:00 2001 From: Sawyer Fuller Date: Fri, 18 Dec 2020 20:24:51 -0800 Subject: [PATCH 62/67] bdalg.connect: added and fixed index checks to fix #421; docstring updated to indicate that Q matrix can be >2 columns --- control/bdalg.py | 39 +++++++++++++++++++++++++++-------- control/tests/bdalg_test.py | 41 +++++++++++++++++++++++++++++++++---- 2 files changed, 67 insertions(+), 13 deletions(-) diff --git a/control/bdalg.py b/control/bdalg.py index 3f13fb1b3..7b92245b0 100644 --- a/control/bdalg.py +++ b/control/bdalg.py @@ -302,14 +302,16 @@ def connect(sys, Q, inputv, outputv): sys : StateSpace Transferfunction System to be connected Q : 2D array - Interconnection matrix. First column gives the input to be connected - second column gives the output to be fed into this input. Negative - values for the second column mean the feedback is negative, 0 means - no connection is made. Inputs and outputs are indexed starting at 1. + Interconnection matrix. First column gives the input to be connected. + The second column gives the index of an output that is to be fed into + that input. Each additional column gives the index of an additional + input that may be optionally added to that input. Negative + values mean the feedback is negative. A zero value is ignored. Inputs + and outputs are indexed starting at 1 to communicate sign information. inputv : 1D array - list of final external inputs + list of final external inputs, indexed starting at 1 outputv : 1D array - list of final external outputs + list of final external outputs, indexed starting at 1 Returns ------- @@ -325,15 +327,34 @@ def connect(sys, Q, inputv, outputv): >>> sysc = connect(sys, Q, [2], [1, 2]) """ + inputv, outputv, Q = np.asarray(inputv), np.asarray(outputv), np.asarray(Q) + # check indices + index_errors = (inputv - 1 > sys.inputs) | (inputv < 1) + if np.any(index_errors): + raise IndexError( + "inputv index %s out of bounds"%inputv[np.where(index_errors)]) + index_errors = (outputv - 1 > sys.outputs) | (outputv < 1) + if np.any(index_errors): + raise IndexError( + "outputv index %s out of bounds"%outputv[np.where(index_errors)]) + index_errors = (Q[:,0:1] - 1 > sys.inputs) | (Q[:,0:1] < 1) + if np.any(index_errors): + raise IndexError( + "Q input index %s out of bounds"%Q[np.where(index_errors)]) + index_errors = (np.abs(Q[:,1:]) - 1 > sys.outputs) + if np.any(index_errors): + raise IndexError( + "Q output index %s out of bounds"%Q[np.where(index_errors)]) + # first connect K = np.zeros((sys.inputs, sys.outputs)) for r in np.array(Q).astype(int): inp = r[0]-1 for outp in r[1:]: - if outp > 0 and outp <= sys.outputs: - K[inp,outp-1] = 1. - elif outp < 0 and -outp >= -sys.outputs: + if outp < 0: K[inp,-outp-1] = -1. + elif outp > 0: + K[inp,outp-1] = 1. sys = sys.feedback(np.array(K), sign=1) # now trim diff --git a/control/tests/bdalg_test.py b/control/tests/bdalg_test.py index d33007310..6a3e45eee 100644 --- a/control/tests/bdalg_test.py +++ b/control/tests/bdalg_test.py @@ -275,10 +275,43 @@ def test_feedback_args(self): def testConnect(self): sys = append(self.sys2, self.sys3) # two siso systems - # feedback interconnection -3 is out of bounds - Q1 = [[1, 2], [2, -3]] - self.assertRaises(IndexError, connect(sys, Q1, [2], [1, 2])) - + # feedback interconnection out of bounds: input too high + Q = [[1, 3], [2, -2]] + with self.assertRaises(IndexError) as context: + connect(sys, Q, [2], [1, 2]) + # feedback interconnection out of bounds: input too low + Q = [[0, 2], [2, -2]] + with self.assertRaises(IndexError) as context: + connect(sys, Q, [2], [1, 2]) + + # feedback interconnection out of bounds: output too high + Q = [[1, 2], [2, -3]] + with self.assertRaises(IndexError) as context: + connect(sys, Q, [2], [1, 2]) + Q = [[1, 2], [2, 4]] + with self.assertRaises(IndexError) as context: + connect(sys, Q, [2], [1, 2]) + + # input/output index testing + Q = [[1, 2], [2, -2]] # OK interconnection + + # input index is out of bounds: too high + with self.assertRaises(IndexError) as context: + connect(sys, Q, [3], [1, 2]) + # input index is out of bounds: too low + with self.assertRaises(IndexError) as context: + connect(sys, Q, [0], [1, 2]) + with self.assertRaises(IndexError) as context: + connect(sys, Q, [-2], [1, 2]) + # output index is out of bounds: too high + with self.assertRaises(IndexError) as context: + connect(sys, Q, [2], [1, 3]) + # output index is out of bounds: too low + with self.assertRaises(IndexError) as context: + connect(sys, Q, [2], [1, 0]) + with self.assertRaises(IndexError) as context: + connect(sys, Q, [2], [1, -1]) + if __name__ == "__main__": unittest.main() From 9c5b5e4ae84f3be094241ea2a6464c29b58665d4 Mon Sep 17 00:00:00 2001 From: Sawyer Fuller Date: Sun, 20 Dec 2020 20:03:55 -0800 Subject: [PATCH 63/67] bdalg.connect: new tests that should pass, stylistic changes --- control/bdalg.py | 32 ++++++++-------- control/tests/bdalg_test.py | 74 +++++++++++++++++++++---------------- 2 files changed, 58 insertions(+), 48 deletions(-) diff --git a/control/bdalg.py b/control/bdalg.py index 7b92245b0..a9ba6cd16 100644 --- a/control/bdalg.py +++ b/control/bdalg.py @@ -303,10 +303,10 @@ def connect(sys, Q, inputv, outputv): System to be connected Q : 2D array Interconnection matrix. First column gives the input to be connected. - The second column gives the index of an output that is to be fed into - that input. Each additional column gives the index of an additional + The second column gives the index of an output that is to be fed into + that input. Each additional column gives the index of an additional input that may be optionally added to that input. Negative - values mean the feedback is negative. A zero value is ignored. Inputs + values mean the feedback is negative. A zero value is ignored. Inputs and outputs are indexed starting at 1 to communicate sign information. inputv : 1D array list of final external inputs, indexed starting at 1 @@ -330,22 +330,22 @@ def connect(sys, Q, inputv, outputv): inputv, outputv, Q = np.asarray(inputv), np.asarray(outputv), np.asarray(Q) # check indices index_errors = (inputv - 1 > sys.inputs) | (inputv < 1) - if np.any(index_errors): - raise IndexError( - "inputv index %s out of bounds"%inputv[np.where(index_errors)]) + if np.any(index_errors): + raise IndexError( + "inputv index %s out of bounds" % inputv[np.where(index_errors)]) index_errors = (outputv - 1 > sys.outputs) | (outputv < 1) - if np.any(index_errors): - raise IndexError( - "outputv index %s out of bounds"%outputv[np.where(index_errors)]) + if np.any(index_errors): + raise IndexError( + "outputv index %s out of bounds" % outputv[np.where(index_errors)]) index_errors = (Q[:,0:1] - 1 > sys.inputs) | (Q[:,0:1] < 1) - if np.any(index_errors): - raise IndexError( - "Q input index %s out of bounds"%Q[np.where(index_errors)]) + if np.any(index_errors): + raise IndexError( + "Q input index %s out of bounds" % Q[np.where(index_errors)]) index_errors = (np.abs(Q[:,1:]) - 1 > sys.outputs) - if np.any(index_errors): - raise IndexError( - "Q output index %s out of bounds"%Q[np.where(index_errors)]) - + if np.any(index_errors): + raise IndexError( + "Q output index %s out of bounds" % Q[np.where(index_errors)]) + # first connect K = np.zeros((sys.inputs, sys.outputs)) for r in np.array(Q).astype(int): diff --git a/control/tests/bdalg_test.py b/control/tests/bdalg_test.py index 6a3e45eee..a7ec6c14b 100644 --- a/control/tests/bdalg_test.py +++ b/control/tests/bdalg_test.py @@ -194,50 +194,50 @@ def testLists(self): sys1_2 = ctrl.series(sys1, sys2) np.testing.assert_array_almost_equal(sort(pole(sys1_2)), [-4., -2.]) np.testing.assert_array_almost_equal(sort(zero(sys1_2)), [-3., -1.]) - + sys1_3 = ctrl.series(sys1, sys2, sys3); np.testing.assert_array_almost_equal(sort(pole(sys1_3)), [-6., -4., -2.]) - np.testing.assert_array_almost_equal(sort(zero(sys1_3)), + np.testing.assert_array_almost_equal(sort(zero(sys1_3)), [-5., -3., -1.]) - + sys1_4 = ctrl.series(sys1, sys2, sys3, sys4); np.testing.assert_array_almost_equal(sort(pole(sys1_4)), [-8., -6., -4., -2.]) np.testing.assert_array_almost_equal(sort(zero(sys1_4)), [-7., -5., -3., -1.]) - + sys1_5 = ctrl.series(sys1, sys2, sys3, sys4, sys5); np.testing.assert_array_almost_equal(sort(pole(sys1_5)), [-8., -6., -4., -2., -0.]) - np.testing.assert_array_almost_equal(sort(zero(sys1_5)), + np.testing.assert_array_almost_equal(sort(zero(sys1_5)), [-9., -7., -5., -3., -1.]) - # Parallel + # Parallel sys1_2 = ctrl.parallel(sys1, sys2) np.testing.assert_array_almost_equal(sort(pole(sys1_2)), [-4., -2.]) np.testing.assert_array_almost_equal(sort(zero(sys1_2)), sort(zero(sys1 + sys2))) - + sys1_3 = ctrl.parallel(sys1, sys2, sys3); np.testing.assert_array_almost_equal(sort(pole(sys1_3)), [-6., -4., -2.]) - np.testing.assert_array_almost_equal(sort(zero(sys1_3)), + np.testing.assert_array_almost_equal(sort(zero(sys1_3)), sort(zero(sys1 + sys2 + sys3))) - + sys1_4 = ctrl.parallel(sys1, sys2, sys3, sys4); np.testing.assert_array_almost_equal(sort(pole(sys1_4)), [-8., -6., -4., -2.]) - np.testing.assert_array_almost_equal(sort(zero(sys1_4)), - sort(zero(sys1 + sys2 + + np.testing.assert_array_almost_equal(sort(zero(sys1_4)), + sort(zero(sys1 + sys2 + sys3 + sys4))) - + sys1_5 = ctrl.parallel(sys1, sys2, sys3, sys4, sys5); np.testing.assert_array_almost_equal(sort(pole(sys1_5)), [-8., -6., -4., -2., -0.]) - np.testing.assert_array_almost_equal(sort(zero(sys1_5)), - sort(zero(sys1 + sys2 + + np.testing.assert_array_almost_equal(sort(zero(sys1_5)), + sort(zero(sys1 + sys2 + sys3 + sys4 + sys5))) def testMimoSeries(self): """regression: bdalg.series reverses order of arguments""" @@ -274,44 +274,54 @@ def test_feedback_args(self): def testConnect(self): sys = append(self.sys2, self.sys3) # two siso systems - + + # should not raise error + connect(sys, [[1, 2], [2, -2]], [2], [1, 2]) + connect(sys, [[1, 2], [2, 0]], [2], [1, 2]) + connect(sys, [[1, 2, 0], [2, -2, 1]], [2], [1, 2]) + connect(sys, [[1, 2], [2, -2]], [2, 1], [1]) + sys3x3 = append(sys, self.sys3) # 3x3 mimo + connect(sys3x3, [[1, 2, 0], [2, -2, 1], [3, -3, 0]], [2], [1, 2]) + connect(sys3x3, [[1, 2, 0], [2, -2, 1], [3, -3, 0]], [1, 2, 3], [3]) + connect(sys3x3, [[1, 2, 0], [2, -2, 1], [3, -3, 0]], [2, 3], [2, 1]) + # feedback interconnection out of bounds: input too high - Q = [[1, 3], [2, -2]] - with self.assertRaises(IndexError) as context: + Q = [[1, 3], [2, -2]] + with self.assertRaises(IndexError): connect(sys, Q, [2], [1, 2]) # feedback interconnection out of bounds: input too low - Q = [[0, 2], [2, -2]] - with self.assertRaises(IndexError) as context: + Q = [[0, 2], [2, -2]] + with self.assertRaises(IndexError): connect(sys, Q, [2], [1, 2]) # feedback interconnection out of bounds: output too high - Q = [[1, 2], [2, -3]] - with self.assertRaises(IndexError) as context: + Q = [[1, 2], [2, -3]] + with self.assertRaises(IndexError): connect(sys, Q, [2], [1, 2]) - Q = [[1, 2], [2, 4]] - with self.assertRaises(IndexError) as context: + Q = [[1, 2], [2, 4]] + with self.assertRaises(IndexError): connect(sys, Q, [2], [1, 2]) - + # input/output index testing Q = [[1, 2], [2, -2]] # OK interconnection - + # input index is out of bounds: too high - with self.assertRaises(IndexError) as context: + with self.assertRaises(IndexError): connect(sys, Q, [3], [1, 2]) # input index is out of bounds: too low - with self.assertRaises(IndexError) as context: + with self.assertRaises(IndexError): connect(sys, Q, [0], [1, 2]) - with self.assertRaises(IndexError) as context: + with self.assertRaises(IndexError): connect(sys, Q, [-2], [1, 2]) # output index is out of bounds: too high - with self.assertRaises(IndexError) as context: + with self.assertRaises(IndexError): connect(sys, Q, [2], [1, 3]) # output index is out of bounds: too low - with self.assertRaises(IndexError) as context: + with self.assertRaises(IndexError): connect(sys, Q, [2], [1, 0]) - with self.assertRaises(IndexError) as context: + with self.assertRaises(IndexError): connect(sys, Q, [2], [1, -1]) - + if __name__ == "__main__": unittest.main() From 120a926f34bc8c990d91c7b2d10a114666f0991d Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Thu, 24 Dec 2020 09:52:37 -0800 Subject: [PATCH 64/67] Documentation update (#476) * fix typos, equation numbering in doc/flatsys.rst * small updates (including numpydoc fixes) to statefbk.py, mateqn.py docstrings * update setup.py contact info * small fixes to iosys docstrings (from samlaf) * update lqr() return type documentation (addresses #418) * added 2D array/matrix note to all functions using _ssmatrix * PEP8 formatting updates for statefbk.py, mateqn.py (while I was at it) --- control/config.py | 7 +- control/iosys.py | 2 +- control/mateqn.py | 348 +++++++++++++++++++++++++++----------------- control/statefbk.py | 301 ++++++++++++++++++++++---------------- doc/flatsys.rst | 11 +- setup.py | 8 +- 6 files changed, 406 insertions(+), 271 deletions(-) diff --git a/control/config.py b/control/config.py index c06d38b6e..21840231b 100644 --- a/control/config.py +++ b/control/config.py @@ -154,6 +154,11 @@ class and functions. If flat is `False`, then matrices are of the Numpy `matrix` class. Set `warn` to false to omit display of the warning message. + Notes + ----- + Prior to release 0.9.x, the default type for 2D arrays is the Numpy + `matrix` class. Starting in release 0.9.0, the default type for state + space operations is a 2D array. """ if flag and warn: warnings.warn("Return type numpy.matrix is soon to be deprecated.", @@ -179,4 +184,4 @@ def use_legacy_defaults(version): third_digit = int(version[4]) use_numpy_matrix(True) # alternatively: set_defaults('statesp', use_numpy_matrix=True) else: - raise ValueError('''version number not recognized. Possible values range from '0.1' to '0.8.4'.''') \ No newline at end of file + raise ValueError('''version number not recognized. Possible values range from '0.1' to '0.8.4'.''') diff --git a/control/iosys.py b/control/iosys.py index 9b5b89bc8..a90b5193c 100644 --- a/control/iosys.py +++ b/control/iosys.py @@ -780,7 +780,7 @@ def __init__(self, syslist, connections=[], inplist=[], outlist=[], The InterconnectedSystem class is used to represent an input/output system that consists of an interconnection between a set of subystems. - The outputs of each subsystem can be summed together to to provide + The outputs of each subsystem can be summed together to provide inputs to other subsystems. The overall system inputs and outputs can be any subset of subsystem inputs and outputs. diff --git a/control/mateqn.py b/control/mateqn.py index 87dd00dab..0b129fd9e 100644 --- a/control/mateqn.py +++ b/control/mateqn.py @@ -1,45 +1,42 @@ -""" mateqn.py - -Matrix equation solvers (Lyapunov, Riccati) - -Implementation of the functions lyap, dlyap, care and dare -for solution of Lyapunov and Riccati equations. """ +# mateqn.py - Matrix equation solvers (Lyapunov, Riccati) +# +# Implementation of the functions lyap, dlyap, care and dare +# for solution of Lyapunov and Riccati equations. +# +# Author: Bjorn Olofsson # Python 3 compatibility (needs to go here) from __future__ import print_function -"""Copyright (c) 2011, All rights reserved. +# Copyright (c) 2011, All rights reserved. -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions -are met: +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: -1. Redistributions of source code must retain the above copyright - notice, this list of conditions and the following disclaimer. +# 1. Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. -2. Redistributions in binary form must reproduce the above copyright - notice, this list of conditions and the following disclaimer in the - documentation and/or other materials provided with the distribution. +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. -3. Neither the name of the project author nor the names of its - contributors may be used to endorse or promote products derived - from this software without specific prior written permission. +# 3. Neither the name of the project author nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS -FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL CALTECH -OR THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF -USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND -ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT -OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF -SUCH DAMAGE. - -Author: Bjorn Olofsson -""" +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL CALTECH +# OR THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF +# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND +# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT +# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +# SUCH DAMAGE. from numpy import shape, size, asarray, copy, zeros, eye, dot, \ finfo, inexact, atleast_2d @@ -49,7 +46,10 @@ __all__ = ['lyap', 'dlyap', 'dare', 'care'] -#### Lyapunov equation solvers lyap and dlyap +# +# Lyapunov equation solvers lyap and dlyap +# + def lyap(A, Q, C=None, E=None): """X = lyap(A, Q) solves the continuous-time Lyapunov equation @@ -59,13 +59,13 @@ def lyap(A, Q, C=None, E=None): where A and Q are square matrices of the same dimension. Further, Q must be symmetric. - X = lyap(A,Q,C) solves the Sylvester equation + X = lyap(A, Q, C) solves the Sylvester equation :math:`A X + X Q + C = 0` where A and Q are square matrices. - X = lyap(A,Q,None,E) solves the generalized continuous-time + X = lyap(A, Q, None, E) solves the generalized continuous-time Lyapunov equation :math:`A X E^T + E X A^T + Q = 0` @@ -73,6 +73,24 @@ def lyap(A, Q, C=None, E=None): where Q is a symmetric matrix and A, Q and E are square matrices of the same dimension. + Parameters + ---------- + A : 2D array + Dynamics matrix + C : 2D array, optional + If present, solve the Slyvester equation + E : 2D array, optional + If present, solve the generalized Laypunov equation + + Returns + ------- + Q : 2D array (or matrix) + Solution to the Lyapunov or Sylvester equation + + Notes + ----- + The return type for 2D arrays depends on the default class set for + state space operations. See :func:`~control.use_numpy_matrix`. """ # Make sure we have access to the right slycot routines @@ -128,7 +146,8 @@ def lyap(A, Q, C=None, E=None): # Solve the Lyapunov equation by calling Slycot function sb03md try: - X,scale,sep,ferr,w = sb03md(n,-Q,A,eye(n,n),'C',trana='T') + X, scale, sep, ferr, w = \ + sb03md(n, -Q, A, eye(n, n), 'C', trana='T') except ValueError as ve: if ve.info < 0: e = ValueError(ve.message) @@ -153,13 +172,14 @@ def lyap(A, Q, C=None, E=None): raise ControlArgument("Q must be a quadratic matrix.") if (size(C) > 1 and shape(C)[0] != n) or \ - (size(C) > 1 and shape(C)[1] != m) or \ - (size(C) == 1 and size(A) != 1) or (size(C) == 1 and size(Q) != 1): + (size(C) > 1 and shape(C)[1] != m) or \ + (size(C) == 1 and size(A) != 1) or \ + (size(C) == 1 and size(Q) != 1): raise ControlArgument("C matrix has incompatible dimensions.") # Solve the Sylvester equation by calling the Slycot function sb04md try: - X = sb04md(n,m,A,Q,-C) + X = sb04md(n, m, A, Q, -C) except ValueError as ve: if ve.info < 0: e = ValueError(ve.message) @@ -178,14 +198,14 @@ def lyap(A, Q, C=None, E=None): elif C is None and E is not None: # Check input data for consistency if (size(Q) > 1 and shape(Q)[0] != shape(Q)[1]) or \ - (size(Q) > 1 and shape(Q)[0] != n) or \ - (size(Q) == 1 and n > 1): + (size(Q) > 1 and shape(Q)[0] != n) or \ + (size(Q) == 1 and n > 1): raise ControlArgument("Q must be a square matrix with the same \ dimension as A.") if (size(E) > 1 and shape(E)[0] != shape(E)[1]) or \ - (size(E) > 1 and shape(E)[0] != n) or \ - (size(E) == 1 and n > 1): + (size(E) > 1 and shape(E)[0] != n) or \ + (size(E) == 1 and n > 1): raise ControlArgument("E must be a square matrix with the same \ dimension as A.") @@ -201,8 +221,9 @@ def lyap(A, Q, C=None, E=None): # Solve the generalized Lyapunov equation by calling Slycot # function sg03ad try: - A,E,Q,Z,X,scale,sep,ferr,alphar,alphai,beta = \ - sg03ad('C','B','N','T','L',n,A,E,eye(n,n),eye(n,n),-Q) + A, E, Q, Z, X, scale, sep, ferr, alphar, alphai, beta = \ + sg03ad('C', 'B', 'N', 'T', 'L', n, + A, E, eye(n, n), eye(n, n), -Q) except ValueError as ve: if ve.info < 0 or ve.info > 4: e = ValueError(ve.message) @@ -235,7 +256,7 @@ def lyap(A, Q, C=None, E=None): return _ssmatrix(X) -def dlyap(A,Q,C=None,E=None): +def dlyap(A, Q, C=None, E=None): """ dlyap(A,Q) solves the discrete-time Lyapunov equation :math:`A X A^T - X + Q = 0` @@ -275,27 +296,27 @@ def dlyap(A,Q,C=None,E=None): # Reshape 1-d arrays if len(shape(A)) == 1: - A = A.reshape(1,A.size) + A = A.reshape(1, A.size) if len(shape(Q)) == 1: - Q = Q.reshape(1,Q.size) + Q = Q.reshape(1, Q.size) if C is not None and len(shape(C)) == 1: - C = C.reshape(1,C.size) + C = C.reshape(1, C.size) if E is not None and len(shape(E)) == 1: - E = E.reshape(1,E.size) + E = E.reshape(1, E.size) # Determine main dimensions if size(A) == 1: n = 1 else: - n = size(A,0) + n = size(A, 0) if size(Q) == 1: m = 1 else: - m = size(Q,0) + m = size(Q, 0) # Solve standard Lyapunov equation if C is None and E is None: @@ -315,7 +336,8 @@ def dlyap(A,Q,C=None,E=None): # Solve the Lyapunov equation by calling the Slycot function sb03md try: - X,scale,sep,ferr,w = sb03md(n,-Q,A,eye(n,n),'D',trana='T') + X, scale, sep, ferr, w = \ + sb03md(n, -Q, A, eye(n, n), 'D', trana='T') except ValueError as ve: if ve.info < 0: e = ValueError(ve.message) @@ -336,13 +358,13 @@ def dlyap(A,Q,C=None,E=None): raise ControlArgument("Q must be a quadratic matrix") if (size(C) > 1 and shape(C)[0] != n) or \ - (size(C) > 1 and shape(C)[1] != m) or \ - (size(C) == 1 and size(A) != 1) or (size(C) == 1 and size(Q) != 1): + (size(C) > 1 and shape(C)[1] != m) or \ + (size(C) == 1 and size(A) != 1) or (size(C) == 1 and size(Q) != 1): raise ControlArgument("C matrix has incompatible dimensions") # Solve the Sylvester equation by calling Slycot function sb04qd try: - X = sb04qd(n,m,-A,asarray(Q).T,C) + X = sb04qd(n, m, -A, asarray(Q).T, C) except ValueError as ve: if ve.info < 0: e = ValueError(ve.message) @@ -361,14 +383,14 @@ def dlyap(A,Q,C=None,E=None): elif C is None and E is not None: # Check input data for consistency if (size(Q) > 1 and shape(Q)[0] != shape(Q)[1]) or \ - (size(Q) > 1 and shape(Q)[0] != n) or \ - (size(Q) == 1 and n > 1): + (size(Q) > 1 and shape(Q)[0] != n) or \ + (size(Q) == 1 and n > 1): raise ControlArgument("Q must be a square matrix with the same \ dimension as A.") if (size(E) > 1 and shape(E)[0] != shape(E)[1]) or \ - (size(E) > 1 and shape(E)[0] != n) or \ - (size(E) == 1 and n > 1): + (size(E) > 1 and shape(E)[0] != n) or \ + (size(E) == 1 and n > 1): raise ControlArgument("E must be a square matrix with the same \ dimension as A.") @@ -378,8 +400,9 @@ def dlyap(A,Q,C=None,E=None): # Solve the generalized Lyapunov equation by calling Slycot # function sg03ad try: - A,E,Q,Z,X,scale,sep,ferr,alphar,alphai,beta = \ - sg03ad('D','B','N','T','L',n,A,E,eye(n,n),eye(n,n),-Q) + A, E, Q, Z, X, scale, sep, ferr, alphar, alphai, beta = \ + sg03ad('D', 'B', 'N', 'T', 'L', n, + A, E, eye(n, n), eye(n, n), -Q) except ValueError as ve: if ve.info < 0 or ve.info > 4: e = ValueError(ve.message) @@ -412,10 +435,14 @@ def dlyap(A,Q,C=None,E=None): return _ssmatrix(X) -#### Riccati equation solvers care and dare +# +# Riccati equation solvers care and dare +# + + def care(A, B, Q, R=None, S=None, E=None, stabilizing=True): - """ (X,L,G) = care(A,B,Q,R=None) solves the continuous-time algebraic Riccati - equation + """(X, L, G) = care(A, B, Q, R=None) solves the continuous-time + algebraic Riccati equation :math:`A^T X + X A - X B R^{-1} B^T X + Q = 0` @@ -425,16 +452,39 @@ def care(A, B, Q, R=None, S=None, E=None, stabilizing=True): matrix G = B^T X and the closed loop eigenvalues L, i.e., the eigenvalues of A - B G. - (X,L,G) = care(A,B,Q,R,S,E) solves the generalized continuous-time - algebraic Riccati equation + (X, L, G) = care(A, B, Q, R, S, E) solves the generalized + continuous-time algebraic Riccati equation :math:`A^T X E + E^T X A - (E^T X B + S) R^{-1} (B^T X E + S^T) + Q = 0` - where A, Q and E are square matrices of the same - dimension. Further, Q and R are symmetric matrices. If R is None, - it is set to the identity matrix. The function returns the - solution X, the gain matrix G = R^-1 (B^T X E + S^T) and the - closed loop eigenvalues L, i.e., the eigenvalues of A - B G , E.""" + where A, Q and E are square matrices of the same dimension. Further, Q + and R are symmetric matrices. If R is None, it is set to the identity + matrix. The function returns the solution X, the gain matrix G = R^-1 + (B^T X E + S^T) and the closed loop eigenvalues L, i.e., the eigenvalues + of A - B G , E. + + Parameters + ---------- + A, B, Q : 2D arrays + Input matrices for the Riccati equation + R, S, E : 2D arrays, optional + Input matrices for generalized Riccati equation + + Returns + ------- + X : 2D array (or matrix) + Solution to the Ricatti equation + L : 1D array + Closed loop eigenvalues + G : 2D array (or matrix) + Gain matrix + + Notes + ----- + The return type for 2D arrays depends on the default class set for + state space operations. See :func:`~control.use_numpy_matrix`. + + """ # Make sure we can import required slycot routine try: @@ -455,35 +505,35 @@ def care(A, B, Q, R=None, S=None, E=None, stabilizing=True): # Reshape 1-d arrays if len(shape(A)) == 1: - A = A.reshape(1,A.size) + A = A.reshape(1, A.size) if len(shape(B)) == 1: - B = B.reshape(1,B.size) + B = B.reshape(1, B.size) if len(shape(Q)) == 1: - Q = Q.reshape(1,Q.size) + Q = Q.reshape(1, Q.size) if R is not None and len(shape(R)) == 1: - R = R.reshape(1,R.size) + R = R.reshape(1, R.size) if S is not None and len(shape(S)) == 1: - S = S.reshape(1,S.size) + S = S.reshape(1, S.size) if E is not None and len(shape(E)) == 1: - E = E.reshape(1,E.size) + E = E.reshape(1, E.size) # Determine main dimensions if size(A) == 1: n = 1 else: - n = size(A,0) + n = size(A, 0) if size(B) == 1: m = 1 else: - m = size(B,1) + m = size(B, 1) if R is None: - R = eye(m,m) + R = eye(m, m) # Solve the standard algebraic Riccati equation if S is None and E is None: @@ -492,13 +542,13 @@ def care(A, B, Q, R=None, S=None, E=None, stabilizing=True): raise ControlArgument("A must be a quadratic matrix.") if (size(Q) > 1 and shape(Q)[0] != shape(Q)[1]) or \ - (size(Q) > 1 and shape(Q)[0] != n) or \ - size(Q) == 1 and n > 1: + (size(Q) > 1 and shape(Q)[0] != n) or \ + size(Q) == 1 and n > 1: raise ControlArgument("Q must be a quadratic matrix of the same \ dimension as A.") if (size(B) > 1 and shape(B)[0] != n) or \ - size(B) == 1 and n > 1: + size(B) == 1 and n > 1: raise ControlArgument("Incompatible dimensions of B matrix.") if not _is_symmetric(Q): @@ -514,7 +564,7 @@ def care(A, B, Q, R=None, S=None, E=None, stabilizing=True): # Solve the standard algebraic Riccati equation by calling Slycot # functions sb02mt and sb02md try: - A_b,B_b,Q_b,R_b,L_b,ipiv,oufact,G = sb02mt(n,m,B,R) + A_b, B_b, Q_b, R_b, L_b, ipiv, oufact, G = sb02mt(n, m, B, R) except ValueError as ve: if ve.info < 0: e = ValueError(ve.message) @@ -568,7 +618,7 @@ def care(A, B, Q, R=None, S=None, E=None, stabilizing=True): # Return the solution X, the closed-loop eigenvalues L and # the gain matrix G - return (_ssmatrix(X) , w[:n] , _ssmatrix(G)) + return (_ssmatrix(X), w[:n], _ssmatrix(G)) # Solve the generalized algebraic Riccati equation elif S is not None and E is not None: @@ -577,31 +627,31 @@ def care(A, B, Q, R=None, S=None, E=None, stabilizing=True): raise ControlArgument("A must be a quadratic matrix.") if (size(Q) > 1 and shape(Q)[0] != shape(Q)[1]) or \ - (size(Q) > 1 and shape(Q)[0] != n) or \ - size(Q) == 1 and n > 1: + (size(Q) > 1 and shape(Q)[0] != n) or \ + size(Q) == 1 and n > 1: raise ControlArgument("Q must be a quadratic matrix of the same \ dimension as A.") if (size(B) > 1 and shape(B)[0] != n) or \ - size(B) == 1 and n > 1: + size(B) == 1 and n > 1: raise ControlArgument("Incompatible dimensions of B matrix.") if (size(E) > 1 and shape(E)[0] != shape(E)[1]) or \ - (size(E) > 1 and shape(E)[0] != n) or \ - size(E) == 1 and n > 1: + (size(E) > 1 and shape(E)[0] != n) or \ + size(E) == 1 and n > 1: raise ControlArgument("E must be a quadratic matrix of the same \ dimension as A.") if (size(R) > 1 and shape(R)[0] != shape(R)[1]) or \ - (size(R) > 1 and shape(R)[0] != m) or \ - size(R) == 1 and m > 1: + (size(R) > 1 and shape(R)[0] != m) or \ + size(R) == 1 and m > 1: raise ControlArgument("R must be a quadratic matrix of the same \ dimension as the number of columns in the B matrix.") if (size(S) > 1 and shape(S)[0] != n) or \ - (size(S) > 1 and shape(S)[1] != m) or \ - size(S) == 1 and n > 1 or \ - size(S) == 1 and m > 1: + (size(S) > 1 and shape(S)[1] != m) or \ + size(S) == 1 and n > 1 or \ + size(S) == 1 and m > 1: raise ControlArgument("Incompatible dimensions of S matrix.") if not _is_symmetric(Q): @@ -624,7 +674,8 @@ def care(A, B, Q, R=None, S=None, E=None, stabilizing=True): else: sort = 'U' rcondu, X, alfar, alfai, beta, S_o, T, U, iwarn = \ - sg02ad('C', 'B', 'N', 'U', 'N', 'N', sort, 'R', n, m, 0, A, E, B, Q, R, S) + sg02ad('C', 'B', 'N', 'U', 'N', 'N', sort, + 'R', n, m, 0, A, E, B, Q, R, S) except ValueError as ve: if ve.info < 0 or ve.info > 7: e = ValueError(ve.message) @@ -662,14 +713,14 @@ def care(A, B, Q, R=None, S=None, E=None, stabilizing=True): raise e # Calculate the closed-loop eigenvalues L - L = zeros((n,1)) + L = zeros((n, 1)) L.dtype = 'complex64' for i in range(n): L[i] = (alfar[i] + alfai[i]*1j)/beta[i] # Calculate the gain matrix G if size(R_b) == 1: - G = dot(1/(R_b), dot(asarray(B_b).T, dot(X,E_b)) + asarray(S_b).T) + G = dot(1/(R_b), dot(asarray(B_b).T, dot(X, E_b)) + asarray(S_b).T) else: G = solve(R_b, dot(asarray(B_b).T, dot(X, E_b)) + asarray(S_b).T) @@ -681,8 +732,9 @@ def care(A, B, Q, R=None, S=None, E=None, stabilizing=True): else: raise ControlArgument("Invalid set of input parameters.") + def dare(A, B, Q, R, S=None, E=None, stabilizing=True): - """ (X,L,G) = dare(A,B,Q,R) solves the discrete-time algebraic Riccati + """(X, L, G) = dare(A, B, Q, R) solves the discrete-time algebraic Riccati equation :math:`A^T X A - X - A^T X B (B^T X B + R)^{-1} B^T X A + Q = 0` @@ -692,8 +744,8 @@ def dare(A, B, Q, R, S=None, E=None, stabilizing=True): matrix G = (B^T X B + R)^-1 B^T X A and the closed loop eigenvalues L, i.e., the eigenvalues of A - B G. - (X,L,G) = dare(A,B,Q,R,S,E) solves the generalized discrete-time algebraic - Riccati equation + (X, L, G) = dare(A, B, Q, R, S, E) solves the generalized discrete-time + algebraic Riccati equation :math:`A^T X A - E^T X E - (A^T X B + S) (B^T X B + R)^{-1} (B^T X A + S^T) + Q = 0` @@ -701,6 +753,28 @@ def dare(A, B, Q, R, S=None, E=None, stabilizing=True): R are symmetric matrices. The function returns the solution X, the gain matrix :math:`G = (B^T X B + R)^{-1} (B^T X A + S^T)` and the closed loop eigenvalues L, i.e., the eigenvalues of A - B G , E. + + Parameters + ---------- + A, B, Q : 2D arrays + Input matrices for the Riccati equation + R, S, E : 2D arrays, optional + Input matrices for generalized Riccati equation + + Returns + ------- + X : 2D array (or matrix) + Solution to the Ricatti equation + L : 1D array + Closed loop eigenvalues + G : 2D array (or matrix) + Gain matrix + + Notes + ----- + The return type for 2D arrays depends on the default class set for + state space operations. See :func:`~control.use_numpy_matrix`. + """ if S is not None or E is not None or not stabilizing: return dare_old(A, B, Q, R, S, E, stabilizing) @@ -712,6 +786,7 @@ def dare(A, B, Q, R, S=None, E=None, stabilizing=True): L = eigvals(A - B.dot(G)) return _ssmatrix(X), L, _ssmatrix(G) + def dare_old(A, B, Q, R, S=None, E=None, stabilizing=True): # Make sure we can import required slycot routine try: @@ -732,33 +807,33 @@ def dare_old(A, B, Q, R, S=None, E=None, stabilizing=True): # Reshape 1-d arrays if len(shape(A)) == 1: - A = A.reshape(1,A.size) + A = A.reshape(1, A.size) if len(shape(B)) == 1: - B = B.reshape(1,B.size) + B = B.reshape(1, B.size) if len(shape(Q)) == 1: - Q = Q.reshape(1,Q.size) + Q = Q.reshape(1, Q.size) if R is not None and len(shape(R)) == 1: - R = R.reshape(1,R.size) + R = R.reshape(1, R.size) if S is not None and len(shape(S)) == 1: - S = S.reshape(1,S.size) + S = S.reshape(1, S.size) if E is not None and len(shape(E)) == 1: - E = E.reshape(1,E.size) + E = E.reshape(1, E.size) # Determine main dimensions if size(A) == 1: n = 1 else: - n = size(A,0) + n = size(A, 0) if size(B) == 1: m = 1 else: - m = size(B,1) + m = size(B, 1) # Solve the standard algebraic Riccati equation if S is None and E is None: @@ -767,13 +842,13 @@ def dare_old(A, B, Q, R, S=None, E=None, stabilizing=True): raise ControlArgument("A must be a quadratic matrix.") if (size(Q) > 1 and shape(Q)[0] != shape(Q)[1]) or \ - (size(Q) > 1 and shape(Q)[0] != n) or \ - size(Q) == 1 and n > 1: + (size(Q) > 1 and shape(Q)[0] != n) or \ + size(Q) == 1 and n > 1: raise ControlArgument("Q must be a quadratic matrix of the same \ dimension as A.") if (size(B) > 1 and shape(B)[0] != n) or \ - size(B) == 1 and n > 1: + size(B) == 1 and n > 1: raise ControlArgument("Incompatible dimensions of B matrix.") if not _is_symmetric(Q): @@ -790,7 +865,7 @@ def dare_old(A, B, Q, R, S=None, E=None, stabilizing=True): # Solve the standard algebraic Riccati equation by calling Slycot # functions sb02mt and sb02md try: - A_b,B_b,Q_b,R_b,L_b,ipiv,oufact,G = sb02mt(n,m,B,R) + A_b, B_b, Q_b, R_b, L_b, ipiv, oufact, G = sb02mt(n, m, B, R) except ValueError as ve: if ve.info < 0: e = ValueError(ve.message) @@ -839,15 +914,15 @@ def dare_old(A, B, Q, R, S=None, E=None, stabilizing=True): # Calculate the gain matrix G if size(R_b) == 1: - G = dot(1/(dot(asarray(B_ba).T, dot(X, B_ba)) + R_ba), \ - dot(asarray(B_ba).T, dot(X, A_ba))) + G = dot(1/(dot(asarray(B_ba).T, dot(X, B_ba)) + R_ba), + dot(asarray(B_ba).T, dot(X, A_ba))) else: - G = solve(dot(asarray(B_ba).T, dot(X, B_ba)) + R_ba, \ - dot(asarray(B_ba).T, dot(X, A_ba))) + G = solve(dot(asarray(B_ba).T, dot(X, B_ba)) + R_ba, + dot(asarray(B_ba).T, dot(X, A_ba))) # Return the solution X, the closed-loop eigenvalues L and # the gain matrix G - return (_ssmatrix(X) , w[:n], _ssmatrix(G)) + return (_ssmatrix(X), w[:n], _ssmatrix(G)) # Solve the generalized algebraic Riccati equation elif S is not None and E is not None: @@ -856,31 +931,31 @@ def dare_old(A, B, Q, R, S=None, E=None, stabilizing=True): raise ControlArgument("A must be a quadratic matrix.") if (size(Q) > 1 and shape(Q)[0] != shape(Q)[1]) or \ - (size(Q) > 1 and shape(Q)[0] != n) or \ - size(Q) == 1 and n > 1: + (size(Q) > 1 and shape(Q)[0] != n) or \ + size(Q) == 1 and n > 1: raise ControlArgument("Q must be a quadratic matrix of the same \ dimension as A.") if (size(B) > 1 and shape(B)[0] != n) or \ - size(B) == 1 and n > 1: + size(B) == 1 and n > 1: raise ControlArgument("Incompatible dimensions of B matrix.") if (size(E) > 1 and shape(E)[0] != shape(E)[1]) or \ - (size(E) > 1 and shape(E)[0] != n) or \ - size(E) == 1 and n > 1: + (size(E) > 1 and shape(E)[0] != n) or \ + size(E) == 1 and n > 1: raise ControlArgument("E must be a quadratic matrix of the same \ dimension as A.") if (size(R) > 1 and shape(R)[0] != shape(R)[1]) or \ - (size(R) > 1 and shape(R)[0] != m) or \ - size(R) == 1 and m > 1: + (size(R) > 1 and shape(R)[0] != m) or \ + size(R) == 1 and m > 1: raise ControlArgument("R must be a quadratic matrix of the same \ dimension as the number of columns in the B matrix.") if (size(S) > 1 and shape(S)[0] != n) or \ - (size(S) > 1 and shape(S)[1] != m) or \ - size(S) == 1 and n > 1 or \ - size(S) == 1 and m > 1: + (size(S) > 1 and shape(S)[1] != m) or \ + size(S) == 1 and n > 1 or \ + size(S) == 1 and m > 1: raise ControlArgument("Incompatible dimensions of S matrix.") if not _is_symmetric(Q): @@ -904,7 +979,8 @@ def dare_old(A, B, Q, R, S=None, E=None, stabilizing=True): else: sort = 'U' rcondu, X, alfar, alfai, beta, S_o, T, U, iwarn = \ - sg02ad('D', 'B', 'N', 'U', 'N', 'N', sort, 'R', n, m, 0, A, E, B, Q, R, S) + sg02ad('D', 'B', 'N', 'U', 'N', 'N', sort, + 'R', n, m, 0, A, E, B, Q, R, S) except ValueError as ve: if ve.info < 0 or ve.info > 7: e = ValueError(ve.message) @@ -941,18 +1017,18 @@ def dare_old(A, B, Q, R, S=None, E=None, stabilizing=True): e.info = ve.info raise e - L = zeros((n,1)) + L = zeros((n, 1)) L.dtype = 'complex64' for i in range(n): L[i] = (alfar[i] + alfai[i]*1j)/beta[i] # Calculate the gain matrix G if size(R_b) == 1: - G = dot(1/(dot(asarray(B_b).T, dot(X,B_b)) + R_b), \ - dot(asarray(B_b).T, dot(X,A_b)) + asarray(S_b).T) + G = dot(1/(dot(asarray(B_b).T, dot(X, B_b)) + R_b), + dot(asarray(B_b).T, dot(X, A_b)) + asarray(S_b).T) else: - G = solve(dot(asarray(B_b).T, dot(X,B_b)) + R_b, \ - dot(asarray(B_b).T, dot(X,A_b)) + asarray(S_b).T) + G = solve(dot(asarray(B_b).T, dot(X, B_b)) + R_b, + dot(asarray(B_b).T, dot(X, A_b)) + asarray(S_b).T) # Return the solution X, the closed-loop eigenvalues L and # the gain matrix G diff --git a/control/statefbk.py b/control/statefbk.py index c9e01a52f..d07410bfa 100644 --- a/control/statefbk.py +++ b/control/statefbk.py @@ -47,7 +47,8 @@ from .statesp import _ssmatrix from .exception import ControlSlycot, ControlArgument, ControlDimension -__all__ = ['ctrb', 'obsv', 'gram', 'place', 'place_varga', 'lqr', 'lqe', 'acker'] +__all__ = ['ctrb', 'obsv', 'gram', 'place', 'place_varga', 'lqr', 'lqe', + 'acker'] # Pole placement @@ -58,19 +59,18 @@ def place(A, B, p): Parameters ---------- - A : 2-d array + A : 2D array Dynamics matrix - B : 2-d array + B : 2D array Input matrix - p : 1-d list + p : 1D list Desired eigenvalue locations Returns ------- - K : 2-d array + K : 2D array (or matrix) Gain such that A - B K has eigenvalues given in p - Notes ----- Algorithm @@ -83,6 +83,9 @@ def place(A, B, p): The algorithm will not place poles at the same location more than rank(B) times. + The return type for 2D arrays depends on the default class set for + state space operations. See :func:`~control.use_numpy_matrix`. + References ---------- .. [1] A.L. Tits and Y. Yang, "Globally convergent algorithms for robust @@ -98,6 +101,11 @@ def place(A, B, p): See Also -------- place_varga, acker + + Notes + ----- + The return type for 2D arrays depends on the default class set for + state space operations. See :func:`~control.use_numpy_matrix`. """ from scipy.signal import place_poles @@ -125,42 +133,47 @@ def place_varga(A, B, p, dtime=False, alpha=None): Required Parameters ---------- - A : 2-d array + A : 2D array Dynamics matrix - B : 2-d array + B : 2D array Input matrix - p : 1-d list + p : 1D list Desired eigenvalue locations Optional Parameters --------------- - dtime: False for continuous time pole placement or True for discrete time. - The default is dtime=False. - alpha: double scalar - If DICO='C', then place_varga will leave the eigenvalues with real - real part less than alpha untouched. - If DICO='D', the place_varga will leave eigenvalues with modulus - less than alpha untouched. + dtime : bool + False for continuous time pole placement or True for discrete time. + The default is dtime=False. + + alpha : double scalar + If `dtime` is false then place_varga will leave the eigenvalues with + real part less than alpha untouched. If `dtime` is true then + place_varga will leave eigenvalues with modulus less than alpha + untouched. - By default (alpha=None), place_varga computes alpha such that all - poles will be placed. + By default (alpha=None), place_varga computes alpha such that all + poles will be placed. Returns ------- - K : 2D array + K : 2D array (or matrix) Gain such that A - B K has eigenvalues given in p. - Algorithm --------- - This function is a wrapper for the slycot function sb01bd, which - implements the pole placement algorithm of Varga [1]. In contrast to - the algorithm used by place(), the Varga algorithm can place - multiple poles at the same location. The placement, however, may not - be as robust. + This function is a wrapper for the slycot function sb01bd, which + implements the pole placement algorithm of Varga [1]. In contrast to the + algorithm used by place(), the Varga algorithm can place multiple poles at + the same location. The placement, however, may not be as robust. + + [1] Varga A. "A Schur method for pole assignment." IEEE Trans. Automatic + Control, Vol. AC-26, pp. 517-519, 1981. - [1] Varga A. "A Schur method for pole assignment." - IEEE Trans. Automatic Control, Vol. AC-26, pp. 517-519, 1981. + Notes + ----- + The return type for 2D arrays depends on the default class set for + state space operations. See :func:`~control.use_numpy_matrix`. Examples -------- @@ -171,6 +184,7 @@ def place_varga(A, B, p, dtime=False, alpha=None): See Also: -------- place, acker + """ # Make sure that SLICOT is installed @@ -182,8 +196,7 @@ def place_varga(A, B, p, dtime=False, alpha=None): # Convert the system inputs to NumPy arrays A_mat = np.array(A) B_mat = np.array(B) - if (A_mat.shape[0] != A_mat.shape[1] or - A_mat.shape[0] != B_mat.shape[0]): + if (A_mat.shape[0] != A_mat.shape[1] or A_mat.shape[0] != B_mat.shape[0]): raise ControlDimension("matrix dimensions are incorrect") # Compute the system eigenvalues and convert poles to numpy array @@ -213,17 +226,17 @@ def place_varga(A, B, p, dtime=False, alpha=None): # but does the trick alpha = -2*abs(min(system_eigs.real)) elif dtime and alpha < 0.0: - raise ValueError("Need alpha > 0 when DICO='D'") - + raise ValueError("Discrete time systems require alpha > 0") # Call SLICOT routine to place the eigenvalues - A_z,w,nfp,nap,nup,F,Z = \ + A_z, w, nfp, nap, nup, F, Z = \ sb01bd(B_mat.shape[0], B_mat.shape[1], len(placed_eigs), alpha, A_mat, B_mat, placed_eigs, DICO) # Return the gain matrix, with MATLAB gain convention return _ssmatrix(-F) + # contributed by Sawyer B. Fuller def lqe(A, G, C, QN, RN, NN=None): """lqe(A, G, C, QN, RN, [, N]) @@ -245,33 +258,42 @@ def lqe(A, G, C, QN, RN, NN=None): .. math:: x_e = A x_e + B u + L(y - C x_e - D u) - produces a state estimate that x_e that minimizes the expected squared error - using the sensor measurements y. The noise cross-correlation `NN` is set to - zero when omitted. + produces a state estimate that x_e that minimizes the expected squared + error using the sensor measurements y. The noise cross-correlation `NN` + is set to zero when omitted. Parameters ---------- - A, G: 2-d array + A, G : 2D array Dynamics and noise input matrices - QN, RN: 2-d array + QN, RN : 2D array Process and sensor noise covariance matrices - NN: 2-d array, optional + NN : 2D array, optional Cross covariance matrix Returns ------- - L: 2D array + L : 2D array (or matrix) Kalman estimator gain - P: 2D array + P : 2D array (or matrix) Solution to Riccati equation .. math:: A P + P A^T - (P C^T + G N) R^{-1} (C P + N^T G^T) + G Q G^T = 0 - E: 1D array + E : 2D array (or matrix) Eigenvalues of estimator poles eig(A - L C) + Notes + ----- + The return type for 2D arrays depends on the default class set for + state space operations. See :func:`~control.use_numpy_matrix`. + + The return type for `E` differs from the equivalent return values in the + :func:`~control.lqr`, :func:`~control.care`, and other similar + functions. The return type will be changed to a 1D array in a future + release. Examples -------- @@ -281,18 +303,19 @@ def lqe(A, G, C, QN, RN, NN=None): See Also -------- lqr + """ # TODO: incorporate cross-covariance NN, something like this, # which doesn't work for some reason - #if NN is None: + # if NN is None: # NN = np.zeros(QN.size(0),RN.size(1)) - #NG = G @ NN + # NG = G @ NN - #LT, P, E = lqr(A.T, C.T, G @ QN @ G.T, RN) - #P, E, LT = care(A.T, C.T, G @ QN @ G.T, RN) + # LT, P, E = lqr(A.T, C.T, G @ QN @ G.T, RN) + # P, E, LT = care(A.T, C.T, G @ QN @ G.T, RN) A, G, C = np.array(A, ndmin=2), np.array(G, ndmin=2), np.array(C, ndmin=2) - QN, RN = np.array(QN, ndmin=2), np.array(RN, ndmin=2) + QN, RN = np.array(QN, ndmin=2), np.array(RN, ndmin=2) P, E, LT = care(A.T, C.T, np.dot(np.dot(G, QN), G.T), RN) return _ssmatrix(LT.T), _ssmatrix(P), _ssmatrix(E) @@ -306,16 +329,20 @@ def acker(A, B, poles): Parameters ---------- - A, B : 2-d arrays + A, B : 2D arrays State and input matrix of the system - poles: 1-d list + poles : 1D list Desired eigenvalue locations Returns ------- - K: matrix + K : 2D array (or matrix) Gains such that A - B K has given eigenvalues + Notes + ----- + The return type for 2D arrays depends on the default class set for + state space operations. See :func:`~control.use_numpy_matrix`. """ # Convert the inputs to matrices a = _ssmatrix(A) @@ -333,13 +360,14 @@ def acker(A, B, poles): # TODO: compute pmat using Horner's method (O(n) instead of O(n^2)) n = np.size(p) pmat = p[n-1] * np.linalg.matrix_power(a, 0) - for i in np.arange(1,n): + for i in np.arange(1, n): pmat = pmat + np.dot(p[n-i-1], np.linalg.matrix_power(a, i)) K = np.linalg.solve(ct, pmat) K = K[-1][:] # Extract the last row return _ssmatrix(K) + def lqr(*args, **keywords): """lqr(A, B, Q, R[, N]) @@ -362,33 +390,37 @@ def lqr(*args, **keywords): Parameters ---------- - A, B: 2-d array + A, B : 2D array Dynamics and input matrices - sys: LTI (StateSpace or TransferFunction) + sys : LTI (StateSpace or TransferFunction) Linear I/O system - Q, R: 2-d array + Q, R : 2D array State and input weight matrices - N: 2-d array, optional + N : 2D array, optional Cross weight matrix Returns ------- - K: 2D array + K : 2D array (or matrix) State feedback gains - S: 2D array + S : 2D array (or matrix) Solution to Riccati equation - E: 1D array + E : 1D array Eigenvalues of the closed loop system - Examples - -------- - >>> K, S, E = lqr(sys, Q, R, [N]) - >>> K, S, E = lqr(A, B, Q, R, [N]) - See Also -------- lqe + Notes + ----- + The return type for 2D arrays depends on the default class set for + state space operations. See :func:`~control.use_numpy_matrix`. + + Examples + -------- + >>> K, S, E = lqr(sys, Q, R, [N]) + >>> K, S, E = lqr(A, B, Q, R, [N]) """ # Make sure that SLICOT is installed @@ -409,26 +441,26 @@ def lqr(*args, **keywords): try: # If this works, we were (probably) passed a system as the # first argument; extract A and B - A = np.array(args[0].A, ndmin=2, dtype=float); - B = np.array(args[0].B, ndmin=2, dtype=float); - index = 1; + A = np.array(args[0].A, ndmin=2, dtype=float) + B = np.array(args[0].B, ndmin=2, dtype=float) + index = 1 except AttributeError: # Arguments should be A and B matrices - A = np.array(args[0], ndmin=2, dtype=float); - B = np.array(args[1], ndmin=2, dtype=float); - index = 2; + A = np.array(args[0], ndmin=2, dtype=float) + B = np.array(args[1], ndmin=2, dtype=float) + index = 2 # Get the weighting matrices (converting to matrices, if needed) - Q = np.array(args[index], ndmin=2, dtype=float); - R = np.array(args[index+1], ndmin=2, dtype=float); + Q = np.array(args[index], ndmin=2, dtype=float) + R = np.array(args[index+1], ndmin=2, dtype=float) if (len(args) > index + 2): - N = np.array(args[index+2], ndmin=2, dtype=float); + N = np.array(args[index+2], ndmin=2, dtype=float) else: - N = np.zeros((Q.shape[0], R.shape[1])); + N = np.zeros((Q.shape[0], R.shape[1])) # Check dimensions for consistency - nstates = B.shape[0]; - ninputs = B.shape[1]; + nstates = B.shape[0] + ninputs = B.shape[1] if (A.shape[0] != nstates or A.shape[1] != nstates): raise ControlDimension("inconsistent system dimensions") @@ -438,33 +470,39 @@ def lqr(*args, **keywords): raise ControlDimension("incorrect weighting matrix dimensions") # Compute the G matrix required by SB02MD - A_b,B_b,Q_b,R_b,L_b,ipiv,oufact,G = \ - sb02mt(nstates, ninputs, B, R, A, Q, N, jobl='N'); + A_b, B_b, Q_b, R_b, L_b, ipiv, oufact, G = \ + sb02mt(nstates, ninputs, B, R, A, Q, N, jobl='N') # Call the SLICOT function - X,rcond,w,S,U,A_inv = sb02md(nstates, A_b, G, Q_b, 'C') + X, rcond, w, S, U, A_inv = sb02md(nstates, A_b, G, Q_b, 'C') # Now compute the return value # We assume that R is positive definite and, hence, invertible - K = np.linalg.solve(R, np.dot(B.T, X) + N.T); - S = X; - E = w[0:nstates]; + K = np.linalg.solve(R, np.dot(B.T, X) + N.T) + S = X + E = w[0:nstates] return _ssmatrix(K), _ssmatrix(S), E + def ctrb(A, B): """Controllabilty matrix Parameters ---------- - A, B: array_like or string + A, B : array_like or string Dynamics and input matrix of the system Returns ------- - C: matrix + C : 2D array (or matrix) Controllability matrix + Notes + ----- + The return type for 2D arrays depends on the default class set for + state space operations. See :func:`~control.use_numpy_matrix`. + Examples -------- >>> C = ctrb(A, B) @@ -477,28 +515,34 @@ def ctrb(A, B): n = np.shape(amat)[0] # Construct the controllability matrix - ctrb = np.hstack([bmat] + [np.dot(np.linalg.matrix_power(amat, i), bmat) - for i in range(1, n)]) + ctrb = np.hstack( + [bmat] + [np.dot(np.linalg.matrix_power(amat, i), bmat) + for i in range(1, n)]) return _ssmatrix(ctrb) + def obsv(A, C): """Observability matrix Parameters ---------- - A, C: array_like or string + A, C : array_like or string Dynamics and output matrix of the system Returns ------- - O: matrix + O : 2D array (or matrix) Observability matrix + Notes + ----- + The return type for 2D arrays depends on the default class set for + state space operations. See :func:`~control.use_numpy_matrix`. + Examples -------- >>> O = obsv(A, C) - - """ + """ # Convert input parameters to matrices (if they aren't already) amat = _ssmatrix(A) @@ -510,21 +554,22 @@ def obsv(A, C): for i in range(1, n)]) return _ssmatrix(obsv) -def gram(sys,type): + +def gram(sys, type): """Gramian (controllability or observability) Parameters ---------- - sys: StateSpace - State-space system to compute Gramian for - type: String - Type of desired computation. - `type` is either 'c' (controllability) or 'o' (observability). To compute the - Cholesky factors of gramians use 'cf' (controllability) or 'of' (observability) + sys : StateSpace + System description + type : String + Type of desired computation. `type` is either 'c' (controllability) + or 'o' (observability). To compute the Cholesky factors of Gramians + use 'cf' (controllability) or 'of' (observability) Returns ------- - gram: array + gram : 2D array (or matrix) Gramian of system Raises @@ -538,22 +583,27 @@ def gram(sys,type): if slycot routine sb03md cannot be found if slycot routine sb03od cannot be found + Notes + ----- + The return type for 2D arrays depends on the default class set for + state space operations. See :func:`~control.use_numpy_matrix`. + Examples -------- - >>> Wc = gram(sys,'c') - >>> Wo = gram(sys,'o') - >>> Rc = gram(sys,'cf'), where Wc=Rc'*Rc - >>> Ro = gram(sys,'of'), where Wo=Ro'*Ro + >>> Wc = gram(sys, 'c') + >>> Wo = gram(sys, 'o') + >>> Rc = gram(sys, 'cf'), where Wc = Rc' * Rc + >>> Ro = gram(sys, 'of'), where Wo = Ro' * Ro """ - #Check for ss system object - if not isinstance(sys,statesp.StateSpace): + # Check for ss system object + if not isinstance(sys, statesp.StateSpace): raise ValueError("System must be StateSpace!") if type not in ['c', 'o', 'cf', 'of']: raise ValueError("That type is not supported!") - #TODO: Check for continous or discrete, only continuous supported right now + # TODO: Check for continous or discrete, only continuous supported for now # if isCont(): # dico = 'C' # elif isDisc(): @@ -561,50 +611,53 @@ def gram(sys,type): # else: dico = 'C' - #TODO: Check system is stable, perhaps a utility in ctrlutil.py - # or a method of the StateSpace class? + # TODO: Check system is stable, perhaps a utility in ctrlutil.py + # or a method of the StateSpace class? if np.any(np.linalg.eigvals(sys.A).real >= 0.0): raise ValueError("Oops, the system is unstable!") - if type=='c' or type=='o': - #Compute Gramian by the Slycot routine sb03md - #make sure Slycot is installed + if type == 'c' or type == 'o': + # Compute Gramian by the Slycot routine sb03md + # make sure Slycot is installed try: from slycot import sb03md except ImportError: raise ControlSlycot("can't find slycot module 'sb03md'") - if type=='c': + if type == 'c': tra = 'T' - C = -np.dot(sys.B,sys.B.transpose()) - elif type=='o': + C = -np.dot(sys.B, sys.B.transpose()) + elif type == 'o': tra = 'N' - C = -np.dot(sys.C.transpose(),sys.C) + C = -np.dot(sys.C.transpose(), sys.C) n = sys.states - U = np.zeros((n,n)) + U = np.zeros((n, n)) A = np.array(sys.A) # convert to NumPy array for slycot - X,scale,sep,ferr,w = sb03md(n, C, A, U, dico, job='X', fact='N', trana=tra) + X, scale, sep, ferr, w = sb03md( + n, C, A, U, dico, job='X', fact='N', trana=tra) gram = X return _ssmatrix(gram) - elif type=='cf' or type=='of': - #Compute cholesky factored gramian from slycot routine sb03od + elif type == 'cf' or type == 'of': + # Compute cholesky factored gramian from slycot routine sb03od try: from slycot import sb03od except ImportError: raise ControlSlycot("can't find slycot module 'sb03od'") - tra='N' + tra = 'N' n = sys.states - Q = np.zeros((n,n)) + Q = np.zeros((n, n)) A = np.array(sys.A) # convert to NumPy array for slycot - if type=='cf': + if type == 'cf': m = sys.B.shape[1] B = np.zeros_like(A) - B[0:m,0:n] = sys.B.transpose() - X,scale,w = sb03od(n, m, A.transpose(), Q, B, dico, fact='N', trans=tra) - elif type=='of': + B[0:m, 0:n] = sys.B.transpose() + X, scale, w = sb03od( + n, m, A.transpose(), Q, B, dico, fact='N', trans=tra) + elif type == 'of': m = sys.C.shape[0] C = np.zeros_like(A) - C[0:n,0:m] = sys.C.transpose() - X,scale,w = sb03od(n, m, A, Q, C.transpose(), dico, fact='N', trans=tra) + C[0:n, 0:m] = sys.C.transpose() + X, scale, w = sb03od( + n, m, A, Q, C.transpose(), dico, fact='N', trans=tra) gram = X return _ssmatrix(gram) diff --git a/doc/flatsys.rst b/doc/flatsys.rst index ed65cfd01..f085347a6 100644 --- a/doc/flatsys.rst +++ b/doc/flatsys.rst @@ -27,6 +27,7 @@ and we can write the solutions of the nonlinear system as functions of .. math:: x &= \beta(z, \dot z, \dots, z^{(q)}) \\ u &= \gamma(z, \dot z, \dots, z^{(q)}). + :label: flat2state For a differentially flat system, all of the feasible trajectories for the system can be written as functions of a flat output :math:`z(\cdot)` and @@ -52,7 +53,7 @@ and we see that the initial and final condition in the full state space depends on just the output :math:`z` and its derivatives at the initial and final times. Thus any trajectory for :math:`z` that satisfies these boundary conditions will be a feasible trajectory for the -system, using equation~\eqref{eq:trajgen:flat2state} to determine the +system, using equation :eq:`flat2state` to determine the full state space and input trajectories. In particular, given initial and final conditions on :math:`z` and its @@ -142,7 +143,7 @@ For more general systems, the `FlatSystem` object must be created manually In addition to the flat system descriptionn, a set of basis functions :math:`\phi_i(t)` must be chosen. The `FlatBasis` class is used to represent the basis functions. A polynomial basis function of the form 1, :math:`t`, -:math:`t^2:, ... can be computed using the `PolyBasis` class, which is +:math:`t^2`, ... can be computed using the `PolyBasis` class, which is initialized by passing the desired order of the polynomial basis set: polybasis = control.flatsys.PolyBasis(N) @@ -225,9 +226,9 @@ derived *Feedback Systems* by Astrom and Murray, Example 3.11. To find a trajectory from an initial state :math:`x_0` to a final state :math:`x_\text{f}` in time :math:`T_\text{f}` we solve a point-to-point -trajectory generation problem. We also set the initial and final inputs, whi -ch sets the vehicle velocity :math:`v` and steering wheel angle :math:`\delta` -at the endpoints. +trajectory generation problem. We also set the initial and final inputs, which +sets the vehicle velocity :math:`v` and steering wheel angle :math:`\delta` at +the endpoints. .. code-block:: python diff --git a/setup.py b/setup.py index ea825d471..ec16d7135 100644 --- a/setup.py +++ b/setup.py @@ -34,10 +34,10 @@ setup( name='control', version=version, - author='Richard Murray', - author_email='murray@cds.caltech.edu', - url='http://python-control.sourceforge.net', - description='Python control systems library', + author='Python Control Developers', + author_email='python-control-developers@lists.sourceforge.net', + url='http://python-control.org', + description='Python Control Systems Library', long_description=long_description, packages=find_packages(), classifiers=[f for f in CLASSIFIERS.split('\n') if f], From 38f29c739624f135412753ac24333378e2e6fa8e Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Sat, 26 Dec 2020 08:31:28 -0800 Subject: [PATCH 65/67] Consistent return values for lqe and lqr (#477) * update lqe return values to match lqr * update lqe docstring --- control/statefbk.py | 9 ++------- control/tests/statefbk_test.py | 2 +- 2 files changed, 3 insertions(+), 8 deletions(-) diff --git a/control/statefbk.py b/control/statefbk.py index d07410bfa..c08c645e9 100644 --- a/control/statefbk.py +++ b/control/statefbk.py @@ -282,7 +282,7 @@ def lqe(A, G, C, QN, RN, NN=None): A P + P A^T - (P C^T + G N) R^{-1} (C P + N^T G^T) + G Q G^T = 0 - E : 2D array (or matrix) + E : 1D array Eigenvalues of estimator poles eig(A - L C) Notes @@ -290,11 +290,6 @@ def lqe(A, G, C, QN, RN, NN=None): The return type for 2D arrays depends on the default class set for state space operations. See :func:`~control.use_numpy_matrix`. - The return type for `E` differs from the equivalent return values in the - :func:`~control.lqr`, :func:`~control.care`, and other similar - functions. The return type will be changed to a 1D array in a future - release. - Examples -------- >>> K, P, E = lqe(A, G, C, QN, RN) @@ -317,7 +312,7 @@ def lqe(A, G, C, QN, RN, NN=None): A, G, C = np.array(A, ndmin=2), np.array(G, ndmin=2), np.array(C, ndmin=2) QN, RN = np.array(QN, ndmin=2), np.array(RN, ndmin=2) P, E, LT = care(A.T, C.T, np.dot(np.dot(G, QN), G.T), RN) - return _ssmatrix(LT.T), _ssmatrix(P), _ssmatrix(E) + return _ssmatrix(LT.T), _ssmatrix(P), E # Contributed by Roberto Bucher diff --git a/control/tests/statefbk_test.py b/control/tests/statefbk_test.py index fc0ffeffa..3be70d643 100644 --- a/control/tests/statefbk_test.py +++ b/control/tests/statefbk_test.py @@ -302,7 +302,7 @@ def test_LQR_3args(self): def check_LQE(self, L, P, poles, G, QN, RN): P_expected = np.array(np.sqrt(G*QN*G * RN)) L_expected = P_expected / RN - poles_expected = np.array([-L_expected], ndmin=2) + poles_expected = np.array([-L_expected]) np.testing.assert_array_almost_equal(P, P_expected) np.testing.assert_array_almost_equal(L, L_expected) np.testing.assert_array_almost_equal(poles, poles_expected) From bd354c9da4eea9232c745f9bfcd94855038cfeb2 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Mon, 28 Dec 2020 07:48:56 -0800 Subject: [PATCH 66/67] fixes to markov() + add tranpose keyword, default warning (#478) * updated markov() calculation + new unit tests * updated markov() to add tranpose keyword + default warning; tests, PEP8 * resolves issue #395 --- control/modelsimp.py | 326 ++++++++++++++++++-------- control/tests/modelsimp_array_test.py | 89 ++++++- control/tests/modelsimp_test.py | 2 +- 3 files changed, 313 insertions(+), 104 deletions(-) diff --git a/control/modelsimp.py b/control/modelsimp.py index 9fd36923e..4cfcf4048 100644 --- a/control/modelsimp.py +++ b/control/modelsimp.py @@ -45,17 +45,21 @@ # External packages and modules import numpy as np -from .exception import ControlSlycot +import warnings +from .exception import ControlSlycot, ControlMIMONotImplemented, \ + ControlDimension from .lti import isdtime, isctime from .statesp import StateSpace from .statefbk import gram __all__ = ['hsvd', 'balred', 'modred', 'era', 'markov', 'minreal'] + # Hankel Singular Value Decomposition -# The following returns the Hankel singular values, which are singular values -#of the matrix formed by multiplying the controllability and observability -#grammians +# +# The following returns the Hankel singular values, which are singular values +# of the matrix formed by multiplying the controllability and observability +# Gramians def hsvd(sys): """Calculate the Hankel singular values. @@ -90,8 +94,8 @@ def hsvd(sys): if (isdtime(sys, strict=True)): raise NotImplementedError("Function not implemented in discrete time") - Wc = gram(sys,'c') - Wo = gram(sys,'o') + Wc = gram(sys, 'c') + Wo = gram(sys, 'o') WoWc = np.dot(Wo, Wc) w, v = np.linalg.eig(WoWc) @@ -101,6 +105,7 @@ def hsvd(sys): # Return the Hankel singular values, high to low return hsv[::-1] + def modred(sys, ELIM, method='matchdc'): """ Model reduction of `sys` by eliminating the states in `ELIM` using a given @@ -136,21 +141,20 @@ def modred(sys, ELIM, method='matchdc'): >>> rsys = modred(sys, ELIM, method='truncate') """ - #Check for ss system object, need a utility for this? + # Check for ss system object, need a utility for this? - #TODO: Check for continous or discrete, only continuous supported right now - # if isCont(): - # dico = 'C' - # elif isDisc(): - # dico = 'D' - # else: + # TODO: Check for continous or discrete, only continuous supported for now + # if isCont(): + # dico = 'C' + # elif isDisc(): + # dico = 'D' + # else: if (isctime(sys)): dico = 'C' else: raise NotImplementedError("Function not implemented in discrete time") - - #Check system is stable + # Check system is stable if np.any(np.linalg.eigvals(sys.A).real >= 0.0): raise ValueError("Oops, the system is unstable!") @@ -160,22 +164,22 @@ def modred(sys, ELIM, method='matchdc'): # A1 is a matrix of all columns of sys.A not to eliminate A1 = sys.A[:, NELIM[0]].reshape(-1, 1) for i in NELIM[1:]: - A1 = np.hstack((A1, sys.A[:,i].reshape(-1, 1))) - A11 = A1[NELIM,:] - A21 = A1[ELIM,:] + A1 = np.hstack((A1, sys.A[:, i].reshape(-1, 1))) + A11 = A1[NELIM, :] + A21 = A1[ELIM, :] # A2 is a matrix of all columns of sys.A to eliminate A2 = sys.A[:, ELIM[0]].reshape(-1, 1) for i in ELIM[1:]: - A2 = np.hstack((A2, sys.A[:,i].reshape(-1, 1))) - A12 = A2[NELIM,:] - A22 = A2[ELIM,:] + A2 = np.hstack((A2, sys.A[:, i].reshape(-1, 1))) + A12 = A2[NELIM, :] + A22 = A2[ELIM, :] - C1 = sys.C[:,NELIM] - C2 = sys.C[:,ELIM] - B1 = sys.B[NELIM,:] - B2 = sys.B[ELIM,:] + C1 = sys.C[:, NELIM] + C2 = sys.C[:, ELIM] + B1 = sys.B[NELIM, :] + B2 = sys.B[ELIM, :] - if method=='matchdc': + if method == 'matchdc': # if matchdc, residualize # Check if the matrix A22 is invertible @@ -195,7 +199,7 @@ def modred(sys, ELIM, method='matchdc'): Br = B1 - np.dot(A12, A22I_B2) Cr = C1 - np.dot(C2, A22I_A21) Dr = sys.D - np.dot(C2, A22I_B2) - elif method=='truncate': + elif method == 'truncate': # if truncate, simply discard state x2 Ar = A11 Br = B1 @@ -204,12 +208,12 @@ def modred(sys, ELIM, method='matchdc'): else: raise ValueError("Oops, method is not supported!") - rsys = StateSpace(Ar,Br,Cr,Dr) + rsys = StateSpace(Ar, Br, Cr, Dr) return rsys + def balred(sys, orders, method='truncate', alpha=None): - """ - Balanced reduced order model of sys of a given order. + """Balanced reduced order model of sys of a given order. States are eliminated based on Hankel singular value. If sys has unstable modes, they are removed, the balanced realization is done on the stable part, then @@ -229,22 +233,23 @@ def balred(sys, orders, method='truncate', alpha=None): method: string Method of removing states, either ``'truncate'`` or ``'matchdc'``. alpha: float - Redefines the stability boundary for eigenvalues of the system matrix A. - By default for continuous-time systems, alpha <= 0 defines the stability - boundary for the real part of A's eigenvalues and for discrete-time - systems, 0 <= alpha <= 1 defines the stability boundary for the modulus - of A's eigenvalues. See SLICOT routines AB09MD and AB09ND for more - information. + Redefines the stability boundary for eigenvalues of the system + matrix A. By default for continuous-time systems, alpha <= 0 + defines the stability boundary for the real part of A's eigenvalues + and for discrete-time systems, 0 <= alpha <= 1 defines the stability + boundary for the modulus of A's eigenvalues. See SLICOT routines + AB09MD and AB09ND for more information. Returns ------- rsys: StateSpace - A reduced order model or a list of reduced order models if orders is a list + A reduced order model or a list of reduced order models if orders is + a list. Raises ------ ValueError - * if `method` is not ``'truncate'`` or ``'matchdc'`` + If `method` is not ``'truncate'`` or ``'matchdc'`` ImportError if slycot routine ab09ad, ab09md, or ab09nd is not found @@ -256,70 +261,78 @@ def balred(sys, orders, method='truncate', alpha=None): >>> rsys = balred(sys, orders, method='truncate') """ - if method!='truncate' and method!='matchdc': + if method != 'truncate' and method != 'matchdc': raise ValueError("supported methods are 'truncate' or 'matchdc'") - elif method=='truncate': + elif method == 'truncate': try: from slycot import ab09md, ab09ad except ImportError: - raise ControlSlycot("can't find slycot subroutine ab09md or ab09ad") - elif method=='matchdc': + raise ControlSlycot( + "can't find slycot subroutine ab09md or ab09ad") + elif method == 'matchdc': try: from slycot import ab09nd except ImportError: raise ControlSlycot("can't find slycot subroutine ab09nd") - #Check for ss system object, need a utility for this? + # Check for ss system object, need a utility for this? - #TODO: Check for continous or discrete, only continuous supported right now - # if isCont(): - # dico = 'C' - # elif isDisc(): - # dico = 'D' - # else: + # TODO: Check for continous or discrete, only continuous supported for now + # if isCont(): + # dico = 'C' + # elif isDisc(): + # dico = 'D' + # else: dico = 'C' - job = 'B' # balanced (B) or not (N) - equil = 'N' # scale (S) or not (N) + job = 'B' # balanced (B) or not (N) + equil = 'N' # scale (S) or not (N) if alpha is None: if dico == 'C': alpha = 0. elif dico == 'D': alpha = 1. - rsys = [] #empty list for reduced systems + rsys = [] # empty list for reduced systems - #check if orders is a list or a scalar + # check if orders is a list or a scalar try: order = iter(orders) - except TypeError: #if orders is a scalar + except TypeError: # if orders is a scalar orders = [orders] for i in orders: - n = np.size(sys.A,0) - m = np.size(sys.B,1) - p = np.size(sys.C,0) + n = np.size(sys.A, 0) + m = np.size(sys.B, 1) + p = np.size(sys.C, 0) if method == 'truncate': - #check system stability + # check system stability if np.any(np.linalg.eigvals(sys.A).real >= 0.0): - #unstable branch - Nr, Ar, Br, Cr, Ns, hsv = ab09md(dico,job,equil,n,m,p,sys.A,sys.B,sys.C,alpha=alpha,nr=i,tol=0.0) + # unstable branch + Nr, Ar, Br, Cr, Ns, hsv = ab09md( + dico, job, equil, n, m, p, sys.A, sys.B, sys.C, + alpha=alpha, nr=i, tol=0.0) else: - #stable branch - Nr, Ar, Br, Cr, hsv = ab09ad(dico,job,equil,n,m,p,sys.A,sys.B,sys.C,nr=i,tol=0.0) + # stable branch + Nr, Ar, Br, Cr, hsv = ab09ad( + dico, job, equil, n, m, p, sys.A, sys.B, sys.C, + nr=i, tol=0.0) rsys.append(StateSpace(Ar, Br, Cr, sys.D)) elif method == 'matchdc': - Nr, Ar, Br, Cr, Dr, Ns, hsv = ab09nd(dico,job,equil,n,m,p,sys.A,sys.B,sys.C,sys.D,alpha=alpha,nr=i,tol1=0.0,tol2=0.0) + Nr, Ar, Br, Cr, Dr, Ns, hsv = ab09nd( + dico, job, equil, n, m, p, sys.A, sys.B, sys.C, sys.D, + alpha=alpha, nr=i, tol1=0.0, tol2=0.0) rsys.append(StateSpace(Ar, Br, Cr, Dr)) - #if orders was a scalar, just return the single reduced model, not a list + # if orders was a scalar, just return the single reduced model, not a list if len(orders) == 1: return rsys[0] - #if orders was a list/vector, return a list/vector of systems + # if orders was a list/vector, return a list/vector of systems else: return rsys + def minreal(sys, tol=None, verbose=True): ''' Eliminates uncontrollable or unobservable states in state-space @@ -347,9 +360,10 @@ def minreal(sys, tol=None, verbose=True): nstates=len(sys.pole()) - len(sysr.pole()))) return sysr + def era(YY, m, n, nin, nout, r): - """ - Calculate an ERA model of order `r` based on the impulse-response data `YY`. + """Calculate an ERA model of order `r` based on the impulse-response data + `YY`. .. note:: This function is not implemented yet. @@ -376,54 +390,172 @@ def era(YY, m, n, nin, nout, r): Examples -------- >>> rsys = era(YY, m, n, nin, nout, r) + """ raise NotImplementedError('This function is not implemented yet.') -def markov(Y, U, m): - """ - Calculate the first `M` Markov parameters [D CB CAB ...] + +def markov(Y, U, m=None, transpose=None): + """Calculate the first `m` Markov parameters [D CB CAB ...] from input `U`, output `Y`. + This function computes the Markov parameters for a discrete time system + + .. math:: + + x[k+1] &= A x[k] + B u[k] \\\\ + y[k] &= C x[k] + D u[k] + + given data for u and y. The algorithm assumes that that C A^k B = 0 for + k > m-2 (see [1]). Note that the problem is ill-posed if the length of + the input data is less than the desired number of Markov parameters (a + warning message is generated in this case). + Parameters ---------- - Y: array_like - Output data - U: array_like - Input data - m: int - Number of Markov parameters to output + Y : array_like + Output data. If the array is 1D, the system is assumed to be single + input. If the array is 2D and transpose=False, the columns of `Y` + are taken as time points, otherwise the rows of `Y` are taken as + time points. + U : array_like + Input data, arranged in the same way as `Y`. + m : int, optional + Number of Markov parameters to output. Defaults to len(U). + transpose : bool, optional + Assume that input data is transposed relative to the standard + :ref:`time-series-convention`. The default value is true for + backward compatibility with legacy code. Returns ------- - H: ndarray - First m Markov parameters + H : ndarray + First m Markov parameters, [D CB CAB ...] + + References + ---------- + .. [1] J.-N. Juang, M. Phan, L. G. Horta, and R. W. Longman, + Identification of observer/Kalman filter Markov parameters - Theory + and experiments. Journal of Guidance Control and Dynamics, 16(2), + 320-329, 2012. http://doi.org/10.2514/3.21006 Notes ----- - Currently only works for SISO + Currently only works for SISO systems. + + This function does not currently comply with the Python Control Library + :ref:`time-series-convention` for representation of time series data. + Use `transpose=False` to make use of the standard convention (this + will be updated in a future release). Examples -------- - >>> H = markov(Y, U, m) - """ + >>> T = numpy.linspace(0, 10, 100) + >>> U = numpy.ones((1, 100)) + >>> T, Y, _ = forced_response(tf([1], [1, 0.5], True), T, U) + >>> H = markov(Y, U, 3, transpose=False) - # Convert input parameters to matrices (if they aren't already) - Ymat = np.array(Y) - Umat = np.array(U) - n = np.size(U) - - # Construct a matrix of control inputs to invert + """ + # Check on the specified format of the input + if transpose is None: + # For backwards compatibility, assume time series in rows but warn user + warnings.warn( + "Time-series data assumed to be in rows. This will change in a " + "future release. Use `transpose=True` to preserve current " + "behavior.") + transpose = True + + # Convert input parameters to 2D arrays (if they aren't already) + Umat = np.array(U, ndmin=2) + Ymat = np.array(Y, ndmin=2) + + # If data is in transposed format, switch it around + if transpose: + Umat, Ymat = np.transpose(Umat), np.transpose(Ymat) + + # Make sure the system is a SISO system + if Umat.shape[0] != 1 or Ymat.shape[0] != 1: + raise ControlMIMONotImplemented + + # Make sure the number of time points match + if Umat.shape[1] != Ymat.shape[1]: + raise ControlDimension( + "Input and output data are of differnent lengths") + n = Umat.shape[1] + + # If number of desired parameters was not given, set to size of input data + if m is None: + m = Umat.shape[1] + + # Make sure there is enough data to compute parameters + if m > n: + warn.warning("Not enough data for requested number of parameters") + + # + # Original algorithm (with mapping to standard order) + # + # RMM note, 24 Dec 2020: This algorithm sets the problem up correctly + # until the final column of the UU matrix is created, at which point it + # makes some modifications that I don't understand. This version of the + # algorithm does not seem to return the actual Markov parameters for a + # system. + # + # # Create the matrix of (shifted) inputs + # UU = np.transpose(Umat) + # for i in range(1, m-1): + # # Shift previous column down and add a zero at the top + # newCol = np.vstack((0, np.reshape(UU[0:n-1, i-1], (-1, 1)))) + # UU = np.hstack((UU, newCol)) + # + # # Shift previous column down and add a zero at the top + # Ulast = np.vstack((0, np.reshape(UU[0:n-1, m-2], (-1, 1)))) + # + # # Replace the elements of the last column new values (?) + # # Each row gets the sum of the rows above it (?) + # for i in range(n-1, 0, -1): + # Ulast[i] = np.sum(Ulast[0:i-1]) + # UU = np.hstack((UU, Ulast)) + # + # # Solve for the Markov parameters from Y = H @ UU + # # H = [[D], [CB], [CAB], ..., [C A^{m-3} B], [???]] + # H = np.linalg.lstsq(UU, np.transpose(Ymat))[0] + # + # # Markov parameters are in rows => transpose if needed + # return H if transpose else np.transpose(H) + + # + # New algorithm - Construct a matrix of control inputs to invert + # + # This algorithm sets up the following problem and solves it for + # the Markov parameters + # + # [ y(0) ] [ u(0) 0 0 ] [ D ] + # [ y(1) ] [ u(1) u(0) 0 ] [ C B ] + # [ y(2) ] = [ u(2) u(1) u(0) ] [ C A B ] + # [ : ] [ : : : : ] [ : ] + # [ y(n-1) ] [ u(n-1) u(n-2) u(n-3) ... u(n-m) ] [ C A^{m-2} B ] + # + # Note: if the number of Markov parameters (m) is less than the size of + # the input/output data (n), then this algorithm assumes C A^{j} B = 0 + # for j > m-2. See equation (3) in + # + # J.-N. Juang, M. Phan, L. G. Horta, and R. W. Longman, Identification + # of observer/Kalman filter Markov parameters - Theory and + # experiments. Journal of Guidance Control and Dynamics, 16(2), + # 320-329, 2012. http://doi.org/10.2514/3.21006 + # + + # Create matrix of (shifted) inputs UU = Umat - for i in range(1, m-1): - # TODO: second index on UU doesn't seem right; could be neg or pos?? - newCol = np.vstack((0, np.reshape(UU[0:n-1, i-2], (-1, 1)))) - UU = np.hstack((UU, newCol)) - Ulast = np.vstack((0, np.reshape(UU[0:n-1, m-2], (-1, 1)))) - for i in range(n-1, 0, -1): - Ulast[i] = np.sum(Ulast[0:i-1]) - UU = np.hstack((UU, Ulast)) + for i in range(1, m): + # Shift previous column down and add a zero at the top + new_row = np.hstack((0, UU[i-1, 0:-1])) + UU = np.vstack((UU, new_row)) + UU = np.transpose(UU) # Invert and solve for Markov parameters - H = np.linalg.lstsq(UU, Y)[0] + YY = np.transpose(Ymat) + H, _, _, _ = np.linalg.lstsq(UU, YY, rcond=None) - return H + # Return the first m Markov parameters + return H if transpose else np.transpose(H) diff --git a/control/tests/modelsimp_array_test.py b/control/tests/modelsimp_array_test.py index 4a6f591e6..dbd6a5796 100644 --- a/control/tests/modelsimp_array_test.py +++ b/control/tests/modelsimp_array_test.py @@ -9,7 +9,7 @@ import control from control.modelsimp import * from control.matlab import * -from control.exception import slycot_check +from control.exception import slycot_check, ControlMIMONotImplemented class TestModelsimp(unittest.TestCase): def setUp(self): @@ -49,14 +49,91 @@ def testHSVD(self): # Go back to using the normal np.array representation control.use_numpy_matrix(False) - def testMarkov(self): - U = np.array([[1.], [1.], [1.], [1.], [1.]]) + def testMarkovSignature(self): + U = np.array([[1., 1., 1., 1., 1.]]) Y = U - M = 3 - H = markov(Y,U,M) - Htrue = np.array([[1.], [0.], [0.]]) + m = 3 + H = markov(Y, U, m, transpose=False) + Htrue = np.array([[1., 0., 0.]]) np.testing.assert_array_almost_equal( H, Htrue ) + # Make sure that transposed data also works + H = markov(np.transpose(Y), np.transpose(U), m, transpose=True) + np.testing.assert_array_almost_equal( H, np.transpose(Htrue) ) + + # Default (in v0.8.4 and below) should be transpose=True (w/ warning) + import warnings + warnings.simplefilter('always', UserWarning) # don't supress + with warnings.catch_warnings(record=True) as w: + # Set up warnings filter to only show warnings in control module + warnings.filterwarnings("ignore") + warnings.filterwarnings("always", module="control") + + # Generate Markov parameters without any arguments + H = markov(np.transpose(Y), np.transpose(U), m) + np.testing.assert_array_almost_equal( H, np.transpose(Htrue) ) + + # Make sure we got a warning + self.assertEqual(len(w), 1) + self.assertIn("assumed to be in rows", str(w[-1].message)) + self.assertIn("change in a future release", str(w[-1].message)) + + # Test example from docstring + T = np.linspace(0, 10, 100) + U = np.ones((1, 100)) + T, Y, _ = control.forced_response( + control.tf([1], [1, 0.5], True), T, U) + H = markov(Y, U, 3, transpose=False) + + # Test example from issue #395 + inp = np.array([1, 2]) + outp = np.array([2, 4]) + mrk = markov(outp, inp, 1, transpose=False) + + # Make sure MIMO generates an error + U = np.ones((2, 100)) # 2 inputs (Y unchanged, with 1 output) + np.testing.assert_raises(ControlMIMONotImplemented, markov, Y, U, m) + + # Make sure markov() returns the right answer + def testMarkovResults(self): + # + # Test over a range of parameters + # + # k = order of the system + # m = number of Markov parameters + # n = size of the data vector + # + # Values should match exactly for n = m, otherewise you get a + # close match but errors due to the assumption that C A^k B = + # 0 for k > m-2 (see modelsimp.py). + # + for k, m, n in \ + ((2, 2, 2), (2, 5, 5), (5, 2, 2), (5, 5, 5), (5, 10, 10)): + + # Generate stable continuous time system + Hc = control.rss(k, 1, 1) + + # Choose sampling time based on fastest time constant / 10 + w, _ = np.linalg.eig(Hc.A) + Ts = np.min(-np.real(w)) / 10. + + # Convert to a discrete time system via sampling + Hd = control.c2d(Hc, Ts, 'zoh') + + # Compute the Markov parameters from state space + Mtrue = np.hstack([Hd.D] + [np.dot( + Hd.C, np.dot(np.linalg.matrix_power(Hd.A, i), + Hd.B)) for i in range(m-1)]) + + # Generate input/output data + T = np.array(range(n)) * Ts + U = np.cos(T) + np.sin(T/np.pi) + _, Y, _ = control.forced_response(Hd, T, U, squeeze=True) + Mcomp = markov(Y, U, m, transpose=False) + + # Compare to results from markov() + np.testing.assert_array_almost_equal(Mtrue, Mcomp) + def testModredMatchDC(self): #balanced realization computed in matlab for the transfer function: # num = [1 11 45 32], den = [1 15 60 200 60] diff --git a/control/tests/modelsimp_test.py b/control/tests/modelsimp_test.py index 2368bd92f..c0ba72a3b 100644 --- a/control/tests/modelsimp_test.py +++ b/control/tests/modelsimp_test.py @@ -25,7 +25,7 @@ def testMarkov(self): U = np.matrix("1.; 1.; 1.; 1.; 1.") Y = U M = 3 - H = markov(Y,U,M) + H = markov(Y, U, M) Htrue = np.matrix("1.; 0.; 0.") np.testing.assert_array_almost_equal( H, Htrue ) From 35f1e6486004bd35e2fcad399572754dd609d979 Mon Sep 17 00:00:00 2001 From: Richard Murray Date: Mon, 28 Dec 2020 11:01:17 -0800 Subject: [PATCH 67/67] Sphinx update (#479) * fix footnote reference in markov() docstring * require sphinx 3.4 or higher for readthedocs --- control/modelsimp.py | 2 +- doc-requirements.txt | 1 + 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/control/modelsimp.py b/control/modelsimp.py index 4cfcf4048..8f6124481 100644 --- a/control/modelsimp.py +++ b/control/modelsimp.py @@ -407,7 +407,7 @@ def markov(Y, U, m=None, transpose=None): y[k] &= C x[k] + D u[k] given data for u and y. The algorithm assumes that that C A^k B = 0 for - k > m-2 (see [1]). Note that the problem is ill-posed if the length of + k > m-2 (see [1]_). Note that the problem is ill-posed if the length of the input data is less than the desired number of Markov parameters (a warning message is generated in this case). diff --git a/doc-requirements.txt b/doc-requirements.txt index 112ca8cbe..cf1a3a76e 100644 --- a/doc-requirements.txt +++ b/doc-requirements.txt @@ -1,3 +1,4 @@ +sphinx>=3.4 numpy scipy matplotlib