arf.h

Initialises x to zero.

Frees the memory used by x.

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

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

Set x to 0, 1, +\infty, -\infty and NaN respectively.

Return whether x is 0, 1, +\infty, -\infty, NaN, and \pm\infty respectively.

Return whether x is a finite nonzero number, whether it is one of the special values 0, \pm\infty, NaN, and whether it is finite (zero included). arf_is_finite is not the negation of arf_is_inf, because of NaN.

Set the output to the exact value of the input. A double NaN gives NaN and -0.0 gives 0.

Initialise x and set it to v.

Sets y to the integer stored in the xn limbs at x, negated if sgnbit is 1. Requires \mathit{xn} > 0 and x[xn - 1] nonzero.

Set x to \mathit{man} \cdot 2^{\mathit{exp}} exactly.

Swaps x and y without copying.

Set the output to the input rounded to prec bits in the direction rnd, and return the inexact flag.

Sets y to x \cdot 2^{\mathit{exp}} rounded to prec bits in the direction rnd, and returns the inexact flag.

Sets y to the rational number x rounded to prec bits in the direction rnd, and returns the inexact flag. This is arf_fmpz_div_fmpz applied to the numerator and denominator.

Set y to -x, respectively |x|. Exact.

Sets y to -x rounded to prec bits in the direction rnd, and returns the inexact flag.

Set y to x \cdot 2^e. Exact. This is the inverse of arf_frexp.

Set z to the smaller, respectively larger, of a and b.

Sets man and exp to the integers with x = \mathit{man} \cdot 2^{\mathit{exp}} and man odd, for finite nonzero x. For x = 0 both are set to 0. The result is undefined for infinite or NaN x.

Writes x = m \cdot 2^e with 1/2 \le |m| < 1, setting man to m and exp to e. A special value is copied to man, and exp is set to 0.

Returns x rounded to a double in the direction rnd, with correct rounding also on overflow (to the largest finite double or to \pm\infty, depending on the direction) and on underflow (to zero or the smallest subnormal).

Sets x to y rounded to the precision of x with the MPFR rounding mode rnd, and returns the MPFR ternary value (-1, 0 or 1). An exponent outside the current MPFR exponent range gives an infinity or a zero and sets the MPFR overflow or underflow flag.

Sets z to x rounded to an integer in the direction rnd (ties to even for ARF_RND_NEAR), and returns 1 if x is not an integer, 0 otherwise.

Returns x rounded to an integer in the direction rnd (ties to even for ARF_RND_NEAR). Raises an exception if x is infinite, NaN, or if the rounded value does not fit in an slong.

Set y to the integer \operatorname{trunc}(x / 2^e), so that y \cdot 2^e is x truncated towards zero to a multiple of 2^e, and return 1 if truncation occurred. The size caveats of arf_get_fmpz apply.

Set z to \lfloor x \rfloor, \lceil x \rceil and the nearest integer to x with ties to even. The result is exact and never needs more bits than x; round it with arf_set_round if needed.

Sets y to the exact rational value of x. Raises an exception for infinite or NaN x; the size caveats of arf_get_fmpz apply.

Return whether x and y are the same number. Unlike IEEE 754 comparison, NaN is equal to itself. For a double y, both zeros compare equal to 0 and every NaN to NaN.

Return a negative number, zero or a positive number according as x < y, x = y or x > y. If either argument is NaN, the result is 0.

Compare |x| with |y|, with the same return convention as arf_cmp.

Compare x, respectively |x|, with 2^e.

Returns -1, 0 or 1 according to the sign of x, and 0 for NaN.

Returns the number of bits of the odd mantissa of x, that is, the smallest precision at which x is exactly representable, and 0 for a special value.

Sets e to the exponent of the lowest nonzero bit of x, that is, to the exponent of arf_get_fmpz_2exp, so that x is an odd multiple of 2^e. Sets e to 0 for a special value.

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

Set b to the smallest integer with |x| < 2^b, respectively |x| \le 2^b, for finite nonzero x. The result is undefined for special values.

Returns the smallest integer b with |x| < 2^b, clamped to [-\mathrm{ARF\_PREC\_EXACT}, \mathrm{ARF\_PREC\_EXACT}]. Returns -\mathrm{ARF\_PREC\_EXACT} for zero and \mathrm{ARF\_PREC\_EXACT} for infinities and NaN.

Set y to an upper, respectively lower, bound for |x|. An infinite or NaN x gives +\infty for the upper bound.

Sets y to the value of x. Exact.

Initialises y and sets it to an upper bound for |x|.

Initialises y to an upper bound for |x|, for finite x whose exponent is small enough for the mag_fast_ functions. Nothing is checked.

Sets z to 2^{e - \mathit{prec}}, where e is the exponent of y (2^{e-1} \le |y| < 2^e): one unit in the last place of a prec-bit number of the size of y. Raises an exception for a special y.

Set z to an upper bound for x + 2^{e - \mathit{prec}}, with e the exponent of y. This adds the rounding error of a prec-bit operation with result y to the radius x. The fast version requires small exponents; the other raises an exception for a special y.

Initialise the output as a shallow copy of x or of -x, sharing its limbs, without allocating memory.

Set z to x + y, correctly rounded.

Sets z to x + y \cdot 2^{\mathit{exp}}, correctly rounded.

Set z to x - y, correctly rounded.

Set z to xy, correctly rounded.

Sets z to -xy, correctly rounded.

Set z to z + xy, respectively z - xy, with a single rounding (fused multiply-add).

Sets res to xy + z with a single rounding.

Sets z to x^2 + y^2 with a single rounding.

Set z to x / y, correctly rounded for the strict modes. Division by zero gives NaN. The relaxed modes ARF_RND_FAST and ARF_RND_ACCURATE are accepted.

Set z to \sqrt{x}, correctly rounded for the strict modes. A negative x gives NaN. The relaxed modes are accepted.

Sets z to 1/\sqrt{x}, correctly rounded for the strict modes. A negative x gives NaN and x = 0 gives +\infty. The relaxed modes are accepted.

Sets z to x^{1/k}, correctly rounded. A negative x gives NaN.

Sets s to the sum of the len entries of terms with a single rounding, and returns the inexact flag.

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

Computes the same dot product as arf_dot approximately: the final rounding is in the direction rnd, but the intermediate roundings are not specified, so neither correct rounding nor an error bound is guaranteed. It uses the fixed-point accumulation of arb_dot without the error bound, and is the midpoint computation of arb_approx_dot.

Set e + fi = (a + bi)(c + di) with both parts correctly rounded. Bit 0 of the return value is the inexact flag of e and bit 1 that of f.

Sets e + fi = (a + bi)^2, with the same conventions as arf_complex_mul, but faster.

Print the exact value of x as (m * 2^e) with an odd integer mantissa, or as (0), (+inf), (-inf) or (nan), to standard output or to file.

Print x in decimal with d significant digits, or return such a string (to be freed with flint_free). The decimal conversion is faithful: the error is at most one unit in the last digit.

Prints the internal fields of x (exponent, size, sign and limbs).

arf_dump_str returns a string, to be freed with flint_free, holding the exact value of x as two hexadecimal integers (mantissa and exponent), which arf_load_str reads back exactly. arf_load_str returns nonzero if the string is not in this format.

Write x to stream in the format of arf_dump_str, and read it back. Both return nonzero on failure. Several values written in sequence must be separated by whitespace.

Set x to a random finite number with a mantissa of at most bits bits and an exponent of at most mag_bits bits, with a non-uniform distribution that favours corner cases. The second version never returns zero; the third sometimes returns \pm\infty or NaN.

Sets x to a uniformly distributed random number in [0, 1] with bits bits, obtained by rounding a random integer in the direction rnd.

Return whether the strict mode rnd rounds a number with sign bit sgnbit (1 for negative) towards zero, respectively away from zero. Both return 0 for ARF_RND_NEAR.

Returns the MPFR rounding mode corresponding to rnd (MPFR_RNDZ, MPFR_RNDA, MPFR_RNDD, MPFR_RNDU, and MPFR_RNDN for any other mode). Available only if mpfr.h is included before arf.h.

Returns the strict mode by which the standard algorithms implement a relaxed mode: ARF_RND_DOWN for ARF_RND_FAST and ARF_RND_NEAR for ARF_RND_ACCURATE. Other modes are returned unchanged.

Sets z to xy when at least one of x and y is a special value.

The implementations of arf_mul: for any rounding mode, for ARF_RND_DOWN, and through mpfr_mul.

Sets x to \pm v (negative if sgnbit is 1) rounded to prec bits.

Sets the mantissa of z to the two-limb value (\mathit{hi}, \mathit{lo}), negated if sgnbit is 1, rounded to prec bits. Requires a nonzero value. Writes the exponent shift to fix without setting the exponent of z.

Sets the mantissa of y to the xn limbs at x (top limb nonzero), negated if sgnbit is 1, rounded to prec bits, and returns the inexact flag. Writes the exponent shift caused by leading zero bits and by rounding up to a power of two to exp_shift without setting the exponent of y. x may point into the limbs of y, as the Newton division code does.

Sets z to the fixed-point number with xn limbs of which fixn are fractional, negated if negative is set, rounded to prec bits.

Writes the integer part of the number with mantissa (x, \mathit{xn}) (top bit set, x[0] nonzero) and exponent exp to y, using exactly as many limbs as needed, and returns whether a fractional part was discarded.

Adds two mantissas, the second shifted right by shift bits relative to the first, which has exponent xexp, and rounds the result into z. This is the kernel of arf_add.

Evaluates the MPFR function func (cast to a generic function pointer) on x (and y, if not NULL) at precision prec, writing one result or, if r2 is not NULL, two results. Returns the MPFR ternary value.

Switch the mantissa storage of x to a heap array of n limbs, and back to inline storage.

Decide whether a relaxed-mode inversion, division, square root or reciprocal square root at precision prec uses Newton iteration; the _large versions contain the tests that are made only above the precision cutoffs.

Compute 1/x, x/y, \sqrt{x} and 1/\sqrt{x} for a relaxed mode rnd by Newton iteration, with the error bounds stated for ARF_RND_FAST. Require finite nonzero (positive, for the roots) input. Return the inexact flag of the result (0 if and only if res equals the exact value; see ARF_RND_FAST for how it is determined).

Free the thread-local scratch space of multiplication and addition; registered with flint_register_cleanup_function and called by flint_cleanup.