(phoYSrSSKrSSKJr SSKJrJrJr SSK J r SSK J r J r JrJr SSKJr S r"S S 5r"S S 5r"SS5r"SS5rSrSrSrSrSrg)z$Constraints definition for minimize.N)BFGS)VectorFunctionLinearVectorFunctionIdentityVectorFunction)OptimizeWarning)warncatch_warnings simplefilterfilterwarnings)issparsecd[U[R5(aUR5$U$N) isinstancenpndarrayitem)xs N/var/www/html/venv/lib/python3.13/site-packages/scipy/optimize/_constraints.py_arr_to_scalarr s%"!RZZ0016687a7c(\rSrSrSrSSjrSrg)NonlinearConstraintaNonlinear constraint on the variables. The constraint has the general inequality form:: lb <= fun(x) <= ub Here the vector of independent variables x is passed as ndarray of shape (n,) and ``fun`` returns a vector with m components. It is possible to use equal bounds to represent an equality constraint or infinite bounds to represent a one-sided constraint. Parameters ---------- fun : callable The function defining the constraint. The signature is ``fun(x) -> array_like, shape (m,)``. lb, ub : array_like Lower and upper bounds on the constraint. Each array must have the shape (m,) or be a scalar, in the latter case a bound will be the same for all components of the constraint. Use ``np.inf`` with an appropriate sign to specify a one-sided constraint. Set components of `lb` and `ub` equal to represent an equality constraint. Note that you can mix constraints of different types: interval, one-sided or equality, by setting different components of `lb` and `ub` as necessary. jac : {callable, '2-point', '3-point', 'cs'}, optional Method of computing the Jacobian matrix (an m-by-n matrix, where element (i, j) is the partial derivative of f[i] with respect to x[j]). The keywords {'2-point', '3-point', 'cs'} select a finite difference scheme for the numerical estimation. A callable must have the following signature:: jac(x) -> {ndarray, sparse matrix}, shape (m, n) Default is '2-point'. hess : {callable, '2-point', '3-point', 'cs', HessianUpdateStrategy, None}, optional Method for computing the Hessian matrix. The keywords {'2-point', '3-point', 'cs'} select a finite difference scheme for numerical estimation. Alternatively, objects implementing `HessianUpdateStrategy` interface can be used to approximate the Hessian. Currently available implementations are: - `BFGS` (default option) - `SR1` A callable must return the Hessian matrix of ``dot(fun, v)`` and must have the following signature: ``hess(x, v) -> {LinearOperator, sparse matrix, array_like}, shape (n, n)``. Here ``v`` is ndarray with shape (m,) containing Lagrange multipliers. keep_feasible : array_like of bool, optional Whether to keep the constraint components feasible throughout iterations. A single value set this property for all components. Default is False. Has no effect for equality constraints. finite_diff_rel_step: None or array_like, optional Relative step size for the finite difference approximation. Default is None, which will select a reasonable value automatically depending on a finite difference scheme. finite_diff_jac_sparsity: {None, array_like, sparse matrix}, optional Defines the sparsity structure of the Jacobian matrix for finite difference estimation, its shape must be (m, n). If the Jacobian has only few non-zero elements in *each* row, providing the sparsity structure will greatly speed up the computations. A zero entry means that a corresponding element in the Jacobian is identically zero. If provided, forces the use of 'lsmr' trust-region solver. If None (default) then dense differencing will be used. Notes ----- Finite difference schemes {'2-point', '3-point', 'cs'} may be used for approximating either the Jacobian or the Hessian. We, however, do not allow its use for approximating both simultaneously. Hence whenever the Jacobian is estimated via finite-differences, we require the Hessian to be estimated using one of the quasi-Newton strategies. The scheme 'cs' is potentially the most accurate, but requires the function to correctly handles complex inputs and be analytically continuable to the complex plane. The scheme '3-point' is more accurate than '2-point' but requires twice as many operations. Examples -------- Constrain ``x[0] < sin(x[1]) + 1.9`` >>> from scipy.optimize import NonlinearConstraint >>> import numpy as np >>> con = lambda x: x[0] - np.sin(x[1]) >>> nlc = NonlinearConstraint(con, -np.inf, 1.9) Nc ~Uc [5nXlX lX0lXplXlX@lXPlX`lgr) rfunlbubfinite_diff_rel_stepfinite_diff_jac_sparsityjachess keep_feasible) selfrrrr!r"r#rr s r__init__NonlinearConstraint.__init__ls; <6D$8!(@% *r)r rrr"r!r#rr)2-pointNFNN)__name__ __module__ __qualname____firstlineno____doc__r%__static_attributes__rrrrsYt9=;?*. +rrc^\rSrSrSrSr\R*\RS4SjrSr Sr g) LinearConstraint{a&Linear constraint on the variables. The constraint has the general inequality form:: lb <= A.dot(x) <= ub Here the vector of independent variables x is passed as ndarray of shape (n,) and the matrix A has shape (m, n). It is possible to use equal bounds to represent an equality constraint or infinite bounds to represent a one-sided constraint. Parameters ---------- A : {array_like, sparse matrix}, shape (m, n) Matrix defining the constraint. lb, ub : dense array_like, optional Lower and upper limits on the constraint. Each array must have the shape (m,) or be a scalar, in the latter case a bound will be the same for all components of the constraint. Use ``np.inf`` with an appropriate sign to specify a one-sided constraint. Set components of `lb` and `ub` equal to represent an equality constraint. Note that you can mix constraints of different types: interval, one-sided or equality, by setting different components of `lb` and `ub` as necessary. Defaults to ``lb = -np.inf`` and ``ub = np.inf`` (no limits). keep_feasible : dense array_like of bool, optional Whether to keep the constraint components feasible throughout iterations. A single value set this property for all components. Default is False. Has no effect for equality constraints. cURRS:wa Sn[U5eURRSSn[R "UR U5Ul[R "URU5Ul[R "URU5Ulg![a Sn[U5ef=f)Nz%`A` must have exactly two dimensions.rrzM`lb`, `ub`, and `keep_feasible` must be broadcastable to shape `A.shape[0:1]`) Andim ValueErrorshaper broadcast_torrr#)r$messager7s r_input_validation"LinearConstraint._input_validations 66;;! =GW% % &FFLL1%Eoodggu5DGoodggu5DG!#1C1CU!KD  &1GW% % &s B B55C Fc[U5(dW[5 [S5 [R"U5R [R 5UlSSS5 OXl[U5(d[U5(a [S5e[R"U5R [R 5Ul [R"U5R [R 5Ul [U5(a [S5e[R"U5R [5Ul UR5 g!,(df  GN=f)Nerrorz'Constraint limits must be dense arrays.&`keep_feasible` must be a dense array.)r r r r atleast_2dastypefloat64r4r6 atleast_1drrboolr#r:)r$r4rrr#s rr%LinearConstraint.__init__s{{  !W%q)00<"!F B<<8B<<FG G--#**2::6--#**2::6 M " "EF F]]=9@@F  "!s AE## E2crURU-UR- URURU-- 4$)aq Calculate the residual between the constraint function and the limits For a linear constraint of the form:: lb <= A@x <= ub the lower and upper residuals between ``A@x`` and the limits are values ``sl`` and ``sb`` such that:: lb + sl == A@x == ub - sb When all elements of ``sl`` and ``sb`` are positive, all elements of the constraint are satisfied; a negative element in ``sl`` or ``sb`` indicates that the corresponding element of the constraint is not satisfied. Parameters ---------- x: array_like Vector of independent variables Returns ------- sl, sb : array-like The lower and upper residuals )r4rrr$rs rresidualLinearConstraint.residuals18vvax$''!477TVVAX#555r)r4r#rrN) r(r)r*r+r,r:rinfr%rGr-r.rrr0r0{s)> &!ffWu!,6rr0cd\rSrSrSrSr\R*\RS4SjrSr Sr Sr g ) Boundsa Bounds constraint on the variables. The constraint has the general inequality form:: lb <= x <= ub It is possible to use equal bounds to represent an equality constraint or infinite bounds to represent a one-sided constraint. Parameters ---------- lb, ub : dense array_like, optional Lower and upper bounds on independent variables. `lb`, `ub`, and `keep_feasible` must be the same shape or broadcastable. Set components of `lb` and `ub` equal to fix a variable. Use ``np.inf`` with an appropriate sign to disable bounds on all or some variables. Note that you can mix constraints of different types: interval, one-sided or equality, by setting different components of `lb` and `ub` as necessary. Defaults to ``lb = -np.inf`` and ``ub = np.inf`` (no bounds). keep_feasible : dense array_like of bool, optional Whether to keep the constraint components feasible throughout iterations. Must be broadcastable with `lb` and `ub`. Default is False. Has no effect for equality constraints. c[R"URURUR5nUuUlUlUlg![ a Sn[ U5ef=f)Nz6`lb`, `ub`, and `keep_feasible` must be broadcastable.)rbroadcast_arraysrrr#r6)r$resr9s rr:Bounds._input_validations[ &%%dggtww8J8JKC36 0DGTWd0 &NGW% % &s A AA&Fcx[U5(d[U5(a [S5e[R"U5Ul[R"U5Ul[U5(a [S5e[R"U5R [5UlUR5 g)Nz,Lower and upper bounds must be dense arrays.r>) r r6rrBrrr@rCr#r:)r$rrr#s rr%Bounds.__init__s~ B<<8B<<KL L--#--# M " "EF F]]=9@@F  rc[U5RSUR<SUR<3n[R "UR 5(aSUR <S3nX-$SnX-$)N(z, z, keep_feasible=))typer(rrranyr#)r$startends r__repr__Bounds.__repr__ sn:&&'q 2dgg[A 66$$$ % %$T%7%7$:![R"TU5$r)rdotrr4s rr"new_constraint_to_old..funs66!Q< rc>T$rr.rs rr!"new_constraint_to_old..jacsHrzSAt least one constraint is unbounded above and below. Such constraints are ignored.cn>[R"T"U55R5nUTTT- $r)rr~flatten)ryri_eqrs rf_eq#new_constraint_to_old..f_eqs1Q ((*AT7RX% %req)rVrc>T"U5n[U5(aUR5n[R"U5nUTSS24$r)r toarrayrr?)rdyrr!s rj_eq#new_constraint_to_old..j_eqs<VB<<B]]2&$'{"rrr!c>[R"TT-5n[R"T"U55R5nUTTT- UST&UTT T- *UTS&U$r)rzerosr~r) rry_allr i_bound_above i_bound_belowr n_bound_above n_bound_belowrs rf_ineq%new_constraint_to_old..f_ineq so67AHHSV$,,.E %m 4r-7H HAn} "' "6M9J"J KAmn Hrineqc>[R"TT-[T545nT"U5n[U5(aUR 5n[R "U5nUTUST2SS24'UT*UTS2SS24'U$r)rrlenr rr?) rrdy_allrrr!rrrhs rj_ineq%new_constraint_to_old..j_ineqsXX}}M>1$%)/ )>(>=>1$% rrzEquality and inequality constraints are specified in the same element of the constraint list. For efficient use with this method, equality and inequality constraints should be specified in separate elements of the constraint list. )rrr rr"rr#r rrcallabler!rrWr4r rr_rf logical_xorrI logical_andsumr)conrhpcon i_unboundedceqrrcineqrrold_constraintsr4rrrrr!rrrrs ` @@@@@@@@@@rnew_constraint_to_oldrs8#*++  ( ( 4((4sxx..!! /!Q 0 gg CGG  ''CC 66### $ $ O Q 0 EE A;; A   c2 &D [[FB 8DNN2"&&=$7MNN2<6M..wbff =K vvk (  , C vvd|| &T*+ ? # !F5M EFF=)MFF=)M}$   !01 ?  %!HUOkO ?a =  , rc^^TSR5nUS;a[STSS35eS T;a[S U-5eS nUS :XaS nO[ R nS nST;aTSmUU4SjnST;aUU4SjnOTS nST;aTSn[XtXV5$![an[SU-5UeSnAf[an[S5UeSnAf[an[S5UeSnAff=f)zM Converts old-style constraint dictionaries to new-style constraint objects. rV)rrzUnknown constraint type 'z'.z"Constraint %d has no type defined.Nz/Constraints must be a sequence of dictionaries.z#Constraint's type must be a string.rz&Constraint %d has no function defined.rrr'argsc>TS"U/TQ76$)Nrr.rrrs rr"old_constraint_to_new..funHsu:a'$' 'rr!c>TS"U/TQ76$)Nr!r.rs rr!"old_constraint_to_new..jacKs5z!+d++r)lowerr6KeyError TypeErrorAttributeErrorrrIr) icrctypeerrr!rrs ` @rold_constraint_to_newr*s# JF !!#  &8V RHI I ' CABFGG B }  VV C }6{ ( C< ,%j C<e*C s 00C I;b@AqH  =   F=>AEFs/B C-'B66 C- C C- C((C-)r,numpyr_hessian_update_strategyr_differentiable_functionsrrr _optimizerwarningsr r r r scipy.sparser rrr0rKr_r|rrrrr.rrrsz**BB&GG!8 g+g+Ta6a6HO(O(db%b%J$* `F(1r