Struct gmp_mpfr::Float [−] [src]

pub struct Float { /* fields omitted */ }

A multi-precision floating-point number. The precision has to be set during construction.

There are two versions of most methods:

The first rounds the returned or stored Float to the nearest representable value.
The second applies the specified rounding method, and returns the rounding direction:
- Ordering::Less if the returned/stored Float is less than the exact result,
- Ordering::Equal if the returned/stored Float is equal to the exact result,
- Ordering::Greater if the returned/stored Float is greater than the exact result,

Methods

`impl Float`
[src]

`fn new_with_prec(prec: Prec) -> Float`

Create a new floating-point number with the specified precision and with value 0.

`fn prec(&self) -> Prec`

Returns the precision of self.

`fn set_prec(&mut self, prec: Prec)`

Sets the precision of self exactly, rounding to the nearest.

`fn set_prec_round(&mut self, prec: Prec, round: Round)`

Sets the precision of self exactly, applying the specified rounding method.

`fn to_integer(&self) -> Integer`

Converts to an integer, rounding to the nearest.

`fn to_integer_round(&self, round: Round) -> (Integer, Ordering)`

Converts to an integer, applying the specified rounding method.

`fn to_integer_exp(&self) -> Option<(Integer, Exp)>`

If self is a finite number, returns an integer and exponent such that self is exactly equal to the integer multiplied by two raised to the power of the exponent.

Examples

use gmp_mpfr::{Assign, Float, FromPrec, Special};

let mut float = Float::from_prec(6.5, 16);
// 6.5 in binary is 110.1
// Since the precision is 16 bits, this becomes
// 1101_0000_0000_0000 times two to the power of -12
let (int, exp) = float.to_integer_exp().unwrap();
assert!(int == 0b1101_0000_0000_0000);
assert!(exp == -13);

float.assign(0);
let (zero, _) = float.to_integer_exp().unwrap();
assert!(zero == 0);

float.assign(Special::Infinity);
assert!(float.to_integer_exp().is_none());

`fn to_u32(&self) -> Option<u32>`

Converts to a u32, rounding to the nearest. If the value is too small or too large for the target type, the minimum or maximum value allowed is returned. If the value is a NaN, None is returned.

`fn to_i32(&self) -> Option<i32>`

Converts to an i32, rounding to the nearest. If the value is too small or too large for the target type, the minimum or maximum value allowed is returned. If the value is a NaN, None is returned.

`fn to_f64(&self) -> f64`

Converts to an f64, rounding to the nearest. If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.

`fn to_f32(&self) -> f32`

Converts to an f32, rounding to the nearest. If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.

`fn to_u32_round(&self, round: Round) -> Option<u32>`

Converts to a u32, applying the specified rounding method. If the value is too small or too large for the target type, the minimum or maximum value allowed is returned. If the value is a NaN, None is returned.

`fn to_i32_round(&self, round: Round) -> Option<i32>`

Converts to an i32, applying the specified rounding method. If the value is too small or too large for the target type, the minimum or maximum value allowed is returned. If the value is a NaN, None is returned.

`fn to_f64_round(&self, round: Round) -> f64`

Converts to an f64, applying the specified rounding method. If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.

`fn to_f32_round(&self, round: Round) -> f32`

Converts to an f32, applying the specified rounding method. If the value is too small or too large for the target type, the minimum or maximum value allowed is returned.

`fn square(&mut self) -> &mut Float`

Computes the square, rounding to the nearest.

`fn square_round(&mut self, round: Round) -> Ordering`

Computes the square, applying the specified rounding method.

`fn sqrt(&mut self) -> &mut Float`

Computes the square root, rounding to the nearest.

`fn sqrt_round(&mut self, round: Round) -> Ordering`

Computes the square root, applying the specified rounding method.

`fn set_sqrt(&mut self, u: u32) -> &mut Float`

Sets self to the square root of u, rounding to the nearest.

`fn set_sqrt_round(&mut self, u: u32, round: Round) -> Ordering`

Sets self to the square root of u, applying the specified rounding method.

`fn recip_sqrt(&mut self) -> &mut Float`

Computes the reciprocal square root, rounding to the nearest.

`fn recip_sqrt_round(&mut self, round: Round) -> Ordering`

Computes the reciprocal square root, applying the specified rounding method.

`fn cbrt(&mut self) -> &mut Float`

Computes the cube root, rounding to the nearest.

`fn cbrt_round(&mut self, round: Round) -> Ordering`

Computes the cube root, applying the specified rounding method.

`fn root(&mut self, k: u32) -> &mut Float`

Computes the kth root, rounding to the nearest.

`fn root_round(&mut self, k: u32, round: Round) -> Ordering`

Computes the kth root, applying the specified rounding method.

`fn abs(&mut self) -> &mut Float`

Computes the absolute value, rounding to the nearest.

`fn abs_round(&mut self, round: Round) -> Ordering`

Computes the absolute value, applying the specified rounding method.

`fn recip(&mut self) -> &mut Float`

Computes the reciprocal, rounding to the nearest.

`fn recip_round(&mut self, round: Round) -> Ordering`

Computes the reciprocal, applying the specified rounding method.

`fn dim(&mut self, other: &Float) -> &mut Float`

Computes the positive difference between self and other, rounding to the nearest.

`fn dim_round(&mut self, other: &Float, round: Round) -> Ordering`

Computes the arithmetic-geometric mean of self and other, applying the specified rounding method.

`fn cmp_abs(&self, other: &Float) -> Option<Ordering>`

Compares the absolute values of self and other.

`fn ln(&mut self) -> &mut Float`

Computes the natural logarithm, rounding to the nearest.

`fn ln_round(&mut self, round: Round) -> Ordering`

Computes the natural logarithm, applying the specified rounding method.

`fn log2(&mut self) -> &mut Float`

Computes the logarithm to base 2, rounding to the nearest.

`fn log2_round(&mut self, round: Round) -> Ordering`

Computes the logarithm to base 2, applying the specified rounding method.

`fn log10(&mut self) -> &mut Float`

Computes the logarithm to base 10, rounding to the nearest.

`fn log10_round(&mut self, round: Round) -> Ordering`

Computes the logarithm to base 10, applying the specified rounding method.

`fn exp(&mut self) -> &mut Float`

Computes the exponential, rounding to the nearest.

`fn exp_round(&mut self, round: Round) -> Ordering`

Computes the exponential, applying the specified rounding method.

`fn exp2(&mut self) -> &mut Float`

Computes 2 to the power of self, rounding to the nearest.

`fn exp2_round(&mut self, round: Round) -> Ordering`

Computes 2 to the power of self, applying the specified rounding method.

`fn exp10(&mut self) -> &mut Float`

Computes 10 to the power of self, rounding to the nearest.

`fn exp10_round(&mut self, round: Round) -> Ordering`

Computes 10 to the power of self, applying the specified rounding method.

`fn cos(&mut self) -> &mut Float`

Computes the cosine, rounding to the nearest.

`fn cos_round(&mut self, round: Round) -> Ordering`

Computes the cosine, applying the specified rounding method.

`fn sin(&mut self) -> &mut Float`

Computes the sine, rounding to the nearest.

`fn sin_round(&mut self, round: Round) -> Ordering`

Computes the sine, applying the specified rounding method.

`fn tan(&mut self) -> &mut Float`

Computes the tangent, rounding to the nearest.

`fn tan_round(&mut self, round: Round) -> Ordering`

Computes the tangent, applying the specified rounding method.

`fn sin_cos(&mut self, buf: &mut Float)`

Computes the sine and cosine, rounding to the nearest. The sine is stored in self and keeps its precision, while the cosine is stored in buf keeping its precision.

`fn sin_cos_round(&mut self, buf: &mut Float, round: Round) -> (Ordering, Ordering)`

Computes the sine and cosine, applying the specified rounding method. The sine is stored in self and keeps its precision, while the cosine is stored in buf keeping its precision.

`fn sec(&mut self) -> &mut Float`

Computes the secant, rounding to the nearest.

`fn sec_round(&mut self, round: Round) -> Ordering`

Computes the secant, applying the specified rounding method.

`fn csc(&mut self) -> &mut Float`

Computes the cosecant, rounding to the nearest.

`fn csc_round(&mut self, round: Round) -> Ordering`

Computes the cosecant, applying the specified rounding method.

`fn cot(&mut self) -> &mut Float`

Computes the cotangent, rounding to the nearest.

`fn cot_round(&mut self, round: Round) -> Ordering`

Computes the cotangent, applying the specified rounding method.

`fn acos(&mut self) -> &mut Float`

Computes the arc-cosine, rounding to the nearest.

`fn acos_round(&mut self, round: Round) -> Ordering`

Computes the arc-cosine, applying the specified rounding method.

`fn asin(&mut self) -> &mut Float`

Computes the arc-sine, rounding to the nearest.

`fn asin_round(&mut self, round: Round) -> Ordering`

Computes the arc-sine, applying the specified rounding method.

`fn atan(&mut self) -> &mut Float`

Computes the arc-tangent, rounding to the nearest.

`fn atan_round(&mut self, round: Round) -> Ordering`

Computes the arc-tangent, applying the specified rounding method.

`fn atan2(&mut self, other: &Float) -> &mut Float`

Computes the arc-tangent2 of self and other, rounding to the nearest.

This is similar to the arc-tangent of self / other, except in the cases when either self or other or both are zero or infinity.

`fn atan2_round(&mut self, other: &Float, round: Round) -> Ordering`

Computes the arc-tangent2 of self and other, applying the specified rounding method.

This is similar to the arc-tangent of self / other, except in the cases when either self or other or both are zero or infinity.

`fn cosh(&mut self) -> &mut Float`

Computes the hyperbolic cosine, rounding to the nearest.

`fn cosh_round(&mut self, round: Round) -> Ordering`

Computes the hyperbolic cosine, applying the specified rounding method.

`fn sinh(&mut self) -> &mut Float`

Computes the hyperbolic sine, rounding to the nearest.

`fn sinh_round(&mut self, round: Round) -> Ordering`

Computes the hyperbolic sine, applying the specified rounding method.

`fn tanh(&mut self) -> &mut Float`

Computes the hyperbolic tangent, rounding to the nearest.

`fn tanh_round(&mut self, round: Round) -> Ordering`

Computes the hyperbolic tangent, applying the specified rounding method.

`fn sinh_cosh(&mut self, buf: &mut Float)`

Computes the hyperbolic sine and cosine, rounding to the nearest. The sine is stored in self and keeps its precision, while the cosine is stored in buf keeping its precision.

`fn sinh_cosh_round(&mut self, buf: &mut Float, round: Round) -> (Ordering, Ordering)`

Computes the hyperbolic sine and cosine, applying the specified rounding method. The sine is stored in self and keeps its precision, while the cosine is stored in buf keeping its precision.

`fn sech(&mut self) -> &mut Float`

Computes the hyperbolic secant, rounding to the nearest.

`fn sech_round(&mut self, round: Round) -> Ordering`

Computes the hyperbolic secant, applying the specified rounding method.

`fn csch(&mut self) -> &mut Float`

Computes the hyperbolic cosecant, rounding to the nearest.

`fn csch_round(&mut self, round: Round) -> Ordering`

Computes the hyperbolic cosecant, applying the specified rounding method.

`fn coth(&mut self) -> &mut Float`

Computes the hyperbolic cotangent, rounding to the nearest.

`fn coth_round(&mut self, round: Round) -> Ordering`

Computes the hyperbolic cotangent, applying the specified rounding method.

`fn acosh(&mut self) -> &mut Float`

Computes the inverse hyperbolic cosine, rounding to the nearest.

`fn acosh_round(&mut self, round: Round) -> Ordering`

Computes the inverse hyperbolic cosine, applying the specified rounding method.

`fn asinh(&mut self) -> &mut Float`

Computes the inverse hyperbolic sine, rounding to the nearest.

`fn asinh_round(&mut self, round: Round) -> Ordering`

Computes the inverse hyperbolic sine, applying the specified rounding method.

`fn atanh(&mut self) -> &mut Float`

Computes the inverse hyperbolic tangent, rounding to the nearest.

`fn atanh_round(&mut self, round: Round) -> Ordering`

Computes the inverse hyperbolic tangent, applying the specified rounding method.

`fn set_factorial(&mut self, u: u32) -> &mut Float`

Sets self to the factorial of u, rounding to the nearest.

`fn set_factorial_round(&mut self, u: u32, round: Round) -> Ordering`

Sets self to the factorial of u, applying the specified rounding method.

`fn ln_1p(&mut self) -> &mut Float`

Computes the natural logarithm of one plus self, rounding to the nearest.

`fn ln_1p_round(&mut self, round: Round) -> Ordering`

Computes the natural logarithm of one plus self, applying the specified rounding method.

`fn exp_m1(&mut self) -> &mut Float`

Subtracts one from the exponential of self, rounding to the nearest.

`fn exp_m1_round(&mut self, round: Round) -> Ordering`

Subtracts one from the exponential of self, applying the specified rounding method.

`fn eint(&mut self) -> &mut Float`

Computes the exponential integral of self, rounding to the nearest.

`fn eint_round(&mut self, round: Round) -> Ordering`

Computes the exponential integral of self, applying the specified rounding method.

`fn li2(&mut self) -> &mut Float`

Computes the real part of the dilogarithm of self, rounding to the nearest.

`fn li2_round(&mut self, round: Round) -> Ordering`

Computes the real part of the dilogarithm of self, applying the specified rounding method.

`fn gamma(&mut self) -> &mut Float`

Computes the value of the Gamma function on self, rounding to the nearest.

`fn gamma_round(&mut self, round: Round) -> Ordering`

Computes the value of the Gamma function on self, applying the specified rounding method.

`fn ln_gamma(&mut self) -> &mut Float`

Computes the logarithm of the Gamma function on self, rounding to the nearest.

`fn ln_gamma_round(&mut self, round: Round) -> Ordering`

Computes the logarithm of the Gamma function on self, applying the specified rounding method.

`fn lgamma(&mut self) -> Ordering`

Computes the logarithm of the absolute value of the Gamma function on self, rounding to the nearest. Returns Ordering::Less if the Gamma function is negative, or Ordering::Greater if the Gamma function is positive.

`fn lgamma_round(&mut self, round: Round) -> (Ordering, Ordering)`

Computes the logarithm of the absolute value of the Gamma function on self, applying the specified rounding method. The returned tuple contains:

The logarithm of the absolute value of the Gamma function.
The rounding direction.

`fn digamma(&mut self) -> &mut Float`

Computes the value of the Digamma function on self, rounding to the nearest.

`fn digamma_round(&mut self, round: Round) -> Ordering`

Computes the value of the Digamma function on self, applying the specified rounding method.

`fn zeta(&mut self) -> &mut Float`

Computes the value of the Riemann Zeta function on self, rounding to the nearest.

`fn zeta_round(&mut self, round: Round) -> Ordering`

Computes the value of the Riemann Zeta function on self, applying the specified rounding method.

`fn set_zeta(&mut self, u: u32) -> &mut Float`

Sets self to the value of the Riemann Zeta function on u, rounding to the nearest.

`fn set_zeta_round(&mut self, u: u32, round: Round) -> Ordering`

Sets self to the value of the Riemann Zeta function on u, applying the specified rounding method.

`fn erf(&mut self) -> &mut Float`

Computes the value of the error function on self, rounding to the nearest.

`fn erf_round(&mut self, round: Round) -> Ordering`

Computes the value of the error function on self, applying the specified rounding method.

`fn erfc(&mut self) -> &mut Float`

Computes the value of the complementary error function on self, rounding to the nearest.

`fn erfc_round(&mut self, round: Round) -> Ordering`

Computes the value of the complementary error function on self, applying the specified rounding method.

`fn j0(&mut self) -> &mut Float`

Computes the value of the first kind Bessel function of order 0 on self, rounding to the nearest.

`fn j0_round(&mut self, round: Round) -> Ordering`

Computes the value of the first kind Bessel function of order 0 on self, applying the specified rounding method.

`fn j1(&mut self) -> &mut Float`

Computes the value of the first kind Bessel function of order 1 on self, rounding to the nearest.

`fn j1_round(&mut self, round: Round) -> Ordering`

Computes the value of the first kind Bessel function of order 1 on self, applying the specified rounding method.

`fn jn(&mut self, n: i32) -> &mut Float`

Computes the value of the first kind Bessel function of order n on self, rounding to the nearest.

`fn jn_round(&mut self, n: i32, round: Round) -> Ordering`

Computes the value of the first kind Bessel function of order n on self, applying the specified rounding method.

`fn y0(&mut self) -> &mut Float`

Computes the value of the second kind Bessel function of order 0 on self, rounding to the nearest.

`fn y0_round(&mut self, round: Round) -> Ordering`

Computes the value of the second kind Bessel function of order 0 on self, applying the specified rounding method.

`fn y1(&mut self) -> &mut Float`

Computes the value of the second kind Bessel function of order 1 on self, rounding to the nearest.

`fn y1_round(&mut self, round: Round) -> Ordering`

Computes the value of the second kind Bessel function of order 1 on self, applying the specified rounding method.

`fn yn(&mut self, n: i32) -> &mut Float`

Computes the value of the second kind Bessel function of order n on self, rounding to the nearest.

`fn yn_round(&mut self, n: i32, round: Round) -> Ordering`

Computes the value of the second kind Bessel function of order n on self, applying the specified rounding method.

`fn agm(&mut self, other: &Float) -> &mut Float`

Computes the arithmetic-geometric mean of self and other, rounding to the nearest.

`fn agm_round(&mut self, other: &Float, round: Round) -> Ordering`

Computes the arithmetic-geometric mean of self and other, applying the specified rounding method.

`fn hypot(&mut self, other: &Float) -> &mut Float`

Computes the Euclidean norm of self and other, rounding to the nearest.

`fn hypot_round(&mut self, other: &Float, round: Round) -> Ordering`

Computes the Euclidean norm of self and other, applying the specified rounding method.

`fn ai(&mut self) -> &mut Float`

Computes the value of the Airy function Ai on self, rounding to the nearest.

`fn ai_round(&mut self, round: Round) -> Ordering`

Computes the value of the Airy function Ai on self, applying the specified rounding method.

`fn ceil(&mut self) -> &mut Float`

Rounds up to the next higher integer, then rounds to the nearest. This function performs double rounding.

`fn ceil_round(&mut self, round: Round) -> Ordering`

Rounds up to the next higher integer, then applies the specified rounding method. This function performs double rounding.

`fn floor(&mut self) -> &mut Float`

Rounds down to the next lower integer, then rounds to the nearest. This function performs double rounding.

`fn floor_round(&mut self, round: Round) -> Ordering`

Rounds down to the next lower integer, then applies the specified rounding method. This function performs double rounding.

`fn round(&mut self) -> &mut Float`

Rounds to the nearest integer, rounding half-way cases away from zero, then rounds to the nearest representable value. This function performs double rounding.

`fn round_round(&mut self, round: Round) -> Ordering`

Rounds to the next lower integer, then applies the specified rounding method to get a representable value. This function performs double rounding.

`fn trunc(&mut self) -> &mut Float`

Rounds to the next integer towards zero, then rounds to the nearest. This function performs double rounding.

`fn trunc_round(&mut self, round: Round) -> Ordering`

Rounds to the next integer towards zero, then applies the specified rounding method. This function performs double rounding.

`fn is_integer(&self) -> bool`

Returns true if self is an integer.

`fn is_nan(&self) -> bool`

Returns true if self is not a number.

`fn is_infinite(&self) -> bool`

Returns true if self is plus or minus infinity.

`fn is_finite(&self) -> bool`

Returns true if self is a finite number, that is neither NaN nor infinity.

`fn is_zero(&self) -> bool`

Returns true if self is plus or minus zero.

`fn is_normal(&self) -> bool`

Returns true if self is a normal number, that is neither NaN, nor infinity, nor zero. Note that Float cannot be subnormal.

`fn sign(&self) -> Ordering`

Returns Less if self is less than zero, Greater if self is greater than zero, or Equal if self is equal to zero.

`fn get_exp(&self) -> Option<Exp>`

Returns the exponent of self if self is a normal number, otherwise None. The significand is assumed to be in the range [0.5,1).

`fn get_sign(&self) -> bool`

Returns the sign bit, that is true if the number is negative.

`fn subnormalize(&mut self) -> &mut Float`

Emulate subnormal numbers, rounding to the nearest. This method has no effect if the value is not in the subnormal range.

`fn subnormalize_round(&mut self, prev_rounding: Ordering, round: Round) -> Ordering`

Emulate subnormal numbers, applying the specified rounding method. This method simply propagates prev_rounding if the value is not in the subnormal range.

`fn to_string_radix(&self, radix: i32) -> String`

Returns a string representation of self for the specified radix rounding to the nearest. If radix is > 36, 'a' to 'z' represent digits 10 to 36, and 'A' to 'Z' represent digits 37 to 62. The exponent is encoded in decimal.

Panics

Panics if radix is less than 2 or greater than 62.

`fn to_string_radix_round(&self, radix: i32, round: Round) -> String`

Returns a string representation of self for the specified radix applying the specified rounding method. If radix is > 36, 'a' to 'z' represent digits 10 to 36, and 'A' to 'Z' represent digits 37 to 62. The exponent is encoded in decimal.

Panics

Panics if radix is less than 2 or greater than 62.

Trait Implementations

`impl Drop for Float`
[src]

`fn drop(&mut self)`

A method called when the value goes out of scope. Read more

`impl Clone for Float`
[src]

`fn clone(&self) -> Float`

Returns a copy of the value. Read more

`fn clone_from(&mut self, source: &Float)`

Performs copy-assignment from source. Read more

`impl FromPrec<Constant> for Float`
[src]

`fn from_prec(t: Constant, prec: Prec) -> Float`

Constructs a Float from a Constant with the specified precision, rounding to the nearest.

`impl FromPrecRound<Constant> for Float`
[src]

`fn from_prec_round(t: Constant, prec: Prec, round: Round) -> (Float, Ordering)`

Constructs a Float from a Constant with the specified precision, applying the specified rounding method.

`impl FromPrec<Special> for Float`
[src]

`fn from_prec(special: Special, prec: Prec) -> Float`

Constructs a Float from a Special with the specified precision.

`impl FromPrec<Integer> for Float`
[src]

`fn from_prec(t: Integer, prec: Prec) -> Float`

Constructs a Float from an Integer with the specified precision, rounding to the nearest.

`impl FromPrecRound<Integer> for Float`
[src]

`fn from_prec_round(t: Integer, prec: Prec, round: Round) -> (Float, Ordering)`

Constructs a Float from an Integer with the specified precision, applying the specified rounding method.

`impl FromPrec<Rational> for Float`
[src]

`fn from_prec(t: Rational, prec: Prec) -> Float`

Constructs a Float from a Rational with the specified precision, rounding to the nearest.

`impl FromPrecRound<Rational> for Float`
[src]

`fn from_prec_round(t: Rational, prec: Prec, round: Round) -> (Float, Ordering)`

Constructs a Float from a Rational with the specified precision, applying the specified rounding method.

`impl FromPrec<Float> for Float`
[src]

`fn from_prec(t: Float, prec: Prec) -> Float`

Constructs a Float from another Float with the specified precision, rounding to the nearest.

`impl FromPrecRound<Float> for Float`
[src]

`fn from_prec_round(t: Float, prec: Prec, round: Round) -> (Float, Ordering)`

Constructs a Float from another Float with the specified precision, applying the specified rounding method.

`impl<'a> FromPrec<&'a Integer> for Float`
[src]

`fn from_prec(t: &'a Integer, prec: Prec) -> Float`

Constructs a Float from an Integer with the specified precision, rounding to the nearest.

`impl<'a> FromPrecRound<&'a Integer> for Float`
[src]

`fn from_prec_round(t: &'a Integer, prec: Prec, round: Round) -> (Float, Ordering)`

Constructs a Float from an Integer with the specified precision, applying the specified rounding method.

`impl<'a> FromPrec<&'a Rational> for Float`
[src]

`fn from_prec(t: &'a Rational, prec: Prec) -> Float`

Constructs a Float from a Rational with the specified precision, rounding to the nearest.

`impl<'a> FromPrecRound<&'a Rational> for Float`
[src]

`fn from_prec_round(t: &'a Rational, prec: Prec, round: Round) -> (Float, Ordering)`

Constructs a Float from a Rational with the specified precision, applying the specified rounding method.

`impl<'a> FromPrec<&'a Float> for Float`
[src]

`fn from_prec(t: &'a Float, prec: Prec) -> Float`

Constructs a Float from another `Float with the specified precision, rounding to the nearest.

`impl<'a> FromPrecRound<&'a Float> for Float`
[src]

`fn from_prec_round(t: &'a Float, prec: Prec, round: Round) -> (Float, Ordering)`

Constructs a Float from another `Float with the specified precision, applying the specified rounding method.

`impl FromPrec<u32> for Float`
[src]

`fn from_prec(t: u32, prec: Prec) -> Float`

Constructs a Float from a u32 with the specified precision, rounding to the nearest.

`impl FromPrecRound<u32> for Float`
[src]

`fn from_prec_round(t: u32, prec: Prec, round: Round) -> (Float, Ordering)`

Constructs a Float from a u32 with the specified precision, applying the specified rounding method.

`impl FromPrec<i32> for Float`
[src]

`fn from_prec(t: i32, prec: Prec) -> Float`

Constructs a Float from an i32 with the specified precision, rounding to the nearest.

`impl FromPrecRound<i32> for Float`
[src]

`fn from_prec_round(t: i32, prec: Prec, round: Round) -> (Float, Ordering)`

Constructs a Float from an i32 with the specified precision, applying the specified rounding method.

`impl FromPrec<f64> for Float`
[src]

`fn from_prec(t: f64, prec: Prec) -> Float`

Constructs a Float from an f64 with the specified precision, rounding to the nearest.

`impl FromPrecRound<f64> for Float`
[src]

`fn from_prec_round(t: f64, prec: Prec, round: Round) -> (Float, Ordering)`

Constructs a Float from an f64 with the specified precision, applying the specified rounding method.

`impl FromPrec<f32> for Float`
[src]

`fn from_prec(t: f32, prec: Prec) -> Float`

Constructs a Float from an f32 with the specified precision, rounding to the nearest.

`impl FromPrecRound<f32> for Float`
[src]

`fn from_prec_round(t: f32, prec: Prec, round: Round) -> (Float, Ordering)`

Constructs a Float from an f32 with the specified precision, applying the specified rounding method.

`impl Assign<Constant> for Float`
[src]

`fn assign(&mut self, other: Constant)`

Assigns from a Constant and rounds to the nearest.

`impl AssignRound<Constant> for Float`
[src]

`fn assign_round(&mut self, other: Constant, round: Round) -> Ordering`

Assigns from a Constant and applies the specified rounding method.

`impl Assign<Special> for Float`
[src]

`fn assign(&mut self, other: Special)`

Assigns from a Special.

`impl<'a> Assign<&'a Float> for Float`
[src]

`fn assign(&mut self, other: &'a Float)`

Assigns from another Float and rounds to the nearest.

`impl<'a> AssignRound<&'a Float> for Float`
[src]

`fn assign_round(&mut self, other: &'a Float, round: Round) -> Ordering`

Assigns from another Float and applies the specified rounding method.

`impl Assign<Float> for Float`
[src]

`fn assign(&mut self, other: Float)`

Assigns from another Float and rounds to the nearest.

`impl AssignRound<Float> for Float`
[src]

`fn assign_round(&mut self, other: Float, round: Round) -> Ordering`

Assigns from another Float and applies the specified rounding method.

`impl<'a> Assign<&'a Integer> for Float`
[src]

`fn assign(&mut self, other: &'a Integer)`

Assigns from an Integer and rounds to the nearest.

`impl<'a> AssignRound<&'a Integer> for Float`
[src]

`fn assign_round(&mut self, other: &'a Integer, round: Round) -> Ordering`

Assigns from an Integer and applies the specified rounding method.

`impl Assign<Integer> for Float`
[src]

`fn assign(&mut self, other: Integer)`

Assigns from an Integer and rounds to the nearest.

`impl AssignRound<Integer> for Float`
[src]

`fn assign_round(&mut self, other: Integer, round: Round) -> Ordering`

Assigns from an Integer and applies the specified rounding method.

`impl<'a> Assign<&'a Rational> for Float`
[src]

`fn assign(&mut self, other: &'a Rational)`

Assigns from a Rational and rounds to the nearest.

`impl<'a> AssignRound<&'a Rational> for Float`
[src]

`fn assign_round(&mut self, other: &'a Rational, round: Round) -> Ordering`

Assigns from a Rational and applies the specified rounding method.

`impl Assign<Rational> for Float`
[src]

`fn assign(&mut self, other: Rational)`

Assigns from a Rational and rounds to the nearest.

`impl AssignRound<Rational> for Float`
[src]

`fn assign_round(&mut self, other: Rational, round: Round) -> Ordering`

Assigns from a Rational and applies the specified rounding method.

Struct gmp_mpfr::Float [−] [src]

Methods

impl Float[src]

fn new_with_prec(prec: Prec) -> Float

fn prec(&self) -> Prec

fn set_prec(&mut self, prec: Prec)

fn set_prec_round(&mut self, prec: Prec, round: Round)

fn to_integer(&self) -> Integer

fn to_integer_round(&self, round: Round) -> (Integer, Ordering)

fn to_integer_exp(&self) -> Option<(Integer, Exp)>

Examples

fn to_u32(&self) -> Option<u32>

fn to_i32(&self) -> Option<i32>

fn to_f64(&self) -> f64

fn to_f32(&self) -> f32

fn to_u32_round(&self, round: Round) -> Option<u32>

fn to_i32_round(&self, round: Round) -> Option<i32>

fn to_f64_round(&self, round: Round) -> f64

fn to_f32_round(&self, round: Round) -> f32

fn square(&mut self) -> &mut Float

fn square_round(&mut self, round: Round) -> Ordering

fn sqrt(&mut self) -> &mut Float

fn sqrt_round(&mut self, round: Round) -> Ordering

fn set_sqrt(&mut self, u: u32) -> &mut Float

fn set_sqrt_round(&mut self, u: u32, round: Round) -> Ordering

fn recip_sqrt(&mut self) -> &mut Float

fn recip_sqrt_round(&mut self, round: Round) -> Ordering

fn cbrt(&mut self) -> &mut Float

fn cbrt_round(&mut self, round: Round) -> Ordering

fn root(&mut self, k: u32) -> &mut Float

fn root_round(&mut self, k: u32, round: Round) -> Ordering

fn abs(&mut self) -> &mut Float

fn abs_round(&mut self, round: Round) -> Ordering

fn recip(&mut self) -> &mut Float

fn recip_round(&mut self, round: Round) -> Ordering

fn dim(&mut self, other: &Float) -> &mut Float

fn dim_round(&mut self, other: &Float, round: Round) -> Ordering

fn cmp_abs(&self, other: &Float) -> Option<Ordering>

fn ln(&mut self) -> &mut Float

fn ln_round(&mut self, round: Round) -> Ordering

fn log2(&mut self) -> &mut Float

fn log2_round(&mut self, round: Round) -> Ordering

fn log10(&mut self) -> &mut Float

fn log10_round(&mut self, round: Round) -> Ordering

fn exp(&mut self) -> &mut Float

fn exp_round(&mut self, round: Round) -> Ordering

fn exp2(&mut self) -> &mut Float

fn exp2_round(&mut self, round: Round) -> Ordering

fn exp10(&mut self) -> &mut Float

fn exp10_round(&mut self, round: Round) -> Ordering

fn cos(&mut self) -> &mut Float

fn cos_round(&mut self, round: Round) -> Ordering

fn sin(&mut self) -> &mut Float

fn sin_round(&mut self, round: Round) -> Ordering

fn tan(&mut self) -> &mut Float

fn tan_round(&mut self, round: Round) -> Ordering

fn sin_cos(&mut self, buf: &mut Float)

fn sin_cos_round(&mut self, buf: &mut Float, round: Round) -> (Ordering, Ordering)

fn sec(&mut self) -> &mut Float

fn sec_round(&mut self, round: Round) -> Ordering

fn csc(&mut self) -> &mut Float

fn csc_round(&mut self, round: Round) -> Ordering

fn cot(&mut self) -> &mut Float

fn cot_round(&mut self, round: Round) -> Ordering

fn acos(&mut self) -> &mut Float

fn acos_round(&mut self, round: Round) -> Ordering

fn asin(&mut self) -> &mut Float

fn asin_round(&mut self, round: Round) -> Ordering

fn atan(&mut self) -> &mut Float

fn atan_round(&mut self, round: Round) -> Ordering

fn atan2(&mut self, other: &Float) -> &mut Float

fn atan2_round(&mut self, other: &Float, round: Round) -> Ordering

fn cosh(&mut self) -> &mut Float

fn cosh_round(&mut self, round: Round) -> Ordering

fn sinh(&mut self) -> &mut Float

fn sinh_round(&mut self, round: Round) -> Ordering

fn tanh(&mut self) -> &mut Float

fn tanh_round(&mut self, round: Round) -> Ordering

fn sinh_cosh(&mut self, buf: &mut Float)

fn sinh_cosh_round(&mut self, buf: &mut Float, round: Round) -> (Ordering, Ordering)