Struct ExactNum 

pub struct ExactNum { /* private fields */ }

A floating point number of arbitrary precision.

Implementations

impl ExactNum

pub fn to_inline_bytes(&self) -> Result<InlineBinaryBuffer, Error>

Encode an inlined value into a stack buffer.

Specials always succeed. A finite mantissa wider than BINARY_INLINE_MANT_BITS returns Error::MemoryAllocation.

pub fn write_inline_bytes(&self, dest: &mut [u8]) -> Result<usize, Error>

Write the 16-byte inline record into dest.

Returns Error::InvalidArgument if dest is shorter than BINARY_INLINE_LEN. Wider finite mantissas return Error::MemoryAllocation.

pub fn from_inline_bytes(bytes: &[u8; 16]) -> Result<ExactNum, Error>

Decode a 16-byte inline record.

pub fn to_bytes(&self) -> Result<Vec<u8>, Error>

Encode self (inline 16 bytes, or a heap record if the mantissa is wider).

pub fn write_bytes(&self, dest: &mut [u8]) -> Result<usize, Error>

Write the compact record into dest without allocating.

pub fn from_bytes(bytes: &[u8]) -> Result<ExactNum, Error>

Decode a compact record. Extra trailing bytes are Error::InvalidArgument.

impl ExactNum

pub fn normal_pdf( &self, mu: &ExactNum, sigma: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Standard-form normal density (\varphi(x;\mu,\sigma)=\exp(-(x-\mu)^2/(2\sigma^2))/(\sigma\sqrt{2\pi})).

sigma ≤ 0 or a non-finite parameter is NaN.

Precision

• Algorithm: exp / sqrt / π at p + WORD_BIT_SIZE, then one rounding to p.
• Bound: working precision p + WORD_BIT_SIZE.
• MPFR oracle: no (composite of existing leaves).

pub fn normal_cdf( &self, mu: &ExactNum, sigma: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Normal CDF (\Phi(x;\mu,\sigma)=(1+\mathrm{erf}((x-\mu)/(\sigma\sqrt{2})))/2).

sigma ≤ 0 is NaN.

Precision

• Algorithm: existing erf at p + WORD_BIT_SIZE.
• Bound: working precision p + WORD_BIT_SIZE.
• MPFR oracle: no (composite of erf).

pub fn gamma_pdf( &self, alpha: &ExactNum, beta: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Gamma density on the scale parameterization (x^{\alpha-1}e^{-x/\beta}/(\beta^\alpha\Gamma(\alpha))).

Requires x ≥ 0, alpha > 0, beta > 0.

Precision

• Algorithm: pow / exp / gamma at p + WORD_BIT_SIZE.
• Bound: working precision p + WORD_BIT_SIZE.
• MPFR oracle: no.

pub fn beta_pdf( &self, alpha: &ExactNum, beta: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Beta density (x^{\alpha-1}(1-x)^{\beta-1}/B(\alpha,\beta)) with (B(\alpha,\beta)=\Gamma(\alpha)\Gamma(\beta)/\Gamma(\alpha+\beta)).

Requires x ∈ [0, 1], alpha > 0, beta > 0.

Precision

• Algorithm: pow / gamma at p + WORD_BIT_SIZE.
• Bound: working precision p + WORD_BIT_SIZE.
• MPFR oracle: no.

pub fn poisson_pmf( &self, lambda: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Poisson PMF (\lambda^k e^{-\lambda}/k!) for a non-negative integer self (= k).

Precision

• Algorithm: pow / exp / (\Gamma(k+1)) at p + WORD_BIT_SIZE.
• Bound: working precision p + WORD_BIT_SIZE.
• MPFR oracle: no.

pub fn binomial_pmf( &self, n: &ExactNum, prob: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Binomial PMF (\binom{n}{k} \mathrm{prob}^k (1-\mathrm{prob})^{n-k}).

self is (k). Requires non-negative integers k ≤ n and prob ∈ [0, 1].

Precision

• Algorithm: multiplicative binomial coefficient, then pow.
• Bound: working precision p + WORD_BIT_SIZE.
• MPFR oracle: no.

pub fn chi_squared_cdf( &self, k: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Chi-squared CDF (P(k/2, x/2)=\gamma(k/2, x/2)/\Gamma(k/2)).

self is (x). Requires x ≥ 0 and k > 0.

Precision

• Algorithm: lower gammainc over gamma at p + WORD_BIT_SIZE.
• Bound: working precision p + WORD_BIT_SIZE.
• MPFR oracle: no.

pub fn student_t_pdf( &self, nu: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Student-(t) density via (\Gamma): (\Gamma((\nu+1)/2)/(\sqrt{\nu\pi},\Gamma(\nu/2)),(1+x^2/\nu)^{-(\nu+1)/2}).

self is (x). Requires nu > 0.

Precision

• Algorithm: gamma / pow / sqrt at p + WORD_BIT_SIZE.
• Bound: working precision p + WORD_BIT_SIZE.
• MPFR oracle: no.

impl ExactNum

pub fn new(p: usize) -> ExactNum

Returns a new number with value of 0 and precision of p bits. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn nan(err: Option<Error>) -> ExactNum

Constructs not-a-number with an associated error err.

pub fn is_inf_pos(&self) -> bool

Returns true if self is positive infinity.

pub fn is_inf_neg(&self) -> bool

Returns true if self is negative infinity.

pub fn is_inf(&self) -> bool

Returns true if self is infinite.

pub fn is_nan(&self) -> bool

Return true if self is not a number.

pub fn is_int(&self) -> bool

Return true if self is an integer number.

pub fn err(&self) -> Option<Error>

Returns the associated with NaN error, if any.

pub fn add(&self, d2: &ExactNum, p: usize, rm: RoundingMode) -> ExactNum

Adds d2 to self and returns the result of the operation with precision p rounded according to rm. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn add_full_prec(&self, d2: &ExactNum) -> ExactNum

Adds d2 to self and returns the result of the operation. The resulting precision is equal to the full precision of the result. This operation can be used to emulate integer addition.

pub fn sub(&self, d2: &ExactNum, p: usize, rm: RoundingMode) -> ExactNum

Subtracts d2 from self and returns the result of the operation with precision p rounded according to rm. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn sub_full_prec(&self, d2: &ExactNum) -> ExactNum

Subtracts d2 from self and returns the result of the operation. The resulting precision is equal to the full precision of the result. This operation can be used to emulate integer subtraction.

pub fn mul(&self, d2: &ExactNum, p: usize, rm: RoundingMode) -> ExactNum

Multiplies d2 by self and returns the result of the operation with precision p rounded according to rm. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn mul_full_prec(&self, d2: &ExactNum) -> ExactNum

Multiplies d2 by self and returns the result of the operation. The resulting precision is equal to the full precision of the result. This operation can be used to emulate integer multiplication.

pub fn fma( &self, b: &ExactNum, c: &ExactNum, p: usize, rm: RoundingMode, ) -> ExactNum

Computes self * b + c with precision p, rounded once with rm.

Unlike mul followed by add, the product is not rounded to p before the addition.

pub fn two_sum( &self, b: &ExactNum, p: usize, rm: RoundingMode, ) -> (ExactNum, ExactNum)

Knuth–Dekker two-sum: (hi, lo) with hi rounded to p bits using rm and hi + lo equal to the exact sum of finite operands (via add_full_prec). Unlike a hardware-float Dekker two-sum, this takes (p, rm) because the high part is an ExactNum at a chosen precision, not an implicit machine word.

Inf / NaN: hi is self.add(b, p, rm); lo is zero (or NaN if hi is NaN). Reconstruct with hi.add(&lo, p, rm) (not add_full_prec, which uses internal precision 0).

pub fn two_product( &self, b: &ExactNum, p: usize, rm: RoundingMode, ) -> (ExactNum, ExactNum)

Two-product: (hi, lo) with hi rounded to p bits using rm and hi + lo equal to the exact product of finite operands (via mul_full_prec).

pub fn fused_sum(xs: &[ExactNum], p: usize, rm: RoundingMode) -> ExactNum

Sum xs at extra working precision and round once to p bits.

pub fn fused_dot( xs: &[ExactNum], ys: &[ExactNum], p: usize, rm: RoundingMode, ) -> ExactNum

Dot product of equal-length slices: extra-precision ∑ xs[i]*ys[i], then one round to p. Length mismatch yields NaN (InvalidArgument).

pub fn polyval( coeffs: &[ExactNum], x: &ExactNum, p: usize, rm: RoundingMode, ) -> ExactNum

Horner evaluation a₀ + x(a₁ + x(a₂ + …)) with fused multiply-add at extra working precision, then one round to p. coeffs[0] is the constant term (lowest degree first). Empty coeffs yields zero.

pub fn mul_add( &self, b: &ExactNum, c: &ExactNum, p: usize, rm: RoundingMode, ) -> ExactNum

Alias of Self::fma.

pub fn div(&self, d2: &ExactNum, p: usize, rm: RoundingMode) -> ExactNum

Divides self by d2 and returns the result of the operation with precision p rounded according to rm. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn rem(&self, d2: &ExactNum) -> ExactNum

Returns the remainder of division of |self| by |d2|. The sign of the result is set to the sign of self.

pub fn cmp(&self, d2: &ExactNum) -> Option<i128>

Compares self to d2. Returns positive if self > d2, negative if self < d2, zero if self == d2, None if self or d2 is NaN.

pub fn abs_cmp(&self, d2: &ExactNum) -> Option<i128>

Compares the absolute value of self to the absolute value of d2. Returns positive if |self| is greater than |d2|, negative if |self| is smaller than |d2|, 0 if |self| equals to |d2|, None if self or d2 is NaN.

pub fn inv_sign(&mut self)

Reverses the sign of self.

pub fn pow( &self, n: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Compute the power of self to the n with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn powi(&self, n: usize, p: usize, rm: RoundingMode) -> ExactNum

Compute the power of self to the integer n with precision p. The result is rounded using the rounding mode rm. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn powsi(&self, n: isize, p: usize, rm: RoundingMode) -> ExactNum

Compute the power of self to the signed integer n with precision p. The result is rounded using the rounding mode rm. Precision is rounded upwards to the word size. Negative n is a reciprocal of the corresponding positive power. The function returns NaN if the precision p is incorrect, or Inf if self is zero and n is negative.

pub fn log( &self, n: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Computes the logarithm base n of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn is_positive(&self) -> bool

Returns true if self is positive. The function returns false if self is NaN.

pub fn is_negative(&self) -> bool

Returns true if self is negative. The function returns false if self is NaN.

pub fn is_subnormal(&self) -> bool

Returns true if self is subnormal. A number is subnormal if the most significant bit of the mantissa is not equal to 1.

pub fn is_zero(&self) -> bool

Returns true if self is zero.

pub fn clamp(&self, min: &ExactNum, max: &ExactNum) -> ExactNum

Restricts the value of self to an interval determined by the values of min and max. The function returns max if self is greater than max, min if self is less than min, and self otherwise. If either argument is NaN or min is greater than max, the function returns NaN.

pub fn max(&self, d1: &ExactNum) -> ExactNum

Returns the value of d1 if d1 is greater than self, or the value of self otherwise. If either argument is NaN, the function returns NaN.

pub fn min(&self, d1: &ExactNum) -> ExactNum

Returns value of d1 if d1 is less than self, or the value of self otherwise. If either argument is NaN, the function returns NaN.

pub fn signum(&self) -> ExactNum

Returns a ExactNum with the value -1 if self is negative, 1 if self is positive, zero otherwise. The function returns NaN If self is NaN.

pub fn parse( s: &str, rdx: Radix, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Parses a number from the string s. The function expects s to be a number in scientific format in radix rdx, or +-Inf, or NaN. if p equals to usize::MAX then the precision of the resulting number is determined automatically from the input.

Examples

let mut cc = Consts::new().expect("Constants cache initialized.");

let n = ExactNum::parse("0.0", Radix::Bin, 64, RoundingMode::ToEven, &mut cc);
assert!(n.is_zero());

let n = ExactNum::parse("-Inf", Radix::Hex, 1, RoundingMode::None, &mut cc);
assert!(n.is_inf_neg());

let n = ExactNum::parse("NaN", Radix::Oct, 2, RoundingMode::None, &mut cc);
assert!(n.is_nan());

pub fn format( &self, rdx: Radix, rm: RoundingMode, cc: &mut Consts, ) -> Result<String, Error>

Formats the number using radix rdx and rounding mode rm. Note, since hexadecimal digits include the character “e”, the exponent part is separated from the mantissa by “_”. For example, a number with mantissa 123abcdef and exponent 123 would be formatted as 123abcdef_e+123.

Errors

• MemoryAllocation: failed to allocate memory for mantissa.
• ExponentOverflow: the resulting exponent becomes greater than the maximum allowed value for the exponent.

pub fn with_radix(self, radix: Radix) -> RadixFloat

Wraps self in a crate::RadixFloat tagged with radix for parse/format.

pub fn classify(&self) -> FpCategory

Returns category of self.

pub fn atan(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes the arctangent of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn atan2( &self, x: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Computes atan2(self, x) with precision p (quadrant-aware arctangent of self / x). The result is rounded using the rounding mode rm. This function requires constants cache cc. Precision is rounded upwards to the word size.

pub fn hypot(&self, other: &ExactNum, p: usize, rm: RoundingMode) -> ExactNum

Computes sqrt(self² + other²) with precision p. The result is rounded using the rounding mode rm. Precision is rounded upwards to the word size. hypot(±Inf, y) and hypot(x, ±Inf) are +Inf, including when the other argument is NaN.

pub fn log1p(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes ln(1 + self) with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc. Returns -Inf for self == -1, and NaN if self < -1.

pub fn expm1(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes exp(self) - 1 with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc.

pub fn tanh(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes the hyperbolic tangent of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn exponent(&self) -> Option<i32>

Returns the exponent of self, or None if self is Inf or NaN.

pub fn precision(&self) -> Option<usize>

Returns the number of significant bits used in the mantissa, or None if self is Inf or NaN. Normal numbers use all bits of the mantissa. Subnormal numbers use fewer bits than the mantissa can hold.

pub fn max_value(p: usize) -> ExactNum

Returns the maximum value for the specified precision p: all bits of the mantissa are set to 1, the exponent has the maximum possible value, and the sign is positive. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn min_value(p: usize) -> ExactNum

Returns the minimum value for the specified precision p: all bits of the mantissa are set to 1, the exponent has the maximum possible value, and the sign is negative. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn min_positive(p: usize) -> ExactNum

Returns the minimum positive subnormal value for the specified precision p: only the least significant bit of the mantissa is set to 1, the exponent has the minimum possible value, and the sign is positive. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn min_positive_normal(p: usize) -> ExactNum

Returns the minimum positive normal value for the specified precision p: only the most significant bit of the mantissa is set to 1, the exponent has the minimum possible value, and the sign is positive. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn from_word(d: u64, p: usize) -> ExactNum

Returns a new number with value d and the precision p. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn neg(&self) -> ExactNum

Returns a copy of the number with the sign reversed.

pub fn as_raw_parts(&self) -> Option<(&[u64], usize, Sign, i32, bool)>

Decomposes self into raw parts. The function returns a reference to a slice of words representing mantissa, numbers of significant bits in the mantissa, sign, exponent, and a bool value which specify whether the number is inexact.

pub fn from_raw_parts( m: &[u64], n: usize, s: Sign, e: i32, inexact: bool, ) -> ExactNum

Constructs a number from the raw parts:

• m is the mantisaa.
• n is the number of significant bits in mantissa.
• s is the sign.
• e is the exponent.
• inexact specify whether number is inexact.

This function returns NaN in the following situations:

• n is larger than the number of bits in m.
• n is smaller than the number of bits in m, but m does not represent corresponding subnormal number mantissa.
• n is smaller than the number of bits in m, but e is not the minimum possible exponent.
• n or the size of m is too large (larger than isize::MAX / 2 + EXPONENT_MIN).
• e is less than EXPONENT_MIN or greater than EXPONENT_MAX.

pub fn from_words(m: &[u64], s: Sign, e: i32) -> ExactNum

Constructs a number from the slice of words:

• m is the mantissa.
• s is the sign.
• e is the exponent.

The function returns NaN if e is less than EXPONENT_MIN or greater than EXPONENT_MAX.

pub fn sign(&self) -> Option<Sign>

Returns the sign of self, or None if self is NaN.

pub fn set_exponent(&mut self, e: i32)

Sets the exponent of self. Note that if self is subnormal, the exponent may not change, but the mantissa will shift instead. e will be clamped to the range from EXPONENT_MIN to EXPONENT_MAX if it’s outside of the range. See example below.

Examples

// construct a subnormal value.
let mut n = ExactNum::min_positive(128);

assert_eq!(n.exponent(), Some(EXPONENT_MIN));
assert_eq!(n.precision(), Some(1));

// increase exponent.
let n_exp = n.exponent().expect("n is not NaN");
n.set_exponent(n_exp + 1);

// the outcome for subnormal number.
assert_eq!(n.exponent(), Some(EXPONENT_MIN));
assert_eq!(n.precision(), Some(2));

pub fn mantissa_max_bit_len(&self) -> Option<usize>

Returns the maximum mantissa length of self in bits regardless of whether self is normal or subnormal.

pub fn is_inline(&self) -> bool

True when a finite value stores its mantissa on the stack (at most crate::INLINE_WORDS limbs). Inf and NaN return false.

pub fn set_precision(&mut self, p: usize, rm: RoundingMode) -> Result<(), Error>

Sets the precision of self to p. If the new precision is smaller than the existing one, the number is rounded using specified rounding mode rm.

Errors

• MemoryAllocation: failed to allocate memory for mantissa.
• InvalidArgument: the precision is incorrect.

pub fn reciprocal(&self, p: usize, rm: RoundingMode) -> ExactNum

Computes the reciprocal of a number with precision p. The result is rounded using the rounding mode rm. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn set_sign(&mut self, s: Sign)

Sets the sign of self.

pub fn mantissa_digits(&self) -> Option<&[u64]>

Returns the raw mantissa words of a number.

pub fn convert_from_radix( sign: Sign, digits: &[u8], e: i32, rdx: Radix, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Converts an array of digits in radix rdx to ExactNum with precision p. digits represents mantissa and is interpreted as a number smaller than 1 and greater or equal to 1/rdx. The first element in digits is the most significant digit. e is the exponent part of the number, such that the number can be represented as digits * rdx ^ e. Precision is rounded upwards to the word size. if p equals usize::MAX then the precision of the resulting number is determined automatically from the input.

Examples

Code below converts -0.1234567₈ × 10₈^3₈ given in radix 8 to ExactNum.

let mut cc = Consts::new().expect("Constants cache initialized.");

let n = ExactNum::convert_from_radix(
    Sign::Neg,
    &[1, 2, 3, 4, 5, 6, 7, 0],
    3,
    Radix::Oct,
    64,
    RoundingMode::None,
    &mut cc);
assert!(!n.is_nan());
assert!(n.is_negative());

Errors

On error, the function returns NaN with the following associated error:

• MemoryAllocation: failed to allocate memory for mantissa.
• ExponentOverflow: the resulting exponent becomes greater than the maximum allowed value for the exponent.
• InvalidArgument: the precision is incorrect, or digits contains unacceptable digits for given radix, or when e is less than EXPONENT_MIN or greater than EXPONENT_MAX.

pub fn convert_to_radix( &self, rdx: Radix, rm: RoundingMode, cc: &mut Consts, ) -> Result<(Sign, Vec<u8>, i32), Error>

Converts self to radix rdx using rounding mode rm. The function returns sign, mantissa digits in radix rdx, and exponent such that the converted number can be represented as mantissa digits * rdx ^ exponent. The first element in the mantissa is the most significant digit.

Examples

let mut cc = Consts::new().expect("Constants cache initialized.");
let n = ExactNum::parse("123.45678", Radix::Dec, 64, RoundingMode::None, &mut cc);
let (s, m, _e) = n.convert_to_radix(Radix::Dec, RoundingMode::None, &mut cc).expect("Conversion failed");
assert_eq!(s, Sign::Pos);
assert!(!m.is_empty());

Errors

• MemoryAllocation: failed to allocate memory for mantissa.
• ExponentOverflow: the resulting exponent becomes greater than the maximum allowed value for the exponent.
• InvalidArgument: self is Inf or NaN.

pub fn inexact(&self) -> bool

Returns true if self is inexact. The function returns false if self is Inf or NaN.

pub fn set_inexact(&mut self, inexact: bool)

Marks self as inexact if inexact is true, or exact otherwise. The function has no effect if self is Inf or NaN.

pub fn try_set_precision( &mut self, p: usize, rm: RoundingMode, s: usize, ) -> bool

Try to round and then set the precision to p, given self has s correct digits in mantissa. The function returns true if rounding succeeded, or if self is Inf or NaN. If the fuction returns false, self is still modified, and should be discarded. In case of an error, self will be set to NaN with an associated error. If the precision p is incorrect self will be set to NaN.

pub fn frexp(&self) -> (ExactNum, i32)

Split self = m · 2^e with m in [0.5, 1) (zeros return (0, 0); Inf/NaN return (self, 0)).

pub fn ldexp(&self, n: i32, p: usize, rm: RoundingMode) -> ExactNum

self · 2^n. Alias of Self::scalb.

pub fn scalb(&self, n: i32, p: usize, rm: RoundingMode) -> ExactNum

self · 2^n (IEEE scalbn).

pub fn logb(&self, p: usize, rm: RoundingMode) -> ExactNum

floor(log2(|self|)) as a float. Zero becomes -Inf; Inf/NaN unchanged in kind.

pub fn ilogb(&self) -> Option<i32>

Integer floor(log2(|self|)). None for zero, Inf, or NaN.

impl ExactNum

pub fn abs(&self) -> ExactNum

Returns the absolute value of self.

pub fn copysign(&self, sign: &ExactNum, p: usize, rm: RoundingMode) -> ExactNum

Returns a value with the magnitude of self and the sign of sign.

pub fn next_after( &self, toward: &ExactNum, p: usize, rm: RoundingMode, ) -> ExactNum

Returns the next representable value from self toward toward at precision p.

pub fn int(&self) -> ExactNum

Returns the integer part of self.

pub fn fract(&self) -> ExactNum

Returns the fractional part of self.

pub fn ceil(&self) -> ExactNum

Returns the smallest integer greater than or equal to self.

pub fn floor(&self) -> ExactNum

Returns the largest integer less than or equal to self.

pub fn round(&self, n: usize, rm: RoundingMode) -> ExactNum

Returns the rounded number with n binary positions in the fractional part of the number using rounding mode rm.

pub fn sqrt(&self, p: usize, rm: RoundingMode) -> ExactNum

Computes the square root of a number with precision p. The result is rounded using the rounding mode rm. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn cbrt(&self, p: usize, rm: RoundingMode) -> ExactNum

Computes the cube root of a number with precision p. The result is rounded using the rounding mode rm. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn nth_root(&self, n: usize, p: usize, rm: RoundingMode) -> ExactNum

Computes the n-th root of self with precision p. n = 2 and n = 3 delegate to sqrt and cbrt.

pub fn ln(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes the natural logarithm of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn log2(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes the logarithm base 2 of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn log10(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes the logarithm base 10 of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn exp(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes e to the power of self with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn exp2(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes 2 to the power of self with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn exp10(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes 10 to the power of self with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn rem_pi(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Reduces self modulo 2π into the interval (-2π, 2π) using precision p and rounding mode rm. This function requires constants cache cc for computing the result.

pub fn sin(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes the sine of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn cos(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes the cosine of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn sin_cos( &self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> (ExactNum, ExactNum)

Computes (sin(self), cos(self)) with precision p using a shared argument reduction.

pub fn tan(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes the tangent of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn asin(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes the arcsine of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn acos(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes the arccosine of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn sinh(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes the hyperbolic sine of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn cosh(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes the hyperbolic cosine of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn sinh_cosh( &self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> (ExactNum, ExactNum)

Computes (sinh(self), cosh(self)) with precision p using a single exp(|x|) evaluation.

pub fn erf(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Error function erf(self) with precision p.

Precision

• Algorithm: Taylor series when |x|.exponent() ≤ 2; complementary asymptotic otherwise. Saturates to ±1 when 2|e| > p+4.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY). 1 ULP vs MPFR on |x| ≲ 4.
• Thresholds: exponent cut ≤ 2 (not a named constant).
• MPFR oracle: yes, |x| ≲ 4 under mpfr-tests. Complex erf on the real axis uses the same oracle; GNU MPC has no mpc_erf.

pub fn erfc(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Complementary error function erfc(self) = 1 - erf(self) with precision p.

Precision

• Algorithm: 1 - erf at extra working precision (same series / asymptotic as erf).
• Bound: Ziv correct-rounding (MAX_PREC_RETRY). 1 ULP vs MPFR on |x| ≲ 4.
• MPFR oracle: yes, |x| ≲ 4 under mpfr-tests.

pub fn gamma(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Gamma function Γ(self) with precision p. Poles at non-positive integers yield NaN (or +Inf at 0).

Precision

• Algorithm: Stirling series for ln Γ then exp; reflection across the negative axis. Integer factorials for small positive integers.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY). 1 ULP vs MPFR on the oracle domain.
• MPFR oracle: yes, under mpfr-tests.

pub fn ln_gamma(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

ln Γ(self) for positive self with precision p.

Precision

• Algorithm: Stirling series (Bernoulli) at working precision p + WORD_BIT_SIZE.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY). 1 ULP vs MPFR on the oracle domain.
• MPFR oracle: yes, under mpfr-tests.

pub fn digamma(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Digamma ψ(self). Poles at non-positive integers. Reflection for z < 0.

Precision

• Algorithm: recurrence to a large argument, then Bernoulli series; reflection for z < 0.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY). 1 ULP vs MPFR digamma on z > 0.
• MPFR oracle: yes, z > 0 under mpfr-tests.

pub fn gammainc( &self, x: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Lower incomplete gamma γ(self, x) for self > 0, x ≥ 0.

Precision

• Algorithm: power series in x at working precision; +∞ in x returns Γ(self).
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: identity γ(s,x)=Γ(s)−Γ(s,x); upper uses mpfr_gamma_inc.

pub fn gammainc_upper( &self, x: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Upper incomplete gamma Γ(self, x) for self > 0, x ≥ 0.

Precision

• Algorithm: Γ(self) - γ(self, x) at working precision; +∞ in x returns 0.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: yes, mpfr_gamma_inc under mpfr-tests.

pub fn ei(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Exponential integral Ei(self) (principal value for self < 0). 0 is a pole.

Precision

• Algorithm: power series for moderate |x|; factorial asymptotic when |x| is large (exponent() > 6 and |x| ≳ 0.7 p).
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: yes, mpfr_eint under mpfr-tests.

pub fn si(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Sine integral Si(self). +∞ → π/2, −∞ → −π/2.

Precision

• Algorithm: series, or auxiliary f,g asymptotic on the same cut as Ei.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no (Si odd, Si(0)=0, Si(+∞)=π/2).

pub fn ci(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Cosine integral Ci(self) for self > 0.

Precision

• Algorithm: series, or auxiliary f,g asymptotic (same |x| cut as Ei). Near-zero is a pole.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no (identity / series golds; GNU MPFR has no Si/Ci).

pub fn li(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Logarithmic integral li(self) = Ei(ln self) for self > 0, self ≠ 1.

Precision

• Algorithm: Ei(ln self) at extra working precision (inherits Ei series / asymptotic).
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no (li(e)=Ei(1) identity).

pub fn fresnel_s(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Fresnel sine integral S(self). ±∞ → ±1/2.

Precision

• Algorithm: series, or auxiliary f,g when |x|.exponent() ≥ 8 (or 3 x² > p).
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no (S odd, S(0)=0, S(+∞)=1/2).

pub fn fresnel_c(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Fresnel cosine integral C(self). ±∞ → ±1/2.

Precision

• Algorithm: same series / auxiliary f,g split as Self::fresnel_s.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no (same identities as Self::fresnel_s).

pub fn ai(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Airy (\mathrm{Ai}(\mathrm{self})). (+\infty\to 0); (-\infty) has no limit → NaN.

Precision

• Algorithm: power series for |x| < AIRY_SERIES_THRESHOLD (8); asymptotic otherwise.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: yes, mpfr_ai under mpfr-tests.

pub fn bi(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Airy (\mathrm{Bi}(\mathrm{self})). (+\infty\to+\infty); (-\infty) has no limit → NaN.

Precision

• Algorithm: same AIRY_SERIES_THRESHOLD = 8 split as Self::ai.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no (Ai Bi' − Ai' Bi = 1/π; GNU MPFR has no Bi).

pub fn ai_prime(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

(\mathrm{Ai}’(\mathrm{self})). (+\infty\to 0); (-\infty) → NaN.

Precision

• Algorithm: differentiated series / asymptotic; AIRY_SERIES_THRESHOLD = 8.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn bi_prime(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

(\mathrm{Bi}’(\mathrm{self})). (+\infty\to+\infty); (-\infty) → NaN.

Precision

• Algorithm: differentiated series / asymptotic; AIRY_SERIES_THRESHOLD = 8.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn bessel_j( &self, n: usize, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Bessel function of the first kind J_n(self) for integer order n.

Precision

• Algorithm: power series; Miller recurrence for large n (n ≤ 1024).
• Bound: Ziv correct-rounding (MAX_PREC_RETRY). 1 ULP vs MPFR jn for n = 0,1,2.
• MPFR oracle: yes, n = 0,1,2 under mpfr-tests.

pub fn bessel_j_nu( &self, nu: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

(J_ν(\mathrm{self})) for real order nu.

Precision

• Algorithm: series in x; integer ν delegates to Self::bessel_j.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no (identity golds).

pub fn bessel_y( &self, nu: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

(Y_ν(\mathrm{self})) for self > 0.

Precision

• Algorithm: Wronskian / series from (J_ν); cut on ((-\infty, 0]).
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: yes, mpfr_yn for n = 0,1 under mpfr-tests.

pub fn bessel_i( &self, nu: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

(I_ν(\mathrm{self})).

Precision

• Algorithm: series; (I_ν(z) = i^{-ν} J_ν(iz)) for the complex path.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn bessel_k( &self, nu: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

(K_ν(\mathrm{self})) for self > 0. (K_{-ν}=K_ν).

Precision

• Algorithm: series / Temme; large-|x| asymptotic k_asymptotic.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn elliptic_k( &self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Complete elliptic K(self). Parameter m = k². m = 1 is +∞; m > 1 uses the reciprocal-modulus transform.

Precision

• Algorithm: Carlson R_F duplication; cap CARLSON_DUPE_MAX = 128.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no (identity golds; GNU MPFR has no Carlson K).

pub fn elliptic_e_complete( &self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Complete elliptic E(self) for self ≤ 1. E(1) = 1.

Precision

• Algorithm: Carlson R_F / R_D; CARLSON_DUPE_MAX = 128.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn elliptic_f( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Incomplete F(self | m) for |self| ≤ 1. self = sin φ, m = k².

Precision

• Algorithm: Carlson R_F; CARLSON_DUPE_MAX = 128.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn elliptic_e( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Incomplete E(self | m) for |self| ≤ 1.

Precision

• Algorithm: Carlson R_F / R_D; CARLSON_DUPE_MAX = 128.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn elliptic_pi_complete( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Complete Π(self, m) for self < 1, m < 1.

Precision

• Algorithm: Carlson R_J; CARLSON_DUPE_MAX = 128.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn elliptic_pi( &self, x: &ExactNum, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Incomplete Π(self; x | m).

Precision

• Algorithm: Carlson R_J; CARLSON_DUPE_MAX = 128.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn jacobi_am( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Jacobi amplitude am(self | m). Parameter m = k² ∈ [0, 1].

Precision

• Algorithm: AGM / descending Landen; cap JACOBI_AGM_MAX = 128. (m=0) is trig; (m=1) is hyperbolic.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no (identity golds; GNU MPFR has no Jacobi sn).

pub fn jacobi_sn( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

sn(self | m). Parameter m = k² ∈ [0, 1]. The inverse on (-K, K) is Self::elliptic_f: F(sn(u|m)|m) = u.

Precision

• Algorithm: AGM amplitude; cap JACOBI_AGM_MAX = 128.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn jacobi_cn( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

cn(self | m). Parameter m = k² ∈ [0, 1].

Precision

• Algorithm: AGM amplitude; cap JACOBI_AGM_MAX = 128.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn jacobi_dn( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

dn(self | m). Parameter m = k² ∈ [0, 1].

Precision

• Algorithm: AGM amplitude; cap JACOBI_AGM_MAX = 128.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn jacobi_cd( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

cd(self | m) = cn / dn. Parameter m = k² ∈ [0, 1].

Precision

• Algorithm: AGM amplitude; cap JACOBI_AGM_MAX = 128.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn jacobi_ns( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

ns(self | m) = 1/sn.

pub fn jacobi_nc( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

nc(self | m) = 1/cn.

pub fn jacobi_nd( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

nd(self | m) = 1/dn.

pub fn jacobi_sc( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

sc(self | m) = sn/cn.

pub fn jacobi_sd( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

sd(self | m) = sn/dn.

pub fn jacobi_cs( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

cs(self | m) = cn/sn.

pub fn jacobi_ds( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

ds(self | m) = dn/sn.

pub fn jacobi_dc( &self, m: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

dc(self | m) = dn/cn.

pub fn legendre_p(&self, n: u32, p: usize, rm: RoundingMode) -> ExactNum

Legendre (P_n(\mathrm{self})) for integer n.

Precision

• Algorithm: three-term recurrence at p + O(n) bits. Cap ORTHOPOLY_N_MAX.
• Bound: working-precision recurrence (not a Ziv leaf).
• MPFR oracle: no.

pub fn assoc_legendre_p( &self, n: u32, m: i32, p: usize, rm: RoundingMode, ) -> ExactNum

Associated (P_n^m(\mathrm{self})) (Condon–Shortley).

Precision

• Algorithm: recurrence from (P_n); Condon–Shortley phase.
• Bound: working-precision recurrence (not a Ziv leaf).
• MPFR oracle: no.

pub fn hypergeom_2f1( &self, b: &ExactNum, c: &ExactNum, z: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Gaussian ({}_2F_1(\mathrm{self}, b; c; z)).

Precision

• Algorithm: series for |z| < 1; Gauss at z = 1; Pfaff / continuation. Cap HYPERGEOM_TERM_MAX = 10_000.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY) when the series converges.
• MPFR oracle: no.

pub fn betainc( &self, b: &ExactNum, x: &ExactNum, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> ExactNum

Regularized incomplete beta (I_x(a=\mathrm{self}, b)).

Precision

• Algorithm: series / continued fraction in x ∈ [0, 1] for a > 0, b > 0.
• Bound: Ziv correct-rounding (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn asinh(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes the hyperbolic arcsine of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn acosh(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes the hyperbolic arccosine of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

pub fn atanh(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Computes the hyperbolic arctangent of a number with precision p. The result is rounded using the rounding mode rm. This function requires constants cache cc for computing the result. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

impl ExactNum

pub fn from_i8(i: i8, p: usize) -> ExactNum

Constructs ExactNum with precision p from an integer value i. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

impl ExactNum

pub fn from_i16(i: i16, p: usize) -> ExactNum

Constructs ExactNum with precision p from an integer value i. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

impl ExactNum

pub fn from_i32(i: i32, p: usize) -> ExactNum

Constructs ExactNum with precision p from an integer value i. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

impl ExactNum

pub fn from_i64(i: i64, p: usize) -> ExactNum

Constructs ExactNum with precision p from an integer value i. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

impl ExactNum

pub fn from_i128(i: i128, p: usize) -> ExactNum

Constructs ExactNum with precision p from an integer value i. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

impl ExactNum

pub fn from_u8(i: u8, p: usize) -> ExactNum

Constructs ExactNum with precision p from an integer value i. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

impl ExactNum

pub fn from_u16(i: u16, p: usize) -> ExactNum

Constructs ExactNum with precision p from an integer value i. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

impl ExactNum

pub fn from_u32(i: u32, p: usize) -> ExactNum

Constructs ExactNum with precision p from an integer value i. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

impl ExactNum

pub fn from_u64(i: u64, p: usize) -> ExactNum

Constructs ExactNum with precision p from an integer value i. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

impl ExactNum

pub fn from_u128(i: u128, p: usize) -> ExactNum

Constructs ExactNum with precision p from an integer value i. Precision is rounded upwards to the word size. The function returns NaN if the precision p is incorrect.

impl ExactNum

pub fn hermite_he(&self, n: usize, p: usize, rm: RoundingMode) -> ExactNum

Probabilist’s Hermite polynomial He_n(self).

He_0 = 1, He_1 = x, He_{n+1} = x He_n − n He_{n−1}. n > ORTHOPOLY_N_MAX or non-finite self is NaN.

pub fn hermite_h(&self, n: usize, p: usize, rm: RoundingMode) -> ExactNum

Physicist’s Hermite polynomial H_n(self).

H_0 = 1, H_1 = 2x, H_{n+1} = 2x H_n − 2n H_{n−1}. n > ORTHOPOLY_N_MAX or non-finite self is NaN.

pub fn laguerre(&self, n: usize, p: usize, rm: RoundingMode) -> ExactNum

Laguerre polynomial L_n(self).

L_0 = 1, L_1 = 1 − x, L_{n+1} = ((2n+1−x) L_n − n L_{n−1}) / (n+1). n > ORTHOPOLY_N_MAX or non-finite self is NaN.

pub fn gen_laguerre( &self, n: usize, alpha: &ExactNum, p: usize, rm: RoundingMode, ) -> ExactNum

Generalized Laguerre L_n^{(α)}(self).

L_0^{(α)} = 1, L_1^{(α)} = 1+α−x, L_{n+1}^{(α)} = (((2n+1+α−x) L_n − (n+α) L_{n−1}) / (n+1). n > ORTHOPOLY_N_MAX or a non-finite argument is NaN.

pub fn chebyshev_t(&self, n: usize, p: usize, rm: RoundingMode) -> ExactNum

Chebyshev polynomial of the first kind T_n(self).

T_0 = 1, T_1 = x, T_{n+1} = 2x T_n − T_{n−1}. n > ORTHOPOLY_N_MAX or non-finite self is NaN.

pub fn chebyshev_u(&self, n: usize, p: usize, rm: RoundingMode) -> ExactNum

Chebyshev polynomial of the second kind U_n(self).

U_0 = 1, U_1 = 2x, U_{n+1} = 2x U_n − U_{n−1}. n > ORTHOPOLY_N_MAX or non-finite self is NaN.

pub fn gegenbauer( &self, n: usize, lambda: &ExactNum, p: usize, rm: RoundingMode, ) -> ExactNum

Gegenbauer (ultraspherical) polynomial C_n^{(λ)}(self).

C_0 = 1, C_1 = 2λ x, C_{n+1} = (2(n+λ) x C_n − (n+2λ−1) C_{n−1}) / (n+1). Standard C_n^{(λ)}: C_2^{(1)} = 4x² − 1 = U_2, and C_n^{(1/2)} = P_n (Legendre). n > ORTHOPOLY_N_MAX or a non-finite argument is NaN.

impl ExactNum

pub fn parse_exact(s: &str) -> Option<ExactNum>

Parse a decimal that is exact in binary (a dyadic rational). None if the value is not a finite dyadic (so 0.1 is None here; use ExactRational::parse_exact).

pub fn format_exact(&self, rdx: Radix) -> Option<String>

Minimum digits in rdx that recover self exactly when the value is a terminating expansion in that radix.

Trait Implementations

impl Add for ExactNum

type Output = ExactNum

The resulting type after applying the + operator.

fn add(self, rhs: ExactNum) -> ExactNum

Performs the + operation.

impl Add<&ExactNum> for &ExactNum

type Output = ExactNum

The resulting type after applying the + operator.

fn add(self, rhs: &ExactNum) -> ExactNum

Performs the + operation.

impl Add<&ExactNum> for ExactNum

type Output = ExactNum

The resulting type after applying the + operator.

fn add(self, rhs: &ExactNum) -> ExactNum

Performs the + operation.

impl Add<ExactNum> for &ExactNum

type Output = ExactNum

The resulting type after applying the + operator.

fn add(self, rhs: ExactNum) -> ExactNum

Performs the + operation.

impl Binary for ExactNum

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the number. The implementation is not available in no_std environment.

impl Clone for ExactNum

fn clone(&self) -> ExactNum

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExactNum

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for ExactNum

fn default() -> ExactNum

Returns the “default value” for a type.

impl Display for ExactNum

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the number. The implementation is not available in no_std environment.

impl Div for ExactNum

type Output = ExactNum

The resulting type after applying the / operator.

fn div(self, rhs: ExactNum) -> ExactNum

Performs the / operation.

impl Div<&ExactNum> for &ExactNum

type Output = ExactNum

The resulting type after applying the / operator.

fn div(self, rhs: &ExactNum) -> ExactNum

Performs the / operation.

impl Div<&ExactNum> for ExactNum

type Output = ExactNum

The resulting type after applying the / operator.

fn div(self, rhs: &ExactNum) -> ExactNum

Performs the / operation.

impl Div<ExactNum> for &ExactNum

type Output = ExactNum

The resulting type after applying the / operator.

fn div(self, rhs: ExactNum) -> ExactNum

Performs the / operation.

impl Eq for ExactNum

impl From<ExactNumNumber> for ExactNum

fn from(x: ExactNumNumber) -> ExactNum

Converts to this type from the input type.

impl From<i8> for ExactNum

fn from(v: i8) -> ExactNum

Converts to this type from the input type.

impl From<i16> for ExactNum

fn from(v: i16) -> ExactNum

Converts to this type from the input type.

impl From<i32> for ExactNum

fn from(v: i32) -> ExactNum

Converts to this type from the input type.

impl From<i64> for ExactNum

fn from(v: i64) -> ExactNum

Converts to this type from the input type.

impl From<i128> for ExactNum

fn from(v: i128) -> ExactNum

Converts to this type from the input type.

impl From<u8> for ExactNum

fn from(v: u8) -> ExactNum

Converts to this type from the input type.

impl From<u16> for ExactNum

fn from(v: u16) -> ExactNum

Converts to this type from the input type.

impl From<u32> for ExactNum

fn from(v: u32) -> ExactNum

Converts to this type from the input type.

impl From<u64> for ExactNum

fn from(v: u64) -> ExactNum

Converts to this type from the input type.

impl From<u128> for ExactNum

fn from(v: u128) -> ExactNum

Converts to this type from the input type.

impl FromExt<&str> for ExactNum

fn from_ext(v: &str, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Converts v to ExactNum with precision p using rounding mode rm.

impl<T> FromExt<T> for ExactNum

where ExactNum: From<T>,

fn from_ext(v: T, p: usize, rm: RoundingMode, _cc: &mut Consts) -> ExactNum

Converts v to ExactNum with precision p using rounding mode rm.

impl FromStr for ExactNum

Available on crate feature std only.

fn from_str(src: &str) -> Result<ExactNum, <ExactNum as FromStr>::Err>

Returns parsed number or NAN in case of error. The implementation is not available in no_std environment.

type Err = Error

The associated error which can be returned from parsing.

impl LowerExp for ExactNum

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the number. The implementation is not available in no_std environment.

impl LowerHex for ExactNum

Available on crate feature std only.

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Mul for ExactNum

type Output = ExactNum

The resulting type after applying the * operator.

fn mul(self, rhs: ExactNum) -> ExactNum

Performs the * operation.

impl Mul<&ExactNum> for &ExactNum

type Output = ExactNum

The resulting type after applying the * operator.

fn mul(self, rhs: &ExactNum) -> ExactNum

Performs the * operation.

impl Mul<&ExactNum> for ExactNum

type Output = ExactNum

The resulting type after applying the * operator.

fn mul(self, rhs: &ExactNum) -> ExactNum

Performs the * operation.

impl Mul<ExactNum> for &ExactNum

type Output = ExactNum

The resulting type after applying the * operator.

fn mul(self, rhs: ExactNum) -> ExactNum

Performs the * operation.

impl Neg for ExactNum

type Output = ExactNum

The resulting type after applying the - operator.

fn neg(self) -> <ExactNum as Neg>::Output

Performs the unary - operation.

impl Neg for &ExactNum

type Output = ExactNum

The resulting type after applying the - operator.

fn neg(self) -> <&ExactNum as Neg>::Output

Performs the unary - operation.

impl Octal for ExactNum

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the number. The implementation is not available in no_std environment.

impl PartialEq for ExactNum

fn eq(&self, other: &ExactNum) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'a> PartialEq<&'a ExactNum> for ExactNum

fn eq(&self, other: &&'a ExactNum) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for ExactNum

fn partial_cmp(&self, other: &ExactNum) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a> PartialOrd<&'a ExactNum> for ExactNum

fn partial_cmp(&self, other: &&'a ExactNum) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub for ExactNum

type Output = ExactNum

The resulting type after applying the - operator.

fn sub(self, rhs: ExactNum) -> ExactNum

Performs the - operation.

impl Sub<&ExactNum> for &ExactNum

type Output = ExactNum

The resulting type after applying the - operator.

fn sub(self, rhs: &ExactNum) -> ExactNum

Performs the - operation.

impl Sub<&ExactNum> for ExactNum

type Output = ExactNum

The resulting type after applying the - operator.

fn sub(self, rhs: &ExactNum) -> ExactNum

Performs the - operation.

impl Sub<ExactNum> for &ExactNum

type Output = ExactNum

The resulting type after applying the - operator.

fn sub(self, rhs: ExactNum) -> ExactNum

Performs the - operation.

impl UpperExp for ExactNum

Available on crate feature std only.

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl UpperHex for ExactNum

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the number. The implementation is not available in no_std environment.