Data.Number.Flint.Acb.Hypgeom

Hypergeometric functions of complex variables

Rising factorials

acb_hypgeom_rising_ui_forward :: Ptr CAcb -> Ptr CAcb -> CULong -> CLong -> IO ()

acb_hypgeom_rising_ui_forward res x n prec

acb_hypgeom_rising_ui_bs :: Ptr CAcb -> Ptr CAcb -> CULong -> CLong -> IO ()

acb_hypgeom_rising_ui_bs res x n prec

acb_hypgeom_rising_ui_rs :: Ptr CAcb -> Ptr CAcb -> CULong -> CULong -> CLong -> IO ()

acb_hypgeom_rising_ui_rs res x n m prec

acb_hypgeom_rising_ui_rec :: Ptr CAcb -> Ptr CAcb -> CULong -> CLong -> IO ()

acb_hypgeom_rising_ui_rec res x n prec

acb_hypgeom_rising_ui :: Ptr CAcb -> Ptr CAcb -> CULong -> CLong -> IO ()

acb_hypgeom_rising_ui res x n prec

acb_hypgeom_rising :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_rising res x n prec

Computes the rising factorial \((x)_n\).

The forward version uses the forward recurrence. The bs version uses binary splitting. The rs version uses rectangular splitting. It takes an extra tuning parameter m which can be set to zero to choose automatically. The rec version chooses an algorithm automatically, avoiding use of the gamma function (so that it can be used in the computation of the gamma function). The default versions (rising_ui and rising_ui) choose an algorithm automatically and may additionally fall back on the gamma function.

acb_hypgeom_rising_ui_jet_powsum :: Ptr CAcb -> Ptr CAcb -> CULong -> CLong -> CLong -> IO ()

acb_hypgeom_rising_ui_jet_powsum res x n len prec

acb_hypgeom_rising_ui_jet_bs :: Ptr CAcb -> Ptr CAcb -> CULong -> CLong -> CLong -> IO ()

acb_hypgeom_rising_ui_jet_bs res x n len prec

acb_hypgeom_rising_ui_jet_rs :: Ptr CAcb -> Ptr CAcb -> CULong -> CULong -> CLong -> CLong -> IO ()

acb_hypgeom_rising_ui_jet_rs res x n m len prec

acb_hypgeom_rising_ui_jet :: Ptr CAcb -> Ptr CAcb -> CULong -> CLong -> CLong -> IO ()

acb_hypgeom_rising_ui_jet res x n len prec

Computes the jet of the rising factorial \((x)_n\), truncated to length len. In other words, constructs the polynomial \((X + x)_n \in \mathbb{R}[X]\), truncated if \(\operatorname{len} < n + 1\) (and zero-extended if \(\operatorname{len} > n + 1\)).

The powsum version computes the sequence of powers of x and forms integral linear combinations of these. The bs version uses binary splitting. The rs version uses rectangular splitting. It takes an extra tuning parameter m which can be set to zero to choose automatically. The default version chooses an algorithm automatically.

acb_hypgeom_log_rising_ui :: Ptr CAcb -> Ptr CAcb -> CULong -> CLong -> IO ()

acb_hypgeom_log_rising_ui res x n prec

Computes the log-rising factorial \(\log \, (x)_n = \sum_{k=0}^{n-1} \log(x+k)\).

This first computes the ordinary rising factorial and then determines the branch correction \(2 \pi i m\) with respect to the principal logarithm. The correction is computed using Hare's algorithm in floating-point arithmetic if this is safe; otherwise, a direct computation of \(\sum_{k=0}^{n-1} \arg(x+k)\) is used as a fallback.

acb_hypgeom_log_rising_ui_jet :: Ptr CAcb -> Ptr CAcb -> CULong -> CLong -> CLong -> IO ()

acb_hypgeom_log_rising_ui_jet res x n len prec

Computes the jet of the log-rising factorial \(\log \, (x)_n\), truncated to length len.

Gamma function

acb_hypgeom_gamma_stirling_sum_horner :: Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> IO ()

acb_hypgeom_gamma_stirling_sum_horner s z N prec

acb_hypgeom_gamma_stirling_sum_improved :: Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> CLong -> IO ()

acb_hypgeom_gamma_stirling_sum_improved s z N K prec

Sets res to the final sum in the Stirling series for the gamma function truncated before the term with index N, i.e. computes \(\sum_{n=1}^{N-1} B_{2n} / (2n(2n-1) z^{2n-1})\). The horner version uses Horner scheme with gradual precision adjustments. The improved version uses rectangular splitting for the low-index terms and reexpands the high-index terms as hypergeometric polynomials, using a splitting parameter K (which can be set to 0 to use a default value).

acb_hypgeom_gamma_stirling :: Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_gamma_stirling res x reciprocal prec

Sets res to the gamma function of x computed using the Stirling series together with argument reduction. If reciprocal is set, the reciprocal gamma function is computed instead.

acb_hypgeom_gamma_taylor :: Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO CInt

acb_hypgeom_gamma_taylor res x reciprocal prec

Attempts to compute the gamma function of x using Taylor series together with argument reduction. This is only supported if x and prec are both small enough. If successful, returns 1; otherwise, does nothing and returns 0. If reciprocal is set, the reciprocal gamma function is computed instead.

acb_hypgeom_gamma :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_gamma res x prec

Sets res to the gamma function of x computed using a default algorithm choice.

acb_hypgeom_rgamma :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_rgamma res x prec

Sets res to the reciprocal gamma function of x computed using a default algorithm choice.

acb_hypgeom_lgamma :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_lgamma res x prec

Sets res to the principal branch of the log-gamma function of x computed using a default algorithm choice.

Convergent series

acb_hypgeom_pfq_bound_factor :: Ptr CMag -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> Ptr CAcb -> CULong -> IO ()

acb_hypgeom_pfq_bound_factor C a p b q z n

Computes a factor C such that \(\left|\sum_{k=n}^{\infty} T(k)\right| \le C |T(n)|\). See algorithms_hypergeometric_convergent. As currently implemented, the bound becomes infinite when \(n\) is too small, even if the series converges.

acb_hypgeom_pfq_choose_n :: Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> IO CLong

acb_hypgeom_pfq_choose_n a p b q z prec

Heuristically attempts to choose a number of terms n to sum of a hypergeometric series at a working precision of prec bits.

Uses double precision arithmetic internally. As currently implemented, it can fail to produce a good result if the parameters are extremely large or extremely close to nonpositive integers.

Numerical cancellation is assumed to be significant, so truncation is done when the current term is prec bits smaller than the largest encountered term.

This function will also attempt to pick a reasonable truncation point for divergent series.

acb_hypgeom_pfq_sum_forward :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> CLong -> IO ()

acb_hypgeom_pfq_sum_forward s t a p b q z n prec

acb_hypgeom_pfq_sum_rs :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> CLong -> IO ()

acb_hypgeom_pfq_sum_rs s t a p b q z n prec

acb_hypgeom_pfq_sum_bs :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> CLong -> IO ()

acb_hypgeom_pfq_sum_bs s t a p b q z n prec

acb_hypgeom_pfq_sum_fme :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> CLong -> IO ()

acb_hypgeom_pfq_sum_fme s t a p b q z n prec

acb_hypgeom_pfq_sum :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> CLong -> IO ()

acb_hypgeom_pfq_sum s t a p b q z n prec

Computes \(s = \sum_{k=0}^{n-1} T(k)\) and \(t = T(n)\). Does not allow aliasing between input and output variables. We require \(n \ge 0\).

The forward version computes the sum using forward recurrence.

The bs version computes the sum using binary splitting.

The rs version computes the sum in reverse order using rectangular splitting. It only computes a magnitude bound for the value of t.

The fme version uses fast multipoint evaluation.

The default version automatically chooses an algorithm depending on the inputs.

acb_hypgeom_pfq_sum_bs_invz :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> CLong -> IO ()

acb_hypgeom_pfq_sum_bs_invz s t a p b q w n prec

acb_hypgeom_pfq_sum_invz :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> IO ()

acb_hypgeom_pfq_sum_invz s t a p b q z w n prec

Like acb_hypgeom_pfq_sum, but taking advantage of \(w = 1/z\) possibly having few bits.

acb_hypgeom_pfq_direct :: Ptr CAcb -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> CLong -> IO ()

acb_hypgeom_pfq_direct res a p b q z n prec

Computes

\[{}_pf_{q}(z) = \sum_{k=0}^{\infty} T(k) = \sum_{k=0}^{n-1} T(k) + \varepsilon\]

directly from the defining series, including a rigorous bound for the truncation error \(\varepsilon\) in the output.

If \(n < 0\), this function chooses a number of terms automatically using acb_hypgeom_pfq_choose_n.

acb_hypgeom_pfq_series_sum_forward :: Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr (Ptr CAcbPoly) -> CLong -> Ptr (Ptr CAcbPoly) -> CLong -> Ptr CAcbPoly -> CInt -> CLong -> CLong -> CLong -> IO ()

acb_hypgeom_pfq_series_sum_forward s t a p b q z regularized n len prec

acb_hypgeom_pfq_series_sum_bs :: Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr (Ptr CAcbPoly) -> CLong -> Ptr (Ptr CAcbPoly) -> CLong -> Ptr CAcbPoly -> CInt -> CLong -> CLong -> CLong -> IO ()

acb_hypgeom_pfq_series_sum_bs s t a p b q z regularized n len prec

acb_hypgeom_pfq_series_sum_rs :: Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr (Ptr CAcbPoly) -> CLong -> Ptr (Ptr CAcbPoly) -> CLong -> Ptr CAcbPoly -> CInt -> CLong -> CLong -> CLong -> IO ()

acb_hypgeom_pfq_series_sum_rs s t a p b q z regularized n len prec

acb_hypgeom_pfq_series_sum :: Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr (Ptr CAcbPoly) -> CLong -> Ptr (Ptr CAcbPoly) -> CLong -> Ptr CAcbPoly -> CInt -> CLong -> CLong -> CLong -> IO ()

acb_hypgeom_pfq_series_sum s t a p b q z regularized n len prec

Computes \(s = \sum_{k=0}^{n-1} T(k)\) and \(t = T(n)\) given parameters and argument that are power series. Does not allow aliasing between input and output variables. We require \(n \ge 0\) and that len is positive.

If regularized is set, the regularized sum is computed, avoiding division by zero at the poles of the gamma function.

The forward, bs, rs and default versions use forward recurrence, binary splitting, rectangular splitting, and an automatic algorithm choice.

acb_hypgeom_pfq_series_direct :: Ptr CAcbPoly -> Ptr (Ptr CAcbPoly) -> CLong -> Ptr (Ptr CAcbPoly) -> CLong -> Ptr CAcbPoly -> CInt -> CLong -> CLong -> CLong -> IO ()

acb_hypgeom_pfq_series_direct res a p b q z regularized n len prec

Computes \({}_pf_{q}(z)\) directly using the defining series, given parameters and argument that are power series. The result is a power series of length len. We require that len is positive.

An error bound is computed automatically as a function of the number of terms n. If \(n < 0\), the number of terms is chosen automatically.

If regularized is set, the regularized hypergeometric function is computed instead.

Asymptotic series

acb_hypgeom_u_asymp :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> IO ()

acb_hypgeom_u_asymp res a b z n prec

Sets res to \(U^{*}(a,b,z)\) computed using n terms of the asymptotic series, with a rigorous bound for the error included in the output. We require \(n \ge 0\).

acb_hypgeom_u_use_asymp :: Ptr CAcb -> CLong -> IO CInt

acb_hypgeom_u_use_asymp z prec

Heuristically determines whether the asymptotic series can be used to evaluate \(U(a,b,z)\) to prec accurate bits (assuming that a and b are small).

Generalized hypergeometric function

acb_hypgeom_pfq :: Ptr CAcbPoly -> Ptr CAcb -> CLong -> Ptr CAcb -> CLong -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_pfq res a p b q z regularized prec

Computes the generalized hypergeometric function \({}_pF_{q}(z)\), or the regularized version if regularized is set.

This function automatically delegates to a specialized implementation when the order (p, q) is one of (0,0), (1,0), (0,1), (1,1), (2,1). Otherwise, it falls back to direct summation.

While this is a top-level function meant to take care of special cases automatically, it does not generally perform the optimization of deleting parameters that appear in both a and b. This can be done ahead of time by the user in applications where duplicate parameters are likely to occur.

Confluent hypergeometric functions

acb_hypgeom_u_1f1_series :: Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr CAcbPoly -> CLong -> CLong -> IO ()

acb_hypgeom_u_1f1_series res a b z len prec

Computes \(U(a,b,z)\) as a power series truncated to length len, given \(a, b, z \in \mathbb{C}[[x]]\). If \(b[0] \in \mathbb{Z}\), it computes one extra derivative and removes the singularity (it is then assumed that \(b[1] \ne 0\)). As currently implemented, the output is indeterminate if \(b\) is nonexact and contains an integer.

acb_hypgeom_u_1f1 :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_u_1f1 res a b z prec

Computes \(U(a,b,z)\) as a sum of two convergent hypergeometric series. If \(b \in \mathbb{Z}\), it computes the limit value via acb_hypgeom_u_1f1_series. As currently implemented, the output is indeterminate if \(b\) is nonexact and contains an integer.

acb_hypgeom_u :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_u res a b z prec

Computes \(U(a,b,z)\) using an automatic algorithm choice. The function acb_hypgeom_u_asymp is used if \(a\) or \(a-b+1\) is a nonpositive integer (in which case the asymptotic series terminates), or if z is sufficiently large. Otherwise acb_hypgeom_u_1f1 is used.

acb_hypgeom_m_asymp :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_m_asymp res a b z regularized prec

acb_hypgeom_m_1f1 :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_m_1f1 res a b z regularized prec

acb_hypgeom_m :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_m res a b z regularized prec

Computes the confluent hypergeometric function \(M(a,b,z) = {}_1F_1(a,b,z)\), or \(\mathbf{M}(a,b,z) = \frac{1}{\Gamma(b)} {}_1F_1(a,b,z)\) if regularized is set.

acb_hypgeom_1f1 :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_1f1 res a b z regularized prec

Alias for acb_hypgeom_m.

acb_hypgeom_0f1_asymp :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_0f1_asymp res a z regularized prec

acb_hypgeom_0f1_direct :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_0f1_direct res a z regularized prec

acb_hypgeom_0f1 :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_0f1 res a z regularized prec

Computes the confluent hypergeometric function \({}_0F_1(a,z)\), or \(\frac{1}{\Gamma(a)} {}_0F_1(a,z)\) if regularized is set, using asymptotic expansions, direct summation, or an automatic algorithm choice. The asymp version uses the asymptotic expansions of Bessel functions, together with the connection formulas

\[`\] \[\frac{{}_0F_1(a,z)}{\Gamma(a)} = (-z)^{(1-a)/2} J_{a-1}(2 \sqrt{-z}) = z^{(1-a)/2} I_{a-1}(2 \sqrt{z}).\]

The Bessel-J function is used in the left half-plane and the Bessel-I function is used in the right half-plane, to avoid loss of accuracy due to evaluating the square root on the branch cut.

Error functions and Fresnel integrals

acb_hypgeom_erf_propagated_error :: Ptr CMag -> Ptr CMag -> Ptr CAcb -> IO ()

acb_hypgeom_erf_propagated_error re im z

Sets re and im to upper bounds for the error in the real and imaginary part resulting from approximating the error function of z by the error function evaluated at the midpoint of z. Uses the first derivative.

acb_hypgeom_erf_1f1a :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_erf_1f1a res z prec

acb_hypgeom_erf_1f1b :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_erf_1f1b res z prec

acb_hypgeom_erf_asymp :: Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> CLong -> IO ()

acb_hypgeom_erf_asymp res z complementary prec prec2

Computes the error function respectively using

\[ \begin{aligned} \operatorname{erf}(z) &= \frac{2z}{\sqrt{\pi}} {}_1F_1(\tfrac{1}{2}, \tfrac{3}{2}, -z^2)\\ \operatorname{erf}(z) &= \frac{2z e^{-z^2}}{\sqrt{\pi}} {}_1F_1(1, \tfrac{3}{2}, z^2)\\ \operatorname{erf}(z) &= \frac{z}{\sqrt{z^2}} \left(1 - \frac{e^{-z^2}}{\sqrt{\pi}} U(\tfrac{1}{2}, \tfrac{1}{2}, z^2)\right) = \frac{z}{\sqrt{z^2}} - \frac{e^{-z^2}}{z \sqrt{\pi}} U^{*}(\tfrac{1}{2}, \tfrac{1}{2}, z^2). \end{aligned} \]

The asymp version takes a second precision to use for the U term. It also takes an extra flag complementary, computing the complementary error function if set.

acb_hypgeom_erf :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_erf res z prec

Computes the error function using an automatic algorithm choice. If z is too small to use the asymptotic expansion, a working precision sufficient to circumvent cancellation in the hypergeometric series is determined automatically, and a bound for the propagated error is computed with acb_hypgeom_erf_propagated_error.

_acb_hypgeom_erf_series :: Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> CLong -> IO ()

_acb_hypgeom_erf_series res z zlen len prec

acb_hypgeom_erf_series :: Ptr CAcbPoly -> Ptr CAcbPoly -> CLong -> CLong -> IO ()

acb_hypgeom_erf_series res z len prec

Computes the error function of the power series z, truncated to length len.

acb_hypgeom_erfc :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_erfc res z prec

Computes the complementary error function \(\operatorname{erfc}(z) = 1 - \operatorname{erf}(z)\). This function avoids catastrophic cancellation for large positive z.

_acb_hypgeom_erfc_series :: Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> CLong -> IO ()

_acb_hypgeom_erfc_series res z zlen len prec

acb_hypgeom_erfc_series :: Ptr CAcbPoly -> Ptr CAcbPoly -> CLong -> CLong -> IO ()

acb_hypgeom_erfc_series res z len prec

Computes the complementary error function of the power series z, truncated to length len.

acb_hypgeom_erfi :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_erfi res z prec

Computes the imaginary error function \(\operatorname{erfi}(z) = -i\operatorname{erf}(iz)\). This is a trivial wrapper of acb_hypgeom_erf.

_acb_hypgeom_erfi_series :: Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> CLong -> IO ()

_acb_hypgeom_erfi_series res z zlen len prec

acb_hypgeom_erfi_series :: Ptr CAcbPoly -> Ptr CAcbPoly -> CLong -> CLong -> IO ()

acb_hypgeom_erfi_series res z len prec

Computes the imaginary error function of the power series z, truncated to length len.

acb_hypgeom_fresnel :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_fresnel res1 res2 z normalized prec

Sets res1 to the Fresnel sine integral \(S(z)\) and res2 to the Fresnel cosine integral \(C(z)\). Optionally, just a single function can be computed by passing NULL as the other output variable. The definition \(S(z) = \int_0^z \sin(t^2) dt\) is used if normalized is 0, and \(S(z) = \int_0^z \sin(\tfrac{1}{2} \pi t^2) dt\) is used if normalized is 1 (the latter is the Abramowitz & Stegun convention). \(C(z)\) is defined analogously.

_acb_hypgeom_fresnel_series :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> CInt -> CLong -> CLong -> IO ()

_acb_hypgeom_fresnel_series res1 res2 z zlen normalized len prec

acb_hypgeom_fresnel_series :: Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr CAcbPoly -> CInt -> CLong -> CLong -> IO ()

acb_hypgeom_fresnel_series res1 res2 z normalized len prec

Sets res1 to the Fresnel sine integral and res2 to the Fresnel cosine integral of the power series z, truncated to length len. Optionally, just a single function can be computed by passing NULL as the other output variable.

Bessel functions

acb_hypgeom_bessel_j_asymp :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_bessel_j_asymp res nu z prec

Computes the Bessel function of the first kind via acb_hypgeom_u_asymp. For all complex \(\nu, z\), we have

\[`\] \[J_{\nu}(z) = \frac{z^{\nu}}{2^{\nu} e^{iz} \Gamma(\nu+1)} {}_1F_1(\nu+\tfrac{1}{2}, 2\nu+1, 2iz) = A_{+} B_{+} + A_{-} B_{-}\]

where

\[`\] \[A_{\pm} = z^{\nu} (z^2)^{-\tfrac{1}{2}-\nu} (\mp i z)^{\tfrac{1}{2}+\nu} (2 \pi)^{-1/2} = (\pm iz)^{-1/2-\nu} z^{\nu} (2 \pi)^{-1/2}\]

\[`\] \[B_{\pm} = e^{\pm i z} U^{*}(\nu+\tfrac{1}{2}, 2\nu+1, \mp 2iz).\]

Nicer representations of the factors \(A_{\pm}\) can be given depending conditionally on the parameters. If \(\nu + \tfrac{1}{2} = n \in \mathbb{Z}\), we have \(A_{\pm} = (\pm i)^{n} (2 \pi z)^{-1/2}\). And if \(\operatorname{Re}(z) > 0\), we have \(A_{\pm} = \exp(\mp i [(2\nu+1)/4] \pi) (2 \pi z)^{-1/2}\).

acb_hypgeom_bessel_j_0f1 :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_bessel_j_0f1 res nu z prec

Computes the Bessel function of the first kind from

\[`\] \[J_{\nu}(z) = \frac{1}{\Gamma(\nu+1)} \left(\frac{z}{2}\right)^{\nu} {}_0F_1\left(\nu+1, -\frac{z^2}{4}\right).\]

acb_hypgeom_bessel_j :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_bessel_j res nu z prec

Computes the Bessel function of the first kind \(J_{\nu}(z)\) using an automatic algorithm choice.

acb_hypgeom_bessel_y :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_bessel_y res nu z prec

Computes the Bessel function of the second kind \(Y_{\nu}(z)\) from the formula

\[`\] \[Y_{\nu}(z) = \frac{\cos(\nu \pi) J_{\nu}(z) - J_{-\nu}(z)}{\sin(\nu \pi)}\]

unless \(\nu = n\) is an integer in which case the limit value

\[`\] \[Y_n(z) = -\frac{2}{\pi} \left( i^n K_n(iz) + \left[\log(iz)-\log(z)\right] J_n(z) \right)\]

is computed. As currently implemented, the output is indeterminate if \(\nu\) is nonexact and contains an integer.

acb_hypgeom_bessel_jy :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_bessel_jy res1 res2 nu z prec

Sets res1 to \(J_{\nu}(z)\) and res2 to \(Y_{\nu}(z)\), computed simultaneously. From these values, the user can easily construct the Bessel functions of the third kind (Hankel functions) \(H_{\nu}^{(1)}(z), H_{\nu}^{(2)}(z) = J_{\nu}(z) \pm i Y_{\nu}(z)\).

Modified Bessel functions

acb_hypgeom_bessel_i_asymp :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_bessel_i_asymp res nu z scaled prec

acb_hypgeom_bessel_i_0f1 :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_bessel_i_0f1 res nu z scaled prec

acb_hypgeom_bessel_i :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_bessel_i res nu z prec

acb_hypgeom_bessel_i_scaled :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_bessel_i_scaled res nu z prec

Computes the modified Bessel function of the first kind \(I_{\nu}(z) = z^{\nu} (iz)^{-\nu} J_{\nu}(iz)\) respectively using asymptotic series (see acb_hypgeom_bessel_j_asymp), the convergent series

\[`\] \[I_{\nu}(z) = \frac{1}{\Gamma(\nu+1)} \left(\frac{z}{2}\right)^{\nu} {}_0F_1\left(\nu+1, \frac{z^2}{4}\right),\]

or an automatic algorithm choice.

The scaled version computes the function \(e^{-z} I_{\nu}(z)\). The asymp and 0f1 functions implement both variants and allow choosing with a flag.

acb_hypgeom_bessel_k_asymp :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_bessel_k_asymp res nu z scaled prec

Computes the modified Bessel function of the second kind via via acb_hypgeom_u_asymp. For all \(\nu\) and all \(z \ne 0\), we have

\[`\] \[K_{\nu}(z) = \left(\frac{2z}{\pi}\right)^{-1/2} e^{-z} U^{*}(\nu+\tfrac{1}{2}, 2\nu+1, 2z).\]

If scaled is set, computes the function \(e^{z} K_{\nu}(z)\).

acb_hypgeom_bessel_k_0f1_series :: Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr CAcbPoly -> CInt -> CLong -> CLong -> IO ()

acb_hypgeom_bessel_k_0f1_series res nu z scaled len prec

Computes the modified Bessel function of the second kind \(K_{\nu}(z)\) as a power series truncated to length len, given \(\nu, z \in \mathbb{C}[[x]]\). Uses the formula

\[`\] \[K_{\nu}(z) = \frac{1}{2} \frac{\pi}{\sin(\pi \nu)} \left[ \left(\frac{z}{2}\right)^{-\nu} {}_0{\widetilde F}_1\left(1-\nu, \frac{z^2}{4}\right) - \left(\frac{z}{2}\right)^{\nu} {}_0{\widetilde F}_1\left(1+\nu, \frac{z^2}{4}\right) \right].\]

If \(\nu[0] \in \mathbb{Z}\), it computes one extra derivative and removes the singularity (it is then assumed that \(\nu[1] \ne 0\)). As currently implemented, the output is indeterminate if \(\nu[0]\) is nonexact and contains an integer.

If scaled is set, computes the function \(e^{z} K_{\nu}(z)\).

acb_hypgeom_bessel_k_0f1 :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_bessel_k_0f1 res nu z scaled prec

Computes the modified Bessel function of the second kind from

\[`\] \[K_{\nu}(z) = \frac{1}{2} \left[ \left(\frac{z}{2}\right)^{-\nu} \Gamma(\nu) {}_0F_1\left(1-\nu, \frac{z^2}{4}\right) - \left(\frac{z}{2}\right)^{\nu} \frac{\pi}{\nu \sin(\pi \nu) \Gamma(\nu)} {}_0F_1\left(\nu+1, \frac{z^2}{4}\right) \right]\]

if \(\nu \notin \mathbb{Z}\). If \(\nu \in \mathbb{Z}\), it computes the limit value via acb_hypgeom_bessel_k_0f1_series. As currently implemented, the output is indeterminate if \(\nu\) is nonexact and contains an integer.

If scaled is set, computes the function \(e^{z} K_{\nu}(z)\).

acb_hypgeom_bessel_k :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_bessel_k res nu z prec

Computes the modified Bessel function of the second kind \(K_{\nu}(z)\) using an automatic algorithm choice.

acb_hypgeom_bessel_k_scaled :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_bessel_k_scaled res nu z prec

Computes the function \(e^{z} K_{\nu}(z)\).

Airy functions

acb_hypgeom_airy_direct :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> IO ()

acb_hypgeom_airy_direct ai ai_prime bi bi_prime z n prec

Computes the Airy functions using direct series expansions truncated at n terms. Error bounds are included in the output.

acb_hypgeom_airy_asymp :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> IO ()

acb_hypgeom_airy_asymp ai ai_prime bi bi_prime z n prec

Computes the Airy functions using asymptotic expansions truncated at n terms. Error bounds are included in the output. For details about how the error bounds are computed, see algorithms_hypergeometric_asymptotic_airy.

acb_hypgeom_airy_bound :: Ptr CMag -> Ptr CMag -> Ptr CMag -> Ptr CMag -> Ptr CAcb -> IO ()

acb_hypgeom_airy_bound ai ai_prime bi bi_prime z

Computes bounds for the Airy functions using first-order asymptotic expansions together with error bounds. This function uses some shortcuts to make it slightly faster than calling acb_hypgeom_airy_asymp with \(n = 1\).

acb_hypgeom_airy :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_airy ai ai_prime bi bi_prime z prec

Computes Airy functions using an automatic algorithm choice.

We use acb_hypgeom_airy_asymp whenever this gives full accuracy and acb_hypgeom_airy_direct otherwise. In the latter case, we first use hardware double precision arithmetic to determine an accurate estimate of the working precision needed to compute the Airy functions accurately for given z. This estimate is obtained by comparing the leading-order asymptotic estimate of the Airy functions with the magnitude of the largest term in the power series. The estimate is generic in the sense that it does not take into account vanishing near the roots of the functions. We subsequently evaluate the power series at the midpoint of z and bound the propagated error using derivatives. Derivatives are bounded using acb_hypgeom_airy_bound.

acb_hypgeom_airy_jet :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> IO ()

acb_hypgeom_airy_jet ai bi z len prec

Writes to ai and bi the respective Taylor expansions of the Airy functions at the point z, truncated to length len. Either of the outputs can be NULL to avoid computing that function. The variable z is not allowed to be aliased with the outputs. To simplify the implementation, this method does not compute the series expansions of the primed versions directly; these are easily obtained by computing one extra coefficient and differentiating the output with _acb_poly_derivative.

_acb_hypgeom_airy_series :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> CLong -> IO ()

_acb_hypgeom_airy_series ai ai_prime bi bi_prime z zlen len prec

acb_hypgeom_airy_series :: Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr CAcbPoly -> CLong -> CLong -> IO ()

acb_hypgeom_airy_series ai ai_prime bi bi_prime z len prec

Computes the Airy functions evaluated at the power series z, truncated to length len. As with the other Airy methods, any of the outputs can be NULL.

Coulomb wave functions

acb_hypgeom_coulomb :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_coulomb F G Hpos Hneg l eta z prec

Writes to F, G, Hpos, Hneg the values of the respective Coulomb wave functions. Any of the outputs can be NULL.

acb_hypgeom_coulomb_jet :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> IO ()

acb_hypgeom_coulomb_jet F G Hpos Hneg l eta z len prec

Writes to F, G, Hpos, Hneg the respective Taylor expansions of the Coulomb wave functions at the point z, truncated to length len. Any of the outputs can be NULL.

_acb_hypgeom_coulomb_series :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> CLong -> IO ()

_acb_hypgeom_coulomb_series F G Hpos Hneg l eta z zlen len prec

acb_hypgeom_coulomb_series :: Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr CAcb -> Ptr CAcb -> Ptr CAcbPoly -> CLong -> CLong -> IO ()

acb_hypgeom_coulomb_series F G Hpos Hneg l eta z len prec

Computes the Coulomb wave functions evaluated at the power series z, truncated to length len. Any of the outputs can be NULL.

Incomplete gamma and beta functions

acb_hypgeom_gamma_upper_asymp :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_gamma_upper_asymp res s z regularized prec

acb_hypgeom_gamma_upper_1f1a :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_gamma_upper_1f1a res s z regularized prec

acb_hypgeom_gamma_upper_1f1b :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_gamma_upper_1f1b res s z regularized prec

acb_hypgeom_gamma_upper_singular :: Ptr CAcb -> CLong -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_gamma_upper_singular res s z regularized prec

acb_hypgeom_gamma_upper :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_gamma_upper res s z regularized prec

If regularized is 0, computes the upper incomplete gamma function \(\Gamma(s,z)\).

If regularized is 1, computes the regularized upper incomplete gamma function \(Q(s,z) = \Gamma(s,z) / \Gamma(s)\).

If regularized is 2, computes the generalized exponential integral \(z^{-s} \Gamma(s,z) = E_{1-s}(z)\) instead (this option is mainly intended for internal use; acb_hypgeom_expint is the intended interface for computing the exponential integral).

The different methods respectively implement the formulas

\[`\] \[\Gamma(s,z) = e^{-z} U(1-s,1-s,z)\]

\[`\] \[\Gamma(s,z) = \Gamma(s) - \frac{z^s}{s} {}_1F_1(s, s+1, -z)\]

\[`\] \[\Gamma(s,z) = \Gamma(s) - \frac{z^s e^{-z}}{s} {}_1F_1(1, s+1, z)\]

\[`\] \[\Gamma(s,z) = \frac{(-1)^n}{n!} (\psi(n+1) - \log(z)) + \frac{(-1)^n}{(n+1)!} z \, {}_2F_2(1,1,2,2+n,-z) - z^{-n} \sum_{k=0}^{n-1} \frac{(-z)^k}{(k-n) k!}, \quad n = -s \in \mathbb{Z}_{\ge 0}\]

and an automatic algorithm choice. The automatic version also handles other special input such as \(z = 0\) and \(s = 1, 2, 3\). The singular version evaluates the finite sum directly and therefore assumes that s is not too large.

_acb_hypgeom_gamma_upper_series :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> CInt -> CLong -> CLong -> IO ()

_acb_hypgeom_gamma_upper_series res s z zlen regularized n prec

acb_hypgeom_gamma_upper_series :: Ptr CAcbPoly -> Ptr CAcb -> Ptr CAcbPoly -> CInt -> CLong -> CLong -> IO ()

acb_hypgeom_gamma_upper_series res s z regularized n prec

Sets res to an upper incomplete gamma function where s is a constant and z is a power series, truncated to length n. The regularized argument has the same interpretation as in acb_hypgeom_gamma_upper.

acb_hypgeom_gamma_lower :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_gamma_lower res s z regularized prec

If regularized is 0, computes the lower incomplete gamma function \(\gamma(s,z) = \frac{z^s}{s} {}_1F_1(s, s+1, -z)\).

If regularized is 1, computes the regularized lower incomplete gamma function \(P(s,z) = \gamma(s,z) / \Gamma(s)\).

If regularized is 2, computes a further regularized lower incomplete gamma function \(\gamma^{*}(s,z) = z^{-s} P(s,z)\).

_acb_hypgeom_gamma_lower_series :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> CInt -> CLong -> CLong -> IO ()

_acb_hypgeom_gamma_lower_series res s z zlen regularized n prec

acb_hypgeom_gamma_lower_series :: Ptr CAcbPoly -> Ptr CAcb -> Ptr CAcbPoly -> CInt -> CLong -> CLong -> IO ()

acb_hypgeom_gamma_lower_series res s z regularized n prec

Sets res to an lower incomplete gamma function where s is a constant and z is a power series, truncated to length n. The regularized argument has the same interpretation as in acb_hypgeom_gamma_lower.

acb_hypgeom_beta_lower :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_beta_lower res a b z regularized prec

Computes the (lower) incomplete beta function, defined by \(B(a,b;z) = \int_0^z t^{a-1} (1-t)^{b-1}\), optionally the regularized incomplete beta function \(I(a,b;z) = B(a,b;z) / B(a,b;1)\).

In general, the integral must be interpreted using analytic continuation. The precise definitions for all parameter values are

\[`\] \[B(a,b;z) = \frac{z^a}{a} {}_2F_1(a, 1-b, a+1, z)\]

\[`\] \[I(a,b;z) = \frac{\Gamma(a+b)}{\Gamma(b)} z^a {}_2{\widetilde F}_1(a, 1-b, a+1, z).\]

Note that both functions with this definition are undefined for nonpositive integer a, and I is undefined for nonpositive integer \(a + b\).

_acb_hypgeom_beta_lower_series :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> CInt -> CLong -> CLong -> IO ()

_acb_hypgeom_beta_lower_series res a b z zlen regularized n prec

acb_hypgeom_beta_lower_series :: Ptr CAcbPoly -> Ptr CAcb -> Ptr CAcb -> Ptr CAcbPoly -> CInt -> CLong -> CLong -> IO ()

acb_hypgeom_beta_lower_series res a b z regularized n prec

Sets res to the lower incomplete beta function \(B(a,b;z)\) (optionally the regularized version \(I(a,b;z)\)) where a and b are constants and z is a power series, truncating the result to length n. The underscore method requires positive lengths and does not support aliasing.

Exponential and trigonometric integrals

acb_hypgeom_expint :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_expint res s z prec

Computes the generalized exponential integral \(E_s(z)\). This is a trivial wrapper of acb_hypgeom_gamma_upper.

acb_hypgeom_ei_asymp :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_ei_asymp res z prec

acb_hypgeom_ei_2f2 :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_ei_2f2 res z prec

acb_hypgeom_ei :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_ei res z prec

Computes the exponential integral \(\operatorname{Ei}(z)\), respectively using

\[`\] \[\operatorname{Ei}(z) = -e^z U(1,1,-z) - \log(-z) + \frac{1}{2} \left(\log(z) - \log\left(\frac{1}{z}\right) \right)\]

\[`\] \[\operatorname{Ei}(z) = z {}_2F_2(1, 1; 2, 2; z) + \gamma + \frac{1}{2} \left(\log(z) - \log\left(\frac{1}{z}\right) \right)\]

and an automatic algorithm choice.

_acb_hypgeom_ei_series :: Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> CLong -> IO ()

_acb_hypgeom_ei_series res z zlen len prec

acb_hypgeom_ei_series :: Ptr CAcbPoly -> Ptr CAcbPoly -> CLong -> CLong -> IO ()

acb_hypgeom_ei_series res z len prec

Computes the exponential integral of the power series z, truncated to length len.

acb_hypgeom_si_asymp :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_si_asymp res z prec

acb_hypgeom_si_1f2 :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_si_1f2 res z prec

acb_hypgeom_si :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_si res z prec

Computes the sine integral \(\operatorname{Si}(z)\), respectively using

\[`\] \[\operatorname{Si}(z) = \frac{i}{2} \left[ e^{iz} U(1,1,-iz) - e^{-iz} U(1,1,iz) + \log(-iz) - \log(iz) \right]\]

\[`\] \[\operatorname{Si}(z) = z {}_1F_2(\tfrac{1}{2}; \tfrac{3}{2}, \tfrac{3}{2}; -\tfrac{z^2}{4})\]

and an automatic algorithm choice.

_acb_hypgeom_si_series :: Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> CLong -> IO ()

_acb_hypgeom_si_series res z zlen len prec

acb_hypgeom_si_series :: Ptr CAcbPoly -> Ptr CAcbPoly -> CLong -> CLong -> IO ()

acb_hypgeom_si_series res z len prec

Computes the sine integral of the power series z, truncated to length len.

acb_hypgeom_ci_asymp :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_ci_asymp res z prec

acb_hypgeom_ci_2f3 :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_ci_2f3 res z prec

acb_hypgeom_ci :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_ci res z prec

Computes the cosine integral \(\operatorname{Ci}(z)\), respectively using

\[`\] \[\operatorname{Ci}(z) = \log(z) - \frac{1}{2} \left[ e^{iz} U(1,1,-iz) + e^{-iz} U(1,1,iz) + \log(-iz) + \log(iz) \right]\]

\[`\] \[\operatorname{Ci}(z) = -\tfrac{z^2}{4} {}_2F_3(1, 1; 2, 2, \tfrac{3}{2}; -\tfrac{z^2}{4}) + \log(z) + \gamma\]

and an automatic algorithm choice.

_acb_hypgeom_ci_series :: Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> CLong -> IO ()

_acb_hypgeom_ci_series res z zlen len prec

acb_hypgeom_ci_series :: Ptr CAcbPoly -> Ptr CAcbPoly -> CLong -> CLong -> IO ()

acb_hypgeom_ci_series res z len prec

Computes the cosine integral of the power series z, truncated to length len.

acb_hypgeom_shi :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_shi res z prec

Computes the hyperbolic sine integral \(\operatorname{Shi}(z) = -i \operatorname{Si}(iz)\). This is a trivial wrapper of acb_hypgeom_si.

_acb_hypgeom_shi_series :: Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> CLong -> IO ()

_acb_hypgeom_shi_series res z zlen len prec

acb_hypgeom_shi_series :: Ptr CAcbPoly -> Ptr CAcbPoly -> CLong -> CLong -> IO ()

acb_hypgeom_shi_series res z len prec

Computes the hyperbolic sine integral of the power series z, truncated to length len.

acb_hypgeom_chi_asymp :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_chi_asymp res z prec

acb_hypgeom_chi_2f3 :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_chi_2f3 res z prec

acb_hypgeom_chi :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_chi res z prec

Computes the hyperbolic cosine integral \(\operatorname{Chi}(z)\), respectively using

\[`\] \[\operatorname{Chi}(z) = -\frac{1}{2} \left[ e^{z} U(1,1,-z) + e^{-z} U(1,1,z) + \log(-z) - \log(z) \right]\]

\[`\] \[\operatorname{Chi}(z) = \tfrac{z^2}{4} {}_2F_3(1, 1; 2, 2, \tfrac{3}{2}; \tfrac{z^2}{4}) + \log(z) + \gamma\]

and an automatic algorithm choice.

_acb_hypgeom_chi_series :: Ptr CAcb -> Ptr CAcb -> CLong -> CLong -> CLong -> IO ()

_acb_hypgeom_chi_series res z zlen len prec

acb_hypgeom_chi_series :: Ptr CAcbPoly -> Ptr CAcbPoly -> CLong -> CLong -> IO ()

acb_hypgeom_chi_series res z len prec

Computes the hyperbolic cosine integral of the power series z, truncated to length len.

acb_hypgeom_li :: Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_li res z offset prec

If offset is zero, computes the logarithmic integral \(\operatorname{li}(z) = \operatorname{Ei}(\log(z))\).

If offset is nonzero, computes the offset logarithmic integral \(\operatorname{Li}(z) = \operatorname{li}(z) - \operatorname{li}(2)\).

_acb_hypgeom_li_series :: Ptr CAcb -> Ptr CAcb -> CLong -> CInt -> CLong -> CLong -> IO ()

_acb_hypgeom_li_series res z zlen offset len prec

acb_hypgeom_li_series :: Ptr CAcbPoly -> Ptr CAcbPoly -> CInt -> CLong -> CLong -> IO ()

acb_hypgeom_li_series res z offset len prec

Computes the logarithmic integral (optionally the offset version) of the power series z, truncated to length len.

Gauss hypergeometric function

acb_hypgeom_2f1_continuation :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_2f1_continuation res0 res1 a b c z0 z1 f0 f1 prec

Given \(F(z_0), F'(z_0)\) in f0, f1, sets res0 and res1 to \(F(z_1), F'(z_1)\) by integrating the hypergeometric differential equation along a straight-line path. The evaluation points should be well-isolated from the singular points 0 and 1.

acb_hypgeom_2f1_series_direct :: Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr CAcbPoly -> Ptr CAcbPoly -> CInt -> CLong -> CLong -> IO ()

acb_hypgeom_2f1_series_direct res a b c z regularized len prec

Computes \(F(z)\) of the given power series truncated to length len, using direct summation of the hypergeometric series.

acb_hypgeom_2f1_direct :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_2f1_direct res a b c z regularized prec

Computes \(F(z)\) using direct summation of the hypergeometric series.

acb_hypgeom_2f1_transform :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CInt -> CLong -> IO ()

acb_hypgeom_2f1_transform res a b c z flags which prec

acb_hypgeom_2f1_transform_limit :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CInt -> CLong -> IO ()

acb_hypgeom_2f1_transform_limit res a b c z regularized which prec

Computes \(F(z)\) using an argument transformation determined by the flag which. Legal values are 1 for \(z/(z-1)\), 2 for \(1/z\), 3 for \(1/(1-z)\), 4 for \(1-z\), and 5 for \(1-1/z\).

The transform_limit version assumes that which is not 1. If which is 2 or 3, it assumes that \(b-a\) represents an exact integer. If which is 4 or 5, it assumes that \(c-a-b\) represents an exact integer. In these cases, it computes the correct limit value.

See acb_hypgeom_2f1 for the meaning of flags.

acb_hypgeom_2f1_corner :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_2f1_corner res a b c z regularized prec

Computes \(F(z)\) near the corner cases \(\exp(\pm \pi i \sqrt{3})\) by analytic continuation.

acb_hypgeom_2f1_choose :: Ptr CAcb -> IO CInt

acb_hypgeom_2f1_choose z

Chooses a method to compute the function based on the location of z in the complex plane. If the return value is 0, direct summation should be used. If the return value is 1 to 5, the transformation with this index in acb_hypgeom_2f1_transform should be used. If the return value is 6, the corner case algorithm should be used.

acb_hypgeom_2f1 :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_2f1 res a b c z flags prec

Computes \(F(z)\) or \(\operatorname{\mathbf{F}}(z)\) using an automatic algorithm choice.

The following bit fields can be set in flags:

• ACB_HYPGEOM_2F1_REGULARIZED - computes the regularized hypergeometric function \(\operatorname{\mathbf{F}}(z)\). Setting flags to 1 is the same as just toggling this option.
• ACB_HYPGEOM_2F1_AB - \(a-b\) is an integer.
• ACB_HYPGEOM_2F1_ABC - \(a+b-c\) is an integer.
• ACB_HYPGEOM_2F1_AC - \(a-c\) is an integer.
• ACB_HYPGEOM_2F1_BC - \(b-c\) is an integer.

The last four flags can be set to indicate that the respective parameter differences are known to represent exact integers, even if the input intervals are inexact. This allows the correct limits to be evaluated when applying transformation formulas. For example, to evaluate \({}_2F_1(\sqrt{2}, 1/2, \sqrt{2}+3/2, 9/10)\), the ABC flag should be set. If not set, the result will be an indeterminate interval due to internally dividing by an interval containing zero. If the parameters are exact floating-point numbers (including exact integers or half-integers), then the limits are computed automatically, and setting these flags is unnecessary.

Currently, only the AB and ABC flags are used this way; the AC and BC flags might be used in the future.

Orthogonal polynomials and functions

acb_hypgeom_chebyshev_t :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_chebyshev_t res n z prec

acb_hypgeom_chebyshev_u :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_chebyshev_u res n z prec

Computes the Chebyshev polynomial (or Chebyshev function) of first or second kind

\[`\] \[T_n(z) = {}_2F_1\left(-n,n,\frac{1}{2},\frac{1-z}{2}\right)\]

\[`\] \[U_n(z) = (n+1) {}_2F_1\left(-n,n+2,\frac{3}{2},\frac{1-z}{2}\right).\]

The hypergeometric series definitions are only used for computation near the point 1. In general, trigonometric representations are used. For word-size integer n, acb_chebyshev_t_ui and acb_chebyshev_u_ui are called.

acb_hypgeom_jacobi_p :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_jacobi_p res n a b z prec

Computes the Jacobi polynomial (or Jacobi function)

\[`\] \[P_n^{(a,b)}(z)=\frac{(a+1)_n}{\Gamma(n+1)} {}_2F_1\left(-n,n+a+b+1,a+1,\frac{1-z}{2}\right).\]

For nonnegative integer n, this is a polynomial in a, b and z, even when the parameters are such that the hypergeometric series is undefined. In such cases, the polynomial is evaluated using direct methods.

acb_hypgeom_gegenbauer_c :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_gegenbauer_c res n m z prec

Computes the Gegenbauer polynomial (or Gegenbauer function)

\[`\] \[C_n^{m}(z)=\frac{(2m)_n}{\Gamma(n+1)} {}_2F_1\left(-n,2m+n,m+\frac{1}{2},\frac{1-z}{2}\right).\]

For nonnegative integer n, this is a polynomial in m and z, even when the parameters are such that the hypergeometric series is undefined. In such cases, the polynomial is evaluated using direct methods.

acb_hypgeom_laguerre_l :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_laguerre_l res n m z prec

Computes the Laguerre polynomial (or Laguerre function)

\[`\] \[L_n^{m}(z)=\frac{(m+1)_n}{\Gamma(n+1)} {}_1F_1\left(-n,m+1,z\right).\]

For nonnegative integer n, this is a polynomial in m and z, even when the parameters are such that the hypergeometric series is undefined. In such cases, the polynomial is evaluated using direct methods.

There are at least two incompatible ways to define the Laguerre function when n is a negative integer. One possibility when \(m = 0\) is to define \(L_{-n}^0(z) = e^z L_{n-1}^0(-z)\). Another possibility is to cover this case with the recurrence relation \(L_{n-1}^m(z) + L_n^{m-1}(z) = L_n^m(z)\). Currently, we leave this case undefined (returning indeterminate).

acb_hypgeom_hermite_h :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_hermite_h res n z prec

Computes the Hermite polynomial (or Hermite function)

\[`\] \[H_n(z) = 2^n \sqrt{\pi} \left( \frac{1}{\Gamma((1-n)/2)} {}_1F_1\left(-\frac{n}{2},\frac{1}{2},z^2\right) - \frac{2z}{\Gamma(-n/2)} {}_1F_1\left(\frac{1-n}{2},\frac{3}{2},z^2\right)\right).\]

acb_hypgeom_legendre_p :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_legendre_p res n m z type prec

Sets res to the associated Legendre function of the first kind evaluated for degree n, order m, and argument z. When m is zero, this reduces to the Legendre polynomial \(P_n(z)\).

Many different branch cut conventions appear in the literature. If type is 0, the version

\[`\] \[P_n^m(z) = \frac{(1+z)^{m/2}}{(1-z)^{m/2}} \mathbf{F}\left(-n, n+1, 1-m, \frac{1-z}{2}\right)\]

is computed, and if type is 1, the alternative version

\[`\] \[{\mathcal P}_n^m(z) = \frac{(z+1)^{m/2}}{(z-1)^{m/2}} \mathbf{F}\left(-n, n+1, 1-m, \frac{1-z}{2}\right).\]

is computed. Type 0 and type 1 respectively correspond to type 2 and type 3 in Mathematica and mpmath.

acb_hypgeom_legendre_q :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_legendre_q res n m z type prec

Sets res to the associated Legendre function of the second kind evaluated for degree n, order m, and argument z. When m is zero, this reduces to the Legendre function \(Q_n(z)\).

Many different branch cut conventions appear in the literature. If type is 0, the version

\[`\] \[Q_n^m(z) = \frac{\pi}{2 \sin(\pi m)} \left( \cos(\pi m) P_n^m(z) - \frac{\Gamma(1+m+n)}{\Gamma(1-m+n)} P_n^{-m}(z)\right)\]

is computed, and if type is 1, the alternative version

\[`\] \[\mathcal{Q}_n^m(z) = \frac{\pi}{2 \sin(\pi m)} e^{\pi i m} \left( \mathcal{P}_n^m(z) - \frac{\Gamma(1+m+n)}{\Gamma(1-m+n)} \mathcal{P}_n^{-m}(z)\right)\]

is computed. Type 0 and type 1 respectively correspond to type 2 and type 3 in Mathematica and mpmath.

When m is an integer, either expression is interpreted as a limit. We make use of the connection formulas [WQ3a], [WQ3b] and [WQ3c] to allow computing the function even in the limiting case. (The formula [WQ3d] would be useful, but is incorrect in the lower half plane.)

acb_hypgeom_legendre_p_uiui_rec :: Ptr CAcb -> CULong -> CULong -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_legendre_p_uiui_rec res n m z prec

For nonnegative integer n and m, uses recurrence relations to evaluate \((1-z^2)^{-m/2} P_n^m(z)\) which is a polynomial in z.

acb_hypgeom_spherical_y :: Ptr CAcb -> CLong -> CLong -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_spherical_y res n m theta phi prec

Computes the spherical harmonic of degree n, order m, latitude angle theta, and longitude angle phi, normalized such that

\[`\] \[Y_n^m(\theta, \phi) = \sqrt{\frac{2n+1}{4\pi} \frac{(n-m)!}{(n+m)!}} e^{im\phi} P_n^m(\cos(\theta)).\]

The definition is extended to negative m and n by symmetry. This function is a polynomial in \(\cos(\theta)\) and \(\sin(\theta)\). We evaluate it using acb_hypgeom_legendre_p_uiui_rec.

Dilogarithm

acb_hypgeom_dilog_zero_taylor :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_dilog_zero_taylor res z prec

Computes the dilogarithm for z close to 0 using the hypergeometric series (effective only when \(|z| \ll 1\)).

acb_hypgeom_dilog_zero :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_dilog_zero res z prec

Computes the dilogarithm for z close to 0, using the bit-burst algorithm instead of the hypergeometric series directly at very high precision.

acb_hypgeom_dilog_transform :: Ptr CAcb -> Ptr CAcb -> CInt -> CLong -> IO ()

acb_hypgeom_dilog_transform res z algorithm prec

Computes the dilogarithm by applying one of the transformations \(1/z\), \(1-z\), \(z/(z-1)\), \(1/(1-z)\), indexed by algorithm from 1 to 4, and calling acb_hypgeom_dilog_zero with the reduced variable. Alternatively, for algorithm between 5 and 7, starts from the respective point \(\pm i\), \((1\pm i)/2\), \((1\pm i)/2\) (with the sign chosen according to the midpoint of z) and computes the dilogarithm by the bit-burst method.

acb_hypgeom_dilog_continuation :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_dilog_continuation res a z prec

Computes \(\operatorname{Li}_2(z) - \operatorname{Li}_2(a)\) using Taylor expansion at a. Binary splitting is used. Both a and z should be well isolated from the points 0 and 1, except that a may be exactly 0. If the straight line path from a to b crosses the branch cut, this method provides continuous analytic continuation instead of computing the principal branch.

acb_hypgeom_dilog_bitburst :: Ptr CAcb -> Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_dilog_bitburst res z0 z prec

Sets z0 to a point with short bit expansion close to z and sets res to \(\operatorname{Li}_2(z) - \operatorname{Li}_2(z_0)\), computed using the bit-burst algorithm.

acb_hypgeom_dilog :: Ptr CAcb -> Ptr CAcb -> CLong -> IO ()

acb_hypgeom_dilog res z prec

Computes the dilogarithm using a default algorithm choice.