
    9i^]                        S r SS/rSSKrSSKJr  SSKJr  SSK	J
r
JrJrJrJr  SS	KJr  SS
KJrJr  SSKJr  SSKJr  SSKJr  Sr\R8                  " \R:                  " \R<                  5      R>                  5      r S r!SSSSSSSSSSSSSS\ S4S jr"SSSSSSSS\ SSS4S jr#S\S\S\$S\%S\%4
S jr&S\S\S\$S\%S\%4
S jr'g)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_slsqp    N   )slsqp)norm)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_extra)NDArrayzrestructuredtext enc                 F    [        XSUUS9n[        R                  " U5      $ )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)methodabs_stepargs)r   np
atleast_2d)xfuncepsilonr   jacs        X/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/scipy/optimize/_slsqp_py.pyr   r   #   s(    6 DI!%'C ==     d   gư>c                 2  ^
 Ub  UnUUUUS:g  UUS.nSnU[        U
4S jU 5       5      -  nU[        U
4S jU 5       5      -  nU(       a
  USX8T
S.4-  nU(       a
  USXYT
S.4-  n[        XT
4XvUS	.UD6nU(       a  US
   US   US   US   US   4$ US
   $ )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 <tutorial-sqlsp>`.

r   )maxiterftoliprintdispepscallbackr    c              3   0   >#    U  H  nS UTS.v   M     g7f)eqtypefunr   Nr    .0cr   s     r   	<genexpr>fmin_slsqp.<locals>.<genexpr>   s     I&Q448&   c              3   0   >#    U  H  nS UTS.v   M     g7f)ineqr+   Nr    r.   s     r   r1   r2      s     LGq6!T:Gr3   r*   )r,   r-   r   r   r5   )r   boundsconstraintsr   r-   nitstatusmessage)tuple_minimize_slsqp)r   x0eqconsf_eqconsieqcons	f_ieqconsr6   fprimefprime_eqconsfprime_ieqconsr   iteraccr%   r&   full_outputr   r(   optsconsress             `          r   r   r   E   s    ` aK "D D 	EI&IIIDELGLLLD $x  # 	#&  # 	# $D 4f&*4.24C3xUSZXINN3xr   Fc                   ^^^4^5 [        U5        UnU
m4U	(       d  Sn[        U5      n[        R                  " UR	                  U5      SUS9nUR
                  nUR                  UR                  S5      (       a  UR                  nUR                  UR                  UU5      S5      nUb  [        U5      S:X  a"  [        R                  * [        R                  4m5O[        U5      m5[        R                  " UT5S   T5S   5      n[        U[         5      (       a  U4nSSS.n[#        U5       H  u  nn US	   R%                  5       nUS;  a  ['        S
US	    S35      e SU;  a  ['        SU S35      eUR/                  S5      nUc  U4UUU54S jnU" US   5      nUU==   US   UUR/                  SS5      S.4-  ss'   M     SSSSSSSSSSS S!.n[1        [3        [        US"    Vs/ s H&  n[        R4                  " US   " U/US   Q76 5      PM(     sn5      5      n[1        [3        [        US#    Vs/ s H&  n[        R4                  " US   " U/US   Q76 5      PM(     sn5      5      nUU-   n[        U5      nUb  [        U5      S:X  ar  [        R6                  " U[8        S$9n [        R6                  " U[8        S$9n!U R;                  [        R<                  5        U!R;                  [        R<                  5        GOF[        R>                  " U V"V#s/ s H  u  n"n#[A        U"5      [A        U#5      4PM     sn#n"[8        5      n$U$RB                  S   U:w  a  [E        S%5      e[        RF                  " S&S'9   U$SS2S4   U$SS2S4   :  n%SSS5        W%RI                  5       (       a%  ['        S(S)RK                  S* U% 5       5       S+35      eU$SS2S4   RM                  5       U$SS2S4   RM                  5       n!n [        RN                  " U$5      ) n&[        R<                  U U&SS2S4   '   [        R<                  U!U&SS2S4   '   [Q        U UTX*TT5US,9n'[S        U'RT                  T55      n([S        U'RV                  T55      n)0 S-U_S.S/_S0S/_S1S/_S2S/_S3S/_S4S/_S5S/_S6S/_S7S/_S8S9U-  _S:S_S;S_S<S_S=S_S>[Y        U5      _S?S_UUSUS@.En*USA:  a  [[        SBSC SDSESC SDSFSG SDSHSG 35        [        R\                  " [_        USAU-  -   SA-   S5      /[        R`                  S$9n+UUS-   -  SA-  SIU-  U-  -   USJU-  -   SK-   U-  -
  SLU-  -   SMU-  U-  -   SNU-  -   UU-  -   SO-   n,US:X  a  U,SAU-  US-   -  -  n,[        R\                  " [_        U,S5      [        R
                  S$9n-U(" U5      n.U)" U5      n/[        R\                  " [_        SUSAU-  -   SA-   5      /[        R
                  S$9n0[        R\                  " [_        SU5      U/[        R
                  SPSQ9n1[        R\                  " [_        SU5      /[        R
                  S$9n2[c        U1UUUU5        [e        U2UUUU5        Sn3 [g        U*U.U/U1U2UU0U U!U-U+5        U*SR   S:X  a   U'RU                  U5      n.[e        U2UUUU5        U*SR   S:X  a   U'RW                  U5      n/[c        U1UUUU5        U*S=   U3:  aU  Ub  U" [        RL                  " U5      5        USA:  a0  [[        U*S=   SS SDU'Rh                  SS SDU.ST SD[k        U/5      ST 35        [m        U*SR   5      S:w  a  OU*S=   n3M  US:  ab  [[        UU*SR      SUU*SR    SV3-   5        [[        SWU.5        [[        SXU*S=   5        [[        SYU'Rh                  5        [[        SZU'Rn                  5        [q        UU.U/U*S=   U'Rh                  U'Rn                  U*SR   UU*SR      U*SR   S:H  U0SU S[9
$ ! [(         a  n[)        SU S35      UeSnAf[*         a  n[+        S5      UeSnAf[,         a  n[+        S5      UeSnAff = fs  snf s  snf s  sn#n"f ! , (       d  f       GN= f)\a  
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.

r   r   )ndimxpzreal floatingNr    )r*   r5   r,   zUnknown 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.r   c                    >^  UUU UU4S jnU$ )Nc           	      `   > [        U T5      n TS;   a  [        TU TUTTS9$ [        TU STUTS9$ )N)r   z3-pointcs)r   r   rel_stepr6   r   )r   r   r   r6   )r   r   )r   r   r   finite_diff_rel_stepr-   r   
new_boundss     r   cjac3_minimize_slsqp.<locals>.cjac_factory.<locals>.cjac]  sT    %a4A::0a$:N8B D D  1a	:A8B D Dr   r    )r-   rU   r   rS   r   rT   s   ` r   cjac_factory%_minimize_slsqp.<locals>.cjac_factory\  s    
D 
D r   r   )r-   r   r   z$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 linesearchzIteration limit reached)rN   r   r                        	   r*   r5   )dtypezDSLSQP Error: the length of bounds is not compatible with that of x0.ignore)invalidzSLSQP Error: lb > ub in bounds z, c              3   8   #    U  H  n[        U5      v   M     g 7f)N)str)r/   bs     r   r1   "_minimize_slsqp.<locals>.<genexpr>  s     )A&Q#a&&&s   .)r   r   r   rS   r6   workersrF   alphag        f0gsh1h2h3h4tt0tolg      $@exactinconsistentresetrE   itermaxline)mmeqmodenrY   NITz>5 FCOBJFUNz>16GNORMrZ   r\   r^   r`   r_   #      F)ra   orderr{   5dz16.6Ez    (Exit mode )z#            Current function value:z            Iterations:z!            Function evaluations:z!            Gradient evaluations:)
r   r-   r   r8   nfevnjevr9   r:   successmultipliers)9r	   r   xpx
atleast_ndasarrayfloat64isdtypera   reshapeastypelenr   infr   clip
isinstancedict	enumeratelower
ValueErrorKeyError	TypeErrorAttributeErrorgetsummap
atleast_1demptyfloatfillnanarrayr   shape
IndexErrorerrstateanyjoincopyisfiniter
   r   r-   gradintprintzerosmaxint32_eval_con_normals_eval_constraintr   r   lanormabsngevr   )6r   r=   r   r   r6   r7   r#   r$   r%   r&   r'   r(   rS   ri   unknown_optionsrF   rM   ra   r   rI   icconctypeerU   rW   
exit_modesr0   rz   mieqry   r|   xlxuloupbndsbnderrinfbndsfwrapped_funwrapped_grad
state_dictindicesbuffer_sizebufferfxgmultCd	iter_prevr   rT   s6      `        `                                       @@r   r<   r<      s"	   ^ ?+
CG 
	B	

2Q2	6BJJE	zz"((O,,


299R',A ~V)vvgrvv&
%f-
 	:a=*Q-0A +t$$"ob!D[)C	NK%%'E N* #<S[M!LMM + {2$.GHII wwu~<   E
+D 	UE
 $!$!46 9 	9S *Z =<<LB;;;JF/
1J c#Dz#!! ahq&=1V9&=>!# $ %Cs3V&$1 qx'>AfI'>?$& ' (D 	d
AAA ~V)XXau%XXau%

xx&,.&,(2r ),nR.@A&,./46::a=A ; < < [[*!Q$Z$q!t*,F + ::<<> $		)A&)A AB!E F Fad"DAJOO$5B ++d##666!Q$<666!Q$< 
"$s7K)3W
FB
 #266:6K#BGGZ8L.s 	c 	c	
 	c 	c 	c 	c 	S 	c 	tCx 	 	 	 	  	3w<!" 	#$ +J2 {r
!D9Ahs^1WSMBC hhA!GaK+,BHH=G 	
1Q3
QqSUa!A#gk3..14qs1u<r!tCc#gMPRR 
 qyqsAE{"XXc+q)<F
 
QBQA 88SA!GaK()<D 	#a)Qrzz=A
#a)BJJ/AaD!S)Q4C(I
j"aAq$BHf"BQ4C0f#
AaD!S1f	)#$ {F+B/qAE
!F1Ie#46 7 z&!"a'v&	5 : {z&)*z&?Q>RRS-TT	
 	3R8'F);<1277;1277;

6 2rww&!:j6H+IF#q(tBQx C  	K[,ABCJ 	2 * +012 	JABI	Jd#&. +*sN   4_.*-a8-a#a
;a.
`?8``?`!!`?.`::`?
a!r   r   rI   ry   rz   c                    US:X  a  g US:  a\  SnUS    HQ  n[         R                  " US   " U/US   Q76 5      R                  5       nXpXU[        U5      -   & U[        U5      -  nMS     X4:  a\  UnUS    HQ  n[         R                  " US   " U/US   Q76 5      R                  5       nXpXU[        U5      -   & U[        U5      -  nMS     g )Nr   r*   r-   r   r5   )r   r   ravelr   )r   r   rI   ry   rz   rowr   temps           r   r   r   0  s    Av Qw:C==UA!<F!<=CCED%)cD	/"3t9C 
 	w<C==UA!<F!<=CCED%)cD	/"3t9C  
 r   r   c                    US:X  a  g US:  a[  SnUS    HP  n[         R                  " US   " U/US   Q76 5      nXpXUUR                  S   -   2S S 24'   XWR                  S   -  nMR     X4:  a[  UnUS    HP  n[         R                  " US   " U/US   Q76 5      nXpXUUR                  S   -   2S S 24'   XWR                  S   -  nMR     g )Nr   r*   r   r   r5   )r   r   r   )r   r   rI   ry   rz   r   r   r   s           r   r   r   I  s    Av
Qw:C==UA!<F!<=D,0c

1%%q()::a= C 
 	w<C==UA!<F!<=D,0c

1%%q()::a= C  
 r   )(__doc____all__numpyr   	_slsqplibr   scipy.linalgr   r   	_optimizer   r	   r
   r   r   _numdiffr   _constraintsr   r   scipy._lib._array_apir   
scipy._libr   r   numpy.typingr   __docformat__sqrtfinfor   r'   _epsilonr   r   r<   r   r   r   r   r    r   r   <module>r      s
   l
+   '' ' ( : 1 -  %77288BJJ'++,D !#T2T"#6d8	Od $&4 "fQU 4d 	Vr
 G 4 C c 2 W D S s r   