o ֭jzJ@sdZddgZddlZddlmZddlmZmZmZm Z m Z m Z m Z m Z mZmZddlmZmZmZmZmZdd lmZdd lmZmZdd lmZdd lmZd Z e e e!j"Z#ddZ$dddddddddddddde#dfddZ%dddddddde#ddf ddZ&ddZ'ddZ(dS)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) zerosarraylinalgappend concatenatefinfosqrtvstackisfinite atleast_1d)OptimizeResult_check_unknown_options_prepare_scalar_function_clip_x_for_func _check_clip_x)approx_derivative)old_bound_to_new_arr_to_scalar)array_namespace)array_api_extrazrestructuredtext encGst||d||d}t|S)a 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)rnp atleast_2d)xfuncepsilonrjacr$U/var/www/html/CropPilot/venv/lib/python3.10/site-packages/scipy/optimize/_slsqp_py.pyr$s  r$dgư>cs|dur|} | | | | dk||d}d}|tfdd|D7}|tfdd|D7}|r9|d||d f7}|rE|d || d f7}t||f|||d |}|rf|d |d |d|d|dfS|d S)aC 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 `. Nr)maxiterftoliprintdispepscallbackr$c3|] }d|dVqdS)eqtypefunrNr$.0crr$r% zfmin_slsqp..c3r-)ineqr/Nr$r2r5r$r%r6r7r.)r0r1r#rr8)r#bounds constraintsr r1nitstatusmessage)tuple_minimize_slsqp)r!x0eqconsf_eqconsieqcons f_ieqconsr9fprime fprime_eqconsfprime_ieqconsriteraccr)r* full_outputr"r,optsconsresr$r5r%rFs8p  "Fc E sXt| |d}|}| | sd}t|}tj||d|d}|j}||jdr,|j}|| ||d|dus@t |dkrHt j t j fnt |t ddt|tr_|f}ddd}t|D]\}}z|d }Wn3ty}ztd ||d}~wty}ztd |d}~wty}ztd |d}~ww|dvrtd |d dd|vrtd||d}|dur؇fdd}||d}|||d||dddf7<qhddddddddddd d! }ttt fd"d#|d$D}ttt fd%d#|d&D}||}td|g}t }|d}||||} d'|||d||d| d(d(| || ||d(|||d|d(d(|d'|d'|d}!| }"t|!}#t|"}$|dust |dkrt j|td)}%t j|td)}&|%t j |&t j n~td*d#|Dt}'|'j!d|krt"d+t j#d,d-|'dddf|'dddfk}(Wdn 1swY|($rtd.d/%d0d1|(Dd2|'dddf|'dddf}%}&t&|'})t j |%|)dddf<t j |&|)dddf<t'||| d3}*t(|*j)}+t(|*j*},tdt+}-t|t}t|t+}.d}/tdt}0tdt}1tdt}2tdt}3tdt}4tdt}5tdt}6tdt}7tdt}8tdt}9tdt+}:tdt+};tdt+}tdt+}tdt+}?tdt+}@|d(krt,d4d5|+}At-|,d6}Bt.|}Ct/||||||}D t0g|||%|&|A|C|B|D||.|-|#|$|0|1|2|3|4|5|6|7|8|9|:|;|<|=|>||?|@R|-dkr|+}At.|}C|-dkr2t-|,d6}Bt/||||||}D|.|/krV| durC| t 1|d(krVt,d7|.|*j2|At34|Bft5|-dkr^nt+|.}/q|dkrt,|t+|-d8t6|-d9t,d:|At,d;|.t,d<|*j2t,d=|*j7t8|A|Bddt+|.|*j2|*j7t+|-|t+|-|-dkd> S)?a Minimize a scalar function of one or more variables using Sequential Least Squares Programming (SLSQP). Options ------- ftol : float Precision goal for the value of f in the stopping criterion. 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 Maximum number of iterations. 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. rr)ndimxpz real floatingNr$)r.r8r0z"Constraint %d has no type defined.z/Constraints must be defined using a dictionary.z#Constraint's type must be a string.zUnknown constraint type 'z'.r1z&Constraint %d has no function defined.r#csfdd}|S)Ncs:t|}dvrt||dSt|d|dS)N)rz3-pointcs)rrrel_stepr9r)rrrr9)rr)r r)r"finite_diff_rel_stepr1r# new_boundsr$r%cjac,s  z3_minimize_slsqp..cjac_factory..cjacr$)r1rU)r"rSr#rT)r1r% cjac_factory+s z%_minimize_slsqp..cjac_factoryr)r1r#rz$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) rPrr c(g|]}t|dg|dRqSr1rrr2r r$r% N z#_minimize_slsqp..r.cr_r`rar2rbr$r%rcPrdr8rXrW)dtypecSs g|] \}}t|t|fqSr$)r)r3lur$r$r%rciszDSLSQP Error: the length of bounds is not compatible with that of x0.ignore)invalidzSLSQP Error: lb > ub in bounds z, css|]}t|VqdS)N)str)r3br$r$r%r6tsz"_minimize_slsqp...)r#rr"rSr9z%5s %5s %16s %16s)NITFCOBJFUNGNORMgz%5i %5i % 16.6E % 16.6Ez (Exit mode )z# Current function value:z Iterations:z! Function evaluations:z! Gradient evaluations:) r r1r#r;nfevnjevr<r=success)9rrxpx atleast_ndasarrayfloat64isdtyperereshapeastypelenrinfrclip isinstancedict enumeratelowerKeyError TypeErrorAttributeError ValueErrorgetsummaprmaxremptyfloatfillnanshape IndexErrorerrstateanyjoinr rrr1gradintprintr_eval_constraint_eval_con_normalsrcopyrrrnormabsrjngevr)Er!r@rr#r9r:r'r(r)r*r+r,rSunknown_optionsrHrIrOrerLicconctypeerUrV exit_modesmeqmieqmlann1mineqlen_wlen_jwwjwxlxubndsbnderrinfbndsf wrapped_fun wrapped_gradmodemajiter majiter_prevalphaf0gsh1h2h3h4tt0toliexactinconsiresetitermxlinen2n3fxgr4ar$)r"rSr#rTr r%r?s         > "  "                            <             r?csh|drtfdd|dD}ntd}|dr(tfdd|dD}ntd}t||f}|S)Nr.cr_r`rar3rrbr$r%rcrdz$_eval_constraint..rr8cr_r`rarrbr$r%rcrd)r r)r rLc_eqc_ieqr4r$rbr%rs     rc s|drtfdd|dD}nt||f}|dr*tfdd|dD}nt||f}|dkr;t||f} nt||f} t| t|dgfd} | S)Nr.c$g|]}|dg|dRqSr#rr$rrbr$r%rcz%_eval_con_normals..r8crrr$rrbr$r%rcrrr)r rr ) r rLrrrrra_eqa_ieqrr$rbr%rs     r))__doc____all__numpyrscipy.optimize._slsqprrrrrr r r r r r _optimizerrrrr_numdiffr _constraintsrrscipy._lib._array_apir scipy._librru __docformat__rr+_epsilonrrr?rrr$r$r$r%s: 0   "