Vpf$  ddlmZddlmZddlZddlZddlmZm Z m Z ddl Z ddl mZ ddl mZmZmZddl mZddlmZddlmZdd lmZdd lmZmZmZmZdd lmZmZej d Z!e!d zZ"eedddZ# dddZ$ dddZ%eeddd Z& ddd$Z'edd*Z(edd,Z(edd.Z(eed/dd0Z(e ddd4Z)e ddd5Z)edddd1d6dd7Z)e ddd8Z) ddd9Z)ddd:Z*eddAZ+eddCZ+eddEZ+eedFddGZ+e dddJZ,eddddddHddKddLZ,e dddMZ,e dddNZ, dddOZ,eedPddRZ-dddTZ.dddUZ/eedVdddWZ0eedX ddd\Z1edd^Z2edd_Z2eddaZ2eedbcdddZ2e dddeZ3e dddfZ3e dddgZ3eedh dddiZ3eddnZ4eddpZ4eddrZ4eedsddtZ4e dddxZ5e dddyZ5eddddzdd{Z5e ddd|Z5 ddd}Z5eed~ddZ6 dddZ7eedddZ8 dddZ9eeddddddZ:eddZ;dd dZ<d dZ=eedcd dZ>d dZ?d dZ@d dZAd dZBd dZCedddd dZDeddddZDedddddZDeeddddddZDeddZEeeddddddddZFeede jGddddddddZHeddZIeddZJdbdd„ZKeedìdddńZLedddVddDŽZMedddVddȄZMeedɬddddʜdd˄ZMddd̈́ZNeedάddЄZOdS() annotations)partialN)overloadAnyLiteral)jitvmapjvp)lax)dtypes)linalg)qdwh)check_arraylikepromote_dtypespromote_dtypes_inexactpromote_dtypes_complex)Array ArrayLikez Does not support the Scipy argument ``check_finite=True``, because compiled JAX code cannot perform checks of array values at runtime. z: Does not support the Scipy argument ``overwrite_*=True``.lower)static_argnamesarrboolreturnrcttj|\}tj|r|ntj|jd}|r|ntj|jS)NF)symmetrize_input)rjnpasarray lax_linalgcholeskyconjmT)rrls U/var/www/html/nettyfy-visnx/env/lib/python3.11/site-packages/jax/_src/scipy/linalg.py _choleskyr%*sZck!nn--"!u8!!#(14..5QQQ! '!$'FT overwrite_a check_finitec&~~t||S)aCompute the Cholesky decomposition of a matrix. JAX implementation of :func:`scipy.linalg.cholesky`. The Cholesky decomposition of a matrix `A` is: .. math:: A = U^HU = LL^H where `U` is an upper-triangular matrix and `L` is a lower-triangular matrix. Args: a: input array, representing a (batched) positive-definite hermitian matrix. Must have shape ``(..., N, N)``. lower: if True, compute the lower Cholesky decomposition `L`. if False (default), compute the upper Cholesky decomposition `U`. overwrite_a: unused by JAX check_finite: unused by JAX Returns: array of shape ``(..., N, N)`` representing the cholesky decomposition of the input. See Also: - :func:`jax.numpy.linalg.cholesky`: NumPy-stype Cholesky API - :func:`jax.lax.linalg.cholesky`: XLA-style Cholesky API - :func:`jax.scipy.linalg.cho_factor` - :func:`jax.scipy.linalg.cho_solve` Examples: A small real Hermitian positive-definite matrix: >>> x = jnp.array([[2., 1.], ... [1., 2.]]) Upper Cholesky factorization: >>> jax.scipy.linalg.cholesky(x) Array([[1.4142135 , 0.70710677], [0. , 1.2247449 ]], dtype=float32) Lower Cholesky factorization: >>> jax.scipy.linalg.cholesky(x, lower=True) Array([[1.4142135 , 0. ], [0.70710677, 1.2247449 ]], dtype=float32) Reconstructing ``x`` from its factorization: >>> L = jax.scipy.linalg.cholesky(x, lower=True) >>> jnp.allclose(x, L @ L.T) Array(True, dtype=bool) )r%rrr'r(s r$r r 1sp< 1e  r&tuple[Array, bool]c,~~t|||fS)aFactorization for Cholesky-based linear solves JAX implementation of :func:`scipy.linalg.cho_factor`. This function returns a result suitable for use with :func:`jax.scipy.linalg.cho_solve`. For direct Cholesky decompositions, prefer :func:`jax.scipy.linalg.cholesky`. Args: a: input array, representing a (batched) positive-definite hermitian matrix. Must have shape ``(..., N, N)``. lower: if True, compute the lower triangular Cholesky decomposition (default: False). overwrite_a: unused by JAX check_finite: unused by JAX Returns: ``(c, lower)``: ``c`` is an array of shape ``(..., N, N)`` representing the lower or upper cholesky decomposition of the input; ``lower`` is a boolean specifying whether this is the lower or upper decomposition. See Also: - :func:`jax.scipy.linalg.cholesky` - :func:`jax.scipy.linalg.cho_solve` Examples: A small real Hermitian positive-definite matrix: >>> x = jnp.array([[2., 1.], ... [1., 2.]]) Compute the cholesky factorization via :func:`~jax.scipy.linalg.cho_factor`, and use it to solve a linear equation via :func:`~jax.scipy.linalg.cho_solve`. >>> b = jnp.array([3., 4.]) >>> cfac = jax.scipy.linalg.cho_factor(x) >>> y = jax.scipy.linalg.cho_solve(cfac, b) >>> y Array([0.6666666, 1.6666666], dtype=float32) Check that the result is consistent: >>> jnp.allclose(x @ y, b) Array(True, dtype=bool) r)r r*s r$ cho_factorr-ms"X< 1E " " "E **r&cbc ttj|tj|\}}tj||tj||d|| | }tj||d|||}|S)NT) left_sider transpose_a conjugate_a)rrrr_check_solve_shapestriangular_solve)r.r/rs r$ _cho_solver6s  A A ? ?$!Q  A&&&!!Q$e27iYPPP!!!Q$e.3HHH! (r& c_and_lowertuple[ArrayLike, bool] overwrite_bc2~~|\}}t|||S)a:Solve a linear system using a Cholesky factorization JAX implementation of :func:`scipy.linalg.cho_solve`. Uses the output of :func:`jax.scipy.linalg.cho_factor`. Args: c_and_lower: ``(c, lower)``, where ``c`` is an array of shape ``(..., N, N)`` representing the lower or upper cholesky decomposition of the matrix, and ``lower`` is a boolean specifying whether this is the lower or upper decomposition. b: right-hand-side of linear system. Must have shape ``(..., N)`` overwrite_a: unused by JAX check_finite: unused by JAX Returns: Array of shape ``(..., N)`` representing the solution of the linear system. See Also: - :func:`jax.scipy.linalg.cholesky` - :func:`jax.scipy.linalg.cho_factor` Examples: A small real Hermitian positive-definite matrix: >>> x = jnp.array([[2., 1.], ... [1., 2.]]) Compute the cholesky factorization via :func:`~jax.scipy.linalg.cho_factor`, and use it to solve a linear equation via :func:`~jax.scipy.linalg.cho_solve`. >>> b = jnp.array([3., 4.]) >>> cfac = jax.scipy.linalg.cho_factor(x) >>> y = jax.scipy.linalg.cho_solve(cfac, b) >>> y Array([0.6666666, 1.6666666], dtype=float32) Check that the result is consistent: >>> jnp.allclose(x @ y, b) Array(True, dtype=bool) )r6)r7r/r9r(r.rs r$ cho_solver;s%T< (!U Aq%  r&x full_matrices compute_uv Literal[True]tuple[Array, Array, Array]cdSNr<r=r>s r$_svdrEsililr&Literal[False]cdSrBrCrDs r$rErEsUXUXr&"Array | tuple[Array, Array, Array]cdSrBrCrDs r$rErEshkhkr&r=r>cvttj|\}tj|||S)NrJ)rrrrsvd)rr=r>s r$rErEs0ck!nn--"! : N N NNr&gesdd lapack_driverstrcdSrBrCrr=r>r'r(rNs r$rLrLs FISr&cdSrBrCrQs r$rLrL 14r&)r'r(rNcdSrBrCrQs r$rLrLrSr&cdSrBrCrQs r$rLrLs NQSr&c,~~~t|||S)a Compute the singular value decomposition. JAX implementation of :func:`scipy.linalg.svd`. The SVD of a matrix `A` is given by .. math:: A = U\Sigma V^H - :math:`U` contains the left singular vectors and satisfies :math:`U^HU=I` - :math:`V` contains the right singular vectors and satisfies :math:`V^HV=I` - :math:`\Sigma` is a diagonal matrix of singular values. Args: a: input array, of shape ``(..., N, M)`` full_matrices: if True (default) compute the full matrices; i.e. ``u`` and ``vh`` have shape ``(..., N, N)`` and ``(..., M, M)``. If False, then the shapes are ``(..., N, K)`` and ``(..., K, M)`` with ``K = min(N, M)``. compute_uv: if True (default), return the full SVD ``(u, s, vh)``. If False then return only the singular values ``s``. overwrite_a: unused by JAX check_finite: unused by JAX lapack_driver: unused by JAX Returns: A tuple of arrays ``(u, s, vh)`` if ``compute_uv`` is True, otherwise the array ``s``. - ``u``: left singular vectors of shape ``(..., N, N)`` if ``full_matrices`` is True or ``(..., N, K)`` otherwise. - ``s``: singular values of shape ``(..., K)`` - ``vh``: conjugate-transposed right singular vectors of shape ``(..., M, M)`` if ``full_matrices`` is True or ``(..., K, M)`` otherwise. where ``K = min(N, M)``. See also: - :func:`jax.numpy.linalg.svd`: NumPy-style SVD API - :func:`jax.lax.linalg.svd`: XLA-style SVD API Examples: Consider the SVD of a small real-valued array: >>> x = jnp.array([[1., 2., 3.], ... [6., 5., 4.]]) >>> u, s, vt = jax.scipy.linalg.svd(x, full_matrices=False) >>> s # doctest: +SKIP Array([9.361919 , 1.8315067], dtype=float32) The singular vectors are in the columns of ``u`` and ``v = vt.T``. These vectors are orthonormal, which can be demonstrated by comparing the matrix product with the identity matrix: >>> jnp.allclose(u.T @ u, jnp.eye(2), atol=1E-5) Array(True, dtype=bool) >>> v = vt.T >>> jnp.allclose(v.T @ v, jnp.eye(2), atol=1E-5) Array(True, dtype=bool) Given the SVD, ``x`` can be reconstructed via matrix multiplication: >>> x_reconstructed = u @ jnp.diag(s) @ vt >>> jnp.allclose(x_reconstructed, x) Array(True, dtype=bool) rJ)rErQs r$rLrLs!H< a} D D DDr&cD~~tj|S)aCompute the determinant of a matrix JAX implementation of :func:`scipy.linalg.det`. Args: a: input array, of shape ``(..., N, N)`` overwrite_a: unused by JAX check_finite: unused by JAX Returns Determinant of shape ``a.shape[:-2]`` See Also: :func:`jax.numpy.linalg.det`: NumPy-style determinant API Examples: Determinant of a small 2D array: >>> x = jnp.array([[1., 2.], ... [3., 4.]]) >>> jax.scipy.linalg.det(x) Array(-2., dtype=float32) Batch-wise determinant of multiple 2D arrays: >>> x = jnp.array([[[1., 2.], ... [3., 4.]], ... [[8., 5.], ... [7., 9.]]]) >>> jax.scipy.linalg.det(x) Array([-2., 37.], dtype=float32) )rr detrr'r(s r$rXrX@sB<   r&ArrayLike | None eigvals_onlyeigvalsNonetypeintcdSrBrCrr/rr[r\r^s r$_eighrbes.1cr&tuple[Array, Array]cdSrBrCras r$rbrbis >>ck!nn--"! % ( ( ($!Q H a4Kr&rhturboc dSrBrC rr/rr[r'r9rmr\r^r(s r$rjrjs LO3r&)r'r9rmr\r^r(cdSrBrCros r$rjrj >ASr&c dSrBrCros r$rjrjrqr&c dSrBrCros r$rjrjs TWSVr&c 2~~~~ t||||||S)uCompute eigenvalues and eigenvectors for a Hermitian matrix JAX implementation of :func:`scipy.linalg.eigh`. Args: a: Hermitian input array of shape ``(..., N, N)`` b: optional Hermitian input of shape ``(..., N, N)``. If specified, compute the generalized eigenvalue problem. lower: if True (default) access only the lower portion of the input matrix. Otherwise access only the upper portion. eigvals_only: If True, compute only the eigenvalues. If False (default) compute both eigenvalues and eigenvectors. type: if ``b`` is specified, ``type`` gives the type of generalized eigenvalue problem to be computed. Denoting ``(λ, v)`` as an eigenvalue, eigenvector pair: - ``type = 1`` solves ``a @ v = λ * b @ v`` (default) - ``type = 2`` solves ``a @ b @ v = λ * v`` - ``type = 3`` solves ``b @ a @ v = λ * v`` eigvals: a ``(low, high)`` tuple specifying which eigenvalues to compute. overwrite_a: unused by JAX. overwrite_b: unused by JAX. turbo: unused by JAX. check_finite: unused by JAX. Returns: A tuple of arrays ``(eigvals, eigvecs)`` if ``eigvals_only`` is False, otherwise an array ``eigvals``. - ``eigvals``: array of shape ``(..., N)`` containing the eigenvalues. - ``eigvecs``: array of shape ``(..., N, N)`` containing the eigenvectors. See also: - :func:`jax.numpy.linalg.eigh`: NumPy-style eigh API. - :func:`jax.lax.linalg.eigh`: XLA-style eigh API. - :func:`jax.numpy.linalg.eig`: non-hermitian eigenvalue problem. - :func:`jax.scipy.linalg.eigh_tridiagonal`: tri-diagonal eigenvalue problem. Examples: Compute the standard eigenvalue decomposition of a simple 2x2 matrix: >>> a = jnp.array([[2., 1.], ... [1., 2.]]) >>> eigvals, eigvecs = jax.scipy.linalg.eigh(a) >>> eigvals Array([1., 3.], dtype=float32) >>> eigvecs Array([[-0.70710677, 0.70710677], [ 0.70710677, 0.70710677]], dtype=float32) Eigenvectors are orthonormal: >>> jnp.allclose(eigvecs.T @ eigvecs, jnp.eye(2), atol=1E-5) Array(True, dtype=bool) Solution satisfies the eigenvalue problem: >>> jnp.allclose(a @ eigvecs, eigvecs @ jnp.diag(eigvals)) Array(True, dtype=bool) )rbros r$rjrjs&@;| q!UL'4 8 88r&outputrvc|dkr,|tj|j}t j|S)Ncomplex)astyper to_complex_dtypedtyperschurrrvs r$_schurr~s< y (1122A  !  r&realcP|dvrtd|dt||S)aCompute the Schur decomposition JAX implementation of :func:`scipy.linalg.schur`. The Schur form `T` of a matrix `A` satisfies: .. math:: A = Z T Z^H where `Z` is unitary, and `T` is upper-triangular for the complex-valued Schur decomposition (i.e. ``output="complex"``) and is quasi-upper-triangular for the real-valued Schur decomposition (i.e. ``output="real"``). In the quasi-triangular case, the diagonal may include 2x2 blocks associated with complex-valued eigenvalue pairs of `A`. Args: a: input array of shape ``(..., N, N)`` output: Specify whether to compute the ``"real"`` (default) or ``"complex"`` Schur decomposition. Returns: A tuple of arrays ``(T, Z)`` - ``T`` is a shape ``(..., N, N)`` array containing the upper-triangular Schur form of the input. - ``Z`` is a shape ``(..., N, N)`` array containing the unitary Schur transformation matrix. See also: - :func:`jax.scipy.linalg.rsf2csf`: convert real Schur form to complex Schur form. - :func:`jax.lax.linalg.schur`: XLA-style API for Schur decomposition. Examples: A Schur decomposition of a 3x3 matrix: >>> a = jnp.array([[1., 2., 3.], ... [1., 4., 2.], ... [3., 2., 1.]]) >>> T, Z = jax.scipy.linalg.schur(a) The Schur form ``T`` is quasi-upper-triangular in general, but is truly upper-triangular in this case because the input matrix is symmetric: >>> T # doctest: +SKIP Array([[-2.0000005 , 0.5066295 , -0.43360388], [ 0. , 1.5505103 , 0.74519426], [ 0. , 0. , 6.449491 ]], dtype=float32) The transformation matrix ``Z`` is unitary: >>> jnp.allclose(Z.T @ Z, jnp.eye(3), atol=1E-5) Array(True, dtype=bool) The input can be reconstructed from the outputs: >>> jnp.allclose(Z @ T @ Z.T, a) Array(True, dtype=bool) )rrxz?Expected 'output' to be either 'real' or 'complex', got output=.) ValueErrorr~r}s r$r|r|sDx &&& KKKK M MM 6  r&cD~~tj|S)aReturn the inverse of a square matrix JAX implementation of :func:`scipy.linalg.inv`. Args: a: array of shape ``(..., N, N)`` specifying square array(s) to be inverted. overwrite_a: unused in JAX check_finite: unused in JAX Returns: Array of shape ``(..., N, N)`` containing the inverse of the input. Notes: In most cases, explicitly computing the inverse of a matrix is ill-advised. For example, to compute ``x = inv(A) @ b``, it is more performant and numerically precise to use a direct solve, such as :func:`jax.scipy.linalg.solve`. See Also: - :func:`jax.numpy.linalg.inv`: NumPy-style API for matrix inverse - :func:`jax.scipy.linalg.solve`: direct linear solver Examples: Compute the inverse of a 3x3 matrix >>> a = jnp.array([[1., 2., 3.], ... [2., 4., 2.], ... [3., 2., 1.]]) >>> a_inv = jax.scipy.linalg.inv(a) >>> a_inv # doctest: +SKIP Array([[ 0. , -0.25 , 0.5 ], [-0.25 , 0.5 , -0.25000003], [ 0.5 , -0.25 , 0. ]], dtype=float32) Check that multiplying with the inverse gives the identity: >>> jnp.allclose(a @ a_inv, jnp.eye(3), atol=1E-5) Array(True, dtype=bool) Multiply the inverse by a vector ``b``, to find a solution to ``a @ x = b`` >>> b = jnp.array([1., 4., 2.]) >>> a_inv @ b Array([ 0. , 1.25, -0.5 ], dtype=float32) Note, however, that explicitly computing the inverse in such a case can lead to poor performance and loss of precision as the size of the problem grows. Instead, you should use a direct solver like :func:`jax.scipy.linalg.solve`: >>> jax.scipy.linalg.solve(a, b) Array([ 0. , 1.25, -0.5 ], dtype=float32) )rr invrYs r$rr'sh<   r&)r'r(c~~ttj|\}tj|\}}}||fS)aFactorization for LU-based linear solves JAX implementation of :func:`scipy.linalg.lu_factor`. This function returns a result suitable for use with :func:`jax.scipy.linalg.lu_solve`. For direct LU decompositions, prefer :func:`jax.scipy.linalg.lu`. Args: a: input array of shape ``(..., M, N)``. overwrite_a: unused by JAX check_finite: unused by JAX Returns: A tuple ``(lu, piv)`` - ``lu`` is an array of shape ``(..., M, N)``, containing ``L`` in its lower triangle and ``U`` in its upper. - ``piv`` is an array of shape ``(..., K)`` with ``K = min(M, N)``, which encodes the pivots. See Also: - :func:`jax.scipy.linalg.lu` - :func:`jax.scipy.linalg.lu_solve` Examples: Solving a small linear system via LU factorization: >>> a = jnp.array([[2., 1.], ... [1., 2.]]) Compute the lu factorization via :func:`~jax.scipy.linalg.lu_factor`, and use it to solve a linear equation via :func:`~jax.scipy.linalg.lu_solve`. >>> b = jnp.array([3., 4.]) >>> lufac = jax.scipy.linalg.lu_factor(a) >>> y = jax.scipy.linalg.lu_solve(lufac, b) >>> y Array([0.6666666, 1.6666667], dtype=float32) Check that the result is consistent: >>> jnp.allclose(a @ y, b) Array(True, dtype=bool) )rrrrlu)rr'r(rpivots_s r$ lu_factorr_s@\<ck!nn--"!-""-"fa Vr&)transr9r( lu_and_pivtuple[Array, ArrayLike]rc~~|\}}|jdd\}}tj||} tj|| ||S)aSolve a linear system using an LU factorization JAX implementation of :func:`scipy.linalg.lu_solve`. Uses the output of :func:`jax.scipy.linalg.lu_factor`. Args: lu_and_piv: ``(lu, piv)``, output of :func:`~jax.scipy.linalg.lu_factor`. ``lu`` is an array of shape ``(..., M, N)``, containing ``L`` in its lower triangle and ``U`` in its upper. ``piv`` is an array of shape ``(..., K)``, with ``K = min(M, N)``, which encodes the pivots. b: right-hand-side of linear system. Must have shape ``(..., M)`` trans: type of system to solve. Options are: - ``0``: :math:`A x = b` - ``1``: :math:`A^Tx = b` - ``2``: :math:`A^Hx = b` overwrite_b: unused by JAX check_finite: unused by JAX Returns: Array of shape ``(..., N)`` representing the solution of the linear system. See Also: - :func:`jax.scipy.linalg.lu` - :func:`jax.scipy.linalg.lu_factor` Examples: Solving a small linear system via LU factorization: >>> a = jnp.array([[2., 1.], ... [1., 2.]]) Compute the lu factorization via :func:`~jax.scipy.linalg.lu_factor`, and use it to solve a linear equation via :func:`~jax.scipy.linalg.lu_solve`. >>> b = jnp.array([3., 4.]) >>> lufac = jax.scipy.linalg.lu_factor(a) >>> y = jax.scipy.linalg.lu_solve(lufac, b) >>> y Array([0.6666666, 1.6666667], dtype=float32) Check that the result is consistent: >>> jnp.allclose(a @ y, b) Array(True, dtype=bool) N)shaperlu_pivots_to_permutationlu_solve) rr/rr9r(rrmrperms r$rrsOd<*"f "##$!Q  ,VQ 7 7$  Rq% 0 00r& permute_lcdSrBrCrrs r$_lursHKr&cdSrBrCrs r$rrsPSPSr&0tuple[Array, Array] | tuple[Array, Array, Array]cdSrBrCrs r$rrs\_\_r&rh)static_argnumsc ttj|\}tj|\}}}t j|}tj|\}}tjtj |dddftj ||jdddfk|}t||} tj |dddd| ftj || |z} tj|d| ddf} |r(tj|| t jj| fS|| | fS)Nr{ precision)rrrrrr r{rrarrayarangemintrileyetriumatmul PrecisionHIGHEST) rrrr permutationr{rnpkr#us r$rrs9ck!nn--"!!}Q''"a )A,,% 1$!Q hsyT111W-A[EV1W1W1WXYXYXY[_X_1``hmnnnoo! !Qii! hr2qqq"1"u1E : : ::! hrll2A2qqq5! :acm&; < < >> a = jnp.array([[1., 2., 3.], ... [5., 4., 2.], ... [3., 2., 1.]]) >>> P, L, U = jax.scipy.linalg.lu(a) ``P`` is a permutation matrix: i.e. each row and column has a single ``1``: >>> P Array([[0., 1., 0.], [1., 0., 0.], [0., 0., 1.]], dtype=float32) ``L`` and ``U`` are lower-triangular and upper-triangular matrices: >>> with jnp.printoptions(precision=3): ... print(L) ... print(U) [[ 1. 0. 0. ] [ 0.2 1. 0. ] [ 0.6 -0.333 1. ]] [[5. 4. 2. ] [0. 1.2 2.6 ] [0. 0. 0.667]] The original matrix can be reconstructed by multiplying the three together: >>> a_reconstructed = P @ L @ U >>> jnp.allclose(a, a_reconstructed) Array(True, dtype=bool) )rrs r$rrsH< Q  r&mode Literal['r']pivoting tuple[Array]cdSrBrCrrrs r$_qrr7sKN3r&Literal['full', 'economic']cdSrBrCrs r$rr:sadadr&"tuple[Array] | tuple[Array, Array]cdSrBrCrs r$rr=sX[X[r&)rrc|rtd|dvrd}n|dkrd}ntd|dttj|\}t j||\}}|d kr|fS||fS) Nz0The pivoting=True case of qr is not implemented.)fullrTeconomicFz#Unsupported QR decomposition mode ''r=r)rirrrrrqr)rrrr=qrs r$rr@s < : < << ]MM zMM B4BBB C CCck!nn--"! q 6 6 6$!Q S[[ 4K A+r&rlworkrcdSrBrCrr'rrrr(s r$rrRsRURUr&cdSrBrCrs r$rrVKN3r&)rr(cdSrBrCrs r$rrZrr&cdSrBrCrs r$rr^sadadr&c*~~~t|||S)ayCompute the QR decomposition of an array JAX implementation of :func:`scipy.linalg.qr`. The QR decomposition of a matrix `A` is given by .. math:: A = QR Where `Q` is a unitary matrix (i.e. :math:`Q^HQ=I`) and `R` is an upper-triangular matrix. Args: a: array of shape (..., M, N) mode: Computational mode. Supported values are: - ``"full"`` (default): return `Q` of shape ``(M, M)`` and `R` of shape ``(M, N)``. - ``"r"``: return only `R` - ``"economic"``: return `Q` of shape ``(M, K)`` and `R` of shape ``(K, N)``, where K = min(M, N). pivoting: Not implemented in JAX. overwrite_a: unused in JAX lwork: unused in JAX check_finite: unused in JAX Returns: A tuple ``(Q, R)`` (if ``mode`` is not ``"r"``) otherwise an array ``R``, where: - ``Q`` is an orthogonal matrix of shape ``(..., M, M)`` (if ``mode`` is ``"full"``) or ``(..., M, K)`` (if ``mode`` is ``"economic"``). - ``R`` is an upper-triangular matrix of shape ``(..., M, N)`` (if ``mode`` is ``"r"`` or ``"full"``) or ``(..., K, N)`` (if ``mode`` is ``"economic"``) with ``K = min(M, N)``. See also: - :func:`jax.numpy.linalg.qr`: NumPy-style QR decomposition API - :func:`jax.lax.linalg.qr`: XLA-style QR decomposition API Examples: Compute the QR decomposition of a matrix: >>> a = jnp.array([[1., 2., 3., 4.], ... [5., 4., 2., 1.], ... [6., 3., 1., 5.]]) >>> Q, R = jax.scipy.linalg.qr(a) >>> Q # doctest: +SKIP Array([[-0.12700021, -0.7581426 , -0.6396022 ], [-0.63500065, -0.43322435, 0.63960224], [-0.7620008 , 0.48737738, -0.42640156]], dtype=float32) >>> R # doctest: +SKIP Array([[-7.8740077, -5.080005 , -2.4130025, -4.953006 ], [ 0. , -1.7870499, -2.6534991, -1.028908 ], [ 0. , 0. , -1.0660033, -4.050814 ]], dtype=float32) Check that ``Q`` is orthonormal: >>> jnp.allclose(Q.T @ Q, jnp.eye(3), atol=1E-5) Array(True, dtype=bool) Reconstruct the input: >>> jnp.allclose(Q @ R, a) Array(True, dtype=bool) )rrs r$rrcsL5, Qh  r&)assume_arrc ,|dkr tj|Sttjtj|\}t j|ttj |ttj fdfdd}j |j dzkr ||St||j dz tj |j dz |S)Nposrc.tj|SrB)r_matvec_multiply)r<rs r$z_solve..s +Aq11r&c$t|SrB)r;)rr<factorss r$rz_solve..s7A..r&T)solve symmetricrh)rr rrrrr4r-r stop_gradientrcustom_linear_solvendimr max)rr/rr custom_solvers` @r$_solvers   :  Aq ! !!  A A ? ?$!Q  A&&& s(++5 9 9 9' 1111 . . . . , Vqvz <?? C4 afqj#afaf*=*=*A B B1 E EEr&gendebugch~~~~gd}||vrtd|d|t||||S)aSolve a linear system of equations JAX implementation of :func:`scipy.linalg.solve`. This solves a (batched) linear system of equations ``a @ x = b`` for ``x`` given ``a`` and ``b``. Args: a: array of shape ``(..., N, N)``. b: array of shape ``(..., N)`` or ``(..., N, M)`` lower: Referenced only if ``assume_a != 'gen'``. If True, only use the lower triangle of the input, If False (default), only use the upper triangle. assume_a: specify what properties of ``a`` can be assumed. Options are: - ``"gen"``: generic matrix (default) - ``"sym"``: symmetric matrix - ``"her"``: hermitian matrix - ``"pos"``: positive-definite matrix overwrite_a: unused by JAX overwrite_b: unused by JAX debug: unused by JAX check_finite: unused by JAX Returns: An array of the same shape as ``b`` containing the solution to the linear system. See also: - :func:`jax.scipy.linalg.lu_solve`: Solve via LU factorization. - :func:`jax.scipy.linalg.cho_solve`: Solve via Cholesky factorization. - :func:`jax.scipy.linalg.solve_triangular`: Solve a triangular system. - :func:`jax.numpy.linalg.solve`: NumPy-style API for solving linear systems. - :func:`jax.lax.custom_linear_solve`: matrix-free linear solver. Examples: A simple 3x3 linear system: >>> A = jnp.array([[1., 2., 3.], ... [2., 4., 2.], ... [3., 2., 1.]]) >>> b = jnp.array([14., 16., 10.]) >>> x = jax.scipy.linalg.solve(A, b) >>> x Array([1., 2., 3.], dtype=float32) Confirming that the result solves the system: >>> jnp.allclose(A @ x, b) Array(True, dtype=bool) )rsymherrzExpected assume_a to be one of z; got )rr) rr/rr'r9rr(rvalid_assume_as r$rrsWj;|///. ^## Y~YYXYY Z ZZ 1h & &&r&)rr unit_diagonal int | strrc |dks|dkrd\}}n6|dks|dkrd\}}n$|dks|dkrd \}}ntd |ttj|tj|\}}tj|tj|dzk}|r|d }t j||d |||| }|r|dS|S)NrN)FFrhT)TFC)TTzInvalid 'trans' value ).NT)r1rr2r3r).r)rrrrrrr5) rr/rrrr2r3 b_is_vectorouts r$_solve_triangularrs  aZZ5C<<+K zzUc\\*K zzUc\\)K 5e55 6 66  A A ? ?$!Q sx{{Q.+ ) A#AqD0;0;2? A A A# v; Jr&c.~~~t|||||S)aESolve a triangular linear system of equations JAX implementation of :func:`scipy.linalg.solve_triangular`. This solves a (batched) linear system of equations ``a @ x = b`` for ``x`` given a triangular matrix ``a`` and a vector or matrix ``b``. Args: a: array of shape ``(..., N, N)``. Only part of the array will be accessed, depending on the ``lower`` and ``unit_diagonal`` arguments. b: array of shape ``(..., N)`` or ``(..., N, M)`` lower: If True, only use the lower triangle of the input, If False (default), only use the upper triangle. unit_diagonal: If True, ignore diagonal elements of ``a`` and assume they are ``1`` (default: False). trans: specify what properties of ``a`` can be assumed. Options are: - ``0`` or ``'N'``: solve :math:`Ax=b` - ``1`` or ``'T'``: solve :math:`A^Tx=b` - ``2`` or ``'C'``: solve :math:`A^Hx=b` overwrite_b: unused by JAX debug: unused by JAX check_finite: unused by JAX Returns: An array of the same shape as ``b`` containing the solution to the linear system. See also: :func:`jax.scipy.linalg.solve`: Solve a general linear system. Examples: A simple 3x3 triangular linear system: >>> A = jnp.array([[1., 2., 3.], ... [0., 3., 2.], ... [0., 0., 5.]]) >>> b = jnp.array([10., 8., 5.]) >>> x = jax.scipy.linalg.solve_triangular(A, b) >>> x Array([3., 2., 1.], dtype=float32) Confirming that the result solves the system: >>> jnp.allclose(A @ x, b) Array(True, dtype=bool) Computing the transposed problem: >>> x = jax.scipy.linalg.solve_triangular(A, b, trans='T') >>> x Array([10. , -4. , -3.4], dtype=float32) Confirming that the result solves the system: >>> jnp.allclose(A.T @ x, b) Array(True, dtype=bool) )r)rr/rrrr9rr(s r$solve_triangularrs"z5, 1a} = ==r&upper_triangular max_squaringsArrct|\}|jdks|jd|jdkrtd|jd|jdkr4t jt td|Stt j |\}}d }fd }tj k|||||f}|S) a)Compute the matrix exponential JAX implementation of :func:`scipy.linalg.expm`. Args: A: array of shape ``(..., N, N)`` upper_triangular: if True, then assume that ``A`` is upper-triangular. Default=False. max_squarings: The number of squarings in the scaling-and-squaring approximation method (default: 16). Returns: An array of shape ``(..., N, N)`` containing the matrix exponent of ``A``. Notes: This uses the scaling-and-squaring approximation method, with computational complexity controlled by the optional ``max_squarings`` argument. Theoretically, the number of required squarings is ``max(0, ceil(log2(norm(A))) - c)`` where ``norm(A)`` is the L1 norm and ``c=2.42`` for float64/complex128, or ``c=1.97`` for float32/complex64. See Also: :func:`jax.scipy.linalg.expm_frechet` Examples: ``expm`` is the matrix exponential, and has similar properties to the more familiar scalar exponential. For scalars ``a`` and ``b``, :math:`e^{a + b} = e^a e^b`. However, for matrices, this property only holds when ``A`` and ``B`` commute (``AB = BA``). In this case, ``expm(A+B) = expm(A) @ expm(B)`` >>> A = jnp.array([[2, 0], ... [0, 1]]) >>> B = jnp.array([[3, 0], ... [0, 4]]) >>> jnp.allclose(jax.scipy.linalg.expm(A+B), ... jax.scipy.linalg.expm(A) @ jax.scipy.linalg.expm(B), ... rtol=0.0001) Array(True, dtype=bool) If a matrix ``X`` is invertible, then ``expm(X @ A @ inv(X)) = X @ expm(A) @ inv(X)`` >>> X = jnp.array([[3, 1], ... [2, 5]]) >>> X_inv = jax.scipy.linalg.inv(X) >>> jnp.allclose(jax.scipy.linalg.expm(X @ A @ X_inv), ... X @ jax.scipy.linalg.expm(A) @ X_inv) Array(True, dtype=bool) rrrz8Expected A to be a (batched) square matrix, got A.shape=rrz (n,n)->(n,n)) signaturecH|^}}tj|tjSrB)r full_likenan)argsrrs r$_nanzexpm.._nans EA =CG $ $$r&cX|\}}}t||}t|}|SrB) _solve_P_Q _squaring)rrPQRr n_squaringsrs r$_computezexpm.._computes6GAq!1a)**A![-00A Hr&) rrrrr vectorizerexpm _calc_P_Qrr cond) rrrrrrrrrs `` @r$rr]sda  "!VaZZ172;!'"+-- SSSS T TTVaZZ 3= d%5]SSS   ! # ##  A//!Q %%%        h{]*D(Q1IFF! (r&c ^|jdks|jd|jdkrtdtj|d}|jdks |jdkrd}tjdtjtj ||z }|d| |jzz }tj gd|j }tj ||}tj|tt t"t$t&g|\}}n|jd ks |jd krd }tjdtjtj ||z }|d| |jzz }tj d dg|j }tj ||}tj|tt t"g|\}}nt)d|jd||z}| |z} || |fS)Nrrrhz expected A to be a square matrixfloat64 complex128gC|@)g,?g|zی@?gQi?g d@rfloat32 complex64gj%eg@g#"ՀA?gNj?zA.dtype=z is not supported.)rrrrr normr{maximumfloorlog2ryrdigitizer switch_pade3_pade5_pade7_pade9_pade13 TypeError) rA_L1maxnormrcondsidxUVrrs r$rrs Vq[[AGAJ!'!*,, 7 8 88 1  $W QW 44 7Q #(4'>*B*B C CDD;1 ""17++ ++1 9FFF J ( ( (5 dE " "3 *S66667CQ G G41aaw)qw+55G+a38D7N+C+C!D!DEEK A##AG,, ,,A I-/EF J ( ( (E ,tU # #C :cFFF3Q 7 7DAqq :qw::: ; ;;!e!b1f! A{ r&rrcf|rt||Stj||SrB)rrr r)rrrs r$rrs2" Aq ! !! :  Aq ! !!r&BcNtj||tjjS)Nr)rdotr rr)rr"s r$ _precise_dotr%s A!6 7 7 77r&rrrcddfd}tj||tj|j\}}|S)Nc"t||SrB)r%r<s r$_squaring_precisez$_squaring.._squaring_precises 1  r&c|SrBrCr(s r$ _identityz_squaring.._identitys Hr&c>tj|k|dfSrB)r r )r.ir+r)rs r$_scan_fz_squaring.._scan_fs# 8A O%6 1 E Et KKr&r)r scanrrr{)rrrr.resrr+r)s ` @@r$rrs{   LLLLLLL 8GQ = @Q R R R S S&#q *r&cd}|j\}}tj|||j}t ||}t ||d|z|d|zz}|d|z|d|zz}||fS)N)g^@gN@g(@?rrhrrrrrr{r%)rr/MridentA2rr s r$rrs! $!Q '!Qag & & &%Aq"1qtBw1e+--! qT"WqtEz !! A+r&cBd}|j\}}tj|||j}t ||}t ||}t ||d|z|d|zz|d|zz}|d|z|d|zz|d|zz}||fS) N)g@g@g@@g@z@g>@r2rr3rhrrr4) rr/r5rr6r7A4rr s r$rrs,! $!Q '!Qag & & &%Aq"B"1ad2g!R'!A$u*455! qT"WqtBw 1e +! A+r&cd}|j\}}tj|||j}t ||}t ||}t ||}t ||d|z|d|zz|d|zz|d|zz}|d|z|d|zz|d |zz|d |zz} || fS) N)g~pAg~`Ag@t>Ag@Ag@g@gL@r2rr9r3rhr:rrr4 rr/r5rr6r7r;A6rr s r$rrsF! $!Q '!Qag & & &%Aq"B"B"1ad2g!R'!A$r'1AaDJ>??!d2g!R!A$r'!AaDJ.! 1*r&cd}|j\}}tj|||j}t ||}t ||}t ||}t ||}t ||d|z|d|zz|d|zz|d|zz|d|zz} |d|z|d |zz|d |zz|d |zz|d |zz} | | fS) N) gynBgynBgAg@ Ag2|Ag~@Ag@g@gV@r2r r=r9r3rhr>r:rrr4) rr/r5rr6r7r;r@A8rr s r$rrs*! $!Q '!Qag & & &%Aq"B"B"B"1ad2g!R'!A$r'1AaDG;ad5jHII!d2g!R!A$r'!AaDG+ad5j8! 1*r&c Zd}|j\}}tj|||j}t ||}t ||}t ||}t |t ||d|z|d|zz|d|zz|d|zz|d|zz|d|zz|d |zz}t ||d |z|d |zz|d |zz|d |zz|d|zz|d|zz|d|zz} || fS)N)gD`lCgD`\Cg`=Hb;Cg eCgJXBg"5Bg/cBg\L8BgpķAgsyAgS-Ag@gf@r2r rBr=r9r3rh rCr>r:rrr4r?s r$rr sNH! $!Q '!Qag & & &%Aq"B"B"1l2quRx!B%(':QqT"W'DEE!RORSTURVWYRYY\]^_\`ac\ccfghifjkpfppqq!2quRx!B%(*QqT"W455!R?!A$r'IAaDQSGSVWXYVZ[`V``! 1*r&)method compute_expmErJ str | NonerKcdSrBrCrrLrJrKs r$ expm_frechetrPsMPSr&)rJcdSrBrCrOs r$rPrPs9<r&cdSrBrCrOs r$rPrP sLOCr&c~tj|}tj|}|jdks|jd|jdkrt d|j|jdks|jd|jdkrt d|j|j|jkrt d|jd|jt t d d }t||f|f\}}|r||fS|S) aiCompute the Frechet derivative of the matrix exponential. JAX implementation of :func:`scipy.linalg.expm_frechet` Args: A: array of shape ``(..., N, N)`` E: array of shape ``(..., N, N)``; specifies the direction of the derivative. compute_expm: if True (default) then compute and return ``expm(A)``. method: ignored by JAX Returns: A tuple ``(expm_A, expm_frechet_AE)`` if ``compute_expm`` is True, else the array ``expm_frechet_AE``. Both returned arrays have shape ``(..., N, N)``. See also: :func:`jax.scipy.linalg.expm` Examples: We can use this API to compute the matrix exponential of ``A``, as well as its derivative in the direction ``E``: >>> key1, key2 = jax.random.split(jax.random.key(3372)) >>> A = jax.random.normal(key1, (3, 3)) >>> E = jax.random.normal(key2, (3, 3)) >>> expmA, expm_frechet_AE = jax.scipy.linalg.expm_frechet(A, E) This can be equivalently computed using JAX's automatic differentiation methods; here we'll compute the derivative of :func:`~jax.scipy.linalg.expm` in the direction of ``E`` using :func:`jax.jvp`, and find the same results: >>> expmA2, expm_frechet_AE2 = jax.jvp(jax.scipy.linalg.expm, (A,), (E,)) >>> jnp.allclose(expmA, expmA2) Array(True, dtype=bool) >>> jnp.allclose(expm_frechet_AE, expm_frechet_AE2) Array(True, dtype=bool) rrrhz8expected A to be a (batched) square matrix, got A.shape=rz8expected E to be a (batched) square matrix, got E.shape=z3expected A and E to be the same shape, got A.shape=z E.shape=Frr)rrrrrrrr ) rrLrJrKA_arrE_arr bound_funexpm_Aexpm_frechet_AEs r$rPrP%s-N +a..% +a..% Z!^^u{2%+a.88 ]PUP[]] ^ ^^ Z!^^u{2%+b/99 ]PUP[]] ^ ^^ [EK D % DD6;kDD E EEdU"EEE) E8eX>>&/ ? "" r&arrsc t|dkrtjdf}tt |}dt |D}|r5t d||d|dd|D}|d}tj |}|ddD]}|j \}}tj || dd|j d ddff}tj || ddd|dff}tj ||gd }|S) aCreate a block diagonal matrix from input arrays. JAX implementation of :func:`scipy.linalg.block_diag`. Args: *arrs: arrays of at most two dimensions Returns: 2D block-diagonal array constructed by placing the input arrays along the diagonal. Examples: >>> A = jnp.ones((1, 1)) >>> B = jnp.ones((2, 2)) >>> C = jnp.ones((3, 3)) >>> jax.scipy.linalg.block_diag(A, B, C) Array([[1., 0., 0., 0., 0., 0.], [0., 1., 1., 0., 0., 0.], [0., 1., 1., 0., 0., 0.], [0., 0., 0., 1., 1., 1.], [0., 0., 0., 1., 1., 1.], [0., 0., 0., 1., 1., 1.]], dtype=float32) r)rhrcHg|]\}}tj|dk| S)r)rr).0r-rs r$ zblock_diag..zs)AAAda!qr&z_Arguments to jax.scipy.linalg.block_diag must have at most 2 dimensions, got {} at argument {}.c6g|]}tj|SrC)r atleast_2d)r\rs r$r]zblock_diag..s"444!CN1%%444r&rhN)rrrr) dimension)lenrzerostupler enumeraterformatr r{rpadr^ concatenate)rY bad_shapesconverted_arrsaccr{rrr.s r$ block_diagrk^sU2 YY!^^ Yv   D ~t$ % %$AAiooAAA*B AfT*Q-0*Q-@@ B BB54t444.q# )C..% !"" 11a 7DAq 5::a==9sy}a.C"DEEA '#uzz!}}y1a)&< = =C /3(a 0 0 0CC *r&)r[select select_range)r[rlrmtolderlrmtuple[float, float] | Nonern float | NonecZ  !|stddtj|tj|}tjtjtjtjf}j|jkrtdjd|jj|vs |j|vrtdjd|jj d}|dkrtj Stj jtj rRtj tj |tj |ztj} n(tj|} tj|tj| dd| dd | ddz| d dgd } tj| z} tj| z } tjtj| tj| } t+jj}t+jgj }t+j||jz ||jz|jz}|tjdtjz tj|j| dz|j| z|tj||jdz|d kr!tj|tj !n|d krc|t=d|d|dkrt=dtj|d|ddztj !n$|dkrtdt=dd}tj|j|z|jz| z}| |z d|z zz }| |z| zz}tj !}tj ||}tj ||}d||zz}tj | tj |fd} !fd}tCj"||d|||f\}}}}|S)aSolve the eigenvalue problem for a symmetric real tridiagonal matrix JAX implementation of :func:`scipy.linalg.eigh_tridiagonal`. Args: d: real-valued array of shape ``(N,)`` specifying the diagonal elements. e: real-valued array of shape ``(N - 1,)`` specifying the off-diagonal elements. eigvals_only: If True, return only the eigenvalues (default: False). Computation of eigenvectors is not yet implemented, so ``eigvals_only`` must be set to True. select: specify which eigenvalues to calculate. Supported values are: - ``'a'``: all eigenvalues - ``'i'``: eigenvalues with indices ``select_range[0] <= i <= select_range[1]`` JAX does not currently implement ``select = 'v'``. select_range: range of values used when ``select='i'``. tol: absolute tolerance to use when solving for the eigenvalues. Returns: An array of eigenvalues with shape ``(N,)``. See also: :func:`jax.scipy.linalg.eigh`: general Hermitian eigenvalue solver Examples: >>> d = jnp.array([1., 2., 3., 4.]) >>> e = jnp.array([1., 1., 1.]) >>> eigvals = jax.scipy.linalg.eigh_tridiagonal(d, e, eigvals_only=True) >>> eigvals Array([0.2547188, 1.8227171, 3.1772828, 4.745281 ], dtype=float32) For comparison, we can construct the full matrix and compute the same result using :func:`~jax.scipy.linalg.eigh`: >>> A = jnp.diag(d) + jnp.diag(e, 1) + jnp.diag(e, -1) >>> A Array([[1., 1., 0., 0.], [1., 2., 1., 0.], [0., 1., 3., 1.], [0., 0., 1., 4.]], dtype=float32) >>> eigvals_full = jax.scipy.linalg.eigh(A, eigvals_only=True) >>> jnp.allclose(eigvals, eigvals_full) Array(True, dtype=bool) z.Calculation of eigenvectors is not implementedcjdtjjtjtjjtjfd}fd|\}}d}d} dz |z} | fd} | | ||f\} }}|fd} t j| | | ||f\} } }|S) z)Implements the Sturm sequence recurrence.rrcdz }tj|dk}tjdk|}||fSNrrwhere)rcountalphaalpha0_perturbationonesr<rbs r$ sturm_step0z5eigh_tridiagonal.._sturm..sturm_step0sL (Q,aiAtU++e )E!HM#6 : :a Xor&c||dz |z z z }tj|k|dz|}tj|ktj| |}||fS)Nrh)rrxminimum)r-rryrzbeta_sqpivminr<s r$ sturm_stepz4eigh_tridiagonal.._sturm..sturm_stepsl (WQU^a' '! +aiV UQY66e )AKQ!8!8! < ._sturm..unrolled_stepssToeQZ  33!:eaiE2255 Z E ))r&c:|\}}}tj|SrB)rless)iqcr-rryrs r$r z.eigh_tridiagonal.._sturm..condskaE Xa^^r&)rrrbint32r|r while_loop)rzrrr{r<r}rry blocksizer-peelrr rrr|rrrbs````` @@@@@r$_sturmz eigh_tridiagonal.._sturmsM AA IagSY / / /E 8AG39 - - -D{}}HAuI A EY DJ****** !.!Q//KAq%J.~1e}EEKAq% Lr&z;diagonal and off-diagonal values must have same dtype, got z and zbOnly float32 and float64 inputs are supported as inputs to jax.scipy.linalg.eigh_tridiagonal, got rrhNraxisrrr-z/for select='i', select_range must be specified.z&Got empty index range in select_range.rkz4eigh_tridiagonal(..., select='v') is not implementedz-'select must have a value in {'a', 'i', 'v'}.g@r)r?c |\}}}}tjtj|tjtj||z SrB)r logical_andramax)rr-rrupperabs_tolmax_its r$r zeigh_tridiagonal..cond@sQAua ? F #(55=1122 4 44r&c|\}}}} |}tj| k||}tj| k||}d||zz}|dz|||fS)Nrrhrw) rr-rmidrcountsrrzr{rr target_countss r$bodyzeigh_tridiagonal..bodyFszAuc5 VE7F,? E EF If -sE : :E If},c5 9 9E  C q5%e ##r&)#rirrr r rr r{rrr issubdtypecomplexfloatingr!sqrtabssquarergraminrnpfinfor|repstinynmantrrrr broadcast_tor r)"rorpr[rlrmrnbetasupported_dtypesrbeta_absoff_diag_abs_row_sumlambda_est_maxlambda_est_mint_normronesafeminfudge norm_slackrr target_shaperr rrrrrzr{rrrrs" @@@@@@@@r$eigh_tridiagonalrs` P N O OO...` +a..% Q$k3; s~N [DJ : ;::-1Z:: ; ;; [(((DJ>N,N,N 6{66)-66 7 77 k!n!!VV 8E??^EK!455 HUOOEhtchtnn,--Gx  HHwt}}HjG|Xcrc]Xabb\18BCC=AKKK8E$8899.8E$8899. ;sw~..0G0G H H& (5;  % %+&&&# JsUYuyEJ(F G G' S[CHW$5$566 6& 59x{#:;; I '_k#w''G ;?& s]]Jq 222MM }} H I IIAa(( ? @ @@J|A Q!0C39UUUMM }} , - -- D E EE %yEK((5059 m`, in which case it has orthonormal rows. Writing the SVD of :math:`a` as :math:`a = u_\mathit{svd} \cdot s_\mathit{svd} \cdot v^h_\mathit{svd}`, we have :math:`u = u_\mathit{svd} \cdot v^h_\mathit{svd}`. Thus the unitary factor :math:`u` can be constructed as the application of the sign function to the singular values of :math:`a`; or, if :math:`a` is Hermitian, the eigenvalues. Several methods exist to compute the polar decomposition. Currently two are supported: * ``method="svd"``: Computes the SVD of :math:`a` and then forms :math:`u = u_\mathit{svd} \cdot v^h_\mathit{svd}`. * ``method="qdwh"``: Applies the `QDWH`_ (QR-based Dynamically Weighted Halley) algorithm. Args: a: The :math:`m \times n` input matrix. side: Determines whether a right or left polar decomposition is computed. If ``side`` is ``"right"`` then :math:`a = up`. If ``side`` is ``"left"`` then :math:`a = pu`. The default is ``"right"``. method: Determines the algorithm used, as described above. precision: :class:`~jax.lax.Precision` object specifying the matmul precision. eps: The final result will satisfy :math:`\left|x_k - x_{k-1}\right| < \left|x_k\right| (4\epsilon)^{\frac{1}{3}}`, where :math:`x_k` are the QDWH iterates. Ignored if ``method`` is not ``"qdwh"``. max_iterations: Iterations will terminate after this many steps even if the above is unsatisfied. Ignored if ``method`` is not ``"qdwh"``. Returns: A ``(unitary, posdef)`` tuple, where ``unitary`` is the unitary factor (:math:`m \times n`), and ``posdef`` is the positive-semidefinite factor. ``posdef`` is either :math:`n \times n` or :math:`m \times m` depending on whether ``side`` is ``"right"`` or ``"left"``, respectively. Examples: Polar decomposition of a 3x3 matrix: >>> a = jnp.array([[1., 2., 3.], ... [5., 4., 2.], ... [3., 2., 1.]]) >>> U, P = jax.scipy.linalg.polar(a) U is a Unitary Matrix: >>> jnp.round(U.T @ U) Array([[ 1., -0., -0.], [-0., 1., 0.], [-0., 0., 1.]], dtype=float32) P is positive-semidefinite Matrix: >>> with jnp.printoptions(precision=2, suppress=True): ... print(P) [[4.79 3.25 1.23] [3.25 3.06 2.01] [1.23 2.01 2.91]] The original matrix can be reconstructed by multiplying the U and P: >>> a_reconstructed = U @ P >>> jnp.allclose(a, a_reconstructed) Array(True, dtype=bool) .. _QDWH: https://epubs.siam.org/doi/abs/10.1137/090774999 rz"The input `a` must be a 2-D array.)rleftz5The argument `side` must be either 'right' or 'left'.rrF) is_hermitianrrzdmethod='qdwh' only supports mxn matrices where m < n where side='right' and m >= n side='left', got z with side=rLrNz#Unknown polar decomposition method r) rrrrrrrr!rirrLryr{)rrrJrrarrrrunitaryposdefru_svds_svdvh_svds r$polarrQsl A#X]] 9 : :: """ L M MM $!Q vAvv$'//"i%SIIIgvq!! Q46>> EJJLLc"i%SIIIgvq!x}}f   gg !M47I!M!MEI!M!M N NN%>#UCCCE5& LL % %EfnG w %aaa.0F:ffdAAAg&57<<>>:ff D6DDD E EE &r&rctjtjj}tj}fdfd}t jd|||}|S)u Implements Björck, Å., & Hammarling, S. (1983). "A Schur method for the square root of a matrix". Linear algebra and its applications", 52, 127-140. c(|\dz |z tjdzfdd}tjf|kdf|z zz }jf|fS)Nrhc4||f|fzzSrBrC)rvalrr-rs r$rz-_sqrtm_triu..i_loop..s!sQq!tWqAw5F/Fr&)r fori_looprrxatset) r#datasvaluerr-rrdiags @@@r$i_loopz_sqrtm_triu..i_loops DAq A A a!eQ F F F F F FLLA Ia1glCAw{tAwa'89 ; ;E ad1a4jnnU## ##r&c@tjd|||f\}}|Srv)r r)rrrrs r$j_loopz_sqrtm_triu..j_loops% =Av1v . .DAq Hr&r)rrrsizer r)rrrrrrs` @@r$ _sqrtm_triurs #(1++  $ i! htnn!$$$$$$      mAq&!$$! (r&c t|d\}}t|}tjtj||tjjtj|jtjjS)Nrxrur) r|rrrr rrr!r)rrZsqrt_Ts r$_sqrtmrsl q # # #$!Q q>>& CJq&CM4IJJJHQSMMS]-B D D DDr&rcJ|dkrtdt|S)uCompute the matrix square root JAX implementation of :func:`scipy.linalg.sqrtm`. Args: A: array of shape ``(N, N)`` blocksize: Not supported in JAX; JAX always uses ``blocksize=1``. Returns: An array of shape ``(N, N)`` containing the matrix square root of ``A`` See Also: :func:`jax.scipy.linalg.expm` Examples: >>> a = jnp.array([[1., 2., 3.], ... [2., 4., 2.], ... [3., 2., 1.]]) >>> sqrt_a = jax.scipy.linalg.sqrtm(a) >>> with jnp.printoptions(precision=2, suppress=True): ... print(sqrt_a) [[0.92+0.71j 0.54+0.j 0.92-0.71j] [0.54+0.j 1.85+0.j 0.54-0.j ] [0.92-0.71j 0.54-0.j 0.92+0.71j]] By definition, matrix multiplication of the matrix square root with itself should equal the input: >>> jnp.allclose(a, sqrt_a @ sqrt_a) Array(True, dtype=bool) Notes: This function implements the complex Schur method described in [1]_. It does not use recursive blocking to speed up computations as a Sylvester Equation solver is not yet available in JAX. References: .. [1] Björck, Å., & Hammarling, S. (1983). "A Schur method for the square root of a matrix". Linear algebra and its applications, 52, 127-140. rhz'Blocked version is not implemented yet.)rir)rrs r$sqrtmrs)R]]  I J JJ r&)r(rc~tj|}tj|}|jdks|jd|jdkrt d|jdks|jd|jdkrt d|jd|jdkrt d|jd|jt ||\}}tj|jj|jddkr||fSfdfd }tj d|||fS) a+Convert real Schur form to complex Schur form. JAX implementation of :func:`scipy.linalg.rsf2csf`. Args: T: array of shape ``(..., N, N)`` containing the real Schur form of the input. Z: array of shape ``(..., N, N)`` containing the corresponding Schur transformation matrix. check_finite: unused by JAX Returns: A tuple of arrays ``(T, Z)`` of the same shape as the inputs, containing the Complex Schur form and the associated Schur transformation matrix. See Also: :func:`jax.scipy.linalg.schur`: Schur decomposition Examples: >>> A = jnp.array([[0., 3., 3.], ... [0., 1., 2.], ... [2., 0., 1.]]) >>> Tr, Zr = jax.scipy.linalg.schur(A) >>> Tc, Zc = jax.scipy.linalg.rsf2csf(Tr, Zr) Both the real and complex form can be used to reconstruct the input matrix to float32 precision: >>> jnp.allclose(Zr @ Tr @ Zr.T, A, atol=1E-5) Array(True, dtype=bool) >>> jnp.allclose(Zc @ Tc @ Zc.conj().T, A, atol=1E-5) Array(True, dtype=bool) The real-valued Schur form is only quasi-upper-triangular, as we can see in this case: >>> with jax.numpy.printoptions(precision=2, suppress=True): ... print(Tr) [[ 3.76 -2.17 1.38] [ 0. -0.88 -0.35] [ 0. 2.37 -0.88]] By contrast, the complex form is truly upper-triangular: >>> with jnp.printoptions(precision=2, suppress=True): ... print(Tc) [[ 3.76+0.j 1.29-0.78j 2.02-0.5j ] [ 0. +0.j -0.88+0.91j -2.02+0.j ] [ 0. +0.j 0. +0.j -0.88-0.91j]] rrrhzInput 'T' must be square.zInput 'Z' must be square.z"Input array shapes must match: Z: z vs. T: c tjtj||dz |dz fd|||fz }tjtj|d|||dz fg|j}|d|z }|||dz f|z }tj| |g| |gg|j}tj ||dz dd}tj |dz k} |tj | |dz} tj | || } tj || |dz d}tj ||dz dd} tj ddtjf|dzk} tj | | d| jz}tj | | |}tj |||dz d}tj ||dz dd}tj ||| jz|dz d}||fS)Nrh)rrrrrr)rr r\r dynamic_slicerrryr{r!dynamic_slice_in_dimrrxdynamic_update_slice_in_dimnewaxisr)rrrmurr.rGT_rowscol_maskG_dot_T_zeroed_cols T_rows_newT_colsrow_maskT_zeroed_rows_dot_GH T_cols_newZ_colsrs r$ _update_T_Zzrsf2csf.._update_T_Zas@   C-a!A#qsVDD E E!Q$ OB  2a5!AqsF)"45566==agFFA 1 A !QqS& A A AFFHHa=A2q'*!':::A %a1aa 8 8 8Fz!}}!#Hci&!<<<H9f.ABBJ ':qsCCCA %a1aa 8 8 8Fz!}}QQQ ^,qs2H9Xvq99AFFHHJFH9f.BCCJ ':qsCCCA %a1aa 8 8 8F '6AFFHHJ+>!!LLLA a4Kr&c f|z }|\}}tjtj|||dz ftj||dz |dz ftj|||fzzkd|||\}}|j||dz fd}||fS)Nrhc ||fSrBrC)rrrs r$rz0rsf2csf.._rsf2scf_iter..s q!fr&r)r r rrrr)r-TZrrrrrrs r$ _rsf2scf_iterzrsf2csf.._rsf2scf_iter{s !A DAq 8 ga1Q3i3!A#qs( 4 4swqAw7G7G GHHA   DAq Q!V A a4Kr&) rrrrrrrr{rr r) rrr(T_arrZ_arrrrrrs @@@r$rsf2csfrs\d +a..% +a..% Z1__ A%+a.88 0 1 11 Z1__ A%+a.88 0 1 11 [^u{1~%% \%+\\u{\\ ] ]]'u55,% %+"# k!n!!VV %<4        q!]UEN ; ;;r&calc_qcdSrBrCrrr'r(s r$ hessenbergrs47Cr&cdSrBrCrs r$rrsBE#r&)rr(r')rr'r(c |~~tj|d}|dkr>|r(tj|tj|fStj|Stj|\}}tj|d}|rtj|dddddf|}|jdd} tjtj| dz|j tj | d|dz fz|j gtj | |dz dfz|j |gg}||fS|S) aCompute the Hessenberg form of the matrix JAX implementation of :func:`scipy.linalg.hessenberg`. The Hessenberg form `H` of a matrix `A` satisfies: .. math:: A = Q H Q^H where `Q` is unitary and `H` is zero below the first subdiagonal. Args: a : array of shape ``(..., N, N)`` calc_q: if True, calculate the ``Q`` matrix (default: False) overwrite_a: unused by JAX check_finite: unused by JAX Returns: A tuple of arrays ``(H, Q)`` if ``calc_q`` is True, else an array ``H`` - ``H`` has shape ``(..., N, N)`` and is the Hessenberg form of ``a`` - ``Q`` has shape ``(..., N, N)`` and is the associated unitary matrix Examples: Computing the Hessenberg form of a 4x4 matrix >>> a = jnp.array([[1., 2., 3., 4.], ... [1., 4., 2., 3.], ... [3., 2., 1., 4.], ... [2., 3., 2., 2.]]) >>> H, Q = jax.scipy.linalg.hessenberg(a, calc_q=True) >>> with jnp.printoptions(suppress=True, precision=3): ... print(H) [[ 1. -5.078 1.167 1.361] [-3.742 5.786 -3.613 -1.825] [ 0. -2.992 2.493 -0.577] [ 0. 0. -0.043 -1.279]] Notice the zeros in the subdiagonal positions. The original matrix can be reconstructed using the ``Q`` vectors: >>> a_reconstructed = Q @ H @ Q.conj().T >>> jnp.allclose(a_reconstructed, a) Array(True, dtype=bool) rr.rhNr)rhrhr) rr zeros_likerrrhouseholder_productblockr|r{rb) rrr'r(ra_outtaushr batch_dimss r$rrsLb< ill2!!VV  ^A  q 1 1 11 ^A  %a((+% hub!  &uS!""crc\':DAAASbS!J CHZ&0 DDDIjAq1u:5U[IIIKIjAE1:5U[III1MO P PA a4K Hr&rc|7td|tjtj|}ntd||tj|}tj|}|j\}|j\}|dks|dkr5tj||ftj|j|jS||zdz }tj |ddd|ddf}tj | d|df|fddd tj j d}tj|d S) axConstruct a Toeplitz matrix JAX implementation of :func:`scipy.linalg.toeplitz`. A Toeplitz matrix has equal diagonals: :math:`A_{ij} = k_{i - j}` for :math:`0 \le i < n` and :math:`0 \le j < n`. This function specifies the diagonals via the first column ``c`` and the first row ``r``, such that for row `i` and column `j`: .. math:: A_{ij} = \begin{cases} c_{i - j} & i \ge j \\ r_{j - i} & i < j \end{cases} Notice this implies that :math:`r_0` is ignored. Args: c: array specifying the first column. Will be flattened if not 1-dimensional. r: (optional) array specifying the first row. If not specified, defaults to ``conj(c)``. Will be flattened if not 1-dimensional. Returns: toeplitz matrix of shape ``(c.size, r.size)``. Examples: Specifying ``c`` only: >>> c = jnp.array([1, 2, 3]) >>> jax.scipy.linalg.toeplitz(c) Array([[1, 2, 3], [2, 1, 2], [3, 2, 1]], dtype=int32) Specifying ``c`` and ``r``: >>> r = jnp.array([-1, -2, -3]) >>> jax.scipy.linalg.toeplitz(c, r) # Note r[0] is ignored Array([[ 1, -2, -3], [ 2, 1, -2], [ 3, 2, 1]], dtype=int32) If specifying only complex-valued ``c``, ``r`` defaults to ``c.conj()``, resulting in a Hermitian matrix if ``c[0].imag == 0``: >>> c = jnp.array([1, 2+1j, 1+2j]) >>> M = jax.scipy.linalg.toeplitz(c) >>> M Array([[1.+0.j, 2.-1.j, 1.-2.j], [2.+1.j, 1.+0.j, 2.-1.j], [1.+2.j, 2.+1.j, 1.+0.j]], dtype=complex64) >>> print("M is Hermitian:", jnp.all(M == M.conj().T)) M is Hermitian: True NtoeplitzrrrhrrVALID)NTCIOTr)dimension_numbersrr)rr conjugaterflattenrempty promote_typesr{rgr conv_general_dilated_patchesreshaperrflip) r.rc_arrr_arrncolsnrowsnelemselemspatchess r$rrshrYJ""" ck!nn%%AAJ1%%% +a.. " "% +a.. " "% ;&% ;&% aZZ5A:: 9eU^,U[%+FF H H HH 5=1 & /52;abb 2 3 3%  , mmQN## hg1F % ' ' '() *' ' " " ""r&)rrcftjtj|dfd}d||jzdzz S)aCreate a Hilbert matrix of order n. JAX implementation of :func:`scipy.linalg.hilbert`. The Hilbert matrix is defined by: .. math:: H_{ij} = \frac{1}{i + j + 1} for :math:`1 \le i \le n` and :math:`1 \le j \le n`. Args: n: the size of the matrix to create. Returns: A Hilbert matrix of shape ``(n, n)`` Examples: >>> jax.scipy.linalg.hilbert(2) Array([[1. , 0.5 ], [0.5 , 0.33333334]], dtype=float32) >>> jax.scipy.linalg.hilbert(3) Array([[1. , 0.5 , 0.33333334], [0.5 , 0.33333334, 0.25 ], [0.33333334, 0.25 , 0.2 ]], dtype=float32) rhr)r broadcasted_iotarr r)rrs r$hilbertr(s2: 3;A22! AGaKr&)rrrrrr)FFT) rrrrr'rr(rrr) rrrrr'rr(rrr+)r.rr/rrrrr)FT) r7r8r/rr9rr(rrr)r<rr=rr>r?rr@)r<rr=rr>rFrr)r<rr=rr>rrrH)rrr=rr>rrrH)TTFTrM)rrr=rr>r?r'rr(rrNrOrr@)FTrM)rrr=rr>rFr'rr(rrNrOrr)T)rrr=rr>rr'rr(rrNrOrrH)rrr'rr(rrr)rrr/rZrrr[r?r\r]r^r_rr)rrr/rZrrr[rFr\r]r^r_rrc)rrr/rZrrr[rr\r]r^r_rre) NTFFFTNrhT)rrr/rZrrr[rFr'rr9rrmrr\r]r^r_r(rrrc)NT)rrr/rZrrr[r?r'rr9rrmrr\r]r^r_r(rrr)FFTNrhT)rrr/rZrrr[rr'rr9rrmrr\r]r^r_r(rrre)rrrvrOrrc)r)rrrvrOrrc)rrr'rr(rrrc)rFT) rrr/rrr_r9rr(rrr)rrrr?rrc)rrrrFrr@)rrrrrr) rrrrFr'rr(rrr@) rrrr?r'rr(rrrc) rrrrr'rr(rrr)rrrrrrrr)rrrrrrrrc)rrrrOrrrr)FNrFT)rrr'rrrrrrrr(rrrc)rrr'rrrrrrrr(rrr)FN)rrr'rrrrrOrrr(rrr) rrr/rrrOrrrr)FFFFTr)rrr/rrrr'rr9rrrr(rrrOrr) rrr/rrrrrrrrr)rFFFNT)rrr/rrrrrrrr9rrrr(rrr)rrrrrr_rr)rrrr@)F)rrrrrrrr)rrr"rrr)rrrrrr_rr)rrrrc) rrrLrrJrMrKr?rrc) rrrLrrJrMrKrFrr) rrrLrrJrMrKrrre)rYrrr)rorrprr[rrlrOrmrqrnrrrr)r) rrrrOrJrOrrrrrrrc)rrrr)rrrr)rrrr_rr)rrrrr(rrrc) rrrrFr'rr(rrr) rrrr?r'rr(rrrc) rrrrr'rr(rrrerB)r.rrrZrr)rr_rr)P __future__r functoolsrnumpyrtextwraptypingrrrjax jax.numpyrrr r r jax._srcr jax._src.laxr rrjax._src.numpy.utilrrrrjax._src.typingrrdedent_no_chkfinite_doc_no_overwrite_and_chkfinite_docr%r r-r6r;rErLrXrbrjr~r|rrrrrrrrrrrrrrr%rrrrrrrPrkrdefault_matmul_precisionrrrrrrrrrCr&r$r)s #""""")))))))))) -------,,,,,,,$HO%#46s"sj)))(((*)( EJ"&99999xGL$(-+-+-+-+-+^ j)))   *) ?C,!,!,!,!,!\ lll l XXX X kkk k=>>>OOO?>O NR8<$IIII I 8<$4444 4 4!$44444 4 EI8<$QQQQ Q FJ8<$EEEEEEEEEEP"""""J 222 2 @@@ @ HHH H JKKKLK$ AECHHL-1OOOO O  A:?"$TAAAAA A  :?HL-1AAAA A  AE9>HL-1WWWW W BF9>HL-1A9A9A9A9A9F k***+* ?????D55555p =>>>0000?>0f FGGGMN=A51515151HG51n KKK K SSS S ___ _T"""   #"  LQ EEEE E CH >>>> > BG [[[[ [ JKKKBG DDDDLKDL NNN N ddd d [[[ [233343" gm48VVVV V 48OOOO O ODOOOOO O OU48eeee ePV48G G G G G T 3444FFF54F.5:NS5:9'9'9'9'9'v ABBBCB6V[FK=A>>>>>>>>>>B CDDD38rH H H H H EDH T<""""" 8888 Q                       EI/3QQQQQ Q EI===== = EI&*PPPPP P 8999EI&*55555:95p( ( ( ( V HIIIIN#&SW)-D D D D D JID L 0111i((vfZ^'+vvvvv)(21vr    2DDDD+++++\ /000i<i<i<i<10i