Struct gmp_mpfr::Float [−] [src]

pub struct Float { /* fields omitted */ }

A multi-precision floating-point number.

The precision has to be set during construction.

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 nearest.

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

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

`fn from_constant(prec: Prec, constant: Constant) -> Float`

Constructs from a constant, rounding to the nearest.

`fn from_constant_round(prec: Prec, constant: Constant, round: Round) -> Float`

Constructs from a constant, applying the specified rounding method.

`fn assign_constant(&mut self, constant: Constant)`

Assigns the value of a constant, rounding to the nearest.

`fn assign_constant_round(&mut self, constant: Constant, round: Round)`

Assigns the value of a constant, applying the specified rounding method.

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

Constructs from a special value.

`fn assign_special(&mut self, special: Special)`

Assigns the value of a special value.

`fn to_integer(&self) -> Integer`

Converts to an integer, rounding to the nearest.

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

Converts to an integer, applying the specified rounding method.

`fn to_u64(&self) -> u64`

Converts to a u64, 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(&self) -> u32`

Converts to a u64, 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_i64(&self) -> i64`

Converts to an i64, 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_i32(&self) -> 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.

`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_u64_round(&self, round: Round) -> u64`

Converts to a u64, 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_u32_round(&self, round: Round) -> 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.

`fn to_i64_round(&self, round: Round) -> i64`

Converts to an i64, 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_i32_round(&self, round: Round) -> 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.

`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 sqrt(self) -> Float`

Computes the square root, rounding to the nearest.

`fn sqrt_round(self, round: Round) -> Float`

Computes the square root, applying the specified rounding method.

`fn rec_sqrt(self) -> Float`

Computes the reciprocal square root, rounding to the nearest.

`fn rec_sqrt_round(self, round: Round) -> Float`

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

`fn cbrt(self) -> Float`

Computes the cube root, rounding to the nearest.

`fn cbrt_round(self, round: Round) -> Float`

Computes the cube root, applying the specified rounding method.

`fn root(self, k: u64) -> Float`

Computes the kth root, rounding to the nearest.

`fn root_round(self, k: u64, round: Round) -> Float`

Computes the kth root, applying the specified rounding method.

`fn abs(self) -> Float`

Computes the absolute value, rounding to the nearest.

`fn abs_round(self, round: Round) -> Float`

Computes the absolute value, applying the specified rounding method.

`fn log(self) -> Float`

Computes the natural logarithm, rounding to the nearest.

`fn log_round(self, round: Round) -> Float`

Computes the natural logarithm, applying the specified rounding method.

`fn log2(self) -> Float`

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

`fn log2_round(self, round: Round) -> Float`

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

`fn log10(self) -> Float`

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

`fn log10_round(self, round: Round) -> Float`

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

`fn exp(self) -> Float`

Computes the exponential, rounding to the nearest.

`fn exp_round(self, round: Round) -> Float`

Computes the exponential, applying the specified rounding method.

`fn exp2(self) -> Float`

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

`fn exp2_round(self, round: Round) -> Float`

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

`fn exp10(self) -> Float`

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

`fn exp10_round(self, round: Round) -> Float`

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

`fn cos(self) -> Float`

Computes the cosine, rounding to the nearest.

`fn cos_round(self, round: Round) -> Float`

Computes the cosine, applying the specified rounding method.

`fn sin(self) -> Float`

Computes the sine, rounding to the nearest.

`fn sin_round(self, round: Round) -> Float`

Computes the sine, applying the specified rounding method.

`fn tan(self) -> Float`

Computes the tangent, rounding to the nearest.

`fn tan_round(self, round: Round) -> Float`

Computes the tangent, applying the specified rounding method.

`fn sin_cos(self) -> (Float, Float)`

Computes the sine and cosine, rounding to the nearest. Both returned values have the precision of self.

`fn sin_cos_round(self, round: Round) -> (Float, Float)`

Computes the sine and cosine, applying the specified rounding method. Both returned values have the precision of self.

`fn sin_cos_buf(self, buf: Float) -> (Float, Float)`

Computes the sine and cosine, rounding to the nearest. The value of buf is ignored, but its precision is not. The returned sine has the precision of self, while the returned cosine has the precison of buf.

`fn sin_cos_round_buf(self, buf: Float, round: Round) -> (Float, Float)`

Computes the sine and cosine, applying the specified rounding method. The value of buf is ignored, but its precision is not. The returned sine has the precision of self, while the returned cosine has the precison of buf.

`fn sec(self) -> Float`

Computes the secant, rounding to the nearest.

`fn sec_round(self, round: Round) -> Float`

Computes the secant, applying the specified rounding method.

`fn csc(self) -> Float`

Computes the cosecant, rounding to the nearest.

`fn csc_round(self, round: Round) -> Float`

Computes the cosecant, applying the specified rounding method.

`fn cot(self) -> Float`

Computes the cotangent, rounding to the nearest.

`fn cot_round(self, round: Round) -> Float`

Computes the cotangent, applying the specified rounding method.

`fn acos(self) -> Float`

Computes the arc-cosine, rounding to the nearest.

`fn acos_round(self, round: Round) -> Float`

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

`fn asin(self) -> Float`

Computes the arc-sine, rounding to the nearest.

`fn asin_round(self, round: Round) -> Float`

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

`fn atan(self) -> Float`

Computes the arc-tangent, rounding to the nearest.

`fn atan_round(self, round: Round) -> Float`

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

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

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

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

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

`fn cosh(self) -> Float`

Computes the hyperbolic cosine, rounding to the nearest.

`fn cosh_round(self, round: Round) -> Float`

Computes the hyperbolic cosine, applying the specified rounding method.

`fn sinh(self) -> Float`

Computes the hyperbolic sine, rounding to the nearest.

`fn sinh_round(self, round: Round) -> Float`

Computes the hyperbolic sine, applying the specified rounding method.

`fn tanh(self) -> Float`

Computes the hyperbolic tangent, rounding to the nearest.

`fn tanh_round(self, round: Round) -> Float`

Computes the hyperbolic tangent, applying the specified rounding method.

`fn sinh_cosh(self) -> (Float, Float)`

Computes the hyperbolic sine and cosine, rounding to the nearest. The returned hyperbolic sine has the precision of self, and the returned hyperbolic cosine has the precison of buf.

`fn sinh_cosh_round(self, round: Round) -> (Float, Float)`

Computes the hyperbolic sine and cosine, applying the specified rounding method. The returned hyperbolic sine has the precision of self, and the returned hyperbolic cosine has the precison of buf.

`fn sinh_cosh_buf(self, buf: Float) -> (Float, Float)`

Computes the hyperbolic sine and cosine, rounding to the nearest. The returned hyperbolic sine has the precision of self, and the returned hyperbolic cosine has the precison of buf.

`fn sinh_cosh_round_buf(self, buf: Float, round: Round) -> (Float, Float)`

Computes the hyperbolic sine and cosine, applying the specified rounding method. The returned hyperbolic sine has the precision of self, and the returned hyperbolic cosine has the precison of buf.

`fn sech(self) -> Float`

Computes the hyperbolic secant, rounding to the nearest.

`fn sech_round(self, round: Round) -> Float`

Computes the hyperbolic secant, applying the specified rounding method.

`fn csch(self) -> Float`

Computes the hyperbolic cosecant, rounding to the nearest.

`fn csch_round(self, round: Round) -> Float`

Computes the hyperbolic cosecant, applying the specified rounding method.

`fn coth(self) -> Float`

Computes the hyperbolic cotangent, rounding to the nearest.

`fn coth_round(self, round: Round) -> Float`

Computes the hyperbolic cotangent, applying the specified rounding method.

`fn acosh(self) -> Float`

Computes the inverse hyperbolic cosine, rounding to the nearest.

`fn acosh_round(self, round: Round) -> Float`

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

`fn asinh(self) -> Float`

Computes the inverse hyperbolic sine, rounding to the nearest.

`fn asinh_round(self, round: Round) -> Float`

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

`fn atanh(self) -> Float`

Computes the inverse hyperbolic tangent, rounding to the nearest.

`fn atanh_round(self, round: Round) -> Float`

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

`fn log1p(self) -> Float`

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

`fn log1p_round(self, round: Round) -> Float`

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

`fn expm1(self) -> Float`

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

`fn expm1_round(self, round: Round) -> Float`

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

`fn eint(self) -> Float`

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

`fn eint_round(self, round: Round) -> Float`

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

`fn li2(self) -> Float`

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

`fn li2_round(self, round: Round) -> Float`

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

`fn gamma(self) -> Float`

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

`fn gamma_round(self, round: Round) -> Float`

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

`fn lngamma(self) -> Float`

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

`fn lngamma_round(self, round: Round) -> Float`

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

`fn digamma(self) -> Float`

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

`fn digamma_round(self, round: Round) -> Float`

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

`fn zeta(self) -> Float`

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

`fn zeta_round(self, round: Round) -> Float`

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

`fn set_zeta(self, u: u64) -> Float`

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

`fn set_zeta_round(self, u: u64, round: Round) -> Float`

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

`fn erf(self) -> Float`

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

`fn erf_round(self, round: Round) -> Float`

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

`fn erfc(self) -> Float`

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

`fn erfc_round(self, round: Round) -> Float`

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

`fn j0(self) -> Float`

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

`fn j0_round(self, round: Round) -> Float`

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

`fn j1(self) -> Float`

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

`fn j1_round(self, round: Round) -> Float`

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

`fn jn(self, n: i64) -> Float`

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

`fn jn_round(self, n: i64, round: Round) -> Float`

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

`fn y0(self) -> Float`

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

`fn y0_round(self, round: Round) -> Float`

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

`fn y1(self) -> Float`

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

`fn y1_round(self, round: Round) -> Float`

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

`fn yn(self, n: i64) -> Float`

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

`fn yn_round(self, n: i64, round: Round) -> Float`

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

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

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

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

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

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

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

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

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

`fn ai(self) -> Float`

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

`fn ai_round(self, round: Round) -> Float`

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

`fn ceil(self) -> Float`

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

`fn ceil_round(self, round: Round) -> Float`

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

`fn floor(self) -> Float`

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

`fn floor_round(self, round: Round) -> Float`

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

`fn round(self) -> Float`

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

`fn round_round(self, round: Round) -> Float`

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

`fn trunc(self) -> Float`

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

`fn trunc_round(self, round: Round) -> Float`

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_inf(&self) -> bool`

Returns true if self is plus or minus infinity.

`fn is_number(&self) -> bool`

Returns true if self is an ordinary number, that is neither NaN nor infinity.

`fn is_zero(&self) -> bool`

Returns true if self is plus or minus zero.

`fn is_regular(&self) -> bool`

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

`fn sgn(&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 regular 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 to_string(&self, base: c_int, round: Round) -> String`

Returns a string representation of self for the specified base and applying the specified rounding method. If base 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 if base 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<Integer> for Float`
[src]

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

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

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

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