uki ddlmZddlmZddlZddlmZmZddlZ ddl m Z ddl m Z ddl m Z ddl mZdd l mZdd l mZdd l mZdd l mZdd l mZddlmZmZmZddlmZmZmZddlmZddlm Z!ddlm"Z#ddl$m%Z%m&Z&ddl'm(Z)ddl*m+Z,ddl-m.Z.m/Z/ddl0m1Z2ddl0m3Z4ddZ5eddZ6ddZ7ddZ+dddZ8ddZ9ddZ:dd Z;dd!Zdd$Z?dd%Z@ejdd&ZBeBjd'dd(ZDe)jZEejdd)ZFd*ZGeFjeGejdd+ZId,ZJeIjeJejd-ZKd.ZLeKjeLdd/ZMdd0ZN dd1ZO dd2ZPe jgd3ZRejddd4ZSddd5ZTeSjeeeTdd6ZUe jd7e jZWe jd8e jZYe jd9e jZZe jd:e jZ[dd;Z\dd<Z]dd=Z^dd>Z_eejd?@dddAZ`dBZae`jeadCZbdDZcddEZde je jdFe jzZhdGZiddHZjddIZkddJZlddKZmdLZndMdNddQZoedOdPgRdMdNddSZp ddTZqedFU ddVZredWU ddXZsddYZtddZZued[U dd\Zv d dd]Zw d dd^Zxdd_Zydd`ZzddaZ{ddbZ|ddcZ}ddZ~deZdfZddgZddhZejeddiZejedjZejeddkZddlZddmZddnZejedoZddpZddqZddrZeejds@e#jDeddtZejeduZddvZddwZddxZddyZddzZdd{Zejdd|Zd}Zd~ZejdddZdZee#jDdZee#jDdZedZejee#jDddZejddddZdZdZdZee#jDdZee#jDdZee#jDdZedZejee#jDddZejdddddd ddZ1dd ddZ3y)) annotations)partialN)castAny)api_util)config)core)custom_derivatives) deprecations)dispatch)dtypes)lax)numpy)isposinfisneginfsinc)jitjvpvmap)_const)einsum) vectorize)promote_args_inexactpromote_dtypes_inexact)special)betaln)Array ArrayLike)softmax) log_softmaxcHtd|\}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)rrlgammaxs Q/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/jax/_src/scipy/special.pyr"r",s 0Iq)"! Actd|\}tj|jtj r t d|jj}tj|}|dk}tj|||k(ztj|z||dzdk7z|dk(tj|zzg|tj|dg|dS)aSign 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. * if :math:`x = -\infty`, NaN is returned. * if :math:`x = \pm 0`, :math:`\pm 1` is returned. * if :math:`x` is a negative integer, NaN is returned. The sign of gamma at a negative integer depends on from which side the pole is approached. * if :math:`x = \infty`, :math:`1` is returned. * if :math:`x` is NaN, NaN is returned. 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 gammasgnz0gammasgn does not support complex-valued inputs.r?)rr issubdtypedtypenpcomplexfloating ValueErrortyperfloorjnpselectisnansignbitnan)r%typfloor_x x_negatives r&r)r)HsBJ*"! qww 2 23 G HH  # IIaL'1u* AL!SYYq\1GaK1$%16S[[^*CDF[#d)H  r'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)! * if :math:`z = -\infty`, NaN is returned. * if :math:`x = \pm 0`, :math:`\pm \infty` is returned. * if :math:`x` is a negative integer, NaN is returned. The sign of gamma at a negative integer depends on from which side the pole is approached. * if :math:`x = \infty`, :math:`\infty` is returned. * if :math:`x` is NaN, NaN is returned. 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)rexpr#r$s r&r=r=vs3RGQ'"! !swwszz!}- --r'c:td||\}}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_impl)abs r&rrs#* h1 -$!Q a r'c |r tdtd|\}tj|dkdt j t 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)NotImplementedErrorrr4whererr>r#)nexacts r&rDrDsN2 9 ::K+"! 1q5!SWWSZZA%67 88r'c$td||\}}tj|jtj r t dt|t|zt||zz}|tjt||zS)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` betaz,beta does not support complex-valued inputs.) rr r-r.r/r0r1r)rr>r)rArBsigns r&rKrKsu, fa +$!Q qww 2 23 C DD !x{ "Xa!e_ 4$ q! % %%r'ctd|||\}}}tj|jtj r t dtj|||S)aThe regularized incomplete beta function. JAX implementation of :obj:`scipy.special.betainc`. .. math:: \mathrm{betainc}(a, b, x) = \frac{1}{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` betaincz/betainc does not support complex-valued inputs.) rr r-r.r/r0r1rrNrArBr%s r&rNrNsS. !Aq! 4'!Q qww 2 23 F GG Q1 r'cHtd|\}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)rrrQr$s r&rQrQs 0Iq)"! Qr'cNtd||\}}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)rrigammarAr%s r&rSrS1s', j!Q /$!Q Aq r'cNtd||\}}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)rrigammacrUs r&rWrWKs', k1a 0$!Q Q r'cHtd|\}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)rrrZr$s r&rZrZes ,E1%"! r'cHtd|\}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)rrr\r$s r&r\r\s 2FA&"! !r'cHtd|\}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)rrerf_invr$s r&r^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. logitrE)rrlogdivsub _lax_constr$s r&raras> GQ'"! CGGJq!$4a89 ::r'c tj|tj|tjt |d|SNrE)rrcmulrdre)gansr%s r&rks.cggaCGGJq!4Da,H!IJr'cHtd|\}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)rrlogisticr$s r&rmrms GQ'"! ar'c td||\}}|dk7}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)rr4rGrrhrb zeros_liker%yx_oks r&rprpsN( gq! ,$!Q b$ 4CGGAJ/1B CCr'c|\}}|\}}t||}||tj|z||z|z zj|jfSN)rprrbastyper.primalstangentsr%rtx_doty_dotresults r& _xlogy_jvprsS &1a.5% A;& %#''!*$uqy1}4<>!3D EEr'c|\}}|\}}t||}||tj|z||zd|zz zj|jfSrg)rrrrxr.rys r& _xlog1py_jvprsX &1a.5% 1a=& %#))A,&a!e)<<DDV\\R RRr'ct||S)z/Compute x log(x) with well-defined derivatives.)rpr$s r&_xlogxrs q!r'c^|\}|\}t||tj|dzzfSrg)rrrbrzr{r%r|s r& _xlogx_jvpr$s0"! &% )Ucggaj1n- --r'c xtd|\}tj|jtj r t dtjtj|t|dtj|tj 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 & \mathrm{otherwise} \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` entrz,entr does not support complex-valued inputs.r)rr r-r.r/r0r1rr5ltre full_likeinfnegrr$s r&rr+s.FA&"! qww 2 23 C DD CFF1jA./MM!bffW-GGF1I& ((r'c tjt|d}td||\}}t j t j t j t |d|t j|t |dt jt |tj}t jtj||jt |d}tjt!tj"|dtj"|t%t'|j(z 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?rEr.r*axis)r concrete_or_errorintrrrhrerdrbr/pircr4aranger.sumr" expand_dimstuplerangendim)rAdd_constantrBress r&rrJs6 S!%AB! ~q! 4%!R WWSWWSWWZ4%8"= WWRAq)9:<WWZ255124( ggcjj"((+Z1-=>! 3eAFFm0DEFG # xr'ctd||\}}tj|jtj r t dt|||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_divz.kl_div does not support complex-valued inputs.)rr r-r.r/r0r1rel_entr)pqs r&rrrsR6 h1 -$!Q qww 2 23 E FF !Q! a r'c td||\}}tj|jtj r t dt|d}tjtj||tj||}tjtj||tj||}tj||d}tj||d}tjt!|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` rz0rel_entr does not support complex-valued inputs.rqrE)rr r-r.r/r0r1rer bitwise_andgteqger4rGrdrrpr) rrzeroboth_gt_zero_mask one_zero_masksafe_psafe_qlog_valr~s r&rrs6 j!Q /$!Q qww 2 23 G HH As $oocffQosvvaG//#&&D/366!T?C- 99&1 -& 99&1 -& GGF6NE&&$9 :' 99#))M4"H & -r') i0i viigS`3lKEgPq wg+cQ{Bg1oXU0gީ~#'Cg2HUgopyL.Dgi Tg"WDg.,ch| 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 [Riemann zeta function not implemented; pass q != None to compute the Hurwitz Zeta function.zeta)rFrrr)r%rs r&rrs=$Y c ee fa +$!Q !Qr'c | tdtd||\}}tj|j}t j |dt j |d}}tj|tjk(r|dn|dx}}|ttksJt j tj||jtt|j} t j|| z| zd} tj ||z|d|z z||dz } ||z| z} t j tjd|z|jtt|j} || z||zz }t j"|dd dddf}t j$|t'j(|j* }tj tj,td|j.d|tt|j}||z }| |d |jdzz}| | z|zS) NrrrrrEr*.)max?)rFrrr.r2r4rr/float32len_BERNOULLI_COEFSrrrrrrccumprodclipr finforarrayshape)r%rsrAr.s_a_NMkSIT0ms_over_aT1coefsTs r&_zeta_series_expansionrsY c ee fa +$!Q ))A,  % ??1b !3??1b#9b"iilbjj0%(eBi?!a c"# ## # oobii15qvv3GH! ggrAv2#or"! ggq1u%(Q,'U1X6! A1"}" oobiiAQWW5uU166]7KL!1fa ( {{8R cc*" xx U+//0" .."2=BHHRL"AOuQVV}- /% Ez"E#J #$! Qr'crtjtj|tj s"t dtj|dtd||\}}tj|jtjr t dtj||S)aaThe polygamma function. JAX implementation of :func:`scipy.special.polygamma`. .. math:: \mathrm{polygamma}(n, x) = \psi^{(n)}(x) = \frac{\mathrm{d}^{n+1}}{\mathrm{d}x^{n+1}} \log \Gamma(x) where :math:`\psi` is the :func:`~jax.scipy.special.digamma` function and :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` z=Argument `n` to polygamma must be of integer type. Got dtype . polygammaz1polygamma does not support complex-valued inputs.) r r-rr.r/integerr1rr0r)rHr%n_arrx_arrs r&rrs.   399Q< 4  G RS ~UVW &k1a8,% u{{B$6$67 H II ue $$r'iirctj|}tj|}|tj tj fvrtdj|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.) r4asarrayrr.r/rfloat64 TypeErrorformat_ndtrr%r.s r&ndtrr|sW2 kk!n! ))A,% 2::rzz** I   q/r'c tj|j}|dtjd|z}||z}tj |}tj tj|||dtj|ztj tj||d|dtj|z tj|}|d|zS)zImplements ndtr core logic.r@rr,rq) rr.r2r/sqrtabsr5rrZrr\)r%r. half_sqrt_2wzrts r&rrs ))A,  %c RWWRu55++o! ggaj! jj;'Bi#''!*,jj59!5&+Bi#((1+&=&)hhqk34! sar'ctj|}|tjtjfvrt dj |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)rr.r/rrrr_ndtri)rr.s r&ndtrirsK( ))A,% 2::rzz** I   r'c  tj|j}tj|}tj gd|}tj gd|}tj gd|}tj gd|}tj gd|}tj gd|}t j||tjd kD|d |z |} t j| |d k(t j||d | } | |d z } tj| } | | | zt j|| t j|| z zz} | |tjd tjz z} tj|dtj| z}|tj||z z }t j|d |z t j|d |z z |z }t j|d |z t j|d |z z |z }||z }||z }t j| |tjdkD| t j||dk\||}t j||d tjdz kD|| }t!j"d5t j||tj$}t j||d k(| t j||d k(||}dddt'|t(j*s t-j.d|g|S|S#1swY?xYw#t0j2$r}t5d|j6ddd}~wwxYw)zImplements ndtri core logic.)g-^OMgX@gVLg;+@g~r) 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)=>gr,rqrrrE @FNrzinvalid value (z) encountered in ndtri.)rr.r2r/rrr4rGexpm1fullsquarepolyvalrrrbr>r debug_infsr isinstancer Tracerr check_specialrInternalFloatingPointErrorFloatingPointErrorty)rr.rp0q0p1q1p2q2maybe_complement_p sanitized_mcprww x_for_big_pr first_termsecond_term_small_psecond_term_otherwise x_for_small_p x_otherwiser%infinityes r&rrs ))A,  % ((1+%  xx,49 :"  xx,49:" xx-5:;" xx-5:;" xx,49:" xx,49:"yyUBHHSM>%:!:E"IM1M))E"I% hhueCj!- eCj ! zz!}"AFckk"b1CKKB4GGHH+ %RUU +,,,+  hhuSzCGGM223!3771:>!* BA.RQ1GG!K++b!a%03;;r1q53IIAM22-22+ ii bffSk 22 !uSz/=+FH! iiE"rvvc{*++Q3! MxxuRVV}-H  U3Z(CIIa5:ox$K MAM At{{ #EWqc* ((MM  . .E  ADD6!8 9 ;@DEEs%'A*O4OOP .PP )rE)nondiff_argnumsct|ts td|dkr td|dkDr tdt j |}t j|}|tjk(r t}t}nB|tjk(r t}t}n"tdtj|dt jt j ||t#|  t jt j ||t j$t#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.)rrrr1r4rrr.r/r_LOGNDTR_FLOAT64_LOWER_LOGNDTR_FLOAT64_UPPERr_LOGNDTR_FLOAT32_LOWER_LOGNDTR_FLOAT32_UPPERrGrrrbr_log_ndtr_lowermin)r% series_orderrr. lower_segment upper_segments r&log_ndtrr.s!~ L# & < ==A 9 ::B 2 33 ++a.% ))E % bjj 6M 6M  *M*M hrxx//AB CC  ffUM" eV}n iium,wwuSWWUM%BCD&swwum'D'356 77r'c ||c\}\}t||}tj|tjtjt ||}||fS)N)r)rrrhr>rd _norm_logpdf)rrzr{r%trjt_outs r& _log_ndtr_jvprsO*$1.# ''!SWWSWW\!_c:; <% er'cTtj|j}tj|}|d |ztj| z |dt jdt j zzz }|tjt||zS)zGAsymptotic expansion version of `Log[cdf(x)]`, appropriate for `x<<-1`.rr)rr.r2rrbr/r_log_ndtr_asymptotic_series)r%rr.x_2 log_scales r&rrs} ))A,  % 1 #SzkC#''1"+-cBFF2: BBr'cHtd|\}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_i0er$s r&r1r1!,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)rrrhr>rr2r$s r&r5r5=(D!$"! $cnnQ&7 88r'cHtd|\}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_i1er$s r&r8r8r3r'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)rrrhr>rr9r$s r&r;r;r6r'c|\}}}}d|dzz|z|z |z }d}d}tjtj|ddk(||||f}|}|}||||f|fS)Nrr,c|\}}|d|zzS)Nr)ubsfs r&true_fn_update_bsz3_bessel_jn_scan_body_fun..true_fn_update_bs-s EB a<r'c|\}}|Srwr>)r?r@_s r&false_fn_update_bsz4_bessel_jn_scan_body_fun..false_fn_update_bs1s EB Ir'r*r)operand)rcondr4mod) carryrf0f1r@rrArBrEs r&_bessel_jn_scan_body_funrL)s-"b"a QWoQ#! xx1 "$5"RG5" "" b"a! r'2)n_itervrNc 6t|d}t|d}t|d}t|d}tjt||||ftjtj ||dzd\\}}}}}|d}|d|dz}|||z z }|S)NrqgؗҜ 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.)rOrNrr)r4rrrr.r r-complexr1r roperatorindexrrrWrrrmoveaxis)rrOrNz_dtype bessel_jn_funrDs r& bessel_jnr`Ns4 kk!n!a "! IIaL' w( 3 44 X^^Q0JK!  ! !#v/N O&*&9- =(a'M( mA&A ..r'ctjtj|dz|tj|dz|d\}}|rf||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| | }| j | j| | }tjd |dzd |dzd |dzf\}}}||z|z d k(j|}tjd ||}tjd ||}||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. rErijindexingrr,@@r*Nrz jk,ijk->ijk) r4meshgridrr triu_indiceszerosatsetogridrx jnp_einsumr)l_max is_normalizedr.m_matl_matc0c1c2c3d0d1d0_mask_indicesd1_mask_indicesd_zerosd0_maskd1_maskijrmask d0_mask_3d d1_mask_3ds r&_gen_recurrence_maskrws$JJuqy&JJuqy& ,% B B uB #+%#+ &B 38c>b2g. /B BHb)rCxBG.DE FB +  .B %-# %%- 0B$$UQY2/$$UQY2/ IIuqy%!),E :' JJ ' + +B,? @' JJ ' + +B,? @' IIjuqyj*519*juqyj8 9'!Q a%!)q.  '$  >*  >* j !!r')static_argnumsc  |j\}}}tj|dddd|ddf}tj|dd|dzddddf}tj|dd|ddddf}|r td|dkDr{tjd|dz |j } |dd|dz ddf} d | dz| zz } t jd | | } |jdd|ddfj| }|dkDrtjd|dz |j } |dd|dz ddf} d | dz| dzz| z| dz zz } t jd | | }|jd d |ddfj|}tjtj||j tj||j d\}}tj||f|j }tj|d |}tj|f|j }d|d z z }|j|j||}|jdddfj|}||z}||dz z|d z z}|j|j||}|jdddfj|}t jd||t jd||z}d|d zz }|j|j||}||z|d zz}|j|j||}t jd||t jd||z}|||z d zzdz }|j|j||} t jd| |d|zz }!|dkDrtj||j } t jd | dz| z|d ddddf}"|dkDr|"|dddddfz }"t jddtjd||zz z |"}#|!jdddddfj|#}!|!jdd ddfjd }!|!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)rErrN)rr*rrr*))r*rrrz9Negative orders for normalization is not implemented yet.rErr+i,ij->ijr,rrbrcr,r ij,ijk->ijkrzj,ij->ij)rr4padrFrr.rmrrjrkrgrirhr)$rr%ronum_mnum_lnum_xp_m_lm1 p_mp2_lm1 p_mm2_lm1l_vecp_p1coeff update_p_p1p_p2 update_p_p2rprq coeff_zerosupper_0_indiceszero_veca0 a0_maskedb0rr c0_maskedp_mm1_lrv d0_maskede0 e0_maskedp_mp1_lrJ f0_masked p_derivativeg0p_derivative_m0s$ r&_gen_derivativesrs"% GGA/ 0FUFA >'ggg78519a9JK)ggg78%AF) C EE qyjjEAIQWW5e q!EAI+q !duqyE)*e%%j%>k,,q!E'1}-11+>i qyjjEAIQWW5e q!EAI+q !deaiEAI.6%!)DEe%%j%>k,,q!E'1}-11+>iJJuAGG$JJuAGG$ ,%  5%.8+$$UAu5/ YYxqww /( us{"nn_-11"_2EF)ll1a4 $$X.) u}" R#X"s(#"nn_-11"_2EF)ll1a4 $$X.)  }i A   }i CD' us{"nn_-11"_2EF) Bw"s("nn_-11"_2EF)  }i C   }i AB' UU]S !C'"nn_-11"_2EF)""=)WEg U, QY JJuAGG ,E   : U':AaAgJ GB qy 1a7 b '' C#((1q1u9:M4MrRO??1a7+//@L??1a7+//2L r'rc tj|dz|dzjdfj}tjd|dzj}tj|j}|rsdtj t jz }tjdtj dd|z zz}tj d|zdz}n%d}tjdd|zz }d|zdz}|jd j|}tjtjtj dzz |jdfd } |tjd || z} tj|dz} |j| ddd | ddd fj| }tjd tjd||tj|} | dd || dd |dzf} |j| j| }t||j\fd}|j!t#j$|}|dkDrt'j(d|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. rErrrrr,rrfrrrNz ij,ij->ijzi,j->ij)ror.c |}|}tjd|tjdtj|ddtjd|tj|ddz }||z}|S)Nrz ijk,k->ijkrE)shiftrr*)rmrr4roll)r}p_valcoeff_0coeff_1hrrr%s r&body_funz*_gen_associated_legendre..body_fun]smGmG   =%%$chhuAA&FK L   ='388EQR3S T  UA AIE Lr'r*)lowerupperrinit_val)r4rirr.rrr/rrrjrk broadcast_tormr diag_indicesrrxr result_typer fori_loop)rnr%rora_idxb_idx initial_valuef_af_brtp_diagr p_offdiagoffdiag_indicesrrrs ` @@r&_gen_associated_legendrer swb iiEAIqwwqz2!''B! **Q  1% **U!'' *%"SXXbee_4M ++b388C#+$566 7C ((3;$ %CM ++cC%K' (C + Cdd6l}%! kk sxxa!e ,uaggaj.AB ! :,,Za@ @&!!%!),,ddLOAB a!4 56::6B! #**9c1=3++E235)"!_Ve,l1ofu.E.IJ/dd? *!0 =9*j hhv!!!Q 34! QY AU1Wx!LA (r'ctj|}|tjtjfvrt dj ||jdk7r tdtjt|d}tjt|d}||k7r td|}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.rEz must be a 1D array.Argument m of lpmn.Argument n of lpmn.,Computations for m!=n are not yet supported.F)rr.r/rrrrrr1r rrrFrr)rrHrr.rnrop_vals p_derivativess r&lpmnrps* ))A,% 2::rzz** I  VVq[ , -- S!%:;! S!%:;!!V L MM %- #E1m <&"61m<- -  r'ctj|}|tjtjfvrt dj ||jdk7r tdtjt|d}tjt|d}||k7r td|}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`. rrErrrr)rr.r/rrrrrr1r rrrFr)rrHrror.rns r& lpmn_valuesrsD ))A,% 2::rzz** I  VVq[ , -- S!%:;! S!%:;!!V L MM % !%M ::r')chtj|}t||d}|jt ||tj t |fjd}t ||z}tjtj|tj|} tj|tj| z|tj| z} tj|dkdt |ztj| z| } | S)z!Computes the spherical harmonics.Tr)moderr+)r4cosrrjrrrgetrrZsinrealimagrG conjugate) rHrthetaphin_maxcos_colatitudelegendre legendre_valangle vandermonde harmonicss r& _sph_harmrs775>. %e^T B(SVQ 3q6(::;??V?L, a&3,% CGGENCGGEN;+kk,+)>>&+)>>@)iiAAy)AA!#) r'c| tdtj|rtj|g}|t j |}t jt|d}t|||||S)a0Computes 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 \theta) * \exp(i m \phi)`, 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:`\theta` and :math:`\phi` 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: 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_y`. Return values for `n < 0` are undefined. m: The order of the harmonic; must have `|m| <= n`. Return values for `|m| > n` are undefined. theta: The polar (colatitudinal) coordinate; must be in [0, pi]. phi: The azimuthal (longitudinal) coordinate; must be in [0, 2*pi]. diff_n: Unsupported by JAX. 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). zGThe 'diff_n' argument to jax.scipy.special.sph_harm_y is not supported.zThe `n_max` argument of `jnp.scipy.special.sph_harm` must be statically specified to use `sph_harm` within JAX transformations.) rFr4isscalarrr/rr rrr)rHrrrdiff_nrs r& sph_harm_yrs~H  Q SS \\% IIug E ] FF1IE   5N O% 1aU ++r'cRtjdddt|||||S)aComputes the spherical harmonics. Note: This function is deprecated, and :func:`~jax.scipy.special.sph_harm_y` should be used instead, noting that the order of ``m`` and ``n`` are reversed, and definitions of ``theta`` and ``phi`` are swapped. 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). zjax-scipy-special-sph-harmzjax.scipy.special.sph_harm is deprecated. Please use jax.scipy.special.sph_harm_y instead, noting that the order of `m` and `n` are reversed, and definitions of `theta` and `phi` are swapped.r*) stacklevel)r)r warnr)rrHrrrs r&sph_harmr!s6R"M  Aq#uE 22r'c@tjgd|j}tjgd|j}tj||tj||z }||ztj ztj |zS)N)gfgrG(Pk@g`χPg>x@gN P(9煘)3M8Ar)r,gX$@JgEv@g_'g鏱9Ag-C&r)r/rr.r4r euler_gammarb)r%ABrAs r&_expint1rZs~hh 77! hh 77! kk!Q#++a++! Q #''!* ,,r'ct|d}||z }tj||tj||z }||z|z}tj||z|zSNr,)rer4rr>)rrr%onerrAs r&_eval_expint_krqs[1c# Ag! kk!Q#++a++!!eck! a! r'ctjgd|j}tjgd|j}t|||S)N)g `V,1K?gN{Xg+qggmZ @g0$N8ܿg=S?g`PYg,n߁?r)r,gA?gE]l?gIUW?gScjw?gY)R:r?gSS&?g ٹ?r/rr.rr%rrs r&_expint2rzsMhh  77 ! hh  77 ! 1a  r'ctjgd|j}tjgd|j}t|||S)N)g󲛯g/Sg!J?gwh]Lпga*\?g*re QgL?g r>r) r,giy?gT]j?g\?gw.?gTp1L?gxV>?gТӾgv[>rrs r&_expint3rMhh  77 ! hh  77 ! 1a  r'ctjgd|j}tjgd|j}t|||S)N) gܞHgn&G?gD Ͽg(Kȗ?go /?g}$4 gJԼǾ>gGW󇘾g3uO>g^]h8>r) r,g$>:TJjͿgD;J?g`0 gO.uf?gTzb+g٨%L>gR* 흾gBw6,M>gl\[">rrs r&_expint4rsMhh  77 ! hh  77 ! 1a  r'ctjgd|j}tjgd|j}t|||S)N)gvϿg5F9¿g ?%=?g gV?g4gP/CU.>g/fr) r,g9\pg\!ѿgE{H"Ѹ?gOVfgiCkX?g.G/g[Y>gZg2r) r,gW[8gwM+?gC68ѿgJ? ?g+kg=x(?gMd~y ھg|e[gã>g/rrs r&_expint7rsMhh  77 ! hh  77 ! 1a  r'c 6t}||d|k|||dkzgtddDcgc]$}||d|z|k|||d|dzzkz&c}z}tj||tt t ttttgScc}w)Nrr*rE) rerr4 piecewiserrrrrrr)r%_cr}condss r& _expi_posrs" q!HqLQ"Q(] + ,>CAqk09:R16]Q11aAEl 3340 %   x8XxJ 0s)Bct|  Srw)exp1r$s r& _expi_negr!s r(r'ctd|\}tj|jtj r t dtj||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` expiz,expi does not support complex-valued inputs.r) rr r-r.r/r0r1r4rrr)r%rs r&r r %sV*  *&% u{{B$6$67 C DD uuqykIy+A BBr'c^|\}|\}t|tj||z |zfSrw)r r4r>rs r&expi_jvpr ?s2 $1 (5 a#''!*q.5( ((r'cJtd|\}tj|jtj rt d|jdtj|}t|\}}t|\}}t|\}}|dk}|dkD|dkz} tj|| g||g|} tj|| g||g|} tj|| z} tjt|tj | } | | fS)uSSine and cosine integrals. JAX implementation of :obj:`scipy.special.sici`. .. math:: \mathrm{Si}(x) = \int_0^x \frac{\sin t}{t} \, dt .. math:: \mathrm{Ci}(x) = \gamma + \ln(x) + \int_0^x \frac{\cos t - 1}{t} \, dt where :math:`\gamma` is the Euler–Mascheroni constant. Args: x: array-like, real-valued input. Returns: A tuple of two arrays, each with the same shape as `x`: - The first array contains the sine integral values `Si(x)`. - The second array contains the cosine integral values `Ci(x)`. See also: - :func:`jax.numpy.sinc` siciz4Argument `x` to sici must be real-valued. Got dtype rrgeA)rr r-r.r/r0r1r4r _sici_series _sici_asympt _sici_approxr5rLrGrr8) r%x_abs si_series ci_seriessi_asympci_asymp si_approx ci_approxcond1cond2sicis r&rrGs :FA&"! qww 2 23 g'`vg&>-P?g6)p+r,r)go7=gk6#h>g g>g(?gҌ[?r,)r/rr.r4r)r%SNSDrs r&rz_sici_series..si_seriessm  ()ww  0B ! )*  1B AA  B" "ckk"a&8 88r'cFtjgd|j}tjgd|j}||z}tjt j |z|t j ||zt j ||z zS)N)gg'`s?g2E%?r+r)g#q=gjh{/Z*>g)/ث>g,b4?gP, ?re)r/rr.rr4rbr)r%CNCDrs r&rz_sici_series..ci_seriess ! )*  1B  ()ww  0B AA >>CGGAJ &S[[Q-?)?#++bRSBT)T TTr'rrq)r4rGr/r)r%rrrrs r&rrs`9"U" yyF aL"  yyFVVG aL" R-r'ctj|}tj|}d||zz }tjgd|j }tjgd|j }tjgd|j }tjgd|j }tjgd|j }tjgd|j } tjgd |j } tjgd |j } tj |||tj ||zz } |tj ||ztj ||z } tj |||tj | |zz }|tj | |ztj | |z }|d k}tj|| |}tj|| |}tjd z ||zz ||zz }||z||zz }||fS) Nr,)gz @g"f@gqt?gy`?gc~{?gu4?g%@5[k>r)rEgwvT @gml;@g׹f?gv!r?g-x;|?gG?gEڸkk>)g[/]2L?gyVj?g)fk?gVS')?g1rv?gf;%?g Q=>gFF@>)rEg M?gjAuMR?g-#ʽP?gwL~y?g0zU&?gt.ʢ>g&ZMVF@>) g/]&-?gHNj?g0?gyŇ?g& }6?g̲d>g bR/a>g^B/=z.=Q;=) r,gr[?gF*?g[ ?go㫨7?g2{>g f1FHa>g@.=r&) gʆ2P?guٖt%?g ׮?g"Yb"\?ghK?g=K>g΢;wF>gd]=cEI<) r,g7M?gy8?g^W%?g^qHy-_?g9"Y1Q?g>goq<&>g|X=r'rr*) r4rrr/rr.rrGr)r%rcrFN4FD4GN4GD4FN8FD8GN8GD8f4g4f8g8rrArirrs r&rrs ggaj! ggaj! QUm!  77 #   77 #   77 #   77 #   77 #   77 #   77 #   77 # {{3a#++c1"556"3;;sA S!!44" {{3a#++c1"556"3;;sA S!!44" S$ iib"! iib"!  QUQU""1uq1u}" R-r'c||c\}\}t|}t|tjz }t j ||z }||z||zf}||fSrw)rrr/rr4r)rzr{rr primal_outsin_termcos_term tangent_outs r&sici_jvpr:$ s[*$1Aw* !bee)_( WWQZ!^(Ax!|,+ [  r'c t tj|jj  |d  |d t j tj|z }tj |d| fd|}tj| |dk( z|}t|| |z tj| |dk( |z z t j} fd} fd}tj|||}|}| |dz } |d| z|ztjt!|z |d z S) Nrqr,rEc||z zSrwr>)r}psirs r&rkz_expn1..9 s#a-r')r%rxkykpkrjrc .|dxxz cc<|dxx|d|dz zcc<|dxxz cc<|dxxtj|dk7|d|dz z cc<tj|dk7t|d|dz |d<|S)Nr>r?rr@rjrr4rGr)rrrs r&bodyz_expn1..bodyE sdGsNGdGqv$GdGsNGeH !D'T/1T7QtW+rMACHEPrs r&rGz_expn1..condM s) cFR#_ $3& 99r'rrj)rer rr.epsr/rr4rbrrrGdictr while_loopr>r")r%rHr=n1rQrCrGrrrrFrrrs @@@@r&_expn1rL1 s2" << $ $& As$ 1c # #''!*$# bAh#?E# yybAhc 1-" b   Qw !r!Qx-scBh'78ff $ : nnT4&!!"Q(l! 31s SWWWQZ0 01U8 ;;r'c  t|dtj|jj|d |d t d | |z |zz |t j | } fd}fd}tj|||}|dtj| zS) NgCrqr,rE) rpkm2qkm2pkm1qkm1rjrrKr%c |d}|dxx|ddz cc<|d}||dz|dk(}tj||}tj|||dz |dz z||dz }|d|z|d|zz}|d|z|d|zz}|k7}tj|||z |d x|d <} tj|t|d | z | z |d <tj|| |d |d <|d|d<||d<|d|d<||d<t|kD} d D]4} d D]-} | dz| z} tj| || z || || </6|S)Nr%rrEr*rPrNrQrOrKrjrpq12kmrB)rr%roddr?r>r@qknzrKis_bigrr}keyBIGrrHrrs r&rCz_expn2..bodyj s #AcFb3mF #A bAh,"Q( "C 3Q B 3QAq\R1X55q2a8| DB 6R!F)b. (B 6R!F)b. (B tB2rBw#//AcFQ YYr3%1 12C 8AcFyyQ%)AeH& AfIAfI& AfIAfI Ws]F 99!$hl61S6C<38#99 Hr'c:|d|ddkD|dkDzS)Nr%rrrr>rEs r&rGz_expn2..cond s) cFR#] "qv 77r'rj) rer rr.rGrHr/rrrIr4r>) r%rHrQrCrGrr[rFrrrs ` @@@@@r&_expn2r]V s" 1$%# << $ $& As$ 1c # Ah Q q1u BFFm  $  08 nnT4&! 5CGGQBK r'ct}||d}||z}|||zz }|}||z||d|z|z||d|z|zz ||zzz}||||||d|zz zzz}|||zz}||ztj| z|z S)Nr,rrr*)rer4r>)r%rHrrr>r?rrjs r&_expn3r_ s" 1c #1u" b2g"! Q"Q(Q,"R1X\A%55A=># cAR1X\)**+# cAg# )swwr{ "R ''r')rc td||\}}tj|jtj r t dt}||d}||d}|||dk||kz||k(|||dkz||k(|||dk\z|||dk(||k\z|||dk\||kDg}tj|||dk(||z|}tjtj||z tj| |z tttg}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` expnz,expn does not support complex-valued inputs.rrEr*ir*)rr r-r.r/r0r1rer4rGr8rr>r_r]rLr) rHr%rrrrrJvalsrets r&rara s>. fa +$!Q qww 2 23 C DD" Aq$ 1a#Aq\a$h$Y1r!Qx< $Y11a=!"Q(]qDy!"Q+W  % yybAhAq)"FFFF"HGGQBK!O    $ a*# *r'c ||c\}\}t||tjtj|ttj|t |d|fSrg)rarrhrrdre)rHrzr{r%r|s r&expn_jvpre sWH.$1 aSWWGGENDJq!$45q9 r'ctd|\}tj|jtj r t dtttd|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` rz,exp1 does not support complex-valued inputs.rE) rr r-r.r/r0r1rrrar$s r&rr sK(FA&"! qww 2 23 C DD eT!QZ  r'ctjgd|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,)r4rr.r)rrrs r& _spence_polyrh sf ii77$! ii''#! ckk!Q #++a"3 33r'c|dkD}tj||gddg}|dkD}|dk}||z}tj|||gdddg}t|}tjd zd z tj |tj d |z zz |z }tj |||}d tj |d zz|z }tj |||S) Nrc d|z Srr>r$s r&rkz_spence_calc.. s sQwr'c|Srwr>r$s r&rkz_spence_calc.. s!r'g?rcd|z dz Srr>r$s r&rkz_spence_calc.. ssQw}r'c| Srwr>r$s r&rkz_spence_calc.. sr'c |dz Srr>r$s r&rkz_spence_calc.. s Cr'r*g@r,r,)r4rrhr/rrbrG)r%x2_bool x1_5_boolx_5_boolrrt y_flag_one y_flag_twos r& _spence_calcrt s G' mmAy& 46!#g) W( i ' mmA),"')*! 1o!uuzC#''!*swwsQw/?"??!C* ii*a(!cggajAo%)* 7J **r'ctj||dk|dk(|dk(gtjdtjdzdz t gS)Nrqr,rr*r)r4rr/r8rrtr$s r&_spencerv sI qCc184255A:><@ BBr'ctj|}tj|}|tj tj fvrtd|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.) r4rrr.r/rrrrvrs r&spencerx! sZH kk!n! ))A,% 2::rzz** LM OO r'ctjtj|d}|dkr t dt j gd}|dkr|d|dzSt j|dzjddj|}t jd|dzd |j }d tjd zz t j|dz |zdz tjd zz z}t jd d |j }t j|dddf|dddf zd }|jddd j|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.)rEr,gUUUUUU?rNrErr*rr,rMr)r rr[r\r1r4rrirjrkrr.r/rrr)rHb3bnrrrrs r& bernoullir|M s8  X^^Q0IJ!U 8 99 yy "U fq1u: yyQ2A""2&" jjAE1BHH-! RUUaZ3;;Qx!|a'7"%%1*'DEE" jjBbhh'! wwqDzaaj[(q1" qt!tq2v ''r'c6td||\}}tj|jtj r t dtj|dk(tjd|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. pochz0jnp.poch does not support complex-valued inputs.rqrEr) rr r-r.r/r0r1r4rGrr=rrs r&r~r~k ss, fa +$!Q qww 2 23 G HH 17CIIaqww7q1ua9P QQr'cPt||zt|z t||zS)zT Defined in : https://functions.wolfram.com/GammaBetaErf/Pochhammer/20/01/01/ rQr~rs r&_poch_z_derivativer s& !a%.71: %a 33r'c8t||zt||zS)zT Defined in : https://functions.wolfram.com/GammaBetaErf/Pochhammer/20/01/02/ rrs r&_poch_m_derivativer s Q$q!* $$r'c t|||zSrw)r)z_dotr6rrs r&rkrk s#5a#;e#Cr'c t|||zSrw)r)m_dotr6rrs r&rkrk 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 }|||fSrgr>stateseriertermrArBr%s r&rCz_hyp1f1_serie..body sQNE1d TMEQUq1u  !QU ++DFA !T>r'cx|\}}}|dktj|tj|z kDzSNrrrrrr precisions r&rGz_hyp1f1_serie..cond 7NE1d G 6B CCr'rErr rr.rGrrIrArBr%rCrGrQrs``` @r& _hyp1f1_serier sUll177#'')D Aq1uqy$ dD )! ,,r'c<tjjjfd}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 }|||fSrgr>rs r&rCz _hyp1f1_asymptotic..body sYNE1d TMEQUQY1q519 %Q /! 33DFA !T>r'cx|\}}}|dktj|tj|z kDzSrrrs r&rGz _hyp1f1_asymptotic..cond rr'rEr)r rr.rGrrIr=r>)rArBr%rCrGrQrrs``` @r&_hyp1f1_asymptoticr sll177#'')D AA!a% 1$ $$ ..tT *1 -% qE!H swwqz )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 }|||fSrgrQrs r&rCz"_hyp1f1_a_derivative..body shNE1d TWQU^gaj0 11EQUq1u  !QU ++DFA !T>r'cx|\}}}|dktj|tj|z kDzSrrrs r&rGz"_hyp1f1_a_derivative..cond rr'rrErrs``` @r&_hyp1f1_a_derivativer Ull177#'')D 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 }|||fSrgrrs r&rCz"_hyp1f1_b_derivative..body shNE1d TWQZ'!a%.0 11EQUq1u  !QU ++DFA !T>r'cx|\}}}|dktj|tj|z kDzSrrrs r&rGz"_hyp1f1_b_derivative..cond rr'rrErrs``` @r&_hyp1f1_b_derivativer rr'c4||z t|dz|dz|zS)zv Define it as a serie using : https://functions.wolfram.com/HypergeometricFunctions/Hypergeometric1F1/20/01/04/ rE)hyp1f1rOs r&_hyp1f1_x_derivativer s$ QAq1ua( ((r'c Dtd|||\}}}tj|jtj r t dtjtj|dktt|||}|dk(dz||k(|dk7zdzz|dk(|dk7zdzz}tj||tjd|jtj|tjtj |jS) 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. rz.hyp1f1 does not support complex-valued inputs.drrEr*rr)rr r-r.r/r0r1rrGrrrselect_nr4rr>r)rArBr%r~r\s r&rr s< !1a 3'!Q qww 2 23 E FF 88CGGAJ$m5GAq Q& 6Q,16a1f-2 2qAv!q&6IQ5N N% eii1ggajiiagg6  88r'c"t||||zSrw)r)a_dotr6rArBr%s r&rkrkG %9!Q%BU%Jr'c"t||||zSrw)r)b_dotr6rArBr%s r&rkrkH rr'c"t||||zSrw)r)r|r6rArBr%s r&rkrkI rr'c>tjjjdz}t j }t j kt j t j|z |kt jt j dzdk(t j dkkD}}t j|t j||t jfd}t jdjt jdjf} tjt jdjdz|| dS)z The Taylor series representation of the 2F1 hypergeometric function terminates when either a or b is a non-positive integer. See Eq. 4.1 and Taylor Series Method (a) from PEARSON, OLVER & PORTER 2014 https://doi.org/10.48550/arXiv.1407.7786 rMrErch|\}}||z dz |zdz z |zdz z|z zz}||z }||fSrgr>)r}rrrrArBr(r%s r&rCz_hyp2f1_terminal..bodyn sWKE4a!eaiLAEAI &!a%!) 4q 81 <rrrrrArBr(r%s r&rCz_hyp2f1_serie..body sbNE1d TMEQUQY1q519 %Q 3a 7! ;;DFA !T>r'cx|\}}}|dktj|tj|zkDzSrr)rrrrrtols r&rGz_hyp2f1_serie..cond s7NE1d G swwu~(== >>r'rrrE)r rr.rGr4rrrI)rArBr(r%rCrGrQrs```` @r& _hyp2f1_serier~ s agg  " "$? ))AQWW % ))AQWW % ))AQWW % '$ dD )! ,,r'c `tj|jjdz}||z |z }t j |}t j |}t j |}t j |dkt j||z |k} t j |dkt j||z |k} t j| | } t j| } t jt j |dkD| t jt j||z |k\ddt j| dd} tj| t||||t||||t||||S)a$ Check for recurrence relations along with whether or not the series terminates. True recursion is not possible; however, the recurrence relation may still be approximated. See 4.6.1. Recurrence Relations from PEARSON, OLVER & PORTER 2014 https://doi.org/10.48550/arXiv.1407.7786 rMrg?rEr*)r rr.rGr4rrr logical_orrrGrrr_hyp2f1_digamma_transformr)rArBr(r%rGriarid neg_int_a neg_int_bneg_int_a_or_bnot_neg_int_a_or_br\s r&_hyp2f1_terminal_or_serier sN  QWW!!B&#!eai! yy|" yy|" yy|"ooa1fcgga"fo&;<)ooa1fcgga"fo&;<)>>)Y7.~6 ))COOAG-?@ #''!b&/S(!Q/ .!Q' )% e#Aq!Q//1a;&q!Q2 44r'c tjjjz z }dz t j |t j dk\|| t j dk\|t jd|jt j dk\t jd|j|t j dk\ jdt j}tdtdzztzz tzz |z }|tdzz}zzzztdzz }fd}d} |||t jdjt jdj|f } tj|| | \ } } } } } } } } } } }f d }t j dk(|tzttzz ||S) zi Digamma transformation of the 2F1 hypergeometric function. See AMS55 #15.3.10, #15.3.11, #15.3.12 rErrint32r,rc |\ }}}}}}}}}}}tj|dktj|tj|zk\Sr)r4rr)rrDrrrtrs r&rGz'_hyp2f1_digamma_transform..cond sT&+#Aq!Q1aAq! ??#g ggajD3771:%% r'c 4|\ }}}}}}}}} } } td| ztd| z|zzt|| z|zz t|| z|zz |z }||z}| |z } || || z|zz| dzz z}||| z|z| dz|zz z}| dz } ||||||||| | | f Srr) rrAaxrBrwr rrrKrrrts r&rCz'_hyp2f1_digamma_transform..body s(-%Ar1b!Q1aAa737Q;//'!a%"*2EE !a%"*   " #A AAFAa!ebj QW %%A!a%"*S1 %%AHA b!RAq!Q1 ,,r'cf tjdj}tjdj}tjdj}d} |||f}tjd||d}t }|t |zt  zt zzz z}||t  zt zzz z}tj dzdk7| |}z}tj dkD||z|z|||zzS)NrErrc|\}}}}}}}} d|z |z} ||||z|zz||z|zz| z z}|dz }||z}| |z } |||||||| fSrr>) r}rrArBd2r rrry1rKs r&for_bodyz@_hyp2f1_digamma_transform..compute_sum..for_body s!&aB1aB 'A+a1A q1urz *Q ..a3ha1faAgb 2q!Q2 %%r'r)r4rr.rrr=rG)rtrrrrrrrAardrBr(rwrr rdrr%s r& compute_sumz._hyp2f1_digamma_transform..compute_sum s 1AGG $B !177#A !177#A &!RAq!R'H q#x 22 6B aA%(Q,%B-%B-7 88BeAFmeAFm+ ,,A 37q.1"a(A RA 99R!VQURZR!V 44r')r rr.rGr4rrGrrxrbrQr=rrI)rArBr(r%rrrtrrGrCrQrDrrKrrrwrr rrrs```` @@@@@@@r&rr s agg  " "$!eai!!e! yy|" iiaQB! yyq!SYYq89" yyq#))AQWW5q9" "'2s#**73# wwqz" clWS1W%%B7'!b&/IBN!uQW~!2v!b&Aa#g.! - RB1a1AGG!.body qNE1d TWQU^gaj0 11EQUq1u Q '1q5 1A 55DFA !T>r'cx|\}}}|dktj|tj|z kDzSrrrs r&rGz"_hyp2f1_a_derivative..cond rr'rrErrArBr(r%rCrGrQrs```` @r&_hyp2f1_a_derivativer Zll177#'')D Aq1uqy1} $ dD )! ,,r'ctjjjfd}fd}ddzz zf}t j |||dS)zv Define it as a serie using : https://functions.wolfram.com/HypergeometricFunctions/Hypergeometric2F1/20/01/02/ c|\}}}||t|ztz zz }||z|zz|zz |dzz zz}|dz }|||fSrgrrs r&rCz"_hyp2f1_b_derivative..body3 rr'cx|\}}}|dktj|tj|z kDzSrrrs r&rGz"_hyp2f1_b_derivative..cond; rr'rrErrs```` @r&_hyp2f1_b_derivativer) rr'ctjjjfd}fd}ddzz zf}t j |||dS)zv Define it as a serie using : https://functions.wolfram.com/HypergeometricFunctions/Hypergeometric2F1/20/01/03/ c|\}}}||tt|zz zz }||z|zz|zz |dzz zz}|dz }|||fSrgrrs r&rCz"_hyp2f1_c_derivative..bodyO sqNE1d TWQZ'!a%.0 11EQUq1u Q '1q5 1A 55DFA !T>r'cx|\}}}|dktj|tj|z kDzSrrrs r&rGz"_hyp2f1_c_derivative..condW rr'rrErrs```` @r&_hyp2f1_c_derivativerE rr'cB||z|z t|dz|dz|dz|zS)z Define the derivative with regard to ``x`` : https://functions.wolfram.com/HypergeometricFunctions/Hypergeometric2F1/20/01/05/ rE)hyp2f1)rArBr(r%s r&_hyp2f1_x_derivativera s. QVAE1q5!a%3 33r'c!@td||||\}}}}tj|jjdz}||z |z }d|z }||z }||z }t j |} t j |} t j |} t j|dkt j|| z |k} t j|dkt j|| z |k} t j| | }t jt j|dk(t jt j|dk(|dk(|dk7dt jt j|dk(t j|dk|dzdk(dt jt j|dkt jt jt j|| z |k\|dkdt jt j|dk|dk(dt jt j|dk||k(dt jt j|dk||k(dt j|dkDdt j|dk(d d }tj|t jd|j t jtj |j ||zt#||||z|| z|| zt%|t%|zt%|t%|zz t#||||S) aThe 2F1 hypergeometric function. JAX implementation of :obj:`scipy.special.hyp2f1`. .. math:: \mathrm{hyp2f1}(a, b, c, x) = {}_2F_1(a; b; c; x) = \sum_{k=0}^\infty \frac{(a)_k(b)_k}{(c)_k}\frac{x^k}{k!} where :math:`(\cdot)_k` is the Pochammer symbol. The JAX version only accepts positive and real inputs. Values of ``a``, ``b``, ``c``, and ``x`` leading to high values of 2F1 may lead to erroneous results; consider enabling double precision in this case. Args: a: arraylike, real-valued b: arraylike, real-valued c: arraylike, real-valued x: arraylike, real-valued Returns: array of 2F1 values. rrMrErrr*rrrrr)rr rr.rGr4rrrrrGrrrrr/rrr=)rArBr(r%rGrrcacbricaicb neg_int_ca neg_int_cbneg_int_ca_or_cbr\s r&rrk s8$HaAq9*!Q1 QWW!!B&#!eai!!e!1u"1u" yy|" " # " #rQwS(9C(?@*rQwS(9C(?@*^^J ; ))CNN163??3>>!q&RSWXRX;Y[\`a[a+bcef IIcnnQ!VS__QUAEQJ-OPRSiiRQTQXQXYZ]_Y_Q`dgQgijmninAo1pqst #//!q&!q&91))COOAE16:AIIcooa!eQ!Vr'r&rs#'!!::''1/5L/D,7?8**Z*.Z29>&::8444:0;;" JL&  ! ! DD.K  ZFF.S |. j(>%P     B((( (X288(4: GC/ 01%F"#rzz2!#rzz2 "!RZZ0!!RZZ0D 8c L  & &=e7>e7N   K(&& wrwwq255y12C 49049.(57"c8_%35%/&%/P1" 1"#1",/1"1"hQ[[$([-2[[|Fb %b ,0b 5:b b J)!X3;nD # :%)#' 1,1,1,1," 1, ! 1, -2 1,p"& 03030303 03+0 03r-.!2!4!:!4!*!8 CC0) ) 11f0djX! !"- ` !640+,B )X(<RR84% CB -6A8--4--4))'8'8TJJJ. b-:4>Pf--4--4--4449=9=xPPPP 26 "/ " "L6: &3 & &r'