VpfY9p ddlmZddlmZddlZddlmZmZmZddl Z ddl m Z ddl mZddl mZddl mZddl mZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZmZddlmZddl m!Z"ddl#m$Z$m%Z%ddl&m'Z(ddl&m)Z*ddZ+ddZ,ddZ-ddZ!ddd"Z.edd#Z/edd%Z/edd&Z/d'Z/d(Z0dd)Z1dd*Z2dd+Z3dd,Z4dd-Z5dd.Z6dd/Z7ej8dd0Z9e9:d1dd2Z;ej<Ze=?e>ej8dd5Z@d6ZAe@?eAej8d7ZBd8ZCeB?eCdd9ZDdd;ZEdd>ZFdd?ZGgd@ZHej8dddBZIdddCZJeI?eeeJddDZKe jLdEe jMZNe jLdFe jOZPe jLdGe jMZQe jLdHe jOZRddIZSddJZTddKZUddLZVeej8dMNdddRZWdSZXeW?eXdTZYdUZZddWZ[e j\e j]dXe j^zZ_dYZ`ddZZadd[Zbdd\Zcdd]Zdd^Zed_d`dddZfeedbdcged_d`ddfZgddlZheedXmddnZieedomddpZjddrZkddsZleedtmddxZm dddzZndd{ZoddZpddZqddZrddZsdZtdZudZvddZwddZxej8eddZyeyj?edZzddZ{ddZ|ddZ}eej8dNe j~eddZej?edZddZddZddZddZddZddZej8ddZdZdZe:dddZdZee j~dZee j~dZedZej8ee j~ddZe:dddddddZ'ddddZ)dS)) annotations)partialN)castoverloadAny)jit)jvp)vmap)lax)core)custom_derivatives) deprecations)dtypes)_const)promote_args_inexactpromote_dtypes_inexact)special)betaln)Array ArrayLike)softmax) log_softmaxxrreturnrcNtd|\}tj|S)aLNatural log of the absolute value of the gamma function. JAX implementation of :obj:`scipy.special.gammaln`. .. math:: \mathrm{gammaln}(x) = \log(|\Gamma(x)|) Where :math:`\Gamma` is the :func:`~jax.scipy.special.gamma` function. Args: x: arraylike, real valued. Returns: array containing the values of the log-gamma function See Also: - :func:`jax.scipy.special.gammaln`: the natural log of the gamma function - :func:`jax.scipy.special.gammasgn`: the sign of the gamma function Notes: ``gammaln`` does not support complex-valued inputs. gammaln)rr lgammars V/var/www/html/nettyfy-visnx/env/lib/python3.11/site-packages/jax/_src/scipy/special.pyrr*s#0Iq))"! Actd|\}tj|}tj|dk||kz|dzdkzddS)amSign of the gamma function. JAX implementation of :obj:`scipy.special.gammasgn`. .. math:: \mathrm{gammasgn}(x) = \begin{cases} +1 & \Gamma(x) > 0 \\ -1 & \Gamma(x) < 0 \end{cases} Where :math:`\Gamma` is the :func:`~jax.scipy.special.gamma` function. Because :math:`\Gamma(x)` is never zero, no condition is required for this case. Args: x: arraylike, real valued. Returns: array containing the sign of the gamma function See Also: - :func:`jax.scipy.special.gamma`: the gamma function - :func:`jax.scipy.special.gammaln`: the natural log of the gamma function gammasgnr?)rr floorjnpwhere)rfloor_xs rr"r"FsQ2J**"! IaLL' AEa7l+w{a/?@#t L LLr ctd|\}t|tjtj|zS)aThe gamma function. JAX implementation of :obj:`scipy.special.gamma`. The gamma function is defined for :math:`\Re(z)>0` as .. math:: \mathrm{gamma}(z) = \Gamma(z) = \int_0^\infty t^{z-1}e^{-t}\mathrm{d}t and is extended by analytic continuation to arbitrary complex values `z`. For positive integers `n`, the gamma function is related to the :func:`~jax.scipy.special.factorial` function via the following identity: .. math:: \Gamma(n) = (n - 1)! Args: x: arraylike, real valued. Returns: array containing the values of the gamma function See Also: - :func:`jax.scipy.special.factorial`: the factorial function. - :func:`jax.scipy.special.gammaln`: the natural log of the gamma function - :func:`jax.scipy.special.gammasgn`: the sign of the gamma function Notes: Unlike the scipy version, JAX's ``gamma`` does not support complex-valued inputs. gamma)rr"r exprrs rr+r+ds9BGQ''"! !swsz!}}-- --r abcJtd||\}}t||S)aNatural log of the absolute value of the beta function JAX implementation of :obj:`scipy.special.betaln`. .. math:: \mathrm{betaln}(a, b) = \log B(a, b) where :math:`B` is the :func:`~jax.scipy.special.beta` function. Args: a: arraylike, real-valued. Parameter *a* of the beta distribution. b: arraylike, real-valued. Parameter *b* of the beta distribution. Returns: array containing the values of the log-beta function See Also: :func:`jax.scipy.special.beta` r)r _betaln_implr-r.s rrrs)* h1 - -$!Q a  r Fnexactboolc |rtdtd|\}tj|dkdt jt j|dzS)aFactorial function JAX implementation of :obj:`scipy.special.factorial` .. math:: \mathrm{factorial}(n) = n! = \prod_{k=1}^n k Args: n: arraylike, values for which factorial will be computed elementwise exact: bool, only ``exact=False`` is supported. Returns: array containing values of the factorial. Notes: This computes the float-valued factorial via the :func:`~jax.scipy.special.gamma` function. JAX does not support exact factorials, because it is not particularly useful: above ``n=20``, the exact result cannot be represented by 64-bit integers, which are the largest integers available to JAX. See Also: :func:`jax.scipy.special.gamma` zfactorial with exact=True factorialr)NotImplementedErrorrr'r(r r,r)r2r3s rr6r6s\2 ; 9 : ::K++"! 1q5!SWSZA%6%677 8 88r cdSNr1s rbetar<s/2sr ycdSr:r;)r-r=s rr<r<25#r cdSr:r;)rr=s rr<r<r?r cd|vrDd}tjd|dd|vrtd|d|d<d|vrDd }tjd|dd |vrtd |d|d <|dd hz x}rtd t |t |i|S) a!The beta function JAX implementation of :obj:`scipy.special.beta`. .. math:: \mathrm{beta}(a, b) = B(a, b) = \frac{\Gamma(a)\Gamma(b)}{\Gamma(a + b)} where :math:`\Gamma` is the :func:`~jax.scipy.special.gamma` function. Args: a: arraylike, real-valued. Parameter *a* of the beta distribution. b: arraylike, real-valued. Parameter *b* of the beta distribution. Returns: array containing the values of the beta function. See Also: - :func:`jax.scipy.special.gamma` - :func:`jax.scipy.special.betaln` rzKThe `x` parameter of jax.scipy.special.beta is deprecated, use `a` instead.zjax-scipy-beta-argsr#) stacklevelr-z0beta() got both parameter 'a' and parameter 'x'.r=zKThe `y` parameter of jax.scipy.special.beta is deprecated, use `b` instead.r.z0beta() got both parameter 'b' and parameter 'y'.z(beta() got unexpected keyword arguments )rwarn TypeErrorpopkeyslist_beta)argskwdsmsgextras rr<r<s. D[[ WC+SQ???? d{{ H I II DID[[ WC+SQ???? d{{ H I II DIiikkS#J&&UN LtE{{LL M MM    r ctd||\}}t|t|zt||zz}|tjt ||zS)Nr<)rr"r r,r)r-r.signs rrHrHsY fa + +$!Q !x{{ "Xa!e__ 4$ q! %% %%r cZtd|||\}}}tj|||S)ayThe regularized incomplete beta function. JAX implementation of :obj:`scipy.special.betainc`. .. math:: \mathrm{betainc}(a, b, x) = B(a, b)\int_0^x t^{a-1}(1-t^{b-1})\mathrm{d}t where :math:`B(a, b)` is the :func:`~jax.scipy.special.beta` function. Args: a: arraylike, real-valued. Parameter *a* of the beta distribution. b: arraylike, real-valued. Parameter *b* of the beta distribution. x: arraylike, real-valued. Upper limit of the integration. Returns: array containing values of the betainc function See Also: - :func:`jax.scipy.special.beta` - :func:`jax.scipy.special.betaln` betainc)rr rPr-r.rs rrPrPs1. !Aq! 4 4'!Q Q1  r cNtd|\}tj|S)aThe digamma function JAX implementation of :obj:`scipy.special.digamma`. .. math:: \mathrm{digamma}(z) = \psi(z) = \frac{\mathrm{d}}{\mathrm{d}z}\log \Gamma(z) where :math:`\Gamma(z)` is the :func:`~jax.scipy.special.gamma` function. Args: x: arraylike, real-valued. Returns: array containing values of the digamma function. Notes: The JAX version of `digamma` accepts real-valued inputs. See also: - :func:`jax.scipy.special.gamma` - :func:`jax.scipy.special.polygamma` digamma)rr rSrs rrSrSs#0Iq))"! Qr cTtd||\}}tj||S)a\The regularized lower incomplete gamma function. JAX implementation of :obj:`scipy.special.gammainc`. .. math:: \mathrm{gammainc}(x; a) = \frac{1}{\Gamma(a)}\int_0^x t^{a-1}e^{-t}\mathrm{d}t where :math:`\Gamma(a)` is the :func:`~jax.scipy.special.gamma` function. Args: a: arraylike, real-valued. Positive shape parameter of the gamma distribution. x: arraylike, real-valued. Non-negative upper limit of integration Returns: array containing values of the gammainc function. See Also: - :func:`jax.scipy.special.gamma` - :func:`jax.scipy.special.gammaincc` gammainc)rr igammar-rs rrUrU-s+, j!Q / /$!Q Aq  r cTtd||\}}tj||S)acThe regularized upper incomplete gamma function. JAX implementation of :obj:`scipy.special.gammaincc`. .. math:: \mathrm{gammaincc}(x; a) = \frac{1}{\Gamma(a)}\int_x^\infty t^{a-1}e^{-t}\mathrm{d}t where :math:`\Gamma(a)` is the :func:`~jax.scipy.special.gamma` function. Args: a: arraylike, real-valued. Positive shape parameter of the gamma distribution. x: arraylike, real-valued. Non-negative lower limit of integration Returns: array containing values of the gammaincc function. See Also: - :func:`jax.scipy.special.gamma` - :func:`jax.scipy.special.gammainc` gammaincc)rr igammacrWs rrYrYGs+, k1a 0 0$!Q Q  r cNtd|\}tj|S)aThe error function JAX implementation of :obj:`scipy.special.erf`. .. math:: \mathrm{erf}(x) = \frac{2}{\sqrt\pi} \int_{0}^x e^{-t^2} \mathrm{d}t Args: x: arraylike, real-valued. Returns: array containing values of the error function. Notes: The JAX version only supports real-valued inputs. See also: - :func:`jax.scipy.special.erfc` - :func:`jax.scipy.special.erfinv` erf)rr r\rs rr\r\as#,E1%%"! r cNtd|\}tj|S)a7The complement of the error function JAX implementation of :obj:`scipy.special.erfc`. .. math:: \mathrm{erfc}(x) = \frac{2}{\sqrt\pi} \int_{x}^\infty e^{-t^2} \mathrm{d}t This is the complement of the error function :func:`~jax.scipy.special.erf`, ``erfc(x) = 1 - erf(x)``. Args: x: arraylike, real-valued. Returns: array containing values of the complement of the error function. Notes: The JAX version only supports real-valued inputs. See also: - :func:`jax.scipy.special.erf` - :func:`jax.scipy.special.erfinv` erfc)rr r^rs rr^r^{s#2FA&&"! !r cNtd|\}tj|S)aThe inverse of the error function JAX implementation of :obj:`scipy.special.erfinv`. Returns the inverse of :func:`~jax.scipy.special.erf`. Args: x: arraylike, real-valued. Returns: array containing values of the inverse error function. Notes: The JAX version only supports real-valued inputs. See also: - :func:`jax.scipy.special.erf` - :func:`jax.scipy.special.erfc` erfinv)rr erf_invrs rr`r`s#(Ha(("! Qr c td|\}tjtj|tjt |d|S)zThe logit function JAX implementation of :obj:`scipy.special.logit`. .. math:: \mathrm{logit}(p) = \log\frac{p}{1 - p} Args: x: arraylike, real-valued. Returns: array containing values of the logit function. logitr7)rr logdivsub _lax_constrs rrcrcsG GQ''"! CGJq!$4$4a8899 : ::r c tj|tj|tjt |d|SNr7)r remulrfrg)gansrs rrms4cgaCGJq!4D4Da,H,H!I!IJJr cNtd|\}tj|S)aThe logistic sigmoid (expit) function JAX implementation of :obj:`scipy.special.expit`. .. math:: \mathrm{expit}(x) = \frac{1}{1 + e^{-x}} Args: x: arraylike, real-valued. Returns: array containing values of the expit function. expit)rr logisticrs rroros#GQ''"! ar c td||\}}|dk}tj|tj|tj|tj|S)aCompute x*log(y), returning 0 for x=0. JAX implementation of :obj:`scipy.special.xlogy`. This is defined to return zero when :math:`(x, y) = (0, 0)`, with a custom derivative rule so that automatic differentiation is well-defined at this point. Args: x: arraylike, real-valued. y: arraylike, real-valued. Returns: array containing xlogy values. See also: :func:`jax.scipy.special.xlog1py` xlogy)rr'r(r rjrd zeros_likerr=x_oks rrrrrsT( gq! , ,$!Q b$ 4CGAJJ//1B1B C CCr c|\}}|\}}t||}||tj|z||z|z z|jfSr:)rrr rdastypedtypeprimalstangentsrr=x_doty_dotresults r _xlogy_jvprsV &1a.5% A;;& %#'!**$uqy1}4<!3D3D E EEr c|\}}|\}}t||}||tj|z||zd|zz z|jfSri)rr rrxryrzs r _xlog1py_jvprs[ &1a.5% 1a==& %#)A,,&a!e)<<DDV\RR RRr c"t||S)z/Compute x log(x) with well-defined derivatives.)rrrs r_xlogxrs q!r cd|\}|\}t||tj|dzzfSri)rr rdr{r|rr}s r _xlogx_jvpr s2"! &% ))Ucgajj1n- --r c td|\}tjtj|t |dtj|t j tjt|S)aThe entropy function JAX implementation of :obj:`scipy.special.entr`. .. math:: \mathrm{entr}(x) = \begin{cases} -x\log(x) & x > 0 \\ 0 & x = 0\\ -\infty & x > 0 \end{cases} Args: x: arraylike, real-valued. Returns: array containing entropy values. See also: - :func:`jax.scipy.special.kl_div` - :func:`jax.scipy.special.rel_entr` entrr) rr selectltrg full_likenpinfnegrrs rrr'sg.FA&&"! CF1jA..//M!bfW--GF1II&& ( ((r dc tjt|d}td||\}}t jt jt jt |d|t j|t |dt jt |tj }t j tj ||jt |d}tjt!tj|dtj|t%t'|jz d}||zS) a-The natural log of the multivariate gamma function. JAX implementation of :func:`scipy.special.multigammaln`. .. math:: \mathrm{multigammaln}(a, d) = \log\Gamma_d(a) where .. math:: \Gamma_d(a) = \pi^{d(d-1)/4}\prod_{i=1}^d\Gamma(a-(i-1)/2) and :math:`\Gamma(x)` is the :func:`~jax.scipy.special.gamma` function. Args: a: arraylike, real-valued. d: int, the dimension of the integration space. Returns: array containing values of the log-multigamma function. See also: - :func:`jax.scipy.special.gamma` zd argument of multigammaln multigammalng?r7ryr#axis)r concrete_or_errorintrr rjrgrfrdrpirer'arangerysumr expand_dimstuplerangendim)r-rd_constantr.ress rrrDs16 S!%ABB! ~q! 4 4%!R WSWSWZ4%8%8"== WRAq)9)9::<<WZ25112244( gcj"(+++Z1-=-=>>! 333eAFmm0D0DEEEFGG   # xr pqcVtd||\}}t|||z |zS)aThe Kullback-Leibler divergence. JAX implementation of :obj:`scipy.special.kl_div`. .. math:: \mathrm{kl\_div}(p, q) = \begin{cases} p\log(p/q)-p+q & p>0,q>0\\ q & p=0,q\ge 0\\ \infty & \mathrm{otherwise} \end{cases} Args: p: arraylike, real-valued. q: arraylike, real-valued. Returns: array of KL-divergence values See also: - :func:`jax.scipy.special.entr` - :func:`jax.scipy.special.rel_entr` kl_div)rrel_entr)rrs rrrls16 h1 - -$!Q !Q! a r c Ztd||\}}t|d}tjtj||tj||}tjtj||tj||}tj||d}tj||d}tj t|t||}tj||tj||tj }|S)aThe relative entropy function. JAX implementation of :obj:`scipy.special.rel_entr`. .. math:: \mathrm{rel\_entr}(p, q) = \begin{cases} p\log(p/q) & p>0,q>0\\ 0 & p=0,q\ge 0\\ \infty & \mathrm{otherwise} \end{cases} Args: p: arraylike, real-valued. q: arraylike, real-valued. Returns: array of relative entropy values. See also: - :func:`jax.scipy.special.entr` - :func:`jax.scipy.special.kl_div` rrsr7) rrgr bitwise_andgteqger'r(rfrrrr) rrzeroboth_gt_zero_mask one_zero_masksafe_psafe_qlog_valrs rrrs6 j!Q / /$!Q As  $ocfQoosvaGG/#&D//36!T??CC- 9&1 - -& 9&1 - -& GF6NNE&&$9$9 : :' 9#)M4"I"I  & -r ) i0i viigS`3lKEgPq wg+cQ{Bg1oXU0gީ~#'Cg2HUgopyL.Dgi Tg"WDg.,ArrayLike | Nonecv|tdtd||\}}tj||S)aTThe Hurwitz zeta function. JAX implementation of :func:`scipy.special.zeta`. JAX does not implement the Riemann zeta function (i.e. ``q = None``). .. math:: \zeta(x, q) = \sum_{n=0}^\infty \frac{1}{(n + q)^x} Args: x: arraylike, real-valued q: arraylike, real-valued Returns: array of zeta function values N[Riemann zeta function not implemented; pass q != None to compute the Hurwitz Zeta function.zeta)r8rr r)rrs rrrsF$Y c e ee fa + +$!Q !Qr c6|tdtd||\}}tj|j}t j|dt j|d}}tj|t jkr |dn |dx}}|ttksJt jtj ||jtt|j} t j|| z| zd} tj||z|d|z z||dz } ||z| z} t jtj d|z|jtt|j} || z||zz }t j|dd dddf}t j|t j|j }tjtjtd|jd|tt|j}||z }| |d |dzz}| | z|zS) Nrrrrr7r#.)max?)r8rr rytyper'rfloat32len_BERNOULLI_COEFSrrrrrrrecumprodclipfinforarrayshape)rrsr-rys_a_NMkSIT0ms_over_aT1coefsTs r_zeta_series_expansionrsGY c e ee fa + +$!Q )A,, % ?1b ! !3?1b#9#9b"illck11%%(((uuRyy@!a c"## # # # # obi1115qv3G3GHH! grAv2#or""! gq1u%%((Q,'UU1XX66! A1"}" obiAQW555uU16]]7K7KLL!1fa ( {8R  ccc*" x %((,---" ."2=BHRL="AOOOuQV}}-- / /% Ez"EE#JJ #$! Qr ctjtj|tjsJt d||\}}tj||S)aThe polygamma function. JAX implementation of :func:`scipy.special.polygamma`. .. math:: \mathrm{polygamma}(n, x) = \psi^{(n)}(x) = \frac{\mathrm{d}^n}{\mathrm{d}x^n}\log \Gamma(x) where :math:`\Gamma` is the :func:`~jax.scipy.special.gamma` function. Args: n: arraylike, integer-valued. The order of the derivative. x: arraylike, real-valued. The value at which to evaluate the function. Returns: array See also: - :func:`jax.scipy.special.gamma` - :func:`jax.scipy.special.digamma` polygamma)r' issubdtyper ryintegerrr)r2rn_arrx_arrs rrrsM,  ! ck 2 2222%k1a88,% ue $ $$r iirctj|}tj|}|tjtjfvr"t d|t|S)acNormal distribution function. JAX implementation of :obj:`scipy.special.ndtr`. Returns the area under the Gaussian probability density function, integrated from minus infinity to x: .. math:: \begin{align} \mathrm{ndtr}(x) =& \ \frac{1}{\sqrt{2 \pi}}\int_{-\infty}^{x} e^{-\frac{1}{2}t^2} dt \\ =&\ \frac{1}{2} (1 + \mathrm{erf}(\frac{x}{\sqrt{2}})) \\ =&\ \frac{1}{2} \mathrm{erfc}(\frac{x}{\sqrt{2}}) \end{align} Args: x: An array of type `float32`, `float64`. Returns: An array with `dtype=x.dtype`. Raises: TypeError: if `x` is not floating-type. ?x.dtype={} is not supported, see docstring for supported types.) r'asarrayr ryrfloat64rDformat_ndtrrrys rndtrrls_2 k!nn! )A,,% 3; ,,, I    q/r c tj|j}|dtjd|z}||z}tj|}tjtj|||dtj|ztjtj ||d|dtj |z tj |}|d|zS)zImplements ndtr core logic.r@rr$rs) r ryrrsqrtabsrrr\rr^)rry half_sqrt_2wzr=s rrrs )A,, %c RWRu5555++o! gajj! j;''eBii#'!**,j5599!5!5&+eBii#(1++&=&)hqkk3344! sar ctj|}|tjtjfvr"t d|t|S)aThe inverse of the CDF of the Normal distribution function. JAX implementation of :obj:`scipy.special.ndtri`. Returns `x` such that the area under the PDF from :math:`-\infty` to `x` is equal to `p`. A piece-wise rational approximation is done for the function. This is based on the implementation in netlib. Args: p: an array of type `float32`, `float64`. Returns: an array with `dtype=p.dtype`. Raises: TypeError: if `p` is not floating-type. r)r ryr'rrrDr_ndtri)rrys rndtrirsS( )A,,% 3; ,,, I    r c 2ttgd}ttgd}ttgd}ttgd}ttgd}ttgd}tj|jt j|}fdt j|tj d kd |z |}t j|d kt j |d |} | d z } tj | } | | | z| || |z zz} | tj d tj z z} tj dtj| z} | tj| | z z }d | z |d | z |z | z }d | z |d | z |z | z }||z }||z }t j| tjdk| t j| d k||}t j|d tjdz k|| }t j |tj}t j|d k| t j|d k||}|S)zImplements ndtri core logic.)g-^OMgX@gVLg;+@g~) r$gt ҕE?g@gԁ 5U@g_6V.lgSi@gٷaTgcu/@gͿ) gێ<8@gyՒm?@gBהL@gN F@g>F^-@glz9~@gwDgAcglL) r$g;Z/@go)F@gF"D@gE؇.@g < @g2 3¿gmENg}yN) gtՓ @g x'1@g+@g T?gQ&^E?gM5iPV?g3?g4" L)L>gX0:>) r$g(V@g8ҪMp @gb*G?g<_?gǶ'|?g)e+5?gC>g=kv)=>ctj|}|jstj|S|d||dd|zzS)z2Compute n_th order polynomial via Horner's method.rr7N)rrsizer'rt)varcoeffs_create_polynomialrys rrz"_ndtri.._create_polynomialsX Xfe $ $F ;! ^C  !9))#vabbz::S@ @@r gr$rsrrg @)rGreversedr ryrr'rr(rexpm1fullsquarerrrdr,r)rp0q0p1q1p2q2rmaybe_complement_p sanitized_mcprww x_for_big_pr first_termsecond_term_small_psecond_term_otherwise x_for_small_p x_otherwiserinfinityx_fix_boundariesrrys @@rrrs  H111 2 233"  H111 2 233" H222 3 344" H222 3 344" H111 2 233" H111 2 233" )A,, % )A,,%AAAAAAyUUBHSMM>%:%:!:EE"IIM1MM)EE"II% hueeCjj!!- eeCjj ! z!}}"AF00R88 2 22r : :;<<+ %%RU ++,,,,+  huuSzzCGM22233!371::>!*rQ++rQ++,./0rQ++rQ++,./022-22+ i bfSkk 2 22 !uuSzz/=+FFHH! iEE"rvc{{*+++Q33! XeUU26]] + +(Y55::oy#)AsOXq"I"IKK r )r7)nondiff_argnums series_orderrct|tstd|dkrtd|dkrtdt j|}t j|}|tjkrt}t}nD|tj krt}t}n%tdtj|dt jt j||t#|  t jt j||t jt#t j||t)t j|||S)aLog Normal distribution function. JAX implementation of :obj:`scipy.special.log_ndtr`. For details of the Normal distribution function see `ndtr`. This function calculates :math:`\log(\mathrm{ndtr}(x))` by either calling :math:`\log(\mathrm{ndtr}(x))` or using an asymptotic series. Specifically: - For `x > upper_segment`, use the approximation `-ndtr(-x)` based on :math:`\log(1-x) \approx -x, x \ll 1`. - For `lower_segment < x <= upper_segment`, use the existing `ndtr` technique and take a log. - For `x <= lower_segment`, we use the series approximation of `erf` to compute the log CDF directly. The `lower_segment` is set based on the precision of the input: .. math:: \begin{align} \mathit{lower\_segment} =& \ \begin{cases} -20 & x.\mathrm{dtype}=\mathit{float64} \\ -10 & x.\mathrm{dtype}=\mathit{float32} \\ \end{cases} \\ \mathit{upper\_segment} =& \ \begin{cases} 8& x.\mathrm{dtype}=\mathit{float64} \\ 5& x.\mathrm{dtype}=\mathit{float32} \\ \end{cases} \end{align} When `x < lower_segment`, the `ndtr` asymptotic series approximation is: .. math:: \begin{align} \mathrm{ndtr}(x) =&\ \mathit{scale} * (1 + \mathit{sum}) + R_N \\ \mathit{scale} =&\ \frac{e^{-0.5 x^2}}{-x \sqrt{2 \pi}} \\ \mathit{sum} =&\ \sum_{n=1}^N {-1}^n (2n-1)!! / (x^2)^n \\ R_N =&\ O(e^{-0.5 x^2} (2N+1)!! / |x|^{2N+3}) \end{align} where :math:`(2n-1)!! = (2n-1) (2n-3) (2n-5) ... (3) (1)` is a `double-factorial `_ operator. Args: x: an array of type `float32`, `float64`. series_order: Positive Python integer. Maximum depth to evaluate the asymptotic expansion. This is the `N` above. Returns: an array with `dtype=x.dtype`. Raises: TypeError: if `x.dtype` is not handled. TypeError: if `series_order` is a not Python `integer.` ValueError: if `series_order` is not in `[0, 30]`. z&series_order must be a Python integer.rz"series_order must be non-negative.zseries_order must be <= 30.x.dtype=z is not supported.) isinstancerrD ValueErrorr'rr ryr_LOGNDTR_FLOAT64_LOWER_LOGNDTR_FLOAT64_UPPERr_LOGNDTR_FLOAT32_LOWER_LOGNDTR_FLOAT32_UPPERrr(rrrdr_log_ndtr_lowermin)rrrry lower_segment upper_segments rlog_ndtrr%sX~ L# & &> < = ==A 9 : ::B 2 3 33 +a..% )E  % ck 6M 6MM  *M*MM BrxBBB C CC  fUM"" eV}}n ium,,wuSWUM%B%BCCDD&swum'D'D'35566 7 77r c ||c\}\}t||}tj|tjtjt ||}||fS)N)r)rr rjr,rf _norm_logpdf)rr{r|rtrlt_outs r _log_ndtr_jvpr!sZ*$1...# '!SWSW\!__c::;; < <% er cLtj|j}tj|}|d |ztj| z |dt jdt jzzz }|tjt||zS)zGAsymptotic expansion version of `Log[cdf(x)]`, appropriate for `x<<-1`.rr)r ryrrrdrr_log_ndtr_asymptotic_series)rrryx_2 log_scales rrrs )A,, % 1 #uSzzkC#'1"++-cBF2: B BBr cNtd|\}tj|S)aExponentially scaled modified bessel function of zeroth order. JAX implementation of :obj:`scipy.special.i0e`. .. math:: \mathrm{i0e}(x) = e^{-|x|} I_0(x) where :math:`I_0(x)` is the modified Bessel function :func:`~jax.scipy.special.i0`. Args: x: array, real-valued Returns: array of bessel function values. See also: - :func:`jax.scipy.special.i0` - :func:`jax.scipy.special.i1` - :func:`jax.scipy.special.i1e` i0e)rr bessel_i0ers rr5r5%,E1%%"!   r ctd|\}tjtjtj|tj|S)aModified bessel function of zeroth order. JAX implementation of :obj:`scipy.special.i0`. .. math:: \mathrm{i0}(x) = I_0(x) = \sum_{k=0}^\infty \frac{(x^2/4)^k}{(k!)^2} Args: x: array, real-valued Returns: array of bessel function values. See also: - :func:`jax.scipy.special.i0e` - :func:`jax.scipy.special.i1` - :func:`jax.scipy.special.i1e` i0)rr rjr,rr6rs rr9r9C(D!$$"! $$cnQ&7&7 8 88r cNtd|\}tj|S)aExponentially scaled modified bessel function of first order. JAX implementation of :obj:`scipy.special.i1e`. .. math:: \mathrm{i1e}(x) = e^{-|x|} I_1(x) where :math:`I_1(x)` is the modified Bessel function :func:`~jax.scipy.special.i1`. Args: x: array, real-valued Returns: array of bessel function values See also: - :func:`jax.scipy.special.i0` - :func:`jax.scipy.special.i0e` - :func:`jax.scipy.special.i1` i1e)rr bessel_i1ers rr<r<r7r ctd|\}tjtjtj|tj|S)aModified bessel function of first order. JAX implementation of :obj:`scipy.special.i1`. .. math:: \mathrm{i1}(x) = I_1(x) = \frac{1}{2}x\sum_{k=0}^\infty\frac{(x^2/4)^k}{k!(k+1)!} Args: x: array, real-valued Returns: array of bessel function values See also: - :func:`jax.scipy.special.i0` - :func:`jax.scipy.special.i0e` - :func:`jax.scipy.special.i1e` i1)rr rjr,rr=rs rr?r? r:r c|\}}}}d|dzz|z|z |z }d}d}tjtj|ddk||||f}|}|}||||f|fS)Nrr$c|\}}|d|zzS)Nrr;)ubsfs rtrue_fn_update_bsz3_bessel_jn_scan_body_fun..true_fn_update_bs$s EB a<r c|\}}|Sr:r;)rBrC_s rfalse_fn_update_bsz4_bessel_jn_scan_body_fun..false_fn_update_bs(s EB Ir r#r)operand)r condr'mod) carryrf0f1rCrrDrErHs r_bessel_jn_scan_body_funrO s-"b"a QWoQ#! x1 "$5"RG555" "" b"a! r 2)n_iterrvrQc bt|d}t|d}t|d}t|d}tjt||||ftjtj||dzd\\}}}}}|d}|d|dz}|||z z }|S)NrsgؗҜ 20`. Details in `BJNDD` (https://people.sc.fsu.edu/~jburkardt/f77_src/special_functions/special_functions.f) Returns: An array of shape `(v+1, *z.shape)` containing the values of the Bessel function of orders 0, 1, ..., v. The return type matches the type of `z`. Raises: TypeError if `v` is not integer. ValueError if elements of array `z` are not float. zcomplex input not supported.zArgument v of bessel_jn.zArgument n_iter of bessel_jn.)rRrQrr)r'rrr ryrrcomplexrr roperatorindexrrrZrrr moveaxis)rrRrQz_dtype bessel_jn_funrGs r bessel_jnrcEs4 k!nn!a  "! IaLL' w((5 3 4 44 X^Q0JKK!  !#v/N O O&*&999- ==((a''MM mmA&&A . ..r l_max is_normalizedryrtuple[Array, Array]ctjtj|dz|tj|dz|d\}}|rd||z}||z}d|z}|dz |dz z}tjd|zdz ||z z } tj|dz||z z|dz ||z zz } nd|zdz ||z z } ||zdz ||z z } tj|dzd} tj|dzd } tj|dz|dzf|} | j| | | }| j| | | }tjd |dzd |dzd |dzf\}}}||z|z d k |}tj d ||}tj d ||}||fS) aGenerates a mask for recurrence relation on the remaining entries. The remaining entries are with respect to the diagonal and offdiagonal entries. Args: l_max: see `gen_normalized_legendre`. is_normalized: True if the recurrence mask is used by normalized associated Legendre functions. Returns: Arrays representing the mask used by the recurrence relations. r7rijindexingrr$g@@r#Nrz jk,ijk->ijk) r'meshgridrr triu_indiceszerosatsetogridrxeinsum)rdrerym_matl_matc0c1c2c3d0d1d0_mask_indicesd1_mask_indicesd_zerosd0_maskd1_maskijrmask d0_mask_3d d1_mask_3ds r_gen_recurrence_maskrns$Juqy&&&Juqy&&& ,% 1 B B uB #+%#+ &B 38c>b2g. / /B BHb)rCxBG.DE F FBB +  .B %-# %%- 0B$UQY22/$UQY22/ Iuqy%!),E : : :' J ' + +B,? @ @' J ' + +B,? @ @' Ijuqyj*519*juqyj8 9'!Q a%!)q.  ' '$z-$77*z-$77* j !!r )static_argnumsc  |j\}}}tj|dddd|ddf}tj|dd|dzddddf}tj|dd|ddddf}|rtd|dkrytjd|dz |j} |dd|dz ddf} d | dz| zz } tjd | | } |jdd|ddf| }|dkrtjd|dz |j} |dd|dz ddf} d | dz| dzz| z| dz zz } tjd | | }|jd d |ddf|}tj tj||jtj||jd\}}tj ||f|j}tj |d |}tj |f|j}d|d z z }|j|||}|jdddf|}||z}||dz z|d z z}|j|||}|jdddf|}tjd||tjd||z}d|d zz }|j|||}||z|d zz}|j|||}tjd||tjd||z}|||z d zzdz }|j|||} tjd| |d|zz }!|dkrtj||j} tjd | dz| z|d ddddf}"|dkr|"|dddddfz }"tjddtj d||zz z |"}#|!jdddddf|#}!|!jdd ddfd }!|!S)a Generates derivatives of associated Legendre functions of the first kind. Args: p: The 3D array containing the values of associated Legendre functions; the dimensions are in the sequence of order (m), degree (l), and evaluation points. x: A vector of type `float32` or `float64` containing the sampled points. is_normalized: True if the associated Legendre functions are normalized. Returns: The 3D array representing the derivatives of associated Legendre functions of the first kind. )rr)r7rrN)rr#rrr#))r#rrrz9Negative orders for normalization is not implemented yet.r7rr%i,ij->ijr$rr rhrir0r ij,ijk->ijkrzj,ij->ij) rr'padr8rryrrrorprlrnrmr)$rrrenum_mnum_lnum_xp_m_lm1 p_mp2_lm1 p_mm2_lm1l_vecp_p1coeff update_p_p1p_p2 update_p_p2rsrt coeff_zerosupper_0_indiceszero_veca0 a0_maskedb0ru c0_maskedp_mm1_lry d0_maskede0 e0_maskedp_mp1_lrM f0_masked p_derivativeg0p_derivative_m0s$ r_gen_derivativesrs%"% GA/ 0 0FUFAAA >'gg788519aaa9JK)gg788%AAAF)? C E EE qyyjEAIQW555e q!EAI+qqq !duqyE)*eJz5$77k,q!E'111}-11+>>i qyyjEAIQW555e q!EAI+qqq !deaiEAI.6%!)DEeJz5$77k,q!E'111}-11+>>iJuAG$$$JuAG$$$ ,%  5%.888+$UAu55/ Yxqw / / /( us{"n_-11"_2EFF)l1aaa4 $$X..) u}" R#X"s(#"n_-11"_2EFF)l1aaa4 $$X..)Z y' : : Z y) < <=' us{"n_-11"_2EFF) Bw"s("n_-11"_2EFF)Z y) < < Z y' : :;' UU]S !C'"n_-11"_2EFF)M9g>>wN, QYY JuAG , , ,E Je 3Qq!!!QQQwZ @ @B qyy 1aaa7 bjS38AAI3F3F-FKKO?1aaa7+//@@L?1a7+//22L r rc tj|dz|dzjdfj}tjd|dzj}tj|j}|rkdtjtjz }tjdtjdd|z zz}tjd|zdz}n$d}tjdd|zz }d|zdz}|jd  |}tjtj tjdzz |jdfd } |tj d || z} tj |dz} |j| ddd | ddd f | }tj d tj d||tj |} | dd || dd |dzf} |j|  | }t||j\fd}|tj|}|dkrt!jd|dz||}|S)u Computes associated Legendre functions (ALFs) of the first kind. The ALFs of the first kind are used in spherical harmonics. The spherical harmonic of degree `l` and order `m` can be written as `Y_l^m(θ, φ) = N_l^m * P_l^m(cos(θ)) * exp(i m φ)`, where `N_l^m` is the normalization factor and θ and φ are the colatitude and longitude, respectively. `N_l^m` is chosen in the way that the spherical harmonics form a set of orthonormal basis functions of L^2(S^2). For the computational efficiency of spherical harmonics transform, the normalization factor is used in the computation of the ALFs. In addition, normalizing `P_l^m` avoids overflow/underflow and achieves better numerical stability. Three recurrence relations are used in the computation. Args: l_max: The maximum degree of the associated Legendre function. Both the degrees and orders are `[0, 1, 2, ..., l_max]`. x: A vector of type `float32`, `float64` containing the sampled points in spherical coordinates, at which the ALFs are computed; `x` is essentially `cos(θ)`. For the numerical integration used by the spherical harmonics transforms, `x` contains the quadrature points in the interval of `[-1, 1]`. There are several approaches to provide the quadrature points: Gauss-Legendre method (`scipy.special.roots_legendre`), Gauss-Chebyshev method (`scipy.special.roots_chebyu`), and Driscoll & Healy method (Driscoll, James R., and Dennis M. Healy. "Computing Fourier transforms and convolutions on the 2-sphere." Advances in applied mathematics 15, no. 2 (1994): 202-250.). The Gauss-Legendre quadrature points are nearly equal-spaced along θ and provide exact discrete orthogonality, (P^m)^T W P_m = I, where `T` represents the transpose operation, `W` is a diagonal matrix containing the quadrature weights, and `I` is the identity matrix. The Gauss-Chebyshev points are equally spaced, which only provide approximate discrete orthogonality. The Driscoll & Healy quadrature points are equally spaced and provide the exact discrete orthogonality. The number of sampling points is required to be twice as the number of frequency points (modes) in the Driscoll & Healy approach, which enables FFT and achieves a fast spherical harmonics transform. is_normalized: True if the associated Legendre functions are normalized. With normalization, `N_l^m` is applied such that the spherical harmonics form a set of orthonormal basis functions of L^2(S^2). Returns: The 3D array of shape `(l_max + 1, l_max + 1, len(x))` containing the values of the ALFs at `x`; the dimensions in the sequence of order, degree, and evaluation points. r7rrrrr$rrkrrrNz ij,ij->ijzi,j->ij)reryc |}|}tjd|tjdtj|ddtjd|tj|ddz }||z}|S)Nrz ijk,k->ijkr7)shiftrr#)r'rrroll)rp_valcoeff_0coeff_1hrrrs rbody_funz*_gen_associated_legendre..body_funTsmGmG MJ$chuAA&F&F&FKK L L M7CHU!!,L,L,L M M  NA AIE Lr r#)lowerupperrinit_val)r'rnrryrrrrrorp broadcast_torr diag_indicesrrx result_typer fori_loop)rdrrera_idxb_idx initial_valuef_af_br=p_diagr p_offdiagoffdiag_indicesrrrs ` @@r_gen_associated_legendrersb iEAIqwqz2!'BBB! *Q  1 1 1% *U!' * * *%"SXcf%5%55M +b38C#+$5666 7 7C (3;$ % %CCM +cC%K' ( (C + Cd6l}%%! k sxa!e ,,uagaj.ABB ! 3:j#q99 9&!%!),,,dLOABB a!4 56::6BB!jIsA663+E22355)"!_VeV,l1ofuf.E.IJ/d? **!0 =999*j       hhsq!Z0011! QYY AU1Wx!LLLA (r rctj|}|tjtjfvr"t d||jdkrtdtj t|d}tj t|d}||krtd|}d}t|||}t|||}||fS)aHThe associated Legendre functions (ALFs) of the first kind. Args: m: The maximum order of the associated Legendre functions. n: The maximum degree of the associated Legendre function, often called `l` in describing ALFs. Both the degrees and orders are `[0, 1, 2, ..., l_max]`, where `l_max` denotes the maximum degree. z: A vector of type `float32` or `float64` containing the sampling points at which the ALFs are computed. Returns: A 2-tuple of 3D arrays of shape `(l_max + 1, l_max + 1, len(z))` containing the values and derivatives of the associated Legendre functions of the first kind. The return type matches the type of `z`. Raises: TypeError if elements of array `z` are not in (float32, float64). ValueError if array `z` is not 1D. NotImplementedError if `m!=n`. ?z.dtype={} is not supported, see docstring for supported types.r7z must be a 1D array.Argument m of lpmn.Argument n of lpmn.,Computations for m!=n are not yet supported.F)r ryr'rrrDrrrr rrr8rr)rr2rryrdrep_vals p_derivativess rlpmnrgs* )A,,% 3; ,,, I   Vq[[ , - -- S!%:;;! S!%:;;!!VV L M MM %- #E1m < <&"61m<<- -  r ctj|}|tjtjfvr"t d||jdkrtdtj t|d}tj t|d}||krtd|}t|||S)u}The associated Legendre functions (ALFs) of the first kind. Unlike `lpmn`, this function only computes the values of ALFs. The ALFs of the first kind can be used in spherical harmonics. The spherical harmonic of degree `l` and order `m` can be written as :math:`Y_l^m(\theta, \phi) = N_l^m * P_l^m(\cos \theta) * \exp(i m \phi)`, where :math:`N_l^m` is the normalization factor and θ and φ are the colatitude and longitude, respectively. :math:`N_l^m` is chosen in the way that the spherical harmonics form a set of orthonormal basis function of :math:`L^2(S^2)`. Normalizing :math:`P_l^m` avoids overflow/underflow and achieves better numerical stability. Args: m: The maximum order of the associated Legendre functions. n: The maximum degree of the associated Legendre function, often called `l` in describing ALFs. Both the degrees and orders are `[0, 1, 2, ..., l_max]`, where `l_max` denotes the maximum degree. z: A vector of type `float32` or `float64` containing the sampling points at which the ALFs are computed. is_normalized: True if the associated Legendre functions are normalized. With normalization, :math:`N_l^m` is applied such that the spherical harmonics form a set of orthonormal basis functions of :math:`L^2(S^2)`. Returns: A 3D array of shape `(l_max + 1, l_max + 1, len(z))` containing the values of the associated Legendre functions of the first kind. The return type matches the type of `z`. Raises: TypeError if elements of array `z` are not in (float32, float64). ValueError if array `z` is not 1D. NotImplementedError if `m!=n`. rr7rrrr)r ryr'rrrDrrrr rrr8r)rr2rreryrds r lpmn_valuesrsD )A,,% 3; ,,, I   Vq[[ , - -- S!%:;;! S!%:;;!!VV L M MM % !%M : ::r )thetaphin_maxctj|}t||d}|jt ||tjt |fd}t ||z}tj tj|tj |} tj |tj | z|tj | z} tj |dkdt |ztj| z| } | S)z!Computes the spherical harmonics.Tr)moderr%)r'cosrrorrrgetr r]sinrealimagr( conjugate) rr2rrrcos_colatitudelegendre legendre_valangle vandermonde harmonicss r _sph_harmrs73<<. %e^T B B(SVVQ 3q66(:(::;??V?LL, a&&5.% CGENNCGENN;;+k,+)>)>>&+)>)>>@@)iAAy)A)AA!##) r int | Nonectj|rtj|g}|tj|}t jt|d}t|||||S)aComputes the spherical harmonics. The JAX version has one extra argument `n_max`, the maximum value in `n`. The spherical harmonic of degree `n` and order `m` can be written as :math:`Y_n^m(\theta, \phi) = N_n^m * P_n^m(\cos \phi) * \exp(i m \theta)`, where :math:`N_n^m = \sqrt{\frac{\left(2n+1\right) \left(n-m\right)!} {4 \pi \left(n+m\right)!}}` is the normalization factor and :math:`\phi` and :math:`\theta` are the colatitude and longitude, respectively. :math:`N_n^m` is chosen in the way that the spherical harmonics form a set of orthonormal basis functions of :math:`L^2(S^2)`. Args: m: The order of the harmonic; must have `|m| <= n`. Return values for `|m| > n` are undefined. n: The degree of the harmonic; must have `n >= 0`. The standard notation for degree in descriptions of spherical harmonics is `l (lower case L)`. We use `n` here to be consistent with `scipy.special.sph_harm`. Return values for `n < 0` are undefined. theta: The azimuthal (longitudinal) coordinate; must be in [0, 2*pi]. phi: The polar (colatitudinal) coordinate; must be in [0, pi]. n_max: The maximum degree `max(n)`. If the supplied `n_max` is not the true maximum value of `n`, the results are clipped to `n_max`. For example, `sph_harm(m=jnp.array([2]), n=jnp.array([10]), theta, phi, n_max=6)` actually returns `sph_harm(m=jnp.array([2]), n=jnp.array([6]), theta, phi, n_max=6)` Returns: A 1D array containing the spherical harmonics at (m, n, theta, phi). NzThe `n_max` argument of `jnp.scipy.special.sph_harm` must be statically specified to use `sph_harm` within JAX transformations.) r'isscalarrrrr rrr)rr2rrrs rsph_harmrsqF \# )SE  C ] F1IIE   5N O O% 1aU + ++r c"gd}gd}tj||j}tj||j}tj||tj||z }||ztjztj|zS)N)gfgrG(Pk@g`χPg>x@gN P(9煘)3M8A)r$gX$@JgEv@g_'g鏱9Ag-C&rr)r'rrypolyval euler_gammard)rABA_arrB_arrrDs r_expint1rs!! )AQW % % %% )AQW % % %% k%ck%333! Q 371:: --r r list[float]rc2tj||j}tj||j}t|d}||z }tj||tj||z }||z|z}tj||z|zS)Nrr$)r'rryrgrr,)rrrrronerrDs r_eval_expint_kr2s )AQW % % %% )AQW % % %%1c# Ag! k%ck%333!!eck! a! r c4gd}gd}t|||S)N)g `V,1K?gN{Xg+qggmZ @g0$N8ܿg=S?g`PYg,n߁?)r$gA?gE]l?gIUW?gScjw?gY)R:r?gSS&?g ٹ?rrrrs r_expint2r=s8   !   ! 1a  r c4gd}gd}t|||S)N)g󲛯g/Sg!J?gwh]Lпga*\?g*re QgL?g r>) r$giy?gT]j?g\?gw.?gTp1L?gxV>?gТӾgv[>rrs r_expint3rV8   !   ! 1a  r c4gd}gd}t|||S)N) gܞHgn&G?gD Ͽg(Kȗ?go /?g}$4 gJԼǾ>gGW󇘾g3uO>g^]h8>) r$g$>:TJjͿgD;J?g`0 gO.uf?gTzb+g٨%L>gR* 흾gBw6,M>gl\[">rrs r_expint4rps8   !   ! 1a  r c4gd}gd}t|||S)N)gvϿg5F9¿g ?%=?g gV?g4gP/CU.>g/f) r$g9\pg\!ѿgE{H"Ѹ?gOVfgiCkX?g.G/g[Y>gZg2) r$gW[8gwM+?gC68ѿgJ? ?g+kg=x(?gMd~y ھg|e[gã>g/rrs r_expint7rs8   !   ! 1a  r c tdkdkzgfdtddDz}tj|tt t ttttgS)Nrr#c dg|],}d|zkd|dzzkz-S)r#r7r;).0r_crs r z_expi_pos..sW0009:RR16]]Q11aAEl 3 334000r r7) rgrr' piecewiserrrrrrr)rcondsrs` @r _expi_posr s" Bq!HHqLQ""Q((] + ,00000>CAqkk000 %   x8XxJ  r c$t|  Sr:)exp1rs r _expi_negr s r((r cttd|\}tj||dkgttgS)aHExponential integral function. JAX implementation of :obj:`scipy.special.expi` .. math:: \mathrm{expi}(x) = \int_{-\infty}^x \frac{e^t}{t} \mathrm{d}t Args: x: arraylike, real-valued Returns: array of expi values See also: - :func:`jax.scipy.special.expn` - :func:`jax.scipy.special.exp1` expir)rr'rr r )rrs rrrs4*  * *&% uuqykIy+A B BBr cd|\}|\}t|tj||z |zfSr:)rr'r,rs rexpi_jvprs4 $1 (5 a#'!**q.5( ((r x_inc t tj|}tj|jj  |d |d tj tj|z }tj  |d| fd|}tj | |dk z|}t||  |z tj | |dk |z z tj } fd} fd}tj |||}|} | |dz } |d| z|ztjt| z |d z S) Nrsr$r7c||z zSr:r;)rpsirs rrmz_expn1..s#a-r )rrxkykpkrlrc ~|dxxz cc<|dxx|d|dz zcc<|dxxz cc<|dxxtj|dk|d|dz z cc<tj|dkt|d|dz |d<|S)Nrrrrrlrr'r(r)rrrs rbodyz_expn1..bodysdGGGsNGGGdGGGqv$GGGdGGGsNGGGeHHH !D'T/1T7QtW+.cond&s- cFRR#__ $3& 99r rrl)rgr'rrryepsrrdr rr(dictr while_loopr,r)r2rrrn1rTrrJrrrrrrrs @@@@r_expn1r# s" k$! 9QW   !& As$ 1c # 371::%# bbAhh#?#?#?#?EE# ybbAhhc 1--" b   Qw !rr!Qxx-scBh'788 g   $      :::::: nT4&&!!""Q((l! 31s SWWQZZ00 01U8 ;;r c  t|dtjjj|d |d t d | |z |zz |tj | } fd}fd}tj|||}|dtj | zS) NgCrsr$r7) rpkm2qkm2pkm1qkm1rlrr"rc z|d}|dxx|ddz cc<|d}||dz|dk}tj||}tj|||dz |dz z||dz }|d|z|d|zz}|d|z|d|zz}|k}tj|||z |d x|d <} tj|t|d | z | z |d <tj|| |d |d <|d|d<||d<|d|d<||d<t|k} d D]7} d D]2} | dz| z} tj| || z || || <38|S)Nrrr7r#r'r%r(r&r"rlrpq12kmr)rrroddrrrqknzr"is_bigrrkeyBIGrr2rrs rrz_expn2..bodyCs #AcFFFbb3mmFFF #A bbAhh,""Q(( "C 3Q  B 3QAq\RR1XX55q22a88| D DB 6R!F)b. (B 6R!F)b. (B tB2rBw#///AcFQ Yr3%1 122C 8 8AcFyQ%))AeH& AfIAfI& AfIAfI WWs]F 9999!$hl61S6C<388#9 Hr cV|d|ddk|dkzS)Nrrrrr;rs rrJz_expn2..cond[s- cFRR#]] "qv 77r rl) rgr'rryrrrr r r,) r2rrTrrJrr2rrrrs ` @@@@@r_expn2r4/s" 1$%%# 9SY   #& As$ 1c # bAhh Q q1u bCGnn    $         0888888 nT4&&! 5CGQBKK r c*t}||d}||z}|||zz }|}||z||d|z|z||d|z|zz ||zzz}||||||d|zz zzz}|||zz}||ztj| z|z S)Nr$rrr#)rgr'r,)r2rrrrrrrls r_expn3r6bs" 1c #1u" b2g"! Q""Q((Q,"RR1XX\A%55A=># cARR1XX\)**+# cAg# )swr{{ "R ''r )rc td||\}}t}||d}||d}|||dk||kz||k|||dkz||k|||dkz|||dk||kz|||dk||kg}tj|||dk||z|}tjtj||z tj| |z tt|tt|tt|g}tj |||}|S)aGeneralized exponential integral function. JAX implementation of :obj:`scipy.special.expn`. .. math:: \mathrm{expn}(x) = E_n(x) = x^{n-1}\int_x^\infty\frac{e^{-t}}{t^n}\mathrm{d}t Args: n: arraylike, real-valued x: arraylike, real-valued Returns: array of expn values See also: - :func:`jax.scipy.special.expi` - :func:`jax.scipy.special.exp1` expnrr7r#i) rrgr'r(nanrr,rr6r4r#r) r2rrrrrr!valsrets rr8r8osU. fa + +$!Q" Aq$ 1a#Aq\a$h$Y1rr!Qxx< $Y11a=!""Q((]qDy!""Q++W  % ybbAhhAq))"GG"HGQBKK!O FA FA FA $ a%%# *r c ||c\}\}t||tjtj|ttj|t |d|fSri)r8r rjrrfrg)r2r{r|rr}s rexpn_jvpr=scH.$1 aSWGENNDJq!$4$455q99 r cltd|\}tttd|S)aWExponential integral function. JAX implementation of :obj:`scipy.special.exp1` .. math:: \mathrm{exp1}(x) = E_1(x) = x^{n-1}\int_x^\infty\frac{e^{-t}}{t}\mathrm{d}t Args: x: arraylike, real-valued Returns: array of exp1 values See also: - :func:`jax.scipy.special.expi` - :func:`jax.scipy.special.expn` r r7)rrrr8rs rr r s-(FA&&"! eT!QZZ  r rctjgd|j}tjgd|j}| tj||ztj||z S)N)g b?g4ھcD}?gh\Qa!?gdn&?gj[!&@g'4z#@g#+wa @r$r)grF?g! #ך?g?4B?g)m?gN @goR7c!@g#+wa @r$)r'rryr)rrrs r _spence_polyr@s i7$$$! i'###! ck!Q #+a"3"3 33r c|dk}tj||gddg}|dk}|dk}||z}tj|||gdddg}t|}tjd zd z tj|tjd |z zz |z }tj|||}d tj|d zz|z }tj|||S) Nrc d|z SNr$r;rs rrmz_spence_calc..s sQwr c|Sr:r;rs rrmz_spence_calc..s!r g?rcd|z dz SrCr;rs rrmz_spence_calc..ssQw}r c| Sr:r;rs rrmz_spence_calc..sr c |dz SrCr;rs rrmz_spence_calc..s Cr r#g@r$r0)r'rr@rrdr()rx2_bool x1_5_boolx_5_boolrr= y_flag_one y_flag_twos r _spence_calcrMs G' mAy&& 466!#g) W( i ' mA),,"l'')**! 1oo!v{S 371::a0@0@#@@1D* i*a((!cgajjAo%)* 7J * **r ctj||dk|dk|dkgtjdtjdzdz tgS)Nrsr$rr#r)r'rr9rrMrs r_spencerOsI qCc184CFaK!O\B D DDr ctj|}tj|}|tjtjfvrt d|dt|S)a?Spence's function, also known as the dilogarithm for real values. JAX implementation of :obj:`scipy.special.spence`. It is defined to be: .. math:: \mathrm{spence}(x) = \begin{equation} \int_1^x \frac{\log(t)}{1 - t}dt \end{equation} Unlike the SciPy implementation, this is only defined for positive real values of `z`. For negative values, `NaN` is returned. Args: z: An array of type `float32`, `float64`. Returns: An array with `dtype=z.dtype`. computed values of Spence's function. Raises: TypeError: if elements of array `z` are not in (float32, float64). Notes: There is a different convention which defines Spence's function by the integral: .. math:: \begin{equation} -\int_0^z \frac{\log(1 - t)}{t}dt \end{equation} This is our spence(1 - z). rz5 is not supported, see docstring for supported types.)r'rr ryrrrDrOrs rspencerQsbH k!nn! )A,,% 3; ,,, MMMM O OO r ctjtj|d}|dkrt dt jgd}|dkr |d|dzSt j|dzjdd |}t j d|dzd |j }d t j d zz t j |dz |zdz t j d zz z}t j d d |j }t j|dddf|dddf zd }|jddd  |d|zzS)a^Generate the first N Bernoulli numbers. JAX implementation of :func:`scipy.special.bernoulli`. Args: n: integer, the number of Bernoulli terms to generate. Returns: Array containing the first ``n`` Bernoulli numbers. Notes: ``bernoulli`` generates numbers using the :math:`B_n^-` convention, such that :math:`B_1=-1/2`. zArgument n of bernoullirz!n must be a non-negative integer.)r7r0gUUUUUU?r Nr7rr#rr$rPr)r rr^r_rr'rrnrorprryrrr)r2b3bnrrrrs r bernoullirU" sV  X^Q0IJJ!UU 8 9 99 y  "UU fq1uf: yQ2A2""2&&" jAE1BH---! SVq[CK!a%1 q(836Q;(FGGG" jBbh'''! wqDzaaaaj[(q111" qt!tq2v ' ''r ctd||\}}tj|dktjd|jt ||zt |z S)aThe Pochammer symbol. JAX implementation of :obj:`scipy.special.poch`. .. math:: \mathrm{poch}(z, m) = (z)_m = \frac{\Gamma(z + m)}{\Gamma(z)} where :math:`\Gamma(z)` is the :func:`~jax.scipy.special.gamma` function. Args: z: arraylike, real-valued m: arraylike, real-valued Returns: array of Pochammer values. Notes: The JAX version supports only real-valued inputs. pochrsr7r)rr'r(rryr+rrs rrWrW@ sW, fa + +$!Q 17CIaqw777q1ua9P Q QQr cht||zt|z t||zS)zT Defined in : https://functions.wolfram.com/GammaBetaErf/Pochhammer/20/01/01/ rSrWrXs r_poch_z_derivativer[[ s, !a%..71:: %a 33r cHt||zt||zS)zT Defined in : https://functions.wolfram.com/GammaBetaErf/Pochhammer/20/01/02/ rZrXs r_poch_m_derivativer]d s! Q$q!** $$r c(t|||zSr:)r[)z_dot primal_outrrs rrmrmn s#5a#;#;e#Cr c(t|||zSr:)r])m_dotr`rrs rrmrmo s"4Q":":U"Br ctjjjfd}fd}ddz zf}t j|||dS)z Compute the 1F1 hypergeometric function using the taylor expansion See Eq. 3.2 and associated method (a) from PEARSON, OLVER & PORTER 2014 https://doi.org/10.48550/arXiv.1407.7786 c\|\}}}||z }||z|zz z|dzz z}|dz }|||fSrir;stateseriertermr-r.rs rrz_hyp1f1_serie..body| sQNE1d TMEQUq1u  !QU ++DFA !T>r cx|\}}}|dktj|tj|z kzSNr rrfrgrrh precisions rrJz_hyp1f1_serie..cond 7NE1d G 6B CCr r7rr'rryrr r r-r.rrrJrTrns``` @r _hyp1f1_serierrs si  $)DDDDD Aq1uqy$ dD ) )! ,,r c8tjjjfd}fd}ddz dz zz f}t j|||d}t t z t jzz zz|zS)z Compute the 1F1 hypergeometric function using asymptotic expansion See Eq. 3.8 and simplification for real inputs from PEARSON, OLVER & PORTER 2014 https://doi.org/10.48550/arXiv.1407.7786 ch|\}}}||z }|z |zdz |zz|dzz z z}|dz }|||fSrir;res rrz _hyp1f1_asymptotic..body sYNE1d TMEQUQY1q519 %Q /! 33DFA !T>r cx|\}}}|dktj|tj|z kzSrjrlrms rrJz _hyp1f1_asymptotic..cond ror r7r)r'rryrr r r+r,)r-r.rrrJrTrgrns``` @r_hyp1f1_asymptoticrv si  $)DDDDD AA!a% 1$ $$ .tT * *1 -% qE!HH swqzz )A!a%L 85 @@r ctjjjfd}fd}ddz zf}t j|||dS)zv Define it as a serie using : https://functions.wolfram.com/HypergeometricFunctions/Hypergeometric1F1/20/01/01/ c|\}}}||t|ztz zz }||z|zz z|dzz z}|dz }|||fSrirSres rrz"_hyp1f1_a_derivative..body slNE1d TWQU^^gajj0 11EQUq1u  !QU ++DFA !T>r cx|\}}}|dktj|tj|z kzSrjrlrms rrJz"_hyp1f1_a_derivative..cond ror rr7rprqs``` @r_hyp1f1_a_derivativer{ i  $)DDDDD Aq1uqy$ dD ) )! ,,r ctjjjfd}fd}ddz zf}t j|||dS)zv Define it as a serie using : https://functions.wolfram.com/HypergeometricFunctions/Hypergeometric1F1/20/01/02/ c|\}}}||tt|zz zz }||z|zz z|dzz z}|dz }|||fSriryres rrz"_hyp1f1_b_derivative..body slNE1d TWQZZ'!a%..0 11EQUq1u  !QU ++DFA !T>r cx|\}}}|dktj|tj|z kzSrjrlrms rrJz"_hyp1f1_b_derivative..cond ror rr7rprqs``` @r_hyp1f1_b_derivativer r|r c<||z t|dz|dz|zS)zv Define it as a serie using : https://functions.wolfram.com/HypergeometricFunctions/Hypergeometric1F1/20/01/04/ r7)hyp1f1rQs r_hyp1f1_x_derivativer s' QAq1ua(( ((r c td|||\}}}tjtj|dktt |||}|dkdz||k|dkzdzz|dk|dkzdzz}tj||tjd|j tj |tjtj |j S)aThe 1F1 hypergeometric function. JAX implementation of :obj:`scipy.special.hyp1f1`. .. math:: \mathrm{hyp1f1}(a, b, x) = {}_1F_1(x;a, b) = \sum_{k=0}^\infty \frac{(a)_k}{(b)_kk!}x^k where :math:`(\cdot)_k` is the Pochammer symbol (refer to :func:`~jax.scipy.special.poch`). The JAX version only accepts positive and real inputs. Values of ``a``, ``b``, and ``x``, leading to high values of 1F1 may lead to erroneous results; consider enabling double precision in this case. The convention for ``a = b = 0`` is ``1``, unlike in scipy's implementation. Args: a: arraylike, real-valued b: arraylike, real-valued x: arraylike, real-valued Returns: array of 1F1 values. rdrr7r#r r) rr rJrrrrvselect_nr'rryr,r)r-r.rrr_s rrr s< !1a 3 3'!Q 8CGAJJ$m5GAq Q Q& 6Q,16a1f-2 2qAv!q&6IQ5N N% ei111gajjiqw777  9 99r c*t||||zSr:)r{)a_dotr`r-r.rs rrmrm %9!Q%B%BU%Jr c*t||||zSr:)r)b_dotr`r-r.rs rrmrm rr c*t||||zSr:)r)r}r`r-r.rs rrmrm rr rrint | tuple[int, ...] | Nonec$t||S)aSoftmax function. JAX implementation of :func:`scipy.special.softmax`. Computes the function which rescales elements to the range :math:`[0, 1]` such that the elements along :code:`axis` sum to :math:`1`. .. math :: \mathrm{softmax}(x) = \frac{\exp(x_i)}{\sum_j \exp(x_j)} Args: x : input array axis: the axis or axes along which the softmax should be computed. The softmax output summed across these dimensions should sum to :math:`1`. Returns: An array of the same shape as ``x``. Note: If any input values are ``+inf``, the result will be all ``NaN``: this reflects the fact that ``inf / inf`` is not well-defined in the context of floating-point math. See also: :func:`log_softmax` r) nn_softmaxrrs rrr s> AD ! ! !!r c$t||S)aLog-Softmax function. JAX implementation of :func:`scipy.special.log_softmax` Computes the logarithm of the :code:`softmax` function, which rescales elements to the range :math:`[-\infty, 0)`. .. math :: \mathrm{log\_softmax}(x)_i = \log \left( \frac{\exp(x_i)}{\sum_j \exp(x_j)} \right) Args: x : input array axis: the axis or axes along which the :code:`log_softmax` should be computed. Returns: An array of the same shape as ``x`` Note: If any input values are ``+inf``, the result will be all ``NaN``: this reflects the fact that ``inf / inf`` is not well-defined in the context of floating-point math. See also: :func:`softmax` r)nn_log_softmaxrs rrr? s@  % % %%r )rrrr)r-rr.rrr)F)r2rr3r4rr)r-rr=rrr)rrr=rrr)r-rr.rrrrr)r-rrrrr)r-rrrrr)rrrrrrr:)rrrrrr)r2rrrrr)rrrr)r )rrrrrr)r2rrr+)rrrRrrQrrr)rdrrer4ryrrrf)rrrrrer4rr)rdrrrrer4rr)rrr2rrrrrf) rrr2rrrrer4rr) rrr2rrrrrrrrr) rrr2rrrrrrrrr)rrrr)rrrrrrrr)r2rrrrr)r2rrrrr)rrrr)r2rrr)rrrrrr)rrrrrr) __future__r functoolsrr^typingrrrnumpyr jax.numpyr'jaxrr r r jax._srcr r rrjax._src.lax.laxrrgjax._src.numpy.utilrr jax._src.opsr ops_special!jax._src.third_party.scipy.betalnrr0jax._src.typingrrjax._src.nn.functionsrrrrrr"r+r6r<rHrPrSrUrYr\r^r` custom_jvprcdefjvpsro logsumexprrrdefjvprrrrrrrrrrrrrrrrrrrrrrrrr!rr#r'rdrrr1rr5r9r<r?rOrZrcrrrrrrrrrrrrrrrr r rrr#r4r6 vectorizer8r=r r@rMrOrQrUrWr[r]rrrvr{rrrr;r rrs( #"""""&&&&&&&&&&''''''!!!!!!111111LLLLLLLL//////DDDDDD,,,,,,,,777777??????8MMMM<".".".".J299999< 222 2 555 5 555 5%%%N&&& 68444:0;;;;" JJLLL&  ! DDDD.KKK  ZFFFF.SSS |... j((((:%%%%P    >&&&&T(4: GGC/ 0 0111%%%%z"#rz22!#rz22 "!RZ00!!RZ00D    8jjjjZ   &===e7e7e7e7>=e7N   KKK(((&&&&& wrwq25y1122CCC 49999049999.(57" sHo...35%/%/%/%/%//.%/P1"1"1"1"h a!!![[["![| V$$$b b b %$b J)!)!)!)!X3;3;3;3;n T"""#":"& ,,,,,,,,,,j....2!!!!2!!!!4!!!!:!!!4!!!*!!!8    CCCC.)) ) #<#<#<#=+ \ !!!!244440++++,DDDD ))))X((((<RRRR4444%%% CCBB ---6AAA8---4---4)))$9$9$9$9NJJJJJJ26""""""J6: & & & & & & & &r