# scipy.linalg.solve_continuous_are

scipy.linalg.solve_continuous_are(a, b, q, r, e=None, s=None, balanced=True)

  Solves the continuous-time algebraic Riccati equation (CARE).

  The CARE is defined as

  \[X A + A^H X - X B R^{-1} B^H X + Q = 0\]

  The limitations for a solution to exist are :

  > - All eigenvalues of \(A\) on the right half plane, should be controllable.

  > - The associated hamiltonian pencil (See Notes), should have eigenvalues sufficiently away from the imaginary axis.

  Moreover, if `e` or `s` is not precisely `None`, then the generalized version of CARE

  \[E^HXA + A^HXE - (E^HXB + S) R^{-1} (B^HXE + S^H) + Q = 0\]

  is solved. When omitted, `e` is assumed to be the identity and `s` is assumed to be the zero matrix with sizes compatible with `a` and `b`, respectively.

  Parameters
    a(M, M) array_like

      Square matrix

    b(M, N) array_like

      Input

    q(M, M) array_like

      Input

    r(N, N) array_like

      Nonsingular square matrix

    e(M, M) array_like, optional

      Nonsingular square matrix

    s(M, N) array_like, optional

      Input

    balanced bool, optional

      The boolean that indicates whether a balancing step is performed on the data. The default is set to True.

  Returns
    x(M, M) ndarray

      Solution to the continuous-time algebraic Riccati equation.

  Raises
    LinAlgError

      For cases where the stable subspace of the pencil could not be isolated. See Notes section and the references for details.

  See also

  `solve_discrete_are`

    Solves the discrete-time algebraic Riccati equation

  Notes

  The equation is solved by forming the extended hamiltonian matrix pencil, as described in [1], \(H - \lambda J\) given by the block matrices

      [ A    0    B ]             [ E   0    0 ]
      [-Q  -A^H  -S ] - \lambda * [ 0  E^H   0 ]
      [ S^H B^H   R ]             [ 0   0    0 ]

  and using a QZ decomposition method.

  In this algorithm, the fail conditions are linked to the symmetry of the product \(U_2 U_1^{-1}\) and condition number of \(U_1\). Here, \(U\) is the 2m-by-m matrix that holds the eigenvectors spanning the stable subspace with 2-m rows and partitioned into two m-row matrices. See [1] and [2] for more details.

  In order to improve the QZ decomposition accuracy, the pencil goes through a balancing step where the sum of absolute values of \(H\) and \(J\) entries (after removing the diagonal entries of the sum) is balanced following the recipe given in [3].

  New in version 0.11.0.

  References

  1(1,2)

    P. van Dooren , “A Generalized Eigenvalue Approach For Solving Riccati Equations.”, SIAM Journal on Scientific and Statistical Computing, Vol.2(2), DOI:10.1137/0902010

  2

    A.J. Laub, “A Schur Method for Solving Algebraic Riccati Equations.”, Massachusetts Institute of Technology. Laboratory for Information and Decision Systems. LIDS-R ; 859. Available online : http://hdl.handle.net/1721.1/1301

  3

    P. Benner, “Symplectic Balancing of Hamiltonian Matrices”, 2001, SIAM J. Sci. Comput., 2001, Vol.22(5), DOI:10.1137/S1064827500367993

  Examples

  Given a, b, q, and r solve for x:

      >>> from scipy import linalg
      >>> a = np.array([[4, 3], [-4.5, -3.5]])
      >>> b = np.array([[1], [-1]])
      >>> q = np.array([[9, 6], [6, 4.]])
      >>> r = 1
      >>> x = linalg.solve_continuous_are(a, b, q, r)
      >>> x
      array([[ 21.72792206,  14.48528137],
             [ 14.48528137,   9.65685425]])
      >>> np.allclose(a.T.dot(x) + x.dot(a)-x.dot(b).dot(b.T).dot(x), -q)
      True

scipy.linalg.solve_sylvester scipy.linalg.solve_discrete_are