(phSrSSKJr SSKrSSKrSSKrSSKrSSKrSSK J r SSK J r J r Jr SSKJr SSKJr SSKJr SS KJr SS KJr S /rSS S .Sjjr"SS5r"SS5r"SS5rg)z`). Alternatively supply a map-like callable, such as `multiprocessing.Pool.map` for parallel evaluation. This evaluation is carried out as ``workers(func, iterable)``. Requires that `func` be pickleable. .. versionadded:: 1.11.0 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``, ``COBYLA``, or ``COBYQA`` 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] Hock, 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. .. [5] https://docs.scipy.org/doc/scipy/tutorial/optimize.html#constrained-minimization-of-multivariate-scalar-functions-minimize 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) >>> import numpy as np >>> 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, 23) 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, n=150, constraints=cons) >>> res message: Optimization terminated successfully. success: True fun: 29.894378159142136 funl: [ 2.989e+01] x: [ 6.355e-01 1.137e-13 3.127e-01 5.178e-02] # may vary xl: [[ 6.355e-01 1.137e-13 3.127e-01 5.178e-02]] # may vary nit: 1 nfev: 142 # may vary nlfev: 35 # may vary nljev: 5 nlhev: 0 >>> g1(res.x), g2(res.x), h1(res.x) (-5.062616992290714e-14, -2.9594104944408173e-12, 0.0) ) args constraintsniterscallbackminimizer_kwargsoptionssampling_methodrNz/Successfully completed construction of complex.rTzCFailed to find a feasible minimizer point. Lowest sampling point = )mesz%Optimization terminated successfully.) isinstancerr lbublenSHGO iterate_all break_routinedisplogginginfoLMCxl_mapsfind_lowest_vertex fail_routinef_lowestresfunx_lowestxfnnfev n_sampledtnevmessagesuccess) funcboundsrrrrrrrrrshcs G/var/www/html/venv/lib/python3.13/site-packages/scipy/optimize/_shgo.pyr r sKN &&!!"699fiiVYYH d! 0  $'       88 LLJ K 377??q     88; ~G Hll LL vv }}     A 77NE  s F-- F<c\rSrSrS$SjrSrSrSrSrSr S r S r S r S r S rSrSrSrSrSrSrSrS%SjrSrSrSrSrS&SjrS&SjrSrS'SjrS%SjrSr S r!S!r"S(S"jr#S#r$g))riNc p^SSKJn /SQn [U [5(a.X;a)[ SR SR U 555eUSSLaJ[US5(d7[U5Tl TRRnXS'TRnOUTl [X5Tl UTlUTlUTl["R$"U[&5n["R("U5STl["R,"U5)nSUUSS2S4S4'S UUSS2S 4S 4'USS2S4USS2S 4:nUR/5(a%[ S SR S U55S 35eUTlUTlUbUTl/Tl/Tl["R:"TR*[&5S5TlTR0HKnUSS;dMTR4R=US5 TR6R=US5 MM [?TR45Tl[?TR65TlOSTlSTlSTR0TR S.Tl UbTR@RCU5 OSS0TR@S'TR@SRE5S;a Ub SU;aUc TR4bTR2TR@S'U bTRGU 5 OTSTl$STl%STl&STl'STl(STl)STl$STl*STl+STl,STl-STl./SQTl/0S/SQ_S /_S!/_S"S/_S#S/_S$/S%Q_S&SS'/_S(SS'/_S)SS*/_S+/S,Q_S-/S.Q_S/SS0/_S1/S%Q_S2/S%Q_S3SS0/_S4/S5Q_nTR@SnT=R^UURE5- sl/S6nU"TR@TR^5 U"TR@STR^S/-5 STl0STl1UTl2STl3UTl4STl5STl6STl7STl8STl9STl:TRhc1TRdc$U S7:XaS8TR*-S -Tl4STl5TRdcS Tl2TRhcU S7:XdS9=Tl4Tl4STl5TRhS9:XaU S7:XaS8TR*-S -Tl4TRLc4TRNc'TRPcTRTc TRHbSTl2[wTR*TRTRSTRVTR0U S:9Tl<U S7:XaTRzTl>U Tl?OU S;;d[U [5(dTRTl>U S;;aU S<:Xat[S8["R"["R"TRh55-5Tl4STl5STl?U RTR*SSS=9TlEU4S?jn OS@Tl?TRTlHU TlISTlJSTlK/TlL[5TlN[5TlPSTRlQSTRlRSTRlSSTRlTg![[4a UTl GNf=f![a TR6R=S5 GMf=f)ANr)qmc)haltonsobol simplicialz4Unknown sampling_method specified. Valid methods: {}z, jacTgd~Qgd~QJrzError: lb > ub in bounds c38# UHn[U5v M g7fN)str).0bs r6 SHGO.__init__..s)A&Q#a&&&s.oldtypeineqr*rSLSQP)methodr4rrftolg-q=rrK)slsqpcobylacobyqa trust-constrrF)r*x0rrrrK_custom)r=hesshesspr4rz nelder-meadpowellcgbfgsz newton-cgr=rSrTzl-bfgs-br4tncrNcatolrO)r4rfeasibility_tolrM)r=r4rdoglegrSz trust-ncgz trust-krylovz trust-exactrP)r=rSrTrch[U5nU[U5- HnURUS5 M g)z8Remove keys from dictionary if not in goodkeys - inplaceN)setpop) dictionarygoodkeys existingkeyskeys r6_restrict_to_keys(SHGO.__init__.._restrict_to_keyss,z?L#c(m3sD)4r<d)dimdomainsfield sfield_argssymmetryrr)r:r;r;)dscrambleseedr:c:>TRRU5$r?) qmc_enginerandom)rrnselfs r6r&SHGO.__init__..sampling_methods??11!44rfcustom)U scipy.statsr9rr@ ValueErrorformatjoincallablerr3 derivative TypeErrorKeyErrorr r4rrnparrayfloatshaperiisfiniteanyrmin_consg_consg_argsr emptyappendtuplerupdatelower init_options f_min_trueminimize_every_itermaxitermaxfevmaxevmaxtimeminhgrdrminfty_cons_sampl local_iterr!min_solver_args stop_globalr r iters_donerncn_prcr/r-hgrqhull_incrementalr HCiterate_hypercubeiterate_complexriterate_delaunayintceillog2SobolrrHaltonsampling_customsamplingsampling_function stop_l_iterstop_complex_iterminimizer_pool LMapCacher$rr)r.nlfevnljevnlhev)rtr3r4rrrrrrrrrr9methodsr=aboundinfindbnderrcons solver_argsrKrds` r6__init__ SHGO.__init__s $3 os + +0N34:F499W;M4NP P !%(D0!"25"9::&t, ii***-'yy  %T0     &%(88F#A&++f%%"'vad|Q"&vad|Q1q!t , ::<<8 $ )A&)A AB!EF F '  "'DMDKDK 75) D  ((!>?DF DG+2D(&)ii$((U56'0'8DO,4D(&)jj488d67'1'9DO5 (0$ 00DM%4D "!!&!;"# ]8$ DI b$/ **2../s+A]-"]-^ -^^ %^54^5cURSRU5 SHBnX RS;dMURSRU5URU'MD URSS5UlURSS5UlURSS5UlURSS5Ul[R"5Ul URS S5Ul S U;a"US Ul URS S 5Ul OSUl URS S5Ul URSS5UlUR(aS/[UR 5-UlOSUlURSS5UlURSS5UlURSS5Ulg)z Initiates the options. Can also be useful to change parameters after class initiation. Parameters ---------- options : dict Returns ------- None rrXrTrNrrrf_minf_tolg-C6?rrmFrrinfty_constraintsr!)rrr_getrrrrtimeinitrrrrrmrr4rrr!)rtropts r6rSHGO.init_optionss" i(//8,C++I66)))488=%%c*, $+;;/Dd#K {{9d3 kk(D1 [[$/ IIK {{9d3 g %g.DO Wd3DJ"DO{{9d3  J6 ==E#dkk"22DM DM"++lE: ' ,? FKK. rfcU$r?rIrts r6 __enter__SHGO.__enter__-s rfc\URRRR"U6$r?)rV _mapwrapper__exit__)rtrs r6r SHGO.__exit__0s!wwyy$$--t44rfcUR(a[R"S5 UR(dEUR(aO3UR 5 UR 5 UR(dMEUR(d!UR(dUR5 URURl URRRUlg)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 generationN)r!r"r#rr iteratestopping_criteriar find_minimarr)nitrrr.r-rs r6rSHGO.iterate_all5s 99 LL5 6""!! LLN  " " $ """''%%  " ''))..rfcUR(a[R"S5 UR5 [ UR 5S:wabUR UR5 UR5 URRUl URRUl OUR5 UR(a$[R"SUR 35 gg)zt Construct the minimizer pool, map the minimizers to local minima and sort the results into a global return object. zSearching for minimizer pool...rzMinimiser pool = SHGO.X_min = N)r!r"r# minimizersrX_min minimise_poolr sort_resultr)r*r(r,r+r&rs r6rSHGO.find_minimaSs 99 LL: ;  tzz?a    t /    !HHLLDM HHJJDM  # # % 99 LL9$**F G rfcv[RUlURRR HnURRUR UR:dM6UR(a:[R"SURRUR 35 URRUR UlURRURUl M URR HhnURURUR:dM,URURUlURURUl Mj UR[R:XaSUlSUl gg)Nzself.HC.V[x].f = )rinfr(rrcachefr!r"r#x_ar+r$rx_l)rtr,lmcs r6r&SHGO.find_lowest_vertexns Awwyy|~~ -99LL#4TWWYYq\^^4D!EF $ !  $ ! 0 0 ! 88>>Cxx}""T]]2 $ 3 3 $ 1 1 " ==BFF " DM DM #rfc[SURUR455nUR(a&[R "SUR SU35 URb!UR UR:aSUlURb!UR UR:aSUlUR$)Nc3.# UH ocMUv M g7fr?rI)rAr,s r6rC)SHGO.finite_iterations..sH6q6s zIterations done =  / T)minrrr!r"r#rr)rtmis r6finite_iterationsSHGO.finite_iterationss HTZZ6H H 99 LL-doo->c"F G :: !4::.#' << #4<<0#' rfcUR(a0[R"SURSUR35 URUR:aSUlUR $)NzFunction evaluations done = rT)r!r"r#r-rrrs r6 finite_fevSHGO.finite_fevsO 99 LL7yDKK=Q R 77dkk !#D rfcUR(a0[R"SURSUR35 URUR:aSUlgg)NzSampling evaluations done = rT)r!r"r#r/rrrs r6 finite_evSHGO.finite_evsR 99 LL77GH"jj\+ , >>TZZ '#D  (rfc"UR(aF[R"S[R"5UR- SUR 35 [R"5UR- UR :aSUlgg)NzTime elapsed = rT)r!r"r#rrrrrs r6 finite_timeSHGO.finite_timesg 99 LL?499;+B*CD"ll^- . IIK$)) # 4#D  5rfcUR5 UR(aF[R"SUR35 [R"SUR 35 URc UR $UR S:Xa-URUR::aSUlUR $URUR - [UR 5- nURUR ::aRSUl[U5SUR-:a/[R"SUR SUR3SS 9 XR::aSUlUR $) 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']`` zLowest function evaluation = zSpecified minimum = Trgz&A much lower value than expected f* = z was found f_lowest = ) stacklevel) r&r!r"r#r(rrrabswarningswarn)rtpes r6finite_precisionSHGO.finite_precisions0 ! 99 LL8H I LL//@A B == ## # ??c !}} *#' --$//1S5IIB}}/#' r7a$**n,MM@@QR004 @#$ ZZ#' rfcURRS:XagURRUR- UlURRUlURUR::aSUlUR (a1[R"SURSURS35 UR $)zF Stop the algorithm if homology group rank did not grow in iteration. rNTzCurrent homology growth = z (minimum growth = )) r$sizerhgrdrrr!r"r#rs r6finite_homology_growthSHGO.finite_homology_growths 88==A  HHMMDHH, 88== 99 $#D  99 LL5dii[A//3||nA? @rfcURbUR5 URbUR5 URbUR 5 UR bUR 5 URbUR5 URbUR5 URbUR5 UR$)zL Various stopping criteria ran every iteration Returns ------- stop : bool )rrrrrrrrrrrrrrrs r6rSHGO.stopping_criterias << #  " " $ :: !  " " $ ;; " OO  :: ! NN  << #     ?? &  ! ! # << #  ' ' )rfcUR5 UR(a!UR(dUR5 U=RS- slgNr)rrr rrrs r6r SHGO.iterates>   # #%%  " 1rfcUR(a[R"S5 URcDURR 5 URR R5UlODURRUR5 U=RUR- slUR(a[R"S5 [URR5S:atURRHZnURR UnUR5nURHnUR!UR5nM M\ URR R#5 UR(a[R"S5 URR R$Ulg)zk Iterate a subdivision of the complex Note: called with ``self.iterate_complex()`` after class initiation z GG   !WWYY^^-DN GGNN466 " NNdff $N 99 LL: ; txx 1 $hhnnGGIIbMA#\\!$$/F%  ! 99 LL1 2''))..rfcU=RUR- slURURS9 UR(a\[ R "SUR35 [ R "SUR35 [ R "S5 URS:a[R"URSS9Ul URR5Ul /n[UR5H1up#US:dM URURUS- US-5 M3 [R"U5n[!S S S /5"URU5Ul0UlOaURR&SURS-:aUR)UR*S 9 URR&SUlUR(a[ R "S 5 [-US 5(aDUR.R1UR"R$UR"R25 UR(a[ R "S 5 UR.R4R75 UR(a[ R "S5 UR.R4R8UlURUlg)zv Build a complex of Delaunay triangulated points Note: called with ``self.iterate_complex()`` after class initiation )rz self.n = z self.nc = zRConstructing and refining simplicial complex graph structure from sampling points.rgraxisrTripoints simplices)rrrN)rrsampled_surfacerr!r"r#rirargsortC Ind_sortedflatten enumeraterrrrrrdelaunay_triangulationrhasattrrvf_to_vvrrr r.r-r/)rttrisindind_ss r6rSHGO.iterate_delaunay,s 466 d.C.CD 99 LL9TVVH- . LL:dggY/ 0 LL; < 88a< jja8DO"oo557DOD'8 7KKaa @A988D>D!%(K)@A$&&$ODHDKvv||AA-++$**+=aDJ 99 LLF G 4   GG  TXX__dhh.@.@ A 99 LL: ;  ! 99 LL1 2''))..rfch/UlURRRGHnSn[ UR R 5S:agUR R HMn[R"[R"U5[R"U5:H5(dMKSnMO U(aMURRUR5(dMUR(a[R"S5 [R"SURRURS35 [R"SURRURS35 [R"S5 URRUUR;a2URR!URRU5 UR(dGM[R"S 5 [R"S5 URRUR"H3n[R"S UR$S UR35 M5 [R"S5 GM /Ul/Ul0UlURHynUR(R!UR5 UR&R!UR5 UR$UR*[-UR5'M{ [R"UR&5Ul[R"UR(5UlUR/5 UR($) z' Returns the indexes of all minimizers FrTz<============================================================zv.x = z is minimizerzv.f = z==============================z Neighbors:zx = z || f = )rrrrrr$r%rallr minimiserr!r"r#rrrr r,minimizer_pool_Fr X_min_cacher sort_min_pool)rtr,in_LMCxlmivnrs r6rSHGO.minimizersesg!AF488##$q( HH,,DvvbhhqkRXXd^;<)> ?XXdjj)  zzrfcvURURSURSS9nURS5 UR(dUR 5 U(aUS-nUS:XaSUlO[ R"UR5SS:XaSUlOURURUR5 URSS2S4nURURSSS24URS5nURU5 UR(dMSUlg)z This processing method can optionally minimise only the best candidate solutions in the minimiser pool Parameters ---------- force_iter : int Number of starting minimizers to process (can be specified globally or locally) rr"rTNF) rrr trim_min_poolrrrr g_topographr,ZSs)rt force_iter lres_f_min ind_xmin_ls r6rSHGO.minimise_pools]]4::a=d6I6I!6L]M  1""  " " $a ?'+D$xx #A&!+#'    Z\\4:: 62Jtwwr1u~t7J7J27NOJ   z *5""":!rfc[R"UR5Ul[R"UR 5URUl[R"UR5URUlgr?)rrr( ind_f_minrrrs r6r*SHGO.sort_min_pools^D$9$9: hht':':;DNNK ")>)> ? NN!rfc[R"URUSS9Ul[R"URU5Ul[R"URU5Ulg)Nrr)rdeleterr(r)rttrim_inds r6r2SHGO.trim_min_poolsOYYtzz8!< " $*?*? J ii(;(;XFrfcj[R"U/5n[RR XS5Ul[R "UR SS9UlX RSUlURURUl URSUl UR$)z Returns the topographical vector stemming from the specified value ``x_min`` for the current feasible set ``X_min`` with True boolean values indicating positive entries and False values indicating negative entries. euclideanr1rr) rrrdistancecdistYrr4r5r)rtx_minrs r6r3SHGO.g_topographs%!!!''kBDFF,-""11$&&9"11!4wwrfcURVs/sH o"SUS/PM nnURHmn[UR5HQupVXaRU:aXcUS:aXcUS'XaRU:dM=XcUS:dMJXcUS'MS Mo UR(a<[ R "SUR35 [ R "SU35 U$s snf)z 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. rrzcbounds found for v_min.x_a = z cbounds = )r4r rrr!r"r#)rtv_minx_b_icboundsr-ix_is r6construct_lcb_simplicialSHGO.construct_lcb_simplicials 6:[[A[E!HeAh'[A((B#BFF+))A,&S1:a=-@$'AJqM))A,&S1:a=-@$'AJqM, 99 LL9%))E F LL:gY/ 0!BsC0cVURVs/sH o3SUS/PM nnU$s snf)z 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. rrr4)rtrIr"rJrKs r6construct_lcb_delaunaySHGO.construct_lcb_delaunays26:[[A[E!HeAh'[ABs&cUR(a-[R"SURR35 URUR bI[R"SURUR 35 URUR $UR b[R"SUS35 UR(a[R"SUS35 URS:Xa[U5nUR[U5n[U5nURURRU5nSUR;a1XPRS'[R"URS5 OPURXS 9nSUR;a1XPRS'[R"URS5 UR(aISUR;a9[R"S 5 [R"URS5 [!UR"U40URD6nUR(a[R"S U35 UR$=R&UR(- slS U;a)UR$=R*UR,- slS U;a)UR$=R.UR0- slUR2SUlURU URR9XUS9 U$![4[64a UR2 NIf=f)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 = zFound self.LMC[x_min].lres = z#Callback for minimizer starting at :zStarting minimization at z...r<r4r0zbounds in kwarg:zlres = njevnhevrrQ)r!r"r#r$v_mapslresrrrr)rNrrrrrRrr3r)rr.rrVrrWr* IndexErrorr}add_res)rtrFr"x_min_t x_min_t_normg_boundsrYs r6r SHGO.minimize$s" 99 LL3DHHOO3DE F 88E?   + LL8 HHUO0013 488E?'' ' == $ LL>ugQG H 99 LL4UG3? @   < /ElG++E'N;L .L44TWWYY|5LMH4///2:%%h/ T228<=2252BH4///2:%%h/ T228<= 99T%:%:: LL+ , LL..x8 9 5BD,A,AB 99 LL74&) * $))# T> HHNNdii 'N T> HHNNdii 'N xx{DH  X6 I&  HH sMM76M7cRURR5nUSURlUSURlUSURlUSURlURURR-URl UR$)1 Sort results and build the global return object rfunlr,r*) r$sort_cache_resultr)rrbr,r*r-rr.)rtresultss r6rSHGO.sort_resultpsy ((,,.dm  S\ u~ $((..0 xxrfcdSUlSURlS/UlXRlg)NTF)r r)r2rr1)rtrs r6r'SHGO.fail_routines)! V rfc UR(a[R"S5 URURUR 5 [ URR5S:aO[R"UR[R"URR545Ul U(dURbUR5 UR5 URUlg)ah 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 pointsrN)r!r"r#rrrirr$r%rvstackrrrsampling_subspacesorted_samplesr/)rtrs r6rSHGO.sampled_surfaces" 99 LL5 6 dggtxx( txx 1 $YY1A1A(BCDDF{{&&&( rfcURS:XaURX5UlOURX5Ul[[ UR 55H`nURSS2U4UR USUR US- -UR US-URSS2U4'Mb UR$)z] Generates uniform sampling points in a hypercube and scales the points to the bound limits. rNr)r/rrrangerr4)rtrrirLs r6rSHGO.sampling_customs >>Q ++A3DF++A3DFs4;;'(A FF1a4L![[^A.Q1BBD"kk!nQ/0DFF1a4L)vv rfc [UR5Hup[R"URVs/sH0n[R "U"U/UR UQ76S:5PM2 sn[S9nURUUlURRS:XdMSURl UR(dM[R"URR5 M gs snf)z7Find subspace of feasible points from g_func definitionr)dtyperzJNo sampling point found within the feasible set. Increasing sampling size.N)rrrrrr&rboolrr)r1r!r"r#)rtr"gx_Cfeasibles r6rjSHGO.sampling_subspaces  ,FC xxEIVVLVc#1 C 01S89VLHVVH%DFvv{{a%. 999LL!1!12#- Ms7C= c[R"URSS9UlURURUlURUR4$)z*Find indexes of the sorted sampling pointsrr)rrrrXsrs r6rkSHGO.sorted_sampless?**TVV!4&&)''rfcb[US5(aKUR(a:URRURUS2SS245 UR$[ R "URURS9UlUR$![ Ra [[R"5S5SSS:XaX[R"S5 SUl[ R "URURS9UlUR$ef=f)Nr) incrementalrQH6239aQH6239 Qhull precision error detected, this usually occurs when no bounds are specified, Qhull can only run with handling cocircular/cospherical points and in this case incremental mode is switched off. The performance of shgo will be reduced in this mode.F) rrr add_pointsrrDelaunay QhullErrorr@sysexc_infor"warning)rtrs r6rSHGO.delaunay_triangulations 4  D$:$: HH  uvqy 1 2,xx) "++DFF8<8N8N.&xx!%% s||~a()"1-9OO%DE.3D*&//040F0F HDH xx s.BBD.,D.)=rrrr$r5rrr)rxrEr4rr4r rrrir!r(rrr-r3rrrrr;rrrrrrrrrrrrrrrrr(rrr/rrrrrr)rrrrrrrmr+) rINNNNNNr<r)Fr?)zFailed to converge)r)%__name__ __module__ __qualname____firstlineno__rrrrrrr&rrrrrrrrrrrrr*r2r3rNrRrrr'rrrjrkr__static_attributes__rIrfr6rrsBF=AEFBJ=/~5 !<H6!(   $$" H  0 -^6r0h2h & D(IX" !B$3,( rfrc\rSrSrSrSrg)LMapicHXlSUlSUlSUl/Ulgr?)rrrYrlbounds)rtrs r6r LMap.__init__s#   rf)rrrYrrN)rrrrrrrIrfr6rrsrfrc0\rSrSrSrSrSSjrSrSrg) ricv0Ul/Ul/Ul[5Ul/Ul/UlSUlg)Nr)rrXr%r^ xl_maps_setf_maps lbound_mapsrrs r6rLMapCache.__init__s9   5  rfc[RRU5n[ U5nUR U$![a N'f=f![ a+ [U5nX R U'UR Us$f=fr?)rndarraytolistr}rrr~r)rtrxvals r6 __getitem__LMapCache.__getitem__s  !!!$A !H !::a=      !7D JJqM::a=  !s <A A A  2BBNc[RRU5n[U5nURUR UlX R UlURUR Ul X0R Ul U=RS- sl URRU5 URRUR5 URR![UR55 UR"RUR5 UR$RU5 gr)rrrrr,rrrYr*rrrrXrr%raddrr)rtrrYr4s r6r[LMapCache.add_ress JJ  a  !H FF 1 ! 1 "hh 1  & 1  Q  1 DFF# U466]+ 488$ 'rfc0n[R"UR5Ul[R"UR5Ul[R"UR5nURUUS'[R"UR5UlURUUS'USR US'URUSUS'URUSUS'[R RUR5Ul[R RUR5UlU$)rarrbrr,r*)rrr%rrTrr)rtrd ind_sorteds r6rcLMapCache.sort_cache_result(sxx - hht{{+ ZZ ,  Z0 hht{{+ ++j1!&/++||JqM2 Z]3zz((6 jj'' 4 rf)rrrrrXr%rr?) rrrrrrr[rcrrIrfr6rrs  !($rfr)rINrhrNNNr<)__doc__ collectionsrrr"rrnumpyrscipyrscipy.optimizerrrscipy.optimize._optimizerscipy.optimize._constraintsr scipy.optimize._minimizer scipy._lib._utilr !scipy.optimize._shgo_lib._complexr __all__r rrrrIrfr6rsxB"  ;;/9<-5 (GK9EO OdHHV DDrf