403Webshell
Server IP : 217.160.0.135  /  Your IP : 216.73.217.37
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 :  /lib/python3/dist-packages/scipy/optimize/__pycache__/

Upload File :
current_dir [ Writeable ] document_root [ Writeable ]

 

Command :


[ Back ]     

Current File : /lib/python3/dist-packages/scipy/optimize/__pycache__/_linesearch.cpython-311.pyc
�

d�c�g����dZddlmZddlmZddlZgd�ZGd�de	��Z
				dd�Z			d d�ZeZ
			d!d�Z				d"d�Zd�Zd�Zd�Zd#d�Zd#d�Zd$d�Z	d%d�Z		d&d�ZdS)'z�
Functions
---------
.. autosummary::
   :toctree: generated/

    line_search_armijo
    line_search_wolfe1
    line_search_wolfe2
    scalar_search_wolfe1
    scalar_search_wolfe2

�)�warn)�	_minpack2N)�LineSearchWarning�line_search_wolfe1�line_search_wolfe2�scalar_search_wolfe1�scalar_search_wolfe2�line_search_armijoc��eZdZdS)rN)�__name__�
__module__�__qualname__���</usr/lib/python3/dist-packages/scipy/optimize/_linesearch.pyrrs�������Drrr�-C��6?��������?�2�:�0�yE>�+����=c
����������|�	��g��R�}|g�dg�dg������fd�}
������fd�}tj|���}t|
||||||	|
||��
�
\}}}|�d�d||�dfS)a�
    As `scalar_search_wolfe1` but do a line search to direction `pk`

    Parameters
    ----------
    f : callable
        Function `f(x)`
    fprime : callable
        Gradient of `f`
    xk : array_like
        Current point
    pk : array_like
        Search direction

    gfk : array_like, optional
        Gradient of `f` at point `xk`
    old_fval : float, optional
        Value of `f` at point `xk`
    old_old_fval : float, optional
        Value of `f` at point preceding `xk`

    The rest of the parameters are the same as for `scalar_search_wolfe1`.

    Returns
    -------
    stp, f_count, g_count, fval, old_fval
        As in `line_search_wolfe1`
    gval : array
        Gradient of `f` at the final point

    Nrc�B���dxxdz
cc<��|�zzg��R�S�Nr�r)�s�args�f�fc�pk�xks �����r�phizline_search_wolfe1.<locals>.phiIs8���
�1�����
�����q��a��d��"�T�"�"�"�"rc�~����|�zzg��R��d<�dxxdz
cc<tj�d���Sr��np�dot)rr�fprime�gc�gvalrr s ������r�derphiz"line_search_wolfe1.<locals>.derphiMsQ����&��a��d��*�T�*�*�*��Q��
�1�����
�����v�d�1�g�r�"�"�"r)�c1�c2�amax�amin�xtol)r$r%r)rr&r r�gfk�old_fval�old_old_fvalrr*r+r,r-r.r!r)�derphi0�stp�fvalrr'r(s````   `          @@@rrrs����������F�{��f�R��$������5�D�
��B�
��B�#�#�#�#�#�#�#�#�#�#�#�#�#�#�#�#�#�#�#�
�f�S�"�o�o�G�.����<���b�t�$�T�;�;�;��C��x���1��r�!�u�d�H�d�1�g�5�5rc
��|�|d��}|�|d��}|�(|dkr"tdd||z
z|z��}
|
dkrd}
nd}
|}|}tjdtj��}
tjdt��}d}d	}t|��D]M}t
j|
|||||	||||
|��\}}}}|dd
�dkr|}
||��}||��}�Lnd}|dd�d
ks|dd�dkrd}|||fS)a,
    Scalar function search for alpha that satisfies strong Wolfe conditions

    alpha > 0 is assumed to be a descent direction.

    Parameters
    ----------
    phi : callable phi(alpha)
        Function at point `alpha`
    derphi : callable phi'(alpha)
        Objective function derivative. Returns a scalar.
    phi0 : float, optional
        Value of phi at 0
    old_phi0 : float, optional
        Value of phi at previous point
    derphi0 : float, optional
        Value derphi at 0
    c1 : float, optional
        Parameter for Armijo condition rule.
    c2 : float, optional
        Parameter for curvature condition rule.
    amax, amin : float, optional
        Maximum and minimum step size
    xtol : float, optional
        Relative tolerance for an acceptable step.

    Returns
    -------
    alpha : float
        Step size, or None if no suitable step was found
    phi : float
        Value of `phi` at the new point `alpha`
    phi0 : float
        Value of `phi` at `alpha=0`

    Notes
    -----
    Uses routine DCSRCH from MINPACK.

    N�r��?�)\��(@)�)�
sSTART�dr9sFG�sERROR�sWARN)�minr$�zeros�intc�float�range�minpack2�dcsrch)r!r)�phi0�old_phi0r2r*r+r,r-r.�alpha1�phi1�derphi1�isave�dsave�task�maxiter�ir3s                   rrr[sa��X�|��s�2�w�w�����&��*�*�����1����S�&�$��/�2�7�:�;�;���A�:�:��F�����D��G��H�T�2�7�#�#�E��H�U�E�"�"�E��D��G�
�7�^�^����#+�?�6�4��35�r�4��37��u�e�$M�$M� ��T�7�D�����8�u����F��3�s�8�8�D��f�S�k�k�G�G��E����B�Q�B�x�8���t�B�Q�B�x�7�2�2�����d�?�r�
c
�^������������dg�dg�dg�dg������fd�}
|��������fd��|�	��g��R�}tj|���}��������fd�}nd}t|
�|||||	|
||��
�
\}}}}|�tdt��n�d}|�d�d|||fS)a�Find alpha that satisfies strong Wolfe conditions.

    Parameters
    ----------
    f : callable f(x,*args)
        Objective function.
    myfprime : callable f'(x,*args)
        Objective function gradient.
    xk : ndarray
        Starting point.
    pk : ndarray
        Search direction.
    gfk : ndarray, optional
        Gradient value for x=xk (xk being the current parameter
        estimate). Will be recomputed if omitted.
    old_fval : float, optional
        Function value for x=xk. Will be recomputed if omitted.
    old_old_fval : float, optional
        Function value for the point preceding x=xk.
    args : tuple, optional
        Additional arguments passed to objective function.
    c1 : float, optional
        Parameter for Armijo condition rule.
    c2 : float, optional
        Parameter for curvature condition rule.
    amax : float, optional
        Maximum step size
    extra_condition : callable, optional
        A callable of the form ``extra_condition(alpha, x, f, g)``
        returning a boolean. Arguments are the proposed step ``alpha``
        and the corresponding ``x``, ``f`` and ``g`` values. The line search
        accepts the value of ``alpha`` only if this
        callable returns ``True``. If the callable returns ``False``
        for the step length, the algorithm will continue with
        new iterates. The callable is only called for iterates
        satisfying the strong Wolfe conditions.
    maxiter : int, optional
        Maximum number of iterations to perform.

    Returns
    -------
    alpha : float or None
        Alpha for which ``x_new = x0 + alpha * pk``,
        or None if the line search algorithm did not converge.
    fc : int
        Number of function evaluations made.
    gc : int
        Number of gradient evaluations made.
    new_fval : float or None
        New function value ``f(x_new)=f(x0+alpha*pk)``,
        or None if the line search algorithm did not converge.
    old_fval : float
        Old function value ``f(x0)``.
    new_slope : float or None
        The local slope along the search direction at the
        new value ``<myfprime(x_new), pk>``,
        or None if the line search algorithm did not converge.


    Notes
    -----
    Uses the line search algorithm to enforce strong Wolfe
    conditions. See Wright and Nocedal, 'Numerical Optimization',
    1999, pp. 59-61.

    Examples
    --------
    >>> import numpy as np
    >>> from scipy.optimize import line_search

    A objective function and its gradient are defined.

    >>> def obj_func(x):
    ...     return (x[0])**2+(x[1])**2
    >>> def obj_grad(x):
    ...     return [2*x[0], 2*x[1]]

    We can find alpha that satisfies strong Wolfe conditions.

    >>> start_point = np.array([1.8, 1.7])
    >>> search_gradient = np.array([-1.0, -1.0])
    >>> line_search(obj_func, obj_grad, start_point, search_gradient)
    (1.0, 2, 1, 1.1300000000000001, 6.13, [1.6, 1.4])

    rNc�B���dxxdz
cc<��|�zzg��R�Srr)�alpharrrrr s �����rr!zline_search_wolfe2.<locals>.phis8���
�1�����
�����q��e�b�j��(�4�(�(�(�(rc����dxxdz
cc<��|�zzg��R��d<|�d<tj�d���Srr#)rRrr&r'r(�
gval_alpharr s �������rr)z"line_search_wolfe2.<locals>.derphisZ���
�1�����
�����&��e�b�j��0�4�0�0�0��Q���
�1�
��v�d�1�g�r�"�"�"rc�j���d|kr�|���|�zz}�|||�d��S)Nrr)	rRr!�xr)�extra_conditionr(rTrr s	   ������r�extra_condition2z,line_search_wolfe2.<locals>.extra_condition2%sF����!�}��%�%���u�
�
�
��U�R�Z��A�"�?�5�!�S�$�q�'�:�:�:r)rM�*The line search algorithm did not converge)r$r%r	rr)r�myfprimer rr/r0r1rr*r+r,rWrMr!r2rX�
alpha_star�phi_star�derphi_starr)rr&r'r(rTs` ``   `   `       @@@@@@rrr�s�������������p��B�
��B��6�D���J�)�)�)�)�)�)�)�)�)��F�#�#�#�#�#�#�#�#�#�#�#��{��f�R��$������f�S�"�o�o�G��"�	;�	;�	;�	;�	;�	;�	;�	;�	;�	;�	;� ��2F����<��"�b�$��g�3/�3/�3/�/�J��(�K����
9�;L�M�M�M�M��1�g���r�!�u�b��e�X�x��D�Drc
�J�|�|d��}|�|d��}d}
|� |dkrtdd||z
z|z��}nd}|dkrd}|�t||��}||��}|}
|}|�d�}t|	��D�]}|dks|�6|
|kr0d}|}|}d}|dkrd}ndd	|zz}t|t��n�|dk}||||z|zzks||
kr"|r t	|
||
|||||||||��\}}}n�||��}t|��||zkr|||��r|}|}|}nm|dkr t	||
||
||||||||��\}}}nGd
|z}|�t||��}|}
|}|}
||��}|}��|}|}d}tdt��||||fS)a�Find alpha that satisfies strong Wolfe conditions.

    alpha > 0 is assumed to be a descent direction.

    Parameters
    ----------
    phi : callable phi(alpha)
        Objective scalar function.
    derphi : callable phi'(alpha)
        Objective function derivative. Returns a scalar.
    phi0 : float, optional
        Value of phi at 0.
    old_phi0 : float, optional
        Value of phi at previous point.
    derphi0 : float, optional
        Value of derphi at 0
    c1 : float, optional
        Parameter for Armijo condition rule.
    c2 : float, optional
        Parameter for curvature condition rule.
    amax : float, optional
        Maximum step size.
    extra_condition : callable, optional
        A callable of the form ``extra_condition(alpha, phi_value)``
        returning a boolean. The line search accepts the value
        of ``alpha`` only if this callable returns ``True``.
        If the callable returns ``False`` for the step length,
        the algorithm will continue with new iterates.
        The callable is only called for iterates satisfying
        the strong Wolfe conditions.
    maxiter : int, optional
        Maximum number of iterations to perform.

    Returns
    -------
    alpha_star : float or None
        Best alpha, or None if the line search algorithm did not converge.
    phi_star : float
        phi at alpha_star.
    phi0 : float
        phi at 0.
    derphi_star : float or None
        derphi at alpha_star, or None if the line search algorithm
        did not converge.

    Notes
    -----
    Uses the line search algorithm to enforce strong Wolfe
    conditions. See Wright and Nocedal, 'Numerical Optimization',
    1999, pp. 59-61.

    Nr6rr7r8c��dS)NTr)rRr!s  r�<lambda>z&scalar_search_wolfe2.<locals>.<lambda>�s��T�rz7Rounding errors prevent the line search from convergingz4The line search algorithm could not find a solution zless than or equal to amax: %sr9rY)r>rBrr�_zoom�abs)r!r)rErFr2r*r+r,rWrM�alpha0rG�phi_a1�phi_a0�	derphi_a0rNr[r\r]�msg�not_first_iteration�	derphi_a1�alpha2s                       rr	r	=s���r�|��s�2�w�w�����&��*�*��
�F����1����S�&�$��/�2�7�:�;�;�����
��z�z������V�T�"�"��
�S��[�[�F��F��I���1�1��
�7�^�^�8N�8N���Q�;�;�4�+��$����J��H��D��K���{�{�O���L�6��=�>��
��'�(�(�(��E��!�e���T�B��K�'�1�1�1�1�
�v�
�
�#6�
��f�f�f�$�i��f�"�G�R��_�F�F�
.�J��+�
�E��F�6�N�N�	��	�N�N�r�c�'�k�)�)���v�v�.�.�
�#�
�!��'������N�N��f�f�f�$�i��f�"�G�R��_�F�F�
.�J��+�
�E��V��������&�&�F���������V�����	�	��
������
9�;L�M�M�M��x��{�2�2rc
��tjddd���5	|}||z
}||z
}	||	zdz||	z
z}
tjd��}|	dz|d<|dz|d<|	dz|d<|dz|d	<tj|tj||z
||zz
||z
||	zz
g�������\}}
||
z}|
|
z}
|
|
zd|z|zz
}||
tj|��zd|zzz}n#t$rYd
d
d
��d
SwxYw	d
d
d
��n#1swxYwYtj|��sd
S|S)z�
    Finds the minimizer for a cubic polynomial that goes through the
    points (a,fa), (b,fb), and (c,fc) with derivative at a of fpa.

    If no minimizer can be found, return None.

    �raise��divide�over�invalidr9)r9r9)rr)rr�)rr)rrN)	r$�errstate�emptyr%�asarray�flatten�sqrt�ArithmeticError�isfinite)�a�fa�fpa�b�fb�cr�C�db�dc�denom�d1�A�B�radical�xmins                r�	_cubicminr��s���
��G�'�7�	C�	C�	C���	��A��Q��B��Q��B��"�W��N�b�2�g�.�E���&�!�!�B��Q�w�B�t�H��a��x�B�t�H��a��x�B�t�H��Q�w�B�t�H��V�B��
�B��G�a�"�f�,<�,.��G�a�"�f�,<�,>�!?�!?�?F�w�y�y�J�J�F�Q��
��J�A�
��J�A��!�e�a�!�e�a�i�'�G����R�W�W�-�-�-�!�a�%�8�8�D�D���	�	�	��%��������"	����
�!������������������&�;�t�����t��Ks5�D�CC4�3D�4
D
�>D�D
�
D�D!�$D!c��tjddd���5	|}|}||dzz
}||z
||zz
||zz}||d|zzz
}	n#t$rYddd��dSwxYw	ddd��n#1swxYwYtj|	��sdS|	S)z�
    Finds the minimizer for a quadratic polynomial that goes through
    the points (a,fa), (b,fb) with derivative at a of fpa.

    rlrmr7�@N)r$rrrwrx)
ryrzr{r|r}�Drr�r�r�s
          r�_quadminr��s#��
��G�'�7�	C�	C�	C���	��A��A��Q��W��B��a��!�b�&��R�"�W�-�A��q�C�!�G�}�$�D�D���	�	�	����������	����
�
�������������������;�t�����t��Ks4�A,�(A�A,�
A�
A,�A�A,�,A0�3A0c	�L�d}d}
d}d}|}d}	||z
}|dkr||}}n||}}|
dkr||z}t|||||||��}|
dks|�|||z
ks	|||zkr4||z}t|||||��}|�|||z
ks	|||zkr|d|zz}||��}|||	|z|zzks||kr	|}|}|}|}nT||��}t|��|
|zkr|||��r|}|}|}n3|||z
zdkr	|}|}|}|}n|}|}|}|}|}|
dz
}
|
|krd}d}d}n��|||fS)	aZoom stage of approximate linesearch satisfying strong Wolfe conditions.
    
    Part of the optimization algorithm in `scalar_search_wolfe2`.
    
    Notes
    -----
    Implements Algorithm 3.6 (zoom) in Wright and Nocedal,
    'Numerical Optimization', 1999, pp. 61.

    rOrg�������?皙�����?TN��?r)r�r�rb)�a_lo�a_hi�phi_lo�phi_hi�	derphi_lor!r)rEr2r*r+rWrMrN�delta1�delta2�phi_rec�a_rec�dalpharyr|�cchk�a_j�qchk�phi_aj�	derphi_aj�a_star�val_star�
valprime_stars                             rraras����G�	�A�
�F�
�F��G�
�E�@������A�:�:���q�A�A���q�A�
��E�E��F�?�D��D�&�)�T�6�!�7�,�,�C�
��F�F����q�4�x���S�1�t�8�^�^��F�?�D��4���D�&�A�A�C����q��v���3��4��<�<��S��Z�'����S�����T�B�s�F�7�N�*�*�*��&�0@�0@��G��E��D��F�F���s���I��9�~�~�"��W��,�,����f�1M�1M�,���!�� )�
���$��+�&�!�+�+� ��������� �����D��F�!�I�	�Q���
��K�K��F��H� �M��A@�B�8�]�*�*rrc�������
�tj����dg�
���
��fd�}|�|d��}	n|}	tj|���}
t||	|
||���\}}|�
d|fS)aMinimize over alpha, the function ``f(xk+alpha pk)``.

    Parameters
    ----------
    f : callable
        Function to be minimized.
    xk : array_like
        Current point.
    pk : array_like
        Search direction.
    gfk : array_like
        Gradient of `f` at point `xk`.
    old_fval : float
        Value of `f` at point `xk`.
    args : tuple, optional
        Optional arguments.
    c1 : float, optional
        Value to control stopping criterion.
    alpha0 : scalar, optional
        Value of `alpha` at start of the optimization.

    Returns
    -------
    alpha
    f_count
    f_val_at_alpha

    Notes
    -----
    Uses the interpolation algorithm (Armijo backtracking) as suggested by
    Wright and Nocedal in 'Numerical Optimization', 1999, pp. 56-57

    rc�B���dxxdz
cc<��|�zzg��R�Srr)rGrrrrr s �����rr!zline_search_armijo.<locals>.phi�s8���
�1�����
�����q��f�R�i��'�$�'�'�'�'rNr6)r*rc)r$�
atleast_1dr%�scalar_search_armijo)rr rr/r0rr*rcr!rEr2rRrHrs```  `       @rr
r
`s��������D
��r�	�	�B�
��B�(�(�(�(�(�(�(�(�(����s�2�w�w������f�S�"�o�o�G�&�s�D�'�b�.4�6�6�6�K�E�4��"�Q�%���rc
�`�t||||||||���}|d|dd|dfS)z8
    Compatibility wrapper for `line_search_armijo`
    )rr*rcrrr9)r
)	rr rr/r0rr*rc�rs	         r�line_search_BFGSr��sD��	�1�b�"�c�8�$�2�"(�	*�	*�	*�A��Q�4��1��q�!�A�$��rc��||��}||||z|zzkr||fS||dzzdz||z
||zz
z}||��}||||z|zzkr||fS||kr�|dz|dzz||z
z}	|dz||z
||zz
z|dz||z
||zz
zz
}
|
|	z}
|dz||z
||zz
z|dz||z
||zz
zz}||	z}|tjt|dzd|
z|zz
����zd|
zz}||��}
|
|||z|zzkr||
fS||z
|dzksd||zz
dkr|dz}|}|}|}|
}||k��d|fS)a(Minimize over alpha, the function ``phi(alpha)``.

    Uses the interpolation algorithm (Armijo backtracking) as suggested by
    Wright and Nocedal in 'Numerical Optimization', 1999, pp. 56-57

    alpha > 0 is assumed to be a descent direction.

    Returns
    -------
    alpha
    phi1

    r9r�rqg@rg���Q��?N)r$rvrb)r!rEr2r*rcr-rerGrd�factorryr|rj�phi_a2s              rr�r��s����S��[�[�F�
���6�	�'�)�)�)�)��v�~���Z�&�!�)�
#�c�
)�V�d�]�W�v�=M�-M�
N�F�
�S��[�[�F��$��F��7�*�*�*�*��v�~���4�-�-����V�Q�Y�&�&��-�8���A�I��$�����7�8��A�I��$�����7�8�
9��
��J��
�Q�Y�J�&�4�-�'�&�.�8�9��A�I��$�����7�8�
9��
��J���"�r�w�s�1�a�4�!�a�%�'�/�#9�:�:�;�;�;��A��F����V�����d�R��Y�w�.�.�.�.��6�>�!��V�O�v��|�+�+��F�6�M�0A�T�/I�/I��c�\�F���������+�4�-�-�0��<�rr�r�c���|d}t|��}	d}
d}d}	||
|zz}
||
��\}}||	|z||
dzz|zz
kr|
}n�|
dz|z|d|
zdz
|zzz}|||zz
}
||
��\}}||	|z||dzz|zz
kr|}nP|dz|z|d|zdz
|zzz}tj|||
z||
z��}
tj|||z||z��}��||
||fS)a@
    Nonmonotone backtracking line search as described in [1]_

    Parameters
    ----------
    f : callable
        Function returning a tuple ``(f, F)`` where ``f`` is the value
        of a merit function and ``F`` the residual.
    x_k : ndarray
        Initial position.
    d : ndarray
        Search direction.
    prev_fs : float
        List of previous merit function values. Should have ``len(prev_fs) <= M``
        where ``M`` is the nonmonotonicity window parameter.
    eta : float
        Allowed merit function increase, see [1]_
    gamma, tau_min, tau_max : float, optional
        Search parameters, see [1]_

    Returns
    -------
    alpha : float
        Step length
    xp : ndarray
        Next position
    fp : float
        Merit function value at next position
    Fp : ndarray
        Residual at next position

    References
    ----------
    [1] "Spectral residual method without gradient information for solving
        large-scale nonlinear systems of equations." W. La Cruz,
        J.M. Martinez, M. Raydan. Math. Comp. **75**, 1429 (2006).

    ���rTr9)�maxr$�clip)r�x_k�d�prev_fs�eta�gamma�tau_min�tau_max�f_k�f_bar�alpha_p�alpha_mrR�xp�fp�Fp�alpha_tp�alpha_tms                  r�_nonmonotone_line_search_cruzr��s]��P�"�+�C���L�L�E��G��G�
�E�J�
�7�Q�;�
����2�����B�
����u�w��z�1�C�7�7�7�7��E���A�:��#�r�Q�w�Y��]�C�,?�'?�@��
�7�Q�;�
����2�����B�
����u�w��z�1�C�7�7�7�7��H�E���A�:��#�r�Q�w�Y��]�C�,?�'?�@���'�(�G�g�$5�w��7H�I�I���'�(�G�g�$5�w��7H�I�I��)J�,�"�b�"��r�333333�?c���d}d}d}
	|||zz}||��\}}|||z||dzz|zz
kr|}
n�|dz|z|d|zdz
|zzz}|||zz
}||��\}}|||z||dzz|zz
kr|}
nP|dz|z|d|zdz
|zzz}tj|||z|	|z��}tj|||z|	|z��}��|
|zdz}|
|z||zz|z|z}|}|
|||||fS)a�
    Nonmonotone line search from [1]

    Parameters
    ----------
    f : callable
        Function returning a tuple ``(f, F)`` where ``f`` is the value
        of a merit function and ``F`` the residual.
    x_k : ndarray
        Initial position.
    d : ndarray
        Search direction.
    f_k : float
        Initial merit function value.
    C, Q : float
        Control parameters. On the first iteration, give values
        Q=1.0, C=f_k
    eta : float
        Allowed merit function increase, see [1]_
    nu, gamma, tau_min, tau_max : float, optional
        Search parameters, see [1]_

    Returns
    -------
    alpha : float
        Step length
    xp : ndarray
        Next position
    fp : float
        Merit function value at next position
    Fp : ndarray
        Residual at next position
    C : float
        New value for the control parameter C
    Q : float
        New value for the control parameter Q

    References
    ----------
    .. [1] W. Cheng & D.-H. Li, ''A derivative-free nonmonotone line
           search and its application to the spectral residual
           method'', IMA J. Numer. Anal. 29, 814 (2009).

    rTr9)r$r�)rr�r�r�r�Qr�r�r�r��nur�r�rRr�r�r�r�r��Q_nexts                    r�_nonmonotone_line_search_chengr�#s{��^�G��G�
�E�J�
�7�Q�;�
����2�����B�
��S��5�7�A�:�-��3�3�3�3��E���A�:��#�r�Q�w�Y��]�C�,?�'?�@��
�7�Q�;�
����2�����B�
��S��5�7�A�:�-��3�3�3�3��H�E���A�:��#�r�Q�w�Y��]�C�,?�'?�@���'�(�G�g�$5�w��7H�I�I���'�(�G�g�$5�w��7H�I�I��)J�.�!�V�a�Z�F�	�a��1�s�7�	�b�	 �F�*�A��A��"�b�"�a��"�"r)	NNNrrrrrr)NNNrrrrr)	NNNrrrNNrO)NNNrrNNrO)rrr)rrr)rr�r�)rr�r�r�)�__doc__�warningsr�scipy.optimizerrC�numpyr$�__all__�RuntimeWarningrrr�line_searchrr	r�r�rar
r�r�r�r�rrr�<module>r�s�����������0�0�0�0�0�0�����!�!�!��	�	�	�	�	��	�	�	�/3�37�?C�!�96�96�96�96�xIM�%(�27�P�P�P�P�f!��@D�IM�57�EE�EE�EE�EE�P,0�04�/3�79�N3�N3�N3�N3�b���D���*T+�T+�T+�v1�1�1�1�h����7�7�7�7�~DG�E�E�E�E�REH�&*�N#�N#�N#�N#�N#�N#r

Youez - 2016 - github.com/yon3zu
LinuXploit