o ñ h@Xã@s¤dZddlmZmZmZddlmZddlZddl m Z gd¢Z dd„Z dd d „Z dd d „Z ddd„Zdd„Zdd„Zdd„Zejdddddd fdd„ZdS)z3Equality-constrained quadratic programming solvers.é)ÚlinalgÚbmatÚ csc_matrix)ÚcopysignN)Únorm)Ú eqp_kktfactÚsphere_intersectionsÚbox_intersectionsÚbox_sphere_intersectionsÚinside_box_boundariesÚmodified_doglegÚ projected_cgc Cs~t |¡\}t |¡\}tt||jg|dggƒƒ}t | | g¡}t |¡}| |¡} | d|…} | |||… } | | fS)aÍSolve equality-constrained quadratic programming (EQP) problem. Solve ``min 1/2 x.T H x + x.t c`` subject to ``A x + b = 0`` using direct factorization of the KKT system. Parameters ---------- H : sparse matrix, shape (n, n) Hessian matrix of the EQP problem. c : array_like, shape (n,) Gradient of the quadratic objective function. A : sparse matrix Jacobian matrix of the EQP problem. b : array_like, shape (m,) Right-hand side of the constraint equation. Returns ------- x : array_like, shape (n,) Solution of the KKT problem. lagrange_multipliers : ndarray, shape (m,) Lagrange multipliers of the KKT problem. N) ÚnpÚshaperrÚTÚhstackrÚspluÚsolve) ÚHÚcÚAÚbÚnÚmÚ kkt_matrixÚkkt_vecÚluÚkkt_solÚxÚlagrange_multipliers©r úd/var/www/vscode/kcb/lib/python3.10/site-packages/scipy/optimize/_trustregion_constr/qp_subproblem.pyrs     rFc Cs*t|ƒdkrdSt |¡r"|rtj }tj}nd}d}d}|||fSt ||¡}dt ||¡}t ||¡|d} ||d|| } | dkrOd}dd|fSt | ¡} |t| |ƒ} | d|}d| | }t||gƒ\}}|rud}n|dks}|dkr„d}d}d}n d}td|ƒ}t d|ƒ}|||fS) aHFind the intersection between segment (or line) and spherical constraints. Find the intersection between the segment (or line) defined by the parametric equation ``x(t) = z + t*d`` and the ball ``||x|| <= trust_radius``. Parameters ---------- z : array_like, shape (n,) Initial point. d : array_like, shape (n,) Direction. trust_radius : float Ball radius. entire_line : bool, optional When ``True``, the function returns the intersection between the line ``x(t) = z + t*d`` (``t`` can assume any value) and the ball ``||x|| <= trust_radius``. When ``False``, the function returns the intersection between the segment ``x(t) = z + t*d``, ``0 <= t <= 1``, and the ball. Returns ------- ta, tb : float The line/segment ``x(t) = z + t*d`` is inside the ball for for ``ta <= t <= tb``. intersect : bool When ``True``, there is a intersection between the line/segment and the sphere. On the other hand, when ``False``, there is no intersection. r©rrFéTééFéþÿÿÿ) rrÚisinfÚinfÚdotÚsqrtrÚsortedÚmaxÚmin) ÚzÚdÚ trust_radiusÚ entire_lineÚtaÚtbÚ intersectÚarrÚ discriminantÚsqrt_discriminantÚauxr r r!rAs@ !          rc Cs*t |¡}t |¡}t |¡}t |¡}t|ƒdkrdS|dk}||||k ¡s4||||k ¡r;d}dd|fSt |¡}||}||}||}||}|||}|||} tt || ¡ƒ} tt || ¡ƒ} | | krsd}nd}|s| dks| dkr†d}d} d} n td| ƒ} td| ƒ} | | |fS)a5Find the intersection between segment (or line) and box constraints. Find the intersection between the segment (or line) defined by the parametric equation ``x(t) = z + t*d`` and the rectangular box ``lb <= x <= ub``. Parameters ---------- z : array_like, shape (n,) Initial point. d : array_like, shape (n,) Direction. lb : array_like, shape (n,) Lower bounds to each one of the components of ``x``. Used to delimit the rectangular box. ub : array_like, shape (n, ) Upper bounds to each one of the components of ``x``. Used to delimit the rectangular box. entire_line : bool, optional When ``True``, the function returns the intersection between the line ``x(t) = z + t*d`` (``t`` can assume any value) and the rectangular box. When ``False``, the function returns the intersection between the segment ``x(t) = z + t*d``, ``0 <= t <= 1``, and the rectangular box. Returns ------- ta, tb : float The line/segment ``x(t) = z + t*d`` is inside the box for for ``ta <= t <= tb``. intersect : bool When ``True``, there is a intersection between the line (or segment) and the rectangular box. On the other hand, when ``False``, there is no intersection. rr"FTr#) rÚasarrayrÚanyÚ logical_notr,Úminimumr-Úmaximum) r.r/ÚlbÚubr1Úzero_dr4Ú not_zero_dÚt_lbÚt_ubr2r3r r r!r —s< %    (       r cCst|||||ƒ\}}} t||||ƒ\} } } t || ¡} t || ¡}| r,| r,| |kr,d}nd}|rC| | | dœ}||| dœ}| ||||fS| ||fS)aýFind the intersection between segment (or line) and box/sphere constraints. Find the intersection between the segment (or line) defined by the parametric equation ``x(t) = z + t*d``, the rectangular box ``lb <= x <= ub`` and the ball ``||x|| <= trust_radius``. Parameters ---------- z : array_like, shape (n,) Initial point. d : array_like, shape (n,) Direction. lb : array_like, shape (n,) Lower bounds to each one of the components of ``x``. Used to delimit the rectangular box. ub : array_like, shape (n, ) Upper bounds to each one of the components of ``x``. Used to delimit the rectangular box. trust_radius : float Ball radius. entire_line : bool, optional When ``True``, the function returns the intersection between the line ``x(t) = z + t*d`` (``t`` can assume any value) and the constraints. When ``False``, the function returns the intersection between the segment ``x(t) = z + t*d``, ``0 <= t <= 1`` and the constraints. extra_info : bool, optional When ``True``, the function returns ``intersect_sphere`` and ``intersect_box``. Returns ------- ta, tb : float The line/segment ``x(t) = z + t*d`` is inside the rectangular box and inside the ball for ``ta <= t <= tb``. intersect : bool When ``True``, there is a intersection between the line (or segment) and both constraints. On the other hand, when ``False``, there is no intersection. sphere_info : dict, optional Dictionary ``{ta, tb, intersect}`` containing the interval ``[ta, tb]`` for which the line intercepts the ball. And a boolean value indicating whether the sphere is intersected by the line. box_info : dict, optional Dictionary ``{ta, tb, intersect}`` containing the interval ``[ta, tb]`` for which the line intercepts the box. And a boolean value indicating whether the box is intersected by the line. TF)r2r3r4)r rrr=r<)r.r/r>r?r0r1Ú extra_infoÚta_bÚtb_bÚ intersect_bÚta_sÚtb_sÚ intersect_sr2r3r4Ú sphere_infoÚbox_infor r r!r ìs" 1 ÿ þ     r cCs||k ¡o ||k ¡S)zCheck if lb <= x <= ub.)Úall©rr>r?r r r!r 1sr cCst t ||¡|¡S)zReturn clipped value of x)rr<r=rNr r r!Úreinforce_box_boundaries6srOcCs| |¡ }t|||ƒrt|ƒ|kr|}|S|j |¡}| |¡} t ||¡ t | | ¡|} t | ¡} | } || } t| | |||ƒ\}}}|rO| || }n| } | } t| | |||ƒ\}}}| || }| } |} t| | |||ƒ\}}}| || }t| |¡|ƒt| |¡|ƒkr|S|S)aAApproximately minimize ``1/2*|| A x + b ||^2`` inside trust-region. Approximately solve the problem of minimizing ``1/2*|| A x + b ||^2`` subject to ``||x|| < Delta`` and ``lb <= x <= ub`` using a modification of the classical dogleg approach. Parameters ---------- A : LinearOperator (or sparse matrix or ndarray), shape (m, n) Matrix ``A`` in the minimization problem. It should have dimension ``(m, n)`` such that ``m < n``. Y : LinearOperator (or sparse matrix or ndarray), shape (n, m) LinearOperator that apply the projection matrix ``Q = A.T inv(A A.T)`` to the vector. The obtained vector ``y = Q x`` being the minimum norm solution of ``A y = x``. b : array_like, shape (m,) Vector ``b``in the minimization problem. trust_radius: float Trust radius to be considered. Delimits a sphere boundary to the problem. lb : array_like, shape (n,) Lower bounds to each one of the components of ``x``. It is expected that ``lb <= 0``, otherwise the algorithm may fail. If ``lb[i] = -Inf``, the lower bound for the ith component is just ignored. ub : array_like, shape (n, ) Upper bounds to each one of the components of ``x``. It is expected that ``ub >= 0``, otherwise the algorithm may fail. If ``ub[i] = Inf``, the upper bound for the ith component is just ignored. Returns ------- x : array_like, shape (n,) Solution to the problem. Notes ----- Based on implementations described in pp. 885-886 from [1]_. References ---------- .. [1] Byrd, Richard H., Mary E. Hribar, and Jorge Nocedal. "An interior point algorithm for large-scale nonlinear programming." SIAM Journal on Optimization 9.4 (1999): 877-900. )r)r rrrÚ zeros_liker )rÚYrr0r>r?Ú newton_pointrÚgÚA_gÚ cauchy_pointÚ origin_pointr.ÚpÚ_Úalphar4Úx1Úx2r r r!r ;s> 0       ÿ  ÿ   ÿ $r c ( Csfd} t |¡\} t |¡\}| | ¡}| | |¡|¡}| |¡}| }| r+|g}| |¡}t|ƒd}|t|ƒ}|dkrDtdƒ‚|| kr]ddddœ}| rY| |¡||d<||fS|durpttd t |¡d |ƒ| ƒ}|dur|t  | tj ¡}|dur‡t  | tj ¡}| dur| |} t| | |ƒ} | durž| |} d }d }d}t  |¡}d}t | ƒD]ç}||kr¹d }nÞ|d 7}| |¡}|dkrðt  |¡rÏtdƒ‚t|||||dd\}} }!|!rä|| |}t|||ƒ}d}d}n§||} || |}"tj |"¡|kr't|| ||||ƒ\}}#}!|!r||#| |}t|||ƒ}d}d}npt|"||ƒr1d}n|d 7}|dkrZt|| ||||ƒ\}}#}!|!rZ||#| |}t|||ƒ}d}|| kran6| ri| |"¡|| |}$| |$¡}%t|%ƒd}&|&|}'|% |'|}|"}|%}|%}t|ƒd}| |¡}q¯t|||ƒs¢|}d}|||dœ}| r¯||d<||fS)a¨ Solve EQP problem with projected CG method. Solve equality-constrained quadratic programming problem ``min 1/2 x.T H x + x.t c`` subject to ``A x + b = 0`` and, possibly, to trust region constraints ``||x|| < trust_radius`` and box constraints ``lb <= x <= ub``. Parameters ---------- H : LinearOperator (or sparse matrix or ndarray), shape (n, n) Operator for computing ``H v``. c : array_like, shape (n,) Gradient of the quadratic objective function. Z : LinearOperator (or sparse matrix or ndarray), shape (n, n) Operator for projecting ``x`` into the null space of A. Y : LinearOperator, sparse matrix, ndarray, shape (n, m) Operator that, for a given a vector ``b``, compute smallest norm solution of ``A x + b = 0``. b : array_like, shape (m,) Right-hand side of the constraint equation. trust_radius : float, optional Trust radius to be considered. By default, uses ``trust_radius=inf``, which means no trust radius at all. lb : array_like, shape (n,), optional Lower bounds to each one of the components of ``x``. If ``lb[i] = -Inf`` the lower bound for the i-th component is just ignored (default). ub : array_like, shape (n, ), optional Upper bounds to each one of the components of ``x``. If ``ub[i] = Inf`` the upper bound for the i-th component is just ignored (default). tol : float, optional Tolerance used to interrupt the algorithm. max_iter : int, optional Maximum algorithm iterations. Where ``max_inter <= n-m``. By default, uses ``max_iter = n-m``. max_infeasible_iter : int, optional Maximum infeasible (regarding box constraints) iterations the algorithm is allowed to take. By default, uses ``max_infeasible_iter = n-m``. return_all : bool, optional When ``true``, return the list of all vectors through the iterations. Returns ------- x : array_like, shape (n,) Solution of the EQP problem. info : Dict Dictionary containing the following: - niter : Number of iterations. - stop_cond : Reason for algorithm termination: 1. Iteration limit was reached; 2. Reached the trust-region boundary; 3. Negative curvature detected; 4. Tolerance was satisfied. - allvecs : List containing all intermediary vectors (optional). - hits_boundary : True if the proposed step is on the boundary of the trust region. Notes ----- Implementation of Algorithm 6.2 on [1]_. In the absence of spherical and box constraints, for sufficient iterations, the method returns a truly optimal result. In the presence of those constraints, the value returned is only a inexpensive approximation of the optimal value. References ---------- .. [1] Gould, Nicholas IM, Mary E. Hribar, and Jorge Nocedal. "On the solution of equality constrained quadratic programming problems arising in optimization." SIAM Journal on Scientific Computing 23.4 (2001): 1376-1395. gÙ}ÚõÐò¾:r$rz.Trust region problem does not have a solution.T)ÚniterÚ stop_condÚ hits_boundaryÚallvecsNg{®Gáz„?gš™™™™™¹?Fr#r%z9Negative curvature not allowed for unrestricted problems.)r1é)rrr)rÚ ValueErrorÚappendr,r-r*Úfullr(rPÚranger'r rOrr )(rrÚZrQrr0r>r?ÚtolÚmax_iterÚmax_infeasible_iterÚ return_allÚ CLOSE_TO_ZEROrrrÚrrSrWr_ÚH_pÚrt_gÚ tr_distanceÚinfor^r]ÚcounterÚlast_feasible_xÚkÚiÚpt_H_prXrYr4Úx_nextÚthetaÚr_nextÚg_nextÚ rt_g_nextÚbetar r r!r ›sÌP               ÿ    ÿ   ÿÿ       ÿr )F)FF)Ú__doc__Ú scipy.sparserrrÚmathrÚnumpyrÚ numpy.linalgrÚ__all__rrr r r rOr r(r r r r r!Ús,   . ÿW ÿV þE`ý