403Webshell
Server IP : 217.160.0.135  /  Your IP : 216.73.216.115
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__/_differentialevolution.cpython-311.pyc
�

d�c���dZddlZddlZddlmZmZddlmZddl	m
Z
mZmZddl
mZmZmZmZddlmZdgZejej��jZ						dddd�d�ZGd�d��ZGd�d��ZdS)zn
differential_evolution: The differential evolution global optimization algorithm
Added by Andrew Nelson 2014
�N)�OptimizeResult�minimize)�_status_message)�check_random_state�
MapWrapper�_FunctionWrapper)�Bounds�new_bounds_to_old�NonlinearConstraint�LinearConstraint)�issparse�differential_evolution��best1bin����{�G�z�?���?��ffffff�?FT�latinhypercube�	immediater��integrality�
vectorizedc���t||fid|�d|�d|�d|�d|�d|�d|�d|	�d	|�d
|
�d|�d|
�d
|�d|�d|�d|�d|�d|�d|��5}|���}ddd��n#1swxYwY|S)aDFinds the global minimum of a multivariate function.

    The differential evolution method [1]_ is stochastic in nature. It does
    not use gradient methods to find the minimum, and can search large areas
    of candidate space, but often requires larger numbers of function
    evaluations than conventional gradient-based techniques.

    The algorithm is due to Storn and Price [2]_.

    Parameters
    ----------
    func : callable
        The objective function to be minimized. Must be in the form
        ``f(x, *args)``, where ``x`` is the argument in the form of a 1-D array
        and ``args`` is a tuple of any additional fixed parameters needed to
        completely specify the function. The number of parameters, N, is equal
        to ``len(x)``.
    bounds : sequence or `Bounds`
        Bounds for variables. There are two ways to specify the bounds:
        1. Instance of `Bounds` class.
        2. ``(min, max)`` pairs for each element in ``x``, defining the finite
        lower and upper bounds for the optimizing argument of `func`.
        The total number of bounds is used to determine the number of
        parameters, N.
    args : tuple, optional
        Any additional fixed parameters needed to
        completely specify the objective function.
    strategy : str, optional
        The differential evolution strategy to use. Should be one of:

            - 'best1bin'
            - 'best1exp'
            - 'rand1exp'
            - 'randtobest1exp'
            - 'currenttobest1exp'
            - 'best2exp'
            - 'rand2exp'
            - 'randtobest1bin'
            - 'currenttobest1bin'
            - 'best2bin'
            - 'rand2bin'
            - 'rand1bin'

        The default is 'best1bin'.
    maxiter : int, optional
        The maximum number of generations over which the entire population is
        evolved. The maximum number of function evaluations (with no polishing)
        is: ``(maxiter + 1) * popsize * N``
    popsize : int, optional
        A multiplier for setting the total population size. The population has
        ``popsize * N`` individuals. This keyword is overridden if an
        initial population is supplied via the `init` keyword. When using
        ``init='sobol'`` the population size is calculated as the next power
        of 2 after ``popsize * N``.
    tol : float, optional
        Relative tolerance for convergence, the solving stops when
        ``np.std(pop) <= atol + tol * np.abs(np.mean(population_energies))``,
        where and `atol` and `tol` are the absolute and relative tolerance
        respectively.
    mutation : float or tuple(float, float), optional
        The mutation constant. In the literature this is also known as
        differential weight, being denoted by F.
        If specified as a float it should be in the range [0, 2].
        If specified as a tuple ``(min, max)`` dithering is employed. Dithering
        randomly changes the mutation constant on a generation by generation
        basis. The mutation constant for that generation is taken from
        ``U[min, max)``. Dithering can help speed convergence significantly.
        Increasing the mutation constant increases the search radius, but will
        slow down convergence.
    recombination : float, optional
        The recombination constant, should be in the range [0, 1]. In the
        literature this is also known as the crossover probability, being
        denoted by CR. Increasing this value allows a larger number of mutants
        to progress into the next generation, but at the risk of population
        stability.
    seed : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional
        If `seed` is None (or `np.random`), the `numpy.random.RandomState`
        singleton is used.
        If `seed` is an int, a new ``RandomState`` instance is used,
        seeded with `seed`.
        If `seed` is already a ``Generator`` or ``RandomState`` instance then
        that instance is used.
        Specify `seed` for repeatable minimizations.
    disp : bool, optional
        Prints the evaluated `func` at every iteration.
    callback : callable, `callback(xk, convergence=val)`, optional
        A function to follow the progress of the minimization. ``xk`` is
        the best solution found so far. ``val`` represents the fractional
        value of the population convergence.  When ``val`` is greater than one
        the function halts. If callback returns `True`, then the minimization
        is halted (any polishing is still carried out).
    polish : bool, optional
        If True (default), then `scipy.optimize.minimize` with the `L-BFGS-B`
        method is used to polish the best population member at the end, which
        can improve the minimization slightly. If a constrained problem is
        being studied then the `trust-constr` method is used instead. For large
        problems with many constraints, polishing can take a long time due to
        the Jacobian computations.
    init : str or array-like, optional
        Specify which type of population initialization is performed. Should be
        one of:

            - 'latinhypercube'
            - 'sobol'
            - 'halton'
            - 'random'
            - array specifying the initial population. The array should have
              shape ``(S, N)``, where S is the total population size and N is
              the number of parameters.
              `init` is clipped to `bounds` before use.

        The default is 'latinhypercube'. Latin Hypercube sampling tries to
        maximize coverage of the available parameter space.

        'sobol' and 'halton' are superior alternatives and maximize even more
        the parameter space. 'sobol' will enforce an initial population
        size which is calculated as the next power of 2 after
        ``popsize * N``. 'halton' has no requirements but is a bit less
        efficient. See `scipy.stats.qmc` for more details.

        'random' initializes the population randomly - this has the drawback
        that clustering can occur, preventing the whole of parameter space
        being covered. Use of an array to specify a population could be used,
        for example, to create a tight bunch of initial guesses in an location
        where the solution is known to exist, thereby reducing time for
        convergence.
    atol : float, optional
        Absolute tolerance for convergence, the solving stops when
        ``np.std(pop) <= atol + tol * np.abs(np.mean(population_energies))``,
        where and `atol` and `tol` are the absolute and relative tolerance
        respectively.
    updating : {'immediate', 'deferred'}, optional
        If ``'immediate'``, the best solution vector is continuously updated
        within a single generation [4]_. This can lead to faster convergence as
        trial vectors can take advantage of continuous improvements in the best
        solution.
        With ``'deferred'``, the best solution vector is updated once per
        generation. Only ``'deferred'`` is compatible with parallelization or
        vectorization, and the `workers` and `vectorized` keywords can
        over-ride this option.

        .. versionadded:: 1.2.0

    workers : int or map-like callable, optional
        If `workers` is an int the population is subdivided into `workers`
        sections and evaluated in parallel
        (uses `multiprocessing.Pool <multiprocessing>`).
        Supply -1 to use all available CPU cores.
        Alternatively supply a map-like callable, such as
        `multiprocessing.Pool.map` for evaluating the population in parallel.
        This evaluation is carried out as ``workers(func, iterable)``.
        This option will override the `updating` keyword to
        ``updating='deferred'`` if ``workers != 1``.
        This option overrides the `vectorized` keyword if ``workers != 1``.
        Requires that `func` be pickleable.

        .. versionadded:: 1.2.0

    constraints : {NonLinearConstraint, LinearConstraint, Bounds}
        Constraints on the solver, over and above those applied by the `bounds`
        kwd. Uses the approach by Lampinen [5]_.

        .. versionadded:: 1.4.0

    x0 : None or array-like, optional
        Provides an initial guess to the minimization. Once the population has
        been initialized this vector replaces the first (best) member. This
        replacement is done even if `init` is given an initial population.
        ``x0.shape == (N,)``.

        .. versionadded:: 1.7.0

    integrality : 1-D array, optional
        For each decision variable, a boolean value indicating whether the
        decision variable is constrained to integer values. The array is
        broadcast to ``(N,)``.
        If any decision variables are constrained to be integral, they will not
        be changed during polishing.
        Only integer values lying between the lower and upper bounds are used.
        If there are no integer values lying between the bounds then a
        `ValueError` is raised.

        .. versionadded:: 1.9.0

    vectorized : bool, optional
        If ``vectorized is True``, `func` is sent an `x` array with
        ``x.shape == (N, S)``, and is expected to return an array of shape
        ``(S,)``, where `S` is the number of solution vectors to be calculated.
        If constraints are applied, each of the functions used to construct
        a `Constraint` object should accept an `x` array with
        ``x.shape == (N, S)``, and return an array of shape ``(M, S)``, where
        `M` is the number of constraint components.
        This option is an alternative to the parallelization offered by
        `workers`, and may help in optimization speed by reducing interpreter
        overhead from multiple function calls. This keyword is ignored if
        ``workers != 1``.
        This option will override the `updating` keyword to
        ``updating='deferred'``.
        See the notes section for further discussion on when to use
        ``'vectorized'``, and when to use ``'workers'``.

        .. versionadded:: 1.9.0

    Returns
    -------
    res : OptimizeResult
        The optimization result represented as a `OptimizeResult` object.
        Important attributes are: ``x`` the solution array, ``success`` a
        Boolean flag indicating if the optimizer exited successfully and
        ``message`` which describes the cause of the termination. See
        `OptimizeResult` for a description of other attributes. If `polish`
        was employed, and a lower minimum was obtained by the polishing, then
        OptimizeResult also contains the ``jac`` attribute.
        If the eventual solution does not satisfy the applied constraints
        ``success`` will be `False`.

    Notes
    -----
    Differential evolution is a stochastic population based method that is
    useful for global optimization problems. At each pass through the
    population the algorithm mutates each candidate solution by mixing with
    other candidate solutions to create a trial candidate. There are several
    strategies [3]_ for creating trial candidates, which suit some problems
    more than others. The 'best1bin' strategy is a good starting point for
    many systems. In this strategy two members of the population are randomly
    chosen. Their difference is used to mutate the best member (the 'best' in
    'best1bin'), :math:`b_0`, so far:

    .. math::

        b' = b_0 + mutation * (population[rand0] - population[rand1])

    A trial vector is then constructed. Starting with a randomly chosen ith
    parameter the trial is sequentially filled (in modulo) with parameters
    from ``b'`` or the original candidate. The choice of whether to use ``b'``
    or the original candidate is made with a binomial distribution (the 'bin'
    in 'best1bin') - a random number in [0, 1) is generated. If this number is
    less than the `recombination` constant then the parameter is loaded from
    ``b'``, otherwise it is loaded from the original candidate. The final
    parameter is always loaded from ``b'``. Once the trial candidate is built
    its fitness is assessed. If the trial is better than the original candidate
    then it takes its place. If it is also better than the best overall
    candidate it also replaces that.
    To improve your chances of finding a global minimum use higher `popsize`
    values, with higher `mutation` and (dithering), but lower `recombination`
    values. This has the effect of widening the search radius, but slowing
    convergence.
    By default the best solution vector is updated continuously within a single
    iteration (``updating='immediate'``). This is a modification [4]_ of the
    original differential evolution algorithm which can lead to faster
    convergence as trial vectors can immediately benefit from improved
    solutions. To use the original Storn and Price behaviour, updating the best
    solution once per iteration, set ``updating='deferred'``.
    The ``'deferred'`` approach is compatible with both parallelization and
    vectorization (``'workers'`` and ``'vectorized'`` keywords). These may
    improve minimization speed by using computer resources more efficiently.
    The ``'workers'`` distribute calculations over multiple processors. By
    default the Python `multiprocessing` module is used, but other approaches
    are also possible, such as the Message Passing Interface (MPI) used on
    clusters [6]_ [7]_. The overhead from these approaches (creating new
    Processes, etc) may be significant, meaning that computational speed
    doesn't necessarily scale with the number of processors used.
    Parallelization is best suited to computationally expensive objective
    functions. If the objective function is less expensive, then
    ``'vectorized'`` may aid by only calling the objective function once per
    iteration, rather than multiple times for all the population members; the
    interpreter overhead is reduced.

    .. versionadded:: 0.15.0

    References
    ----------
    .. [1] Differential evolution, Wikipedia,
           http://en.wikipedia.org/wiki/Differential_evolution
    .. [2] Storn, R and Price, K, Differential Evolution - a Simple and
           Efficient Heuristic for Global Optimization over Continuous Spaces,
           Journal of Global Optimization, 1997, 11, 341 - 359.
    .. [3] http://www1.icsi.berkeley.edu/~storn/code.html
    .. [4] Wormington, M., Panaccione, C., Matney, K. M., Bowen, D. K., -
           Characterization of structures from X-ray scattering data using
           genetic algorithms, Phil. Trans. R. Soc. Lond. A, 1999, 357,
           2827-2848
    .. [5] Lampinen, J., A constraint handling approach for the differential
           evolution algorithm. Proceedings of the 2002 Congress on
           Evolutionary Computation. CEC'02 (Cat. No. 02TH8600). Vol. 2. IEEE,
           2002.
    .. [6] https://mpi4py.readthedocs.io/en/stable/
    .. [7] https://schwimmbad.readthedocs.io/en/latest/

    Examples
    --------
    Let us consider the problem of minimizing the Rosenbrock function. This
    function is implemented in `rosen` in `scipy.optimize`.

    >>> import numpy as np
    >>> from scipy.optimize import rosen, differential_evolution
    >>> bounds = [(0,2), (0, 2), (0, 2), (0, 2), (0, 2)]
    >>> result = differential_evolution(rosen, bounds)
    >>> result.x, result.fun
    (array([1., 1., 1., 1., 1.]), 1.9216496320061384e-19)

    Now repeat, but with parallelization.

    >>> result = differential_evolution(rosen, bounds, updating='deferred',
    ...                                 workers=2)
    >>> result.x, result.fun
    (array([1., 1., 1., 1., 1.]), 1.9216496320061384e-19)

    Let's do a constrained minimization.

    >>> from scipy.optimize import LinearConstraint, Bounds

    We add the constraint that the sum of ``x[0]`` and ``x[1]`` must be less
    than or equal to 1.9.  This is a linear constraint, which may be written
    ``A @ x <= 1.9``, where ``A = array([[1, 1]])``.  This can be encoded as
    a `LinearConstraint` instance:

    >>> lc = LinearConstraint([[1, 1]], -np.inf, 1.9)

    Specify limits using a `Bounds` object.

    >>> bounds = Bounds([0., 0.], [2., 2.])
    >>> result = differential_evolution(rosen, bounds, constraints=lc,
    ...                                 seed=1)
    >>> result.x, result.fun
    (array([0.96632622, 0.93367155]), 0.0011352416852625719)

    Next find the minimum of the Ackley function
    (https://en.wikipedia.org/wiki/Test_functions_for_optimization).

    >>> def ackley(x):
    ...     arg1 = -0.2 * np.sqrt(0.5 * (x[0] ** 2 + x[1] ** 2))
    ...     arg2 = 0.5 * (np.cos(2. * np.pi * x[0]) + np.cos(2. * np.pi * x[1]))
    ...     return -20. * np.exp(arg1) - np.exp(arg2) + 20. + np.e
    >>> bounds = [(-5, 5), (-5, 5)]
    >>> result = differential_evolution(ackley, bounds, seed=1)
    >>> result.x, result.fun
    (array([0., 0.]), 4.440892098500626e-16)

    The Ackley function is written in a vectorized manner, so the
    ``'vectorized'`` keyword can be employed. Note the reduced number of
    function evaluations.

    >>> result = differential_evolution(
    ...     ackley, bounds, vectorized=True, updating='deferred', seed=1
    ... )
    >>> result.x, result.fun
    (array([0., 0.]), 4.440892098500626e-16)

    �args�strategy�maxiter�popsize�tol�mutation�
recombination�seed�polish�callback�disp�init�atol�updating�workers�constraints�x0rrN)�DifferentialEvolutionSolver�solve)�func�boundsrrr r!r"r#r$r%r'r(r&r)r*r+r,r-r.rr�solver�rets                       �G/usr/lib/python3/dist-packages/scipy/optimize/_differentialevolution.pyrrsi��P
%�T�6�
<�
<�
<���
<�.6�h�
<�-4�W�
<�.5�W�
<�;>�#�
<�/7�h�	
<�
4A�=�
<�+/�$�

<�8>�v�

<�/7�h�
<�+/�$�
<�6:�T�
<�AE��
<�/7�h�
<�.5�W�
<�2=��
<�)+��
<�2=��
<�1;�
�
<��@F��l�l�n�n��������������������"�Js�A'�'A+�.A+c�@�eZdZdZddddddd�Zddddddd	�Zd
Zddd
dddddejdddddddddfddd�d�Z	d�Z
d�Zd�Zd�Z
ed���Zed ���Zd!�Zd"�Zd#�Zd$�Zd%�Zd&�Zd'�Zd(�Zd)�Zd*�Zd+�Zd,�Zd-�Zd.�Zd/�Zd0�Z d1�Z!d2�Z"d3�Z#d4�Z$d5�Z%d6�Z&dS)7r/a%This class implements the differential evolution solver

    Parameters
    ----------
    func : callable
        The objective function to be minimized. Must be in the form
        ``f(x, *args)``, where ``x`` is the argument in the form of a 1-D array
        and ``args`` is a tuple of any additional fixed parameters needed to
        completely specify the function. The number of parameters, N, is equal
        to ``len(x)``.
    bounds : sequence or `Bounds`
        Bounds for variables. There are two ways to specify the bounds:
        1. Instance of `Bounds` class.
        2. ``(min, max)`` pairs for each element in ``x``, defining the finite
        lower and upper bounds for the optimizing argument of `func`.
        The total number of bounds is used to determine the number of
        parameters, N.
    args : tuple, optional
        Any additional fixed parameters needed to
        completely specify the objective function.
    strategy : str, optional
        The differential evolution strategy to use. Should be one of:

            - 'best1bin'
            - 'best1exp'
            - 'rand1exp'
            - 'randtobest1exp'
            - 'currenttobest1exp'
            - 'best2exp'
            - 'rand2exp'
            - 'randtobest1bin'
            - 'currenttobest1bin'
            - 'best2bin'
            - 'rand2bin'
            - 'rand1bin'

        The default is 'best1bin'

    maxiter : int, optional
        The maximum number of generations over which the entire population is
        evolved. The maximum number of function evaluations (with no polishing)
        is: ``(maxiter + 1) * popsize * N``
    popsize : int, optional
        A multiplier for setting the total population size. The population has
        ``popsize * N`` individuals. This keyword is overridden if an
        initial population is supplied via the `init` keyword. When using
        ``init='sobol'`` the population size is calculated as the next power
        of 2 after ``popsize * N``.
    tol : float, optional
        Relative tolerance for convergence, the solving stops when
        ``np.std(pop) <= atol + tol * np.abs(np.mean(population_energies))``,
        where and `atol` and `tol` are the absolute and relative tolerance
        respectively.
    mutation : float or tuple(float, float), optional
        The mutation constant. In the literature this is also known as
        differential weight, being denoted by F.
        If specified as a float it should be in the range [0, 2].
        If specified as a tuple ``(min, max)`` dithering is employed. Dithering
        randomly changes the mutation constant on a generation by generation
        basis. The mutation constant for that generation is taken from
        U[min, max). Dithering can help speed convergence significantly.
        Increasing the mutation constant increases the search radius, but will
        slow down convergence.
    recombination : float, optional
        The recombination constant, should be in the range [0, 1]. In the
        literature this is also known as the crossover probability, being
        denoted by CR. Increasing this value allows a larger number of mutants
        to progress into the next generation, but at the risk of population
        stability.
    seed : {None, int, `numpy.random.Generator`, `numpy.random.RandomState`}, optional
        If `seed` is None (or `np.random`), the `numpy.random.RandomState`
        singleton is used.
        If `seed` is an int, a new ``RandomState`` instance is used,
        seeded with `seed`.
        If `seed` is already a ``Generator`` or ``RandomState`` instance then
        that instance is used.
        Specify `seed` for repeatable minimizations.
    disp : bool, optional
        Prints the evaluated `func` at every iteration.
    callback : callable, `callback(xk, convergence=val)`, optional
        A function to follow the progress of the minimization. ``xk`` is
        the current value of ``x0``. ``val`` represents the fractional
        value of the population convergence. When ``val`` is greater than one
        the function halts. If callback returns `True`, then the minimization
        is halted (any polishing is still carried out).
    polish : bool, optional
        If True (default), then `scipy.optimize.minimize` with the `L-BFGS-B`
        method is used to polish the best population member at the end, which
        can improve the minimization slightly. If a constrained problem is
        being studied then the `trust-constr` method is used instead. For large
        problems with many constraints, polishing can take a long time due to
        the Jacobian computations.
    maxfun : int, optional
        Set the maximum number of function evaluations. However, it probably
        makes more sense to set `maxiter` instead.
    init : str or array-like, optional
        Specify which type of population initialization is performed. Should be
        one of:

            - 'latinhypercube'
            - 'sobol'
            - 'halton'
            - 'random'
            - array specifying the initial population. The array should have
              shape ``(S, N)``, where S is the total population size and
              N is the number of parameters.
              `init` is clipped to `bounds` before use.

        The default is 'latinhypercube'. Latin Hypercube sampling tries to
        maximize coverage of the available parameter space.

        'sobol' and 'halton' are superior alternatives and maximize even more
        the parameter space. 'sobol' will enforce an initial population
        size which is calculated as the next power of 2 after
        ``popsize * N``. 'halton' has no requirements but is a bit less
        efficient. See `scipy.stats.qmc` for more details.

        'random' initializes the population randomly - this has the drawback
        that clustering can occur, preventing the whole of parameter space
        being covered. Use of an array to specify a population could be used,
        for example, to create a tight bunch of initial guesses in an location
        where the solution is known to exist, thereby reducing time for
        convergence.
    atol : float, optional
        Absolute tolerance for convergence, the solving stops when
        ``np.std(pop) <= atol + tol * np.abs(np.mean(population_energies))``,
        where and `atol` and `tol` are the absolute and relative tolerance
        respectively.
    updating : {'immediate', 'deferred'}, optional
        If ``'immediate'``, the best solution vector is continuously updated
        within a single generation [4]_. This can lead to faster convergence as
        trial vectors can take advantage of continuous improvements in the best
        solution.
        With ``'deferred'``, the best solution vector is updated once per
        generation. Only ``'deferred'`` is compatible with parallelization or
        vectorization, and the `workers` and `vectorized` keywords can
        over-ride this option.
    workers : int or map-like callable, optional
        If `workers` is an int the population is subdivided into `workers`
        sections and evaluated in parallel
        (uses `multiprocessing.Pool <multiprocessing>`).
        Supply `-1` to use all cores available to the Process.
        Alternatively supply a map-like callable, such as
        `multiprocessing.Pool.map` for evaluating the population in parallel.
        This evaluation is carried out as ``workers(func, iterable)``.
        This option will override the `updating` keyword to
        `updating='deferred'` if `workers != 1`.
        Requires that `func` be pickleable.
    constraints : {NonLinearConstraint, LinearConstraint, Bounds}
        Constraints on the solver, over and above those applied by the `bounds`
        kwd. Uses the approach by Lampinen.
    x0 : None or array-like, optional
        Provides an initial guess to the minimization. Once the population has
        been initialized this vector replaces the first (best) member. This
        replacement is done even if `init` is given an initial population.
        ``x0.shape == (N,)``.
    integrality : 1-D array, optional
        For each decision variable, a boolean value indicating whether the
        decision variable is constrained to integer values. The array is
        broadcast to ``(N,)``.
        If any decision variables are constrained to be integral, they will not
        be changed during polishing.
        Only integer values lying between the lower and upper bounds are used.
        If there are no integer values lying between the bounds then a
        `ValueError` is raised.
    vectorized : bool, optional
        If ``vectorized is True``, `func` is sent an `x` array with
        ``x.shape == (N, S)``, and is expected to return an array of shape
        ``(S,)``, where `S` is the number of solution vectors to be calculated.
        If constraints are applied, each of the functions used to construct
        a `Constraint` object should accept an `x` array with
        ``x.shape == (N, S)``, and return an array of shape ``(M, S)``, where
        `M` is the number of constraint components.
        This option is an alternative to the parallelization offered by
        `workers`, and may help in optimization speed. This keyword is
        ignored if ``workers != 1``.
        This option will override the `updating` keyword to
        ``updating='deferred'``.
    �_best1�_randtobest1�_currenttobest1�_best2�_rand2�_rand1)r�randtobest1bin�currenttobest1bin�best2bin�rand2bin�rand1bin)�best1exp�rand1exp�randtobest1exp�currenttobest1exp�best2exp�rand2expz�The population initialization method must be one of 'latinhypercube' or 'random', or an array of shape (S, N) where N is the number of parameters and S>5rrrrrrrNFTrrrrrc	�
�||jvr!t||j|��|_n9||jvr!t||j|��|_nt	d���||_||_||_|dvr||_||_	|dkr)|dkr#tjdtd���d|_|r%|dkrtjd	d���d
x|_	}|r)|dkr#tjdtd���d|_|rd�}|}t|��|_||c|_|_||_t%jt%j|����rTt%jt%j|��dk��s*t%jt%j|��d
k��rt	d���d|_t1|d��rAt3|��dkr.|d
|dg|_|j���|	|_t9||��|_||_t?|t@��rQt%jtC|j"|j#t3|j"����tH���j%|_&n t%j|d���j%|_&t%j'|j&d
��dks+t%jt%j|j&����st	d���|�d}||_(|�t$j)}||_*d|j&d
|j&dzz|_+t%j,|j&d
|j&dz
��|_-t%j'|j&d��|_.t_|
��|_0t%j|���r&t%j1||j.��}t%j2|tf��}t%j4|j&��\}}t%j5|��}t%j6|��}||||k���st	d���t%j7||dz
t$j)��}t%j7||dzt$j)��}||_8||j&d
|j8f<||j&d|j8f<nd
|_8tsd||j.z��|_:|j:|j.f|_;d
|_<t?|tz��r�|dkr|�>��n�|dkrltdt%j5t%j@|j:����z��}||_:|j:|j.f|_;|�Ad���na|dkr|�Ad���nD|dkr|�B��n)t	|jC���|�D|��|�_|�Et%j2|����}|dk|dkz���rt	d���||jFd
<||_Gg|_Ht1|d��r3|D]/}|jH�It�||jK�����0nt�||jK��g|_Ht%jLd �|jHD����|_Mt%jN|j:df��|_Ot%jP|j:tf��|_Q|
|_RdS)!Nz'Please select a valid mutation strategy)r�deferredrrzhdifferential_evolution: the 'workers' keyword has overridden updating='immediate' to updating='deferred'�)�
stacklevelrIzPdifferential_evolution: the 'workers' keyword overrides the 'vectorized' keywordFzkdifferential_evolution: the 'vectorized' keyword has overridden updating='immediate' to updating='deferred'c�F�tj||j����S�N)�np�
atleast_1d�T)r1�xs  r5�maplike_for_vectorized_funczIDifferentialEvolutionSolver.__init__.<locals>.maplike_for_vectorized_func�s���}�T�T�!�#�Y�Y�/�/�/�rz�The mutation constant must be a float in U[0, 2), or specified as a tuple(min, max) where min < max and min, max are in U[0, 2).�__iter__��dtype�floatzWbounds should be a sequence containing real valued (min, max) pairs for each value in xrrzlOne of the integrality constraints does not have any possible integer values between the lower/upper bounds.�r�sobol)�
qmc_engine�halton�random��?�z3Some entries in x0 lay outside the specified bounds�__len__c��g|]	}|j��
Sr)�
num_constr)�.0�cs  r5�
<listcomp>z8DifferentialEvolutionSolver.__init__.<locals>.<listcomp> s��=�=�=�a�Q�\�=�=�=rS)S�	_binomial�getattr�
mutation_func�_exponential�
ValueErrorrr'r&�	_updatingr�warnings�warn�UserWarningr�_mapwrapperr"r*�scalerN�all�isfinite�any�array�dither�hasattr�len�sort�cross_over_probabilityrr1r�
isinstancer	r
�lb�ubrWrP�limits�sizer �inf�maxfun�(_DifferentialEvolutionSolver__scale_arg1�fabs�(_DifferentialEvolutionSolver__scale_arg2�parameter_countr�random_number_generator�broadcast_to�asarray�bool�copy�ceil�floor�	nextafterr�max�num_population_members�population_shape�_nfev�str�init_population_lhs�int�log2�init_population_qmc�init_population_random�,_DifferentialEvolutionSolver__init_error_msg�init_population_array�_unscale_parameters�
populationr-�_wrapped_constraints�append�_ConstraintWrapperrQ�sum�total_constraints�zeros�constraint_violation�ones�feasibler()�selfr1r2rrr r!r"r#r$r%rr'r(r&r)r*r+r,r-r.rrrRrzr{�nlb�nub�n_s�	x0_scaledrcs                               r5�__init__z$DifferentialEvolutionSolver.__init__Zs����t�~�%�%�!(��t�~�h�/G�!H�!H�D���
��*�
*�
*�!(��t�/@��/J�!K�!K�D����F�G�G�G� ��
� ��
�����0�0�0�%�D�N�$����a�<�<�H��3�3��M�1�2=�!�
M�
M�
M�
M�(�D�N��	1�'�Q�,�,��M�@�LM�
O�
O�
O�
O�+0�0�D�O�j��	(�(�k�1�1��M�(�)4��
D�
D�
D�
D�(�D�N��	2�
0�
0�
0�
2�G�%�g�.�.���"�4����$�)���
���r�{�8�,�,�-�-�	N���r�x��)�)�Q�.�/�/�	N���r�x��)�)�A�-�.�.�	N��M�N�N�
N�����8�Z�(�(�	�S��]�]�Q�->�->�#�A�;����4�D�K��K������&3��#�%�T�4�0�0��	���	�
�f�f�%�%�	<��(�#4�V�Y�5;�Y�58���^�^�$E�$E�*/�0�0�0�12�
�K�K�
�(�6��9�9�9�;�D�K��G�D�K��#�#�q�(�(���r�{�4�;�/�/�0�0�
)��%�&�&�
&��?��G�����>��V�F���� �4�;�q�>�D�K��N�#B�C����G�D�K��N�T�[��^�$C�D�D���!�w�t�{�A�6�6���'9�$�'?�'?��$��6�+���	%��/���$���K��*�[�$�7�7�K��W�T�[�)�)�F�B�������B���"���B��{�O�r�+��6�;�;�=�=�
=�!�"<�=�=�=��,�r�+���4�b�f�=�=�C��,�r�+���4�r�v�g�>�>�C�*�D��/2�D�K��4�+�+�,�/2�D�K��4�+�+�,�,�$�D��'*�!�W�t�7K�-K�&L�&L��#�!%�!<�!%�!5�!7�����
��d�C� � �	-��'�'�'��(�(�*�*�*�*������!�r�w�r�w�t�/J�'K�'K�L�L�L�M�M��.1��+�)-�)D�)-�)=�)?��%��(�(�G�(�<�<�<�<���!�!��(�(�H�(�=�=�=�=���!�!��+�+�-�-�-�-� ��!6�7�7�7��&�&�t�,�,�,�
�>��0�0���B���@�@�I��S��Y��_�5�:�:�<�<�
� �I����"+�D�O�A��'���$&��!��;�	�*�*�
	�!�
�
���)�0�0�&�q�$�&�1�1�����
�#�;���7�7�)�D�%�"$��=�=�4�#<�=�=�=�"
�"
���%'�H�d�.I�1�-M�$N�$N��!���� ;�T�B�B��
���	�	�	rSc��|j}d|jz}||�|j���zt	jdd|jd���dd�tjfz}t	j|��|_t|j
��D]?}|�t|j����}|||f|jdd�|f<�@t	j|jtj
��|_d|_dS)z�
        Initializes the population with Latin Hypercube Sampling.
        Latin Hypercube Sampling ensures that each parameter is uniformly
        sampled over its range.
        r]�r}r^F)�endpointNr)r�r��uniformr�rN�linspace�newaxis�
zeros_liker��ranger��permutation�fullr~�population_energiesr�)r��rng�segsize�samples�j�orders      r5r�z/DifferentialEvolutionSolver.init_population_lhs's���*����3�3���S�[�[�d�.C�[�D�D�D��[��R��)D�*/�1�1�1�12���B�J��@�@���-��0�0����t�+�,�,�	6�	6�A��O�O�E�$�*E�$F�$F�G�G�E�$+�E�1�H�$5�D�O�A�A�A�q�D�!�!�$&�7�4�+F�+-�6�$3�$3�� ���
�
�
rSc��ddlm}|j}|dkr|�|j|���}nZ|dkr|�|j|���}n7|dkr|�|j|���}nt|j���|�	|j
���|_tj
|j
tj��|_d|_dS)	aRInitializes the population with a QMC method.

        QMC methods ensures that each parameter is uniformly
        sampled over its range.

        Parameters
        ----------
        qmc_engine : str
            The QMC method to use for initialization. Can be one of
            ``latinhypercube``, ``sobol`` or ``halton``.

        r)�qmcr)�dr%rYr[)�nN)�scipy.statsr�r��LatinHypercuber��Sobol�Haltonrir�r\r�r�rNr�r~r�r�)r�rZr�r��samplers     r5r�z/DifferentialEvolutionSolver.init_population_qmcMs���	$�#�#�#�#�#��*���)�)�)��(�(�4�+?�c�(�J�J�G�G�
�7�
"�
"��i�i�$�"6�S�i�A�A�G�G�
�8�
#�
#��j�j�4�#7�c�j�B�B�G�G��T�2�3�3�3�!�.�.�4�+F�.�G�G���$&�7�4�+F�+-�6�$3�$3�� ���
�
�
rSc��|j}|�|j���|_t	j|jtj��|_d|_	dS)z�
        Initializes the population at random. This type of initialization
        can possess clustering, Latin Hypercube sampling is generally better.
        r�rN)
r�r�r�r�rNr�r�r~r�r�)r�r�s  r5r�z2DifferentialEvolutionSolver.init_population_randomqsQ��
�*���+�+�4�+@�+�A�A���$&�7�4�+F�+-�6�$3�$3�� ���
�
�
rSc��tj|��}tj|d��dks.|jd|jkst|j��dkrt
d���tj|�|��dd��|_	tj|j	d��|_
|j
|jf|_tj|j
tj
��|_d|_dS)ah
        Initializes the population with a user specified population.

        Parameters
        ----------
        init : np.ndarray
            Array specifying subset of the initial population. The array should
            have shape (S, N), where N is the number of parameters.
            The population is clipped to the lower and upper bounds.
        rrXrrJzEThe population supplied needs to have shape (S, len(x)), where S > 4.N)rN�asfarrayr}�shaper�rvri�clipr�r�r�r�r�r~r�r�)r�r)�popns   r5r�z1DifferentialEvolutionSolver.init_population_array�s����{�4� � ���G�D�!���q� � ��
�1�
��!5�5�5��D�J���1�$�$��:�;�;�
;��'�$�":�":�4�"@�"@�!�Q�G�G���&(�g�d�o�q�&A�&A��#�!%�!<�!%�!5�!7���$&�7�4�+F�+-�6�$3�$3�� ���
�
�
rSc�B�|�|jd��S)z3
        The best solution from the solver
        r)�_scale_parametersr��r�s r5rQzDifferentialEvolutionSolver.x�s��
�%�%�d�o�a�&8�9�9�9rSc�
�tjtj|j����rtjStj|j��tjtj|j��tz��zS)zb
        The standard deviation of the population energies divided by their
        mean.
        )	rNrr�isinfr�r~�std�abs�mean�_MACHEPSr�s r5�convergencez'DifferentialEvolutionSolver.convergence�se���6�"�(�4�3�4�4�5�5�	��6�M���t�/�0�0���r�w�t�7�8�8�8�C�D�D�E�	FrSc��tjtj|j����rdStj|j��|j|jtjtj|j����zzkS)z:
        Return True if the solver has converged.
        F)	rNrrr�r�r�r*r"r�r�r�s r5�	convergedz%DifferentialEvolutionSolver.converged�sp���6�"�(�4�3�4�4�5�5�	��5���t�/�0�0��	���2�6�"�'�$�*B�"C�"C�D�D�D�E�E�	FrSc	��
�d\}}td}tjtj|j����rm|�|j��\|_|_|�	|j|j��|j|j<|�
��td|jdz��D]�}	t|��nC#t$r6d}|j|jkrtd}n|j|jkrd}Yn�wxYw|jrt%d||jdfz��|jrD|j|jt,zz}t/|�|j|�	����}|rd
}|s|���rn��td}d}t5|j|jd|j|||du����
|j�r�tj|j���s�tj|j��r2|j|j}}�
j||d|f<�
j||d|f<d
}|jrNd}|� �
j��}tj|dk��rtCj"dtF��|jrt%d|�d���tI|j%tj&�
j��||jj'|j(���}	|xj|	j)z
c_|j�
_)|	j*�
j*kr�|	j+r�tj|	j|jdk��r}tj|jd|	jk��rU|	j*�
_*|	j�
_|	j,�
_,|	j*|jd<|�-|	j��|jd<|jru�
fd�|jD���
_.tj/tj0�
j.�����
_1�
j1�
_2�
j2dkrd�
_+d�
j2���
_3�
S)a�
        Runs the DifferentialEvolutionSolver.

        Returns
        -------
        res : OptimizeResult
            The optimization result represented as a ``OptimizeResult`` object.
            Important attributes are: ``x`` the solution array, ``success`` a
            Boolean flag indicating if the optimizer exited successfully and
            ``message`` which describes the cause of the termination. See
            `OptimizeResult` for a description of other attributes.  If `polish`
            was employed, and a lower minimum was obtained by the polishing,
            then OptimizeResult also contains the ``jac`` attribute.
        )rF�successrT�maxfevz8Maximum number of function evaluations has been reached.z(differential_evolution step %d: f(x)= %gr)r�z8callback function requested stop early by returning Truer )rQ�fun�nfev�nit�messager�zL-BFGS-Bztrust-constrr^z�differential evolution didn't find a solution satisfying the constraints, attempting to polish from the least infeasible solutionzPolishing solution with '�')�methodr2r-c�D��g|]}|��j����Sr)�	violationrQ)rbrc�	DE_results  �r5rdz5DifferentialEvolutionSolver.solve.<locals>.<listcomp>:s=��� @� @� @� !�!"���I�K� 8� 8� @� @� @rSFz7The solution does not satisfy the constraints, MAXCV = )4rrNrpr�r��#_calculate_population_feasibilitiesr�r�r��_calculate_population_energies�_promote_lowest_energyr�r �next�
StopIterationr�rr(�printr'r"r�r�r�rQr�rr&rrrr|r��_constraint_violation_fnrkrlrmrr1r�rPr-r�r�r��jacr��constrr��concatenate�constr_violation�maxcvr�)r�r��warning_flag�status_messagercr|r�
polish_methodr��resultr�s          @r5r0z!DifferentialEvolutionSolver.solve�s����%���\�(��3���6�"�(�4�3�4�4�5�5�		*��8�8���I�I�
5�D�M�4�4�
�3�3��O�D�M�2�4�4�
�$�T�]�3�
�'�'�)�)�)���D�L�1�,�-�-�	 �	 �C�	
��T�
�
�
�
�� �
�
�
�#���:���+�+�%4�X�%>�N�N��Z�4�;�.�.�';�N����
�����y�
7��@���1�!�4�6�6�7�7�7��}�
<��H�� 0�8� ;�<��#�D�M�M�$�&�a�M�$H�$H�I�I���<�';�N��
�t�~�~�/�/�
���
�-�Y�7�N��L�"��f��(��+����"�!��-�
0�0�0�	��;�+	H�r�v�d�&6�7�7�+	H��v�d�&�'�'�
B�'+�k�4�3C���)2��[�)A��q�+�~�&�)2��[�)A��q�+�~�&�&�M��(�
G� .�
�#'�#@�#@���#M�#M� ��6�*�R�/�0�0�G��M�#9�;F�G�G�G��y�
D��B�-�B�B�B�C�C�C��d�i� �g�i�k�2�2�%2�%)�[�]�*.�*:�	<�<�<�F�
�J�J�&�+�%�J�J�!�Z�I�N�
�
�Y�]�*�*��N�+��F�6�8�t�{�1�~�5�6�6�+��F�4�;�q�>�V�X�5�6�6�+�!'�
�	�
�$�h�	�� &�
�	�
�.4�j��(��+�%)�%=�%=�f�h�%G�%G����"��$�
	P� @� @� @� @�%)�%>� @� @� @�I��)+����y�/�0�0�*2�*2�I�&�'�8�I�O����"�"�$)�	�!�&O�=F�_�&O�&O�	�!��s�C�<D�Dc�n�tj|d��}t||j|jz
��}tj|tj��}|�|��}	t|�	|j
|d|�����}tj|��}n)#ttf$r}td��|�d}~wwxYw|j|kr%|jrtd���td���||d|�<|jr|xjdz
c_n|xj|z
c_|S)aw
        Calculate the energies of a population.

        Parameters
        ----------
        population : ndarray
            An array of parameter vectors normalised to [0, 1] using lower
            and upper limits. Has shape ``(np.size(population, 0), N)``.

        Returns
        -------
        energies : ndarray
            An array of energies corresponding to each population member. If
            maxfun will be exceeded during this call, then the number of
            function evaluations will be reduced and energies will be
            right-padded with np.inf. Has shape ``(np.size(population, 0),)``
        rzzThe map-like callable must be of the form f(func, iterable), returning a sequence of numbers the same length as 'iterable'NzcThe vectorized function must return an array of shape (S,) when given an array of shape (len(x), S)z)func(x, *args) must return a scalar valuer)rNr}�minrr�r�r~r��listrnr1�squeeze�	TypeErrorri�RuntimeErrorr)r�r��num_members�S�energies�parameters_pop�
calc_energies�es        r5r�z:DifferentialEvolutionSolver._calculate_population_energiesGs[��$�g�j�!�,�,��
��T�[�4�:�5�6�6���7�;���/�/���/�/�
�;�;��	� �� � ���N�1�Q�3�,?�@�@���M��J�}�5�5�M�M���:�&�	�	�	��P����
�����	�������"�"���
<�"�$;�<�<�<��J�K�K�K�%���1��
��?�	��J�J�!�O�J�J�J��J�J�!�O�J�J��s�(AB-�-C�>C�Cc���tj|j��}||j}|jr(tj|j|��}||}n-tjtj|jd�����}|j|dg|jd|g<|j	|dgdd�f|j	d|gdd�f<|j|dg|jd|g<|j|dgdd�f|jd|gdd�f<dS)Nr��axisr)
rN�aranger�r�r}�argminr�r�r�r�)r��idx�feasible_solutions�idx_t�ls     r5r�z2DifferentialEvolutionSolver._promote_lowest_energy~s���i��3�4�4�� ���/���"�	E��I�d�6�7I�J�K�K�E�"�5�)�A�A��	�"�&��!:��C�C�C�D�D�A�+/�+C�Q��F�+K�� �!�Q��(�%)�_�a��V�Q�Q�Q�Y�%?����A�����	�"� $�
�q�!�f� 5��
�q�!�f���!�1�a�&�!�!�!�)�,�	
�!�1�a�&�!�!�!�)�,�,�,rSc��tj|��|jz}tj||jf��}d}|jD]�}|�|j��j}|jd|j	ks|dkr |jd|krtd���tj|||j	f��}||dd�|||j	z�f<||j	z
}��|S)a\
        Calculates total constraint violation for all the constraints, for a
        set of solutions.

        Parameters
        ----------
        x : ndarray
            Solution vector(s). Has shape (S, N), or (N,), where S is the
            number of solutions to investigate and N is the number of
            parameters.

        Returns
        -------
        cv : ndarray
            Total violation of constraints. Has shape ``(S, M)``, where M is
            the total number of constraint components (which is not necessarily
            equal to len(self._wrapped_constraints)).
        r���r�MAn array returned from a Constraint has the wrong shape. If `vectorized is False` the Constraint should return an array of shape (M,). If `vectorized is True` then the Constraint must return an array of shape (M, S), where S is the number of solution vectors and M is the number of constraint components in a given Constraint object.N)rNr}r�r�r�r�r�rPr�rar��reshape)r�rQr��_out�offset�conrcs       r5r�z4DifferentialEvolutionSolver._constraint_violation_fn�s���*
�G�A�J�J�$�.�.���x��D�2�3�4�4�����,�	%�	%�C��
�
�a�c�"�"�$�A��w�r�{�c�n�,�,��Q���1�7�1�:��?�?�"�$9�:�:�:��
�1�q�#�.�1�2�2�A�67�D����F�6�C�N�2�2�2�3��c�n�$�F�F��rSc���tj|d��}�js0tj|t��tj|df��fS��|��}�jr(tj��	|����}n,tj�fd�|D����}|dd�df}tj
|d���dk}||fS)a�
        Calculate the feasibilities of a population.

        Parameters
        ----------
        population : ndarray
            An array of parameter vectors normalised to [0, 1] using lower
            and upper limits. Has shape ``(np.size(population, 0), N)``.

        Returns
        -------
        feasible, constraint_violation : ndarray, ndarray
            Boolean array of feasibility for each population member, and an
            array of the constraint violation for each population member.
            constraint_violation has shape ``(np.size(population, 0), M)``,
            where M is the number of constraints.
        rrc�:��g|]}��|����Sr)r�)rbrQr�s  �r5rdzSDifferentialEvolutionSolver._calculate_population_feasibilities.<locals>.<listcomp>�s=���-F�-F�-F�12�.2�-J�-J�1�-M�-M�-F�-F�-FrSNr�)rNr}r�r�r�r�r�rrsr�r�)r�r�r�r�r�r�s`     r5r�z?DifferentialEvolutionSolver._calculate_population_feasibilities�s���$�g�j�!�,�,���(�	J��7�;��-�-�r�x��a�8H�/I�/I�I�I��/�/�
�;�;���?�
	>�#%�8��-�-�n�=�=�$�$� � �
$&�8�-F�-F�-F�-F�6D�-F�-F�-F�$G�$G� �$8����1��#=� ��V�0�q�9�9�9�A�=�>���-�-�-rSc��|SrMrr�s r5rTz$DifferentialEvolutionSolver.__iter__�����rSc��|SrMrr�s r5�	__enter__z%DifferentialEvolutionSolver.__enter__�rrSc� �|jj|�SrM)rn�__exit__)r�rs  r5rz$DifferentialEvolutionSolver.__exit__s��(�t��(�$�/�/rSc�^�|r|r||kS|r|sdS|s||k���rdSdS)a
        Trial is accepted if:
        * it satisfies all constraints and provides a lower or equal objective
          function value, while both the compared solutions are feasible
        - or -
        * it is feasible while the original solution is infeasible,
        - or -
        * it is infeasible, but provides a lower or equal constraint violation
          for all constraint functions.

        This test corresponds to section III of Lampinen [1]_.

        Parameters
        ----------
        energy_trial : float
            Energy of the trial solution
        feasible_trial : float
            Feasibility of trial solution
        cv_trial : array-like
            Excess constraint violation for the trial solution
        energy_orig : float
            Energy of the original solution
        feasible_orig : float
            Feasibility of original solution
        cv_orig : array-like
            Excess constraint violation for the original solution

        Returns
        -------
        accepted : bool

        TF)rp)r��energy_trial�feasible_trial�cv_trial�energy_orig�
feasible_orig�cv_origs       r5�
_accept_trialz)DifferentialEvolutionSolver._accept_trials_��D�	�^�	��;�.�.�
�	�M�	��4��	�X��%8�$=�$=�$?�$?�	��4��urSc
�*	��tjtj�j����rm���j��\�_�_���j�j���j�j<��	���j
�6�j��j
d�j
d���_
�jdk�r�t�j��D�]�}�j�jkrt&���|��}��|����|��}�jrc��|��}d}tj}tj|��dks'd}��|��}�xjdz
c_n<d}tjdg��}��|��}�xjdz
c_��|||�j|�j|�j|��r�|�j|<tj|���j|<|�j|<|�j|<��|||�jd�jd�jd��r��	����ŐnÉjdk�r��j�jkrt&�tj�fd	�t�j��D����}��|����|��\}}tj �jtj��}��||��||<�fd
�tC|||�j�j�j��D��}	tj|	��}	tj"|	dd�tj#f|�j���_tj"|	|�j���_tj"|	|�j���_tj"|	dd�tj#f|�j���_��	���j$�jdfS)z�
        Evolve the population by a single generation

        Returns
        -------
        x : ndarray
            The best solution from the solver.
        fun : float
            Value of objective function obtained from the best solution.
        NrrrFTr^rIc�:��g|]}��|����Sr)�_mutate)rb�ir�s  �r5rdz8DifferentialEvolutionSolver.__next__.<locals>.<listcomp>�s#���M�M�M�Q����a���M�M�MrSc�$��g|]}�j|���
Sr)r)rb�valr�s  �r5rdz8DifferentialEvolutionSolver.__next__.<locals>.<listcomp>�s6���B�B�B��%�4�%�s�+�B�B�BrS)%rNrpr�r�r�r�r�r�r�r�rtr�r�rorjr�r�r�rr�r�_ensure_constraintr�r�r�r~r�r1�
atleast_2drr�rsr��zip�wherer�rQ)
r��	candidate�trial�
parameters�cvr��energy�	trial_pop�trial_energies�locs
`         r5�__next__z$DifferentialEvolutionSolver.__next__0s�����6�"�(�4�3�4�4�5�5�
	*��8�8���I�I�
5�D�M�4�4��3�3��O�D�M�2�4�4�
�$�T�]�3�
�'�'�)�)�)��;�"��5�=�=�d�k�!�n�>B�k�!�n�N�N�D�J��>�[�(�(�"�4�#>�?�?�-
6�-
6�	��:���+�+�'�'����Y�/�/���'�'��.�.�.�"�3�3�E�:�:�
��,�
$��6�6�z�B�B�B�$�H��V�F��6�"�:�:��>�>�#'��!%���:�!6�!6���
�
�a��
�
��#�H����t�,�,�B�!�Y�Y�z�2�2�F��J�J�!�O�J�J��%�%�f�h��&*�&>�y�&I�&*�m�I�&>�&*�&?�	�&J�L�L�6�27�D�O�I�.�:<�*�V�:L�:L�D�,�Y�7�/7�D�M�)�,�;=�D�-�i�8��)�)�&�(�B�*.�*B�1�*E�*.�-��*:�*.�*C�A�*F�H�H�6��3�3�5�5�5��[-
6�^�^�z�
)�
)��z�T�[�(�(�#�#���M�M�M�M�%��0K�*L�*L�M�M�M�O�O�I�
�#�#�I�.�.�.� �C�C�I�N�N�L�H�b��W�T�%@�"�&�I�I�N�(,�'J�'J��(�#�(%�(%�N�8�$�B�B�B�B��~�x��T�5M��}�d�&?�A�A�B�B�B�C��(�3�-�-�C� �h�s�1�1�1�b�j�=�'9�'0�'+��8�8�D�O�(*�x��0>�04�0H�(J�(J�D�$��H�S�%-�%)�]�4�4�D�M�)+���Q�Q�Q��
�]�1C�13�15�1J�)L�)L�D�%�
�'�'�)�)�)��v�t�/��2�2�2rSc���|j|dz
|jzz}tj|j��r<tj|j|j��}tj||��||<|S)z2Scale from a number between 0 and 1 to parameters.r)r�r�rNrrrr�r��round)r�r'�scaledrs    r5r�z-DifferentialEvolutionSolver._scale_parameters�sd���"�e�c�k�T�5F�%F�F��
�6�$�"�#�#�	,���� 0�&�,�?�?�A������+�+�F�1�I��
rSc�,�||jz
|jzdzS)z2Scale from parameters to a number between 0 and 1.r)r�r�)r�r(s  r5r�z/DifferentialEvolutionSolver._unscale_parameters�s���T�.�.�$�2C�C�c�I�IrSc��tj|dk|dkz��}|j�|dj���||<dS)z0Make sure the parameters lie between the limits.rrr�N)rNr%r�r�r�)r�r'�masks   r5r"z.DifferentialEvolutionSolver._ensure_constraint�sE���x����u�q�y�1�2�2���2�:�:��Q��
�:�N�N��d���rSc���tj|j|��}|j}|�|j��}|jdvr+|�||�|d����}n)|�|�|d����}|j|j	vrC|�
|j���}||jk}d||<tj|||��}|S|j|j
vrrd}|�
|j���}||jk}d|d<||jkr8||r0||||<|dz|jz}|dz
}||jkr||�0|SdS)z3Create a trial vector based on a mutation strategy.)rEr>rXr�TrrN)rNr�r�r��choicer�rrg�_select_samplesrer�rxr%rh)r�r&r'r��
fill_point�bprime�
crossoversrs        r5rz#DifferentialEvolutionSolver._mutate�s�������	�2�3�3���*���Z�Z�� 4�5�5�
��=�F�F�F��'�'�	�(,�(<�(<�Y��(J�(J�L�L�F�F��'�'��(<�(<�Y��(J�(J�K�K�F��=�D�N�*�*����$�*>��?�?�J�#�d�&A�A�J�
&*�J�z�"��H�Z���7�7�E��L�
�]�d�/�
/�
/��A����$�*>��?�?�J�#�d�&A�A�J� �J�q�M��t�+�+�+�
�1�
�+�$*�:�$6��j�!�(�1�n��0D�D�
��Q����t�+�+�+�
�1�
�+�
�L�0�
/rSc�~�|dd�\}}|jd|j|j||j|z
zzS)zbest1bin, best1expNrJr�r�ro)r�r��r0�r1s    r5r7z"DifferentialEvolutionSolver._best1�sF����!�����B����"�T�Z����$�t��r�':�:�&<�<�	=rSc��|dd�\}}}|j||j|j||j|z
zzS)zrand1bin, rand1expN�r<)r�r�r=r>�r2s     r5r<z"DifferentialEvolutionSolver._rand1�sH���R�a�R�[�
��B�����#�d�j����$�t��r�':�:�'<�<�	=rSc���|dd�\}}}tj|j|��}||j|jd|z
zz
}||j|j||j|z
zz
}|S)zrandtobest1bin, randtobest1expNr@r)rNr�r�ro)r�r�r=r>rAr9s      r5r8z(DifferentialEvolutionSolver._randtobest1�sx���R�a�R�[�
��B�������,�-�-���$�*���� 2�V� ;�<�<���$�*���� 3� $��� 3�!4�5�	5���
rSc��|dd�\}}|j||j|jd|j|z
|j|z|j|z
zz}|S)z$currenttobest1bin, currenttobest1expNrJrr<)r�r&r�r=r>r9s      r5r9z+DifferentialEvolutionSolver._currenttobest1�sh����!�����B��/�)�,�t�z��?�1�%���	�(B�B��?�2�&�'�)-���)<�=�0>�>���
rSc��|dd�\}}}}|jd|j|j||j|z|j|z
|j|z
zz}|S)zbest2bin, best2expN�rr<)r�r�r=r>rA�r3r9s       r5r:z"DifferentialEvolutionSolver._best2sl�� ��!�����B��B��/�!�$�t�z��?�2�&����)<�<��?�2�&�'�)-���)<�=�(>�>���
rSc��|\}}}}}|j||j|j||j|z|j|z
|j|z
zz}|S)zrand2bin, rand2expr<)r�r�r=r>rArF�r4r9s        r5r;z"DifferentialEvolutionSolver._rand2
sg��$���B��B���/�"�%��
��?�2�&����)<�<��?�2�&�'�)-���)<�=�)>�>���
rSc��tt|j����}|�|��|j�|��|d|�}|S)z�
        obtain random integers from range(self.num_population_members),
        without replacement. You can't have the original candidate either.
        N)r�r�r��remover��shuffle)r�r&�number_samples�idxss    r5r7z+DifferentialEvolutionSolver._select_samplessX��
�E�$�5�6�6�7�7�����I�����$�,�,�T�2�2�2��O�^�O�$���rS)'�__name__�
__module__�__qualname__�__doc__rerhr�rNr~r�r�r�r�r��propertyrQr�r�r0r�r�r�r�rTrrrr.r�r�r"rr7r<r8r9r:r;r7rrSr5r/r/�s�������r�r�j&�#1�&7�%�%�%�'�'�I�!)� (�&4�):� (� (�*�*�L�M��+-�$�d�B��H�C�d����E�$�&�Q����t�K�
EI�!�
K�K�K�K�K�Z$�$�$�L"�"�"�H
�
�
�!�!�!�F�:�:��X�:��F�F��X�F�	F�	F�	F�E�E�E�N5�5�5�n.�.�.�(9�9�9�v+.�+.�+.�Z������0�0�0�+�+�+�Zz3�z3�z3�x���J�J�J�O�O�O�
#�#�#�J=�=�=�=�=�=�������������	�	�	�	�	rSr/c�$�eZdZdZd�Zd�Zd�ZdS)r�a;Object to wrap/evaluate user defined constraints.

    Very similar in practice to `PreparedConstraint`, except that no evaluation
    of jac/hess is performed (explicit or implicit).

    If created successfully, it will contain the attributes listed below.

    Parameters
    ----------
    constraint : {`NonlinearConstraint`, `LinearConstraint`, `Bounds`}
        Constraint to check and prepare.
    x0 : array_like
        Initial vector of independent variables, shape (N,)

    Attributes
    ----------
    fun : callable
        Function defining the constraint wrapped by one of the convenience
        classes.
    bounds : 2-tuple
        Contains lower and upper bounds for the constraints --- lb and ub.
        These are converted to ndarray and have a size equal to the number of
        the constraints.
    c�d���|_t�t��r�fd�}nCt�t��r�fd�}n(t�t��rd�}ntd���||_tj�j	t���}tj�jt���}tj|��}||��}|jx|_
}|j|_|jdkrtj||��}|jdkrtj||��}||f|_dS)Nc�z��tj|��}tj��|����SrM)rNr�rOr�)rQ�
constraints �r5r�z(_ConstraintWrapper.__init__.<locals>.fun<s,����J�q�M�M���}�Z�^�^�A�%6�%6�7�7�7rSc���t�j��r�j}ntj�j��}|�|��SrM)r
�ArNr#�dot)rQrXrVs  �r5r�z(_ConstraintWrapper.__init__.<locals>.fun@s>����J�L�)�)�4�"��A�A��
�j�l�3�3�A��u�u�Q�x�x�rSc�*�tj|��SrM)rNr�)rQs r5r�z(_ConstraintWrapper.__init__.<locals>.funGs���z�!�}�}�$rSz*`constraint` of an unknown type is passed.rUr)rVryrrr	rir�rNr�rzrWr{r}rar��ndim�resizer2)r�rVr.r�rzr{�f0�ms `      r5r�z_ConstraintWrapper.__init__8sX���$����j�"5�6�6�	K�
8�
8�
8�
8�
8�
8��
�$4�
5�
5�	K�
 �
 �
 �
 �
 �
 ��
�F�
+�
+�	K�
%�
%�
%�
%��I�J�J�J����
�Z�
�
�U�
3�
3�
3��
�Z�
�
�U�
3�
3�
3��
�Z��^�^���S��W�W�� �g�%���!�!�w���
�7�a�<�<���2�q�!�!�B�
�7�a�<�<���2�q�!�!�B��2�h����rSc�P�tj|�|����SrM)rNrOr�)r�rQs  r5�__call__z_ConstraintWrapper.__call___s���}�T�X�X�a�[�[�)�)�)rSc�P�|�tj|����}	tj|jd|jz
d��}tj|j|jdz
d��}n"#t$r}td��|�d}~wwxYw||zj}|S)aHow much the constraint is exceeded by.

        Parameters
        ----------
        x : array-like
            Vector of independent variables, (N, S), where N is number of
            parameters and S is the number of solutions to be investigated.

        Returns
        -------
        excess : array-like
            How much the constraint is exceeded by, for each of the
            constraints specified by `_ConstraintWrapper.fun`.
            Has shape (M, S) where M is the number of constraint components.
        rrrN)r�rNr��maximumr2rPrir�)r�rQ�ev�	excess_lb�	excess_ubr��vs       r5r�z_ConstraintWrapper.violationbs���"�X�X�b�j��m�m�
$�
$��	=��
�4�;�q�>�B�D�#8�!�<�<�I��
�2�4�$�+�a�.�#8�!�<�<�I�I���		=�		=�		=�� 5�6�6�<=�
=�����		=������
"�%���s�AA:�:
B�B�BN)rNrOrPrQr�r`r�rrSr5r�r�sL��������0%�%�%�N*�*�*�"�"�"�"�"rSr�)rrrrrrrNNFTrrrrrN)rQrk�numpyrN�scipy.optimizerr�scipy.optimize._optimizer�scipy._lib._utilrrr�scipy.optimize._constraintsr	r
rr�scipy.sparser
�__all__�finfo�float64�epsr�rr/r�rrSr5�<module>rqs�������������3�3�3�3�3�3�3�3�4�4�4�4�4�4�M�M�M�M�M�M�M�M�M�M�P�P�P�P�P�P�P�P�P�P�P�P�!�!�!�!�!�!�#�
$���2�8�B�J���#��<F�9=�FJ�=A�CN�9=�y�(,��
y�y�y�y�y�xJ�J�J�J�J�J�J�J�Z$e�e�e�e�e�e�e�e�e�erS

Youez - 2016 - github.com/yon3zu
LinuXploit