
    ^Mhp                         d Z ddlZddlZddlmZmZmZmZm	Z	 ddl
mZmZmZ ddlmZ ddlmZ ddlmZ dd	lmZ dd
lmZ ddlmZ ddlmZ g dZd Zd ZeZd Z d Z!ddZ"ddZ#ddZ$ddZ%dS )zMatrix equation solver routines    N)invLinAlgErrornormcondsvd   )solvesolve_triangularmatrix_balance)get_lapack_funcs)schur)lu)qr)ordqz)_asarray_validated)
block_diag)solve_sylvestersolve_continuous_lyapunovsolve_discrete_lyapunovsolve_lyapunovsolve_continuous_aresolve_discrete_arec                 |   | j         dk    s|j         dk    rkt          j        t          j        t          j        t          j        d}t          d| ||f          \  }t          j        |j        ||j	                           S t          | d          \  }}t          |                                                                d          \  }}t          j        t          j        |                                                                |          |          }	t          d|||	f          \  }
|
t          d	           |
|||	d
          \  }}}||z  }|dk     rt          d| fz            t          j        t          j        ||          |                                                                          S )a  
    Computes a solution (X) to the Sylvester equation :math:`AX + XB = Q`.

    Parameters
    ----------
    a : (M, M) array_like
        Leading matrix of the Sylvester equation
    b : (N, N) array_like
        Trailing matrix of the Sylvester equation
    q : (M, N) array_like
        Right-hand side

    Returns
    -------
    x : (M, N) ndarray
        The solution to the Sylvester equation.

    Raises
    ------
    LinAlgError
        If solution was not found

    Notes
    -----
    Computes a solution to the Sylvester matrix equation via the Bartels-
    Stewart algorithm. The A and B matrices first undergo Schur
    decompositions. The resulting matrices are used to construct an
    alternative Sylvester equation (``RY + YS^T = F``) where the R and S
    matrices are in quasi-triangular form (or, when R, S or F are complex,
    triangular form). The simplified equation is then solved using
    ``*TRSYL`` from LAPACK directly.

    .. versionadded:: 0.11.0

    Examples
    --------
    Given `a`, `b`, and `q` solve for `x`:

    >>> import numpy as np
    >>> from scipy import linalg
    >>> a = np.array([[-3, -2, 0], [-1, -1, 3], [3, -5, -1]])
    >>> b = np.array([[1]])
    >>> q = np.array([[1],[2],[3]])
    >>> x = linalg.solve_sylvester(a, b, q)
    >>> x
    array([[ 0.0625],
           [-0.5625],
           [ 0.6875]])
    >>> np.allclose(a.dot(x) + x.dot(b), q)
    True

    r   sdcztrsylarraysdtyperealoutputNzQLAPACK implementation does not contain a proper Sylvester equation solver (TRSYL)Ctranbz(Illegal value encountered in the %d term)sizenpfloat32float64	complex64
complex128r   emptyshapetypecoder   conj	transposedotRuntimeErrorr   )abqtdictfuncrur   vfr    yscaleinfos                 U/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/scipy/linalg/_solvers.pyr   r      s   l 	v{{afkkjrzl8 8 Q1I>>>xuT]';<<<< 6"""DAq ##%%f555DAq 	rvaffhh((**A..22A j1a)44FE} ? @ @ 	@U1a#...NAudaAaxx (,05(3 4 4 	4 6"&A,, 2 2 4 4555    c                    t          j        t          | d                    } t          j        t          |d                    }t          }t	          | |f          D ]L\  }}t          j        |          rt          }t          j        |j         st          dd|          d          M| j        |j        k    rt          d          | j
        dk    rjt           j        t           j        t           j        t           j        d}t          d	| |f
          \  }t          j        | j        ||j                           S t%          | d          \  }}|                                j                            |                    |                    }	t          d||	f          }
|t          u rdnd} |
|||	|          \  }}}|dk     rt          d|  d          |dk    rt-          j        dt0          d           ||z  }|                    |                              |                                j                  S )a  
    Solves the continuous Lyapunov equation :math:`AX + XA^H = Q`.

    Uses the Bartels-Stewart algorithm to find :math:`X`.

    Parameters
    ----------
    a : array_like
        A square matrix

    q : array_like
        Right-hand side square matrix

    Returns
    -------
    x : ndarray
        Solution to the continuous Lyapunov equation

    See Also
    --------
    solve_discrete_lyapunov : computes the solution to the discrete-time
        Lyapunov equation
    solve_sylvester : computes the solution to the Sylvester equation

    Notes
    -----
    The continuous Lyapunov equation is a special form of the Sylvester
    equation, hence this solver relies on LAPACK routine ?TRSYL.

    .. versionadded:: 0.11.0

    Examples
    --------
    Given `a` and `q` solve for `x`:

    >>> import numpy as np
    >>> from scipy import linalg
    >>> a = np.array([[-3, -2, 0], [-1, -1, 0], [0, -5, -1]])
    >>> b = np.array([2, 4, -1])
    >>> q = np.eye(3)
    >>> x = linalg.solve_continuous_lyapunov(a, q)
    >>> x
    array([[ -0.75  ,   0.875 ,  -3.75  ],
           [  0.875 ,  -1.375 ,   5.3125],
           [ -3.75  ,   5.3125, -27.0625]])
    >>> np.allclose(a.dot(x) + x.dot(a.T), q)
    True
    Tcheck_finiteMatrix aq should be square.*Matrix a and q should have the same shape.r   r   r   r!   r#   r%   r&   r    Tr(   r)   zH?TRSYL exited with the internal error "illegal value in argument number z8.". See LAPACK documentation for the ?TRSYL error codes.r   zInput "a" has an eigenvalue pair whose sum is very close to or exactly zero. The solution is obtained via perturbing the coefficients.   )
stacklevel)r,   
atleast_2dr   float	enumerateiscomplexobjcomplexequalr2   
ValueErrorr+   r-   r.   r/   r0   r   r1   r3   r   r4   rM   r6   warningswarnRuntimeWarning)r8   r:   r_or_cind_r;   r<   r=   r>   r@   r    dtype_stringrA   rB   rC   s                  rD   r   r   s   sS   d 	(>>>??A
(>>>??AFQF## F FQ?1 	Fx! 	FDtCyDDDEEE	F 	w!'EFFF 	v{{jrzl8 8 QF;;;xuT]';<<<< 6"""DAq 	

quuQxx  A Wq!f--E E//33sLU1a,777NAudaxx L?CeL L L M M 	M 
 B %	4 	4 	4 	4 JA5588<<
###rE   c                    t          j        | |                                           }t          j        |j        d                   |z
  }t          ||                                          }t          j        ||j                  S )z
    Solves the discrete Lyapunov equation directly.

    This function is called by the `solve_discrete_lyapunov` function with
    `method=direct`. It is not supposed to be called directly.
    r   )r,   kronr4   eyer2   r	   flattenreshape)r8   r:   lhsxs       rD   _solve_discrete_lyapunov_directre      sb     '!QVVXX

C
&1


$Cc199;;A:a!!!rE   c           	         t          j        | j        d                   }|                                                                 }t          ||z             }t          j        ||z
  |          }dt          j        t          j        t          | |z             |          |          z  }t          |                                                                |           S )z
    Solves the discrete Lyapunov equation using a bilinear transformation.

    This function is called by the `solve_discrete_lyapunov` function with
    `method=bilinear`. It is not supposed to be called directly.
    r   rN   )r,   r`   r2   r4   r5   r   r6   r   )r8   r:   r`   aHaHI_invr9   r   s          rD   !_solve_discrete_lyapunov_bilinearri      s     &

C	
				B"s(mmG
rCx!!A	"&AGa(('
2
22A!&&((,,..333rE   c                 .   t          j        |           } t          j        |          }|| j        d         dk    rd}nd}|                                }|dk    rt	          | |          }n)|dk    rt          | |          }nt          d|           |S )a	  
    Solves the discrete Lyapunov equation :math:`AXA^H - X + Q = 0`.

    Parameters
    ----------
    a, q : (M, M) array_like
        Square matrices corresponding to A and Q in the equation
        above respectively. Must have the same shape.

    method : {'direct', 'bilinear'}, optional
        Type of solver.

        If not given, chosen to be ``direct`` if ``M`` is less than 10 and
        ``bilinear`` otherwise.

    Returns
    -------
    x : ndarray
        Solution to the discrete Lyapunov equation

    See Also
    --------
    solve_continuous_lyapunov : computes the solution to the continuous-time
        Lyapunov equation

    Notes
    -----
    This section describes the available solvers that can be selected by the
    'method' parameter. The default method is *direct* if ``M`` is less than 10
    and ``bilinear`` otherwise.

    Method *direct* uses a direct analytical solution to the discrete Lyapunov
    equation. The algorithm is given in, for example, [1]_. However, it requires
    the linear solution of a system with dimension :math:`M^2` so that
    performance degrades rapidly for even moderately sized matrices.

    Method *bilinear* uses a bilinear transformation to convert the discrete
    Lyapunov equation to a continuous Lyapunov equation :math:`(BX+XB'=-C)`
    where :math:`B=(A-I)(A+I)^{-1}` and
    :math:`C=2(A' + I)^{-1} Q (A + I)^{-1}`. The continuous equation can be
    efficiently solved since it is a special case of a Sylvester equation.
    The transformation algorithm is from Popov (1964) as described in [2]_.

    .. versionadded:: 0.11.0

    References
    ----------
    .. [1] "Lyapunov equation", Wikipedia,
       https://en.wikipedia.org/wiki/Lyapunov_equation#Discrete_time
    .. [2] Gajic, Z., and M.T.J. Qureshi. 2008.
       Lyapunov Matrix Equation in System Stability and Control.
       Dover Books on Engineering Series. Dover Publications.

    Examples
    --------
    Given `a` and `q` solve for `x`:

    >>> import numpy as np
    >>> from scipy import linalg
    >>> a = np.array([[0.2, 0.5],[0.7, -0.9]])
    >>> q = np.eye(2)
    >>> x = linalg.solve_discrete_lyapunov(a, q)
    >>> x
    array([[ 0.70872893,  1.43518822],
           [ 1.43518822, -2.4266315 ]])
    >>> np.allclose(a.dot(x).dot(a.T)-x, -q)
    True

    Nr   
   bilineardirectzUnknown solver )r,   asarrayr2   lowerre   ri   rV   )r8   r:   methodmethrd   s        rD   r   r      s    L 	
1A

1A~71:FFF<<>>Dx+Aq11			-a333633444HrE   Tc           
         t          | |||||d          \
  } }}}}}}}}	}
t          j        d|z  |z   d|z  |z   f|	          }| |d|d|f<   d|d||d|z  f<   ||d|d|z  df<   | ||d|z  d|f<   |                                 j         ||d|z  |d|z  f<   |dn| ||d|z  d|z  df<   |dn|                                j        |d|z  dd|f<   |                                j        |d|z  d|d|z  f<   ||d|z  dd|z  df<   |
r?|=t          ||                                j        t          j        ||	                    }n9t          t          j        d|z            t          j        ||	                    }|rt          j        |          t          j        |          z   }t          j	        |d           t          |dd          \  }\  }}t          j        |t          j        |                    st          j        |          }t          j        ||d|z           |d|         z
  dz            }dt          j        || |d|z  d         f         z  }|dddf         t          j        |          z  }||z  }||z  }t#          |dd| df                   \  }}|dd|df                                         j                            |dddd|z  f                   }|dd|z  |df                                         j                            |dd|z  dd|z  f                   }|	t&          u rd	nd
}t)          ||dddd|          \  }}}}}}|Qt#          t          j        |                    |d|d|f                   ||dd|f         f                    \  }}|d|d|f         }||dd|f         }t-          |          \  }}}dt/          |          z  t          j        d          k     rt3          d          t5          |                                j        t5          |                                j        |                                j        d          d                                          j                            |                                j                  }|r||d|df         |d|         z  z  }|                                j                            |          }t7          |d          }||                                j        z
  }t          j        t          j        d          d|z  g          }t7          |d          |k    rt3          d          ||                                j        z   dz  S )a  
    Solves the continuous-time algebraic Riccati equation (CARE).

    The CARE is defined as

    .. math::

          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 :math:`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

    .. math::

          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]_, :math:`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 :math:`U_2 U_1^{-1}` and condition number of
    :math:`U_1`. Here, :math:`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
    :math:`H` and :math:`J` entries (after removing the diagonal entries of
    the sum) is balanced following the recipe given in [3]_.

    .. versionadded:: 0.11.0

    References
    ----------
    .. [1]  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`:

    >>> import numpy as np
    >>> 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

    carerN   r#   N        r   r   separatepermuter%   rT   lhpTFsortoverwrite_aoverwrite_brH   r'         ?!Failed to find a finite solution.ro   unit_diagonal     @@皙?zQThe associated Hamiltonian pencil has eigenvalues too close to the imaginary axis)_are_validate_argsr,   r1   r4   rM   r   
zeros_liker`   absfill_diagonalr   allclose	ones_likelog2roundr_
reciprocalr   r6   rQ   r   vstackr   r   spacingr   r
   r   max)r8   r9   r:   r=   er   balancedmnrZ   gen_areHJMr\   scaelwisescaleout_strr>   u00u10upuluurd   u_symn_u_symsym_thresholds                               rD   r   r   S  s   p /A561aAv/O /O+Aq!Q1aFG 	!A#a%1Qv...AAbqb"1"fIAbqb!AaC%iLAbqb!A#$$hK2Aa!eRaRiLvvxxzkAa!eQqsUlO9RR1"Aa!eQqSTTkN	""qvvxxzAacddBQBhKVVXXZAacddAacEkNAacddAaCDDjM D1=q!&&((*bmAV&D&D&DEErvac{{BM!6$B$B$BCC  F1IIq		!
B$QA>>>8C{3S 1 122 
	 '#,,C#a!e*s2A2w.122AruQC!I-..Caaag,s););;KAA aA233i==DAq	!!!QRR%a4AaC4j))A	$1Q3$(  4AaC4!A#://A %ffYGQ4)-E$+- - -Aq!Q1
 	}")QUU1RaR!V9--qRaRy9::;;1
BQBF)C
ABBF)C CJBBbzBJrNN""=>>> 	)"''))+*-((**,046 6 6 (,		 	 	
  466!CC		$4$4   %	S!T]S!W$$ HHJJLS!!E5!nnGEJJLLN"EFBJu--s7{;<<ME1~~%% < = = 	= 
NArE   c           
      X   t          | |||||d          \
  } }}}}}}}}	}
t          j        d|z  |z   d|z  |z   f|	          }| |d|d|f<   ||d|d|z  df<   | ||d|z  d|f<   |t          j        |          n|                                j        ||d|z  |d|z  f<   |dn| ||d|z  d|z  df<   |dn|                                j        |d|z  dd|f<   ||d|z  dd|z  df<   t          j        ||	          }|t          j        |          n||d|d|f<   |                                 j        ||d|z  |d|z  f<   |                                j         |d|z  d|d|z  f<   |rt          j        |          t          j        |          z   }t          j        |d           t          |dd          \  }\  }}t          j
        |t          j        |                    st          j        |          }t          j        ||d|z           |d|         z
  dz            }dt          j        || |d|z  d         f         z  }|dddf         t          j        |          z  }||z  }||z  }t!          |dd| df                   \  }}|dd|df                                         j                            |dddd|z  f                   }|dd|df                                         j                            |dddd|z  f                   }|	t$          u rd	nd
}t'          ||dddd|          \  }}}}}}|Qt!          t          j        |                    |d|d|f                   ||dd|f         f                    \  }}|d|d|f         }||dd|f         }t+          |          \  }}}dt-          |          z  t          j        d          k     rt1          d          t3          |                                j        t3          |                                j        |                                j        d          d                                          j                            |                                j                  }|r||d|df         |d|         z  z  }|                                j                            |          }t5          |d          }||                                j        z
  }t          j        t          j        d          d|z  g          }t5          |d          |k    rt1          d          ||                                j        z   dz  S )al  
    Solves the discrete-time algebraic Riccati equation (DARE).

    The DARE is defined as

    .. math::

          A^HXA - X - (A^HXB) (R + B^HXB)^{-1} (B^HXA) + Q = 0

    The limitations for a solution to exist are :

        * All eigenvalues of :math:`A` outside the unit disc, should be
          controllable.

        * The associated symplectic pencil (See Notes), should have
          eigenvalues sufficiently away from the unit circle.

    Moreover, if ``e`` and ``s`` are not both precisely ``None``, then the
    generalized version of DARE

    .. math::

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

    is solved. When omitted, ``e`` is assumed to be the identity and ``s``
    is assumed to be the zero matrix.

    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
        Square matrix
    e : (M, M) array_like, optional
        Nonsingular square matrix
    s : (M, N) array_like, optional
        Input
    balanced : bool
        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 discrete 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_continuous_are : Solves the continuous algebraic Riccati equation

    Notes
    -----
    The equation is solved by forming the extended symplectic matrix pencil,
    as described in [1]_, :math:`H - \lambda J` given by the block matrices ::

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

    and using a QZ decomposition method.

    In this algorithm, the fail conditions are linked to the symmetry
    of the product :math:`U_2 U_1^{-1}` and condition number of
    :math:`U_1`. Here, :math:`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
    :math:`H` and :math:`J` rows/cols (after removing the diagonal entries)
    is balanced following the recipe given in [3]_. If the data has small
    numerical noise, balancing may amplify their effects and some clean up
    is required.

    .. versionadded:: 0.11.0

    References
    ----------
    .. [1]  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`:

    >>> import numpy as np
    >>> from scipy import linalg as la
    >>> a = np.array([[0, 1], [0, -1]])
    >>> b = np.array([[1, 0], [2, 1]])
    >>> q = np.array([[-4, -4], [-4, 7]])
    >>> r = np.array([[9, 3], [3, 1]])
    >>> x = la.solve_discrete_are(a, b, q, r)
    >>> x
    array([[-4., -4.],
           [-4.,  7.]])
    >>> R = la.solve(r + b.T.dot(x).dot(b), b.T.dot(x).dot(a))
    >>> np.allclose(a.T.dot(x).dot(a) - x - a.T.dot(x).dot(b).dot(R), -q)
    True

    darerN   r#   Nrt   r   r   ru   r%   rT   iucTFry   r}   r~   r   r   r   r   zMThe associated symplectic pencil has eigenvalues too close to the unit circle)r   r,   zerosr`   r4   rM   r   r   r   r   r   r   r   r   r   r   r   r6   rQ   r   r   r   r   r   r   r
   r   r   )r8   r9   r:   r=   r   r   r   r   r   rZ   r   r   r   r   r\   r   r   q_of_qrr   r>   r   r   r   r   r   rd   r   r   r   s                                rD   r   r      s   t /A561aAv/O /O+Aq!Q1aFG 	!A#a%1Qv...AAbqb"1"fIAbqb!A#$$hK2Aa!eRaRiL#$9bfQiii!&&((*Aa!eQqsUlO9RR1"Aa!eQqSTTkN	""qvvxxzAacddBQBhKAacddAaCDDjM
av&&&AYq			AAbqb"1"fIffhhjAa!eQqsUlOffhhj[AacddAacEkN  F1IIq		!
B$QA>>>8C{3S 1 122 
	 '#,,C#a!e*s2A2w.122AruQC!I-..Caaag,s););;KAA Aaaa!fIJGQ122##Aaaa!A#gJ//A122##Aaaa!A#gJ//A %ffYGQ)-)-*/$+	- - -Aq!Q1 	}")QUU1RaR!V9--qRaRy9::;;1
BQBF)C
ABBF)C CJBBbzBJrNN""=>>> 	)"''))+*-((**,046 6 6 (,		 	 	
  466!CC		$4$4   %	S!T]S!W$$ HHJJLS!!E5!nnGEJJLLN"EFBJu--s7{;<<ME1~~%% 9 : : 	: 
NArE   rs   c           
         |                                 dvrt          d          t          j        t	          | d                    } t          j        t	          |d                    }t          j        t	          |d                    }t          j        t	          |d                    }t          j        |          rt          nt          }t          | ||f          D ]L\  }}	t          j        |	          rt          }t          j	        |	j
         st          dd|          d          M|j
        \  }
}|
| j
        d         k    rt          d	          |
|j
        d         k    rt          d
          ||j
        d         k    rt          d          t          ||f          D ]o\  }}	t          |	|	                                j        z
  d          t          j        t          |	d                    dz  k    rt          dd|          d          p|dk    rUt          |d          d         }|dk    s)|t          j        d          t          |d          z  k     rt          d          |dup|du}|r6|t          j        t	          |d                    }t          j	        |j
         st          d          |
|j
        d         k    rt          d          t          |d          d         }|dk    s)|t          j        d          t          |d          z  k     rt          d          t          j        |          rt          }|]t          j        t	          |d                    }|j
        |j
        k    rt          d          t          j        |          rt          }| ||||||
|||f
S )a  
    A helper function to validate the arguments supplied to the
    Riccati equation solvers. Any discrepancy found in the input
    matrices leads to a ``ValueError`` exception.

    Essentially, it performs:

        - a check whether the input is free of NaN and Infs
        - a pass for the data through ``numpy.atleast_2d()``
        - squareness check of the relevant arrays
        - shape consistency check of the arrays
        - singularity check of the relevant arrays
        - symmetricity check of the relevant matrices
        - a check whether the regular or the generalized version is asked.

    This function is used by ``solve_continuous_are`` and
    ``solve_discrete_are``.

    Parameters
    ----------
    a, b, q, r, e, s : array_like
        Input data
    eq_type : str
        Accepted arguments are 'care' and 'dare'.

    Returns
    -------
    a, b, q, r, e, s : ndarray
        Regularized input data
    m, n : int
        shape of the problem
    r_or_c : type
        Data type of the problem, returns float or complex
    gen_or_not : bool
        Type of the equation, True for generalized and False for regular ARE.

    )r   rs   z;Equation type unknown. Only 'care' and 'dare' is understoodTrG   rI   aqrrK   r   z3Matrix a and b should have the same number of rows.rL   z3Matrix b and r should have the same number of cols.r   d   r   z should be symmetric/hermitian.rs   F)
compute_uvrt   r}   z!Matrix r is numerically singular.NzMatrix e should be square.z*Matrix a and e should have the same shape.z!Matrix e is numerically singular.z*Matrix b and s should have the same shape.)ro   rV   r,   rP   r   rS   rT   rQ   rR   rU   r2   r   r4   rM   r   r   )r8   r9   r:   r=   r   r   eq_typerZ   r[   matr   r   min_svgeneralized_cases                 rD   r   r     s   N }}... @ A A 	A 	(>>>??A
(>>>??A
(>>>??A
(>>>??A **5WWFq!Qi(( G GS?3 	Fx# 	GEuSzEEEFFF	G 7DAqAGAJNOOOAGAJEFFFAGAJNOOO q!f%% S SSchhjjl"A&&DaLL)A)A#)EEEQtCyQQQRRR F &Q5)))"-R<<6BJrNN41::$===@AAA }5 !=0FFFGGA8QW% ? !=>>>AGAJ !MNNN u---b1F||v
2a(CCC !DEEEq!! ! =0FFFGGAw!'!! !MNNNq!! ! aAq!Q6+;;;rE   )N)NNT)rs   )&__doc__rW   numpyr,   numpy.linalgr   r   r   r   r   _basicr	   r
   r   lapackr   _decomp_schurr   
_decomp_lur   
_decomp_qrr   
_decomp_qzr   _decompr   _special_matricesr   __all__r   r   r   re   ri   r   r   r   r    rE   rD   <module>r      s   % %      : : : : : : : : : : : : : : ; ; ; ; ; ; ; ; ; ; $ $ $ $ $ $                               ' ' ' ' ' ' ) ) ) ) ) )9 9 9R6 R6 R6j`$ `$ `$H +" " "4 4 4X X X XvJ J J JZN N N Nbh< h< h< h< h< h<rE   