$jZdZddlmZmZddlmZddlZddlm Z gdZ dZ dd Z dd Z dd Zd Zd ZdZejddddddfdZdS)z3Equality-constrained quadratic programming solvers.)linalg block_array)copysignN)norm) eqp_kktfactsphere_intersectionsbox_intersectionsbox_sphere_intersectionsinside_box_boundariesmodified_dogleg projected_cgcLtj|\}tj|\}t||jg|dggd}tj| | g}t j|}||} | d|} | |||z } | | fS)aSolve 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 array, shape (n, n) Hessian matrix of the EQP problem. c : array_like, shape (n,) Gradient of the quadratic objective function. A : sparse array 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. Ncsc)format)npshaperThstackrsplusolve) HcAbnm kkt_matrixkkt_veclukkt_solxlagrange_multiplierss ^C:\Projects\DSCons\.venv\Lib\site-packages\scipy\optimize\_trustregion_constr\qp_subproblem.pyrrs0 !BA !BA q!#hD 25AAAJi!aR!!G Z BhhwG A#AacEN? " ""Fc~t|dkrdStj|r'|rtj }tj}nd}d}d}|||fStj||}dtj||z}tj|||dzz } ||zd|z| zz } | dkrd}dd|fStj| } |t | |z} | d|zz }d| z| z }t||g\}}|rd}n5|dks|dkrd}d}d}n"d}td|}td|}|||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. rrrFTF) rrisinfinfdotsqrtrsortedmaxmin) zd trust_radius entire_linetatb intersectarr discriminantsqrt_discriminantauxs r#rrAsB Aww!||{ x !  &BBBBB 2y   q! A BF1aLLA q! |Q&AQ31Q;La !Y -- h(!,, ,C 1B AB RH  FB  66R!VVIBBBIQBQB r9 r$ctj|}tj|}tj|}tj|}t|dkrdS|dk}||||ks$||||krd}dd|fStj|}||}||}||}||}||z |z }||z |z } t tj|| } ttj|| } | | krd}nd}|s3| dks| dkrd}d} d} n t d| } 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') rasarrayrany logical_notr0minimumr1maximum) r2r3lbubr5zero_dr8 not_zero_dt_lbt_ubr6r7s r#r r sJ 1 A 1 A BB BB Aww!||{1fF & BvJ##%%!F)bj*@)E)E)G)G !Y''J * A * A JB JB qDA:D qDA:D RZd # # $ $B RZd # # $ $B Rxx   66R!VVIBBBQBQB r9 r$ct|||||\}}} t||||\} } } tj|| } tj|| }| r | r | |krd}nd}|r| | | d}||| d}| ||||fS| ||fS)aFind 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)r6r7r8)r rrrBrA)r2r3rCrDr4r5 extra_infota_btb_b intersect_bta_stb_s intersect_sr6r7r8 sphere_infobox_infos r#r r sb01b"0;==D$ 21a3?3>@@D$  D$  B D$  B{rRxx  !!KHH dEE2y+x772y  r$cb||ko||kS)zCheck if lb <= x <= ub.)allr!rCrDs r#r r 1s% !G==?? .R}}.r$cRtjtj|||S)zReturn clipped value of x)rrArBrUs r#reinforce_box_boundariesrW6s :bjB'' , ,,r$c|| }t|||rt||kr|}|S|j|}||} t j|| t j| | z |z} t j| } | } || z } t | | |||\}}}|r | || zz}n#| } | } t | | |||\}}}| || zz}| } |} t | | |||\}}}| || zz}t|||zt|||zkr|S|S)a?Approximately 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 array 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 array 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 )rYrr4rCrD newton_pointr!gA_g cauchy_point origin_pointr2p_alphar8x1x2s r#r r ;s`EE!HH9L\2r22    - -   A %%((CF1aLL=26#s#3#33a7L=..L A|#A21aR3?AAAui  q[  .q!R/;== 5! q[ AA*1aR+799KAua U1WB AEE"IIMT!%%))a-0000  r$c d} tj|\} tj|\}|| }||||z}||}| }| r|g}||}t|dz}|t|z }|dkrt d|| kr&dddd}| r||||d<||fS|6t td tj|zd |z| }| tj | tj }|tj | tj }| | |z } t| | |z } | | |z } d }d }d}tj |}d}t| D]}||krd }n|d z }||}|dkr^tj |rt dt|||||d\}} }!|!r|| |zz}t|||}d}d}nR||z } || |zz}"tj|"|kr>t|| |z|||\}}#}!|!r ||#| z|zz}t|||}d}d}nt#|"||rd}n|d z }|dkr:t|| |z|||\}}#}!|!r||#| z|zz}t|||}d}|| krn| r||"|| |zz}$||$}%t|%dz}&|&|z }'|% |'|zz}|"}|%}|%}t|dz}||}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 array 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 array or ndarray), shape (n, n) Operator for projecting ``x`` into the null space of A. Y : LinearOperator, sparse array, 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_boundaryallvecsNg{Gz?g?Fr'r)z9Negative curvature not allowed for unrestricted problems.)r5)rrr-r ValueErrorappendr0r1r.fullr,rYranger+r rWrr )(rrZrZrr4rCrDtolmax_itermax_infeasible_iter return_all CLOSE_TO_ZEROrrr!rr\r`riH_prt_g tr_distanceinforhrgcounterlast_feasible_xkipt_H_prarbr8x_nextthetar_nextg_next rt_g_nextbetas( r#r r s`M !BA !BA qb A aeeAhhlA aA A# %%((C 77A:Da(KQIJJJ } $ $TBB  & NN1   %DO$w {#dRWT]]*C$J77GG z WQ  z WQ  Q38QqS!!H"cMIGmA&&O A 8__TT #::I E Q Q;;x %%  ">???'?q"b,D'B'B'B#5)$E!G A-QB77 $ v U1W 9>>& ! !\ 1 1":1eAgr2;G#I#I Aui &e A %)B33AI M E !R 0 0 GG qLG Q;;":1eAgr2;G#I#I Aui "#eEk!m"3#;?;=r#C#C ( ( ( E  # NN6 " " "U3YvLL!O 4HtAv    AwwzeeAhh B + +  Y* , ,D"!Y d7Nr$)F)FF)__doc__ scipy.sparserrmathrnumpyr numpy.linalgr__all__rrr r r rWr r,r r$r#rs<99,,,,,,,,   *#*#*#\&+SSSSn#(RRRRl*/(-B!B!B!B!J/// --- ]]]@.0VTtD!bbbbbbr$