a hJ@s dZddgZddlZddlmZddlmZmZmZm Z m Z m Z m Z m Z mZmZddlmZmZmZmZmZdd lmZdd lmZmZdd lmZmZdd lmZmZd 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) atleast_ndarray_namespace)expinfzrestructuredtext 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)rnpZ atleast_2d)xfuncepsilonrjacr%T/var/www/html/assistant/venv/lib/python3.9/site-packages/scipy/optimize/_slsqp_py.pyr&s r%dgư>cs|dur |} | | | | dk||d}d}|tfdd|D7}|tfdd|D7}|rr|d||d f7}|r|d || d f7}t||f|||d |}|r|d |d |d|d|dfS|d SdS)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 `. Nr)maxiterftoliprintdispepscallbackr%c3s|]}d|dVqdS)eqtypefunrNr%.0crr%r& zfmin_slsqp..c3s|]}d|dVqdS)ineqr/Nr%r2r5r%r&r6r7r.)r0r1r$rr8)r$bounds constraintsr!r1nitstatusmessage)tuple_minimize_slsqp)r"x0ZeqconsZf_eqconsZieqconsZ f_ieqconsr9ZfprimeZ fprime_eqconsZfprime_ieqconsriteraccr*r+Z full_outputr#r-optsconsresr%r5r&rHs8p  "Fc E! s6t| |d}|}| | s d}t|}t|d|d}|j}||jdrP|j}||||d|dusxt|dkrt j t j fnt |t ddt |tr|f}ddd}t|D]2\}}z|d }Wnty}ztd ||WYd}~nd}~0tyD}ztd |WYd}~nRd}~0tyr}ztd |WYd}~n$d}~00|dvrtd |d d|vrtd||d}|durևfdd}||d}|||d||dddf7<qdddddddddddd }tttfd!d"|d#D}tttfd$d"|d%D}||}td|g}t}|d}||||} d&|||d||d| d'd'| || ||d'|||d|d'd'|d&|d&|d}!| }"t|!}#t|"}$|dus6t|dkrlt j|td(}%t j|td(}&|%t j|&t jntd)d"|Dt}'|'jd|krt d*t j!d+d,0|'dddf|'dddfk}(Wdn1s0Y|("r td-d.#d/d0|(D|'dddf|'dddf}%}&t$|'})t j|%|)dddf<t j|&|)dddf<t%||| d1}*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'kr~t*d2d3|+}At+|,d4}Bt,|}Ct-||||||}Dt.|||%|&|A|C|B|D||.|-|#|$|0|1|2|3|4|5|6|7|8|9|:|;|<|=|>||?|@ |-dkr|+}At,|}C|-dkr@t+|,d4}Bt-||||||}D|.|/kr| durb| t /|d'krt*d5|.|*j0|At12|Bft3|-dkrqt)|.}/q|dkrt*|t)|-d6t4|-d7t*d8|At*d9|.t*d:|*j0t*d;|*j5t6|A|Bddt)|.|*j0|*j5t)|-|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 '%s'.r1z&Constraint %d has no function defined.r$csfdd}|S)Ncs>t|}dvr&t||dSt|d|dSdS)N)rz3-pointcs)rrZrel_stepr9r)rrrr9)rr)r!r)r#finite_diff_rel_stepr1r$ new_boundsr%r&cjac.s  z3_minimize_slsqp..cjac_factory..cjacr%)r1rL)r#rJr$rK)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) rHrr cs(g|] }t|dg|dRqSr1rrr2r!r%r& Psz#_minimize_slsqp..r.cs(g|] }t|dg|dRqSrVrWr2rXr%r&rYRsr8rOrN)dtypecSs g|]\}}t|t|fqSr%)r)r3lur%r%r&rYkszDSLSQP Error: the length of bounds is not compatible with that of x0.ignore)invalidz"SLSQP Error: lb > ub in bounds %s.z, css|]}t|VqdS)N)str)r3br%r%r&r6vr7z"_minimize_slsqp..)r$rr#rJr9z%5s %5s %16s %16s)ZNITZFCZOBJFUNZGNORMgz%5i %5i % 16.6E % 16.6Ez (Exit mode )z# Current function value:z Iterations:z! Function evaluations:z! Gradient evaluations:) r!r1r$r;nfevZnjevr<r=success)7rrrZfloat64ZisdtyperZZreshapeZastypelenr rrZclip isinstancedict enumeratelowerKeyError TypeErrorAttributeError ValueErrorgetsummaprmaxremptyfloatfillnanshape IndexErrorZerrstateanyjoinr rrr1Zgradintprintr_eval_constraint_eval_con_normalsrcopyrbrZnormabsr_Zngevr)Er"r@rr$r9r:r(r)r*r+r,r-rJZunknown_optionsrArBrGrZrDZicconctypeerLrMZ exit_modesmeqmieqmlanZn1ZmineqZlen_wZlen_jwwZjwZxlZxuZbndsZbnderrZinfbndZsfZ wrapped_funZ wrapped_gradmodeZmajiterZ majiter_prevalphaZf0gsZh1Zh2Zh3Zh4tt0ZtolZiexactZinconsZiresetZitermxlineZn2Zn3Zfxgr4ar%)r#rJr$rKr!r&r?sT  "          > @ "                                            r?csh|dr$tfdd|dD}ntd}|drPtfdd|dD}ntd}t||f}|S)Nr.cs(g|] }t|dg|dRqSrVrWr3rrXr%r&rYsz$_eval_constraint..rr8cs(g|] }t|dg|dRqSrVrWrrXr%r&rYs)r r)r!rDZc_eqZc_ieqr4r%rXr&r{s     r{c s|dr$tfdd|dD}n t||f}|drTtfdd|dD}n t||f}|dkrvt||f} n t||f} t| t|dgfd} | S)Nr.cs$g|]}|dg|dRqSr$rr%rrXr%r&rYsz%_eval_con_normals..r8cs$g|]}|dg|dRqSrr%rrXr%r&rYsrr)r rr ) r!rDrrrrrZa_eqZa_ieqrr%rXr&r|s       r|))__doc____all__numpyr Zscipy.optimize._slsqprrrrrr r r r r r _optimizerrrrrZ_numdiffr _constraintsrrZscipy._lib._array_apirrrr __docformat__rrr,Z_epsilonrrr?r{r|r%r%r%r&s8 0 "