
    5[g                         d Z dgZddlZddlmZ ddlmZ ddlm	Z	m
Z
 ddlmZmZ  G d	 d
ej                  j                        ZddlmZ ddZddZy)zz
Matrix square root for general matrices and for upper triangular matrices.

This module exists to avoid cyclic imports.

sqrtm    N)_asarray_validated   )norm)ztrsyldtrsyl)schurrsf2csfc                       e Zd Zy)
SqrtmErrorN)__name__
__module____qualname__     W/var/www/html/bid-api/venv/lib/python3.12/site-packages/scipy/linalg/_matfuncs_sqrtm.pyr   r      s    r   r   )within_block_loopc           	         t        j                  |       }t        j                  |       xr t        j                  |d      dk\  }|sLt        j                  | t         j
                  d      } t        j                  |t         j
                        }nKt        j                  | t         j                  d      } t        j                  |t         j                        }t        j                  t        j                  |            }| j                  \  }}t        ||z  d      }t        ||      \  }}|dz   }	||z
  }
|
|z  ||	z  z   |k7  rt        d      g }d}|
|f||	ffD ]0  \  }}t        |      D ]  }|j                  |||z   f       ||z  } 2 	 t        || ||       t        |      D ]  }||   \  }}t        |dz
  d
d
      D ]  }||   \  }}| ||||f   }||z
  dkD  r&||||||f   j%                  |||||f         z
  }|||||f   }|||||f   }|rt'        |||      \  }}}nt)        |||      \  }}}||z  |||||f<     |S # t        $ r}t!        |j"                   |d	}~ww xY w)a  
    Matrix square root of an upper triangular matrix.

    This is a helper function for `sqrtm` and `logm`.

    Parameters
    ----------
    T : (N, N) array_like upper triangular
        Matrix whose square root to evaluate
    blocksize : int, optional
        If the blocksize is not degenerate with respect to the
        size of the input array, then use a blocked algorithm. (Default: 64)

    Returns
    -------
    sqrtm : (N, N) ndarray
        Value of the sqrt function at `T`

    References
    ----------
    .. [1] Edvin Deadman, Nicholas J. Higham, Rui Ralha (2013)
           "Blocked Schur Algorithms for Computing the Matrix Square Root,
           Lecture Notes in Computer Science, 7782. pp. 171-182.

    g        )initialr   C)dtypeorder)r   r   zinternal inconsistencyN)npdiag	isrealobjminasarray
complex128float64sqrtshapemaxdivmod	Exceptionrangeappendr   RuntimeErrorr   argsdotr   r   )T	blocksizeT_diagkeep_it_realRnnblocksbsmallnlargeblargensmallstart_stop_pairsstartcountsizeiejjstartjstopistartistopSRiiRjjxscaleinfos                               r   _sqrtm_triurG      s   4 WWQZF<<?Frvvfb'AQ'FL JJqS9F"--8JJq

#6F"**5
 A 77DAq!y.!$G Aw'NFFaZFvF&(A-011 E(66*:;tuA##UEDL$9:TME  <)!Q 0':
 7^(+qsB#A,Q/MFE&,u,-A1uqy&,f4599!E&L<B5L=I ;J K K F5L&,./CF5L&,./C!'S!!45$!'S!!45$,-IAfUlF5L()! $ * H3  )!&&!q()s   I 	J (I;;J c                    t        j                  |       j                  j                  }t	        | dd      } t        | j                        dk7  rt        d      |dk  rt        d      t        j                  |       }|rt        |       \  }}t        j                  |      }t        j                  |d      }t        j                  |j                        j                  }	t        |      |	t        |dd       t        |dd       z   z  kD  }
|
j                         r t        ||      \  }}nt        | d	
      \  }}d}	 t!        ||      }t        j"                  |      j$                  }|j'                  |      j'                  |      }t        j(                  |      s,|j+                  dt        j,                  |dd       d      }nmt/        t         d      r/|j+                  dt        j,                  |dz  dd       d      }n.|j+                  dt        j,                  |dz  dd       d      }|r|rt9        d       |S 	 t;        |j'                  |      | z
  d      dz  t;        | d      z  }||fS # t0        $ r9 d}t        j2                  |       }|j5                  t         j6                         Y w xY w# t        $ r t         j<                  }Y ||fS w xY w)a  
    Matrix square root.

    Parameters
    ----------
    A : (N, N) array_like
        Matrix whose square root to evaluate
    disp : bool, optional
        Print warning if error in the result is estimated large
        instead of returning estimated error. (Default: True)
    blocksize : integer, optional
        If the blocksize is not degenerate with respect to the
        size of the input array, then use a blocked algorithm. (Default: 64)

    Returns
    -------
    sqrtm : (N, N) ndarray
        Value of the sqrt function at `A`. The dtype is float or complex.
        The precision (data size) is determined based on the precision of
        input `A`. When the dtype is float, the precision is the same as `A`.
        When the dtype is complex, the precision is double that of `A`. The
        precision might be clipped by each dtype precision range.

    errest : float
        (if disp == False)

        Frobenius norm of the estimated error, ||err||_F / ||A||_F

    References
    ----------
    .. [1] Edvin Deadman, Nicholas J. Higham, Rui Ralha (2013)
           "Blocked Schur Algorithms for Computing the Matrix Square Root,
           Lecture Notes in Computer Science, 7782. pp. 171-182.

    Examples
    --------
    >>> import numpy as np
    >>> from scipy.linalg import sqrtm
    >>> a = np.array([[1.0, 3.0], [1.0, 4.0]])
    >>> r = sqrtm(a)
    >>> r
    array([[ 0.75592895,  1.13389342],
           [ 0.37796447,  1.88982237]])
    >>> r.dot(r)
    array([[ 1.,  3.],
           [ 1.,  4.]])

    T)check_finite
as_inexact   z$Non-matrix input to matrix function.r   z#The blocksize should be at least 1.r   Ncomplex)outputF)r,   f   )copy
complex256c       zFailed to find a square root.fro)r   r   r   itemsizer   lenr"   
ValueErrorr   r	   diagonalfinfoepsabsanyr
   rG   	conjugater+   r*   iscomplexobjastypecliphasattrr   
empty_likefillnanprintr   inf)Adispr,   	byte_sizer.   r+   Zd0d1r[   needs_conversionfailflagr/   ZHXarg2s                   r   r   r   u   s|   b 

1##,,I14DAA
177|q?@@1}>??<<?LQx1[[^[[Bhhqww##r7SC12K#b"g,,F%GG!1a=DAqQy)1HY/\\!_EE!HLLq!1RWWY2678uEA r<(HHq1a!< =>UHKHHq1a!< =>UHK 12	a1e,a/$q%.@D
 $w!  MM!	rvv  	66D$w		s%   C:J .K ?KKK%$K%)@   )Trs   )__doc____all__numpyr   scipy._lib._utilr   _miscr   lapackr   r   _decomp_schurr	   r
   linalgLinAlgErrorr   _matfuncs_sqrtm_triur   rG   r   r   r   r   <module>r~      sL    )  /  " )	&& 	 4Wtar   