a ¯ïaÜêã@sŠdZddlZddlZddlZddlZddlmZddlm Z m Z ddl m Z dgZ dd d„ZGd d „d ƒZGd d„dƒZGdd„dƒZdS)z= shgo: The simplicial homology global optimisation algorithm éN)Úspatial)ÚOptimizeResultÚminimize)ÚComplexÚshgo©éÚ simplicialc Cs¤t|||||||||| d } |  ¡| js8| jr8tdƒt| jjƒdkrˆ|  ¡d| _| j d  | j ¡d| j | j _ | j| j _| j| j _| jsžd| j _d| j _| j S)aF Finds the global minimum of a function using SHG optimization. SHGO stands for "simplicial homology global optimization". 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``. Use ``None`` for one of min or max when there is no bound in that direction. By default bounds are ``(None, None)``. args : tuple, optional Any additional fixed parameters needed to completely specify the objective function. constraints : dict or sequence of dict, optional Constraints definition. Function(s) ``R**n`` in the form:: g(x) >= 0 applied as g : R^n -> R^m h(x) == 0 applied as h : R^n -> R^p Each constraint is defined in a dictionary with fields: type : str Constraint type: 'eq' for equality, 'ineq' for inequality. fun : callable The function defining the constraint. jac : callable, optional The Jacobian of `fun` (only for SLSQP). args : sequence, optional Extra arguments to be passed to the function and Jacobian. Equality constraint means that the constraint function result is to be zero whereas inequality means that it is to be non-negative. Note that COBYLA only supports inequality constraints. .. note:: Only the COBYLA and SLSQP local minimize methods currently support constraint arguments. If the ``constraints`` sequence used in the local optimization problem is not defined in ``minimizer_kwargs`` and a constrained method is used then the global ``constraints`` will be used. (Defining a ``constraints`` sequence in ``minimizer_kwargs`` means that ``constraints`` will not be added so if equality constraints and so forth need to be added then the inequality functions in ``constraints`` need to be added to ``minimizer_kwargs`` too). n : int, optional Number of sampling points used in the construction of the simplicial complex. Note that this argument is only used for ``sobol`` and other arbitrary `sampling_methods`. In case of ``sobol``, it must be a power of 2: ``n=2**m``, and the argument will automatically be converted to the next higher power of 2. Default is 100 for ``sampling_method='simplicial'`` and 128 for ``sampling_method='sobol'``. iters : int, optional Number of iterations used in the construction of the simplicial complex. Default is 1. callback : callable, optional Called after each iteration, as ``callback(xk)``, where ``xk`` is the current parameter vector. minimizer_kwargs : dict, optional Extra keyword arguments to be passed to the minimizer ``scipy.optimize.minimize`` Some important options could be: * method : str The minimization method, the default is ``SLSQP``. * args : tuple Extra arguments passed to the objective function (``func``) and its derivatives (Jacobian, Hessian). * options : dict, optional Note that by default the tolerance is specified as ``{ftol: 1e-12}`` options : dict, optional A dictionary of solver options. Many of the options specified for the global routine are also passed to the scipy.optimize.minimize routine. The options that are also passed to the local routine are marked with "(L)". Stopping criteria, the algorithm will terminate if any of the specified criteria are met. However, the default algorithm does not require any to be specified: * maxfev : int (L) Maximum number of function evaluations in the feasible domain. (Note only methods that support this option will terminate the routine at precisely exact specified value. Otherwise the criterion will only terminate during a global iteration) * f_min Specify the minimum objective function value, if it is known. * f_tol : float Precision goal for the value of f in the stopping criterion. Note that the global routine will also terminate if a sampling point in the global routine is within this tolerance. * maxiter : int Maximum number of iterations to perform. * maxev : int Maximum number of sampling evaluations to perform (includes searching in infeasible points). * maxtime : float Maximum processing runtime allowed * minhgrd : int Minimum homology group rank differential. The homology group of the objective function is calculated (approximately) during every iteration. The rank of this group has a one-to-one correspondence with the number of locally convex subdomains in the objective function (after adequate sampling points each of these subdomains contain a unique global minimum). If the difference in the hgr is 0 between iterations for ``maxhgrd`` specified iterations the algorithm will terminate. Objective function knowledge: * symmetry : bool Specify True if the objective function contains symmetric variables. The search space (and therefore performance) is decreased by O(n!). * jac : bool or callable, optional Jacobian (gradient) of objective function. Only for CG, BFGS, Newton-CG, L-BFGS-B, TNC, SLSQP, dogleg, trust-ncg. If ``jac`` is a boolean and is True, ``fun`` is assumed to return the gradient along with the objective function. If False, the gradient will be estimated numerically. ``jac`` can also be a callable returning the gradient of the objective. In this case, it must accept the same arguments as ``fun``. (Passed to `scipy.optimize.minmize` automatically) * hess, hessp : callable, optional Hessian (matrix of second-order derivatives) of objective function or Hessian of objective function times an arbitrary vector p. Only for Newton-CG, dogleg, trust-ncg. Only one of ``hessp`` or ``hess`` needs to be given. If ``hess`` is provided, then ``hessp`` will be ignored. If neither ``hess`` nor ``hessp`` is provided, then the Hessian product will be approximated using finite differences on ``jac``. ``hessp`` must compute the Hessian times an arbitrary vector. (Passed to `scipy.optimize.minmize` automatically) Algorithm settings: * minimize_every_iter : bool If True then promising global sampling points will be passed to a local minimization routine every iteration. If False then only the final minimizer pool will be run. Defaults to False. * local_iter : int Only evaluate a few of the best minimizer pool candidates every iteration. If False all potential points are passed to the local minimization routine. * infty_constraints: bool If True then any sampling points generated which are outside will the feasible domain will be saved and given an objective function value of ``inf``. If False then these points will be discarded. Using this functionality could lead to higher performance with respect to function evaluations before the global minimum is found, specifying False will use less memory at the cost of a slight decrease in performance. Defaults to True. Feedback: * disp : bool (L) Set to True to print convergence messages. sampling_method : str or function, optional Current built in sampling method options are ``halton``, ``sobol`` and ``simplicial``. The default ``simplicial`` provides the theoretical guarantee of convergence to the global minimum in finite time. ``halton`` and ``sobol`` method are faster in terms of sampling point generation at the cost of the loss of guaranteed convergence. It is more appropriate for most "easier" problems where the convergence is relatively fast. User defined sampling functions must accept two arguments of ``n`` sampling points of dimension ``dim`` per call and output an array of sampling points with shape `n x dim`. Returns ------- res : OptimizeResult The optimization result represented as a `OptimizeResult` object. Important attributes are: ``x`` the solution array corresponding to the global minimum, ``fun`` the function output at the global solution, ``xl`` an ordered list of local minima solutions, ``funl`` the function output at the corresponding local solutions, ``success`` a Boolean flag indicating if the optimizer exited successfully, ``message`` which describes the cause of the termination, ``nfev`` the total number of objective function evaluations including the sampling calls, ``nlfev`` the total number of objective function evaluations culminating from all local search optimizations, ``nit`` number of iterations performed by the global routine. Notes ----- Global optimization using simplicial homology global optimization [1]_. Appropriate for solving general purpose NLP and blackbox optimization problems to global optimality (low-dimensional problems). In general, the optimization problems are of the form:: minimize f(x) subject to g_i(x) >= 0, i = 1,...,m h_j(x) = 0, j = 1,...,p where x is a vector of one or more variables. ``f(x)`` is the objective function ``R^n -> R``, ``g_i(x)`` are the inequality constraints, and ``h_j(x)`` are the equality constraints. Optionally, the lower and upper bounds for each element in x can also be specified using the `bounds` argument. While most of the theoretical advantages of SHGO are only proven for when ``f(x)`` is a Lipschitz smooth function, the algorithm is also proven to converge to the global optimum for the more general case where ``f(x)`` is non-continuous, non-convex and non-smooth, if the default sampling method is used [1]_. The local search method may be specified using the ``minimizer_kwargs`` parameter which is passed on to ``scipy.optimize.minimize``. By default, the ``SLSQP`` method is used. In general, it is recommended to use the ``SLSQP`` or ``COBYLA`` local minimization if inequality constraints are defined for the problem since the other methods do not use constraints. The ``halton`` and ``sobol`` method points are generated using `scipy.stats.qmc`. Any other QMC method could be used. References ---------- .. [1] Endres, SC, Sandrock, C, Focke, WW (2018) "A simplicial homology algorithm for lipschitz optimisation", Journal of Global Optimization. .. [2] Joe, SW and Kuo, FY (2008) "Constructing Sobol' sequences with better two-dimensional projections", SIAM J. Sci. Comput. 30, 2635-2654. .. [3] Hoch, W and Schittkowski, K (1981) "Test examples for nonlinear programming codes", Lecture Notes in Economics and Mathematical Systems, 187. Springer-Verlag, New York. http://www.ai7.uni-bayreuth.de/test_problem_coll.pdf .. [4] Wales, DJ (2015) "Perspective: Insight into reaction coordinates and dynamics from the potential energy landscape", Journal of Chemical Physics, 142(13), 2015. Examples -------- First consider the problem of minimizing the Rosenbrock function, `rosen`: >>> from scipy.optimize import rosen, shgo >>> bounds = [(0,2), (0, 2), (0, 2), (0, 2), (0, 2)] >>> result = shgo(rosen, bounds) >>> result.x, result.fun (array([1., 1., 1., 1., 1.]), 2.920392374190081e-18) Note that bounds determine the dimensionality of the objective function and is therefore a required input, however you can specify empty bounds using ``None`` or objects like ``np.inf`` which will be converted to large float numbers. >>> bounds = [(None, None), ]*4 >>> result = shgo(rosen, bounds) >>> result.x array([0.99999851, 0.99999704, 0.99999411, 0.9999882 ]) Next, we consider the Eggholder function, a problem with several local minima and one global minimum. We will demonstrate the use of arguments and the capabilities of `shgo`. (https://en.wikipedia.org/wiki/Test_functions_for_optimization) >>> def eggholder(x): ... return (-(x[1] + 47.0) ... * np.sin(np.sqrt(abs(x[0]/2.0 + (x[1] + 47.0)))) ... - x[0] * np.sin(np.sqrt(abs(x[0] - (x[1] + 47.0)))) ... ) ... >>> bounds = [(-512, 512), (-512, 512)] `shgo` has built-in low discrepancy sampling sequences. First, we will input 64 initial sampling points of the *Sobol'* sequence: >>> result = shgo(eggholder, bounds, n=64, sampling_method='sobol') >>> result.x, result.fun (array([512. , 404.23180824]), -959.6406627208397) `shgo` also has a return for any other local minima that was found, these can be called using: >>> result.xl array([[ 512. , 404.23180824], [ 283.0759062 , -487.12565635], [-294.66820039, -462.01964031], [-105.87688911, 423.15323845], [-242.97926 , 274.38030925], [-506.25823477, 6.3131022 ], [-408.71980731, -156.10116949], [ 150.23207937, 301.31376595], [ 91.00920901, -391.283763 ], [ 202.89662724, -269.38043241], [ 361.66623976, -106.96493868], [-219.40612786, -244.06020508]]) >>> result.funl array([-959.64066272, -718.16745962, -704.80659592, -565.99778097, -559.78685655, -557.36868733, -507.87385942, -493.9605115 , -426.48799655, -421.15571437, -419.31194957, -410.98477763]) These results are useful in applications where there are many global minima and the values of other global minima are desired or where the local minima can provide insight into the system (for example morphologies in physical chemistry [4]_). If we want to find a larger number of local minima, we can increase the number of sampling points or the number of iterations. We'll increase the number of sampling points to 64 and the number of iterations from the default of 1 to 3. Using ``simplicial`` this would have given us 64 x 3 = 192 initial sampling points. >>> result_2 = shgo(eggholder, bounds, n=64, iters=3, sampling_method='sobol') >>> len(result.xl), len(result_2.xl) (12, 20) Note the difference between, e.g., ``n=192, iters=1`` and ``n=64, iters=3``. In the first case the promising points contained in the minimiser pool are processed only once. In the latter case it is processed every 64 sampling points for a total of 3 times. To demonstrate solving problems with non-linear constraints consider the following example from Hock and Schittkowski problem 73 (cattle-feed) [3]_:: minimize: f = 24.55 * x_1 + 26.75 * x_2 + 39 * x_3 + 40.50 * x_4 subject to: 2.3 * x_1 + 5.6 * x_2 + 11.1 * x_3 + 1.3 * x_4 - 5 >= 0, 12 * x_1 + 11.9 * x_2 + 41.8 * x_3 + 52.1 * x_4 - 21 -1.645 * sqrt(0.28 * x_1**2 + 0.19 * x_2**2 + 20.5 * x_3**2 + 0.62 * x_4**2) >= 0, x_1 + x_2 + x_3 + x_4 - 1 == 0, 1 >= x_i >= 0 for all i The approximate answer given in [3]_ is:: f([0.6355216, -0.12e-11, 0.3127019, 0.05177655]) = 29.894378 >>> def f(x): # (cattle-feed) ... return 24.55*x[0] + 26.75*x[1] + 39*x[2] + 40.50*x[3] ... >>> def g1(x): ... return 2.3*x[0] + 5.6*x[1] + 11.1*x[2] + 1.3*x[3] - 5 # >=0 ... >>> def g2(x): ... return (12*x[0] + 11.9*x[1] +41.8*x[2] + 52.1*x[3] - 21 ... - 1.645 * np.sqrt(0.28*x[0]**2 + 0.19*x[1]**2 ... + 20.5*x[2]**2 + 0.62*x[3]**2) ... ) # >=0 ... >>> def h1(x): ... return x[0] + x[1] + x[2] + x[3] - 1 # == 0 ... >>> cons = ({'type': 'ineq', 'fun': g1}, ... {'type': 'ineq', 'fun': g2}, ... {'type': 'eq', 'fun': h1}) >>> bounds = [(0, 1.0),]*4 >>> res = shgo(f, bounds, iters=3, constraints=cons) >>> res fun: 29.894378159142136 funl: array([29.89437816]) message: 'Optimization terminated successfully.' nfev: 114 nit: 3 nlfev: 35 nlhev: 0 nljev: 5 success: True x: array([6.35521569e-01, 1.13700270e-13, 3.12701881e-01, 5.17765506e-02]) xl: array([[6.35521569e-01, 1.13700270e-13, 3.12701881e-01, 5.17765506e-02]]) >>> g1(res.x), g2(res.x), h1(res.x) (-5.062616992290714e-14, -2.9594104944408173e-12, 0.0) )ÚargsÚ constraintsÚnÚitersÚcallbackÚminimizer_kwargsÚoptionsÚsampling_methodz/Successfully completed construction of complex.rTzEFailed to find a feasible minimizer point. Lowest sampling point = {})Úmesz%Optimization terminated successfully.)ÚSHGOÚconstruct_complexÚ break_routineÚdispÚprintÚlenÚLMCÚxl_mapsÚfind_lowest_vertexÚ fail_routineÚformatÚf_lowestÚresÚfunÚx_lowestÚxÚfnÚnfevÚmessageÚsuccess) ÚfuncÚboundsr r r r rrrrZshcrrúd/Users/vegardjervell/Documents/master/model/venv/lib/python3.9/site-packages/scipy/optimize/_shgo.pyrs2 ýÿ   c@sVeZdZdUdd„Zdd„Zdd „Zd d „Zd d „Zdd„Zdd„Z dd„Z dd„Z dd„Z dd„Z dd„Zdd„Zdd„Zd d!„Zd"d#„ZdVd%d&„Zd'd(„Zd)d*„Zd+d,„Zd-d.„ZdWd/d0„ZdXd1d2„Zd3d4„ZdYd6d7„ZdZd8d9„Zd:d;„Zdd?„Zd@dA„Z dBdC„Z!dDdE„Z"dFdG„Z#dHdI„Z$dJdK„Z%d[dMdN„Z&e'dOdP„ƒZ(dQdR„Z)dSdT„Z*dS)\rrNÚsobolc s$ddlm} gd¢} t| tƒr:| | vr:td d | ¡¡ƒ‚|ˆ_|ˆ_|ˆ_ |ˆ_ t   |t ¡} t  | ¡dˆ_t  | ¡}d| |dd…dfdf<d| |dd…dfdf<| dd…df| dd…dfk}| ¡rðtd  d d d „|Dƒ¡¡ƒ‚| ˆ_|dur®|ˆ_gˆ_gˆ_t|ƒtur4t|ƒtur4|f}|D]Z}|d d kr8ˆj |d¡zˆj |d¡Wn tyŽˆj d¡Yn0q8tˆjƒˆ_tˆjƒˆ_n dˆ_dˆ_ˆj dˆjiˆj dœˆ_|durêˆj |¡nddiˆjd<ˆjddvr&|dur&d|vr&|dus2ˆjdur>ˆjˆjd<| durTˆ | ¡nHdˆ_dˆ_dˆ_dˆ_ dˆ_!dˆ_"dˆ_dˆ_#dˆ_$dˆ_%dˆ_&dˆ_'gd¢ˆ_(gd¢ggdgdggd¢ddgddgdggd ¢dd!ggd¢gd¢dd!gd"œ}ˆjd}ˆj(|| )¡7_(d#d$„}|ˆjˆj(ƒ|ˆjdˆj(dgƒdˆ_*dˆ_+|ˆ_,dˆ_-|ˆ_.|ˆ_/dˆ_0dˆ_1dˆ_2dˆ_3ˆj,durŽdˆ_,ˆj.dur¸d%ˆ_.| d&kr°d'ˆ_.ˆj.ˆ_/ˆjdurôˆj durôˆj!durôˆj#durôˆjdusúdˆ_,| d(krˆj4ˆ_5ˆj6ˆ_7| ˆ_8nÂ| d)vs2t| tƒsÞˆj9ˆ_5ˆj:ˆ_7| d)vrÊ| d&krœt;d*t  ˆjdt j? @¡d+ˆ_An d,ˆ_8| jBˆjdt j? @¡d+ˆ_A‡fd-d.„} nd/ˆ_8ˆjCˆ_D| ˆ_Edˆ_Fdˆ_Ggˆ_HtIƒˆ_JtKƒˆ_LdˆjL_MdˆjL_NdˆjL_OdˆjL_PdS)0Nr)Úqmc)Úhaltonr*r z4Unknown sampling_method specified. Valid methods: {}z, gšd~ÅQÊgšd~ÅQJrzError: lb > ub in bounds {}.css|]}t|ƒVqdS©N)Ústr)Ú.0Úbrrr)Ú Þóz SHGO.__init__..ÚtypeZineqr r rÚSLSQP)r Úmethodr(rrZftolgê-™—q=rr5)r4ZCOBYLAr FT)r Zx0r rrr5)ÚjacÚhessÚhesspr(r r6)r6r7r8r()r6r(r r7)Z_customz nelder-meadZpowellZcgZbfgsz newton-cgzl-bfgs-bZtncZcobylaZslsqpZdoglegz trust-ncgz trust-krylovz trust-exactcSs*t|ƒ}|t|ƒD]}| |d¡qdS)z8Remove keys from dictionary if not in goodkeys - inplaceN)ÚsetÚpop)Ú dictionaryZgoodkeysZ existingkeysÚkeyrrr)Ú_restrict_to_keysAsz(SHGO.__init__.._restrict_to_keysédr*é€r )r,r*é)ÚdZscrambleÚseedr,cs ˆj |¡Sr-)Ú qmc_engineÚrandom)r rA©Úselfrr)Ú}r2zSHGO.__init__..Zcustom)QZ scipy.statsr+Ú isinstancer.Ú ValueErrorrÚjoinr'r(r rÚnpÚarrayÚfloatÚshapeÚdimÚisfiniteÚanyZmin_consÚg_consÚg_argsr3ÚtupleÚlistÚappendÚKeyErrorrÚupdateÚ init_optionsÚ f_min_trueÚminimize_every_iterÚmaxiterÚmaxfevÚmaxevÚmaxtimeÚminhgrdÚsymmetryÚ local_iterÚinfty_cons_samplrÚmin_solver_argsÚlowerÚ stop_globalrr Ú iters_doner ÚncÚn_prcÚ n_sampledr#ÚhgrÚiterate_hypercubeÚiterate_complexÚsimplex_minimizersÚ minimizersrÚiterate_delaunayÚdelaunay_complex_minimisersÚintÚceilÚlog2ZSobolrDZ RandomStaterCZHaltonÚsampling_customÚsamplingÚsampling_functionÚ stop_l_iterZstop_complex_iterÚminimizer_poolÚ LMapCacherrrr$ÚnlfevÚnljevÚnlhev)rFr'r(r r r r rrrrr+ÚmethodsZaboundZinfindZbnderrZconsZ solver_argsr5r=rrEr)Ú__init__¿s6 ÿ   ÿ ÿ ü ÿþýü    ò   ÿ   ÿþþ  ÿ   ÿ  ÿz SHGO.__init__cCsÎ|jd |¡| dd¡|_| dd¡|_| dd¡|_| dd¡|_t ¡|_| dd¡|_ d |vr‚|d |_ | d d ¡|_ nd|_ | d d¡|_ d |v|_ | dd¡|_| dd¡|_| dd¡|_dS)zÞ Initiates the options. Can also be useful to change parameters after class initiation. Parameters ---------- options : dict Returns ------- None rr[Fr\Nr]r^r_Úf_minÚf_tolg-Cëâ6?r`rarbZinfty_constraintsTr)rrXÚgetr[r\r]r^ÚtimeÚinitr_rZrr`rarbrcr)rFrrrr)rY—s    zSHGO.init_optionscCsT|jrtdƒ|js.|jrq.| ¡| ¡q|jsB|jsB| ¡|jd|j _ dS)zð Construct for `iters` iterations. If uniform sampling is used, every iteration adds 'n' sampling points. Iterations if a stopping criteria (e.g., sampling points or processing time) has been met. zSplitting first generationrN) rrrfrÚiterateÚstopping_criteriar[Ú find_minimargrZnitrErrr)rÌs  zSHGO.construct_complexcCsL| ¡t|jƒdkr@| |j¡| ¡|jj|_|jj |_ n|  ¡dS)zŒ Construct the minimizer pool, map the minimizers to local minima and sort the results into a global return object. rN) rorÚX_minÚ minimise_poolrbÚ sort_resultrr rr"r!rrErrr)r‡ès   zSHGO.find_minimacCsÂ|jdkrptj|_|jjjD]8}|jj|j|jkr|jj|j|_|jj|j|_ q|jtjkr¾d|_d|_ nN|j dkrˆd|_d|_ n6tj |j dd|_ |j |j d|_|j|j d|_ dS)Nr réÿÿÿÿ©Zaxis)rrKÚinfrÚHCÚVÚcacheÚfÚx_ar!r#ÚargsortÚFZf_IÚC)rFr"rrr)rüs   zSHGO.find_lowest_vertexcCsF|jdur |j|jdkr d|_|jdur@|j|jdkr@d|_|jS)NrT)r rgrfr\rErrr)Úfinite_iterationss  zSHGO.finite_iterationscCs|j|jkrd|_|jS©NT)r#r]rfrErrr)Ú finite_fevs zSHGO.finite_fevcCs|j|jkrd|_dSr—)rjr^rfrErrr)Ú finite_ev"s zSHGO.finite_evcCst ¡|j|jkrd|_dSr—)rƒr„r_rfrErrr)Ú finite_time'szSHGO.finite_timecCs¶t|jjƒdkr| ¡|jdkr@|jdkr°|j|jkr°d|_np|j|jt|jƒ}|j|jkr d|_t|ƒd|jkr t   dd  |j¡dd  |j¡¡||jkr°d|_|jS) zÏ Stop the algorithm if the final function value is known Specify in options (with ``self.f_min_true = options['f_min']``) and the tolerance with ``f_tol = options['f_tol']`` rçTr@z%A much lower value than expected f* =z {} thanz the was found f_lowest =z{} ) rrrrrrZrrfÚabsÚwarningsÚwarnr)rFÚperrr)Úfinite_precision+s(     ÿþ ý zSHGO.finite_precisioncCsB|jjdkrdS|jj|j|_|jj|_|j|jkr2r2z1SHGO.construct_lcb_simplicial..rrz cbounds found for v_min.x_a = {}z cbounds = {})r(r§Ú enumerater’rr¥r¦r)rFÚv_minÚcboundsr«ÚiZx_irrr)Úconstruct_lcb_simplicial#s  zSHGO.construct_lcb_simplicialcCsdd„|jDƒ}|S)a? Construct locally (approximately) convex bounds Parameters ---------- v_min : Vertex object The minimizer vertex Returns ------- cbounds : list of lists List of size dimension with length-2 list of bounds for each dimension cSsg|]}|d|dg‘qSr¶rr·rrr)r¸Rr2z/SHGO.construct_lcb_delaunay..©r()rFrºr®r»rrr)Úconstruct_lcb_delaunayDszSHGO.construct_lcb_delaunayc CsÀ|jrt d |jj¡¡|j|jdur6|j|jS|jdurNtd |¡ƒ|jrbtd |¡ƒ|j dkr²t |ƒ}|j t |ƒ}t |ƒ}|  |j j|¡}d|jvrÔ||jd<n"|j||d}d|jvrÔ||jd<|jrúd|jvrútdƒt|jdƒt|j|fi|j¤Ž}|jr&td  |¡ƒ|jj|j7_d |vrT|jj|j7_d |vrp|jj|j7_z|jd |_Wnttfyž|jYn0|j||jj|||d |S)aœ This function is used to calculate the local minima using the specified sampling point as a starting value. Parameters ---------- x_min : vector of floats Current starting point to minimize. Returns ------- lres : OptimizeResult The local optimization result represented as a `OptimizeResult` object. zVertex minimiser maps = {}Nz&Callback for minimizer starting at {}:zStarting minimization at {}...r r(r­zbounds in kwarg:z lres = {}ÚnjevÚnhevrr¾)rr¥r¦rrÚv_mapsÚlresrrrrTr©r½rŽrrdrr¿rr'rr{r$r|rÀr}rÁr Ú IndexErrorÚ TypeErrorÚadd_res)rFrµr®Zx_min_tZ x_min_t_normZg_boundsrÃrrr)rWsP  ÿÿ         z SHGO.minimizecCsR|j ¡}|d|j_|d|j_|d|j_|d|j_|j|jj|j_ |jS)úA Sort results and build the global return object ÚxlÚfunlr"r ) rÚsort_cache_resultrrÈrÉr"r r#r{r$)rFÚresultsrrr)rŠ¥s     zSHGO.sort_resultúFailed to convergecCs"d|_d|j_dg|_||j_dS)NTF)rrr&rˆr%)rFrrrr)r¶szSHGO.fail_routinecCsX|jrtdƒ| |j|j¡|j|_|s<|jdur<| ¡| ¡|  ¡|j|_ dS)aÈ Sample the function surface. There are 2 modes, if ``infty_cons_sampl`` is True then the sampled points that are generated outside the feasible domain will be assigned an ``inf`` value in accordance with SHGO rules. This guarantees convergence and usually requires less objective function evaluations at the computational costs of more Delaunay triangulation points. If ``infty_cons_sampl`` is False, then the infeasible points are discarded and only a subspace of the sampled points are used. This comes at the cost of the loss of guaranteed convergence and usually requires more objective function evaluations. zGenerating sampling pointsN) rrrvrhrOr rRÚsampling_subspaceÚsorted_samplesÚfun_refrj)rFrcrrr)r¤¼s zSHGO.sampled_surfacecCsô|j|jdkr¶|jdkrB|jr(tdƒ| ¡| ¡| ¡nZ|jrPtdƒ|jdkrh|jddn|jd|j d|j j d |_ |jr”td ƒ|  ¡|jrðt  d  |j¡¡n:|jrÄtd ƒdg|_z |jWntyîg|_Yn0dS) Nr@zConstructing 1-D minimizer poolz-Constructing Gabrial graph and minimizer poolrF)ÚgrowT)rÐrirz0Triangulation completed, building minimizer poolz Minimizer pool = SHGO.X_min = {}z8Not enough sampling points found in the feasible domain.)r#rOrrÚ ax_subspaceÚsurface_topo_refÚ minimizers_1Dr Údelaunay_triangulationrir•rNÚdelaunay_minimizersr¥r¦rrˆryÚAttributeErrorrErrr)rqßs:    ÿÿ  z SHGO.delaunay_complex_minimiserscCsr| ||¡|_tt|jƒƒD]N}|jdd…|f|j|d|j|d|j|d|jdd…|f<q|jS)zu Generates uniform sampling points in a hypercube and scales the points to the bound limits. Nrr)rwr•Úrangerr()rFr rOr¼rrr)ru sÿ þzSHGO.sampling_customcCsdt|jƒD]T\}}|j||jjg|j|¢RŽdk|_|jjdkr d|j_|jr t |jjƒq dS)z7Find subspace of feasible points from g_func definitionr›rzJNo sampling point found within the feasible set. Increasing sampling size.N) r¹rRr•ÚTrSr¡rr%rr)rFr®Úgrrr)rÍs & zSHGO.sampling_subspacecCs,tj|jdd|_|j|j|_|j|jfS)z*Find indexes of the sorted sampling pointsrrŒ)rKr“r•Ú Ind_sortedÚXsrErrr)rÎ%szSHGO.sorted_samplescCstg|_g|_g|_t|jƒD]R}|j |jdd…|f¡|j |jdd…|f¡|j |jdd…|f¡qdS)zG Finds the subspace vectors along each component axis. N) ZCiZXs_iÚIir×rOrVr•rÚrÛ)rFr¼rrr)rÑ+szSHGO.ax_subspacecCsd}|jdkr|j}|j}d}t t |j¡d¡|_t|jt |j¡dƒD]¦}d}|jdur˜|jD]0}||j|dd…fg|j¢RŽdkrfd}q˜qf|rÔ|j |j|dd…fg|j¢RŽ|j|<|jd7_qN|j rNtj |j|<|jd7_qN|r|dkr||jd|…<|jS)zD Find the objective function output reference table FrTNr›r) r#r”rKZzerosrNr•r×rRr r'rcr)rFZ f_cache_boolZFtempZfn_oldr¼Zeval_frÙrrr)rÏ7s.   $(  z SHGO.fun_refcCsltj|jt |j¡<t |j¡|_|j|j|_tj|jdd|_tj|jddd…ddddd…|_ dS)zT Find the BD and FD finite differences along each component vector. rrŒNr‹) rKrr”ÚisnanZ nan_to_numrÚZFtÚdiffÚFtpÚFtmrErrr)rÒ\s zSHGO.surface_topo_refcCsXg|_g|_t|jƒD]}t|j|tt|j|ƒƒƒD]\}}||kr:|j |¡q:|j|dkrŠ|j |jdd…|fddk¡q|j||j dkrÈ|j |jdd…|f|j ddk¡q|jdd…|f|j|dk}|j dd…|f|j|ddk}|j |o|¡qt   |j¡  ¡r:d|_nd|_t   |j¡  ¡|_|jS)Nrrr@TF)Z Xi_ind_posÚ Xi_ind_topo_ir×rOÚziprÜrrVrßr#ràrKrLÚallÚ Xi_ind_topo)rFr®r¼r"ZI_indZ Xi_ind_top_pZ Xi_ind_top_mrrr)Ú sample_topojs$&$* $zSHGO.sample_topocCspg|_t|jƒD]}| |¡}|r|j |¡q|j|j|_| ¡t|jƒdksd|j |j|_ ng|_ |j S)ú7 Returns the indices of all minimizers r) ryr×r#rårVr”r¨rªrr•rˆ©rFr®Zmin_boolrrr)rÓŽs zSHGO.minimizers_1DrcCsV|st |j¡|_n|j |j|d…dd…f¡ntj|jdd|_|jS)NÚTriT)Ú incremental)rZDelaunayr•rèÚhasattrZ add_points)rFrÐrirrr)rÔ¥s   zSHGO.delaunay_triangulationcCs*|jd|jd||jd|d…S)zŒ Returns the indices of points connected to ``pindex`` on the Gabriel chain subgraph of the Delaunay triangulation. rr)Zvertex_neighbor_vertices)ZpindexZtriangrrr)Úfind_neighbors_delaunay°s  ÿÿzSHGO.find_neighbors_delaunaycCsVg|_| ||j¡}|D]$}|j||j|k}|j |¡qt |j¡ ¡|_|jSr-) rárërèr”rVrKrLrãrä)rFr®ZG_indZg_iZ rel_topo_boolrrr)Úsample_delaunay_topoºszSHGO.sample_delaunay_topocCsÊg|_|jrHt d |j¡¡t d |j¡¡t d t |j ¡¡¡t |jƒD]}|  |¡}|rR|j  |¡qR|j |j|_| ¡|jr t d |j¡¡t|jƒdks¾|j |j|_ng|_|jS)ræz self.fn = {}z self.nc = {}znp.shape(self.C) = {}zself.minimizer_pool = {}r)ryrr¥r¦rr#rhrKrNr•r×rìrVr”r¨rªrrˆrçrrr)rÕÊs& ÿ zSHGO.delaunay_minimizers)rNNNNNNr*)F)N)N)rÌ)F)Fr)+Ú__name__Ú __module__Ú __qualname__rrYrr‡rr–r˜r™ršr r¢r†r…rlrprnr‰rªr¯r°r½r¿rrŠrr¤rqrurÍrÎrÑrÏrÒrårÓrÔÚ staticmethodrërìrÕrrrr)r¾sXþ Y5    . ?!  N  #*  %$  rc@seZdZdd„ZdS)ÚLMapcCs"||_d|_d|_d|_g|_dSr-)r¬Úx_lrÃr€Úlbounds)rFr¬rrr)rès z LMap.__init__N)rírîrïrrrrr)rñçsrñc@s.eZdZdd„Zdd„Zd dd„Zdd „ZdS) rzcCs(i|_g|_g|_g|_g|_d|_dS)Nr)rrÂrÚf_mapsÚ lbound_mapsr¡rErrr)rñs zLMapCache.__init__cCsTtj |¡}t|ƒ}z |j|WStyNt|ƒ}||j|<|j|YS0dSr-)rKÚndarrayÚtolistrTrrWrñ)rFr¬Zxvalrrr)Ú __getitem__ûs    zLMapCache.__getitem__NcCsŽtj |¡}t|ƒ}|j|j|_||j|_|j|j|_ ||j|_ |j d7_ |j   |¡|j  |j¡|j  |j¡|j  |¡dSr£)rKrör÷rTr"rròrÃr r€rór¡rÂrVrrôrõ)rFr¬rÃr(rrr)rÆs    zLMapCache.add_rescCs¬i}t |j¡|_t |j¡|_t |j¡}|j||d<t |j¡|_|j||d<|dj|d<|j|d|d<|j|d|d<tj |j¡|_tj |j¡|_|S)rÇrÈrÉrr"r )rKrLrrôr“rØrör÷)rFrËZ ind_sortedrrr)rÊs zLMapCache.sort_cache_result)N)rírîrïrrørÆrÊrrrr)rzðs  rz)rNNrNNNr )Ú__doc__ZnumpyrKrƒr¥rZscipyrZscipy.optimizerrZ&scipy.optimize._shgo_lib.triangulationrÚ__all__rrrñrzrrrr)Ús4  þ 01