B î&]\ùªã@s¦dZddlmZmZmZddlZddlZddlm Z m Z ddl m Z ddl mZmZddlmZmZdgZe ej¡jZddd„ZGdd„deƒZGdd„deƒZdS)zn differential_evolution: The differential evolution global optimization algorithm Added by Andrew Nelson 2014 é)ÚdivisionÚprint_functionÚabsolute_importN)ÚOptimizeResultÚminimize)Ú_status_message)Úcheck_random_stateÚ MapWrapper)ÚxrangeÚ string_typesÚdifferential_evolution©Úbest1binéèéç{®Gáz„?©gà?éçffffffæ?FTÚlatinhypercubeÚ immediatercCsBt|||||||||| | | | | |||d}| ¡}WdQRX|S)a¢-Finds the global minimum of a multivariate function. Differential Evolution is stochastic in nature (does not use gradient methods) to find the minimium, 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 [1]_. 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. bounds : sequence Bounds for variables. ``(min, max)`` pairs for each element in ``x``, defining the lower and upper bounds for the optimizing argument of `func`. It is required to have ``len(bounds) == len(x)``. ``len(bounds)`` is used to determine the number of parameters in ``x``. 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 * len(x)`` popsize : int, optional A multiplier for setting the total population size. The population has ``popsize * len(x)`` individuals (unless the initial population is supplied via the `init` keyword). 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 : int or `np.random.RandomState`, optional If `seed` is not specified the `np.RandomState` singleton is used. If `seed` is an int, a new `np.random.RandomState` instance is used, seeded with seed. If `seed` is already a `np.random.RandomState instance`, then that `np.random.RandomState` instance is used. Specify `seed` for repeatable minimizations. disp : bool, optional Display status messages 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. init : str or array-like, optional Specify which type of population initialization is performed. Should be one of: - 'latinhypercube' - 'random' - array specifying the initial population. The array should have shape ``(M, len(x))``, where len(x) 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. '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 subset 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, and the `workers` keyword 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``. Requires that `func` be pickleable. .. versionadded:: 1.2.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. 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 [2]_ 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 'i'th 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'``. .. versionadded:: 0.15.0 Examples -------- Let us consider the problem of minimizing the Rosenbrock function. This function is implemented in `rosen` in `scipy.optimize`. >>> 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. >>> bounds = [(0,2), (0, 2), (0, 2), (0, 2), (0, 2)] >>> result = differential_evolution(rosen, bounds, updating='deferred', ... workers=2) >>> result.x, result.fun (array([1., 1., 1., 1., 1.]), 1.9216496320061384e-19) Next find the minimum of the Ackley function (https://en.wikipedia.org/wiki/Test_functions_for_optimization). >>> from scipy.optimize import differential_evolution >>> import numpy as np >>> 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) >>> result.x, result.fun (array([ 0., 0.]), 4.4408920985006262e-16) References ---------- .. [1] 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. .. [2] http://www1.icsi.berkeley.edu/~storn/code.html .. [3] http://en.wikipedia.org/wiki/Differential_evolution .. [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 )ÚargsÚstrategyÚmaxiterÚpopsizeÚtolÚmutationÚ recombinationÚseedÚpolishÚcallbackÚdispÚinitÚatolÚupdatingÚworkersN)ÚDifferentialEvolutionSolverÚsolve)ÚfuncÚboundsrrrrrrrrr r!rr"r#r$r%ZsolverZretr r úDlib/python3.7/site-packages/scipy/optimize/_differentialevolution.pyr sr c@s8eZdZdZdddddddœZddddddd œZd Zd d d dddddejdddddddfdd„Z dd„Z dd„Z dd „Z e d!d"„ƒZe d#d$„ƒZd%d&„Zd'd(„Zd)d*„Zd+d,„Zd-d.„Zd/d0„Zd1d2„Zd3d4„Zd5d6„ZeZd7d8„Zd9d:„Zd;d<„Zd=d>„Zd?d@„ZdAdB„ZdCdD„Z dEdF„Z!dGdH„Z"dIdJ„Z#dKdL„Z$dS)Mr&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. bounds : sequence Bounds for variables. ``(min, max)`` pairs for each element in ``x``, defining the lower and upper bounds for the optimizing argument of `func`. It is required to have ``len(bounds) == len(x)``. ``len(bounds)`` is used to determine the number of parameters in ``x``. 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 * len(x)`` popsize : int, optional A multiplier for setting the total population size. The population has ``popsize * len(x)`` individuals (unless the initial population is supplied via the `init` keyword). 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 : int or `np.random.RandomState`, optional If `seed` is not specified the `np.random.RandomState` singleton is used. If `seed` is an int, a new `np.random.RandomState` instance is used, seeded with `seed`. If `seed` is already a `np.random.RandomState` instance, then that `np.random.RandomState` instance is used. Specify `seed` for repeatable minimizations. disp : bool, optional Display status messages 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, then `scipy.optimize.minimize` with the `L-BFGS-B` method is used to polish the best population member at the end. This requires a few more function evaluations. 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' - 'random' - array specifying the initial population. The array should have shape ``(M, len(x))``, where len(x) 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. '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. 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, and the `workers` keyword 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. Ú_best1Ú _randtobest1Ú_currenttobest1Ú_best2Ú_rand2Ú_rand1)rZrandtobest1binÚcurrenttobest1binZbest2binZrand2binZrand1bin)Zbest1expZrand1expZrandtobest1expÚcurrenttobest1expZbest2expZrand2expz™The population initialization method must be one of 'latinhypercube' or 'random', or an array of shape (M, N) where N is the number of parameters and M>5r rièrg{®Gáz„?)gà?rgffffffæ?NFTrrrrcCsn||jkrt||j|ƒ|_n&||jkr 4.N)rCZasfarrayrOÚshaperTrIr<ZclipÚ_unscale_parametersrcrWrXZonesrPrfrY)r_r"Zpopnr r r*r^Ls    z1DifferentialEvolutionSolver.init_population_arraycCs| |jd¡S)z3 The best solution from the solver r)Ú_scale_parametersrc)r_r r r*ÚxoszDifferentialEvolutionSolver.xcCs:t t |j¡¡rtjSt |j¡t t |j¡t¡S)zb The standard deviation of the population energies divided by their mean. ) rCrEÚisinfrfrPÚstdÚabsÚmeanÚ_MACHEPS)r_r r r*Ú convergencevs z'DifferentialEvolutionSolver.convergencecCs*t |j¡|j|jt t |j¡¡kS)z: Return True if the solver has converged. )rCrprfr#rrqrr)r_r r r*Ú convergeds z%DifferentialEvolutionSolver.convergedc Csd\}}td}t t |j¡¡r@| |j¡|jdd…<| ¡xtd|j dƒD]ø}y t |ƒWn@t k r¤d}|j |j krŽtd}n|j |j kržd}PYnX|jrÂtd||jd fƒ|j}|jrü|j| |jd ¡|j|d dkrüd}d }Pt t |j¡¡rd }n*t |j¡|j|jt t |j¡¡k}|sJ|rTPqTWtd }d}t|j|jd |j |||dk d}|jrt|jt |j¡d|jj d}|j |j!7_ |j |_!|j"|j"kr|j"|_"|j|_|j#|_#|j"|jd <| $|j¡|jd <|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ÚsuccessNrTZmaxfevz8Maximum number of function evaluations has been reached.z(differential_evolution step %d: f(x)= %gr)rtz8callback function requested stop early by returning TrueFr)rnÚfunÚnfevÚnitÚmessagervzL-BFGS-B)Úmethodr))%rrCrDrorfÚ_calculate_population_energiesrcÚ_promote_lowest_energyr rÚnextÚ StopIterationrYrQr!Úprintrtr rmrrErpr#rqrrrrnrrr(ÚcopyrNrMrxrwZjacrl)r_ryZ warning_flagZstatus_messagertZintolZ DE_resultÚresultr r r*r'‰sr          z!DifferentialEvolutionSolver.solvec Cs’t |d¡}t||j|ƒ}t |tj¡}| |¡}y*t| |j |d|…¡ƒ}||d|…<Wn t t fk r~t dƒ‚YnX|j |7_ |S)a› Calculate the energies of all the population members at the same time. Parameters ---------- population : ndarray An array of parameter vectors normalised to [0, 1] using lower and upper limits. Has shape ``(np.size(population, 0), len(x))``. 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')rCrOÚminrQrerPrmÚlistrAr(Ú TypeErrorr<Ú RuntimeErrorrY)r_rcZ num_membersZnfevsZenergiesZparameters_popZ calc_energiesr r r*r|ìs    z:DifferentialEvolutionSolver._calculate_population_energiescCsPt |j¡}|j|dg|jd|g<|j|dgdd…f|jd|gdd…f<dS)Nr)rCZargminrfrc)r_Úlr r r*r}s z2DifferentialEvolutionSolver._promote_lowest_energycCs|S)Nr )r_r r r*r5sz$DifferentialEvolutionSolver.__iter__cCs|S)Nr )r_r r r*Ú __enter__sz%DifferentialEvolutionSolver.__enter__cGs|j ¡dS)N)rAÚclose)r_rr r r*Ú__exit__"sz$DifferentialEvolutionSolver.__exit__cCs|j ¡dS)N)rAr‰)r_r r r*Ú__del__&sz#DifferentialEvolutionSolver.__del__cs¨t t ˆj¡¡r0ˆ ˆj¡ˆjdd…<ˆ ¡ˆjdk rdˆj  ¡ˆjdˆjdˆjdˆ_ ˆj dkrxt ˆj ƒD]‚}ˆjˆjkrt‚ˆ |¡}ˆ |¡ˆ |¡}ˆ |¡}ˆjd7_|ˆj|kr||ˆj|<|ˆj|<|ˆjdkr|ˆ ¡q|Wn”ˆj dkr˜ˆjˆjkr"t‚t ‡fdd„t ˆj ƒDƒ¡}ˆ |¡ˆ |¡}|ˆjk}t |dd…tjf|ˆj¡ˆ_t ||ˆ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. Nrrrr3csg|]}ˆ |¡‘qSr )Ú_mutate)Ú.0Úi)r_r r*ú fsz8DifferentialEvolutionSolver.__next__..)rCrDrorfr|rcr}rGrUÚrandrBr=rdrWrYrQrrŒÚ_ensure_constraintrmr(rFÚwhererbrn)r_Ú candidateÚtrialÚ parametersZenergyZ trial_popZtrial_energiesZlocr )r_r*Ú__next__*sJ  "              z$DifferentialEvolutionSolver.__next__cCs|j|d|jS)z2Scale from a number between 0 and 1 to parameters.gà?)rRrS)r_r”r r r*rmsz-DifferentialEvolutionSolver._scale_parameterscCs||j|jdS)z2Scale from parameters to a number between 0 and 1.gà?)rRrS)r_r•r r r*rlƒsz/DifferentialEvolutionSolver._unscale_parameterscCs0t |dk|dkB¡}|j |dj¡||<dS)z0Make sure the parameters lie between the limits.rrN)rCr’rUrrO)r_r”Úmaskr r r*r‘‡sz.DifferentialEvolutionSolver._ensure_constraintcCsêt |j|¡}|j}| d|j¡}|jdkrD| || |d¡¡}n| | |d¡¡}|j|j kr’|  |j¡}||j k}d||<t  |||¡}|S|j|j kræd}x>||jkrà|  ¡|j krà||||<|d|j}|d7}q¤W|SdS)z3Create a trial vector based on a mutation strategy.r)r2r1r7TrN)rCrrcrUZrandintrTrr:Ú_select_samplesr8rrKr’r;)r_r“r”rgZ fill_pointÚbprimeZ crossoversrŽr r r*rŒŒs*        z#DifferentialEvolutionSolver._mutatecCs4|dd…\}}|jd|j|j||j|S)zbest1bin, best1expNr4r)rcrB)r_rhÚr0Úr1r r r*r+°s z"DifferentialEvolutionSolver._best1cCs6|dd…\}}}|j||j|j||j|S)zrand1bin, rand1expNé)rcrB)r_rhršr›Úr2r r r*r0¶s z"DifferentialEvolutionSolver._rand1cCs\|dd…\}}}t |j|¡}||j|jd|7}||j|j||j|7}|S)zrandtobest1bin, randtobest1expNrœr)rCrrcrB)r_rhršr›rr™r r r*r,¼s z(DifferentialEvolutionSolver._randtobest1cCsL|dd…\}}|j||j|jd|j||j||j|}|S)z$currenttobest1bin, currenttobest1expNr4r)rcrB)r_r“rhršr›r™r r r*r-Ås ,z+DifferentialEvolutionSolver._currenttobest1cCsP|dd…\}}}}|jd|j|j||j||j||j|}|S)zbest2bin, best2expNér)rcrB)r_rhršr›rÚr3r™r r r*r.Ís ,z"DifferentialEvolutionSolver._best2cCsJ|\}}}}}|j||j|j||j||j||j|}|S)zrand2bin, rand2exp)rcrB)r_rhršr›rrŸZr4r™r r r*r/Ös ,z"DifferentialEvolutionSolver._rand2cCs4tt|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„rdrWÚremoverUZshuffle)r_r“Znumber_samplesZidxsr r r*r˜ßs    z+DifferentialEvolutionSolver._select_samples)%Ú__name__Ú __module__Ú __qualname__Ú__doc__r8r;r]rCrPr`r[r\r^Úpropertyrnrtrur'r|r}r5rˆrŠr‹r–r~rmrlr‘rŒr+r0r,r-r.r/r˜r r r r*r&s^  f&#  c(S$   r&c@s eZdZdZdd„Zdd„ZdS)rLzB Object to wrap user cost function, allowing picklability cCs||_|dkrgn||_dS)N)Úfr)r_r¦rr r r*r`ïsz_FunctionWrapper.__init__cCs|j|f|jžŽS)N)r¦r)r_rnr r r*Ú__call__ósz_FunctionWrapper.__call__N)r¡r¢r£r¤r`r§r r r r*rLësrL)r rrrrrrNNFTrrrr)r¤Z __future__rrrr>ZnumpyrCZscipy.optimizerrZscipy.optimize.optimizerZscipy._lib._utilrr Zscipy._lib.sixr r Ú__all__ZfinfoZfloat64Zepsrsr Úobjectr&rLr r r r*Ús.  }[