Ei;XSrSSKJrJr SSKJr SSKrSSKJ r /SQr Sr SS jr SS jr SS jrS rS rSr\R$SSSSSS4Sjrg)z3Equality-constrained quadratic programming solvers.)linalg block_array)copysignN)norm) eqp_kktfactsphere_intersectionsbox_intersectionsbox_sphere_intersectionsinside_box_boundariesmodified_dogleg projected_cgc4[R"U5un[R"U5un[XR/US//SS9n[R"U*U*/5n[ R "U5nURU5n U SUn XXE-*n X4$)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 m/home/mande/repo/quber/.venv/lib/python3.13/site-packages/scipy/optimize/_trustregion_constr/qp_subproblem.pyrrs0 !BA !BA q##hD 25AJii!aR!G Z BhhwG A#acN? ""Fc[U5S:Xag[R"U5(a3U(a"[R*n[RnOSnSnSnXEU4$[R"X5nS[R"X5-n[R"X5US-- n X-SU-U -- n U S:aSnSSU4$[R "U 5n U[ X5-n U *SU-- nSU -U - n[XE/5upEU(aSnO-US:dUS:aSnSnSnOSn[SU5n[SU5nXEU4$) aFind 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#rrAsMB Aw!| xx  &&BBBB y   q A BFF1LA q |Q&A31Q;La !Y - h(, ,C 1B AB RH FB  6R!VIBBIQBQB 9 r$c[R"U5n[R"U5n[R"U5n[R"U5n[U5S:XagUS:HnXX%:R5(dXX5:R5(aSnSSU4$[R"U5nXnXnX'nX7nX - U- nX0- U- n [ [R "X55n [[R"X55n X::aSnOSnU(d+U S:dU S:aSnSn Sn O[ SU 5n [SU 5n XU4$)aFind 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 sOJ 1 A 1 A BB BB Aw!|1fF BJ##%%!)bj*@)E)E)G)G !Y'J A A B B DA:D DA:D RZZ # $B RZZ # $B x   6R!VIBBQBQB 9 r$c[XX#U5upxn [XUU5upn [R"Xz5n [R"X5nU (aU (aX::aSnOSnU(aXU S.nXxU S.nXUUU4$XU4$)aUFind 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 sb0b0;=D 213?3>@D  D B D B{rx  !KH Ey+x77y  r$cXX:*R5=(a X:*R5$)zCheck if lb <= x <= ub.)allr!rCrDs r#r r 1s G==? .}}.r$cX[R"[R"X5U5$)zReturn clipped value of x)rrArBrUs r#reinforce_box_boundariesrW6s ::bjj' ,,r$cURU5*n[XdU5(a[U5U::aUnU$URRU5nURU5n [R"X5*[R"X5- U-n [R "U 5n U n Xj- n [ XXEU5upnU(aXU --nOU n U n [ XXEU5upnXU --nU n Un [ XXEU5upnXU --n[URU5U-5[URU5U-5:aU$U$)aApproximately 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 ;sL`EE!H9L\r22   -   A %%(CFF1L=266##33a7L==.L A#A213?AAi q[  .qR/;= ! q[ AA*1+79KAa 1WB AEE"IMT!%%)a-00  r$c JSn [R"U5un [R"U5unURU*5nURURU5U-5nURU5nU*nU (aU/nURU5n[U5S-nU[U5- nUS:a [ S5eUU :a'SSSS.nU (aWR U5 UUS'UU4$Uc0[ [S[R"U5-S U-5U 5nUc&[R"U [R*5nUc%[R"U [R5nU cX- n [XU- 5n U cX- n S nS nSn[R"U5nSn[U 5GHnUU:aS n GOUS - nURU5nUS::aY[R"U5(a [ S 5e[UUXgUSS9unn n!U!(aUU U--n[XU5nSnSn GO??'?q",D'B#5)E!G A-QB7 $ v U1W 99>>& !\ 1":1eAgr;G#I Auie A %)3AI M  ! 0 0G qLG Q;":1eAgr;G#I Aui"#eEk!m"3#;?;=#C ( (   NN6 "U3YvL!O 4HtAv    AwzeeAhil ! + +  Y* ,D!Y d7Nr$)F)FF)__doc__ scipy.sparserrmathrnumpyr numpy.linalgr__all__rrr r r rWr r,r r$r#rsw9, *#\&+Sn#(Rl*/(-B!J/ - ]@.0VVTtD!br$