9i* SrSSKJr SSKrSSKJrJrJr SSK J r S/r SSS .S jjr SSS S S SS\R*SS4 Sjrg)z Interface to Constrained Optimization By Linear Approximation Functions --------- .. autosummary:: :toctree: generated/ fmin_cobyla ) signatureN)OptimizeResult_check_unknown_options_prepare_scalar_function)NonlinearConstraint fmin_cobyla?-C6?)callbackc ^Sn [U5 UHn [U 5(aM[U 5e TcUm/nUH6nU4U4SjjnUR[ US[ R 55 M8 UUUUU U S.n[XU4SU0UD6nU(a"US(d[SUR35 US $![a)n [U5(aU/nSn A N[U 5U eSn A ff=f) a Minimize a function using the Constrained Optimization By Linear Approximation (COBYLA) method. This method uses the pure-python implementation of the algorithm from PRIMA. Parameters ---------- func : callable Function to minimize. In the form func(x, \*args). x0 : ndarray Initial guess. cons : sequence Constraint functions; must all be ``>=0`` (a single function if only 1 constraint). Each function takes the parameters `x` as its first argument, and it can return either a single number or an array or list of numbers. args : tuple, optional Extra arguments to pass to function. consargs : tuple, optional Extra arguments to pass to constraint functions (default of None means use same extra arguments as those passed to func). Use ``()`` for no extra arguments. rhobeg : float, optional Reasonable initial changes to the variables. rhoend : float, optional Final accuracy in the optimization (not precisely guaranteed). This is a lower bound on the size of the trust region. disp : {0, 1, 2, 3}, optional Controls the frequency of output; 0 implies no output. maxfun : int, optional Maximum number of function evaluations. catol : float, optional Absolute tolerance for constraint violations. callback : callable, optional Called after each iteration, as ``callback(x)``, where ``x`` is the current parameter vector. Returns ------- x : ndarray The argument that minimises `f`. See also -------- minimize: Interface to minimization algorithms for multivariate functions. See the 'COBYLA' `method` in particular. Notes ----- This algorithm is based on linear approximations to the objective function and each constraint. We briefly describe the algorithm. Suppose the function is being minimized over k variables. At the jth iteration the algorithm has k+1 points v_1, ..., v_(k+1), an approximate solution x_j, and a radius RHO_j. (i.e., linear plus a constant) approximations to the objective function and constraint functions such that their function values agree with the linear approximation on the k+1 points v_1,.., v_(k+1). This gives a linear program to solve (where the linear approximations of the constraint functions are constrained to be non-negative). However, the linear approximations are likely only good approximations near the current simplex, so the linear program is given the further requirement that the solution, which will become x_(j+1), must be within RHO_j from x_j. RHO_j only decreases, never increases. The initial RHO_j is rhobeg and the final RHO_j is rhoend. In this way COBYLA's iterations behave like a trust region algorithm. Additionally, the linear program may be inconsistent, or the approximation may give poor improvement. For details about how these issues are resolved, as well as how the points v_i are updated, refer to the source code or the references below. .. versionchanged:: 1.16.0 The original Powell implementation was replaced by a pure Python version from the PRIMA package, with bug fixes and improvements being made. References ---------- Powell M.J.D. (1994), "A direct search optimization method that models the objective and constraint functions by linear interpolation.", in Advances in Optimization and Numerical Analysis, eds. S. Gomez and J-P Hennart, Kluwer Academic (Dordrecht), pp. 51-67 Powell M.J.D. (1998), "Direct search algorithms for optimization calculations", Acta Numerica 7, 287-336 Powell M.J.D. (2007), "A view of algorithms for optimization without derivatives", Cambridge University Technical Report DAMTP 2007/NA03 Zhang Z. (2023), "PRIMA: Reference Implementation for Powell's Methods with Modernization and Amelioration", https://www.libprima.net, :doi:`10.5281/zenodo.8052654` Examples -------- Minimize the objective function f(x,y) = x*y subject to the constraints x**2 + y**2 < 1 and y > 0:: >>> def objective(x): ... return x[0]*x[1] ... >>> def constr1(x): ... return 1 - (x[0]**2 + x[1]**2) ... >>> def constr2(x): ... return x[1] ... >>> from scipy.optimize import fmin_cobyla >>> fmin_cobyla(objective, [0.0, 0.1], [constr1, constr2], rhoend=1e-7) array([-0.70710685, 0.70710671]) The exact solution is (-sqrt(2)/2, sqrt(2)/2). zLcons must be a sequence of callable functions or a single callable function.Nc>U"U/TQ76$Nr )xconfuncconsargss Y/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/scipy/optimize/_cobyla_py.py wrapped_con fmin_cobyla..wrapped_cons1(x( (r)rhobegtoldispmaxitercatolr constraintssuccessz"COBYLA failed to find a solution: r) lencallable TypeErrorappendrnpinf_minimize_cobylaprintmessage)funcx0consargsrrrhoendmaxfunrrrerrthisfuncenlcsconroptssols ` rr r sv C % D HH%%n$ D#& ) ' Q?@   "D 4T #t #! #C C N 23;;-@A s8OC ( D>>6DC.a ' (s B== C0C+ C++C0c ^ ^SSKJn SSKJnJn SSKJn [U 5 UnUbUOSnUS:wa US:waUS:waUS:wa[S U35eS n[XUUS 9nT b9[T 5n[UR5S 1:XaU 4S jmOU 4SjmU4SjnOSnUbUO7[R"[R"[ 5R"5nUUUUUU S.nU "UR$USU UUUS9nUR&U:aSnSnO8UR(U:H=(d UR(U:HnU"SUR(5n[+UR,UR(UUUR.UR0UR&S9$)a Minimize a scalar function of one or more variables using the Constrained Optimization BY Linear Approximation (COBYLA) algorithm. This method uses the pure-python implementation of the algorithm from PRIMA. Options ------- rhobeg : float Reasonable initial changes to the variables. tol : float Final accuracy in the optimization (not precisely guaranteed). This is a lower bound on the size of the trust region. disp : int Controls the frequency of output: 0. (default) There will be no printing 1. A message will be printed to the screen at the end of iteration, showing the best vector of variables found and its objective function value 2. in addition to 1, each new value of RHO is printed to the screen, with the best vector of variables so far and its objective function value. 3. in addition to 2, each function evaluation with its variables will be printed to the screen. maxiter : int Maximum number of function evaluations. catol : float Tolerance (absolute) for constraint violations f_target : float Stop if the objective function is less than `f_target`. .. versionchanged:: 1.16.0 The original Powell implementation was replaced by a pure Python version from the PRIMA package, with bug fixes and improvements being made. References ---------- Zhang Z. (2023), "PRIMA: Reference Implementation for Powell's Methods with Modernization and Amelioration", https://www.libprima.net, :doi:`10.5281/zenodo.8052654` )minimize)SMALL_TR_RADIUSFTARGET_ACHIEVED)get_info_stringNrrzSdisp argument to minimize must be 0, 1, 2, or 3, received cgrr )rr,s r_jac_minimize_cobyla.._jacsr)r,jacintermediate_resultcP>[[R"U5XX4S9nT"US9 g)N)rfunnfevnitmaxcv)rA)rr$copy)rfnftrcstrv nlconstrlistrArs rwrapped_callback_intermediate7_minimize_cobyla..wrapped_callback_intermediates'&4rwwqzq9;'J#-@Arc>>T"[R"U55 gr)r$rG)rrHrIrJrKrLrs rrMrNs$rc<>T"XX#XE5 g![a gf=f)NFT) StopIteration)rrHrIrJrKrLrMs rwrapped_callback*_minimize_cobyla..wrapped_callbacks) -aBEP   s  )rr-maxfeviprintctolftargetcobyla)methodboundsrroptionsFzjDid not converge to a solution satisfying the constraints. See `maxcv` for the magnitude of the violation.COBYLA)rstatusrr(rDrCrF) _lib.pyprimar8_lib.pyprima.common.infosr9r:_lib.pyprima.common.messager;r ValueErrorrrset parametersr$sqrtfinfofloatepsrCrKinforrrIrH)rCr*r,rrrrrrf_targetrrZunknown_optionsr8r9r:r;r-rUr>sfsigrRrVr[resultrr(rMs ` @rr&r&sZ(M=?+ F%T1F {v{v{v{$$*8-. . "#$ ?B! s~~ #8"9 9 B  %  %5277288E?3F3F+GD Gbffb&"-8H%'F ||d@++0SFKKCS4S!(FKK8 FHH!'")")%yy$hh &  ..r)r Nr r r Ng-C6*?)__doc__inspectrnumpyr$ _optimizerrr _constraintsr__all__r r%r&r rrrtsh - /@C;?` `F$&2T44266'"4n.r