fix up rebase issues

murrayrm · murrayrm · commit 53f780807d1f · 2021-12-26T06:49:39.000-08:00
diff --git a/control/mateqn.py b/control/mateqn.py
@@ -37,12 +37,13 @@
 
 import warnings
 import numpy as np
-from numpy import shape, size, copy, zeros, eye, finfo, inexact, atleast_2d
+from numpy import copy, eye, dot, finfo, inexact, atleast_2d
 
 import scipy as sp
-from scipy.linalg import eigvals, solve_discrete_are, solve
+from scipy.linalg import eigvals, solve
 
-from .exception import ControlSlycot, ControlArgument, slycot_check
+from .exception import ControlSlycot, ControlArgument, ControlDimension, \
+    slycot_check
 from .statesp import _ssmatrix
 
 # Make sure we have access to the right slycot routines
@@ -136,9 +137,9 @@ def lyap(A, Q, C=None, E=None, method=None):
     method = _slycot_or_scipy(method)
     if method == 'slycot':
         if sb03md is None:
-            raise ControlSlycot("can't find slycot module 'sb03md'")
+            raise ControlSlycot("Can't find slycot module 'sb03md'")
         if sb04md is None:
-            raise ControlSlycot("can't find slycot module 'sb04md'")
+            raise ControlSlycot("Can't find slycot module 'sb04md'")
 
     # Reshape input arrays
     A = np.array(A, ndmin=2)
@@ -196,7 +197,7 @@ def lyap(A, Q, C=None, E=None, method=None):
             from slycot import sg03ad
 
         except ImportError:
-            raise ControlSlycot("can't find slycot module 'sg03ad'")
+            raise ControlSlycot("Can't find slycot module 'sg03ad'")
 
         # Solve the generalized Lyapunov equation by calling Slycot
         # function sg03ad
@@ -265,11 +266,11 @@ def dlyap(A, Q, C=None, E=None, method=None):
     if method == 'slycot':
         # Make sure we have access to the right slycot routines
         if sb03md is None:
-            raise ControlSlycot("can't find slycot module 'sb03md'")
+            raise ControlSlycot("Can't find slycot module 'sb03md'")
         if sb04qd is None:
-            raise ControlSlycot("can't find slycot module 'sb04qd'")
+            raise ControlSlycot("Can't find slycot module 'sb04qd'")
         if sg03ad is None:
-            raise ControlSlycot("can't find slycot module 'sg03ad'")
+            raise ControlSlycot("Can't find slycot module 'sg03ad'")
 
     # Reshape input arrays
     A = np.array(A, ndmin=2)
@@ -399,18 +400,18 @@ def care(A, B, Q, R=None, S=None, E=None, stabilizing=True, method=None):
         try:
             from slycot import sb02md
         except ImportError:
-            raise ControlSlycot("can't find slycot module 'sb02md'")
+            raise ControlSlycot("Can't find slycot module 'sb02md'")
 
         try:
             from slycot import sb02mt
         except ImportError:
-            raise ControlSlycot("can't find slycot module 'sb02mt'")
+            raise ControlSlycot("Can't find slycot module 'sb02mt'")
 
         # Make sure we can find the required slycot routine
         try:
             from slycot import sg02ad
         except ImportError:
-            raise ControlSlycot("can't find slycot module 'sg02ad'")
+            raise ControlSlycot("Can't find slycot module 'sg02ad'")
 
     # Reshape input arrays
     A = np.array(A, ndmin=2)
@@ -500,10 +501,7 @@ def care(A, B, Q, R=None, S=None, E=None, stabilizing=True, method=None):
                        'R', n, m, 0, A, E, B, Q, R, S)
 
         # Calculate the closed-loop eigenvalues L
-        L = zeros(n)
-        L.dtype = 'complex64'
-        for i in range(n):
-            L[i] = (alfar[i] + alfai[i]*1j) / beta[i]
+        L = np.array([(alfar[i] + alfai[i]*1j) / beta[i] for i in range(n)])
 
         # Calculate the gain matrix G
         G = solve(R_b, B_b.T @ X @ E_b + S_b.T)
@@ -598,7 +596,7 @@ def dare(A, B, Q, R, S=None, E=None, stabilizing=True, method=None):
 
         Rmat = _ssmatrix(R)
         Qmat = _ssmatrix(Q)
-        X = solve_discrete_are(A, B, Qmat, Rmat, e=E, s=S)
+        X = sp.linalg.solve_discrete_are(A, B, Qmat, Rmat, e=E, s=S)
         if S is None:
             G = solve(B.T @ X @ B + Rmat, B.T @ X @ A)
         else:
@@ -616,18 +614,18 @@ def _dare_slycot(A, B, Q, R, S=None, E=None, stabilizing=True):
     try:
         from slycot import sb02md
     except ImportError:
-        raise ControlSlycot("can't find slycot module 'sb02md'")
+        raise ControlSlycot("Can't find slycot module 'sb02md'")
 
     try:
         from slycot import sb02mt
     except ImportError:
-        raise ControlSlycot("can't find slycot module 'sb02mt'")
+        raise ControlSlycot("Can't find slycot module 'sb02mt'")
 
     # Make sure we can find the required slycot routine
     try:
         from slycot import sg02ad
     except ImportError:
-        raise ControlSlycot("can't find slycot module 'sg02ad'")
+        raise ControlSlycot("Can't find slycot module 'sg02ad'")
 
     # Reshape input arrays
     A = np.array(A, ndmin=2)
@@ -667,10 +665,8 @@ def _dare_slycot(A, B, Q, R, S=None, E=None, stabilizing=True):
             sg02ad('D', 'B', 'N', 'U', 'N', 'N', sort,
                    'R', n, m, 0, A, E, B, Q, R, S)
 
-    L = zeros(n)
-    L.dtype = 'complex64'
-    for i in range(n):
-        L[i] = (alfar[i] + alfai[i]*1j)/beta[i]
+    # Calculate the closed-loop eigenvalues L
+    L = np.array([(alfar[i] + alfai[i]*1j) / beta[i] for i in range(n)])
 
     # Calculate the gain matrix G
     G = solve(B_b.T @ X @ B_b + R_b, B_b.T @ X @ A_b + S_b.T)
@@ -687,19 +683,19 @@ def _slycot_or_scipy(method):
     elif method == 'scipy' or (method is None and not slycot_check()):
         return 'scipy'
     else:
-        raise ValueError("unknown method %s" % method)
+        raise ValueError("Unknown method %s" % method)
 
 
 # Utility function to check matrix dimensions
 def _check_shape(name, M, n, m, square=False, symmetric=False):
     if square and M.shape[0] != M.shape[1]:
-        raise ControlArgument("%s must be a square matrix" % name)
+        raise ControlDimension("%s must be a square matrix" % name)
 
     if symmetric and not _is_symmetric(M):
         raise ControlArgument("%s must be a symmetric matrix" % name)
 
     if M.shape[0] != n or M.shape[1] != m:
-        raise ControlArgument("Incompatible dimensions of %s matrix" % name)
+        raise ControlDimension("Incompatible dimensions of %s matrix" % name)
 
 
 # Utility function to check if a matrix is symmetric
diff --git a/control/tests/mateqn_test.py b/control/tests/mateqn_test.py
@@ -41,7 +41,7 @@
 
 import control as ct
 from control.mateqn import lyap, dlyap, care, dare
-from control.exception import ControlArgument, slycot_check
+from control.exception import ControlArgument, ControlDimension, slycot_check
 from control.tests.conftest import slycotonly
 
 
@@ -334,21 +334,21 @@ def test_raise(self):
         Efq = array([[2, 1, 0], [1, 2, 0]])
 
         for cdlyap in [lyap, dlyap]:
-            with pytest.raises(ControlArgument):
+            with pytest.raises(ControlDimension):
                 cdlyap(Afq, Q)
-            with pytest.raises(ControlArgument):
+            with pytest.raises(ControlDimension):
                 cdlyap(A, Qfq)
             with pytest.raises(ControlArgument):
                 cdlyap(A, Qfs)
-            with pytest.raises(ControlArgument):
+            with pytest.raises(ControlDimension):
                 cdlyap(Afq, Q, C)
-            with pytest.raises(ControlArgument):
+            with pytest.raises(ControlDimension):
                 cdlyap(A, Qfq, C)
-            with pytest.raises(ControlArgument):
+            with pytest.raises(ControlDimension):
                 cdlyap(A, Q, Cfd)
-            with pytest.raises(ControlArgument):
+            with pytest.raises(ControlDimension):
                 cdlyap(A, Qfq, None, E)
-            with pytest.raises(ControlArgument):
+            with pytest.raises(ControlDimension):
                 cdlyap(A, Q, None, Efq)
             with pytest.raises(ControlArgument):
                 cdlyap(A, Qfs, None, E)
@@ -365,30 +365,30 @@ def test_raise(self):
         E = array([[2, 1], [1, 2]])
         Ef = array([[2, 1], [1, 2], [1, 2]])
 
-        with pytest.raises(ControlArgument):
+        with pytest.raises(ControlDimension):
             care(Afq, B, Q)
-        with pytest.raises(ControlArgument):
+        with pytest.raises(ControlDimension):
             care(A, B, Qfq)
-        with pytest.raises(ControlArgument):
+        with pytest.raises(ControlDimension):
             care(A, Bf, Q)
-        with pytest.raises(ControlArgument):
+        with pytest.raises(ControlDimension):
             care(1, B, 1)
         with pytest.raises(ControlArgument):
             care(A, B, Qfs)
         with pytest.raises(ControlArgument):
             dare(A, B, Q, Rfs)
         for cdare in [care, dare]:
-            with pytest.raises(ControlArgument):
+            with pytest.raises(ControlDimension):
                 cdare(Afq, B, Q, R, S, E)
-            with pytest.raises(ControlArgument):
+            with pytest.raises(ControlDimension):
                 cdare(A, B, Qfq, R, S, E)
-            with pytest.raises(ControlArgument):
+            with pytest.raises(ControlDimension):
                 cdare(A, Bf, Q, R, S, E)
-            with pytest.raises(ControlArgument):
+            with pytest.raises(ControlDimension):
                 cdare(A, B, Q, R, S, Ef)
-            with pytest.raises(ControlArgument):
+            with pytest.raises(ControlDimension):
                 cdare(A, B, Q, Rfq, S, E)
-            with pytest.raises(ControlArgument):
+            with pytest.raises(ControlDimension):
                 cdare(A, B, Q, R, Sf, E)
             with pytest.raises(ControlArgument):
                 cdare(A, B, Qfs, R, S, E)
diff --git a/control/tests/statefbk_test.py b/control/tests/statefbk_test.py
@@ -324,13 +324,13 @@ def test_LQR_3args(self, matarrayin, matarrayout, method):
 
     def test_lqr_badmethod(self):
         A, B, Q, R = 0, 1, 10, 2
-        with pytest.raises(ValueError, match="unknown"):
+        with pytest.raises(ValueError, match="Unknown method"):
             K, S, poles = lqr(A, B, Q, R, method='nosuchmethod')
 
     def test_lqr_slycot_not_installed(self):
         A, B, Q, R = 0, 1, 10, 2
         if not slycot_check():
-            with pytest.raises(ControlSlycot, match="can't find slycot"):
+            with pytest.raises(ControlSlycot, match="Can't find slycot"):
                 K, S, poles = lqr(A, B, Q, R, method='slycot')
 
     @pytest.mark.xfail(reason="warning not implemented")
@@ -378,11 +378,11 @@ def test_lqr_call_format(self):
         np.testing.assert_array_almost_equal(Eref, E)
 
         # Inconsistent system dimensions
-        with pytest.raises(ct.ControlDimension, match="inconsistent system"):
+        with pytest.raises(ct.ControlDimension, match="Incompatible dimen"):
             K, S, E = lqr(sys.A, sys.C, Q, R)
 
         # incorrect covariance matrix dimensions
-        with pytest.raises(ct.ControlDimension, match="incorrect weighting"):
+        with pytest.raises(ct.ControlDimension, match="Q must be a square"):
             K, S, E = lqr(sys.A, sys.B, sys.C, R, Q)
 
     def check_LQE(self, L, P, poles, G, QN, RN):
@@ -420,7 +420,7 @@ def test_lqe_call_format(self):
         sys_siso = rss(4, 1, 1)
         L_ss, P_ss, E_ss = lqe(sys_siso, np.eye(1), np.eye(1))
         L_tf, P_tf, E_tf = lqe(tf(sys_siso), np.eye(1), np.eye(1))
-        np.testing.assert_array_almost_equal(E_ss, E_tf)
+        np.testing.assert_array_almost_equal(np.sort(E_ss), np.sort(E_tf))
 
         # Make sure we get an error if we specify N
         with pytest.raises(ct.ControlNotImplemented):
