403Webshell
Server IP : 217.160.0.135  /  Your IP : 216.73.217.85
Web Server : Apache
System : Linux www 6.18.52-i1-ampere #1203 SMP Mon Sep 14 18:29:59 CEST 2026 aarch64
User : sws1074145052 ( 1074145052)
PHP Version : 8.3.32
Disable Function : NONE
MySQL : OFF  |  cURL : ON  |  WGET : ON  |  Perl : ON  |  Python : OFF  |  Sudo : OFF  |  Pkexec : OFF
Directory :  /usr/lib/python3/dist-packages/scipy/integrate/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /usr/lib/python3/dist-packages/scipy/integrate/__pycache__/_quad_vec.cpython-311.pyc
�

d�c�R��.�ddlZddlZddlZddlZddlZddlZddlmZm	Z	Gd�dej
��ZGd�d��ZGd�d��Z
d	�Zd
�ZGd�d��Z		d dd�d�Zd�Zd�Zde_de_d�Zd�Zde_d�Zde_dS)!�N)�
MapWrapper�_FunctionWrapperc�*��eZdZd�Z�fd�Zd�Z�xZS)�LRUDictc��||_dS�N)�_LRUDict__max_size)�self�max_sizes  �;/usr/lib/python3/dist-packages/scipy/integrate/_quad_vec.py�__init__zLRUDict.__init__
s
��"�����c����||v}t���||��|r|�|��dSt|��|jkr|�d���dSdS)NF)�last)�super�__setitem__�move_to_end�lenr	�popitem)r
�key�value�existing_key�	__class__s    �rrzLRUDict.__setitem__s}����t���
�����C��'�'�'��	%����S�!�!�!�!�!�
��Y�Y���
(�
(��L�L�e�L�$�$�$�$�$�)�
(rc��t���r)�NotImplementedError)r
�others  r�updatezLRUDict.updates��!�#�#�#r)�__name__�
__module__�__qualname__r
rr�
__classcell__)rs@rrrsV�������#�#�#�%�%�%�%�%�$�$�$�$�$�$�$rrc�$�eZdZdZd�Zd�Zd�ZdS)�SemiInfiniteFuncz9
    Argument transform from (start, +-oo) to (0, 1)
    c�r�||_||_|dkrdnd|_tjjdz|_dS)Nr������?)�_func�_start�_sgn�sys�
float_info�min�_tmin)r
�func�start�inftys    rr
zSemiInfiniteFunc.__init__!s:����
�����!�)�)�B�B���	��^�'��,��
�
�
rc�Z�|j||jz
zdz}|dkrtjSd|zS)Nr&r)r*r)�np�inf)r
�x�zs   r�get_tzSemiInfiniteFunc.get_t)s2���I��T�[��)�A�-����6�6��6�M��1�u�rc��||jkrdS|j|jd|z
z|zz}|�|��}|j||zz|zS�N�r&)r.r)r*r(�r
�tr5�fs    r�__call__zSemiInfiniteFunc.__call__0sS���t�z�>�>��3���d�i�1�q�5�1�A�5�5�A��
�
�1�
�
�A��9��A��&��*�*rN�rrr �__doc__r
r7r>�rrr#r#sK��������-�-�-����+�+�+�+�+rr#c�$�eZdZdZd�Zd�Zd�ZdS)�DoubleInfiniteFuncz6
    Argument transform from (-oo, oo) to (-1, 1)
    c�F�||_tjjdz|_dS)Nr')r(r+r,r-r.)r
r/s  rr
zDoubleInfiniteFunc.__init__=s ����
��^�'��,��
�
�
rc�@�|dkrdnd}|t|��dzzS)Nrr%r&)�abs)r
r5�ss   rr7zDoubleInfiniteFunc.get_tCs(���a�%�%�B�B�Q���C��F�F�Q�J��rc��t|��|jkrdSdt|��z
|z}|�|��}||z|zSr9)rFr.r(r;s    rr>zDoubleInfiniteFunc.__call__GsK���q�6�6�D�J����3��S��V�V��q� �A��
�
�1�
�
�A���E�Q�;�rNr?rArrrCrC9sK��������-�-�-� � � �����rrCc�D�tjt|����Sr)r3�amaxrF)r5s r�	_max_normrKPs��
�7�3�q�6�6�?�?�rc��	tj|��S#t$r7t|d��r#t	|�����cYSYdSwxYw)N�
__sizeof__�@)r+�	getsizeof�	TypeError�hasattr�intrM)�objs r�_get_sizeofrTTsi����}�S�!�!�!�������3��%�%�	)��s�~�~�'�'�(�(�(�(�(��r�r�	���s��;A�Ac��eZdZd�Zd�ZdS)�_Bunchc�\�|���|_|jjdi|��dS)NrA)�keys�_Bunch__keys�__dict__r)r
�kwargss  rr
z_Bunch.__init___s2���k�k�m�m�����
��&�&�v�&�&�&�&�&rc�v��d�d��fd��jD������S)Nz
_Bunch({})z, c3�t�K�|]2}d�|t�j|����V��3dS)z{}={}N)�format�reprrZ)�.0�kr
s  �r�	<genexpr>z"_Bunch.__repr__.<locals>.<genexpr>ds]�����-C�-C�12�.5�^�^�A�t�D�M�RS�DT�?U�?U�-V�-V�-C�-C�-C�-C�-C�-Cr)r^�joinrY)r
s`r�__repr__z_Bunch.__repr__cs_����"�"�4�9�9�-C�-C�-C�-C�6:�k�-C�-C�-C�$C�$C�D�D�	DrN)rrr r
rdrArrrVrV^s7������'�'�'�D�D�D�D�DrrV�N�~h�:�0�yE>�2��חA�'r&FrA)�argsc�
�<�=�>�t|��}t|��}|r(t|t��s|f}t||��}t	|||||||	|
�dn|
|��	�	}
tj|��rUtj|��rAt|||����=|	�t�=fd�|	D����|
d<t�=ddfi|
��Stj|��rjtj|��rVt|||����=|	�t�=fd	�|	D����|
d<t�=ddfi|
��}|df|dd�zStj|��r�tj|��r~||krd
nd}t|���=|	�"dt�=fd�|	D����z|
d<nd|
d<||krt�=d
dfi|
��}nt�=ddfi|
��}|d|zf|dd�zStj|��rtj|��s#td
�||�����ttt
jjd�}t!|��r|}n||}d}d}	t"t"t$t&t&d�|
}n5#t($r(}td�|
����|�d}~wwxYw|	�||fg}nl|}g}t+|	��D]A}t|��}||cxkr|kr	nn||kr�(|�||f��|}�B|�||f��d}d}d}d�>g}d}|D]�\}}|||||��\} }!}"||jz
}|�t| tt0f��r!|tt
jjfvrt2}| }t|!��}t|"��}|t5| ��z}#t7|#���>n|| z
}||!z
}||"z
}t9j| ���>||f<|�|!||f����t;j|��d}$d}%d}&d}'|$d|%d|&d|'di}(t?|��5})|%}*|�r�tA|��|k�rtC||||��z��}+g},d}-tE|��D]p}.|snk|.dkr|-||+dzz
krnWt;j#|��}/|/\}0}}�>�$||fd��}1|,�|0|||1f|||f��|-|0z
}-�q|)tJ|,��D]H\}2}3}4}5}6||6z
}||2z
}||3z
}||4z
}|5D])}7|7\}}} }!| �>||f<t;j&||!||f���*�ItA|��|kr1tC||||��z��}+||+dzkr|$}*nJ||kr|&}*nAtj|��rtj|��s|'}*n|rtA|��|k��ddd��n#1swxYwY|}||z}!|r�tj'|��}8tj(|8j)t
j*|8j+����<tj,�<�>fd�|D��|8j+���}9tj,d�|D����}:tj,d�|D����}t[||*|$k|*|(|*||9|:���};||!|;fS||!fS)a{Adaptive integration of a vector-valued function.

    Parameters
    ----------
    f : callable
        Vector-valued function f(x) to integrate.
    a : float
        Initial point.
    b : float
        Final point.
    epsabs : float, optional
        Absolute tolerance.
    epsrel : float, optional
        Relative tolerance.
    norm : {'max', '2'}, optional
        Vector norm to use for error estimation.
    cache_size : int, optional
        Number of bytes to use for memoization.
    limit : float or int, optional
        An upper bound on the number of subintervals used in the adaptive
        algorithm.
    workers : int or map-like callable, optional
        If `workers` is an integer, part of the computation is done in
        parallel subdivided to this many tasks (using
        :class:`python:multiprocessing.pool.Pool`).
        Supply `-1` to use all cores available to the Process.
        Alternatively, supply a map-like callable, such as
        :meth:`python:multiprocessing.pool.Pool.map` for evaluating the
        population in parallel.
        This evaluation is carried out as ``workers(func, iterable)``.
    points : list, optional
        List of additional breakpoints.
    quadrature : {'gk21', 'gk15', 'trapezoid'}, optional
        Quadrature rule to use on subintervals.
        Options: 'gk21' (Gauss-Kronrod 21-point rule),
        'gk15' (Gauss-Kronrod 15-point rule),
        'trapezoid' (composite trapezoid rule).
        Default: 'gk21' for finite intervals and 'gk15' for (semi-)infinite
    full_output : bool, optional
        Return an additional ``info`` dictionary.
    args : tuple, optional
        Extra arguments to pass to function, if any.

        .. versionadded:: 1.8.0

    Returns
    -------
    res : {float, array-like}
        Estimate for the result
    err : float
        Error estimate for the result in the given norm
    info : dict
        Returned only when ``full_output=True``.
        Info dictionary. Is an object with the attributes:

            success : bool
                Whether integration reached target precision.
            status : int
                Indicator for convergence, success (0),
                failure (1), and failure due to rounding error (2).
            neval : int
                Number of function evaluations.
            intervals : ndarray, shape (num_intervals, 2)
                Start and end points of subdivision intervals.
            integrals : ndarray, shape (num_intervals, ...)
                Integral for each interval.
                Note that at most ``cache_size`` values are recorded,
                and the array may contains *nan* for missing items.
            errors : ndarray, shape (num_intervals,)
                Estimated integration error for each interval.

    Notes
    -----
    The algorithm mainly follows the implementation of QUADPACK's
    DQAG* algorithms, implementing global error control and adaptive
    subdivision.

    The algorithm here has some differences to the QUADPACK approach:

    Instead of subdividing one interval at a time, the algorithm
    subdivides N intervals with largest errors at once. This enables
    (partial) parallelization of the integration.

    The logic of subdividing "next largest" intervals first is then
    not implemented, and we rely on the above extension to avoid
    concentrating on "small" intervals only.

    The Wynn epsilon table extrapolation is not used (QUADPACK uses it
    for infinite intervals). This is because the algorithm here is
    supposed to work on vector-valued functions, in an user-specified
    norm, and the extension of the epsilon algorithm to this case does
    not appear to be widely agreed. For max-norm, using elementwise
    Wynn epsilon could be possible, but we do not do this here with
    the hope that the epsilon extrapolation is mainly useful in
    special cases.

    References
    ----------
    [1] R. Piessens, E. de Doncker, QUADPACK (1983).

    Examples
    --------
    We can compute integrations of a vector-valued function:

    >>> from scipy.integrate import quad_vec
    >>> import numpy as np
    >>> import matplotlib.pyplot as plt
    >>> alpha = np.linspace(0.0, 2.0, num=30)
    >>> f = lambda x: x**alpha
    >>> x0, x1 = 0, 2
    >>> y, err = quad_vec(f, x0, x1)
    >>> plt.plot(alpha, y)
    >>> plt.xlabel(r"$\alpha$")
    >>> plt.ylabel(r"$\int_{0}^{2} x^\alpha dx$")
    >>> plt.show()

    N�gk15)	�epsabs�epsrel�norm�
cache_size�limit�workers�points�
quadrature�full_output)r0r1c3�B�K�|]}��|��V��dSr�r7�r`�xp�f2s  �rrbzquad_vec.<locals>.<genexpr>��-�����$C�$C�b�R�X�X�b�\�\�$C�$C�$C�$C�$C�$Crrsrr&c3�B�K�|]}��|��V��dSrrwrxs  �rrbzquad_vec.<locals>.<genexpr>�r{rr%�rc3�B�K�|]}��|��V��dSrrwrxs  �rrbzquad_vec.<locals>.<genexpr>s-�����+J�+J�R�B�H�H�R�L�L�+J�+J�+J�+J�+J�+Jrz%invalid integration bounds a={}, b={})N�maxrg��)N�gk21rl�trapz�	trapezoidzunknown quadrature {!r}�zTarget precision reached.zTarget precision not reached.z<Target precision could not be reached due to rounding error.zNon-finite values encountered.�)�dtypec�X��g|]&}��|d|df�����'S�r&r�)�get)r`r6�dummy�interval_caches  ��r�
<listcomp>zquad_vec.<locals>.<listcomp>�sE���:�:�:�*+�-�0�0�!�A�$��!���u�E�E�:�:�:rc� �g|]}|d��Sr}rA�r`r6s  rr�zquad_vec.<locals>.<listcomp>�s��4�4�4�Q�A�a�D�5�4�4�4rc�.�g|]}|d|dg��Sr�rAr�s  rr�zquad_vec.<locals>.<listcomp>�s$��>�>�>�q�q��t�Q�q�T�l�>�>�>r)�neval�success�status�message�	intervals�	integrals�errors).�float�
isinstance�tupler�dictr3�isfinite�isinfr#�quad_vecrC�
ValueErrorr^rK�linalgro�callable�_quadrature_gk21�_quadrature_gk15�_quadrature_trapezoid�KeyError�sorted�append�num_eval�complexrFrTr�copy�heapq�heapifyrrr�range�heappop�pop�_subdivide_interval�heappush�asarray�full�shape�nanr��arrayrV)?r=�a�brmrnrorprqrrrsrtrurjr[�res�sgn�
norm_funcs�	norm_func�parallel_count�
min_intervals�_quadrature�e�initial_intervals�prev�p�global_integral�global_error�rounding_errorr�r��x1�x2�ig�err�rnd�cache_count�	CONVERGED�
NOT_CONVERGED�ROUNDING_ERROR�NOT_A_NUMBER�
status_msg�
mapwrapper�ier�tol�
to_process�err_sum�j�interval�neg_old_err�old_int�dint�derr�
dround_err�subint�dnevalr5�res_arrr�r��infor�rzr�s?                                                            @@@rr�r�hs	�����p	�a���A�
�a���A��&��$��&�&�	��7�D�
�Q��%�%������'��!��'1�'9�V�V�z�)�+�+�+�F�
�{�1�~�~�O�"�(�1�+�+�O�
�a�q��
2�
2�
2����$�$C�$C�$C�$C�F�$C�$C�$C�C�C�F�8����A�q�+�+�F�+�+�+�	��Q���O�B�H�Q�K�K�O�
�a�q��
2�
2�
2����$�$C�$C�$C�$C�F�$C�$C�$C�C�C�F�8���r�1�a�*�*�6�*�*���Q���z�C����G�#�#�	��!���O���!���O���E�E�b�b�q�� ��
"�
"����#�e�+J�+J�+J�+J�6�+J�+J�+J�&J�&J�J�F�8���#�F�8����6�6��2�r�1�/�/��/�/�C�C��2�q�!�.�.�v�.�.�C��A��s�
�}�s�1�2�2�w�&�&��k�!�n�n�O���Q���O��@�G�G��1�M�M�N�N�N���
�Y�^���J�
��~�~�%��	�	��t�$�	��N��M�N�-�/�/� 5�$9�	;�;�<F�	G����
�N�N�N��2�9�9�*�E�E�F�F�A�M�����N�����~���V�H�����������	�	�A��a���A���I�I�I�I�A�I�I�I�I�I�!�t�)�)���$�$�d�A�Y�/�/�/��D�D�� � �$���+�+�+��O��L��N��N��I�
�E�#�)�)���B�"�{�2�r�1�i�8�8���C��
��%�%���"��"�u�g�.�/�/�
$���B�I�N� ;�;�;� #�I� �O� ��:�:�L�"�3�Z�Z�N�$��B���7�K�$�[�1�1�N�N��r�!�O��C��L��c�!�N�#'�9�R�=�=���B�x� ����3�$��B��(�(�(�(�	�M�)�����I��M��N��L�	�.��6��V��6�	�J�
�G�	�	�0�
����-	�C�	�N�N�U�2�2��f�f�Y�Y��%?�%?�?�@�@�C��J��G��>�*�*�

(�

(�� ���E��q�5�5�W�|�c�!�e�';�;�;��E� �=��3�3��$,�!��Q��(�,�,�a��V�T�:�:���!�!�[�L�!�Q��#@�!�Y�P[�"\�]�]�]��K�<�'���;E�*�EX�Zd�:e�:e�
>�
>�6��d�J��������4�'����$���*�,���>�>�A�&'�O�B��B��/1�N�B��8�,��N�9��t�R��n�=�=�=�=�>��9�~�~��.�.��&�&���?�)C�)C�"C�D�D���#�a�%�'�'�#�C���.�0�0�(�C���K��-�-�
�"�+�n�2M�2M�
�"���[�-	�C�	�N�N�U�2�2�0�0�0�0�0�0�0�0�0�0�0����0�0�0�0�d�C�
��
'�C����*�S�/�/�����
�r�v�W�]�C�C�C���H�:�:�:�:�:�/8�:�:�:�AH��P�P�P�	���4�4�)�4�4�4�5�5���H�>�>�I�>�>�>�?�?�	��E�"�i�/� �(��o� )� )�#�
%�%�%���S�$����S�z�s+�>'J&�&
K�0#K�K�6FX�X�"Xc���|\}}}}|\}}}}d||zz}	t|dd��dkr"tj|j��|��}|||	||��\}
}}|j}
||	|||��\}}}|
|jz
}
|�|||||��\}}}|
|jz
}
t|dd��dkr|���j}
|
|z|z
}||z|z
}||z}||	|
|f|	|||ff}|||||
fS)Nr'rpr)�getattr�	functools�	lru_cacherpr��
cache_info�misses)rjr�r=r�r��old_errr�r�r��c�s1�err1�round1r��s2�err2�round2�_r�r�r��subintervalss                      rr�r��sT��*.�'�H�a��K�%��G�Q��7��q�1�u�
�A��{�L�!�,�,�q�0�0�7�I��� 6�7�7��:�:��"�{�1�a��I�6�6��B��f�
�
!�F�"�{�1�a��I�6�6��B��f�
�k�"�"�F���#��A�q�!�Y�7�7�
���A��+�&�&���{�L�!�,�,�q�0�0������&��
��7�W��D��$�;�� �D��&��J���2�t�$�q�!�R��&6�7�L���z�<��7�7rc��d||zz}||��}||��}||��}d||z
z|d|zz|zz}dt||z
��zt||����dt||����zzt||����zzdz}	d||z
z||zz}
dt||
|z
����z}|||	fS)z(
    Composite trapezoid quadrature
    r'g�?r�g��ؗ�Ҭ<gUUUUUU�?)rFr�)r�r�r=r��x3�f1rz�f3r��	round_errr�r�s            rr�r��s��

�b�2�g��B�	
��2���B�	
��2���B�	
��2���B�	
��b��	�R�!�B�$�Y��^�	,�B��s�2��7�|�|�#�u�Y�Y�r�]�]�';�';�)*�5���2���+?�+?�)?�(@�).�y�y��}�}�)=�)=�(>�?�AF�G�I�

��R���B��G�	$�B�

��i�i��R��(�(�)�)�
)�C�
�s�I��r�	r�c��dgt|��z}d||zz}d||z
z}	d}
d}tt|����D]C}|||	||zz��}
|
||<||}|
||
zz
}
||t|
��zz
}�Dd}tt|����D]}||||d|zdzzz
}�d}|
dz}tt|����D]&}|||t|||z
��zz
}�'t||
|z
|	z����}t|||	z����}|dkr"|dkr|t	dd|z|zd	z��z}t
jj}t|d
|z|	z|z����}|t
jjkrt||��}|	|
z||fS)z*
    Generic Gauss-Kronrod quadrature
    r:r'r�r&g@rg�?��g�?�2)	rr�rFr�r-r+r,�epsilonr)r�r�r=r�r5�w�v�fvr��h�s_k�s_k_abs�i�ff�vv�s_g�s_k_dabs�y0r��dabs�epsr�s                      r�_quadrature_gkr
�s��
��s�1�v�v��B��q�1�u�
�A��q�1�u�
�A��C��G�
�3�q�6�6�]�]�	 �	 ��
�Q�q�1�Q�q�T�6�z�]�]����1��
�q�T��	�r�B�w����2��B���<�����C�
�3�q�6�6�]�]�"�"���q��t�b��1��q��k�!�!����H�	�s��B�
�3�q�6�6�]�]�+�+���A�a�D�3�r�!�u�r�z�?�?�*�*����	�	�3��9��/�*�*�
+�
+�C����8�a�<�(�(�)�)�D��q�y�y�S�A�X�X��S��s�S�y�4�/�#�5�6�6�6��

�.�
 �C��i�i��S��1��w� 6�7�7�8�8�I��3�>�%�%�%��#�y�!�!���s�7�C��"�"rc	�8�d}d}d}t|||||||��S)z9
    Gauss-Kronrod 21 quadrature with error estimate
    )g�*'il��?g��*>*�?g������?g�^���?gbl�tu��?g��"���?g �@�?g�j	���?g7�^)U��?gz�xP�?rgz�xPÿg7�^)U�ҿg�j	��ۿg �@�g��"���gbl�tu��g�^���g������g��*>*�g�*'il��)
��b�_�?���x�8!�?�1���?�Uz�;�?���p���?rrrr
r)�?���[�?�B@��v��?碙��?��"7��5�?牳��׷?珁����?��-]�+��?��Hi�&>�?�la{F�?��o��?g�|+!�?rrrrrrrrrr�r
�r�r�r=r�r5r�r�s       rr�r�s3��
	/�A�.		.�A�	.�A�,�!�Q��9�a��A�6�6�6r�c	�8�d}d}d}t|||||||��S)z9
    Gauss-Kronrod 15 quadrature with error estimate
    )g�	M���?g)b|�_�?g>��'���?g֡㛟��?g$��:��?gb��]��?gw.����?r:gw.���ʿgb��]�ٿg$��:��g֡㛟��g>��'���g)b|�_�g�	M���)�Wm�����?�D�=q���?�=+�N�o�?g�/<�׿�?r!r r)�pt�g[|�?��a{��&�?��H��Ӻ?��F��?�\}�f��?��ah]�?�؜���*�?g	��O��?r(r'r&r%r$r#r"rrs       rr�r�[s3��
	/�A�"	.�A�	.�A� �!�Q��9�a��A�6�6�6r�)	rerfrgrhrir&NNF)r+r�r��collectionsr��numpyr3�scipy._lib._utilrr�OrderedDictrr#rCrKrTrVr�r�r�rpr�r
r�r�rArr�<module>r.s���
�
�
�
���������������������9�9�9�9�9�9�9�9�$�$�$�$�$�k�%�$�$�$�"+�+�+�+�+�+�+�+�8��������.������D�D�D�D�D�D�D�D�UZ�BG�D��D�D�D�D�D�N
8�8�8�:���($)�� �!"���0#�0#�0#�f>7�>7�>7�B���/7�/7�/7�d����r

Youez - 2016 - github.com/yon3zu
LinuXploit