9i"%SrSSKrSSKrSSKrSSKrSSKrSSKJrJrJ r SSKJ r SSK J r SSK Jr SSKJrJrJr SSKrSSKJr SSKJr SS KJrJrJrJrJr J!r"J#r$J%r&J'r(J)r*J+r, SS K-J.r. SS K/J0r0 /S Qr1\RdRgS S5r4\5\6-\7S '\RdRgSS5r8\4\8S.r9\r:\\7S'\:\Rv-r;\\7S'S\\;S\ \:4SjrS(SSSS.S\;S\S\SS-S\6S-S\S-S \6S!\6S\:4S"jjjr?SS#.S$\:S\S-S\:4S%jjr@\ "S&5rA\ \\7S''\ S\S\S(4S)j5rBSYS*jrCS+S+S+S+S,.S-jrDS.rES+S+S+S+S/SS0.S1jrFSSS+S+S+S+S/SS2.S3jrGS+S+S+S+S/S+SS4.S5jrHSZS6jrIS[S7jrJS8\S\54S9jrKS$\:S\S\64S:jrLS\S\S-4S;jrMSSS\N\O\N-S-S?\6S@\N\P-S\S-S\:4 SAjjrQSS#.S$\:S\S-S\:4SBjjrRSYSCjrSSSD.SEjrTSSSF.SGjrUSYSH\:S\S-S\:4SIjjrVSJrWSKrXSLrY\R"SSM9"SNSO55r[S\SQjr\SRr]SSPSPSSSSPSPSS+SS. STjr^SSU.SVjr_SSU.SWjr`SSU.SXjra0rbg)]a6Utility functions to use Python Array API compatible libraries. For the context about the Array API see: https://data-apis.org/array-api/latest/purpose_and_scope.html The SciPy use case of the Array API is described on the following page: https://data-apis.org/array-api/latest/use_cases.html#use-case-scipy N) GeneratorIterableIterator)contextmanager) ContextVar) ModuleType)AnyLiteral TypeAlias)array_api_compat) is_array_api_obj is_lazy_arraysizenumpydeviceis_numpy_namespaceis_cupy_namespaceis_torch_namespaceis_jax_namespaceis_dask_namespaceis_array_api_strict_namespace)issparse) FunctionDoc)_asarrayarray_namespaceassert_almost_equalassert_array_almost_equal default_xp eager_warnsr is_marrayis_array_api_strict is_complexis_cupyis_jaxis_numpyis_torchSCIPY_ARRAY_API SCIPY_DEVICEscipy_namespace_forxp_assert_closexp_assert_equalxp_assert_lessxp_copy xp_devicexp_ravelxp_sizexp_unsupported_param_msgxp_vector_normxp_capabilitiesxp_result_type xp_promoter'Fr(cpu)r'r(Array ArrayLikearraysreturnc## UGHnUcM [U5(a Sn[U5e[U[RR 5(a [ S5e[U[R5(a [ S5e[U[R[R-5(apURn[R"U[R5(d:[R"U[R5(d[ SU<S35e[U5(aUv GM;[R"U5nURn[R"U[R5(d<[R"U[R5(dSU<S3n[ U5eUR (dGMUv GM g![ a [ S5ef=f7f) aRaise exceptions on known-bad subclasses. Discard 0-dimensional ArrayLikes and convert 1+-dimensional ArrayLikes to numpy. The following subclasses are not supported and raise and error: - `numpy.ma.MaskedArray` - `numpy.matrix` - NumPy arrays which do not have a boolean or numerical dtype - Any array-like which is neither array API compatible nor coercible by NumPy - Any array-like which is coerced by NumPy to an unsupported dtype NzSparse arrays/matrices are not supported by this function. Perhaps one of the `scipy.sparse.linalg` functions would work instead.z8Inputs of type `numpy.ma.MaskedArray` are not supported.z0Inputs of type `numpy.matrix` are not supported.zAn argument has dtype `z3`; only boolean and numerical dtypes are supported.zCAn argument is neither array API compatible nor coercible by NumPy.z1An argument was coerced to an unsupported dtype `)r ValueError isinstancenpma MaskedArray TypeErrormatrixndarraygenericdtype issubdtypenumberbool_r asanyarrayndim)r9arraymsgrEmessages U/var/www/html/land-doc-ocr/venv/lib/python3.13/site-packages/scipy/_lib/_array_api.py_compliance_scipyrODs =  E??)CS/ ! eRUU.. / /VW W eRYY ' 'NO O eRZZ"**4 5 5KKEMM%33r}}UBHH7U7U"9%CS!TUU E " "K 7 e,KKEMM%33r}}UBHH7U7UGyQGH ((zzz U8 7!677 7s%D>HG'BH H'G==HrKxpchURURU55(d Sn[U5eg)zCheck for NaNs or Infs.z#array must not contain infs or NaNsN)allisfiniter<)rKrPrLs rN _check_finiterT|s. 66"++e$ % %3o &c[S(d[$[[U55nU(a[R "U6$[$)aGet the array API compatible namespace for the arrays xs. Parameters ---------- *arrays : sequence of array_like Arrays used to infer the common namespace. Returns ------- namespace : module Common namespace. Notes ----- Thin wrapper around `array_api_compat.array_namespace`. 1. Check for the global switch: SCIPY_ARRAY_API. This can also be accessed dynamically through ``_GLOBAL_CONFIG['SCIPY_ARRAY_API']``. 2. `_compliance_scipy` raise exceptions on known-bad subclasses. See its definition for more details. When the global switch is False, it defaults to the `numpy` namespace. In that case, there is no compliance check. This is a convenience to ease the adoption. Otherwise, arrays must comply with the new rules. r')_GLOBAL_CONFIG np_compatlistrOr r)r9 api_arrayss rNrrs?4 + ,'/0J//<< rU)rP check_finitesubokrEorder)KACFcopyr[r\cUc [U5n[U5(aNUSLa[R"XXS9nODU(a[R"XUS9nO'[R "XUS9nOUR XUS9nU(a [X5 U$![ a- [UR S55nUR XUS9nNJf=f)a8SciPy-specific replacement for `np.asarray` with `order`, `check_finite`, and `subok`. Memory layout parameter `order` is not exposed in the Array API standard. `order` is only enforced if the input array implementation is NumPy based, otherwise `order` is just silently ignored. `check_finite` is also not a keyword in the array API standard; included here for convenience rather than that having to be a separate function call inside SciPy functions. `subok` is included to allow this function to preserve the behaviour of `np.asanyarray` for NumPy based inputs. T)r]rEr\)r]rE)rErb)rr%r>rKrIasarrayrArT)rKrEr]rbrPr[r\ coerced_xps rNrrs0 z U #|| 4<HHUuJE MM%EBEJJu?E FJJuJ=E e L F(A7J&&u&EE Fs.B4C C rPxc4Uc [U5n[USUS9$)z Copies an array. Parameters ---------- x : array xp : array_namespace Returns ------- copy : array Copied array Notes ----- This copy function does not offer all the semantics of `np.copy`, i.e. the `subok` and `order` keywords are not used. T)rbrP)rrrhrPs rNr-r-s", z Q  ADR ((rU _default_xp_default_xp_ctxvar)NNNc## [RU5nSv [RU5 g![RU5 f=f7f)aIn all ``xp_assert_*`` and ``assert_*`` function calls executed within this context manager, test by default that the array namespace is the provided across all arrays, unless one explicitly passes the ``xp=`` parameter or ``check_namespace=False``. Without this context manager, the default value for `xp` is the namespace for the desired array (the second parameter of the tests). N)rlsetreset)rPtokens rNrrs<  " "2 &E(   '  'sA 3A A  A cvSSKnSn[U5(a[R"5$UR XS9$)z@pytest.warns context manager, but only if x is not a lazy array.rNF)match)pytestr contextlib nullcontextwarns)rh warning_typerrrs__thread_safe__s rNrrs7OQ%%'' << < 22rUTcheck_namespace check_dtype check_shapecheck_0dcSnUc[R5nU(a [ XU5 [ U5(aU(ayS[ U5S[ U53nURU5(aURU5(d3URU5(dURU5(aU5eURU5nURU5nU(a=SURSUR3nURUR:XdU5eU(am[U5(a UR5 UR5 SURSUR3nURUR:XdU5eURXR5nXU4$![a [U5nGNf=f)NTz$Array-ness does not match: Actual: z Desired: zdtypes do not match. Actual: Desired: zShapes do not match. Actual: )rlget LookupErrorr_assert_matching_namespacer%typeisscalarrerEis_daskcompute_chunk_sizesshape broadcast_to) actualdesiredrPrzr{r|r}__tracebackhide___msgs rN _strict_checkrs z *#'')B"6B7||7<. T']O=V$$W)=)= F++BKK4H4H QLP QJZZ Fjj!G/ ~[X||w}},2d2, 2;;  & & (  ' ' )/ ~[X||w}},2d2,oog||4G B ; * )B *sF77GGcSn[U5nSURSUR3nXB:XdU5e[U5nSURSUR3nXb:XdU5eg)NTzNamespace of desired array does not match expectations set by the `default_xp` context manager or by the `xp`pytest fixture. Desired array's space: z Expected namespace: z=Namespace of actual and desired arrays do not match. Actual: r)r__name__)rrrPrdesired_arr_spaceractual_arr_spaces rNrr;s'0 &'8&@&@%AB##%;;-  1D  "(D( "&v. '0012 } &D  !'4' !rU)rzr{r|r}err_msgrPc $Sn[XXrX4US9upn[U5(aURRXUS9$[ U5(a(US:XaSOUnURR XSSSSUS9$[ RRXUS9$)NTry)rrrFrtolatol equal_nanr{rL)rr#testingassert_array_equalr& assert_closer>) rrrzr{r|r}rrPrs rNr+r+Ms'FR r{{zz,,Vg,NN ""R-$Wzz&&vQQRV38g'G G :: ( (' ( JJrU)rrrzr{r|r}rrPc Sn [XU XEXgS9upn U RURS5n Uc3U (a,U RUR5RS-S-nOUcSn[ U 5(aU R RXUX8S9$[U 5(a'US:XaSOUnU R RXX#SS US 9$[R RXUX8S9$) NTry real floatingcomplex floating?gHz>)rrrrFr) risdtyperEfinfoepsr#rassert_allcloser&rr>) rrrrrzr{r|r}rrPrfloatings rNr*r*cs''FR zz&,,(MNH |xx %))3.2 r{{zz))&/3*F F "!R-$Wzz&&vT155g'W W :: % %fD+/ & BBrU)rzr{r|r}rverboserPc |Sn [XXX4US9upn[U5(aURRXXgS9$[ U5(aTUR R S:waUR5nUR R S:waUR5n[RRXXgS9$)NTry)rrr6) rr#rassert_array_lessr&rrr6r>) rrrzr{r|r}rrrPrs rNr,r,s'FR r{{zz++F4;,N N " ==   &ZZ\F >>  % 'kkmG :: ' '07 ( JJrUc<SSSU*--pe[X/UQ7XeSSS.UD6$zPBackwards compatible replacement. In new code, use xp_assert_close instead. rg? F)rrr{r|r*rrdecimalargskwdsrrs rNrrBCgX&$ 6 *  * $UPU *$( **rUc<SSSU*--pe[X/UQ7XeSSS.UD6$rrrs rNrrrrUparamcSU<S3$)Nz Providing z$ is only supported for numpy arrays.)rs rNr1r1s y D EErUc:URURS5$)Nr)rrErjs rNr"r"s ::agg1 22rUc[U5(aSSKnUR$[U5(aSSKnUR$[ U5(aU$g)aReturn the `scipy`-like namespace of a non-NumPy backend That is, return the namespace corresponding with backend `xp` that contains `scipy` sub-namespaces like `linalg` and `special`. If no such namespace exists, return ``None``. Useful for dispatching. rN)r#cupyxscipyr$jaxr&)rPrrs rNr)r)sAr{{{{ bzzyy|| rU)axiskeepdimsordrPrrrc6Uc [U5OUn[(aa[US5(aURR XX#S9$US:wa [ S5eUR URU5U-XS9S-$[RRXXS9$)Nlinalg)rrrrzonly the Euclidean norm (`ord=2`) is currently supported in `xp_vector_norm` for backends not implementing the `linalg` extension.)rrr)rrr) rr'hasattrr vector_normr<sumconjr>norm)rhrrrrPs rNr2r2s "z rB 2x 99(((R Rax !66"''!*q.t6GL Lyy~~at~GGrUcFUc [U5OUnURUS5$)N))rreshaperjs rNr/r/s% "z rB ::a rUcUc [U5OUn[[UR55nXBXAsXA'XB'UR X5nU$N)rrYrangerJ permute_dims)aaxis1axis2rPaxess rN xp_swapaxesrsK!z rB aff D#{DKDK  A HrU)force_floatingc UVs/sH+n[R"U5(a [USUS9OUPM- nnUVs/sH o3cMUPM nnU(aURS5 [ U5(aNUR S:a>UVs/sH"n[ USS5S:Xa UROUPM$ nnUR"U6$UR"U6$s snfs snfs snf![a U(de/nUHhn[R"U5(aURU5OUn[ USU5nURUS 5(dMWURU5 Mj UR"/UQ[U5P76s$f=f) a Returns the dtype that results from applying type promotion rules (see Array API Standard Type Promotion Rules) to the arguments. Augments standard `result_type` in a few ways: - There is a `force_floating` argument that ensures that the result type is floating point, even when all args are integer. - When a TypeError is raised (e.g. due to an unsupported promotion) and `force_floating=True`, we define a custom rule: use the result type of the default float and any other floats passed. See https://github.com/scipy/scipy/pull/22695/files#r1997905891 for rationale. - This function accepts array-like iterables, which are immediately converted to the namespace's arrays before result type calculation. Consequently, the result dtype may be different when an argument is `1.` vs `[1.]`. Typically, this function will be called shortly after `array_namespace` on a subset of the arguments passed to `array_namespace`. Tr\rPg?z2.0rrrEr)r>iterablerappendr% __version__getattrrE result_typerArrerxp_default_dtype)rrPrarg args_not_none float_args arg_arrayrEs rNr4r4sy* 24S1A1AXc" -s J  $(rrr4lentuplerbroadcast_shapesr<rr%rrEastype) rrrPrrrErshapesrerMoutkwargss rNr5r5)s& 24S1A1AXc" -s J   DB GE ?BoXcdr :SV V   d)Q,tAw7E$K7$( !  rUc SUR;$)z=Returns True if `xp` is an MArray namespace; False otherwise.marray)rrgs rNr r s r{{ ""rU)reprcr\rSrSr%\S-\S'\S-\S'\R"\S9r \\ \S'Sr Sr S r g) _XPSphinxCapabilityiNr6gpu)default_factorywarningscUcgU(dgUR(a6SSRUR5-n[U5S::dS5eU$g)Nzn/au⛔u⚠️ z; zWarnings too longu✅)rjoinr)selfvalueress rN_render_XPSphinxCapability._rendersL = ==dii 66Cs8r> 6#6 6>JrUcURUR5nURUR5nUSSUS3$)N20z )rr6r)rr6rs rN__str___XPSphinxCapability.__str__s;ll488$ll488$bC8$$rUr)r __module__ __qualname____firstlineno__bool__annotations__ dataclassesfieldrYrstrrr __static_attributes__rrUrNrrs9  %++DAHd3iA %rUrrc [U5n[SSS9[SSS9[SSS9[SSS9[SSU(a/OS/S9[SSU(aS/O/S9S.n [U5[U5-H3upXn U RbSU lU RcM,SU lM5 U R 5HgupU(a5XS1-;a,U RbSU lU Rb SU lM?MAU(dMJX;dMQU RcM`SU lMi UH$upXn U R RU 5 M& U $) NT)r6rzno JIT)r6rrzcomputes graph)rarray_api_strictcupytorch jax.numpy dask.arrayFr)rnrrYr6ritemsrr) skip_backendsxfail_backendscpu_onlynp_only exceptionsallow_dask_computejax_jitrreason capabilitiesmodule_backendwarnings rN_make_sphinx_capabilitiesr(sNZJ%48/DdC#$7$48(Tt"R 4*d+=&'2G L-(4+?? & ;; "GK ;; "GK @(--/ v7)%;;{{&# {{&# ' X&2w{{7NGK0$&($ rUc vSUSUSSUSSUSSUS S US S 3 n[R"U5$) Nz `aG` has experimental support for Python Array API Standard compatible backends in addition to NumPy. Please consider testing these features by setting an environment variable ``SCIPY_ARRAY_API=1`` and providing CuPy, PyTorch, JAX, or Dask arrays as array arguments. The following combinations of backend and device (or other capability) are supported. ==================== ==================== ==================== Library CPU GPU ==================== ==================== ==================== NumPy rz CuPy rz PyTorch rz JAX rz Dask rz} ==================== ==================== ==================== See :ref:`dev-arrayapi` for more information. )textwrapdedent)fun_namer#notes rN_make_capabilities_noter.sZ (0DE'/DE'0DE' 4DE' 5DE D& ??4  rU) capabilities_tablerrrrr"rrr r!c j^^ ^ Tc[OTm[UUUUUUUU US9 m [S0T D6m U UU 4Sjn U $)aIDecorator for a function that states its support among various Array API compatible backends. This decorator has two effects: 1. It allows tagging tests with ``@make_xp_test_case`` or ``make_xp_pytest_param`` (see below) to automatically generate SKIP/XFAIL markers and perform additional backend-specific testing, such as extra validation for Dask and JAX; 2. It automatically adds a note to the function's docstring, containing a table matching what has been tested. See Also -------- make_xp_test_case make_xp_pytest_param array_api_extra.testing.lazy_xp_function ) rrrrr"rr r!rc>TTU'[URT5n[U5nUSRU5 [ U5R SS5SnX lU$![a U$f=f)NNotes r)r.rrrrsplit__doc__AttributeError)fr-docr#r/sphinx_capabilitiess rN decorator"xp_capabilities..decorator&s!-1&qzz3FG!n G D!#hnnT1%a( I      sA## A10A1r)xp_capabilities_tabledictr() r/rrrrr"rrr r!r:r#r9s ` @@rNr3r3s\B4F3M/1#%- L4ClC rUr/c PUc[OUnSSKnSSKJn /nUGHnXnUSnUSnUS(a)UR UR R SXxS95 US(a)UR UR R SXxS 95 US H-upUR UR R XS 95 M/ US H-upUR UR RXS 95 M/ S V s0sHn XU _M n n U"U40U D6 GM U$s sn f)Nr)lazy_xp_functionrr"rT)rrr"r)rrr"r)r"r)r r!)r<rs"scipy._lib.array_api_extra.testingr@rmarkskip_xp_backendsxfail_xp_backends) r/funcsrsr@marksfuncr#rr"mod_namek lazy_kwargss rN_make_xp_pytest_marksrK9sO3E3M/1C E)/ !,/ h'  # LL55*6E F  " LL556D E!-_ = H LL55h5N O!> ,-= > H LL66x6O P!?!BC A1q/) A C--'* L CsD#c>^Uc[OUn[USU06mU4Sj$)Nr/c6>[R"STU5$)NcU"U5$rr)r7gs rN5make_xp_test_case....msadrU) functoolsreduce)rGrFs rNrP#make_xp_test_case..ms (():E4HrU)r<rK)r/rErFs @rNmake_xp_test_caserUXs13E3M/1" "5 P=O PE HHrUc\SSKn[XS9nUR"U/UQ7X@RS.6$)aVariant of ``make_xp_test_case`` that returns a pytest.param for a function, with all necessary skip_xp_backends and xfail_xp_backends marks applied:: @pytest.mark.parametrize( "func", [make_xp_pytest_param(f1), make_xp_pytest_param(f2)] ) def test(func, xp): ... The above is equivalent to:: @pytest.mark.parametrize( "func", [ pytest.param(f1, marks=[ pytest.mark.skip_xp_backends(...), pytest.mark.xfail_xp_backends(...), ...]), pytest.param(f2, marks=[ pytest.mark.skip_xp_backends(...), pytest.mark.xfail_xp_backends(...), ...]), ) def test(func, xp): ... Parameters ---------- func : Callable Function to be tested. It must be decorated with ``@xp_capabilities``. *args : Any, optional Extra pytest parameters for the use case, e.g.:: @pytest.mark.parametrize("func,verb", [ make_xp_pytest_param(f1, "hello"), make_xp_pytest_param(f2, "world")]) def test(func, verb, xp): # iterates on (func=f1, verb="hello") # and (func=f2, verb="world") See Also -------- xp_capabilities make_xp_test_case array_api_extra.testing.lazy_xp_function rNr>)rFid)rsrKrr)rGr/rrsrFs rNmake_xp_pytest_paramrXps/X !$ NE << Ct C5]] CCrUr))) rrFFrFTrN)cr5rtrrRosr*collections.abcrrrr contextvarsrtypesrtypingr r r rr> numpy.typingnpt scipy._libr scipy._lib.array_api_compatr rrr0rXrr.rr%rr#rr&rr$rrrr!scipy._lib._sparserscipy._lib._docscraper__all__environrr'rrrr(rWr7r8rOrTrrr-rlrrrrr+r*r,rrr1r"r)intrfloatr2r/rr4r5rrrr dataclassrr(r.r3rKrUrXr<rrUrNrks  99%"**'    (- !jjnn->FtFzz~~ne4 '  ys}}, 9,5hy15huo5pJ4$U$z$R48 , !%",,,)*T1,Tk ,   ,,, ,^26)u)Z$.)%)8.8 -FJz*F (: (),<"= ( ( 3#'Dd%P($9=$ $tRDK,.24 $$4B@8<#dBQUJ.**FCFCF3%3Z3D3J:+<048$)&'+/ HeHuSz)D0H!He H"D( H5: H46:  d!2 e  *//Ad!&e;1| U  T(9 U  #  E"%%#%0&(.0&* 0f!8R E$2 dAH6:>26I0:>/DfrU