more cleanup, including file attributes for source files

roryyorke · May 10, 2020 · May 3, 2020 · May 3, 2020 · May 3, 2020 · May 3, 2020
commit 18f054e20bc2984616af0caff45eb55ec1efc549
diff --git a/slycot/analysis.py b/slycot/analysis.py
@@ -803,7 +803,7 @@ def ab09ax(dico,job,n,m,p,A,B,C,nr=None,tol=0.0,ldwork=None):
     arg_list = ['dico', 'job', 'ordsel', 'n', 'm', 'p', 'nr',
                 'A', 'lda' + hidden, 'B', 'ldb' + hidden, 'C', 'ldc' + hidden,
                 'hsv', 'T', 'ldt' + hidden, 'Ti', 'ldti' + hidden, 'tol',
-                'iwork'+hidden, 'dwork'+hidden, 'ldwork', 'iwarn', 'info']
+                'iwork' + hidden, 'dwork' + hidden, 'ldwork', 'iwarn', 'info']
     if ldwork is None:
         ldwork = max(1, n*(2*n + max(n, max(m, p))+5)+n*(n+1)/2)
     if nr is None:
@@ -922,7 +922,7 @@ def ab09bd(dico,job,equil,n,m,p,A,B,C,D,nr=None,tol1=0,tol2=0,ldwork=None):
 
     Raises
     ------
-    SlycotArithmeticError : e
+    SlycotArithmeticError
         :info == 1:
             The reduction of A to the real Schur form failed
         :info == 2 and dico == 'C':
@@ -934,7 +934,7 @@ def ab09bd(dico,job,equil,n,m,p,A,B,C,D,nr=None,tol1=0,tol2=0,ldwork=None):
 
     Warns
     -----
-    SlycotResultWarning : e
+    SlycotResultWarning
         :iwarn == 1:
                 The selected order {nr} is greater
                 than the order of a minimal realization of the
@@ -1304,47 +1304,42 @@ def ab13bd(dico, jobn, n, m, p, A, B, C, D, tol = 0.0):
     a discrete-time system. If the H2-norm is computed, the system
     must be stable.
 
-    Required arguments
-    ------------------
-
-        dico : {'D', 'C'} input string(len=1)
-               Indicate whether the system is discrete 'D' or continuous 'C'.
-        jobn : {'H', 'L'} input string(len=1)
-               H2-norm 'H' or L2-norm 'L' to be computed.
-        n : input int
-            The number of state variables.  n >= 0.
-        m : input int
-            The number of system inputs.  m >= 0.
-        p : input int
-            The number of system outputs.  p >= 0.
-        A : input rank-2 array('d') with bounds (n,n)
-            The leading n-by-n part of this array must contain the state
-            dynamics matrix A of the system.
-        B : input rank-2 array('d') with bounds (n,m)
-            The leading n-by-m part of this array must contain the input/state
-            matrix B of the system.
-        C : input rank-2 array('d') with bounds (p,n)
-            The leading p-by-n part of this array must contain the state/output
-            matrix C of the system.
-        D : input rank-2 array('d') with bounds (p,m)
-            The leading p-by-m part of this array must contain the direct
-            transmission matrix D of the system.
-
-    Optional arguments
-    ------------------
-
-        tol : The absolute tolerance level below which the elements of
-              B are considered zero (used for controllability tests).
-              If the user sets tol <= 0, then an implicitly computed,
-              default tolerance, defined by  toldef = n*eps*norm(B),
-              is used instead, where eps is the machine precision
-              (see LAPACK Library routine DLAMCH) and norm(B) denotes
-              the 1-norm of B.
+    Parameters
+    ----------
+    dico : {'D', 'C'}
+        Indicate whether the system is discrete 'D' or continuous 'C'.
+    jobn : {'H', 'L'}
+        H2-norm 'H' or L2-norm 'L' to be computed.
+    n : int
+        The number of state variables.  n >= 0.
+    m : int
+        The number of system inputs.  m >= 0.
+    p : int
+        The number of system outputs.  p >= 0.
+    A : (n,n) ndarray
+        The leading n-by-n part of this array must contain the state
+        dynamics matrix A of the system.
+    B : (n,m) ndarray
+        The leading n-by-m part of this array must contain the input/state
+        matrix B of the system.
+    C : (p,n) ndarray
+        The leading p-by-n part of this array must contain the state/output
+        matrix C of the system.
+    D : (p,m) ndarray
+        The leading p-by-m part of this array must contain the direct
+        transmission matrix D of the system.
+    tol : float, optional
+        The absolute tolerance level below which the elements of
+        B are considered zero (used for controllability tests).
+        If the user sets tol <= 0, then an implicitly computed,
+        default tolerance, defined by  toldef = n*eps*norm(B),
+        is used instead, where eps is the machine precision
+        (see LAPACK Library routine DLAMCH) and norm(B) denotes
+        the 1-norm of B.
 
     Returns
     -------
-
-        norm:  H2 or L2 norm of thes ystem (A,B,C,D)
+    norm:  H2 or L2 norm of the system (A,B,C,D)
 
     Raises
     ------
@@ -1493,9 +1488,9 @@ def ab13dd(dico, jobe, equil, jobd, n, m, p, A, E, B, C, D, tol = 1e-10):
     if jobd != 'D' and jobd != 'Z':
         raise SlycotParameterError('jobd must be "D" or "Z"', -4)
     out = _wrapper.ab13dd(dico, jobe, equil, jobd,
-                          n, m, p, [0.0, 1.0], A, E, B, C, D, tol)    
+                          n, m, p, [0.0, 1.0], A, E, B, C, D, tol)
     raise_if_slycot_error(out[-1], arg_list, ab13dd.__doc__)
-    
+
     fpeak = out[0][0] if out[0][1] > 0 else float('inf')
     gpeak = out[1][0] if out[1][1] > 0 else float('inf')
     return gpeak, fpeak
@@ -1509,15 +1504,15 @@ def ab13ed(n, A, tol = 9.0):
     the nearest complex matrix with an eigenvalue on the imaginary
     axis. The estimate is given as
 
-         low <= beta(A) <= high,
+         ``low <= beta(A) <= high,``
 
     where either
 
-         (1 + tol) * low >= high,
+         ``(1 + tol) * low >= high,``
 
     or
 
-         low = 0   and   high = delta,
+         ``low = 0   and   high = delta,``
 
     and delta is a small number approximately equal to the square root
     of machine precision times the Frobenius norm (Euclidean norm)
@@ -1526,40 +1521,38 @@ def ab13ed(n, A, tol = 9.0):
     to the nearest unstable complex matrix, i.e., the complex
     stability radius.
 
-    Required arguments:
-        n : input int
-            The order of the matrix A.  n >= 0.
-        A : input rank-2 array('d') with bounds (n,n)
-            The leading n-by-n part of this array must contain the matrix A.
-
-    Optional arguments:
-        tol : Specifies the accuracy with which low and high approximate
-              beta(A). If the user sets tol to be less than sqrt(eps),
-              where eps is the machine precision (see LAPACK Library
-              Routine DLAMCH), then the tolerance is taken to be
-              sqrt(eps).
-              The recommended value is tol = 9, which gives an estimate
-              of beta(A) correct to within an order of magnitude.
+    Parameters
+    ----------
+    n : int
+        The order of the matrix A.  ``n >= 0.``
+    A : (n,n) array_like
+        The leading n-by-n part of this array must contain the matrix A.
+    tol : float optional
+        Specifies the accuracy with which low and high approximate
+        beta(A). If the user sets tol to be less than sqrt(eps),
+        where eps is the machine precision (see LAPACK Library
+        Routine DLAMCH), then the tolerance is taken to be
+        sqrt(eps).
+        The recommended value is tol = 9, which gives an estimate
+        of beta(A) correct to within an order of magnitude.
 
-    Return objects:
-        low : float
-              A lower bound for beta(A).
-        high : float
-               An upper bound for beta(A).
+    Returns
+    -------
+    low : float
+          A lower bound for beta(A).
+    high : float
+           An upper bound for beta(A).
 
     Raises
     ------
-
-    SlycotParameterError
-        :info = -i: the i-th argument had an illegal value;
     SlycotArithmeticError
         :info = 1:
             The QR algorithm fails to converge
     """
     hidden = ' (hidden by the wrapper)'
     arg_list = ['n', 'A', 'lda' + hidden, 'low' + hidden, 'high' + hidden, 'tol',
                 'dwork' + hidden, 'ldwork' + hidden, 'info' + hidden]
-    out = _wrapper.ab13ed(n, A, tol)                
+    out = _wrapper.ab13ed(n, A, tol)
     raise_if_slycot_error(out[-1], arg_list, ab13ed.__doc__)
     return out[:-1]
 
@@ -1616,6 +1609,7 @@ def ab13fd(n, A, tol = 0.0):
     SlycotArithmeticError
         :info = 2:
             Either the QR or SVD algorithm fails to converge
+
     Warns
     -----
     SlycotResultWarning

diff --git a/slycot/exceptions.py b/slycot/exceptions.py
diff --git a/slycot/math.py b/slycot/math.py
@@ -183,8 +183,8 @@ def mb03rd(n, A, X=None, jobx='U', sort='N', pmax=1.0, tol=0.0):
 
     **Numerical Aspects**
 
-    The algorithm usually requires :math:`\mathcal{O}(N^3)` operations,
-    but :math:`\mathcal{O}(N^4)` are
+    The algorithm usually requires :math:`\\mathcal{O}(N^3)` operations,
+    but :math:`\\mathcal{O}(N^4)` are
     possible in the worst case, when all diagonal blocks in the real
     Schur form of `A` are 1-by-1, and the matrix cannot be diagonalized
     by well-conditioned transformations.
@@ -206,7 +206,7 @@ def mb03rd(n, A, X=None, jobx='U', sort='N', pmax=1.0, tol=0.0):
 
     **Revisions**
 
-    \V. Sima, Research Institute for Informatics, Bucharest, Apr. 2003.
+    \\V. Sima, Research Institute for Informatics, Bucharest, Apr. 2003.
 
     References
     ----------

diff --git a/slycot/src/AB08MZ.f b/slycot/src/AB08MZ.f
diff --git a/slycot/src/AB08NZ.f b/slycot/src/AB08NZ.f
diff --git a/slycot/src/AB8NXZ.f b/slycot/src/AB8NXZ.f
diff --git a/slycot/src/AG08BZ.f b/slycot/src/AG08BZ.f
diff --git a/slycot/src/AG8BYZ.f b/slycot/src/AG8BYZ.f
diff --git a/slycot/src/MA02BZ.f b/slycot/src/MA02BZ.f
diff --git a/slycot/src/MA02CZ.f b/slycot/src/MA02CZ.f
diff --git a/slycot/src/MA02ID.f b/slycot/src/MA02ID.f
diff --git a/slycot/src/MA02JD.f b/slycot/src/MA02JD.f
diff --git a/slycot/src/MB01MD.f b/slycot/src/MB01MD.f
diff --git a/slycot/src/MB01ND.f b/slycot/src/MB01ND.f
diff --git a/slycot/src/MB01UX.f b/slycot/src/MB01UX.f
diff --git a/slycot/src/MB03TD.f b/slycot/src/MB03TD.f
diff --git a/slycot/src/MB03TS.f b/slycot/src/MB03TS.f
diff --git a/slycot/src/MB03WA.f b/slycot/src/MB03WA.f
diff --git a/slycot/src/MB03XD.f b/slycot/src/MB03XD.f
diff --git a/slycot/src/MB03XP.f b/slycot/src/MB03XP.f
diff --git a/slycot/src/MB03XU.f b/slycot/src/MB03XU.f
diff --git a/slycot/src/MB03YA.f b/slycot/src/MB03YA.f
diff --git a/slycot/src/MB03YD.f b/slycot/src/MB03YD.f
diff --git a/slycot/src/MB03YT.f b/slycot/src/MB03YT.f
diff --git a/slycot/src/MB03ZA.f b/slycot/src/MB03ZA.f
diff --git a/slycot/src/MB03ZD.f b/slycot/src/MB03ZD.f
diff --git a/slycot/src/MB04DD.f b/slycot/src/MB04DD.f
diff --git a/slycot/src/MB04DI.f b/slycot/src/MB04DI.f
diff --git a/slycot/src/MB04DS.f b/slycot/src/MB04DS.f
diff --git a/slycot/src/MB04IZ.f b/slycot/src/MB04IZ.f
diff --git a/slycot/src/MB04PA.f b/slycot/src/MB04PA.f
diff --git a/slycot/src/MB04PB.f b/slycot/src/MB04PB.f
diff --git a/slycot/src/MB04PU.f b/slycot/src/MB04PU.f
diff --git a/slycot/src/MB04QB.f b/slycot/src/MB04QB.f
diff --git a/slycot/src/MB04QC.f b/slycot/src/MB04QC.f
diff --git a/slycot/src/MB04QF.f b/slycot/src/MB04QF.f
diff --git a/slycot/src/MB04QU.f b/slycot/src/MB04QU.f
diff --git a/slycot/src/MB04TB.f b/slycot/src/MB04TB.f
diff --git a/slycot/src/MB04TS.f b/slycot/src/MB04TS.f
diff --git a/slycot/src/MB04WD.f b/slycot/src/MB04WD.f
diff --git a/slycot/src/MB04WP.f b/slycot/src/MB04WP.f
diff --git a/slycot/src/MB04WR.f b/slycot/src/MB04WR.f
diff --git a/slycot/src/MB04WU.f b/slycot/src/MB04WU.f
diff --git a/slycot/src/MB3OYZ.f b/slycot/src/MB3OYZ.f
diff --git a/slycot/src/MB3PYZ.f b/slycot/src/MB3PYZ.f
diff --git a/slycot/src/SB04OW.f b/slycot/src/SB04OW.f
diff --git a/slycot/src/TB01IZ.f b/slycot/src/TB01IZ.f
diff --git a/slycot/src/TB01XZ.f b/slycot/src/TB01XZ.f
diff --git a/slycot/src/TG01AZ.f b/slycot/src/TG01AZ.f
diff --git a/slycot/src/TG01FZ.f b/slycot/src/TG01FZ.f
diff --git a/slycot/src/UD01MZ.f b/slycot/src/UD01MZ.f
diff --git a/slycot/src/UE01MD.f b/slycot/src/UE01MD.f
diff --git a/slycot/synthesis.py b/slycot/synthesis.py
@@ -768,11 +768,6 @@ def sb03md(n,C,A,U,dico,job='X',fact='N',trana='N',ldwork=None):
         w : rank-1 array('c'), shape  (n)
             If fact = 'N', this array contain the eigenvalues of A.
 
-    Raises
-    ------
-    SlycotParameterError
-        :info = -i: the i-th argument had an illegal value;
-
     Warns
     -----
     SlycotResultWarning
@@ -1549,19 +1544,19 @@ def sb10hd(n,m,np,ncon,nmeas,A,B,C,D,tol=0.0,ldwork=None):
     ------
     SlycotArithmeticError
         :info = 1:
-            if the matrix D12 had not full column rank in
+            The matrix D12 had not full column rank in
             respect to the tolerance tol;
         :info = 2:
-            if the matrix D21 had not full row rank in respect
+            The matrix D21 had not full row rank in respect
             to the tolerance tol;
         :info = 3:
-            if the singular value decomposition (SVD) algorithm
+            The singular value decomposition (SVD) algorithm
             did not converge (when computing the SVD of one of
             the matrices D12 or D21).
         :info = 4:
-            if the X-Riccati equation was not solved successfully;
+            The X-Riccati equation was not solved successfully;
         :info = 5:
-            if the Y-Riccati equation was not solved successfully.
+            The Y-Riccati equation was not solved successfully.
     """
 
     hidden = ' (hidden by the wrapper)'

diff --git a/slycot/tests/__init__.py b/slycot/tests/__init__.py