(phQ&SrSSKrSSKrSSKJrJr SSKJrJ r SSK J r J r J r JrJr SSKJrJrJrJr SSKJr S/r\R0"\R25R4r\"S S S 9SSS S .Sjj5r"SS5r"SS5rg)zn differential_evolution: The differential evolution global optimization algorithm Added by Andrew Nelson 2014 N)OptimizeResultminimize)_status_message_wrap_callback)check_random_state MapWrapper_FunctionWrapper rng_integers_transition_to_rng)Boundsnew_bounds_to_oldNonlinearConstraintLinearConstraint)issparsedifferential_evolutionseed ) position_numF integrality vectorizedc[X40SU_SU_SU_SU_SU_SU_SU_SU _S U _S U _S U _S U _S U_SU_SU_SU_SU_SU_SU_6nUR5nSSS5 U$!,(df  W$=f)aNFinds 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. If there are parameters whose bounds are equal the total number of free parameters is ``N - N_equal``. args : tuple, optional Any additional fixed parameters needed to completely specify the objective function. strategy : {str, callable}, optional The differential evolution strategy to use. Should be one of: - 'best1bin' - 'best1exp' - 'rand1bin' - 'rand1exp' - 'rand2bin' - 'rand2exp' - 'randtobest1bin' - 'randtobest1exp' - 'currenttobest1bin' - 'currenttobest1exp' - 'best2exp' - 'best2bin' The default is 'best1bin'. Strategies that may be implemented are outlined in 'Notes'. Alternatively the differential evolution strategy can be customized by providing a callable that constructs a trial vector. The callable must have the form ``strategy(candidate: int, population: np.ndarray, rng=None)``, where ``candidate`` is an integer specifying which entry of the population is being evolved, ``population`` is an array of shape ``(S, N)`` containing all the population members (where S is the total population size), and ``rng`` is the random number generator being used within the solver. ``candidate`` will be in the range ``[0, S)``. ``strategy`` must return a trial vector with shape ``(N,)``. The fitness of this trial vector is compared against the fitness of ``population[candidate]``. .. versionchanged:: 1.12.0 Customization of evolution strategy via a callable. 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 - N_equal)`` popsize : int, optional A multiplier for setting the total population size. The population has ``popsize * (N - N_equal)`` 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 - N_equal)``. tol : float, optional Relative tolerance for convergence, the solving stops when ``np.std(population_energies) <= 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 :math:`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. rng : `numpy.random.Generator`, optional Pseudorandom number generator state. When `rng` is None, a new `numpy.random.Generator` is created using entropy from the operating system. Types other than `numpy.random.Generator` are passed to `numpy.random.default_rng` to instantiate a ``Generator``. disp : bool, optional Prints the evaluated `func` at every iteration. callback : callable, optional A callable called after each iteration. Has the signature:: callback(intermediate_result: OptimizeResult) where ``intermediate_result`` is a keyword parameter containing an `OptimizeResult` with attributes ``x`` and ``fun``, the best solution found so far and the objective function. Note that the name of the parameter must be ``intermediate_result`` for the callback to be passed an `OptimizeResult`. The callback also supports a signature like:: callback(x, convergence: float=val) ``val`` represents the fractional value of the population convergence. When ``val`` is greater than ``1.0``, the function halts. Introspection is used to determine which of the signatures is invoked. Global minimization will halt if the callback raises ``StopIteration`` or returns ``True``; any polishing is still carried out. .. versionchanged:: 1.12.0 callback accepts the ``intermediate_result`` keyword. 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. .. versionchanged:: 1.15.0 If `workers` is specified then the map-like callable that wraps `func` is supplied to `minimize` instead of it using `func` directly. This allows the caller to control how and where the invocations actually run. 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 - N_equal)``. '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 `). 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, ``message`` which describes the cause of the termination, ``population`` the solution vectors present in the population, and ``population_energies`` the value of the objective function for each entry in ``population``. 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:`x_0`, so far: .. math:: b' = x_0 + F \cdot (x_{r_0} - x_{r_1}) where :math:`F` is the `mutation` parameter. 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. The other strategies available are outlined in Qiang and Mitchell (2014) [3]_. - ``rand1`` : :math:`b' = x_{r_0} + F \cdot (x_{r_1} - x_{r_2})` - ``rand2`` : :math:`b' = x_{r_0} + F \cdot (x_{r_1} + x_{r_2} - x_{r_3} - x_{r_4})` - ``best1`` : :math:`b' = x_0 + F \cdot (x_{r_0} - x_{r_1})` - ``best2`` : :math:`b' = x_0 + F \cdot (x_{r_0} + x_{r_1} - x_{r_2} - x_{r_3})` - ``currenttobest1`` : :math:`b' = x_i + F \cdot (x_0 - x_i + x_{r_0} - x_{r_1})` - ``randtobest1`` : :math:`b' = x_{r_0} + F \cdot (x_0 - x_{r_0} + x_{r_1} - x_{r_2})` where the integers :math:`r_0, r_1, r_2, r_3, r_4` are chosen randomly from the interval [0, NP) with `NP` being the total population size and the original candidate having index `i`. The user can fully customize the generation of the trial candidates by supplying a callable to ``strategy``. 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] Qiang, J., Mitchell, C., A Unified Differential Evolution Algorithm for Global Optimization, 2014, https://www.osti.gov/servlets/purl/1163659 .. [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, ... rng=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, rng=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', rng=1 ... ) >>> result.x, result.fun (array([0., 0.]), 4.440892098500626e-16) The following custom strategy function mimics 'best1bin': >>> def custom_strategy_fn(candidate, population, rng=None): ... parameter_count = population.shape(-1) ... mutation, recombination = 0.7, 0.9 ... trial = np.copy(population[candidate]) ... fill_point = rng.choice(parameter_count) ... ... pool = np.arange(len(population)) ... rng.shuffle(pool) ... ... # two unique random numbers that aren't the same, and ... # aren't equal to candidate. ... idxs = [] ... while len(idxs) < 2 and len(pool) > 0: ... idx = pool[0] ... pool = pool[1:] ... if idx != candidate: ... idxs.append(idx) ... ... r0, r1 = idxs[:2] ... ... bprime = (population[0] + mutation * ... (population[r0] - population[r1])) ... ... crossovers = rng.uniform(size=parameter_count) ... crossovers = crossovers < recombination ... crossovers[fill_point] = True ... trial = np.where(crossovers, bprime, trial) ... return trial argsstrategymaxiterpopsizetolmutation recombinationrngpolishcallbackdispinitatolupdatingworkers constraintsx0rrN)DifferentialEvolutionSolversolve)funcboundsrrrrrrrr r"r#r!r$r%r&r'r(r)rrsolverrets X/var/www/html/venv/lib/python3.13/site-packages/scipy/optimize/_differentialevolution.pyrrs^ %T < <.6 <-4 <.5 <;> </7  < 4A  < *-  < 6<  </7 <+/ <6: <AE </7 <.5 <2= <)+ <2= <1; <@Flln <" J# < <" Js A A.cZ\rSrSrSrSSSSSSS .rSSSSSSS .rS rS S SSSSSS\RSSSSSSSS S4SSS.Sjjr Sr Sr Sr Sr\S 5r\S!5rS"rS#rS$rS%rS&rS'rS(rS)rS*rS+rS,rS-rS.rS/rS0r S1r!S2r"S3r#S4r$S5r%S6r&S7r'S8r(S9r)S:r*S;r+g)`_ transition from use of `numpy.random.RandomState` to `numpy.random.Generator` this keyword was changed from `seed` to `rng`. For an interim period both keywords will continue to work (only specify one of them). After the interim period using the `seed` keyword will emit warnings. The behavior of the `seed` and `rng` keywords is outlined below. If `rng` is passed by keyword, types other than `numpy.random.Generator` are passed to `numpy.random.default_rng` to instantiate a `Generator`. If `rng` is already a `Generator` instance, then the provided instance is used. If this argument is passed by position or `seed` is passed by keyword, the behavior is: - 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`/`rng` for repeatable minimizations. disp : bool, optional Prints the evaluated `func` at every iteration. callback : callable, optional A callable called after each iteration. Has the signature: ``callback(intermediate_result: OptimizeResult)`` where ``intermediate_result`` is a keyword parameter containing an `OptimizeResult` with attributes ``x`` and ``fun``, the best solution found so far and the objective function. Note that the name of the parameter must be ``intermediate_result`` for the callback to be passed an `OptimizeResult`. The callback also supports a signature like: ``callback(x, convergence: float=val)`` ``val`` represents the fractional value of the population convergence. When ``val`` is greater than ``1.0``, the function halts. Introspection is used to determine which of the signatures is invoked. Global minimization will halt if the callback raises ``StopIteration`` or returns ``True``; any polishing is still carried out. .. versionchanged:: 1.12.0 callback accepts the ``intermediate_result`` keyword. 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 - N_equal)``. '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 `). 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)best1binrandtobest1bincurrenttobest1binbest2binrand2binrand1bin)best1exprand1exprandtobest1expcurrenttobest1expbest2exprand2expzThe 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>5r8{Gz??ffffff?NFTlatinhypercuber immediaterJrc [U5(aOeX@R;a[XRU5UlO8X@R;a[XRU5UlO [ S5eX@l[U S5UlXl US;aUUl UUl US:wa'US:Xa![R"S[SS9 S Ul U(a$US:wa[R"S SS9 S =Ul nU(a'US:Xa![R"S [SS9 S Ul U(aS nUn[U5UlUUsUlUlXl[(R*"[(R,"U55(ad[(R."[(R0"U5S:5(d2[(R."[(R0"U5S:5(a [ S5eSUl[5US5(a8[7U5S:a)USUS/UlUR2R95 Xl[=X5UlX0l [CU[D5(a[[(R0"[GURHURJ[7URH55[LS9RNUl(O$[(R0"USS9RNUl([(RR"URPS5S:wd9[(R*"[(R,"URP55(d [ S5eUcSnXPl*U c[(RVn Xl,SURPSURPS--Ul-[(R\"URPSURPS- 5Ul/[(R`"SS9 SUR^- Ul1SURb[(R,"URb5)'SSS5 [(RR"URPS5Ul2[gU 5Ul4[(R."U5(GaI[(Rj"UURd5n[(Rl"U[n5n[(Rp"URP5unn[(Rr"U5n[(Rt"U5nUUUU:*R+5(d [ S5e[(Rv"UUS- [(RV5n[(Rv"UUS-[(RV*5nUUl<UURPSURx4'UURPSURx4'OS Ul<URPSURPS:Hn[(Rz"U5n[}SU[}SURdU- 5-5Ul?UR~URd4Ul@SUlA[CU[5(aUS:XaUR5 OUS:Xat[S[(Rr"[(R"UR~55-5nUUl?UR~URd4Ul@URSS9 OSUS:XaURSS9 O=US:XaUR5 O&[ UR5eURU5 Ub]UR[(Rl"U55nUS:US :-R/5(a [ S!5eUURS'UUlL/UlM[5US"5(a9UH2n URR[U UR55 M4 O[UUR5/UlM[(R"URV s/sHn U RPM sn 5UlS[(R"UR~S45UlU[(R"UR~[n5UlW[(R"UR~5UlYXlZg!,(df  GN=fs sn f)#Nz'Please select a valid mutation strategyr)rMdeferredrJrMzhdifferential_evolution: the 'workers' keyword has overridden updating='immediate' to updating='deferred' stacklevelrOzPdifferential_evolution: the 'workers' keyword overrides the 'vectorized' keywordFzkdifferential_evolution: the 'vectorized' keyword has overridden updating='immediate' to updating='deferred'cN[R"U"UR55$N)np atleast_1dT)r,xs r0maplike_for_vectorized_funcIDifferentialEvolutionSolver.__init__..maplike_for_vectorized_func+s}}T!##Y//rzThe 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__dtypefloatz^bounds should be a sequence containing finite real valued (min, max) pairs for each value in xrErIignore)dividezlOne of the integrality constraints does not have any possible integer values between the lower/upper bounds.rLsobol) qmc_enginehaltonrandom?z3Some entries in x0 lay outside the specified bounds__len__)[callable _binomialgetattr mutation_func _exponential ValueErrorrrr"r! _updatingrwarningswarn UserWarningr _mapwrapperrr%scalerUallisfiniteanyarrayditherhasattrlensortcross_over_probabilityr r,r isinstancer r lbubr_rWlimitssizerinfmaxfun(_DifferentialEvolutionSolver__scale_arg1fabs(_DifferentialEvolutionSolver__scale_arg2errstate._DifferentialEvolutionSolver__recip_scale_arg2parameter_countrrandom_number_generator broadcast_toasarrayboolcopyceilfloor nextafterr count_nonzeromaxnum_population_memberspopulation_shape_nfevstrinit_population_lhsintlog2init_population_qmcinit_population_random,_DifferentialEvolutionSolver__init_error_msginit_population_array_unscale_parameters populationr(_wrapped_constraintsappend_ConstraintWrapperrXsum num_constrtotal_constraintszerosconstraint_violationonesfeasiblearange_random_population_indexr#)!selfr,r-rrrrrrrr rr"r#r!r$r%r&r'r(r)rrrYrrnlbnubebeb_countn_s x0_scaledcs! r0__init__$DifferentialEvolutionSolver.__init__sd H     '!(~~h/G!HD  ** *!(/@/@/J!KD FG G &x1IJ   0 0%DN$ a#A; 4DK KK   &3#%T0  ff % %((#4VYY5;YY58^$E*/012 K ((69;;DK GGDKK #q (r{{4;;/00%& & ?G >VVF  4;;q>DKKN#BCGGDKKNT[[^$CD [[ )'($*;*;&;D #MND # #R[[1H1H%I$I J * "wwt{{A6'9#'>$ 66+  //$$K**[$7KWWT[[)FBB"B{Or+6;;==!"<==,,r+4bff=C,,r+4rvvg>C*D /2DKK4+++ ,/2DKK4+++ ,$D [[^t{{1~ -##B''* c!T11H<= =' #"&!00B@ISY_5::<< I"+DOOA '$&! ; * *!))00&q$&&1! #;7)D %"$#'#<#< =#s=Ac8d 8 dc8URnSUR- nX!RURS9-[R "SSURSS9SS2[R 4-n[R"U5Ul[UR5H>nUR[UR55nX5U4URSS2U4'M@ [R"UR[R5UlSUlg)z Initializes the population with Latin Hypercube Sampling. Latin Hypercube Sampling ensures that each parameter is uniformly sampled over its range. rgrrhF)endpointNr)rruniformrrUlinspacenewaxis zeros_likerranger permutationfullrpopulation_energiesr)rr segsizesamplesjorders r0r/DifferentialEvolutionSolver.init_population_lhss ** 333[[d.C.C[DD[[R)D)D*/112BJJ@@--0t++,AOOE$*E*E$FGE$+1H$5DOOAqD !- $&774+F+F+-66$3  r[cSSKJn URnUS:XaURURUS9nOWUS:XaUR URUS9nO6US:XaUR URUS9nO[UR5eURURS9Ul [R"UR[R5UlSUlg) aInitializes 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)qmcrL)drrcre)nN) scipy.statsrrLatinHypercuberSobolHaltonrorrfrrrUrrrr)rrdrr samplers r0r/DifferentialEvolutionSolver.init_population_qmcs $** ) )((4+?+?c(JG 7 "ii$"6"6SiAG 8 #jj4#7#7cjBGT223 3!..4+F+F.G$&774+F+F+-66$3  r[cURnURURS9Ul[R "UR [R5UlSUl g)z Initializes the population at random. This type of initialization can possess clustering, Latin Hypercube sampling is generally better. rrN) rrrrrUrrrrr)rr s r0r2DifferentialEvolutionSolver.init_population_random'sR **++4+@+@+A$&774+F+F+-66$3  r[cV[R"U[RS9n[R"US5S:d6URSUR :wd[ UR5S:wa [S5e[R"URU5SS5Ul [R"URS5Ul URUR 4Ul [R"UR[R5UlSUlg)a( 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. r]rrbrJrPzEThe population supplied needs to have shape (S, len(x)), where S > 4.N)rUrfloat64rshaperr|rocliprrrrrrrr)rr$popns r0r1DifferentialEvolutionSolver.init_population_array6szz$bjj1 GGD! q  1 !5!55DJJ1$:; ;''$":":4"@!QG&(ggdooq&A#!%!URURS5$)z# The best solution from the solver r)_scale_parametersrrs r0rXDifferentialEvolutionSolver.xYs %%dooa&899r[cL[R"[R"UR55(a[R$[R "UR5[R "[R"UR55[-- $)zJ The standard deviation of the population energies divided by their mean. ) rUrxisinfrrstdabsmean_MACHEPSrs r0 convergence'DifferentialEvolutionSolver.convergence`si 66"((4334 5 566Mt//0 8 89:XEG Hr[cT[R"[R"UR55(ag[R"UR5UR UR [R"[R"UR55--:*$)z* Return True if the solver has converged. F) rUrxrrrr%rrrrs r0 converged%DifferentialEvolutionSolver.convergedkst 66"((4334 5 5t//0 266"''$*B*B"CDDEE Fr[c0 ^Sup[Sn[R"[R"TR55(awTR TR 5uTlTlTRTR TR5TRTR'TR5 [STRS-5Hn[T5 TR"(a[%SUSTRS 35 TR&(aZTR(TR*[,-- nTR/US S 9nXEl[1TR'U55nU(aS nU(dTR35(dM O [S nSnTR/XUS9nTR4(Ga[R"TR65(Gdr[R8"TR65(a?TR:TR6pUR<UUS U4'UR<UUSU4'Sn TR>(aUSn TRAUR<5n [R8"U S:5(a[BRD"S[FSS9 TR"(a[%SU S35 [IU4Sj[RJ"UR<5U TR:RLTRNS9n T=RU RP- slTRUl(U RRURR:aU RT(a[R"U R<TR:S:*5(a[R"TR:S U R<:*5(atU RRUl)U R<UlU RVUl+U RRTRS 'TRYU R<5TR S 'TR>(aTR>Vs/sHnUR[UR<5PM snUl.[R^"[R`"UR\55Ul1URbUl2URdS :aSUl*SURd3Ul3U$![aH SnTRTR :a [SnOTRTR :XaSn GMf=f![a SnGNf=fs snf)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, ``message`` which describes the cause of the termination, ``population`` the solution vectors present in the population, and ``population_energies`` the value of the objective function for each entry in ``population``. 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`. )rFsuccessrJTmaxfevz8Maximum number of function evaluations has been reached.zdifferential_evolution step z: f(x)= rz in progress)nitmessagez&callback function requested stop earlyr)rr warning_flagzL-BFGS-Bz trust-constrrhzdifferential evolution didn't find a solution satisfying the constraints, attempting to polish from the least infeasible solutionrPrQzPolishing solution with ''c|>[TRTR[R"U555S$)Nr)listrtr,rU atleast_2d)rXrs r03DifferentialEvolutionSolver.solve..s+ $T%5%5diiqAQ%R STU Vr[)methodr-r(Fz7The solution does not satisfy the constraints, MAXCV = )4rrUrvrr#_calculate_population_feasibilitiesrrr_calculate_population_energies_promote_lowest_energyrrnext StopIterationrrr#printr"rrr_resultrrr!rrxrrXr_constraint_violation_fnrqrrrsrrrWr(nfevfunrjacr violationconstrr concatenateconstr_violationmaxcvr) rrrstatus_messagerres DE_resultrr polish_methodrresults ` r0r+!DifferentialEvolutionSolver.solvevs~(%(3 66"((4334 5 588I 5DM44 33OODMM24  $ $T]] 3  ' ' )DLL1,-C T yy4SE:221568}}HH 0 08 ;<llsMlB"#(#' c(:#;L %MNt~~//A.F-Y7NLLL,!  ;;;rvvd&6&677vvd&&'''+kk43C3C )2[)Aq+~&)2[)Aq+~&&M(( . #'#@#@#M 66*R/00MM#8#.! = yy1-BCW ggikk2%2%)[[]]*.*:*: VXX566 & $hh & .4jj((+%)%=%=fhh%G"  $ $%)%>%> @%>!" IKK 8%> @I )+y//0*2I &'88IO"$) !&==F__NZZ4;;.';N (%(#'L(D @s+ T+V%V+A U=<U= VVc URSS5nURSS5nURSS5n[URURSURUUUSLUR UR 5URS9nUR(aURVs/sHnURUR5PM snUl [R"[R"UR55Ul URUlURS:aSUlU$s snf)NrrrFrT)rXrrrrrrr)getrrXrrrrrrrrUrrrrr)rkwdsrrrr rs r0r#DifferentialEvolutionSolver._results hhud#((9d+xx6 ff((+!---doo> $ 8 8    $ $&*&?&?A&?[[2&?AFM&(ffR^^FMM-J&KF #!22FL||a!& As,%D<c[R"US5n[X RUR- 5n[R "U[R 5nURU5n[URURUSU55n[R"U5nURU:wa'UR(a [S5e[S5eXdSU&UR(aU=RS- slU$U=RU- slU$![[4an[S5UeSnAff=f)a 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 valuerJ)rUrminrrrrrrrtr,squeeze TypeErrorro RuntimeErrorr)rr num_membersSenergiesparameters_pop calc_energieses r0r:DifferentialEvolutionSolver._calculate_population_energiess+$ggj!,   [[4::5 677;/// ;    N1Q,?@MJJ}5M    ""$;<<JK K%1 ?? JJ!OJ JJ!OJ-:& P  s1>D))E 9 EE cX[R"UR5nXRnUR(a([R "UR U5nX#nO3[R "[R"URSS95nUR US/UR SU/'URUS/SS24URSU/SS24'URUS/URSU/'URUS/SS24URSU/SS24'g)NrJaxisr) rUrrrrargminrrrr)ridxfeasible_solutionsidx_tls r0r2DifferentialEvolutionSolver._promote_lowest_energyUsii334 /  " "IId667IJKE")A "&&!:!:CDA+/+C+CQF+K  !Q(%)__aVQY%?A " $ q!f 5 q!f !!1a&!), !!1a&!),r[c[R"U5UR-n[R"X R45nSnUR HnUR UR5RnURSUR:wdUS:aURSU:wa [S5e[R"XbUR45nXcSS2XDUR-24'XER- nM U$)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)). rrJMAn 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) rUrrrrrrrWrrrreshape)rrXr_outoffsetconrs r0r4DifferentialEvolutionSolver._constraint_violation_fnis* GGAJ$.. .xx2234,,C  acc"$$Awwr{cnn,Q1771:?"$9:: 1#..12A67FCNN222 3 nn $F?-B r[c[R"US5nUR(d3[R"U[5[R "US454$UR U5nUR(a&[R"URU55nO?[R"UVs/sHnURU5PM sn5nUSS2S4n[R"USS9S:)nXd4$s snf)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. rrJNr) rUrrrrrrrryrr)rrrrrrXrs r0r?DifferentialEvolutionSolver._calculate_population_feasibilitiess$ggj!, ((77;-rxxa8H/II I// ; ??#%88--n=$ $&886D-F6D.2-J-J1-M6D-F$G $81#= VV0q9A=>---Fs8C?cU$rTrDrs r0r\$DifferentialEvolutionSolver.__iter__ r[cU$rTrDrs r0 __enter__%DifferentialEvolutionSolver.__enter__r2r[c4URR"U6$rT)rt__exit__)rrs r0r7$DifferentialEvolutionSolver.__exit__s(($//r[cU(a U(aX:*$U(aU(dgU(dX6:*R5(agg)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)rv)r energy_trialfeasible_trialcv_trial energy_orig feasible_origcv_origs r0 _accept_trial)DifferentialEvolutionSolver._accept_trials7D ^. . MX%8$=$=$?$?r[c h [R"[R"UR55(awUR UR 5uUlUlURUR UR 5URUR 'UR5 URb;URRURSURS5Ul URS:XGa[UR 5GHnUR"UR$:a[&eUR)U5nUR+U5 UR-U5nUR.(afUR1U5nSn[R2n[R4"U5S:d(SnUR7U5nU=R"S- slO?Sn[R8"S/5nUR7U5nU=R"S- slUR;XeUURUUR UURU5(dGMQX R U'[R<"U5URU'XPR U'X@RU'UR;XeUURSUR SURS5(dGMUR5 GM GOURS:XGaUR"UR$:a[&eUR?[R@"UR 55nUR+U5 UR U5upT[RB"UR [R25nURXu5X'[EXX@RUR UR5V s/sHoR:"U 6PM n n [RF"U 5n [RH"U SS2[RJ4UUR 5Ul[RH"U UUR5Ul[RH"U UUR 5Ul[RH"U SS2[RJ4UUR5UlUR5 URLURS4$s sn f) 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. NrrJrMFTrhrO)'rUrvrrrrrrrrrzrrrurprrrrr_mutate_ensure_constraintrrrrrr,rr@r _mutate_manyrrziprywhererrX) r candidatetrial parameterscvrenergy trial_poptrial_energiesvallocs r0__next__$DifferentialEvolutionSolver.__next__sP 66"((4334 5 588I 5DM44 33OODMM24  $ $T]] 3  ' ' ) ;; "55==dkk!n>Bkk!nNDJ >>[ ("4#>#>? :: +'' Y/''."33E: ,,66zBB$HVVF66":>#'!%:!6 a #Ht,B!YYz2FJJ!OJ%%f&*&>&>y&I&*mmI&>&*&?&? &JLL27OOI.:<**V:LD,,Y7/7MM),;=--i8))&B*.*B*B1*E*.--*:*.*C*CA*FHH335[@^^^z )zzT[[(##)) $556I  # #I . CCINLHWWT%@%@"&&IN(,'J'J#(%N $ ~5M5M}}d&?&?ABA14%%s+A B((3-C hhs1bjj='9'0'+8DO(*xx0>040H0H(JD $HHS%-%)]]4DM)+Q ]1C13151J1J)LD %  ' ' )vvt//222+BsT/cURUS- UR--n[R"UR5(aE[R "URUR 5n[R"X#5X#'U$)z2Scale from a number between 0 and 1 to parameters.rI)rrrUrrrrround)rrIscaledis r0r-DifferentialEvolutionSolver._scale_parameterssk""eckT5F5F%FF  D,, - - 0 0&,,?A+FI r[c>XR- UR-S-$)z2Scale from parameters to a number between 0 and 1.rI)rr)rrJs r0r/DifferentialEvolutionSolver._unscale_parameterss!...$2I2IICOOr[c[R"US:US:5n[R"U5=n(aURR US9X'gg)z0Make sure the parameters lie between the limits.rJrrN)rU bitwise_orrrr)rrImaskoobs r0rD.DifferentialEvolutionSolver._ensure_constraintsP}}UQY 2""4( (3 (66>>C>HEK )r[c URnSnURUR5n[[R "U55(d7UR XUS9nUR UR4:wa [U5eOlUR Sn[R"UVs/sHopR XtUS9PM sn[S9nUR X`R4:wa [U5eURU5$s snf)Nzqstrategy must have signature f(candidate: int, population: np.ndarray, rng=None) returning an array of shape (N,))r rr]) rrrr|rUrrrrryr_r)rrHr msg _populationrIrrs r0_mutate_custom*DifferentialEvolutionSolver._mutate_customs** # ,,T__= 288I&''MM)cMBE{{t3355"3''6"AHHAJKAq37KE{{q"6"677"3''''.. Ls(Dc URn[U5n[UR5(aUR U5$[ R "URU5n[ R"UVs/sHoPRUS5PM sn5nURS;aURX5nOURU5n[X RUS9nURX0R4S9n XR:n URUR;a7[ R "U5n SXX4'[ R""XU5nU$URUR$;a|SU S'['U5Hfn Sn Xn XR:dMXU 4(dM'X{U 4XKU 4'U S-UR-n U S- n XR:dMYXU 4(aM?Mh U$gs snf) z2Create trial vectors based on a mutation strategy.rbrAr:rT).rrrJN)rr|rjrrbrUrrry_select_samplesrmr rrr~rkrrGrnr) r candidatesr rrIrrbprime fill_point crossoversrVr init_fills r0rE(DifferentialEvolutionSolver._mutate_manys**  O DMM " "&&z2 2 34(( K 100A6 KL ==F F'' *>&?[@ "="== ==DNN *  ! A+/J*-' (HHZ7EL ]]d// /!%Jv 1X&M ///J!t4D4D*0I*>EY,'!*Q$2F2F FIFA///J!t4D4DL0)Ls:G3c URn[UR5(aURU5$[ X R 5nUR US5n[R"URU5nURS;aURX5nOURU5nURUR S9nXpR:nURUR;aSXs'[R"XvU5nU$URUR;aXSnSUS'XR :a@Xx(a7XcXS'US-UR -nUS- nXR :a Xx(aM7U$g)z3Create a trial vector based on a mutation strategy.rbrerTrrJN)rrjrrbr rrfrUrrrmrr~rkrGrn) rrHr rirrIrhrjrVs r0rC#DifferentialEvolutionSolver._mutates^** DMM " "&&y1 1!#';';< &&y!4 23 ==F F'' ;F''0F[[d&:&:[; "="== ==DNN * &*J "HHZ7EL ]]d// /A JqM***z}$*$6!(1n0D0DD Q***z}} L0r[cUSSS24Rup#URSURURUURU- --$)zbest1bin, best1exp.NrPrrWrru)rrr0r1s r0r2"DifferentialEvolutionSolver._best1sY bqb!##"TZZ$tr'::&<< =r[cUSSS24Rup#nURUURURUURU- --$)zrand1bin, rand1exp.Nrp)rrrqrrr2s r0r7"DifferentialEvolutionSolver._rand1sYS"1"W%'' #djj$tr'::'<< =r[cUSSS24Rup#n[R"URU5nXPRURSU- -- nXPRURUURU- -- nU$)zrandtobest1bin, randtobest1exp.Nrur)rWrUrrru)rrrqrrrvrhs r0r3(DifferentialEvolutionSolver._randtobest1 sS"1"W%'' ,-** 2V ;<<** 3 $ 3!45 5 r[cUSSS24Rup4URUURURSURU- URU-URU- --nU$)z$currenttobest1bin, currenttobest1exp.NrPrrp)rrHrrqrrrhs r0r4+DifferentialEvolutionSolver._currenttobest1s}bqb!##//),tzz??1% (BB??2&')-)<=0>> r[cUSSS24Rup#pEURSURURUURU-URU- URU- --nU$)zbest2bin, best2exp.Nrrp)rrrqrrrvr3rhs r0r5"DifferentialEvolutionSolver._best2s bqb)++//!$tzz??2&)<<??2&')-)<=(>> r[cUSSS24Rup#pEnURUURURUURU-URU- URU- --nU$)zrand2bin, rand2exp.Nrbrp)rrrqrrrvr~r4rhs r0r6"DifferentialEvolutionSolver._rand2's$S"1"W-////"% ??2&)<<??2&')-)<=)>> r[cURRUR5 URSUS-nX3U:gSU$)z obtain random integers from range(self.num_population_members), without replacement. You can't have the original candidate either. NrJ)rshuffler)rrHnumber_samplesidxss r0rf+DifferentialEvolutionSolver._select_samples0sK $$,,T-J-JK,,-@nq.@AI%&77r[)#__recip_scale_arg2 __scale_arg1 __scale_arg2rtrrrprrr%r"rr(r~r#rzrr,rrrrrmrrr!rrrrrurrrr),__name__ __module__ __qualname____firstlineno____doc__rkrnrrUrrrrrrpropertyrXrrr+rrrrrr\r4r7r@rQrrrDrbrErCr2r7r3r4r5r6rf__static_attributes__rDr[r0r*r*sZk\&7%%% 'I !) (&4): ( ( *LM+-$dBHCTE$&Qt ` EI! `D$L"H !F:: HH FM^25n.(9v+.Z0+Z{3zPI /.'R$L== 8r[r*c*\rSrSrSrSrSrSrSrg)ri:aObject 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. Notes ----- _ConstraintWrapper.fun and _ConstraintWrapper.violation can get sent arrays of shape (N, S) or (N,), where S is the number of vectors of shape (N,) to consider constraints for. c^TUl[T[5(aU4SjnO@[T[5(aU4SjnO$[T[5(aSnO [ S5eX0l[R"TR[S9n[R"TR[S9n[R"U5nU"U5nUR=Ul nURUlURS:Xa[R "XG5nURS:Xa[R "XW5nXE4Ulg)Ncz>[R"U5n[R"TRU55$rT)rUrrVr)rX constraints r0r(_ConstraintWrapper.__init__..fun]s(JJqM}}Z^^A%677r[c2>[TR5(a TRnO [R"TR5nUR U5nUR S:Xa-UR S:Xa[R "U5SS2S4nU$)NrJrPr)rArUrdotndimr)rXrrrs r0rrasnJLL))" A jll3AeeAh 66Q;388q=**S/!Q$/C r[c.[R"U5$rT)rUr)rXs r0rrtszz!}$r[z*`constraint` of an unknown type is passed.r]r)rrrrr rorrUrrr_rrrrrresizer-)rrr)rrrf0ms ` r0r_ConstraintWrapper.__init__Ys$ j"5 6 6 8 $4 5 5 $ F + + %IJ J ZZ U 3 ZZ U 3 ZZ^W gg%!!ww 77a<2!B 77a<2!Bh r[cL[R"URU55$rT)rUrVr)rrXs r0__call___ConstraintWrapper.__call__s}}TXXa[))r[cnUR[R"U55n[R"URSUR - S5n[R"UR URS- S5nX4-R nU$![ an[S5UeSnAff=f)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. rrJr(N)rrUrmaximumr-rWror)rrXev excess_lb excess_ubrvs r0r_ConstraintWrapper.violations"XXbjjm $ = 4;;q>BDD#8!rs3D@@PP! # $ 88BJJ  # #F+;E9=EI=ACN9= _ (, _,_D}8}8@*wwr[