
    Ugn                         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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)kron
block_diag)solve_sylvestersolve_continuous_lyapunovsolve_discrete_lyapunovsolve_lyapunovsolve_continuous_aresolve_discrete_arec                 z   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

    realoutput)trsylNzQLAPACK implementation does not contain a proper Sylvester equation solver (TRSYL)Ctranbr   z(Illegal value encountered in the %d term)r   conj	transposenpdotr   RuntimeErrorr   )abqrusvfr   yscaleinfos               T/var/www/surfInsights/venv3-11/lib/python3.11/site-packages/scipy/linalg/_solvers.pyr   r      s7   n 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 ][\  }}t          j        |          rt          }t          j        |j         s(t          d
                    d|                             \| j        |j        k    rt          d          t          | d          \  }}|                                j                            |                    |                    }t          d||f          }|t          k    rd	nd
}	 |||||	          \  }
}}|dk     rt          d|  d          |dk    rt!          j        dt$          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 {} should be square.aq*Matrix a and q should have the same shape.r   r   r   Tr   r    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equalshape
ValueErrorformatr   r"   r:   r%   r   warningswarnRuntimeWarning)r'   r)   r_or_cind_r*   r+   r.   r   dtype_stringr/   r0   r1   s                r2   r   r   m   s   d 	(>>>??A
(>>>??AFQF## N NQ?1 	Fx! 	N:AA$s)LLMMM	N 	w!'EFFF 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<<
###r3   c                    t          | |                                           }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   r"   r$   eyerC   r	   flattenreshape)r'   r)   lhsxs       r2   _solve_discrete_lyapunov_directrS      s`     q!&&((

C
&1


$Cc199;;A:a!!!r3   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   r;   )r$   rN   rC   r"   r#   r   r%   r   )r'   r)   rN   aHaHI_invr(   cs          r2   !_solve_discrete_lyapunov_bilinearrX      s     &

C	
				B"s(mmG
rCx!!A	"&AGa(('
2
22A!&&((,,..333r3   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|z            |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 %s)r$   asarrayrC   lowerrS   rX   rD   )r'   r)   methodmethrR   s        r2   r   r      s    L 	
1A

1A~71:FFF<<>>Dx+Aq11			-a33,v5666Hr3   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&          k    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

    carer;   dtypeN        r   r   separatepermuter   rA   lhpTFsortoverwrite_aoverwrite_br6   r         ?!Failed to find a finite solution.r^   unit_diagonal     @@皙?zQThe associated Hamiltonian pencil has eigenvalues too close to the imaginary axis)_are_validate_argsr$   emptyr"   r:   r   
zeros_likerN   absfill_diagonalr   allclose	ones_likelog2roundr_
reciprocalr   r%   r>   r   vstackr   r   spacingr   r
   r   max)r'   r(   r)   r*   er,   balancedmnrI   gen_areHJMrK   scaelwisescaleout_strr+   u00u10upuluurR   u_symn_u_symsym_thresholds                               r2   r   r   F  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r3   c           
      \   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$          k    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

    darer;   rc   Nre   r   r   rf   r   rA   iucTFrj   rn   ro   rp   rq   rs   rt   zMThe associated symplectic pencil has eigenvalues too close to the unit circle)ru   r$   zerosrN   r"   r:   rw   rx   ry   r   rz   r{   r|   r}   r~   r   r   r%   r>   r   r   r   r   r   r   r
   r   r   )r'   r(   r)   r*   r   r,   r   r   r   rI   r   r   r   r   rK   r   r   q_of_qrr   r+   r   r   r   r   r   rR   r   r   r   s                                r2   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r3   rb   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 ][\  }}	t          j        |	          rt          }t          j	        |	j
         s(t          d                    d|                             \|j
        \  }
}|
| j
        d         k    rt          d          |
|j
        d         k    rt          d	          ||j
        d         k    rt          d
          t          ||f          D ]~\  }}	t          |	|	                                j        z
  d          t          j        t          |	d                    dz  k    r(t          d                    d|                             |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   rb   z;Equation type unknown. Only 'care' and 'dare' is understoodTr5   r7   aqrr   z3Matrix a and b should have the same number of rows.r9   z3Matrix b and r should have the same number of cols.r   d   z(Matrix {} should be symmetric/hermitian.r   rb   F)
compute_uvre   rn   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.)r^   rD   r$   r=   r   r@   rA   r>   r?   rB   rC   rE   r   r"   r:   r   r   )r'   r(   r)   r*   r   r,   eq_typerI   rJ   matr   r   min_svgeneralized_cases                 r2   ru   ru     s   N }}... @ A A 	A 	(>>>??A
(>>>??A
(>>>??A
(>>>??A **5WWFq!Qi(( O OS?3 	Fx# 	O:AA%*MMNNN	O 7DAqAGAJNOOOAGAJEFFFAGAJNOOO q!f%% 3 3Schhjjl"A&&DaLL)A)A#)EEE   &tCy 1 13 3 3 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+;;;r3   )N)NNT)rb   )'__doc__rF   numpyr$   numpy.linalgr   r   r   r   r   _basicr	   r
   r   lapackr   _decomp_schurr   
_decomp_lur   
_decomp_qrr   
_decomp_qzr   _decompr   _special_matricesr   r   __all__r   r   r   rS   rX   r   r   r   ru    r3   r2   <module>r      s   % %      : : : : : : : : : : : : : : ; ; ; ; ; ; ; ; ; ; $ $ $ $ $ $                               ' ' ' ' ' ' / / / / / / / /9 9 9L6 L6 L6^Y$ Y$ Y$z +" " "4 4 4X X X XvJ J J JZN N N Nbi< i< i< i< i< i<r3   