U Ä@·fVã@sÐdZddlZddlmZddlmZmZmZddl m Z ddl m Z m Z mZddlmZdd lmZd d „ZGd d „d ƒZGdd„dƒZGdd„dƒZGdd„dƒZdd„Zdd„Zdd„Zdd„Zdd„ZdS)z$Constraints definition for minimize.éNé)ÚBFGS)ÚVectorFunctionÚLinearVectorFunctionÚIdentityVectorFunction)ÚOptimizeWarning)ÚwarnÚcatch_warningsÚ simplefilter)Úsuppress_warnings)ÚissparsecCst|tjƒr| ¡S|S©N)Ú isinstanceÚnpZndarrayÚitem©Úx©rú?/tmp/pip-unpacked-wheel-w7avvj8p/scipy/optimize/_constraints.pyÚ_arr_to_scalar src@s&eZdZdZdeƒdddfdd„ZdS)Ú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) ú2-pointFNc Cs4||_||_||_||_||_||_||_||_dSr )ÚfunÚlbÚubÚfinite_diff_rel_stepÚfinite_diff_jac_sparsityÚjacÚhessÚ keep_feasible) ÚselfrrrrrrrrrrrÚ__init__kszNonlinearConstraint.__init__)Ú__name__Ú __module__Ú __qualname__Ú__doc__rr!rrrrrs Xþrc@s6eZdZdZdd„Zej ejdfdd„Zdd„Zd S) ÚLinearConstrainta~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 : 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 : 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. cCs‚|jjdkrd}t|ƒ‚zD|jjdd…}t |j|¡|_t |j|¡|_t |j|¡|_Wn tk r|d}t|ƒ‚YnXdS)Néz%`A` must have exactly two dimensions.rrzM`lb`, `ub`, and `keep_feasible` must be broadcastable to shape `A.shape[0:1]`) ÚAÚndimÚ ValueErrorÚshaperÚ broadcast_torrr)r Úmessager+rrrÚ_input_validation˜s z"LinearConstraint._input_validationFc Cs„t|ƒs8tƒ"tdƒt |¡ tj¡|_W5QRXn||_t |¡ tj¡|_ t |¡ tj¡|_ t |¡ t ¡|_ |  ¡dS)NÚerror)r r r rÚ atleast_2dÚastypeZfloat64r(Ú atleast_1drrÚboolrr.)r r(rrrrrrr!§s zLinearConstraint.__init__cCs |j||j|j|j|fS)a  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 )r(rr©r rrrrÚresidual¸szLinearConstraint.residualN) r"r#r$r%r.rÚinfr!r5rrrrr&xsr&c@s>eZdZdZdd„Zej ejdfdd„Zdd„Zd d „Z d S) ÚBoundsaPBounds 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 : 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 : 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. cCsNz(t |j|j|j¡}|\|_|_|_Wn tk rHd}t|ƒ‚YnXdS)Nz6`lb`, `ub`, and `keep_feasible` must be broadcastable.)rZbroadcast_arraysrrrr*)r Úresr-rrrr.ñs zBounds._input_validationFcCs6t |¡|_t |¡|_t |¡ t¡|_| ¡dSr )rr2rrr1r3rr.)r rrrrrrr!ùs  zBounds.__init__cCsFt|ƒj›d|j›d|j›}t |j¡r:d|j›d}nd}||S)Nú(z, z, keep_feasible=ú))Útyper"rrrÚanyr)r ÚstartÚendrrrÚ__repr__ÿs  zBounds.__repr__cCs||j|j|fS)aßCalculate the residual (slack) between the input and the bounds For a bound constraint of the form:: lb <= x <= ub the lower and upper residuals between `x` and the bounds are values ``sl`` and ``sb`` such that:: lb + sl == x == ub - sb When all elements of ``sl`` and ``sb`` are positive, all elements of ``x`` lie within the bounds; a negative element in ``sl`` or ``sb`` indicates that the corresponding element of ``x`` is out of bounds. Parameters ---------- x: array_like Vector of independent variables Returns ------- sl, sb : array-like The lower and upper residuals )rrr4rrrr5szBounds.residualN) r"r#r$r%r.rr6r!r?r5rrrrr7×s r7c@s0eZdZdZdej ejffdd„Zdd„ZdS)ÚPreparedConstrainta€Constraint prepared from a user defined constraint. On creation it will check whether a constraint definition is valid and the initial point is feasible. If created successfully, it will contain the attributes listed below. Parameters ---------- constraint : {NonlinearConstraint, LinearConstraint`, Bounds} Constraint to check and prepare. x0 : array_like Initial vector of independent variables. sparse_jacobian : bool or None, optional If bool, then the Jacobian of the constraint will be converted to the corresponded format if necessary. If None (default), such conversion is not made. finite_diff_bounds : 2-tuple, optional Lower and upper bounds on the independent variables for the finite difference approximation, if applicable. Defaults to no bounds. Attributes ---------- fun : {VectorFunction, LinearVectorFunction, IdentityVectorFunction} Function defining the constraint wrapped by one of the convenience classes. bounds : 2-tuple Contains lower and upper bounds for the constraints --- lb and ub. These are converted to ndarray and have a size equal to the number of the constraints. keep_feasible : ndarray Array indicating which components must be kept feasible with a size equal to the number of the constraints. Nc Cs6t|tƒr,t|j||j|j|j|j||ƒ}n8t|tƒrFt |j ||ƒ}nt|t ƒr\t ||ƒ}nt dƒ‚|j}tj|jtd}tj|jtd}tj|jtd} t ||¡}t ||¡}t | |¡} | j|fkrÒt dƒ‚| ||k@} |j} t | | || k¡st | | || k¡rt dƒ‚||_||f|_| |_dS)Nz*`constraint` of an unknown type is passed.)Zdtypez"`keep_feasible` has a wrong shape.z_`x0` is infeasible with respect to some inequality constraint with `keep_feasible` set to True.)rrrrrrrrr&rr(r7rr*ÚmrÚasarrayrÚfloatrrr3r,r+Úfr<Úbounds) r Ú constraintÚx0Zsparse_jacobianZfinite_diff_boundsrrArrrÚmaskZf0rrrr!Fs< ü        0 zPreparedConstraint.__init__c Csbtƒ"}| t¡|j t |¡¡}W5QRXt |jd|d¡}t ||jdd¡}||S)aZHow much the constraint is exceeded by. Parameters ---------- x : array-like Vector of independent variables Returns ------- excess : array-like How much the constraint is exceeded by, for each of the constraints specified by `PreparedConstraint.fun`. rr)r ÚfilterÚ UserWarningrrrBÚmaximumrE)r rÚsupZevZ excess_lbZ excess_ubrrrÚ violationms  zPreparedConstraint.violation)r"r#r$r%rr6r!rMrrrrr@$s ! ÿ 'r@cCsBt ||¡}t ||¡}dd„|Dƒ}dd„|Dƒ}tt||ƒƒS)a.Convert the new bounds representation to the old one. The new representation is a tuple (lb, ub) and the old one is a list containing n tuples, ith containing lower and upper bound on a ith variable. If any of the entries in lb/ub are -np.inf/np.inf they are replaced by None. cSs$g|]}|tj krt|ƒnd‘qSr ©rr6rC©Ú.0rrrrÚ ‘sz%new_bounds_to_old..cSs"g|]}|tjkrt|ƒnd‘qSr rNrOrrrrQ’s)rr,ÚlistÚzip)rrÚnrrrÚnew_bounds_to_old…s  rUcCs<t|Ž\}}t dd„|Dƒ¡}t dd„|Dƒ¡}||fS)a.Convert the old bounds representation to the new one. The new representation is a tuple (lb, ub) and the old one is a list containing n tuples, ith containing lower and upper bound on a ith variable. If any of the entries in lb/ub are None they are replaced by -np.inf/np.inf. cSs(g|] }|dk rtt|ƒƒntj ‘qSr ©rCrrr6rOrrrrQ¤sÿz$old_bound_to_new..cSs&g|]}|dk rtt|ƒƒntj‘qSr rVrOrrrrQ¦sÿ)rSrÚarray)rErrrrrÚold_bound_to_new—s  ÿ ÿrXcCsRt ||¡ t¡}t ||¡ t¡}t ||¡}tj ||<tj||<||fS)z6Remove bounds which are not asked to be kept feasible.)rÚresizer1rCr6)rrrZn_varsZ strict_lbZ strict_ubrrrÚ strict_bounds¬s   rZc sôt|tƒrX|jdk s0|jdk s0t|jtƒr0|jr:tdtƒ|j ‰t |j ƒrR|j ‰qœd‰nDt   |j¡rntdtƒ|j‰tˆƒr„ˆ ¡‰‡fdd„‰‡fdd„‰t|ˆ ƒ}|j\‰‰ ˆˆ k‰t  ˆt j kˆ¡‰t  ˆ t jkˆ¡‰t  ˆt j kˆ t jk¡}t   |¡rtdtƒg}t   ˆ¡r^‡‡‡fdd „}d |d œg}ˆdk r^‡‡fd d „}||dd<g}t  ˆ¡‰t  ˆ¡‰ˆˆrЇ‡‡‡‡‡‡ fdd„}d|d œg}ˆdk rЇ‡‡‡‡‡ fdd„} | |dd<||} t| ƒdkrðtdtƒ| S)zU Converts new-style constraint objects to old-style constraint dictionaries. Nz}Constraint options `finite_diff_jac_sparsity`, `finite_diff_rel_step`, `keep_feasible`, and `hess`are ignored by this method.zÑóz'new_constraint_to_old..csˆSr rrr\rrr]Òr^zSAt least one constraint is unbounded above and below. Such constraints are ignored.cs"t ˆ|ƒ¡ ¡}|ˆˆˆSr )rrWÚflatten)rÚy)rÚi_eqrrrÚf_eqäsz#new_constraint_to_old..f_eqÚeq)r;rcs2ˆ|ƒ}t|ƒr| ¡}t |¡}|ˆdd…fSr )r Útoarrayrr0)rÚdy)rarrrÚj_eqês  z#new_constraint_to_old..j_eqrrcsVt ˆˆ¡}t ˆ|ƒ¡ ¡}|ˆˆˆ|dˆ…<|ˆˆˆ |ˆd…<|Sr )rÚzerosrWr_)rr`Zy_all)rÚ i_bound_aboveÚ i_bound_belowrÚ n_bound_aboveÚ n_bound_belowrrrÚf_ineqös z%new_constraint_to_old..f_ineqÚineqcsnt ˆˆtˆƒf¡}ˆ|ƒ}t|ƒr.| ¡}t |¡}|ˆ|dˆ…dd…f<|ˆ |ˆd…dd…f<|Sr )rrgÚlenr rdr0)rreZdy_all)rhrirrjrkrGrrÚj_ineqÿs z%new_constraint_to_old..j_ineqrzçEquality 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. )rrrrrrrrrrÚcallablerrr<r(r rdr@rEÚ logical_xorr6Ú logical_andÚsumrn) ÚconrGZpconZ i_unboundedZceqrbrfZcineqrlroZold_constraintsr) r(rrhrirarrrjrkrrGrÚnew_constraint_to_old¶sp  ÿ þýþ  ÿ     ÿ          ýruc s@zˆd ¡}Wn„tk r@}ztd|ƒ|‚W5d}~XYnntk rj}ztdƒ|‚W5d}~XYnDtk r”}ztdƒ|‚W5d}~XYnX|dkr®tdˆdƒ‚dˆkrÂtd |ƒ‚d }|d krÔd }ntj}d }d ˆkrˆd ‰‡‡fdd„}dˆkr2‡‡fdd„}nˆd}dˆkr2ˆd}t||||ƒS)zU Converts old-style constraint dictionaries to new-style constraint objects. r;z"Constraint %d has no type defined.Nz/Constraints must be a sequence of dictionaries.z#Constraint's type must be a string.)rcrmzUnknown constraint type '%s'.rz&Constraint %d has no function defined.rrcrÚargscsˆd|fˆžŽS)Nrrr©rvrtrrr]2r^z'old_constraint_to_new..rcsˆd|fˆžŽS)Nrrrrwrrr]4r^)ÚlowerÚKeyErrorÚ TypeErrorÚAttributeErrorr*rr6r)ZicrtÚctypeÚerrrrrrwrÚold_constraint_to_news<ÿþ    r~)r%ZnumpyrZ_hessian_update_strategyrZ_differentiable_functionsrrrÚ _optimizerÚwarningsrr r Z numpy.testingr Z scipy.sparser rrr&r7r@rUrXrZrur~rrrrÚs"    f_Ma ^