arb.h

Function versions of arb_midref and arb_radref, for language bindings that cannot use macros.

Initialises x to the exact value 0.

Frees the memory used by x.

Allocate a vector of n balls initialised to zero, and free such a vector.

Swaps x and y without copying.

Returns the number of bytes allocated on the heap by x, excluding sizeof(arb_struct).

Returns the number of bytes used by the vector vec of length len: the array itself plus the heap memory of its entries.

Estimates the number of bytes needed for a vector of len balls with prec-bit midpoints, including the limb data. The return type is double to avoid overflow.

Set x to the exact value 0, respectively 1.

Set x to +\infty, respectively -\infty, with radius 0.

Sets x to [0 \pm \infty], the whole extended real line.

Sets x to [\operatorname{NaN} \pm \infty], an indeterminate value.

Set x to [0 \pm 1] = [-1, 1], respectively [1/2 \pm 1/2] = [0, 1].

Set the output to the exact value of the input, without rounding.

Sets x to y \cdot 2^{\mathit{exp}} exactly.

Sets z to x with the midpoint rounded to prec bits, adding the rounding error to the radius.

Set y to a ball containing x, respectively x \cdot 2^{\mathit{exp}}, with the midpoint rounded to prec bits.

Sets y to a ball containing the rational number x, with the midpoint rounded to prec bits.

Sets y to a ball containing x whose midpoint has only as many bits as the relative accuracy of x justifies, plus 16 guard bits. This saves memory and time when an inaccurate ball has a long midpoint. A ball with negative accuracy becomes [0 \pm (|m| + r)].

Sets res to a ball containing the number described by the decimal string inp, rounded to prec bits, and returns 0 on success. Accepted forms are a decimal literal ("25", "0.001", "7e+141", "-31.4159e-1"), a ball "[3.25 +/- 0.0001]" (brackets optional) and "[+/- 10]", as well as "inf", "-inf" and "nan".

Returns a decimal string for x, to be freed with flint_free, with at most n significant digits of the midpoint. By default it has the form [m +/- r] with an m that is correct to within one unit in its last digit and an r such that the decimal ball contains x; the string can be read back with arb_set_str.

Print the string of arb_get_str to standard output or to file. This is the recommended way to print a ball.

Print the midpoint and the radius as decimal floating-point numbers with digits and 5 significant digits, in the form m +/- r. The decimal values are approximations: the printed interval need not contain x.

Print the exact binary representation of x as (m * 2^e) +/- (r * 2^f).

arb_dump_str returns a string, to be freed with flint_free, holding the exact value of x as four hexadecimal integers (midpoint mantissa and exponent, radius mantissa and exponent, with special encodings for zero, infinities and NaN) separated by spaces. arb_load_str reads it back exactly and returns nonzero on a format error.

Write x to stream in the format of arb_dump_str, and read it back. Both return nonzero on failure.

Set z to the midpoint, respectively the radius, of x as an exact ball.

Add an upper bound for the absolute value of the error term to the radius of x. This is how a truncation error, computed separately, is attached to an approximation.

Add 2^{\mathit{err}} to the radius of x.

Sets z to an upper bound for |t| for all t in x. A NaN midpoint gives +\infty.

Sets z to a lower bound for |t| for all t in x, which is 0 if x contains zero or NaN.

Sets z to a lower bound for all t in x, or to 0 if x contains nonpositive numbers or NaN.

Set u to an upper, respectively lower, bound for |t|, t \in x, rounded outward to prec bits. NaN gives NaN.

Set u to the right endpoint m + r rounded up, respectively the left endpoint m - r rounded down, to prec bits. NaN gives NaN.

Set [a, b] to an interval containing x, with the endpoints rounded outward to prec bits, respectively to the precision of the MPFR variables.

Set x to a ball containing the interval [a, b], with the midpoint rounded to prec bits. Require a \le b.

Sets res to a ball containing the interval [-a, b].

Sets z to a ball containing both x and y. A NaN input gives an indeterminate ball and an infinite radius gives [0 \pm \infty].

If x and y overlap (arb_overlaps), sets z to a ball containing their intersection and returns nonzero; otherwise returns zero and leaves z undefined. A NaN input gives an indeterminate z and a nonzero return value.

Sets res to a ball containing the intersection of x with [0, +\infty]. A nonnegative x is copied; a finite x containing negative numbers gives a ball [r/2 \pm r/2] with no negative points; a negative x gives 0.

arb_rel_error_bits returns e_r - e_m + 1, where e_m and e_r are the exponents of the midpoint and radius (2^{e-1} \le |\cdot| < 2^e): an estimate of \log_2(r/|m|) rounded up. arb_rel_accuracy_bits returns its negation, the number of correct bits. The value is clamped to \pmARF_PREC_EXACT: an exact ball has accuracy ARF_PREC_EXACT, and a ball with a special midpoint or an infinite radius has accuracy -ARF_PREC_EXACT.

Returns the relative accuracy in bits of [\max(1, |m|) \pm r]: for balls near zero, this measures the accuracy relative to 1 instead.

Returns the number of bits of the odd mantissa of the midpoint (arf_bits), the precision needed to represent it exactly.

If x contains exactly one integer, sets z to it and returns nonzero; otherwise returns zero.

Sets res to the rational number with smallest positive denominator in the closed interval represented by x, and among these the one with smallest absolute numerator (0 if x contains 0), and returns 1. Returns 0 and leaves res unchanged if x is not finite.

Writes the exact interval of x as [a, b] \cdot 2^{\mathit{exp}} with integers a, b without common trailing zero bits.

Set the output to a ball containing \lfloor t \rfloor, \lceil t \rceil, \operatorname{trunc}(t), respectively the nearest integer to t (ties to even), for all t in x, with the midpoint rounded to prec bits.

For finite nonzero x, computes integers with x \subseteq [\mathit{mid} - \mathit{rad}, \mathit{mid} + \mathit{rad}] \cdot 10^{\mathit{exp}} such that the larger of |\mathit{mid}| and \mathit{rad} has at least n digits plus a few guard digits. All three are set to 0 if x is infinite or exactly zero.

Return nonzero if rounding the midpoint of x to prec bits in the direction rnd is guaranteed to give the correctly rounded value of every real number in x.

Return whether x is exactly 0, exactly 1, respectively exactly the integer y (midpoint equal and radius zero).

Return whether the radius of x is zero, respectively whether both the midpoint and the radius are finite (not infinite and not NaN).

Return whether x is an exact integer, respectively an exact integer multiple of 2^e.

Return whether all points t of x satisfy t \ne 0, t > 0, t \ge 0, t < 0, respectively t \le 0. They return 0 if x contains NaN.

Return whether some point t of x satisfies t = 0, t < 0, t \le 0, t > 0, respectively t \ge 0. They return 1 if x contains NaN.

Returns whether x contains an integer.

Return 1 if t \;\mathrm{op}\; u holds for all t \in x and u \in y, where op is =, \ne, <, \le, >, respectively \ge, and 0 otherwise. They return 0 if either midpoint is NaN.

Returns whether x and y are identical as balls: the same midpoint and the same radius.

Returns whether x and y have a point in common. Returns 1 if either contains NaN.

Return whether the ball or number y is contained in x. If x contains NaN the result is 1; otherwise, if y is NaN the result is 0.

Returns whether y is contained in the interior of x, that is, contained in x without touching either endpoint.

Set y to -x, exactly, respectively with the midpoint rounded to prec bits.

Sets y to [|m| \pm r]. This contains |t| for all t \in x; if x contains zero the result also contains negative numbers.

Sets y to a ball containing |t| for all t \in x that contains no negative numbers: [|m| \pm r] if |m| \ge r and a ball [s/2 \pm s/2] with s \ge |m| + r otherwise.

Sets res to a ball containing the sign of every point of x: \pm 1 or 0 when the sign is determined, and [0 \pm 1] otherwise.

Returns 1 if x is certainly positive, -1 if it is certainly negative, and 0 otherwise.

Set the output to a ball containing \min(t, u), respectively \max(t, u), for all t \in x, u \in y; arb_minmax computes both.

Set z to x + y. The midpoint is m_x + m_y rounded to prec bits and the radius is r_x + r_y plus the rounding error. prec may be ARF_PREC_EXACT if the exact sum fits in memory.

Sets z to x + \mathit{man} \cdot 2^{\mathit{exp}}.

Set z to x - y. The radius is r_x + r_y plus the rounding error, also when x and y are the same object.

Set z to xy. The midpoint is m_x m_y rounded to prec bits and the radius is |m_x| r_y + |m_y| r_x + r_x r_y plus the rounding error.

Sets res to x^2. Currently this is arb_mul(res, val, val, prec), which uses the same bound as a product of two independent balls.

Set y to x \cdot 2^e. Exact.

Set z to z + xy, respectively z - xy, with a single rounding of the midpoint.

Set res to xy + z with a single rounding of the midpoint; unlike arb_addmul, the output may be a different object from z.

Sets y to 1/x. If x contains zero, the result is indeterminate.

Set z to x / y. If y contains zero, the result is indeterminate ([\operatorname{NaN} \pm \infty]), even when x = 0.

Sets z to x / (2^n - 1), using the expansion 2^{-n} + 2^{-2n} + \cdots for large n.

Set res to s + (-1)^{\mathit{subtract}} \sum_{i=0}^{\mathit{len}-1} x_i y_i, where s is initial (or 0 if initial is NULL) and the entries are read with strides xstep and ystep.

Computes the same dot product without error bounds: only the midpoints of the inputs are read and only the midpoint of res is written, using arf_approx_dot. Useful for approximate (floating-point) algorithms such as iterative refinement.

Like arb_dot with an integer vector y. In the uiui and siui versions each y_i is a two-limb integer stored as two consecutive ulong (low limb first), unsigned, respectively signed in two's complement; ystep counts integers, not limbs.

Set z to \sqrt{x}. If x contains negative numbers the result is indeterminate; use arb_sqrtpos when the negative part is known to be spurious.

Sets z to a ball containing \sqrt{t} for all nonnegative t \in x, ignoring the negative part of x.

Sets z to \sqrt{x^2 + y^2}.

Set z to 1/\sqrt{x}. At high precision this is faster than computing a square root.

Sets r to \sqrt{1 + z} - 1, accurately also for z near 0.

Set z to the principal k-th root of x. arb_root is an alias kept for compatibility.

Set y to b^e by binary exponentiation, with an initial inversion if e < 0. With exact b and e \ge 0, prec may be ARF_PREC_EXACT to get the exact power if it fits in memory.

Sets y to x^a, computed as (x^{1/q})^p if the denominator q of a = p/q is small and as \exp(a \log x) otherwise.

Sets z to x^y: by binary exponentiation if y is a small exact integer, as (x^{1/2})^{2y} if y is a small exact half-integer, and as \exp(y \log x) otherwise, with x^y = \pm(-x)^y for negative x and exact integer y.

Sets z to e^x.

Sets z to e^x - 1, with small relative error also near x = 0.

Sets z to e^x and w to e^{-x}. The second is computed from the first by a division, with its propagated error bounded separately.

Set z to \log x. If x contains nonpositive numbers, the result is indeterminate.

Sets s to \log k, given log_prev = \log(\mathit{prev}) with \mathit{prev} < k. At high precision it uses \log k = \log \mathit{prev} + 2 \operatorname{atanh}((k - \mathit{prev}) / (k + \mathit{prev})) with the atanh series evaluated by binary splitting, which is fast when \mathit{prev} is large and k - \mathit{prev} small; otherwise it ignores log_prev.

Sets r to \log(1 + z), with small relative error also near z = 0.

Sets res to \log_b x. The result is exact when x is an exact power of b.

Sets res to \log \sqrt{x^2 + y^2}, accurately also when x^2 + y^2 is close to 1. This is the real part of the complex logarithm.

Set s to \sin x and c to \cos x. Computing both together costs little more than one.

Set s to \sin(\pi x) and c to \cos(\pi x). These are exact at exact integers and half-integers and accurate near the zeros, which arb_sin applied to a multiple of an enclosure of \pi is not.

Set y to \tan x = \sin x / \cos x, respectively \cot x = \cos x / \sin x.

Set y to \tan(\pi x), respectively \cot(\pi x).

Set s to \sin(\pi x) and c to \cos(\pi x) for a rational x in lowest terms.

Set res to \sec x = 1/\cos x, \csc x = 1/\sin x, respectively \csc(\pi x).

Set z to \operatorname{sinc} x = \sin(x)/x, respectively \operatorname{sinc}(\pi x) = \sin(\pi x)/(\pi x), with the value 1 at x = 0 and accurate enclosures for balls containing 0.

Set z to \operatorname{atan} x.

Sets z to the argument (phase) of the complex number a + bi, in (-\pi, \pi], with the branch cut on (-\infty, 0]. By definition \operatorname{atan2}(0, 0) = 0 and \operatorname{atan2}(0, a) = \pi for a < 0. A ball that straddles the branch cut gives an enclosure of [-\pi, \pi].

Set z to \operatorname{asin} x = \operatorname{atan}(x / \sqrt{1 - x^2}), respectively \operatorname{acos} x = \pi/2 - \operatorname{asin} x. If x is not contained in [-1, 1], the result is indeterminate.

Set s to \sinh x and c to \cosh x. Near 0, \sinh x is computed as (e^{2x} - 1)/(2e^x) via arb_expm1 to avoid cancellation; otherwise (e^x \pm e^{-x})/2 is used.

Set y to \tanh x, respectively \coth x, computed as (e^{2x} - 1)/(e^{2x} + 1) via arb_expm1 for small |x| and as \pm(1 - 2e^{\mp 2x}/(1 + e^{\mp 2x})) for large |x| (and the reciprocals).

Set res to \operatorname{sech} x = 1/\cosh x, respectively \operatorname{csch} x = 1/\sinh x.

Set z to \operatorname{atanh} x, respectively \operatorname{asinh} x. For arb_atanh, an input not contained in (-1, 1) gives an indeterminate result.

Sets z to \operatorname{acosh} x. If x contains numbers less than 1, the result is indeterminate.

Set z to \pi, \sqrt{\pi}, respectively \log \sqrt{2\pi}.

Sets z to e = \exp(1).

Set z to \log 2, respectively \log 10.

Sets z to Euler's constant \gamma = \lim_{k \to \infty} (H_k - \log k), where H_k = 1 + 1/2 + \cdots + 1/k.

Sets z to Catalan's constant G = \sum_{n=0}^{\infty} (-1)^n / (2n+1)^2.

Set s to Apéry's constant \zeta(3), respectively \zeta(5).

Sets z to Khinchin's constant K_0.

Sets z to the Glaisher-Kinkelin constant A = \exp(1/12 - \zeta'(-1)).

Sets res to the reciprocal Fibonacci constant \sum_{n=1}^{\infty} 1/F_n.

Set z to \Gamma(x). Aliases of arb_hypgeom_gamma, arb_hypgeom_gamma_fmpq and arb_hypgeom_gamma_fmpz.

Sets z to \log \Gamma(x). The branch structure of the complex log-gamma function is assumed, so the result is indeterminate if x contains nonpositive numbers. Alias of arb_hypgeom_lgamma.

Sets z to 1/\Gamma(x), which is finite (zero) at the poles of \Gamma. Alias of arb_hypgeom_rgamma.

Sets y to the digamma function \psi(x) = \Gamma'(x)/\Gamma(x).

Set z to the rising factorial x (x+1) \cdots (x+n-1) = \Gamma(x+n)/\Gamma(x). Aliases of arb_hypgeom_rising_ui and arb_hypgeom_rising.

Sets y to the rising factorial of the rational number x, by binary splitting. If the numerator or denominator of x is large compared to prec, arb_rising_ui on an approximation of x is faster.

Sets u to the rising factorial u(x) = x (x+1) \cdots (x+n-1) and v to its derivative u'(x). Wrapper of arb_hypgeom_rising_ui_jet.

Set z to n!, respectively the double factorial n!!.

Set z to the binomial coefficient \binom{n}{k} = (n-k+1)_k / k!.

Set z to the Riemann zeta function \zeta(s), respectively the Hurwitz zeta function \zeta(s, a). For derivatives with respect to s, use arb_poly_zeta_series.

Sets x to \zeta(n) for an integer n \ge 0, n \ne 1, choosing an algorithm automatically. For many values, the vector functions below are more efficient.

Set x to \zeta(s) for num consecutive integers (respectively even or odd integers) s starting at start \ge 2, choosing an algorithm automatically.

Sets z to \zeta(s) for s = \mathit{start}, \mathit{start} + \mathit{step}, \ldots (num values), \mathit{start} \ge 2, by Borwein's algorithm [Bor2000; GS2003], organised for multi-evaluation.

Sets x to \zeta(s), s \ge 2, by binary splitting applied to Borwein's algorithm, in quasilinear time in prec for fixed s.

Set the output to \zeta(s) using the Euler product, which is fast only when s is large compared to prec. Both are wrappers of _acb_dirichlet_euler_product_real_ui.

Sets x to \zeta(n) for even n from the Bernoulli number B_n.

Set b to the Bernoulli number B_n to prec bits of accuracy.

Sets b to B_n using B_{2n} = (-1)^{n+1} 2 (2n)!\, \zeta(2n) / (2\pi)^{2n}, with \zeta evaluated by the Euler product. This is accurate only if prec is small enough compared to n for the product to converge quickly.

Sets res to the Bernoulli polynomial B_n(x). This is fast only if n or x is a small integer. Bernoulli numbers are read from the cache but the cache is not extended.

Sets res[n] to S_n(a, b) = (B_{n+1}(b) - B_{n+1}(a))/(n+1) for 0 \le n < \mathit{len}, which equals \sum_{k=a}^{b-1} k^n for integers b \ge a. The values are computed together from the generating function of the Bernoulli polynomials.

Set w to the polylogarithm \operatorname{Li}_s(z), computed with acb_polylog. The result is indeterminate if z contains 1, and if the midpoint of z is at least 1 unless s is a nonpositive integer (where the function is not real). In particular \operatorname{Li}_s(1) = \zeta(s) is not returned; use acb_polylog or arb_zeta for it.

Sets res to the Lambert W function, the solution w of w e^w = x: the principal branch W_0 if flags is 0, and the branch W_{-1} if flags is 1.

Set z to the Fibonacci number F_n, by binary squaring.

Sets z to the arithmetic-geometric mean of x and y. The result is indeterminate if x or y contains negative numbers.

Set a to the Chebyshev polynomial T_n(x) of the first kind, respectively U_n(x) of the second kind.

Set a = T_n(x), b = T_{n-1}(x), respectively a = U_n(x), b = U_{n-1}(x). The outputs a, b and the input x must be distinct objects.

Set res to the Bell number B_n, exactly if it fits in prec bits and otherwise as a numerical approximation computed efficiently by the algorithm of [Joh2015].

Set res to \sum_{k=a}^{b-1} k^n / k!, the sums used by arb_bell_fmpz. If mmag is not NULL, the target error is 2^{\mathit{mmag} - \mathit{prec}}.

Set res to the Euler number E_n, defined by the exponential generating function 1/\cosh x. The result is exact if E_n fits in prec bits.

Set res to the Euler number E_n exactly. The default algorithm uses a table, the Dirichlet beta function or a hybrid multimodular algorithm depending on n (Euler numbers); the multi_mod version takes a tuning parameter alpha, with a negative value selecting the default.

Set res to the partition function p(n). If \log_2 p(n) exceeds twice prec, the leading term of the Hardy-Ramanujan-Rademacher series with an error bound is used; otherwise the exact value is computed and rounded. See Computing the partition function.

Set res to the product of the primes up to n, respectively of the first n primes, in time quasilinear in n.

Set x to a random ball for testing, with a midpoint of at most prec bits and exponents of at most mag_bits bits: a finite ball, an exact number, a ball with radius about 2^{-\mathit{prec}} times the midpoint, such a ball that is certainly positive, a ball with independent midpoint and radius (possibly very wide), and a ball that may have an infinite or NaN midpoint or an infinite radius.

Sets x to a uniformly distributed random number in [0, 1], rounded to prec bits, so the radius may be nonzero.

Sets q to a random rational number in the interval of x, whose denominator is the binary denominator of x times a random integer of up to bits bits. The midpoint and radius must be finite and of reasonable size.

Returns a pointer to entry i of vec.

Set all entries to zero, respectively to indeterminate balls.

Return whether all entries are exactly zero, respectively finite.

Apply arb_equal, arb_overlaps, respectively arb_contains entrywise and return whether it holds for all entries.

Copy, copy with rounding, swap, negate, and apply arb_trim entrywise.

Set C_i = A_i \pm B_i.

Multiply each entry of vec by c (by 2^c for the _2exp_si version) or divide it by c, writing the result to res; _arb_vec_scalar_addmul instead adds c \cdot \mathit{vec}_i to \mathit{res}_i.

Sets bound to an upper bound for the absolute values of all entries.

Returns the maximum of arb_bits over the entries.

Sets xs to 1, x, x^2, \ldots, x^{\mathit{len}-1}, computing even powers by squaring and odd powers by one multiplication, which keeps the error growth logarithmic in the exponent.

Add |\mathit{err}_i| to the radius of \mathit{res}_i.

Applies arb_get_unique_fmpz entrywise and returns nonzero if every entry contains a unique integer; otherwise returns zero, with the contents of res unspecified.

Print the entries with arb_printn, respectively arb_printd.

Set y \approx \sum_{k=0}^{N-1} x^k/k! and write an error bound in ulps to error; y has xn fractional limbs and one integer limb. The naive version uses the forward recurrence, the rs version rectangular splitting with a table of reciprocal factorials, avoiding divisions. Require N \le 287, 0 \le x \le 1/16 and \mathit{xn} > 0.

Set ysin and ycos to approximations of \sum_{k=0}^{N-1} (-1)^k x^{2k+1}/(2k+1)! and \sum_{k=0}^{N-1} (-1)^k x^{2k}/(2k)!, with xn fractional limbs, and write an error bound in ulps to error. Require N \le 143, 0 \le x \le 1/16 and \mathit{xn} > 0.

Set y \approx \sum_{k=0}^{N-1} (\pm 1)^k x^{2k+1}/(2k+1), alternating (the arctangent series) if alternating is 1 and not (the atanh series, used for logarithms) if it is 0, and write an error bound in ulps to error. Require N \le 255, 0 \le x \le 1/16 and \mathit{xn} > 0.

Attempts to write x = q \log 2 + w with 0 \le w < \log 2, w a fixed-point number of wn limbs with error error ulps. Returns 0 if the precision of the internal table of \log 2 is insufficient.

Attempts to write |x| = q \pi/4 + w with 0 \le w < \pi/4, w a fixed-point number of wn limbs with error error ulps, and writes q \bmod 8 to octant. q may be NULL. Returns 0 if the precision of the internal table of \pi is insufficient.

Returns an N such that |\sum_{k=N}^{\infty} x^k/k!| \le 2^{-\mathit{prec}} for |x| \le 2^{\mathit{mag}} \le 1/4.

Returns the number of leading zero bits of the n-limb number d.

Sets z to e^x, or e^x - 1 if minus_one is set, for an exact x, choosing among all algorithms; inputs with |x| \ge 2^{\mathit{maglim}} give the crude overflow results of arb_exp.

Computes e^x (or e^x - 1) without tables: reduces by \log 2 if |x| is large and then calls arb_exp_arf_rs_generic or arb_exp_arf_bb depending on the precision, the size of x, the length of its mantissa and the number of available threads.

Computes e^x (or e^x - 1) by argument halving and rectangular splitting of the Taylor series in ball arithmetic, for intermediate precision.

Computes e^x (or e^x - 1, accurately) by the bit-burst algorithm: x is split into chunks of doubling length and the series for each chunk is evaluated by binary splitting.

Computes e^x (or e^x - 1) by reduction with logarithms of small primes [HJ2024]: finds integers c_i with r = x - \sum c_i \log p_i small, evaluates e^r and multiplies by \prod p_i^{c_i}.

Compute T, Q and Q_{\exp} with T/(Q \cdot 2^{Q_{\exp}}) = \sum_{k=1}^{N} (x/2^r)^k/k! by binary splitting (the sum runs to N inclusive and omits the constant term). The powtab version precomputes powers of x, which uses more memory and is faster; N should have many trailing zero bits.

Compute \log x from a lower-precision value t \approx \log x by the higher-order iteration \log x = t + \log(1 + (x e^{-t} - 1)), with the logarithm of the small correction evaluated by a short series. Used for arb_log_arf above 2800 bits.

Computes \operatorname{atan} x by the bit-burst algorithm.

Compute T, Q and Q_{\exp} with T/(Q \cdot 2^{Q_{\exp}}) = \sum_{k=1}^{N} (-1)^k (x/2^r)^{2k}/(2k+1) by binary splitting; the sum must be multiplied by x/2^r and the linear term added to give the arctangent.

Sets s to \operatorname{atan}(p/q), or \operatorname{atanh}(p/q) if hyperbolic is set, by binary splitting of the Taylor series.

Compute \operatorname{atan} x from a lower-precision value t by \operatorname{atan} x = t + \operatorname{atan}((x \cos t - \sin t)/(\cos t + x \sin t)), with the correction evaluated by a short Taylor series, so that the precision multiplies by 5 to 11 per step. Arguments with |x| > 16 use \operatorname{atan} x = \pm\pi/2 - \operatorname{atan}(1/x). Used for arb_atan_arf from 3400 bits.

Computes \sin x and \cos x without tables. If |x| is not certainly below \pi/2, the argument is reduced to the first octant using an enclosure of \pi and the function is called recursively; otherwise arb_sin_cos_arf_rs_generic or arb_sin_cos_arf_bb is used depending on the precision. Either output may be NULL.

Computes \sin x and \cos x for |x| \le 1 by argument reduction x \to x/2^q, rectangular splitting of the Taylor series and the double-angle formula, in ball arithmetic, for |x| < 1. Either output may be NULL.

Computes \sin x and \cos x by the bit-burst algorithm. Requires |x| < \pi/2, which is not checked.

Computes \sin x and \cos x by reduction with the arguments of small Gaussian primes [HJ2024]: x - \sum c_i \theta_i is made small with \theta_i = \arg(a_i + b_i i), and the result is multiplied by the Gaussian integer \prod (a_i + b_i i)^{c_i} normalised to modulus 1. Used for arb_sin_cos from 2600 bits to 4 million bits.

Compute enclosures of the ranges of \sin and \cos on a wide ball x = [m \pm r], with both endpoints optimal to within about 2^{-30}.

Compute \sin and \cos of the ball [x \pm \mathit{xrad}], handling special values and the propagated error and calling arb_sin_cos_arf_generic. This is the fallback of arb_sin_cos for the cases without a fast path.