U z|en@sdZddlZddlZddlmZmZmZmZm Z ddl m Z m Z m Z ddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZmZd dddddgZdd ZddZeZ ddZ!ddZ"d ddZ#d!ddZ$d"ddZ%d#ddZ&dS)$zMatrix equation solver routinesN)inv LinAlgErrornormcondsvd)solvesolve_triangularmatrix_balance)get_lapack_funcs)schur)lu)qr)ordqz)_asarray_validated)kron block_diagsolve_sylvestersolve_continuous_lyapunovsolve_discrete_lyapunovsolve_lyapunovsolve_continuous_aresolve_discrete_arec Cst|dd\}}t|dd\}}tt|||}td|||f\}|dkrftd||||dd\} } } | | } | dkrtd | ftt|| |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 realoutput)trsylNzQLAPACK implementation does not contain a proper Sylvester equation solver (TRSYL)CZtranbrz(Illegal value encountered in the %d term)r conj transposenpdotr RuntimeErrorr) abqrusvfryscaleinfor/R/var/www/website-v5/atlas_env/lib/python3.8/site-packages/scipy/linalg/_solvers.pyrs7c Cs&tt|dd}tt|dd}t}t||fD]4\}}t|rJt}tj|js4t d d|q4|j|jkr~t dt |dd\}}| j ||}td||f}|tkrd nd } ||||| d \} } } | d krt d | n| dkrtdt| | 9} || | 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_finiteMatrix {} should be square.Zaq*Matrix a and q should have the same shape.rrrTrrrz?TRSYL exited with the internal error "illegal value in argument number {}.". See LAPACK documentation for the ?TRSYL error codes.rzInput "a" has an eigenvalue pair whose sum is very close to or exactly zero. The solution is obtained via perturbing the coefficients.)r! atleast_2drfloat enumerate iscomplexobjcomplexequalshape ValueErrorformatr rr5r"r warningswarnRuntimeWarning) r$r&r_or_cind_r'r(r+rZ dtype_stringr,r-r.r/r/r0rms22    cCs>t||}t|jd|}t||}t||jS)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)rrr!eyer<rflattenreshape)r$r&lhsxr/r/r0_solve_discrete_lyapunov_directsrJcCslt|jd}|}t||}t|||}dttt||||}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!rEr<rr rr"r)r$r&rEZaHZaHI_invr%cr/r/r0!_solve_discrete_lyapunov_bilinears    rMcCstt|}t|}|dkr4|jddkr0d}nd}|}|dkrPt||}n |dkrdt||}n td||S)aE 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] Hamilton, James D. Time Series Analysis, Princeton: Princeton University Press, 1994. 265. Print. http://doc1.lbfl.li/aca/FLMF037168.pdf .. [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 ZbilineardirectzUnknown solver %s)r!asarrayr<lowerrJrMr=)r$r&methodmethrIr/r/r0rsG     Tc Cst||||||d\ }}}}}}}}} } tjd||d||f| d} || d|d|f<d| d||d|f<|| d|d|df<| | |d|d|f<|j | |d||d|f<|dkrdn| | |d|d|df<|dkrdn|j| d|dd|f<|j| d|d|d|f<|| d|dd|df<| r|dk rt||jtj|| d} nttd|tj|| d} |rzt| t| } d| t | <t | ddd\}\}}t |t |szt |}t||d||d|d}dtj|| |d|df}|dddft|}| |9} | |9} t| dd| df\}}|dd|dfj| dddd|f} |dd||dfj| dd|dd|f} | tkrd nd }t| | d d d d |d\}}}}}}|dk rtt||d|d|f||dd|ff\}}|d|d|f}||dd|f}t|\}}}dt|tdkrtdt|jt|j|jd dd dj|j}|r:||d|df|d|9}|j|}t|d}||j}ttdd|g}t|d|krtd||jdS)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 carerKdtypeNrrseparatepermuterr:lhpTFsort overwrite_a overwrite_br2r?!Failed to find a finite solution.rQ unit_diagonal@@皙?zQThe associated Hamiltonian pencil has eigenvalues too close to the imaginary axis)_are_validate_argsr!emptyrr5r zeros_likerEabsdiag_indices_fromr allclose ones_likelog2roundr_ reciprocalrr"r7rvstackr rspacingrr rmax)r$r%r&r'er)balancedmnrBgen_areHJMrDsca elwisescaleout_strr(u00u10upuluurIu_symn_u_sym sym_thresholdr/r/r0rHsx"$*," &"4<  <     c Cst||||||d\ }}}}}}}}} } tjd||d||f| d} || d|d|f<|| d|d|df<| | |d|d|f<|dkrt|n|j| |d||d|f<|dkrdn| | |d|d|df<|dkrdn|j| d|dd|f<|| d|dd|df<tj| | d} |dkrVt|n|| d|d|f<|j| |d||d|f<|j | d|d|d|f<|r~t| t| } d| t| <t | ddd\}\}}t |t |s~t |}t ||d||d|d}dtj|| |d|df}|dddft|}| |9} | |9} t| dd| df\}}|dd|dfj| dddd|f} |dd|dfj| dddd|f} | tkrd nd }t| | d d d d |d\}}}}}}|dk r~tt||d|d|f||dd|ff\}}|d|d|f}||dd|f}t|\}}}dt|tdkrtdt|jt|j|jd dd dj|j}|r6||d|df|d|9}|j|}t|d}||j}ttdd|g}t|d|krtd||jdS)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 darerKrUNrWrrrXrr:iucTFr\r`rarbrcrerfzLThe associated symplectic pencil has eigenvaluestoo close to the unit circle)rgr!zerosrErr5rirjrkr rlrmrnrorprqrr"r7rrrr rrsrr rrt)r$r%r&r'rur)rvrwrxrBryrzr{r|rDr}r~Zq_of_qrrr(rrrrrrIrrrr/r/r0rsz"4**("$ &"44 <     rTc Cs|dkrtdtt|dd}tt|dd}tt|dd}tt|dd}t|rjtnt}t|||fD]4\}} t| rt}tj | j s|td d|q||j \} } | |j dkrtd| |j dkrtd | |j dkrtd t||fD]F\}} t | | jd tt | d d kr td d|q |dkrt|ddd} | dks| tdt |d krtd|dk p|dk } | r|dk rFtt|dd}tj |j std| |j dkrtdt|ddd} | dks.| tdt |d kr6tdt|rFt}|dk rtt|dd}|j |j krxtdt|rt}||||||| | || 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. )rrTz;Equation type unknown. Only 'care' and 'dare' is understoodTr1r3Zaqrrz3Matrix a and b should have the same number of rows.r4z3Matrix b and r should have the same number of cols.rdz(Matrix {} should be symmetric/hermitian.rrTF) compute_uvrWr`z!Matrix r is numerically singular.NzMatrix 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.)rQr=r!r6rr9r:r7r8r;r<r>rrr5rsr)r$r%r&r'rur)Zeq_typerBrCmatrwrxZmin_svZgeneralized_caser/r/r0rgs`'    *  $ $   rg)N)NNT)NNT)rT)'__doc__r?numpyr! numpy.linalgrrrrr_basicrr r lapackr _decomp_schurr _decomp_lur _decomp_qrr _decomp_qzr_decompr_special_matricesrr__all__rrrrJrMrrrrgr/r/r/r0s:       O^ \ N R