+ LV-j^xRtRR.t^RIt^RIHt^RIHt^RI H t H t H t H t HtHt^RIHt^RIHtHt^R IHt^R IHt^R IHt^R IHtR t]P>!]P@!]PB4PD4t#Rt$RRRRRRRRR^dR^R^]#R3Rlt%RRRR^dR^R]#RRR3 Rlt&RRlt'RRlt(R#)a  This module implements the Sequential Least Squares Programming optimization algorithm (SLSQP), originally developed by Dieter Kraft. See http://www.netlib.org/toms/733 Functions --------- .. autosummary:: :toctree: generated/ approx_jacobian fmin_slsqp approx_jacobian fmin_slsqpN)slsqp)norm)OptimizeResult_check_unknown_options_prepare_scalar_function_clip_x_for_func _check_clip_x_wrap_callback)approx_derivative)old_bound_to_new_arr_to_scalar)array_namespace)array_api_extra)_call_callback_maybe_halt)NDArrayzrestructuredtext encL\WRVVR7p\P!V4#)aC Approximate the Jacobian matrix of a callable function. Parameters ---------- x : array_like The state vector at which to compute the Jacobian matrix. func : callable f(x,*args) The vector-valued function. epsilon : float The perturbation used to determine the partial derivatives. args : sequence Additional arguments passed to func. Returns ------- An array of dimensions ``(lenf, lenx)`` where ``lenf`` is the length of the outputs of `func`, and ``lenx`` is the number of elements in `x`. Notes ----- The approximation is done using forward differences. 2-point)methodabs_stepargs)r np atleast_2d)xfuncepsilonrjacs&&&* i/Volumes/fast/ai/experiments/ui-tars-smoke/.venv/lib/python3.14/site-packages/scipy/optimize/_slsqp_py.pyrr$s(6 DI!% 'C == gư>c 6a VeTp \VR4pRV RV RV RV ^8gRVRV/pRpT\;QJd.V 3RlV4FNK 5M!V 3RlV44, pT\;QJd.V 3R lV4FNK 5M!V 3R lV44, pV'dVR R R VR VRS /3, pV'dVR RR VR V RS /3, p\WS 3R VRVRV/VBpV'd+VR,VR ,VR,VR,VR,3#VR,#)a Minimize a function using Sequential Least Squares Programming Python interface function for the SLSQP Optimization subroutine originally implemented by Dieter Kraft. Parameters ---------- func : callable f(x,*args) Objective function. Must return a scalar. x0 : 1-D ndarray of float Initial guess for the independent variable(s). eqcons : list, optional A list of functions of length n such that eqcons[j](x,*args) == 0.0 in a successfully optimized problem. f_eqcons : callable f(x,*args), optional Returns a 1-D array in which each element must equal 0.0 in a successfully optimized problem. If f_eqcons is specified, eqcons is ignored. ieqcons : list, optional A list of functions of length n such that ieqcons[j](x,*args) >= 0.0 in a successfully optimized problem. f_ieqcons : callable f(x,*args), optional Returns a 1-D ndarray in which each element must be greater or equal to 0.0 in a successfully optimized problem. If f_ieqcons is specified, ieqcons is ignored. bounds : list, optional A list of tuples specifying the lower and upper bound for each independent variable [(xl0, xu0),(xl1, xu1),...] Infinite values will be interpreted as large floating values. fprime : callable ``f(x,*args)``, optional A function that evaluates the partial derivatives of func. fprime_eqcons : callable ``f(x,*args)``, optional A function of the form ``f(x, *args)`` that returns the m by n array of equality constraint normals. If not provided, the normals will be approximated. The array returned by fprime_eqcons should be sized as ( len(eqcons), len(x0) ). fprime_ieqcons : callable ``f(x,*args)``, optional A function of the form ``f(x, *args)`` that returns the m by n array of inequality constraint normals. If not provided, the normals will be approximated. The array returned by fprime_ieqcons should be sized as ( len(ieqcons), len(x0) ). args : sequence, optional Additional arguments passed to func and fprime. iter : int, optional The maximum number of iterations. acc : float, optional Requested accuracy. iprint : int, optional The verbosity of fmin_slsqp : * iprint <= 0 : Silent operation * iprint == 1 : Print summary upon completion (default) * iprint >= 2 : Print status of each iterate and summary disp : int, optional Overrides the iprint interface (preferred). full_output : bool, optional If False, return only the minimizer of func (default). Otherwise, output final objective function and summary information. epsilon : float, optional The step size for finite-difference derivative estimates. callback : callable, optional Called after each iteration, as ``callback(x)``, where ``x`` is the current parameter vector. Returns ------- out : ndarray of float The final minimizer of func. fx : ndarray of float, if full_output is true The final value of the objective function. its : int, if full_output is true The number of iterations. imode : int, if full_output is true The exit mode from the optimizer (see below). smode : string, if full_output is true Message describing the exit mode from the optimizer. See also -------- minimize: Interface to minimization algorithms for multivariate functions. See the 'SLSQP' `method` in particular. Notes ----- Exit modes are defined as follows: - ``-1`` : Gradient evaluation required (g & a) - ``0`` : Optimization terminated successfully - ``1`` : Function evaluation required (f & c) - ``2`` : More equality constraints than independent variables - ``3`` : More than 3*n iterations in LSQ subproblem - ``4`` : Inequality constraints incompatible - ``5`` : Singular matrix E in LSQ subproblem - ``6`` : Singular matrix C in LSQ subproblem - ``7`` : Rank-deficient equality constraint subproblem HFTI - ``8`` : Positive directional derivative for linesearch - ``9`` : Iteration limit reached Examples -------- Examples are given :ref:`in the tutorial `. rmaxiterftoliprintdispepscallbackc34<"TF pRRRVRS/xK R#5i)typeeqfunrN.0crs& r fmin_slsqp..sI&Q64648&c34<"TF pRRRVRS/xK R#5i)r(ineqr*rNr+r,s& rr/r0sLGq665!VT:Gr1r(r)r*rrr3bounds constraintsrnitstatusmessager+)r tuple_minimize_slsqp)rx0eqconsf_eqconsieqcons f_ieqconsr4fprime fprime_eqconsfprime_ieqconsriteraccr#r$ full_outputrr&optsconsress&&&&&&&&&&f&&&&&&& rrrFsH` h0H t C f FaK 7   "D D EEI&IEEI&I IIDEELGLEELGL LLD &$x $ # # &&%E>$ # # $D 4f 4V 4&* 4.2 4C3xUSZXINN3xrFc aa a5a6\V4TpV o5V 'g^p\V4p\P!VP V4^VR7pVP pVP VPR4'd VPpVPVPVV4RP4pVe\V4^8Xd#\P)\P3o6M \V4o6\P!VS6^,S6^,4p\V\ 4'dV3pRRQRRQ/p\#V4FwppVR,P%4pVRR9d\'RVR, R24hR T9d\'R T R24hTP/R4pTfT5T TT63RlpT!TR ,4pTT;;,R TR ,RTRTP/RRQ4/3, uu&K RPR^R^R^R^R^R^R^R^R^R^ R/ p\1\3\VR,Uu.uF/p\P4!VR ,!V.VR,O5!4NK1 up44p\1\3\VR,Uu.uF/p\P4!VR ,!V.VR,O5!4NK1 up44pVV,p\V4pVe\V4^8Xdy\P6!V\8R7p \P6!V\8R7p!V P;\P<4V!P;\P<4EMV\P>!VU"U#u.uFwp"p#\AV"4\AV#43NK up#p"\84p$V$PB^,V8wd \ER4h\PF!RR 7;_uu_4V$RS,V$RT,8p%RRR4X%PI4'd&\'R!R"PKR#V%44 R$24hV$RS,PM4V$RT,PM4p!p \PN!V$4(p&\P<V V&RS,&\P<V!V&RT,&\QVVSW*S S6V R%7p'\SV'PTS64p(\SV'PVS64p)/R&VbR'R(bR)R(bR*R(bR+R(bR,R(bR-R(bR.R(bR/R(bR0R(bR1R2V,bR3^bR4^bR5^bR6^bR7\YV4bR8^bR9VR:VR;^R R?R@R> R?RARB R?RCRB 24\P\!\_V^V,,^,^4.\P`R7p+VV^,,^,^V,V,,V^V,,^,V,, ^ V,,^V,V,,^#V,,VV,,^,p,V^8XdV,^V,V^,,, p,\P\!\_V,^4\P R7p-V(!V4p.V)!V4p/\P\!\_^V^V,,^,4.\P R7p0\P\!\_^V4V.\P RDRE7p1\P\!\_^V4.\P R7p2\cV1VVVV4\eV2VVVV4^p3\gV*V.V/V1V2VV0V V!V-V+4 V*R;,^8Xd!V'PUV4p.\eV2VVVV4V*R;,RP8Xd!V'PWV4p/\cV1VVVV4V*R6,V38dtV e5\i\PL!V4V.RF7p4\kV V44'dM_V^8d5\[V*R6,RG R?V'PlRG R?V.RH R?\oV/4RH 24\qV*R;,4^8wdM V*R6,p3EKV^8dw\[VV*R;,,RIV*R;, RJ2,4\[RKV.4\[RLV*R6,4\[RMV'Pl4\[RNV'Pr4\iVV.V/V*R6,V'PlV'PrV*R;,VV*R;,,V*R;,^8HV0RVRO7 # \(dp\)R T R 24ThRp?i\*dp\+R 4ThRp?i\,dp\+R 4ThRp?ii;iuupiuupiuup#p"i +'giEL;i)Ua Minimize a scalar function of one or more variables using Sequential Least Squares Programming (SLSQP). Parameters ---------- ftol : float Precision target for the value of f in the stopping criterion. This value controls the final accuracy for checking various optimality conditions; gradient of the lagrangian and absolute sum of the constraint violations should be lower than ``ftol``. Similarly, computed step size and the objective function changes are checked against this value. Default is 1e-6. eps : float Step size used for numerical approximation of the Jacobian. disp : bool Set to True to print convergence messages. If False, `verbosity` is ignored and set to 0. maxiter : int, optional Maximum number of iterations. Default value is 100. finite_diff_rel_step : None or array_like, optional If ``jac in ['2-point', '3-point', 'cs']`` the relative step size to use for numerical approximation of `jac`. The absolute step size is computed as ``h = rel_step * sign(x) * max(1, abs(x))``, possibly adjusted to fit into the bounds. For ``method='3-point'`` the sign of `h` is ignored. If None (default) then step is selected automatically. workers : int, map-like callable, optional A map-like callable, such as `multiprocessing.Pool.map` for evaluating any numerical differentiation in parallel. This evaluation is carried out as ``workers(fun, iterable)``. .. versionadded:: 1.16.0 Returns ------- res : OptimizeResult The optimization result represented as an `OptimizeResult` object. In this dict-like object the following fields are of particular importance: ``x`` the solution array, ``success`` a Boolean flag indicating if the optimizer exited successfully, ``message`` which describes the reason for termination, and ``multipliers`` which contains the Karush-Kuhn-Tucker (KKT) multipliers for the QP approximation used in solving the original nonlinear problem. See ``Notes`` below. See also `OptimizeResult` for a description of other attributes. Notes ----- The KKT multipliers are returned in the ``OptimizeResult.multipliers`` attribute as a NumPy array. Denoting the dimension of the equality constraints with ``meq``, and of inequality constraints with ``mineq``, then the returned array slice ``m[:meq]`` contains the multipliers for the equality constraints, and the remaining ``m[meq:meq + mineq]`` contains the multipliers for the inequality constraints. The multipliers corresponding to bound inequalities are not returned. See [1]_ pp. 321 or [2]_ for an explanation of how to interpret these multipliers. The internal QP problem is solved using the methods given in [3]_ Chapter 25. Note that if new-style `NonlinearConstraint` or `LinearConstraint` were used, then ``minimize`` converts them first to old-style constraint dicts. It is possible for a single new-style constraint to simultaneously contain both inequality and equality constraints. This means that if there is mixing within a single constraint, then the returned list of multipliers will have a different length than the original new-style constraints. References ---------- .. [1] Nocedal, J., and S J Wright, 2006, "Numerical Optimization", Springer, New York. .. [2] Kraft, D., "A software package for sequential quadratic programming", 1988, Tech. Rep. DFVLR-FB 88-28, DLR German Aerospace Center, Germany. .. [3] Lawson, C. L., and R. J. Hanson, 1995, "Solving Least Squares Problems", SIAM, Philadelphia, PA. )ndimxpz real floatingNr)r3r(zUnknown constraint type 'z'.z Constraint z has no type defined.z/Constraints must be defined using a dictionary.z#Constraint's type must be a string.r*z has no function defined.rc<aVVVVV3RlpV#)c n<\VS4pSR9d\SVSVSSR7#\SVRSVSR7#)r)rrrel_stepr4)rrrr4)rz3-pointcs)r r )rrrfinite_diff_rel_stepr*r new_boundss&*rcjac3_minimize_slsqp..cjac_factory..cjacasT%a4A::0a$:N8B DD 1a :A8B DDrr+)r*rRrrPrrQsf r cjac_factory%_minimize_slsqp..cjac_factory`s D D rrz$Gradient evaluation required (g & a)z$Optimization terminated successfullyz$Function evaluation required (f & c)z4More equality constraints than independent variablesz*More than 3*n iterations in LSQ subproblemz#Inequality constraints incompatiblez#Singular matrix E in LSQ subproblemz#Singular matrix C in LSQ subproblemz2Rank-deficient equality constraint subproblem HFTIz.Positive directional derivative for linesearchzIteration limit reached)dtypezDSLSQP Error: the length of bounds is not compatible with that of x0.ignore)invalidzSLSQP Error: lb > ub in bounds z, c38"TFp\V4xK R#5i)N)str)r-bs& rr/"_minimize_slsqp..s)A&Q#a&&&s.)rrrrPr4workersrDalphagf0gsh1h2h3h4tt0tolg$@exact inconsistentresetrCitermaxlinemmeqmodenNITz>5 FCOBJFUNz>16GNORMF)rVorder)rr*5dz16.6Ez (Exit mode )z# Current function value:z Iterations:z! Function evaluations:z! Gradient evaluations:) rr*rr6nfevnjevr7r8success multipliersr+)r)r3)NNN)r):rrxpx atleast_ndasarrayfloat64isdtyperVreshapeastypelenrinfr clip isinstancedict enumeratelower ValueErrorKeyError TypeErrorAttributeErrorgetsummap atleast_1demptyfloatfillnanarrayrshape IndexErrorerrstateanyjoincopyisfiniterr r*gradintprintzerosmaxint32_eval_con_normals_eval_constraintrrrr{lanormabsngev)7rr;rrr4r5r!r"r#r$r%r&rPr^unknown_optionsrDrKrVrrGicconctypeerRrT exit_modesr.romieqrnrqxlxuloupbndsbnderrinfbndsf wrapped_fun wrapped_grad state_dictindices buffer_sizebufferfxgmultCd iter_previntermediate_resultrrQs7&&&f&&&&&&&&f&, @@rr:r:sZ ^?+ CG   B  2Q2 6B JJE zz"((O,, 299R',A~V)vvgrvv& %f-  :a=*Q-0A+t$$"o "fb !D[)C NK%%'EN* #!#$ %C s3V &$1qx'>AfI'>?$&' (D d A AA~V) XXau % XXau %  xx&,.&,(2r),nR.@A&,./46 ::a=A ;< <[[ * *$Z$t*,F+ ::<<> $ )A&)A AB!EF Fd"DJOO$5B++d##666$<666$< "$s7K)3W FB #266:6K#BGGZ8L. s c c  c  c  c c S c tCx     3wRRS-T T  3R8 'F);< 1277; 1277;   6 2rww&!:j6H+IF#q(tBQx M K[,ABC J 2*+01 2 JAB I Jd#&. + * *sZe&5f+5f05"f5 &f; f(e// f(<f(= f  f(f( f##f(; g c TV^8dQhR\R\R\R\R\/#)rrrGrnrorrr)formats"r __annotate__r9s/   G 4 C c rcV^8XdR#V^8dr^pVR,Fbp\P!VR,!V.VR,O5!4P4pWpWU\V4,%V\V4, pKd W48drTpVR,Fbp\P!VR,!V.VR,O5!4P4pWpWU\V4,%V\V4, pKd R#)rNr)r*rr3)rrravelr)rrrGrnrorowrtemps&&&&& rrr9sAv  Qw::C==UA!<F !<=CCED%)cD / " 3t9 C  w<rs  l +'77(:1-6 % 77288BJJ'++ ,D!#T2T"#6d8 Rj$&4 "fQU 4d [|  2 r