acb.h

Function versions of acb_realref and acb_imagref, 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 complex numbers initialised to zero, and free such a vector.

Swaps z and x without copying.

Return the heap memory used by x (excluding sizeof(acb_struct)), the total memory of a vector, and an estimate of the memory needed for a vector of len numbers at precision prec; see _arb_vec_estimate_allocated_bytes.

Set z to 0, 1 and i respectively.

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

Set z to the exact value of the input, with zero imaginary part for a real input.

Set z to x + yi exactly.

Set z to a rectangle containing the input, with midpoints rounded to prec bits.

Sets res to the exact midpoint of x (radii zero).

Add an upper bound for |\mathit{err}| to the radii of both the real and the imaginary part of x, so that x then contains every point within distance |\mathit{err}| of the old x in each coordinate.

Sets z to x with both parts trimmed by arb_trim.

Print x as a + b*I with the real and imaginary parts in the decimal ball format of arb_get_str (omitting a zero part), to standard output or to fp. The printed rectangle contains x, and the flags of arb_get_str apply to both parts. This is the recommended way to print a complex number.

Print approximate decimal values of the midpoints with digits digits and of the radii with 3 digits, in the form (a + bj) +/- (r, sj). The printed values are not guaranteed to enclose z.

Print the exact binary representation of both parts, as (a, b) in the format of arb_print.

Set re to the real part, respectively im to the imaginary part of z.

Sets u to |z|, computed with arb_hypot.

Sets r to the argument (phase) of z, \operatorname{atan2}(b, a) for z = a + bi, with values in (-\pi, \pi] and the branch cut on (-\infty, 0]: \arg(0) = 0 and \arg(a) = \pi for a < 0. A rectangle that crosses the negative real axis gives an enclosure of [-\pi, \pi].

Sets res to the complex sign z / |z|, and to 0 if z is exactly 0.

Sets res to the sign of the real part, extended to the imaginary axis by the sign of the imaginary part: 1 in the right half plane, -1 in the left half plane, \operatorname{sgn}(\operatorname{Im} z) on the imaginary axis, and 0 at z = 0. Equivalently \operatorname{csgn}(z) = z/\sqrt{z^2} for z \ne 0.

Set z to an upper, respectively lower, bound for |t| over all t in the rectangle x.

Set u to an upper, respectively lower, bound for |t|, t \in z, computed at precision prec.

Sets u to an upper bound for the distance from the midpoint to any point of the rectangle, computed (not tightly) from the two radii.

Return the relative error, respectively accuracy, in bits, as arb_rel_error_bits would for a real ball whose midpoint is the larger of the two midpoints and whose radius is the larger of the two radii. An exact x has accuracy ARF_PREC_EXACT, and an x with zero midpoint or a non-finite part -ARF_PREC_EXACT.

Returns the relative accuracy in bits of the rectangle with midpoint magnitude replaced by \max(1, |m|), measuring accuracy relative to 1 near the origin.

Returns the larger of arb_bits of the two parts, the precision needed to represent the midpoints exactly.

Sets res to a rectangle containing both x and y.

Return whether z is exactly 0, exactly 1, respectively exactly the integer y.

Return whether both radii are zero, whether both parts are finite, and whether the imaginary part is exactly zero (without testing the real part).

Return whether z is an exact integer, respectively an exact integer multiple of 2^e (with zero imaginary part).

acb_eq returns 1 if x and y are certainly equal (arb_eq holds for both parts), and acb_ne returns 1 if they are certainly different (arb_ne holds for at least one part).

Returns whether x and y are identical as rectangles, both parts being equal as balls (arb_equal). This is a test of the representation, not a proof that two numbers are equal.

Returns whether the rectangles x and y have a point in common.

Return whether y is contained in the rectangle x.

Return whether x contains zero, respectively an integer.

Returns whether y is contained in the interior of x.

If x contains exactly one integer (so its imaginary part contains 0 and its real part a unique integer), sets z to it and returns nonzero; otherwise returns zero.

Set z to -x (exactly, respectively rounded to prec bits) or to the complex conjugate \bar x.

Set z to x + y, respectively x - y, by real additions of the parts.

Set z to ix, x/i = -ix, respectively i^k x. Exact.

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

Sets z to xy. If a part of x or y is exactly zero, two real multiplications are used; if x and y are the same object, the squaring formula (a + bi)^2 = (a^2 - b^2) + 2abi; otherwise the midpoints are multiplied with arf_complex_mul and the radii bounded componentwise.

Sets z to xy using four real multiplications with arb_mul, as (ac - bd) + (ad + bc) i. The result is usually slightly wider than that of acb_mul; this version is kept for testing.

Set z to xy for a real y, multiplying both parts.

Set the output to x^2, respectively x^3. The cube is computed with two real squarings, two real multiplications and some scalar operations.

Set z to z + xy, respectively z - xy.

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

Set z to x / y. If the divisor contains zero, the result is indeterminate. If the divisor is real or purely imaginary, the parts of x are divided directly; otherwise x \cdot (1/y) is computed with acb_inv.

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

Computes the same dot product without error bounds: the radii of the inputs are ignored and only the midpoint of res is written.

Like acb_dot with a real integer vector y; the uiui and siui versions take two-limb integers (unsigned, respectively signed in two's complement) stored as pairs of ulong, low limb first.

Set the output to the principal square root, with the branch cut on (-\infty, 0) and \sqrt{-1} = i (continuous from above). If analytic is set, the result is indeterminate when the input touches the branch cut, including an exact negative real number.

Set the output to the principal reciprocal square root 1/\sqrt{z}. analytic is as for acb_sqrt_analytic.

Sets y1 and y2 to the two square roots of x, in an unspecified order. Unlike acb_sqrt, no accuracy is lost when x is near the branch cut.

Sets y to the principal k-th root \exp(\log(x)/k), using square roots for k = 2 and k = 4 and arb_root_ui for nonnegative real input. For k = 0 the result is indeterminate.

Sets r1 and r2 to the roots of ax^2 + bx + c, a \ne 0. Both roots are computed accurately, also when the quadratic formula would suffer from cancellation.

Set y to b^e by binary exponentiation (with an inversion if e < 0). For huge exponents acb_pow can be faster.

Set the output to the principal power 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 analytic set, the result is indeterminate if x touches the branch cut of the logarithm, unless y is an integer.

Sets res to the root of unity \exp(2\pi i / \mathit{order}).

Sets r to e^z = e^a (\cos b + i \sin b) for z = a + bi.

Sets r to \exp(\pi i z), using arb_sin_cos_pi so that the result is exact or accurate at rational points.

Sets r to e^z and s to e^{-z}.

Sets r to e^z - 1, accurately also for z near 0.

Set the output to the principal logarithm \log z = \log|z| + i \arg z, computed with arb_log_hypot and arb_atan2, with the branch cut on (-\infty, 0] and imaginary part in (-\pi, \pi]. A rectangle crossing the branch cut gives an imaginary part enclosing [-\pi, \pi]; with analytic set the result is then indeterminate instead.

Sets r to \log(1 + z), accurately also for z near 0.

Set the output to \sin z and \cos z, computed as \sin(a + bi) = \sin a \cosh b + i \cos a \sinh b and \cos(a + bi) = \cos a \cosh b - i \sin a \sinh b.

Set r to \tan z, respectively \cot z. For large |\operatorname{Im} z| they are evaluated stably as \pm i plus an exponentially small correction.

Set the output to \sin(\pi z), \cos(\pi z), both, \tan(\pi z), \cot(\pi z), respectively \csc(\pi z), using arb_sin_cos_pi for the real part so that the results are accurate near the zeros.

Set y to \sec x = 1/\cos x, respectively \csc x = 1/\sin x.

Set res to \sin(z)/z, respectively \sin(\pi z)/(\pi z), with the value 1 at z = 0.

Set r to \operatorname{asin} z = -i \log(iz + \sqrt{1 - z^2}), \operatorname{acos} z = \pi/2 - \operatorname{asin} z, respectively \operatorname{atan} z = \tfrac{i}{2} (\log(1 - iz) - \log(1 + iz)). The branch cuts are (-\infty, -1) \cup (1, \infty) for \operatorname{asin} and \operatorname{acos}, and (-i\infty, -i) \cup (i, i\infty) for \operatorname{atan}.

Compute \sinh z = -i \sin(iz), \cosh z = \cos(iz), both, \tanh z = -i \tan(iz), respectively \coth z = i \cot(iz).

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

Set r to \operatorname{asinh} z = -i \operatorname{asin}(iz), \operatorname{acosh} z = \log(z + \sqrt{z + 1} \sqrt{z - 1}), respectively \operatorname{atanh} z = -i \operatorname{atan}(iz).

Sets x to \pi (see arb_const_pi).

Sets res to the branch W_k(z) of the Lambert W function, the solution of w e^w = z; k = 0 is the principal branch. The branch cuts are those of [CGHJK1996]. The algorithm is described in [Joh2017b] and on The Lambert W function.

Sets res to W_k(z) computed from L and M terms of the bivariate asymptotic series at 0 or \infty. The formula is valid everywhere, but the error bound is finite only when |\log z| is large enough.

Returns 1 if w certainly lies in the image of the branch W_k. This is used to verify that a computed approximation is on the intended branch; it is false for points on or overlapping the branch cuts.

Sets res to an upper bound for |W_k'(z)|, given ez1 = ez + 1. On the real line the directional derivative is taken, so the caller must handle the discontinuity at the branch cut separately.

Set y to \Gamma(x), respectively 1/\Gamma(x) (which is 0 at the poles of \Gamma). Aliases of acb_hypgeom_gamma and acb_hypgeom_rgamma.

Sets y to \log \Gamma(x), an alias of acb_hypgeom_lgamma.

Sets res to the logarithmic sine function S(z) = \log \pi - \log \Gamma(z) + \log \Gamma(1 - z), the branch of \log \sin(\pi z) used by the reflection formula of \log \Gamma.

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

Sets res to the generalised polygamma function \psi(s, z).

Set res to the Barnes G-function, respectively its logarithm, which has its branch cut on the negative real axis and satisfies \log G(z + 1) = \log \Gamma(z) + \log G(z) for all z.

Set z to the rising factorial x (x + 1) \cdots (x + n - 1). Aliases of acb_hypgeom_rising_ui and acb_hypgeom_rising.

Sets u to the rising factorial u(x) and v to u'(x). Wrapper of acb_hypgeom_rising_ui_jet.

Sets bound to an upper bound for |s (s + 1) \cdots (s + n - 1)|. Not optimised for large n.

Set z to \zeta(s), respectively \zeta(s, a). Wrappers of acb_dirichlet_zeta and acb_dirichlet_hurwitz; for derivatives with respect to s, use acb_poly_zeta_series.

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

Set w to the polylogarithm \operatorname{Li}_s(z), with the branch cut on (1, +\infty).

Sets m to M(z) = \operatorname{agm}(1, z), defined by always choosing the optimal branch of the square root in the AGM iteration. M is continuous except for a branch cut on the negative real axis, where it is continuous from above.

Sets m to the first len coefficients of the power series M(z + x) \in \mathbb{C}[[x]].

Sets res to the arithmetic-geometric mean of a and b, with the square roots chosen to give the optimal AGM sequence. This is well defined except when a/b is a negative real number, where there are two optimal sequences; then an arbitrary but consistent choice is made, or the union of both when the choice cannot be decided.

Set a to T_n(x), respectively U_n(x).

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

The absolute value, extended to z in the right half plane and -z in the left half plane, with a discontinuity on \operatorname{Re} z = 0.

The sign function, extended to 1 in the right half plane and -1 in the left half plane, with a discontinuity on \operatorname{Re} z = 0. Without analytic, it is the same as acb_csgn.

The Heaviside step function, extended to 1 in the right half plane and 0 in the left half plane, with a discontinuity on \operatorname{Re} z = 0.

The floor and ceiling functions, extended to the constants n, respectively n + 1, on the strips n < \operatorname{Re} z < n + 1, with discontinuities on the lines \operatorname{Re} z = n.

\max(x, y) extended to x where \operatorname{Re} x \ge \operatorname{Re} y and y elsewhere, and \min(x, y) extended to x where \operatorname{Re} x \le \operatorname{Re} y and y elsewhere, with discontinuities where \operatorname{Re} x = \operatorname{Re} y.

The square root on [0, +\infty), extended to the principal complex square root. For a real z without analytic, only the nonnegative part is used, as by arb_sqrtpos. This is the function to integrate \sqrt{f(x)} when f(x) \ge 0 is known: unlike acb_sqrt_analytic, it creates no spurious imaginary parts [\pm \varepsilon] i when an enclosure of f(x) straddles 0.

Set z to a random complex number for testing, with real and imaginary parts generated like those of arb_randtest: in general, with occasional NaN and infinities, with precise parts, and with a high probability of integers and half-integers (useful for parameters of special functions).

Sets z to a random number with precise parts, uniformly distributed in the unit disk.

Returns a pointer to entry i of vec.

Set all entries to zero, respectively to indeterminate values.

Return whether all entries are exactly zero, have exactly zero imaginary part, respectively are finite.

Apply acb_equal, acb_overlaps, respectively acb_contains entrywise and return whether it holds for all entries.

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

Extract the real or imaginary parts of a vector, and build a vector from its real and imaginary parts.

Entrywise sum, difference and square.

Multiply each entry of vec by c (by 2^c for _2exp_si, by i for _onei) or divide it by c, writing to res; the addmul and submul versions add or subtract c \cdot \mathit{vec}_i to \mathit{res}_i.

Returns the maximum of acb_bits over the entries.

Sets xs to 1, x, x^2, \ldots, x^{\mathit{len}-1}.

Sets z to 1, \omega, \omega^2, \ldots, \omega^{\mathit{len}-1} with \omega = \exp(2\pi i/\mathit{order}); order may be negative. To avoid error growth, the powers are not computed by repeated multiplication.

Add |\mathit{err}_i| to both radii of \mathit{res}_i.

Applies acb_get_unique_fmpz entrywise and returns nonzero if every entry contains a unique integer.

Sorts the vector by real and imaginary parts, to make printed output easier to read. This is not a rigorous ordering.

Print the entries with acb_printd, respectively acb_printn.