Struct malachite_float::Float

pub struct Float(/* private fields */);

A floating-point number.

Floats are currently experimental. They are missing many important functions. However, the functions that are currently implemented are thoroughly tested and documented, with the exception of string conversion functions. The current string conversions are incomplete and will be changed in the future to match MPFR’s behavior.

Floats are similar to the primitive floats defined by the IEEE 754 standard. They include NaN, positive and negative infinity, and positive and negative zero. There is only one NaN; there is no concept of a NaN payload.

All the finite Floats are dyadic rationals (rational numbers whose denominator is a power of 2). A finite Float consists of several fields:

• a sign, which denotes whether the Float is positive or negative;
• a significand, which is a Natural number whose value is equal to the Float’s absolute value multiplied by a power of 2;
• an exponent, which is one more than the floor of the base-2 logarithm of the Float’s absolute value;
• and finally, a precision, which is greater than zero and indicates the number of significant bits. It is common to think of a Float as an approximation to some real number, and the precision indicates how good the approximation is intended to be.

Floats inherit some odd behavior from the IEEE 754 standard regarding comparison. A NaN is not equal to any Float, including itself. Positive and negative zero compare as equal, despite being two distinct values. Additionally, (and this is not IEEE 754’s fault), Floats with different precisions compare as equal if they represent the same numeric value.

In many cases, the above behavior is unsatisfactory, so the ComparableFloat and ComparableFloat wrappers are provided. See their documentation for a description of their comparison behavior.

In documentation, we will use the ‘$=$’ sign to mean that two Floats are identical, writing things like $-\text{NaN}=\text{NaN}$ and $-(0.0) = -0.0$.

The Float type is designed to be very similar to the mpfr_t type in MPFR, and all Malachite functions produce exactly the same result as their counterparts in MPFR, unless otherwise noted.

Here are the structural difference between Float and mpfr_t:

• Float can only represent a single NaN value, with no sign or payload.
• Only finite, nonzero Floats have a significand, precision, and exponent. For other Floats, these concepts are undefined. In particular, unlike mpfr_t zeros, Float zeros do not have a precision.
• The types of mpfr_t components are configuration- and platform-dependent. The types of Float components are platform-independent, although the Limb type is configuration-dependent: it is u64 by default, but may be changed to u32 using the --32_bit_limbs compiler flag. The type of the exponent is always i64 and the type of the precision is always u64. The Limb type only affects functions that extract the raw significand. All other functions have the same behavior when compiled with either type.

Floats whose precision is 64 bits or less can be represented without any memory allocation. (Unless Malachite is compiled with 32_bit_limbs, in which case the limit is 32).

Implementations

impl Float

pub fn abs_negative_zero(self) -> Float

If self is negative zero, returns positive zero; otherwise, returns self, taking self by value.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::{ComparableFloat, Float};

assert_eq!(
    ComparableFloat(Float::NAN.abs_negative_zero()),
    ComparableFloat(Float::NAN)
);
assert_eq!(Float::INFINITY.abs_negative_zero(), Float::INFINITY);
assert_eq!(Float::NEGATIVE_INFINITY.abs_negative_zero(), Float::NEGATIVE_INFINITY);
assert_eq!(
    ComparableFloat(Float::ZERO.abs_negative_zero()),
    ComparableFloat(Float::ZERO)
);
assert_eq!(
    ComparableFloat(Float::NEGATIVE_ZERO.abs_negative_zero()),
    ComparableFloat(Float::ZERO)
);
assert_eq!(Float::ONE.abs_negative_zero(), Float::ONE);
assert_eq!(Float::NEGATIVE_ONE.abs_negative_zero(), Float::NEGATIVE_ONE);

pub fn abs_negative_zero_ref(&self) -> Float

If self is negative zero, returns positive zero; otherwise, returns self, taking self by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::{ComparableFloat, Float};

assert_eq!(
    ComparableFloat(Float::NAN.abs_negative_zero_ref()),
    ComparableFloat(Float::NAN)
);
assert_eq!(Float::INFINITY.abs_negative_zero_ref(), Float::INFINITY);
assert_eq!(Float::NEGATIVE_INFINITY.abs_negative_zero_ref(), Float::NEGATIVE_INFINITY);
assert_eq!(
    ComparableFloat(Float::ZERO.abs_negative_zero_ref()),
    ComparableFloat(Float::ZERO)
);
assert_eq!(
    ComparableFloat(Float::NEGATIVE_ZERO.abs_negative_zero_ref()),
    ComparableFloat(Float::ZERO)
);
assert_eq!(Float::ONE.abs_negative_zero_ref(), Float::ONE);
assert_eq!(Float::NEGATIVE_ONE.abs_negative_zero_ref(), Float::NEGATIVE_ONE);

pub fn abs_negative_zero_assign(&mut self)

If self is negative zero, replaces it with positive zero; otherwise, does nothing.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::{ComparableFloat, Float};

let mut x = Float::NAN;
x.abs_negative_zero_assign();
assert_eq!(ComparableFloat(x), ComparableFloat(Float::NAN));

let mut x = Float::INFINITY;
x.abs_negative_zero_assign();
assert_eq!(x, Float::INFINITY);

let mut x = Float::NEGATIVE_INFINITY;
x.abs_negative_zero_assign();
assert_eq!(x, Float::NEGATIVE_INFINITY);

let mut x = Float::ZERO;
x.abs_negative_zero_assign();
assert_eq!(ComparableFloat(x), ComparableFloat(Float::ZERO));

let mut x = Float::NEGATIVE_ZERO;
x.abs_negative_zero_assign();
assert_eq!(ComparableFloat(x), ComparableFloat(Float::ZERO));

let mut x = Float::ONE;
x.abs_negative_zero_assign();
assert_eq!(x, Float::ONE);

let mut x = Float::NEGATIVE_ONE;
x.abs_negative_zero_assign();
assert_eq!(x, Float::NEGATIVE_ONE);

impl Float

pub fn add_prec_round( self, other: Float, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Adds two Floats, rounding the result to the specified precision and with the specified rounding mode. Both Floats are taken by value. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=f(x,\text{NaN},p,m)=f(\infty,-\infty,p,m)=f(-\infty,\infty,p,m)= \text{NaN}$
• $f(\infty,x,p,m)=f(x,\infty,p,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p,m)=f(x,-\infty,p,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0,p,m)=0.0$
• $f(-0.0,-0.0,p,m)=-0.0$
• $f(0.0,-0.0,p,m)=f(-0.0,0.0,p,m)=0.0$ if $m$ is not Floor
• $f(0.0,-0.0,p,m)=f(-0.0,0.0,p,m)=-0.0$ if $m$ is Floor
• $f(x,-x,p,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,-x,p,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::add_prec instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using Float::add_round instead. If both of these things are true, consider using + instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact addition.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).add_prec_round(Float::from(E), 5, RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).add_prec_round(Float::from(E), 5, RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "6.0");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).add_prec_round(Float::from(E), 5, RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).add_prec_round(Float::from(E), 20, RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.85987");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).add_prec_round(Float::from(E), 20, RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "5.85988");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).add_prec_round(Float::from(E), 20, RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.85987");
assert_eq!(o, Ordering::Less);

pub fn add_prec_round_val_ref( self, other: &Float, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Adds two Floats, rounding the result to the specified precision and with the specified rounding mode. The first Floats is taken by value and the second by reference. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=f(x,\text{NaN},p,m)=f(\infty,-\infty,p,m)=f(-\infty,\infty,p,m)= \text{NaN}$
• $f(\infty,x,p,m)=f(x,\infty,p,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p,m)=f(x,-\infty,p,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0,p,m)=0.0$
• $f(-0.0,-0.0,p,m)=-0.0$
• $f(0.0,-0.0,p,m)=f(-0.0,0.0,p,m)=0.0$ if $m$ is not Floor
• $f(0.0,-0.0,p,m)=f(-0.0,0.0,p,m)=-0.0$ if $m$ is Floor
• $f(x,-x,p,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,-x,p,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::add_prec_val_ref instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using Float::add_round_val_ref instead. If both of these things are true, consider using + instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact addition.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .add_prec_round_val_ref(&Float::from(E), 5, RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_prec_round_val_ref(&Float::from(E), 5, RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "6.0");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_prec_round_val_ref(&Float::from(E), 5, RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_prec_round_val_ref(&Float::from(E), 20, RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.85987");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_prec_round_val_ref(&Float::from(E), 20, RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "5.85988");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_prec_round_val_ref(&Float::from(E), 20, RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.85987");
assert_eq!(o, Ordering::Less);

pub fn add_prec_round_ref_val( &self, other: Float, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Adds two Floats, rounding the result to the specified precision and with the specified rounding mode. The first Floats is taken by reference and the second by value. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=f(x,\text{NaN},p,m)=f(\infty,-\infty,p,m)=f(-\infty,\infty,p,m)= \text{NaN}$
• $f(\infty,x,p,m)=f(x,\infty,p,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p,m)=f(x,-\infty,p,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0,p,m)=0.0$
• $f(-0.0,-0.0,p,m)=-0.0$
• $f(0.0,-0.0,p,m)=f(-0.0,0.0,p,m)=0.0$ if $m$ is not Floor
• $f(0.0,-0.0,p,m)=f(-0.0,0.0,p,m)=-0.0$ if $m$ is Floor
• $f(x,-x,p,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,-x,p,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::add_prec_ref_val instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using Float::add_round_ref_val instead. If both of these things are true, consider using + instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact addition.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .add_prec_round_val_ref(&Float::from(E), 5, RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_prec_round_ref_val(Float::from(E), 5, RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "6.0");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_prec_round_ref_val(Float::from(E), 5, RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_prec_round_ref_val(Float::from(E), 20, RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.85987");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_prec_round_ref_val(Float::from(E), 20, RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "5.85988");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_prec_round_ref_val(Float::from(E), 20, RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.85987");
assert_eq!(o, Ordering::Less);

pub fn add_prec_round_ref_ref( &self, other: &Float, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Adds two Floats, rounding the result to the specified precision and with the specified rounding mode. Both Floats are taken by reference. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=f(x,\text{NaN},p,m)=f(\infty,-\infty,p,m)=f(-\infty,\infty,p,m)= \text{NaN}$
• $f(\infty,x,p,m)=f(x,\infty,p,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p,m)=f(x,-\infty,p,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0,p,m)=0.0$
• $f(-0.0,-0.0,p,m)=-0.0$
• $f(0.0,-0.0,p,m)=f(-0.0,0.0,p,m)=0.0$ if $m$ is not Floor
• $f(0.0,-0.0,p,m)=f(-0.0,0.0,p,m)=-0.0$ if $m$ is Floor
• $f(x,-x,p,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,-x,p,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::add_prec_ref_ref instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using Float::add_round_ref_ref instead. If both of these things are true, consider using + instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact addition.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .add_prec_round_ref_ref(&Float::from(E), 5, RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_prec_round_ref_ref(&Float::from(E), 5, RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "6.0");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_prec_round_ref_ref(&Float::from(E), 5, RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_prec_round_ref_ref(&Float::from(E), 20, RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.85987");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_prec_round_ref_ref(&Float::from(E), 20, RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "5.85988");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_prec_round_ref_ref(&Float::from(E), 20, RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.85987");
assert_eq!(o, Ordering::Less);

pub fn add_prec(self, other: Float, prec: u64) -> (Float, Ordering)

Adds two Floats, rounding the result to the nearest value of the specified precision. Both Floats are taken by value. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=f(x,\text{NaN},p)=f(\infty,-\infty,p)=f(-\infty,\infty,p)=\text{NaN}$
• $f(\infty,x,p)=f(x,\infty,p)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p)=f(x,-\infty,p)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0,p)=0.0$
• $f(-0.0,-0.0,p)=-0.0$
• $f(0.0,-0.0,p)=f(-0.0,0.0,p)=0.0$
• $f(x,-x,p)=0.0$ if $x$ is finite and nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_prec_round instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using + instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

use core::f64::consts::{E, PI};
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).add_prec(Float::from(E), 5);
assert_eq!(sum.to_string(), "5.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).add_prec(Float::from(E), 20);
assert_eq!(sum.to_string(), "5.85987");
assert_eq!(o, Ordering::Less);

pub fn add_prec_val_ref(self, other: &Float, prec: u64) -> (Float, Ordering)

Adds two Floats, rounding the result to the nearest value of the specified precision. The first Float is taken by value and the second by reference. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=f(x,\text{NaN},p)=f(\infty,-\infty,p)=f(-\infty,\infty,p)=\text{NaN}$
• $f(\infty,x,p)=f(x,\infty,p)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p)=f(x,-\infty,p)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0,p)=0.0$
• $f(-0.0,-0.0,p)=-0.0$
• $f(0.0,-0.0,p)=f(-0.0,0.0,p)=0.0$
• $f(x,-x,p)=0.0$ if $x$ is finite and nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_prec_round_val_ref instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using + instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

use core::f64::consts::{E, PI};
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).add_prec_val_ref(&Float::from(E), 5);
assert_eq!(sum.to_string(), "5.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).add_prec_val_ref(&Float::from(E), 20);
assert_eq!(sum.to_string(), "5.85987");
assert_eq!(o, Ordering::Less);

pub fn add_prec_ref_val(&self, other: Float, prec: u64) -> (Float, Ordering)

Adds two Floats, rounding the result to the nearest value of the specified precision. The first Float is taken by reference and the second by value. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=f(x,\text{NaN},p)=f(\infty,-\infty,p)=f(-\infty,\infty,p)=\text{NaN}$
• $f(\infty,x,p)=f(x,\infty,p)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p)=f(x,-\infty,p)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0,p)=0.0$
• $f(-0.0,-0.0,p)=-0.0$
• $f(0.0,-0.0,p)=f(-0.0,0.0,p)=0.0$
• $f(x,-x,p)=0.0$ if $x$ is finite and nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_prec_round_ref_val instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using + instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

use core::f64::consts::{E, PI};
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = (&Float::from(PI)).add_prec_ref_val(Float::from(E), 5);
assert_eq!(sum.to_string(), "5.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = (&Float::from(PI)).add_prec_ref_val(Float::from(E), 20);
assert_eq!(sum.to_string(), "5.85987");
assert_eq!(o, Ordering::Less);

pub fn add_prec_ref_ref(&self, other: &Float, prec: u64) -> (Float, Ordering)

Adds two Floats, rounding the result to the nearest value of the specified precision. Both Floats are taken by reference. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=f(x,\text{NaN},p)=f(\infty,-\infty,p)=f(-\infty,\infty,p)=\text{NaN}$
• $f(\infty,x,p)=f(x,\infty,p)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p)=f(x,-\infty,p)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0,p)=0.0$
• $f(-0.0,-0.0,p)=-0.0$
• $f(0.0,-0.0,p)=f(-0.0,0.0,p)=0.0$
• $f(x,-x,p)=0.0$ if $x$ is finite and nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_prec_round_ref_ref instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using + instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

use core::f64::consts::{E, PI};
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = (&Float::from(PI)).add_prec_ref_ref(&Float::from(E), 5);
assert_eq!(sum.to_string(), "5.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = (&Float::from(PI)).add_prec_ref_ref(&Float::from(E), 20);
assert_eq!(sum.to_string(), "5.85987");
assert_eq!(o, Ordering::Less);

pub fn add_round(self, other: Float, rm: RoundingMode) -> (Float, Ordering)

Adds two Floats, rounding the result with the specified rounding mode. Both Floats are taken by value. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the maximum of the precision of the inputs. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$, where $p$ is the maximum precision of the inputs.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

If the output has a precision, it is the maximum of the precisions of the inputs.

Special cases:

• $f(\text{NaN},x,m)=f(x,\text{NaN},m)=f(\infty,-\infty,m)=f(-\infty,\infty,m)= \text{NaN}$
• $f(\infty,x,m)=f(x,\infty,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=f(x,-\infty,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0,m)=0.0$
• $f(-0.0,-0.0,m)=-0.0$
• $f(0.0,-0.0,m)=f(-0.0,0.0,m)=0.0$ if $m$ is not Floor
• $f(0.0,-0.0,m)=f(-0.0,0.0,m)=-0.0$ if $m$ is Floor
• $f(0.0,x,m)=f(x,0.0,m)=f(-0.0,x,m)=f(x,-0.0,m)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,-x,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,-x,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::add_prec_round instead. If you know you’ll be using the Nearest rounding mode, consider using + instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the maximum precision of the inputs is not high enough to represent the output.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).add_round(Float::from(E), RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).add_round(Float::from(E), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "5.859874482048839");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).add_round(Float::from(E), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

pub fn add_round_val_ref( self, other: &Float, rm: RoundingMode ) -> (Float, Ordering)

Adds two Floats, rounding the result with the specified rounding mode. The first Float is taken by value and the second by reference. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the maximum of the precision of the inputs. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$, where $p$ is the maximum precision of the inputs.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

If the output has a precision, it is the maximum of the precisions of the inputs.

Special cases:

• $f(\text{NaN},x,m)=f(x,\text{NaN},m)=f(\infty,-\infty,m)=f(-\infty,\infty,m)= \text{NaN}$
• $f(\infty,x,m)=f(x,\infty,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=f(x,-\infty,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0,m)=0.0$
• $f(-0.0,-0.0,m)=-0.0$
• $f(0.0,-0.0,m)=f(-0.0,0.0,m)=0.0$ if $m$ is not Floor
• $f(0.0,-0.0,m)=f(-0.0,0.0,m)=-0.0$ if $m$ is Floor
• $f(0.0,x,m)=f(x,0.0,m)=f(-0.0,x,m)=f(x,-0.0,m)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,-x,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,-x,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::add_prec_round_val_ref instead. If you know you’ll be using the Nearest rounding mode, consider using + instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is max(self.significant_bits(), other.significant_bits()), and $m$ is other.significant_bits().

Panics

Panics if rm is RoundingMode::Exact but the maximum precision of the inputs is not high enough to represent the output.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).add_round_val_ref(&Float::from(E), RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).add_round_val_ref(&Float::from(E), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "5.859874482048839");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).add_round_val_ref(&Float::from(E), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

pub fn add_round_ref_val( &self, other: Float, rm: RoundingMode ) -> (Float, Ordering)

Adds two Floats, rounding the result with the specified rounding mode. The first Float is taken by reference and the second by value. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the maximum of the precision of the inputs. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$, where $p$ is the maximum precision of the inputs.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

If the output has a precision, it is the maximum of the precisions of the inputs.

Special cases:

• $f(\text{NaN},x,m)=f(x,\text{NaN},m)=f(\infty,-\infty,m)=f(-\infty,\infty,m)= \text{NaN}$
• $f(\infty,x,m)=f(x,\infty,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=f(x,-\infty,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0,m)=0.0$
• $f(-0.0,-0.0,m)=-0.0$
• $f(0.0,-0.0,m)=f(-0.0,0.0,m)=0.0$ if $m$ is not Floor
• $f(0.0,-0.0,m)=f(-0.0,0.0,m)=-0.0$ if $m$ is Floor
• $f(0.0,x,m)=f(x,0.0,m)=f(-0.0,x,m)=f(x,-0.0,m)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,-x,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,-x,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::add_prec_round_ref_val instead. If you know you’ll be using the Nearest rounding mode, consider using + instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is max(self.significant_bits(), other.significant_bits()), and $m$ is self.significant_bits().

Panics

Panics if rm is RoundingMode::Exact but the maximum precision of the inputs is not high enough to represent the output.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = (&Float::from(PI)).add_round_ref_val(Float::from(E), RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

let (sum, o) = (&Float::from(PI)).add_round_ref_val(Float::from(E), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "5.859874482048839");
assert_eq!(o, Ordering::Greater);

let (sum, o) = (&Float::from(PI)).add_round_ref_val(Float::from(E), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

pub fn add_round_ref_ref( &self, other: &Float, rm: RoundingMode ) -> (Float, Ordering)

Adds two Floats, rounding the result with the specified rounding mode. Both Floats are taken by reference. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the maximum of the precision of the inputs. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$, where $p$ is the maximum precision of the inputs.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

If the output has a precision, it is the maximum of the precisions of the inputs.

Special cases:

• $f(\text{NaN},x,m)=f(x,\text{NaN},m)=f(\infty,-\infty,m)=f(-\infty,\infty,m)= \text{NaN}$
• $f(\infty,x,m)=f(x,\infty,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=f(x,-\infty,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0,m)=0.0$
• $f(-0.0,-0.0,m)=-0.0$
• $f(0.0,-0.0,m)=f(-0.0,0.0,m)=0.0$ if $m$ is not Floor
• $f(0.0,-0.0,m)=f(-0.0,0.0,m)=-0.0$ if $m$ is Floor
• $f(0.0,x,m)=f(x,0.0,m)=f(-0.0,x,m)=f(x,-0.0,m)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,-x,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,-x,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::add_prec_round_ref_ref instead. If you know you’ll be using the Nearest rounding mode, consider using + instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the maximum precision of the inputs is not high enough to represent the output.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).add_round_ref_ref(&Float::from(E), RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).add_round_ref_ref(&Float::from(E), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "5.859874482048839");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).add_round_ref_ref(&Float::from(E), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

pub fn add_prec_round_assign( &mut self, other: Float, prec: u64, rm: RoundingMode ) -> Ordering

Adds a Float to a Float in place, rounding the result to the specified precision and with the specified rounding mode. The Float on the right-hand side is taken by value. An Ordering is returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ x \gets x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::add_prec_round documentation for information on special cases.

If you know you’ll be using Nearest, consider using Float::add_prec_assign instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using Float::add_round_assign instead. If both of these things are true, consider using += instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact addition.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(
    x.add_prec_round_assign(Float::from(E), 5, RoundingMode::Floor),
    Ordering::Less
);
assert_eq!(x.to_string(), "5.8");

let mut x = Float::from(PI);
assert_eq!(
    x.add_prec_round_assign(Float::from(E), 5, RoundingMode::Ceiling),
    Ordering::Greater
);
assert_eq!(x.to_string(), "6.0");

let mut x = Float::from(PI);
assert_eq!(
    x.add_prec_round_assign(Float::from(E), 5, RoundingMode::Nearest),
    Ordering::Less
);
assert_eq!(x.to_string(), "5.8");

let mut x = Float::from(PI);
assert_eq!(
    x.add_prec_round_assign(Float::from(E), 20, RoundingMode::Floor),
    Ordering::Less
);
assert_eq!(x.to_string(), "5.85987");

let mut x = Float::from(PI);
assert_eq!(
    x.add_prec_round_assign(Float::from(E), 20, RoundingMode::Ceiling),
    Ordering::Greater
);
assert_eq!(x.to_string(), "5.85988");

let mut x = Float::from(PI);
assert_eq!(
    x.add_prec_round_assign(Float::from(E), 20, RoundingMode::Nearest),
    Ordering::Less
);
assert_eq!(x.to_string(), "5.85987");

pub fn add_prec_round_assign_ref( &mut self, other: &Float, prec: u64, rm: RoundingMode ) -> Ordering

Adds a Float to a Float in place, rounding the result to the specified precision and with the specified rounding mode. The Float on the right-hand side is taken by reference. An Ordering is returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ x \gets x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::add_prec_round documentation for information on special cases.

If you know you’ll be using Nearest, consider using Float::add_prec_assign_ref instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using Float::add_round_assign_ref instead. If both of these things are true, consider using += instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact addition.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(
    x.add_prec_round_assign_ref(&Float::from(E), 5, RoundingMode::Floor),
    Ordering::Less
);
assert_eq!(x.to_string(), "5.8");

let mut x = Float::from(PI);
assert_eq!(
    x.add_prec_round_assign_ref(&Float::from(E), 5, RoundingMode::Ceiling),
    Ordering::Greater
);
assert_eq!(x.to_string(), "6.0");

let mut x = Float::from(PI);
assert_eq!(
    x.add_prec_round_assign_ref(&Float::from(E), 5, RoundingMode::Nearest),
    Ordering::Less
);
assert_eq!(x.to_string(), "5.8");

let mut x = Float::from(PI);
assert_eq!(
    x.add_prec_round_assign_ref(&Float::from(E), 20, RoundingMode::Floor),
    Ordering::Less
);
assert_eq!(x.to_string(), "5.85987");

let mut x = Float::from(PI);
assert_eq!(
    x.add_prec_round_assign_ref(&Float::from(E), 20, RoundingMode::Ceiling),
    Ordering::Greater
);
assert_eq!(x.to_string(), "5.85988");

let mut x = Float::from(PI);
assert_eq!(
    x.add_prec_round_assign_ref(&Float::from(E), 20, RoundingMode::Nearest),
    Ordering::Less
);
assert_eq!(x.to_string(), "5.85987");

pub fn add_prec_assign(&mut self, other: Float, prec: u64) -> Ordering

Adds a Float to a Float in place, rounding the result to the nearest value of the specified precision. The Float on the right-hand side is taken by value. An Ordering is returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x \gets x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::add_prec documentation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::add_prec_round_assign instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using += instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

use core::f64::consts::{E, PI};
use malachite_float::Float;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(x.add_prec_assign(Float::from(E), 5), Ordering::Less);
assert_eq!(x.to_string(), "5.8");

let mut x = Float::from(PI);
assert_eq!(x.add_prec_assign(Float::from(E), 20), Ordering::Less);
assert_eq!(x.to_string(), "5.85987");

pub fn add_prec_assign_ref(&mut self, other: &Float, prec: u64) -> Ordering

Adds a Float to a Float in place, rounding the result to the nearest value of the specified precision. The Float on the right-hand side is taken by reference. An Ordering is returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x \gets x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::add_prec documentation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::add_prec_round_assign_ref instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using += instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

use core::f64::consts::{E, PI};
use malachite_float::Float;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(x.add_prec_assign_ref(&Float::from(E), 5), Ordering::Less);
assert_eq!(x.to_string(), "5.8");

let mut x = Float::from(PI);
assert_eq!(x.add_prec_assign_ref(&Float::from(E), 20), Ordering::Less);
assert_eq!(x.to_string(), "5.85987");

pub fn add_round_assign(&mut self, other: Float, rm: RoundingMode) -> Ordering

Adds a Float to a Float in place, rounding the result with the specified rounding mode. The Float on the right-hand side is taken by value. An Ordering is returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

The precision of the output is the maximum of the precision of the inputs. See RoundingMode for a description of the possible rounding modes.

$$ x \gets x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$, where $p$ is the maximum precision of the inputs.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

If the output has a precision, it is the maximum of the precisions of the inputs.

See the Float::add_round documentation for information on special cases.

If you want to specify an output precision, consider using Float::add_prec_round_assign instead. If you know you’ll be using the Nearest rounding mode, consider using += instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the maximum precision of the inputs is not high enough to represent the output.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(x.add_round_assign(Float::from(E), RoundingMode::Floor), Ordering::Less);
assert_eq!(x.to_string(), "5.859874482048838");

let mut x = Float::from(PI);
assert_eq!(x.add_round_assign(Float::from(E), RoundingMode::Ceiling), Ordering::Greater);
assert_eq!(x.to_string(), "5.859874482048839");

let mut x = Float::from(PI);
assert_eq!(x.add_round_assign(Float::from(E), RoundingMode::Nearest), Ordering::Less);
assert_eq!(x.to_string(), "5.859874482048838");

pub fn add_round_assign_ref( &mut self, other: &Float, rm: RoundingMode ) -> Ordering

Adds a Float to a Float in place, rounding the result with the specified rounding mode. The Float on the right-hand side is taken by reference. An Ordering is returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

The precision of the output is the maximum of the precision of the inputs. See RoundingMode for a description of the possible rounding modes.

$$ x \gets x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$, where $p$ is the maximum precision of the inputs.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

If the output has a precision, it is the maximum of the precisions of the inputs.

See the Float::add_round documentation for information on special cases.

If you want to specify an output precision, consider using Float::add_prec_round_assign_ref instead. If you know you’ll be using the Nearest rounding mode, consider using += instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is max(self.significant_bits(), other.significant_bits()), and $m$ is other.significant_bits().

Panics

Panics if rm is RoundingMode::Exact but the maximum precision of the inputs is not high enough to represent the output.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(x.add_round_assign_ref(&Float::from(E), RoundingMode::Floor), Ordering::Less);
assert_eq!(x.to_string(), "5.859874482048838");

let mut x = Float::from(PI);
assert_eq!(
    x.add_round_assign_ref(&Float::from(E), RoundingMode::Ceiling),
    Ordering::Greater
);
assert_eq!(x.to_string(), "5.859874482048839");

let mut x = Float::from(PI);
assert_eq!(x.add_round_assign_ref(&Float::from(E), RoundingMode::Nearest), Ordering::Less);
assert_eq!(x.to_string(), "5.859874482048838");

pub fn add_rational_prec_round( self, other: Rational, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Adds a Float and a Rational, rounding the result to the specified precision and with the specified rounding mode. The Float and the Rational are both taken by value. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=\text{NaN}$
• $f(\infty,x,p,m)=\infty$
• $f(-\infty,x,p,m)=-\infty$
• $f(0.0,0,p,m)=0.0$
• $f(-0.0,0,p,m)=-0.0$
• $f(x,-x,p,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,-x,p,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::add_rational_prec instead. If you know that your target precision is the precision of the Float input, consider using Float::add_rational_round instead. If both of these things are true, consider using + instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact addition.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .add_rational_prec_round(Rational::from_unsigneds(1u8, 3), 5, RoundingMode::Floor);
assert_eq!(sum.to_string(), "3.4");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round(Rational::from_unsigneds(1u8, 3), 5, RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "3.5");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round(Rational::from_unsigneds(1u8, 3), 5, RoundingMode::Nearest);
assert_eq!(sum.to_string(), "3.5");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round(Rational::from_unsigneds(1u8, 3), 20, RoundingMode::Floor);
assert_eq!(sum.to_string(), "3.474922");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round(Rational::from_unsigneds(1u8, 3), 20, RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "3.474926");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round(Rational::from_unsigneds(1u8, 3), 20, RoundingMode::Nearest);
assert_eq!(sum.to_string(), "3.474926");
assert_eq!(o, Ordering::Greater);

pub fn add_rational_prec_round_val_ref( self, other: &Rational, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Adds a Float and a Rational, rounding the result to the specified precision and with the specified rounding mode. The Float is taken by value and the Rational by reference. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=\text{NaN}$
• $f(\infty,x,p,m)=\infty$
• $f(-\infty,x,p,m)=-\infty$
• $f(0.0,0,p,m)=0.0$
• $f(-0.0,0,p,m)=-0.0$
• $f(x,-x,p,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,-x,p,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::add_rational_prec_val_ref instead. If you know that your target precision is the precision of the Float input, consider using Float::add_rational_round_val_ref instead. If both of these things are true, consider using + instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact addition.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_val_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Floor
    );
assert_eq!(sum.to_string(), "3.4");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_val_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Ceiling
    );
assert_eq!(sum.to_string(), "3.5");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_val_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Nearest
    );
assert_eq!(sum.to_string(), "3.5");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_val_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Floor
    );
assert_eq!(sum.to_string(), "3.474922");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_val_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Ceiling
    );
assert_eq!(sum.to_string(), "3.474926");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_val_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Nearest
    );
assert_eq!(sum.to_string(), "3.474926");
assert_eq!(o, Ordering::Greater);

pub fn add_rational_prec_round_ref_val( &self, other: Rational, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Adds a Float and a Rational, rounding the result to the specified precision and with the specified rounding mode. The Float is taken by reference and the Rational by value. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=\text{NaN}$
• $f(\infty,x,p,m)=\infty$
• $f(-\infty,x,p,m)=-\infty$
• $f(0.0,0,p,m)=0.0$
• $f(-0.0,0,p,m)=-0.0$
• $f(x,-x,p,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,-x,p,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::add_rational_prec_ref_val instead. If you know that your target precision is the precision of the Float input, consider using Float::add_rational_round_ref_val instead. If both of these things are true, consider using + instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact addition.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_ref_val(
        Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Floor
    );
assert_eq!(sum.to_string(), "3.4");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_ref_val(
        Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Ceiling
    );
assert_eq!(sum.to_string(), "3.5");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_ref_val(
        Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Nearest
    );
assert_eq!(sum.to_string(), "3.5");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_ref_val(
        Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Floor
    );
assert_eq!(sum.to_string(), "3.474922");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_ref_val(
        Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Ceiling
    );
assert_eq!(sum.to_string(), "3.474926");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_ref_val(
        Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Nearest
    );
assert_eq!(sum.to_string(), "3.474926");
assert_eq!(o, Ordering::Greater);

pub fn add_rational_prec_round_ref_ref( &self, other: &Rational, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Adds a Float and a Rational, rounding the result to the specified precision and with the specified rounding mode. The Float and the Rational are both taken by reference. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=\text{NaN}$
• $f(\infty,x,p,m)=\infty$
• $f(-\infty,x,p,m)=-\infty$
• $f(0.0,0,p,m)=0.0$
• $f(-0.0,0,p,m)=-0.0$
• $f(x,-x,p,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,-x,p,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::add_rational_prec_ref_ref instead. If you know that your target precision is the precision of the Float input, consider using Float::add_rational_round_ref_ref instead. If both of these things are true, consider using + instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact addition.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_ref_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Floor
    );
assert_eq!(sum.to_string(), "3.4");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_ref_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Ceiling
    );
assert_eq!(sum.to_string(), "3.5");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_ref_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Nearest
    );
assert_eq!(sum.to_string(), "3.5");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_ref_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Floor
    );
assert_eq!(sum.to_string(), "3.474922");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_ref_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Ceiling
    );
assert_eq!(sum.to_string(), "3.474926");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_prec_round_ref_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Nearest
    );
assert_eq!(sum.to_string(), "3.474926");
assert_eq!(o, Ordering::Greater);

pub fn add_rational_prec(self, other: Rational, prec: u64) -> (Float, Ordering)

Adds a Float and a Rational, rounding the result to the nearest value of the specified precision. The Float and the Rational are both are taken by value. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=\text{NaN}$
• $f(\infty,x,p)=\infty$
• $f(-\infty,x,p)=-\infty$
• $f(0.0,0,p)=0.0$
• $f(-0.0,0,p)=-0.0$
• $f(x,-x,p)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_rational_prec_round instead. If you know that your target precision is the precision of the Float input, consider using + instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Examples

use core::f64::consts::PI;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).add_rational_prec(Rational::exact_from(1.5), 5);
assert_eq!(sum.to_string(), "4.8");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).add_rational_prec(Rational::exact_from(1.5), 20);
assert_eq!(sum.to_string(), "4.641594");
assert_eq!(o, Ordering::Greater);

pub fn add_rational_prec_val_ref( self, other: &Rational, prec: u64 ) -> (Float, Ordering)

Adds a Float and a Rational, rounding the result to the nearest value of the specified precision. The Float is taken by value and the Rational by reference. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=\text{NaN}$
• $f(\infty,x,p)=\infty$
• $f(-\infty,x,p)=-\infty$
• $f(0.0,0,p)=0.0$
• $f(-0.0,0,p)=-0.0$
• $f(x,-x,p)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_rational_prec_round_val_ref instead. If you know that your target precision is the precision of the Float input, consider using + instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Examples

use core::f64::consts::PI;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).add_rational_prec_val_ref(&Rational::exact_from(1.5), 5);
assert_eq!(sum.to_string(), "4.8");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).add_rational_prec_val_ref(&Rational::exact_from(1.5), 20);
assert_eq!(sum.to_string(), "4.641594");
assert_eq!(o, Ordering::Greater);

pub fn add_rational_prec_ref_val( &self, other: Rational, prec: u64 ) -> (Float, Ordering)

Adds a Float and a Rational, rounding the result to the nearest value of the specified precision. The Float is taken by reference and the Rational by value. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=\text{NaN}$
• $f(\infty,x,p)=\infty$
• $f(-\infty,x,p)=-\infty$
• $f(0.0,0,p)=0.0$
• $f(-0.0,0,p)=-0.0$
• $f(x,-x,p)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_rational_prec_round_ref_val instead. If you know that your target precision is the precision of the Float input, consider using + instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Examples

use core::f64::consts::PI;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).add_rational_prec_ref_val(Rational::exact_from(1.5), 5);
assert_eq!(sum.to_string(), "4.8");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).add_rational_prec_ref_val(Rational::exact_from(1.5), 20);
assert_eq!(sum.to_string(), "4.641594");
assert_eq!(o, Ordering::Greater);

pub fn add_rational_prec_ref_ref( &self, other: &Rational, prec: u64 ) -> (Float, Ordering)

Adds a Float and a Rational, rounding the result to the nearest value of the specified precision. The Float and the Rational are both are taken by reference. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=\text{NaN}$
• $f(\infty,x,p)=\infty$
• $f(-\infty,x,p)=-\infty$
• $f(0.0,0,p)=0.0$
• $f(-0.0,0,p)=-0.0$
• $f(x,-x,p)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_rational_prec_round_ref_ref instead. If you know that your target precision is the precision of the Float input, consider using + instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Examples

use core::f64::consts::PI;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).add_rational_prec_ref_ref(&Rational::exact_from(1.5), 5);
assert_eq!(sum.to_string(), "4.8");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).add_rational_prec_ref_ref(&Rational::exact_from(1.5), 20);
assert_eq!(sum.to_string(), "4.641594");
assert_eq!(o, Ordering::Greater);

pub fn add_rational_round( self, other: Rational, rm: RoundingMode ) -> (Float, Ordering)

Adds a Float and a Rational, rounding the result with the specified rounding mode. The Float and the Rational are both are taken by value. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the precision of the Float input. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$, where $p$ is the precision of the input Float.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

If the output has a precision, it is the precision of the Float input.

Special cases:

• $f(\text{NaN},x,m)=\text{NaN}$
• $f(\infty,x,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0,m)=0.0$
• $f(-0.0,0,m)=-0.0$
• $f(0.0,x,m)=f(x,0,m)=f(-0.0,x,m)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,-x,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,-x,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::add_rational_prec_round instead. If you know you’ll be using the Nearest rounding mode, consider using + instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the precision of the Float input is not high enough to represent the output.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .add_rational_round(Rational::from_unsigneds(1u8, 3), RoundingMode::Floor);
assert_eq!(sum.to_string(), "3.4749259869231262");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_rational_round(Rational::from_unsigneds(1u8, 3), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "3.4749259869231266");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_round(Rational::from_unsigneds(1u8, 3), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "3.4749259869231266");
assert_eq!(o, Ordering::Greater);

pub fn add_rational_round_val_ref( self, other: &Rational, rm: RoundingMode ) -> (Float, Ordering)

Adds a Float and a Rational, rounding the result with the specified rounding mode. The Float is taken by value and the Rational by reference. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the precision of the Float input. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$, where $p$ is the precision of the input Float.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

If the output has a precision, it is the precision of the Float input.

Special cases:

• $f(\text{NaN},x,m)=\text{NaN}$
• $f(\infty,x,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0,m)=0.0$
• $f(-0.0,0,m)=-0.0$
• $f(0.0,x,m)=f(x,0,m)=f(-0.0,x,m)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,-x,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,-x,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::add_rational_prec_round_val_ref instead. If you know you’ll be using the Nearest rounding mode, consider using + instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the precision of the Float input is not high enough to represent the output.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .add_rational_round_val_ref(&Rational::from_unsigneds(1u8, 3), RoundingMode::Floor);
assert_eq!(sum.to_string(), "3.4749259869231262");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_rational_round_val_ref(&Rational::from_unsigneds(1u8, 3), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "3.4749259869231266");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_round_val_ref(&Rational::from_unsigneds(1u8, 3), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "3.4749259869231266");
assert_eq!(o, Ordering::Greater);

pub fn add_rational_round_ref_val( &self, other: Rational, rm: RoundingMode ) -> (Float, Ordering)

Adds a Float and a Rational, rounding the result with the specified rounding mode. The Float is taken by reference and the Float by value. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the precision of the Float input. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$, where $p$ is the precision of the input Float.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

If the output has a precision, it is the precision of the Float input.

Special cases:

• $f(\text{NaN},x,m)=\text{NaN}$
• $f(\infty,x,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0,m)=0.0$
• $f(-0.0,0,m)=-0.0$
• $f(0.0,x,m)=f(x,0,m)=f(-0.0,x,m)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,-x,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,-x,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::add_rational_prec_round_ref_val instead. If you know you’ll be using the Nearest rounding mode, consider using + instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the precision of the Float input is not high enough to represent the output.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .add_rational_round_ref_val(Rational::from_unsigneds(1u8, 3), RoundingMode::Floor);
assert_eq!(sum.to_string(), "3.4749259869231262");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_rational_round_ref_val(Rational::from_unsigneds(1u8, 3), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "3.4749259869231266");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_round_ref_val(Rational::from_unsigneds(1u8, 3), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "3.4749259869231266");
assert_eq!(o, Ordering::Greater);

pub fn add_rational_round_ref_ref( &self, other: &Rational, rm: RoundingMode ) -> (Float, Ordering)

Adds a Float and a Rational, rounding the result with the specified rounding mode. The Float and the Rational are both are taken by reference. An Ordering is also returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the precision of the Float input. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$, where $p$ is the precision of the input Float.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

If the output has a precision, it is the precision of the Float input.

Special cases:

• $f(\text{NaN},x,m)=\text{NaN}$
• $f(\infty,x,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0,m)=0.0$
• $f(-0.0,0,m)=-0.0$
• $f(0.0,x,m)=f(x,0,m)=f(-0.0,x,m)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,-x,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,-x,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::add_rational_prec_round_ref_ref instead. If you know you’ll be using the Nearest rounding mode, consider using + instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the precision of the Float input is not high enough to represent the output.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .add_rational_round_ref_ref(&Rational::from_unsigneds(1u8, 3), RoundingMode::Floor);
assert_eq!(sum.to_string(), "3.4749259869231262");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .add_rational_round_ref_ref(&Rational::from_unsigneds(1u8, 3), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "3.4749259869231266");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .add_rational_round_ref_ref(&Rational::from_unsigneds(1u8, 3), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "3.4749259869231266");
assert_eq!(o, Ordering::Greater);

pub fn add_rational_prec_round_assign( &mut self, other: Rational, prec: u64, rm: RoundingMode ) -> Ordering

Adds a Rational to a Float in place, rounding the result to the specified precision and with the specified rounding mode. The Rational is taken by value. An Ordering is returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ x \gets x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::add_rational_prec_round documentation for information on special cases.

If you know you’ll be using Nearest, consider using Float::add_rational_prec_assign instead. If you know that your target precision is the precision of the Float input, consider using Float::add_rational_round_assign instead. If both of these things are true, consider using += instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact addition.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_prec_round_assign(
        Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Floor
    ),
    Ordering::Less
);
assert_eq!(x.to_string(), "3.4");

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_prec_round_assign(
        Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Ceiling
    ),
    Ordering::Greater
);
assert_eq!(x.to_string(), "3.5");

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_prec_round_assign(
        Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Nearest
    ),
    Ordering::Greater
);
assert_eq!(x.to_string(), "3.5");

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_prec_round_assign(
        Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Floor
    ),
    Ordering::Less
);
assert_eq!(x.to_string(), "3.474922");

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_prec_round_assign(
        Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Ceiling
    ),
    Ordering::Greater
);
assert_eq!(x.to_string(), "3.474926");

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_prec_round_assign(
        Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Nearest
    ),
    Ordering::Greater
);
assert_eq!(x.to_string(), "3.474926");

pub fn add_rational_prec_round_assign_ref( &mut self, other: &Rational, prec: u64, rm: RoundingMode ) -> Ordering

Adds a Rational to a Float in place, rounding the result to the specified precision and with the specified rounding mode. The Rational is taken by reference. An Ordering is returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ x \gets x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::add_rational_prec_round documentation for information on special cases.

If you know you’ll be using Nearest, consider using Float::add_rational_prec_assign_ref instead. If you know that your target precision is the precision of the Float input, consider using Float::add_rational_round_assign_ref instead. If both of these things are true, consider using += instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact addition.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_prec_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Floor
    ),
    Ordering::Less
);
assert_eq!(x.to_string(), "3.4");

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_prec_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Ceiling
    ),
    Ordering::Greater
);
assert_eq!(x.to_string(), "3.5");

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_prec_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Nearest
    ),
    Ordering::Greater
);
assert_eq!(x.to_string(), "3.5");

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_prec_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Floor
    ),
    Ordering::Less
);
assert_eq!(x.to_string(), "3.474922");

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_prec_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Ceiling
    ),
    Ordering::Greater
);
assert_eq!(x.to_string(), "3.474926");

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_prec_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Nearest
    ),
    Ordering::Greater
);
assert_eq!(x.to_string(), "3.474926");

pub fn add_rational_prec_assign( &mut self, other: Rational, prec: u64 ) -> Ordering

Adds a Rational to a Float in place, rounding the result to the nearest value of the specified precision. The Rational is taken by value. An Ordering is returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x \gets x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::add_rational_prec documentation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::add_rational_prec_round_assign instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using += instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Examples

use core::f64::consts::PI;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(x.add_rational_prec_assign(Rational::exact_from(1.5), 5), Ordering::Greater);
assert_eq!(x.to_string(), "4.8");

let mut x = Float::from(PI);
assert_eq!(x.add_rational_prec_assign(Rational::exact_from(1.5), 20), Ordering::Greater);
assert_eq!(x.to_string(), "4.641594");

pub fn add_rational_prec_assign_ref( &mut self, other: &Rational, prec: u64 ) -> Ordering

Adds a Rational to a Float in place, rounding the result to the nearest value of the specified precision. The Rational is taken by reference. An Ordering is returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x \gets x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::add_rational_prec documentation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::add_rational_prec_round_assign_ref instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using += instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Examples

use core::f64::consts::PI;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_prec_assign_ref(&Rational::exact_from(1.5), 5),
    Ordering::Greater
);
assert_eq!(x.to_string(), "4.8");

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_prec_assign_ref(&Rational::exact_from(1.5), 20),
    Ordering::Greater
);
assert_eq!(x.to_string(), "4.641594");

pub fn add_rational_round_assign( &mut self, other: Rational, rm: RoundingMode ) -> Ordering

Adds a Rational to a Float in place, rounding the result with the specified rounding mode. The Rational is taken by value. An Ordering is returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

The precision of the output is the precision of the input Float. See RoundingMode for a description of the possible rounding modes.

$$ x \gets x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$, where $p$ is the precision of the input Float.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

If the output has a precision, it is the precision of the input Float.

See the Float::add_rational_round documentation for information on special cases.

If you want to specify an output precision, consider using Float::add_rational_prec_round_assign instead. If you know you’ll be using the Nearest rounding mode, consider using += instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the precision of the input Float is not high enough to represent the output.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_round_assign(Rational::from_unsigneds(1u8, 3), RoundingMode::Floor),
    Ordering::Less
);
assert_eq!(x.to_string(), "3.4749259869231262");

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_round_assign(Rational::from_unsigneds(1u8, 3), RoundingMode::Ceiling),
    Ordering::Greater
);
assert_eq!(x.to_string(), "3.4749259869231266");

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_round_assign(Rational::from_unsigneds(1u8, 3), RoundingMode::Nearest),
    Ordering::Greater
);
assert_eq!(x.to_string(), "3.4749259869231266");

pub fn add_rational_round_assign_ref( &mut self, other: &Rational, rm: RoundingMode ) -> Ordering

Adds a Rational to a Float in place, rounding the result with the specified rounding mode. The Rational is taken by reference. An Ordering is returned, indicating whether the rounded sum is less than, equal to, or greater than the exact sum. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

The precision of the output is the precision of the input Float. See RoundingMode for a description of the possible rounding modes.

$$ x \gets x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p+1}$, where $p$ is the precision of the input Float.
• If $x+y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

If the output has a precision, it is the precision of the input Float.

See the Float::add_rational_round documentation for information on special cases.

If you want to specify an output precision, consider using Float::add_rational_prec_round_assign_ref instead. If you know you’ll be using the Nearest rounding mode, consider using += instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the precision of the input Float is not high enough to represent the output.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        RoundingMode::Floor
    ),
    Ordering::Less
);
assert_eq!(x.to_string(), "3.4749259869231262");

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        RoundingMode::Ceiling
),
    Ordering::Greater
);
assert_eq!(x.to_string(), "3.4749259869231266");

let mut x = Float::from(PI);
assert_eq!(
    x.add_rational_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        RoundingMode::Nearest
    ),
    Ordering::Greater
);
assert_eq!(x.to_string(), "3.4749259869231266");

impl Float

pub fn power_of_2_prec(pow: i64, prec: u64) -> Float

Raises 2 to an integer power, returning a Float with the specified precision.

If you need a Float with precision 1, then the PowerOfTwo implementation may be used instead.

$f(k) = 2^k$,

and the result has precision prec.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

use malachite_float::Float;

assert_eq!(Float::power_of_2_prec(0, 1).to_string(), "1.0");
assert_eq!(Float::power_of_2_prec(0, 10).to_string(), "1.0");
assert_eq!(Float::power_of_2_prec(0, 100).to_string(), "1.0");

assert_eq!(Float::power_of_2_prec(100, 1).to_string(), "1.0e30");
assert_eq!(Float::power_of_2_prec(100, 10).to_string(), "1.268e30");
assert_eq!(
    Float::power_of_2_prec(100, 100).to_string(),
    "1267650600228229401496703205376.0"
);

assert_eq!(Float::power_of_2_prec(-100, 1).to_string(), "8.0e-31");
assert_eq!(Float::power_of_2_prec(-100, 10).to_string(), "7.89e-31");
assert_eq!(
    Float::power_of_2_prec(-100, 100).to_string(),
    "7.88860905221011805411728565283e-31"
);

impl Float

pub fn sub_prec_round( self, other: Float, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Subtracts two Floats, rounding the result to the specified precision and with the specified rounding mode. Both Floats are taken by value. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=f(x,\text{NaN},p,m)=f(\infty,\infty,p,m)=f(-\infty,-\infty,p,m)= \text{NaN}$
• $f(\infty,x,p,m)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty,p,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p,m)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty,p,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0,p,m)=0.0$
• $f(-0.0,0.0,p,m)=-0.0$
• $f(0.0,0.0,p,m)=f(-0.0,-0.0,p,m)=0.0$ if $m$ is not Floor
• $f(0.0,0.0,p,m)=f(-0.0,-0.0,p,m)=-0.0$ if $m$ is Floor
• $f(x,x,p,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,x,p,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::sub_prec instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using Float::sub_round instead. If both of these things are true, consider using - instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact subtraction.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_prec_round(Float::from(E), 5, RoundingMode::Floor);
assert_eq!(sum.to_string(), "0.42");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec_round(Float::from(E), 5, RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "0.44");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).sub_prec_round(Float::from(E), 5, RoundingMode::Nearest);
assert_eq!(sum.to_string(), "0.42");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec_round(Float::from(E), 20, RoundingMode::Floor);
assert_eq!(sum.to_string(), "0.4233108");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec_round(Float::from(E), 20, RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "0.4233112");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).sub_prec_round(Float::from(E), 20, RoundingMode::Nearest);
assert_eq!(sum.to_string(), "0.4233108");
assert_eq!(o, Ordering::Less);

pub fn sub_prec_round_val_ref( self, other: &Float, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Subtracts two Floats, rounding the result to the specified precision and with the specified rounding mode. The first Float is taken by value and the second by reference. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=f(x,\text{NaN},p,m)=f(\infty,\infty,p,m)=f(-\infty,-\infty,p,m)= \text{NaN}$
• $f(\infty,x,p,m)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty,p,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p,m)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty,p,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0,p,m)=0.0$
• $f(-0.0,0.0,p,m)=-0.0$
• $f(0.0,0.0,p,m)=f(-0.0,-0.0,p,m)=0.0$ if $m$ is not Floor
• $f(0.0,0.0,p,m)=f(-0.0,-0.0,p,m)=-0.0$ if $m$ is Floor
• $f(x,x,p,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,x,p,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::sub_prec_val_ref instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using Float::sub_round_val_ref instead. If both of these things are true, consider using - instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact subtraction.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_prec_round_val_ref(
    &Float::from(E),
    5,
    RoundingMode::Floor
);
assert_eq!(sum.to_string(), "0.42");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec_round_val_ref(
    &Float::from(E),
    5,
    RoundingMode::Ceiling
);
assert_eq!(sum.to_string(), "0.44");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).sub_prec_round_val_ref(
    &Float::from(E),
    5,
    RoundingMode::Nearest
);
assert_eq!(sum.to_string(), "0.42");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec_round_val_ref(
    &Float::from(E),
    20,
    RoundingMode::Floor
);
assert_eq!(sum.to_string(), "0.4233108");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec_round_val_ref(
    &Float::from(E),
    20,
    RoundingMode::Ceiling
);
assert_eq!(sum.to_string(), "0.4233112");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).sub_prec_round_val_ref(
    &Float::from(E),
    20,
    RoundingMode::Nearest
);
assert_eq!(sum.to_string(), "0.4233108");
assert_eq!(o, Ordering::Less);

pub fn sub_prec_round_ref_val( &self, other: Float, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Subtracts two Floats, rounding the result to the specified precision and with the specified rounding mode. The first Float is taken by reference and the second by value. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=f(x,\text{NaN},p,m)=f(\infty,\infty,p,m)=f(-\infty,-\infty,p,m)= \text{NaN}$
• $f(\infty,x,p,m)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty,p,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p,m)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty,p,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0,p,m)=0.0$
• $f(-0.0,0.0,p,m)=-0.0$
• $f(0.0,0.0,p,m)=f(-0.0,-0.0,p,m)=0.0$ if $m$ is not Floor
• $f(0.0,0.0,p,m)=f(-0.0,-0.0,p,m)=-0.0$ if $m$ is Floor
• $f(x,x,p,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,x,p,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::sub_prec_ref_val instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using Float::sub_round_ref_val instead. If both of these things are true, consider using - instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact subtraction.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_prec_round_ref_val(
    Float::from(E),
    5,
    RoundingMode::Floor
);
assert_eq!(sum.to_string(), "0.42");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec_round_ref_val(
    Float::from(E),
    5,
    RoundingMode::Ceiling
);
assert_eq!(sum.to_string(), "0.44");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).sub_prec_round_ref_val(
    Float::from(E),
    5,
    RoundingMode::Nearest
);
assert_eq!(sum.to_string(), "0.42");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec_round_ref_val(
    Float::from(E),
    20,
    RoundingMode::Floor
);
assert_eq!(sum.to_string(), "0.4233108");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec_round_ref_val(
    Float::from(E),
    20,
    RoundingMode::Ceiling
);
assert_eq!(sum.to_string(), "0.4233112");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).sub_prec_round_ref_val(
    Float::from(E),
    20,
    RoundingMode::Nearest
);
assert_eq!(sum.to_string(), "0.4233108");
assert_eq!(o, Ordering::Less);

pub fn sub_prec_round_ref_ref( &self, other: &Float, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Subtracts two Floats, rounding the result to the specified precision and with the specified rounding mode. Both Floats are taken by reference. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=f(x,\text{NaN},p,m)=f(\infty,\infty,p,m)=f(-\infty,-\infty,p,m)= \text{NaN}$
• $f(\infty,x,p,m)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty,p,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p,m)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty,p,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0,p,m)=0.0$
• $f(-0.0,0.0,p,m)=-0.0$
• $f(0.0,0.0,p,m)=f(-0.0,-0.0,p,m)=0.0$ if $m$ is not Floor
• $f(0.0,0.0,p,m)=f(-0.0,-0.0,p,m)=-0.0$ if $m$ is Floor
• $f(x,x,p,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,x,p,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::sub_prec_ref_ref instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using Float::sub_round_ref_ref instead. If both of these things are true, consider using - instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact subtraction.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_prec_round_ref_ref(
    &Float::from(E),
    5,
    RoundingMode::Floor
);
assert_eq!(sum.to_string(), "0.42");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec_round_ref_ref(
    &Float::from(E),
    5,
    RoundingMode::Ceiling
);
assert_eq!(sum.to_string(), "0.44");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).sub_prec_round_ref_ref(
    &Float::from(E),
    5,
    RoundingMode::Nearest
);
assert_eq!(sum.to_string(), "0.42");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec_round_ref_ref(
    &Float::from(E),
    20,
    RoundingMode::Floor
);
assert_eq!(sum.to_string(), "0.4233108");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec_round_ref_ref(
    &Float::from(E),
    20,
    RoundingMode::Ceiling
);
assert_eq!(sum.to_string(), "0.4233112");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).sub_prec_round_ref_ref(
    &Float::from(E),
    20,
    RoundingMode::Nearest
);
assert_eq!(sum.to_string(), "0.4233108");
assert_eq!(o, Ordering::Less);

pub fn sub_prec(self, other: Float, prec: u64) -> (Float, Ordering)

Subtracts two Floats, rounding the result to the nearest value of the specified precision. Both Floats are taken by value. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=f(x,\text{NaN},p)=f(\infty,\infty,p)=f(-\infty,-\infty,p)=\text{NaN}$
• $f(\infty,x,p)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty,p)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty,p)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0,p)=0.0$
• $f(-0.0,0.0,p)=-0.0$
• $f(0.0,0.0,p)=f(-0.0,-0.0,p,m)=0.0$ if $m$ is not Floor
• $f(0.0,0.0,p)=f(-0.0,-0.0,p,m)=-0.0$ if $m$ is Floor
• $f(x,x,p)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,x,p)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you want to use a rounding mode other than Nearest, consider using Float::sub_prec_round instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using - instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

use core::f64::consts::{E, PI};
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_prec(Float::from(E), 5);
assert_eq!(sum.to_string(), "0.42");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec(Float::from(E), 20);
assert_eq!(sum.to_string(), "0.4233108");
assert_eq!(o, Ordering::Less);

pub fn sub_prec_val_ref(self, other: &Float, prec: u64) -> (Float, Ordering)

Subtracts two Floats, rounding the result to the nearest value of the specified precision. The first Float is taken by value and the second by reference. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=f(x,\text{NaN},p)=f(\infty,\infty,p)=f(-\infty,-\infty,p)=\text{NaN}$
• $f(\infty,x,p)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty,p)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty,p)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0,p)=0.0$
• $f(-0.0,0.0,p)=-0.0$
• $f(0.0,0.0,p)=f(-0.0,-0.0,p,m)=0.0$ if $m$ is not Floor
• $f(0.0,0.0,p)=f(-0.0,-0.0,p,m)=-0.0$ if $m$ is Floor
• $f(x,x,p)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,x,p)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you want to use a rounding mode other than Nearest, consider using Float::sub_prec_round_val_ref instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using - instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

use core::f64::consts::{E, PI};
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_prec_val_ref(&Float::from(E), 5);
assert_eq!(sum.to_string(), "0.42");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec_val_ref(&Float::from(E), 20);
assert_eq!(sum.to_string(), "0.4233108");
assert_eq!(o, Ordering::Less);

pub fn sub_prec_ref_val(&self, other: Float, prec: u64) -> (Float, Ordering)

Subtracts two Floats, rounding the result to the nearest value of the specified precision. The first Float is taken by reference and the second by value. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=f(x,\text{NaN},p)=f(\infty,\infty,p)=f(-\infty,-\infty,p)=\text{NaN}$
• $f(\infty,x,p)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty,p)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty,p)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0,p)=0.0$
• $f(-0.0,0.0,p)=-0.0$
• $f(0.0,0.0,p)=f(-0.0,-0.0,p,m)=0.0$ if $m$ is not Floor
• $f(0.0,0.0,p)=f(-0.0,-0.0,p,m)=-0.0$ if $m$ is Floor
• $f(x,x,p)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,x,p)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you want to use a rounding mode other than Nearest, consider using Float::sub_prec_round_ref_val instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using - instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

use core::f64::consts::{E, PI};
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_prec_ref_val(Float::from(E), 5);
assert_eq!(sum.to_string(), "0.42");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec_ref_val(Float::from(E), 20);
assert_eq!(sum.to_string(), "0.4233108");
assert_eq!(o, Ordering::Less);

pub fn sub_prec_ref_ref(&self, other: &Float, prec: u64) -> (Float, Ordering)

Subtracts two Floats, rounding the result to the nearest value of the specified precision. Both Floats are taken by reference. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=f(x,\text{NaN},p)=f(\infty,\infty,p)=f(-\infty,-\infty,p)=\text{NaN}$
• $f(\infty,x,p)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty,p)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,p)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty,p)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0,p)=0.0$
• $f(-0.0,0.0,p)=-0.0$
• $f(0.0,0.0,p)=f(-0.0,-0.0,p,m)=0.0$ if $m$ is not Floor
• $f(0.0,0.0,p)=f(-0.0,-0.0,p,m)=-0.0$ if $m$ is Floor
• $f(x,x,p)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,x,p)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you want to use a rounding mode other than Nearest, consider using Float::sub_prec_round_ref_ref instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using - instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

use core::f64::consts::{E, PI};
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_prec_ref_ref(&Float::from(E), 5);
assert_eq!(sum.to_string(), "0.42");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_prec_ref_ref(&Float::from(E), 20);
assert_eq!(sum.to_string(), "0.4233108");
assert_eq!(o, Ordering::Less);

pub fn sub_round(self, other: Float, rm: RoundingMode) -> (Float, Ordering)

Subtracts two Floats, rounding the result with the specified rounding mode. Both Floats are taken by value. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the maximum of the precision of the inputs. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$, where $p$ is the maximum precision of the inputs.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

If the output has a precision, it is the maximum of the precisions of the inputs.

Special cases:

• $f(\text{NaN},x,m)=f(x,\text{NaN},m)=f(\infty,\infty,m)=f(-\infty,-\infty,m)= \text{NaN}$
• $f(\infty,x,m)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0,m)=0.0$
• $f(-0.0,0.0,m)=-0.0$
• $f(0.0,0.0,m)=f(-0.0,-0.0,m)=0.0$ if $m$ is not Floor
• $f(0.0,0.0,m)=f(-0.0,-0.0,m)=-0.0$ if $m$ is Floor
• $f(x,x,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,x,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::sub_prec_round instead. If you know you’ll be using the Nearest rounding mode, consider using - instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the maximum precision of the inputs is not high enough to represent the output.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_round(Float::from(-E), RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_round(Float::from(-E), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "5.859874482048839");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).sub_round(Float::from(-E), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

pub fn sub_round_val_ref( self, other: &Float, rm: RoundingMode ) -> (Float, Ordering)

Subtracts two Floats, rounding the result with the specified rounding mode. The Float is taken by value and the Rational by reference. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the maximum of the precision of the inputs. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$, where $p$ is the maximum precision of the inputs.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

If the output has a precision, it is the maximum of the precisions of the inputs.

Special cases:

• $f(\text{NaN},x,m)=f(x,\text{NaN},m)=f(\infty,\infty,m)=f(-\infty,-\infty,m)= \text{NaN}$
• $f(\infty,x,m)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0,m)=0.0$
• $f(-0.0,0.0,m)=-0.0$
• $f(0.0,0.0,m)=f(-0.0,-0.0,m)=0.0$ if $m$ is not Floor
• $f(0.0,0.0,m)=f(-0.0,-0.0,m)=-0.0$ if $m$ is Floor
• $f(x,x,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,x,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::sub_prec_round_val_ref instead. If you know you’ll be using the Nearest rounding mode, consider using - instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is max(self.significant_bits(), other.significant_bits()), and $m$ is other.significant_bits().

Panics

Panics if rm is RoundingMode::Exact but the maximum precision of the inputs is not high enough to represent the output.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_round_val_ref(&Float::from(-E), RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_round_val_ref(&Float::from(-E), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "5.859874482048839");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).sub_round_val_ref(&Float::from(-E), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

pub fn sub_round_ref_val( &self, other: Float, rm: RoundingMode ) -> (Float, Ordering)

Subtracts two Floats, rounding the result with the specified rounding mode. The Float is taken by reference and the Rational by value. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the maximum of the precision of the inputs. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$, where $p$ is the maximum precision of the inputs.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

If the output has a precision, it is the maximum of the precisions of the inputs.

Special cases:

• $f(\text{NaN},x,m)=f(x,\text{NaN},m)=f(\infty,\infty,m)=f(-\infty,-\infty,m)= \text{NaN}$
• $f(\infty,x,m)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0,m)=0.0$
• $f(-0.0,0.0,m)=-0.0$
• $f(0.0,0.0,m)=f(-0.0,-0.0,m)=0.0$ if $m$ is not Floor
• $f(0.0,0.0,m)=f(-0.0,-0.0,m)=-0.0$ if $m$ is Floor
• $f(x,x,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,x,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::sub_prec_round_ref_val instead. If you know you’ll be using the Nearest rounding mode, consider using - instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is max(self.significant_bits(), other.significant_bits()), and $m$ is self.significant_bits().

Panics

Panics if rm is RoundingMode::Exact but the maximum precision of the inputs is not high enough to represent the output.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_round_ref_val(Float::from(-E), RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_round_ref_val(Float::from(-E), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "5.859874482048839");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).sub_round_ref_val(Float::from(-E), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

pub fn sub_round_ref_ref( &self, other: &Float, rm: RoundingMode ) -> (Float, Ordering)

Subtracts two Floats, rounding the result with the specified rounding mode. Both Floats are taken by reference. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the maximum of the precision of the inputs. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$, where $p$ is the maximum precision of the inputs.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

If the output has a precision, it is the maximum of the precisions of the inputs.

Special cases:

• $f(\text{NaN},x,m)=f(x,\text{NaN},m)=f(\infty,\infty,m)=f(-\infty,-\infty,m)= \text{NaN}$
• $f(\infty,x,m)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0,m)=0.0$
• $f(-0.0,0.0,m)=-0.0$
• $f(0.0,0.0,m)=f(-0.0,-0.0,m)=0.0$ if $m$ is not Floor
• $f(0.0,0.0,m)=f(-0.0,-0.0,m)=-0.0$ if $m$ is Floor
• $f(x,x,m)=0.0$ if $x$ is finite and nonzero and $m$ is not Floor
• $f(x,x,m)=-0.0$ if $x$ is finite and nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::sub_prec_round_ref_ref instead. If you know you’ll be using the Nearest rounding mode, consider using - instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the maximum precision of the inputs is not high enough to represent the output.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_round_ref_ref(&Float::from(-E), RoundingMode::Floor);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_round_ref_ref(&Float::from(-E), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "5.859874482048839");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI).sub_round_ref_ref(&Float::from(-E), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "5.859874482048838");
assert_eq!(o, Ordering::Less);

pub fn sub_prec_round_assign( &mut self, other: Float, prec: u64, rm: RoundingMode ) -> Ordering

Subtracts a Float by a Float in place, rounding the result to the specified precision and with the specified rounding mode. The Float on the right-hand side is taken by value. An Ordering is returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ x \gets x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::sub_prec_round documentation for information on special cases.

If you know you’ll be using Nearest, consider using Float::sub_prec_assign instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using Float::sub_round_assign instead. If both of these things are true, consider using -= instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact subtraction.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(
    x.sub_prec_round_assign(Float::from(E), 5, RoundingMode::Floor),
    Ordering::Less
);
assert_eq!(x.to_string(), "0.42");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_prec_round_assign(Float::from(E), 5, RoundingMode::Ceiling),
    Ordering::Greater
);
assert_eq!(x.to_string(), "0.44");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_prec_round_assign(Float::from(E), 5, RoundingMode::Nearest),
    Ordering::Less
);
assert_eq!(x.to_string(), "0.42");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_prec_round_assign(Float::from(E), 20, RoundingMode::Floor),
    Ordering::Less
);
assert_eq!(x.to_string(), "0.4233108");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_prec_round_assign(Float::from(E), 20, RoundingMode::Ceiling),
    Ordering::Greater
);
assert_eq!(x.to_string(), "0.4233112");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_prec_round_assign(Float::from(E), 20, RoundingMode::Nearest),
    Ordering::Less
);
assert_eq!(x.to_string(), "0.4233108");

pub fn sub_prec_round_assign_ref( &mut self, other: &Float, prec: u64, rm: RoundingMode ) -> Ordering

Subtracts a Float by a Float in place, rounding the result to the specified precision and with the specified rounding mode. The Float on the right-hand side is taken by reference. An Ordering is returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ x \gets x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::sub_prec_round documentation for information on special cases.

If you know you’ll be using Nearest, consider using Float::sub_prec_assign_ref instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using Float::sub_round_assign instead. If both of these things are true, consider using -= instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact subtraction.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(
    x.sub_prec_round_assign_ref(&Float::from(E), 5, RoundingMode::Floor),
    Ordering::Less
);
assert_eq!(x.to_string(), "0.42");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_prec_round_assign_ref(&Float::from(E), 5, RoundingMode::Ceiling),
    Ordering::Greater
);
assert_eq!(x.to_string(), "0.44");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_prec_round_assign_ref(&Float::from(E), 5, RoundingMode::Nearest),
    Ordering::Less
);
assert_eq!(x.to_string(), "0.42");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_prec_round_assign_ref(&Float::from(E), 20, RoundingMode::Floor),
    Ordering::Less
);
assert_eq!(x.to_string(), "0.4233108");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_prec_round_assign_ref(&Float::from(E), 20, RoundingMode::Ceiling),
    Ordering::Greater
);
assert_eq!(x.to_string(), "0.4233112");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_prec_round_assign_ref(&Float::from(E), 20, RoundingMode::Nearest),
    Ordering::Less
);
assert_eq!(x.to_string(), "0.4233108");

pub fn sub_prec_assign(&mut self, other: Float, prec: u64) -> Ordering

Subtracts a Float by a Float in place, rounding the result to the nearest value of the specified precision. The Float on the right-hand side is taken by value. An Ordering is returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x \gets x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::sub_prec documentation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::sub_prec_round_assign instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using -= instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

use core::f64::consts::{E, PI};
use malachite_float::Float;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(x.sub_prec_assign(Float::from(E), 5), Ordering::Less);
assert_eq!(x.to_string(), "0.42");

let mut x = Float::from(PI);
assert_eq!(x.sub_prec_assign(Float::from(E), 20), Ordering::Less);
assert_eq!(x.to_string(), "0.4233108");

pub fn sub_prec_assign_ref(&mut self, other: &Float, prec: u64) -> Ordering

Subtracts a Float by a Float in place, rounding the result to the nearest value of the specified precision. The Float on the right-hand side is taken by reference. An Ordering is returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x \gets x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::sub_prec documentation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::sub_prec_round_assign_ref instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using -= instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

use core::f64::consts::{E, PI};
use malachite_float::Float;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(x.sub_prec_assign_ref(&Float::from(E), 5), Ordering::Less);
assert_eq!(x.to_string(), "0.42");

let mut x = Float::from(PI);
assert_eq!(x.sub_prec_assign_ref(&Float::from(E), 20), Ordering::Less);
assert_eq!(x.to_string(), "0.4233108");

pub fn sub_round_assign(&mut self, other: Float, rm: RoundingMode) -> Ordering

Subtracts a Float by a Float in place, rounding the result with the specified rounding mode. The Float on the right-hand side is taken by value. An Ordering is returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

The precision of the output is the maximum of the precision of the inputs. See RoundingMode for a description of the possible rounding modes.

$$ x \gets x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$, where $p$ is the maximum precision of the inputs.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

If the output has a precision, it is the maximum of the precisions of the inputs.

See the Float::sub_round documentation for information on special cases.

If you want to specify an output precision, consider using Float::sub_prec_round_assign instead. If you know you’ll be using the Nearest rounding mode, consider using -= instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the maximum precision of the inputs is not high enough to represent the output.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(x.sub_round_assign(Float::from(-E), RoundingMode::Floor), Ordering::Less);
assert_eq!(x.to_string(), "5.859874482048838");

let mut x = Float::from(PI);
assert_eq!(x.sub_round_assign(Float::from(-E), RoundingMode::Ceiling), Ordering::Greater);
assert_eq!(x.to_string(), "5.859874482048839");

let mut x = Float::from(PI);
assert_eq!(x.sub_round_assign(Float::from(-E), RoundingMode::Nearest), Ordering::Less);
assert_eq!(x.to_string(), "5.859874482048838");

pub fn sub_round_assign_ref( &mut self, other: &Float, rm: RoundingMode ) -> Ordering

Subtracts a Float by a Float in place, rounding the result with the specified rounding mode. The Float on the right-hand side is taken by reference. An Ordering is returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

The precision of the output is the maximum of the precision of the inputs. See RoundingMode for a description of the possible rounding modes.

$$ x \gets x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$, where $p$ is the maximum precision of the inputs.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

If the output has a precision, it is the maximum of the precisions of the inputs.

See the Float::sub_round documentation for information on special cases.

If you want to specify an output precision, consider using Float::sub_prec_round_assign_ref instead. If you know you’ll be using the Nearest rounding mode, consider using -= instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is max(self.significant_bits(), other.significant_bits()), and $m$ is other.significant_bits().

Panics

Panics if rm is RoundingMode::Exact but the maximum precision of the inputs is not high enough to represent the output.

Examples

use core::f64::consts::{E, PI};
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(x.sub_round_assign_ref(&Float::from(-E), RoundingMode::Floor), Ordering::Less);
assert_eq!(x.to_string(), "5.859874482048838");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_round_assign_ref(&Float::from(-E), RoundingMode::Ceiling),
    Ordering::Greater
);
assert_eq!(x.to_string(), "5.859874482048839");

let mut x = Float::from(PI);
assert_eq!(x.sub_round_assign_ref(&Float::from(-E), RoundingMode::Nearest), Ordering::Less);
assert_eq!(x.to_string(), "5.859874482048838");

pub fn sub_rational_prec_round( self, other: Rational, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Subtracts a Float by a Rational, rounding the result to the specified precision and with the specified rounding mode. The Float and the Rational are both taken by value. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=\text{NaN}$
• $f(\infty,x,p,m)=\infty$
• $f(-\infty,x,p,m)=-\infty$
• $f(0.0,0,p,m)=0.0$
• $f(-0.0,0,p,m)=-0.0$
• $f(x,x,p,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,x,p,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::sub_rational_prec instead. If you know that your target precision is the precision of the Float input, consider using Float::sub_rational_round instead. If both of these things are true, consider using - instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact subtraction.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round(Rational::from_unsigneds(1u8, 3), 5, RoundingMode::Floor);
assert_eq!(sum.to_string(), "2.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round(Rational::from_unsigneds(1u8, 3), 5, RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "2.9");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round(Rational::from_unsigneds(1u8, 3), 5, RoundingMode::Nearest);
assert_eq!(sum.to_string(), "2.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round(Rational::from_unsigneds(1u8, 3), 20, RoundingMode::Floor);
assert_eq!(sum.to_string(), "2.808258");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round(Rational::from_unsigneds(1u8, 3), 20, RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "2.808262");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round(Rational::from_unsigneds(1u8, 3), 20, RoundingMode::Nearest);
assert_eq!(sum.to_string(), "2.808258");
assert_eq!(o, Ordering::Less);

pub fn sub_rational_prec_round_val_ref( self, other: &Rational, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Subtracts a Float by a Rational, rounding the result to the specified precision and with the specified rounding mode. The Float is taken by value and the Rational by reference. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=\text{NaN}$
• $f(\infty,x,p,m)=\infty$
• $f(-\infty,x,p,m)=-\infty$
• $f(0.0,0,p,m)=0.0$
• $f(-0.0,0,p,m)=-0.0$
• $f(x,x,p,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,x,p,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::sub_rational_prec_val_ref instead. If you know that your target precision is the precision of the Float input, consider using Float::sub_rational_round_val_ref instead. If both of these things are true, consider using - instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact subtraction.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_val_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Floor
    );
assert_eq!(sum.to_string(), "2.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_val_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Ceiling
    );
assert_eq!(sum.to_string(), "2.9");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_val_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Nearest
    );
assert_eq!(sum.to_string(), "2.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_val_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Floor
    );
assert_eq!(sum.to_string(), "2.808258");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_val_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Ceiling
    );
assert_eq!(sum.to_string(), "2.808262");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_val_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Nearest
    );
assert_eq!(sum.to_string(), "2.808258");
assert_eq!(o, Ordering::Less);

pub fn sub_rational_prec_round_ref_val( &self, other: Rational, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Subtracts a Float by a Rational, rounding the result to the specified precision and with the specified rounding mode. The Float is taken by reference and the Rational by value. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=\text{NaN}$
• $f(\infty,x,p,m)=\infty$
• $f(-\infty,x,p,m)=-\infty$
• $f(0.0,0,p,m)=0.0$
• $f(-0.0,0,p,m)=-0.0$
• $f(x,x,p,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,x,p,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::sub_rational_prec_ref_val instead. If you know that your target precision is the precision of the Float input, consider using Float::sub_rational_round_ref_val instead. If both of these things are true, consider using - instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact subtraction.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_ref_val(
        Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Floor
    );
assert_eq!(sum.to_string(), "2.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_ref_val(
        Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Ceiling
    );
assert_eq!(sum.to_string(), "2.9");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_ref_val(
        Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Nearest
    );
assert_eq!(sum.to_string(), "2.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_ref_val(
        Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Floor
    );
assert_eq!(sum.to_string(), "2.808258");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_ref_val(
        Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Ceiling
    );
assert_eq!(sum.to_string(), "2.808262");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_ref_val(
        Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Nearest
    );
assert_eq!(sum.to_string(), "2.808258");
assert_eq!(o, Ordering::Less);

pub fn sub_rational_prec_round_ref_ref( &self, other: &Rational, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Subtracts a Float by a Rational, rounding the result to the specified precision and with the specified rounding mode. The Float and the Rational are both taken by reference. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,p,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p,m)=\text{NaN}$
• $f(\infty,x,p,m)=\infty$
• $f(-\infty,x,p,m)=-\infty$
• $f(0.0,0,p,m)=0.0$
• $f(-0.0,0,p,m)=-0.0$
• $f(x,x,p,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,x,p,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you know you’ll be using Nearest, consider using Float::sub_rational_prec_ref_ref instead. If you know that your target precision is the precision of the Float input, consider using Float::sub_rational_round_ref_ref instead. If both of these things are true, consider using - instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact subtraction.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_ref_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Floor
    );
assert_eq!(sum.to_string(), "2.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_ref_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Ceiling
    );
assert_eq!(sum.to_string(), "2.9");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_ref_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Nearest
    );
assert_eq!(sum.to_string(), "2.8");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_ref_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Floor
    );
assert_eq!(sum.to_string(), "2.808258");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_ref_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Ceiling
    );
assert_eq!(sum.to_string(), "2.808262");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .sub_rational_prec_round_ref_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Nearest
    );
assert_eq!(sum.to_string(), "2.808258");
assert_eq!(o, Ordering::Less);

pub fn sub_rational_prec(self, other: Rational, prec: u64) -> (Float, Ordering)

Subtracts a Float by a Rational, rounding the result to the nearest value of the specified precision. The Float and the Rational are both are taken by value. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=\text{NaN}$
• $f(\infty,x,p)=\infty$
• $f(-\infty,x,p)=-\infty$
• $f(0.0,0,p)=0.0$
• $f(-0.0,0,p)=-0.0$
• $f(x,x,p)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::sub_rational_prec_round instead. If you know that your target precision is the precision of the Float input, consider using - instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Examples

use core::f64::consts::PI;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_rational_prec(Rational::exact_from(1.5), 5);
assert_eq!(sum.to_string(), "1.62");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_rational_prec(Rational::exact_from(1.5), 20);
assert_eq!(sum.to_string(), "1.641592");
assert_eq!(o, Ordering::Less);

pub fn sub_rational_prec_val_ref( self, other: &Rational, prec: u64 ) -> (Float, Ordering)

Subtracts a Float by a Rational, rounding the result to the nearest value of the specified precision. The Float is taken by value and the Rational by reference. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=\text{NaN}$
• $f(\infty,x,p)=\infty$
• $f(-\infty,x,p)=-\infty$
• $f(0.0,0,p)=0.0$
• $f(-0.0,0,p)=-0.0$
• $f(x,x,p)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::sub_rational_prec_round_val_ref instead. If you know that your target precision is the precision of the Float input, consider using - instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Examples

use core::f64::consts::PI;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_rational_prec_val_ref(&Rational::exact_from(1.5), 5);
assert_eq!(sum.to_string(), "1.62");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_rational_prec_val_ref(&Rational::exact_from(1.5), 20);
assert_eq!(sum.to_string(), "1.641592");
assert_eq!(o, Ordering::Less);

pub fn sub_rational_prec_ref_val( &self, other: Rational, prec: u64 ) -> (Float, Ordering)

Subtracts a Float by a Rational, rounding the result to the nearest value of the specified precision. The Float is taken by reference and the Rational by value. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=\text{NaN}$
• $f(\infty,x,p)=\infty$
• $f(-\infty,x,p)=-\infty$
• $f(0.0,0,p)=0.0$
• $f(-0.0,0,p)=-0.0$
• $f(x,x,p)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::sub_rational_prec_round_ref_val instead. If you know that your target precision is the precision of the Float input, consider using - instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Examples

use core::f64::consts::PI;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_rational_prec_ref_val(Rational::exact_from(1.5), 5);
assert_eq!(sum.to_string(), "1.62");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_rational_prec_ref_val(Rational::exact_from(1.5), 20);
assert_eq!(sum.to_string(), "1.641592");
assert_eq!(o, Ordering::Less);

pub fn sub_rational_prec_ref_ref( &self, other: &Rational, prec: u64 ) -> (Float, Ordering)

Subtracts a Float by a Rational, rounding the result to the nearest value of the specified precision. The Float and the Rational are both are taken by reference. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y,p) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

Special cases:

• $f(\text{NaN},x,p)=\text{NaN}$
• $f(\infty,x,p)=\infty$
• $f(-\infty,x,p)=-\infty$
• $f(0.0,0,p)=0.0$
• $f(-0.0,0,p)=-0.0$
• $f(x,x,p)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::sub_rational_prec_round_ref_ref instead. If you know that your target precision is the precision of the Float input, consider using - instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Examples

use core::f64::consts::PI;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI).sub_rational_prec_ref_ref(&Rational::exact_from(1.5), 5);
assert_eq!(sum.to_string(), "1.62");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI).sub_rational_prec_ref_ref(&Rational::exact_from(1.5), 20);
assert_eq!(sum.to_string(), "1.641592");
assert_eq!(o, Ordering::Less);

pub fn sub_rational_round( self, other: Rational, rm: RoundingMode ) -> (Float, Ordering)

Subtracts a Float by a Rational, rounding the result with the specified rounding mode. The Float and the Rational are both are taken by value. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the precision of the Float input. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$, where $p$ is the precision of the input Float.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

If the output has a precision, it is the precision of the Float input.

Special cases:

• $f(\text{NaN},x,m)=\text{NaN}$
• $f(\infty,x,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0,m)=0.0$
• $f(-0.0,0,m)=-0.0$
• $f(x,0,m)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(0.0,x,m)=f(-0.0,x,m)=-x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,x,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,x,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::sub_rational_prec_round instead. If you know you’ll be using the Nearest rounding mode, consider using - instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the precision of the Float input is not high enough to represent the output.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .sub_rational_round(Rational::from_unsigneds(1u8, 3), RoundingMode::Floor);
assert_eq!(sum.to_string(), "2.8082593202564596");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_round(Rational::from_unsigneds(1u8, 3), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "2.8082593202564601");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .sub_rational_round(Rational::from_unsigneds(1u8, 3), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "2.8082593202564596");
assert_eq!(o, Ordering::Less);

pub fn sub_rational_round_val_ref( self, other: &Rational, rm: RoundingMode ) -> (Float, Ordering)

Subtracts a Float by a Rational, rounding the result with the specified rounding mode. The Float is taken by value and the Rational by reference. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the precision of the Float input. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$, where $p$ is the precision of the input Float.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

If the output has a precision, it is the precision of the Float input.

Special cases:

• $f(\text{NaN},x,m)=\text{NaN}$
• $f(\infty,x,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0,m)=0.0$
• $f(-0.0,0,m)=-0.0$
• $f(x,0,m)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(0.0,x,m)=f(-0.0,x,m)=-x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,x,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,x,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::sub_rational_prec_round_val_ref instead. If you know you’ll be using the Nearest rounding mode, consider using - instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the precision of the Float input is not high enough to represent the output.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .sub_rational_round_val_ref(&Rational::from_unsigneds(1u8, 3), RoundingMode::Floor);
assert_eq!(sum.to_string(), "2.8082593202564596");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_round_val_ref(&Rational::from_unsigneds(1u8, 3), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "2.8082593202564601");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .sub_rational_round_val_ref(&Rational::from_unsigneds(1u8, 3), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "2.8082593202564596");
assert_eq!(o, Ordering::Less);

pub fn sub_rational_round_ref_val( &self, other: Rational, rm: RoundingMode ) -> (Float, Ordering)

Subtracts a Float by a Rational, rounding the result with the specified rounding mode. The Float is taken by reference and the Rational by value. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the precision of the Float input. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$, where $p$ is the precision of the input Float.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

If the output has a precision, it is the precision of the Float input.

Special cases:

• $f(\text{NaN},x,m)=\text{NaN}$
• $f(\infty,x,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0,m)=0.0$
• $f(-0.0,0,m)=-0.0$
• $f(x,0,m)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(0.0,x,m)=f(-0.0,x,m)=-x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,x,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,x,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::sub_rational_prec_round_ref_val instead. If you know you’ll be using the Nearest rounding mode, consider using - instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the precision of the Float input is not high enough to represent the output.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .sub_rational_round_ref_val(Rational::from_unsigneds(1u8, 3), RoundingMode::Floor);
assert_eq!(sum.to_string(), "2.8082593202564596");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_round_ref_val(Rational::from_unsigneds(1u8, 3), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "2.8082593202564601");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .sub_rational_round_ref_val(Rational::from_unsigneds(1u8, 3), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "2.8082593202564596");
assert_eq!(o, Ordering::Less);

pub fn sub_rational_round_ref_ref( &self, other: &Rational, rm: RoundingMode ) -> (Float, Ordering)

Subtracts a Float by a Rational, rounding the result with the specified rounding mode. The Float and the Rational are both are taken by reference. An Ordering is also returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function returns a NaN it also returns Ordering::Equal.

The precision of the output is the precision of the Float input. See RoundingMode for a description of the possible rounding modes.

$$ f(x,y,m) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$, where $p$ is the precision of the input Float.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

If the output has a precision, it is the precision of the Float input.

Special cases:

• $f(\text{NaN},x,m)=\text{NaN}$
• $f(\infty,x,m)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x,m)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0,m)=0.0$
• $f(-0.0,0,m)=-0.0$
• $f(x,0,m)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(0.0,x,m)=f(-0.0,x,m)=-x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,x,m)=0.0$ if $x$ is nonzero and $m$ is not Floor
• $f(x,x,m)=-0.0$ if $x$ is nonzero and $m$ is Floor

If you want to specify an output precision, consider using Float::sub_rational_prec_round_ref_ref instead. If you know you’ll be using the Nearest rounding mode, consider using - instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the precision of the Float input is not high enough to represent the output.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (sum, o) = Float::from(PI)
    .sub_rational_round_ref_ref(&Rational::from_unsigneds(1u8, 3), RoundingMode::Floor);
assert_eq!(sum.to_string(), "2.8082593202564596");
assert_eq!(o, Ordering::Less);

let (sum, o) = Float::from(PI)
    .sub_rational_round_ref_ref(&Rational::from_unsigneds(1u8, 3), RoundingMode::Ceiling);
assert_eq!(sum.to_string(), "2.8082593202564601");
assert_eq!(o, Ordering::Greater);

let (sum, o) = Float::from(PI)
    .sub_rational_round_ref_ref(&Rational::from_unsigneds(1u8, 3), RoundingMode::Nearest);
assert_eq!(sum.to_string(), "2.8082593202564596");
assert_eq!(o, Ordering::Less);

pub fn sub_rational_prec_round_assign( &mut self, other: Rational, prec: u64, rm: RoundingMode ) -> Ordering

Subtracts a Rational by a Float in place, rounding the result to the specified precision and with the specified rounding mode. The Rational is taken by value. An Ordering is returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ x \gets x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::sub_rational_prec_round documentation for information on special cases.

If you know you’ll be using Nearest, consider using Float::sub_rational_prec_assign instead. If you know that your target precision is the precision of the Float input, consider using Float::sub_rational_round_assign instead. If both of these things are true, consider using -= instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact subtraction.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_prec_round_assign(
        Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Floor
    ),
    Ordering::Less
);
assert_eq!(x.to_string(), "2.8");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_prec_round_assign(
        Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Ceiling
    ),
    Ordering::Greater
);
assert_eq!(x.to_string(), "2.9");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_prec_round_assign(
        Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Nearest
    ),
    Ordering::Less
);
assert_eq!(x.to_string(), "2.8");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_prec_round_assign(
        Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Floor
    ),
    Ordering::Less
);
assert_eq!(x.to_string(), "2.808258");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_prec_round_assign(
        Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Ceiling
    ),
    Ordering::Greater
);
assert_eq!(x.to_string(), "2.808262");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_prec_round_assign(
        Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Nearest
    ),
    Ordering::Less
);
assert_eq!(x.to_string(), "2.808258");

pub fn sub_rational_prec_round_assign_ref( &mut self, other: &Rational, prec: u64, rm: RoundingMode ) -> Ordering

Subtracts a Rational by a Float in place, rounding the result to the specified precision and with the specified rounding mode. The Rational is taken by reference. An Ordering is returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

See RoundingMode for a description of the possible rounding modes.

$$ x \gets x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::sub_rational_prec_round documentation for information on special cases.

If you know you’ll be using Nearest, consider using Float::sub_rational_prec_assign_ref instead. If you know that your target precision is the precision of the Float input, consider using Float::sub_rational_round_assign_ref instead. If both of these things are true, consider using -= instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Panics

Panics if rm is RoundingMode::Exact but prec is too small for an exact subtraction.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_prec_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Floor
    ),
    Ordering::Less
);
assert_eq!(x.to_string(), "2.8");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_prec_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Ceiling
    ),
    Ordering::Greater
);
assert_eq!(x.to_string(), "2.9");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_prec_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        5,
        RoundingMode::Nearest
    ),
    Ordering::Less
);
assert_eq!(x.to_string(), "2.8");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_prec_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Floor
    ),
    Ordering::Less
);
assert_eq!(x.to_string(), "2.808258");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_prec_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Ceiling
    ),
    Ordering::Greater
);
assert_eq!(x.to_string(), "2.808262");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_prec_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        20,
        RoundingMode::Nearest
    ),
    Ordering::Less
);
assert_eq!(x.to_string(), "2.808258");

pub fn sub_rational_prec_assign( &mut self, other: Rational, prec: u64 ) -> Ordering

Subtracts a Rational by a Float in place, rounding the result to the nearest value of the specified precision. The Rational is taken by value. An Ordering is returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x \gets x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::sub_rational_prec documentation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::sub_rational_prec_round_assign instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using -= instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Examples

use core::f64::consts::PI;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(x.sub_rational_prec_assign(Rational::exact_from(1.5), 5), Ordering::Less);
assert_eq!(x.to_string(), "1.62");

let mut x = Float::from(PI);
assert_eq!(x.sub_rational_prec_assign(Rational::exact_from(1.5), 20), Ordering::Less);
assert_eq!(x.to_string(), "1.641592");

pub fn sub_rational_prec_assign_ref( &mut self, other: &Rational, prec: u64 ) -> Ordering

Subtracts a Rational by a Float in place, rounding the result to the nearest value of the specified precision. The Rational is taken by reference. An Ordering is returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x \gets x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$.

If the output has a precision, it is prec.

See the Float::sub_rational_prec_val_ref documentation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::sub_rational_prec_round_assign_ref instead. If you know that your target precision is the maximum of the precisions of the two inputs, consider using -= instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(other.significant_bits(), prec).

Examples

use core::f64::consts::PI;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(x.sub_rational_prec_assign_ref(&Rational::exact_from(1.5), 5), Ordering::Less);
assert_eq!(x.to_string(), "1.62");

let mut x = Float::from(PI);
assert_eq!(x.sub_rational_prec_assign_ref(&Rational::exact_from(1.5), 20), Ordering::Less);
assert_eq!(x.to_string(), "1.641592");

pub fn sub_rational_round_assign( &mut self, other: Rational, rm: RoundingMode ) -> Ordering

Subtracts a Rational by a Float in place, rounding the result with the specified rounding mode. The Rational is taken by value. An Ordering is returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

The precision of the output is the precision of the input Float. See RoundingMode for a description of the possible rounding modes.

$$ x \gets x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$, where $p$ is the precision of the input Float.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

If the output has a precision, it is the precision of the input Float.

See the Float::sub_rational_round documentation for information on special cases.

If you want to specify an output precision, consider using Float::sub_rational_prec_round_assign instead. If you know you’ll be using the Nearest rounding mode, consider using -= instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the precision of the input Float is not high enough to represent the output.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_round_assign(Rational::from_unsigneds(1u8, 3), RoundingMode::Floor),
    Ordering::Less
);
assert_eq!(x.to_string(), "2.8082593202564596");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_round_assign(Rational::from_unsigneds(1u8, 3), RoundingMode::Ceiling),
    Ordering::Greater
);
assert_eq!(x.to_string(), "2.8082593202564601");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_round_assign(Rational::from_unsigneds(1u8, 3), RoundingMode::Nearest),
    Ordering::Less
);
assert_eq!(x.to_string(), "2.8082593202564596");

pub fn sub_rational_round_assign_ref( &mut self, other: &Rational, rm: RoundingMode ) -> Ordering

Subtracts a Rational by a Float in place, rounding the result with the specified rounding mode. The Rational is taken by reference. An Ordering is returned, indicating whether the rounded difference is less than, equal to, or greater than the exact difference. Although NaNs are not comparable to any other Float, whenever this function sets the Float to NaN it also returns Ordering::Equal.

The precision of the output is the precision of the input Float. See RoundingMode for a description of the possible rounding modes.

$$ x \gets x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, and $m$ is not Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p+1}$, where $p$ is the precision of the input Float.
• If $x-y$ is finite and nonzero, and $m$ is Nearest, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

If the output has a precision, it is the precision of the input Float.

See the Float::sub_rational_round_val_ref documentation for information on special cases.

If you want to specify an output precision, consider using Float::sub_rational_prec_round_assign_ref instead. If you know you’ll be using the Nearest rounding mode, consider using -= instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Panics

Panics if rm is RoundingMode::Exact but the precision of the input Float is not high enough to represent the output.

Examples

use core::f64::consts::PI;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        RoundingMode::Floor
    ),
    Ordering::Less
);
assert_eq!(x.to_string(), "2.8082593202564596");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        RoundingMode::Ceiling
    ),
    Ordering::Greater
);
assert_eq!(x.to_string(), "2.8082593202564601");

let mut x = Float::from(PI);
assert_eq!(
    x.sub_rational_round_assign_ref(
        &Rational::from_unsigneds(1u8, 3),
        RoundingMode::Nearest
    ),
    Ordering::Less
);
assert_eq!(x.to_string(), "2.8082593202564596");

impl Float

pub const fn is_nan(&self) -> bool

Determines whether a Float is NaN.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{NaN, One};
use malachite_float::Float;

assert_eq!(Float::NAN.is_nan(), true);
assert_eq!(Float::ONE.is_nan(), false);

pub const fn is_finite(&self) -> bool

Determines whether a Float is finite.

NaN is not finite.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, One};
use malachite_float::Float;

assert_eq!(Float::NAN.is_finite(), false);
assert_eq!(Float::INFINITY.is_finite(), false);
assert_eq!(Float::ONE.is_finite(), true);

pub const fn is_infinite(&self) -> bool

Determines whether a Float is infinite.

NaN is not infinite.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, One};
use malachite_float::Float;

assert_eq!(Float::NAN.is_infinite(), false);
assert_eq!(Float::INFINITY.is_infinite(), true);
assert_eq!(Float::ONE.is_infinite(), false);

pub const fn is_positive_zero(&self) -> bool

Determines whether a Float is positive zero.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeZero, One, Zero};
use malachite_float::Float;

assert_eq!(Float::NAN.is_positive_zero(), false);
assert_eq!(Float::INFINITY.is_positive_zero(), false);
assert_eq!(Float::ONE.is_positive_zero(), false);
assert_eq!(Float::ZERO.is_positive_zero(), true);
assert_eq!(Float::NEGATIVE_ZERO.is_positive_zero(), false);

pub const fn is_negative_zero(&self) -> bool

Determines whether a Float is negative zero.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeZero, One, Zero};
use malachite_float::Float;

assert_eq!(Float::NAN.is_negative_zero(), false);
assert_eq!(Float::INFINITY.is_negative_zero(), false);
assert_eq!(Float::ONE.is_negative_zero(), false);
assert_eq!(Float::ZERO.is_negative_zero(), false);
assert_eq!(Float::NEGATIVE_ZERO.is_negative_zero(), true);

pub const fn is_zero(&self) -> bool

Determines whether a Float is zero (positive or negative).

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeZero, One, Zero};
use malachite_float::Float;

assert_eq!(Float::NAN.is_zero(), false);
assert_eq!(Float::INFINITY.is_zero(), false);
assert_eq!(Float::ONE.is_zero(), false);
assert_eq!(Float::ZERO.is_zero(), true);
assert_eq!(Float::NEGATIVE_ZERO.is_zero(), true);

pub const fn is_normal(&self) -> bool

Determines whether a Float is normal, that is, finite and nonzero.

There is no notion of subnormal Floats.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeZero, One, Zero};
use malachite_float::Float;

assert_eq!(Float::NAN.is_normal(), false);
assert_eq!(Float::INFINITY.is_normal(), false);
assert_eq!(Float::ZERO.is_normal(), false);
assert_eq!(Float::NEGATIVE_ZERO.is_normal(), false);
assert_eq!(Float::ONE.is_normal(), true);

pub const fn is_sign_positive(&self) -> bool

Determines whether a Float’s sign is positive.

A NaN has no sign, so this function returns false when given a NaN.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::Float;

assert_eq!(Float::NAN.is_sign_positive(), false);
assert_eq!(Float::INFINITY.is_sign_positive(), true);
assert_eq!(Float::NEGATIVE_INFINITY.is_sign_positive(), false);
assert_eq!(Float::ZERO.is_sign_positive(), true);
assert_eq!(Float::NEGATIVE_ZERO.is_sign_positive(), false);
assert_eq!(Float::ONE.is_sign_positive(), true);
assert_eq!(Float::NEGATIVE_ONE.is_sign_positive(), false);

pub const fn is_sign_negative(&self) -> bool

Determines whether a Float’s sign is negative.

A NaN has no sign, so this function returns false when given a NaN.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::Float;

assert_eq!(Float::NAN.is_sign_negative(), false);
assert_eq!(Float::INFINITY.is_sign_negative(), false);
assert_eq!(Float::NEGATIVE_INFINITY.is_sign_negative(), true);
assert_eq!(Float::ZERO.is_sign_negative(), false);
assert_eq!(Float::NEGATIVE_ZERO.is_sign_negative(), true);
assert_eq!(Float::ONE.is_sign_negative(), false);
assert_eq!(Float::NEGATIVE_ONE.is_sign_negative(), true);

pub const fn classify(&self) -> FpCategory

Classifies a Float into one of several categories.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::Float;
use std::num::FpCategory;

assert_eq!(Float::NAN.classify(), FpCategory::Nan);
assert_eq!(Float::INFINITY.classify(), FpCategory::Infinite);
assert_eq!(Float::NEGATIVE_INFINITY.classify(), FpCategory::Infinite);
assert_eq!(Float::ZERO.classify(), FpCategory::Zero);
assert_eq!(Float::NEGATIVE_ZERO.classify(), FpCategory::Zero);
assert_eq!(Float::ONE.classify(), FpCategory::Normal);
assert_eq!(Float::NEGATIVE_ONE.classify(), FpCategory::Normal);

pub fn into_non_nan(self) -> Option<Float>

Turns a NaN into a None and wraps any non-NaN Float with a Some. The Float is taken by value.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeZero, One, Zero};
use malachite_float::Float;

assert_eq!(Float::NAN.into_non_nan(), None);
assert_eq!(Float::INFINITY.into_non_nan(), Some(Float::INFINITY));
assert_eq!(Float::ZERO.into_non_nan(), Some(Float::ZERO));
assert_eq!(Float::NEGATIVE_ZERO.into_non_nan(), Some(Float::NEGATIVE_ZERO));
assert_eq!(Float::ONE.into_non_nan(), Some(Float::ONE));

pub fn to_non_nan(&self) -> Option<Float>

Turns a NaN into a None and wraps any non-NaN Float with a Some. The Float is taken by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeZero, One, Zero};
use malachite_float::Float;

assert_eq!(Float::NAN.to_non_nan(), None);
assert_eq!(Float::INFINITY.to_non_nan(), Some(Float::INFINITY));
assert_eq!(Float::ZERO.to_non_nan(), Some(Float::ZERO));
assert_eq!(Float::NEGATIVE_ZERO.to_non_nan(), Some(Float::NEGATIVE_ZERO));
assert_eq!(Float::ONE.to_non_nan(), Some(Float::ONE));

pub fn into_finite(self) -> Option<Float>

Turns any Float that’s NaN or infinite into a None and wraps any finite Float with a Some. The Float is taken by value.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeZero, One, Zero};
use malachite_float::Float;

assert_eq!(Float::NAN.into_finite(), None);
assert_eq!(Float::INFINITY.into_finite(), None);
assert_eq!(Float::ZERO.into_finite(), Some(Float::ZERO));
assert_eq!(Float::NEGATIVE_ZERO.into_finite(), Some(Float::NEGATIVE_ZERO));
assert_eq!(Float::ONE.into_finite(), Some(Float::ONE));

pub fn to_finite(&self) -> Option<Float>

Turns any Float that’s NaN or infinite into a None and wraps any finite Float with a Some. The Float is taken by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeZero, One, Zero};
use malachite_float::Float;

assert_eq!(Float::NAN.to_finite(), None);
assert_eq!(Float::INFINITY.to_finite(), None);
assert_eq!(Float::ZERO.to_finite(), Some(Float::ZERO));
assert_eq!(Float::NEGATIVE_ZERO.to_finite(), Some(Float::NEGATIVE_ZERO));
assert_eq!(Float::ONE.to_finite(), Some(Float::ONE));

impl Float

pub fn complexity(&self) -> u64

Determines a Float’s complexity. The complexity is defined as follows:

$$ f(\text{NaN}) = f(\pm\infty) = f(\pm 0.0) = 1, $$

and, if $x$ is finite and nonzero,

$$ f(x) = \max(|\lfloor \log_2 x\rfloor|, p), $$

where $p$ is the precision of $x$.

Informally, the complexity is proportional to the number of characters you would need to write the Float out without using exponents.

See also the Float implementation of SignificantBits.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::basic::traits::{NaN, One};
use malachite_float::Float;

assert_eq!(Float::NAN.complexity(), 1);
assert_eq!(Float::ONE.complexity(), 1);
assert_eq!(Float::one_prec(100).complexity(), 100);
assert_eq!(Float::from(std::f64::consts::PI).complexity(), 53);
assert_eq!(Float::power_of_2(100u64).complexity(), 100);
assert_eq!(Float::power_of_2(-100i64).complexity(), 100);

impl Float

pub fn one_prec(prec: u64) -> Float

Returns the number 1, with the given precision.

$$ f(p) = 1, $$

and the output has precision $p$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is p.

Panics

Panics if p is zero.

Examples

use malachite_float::Float;

assert_eq!(Float::one_prec(1), 1);
assert_eq!(Float::one_prec(10), 1);
assert_eq!(Float::one_prec(100), 1);

assert_eq!(Float::one_prec(1).get_prec(), Some(1));
assert_eq!(Float::one_prec(10).get_prec(), Some(10));
assert_eq!(Float::one_prec(100).get_prec(), Some(100));

pub fn two_prec(prec: u64) -> Float

Returns the number 2, with the given precision.

$$ f(p) = 2, $$

and the output has precision $p$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is p.

Panics

Panics if p is zero.

Examples

use malachite_float::Float;

assert_eq!(Float::two_prec(1), 2);
assert_eq!(Float::two_prec(10), 2);
assert_eq!(Float::two_prec(100), 2);

assert_eq!(Float::two_prec(1).get_prec(), Some(1));
assert_eq!(Float::two_prec(10).get_prec(), Some(10));
assert_eq!(Float::two_prec(100).get_prec(), Some(100));

pub fn negative_one_prec(prec: u64) -> Float

Returns the number $-1$, with the given precision.

$$ f(p) = -1, $$

and the output has precision $p$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is p.

Panics

Panics if p is zero.

Examples

use malachite_float::Float;

assert_eq!(Float::negative_one_prec(1), -1);
assert_eq!(Float::negative_one_prec(10), -1);
assert_eq!(Float::negative_one_prec(100), -1);

assert_eq!(Float::negative_one_prec(1).get_prec(), Some(1));
assert_eq!(Float::negative_one_prec(10).get_prec(), Some(10));
assert_eq!(Float::negative_one_prec(100).get_prec(), Some(100));

pub fn one_half_prec(prec: u64) -> Float

Returns the number 0.5, with the given precision.

$$ f(p) = 0.5, $$

and the output has precision $p$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is p.

Panics

Panics if p is zero.

Examples

use malachite_float::Float;

assert_eq!(Float::one_half_prec(1), 0.5);
assert_eq!(Float::one_half_prec(10), 0.5);
assert_eq!(Float::one_half_prec(100), 0.5);

assert_eq!(Float::one_half_prec(1).get_prec(), Some(1));
assert_eq!(Float::one_half_prec(10).get_prec(), Some(10));
assert_eq!(Float::one_half_prec(100).get_prec(), Some(100));

impl Float

pub fn to_significand(&self) -> Option<Natural>

Gets the significand of a Float, taking the Float by value.

The significand is the smallest positive integer which is some power of 2 times the Float, and whose number of significant bits is a multiple of the limb width. If the Float is NaN, infinite, or zero, then None is returned.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::basic::traits::{Infinity, NaN, One, Zero};
use malachite_nz::natural::Natural;
use malachite_float::Float;

assert_eq!(Float::NAN.to_significand(), None);
assert_eq!(Float::INFINITY.to_significand(), None);
assert_eq!(Float::ZERO.to_significand(), None);

#[cfg(not(feature = "32_bit_limbs"))]
{
    assert_eq!(Float::ONE.to_significand(), Some(Natural::power_of_2(63)));
    assert_eq!(
        Float::from(std::f64::consts::PI).to_significand().unwrap(),
        14488038916154245120u64
    );
}

pub fn into_significand(self) -> Option<Natural>

Gets the significand of a Float, taking the Float by reference.

The significand is the smallest positive integer which is some power of 2 times the Float, and whose number of significant bits is a multiple of the limb width. If the Float is NaN, infinite, or zero, then None is returned.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::basic::traits::{Infinity, NaN, One, Zero};
use malachite_nz::natural::Natural;
use malachite_float::Float;

assert_eq!(Float::NAN.into_significand(), None);
assert_eq!(Float::INFINITY.into_significand(), None);
assert_eq!(Float::ZERO.into_significand(), None);

#[cfg(not(feature = "32_bit_limbs"))]
{
    assert_eq!(Float::ONE.into_significand(), Some(Natural::power_of_2(63)));
    assert_eq!(
        Float::from(std::f64::consts::PI).into_significand().unwrap(),
        14488038916154245120u64
    );
}

pub const fn significand_ref(&self) -> Option<&Natural>

Returns a reference to the significand of a Float.

The significand is the smallest positive integer which is some power of 2 times the Float, and whose number of significant bits is a multiple of the limb width. If the Float is NaN, infinite, or zero, then None is returned.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::basic::traits::{Infinity, NaN, One, Zero};
use malachite_nz::natural::Natural;
use malachite_float::Float;

assert_eq!(Float::NAN.significand_ref(), None);
assert_eq!(Float::INFINITY.significand_ref(), None);
assert_eq!(Float::ZERO.significand_ref(), None);

#[cfg(not(feature = "32_bit_limbs"))]
{
    assert_eq!(*Float::ONE.significand_ref().unwrap(), Natural::power_of_2(63));
    assert_eq!(
        *Float::from(std::f64::consts::PI).significand_ref().unwrap(),
        14488038916154245120u64
    );
}

pub const fn get_exponent(&self) -> Option<i64>

Returns a Float’s exponent.

$$ f(\text{NaN}) = f(\pm\infty) = f(\pm 0.0) = \text{None}, $$

and, if $x$ is finite and nonzero,

$$ f(x) = \operatorname{Some}(\lfloor \log_2 x \rfloor + 1). $$

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::basic::traits::{Infinity, NaN, One, Zero};
use malachite_nz::natural::Natural;
use malachite_float::Float;

assert_eq!(Float::NAN.get_exponent(), None);
assert_eq!(Float::INFINITY.get_exponent(), None);
assert_eq!(Float::ZERO.get_exponent(), None);

assert_eq!(Float::ONE.get_exponent(), Some(1));
assert_eq!(Float::from(std::f64::consts::PI).get_exponent(), Some(2));
assert_eq!(Float::power_of_2(100u64).get_exponent(), Some(101));
assert_eq!(Float::power_of_2(-100i64).get_exponent(), Some(-99));

pub const fn get_prec(&self) -> Option<u64>

Returns a Float’s precision. The precision is a positive integer denoting how many of the Float’s bits are significant.

Only Floats that are finite and nonzero have a precision. For other Floats, None is returned.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, One, Zero};
use malachite_nz::natural::Natural;
use malachite_float::Float;

assert_eq!(Float::NAN.get_prec(), None);
assert_eq!(Float::INFINITY.get_prec(), None);
assert_eq!(Float::ZERO.get_prec(), None);

assert_eq!(Float::ONE.get_prec(), Some(1));
assert_eq!(Float::one_prec(100).get_prec(), Some(100));
assert_eq!(Float::from(std::f64::consts::PI).get_prec(), Some(53));

pub fn get_min_prec(&self) -> Option<u64>

Returns the minimum precision necessary to represent the given Float’s value.

For example, Float:one_prec(100) has a precision of 100, but its minimum precision is 1, because that’s all that’s necessary to represent the value 1.

The minimum precision is always less than or equal to the actual precision.

Only Floats that are finite and nonzero have a minimum precision. For other Floats, None is returned.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, One, Zero};
use malachite_nz::natural::Natural;
use malachite_float::Float;

assert_eq!(Float::NAN.get_min_prec(), None);
assert_eq!(Float::INFINITY.get_min_prec(), None);
assert_eq!(Float::ZERO.get_min_prec(), None);

assert_eq!(Float::ONE.get_min_prec(), Some(1));
assert_eq!(Float::one_prec(100).get_min_prec(), Some(1));
assert_eq!(Float::from(std::f64::consts::PI).get_min_prec(), Some(50));

pub fn set_prec_round(&mut self, prec: u64, rm: RoundingMode) -> Ordering

Changes a Float’s precision. If the precision decreases, rounding may be necessary, and will use the provided RoundingMode.

Returns an Ordering, indicating whether the final value is less than, greater than, or equal to the original value.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Panics

Panics if prec is zero or if rm is RoundingMode::Exact but setting the desired precision requires rounding.

Examples

use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let original_x = Float::from(1.0f64 / 3.0);
assert_eq!(original_x.to_string(), "0.33333333333333331");
assert_eq!(original_x.get_prec(), Some(53));

let mut x = original_x.clone();
assert_eq!(x.set_prec_round(100, RoundingMode::Exact), Ordering::Equal);
assert_eq!(x.to_string(), "0.3333333333333333148296162562474");
assert_eq!(x.get_prec(), Some(100));

let mut x = original_x.clone();
assert_eq!(x.set_prec_round(10, RoundingMode::Floor), Ordering::Less);
assert_eq!(x.to_string(), "0.333");
assert_eq!(x.get_prec(), Some(10));

let mut x = original_x.clone();
assert_eq!(x.set_prec_round(10, RoundingMode::Ceiling), Ordering::Greater);
assert_eq!(x.to_string(), "0.3335");
assert_eq!(x.get_prec(), Some(10));

pub fn set_prec(&mut self, p: u64) -> Ordering

Changes a Float’s precision. If the precision decreases, rounding may be necessary, and RoundingMode::Nearest will be used.

Returns an Ordering, indicating whether the final value is less than, greater than, or equal to the original value.

To use a different rounding mode, try Float::set_prec_round.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use std::cmp::Ordering;

let original_x = Float::from(1.0f64 / 3.0);
assert_eq!(original_x.to_string(), "0.33333333333333331");
assert_eq!(original_x.get_prec(), Some(53));

let mut x = original_x.clone();
assert_eq!(x.set_prec(100), Ordering::Equal);
assert_eq!(x.to_string(), "0.3333333333333333148296162562474");
assert_eq!(x.get_prec(), Some(100));

let mut x = original_x.clone();
assert_eq!(x.set_prec(10), Ordering::Greater);
assert_eq!(x.to_string(), "0.3335");
assert_eq!(x.get_prec(), Some(10));

impl Float

pub fn ulp(&self) -> Option<Float>

Gets a Float’s ulp (unit in last place, or unit of least precision).

If the Float is positive, its ulp is the distance to the next-largest Float with the same precision; if it is negative, the next-smallest. (This definition works even if the Float is the largest in its binade.)

If the Float is NaN, infinite, or zero, then None is returned.

$$ f(\text{NaN}) = f(\pm\infty) = f(\pm 0.0) = \text{None}, $$

and, if $x$ is finite and nonzero,

$$ f(x) = \operatorname{Some}(2^{\lfloor \log_2 x \rfloor-p+1}), $$ where $p$ is the precision of $x$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::basic::traits::{Infinity, NaN, NegativeOne, One, Zero};
use malachite_nz::natural::Natural;
use malachite_float::Float;

assert_eq!(Float::NAN.ulp(), None);
assert_eq!(Float::INFINITY.ulp(), None);
assert_eq!(Float::ZERO.ulp(), None);

let s = Float::ONE.ulp().map(|x| x.to_string());
assert_eq!(s.as_ref().map(|s| s.as_str()), Some("1.0"));

let s = Float::one_prec(100).ulp().map(|x| x.to_string());
assert_eq!(s.as_ref().map(|s| s.as_str()), Some("2.0e-30"));

let s = Float::from(std::f64::consts::PI).ulp().map(|x| x.to_string());
assert_eq!(s.as_ref().map(|s| s.as_str()), Some("4.0e-16"));

let s = Float::power_of_2(100u64).ulp().map(|x| x.to_string());
assert_eq!(s.as_ref().map(|s| s.as_str()), Some("1.0e30"));

let s = Float::power_of_2(-100i64).ulp().map(|x| x.to_string());
assert_eq!(s.as_ref().map(|s| s.as_str()), Some("8.0e-31"));

let s = Float::NEGATIVE_ONE.ulp().map(|x| x.to_string());
assert_eq!(s.as_ref().map(|s| s.as_str()), Some("1.0"));

pub fn increment(&mut self)

Increments a Float by its ulp.

See Float::ulp for details. If the Float is equal to the negative of its ulp, it becomes negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

Panics if self is NaN, infinite, or zero.

Examples

use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::basic::traits::{Infinity, NaN, NegativeOne, One, Zero};
use malachite_nz::natural::Natural;
use malachite_float::Float;

let mut x = Float::ONE;
assert_eq!(x.to_string(), "1.0");
x.increment();
assert_eq!(x.to_string(), "2.0");

let mut x = Float::one_prec(100);
assert_eq!(x.to_string(), "1.0");
x.increment();
assert_eq!(x.to_string(), "1.000000000000000000000000000002");

let mut x = Float::from(std::f64::consts::PI);
assert_eq!(x.to_string(), "3.1415926535897931");
x.increment();
assert_eq!(x.to_string(), "3.1415926535897936");

let mut x = Float::power_of_2(100u64);
assert_eq!(x.to_string(), "1.0e30");
x.increment();
assert_eq!(x.to_string(), "3.0e30");

let mut x = Float::power_of_2(-100i64);
assert_eq!(x.to_string(), "8.0e-31");
x.increment();
assert_eq!(x.to_string(), "1.6e-30");

let mut x = Float::NEGATIVE_ONE;
assert_eq!(x.to_string(), "-1.0");
x.increment();
assert_eq!(x.to_string(), "-0.0");

pub fn decrement(&mut self)

Decrements a Float by its ulp.

See Float::ulp for details. If the Float is equal to its ulp, it becomes positive zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

Panics if self is NaN, infinite, or zero.

Examples

use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::basic::traits::{Infinity, NaN, NegativeOne, One, Zero};
use malachite_nz::natural::Natural;
use malachite_float::Float;

let mut x = Float::ONE;
assert_eq!(x.to_string(), "1.0");
x.decrement();
assert_eq!(x.to_string(), "0.0");

let mut x = Float::one_prec(100);
assert_eq!(x.to_string(), "1.0");
x.decrement();
assert_eq!(x.to_string(), "0.999999999999999999999999999998");

let mut x = Float::from(std::f64::consts::PI);
assert_eq!(x.to_string(), "3.1415926535897931");
x.decrement();
assert_eq!(x.to_string(), "3.1415926535897927");

let mut x = Float::power_of_2(100u64);
assert_eq!(x.to_string(), "1.0e30");
x.decrement();
assert_eq!(x.to_string(), "0.0");

let mut x = Float::power_of_2(-100i64);
assert_eq!(x.to_string(), "8.0e-31");
x.decrement();
assert_eq!(x.to_string(), "0.0");

let mut x = Float::NEGATIVE_ONE;
assert_eq!(x.to_string(), "-1.0");
x.decrement();
assert_eq!(x.to_string(), "-2.0");

impl Float

pub fn from_integer_prec_round( x: Integer, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Converts an Integer to a Float, taking the Integer by value. If the Float is nonzero, it has the specified precision. If rounding is needed, the specified rounding mode is used. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If you’re only using RoundingMode::Nearest, try using Float::from_integer_prec instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(n.significant_bits(), prec).

Examples

use malachite_base::rounding_modes::RoundingMode;
use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_nz::integer::Integer;
use std::cmp::Ordering;

let (x, o) = Float::from_integer_prec_round(Integer::ZERO, 10, RoundingMode::Exact);
assert_eq!(x.to_string(), "0.0");
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_integer_prec_round(
    Integer::from(123),
    20,
    RoundingMode::Exact
);
assert_eq!(x.to_string(), "123.0");
assert_eq!(x.get_prec(), Some(20));
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_integer_prec_round(Integer::from(123), 4, RoundingMode::Floor);
assert_eq!(x.to_string(), "1.2e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Less);

let (x, o) = Float::from_integer_prec_round(
    Integer::from(123),
    4,
    RoundingMode::Ceiling
);
assert_eq!(x.to_string(), "1.3e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Greater);

let (x, o) = Float::from_integer_prec_round(
    Integer::from(-123),
    20,
    RoundingMode::Exact
);
assert_eq!(x.to_string(), "-123.0");
assert_eq!(x.get_prec(), Some(20));
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_integer_prec_round(Integer::from(-123), 4, RoundingMode::Floor);
assert_eq!(x.to_string(), "-1.3e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Less);

let (x, o) = Float::from_integer_prec_round(
    Integer::from(-123),
    4,
    RoundingMode::Ceiling
);
assert_eq!(x.to_string(), "-1.2e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Greater);

pub fn from_integer_prec(x: Integer, prec: u64) -> (Float, Ordering)

Converts an Integer to a Float, taking the Integer by value. If the Float is nonzero, it has the specified precision. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If you want the Float’s precision to be equal to the Integer’s number of significant bits, try just using Float::from instead.

Rounding may occur, in which case RoundingMode::Nearest is used by default. To specify a rounding mode as well as a precision, try Float::from_integer_prec_round.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(n.significant_bits(), prec).

Examples

use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_nz::integer::Integer;
use std::cmp::Ordering;

let (x, o) = Float::from_integer_prec(Integer::ZERO, 10);
assert_eq!(x.to_string(), "0.0");
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_integer_prec(Integer::from(123), 20);
assert_eq!(x.to_string(), "123.0");
assert_eq!(x.get_prec(), Some(20));
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_integer_prec(Integer::from(123), 4);
assert_eq!(x.to_string(), "1.2e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Less);

let (x, o) = Float::from_integer_prec(Integer::from(-123), 20);
assert_eq!(x.to_string(), "-123.0");
assert_eq!(x.get_prec(), Some(20));
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_integer_prec(Integer::from(-123), 4);
assert_eq!(x.to_string(), "-1.2e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Greater);

pub fn from_integer_prec_round_ref( x: &Integer, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Converts an Integer to a Float, taking the Integer by reference. If the Float is nonzero, it has the specified precision. If rounding is needed, the specified rounding mode is used. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If you’re only using RoundingMode::Nearest, try using Float::from_integer_prec_ref instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(n.significant_bits(), prec).

Examples

use malachite_base::rounding_modes::RoundingMode;
use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_nz::integer::Integer;
use std::cmp::Ordering;

let (x, o) = Float::from_integer_prec_round_ref(&Integer::ZERO, 10, RoundingMode::Exact);
assert_eq!(x.to_string(), "0.0");
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_integer_prec_round_ref(
    &Integer::from(123),
    20,
    RoundingMode::Exact
);
assert_eq!(x.to_string(), "123.0");
assert_eq!(x.get_prec(), Some(20));
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_integer_prec_round_ref(
    &Integer::from(123),
    4,
    RoundingMode::Floor
);
assert_eq!(x.to_string(), "1.2e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Less);

let (x, o) = Float::from_integer_prec_round_ref(
    &Integer::from(123),
    4,
    RoundingMode::Ceiling
);
assert_eq!(x.to_string(), "1.3e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Greater);

let (x, o) = Float::from_integer_prec_round_ref(
    &Integer::from(-123),
    20,
    RoundingMode::Exact
);
assert_eq!(x.to_string(), "-123.0");
assert_eq!(x.get_prec(), Some(20));
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_integer_prec_round_ref(
    &Integer::from(-123),
    4,
    RoundingMode::Floor
);
assert_eq!(x.to_string(), "-1.3e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Less);

let (x, o) = Float::from_integer_prec_round_ref(
    &Integer::from(-123),
    4,
    RoundingMode::Ceiling
);
assert_eq!(x.to_string(), "-1.2e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Greater);

pub fn from_integer_prec_ref(x: &Integer, prec: u64) -> (Float, Ordering)

Converts an Integer to a Float, taking the Integer by reference. If the Float is nonzero, it has the specified precision. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If you want the Float’s precision to be equal to the Integer’s number of significant bits, try just using Float::from instead.

Rounding may occur, in which case RoundingMode::Nearest is used by default. To specify a rounding mode as well as a precision, try Float::from_integer_prec_round_ref.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(n.significant_bits(), prec).

Examples

use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_nz::integer::Integer;
use std::cmp::Ordering;

let (x, o) = Float::from_integer_prec_ref(&Integer::ZERO, 10);
assert_eq!(x.to_string(), "0.0");
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_integer_prec_ref(&Integer::from(123), 20);
assert_eq!(x.to_string(), "123.0");
assert_eq!(x.get_prec(), Some(20));
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_integer_prec_ref(&Integer::from(123), 4);
assert_eq!(x.to_string(), "1.2e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Less);

let (x, o) = Float::from_integer_prec_ref(&Integer::from(-123), 20);
assert_eq!(x.to_string(), "-123.0");
assert_eq!(x.get_prec(), Some(20));
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_integer_prec_ref(&Integer::from(-123), 4);
assert_eq!(x.to_string(), "-1.2e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Greater);

impl Float

pub fn from_natural_prec_round( x: Natural, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Converts a Natural to a Float, taking the Natural by value. If the Float is nonzero, it has the specified precision. If rounding is needed, the specified rounding mode is used. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If you’re only using RoundingMode::Nearest, try using Float::from_natural_prec instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(n.significant_bits(), prec).

Examples

use malachite_base::rounding_modes::RoundingMode;
use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use std::cmp::Ordering;

let (x, o) = Float::from_natural_prec_round(Natural::ZERO, 10, RoundingMode::Exact);
assert_eq!(x.to_string(), "0.0");
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_natural_prec_round(
    Natural::from(123u32),
    20,
    RoundingMode::Exact
);
assert_eq!(x.to_string(), "123.0");
assert_eq!(x.get_prec(), Some(20));
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_natural_prec_round(Natural::from(123u32), 4, RoundingMode::Floor);
assert_eq!(x.to_string(), "1.2e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Less);

let (x, o) = Float::from_natural_prec_round(
    Natural::from(123u32),
    4,
    RoundingMode::Ceiling
);
assert_eq!(x.to_string(), "1.3e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Greater);

pub fn from_natural_prec(x: Natural, prec: u64) -> (Float, Ordering)

Converts a Natural to a Float, taking the Natural by value. If the Float is nonzero, it has the specified precision. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If you want the Float’s precision to be equal to the Natural’s number of significant bits, try just using Float::from instead.

Rounding may occur, in which case RoundingMode::Nearest is used by default. To specify a rounding mode as well as a precision, try Float::from_natural_prec_round.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(n.significant_bits(), prec).

Examples

use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use std::cmp::Ordering;

let (x, o) = Float::from_natural_prec(Natural::ZERO, 10);
assert_eq!(x.to_string(), "0.0");
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_natural_prec(Natural::from(123u32), 20);
assert_eq!(x.to_string(), "123.0");
assert_eq!(x.get_prec(), Some(20));
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_natural_prec(Natural::from(123u32), 4);
assert_eq!(x.to_string(), "1.2e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Less);

pub fn from_natural_prec_round_ref( x: &Natural, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Converts a Natural to a Float, taking the Natural by reference. If the Float is nonzero, it has the specified precision. If rounding is needed, the specified rounding mode is used. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If you’re only using RoundingMode::Nearest, try using Float::from_natural_prec_ref instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(n.significant_bits(), prec).

Examples

use malachite_base::rounding_modes::RoundingMode;
use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use std::cmp::Ordering;

let (x, o) = Float::from_natural_prec_round_ref(&Natural::ZERO, 10, RoundingMode::Exact);
assert_eq!(x.to_string(), "0.0");
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_natural_prec_round_ref(
    &Natural::from(123u32),
    20,
    RoundingMode::Exact
);
assert_eq!(x.to_string(), "123.0");
assert_eq!(x.get_prec(), Some(20));
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_natural_prec_round_ref(
    &Natural::from(123u32),
    4,
    RoundingMode::Floor
);
assert_eq!(x.to_string(), "1.2e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Less);

let (x, o) = Float::from_natural_prec_round_ref(
    &Natural::from(123u32),
    4,
    RoundingMode::Ceiling
);
assert_eq!(x.to_string(), "1.3e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Greater);

pub fn from_natural_prec_ref(x: &Natural, prec: u64) -> (Float, Ordering)

Converts a Natural to a Float, taking the Natural by reference. If the Float is nonzero, it has the specified precision. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If you want the Float’s precision to be equal to the Natural’s number of significant bits, try just using Float::from instead.

Rounding may occur, in which case RoundingMode::Nearest is used by default. To specify a rounding mode as well as a precision, try Float::from_natural_prec_round_ref.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(n.significant_bits(), prec).

Examples

use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use std::cmp::Ordering;

let (x, o) = Float::from_natural_prec_ref(&Natural::ZERO, 10);
assert_eq!(x.to_string(), "0.0");
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_natural_prec_ref(&Natural::from(123u32), 20);
assert_eq!(x.to_string(), "123.0");
assert_eq!(x.get_prec(), Some(20));
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_natural_prec_ref(&Natural::from(123u32), 4);
assert_eq!(x.to_string(), "1.2e2");
assert_eq!(x.get_prec(), Some(4));
assert_eq!(o, Ordering::Less);

impl Float

pub fn from_primitive_float_prec_round<T: PrimitiveFloat>( x: T, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Converts a primitive float to a Float. If the Float is nonzero and finite, it has the specified precision. If rounding is needed, the specified rounding mode is used. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value. (Although a NaN is not comparable to anything, converting a NaN to a NaN will also return Ordering::Equals, indicating an exact conversion.)

If you’re only using RoundingMode::Nearest, try using Float::from_primitive_float_prec instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(prec, x.sci_exponent().abs()).

Examples

See here.

pub fn from_primitive_float_prec<T: PrimitiveFloat>( x: T, prec: u64 ) -> (Float, Ordering)

Converts a primitive float to a Float. If the Float is nonzero and finite, it has the specified precision. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value. (Although a NaN is not comparable to anything, converting a NaN to a NaN will also return Ordering::Equals, indicating an exact conversion.)

Rounding may occur, in which case RoundingMode::Nearest is used by default. To specify a rounding mode as well as a precision, try Float::from_primitive_float_prec_round.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(prec, x.sci_exponent().abs()).

Examples

See here.

impl Float

pub const fn const_from_unsigned(x: Limb) -> Float

pub fn from_unsigned_prec_round<T: PrimitiveUnsigned>( x: T, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

where Natural: From<T>,

Converts a primitive unsigned integer to a Float. If the Float is nonzero, it has the specified precision. If rounding is needed, the specified rounding mode is used. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If you’re only using RoundingMode::Nearest, try using Float::from_unsigned_prec instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

See here.

pub fn from_unsigned_prec<T: PrimitiveUnsigned>( x: T, prec: u64 ) -> (Float, Ordering)

where Natural: From<T>,

Converts an unsigned primitive integer to a Float. If the Float is nonzero, it has the specified precision. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If you want the Float’s precision to be equal to the integer’s number of significant bits, try just using Float::from instead.

Rounding may occur, in which case RoundingMode::Nearest is used by default. To specify a rounding mode as well as a precision, try Float::from_unsigned_prec_round.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

See here.

pub fn from_signed_prec_round<T: PrimitiveSigned>( x: T, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

where Integer: From<T>,

Converts a primitive signed integer to a Float. If the Float is nonzero, it has the specified precision. If rounding is needed, the specified rounding mode is used. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If you’re only using RoundingMode::Nearest, try using Float::from_signed_prec instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

See here.

pub fn from_signed_prec<T: PrimitiveSigned>( x: T, prec: u64 ) -> (Float, Ordering)

where Integer: From<T>,

Converts a signed primitive integer to a Float. If the Float is nonzero, it has the specified precision. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If you want the Float’s precision to be equal to the integer’s number of significant bits, try just using Float::from instead.

Rounding may occur, in which case RoundingMode::Nearest is used by default. To specify a rounding mode as well as a precision, try Float::from_signed_prec_round.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is prec.

Examples

See here.

impl Float

pub fn from_rational_prec_round( x: Rational, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Converts a Rational to a Float, taking the Rational by value. If the Float is nonzero, it has the specified precision. If rounding is needed, the specified rounding mode is used. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If you’re only using RoundingMode::Nearest, try using Float::from_rational_prec instead.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(n.significant_bits(), prec).

Examples

use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (x, o) = Float::from_rational_prec_round(
    Rational::from_signeds(1, 3),
    10,
    RoundingMode::Floor
);
assert_eq!(x.to_string(), "0.333");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Less);

let (x, o) = Float::from_rational_prec_round(
    Rational::from_signeds(1, 3),
    10,
    RoundingMode::Ceiling
);
assert_eq!(x.to_string(), "0.3335");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Greater);

let (x, o) = Float::from_rational_prec_round(
    Rational::from_signeds(1, 3),
    10,
    RoundingMode::Nearest
);
assert_eq!(x.to_string(), "0.3335");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Greater);

let (x, o) = Float::from_rational_prec_round(
    Rational::from_signeds(-1, 3),
    10,
    RoundingMode::Floor
);
assert_eq!(x.to_string(), "-0.3335");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Less);

let (x, o) = Float::from_rational_prec_round(
    Rational::from_signeds(-1, 3),
    10,
    RoundingMode::Ceiling
);
assert_eq!(x.to_string(), "-0.333");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Greater);

let (x, o) = Float::from_rational_prec_round(
    Rational::from_signeds(-1, 3),
    10,
    RoundingMode::Nearest
);
assert_eq!(x.to_string(), "-0.3335");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Less);

pub fn from_rational_prec(x: Rational, prec: u64) -> (Float, Ordering)

Converts a Rational to a Float, taking the Rational by value. If the Float is nonzero, it has the specified precision. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Rational is dyadic (its denominator is a power of 2), then you can convert it to a Float using try_from instead. The precision of the resulting Float will be the number of significant bits of the Rational’s numerator.

Rounding may occur, in which case RoundingMode::Nearest is used by default. To specify a rounding mode as well as a precision, try Float::from_rational_prec_round.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(x.significant_bits(), prec).

Examples

use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (x, o) = Float::from_rational_prec(Rational::ZERO, 10);
assert_eq!(x.to_string(), "0.0");
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_rational_prec(Rational::from_signeds(1, 3), 10);
assert_eq!(x.to_string(), "0.3335");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Greater);

let (x, o) = Float::from_rational_prec(Rational::from_signeds(1, 3), 100);
assert_eq!(x.to_string(), "0.3333333333333333333333333333335");
assert_eq!(x.get_prec(), Some(100));
assert_eq!(o, Ordering::Greater);

let (x, o) = Float::from_rational_prec(Rational::from_signeds(-1, 3), 10);
assert_eq!(x.to_string(), "-0.3335");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Less);

let (x, o) = Float::from_rational_prec(Rational::from_signeds(-1, 3), 100);
assert_eq!(x.to_string(), "-0.3333333333333333333333333333335");
assert_eq!(x.get_prec(), Some(100));
assert_eq!(o, Ordering::Less);

pub fn from_rational_prec_round_ref( x: &Rational, prec: u64, rm: RoundingMode ) -> (Float, Ordering)

Converts a Rational to a Float, taking the Rational by reference. If the Float is nonzero, it has the specified precision. If rounding is needed, the specified rounding mode is used. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If you’re only using RoundingMode::Nearest, try using Float::from_rational_prec_ref instead.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(x.significant_bits(), prec).

Examples

use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (x, o) = Float::from_rational_prec_round_ref(
    &Rational::from_signeds(1, 3),
    10,
    RoundingMode::Floor
);
assert_eq!(x.to_string(), "0.333");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Less);

let (x, o) = Float::from_rational_prec_round_ref(
    &Rational::from_signeds(1, 3),
    10,
    RoundingMode::Ceiling
);
assert_eq!(x.to_string(), "0.3335");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Greater);

let (x, o) = Float::from_rational_prec_round_ref(
    &Rational::from_signeds(1, 3),
    10,
    RoundingMode::Nearest
);
assert_eq!(x.to_string(), "0.3335");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Greater);

let (x, o) = Float::from_rational_prec_round_ref(
    &Rational::from_signeds(-1, 3),
    10,
    RoundingMode::Floor
);
assert_eq!(x.to_string(), "-0.3335");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Less);

let (x, o) = Float::from_rational_prec_round_ref(
    &Rational::from_signeds(-1, 3),
    10,
    RoundingMode::Ceiling
);
assert_eq!(x.to_string(), "-0.333");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Greater);

let (x, o) = Float::from_rational_prec_round_ref(
    &Rational::from_signeds(-1, 3),
    10,
    RoundingMode::Nearest
);
assert_eq!(x.to_string(), "-0.3335");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Less);

pub fn from_rational_prec_ref(x: &Rational, prec: u64) -> (Float, Ordering)

Converts a Rational to a Float, taking the Rational by reference. If the Float is nonzero, it has the specified precision. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Rational is dyadic (its denominator is a power of 2), then you can convert it to a Float using try_from instead. The precision of the resulting Float will be the number of significant bits of the Rational’s numerator.

Rounding may occur, in which case RoundingMode::Nearest is used by default. To specify a rounding mode as well as a precision, try Float::from_rational_prec_round_ref.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(x.significant_bits(), prec).

Examples

use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_q::Rational;
use std::cmp::Ordering;

let (x, o) = Float::from_rational_prec_ref(&Rational::ZERO, 10);
assert_eq!(x.to_string(), "0.0");
assert_eq!(o, Ordering::Equal);

let (x, o) = Float::from_rational_prec_ref(&Rational::from_signeds(1, 3), 10);
assert_eq!(x.to_string(), "0.3335");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Greater);

let (x, o) = Float::from_rational_prec_ref(&Rational::from_signeds(1, 3), 100);
assert_eq!(x.to_string(), "0.3333333333333333333333333333335");
assert_eq!(x.get_prec(), Some(100));
assert_eq!(o, Ordering::Greater);

let (x, o) = Float::from_rational_prec_ref(&Rational::from_signeds(-1, 3), 10);
assert_eq!(x.to_string(), "-0.3335");
assert_eq!(x.get_prec(), Some(10));
assert_eq!(o, Ordering::Less);

let (x, o) = Float::from_rational_prec_ref(&Rational::from_signeds(-1, 3), 100);
assert_eq!(x.to_string(), "-0.3333333333333333333333333333335");
assert_eq!(x.get_prec(), Some(100));
assert_eq!(o, Ordering::Less);

impl Float

pub fn sci_mantissa_and_exponent_round<T: PrimitiveFloat>( &self, rm: RoundingMode ) -> Option<(T, i64, Ordering)>

Returns a Float’s scientific mantissa and exponent, rounding according to the specified rounding mode. An Ordering is also returned, indicating whether the mantissa and exponent represent a value that is less than, equal to, or greater than the original value.

When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational mantissa as a float. The conversion might not be exact, so we round to the nearest float using the provided rounding mode. If the rounding mode is Exact but the conversion is not exact, None is returned. $$ f(x, r) \approx \left (\frac{x}{2^{\lfloor \log_2 x \rfloor}}, \lfloor \log_2 x \rfloor\right ). $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::SciMantissaAndExponent;
use malachite_base::num::float::NiceFloat;
use malachite_base::rounding_modes::RoundingMode;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use std::cmp::Ordering;

let test = |x: Float, rm: RoundingMode, out: Option<(f32, i64, Ordering)>| {
    assert_eq!(
        x.sci_mantissa_and_exponent_round(rm)
            .map(|(m, e, o)| (NiceFloat(m), e, o)),
        out.map(|(m, e, o)| (NiceFloat(m), e, o))
    );
};
test(Float::from(3u32), RoundingMode::Floor, Some((1.5, 1, Ordering::Equal)));
test(Float::from(3u32), RoundingMode::Down, Some((1.5, 1, Ordering::Equal)));
test(Float::from(3u32), RoundingMode::Ceiling, Some((1.5, 1, Ordering::Equal)));
test(Float::from(3u32), RoundingMode::Up, Some((1.5, 1, Ordering::Equal)));
test(Float::from(3u32), RoundingMode::Nearest, Some((1.5, 1, Ordering::Equal)));
test(Float::from(3u32), RoundingMode::Exact, Some((1.5, 1, Ordering::Equal)));

let x = Float::from(std::f64::consts::PI);
test(x.clone(), RoundingMode::Floor, Some((1.5707963, 1, Ordering::Less)));
test(x.clone(), RoundingMode::Down, Some((1.5707963, 1, Ordering::Less)));
test(x.clone(), RoundingMode::Ceiling, Some((1.5707964, 1, Ordering::Greater)));
test(x.clone(), RoundingMode::Up, Some((1.5707964, 1, Ordering::Greater)));
test(x.clone(), RoundingMode::Nearest, Some((1.5707964, 1, Ordering::Greater)));
test(x.clone(), RoundingMode::Exact, None);

test(
    Float::from(1000000000u32),
    RoundingMode::Nearest,
    Some((1.8626451, 29, Ordering::Equal)),
);
test(
    Float::from(Natural::from(10u32).pow(52)),
    RoundingMode::Nearest,
    Some((1.670478, 172, Ordering::Greater)),
);

test(Float::from(Natural::from(10u32).pow(52)), RoundingMode::Exact, None);

Trait Implementations

impl<'a> Abs for &'a Float

fn abs(self) -> Float

Takes the absolute value of a Float, taking the Float by reference.

$$ f(x) = |x|. $$

Special cases:

• $f(\text{NaN}) = \text{NaN}$
• $f(\infty) = f(-\infty) = \infty$
• $f(0.0) = f(-0.0) = 0.0$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

use malachite_base::num::arithmetic::traits::Abs;
use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::{ComparableFloat, Float};

assert_eq!(ComparableFloat((&Float::NAN).abs()), ComparableFloat(Float::NAN));
assert_eq!((&Float::INFINITY).abs(), Float::INFINITY);
assert_eq!((&Float::NEGATIVE_INFINITY).abs(), Float::INFINITY);
assert_eq!(ComparableFloat((&Float::ZERO).abs()), ComparableFloat(Float::ZERO));
assert_eq!(ComparableFloat((&Float::NEGATIVE_ZERO).abs()), ComparableFloat(Float::ZERO));
assert_eq!((&Float::ONE).abs(), Float::ONE);
assert_eq!((&Float::NEGATIVE_ONE).abs(), Float::ONE);

type Output = Float

impl Abs for Float

fn abs(self) -> Float

Takes the absolute value of a Float, taking the Float by value.

$$ f(x) = |x|. $$

Special cases:

• $f(\text{NaN}) = \text{NaN}$
• $f(\infty) = f(-\infty) = \infty$
• $f(0.0) = f(-0.0) = 0.0$

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::arithmetic::traits::Abs;
use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::{ComparableFloat, Float};

assert_eq!(ComparableFloat(Float::NAN.abs()), ComparableFloat(Float::NAN));
assert_eq!(Float::INFINITY.abs(), Float::INFINITY);
assert_eq!(Float::NEGATIVE_INFINITY.abs(), Float::INFINITY);
assert_eq!(ComparableFloat(Float::ZERO.abs()), ComparableFloat(Float::ZERO));
assert_eq!(ComparableFloat(Float::NEGATIVE_ZERO.abs()), ComparableFloat(Float::ZERO));
assert_eq!(Float::ONE.abs(), Float::ONE);
assert_eq!(Float::NEGATIVE_ONE.abs(), Float::ONE);

type Output = Float

impl AbsAssign for Float

fn abs_assign(&mut self)

Replaces a Float with its absolute value.

$$ x \gets |x|. $$

Special cases:

• $\text{NaN} \gets \text{NaN}$
• $\infty \gets \infty$
• $-\infty \gets \infty$
• $0.0 \gets 0.0$
• $-0.0 \gets 0.0$

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::arithmetic::traits::AbsAssign;
use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::{ComparableFloat, Float};

let mut x = Float::NAN;
x.abs_assign();
assert_eq!(ComparableFloat(x), ComparableFloat(Float::NAN));

let mut x = Float::INFINITY;
x.abs_assign();
assert_eq!(x, Float::INFINITY);

let mut x = Float::NEGATIVE_INFINITY;
x.abs_assign();
assert_eq!(x, Float::INFINITY);

let mut x = Float::ZERO;
x.abs_assign();
assert_eq!(ComparableFloat(x), ComparableFloat(Float::ZERO));

let mut x = Float::NEGATIVE_ZERO;
x.abs_assign();
assert_eq!(ComparableFloat(x), ComparableFloat(Float::ZERO));

let mut x = Float::ONE;
x.abs_assign();
assert_eq!(x, Float::ONE);

let mut x = Float::NEGATIVE_ONE;
x.abs_assign();
assert_eq!(x, Float::ONE);

impl<'a, 'b> Add<&'a Float> for &'b Float

fn add(self, other: &'a Float) -> Float

Adds two Floats, taking both by reference.

If the output has a precision, it is the maximum of the precisions of the inputs. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

Special cases:

• $f(\text{NaN},x)=f(x,\text{NaN})=f(\infty,-\infty)=f(-\infty,\infty)=\text{NaN}$
• $f(\infty,x)=f(x,\infty)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x)=f(x,-\infty)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0)=0.0$
• $f(-0.0,-0.0)=-0.0$
• $f(0.0,-0.0)=f(-0.0,0.0)=0.0$
• $f(0.0,x)=f(x,0.0)=f(-0.0,x)=f(x,-0.0)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,-x)=0.0$ if $x$ is finite and nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_prec_ref_ref instead. If you want to specify the output precision, consider using Float::add_round_ref_ref. If you want both of these things, consider using Float::add_prec_round_ref_ref.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_float::Float;

assert!((&Float::from(1.5) + &Float::NAN).is_nan());
assert_eq!(&Float::from(1.5) + &Float::INFINITY, Float::INFINITY);
assert_eq!(&Float::from(1.5) + &Float::NEGATIVE_INFINITY, Float::NEGATIVE_INFINITY);
assert!((&Float::INFINITY + &Float::NEGATIVE_INFINITY).is_nan());

assert_eq!(&Float::from(1.5) + &Float::from(2.5), 4.0);
assert_eq!(&Float::from(1.5) + &Float::from(-2.5), -1.0);
assert_eq!(&Float::from(-1.5) + &Float::from(2.5), 1.0);
assert_eq!(&Float::from(-1.5) + &Float::from(-2.5), -4.0);

type Output = Float

The resulting type after applying the + operator.

impl<'a, 'b> Add<&'a Float> for &'b Rational

fn add(self, other: &Float) -> Float

Adds a Rational and a Float, taking both by reference.

If the output has a precision, it is the precision of the input Float. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(x,\text{NaN})=\text{NaN}$
• $f(x,\infty)=\infty$
• $f(x,-\infty)=-\infty$
• $f(0,0.0)=0.0$
• $f(0,-0.0)=-0.0$
• $f(x,0.0)=f(x,0)=f(-0.0,x)=x$
• $f(x,-x)=0.0$ if $x$ is nonzero

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((&Rational::exact_from(1.5) + &Float::NAN).is_nan());
assert_eq!(&Rational::exact_from(1.5) + &Float::INFINITY, Float::INFINITY);
assert_eq!(
    &Rational::exact_from(1.5) + &Float::NEGATIVE_INFINITY,
    Float::NEGATIVE_INFINITY
);

assert_eq!(&Rational::exact_from(1.5) + &Float::from(2.5), 4.0);
assert_eq!(&Rational::exact_from(1.5) + &Float::from(-2.5), -1.0);
assert_eq!(&Rational::exact_from(-1.5) + &Float::from(2.5), 1.0);
assert_eq!(&Rational::exact_from(-1.5) + &Float::from(-2.5), -4.0);

type Output = Float

The resulting type after applying the + operator.

impl<'a> Add<&'a Float> for Float

fn add(self, other: &'a Float) -> Float

Adds two Floats, taking the first by value and the second by reference.

If the output has a precision, it is the maximum of the precisions of the inputs. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

Special cases:

• $f(\text{NaN},x)=f(x,\text{NaN})=f(\infty,-\infty)=f(-\infty,\infty)=\text{NaN}$
• $f(\infty,x)=f(x,\infty)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x)=f(x,-\infty)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0)=0.0$
• $f(-0.0,-0.0)=-0.0$
• $f(0.0,-0.0)=f(-0.0,0.0)=0.0$
• $f(0.0,x)=f(x,0.0)=f(-0.0,x)=f(x,-0.0)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,-x)=0.0$ if $x$ is finite and nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_prec_val_ref instead. If you want to specify the output precision, consider using Float::add_round_val_ref. If you want both of these things, consider using Float::add_prec_round_val_ref.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is max(self.significant_bits(), other.significant_bits()), and $m$ is other.significant_bits().

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_float::Float;

assert!((Float::from(1.5) + &Float::NAN).is_nan());
assert_eq!(Float::from(1.5) + &Float::INFINITY, Float::INFINITY);
assert_eq!(Float::from(1.5) + &Float::NEGATIVE_INFINITY, Float::NEGATIVE_INFINITY);
assert!((Float::INFINITY + &Float::NEGATIVE_INFINITY).is_nan());

assert_eq!(Float::from(1.5) + &Float::from(2.5), 4.0);
assert_eq!(Float::from(1.5) + &Float::from(-2.5), -1.0);
assert_eq!(Float::from(-1.5) + &Float::from(2.5), 1.0);
assert_eq!(Float::from(-1.5) + &Float::from(-2.5), -4.0);

type Output = Float

The resulting type after applying the + operator.

impl<'a> Add<&'a Float> for Rational

fn add(self, other: &Float) -> Float

Adds a Rational and a Float, taking the Rational by value and the Float by reference.

If the output has a precision, it is the precision of the input Float. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(x,\text{NaN})=\text{NaN}$
• $f(x,\infty)=\infty$
• $f(x,-\infty)=-\infty$
• $f(0,0.0)=0.0$
• $f(0,-0.0)=-0.0$
• $f(x,0.0)=f(x,0)=f(-0.0,x)=x$
• $f(x,-x)=0.0$ if $x$ is nonzero

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((Rational::exact_from(1.5) + &Float::NAN).is_nan());
assert_eq!(Rational::exact_from(1.5) + &Float::INFINITY, Float::INFINITY);
assert_eq!(
    Rational::exact_from(1.5) + &Float::NEGATIVE_INFINITY,
    Float::NEGATIVE_INFINITY
);

assert_eq!(Rational::exact_from(1.5) + &Float::from(2.5), 4.0);
assert_eq!(Rational::exact_from(1.5) + &Float::from(-2.5), -1.0);
assert_eq!(Rational::exact_from(-1.5) + &Float::from(2.5), 1.0);
assert_eq!(Rational::exact_from(-1.5) + &Float::from(-2.5), -4.0);

type Output = Float

The resulting type after applying the + operator.

impl<'a, 'b> Add<&'a Rational> for &'b Float

fn add(self, other: &Rational) -> Float

Adds a Float and a Rational, taking both by reference.

If the output has a precision, it is the precision of the input Float. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(\text{NaN},x)=\text{NaN}$
• $f(\infty,x)=\infty$
• $f(-\infty,x)=-\infty$
• $f(0.0,0)=0.0$
• $f(-0.0,0)=-0.0$
• $f(0.0,x)=f(x,0)=f(-0.0,x)=x$
• $f(x,-x)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_rational_prec_ref_ref instead. If you want to specify the output precision, consider using Float::add_rational_round_ref_ref. If you want both of these things, consider using Float::add_rational_prec_round_ref_ref.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((&Float::NAN + &Rational::exact_from(1.5)).is_nan());
assert_eq!(&Float::INFINITY + &Rational::exact_from(1.5), Float::INFINITY);
assert_eq!(
    &Float::NEGATIVE_INFINITY + &Rational::exact_from(1.5),
    Float::NEGATIVE_INFINITY
);

assert_eq!(&Float::from(2.5) + &Rational::exact_from(1.5), 4.0);
assert_eq!(&Float::from(2.5) + &Rational::exact_from(-1.5), 1.0);
assert_eq!(&Float::from(-2.5) + &Rational::exact_from(1.5), -1.0);
assert_eq!(&Float::from(-2.5) + &Rational::exact_from(-1.5), -4.0);

type Output = Float

The resulting type after applying the + operator.

impl<'a> Add<&'a Rational> for Float

fn add(self, other: &Rational) -> Float

Adds a Float and a Rational, taking the Float by value and the Rational by reference.

If the output has a precision, it is the precision of the input Float. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(\text{NaN},x)=\text{NaN}$
• $f(\infty,x)=\infty$
• $f(-\infty,x)=-\infty$
• $f(0.0,0)=0.0$
• $f(-0.0,0)=-0.0$
• $f(0.0,x)=f(x,0)=f(-0.0,x)=x$
• $f(x,-x)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_rational_prec_val_ref instead. If you want to specify the output precision, consider using Float::add_rational_round_val_ref. If you want both of these things, consider using Float::add_rational_prec_round_val_ref.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((Float::NAN + &Rational::exact_from(1.5)).is_nan());
assert_eq!(Float::INFINITY + &Rational::exact_from(1.5), Float::INFINITY);
assert_eq!(
    Float::NEGATIVE_INFINITY + &Rational::exact_from(1.5),
    Float::NEGATIVE_INFINITY
);

assert_eq!(Float::from(2.5) + &Rational::exact_from(1.5), 4.0);
assert_eq!(Float::from(2.5) + &Rational::exact_from(-1.5), 1.0);
assert_eq!(Float::from(-2.5) + &Rational::exact_from(1.5), -1.0);
assert_eq!(Float::from(-2.5) + &Rational::exact_from(-1.5), -4.0);

type Output = Float

The resulting type after applying the + operator.

impl<'a> Add<Float> for &'a Float

fn add(self, other: Float) -> Float

Adds two Floats, taking the first by reference and the second by value.

If the output has a precision, it is the maximum of the precisions of the inputs. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

Special cases:

• $f(\text{NaN},x)=f(x,\text{NaN})=f(\infty,-\infty)=f(-\infty,\infty)=\text{NaN}$
• $f(\infty,x)=f(x,\infty)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x)=f(x,-\infty)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0)=0.0$
• $f(-0.0,-0.0)=-0.0$
• $f(0.0,-0.0)=f(-0.0,0.0)=0.0$
• $f(0.0,x)=f(x,0.0)=f(-0.0,x)=f(x,-0.0)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,-x)=0.0$ if $x$ is finite and nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_prec_ref_val instead. If you want to specify the output precision, consider using Float::add_round_ref_val. If you want both of these things, consider using Float::add_prec_round_ref_val.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is max(self.significant_bits(), other.significant_bits()), and $m$ is self.significant_bits().

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_float::Float;

assert!((&Float::from(1.5) + Float::NAN).is_nan());
assert_eq!(&Float::from(1.5) + Float::INFINITY, Float::INFINITY);
assert_eq!(&Float::from(1.5) + Float::NEGATIVE_INFINITY, Float::NEGATIVE_INFINITY);
assert!((&Float::INFINITY + Float::NEGATIVE_INFINITY).is_nan());

assert_eq!(&Float::from(1.5) + Float::from(2.5), 4.0);
assert_eq!(&Float::from(1.5) + Float::from(-2.5), -1.0);
assert_eq!(&Float::from(-1.5) + Float::from(2.5), 1.0);
assert_eq!(&Float::from(-1.5) + Float::from(-2.5), -4.0);

type Output = Float

The resulting type after applying the + operator.

impl<'a> Add<Float> for &'a Rational

fn add(self, other: Float) -> Float

Adds a Rational and a Float, taking the Rational by reference and the Float by value.

If the output has a precision, it is the precision of the input Float. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(x,\text{NaN})=\text{NaN}$
• $f(x,\infty)=\infty$
• $f(x,-\infty)=-\infty$
• $f(0,0.0)=0.0$
• $f(0,-0.0)=-0.0$
• $f(x,0.0)=f(x,0)=f(-0.0,x)=x$
• $f(x,-x)=0.0$ if $x$ is nonzero

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((&Rational::exact_from(1.5) + Float::NAN).is_nan());
assert_eq!(&Rational::exact_from(1.5) + Float::INFINITY, Float::INFINITY);
assert_eq!(
    &Rational::exact_from(1.5) + Float::NEGATIVE_INFINITY,
    Float::NEGATIVE_INFINITY
);

assert_eq!(&Rational::exact_from(1.5) + Float::from(2.5), 4.0);
assert_eq!(&Rational::exact_from(1.5) + Float::from(-2.5), -1.0);
assert_eq!(&Rational::exact_from(-1.5) + Float::from(2.5), 1.0);
assert_eq!(&Rational::exact_from(-1.5) + Float::from(-2.5), -4.0);

type Output = Float

The resulting type after applying the + operator.

impl Add<Float> for Rational

fn add(self, other: Float) -> Float

Adds a Rational and a Float, taking both by value.

If the output has a precision, it is the precision of the input Float. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(x,\text{NaN})=\text{NaN}$
• $f(x,\infty)=\infty$
• $f(x,-\infty)=-\infty$
• $f(0,0.0)=0.0$
• $f(0,-0.0)=-0.0$
• $f(x,0.0)=f(x,0)=f(-0.0,x)=x$
• $f(x,-x)=0.0$ if $x$ is nonzero

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((Rational::exact_from(1.5) + Float::NAN).is_nan());
assert_eq!(Rational::exact_from(1.5) + Float::INFINITY, Float::INFINITY);
assert_eq!(Rational::exact_from(1.5) + Float::NEGATIVE_INFINITY, Float::NEGATIVE_INFINITY);

assert_eq!(Rational::exact_from(1.5) + Float::from(2.5), 4.0);
assert_eq!(Rational::exact_from(1.5) + Float::from(-2.5), -1.0);
assert_eq!(Rational::exact_from(-1.5) + Float::from(2.5), 1.0);
assert_eq!(Rational::exact_from(-1.5) + Float::from(-2.5), -4.0);

type Output = Float

The resulting type after applying the + operator.

impl<'a> Add<Rational> for &'a Float

fn add(self, other: Rational) -> Float

Adds a Float and a Rational, taking the Float by reference and the Rational by value.

If the output has a precision, it is the precision of the input Float. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(\text{NaN},x)=\text{NaN}$
• $f(\infty,x)=\infty$
• $f(-\infty,x)=-\infty$
• $f(0.0,0)=0.0$
• $f(-0.0,0)=-0.0$
• $f(0.0,x)=f(x,0)=f(-0.0,x)=x$
• $f(x,-x)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_rational_prec_ref_val instead. If you want to specify the output precision, consider using Float::add_rational_round_ref_val. If you want both of these things, consider using Float::add_rational_prec_round_ref_val.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((&Float::NAN + Rational::exact_from(1.5)).is_nan());
assert_eq!(&Float::INFINITY + Rational::exact_from(1.5), Float::INFINITY);
assert_eq!(
    &Float::NEGATIVE_INFINITY + Rational::exact_from(1.5),
    Float::NEGATIVE_INFINITY
);

assert_eq!(&Float::from(2.5) + Rational::exact_from(1.5), 4.0);
assert_eq!(&Float::from(2.5) + Rational::exact_from(-1.5), 1.0);
assert_eq!(&Float::from(-2.5) + Rational::exact_from(1.5), -1.0);
assert_eq!(&Float::from(-2.5) + Rational::exact_from(-1.5), -4.0);

type Output = Float

The resulting type after applying the + operator.

impl Add<Rational> for Float

fn add(self, other: Rational) -> Float

Adds a Float and a Rational, taking both by value.

If the output has a precision, it is the precision of the input Float. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(\text{NaN},x)=\text{NaN}$
• $f(\infty,x)=\infty$
• $f(-\infty,x)=-\infty$
• $f(0.0,0)=0.0$
• $f(-0.0,0)=-0.0$
• $f(0.0,x)=f(x,0)=f(-0.0,x)=x$
• $f(x,-x)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_rational_prec instead. If you want to specify the output precision, consider using Float::add_rational_round. If you want both of these things, consider using Float::add_rational_prec_round.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((Float::NAN + Rational::exact_from(1.5)).is_nan());
assert_eq!(Float::INFINITY + Rational::exact_from(1.5), Float::INFINITY);
assert_eq!(Float::NEGATIVE_INFINITY + Rational::exact_from(1.5), Float::NEGATIVE_INFINITY);

assert_eq!(Float::from(2.5) + Rational::exact_from(1.5), 4.0);
assert_eq!(Float::from(2.5) + Rational::exact_from(-1.5), 1.0);
assert_eq!(Float::from(-2.5) + Rational::exact_from(1.5), -1.0);
assert_eq!(Float::from(-2.5) + Rational::exact_from(-1.5), -4.0);

type Output = Float

The resulting type after applying the + operator.

impl Add for Float

fn add(self, other: Float) -> Float

Adds two Floats, taking both by value.

If the output has a precision, it is the maximum of the precisions of the inputs. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

Special cases:

• $f(\text{NaN},x)=f(x,\text{NaN})=f(\infty,-\infty)=f(-\infty,\infty)=\text{NaN}$
• $f(\infty,x)=f(x,\infty)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x)=f(x,-\infty)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,0.0)=0.0$
• $f(-0.0,-0.0)=-0.0$
• $f(0.0,-0.0)=f(-0.0,0.0)=0.0$
• $f(0.0,x)=f(x,0.0)=f(-0.0,x)=f(x,-0.0)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,-x)=0.0$ if $x$ is finite and nonzero

If you want to use a rounding mode other than Nearest, consider using Float::add_prec instead. If you want to specify the output precision, consider using Float::add_round. If you want both of these things, consider using Float::add_prec_round.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_float::Float;

assert!((Float::from(1.5) + Float::NAN).is_nan());
assert_eq!(Float::from(1.5) + Float::INFINITY, Float::INFINITY);
assert_eq!(Float::from(1.5) + Float::NEGATIVE_INFINITY, Float::NEGATIVE_INFINITY);
assert!((Float::INFINITY + Float::NEGATIVE_INFINITY).is_nan());

assert_eq!(Float::from(1.5) + Float::from(2.5), 4.0);
assert_eq!(Float::from(1.5) + Float::from(-2.5), -1.0);
assert_eq!(Float::from(-1.5) + Float::from(2.5), 1.0);
assert_eq!(Float::from(-1.5) + Float::from(-2.5), -4.0);

type Output = Float

The resulting type after applying the + operator.

impl<'a> AddAssign<&'a Float> for Float

fn add_assign(&mut self, other: &Float)

Adds a Float to a Float in place, taking the Float on the right-hand side by reference.

If the output has a precision, it is the maximum of the precisions of the inputs. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x\gets = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

Special cases: See the + documenation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::add_prec_assign_ref instead. If you want to specify the output precision, consider using Float::add_round_assign_ref. If you want both of these things, consider using Float::add_prec_round_assign_ref.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is max(self.significant_bits(), other.significant_bits()), and $m$ is other.significant_bits().

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_float::Float;

let mut x = Float::from(1.5);
x += &Float::NAN;
assert!(x.is_nan());

let mut x = Float::from(1.5);
x += &Float::INFINITY;
assert_eq!(x, Float::INFINITY);

let mut x = Float::from(1.5);
x += &Float::NEGATIVE_INFINITY;
assert_eq!(x, Float::NEGATIVE_INFINITY);

let mut x = Float::INFINITY;
x += &Float::NEGATIVE_INFINITY;
assert!(x.is_nan());

let mut x = Float::from(1.5);
x += &Float::from(2.5);
assert_eq!(x, 4.0);

let mut x = Float::from(1.5);
x += &Float::from(-2.5);
assert_eq!(x, -1.0);

let mut x = Float::from(-1.5);
x += &Float::from(2.5);
assert_eq!(x, 1.0);

let mut x = Float::from(-1.5);
x += &Float::from(-2.5);
assert_eq!(x, -4.0);

impl<'a> AddAssign<&'a Rational> for Float

fn add_assign(&mut self, other: &Rational)

Adds a Rational to a Float in place, taking the Rational by reference.

If the output has a precision, it is the precision of the input Float. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x\gets = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

See the + documentation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::add_rational_prec_assign instead. If you want to specify the output precision, consider using Float::add_rational_round_assign. If you want both of these things, consider using Float::add_rational_prec_round_assign.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

let mut x = Float::NAN;
x += &Rational::exact_from(1.5);
assert!(x.is_nan());

let mut x = Float::INFINITY;
x += &Rational::exact_from(1.5);
assert_eq!(x, Float::INFINITY);

let mut x = Float::NEGATIVE_INFINITY;
x += &Rational::exact_from(1.5);
assert_eq!(x, Float::NEGATIVE_INFINITY);

let mut x = Float::from(2.5);
x += &Rational::exact_from(1.5);
assert_eq!(x, 4.0);

let mut x = Float::from(2.5);
x += &Rational::exact_from(-1.5);
assert_eq!(x, 1.0);

let mut x = Float::from(-2.5);
x += &Rational::exact_from(1.5);
assert_eq!(x, -1.0);

let mut x = Float::from(-2.5);
x += &Rational::exact_from(-1.5);
assert_eq!(x, -4.0);

impl AddAssign<Rational> for Float

fn add_assign(&mut self, other: Rational)

Adds a Rational to a Float in place, taking the Rational by value.

If the output has a precision, it is the precision of the input Float. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x\gets = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the precision of the input Float.

See the + documentation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::add_rational_prec_assign instead. If you want to specify the output precision, consider using Float::add_rational_round_assign. If you want both of these things, consider using Float::add_rational_prec_round_assign.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

let mut x = Float::NAN;
x += Rational::exact_from(1.5);
assert!(x.is_nan());

let mut x = Float::INFINITY;
x += Rational::exact_from(1.5);
assert_eq!(x, Float::INFINITY);

let mut x = Float::NEGATIVE_INFINITY;
x += Rational::exact_from(1.5);
assert_eq!(x, Float::NEGATIVE_INFINITY);

let mut x = Float::from(2.5);
x += Rational::exact_from(1.5);
assert_eq!(x, 4.0);

let mut x = Float::from(2.5);
x += Rational::exact_from(-1.5);
assert_eq!(x, 1.0);

let mut x = Float::from(-2.5);
x += Rational::exact_from(1.5);
assert_eq!(x, -1.0);

let mut x = Float::from(-2.5);
x += Rational::exact_from(-1.5);
assert_eq!(x, -4.0);

impl AddAssign for Float

fn add_assign(&mut self, other: Float)

Adds a Float to a Float in place, taking the Float on the right-hand side by value.

If the output has a precision, it is the maximum of the precisions of the inputs. If the sum is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x\gets = x+y+\epsilon. $$

• If $x+y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x+y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x+y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

Special cases: See the + documenation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::add_prec_assign instead. If you want to specify the output precision, consider using Float::add_round_assign. If you want both of these things, consider using Float::add_prec_round_assign.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_float::Float;

let mut x = Float::from(1.5);
x += Float::NAN;
assert!(x.is_nan());

let mut x = Float::from(1.5);
x += Float::INFINITY;
assert_eq!(x, Float::INFINITY);

let mut x = Float::from(1.5);
x += Float::NEGATIVE_INFINITY;
assert_eq!(x, Float::NEGATIVE_INFINITY);

let mut x = Float::INFINITY;
x += Float::NEGATIVE_INFINITY;
assert!(x.is_nan());

let mut x = Float::from(1.5);
x += Float::from(2.5);
assert_eq!(x, 4.0);

let mut x = Float::from(1.5);
x += Float::from(-2.5);
assert_eq!(x, -1.0);

let mut x = Float::from(-1.5);
x += Float::from(2.5);
assert_eq!(x, 1.0);

let mut x = Float::from(-1.5);
x += Float::from(-2.5);
assert_eq!(x, -4.0);

impl Clone for Float

fn clone(&self) -> Float

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> ConvertibleFrom<&'a Float> for Integer

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to an Integer, taking the Float by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is f.significant_bits().

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, Zero};
use malachite_base::num::conversion::traits::ConvertibleFrom;
use malachite_float::Float;
use malachite_nz::integer::Integer;

assert_eq!(Integer::convertible_from(&Float::ZERO), true);
assert_eq!(Integer::convertible_from(&Float::from(123.0)), true);
assert_eq!(Integer::convertible_from(&Float::from(-123.0)), true);

assert_eq!(Integer::convertible_from(&Float::from(1.5)), false);
assert_eq!(Integer::convertible_from(&Float::INFINITY), false);
assert_eq!(Integer::convertible_from(&Float::NAN), false);

impl<'a> ConvertibleFrom<&'a Float> for Natural

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to a Natural (when the Float is non-negative and an integer), taking the Float by reference.

Both positive and negative zero are convertible to a Natural. (Although negative zero is nominally negative, the real number it represents is zero, which is not negative.)

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is f.significant_bits().

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, Zero};
use malachite_base::num::conversion::traits::ConvertibleFrom;
use malachite_float::Float;
use malachite_nz::natural::Natural;

assert_eq!(Natural::convertible_from(&Float::ZERO), true);
assert_eq!(Natural::convertible_from(&Float::from(123.0)), true);

assert_eq!(Natural::convertible_from(&Float::from(-123.0)), false);
assert_eq!(Natural::convertible_from(&Float::from(1.5)), false);
assert_eq!(Natural::convertible_from(&Float::INFINITY), false);
assert_eq!(Natural::convertible_from(&Float::NAN), false);

impl<'a> ConvertibleFrom<&'a Float> for Rational

fn convertible_from(x: &'a Float) -> bool

Determines whether a Float can be converted to a Rational (which is when the Float is finite), taking the Float by reference.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, Zero};
use malachite_base::num::conversion::traits::ConvertibleFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert_eq!(Rational::convertible_from(&Float::ZERO), true);
assert_eq!(Rational::convertible_from(&Float::from(123.0)), true);
assert_eq!(Rational::convertible_from(&Float::from(-123.0)), true);
assert_eq!(Rational::convertible_from(&Float::from(1.5)), true);

assert_eq!(Rational::convertible_from(&Float::INFINITY), false);
assert_eq!(Rational::convertible_from(&Float::NAN), false);

impl<'a> ConvertibleFrom<&'a Float> for f32

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to a primitive float, taking the Float by reference.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Float> for f64

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to a primitive float, taking the Float by reference.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Float> for i128

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to a signed primitive integer, taking the Float by reference.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Float> for i16

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to a signed primitive integer, taking the Float by reference.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Float> for i32

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to a signed primitive integer, taking the Float by reference.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Float> for i64

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to a signed primitive integer, taking the Float by reference.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Float> for i8

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to a signed primitive integer, taking the Float by reference.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Float> for isize

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to a signed primitive integer, taking the Float by reference.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Float> for u128

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to an unsigned primitive integer, taking the Float by reference.

Both positive and negative zero are convertible to any unsigned primitive integer. (Although negative zero is nominally negative, the real number it represents is zero, which is not negative.)

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Float> for u16

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to an unsigned primitive integer, taking the Float by reference.

Both positive and negative zero are convertible to any unsigned primitive integer. (Although negative zero is nominally negative, the real number it represents is zero, which is not negative.)

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Float> for u32

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to an unsigned primitive integer, taking the Float by reference.

Both positive and negative zero are convertible to any unsigned primitive integer. (Although negative zero is nominally negative, the real number it represents is zero, which is not negative.)

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Float> for u64

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to an unsigned primitive integer, taking the Float by reference.

Both positive and negative zero are convertible to any unsigned primitive integer. (Although negative zero is nominally negative, the real number it represents is zero, which is not negative.)

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Float> for u8

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to an unsigned primitive integer, taking the Float by reference.

Both positive and negative zero are convertible to any unsigned primitive integer. (Although negative zero is nominally negative, the real number it represents is zero, which is not negative.)

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Float> for usize

fn convertible_from(f: &'a Float) -> bool

Determines whether a Float can be converted to an unsigned primitive integer, taking the Float by reference.

Both positive and negative zero are convertible to any unsigned primitive integer. (Although negative zero is nominally negative, the real number it represents is zero, which is not negative.)

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Rational> for Float

fn convertible_from(x: &'a Rational) -> bool

Determines whether a Rational can be converted to an Float, taking the Rational by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is x.significant_bits().

Examples

use malachite_base::num::basic::traits::Zero;
use malachite_base::num::conversion::traits::ConvertibleFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert_eq!(Float::convertible_from(&Rational::ZERO), true);
assert_eq!(Float::convertible_from(&Rational::from_signeds(3, 8)), true);
assert_eq!(Float::convertible_from(&Rational::from_signeds(-3, 8)), true);

assert_eq!(Float::convertible_from(&Rational::from_signeds(1, 3)), false);
assert_eq!(Float::convertible_from(&Rational::from_signeds(-1, 3)), false);

impl Debug for Float

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

Formats the value using the given formatter.

impl Default for Float

fn default() -> Float

The default value of a Float, NaN.

impl Display for Float

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

Formats the value using the given formatter.

impl<'a> From<&'a Integer> for Float

fn from(n: &'a Integer) -> Float

Converts an Integer to a Float, taking the Integer by reference.

If the Integer is nonzero, the precision of the Float is equal to the Integer’s number of significant bits. If you want to specify a different precision, try Float::from_integer_prec_ref. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_integer_prec_round_ref.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is n.significant_bits().

Examples

use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_nz::integer::Integer;

assert_eq!(Float::from(&Integer::ZERO).to_string(), "0.0");
assert_eq!(Float::from(&Integer::from(123)).to_string(), "123.0");
assert_eq!(Float::from(&Integer::from(123)).get_prec(), Some(7));
assert_eq!(Float::from(&Integer::from(-123)).to_string(), "-123.0");

impl<'a> From<&'a Natural> for Float

fn from(n: &'a Natural) -> Float

Converts a Natural to a Float, taking the Natural by reference.

If the Natural is nonzero, the precision of the Float is equal to the Natural’s number of significant bits. If you want to specify a different precision, try Float::from_natural_prec_ref. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_natural_prec_round_ref.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is n.significant_bits().

Examples

use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_nz::natural::Natural;

assert_eq!(Float::from(&Natural::ZERO).to_string(), "0.0");
assert_eq!(Float::from(&Natural::from(123u32)).to_string(), "123.0");
assert_eq!(Float::from(&Natural::from(123u32)).get_prec(), Some(7));

impl From<Integer> for Float

fn from(n: Integer) -> Float

Converts an Integer to a Float, taking the Integer by value.

If the Integer is nonzero, the precision of the Float is equal to the Integer’s number of significant bits. If you want to specify a different precision, try Float::from_integer_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_integer_prec_round.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is n.significant_bits().

Examples

use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_nz::integer::Integer;

assert_eq!(Float::from(Integer::ZERO).to_string(), "0.0");
assert_eq!(Float::from(Integer::from(123)).to_string(), "123.0");
assert_eq!(Float::from(Integer::from(123)).get_prec(), Some(7));
assert_eq!(Float::from(Integer::from(-123)).to_string(), "-123.0");

impl From<Natural> for Float

fn from(n: Natural) -> Float

Converts a Natural to a Float, taking the Natural by value.

If the Natural is nonzero, the precision of the Float is equal to the Natural’s number of significant bits. If you want to specify a different precision, try Float::from_natural_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_natural_prec_round.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is n.significant_bits().

Examples

use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_nz::natural::Natural;

assert_eq!(Float::from(Natural::ZERO).to_string(), "0.0");
assert_eq!(Float::from(Natural::from(123u32)).to_string(), "123.0");
assert_eq!(Float::from(Natural::from(123u32)).get_prec(), Some(7));

impl From<f32> for Float

fn from(x: f32) -> Float

Converts a primitive float to a Float.

If the primitive float is finite and nonzero, the precision of the Float is equal to the maximum precision of any primitive float in the same binade (for normal f32s this is 24, and for normal f64s it is 53). If you want to specify a different precision, try Float::from_primitive_float_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_primitive_float_prec_round.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is x.sci_exponent().abs().

Examples

See here.

impl From<f64> for Float

fn from(x: f64) -> Float

Converts a primitive float to a Float.

If the primitive float is finite and nonzero, the precision of the Float is equal to the maximum precision of any primitive float in the same binade (for normal f32s this is 24, and for normal f64s it is 53). If you want to specify a different precision, try Float::from_primitive_float_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_primitive_float_prec_round.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is x.sci_exponent().abs().

Examples

See here.

impl From<i128> for Float

fn from(i: i128) -> Float

Converts a signed primitive integer to a Float.

If the integer is nonzero, the precision of the Float is equal to the integer’s number of significant bits. If you want to specify a different precision, try Float::from_signed_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_signed_prec_round.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<i16> for Float

fn from(i: i16) -> Float

Converts a signed primitive integer to a Float.

If the integer is nonzero, the precision of the Float is equal to the integer’s number of significant bits. If you want to specify a different precision, try Float::from_signed_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_signed_prec_round.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<i32> for Float

fn from(i: i32) -> Float

Converts a signed primitive integer to a Float.

If the integer is nonzero, the precision of the Float is equal to the integer’s number of significant bits. If you want to specify a different precision, try Float::from_signed_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_signed_prec_round.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<i64> for Float

fn from(i: i64) -> Float

Converts a signed primitive integer to a Float.

If the integer is nonzero, the precision of the Float is equal to the integer’s number of significant bits. If you want to specify a different precision, try Float::from_signed_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_signed_prec_round.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<i8> for Float

fn from(i: i8) -> Float

Converts a signed primitive integer to a Float.

If the integer is nonzero, the precision of the Float is equal to the integer’s number of significant bits. If you want to specify a different precision, try Float::from_signed_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_signed_prec_round.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<isize> for Float

fn from(i: isize) -> Float

Converts a signed primitive integer to a Float.

If the integer is nonzero, the precision of the Float is equal to the integer’s number of significant bits. If you want to specify a different precision, try Float::from_signed_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_signed_prec_round.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<u128> for Float

fn from(u: u128) -> Float

Converts an unsigned primitive integer to a Float.

If the integer is nonzero, the precision of the Float is equal to the integer’s number of significant bits. If you want to specify a different precision, try Float::from_unsigned_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_unsigned_prec_round.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<u16> for Float

fn from(u: u16) -> Float

Converts an unsigned primitive integer to a Float.

If the integer is nonzero, the precision of the Float is equal to the integer’s number of significant bits. If you want to specify a different precision, try Float::from_unsigned_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_unsigned_prec_round.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<u32> for Float

fn from(u: u32) -> Float

Converts an unsigned primitive integer to a Float.

If the integer is nonzero, the precision of the Float is equal to the integer’s number of significant bits. If you want to specify a different precision, try Float::from_unsigned_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_unsigned_prec_round.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<u64> for Float

fn from(u: u64) -> Float

Converts an unsigned primitive integer to a Float.

If the integer is nonzero, the precision of the Float is equal to the integer’s number of significant bits. If you want to specify a different precision, try Float::from_unsigned_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_unsigned_prec_round.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<u8> for Float

fn from(u: u8) -> Float

Converts an unsigned primitive integer to a Float.

If the integer is nonzero, the precision of the Float is equal to the integer’s number of significant bits. If you want to specify a different precision, try Float::from_unsigned_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_unsigned_prec_round.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<usize> for Float

fn from(u: usize) -> Float

Converts an unsigned primitive integer to a Float.

If the integer is nonzero, the precision of the Float is equal to the integer’s number of significant bits. If you want to specify a different precision, try Float::from_unsigned_prec. This may require rounding, which uses RoundingMode::Nearest by default. To specify a rounding mode as well as a precision, try Float::from_unsigned_prec_round.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl FromStringBase for Float

fn from_string_base(base: u8, s: &str) -> Option<Self>

impl Infinity for Float

The constant Infinity.

const INFINITY: Float = _

impl IntegerMantissaAndExponent<Natural, i64> for Float

fn integer_mantissa_and_exponent(self) -> (Natural, i64)

Returns a Float’s integer mantissa and exponent, taking the Float by value.

When $x$ is finite and nonzero, we can write $x = 2^{e_i}m_i$, where $e_i$ is an integer and $m_i$ is an odd integer. $$ f(x) = (\frac{|x|}{2^{e_i}}, e_i), $$ where $e_i$ is the unique integer such that $x/2^{e_i}$ is an odd integer.

The inverse operation is from_integer_mantissa_and_exponent.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

Panics if self is zero or not finite.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::IntegerMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(Float::ONE.integer_mantissa_and_exponent(), (Natural::ONE, 0));
assert_eq!(
    Float::from(std::f64::consts::PI).integer_mantissa_and_exponent(),
    (Natural::from(884279719003555u64), -48)
);
assert_eq!(
    Float::from(Natural::from(3u32).pow(50u64)).integer_mantissa_and_exponent(),
    (Natural::from_str("717897987691852588770249").unwrap(), 0)
);
assert_eq!(
    Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0
        .integer_mantissa_and_exponent(),
    (Natural::from_str("1067349099133908271875104088939").unwrap(), -179)
);

fn integer_exponent(self) -> i64

Returns a Float’s integer exponent, taking the Float by value.

When $x$ is finite and nonzero, we can write $x = 2^{e_i}m_i$, where $e_i$ is an integer and $m_i$ is an odd integer. $$ f(x) = e_i, $$ where $e_i$ is the unique integer such that $x/2^{e_i}$ is an odd integer.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if self is zero or not finite.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::IntegerMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(Float::ONE.integer_exponent(), 0);
assert_eq!(Float::from(std::f64::consts::PI).integer_exponent(), -48);
assert_eq!(Float::from(Natural::from(3u32).pow(50u64)).integer_exponent(), 0);
assert_eq!(
    Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0.integer_exponent(),
    -179
);

fn from_integer_mantissa_and_exponent( integer_mantissa: Natural, integer_exponent: i64 ) -> Option<Float>

Constructs a Float from its integer mantissa and exponent.

When $x$ is finite and nonzero, we can write $x = 2^{e_i}m_i$, where $e_i$ is an integer and $m_i$ is an odd integer.

$$ f(x) = 2^{e_i}m_i. $$

The input does not have to be reduced; that is, the mantissa does not have to be odd.

The result is an Option, but for this trait implementation the result is always Some.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is integer_mantissa.significant_bits().

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::IntegerMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(Float::from_integer_mantissa_and_exponent(Natural::ONE, 0).unwrap(), 1);
assert_eq!(
    Float::from_integer_mantissa_and_exponent(Natural::from(884279719003555u64), -48)
        .unwrap(),
    std::f64::consts::PI
);
assert_eq!(
    Float::from_integer_mantissa_and_exponent(
        Natural::from_str("717897987691852588770249").unwrap(),
        0
    ).unwrap(),
    Natural::from(3u32).pow(50u64)
);
assert_eq!(
    Float::from_integer_mantissa_and_exponent(
        Natural::from_str("1067349099133908271875104088939").unwrap(),
        -179
    ).unwrap(),
    Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0
);

fn integer_mantissa(self) -> M

Extracts the integer mantissa from a number.

impl<'a> IntegerMantissaAndExponent<Natural, i64, Float> for &'a Float

fn integer_mantissa_and_exponent(self) -> (Natural, i64)

Returns a Float’s integer mantissa and exponent, taking the Float by reference.

When $x$ is finite and nonzero, we can write $x = 2^{e_i}m_i$, where $e_i$ is an integer and $m_i$ is an odd integer. $$ f(x) = (\frac{|x|}{2^{e_i}}, e_i), $$ where $e_i$ is the unique integer such that $x/2^{e_i}$ is an odd integer.

The inverse operation is from_integer_mantissa_and_exponent.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

Panics if self is zero or not finite.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::IntegerMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!((&Float::ONE).integer_mantissa_and_exponent(), (Natural::ONE, 0));
assert_eq!(
    (&Float::from(std::f64::consts::PI)).integer_mantissa_and_exponent(),
    (Natural::from(884279719003555u64), -48)
);
assert_eq!(
    (&Float::from(Natural::from(3u32).pow(50u64))).integer_mantissa_and_exponent(),
    (Natural::from_str("717897987691852588770249").unwrap(), 0)
);
assert_eq!(
    (&Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0)
        .integer_mantissa_and_exponent(),
    (Natural::from_str("1067349099133908271875104088939").unwrap(), -179)
);

fn integer_exponent(self) -> i64

Returns a Float’s integer exponent, taking the Float by reference.

When $x$ is finite and nonzero, we can write $x = 2^{e_i}m_i$, where $e_i$ is an integer and $m_i$ is an odd integer. $$ f(x) = e_i, $$ where $e_i$ is the unique integer such that $x/2^{e_i}$ is an odd integer.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if self is zero or not finite.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::IntegerMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!((&Float::ONE).integer_exponent(), 0);
assert_eq!((&Float::from(std::f64::consts::PI)).integer_exponent(), -48);
assert_eq!((&Float::from(Natural::from(3u32).pow(50u64))).integer_exponent(), 0);
assert_eq!(
    (&Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0)
        .integer_exponent(),
    -179
);

fn from_integer_mantissa_and_exponent( integer_mantissa: Natural, integer_exponent: i64 ) -> Option<Float>

Constructs a Float from its integer mantissa and exponent.

When $x$ is finite and nonzero, we can write $x = 2^{e_i}m_i$, where $e_i$ is an integer and $m_i$ is an odd integer.

$$ f(x) = 2^{e_i}m_i. $$

The input does not have to be reduced; that is, the mantissa does not have to be odd.

The result is an Option, but for this trait implementation the result is always Some.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is integer_mantissa.significant_bits().

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::IntegerMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(
    <&Float as IntegerMantissaAndExponent<_, _, _>>::from_integer_mantissa_and_exponent(
        Natural::ONE,
        0
    ).unwrap(),
    1
);
assert_eq!(
    <&Float as IntegerMantissaAndExponent<_, _, _>>::from_integer_mantissa_and_exponent(
        Natural::from(884279719003555u64),
        -48
    ).unwrap(),
    std::f64::consts::PI
);
assert_eq!(
    <&Float as IntegerMantissaAndExponent<_, _, _>>::from_integer_mantissa_and_exponent(
        Natural::from_str("717897987691852588770249").unwrap(),
        0
    ).unwrap(),
    Natural::from(3u32).pow(50u64)
);
assert_eq!(
    <&Float as IntegerMantissaAndExponent<_, _, _>>::from_integer_mantissa_and_exponent(
        Natural::from_str("1067349099133908271875104088939").unwrap(),
        -179
    ).unwrap(),
    Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0
);

fn integer_mantissa(self) -> M

Extracts the integer mantissa from a number.

impl<'a> IsInteger for &'a Float

fn is_integer(self) -> bool

Determines whether a Float is an integer.

$f(x) = x \in \Z$.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{One, OneHalf, Zero};
use malachite_base::num::conversion::traits::IsInteger;
use malachite_float::Float;

assert_eq!(Float::ZERO.is_integer(), true);
assert_eq!(Float::ONE.is_integer(), true);
assert_eq!(Float::from(100).is_integer(), true);
assert_eq!(Float::from(-100).is_integer(), true);
assert_eq!(Float::ONE_HALF.is_integer(), false);
assert_eq!((-Float::ONE_HALF).is_integer(), false);

impl IsPowerOf2 for Float

fn is_power_of_2(&self) -> bool

Determines whether a Float is an integer power of 2.

$f(x) = (\exists n \in \Z : 2^n = x)$.

Floats that are NaN, infinite, or zero are not powers of 2.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

use malachite_base::num::basic::traits::{NaN, One, OneHalf, Two};
use malachite_base::num::arithmetic::traits::IsPowerOf2;
use malachite_float::Float;

assert_eq!(Float::NAN.is_power_of_2(), false);

assert_eq!(Float::ONE.is_power_of_2(), true);
assert_eq!(Float::TWO.is_power_of_2(), true);
assert_eq!(Float::ONE_HALF.is_power_of_2(), true);
assert_eq!(Float::from(1024).is_power_of_2(), true);

assert_eq!(Float::from(3).is_power_of_2(), false);
assert_eq!(Float::from(1025).is_power_of_2(), false);
assert_eq!(Float::from(0.1f64).is_power_of_2(), false);

impl LowerHex for Float

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

Formats the value using the given formatter.

impl Max for Float

The highest value representable by this type, positive infinity.

const MAX: Float = Float::INFINITY

The maximum value of Self.

impl Min for Float

The lowest value representable by this type, negative infinity.

const MIN: Float = Float::NEGATIVE_INFINITY

The minimum value of Self.

impl NaN for Float

The constant NaN.

const NAN: Float = _

impl Named for Float

const NAME: &'static str = "Float"

The name of this type, as given by the stringify macro.

See the documentation for impl_named for more details.

impl<'a> Neg for &'a Float

fn neg(self) -> Float

Negates a Float, taking it by reference.

$$ f(x) = -x. $$

Special cases:

• $f(\text{NaN}) = \text{NaN}$
• $f(\infty) = -\infty$
• $f(-\infty) = \infty$
• $f(0.0) = -0.0$
• $f(-0.0) = 0.0$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::{ComparableFloat, Float};

assert_eq!(ComparableFloat(-&Float::NAN), ComparableFloat(Float::NAN));
assert_eq!(-&Float::INFINITY, Float::NEGATIVE_INFINITY);
assert_eq!(-&Float::NEGATIVE_INFINITY, Float::INFINITY);
assert_eq!(ComparableFloat(-&Float::ZERO), ComparableFloat(Float::NEGATIVE_ZERO));
assert_eq!(ComparableFloat(-&Float::NEGATIVE_ZERO), ComparableFloat(Float::ZERO));
assert_eq!(-&Float::ONE, Float::NEGATIVE_ONE);
assert_eq!(-&Float::NEGATIVE_ONE, Float::ONE);

type Output = Float

The resulting type after applying the - operator.

impl Neg for Float

fn neg(self) -> Float

Negates a Float, taking it by value.

$$ f(x) = -x. $$

Special cases:

• $f(\text{NaN}) = \text{NaN}$
• $f(\infty) = -\infty$
• $f(-\infty) = \infty$
• $f(0.0) = -0.0$
• $f(-0.0) = 0.0$

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::{ComparableFloat, Float};

assert_eq!(ComparableFloat(-Float::NAN), ComparableFloat(Float::NAN));
assert_eq!(-Float::INFINITY, Float::NEGATIVE_INFINITY);
assert_eq!(-Float::NEGATIVE_INFINITY, Float::INFINITY);
assert_eq!(ComparableFloat(-Float::ZERO), ComparableFloat(Float::NEGATIVE_ZERO));
assert_eq!(ComparableFloat(-Float::NEGATIVE_ZERO), ComparableFloat(Float::ZERO));
assert_eq!(-Float::ONE, Float::NEGATIVE_ONE);
assert_eq!(-Float::NEGATIVE_ONE, Float::ONE);

type Output = Float

The resulting type after applying the - operator.

impl NegAssign for Float

fn neg_assign(&mut self)

Negates a Float in place.

$$ x \gets -x. $$

Special cases:

• $\text{NaN} \gets \text{NaN}$
• $\infty \gets -\infty$
• $-\infty \gets \infty$
• $0.0 \gets -0.0$
• $-0.0 \gets 0.0$

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::arithmetic::traits::NegAssign;
use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::{ComparableFloat, Float};

let mut x = Float::NAN;
x.neg_assign();
assert_eq!(ComparableFloat(x), ComparableFloat(Float::NAN));

let mut x = Float::INFINITY;
x.neg_assign();
assert_eq!(x, Float::NEGATIVE_INFINITY);

let mut x = Float::NEGATIVE_INFINITY;
x.neg_assign();
assert_eq!(x, Float::INFINITY);

let mut x = Float::ZERO;
x.neg_assign();
assert_eq!(ComparableFloat(x), ComparableFloat(Float::NEGATIVE_ZERO));

let mut x = Float::NEGATIVE_ZERO;
x.neg_assign();
assert_eq!(ComparableFloat(x), ComparableFloat(Float::ZERO));

let mut x = Float::ONE;
x.neg_assign();
assert_eq!(x, Float::NEGATIVE_ONE);

let mut x = Float::NEGATIVE_ONE;
x.neg_assign();
assert_eq!(x, Float::ONE);

impl NegativeInfinity for Float

The constant -Infinity.

const NEGATIVE_INFINITY: Float = _

impl NegativeOne for Float

The constant -1.0, with precision 1.

const NEGATIVE_ONE: Float = _

impl NegativeZero for Float

The constant -0.0, with precision 1.

const NEGATIVE_ZERO: Float = _

impl One for Float

The constant 1.0, with precision 1.

const ONE: Float = _

impl OneHalf for Float

The constant 0.5, with precision 1.

const ONE_HALF: Float = _

impl PartialEq<Float> for Integer

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

Determines whether an Integer is equal to a Float.

No Integer is equal to infinity, negative infinity, or NaN. The Integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{One, OneHalf};
use malachite_float::Float;
use malachite_nz::integer::Integer;

assert!(Integer::from(123) == Float::from(123));
assert!(Integer::from(-123) == Float::from(-123));
assert!(Integer::ONE != Float::ONE_HALF);

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for Natural

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

Determines whether a Natural is equal to a Float.

No Natural is equal to infinity, negative infinity, or NaN. The Natural zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{One, OneHalf};
use malachite_float::Float;
use malachite_nz::natural::Natural;

assert!(Natural::from(123u32) == Float::from(123));
assert!(Natural::ONE != Float::ONE_HALF);

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for Rational

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

Determines whether a Rational is equal to a Float.

No Rational is equal to infinity, negative infinity, or NaN. The Rational zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{One, OneHalf};
use malachite_float::Float;
use malachite_q::Rational;

assert!(Rational::from(123) == Float::from(123));
assert!(Rational::from(-123) == Float::from(-123));
assert!(Rational::ONE_HALF == Float::ONE_HALF);
assert!(Rational::from_unsigneds(1u8, 3) != Float::from(1.0f64 / 3.0));

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for f32

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

Determines whether a primitive float is equal to a Float.

The primitive float infinity is equal to the Float infinity, and the primitive float negative infinity is equal to the Float negative infinity. The primitive float NaN is not equal to anything, not even the Float NaN. Every primitive float zero is equal to every Float zero, regardless of sign.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.sci_exponent().abs()).

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for f64

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

Determines whether a primitive float is equal to a Float.

The primitive float infinity is equal to the Float infinity, and the primitive float negative infinity is equal to the Float negative infinity. The primitive float NaN is not equal to anything, not even the Float NaN. Every primitive float zero is equal to every Float zero, regardless of sign.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.sci_exponent().abs()).

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for i128

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

Determines whether a signed primitive integer is equal to a Float.

No primitive integer is equal to infinity, negative infinity, or NaN. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for i16

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

Determines whether a signed primitive integer is equal to a Float.

No primitive integer is equal to infinity, negative infinity, or NaN. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for i32

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

Determines whether a signed primitive integer is equal to a Float.

No primitive integer is equal to infinity, negative infinity, or NaN. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for i64

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

Determines whether a signed primitive integer is equal to a Float.

No primitive integer is equal to infinity, negative infinity, or NaN. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for i8

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

Determines whether a signed primitive integer is equal to a Float.

No primitive integer is equal to infinity, negative infinity, or NaN. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for isize

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

Determines whether a signed primitive integer is equal to a Float.

No primitive integer is equal to infinity, negative infinity, or NaN. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for u128

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

Determines whether an unsigned primitive integer is equal to a Float.

No primitive integer is equal to infinity, negative infinity, or NaN. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for u16

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

Determines whether an unsigned primitive integer is equal to a Float.

No primitive integer is equal to infinity, negative infinity, or NaN. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for u32

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

Determines whether an unsigned primitive integer is equal to a Float.

No primitive integer is equal to infinity, negative infinity, or NaN. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for u64

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

Determines whether an unsigned primitive integer is equal to a Float.

No primitive integer is equal to infinity, negative infinity, or NaN. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for u8

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

Determines whether an unsigned primitive integer is equal to a Float.

No primitive integer is equal to infinity, negative infinity, or NaN. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Float> for usize

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

Determines whether an unsigned primitive integer is equal to a Float.

No primitive integer is equal to infinity, negative infinity, or NaN. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Integer> for Float

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

Determines whether a Float is equal to an Integer.

Infinity, negative infinity, and NaN are not equal to any Integer. Both the Float zero and the Float negative zero are equal to the Integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{One, OneHalf};
use malachite_float::Float;
use malachite_nz::integer::Integer;

assert!(Float::from(123) == Integer::from(123));
assert!(Float::from(-123) == Integer::from(-123));
assert!(Float::ONE_HALF != Integer::ONE);

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Natural> for Float

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

Determines whether a Float is equal to a Natural.

Infinity, negative infinity, and NaN are not equal to any Natural. Both the Float zero and the Float negative zero are equal to the Natural zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{One, OneHalf};
use malachite_float::Float;
use malachite_nz::natural::Natural;

assert!(Float::from(123) == Natural::from(123u32));
assert!(Float::ONE_HALF != Natural::ONE);

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<Rational> for Float

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

Determines whether a Float is equal to a Rational.

Infinity, negative infinity, and NaN are not equal to any Rational. Both the Float zero and the Float negative zero are equal to the Rational zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::OneHalf;
use malachite_float::Float;
use malachite_q::Rational;

assert!(Float::from(123) == Rational::from(123));
assert!(Float::from(-123) == Rational::from(-123));
assert!(Float::ONE_HALF == Rational::ONE_HALF);
assert!(Float::from(1.0f64 / 3.0) != Rational::from_unsigneds(1u8, 3));

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f32> for Float

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

Determines whether a Float is equal to a primitive float.

The Float infinity is equal to the primitive float infinity, and the Float negative infinity is equal to the primitive float negative infinity. The Float NaN is not equal to anything, not even the primitive float NaN. Every Float zero is equal to every primitive float zero, regardless of sign.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.sci_exponent().abs()).

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<f64> for Float

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

Determines whether a Float is equal to a primitive float.

The Float infinity is equal to the primitive float infinity, and the Float negative infinity is equal to the primitive float negative infinity. The Float NaN is not equal to anything, not even the primitive float NaN. Every Float zero is equal to every primitive float zero, regardless of sign.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.sci_exponent().abs()).

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i128> for Float

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

Determines whether a Float is equal to a signed primitive integer.

Infinity, negative infinity, and NaN are not equal to any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i16> for Float

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

Determines whether a Float is equal to a signed primitive integer.

Infinity, negative infinity, and NaN are not equal to any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i32> for Float

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

Determines whether a Float is equal to a signed primitive integer.

Infinity, negative infinity, and NaN are not equal to any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i64> for Float

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

Determines whether a Float is equal to a signed primitive integer.

Infinity, negative infinity, and NaN are not equal to any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<i8> for Float

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

Determines whether a Float is equal to a signed primitive integer.

Infinity, negative infinity, and NaN are not equal to any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<isize> for Float

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

Determines whether a Float is equal to a signed primitive integer.

Infinity, negative infinity, and NaN are not equal to any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u128> for Float

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

Determines whether a Float is equal to an unsigned primitive integer.

Infinity, negative infinity, and NaN are not equal to any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u16> for Float

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

Determines whether a Float is equal to an unsigned primitive integer.

Infinity, negative infinity, and NaN are not equal to any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u32> for Float

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

Determines whether a Float is equal to an unsigned primitive integer.

Infinity, negative infinity, and NaN are not equal to any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u64> for Float

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

Determines whether a Float is equal to an unsigned primitive integer.

Infinity, negative infinity, and NaN are not equal to any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<u8> for Float

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

Determines whether a Float is equal to an unsigned primitive integer.

Infinity, negative infinity, and NaN are not equal to any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq<usize> for Float

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

Determines whether a Float is equal to an unsigned primitive integer.

Infinity, negative infinity, and NaN are not equal to any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for Float

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

Compares two Floats for equality.

This implementation follows the IEEE 754 standard. NaN is not equal to anything, not even itself. Positive zero is equal to negative zero. Floats with different precisions are equal if they represent the same numeric value.

For different equality behavior, consider using ComparableFloat or ComparableFloatRef.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{NaN, NegativeZero, One, Two, Zero};
use malachite_float::Float;

assert_ne!(Float::NAN, Float::NAN);
assert_eq!(Float::ZERO, Float::ZERO);
assert_eq!(Float::NEGATIVE_ZERO, Float::NEGATIVE_ZERO);
assert_eq!(Float::ZERO, Float::NEGATIVE_ZERO);

assert_eq!(Float::ONE, Float::ONE);
assert_ne!(Float::ONE, Float::TWO);
assert_eq!(Float::ONE, Float::one_prec(100));

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Float> for Integer

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

Compares an Integer to a Float.

No Integer is comparable to NaN. Every Integer is smaller than infinity and greater than negative infinity. The Integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NegativeInfinity};
use malachite_float::Float;
use malachite_nz::integer::Integer;

assert!(Integer::from(100) > Float::from(80));
assert!(Integer::from(-100) < Float::from(-80));
assert!(Integer::from(100) < Float::INFINITY);
assert!(Integer::from(-100) > Float::NEGATIVE_INFINITY);

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for Natural

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

Compares a Natural to a Float.

No Natural is comparable to NaN. Every Natural is smaller than infinity and greater than negative infinity. The Natural zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NegativeInfinity};
use malachite_float::Float;
use malachite_nz::natural::Natural;

assert!(Natural::from(100u32) > Float::from(80));
assert!(Natural::from(100u32) < Float::INFINITY);
assert!(Natural::from(100u32) > Float::NEGATIVE_INFINITY);

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for Rational

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

Compares an Rational to a Float.

No Rational is comparable to NaN. Every Rational is smaller than infinity and greater than negative infinity. The Rational zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NegativeInfinity};
use malachite_float::Float;
use malachite_q::Rational;

assert!(Rational::from(100) > Float::from(80));
assert!(Rational::from(-100) < Float::from(-80));
assert!(Rational::from(100) < Float::INFINITY);
assert!(Rational::from(-100) > Float::NEGATIVE_INFINITY);
assert!(Rational::from_unsigneds(1u8, 3) > Float::from(1.0f64 / 3.0));

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for f32

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

Compares a primitive float to a Float.

The primitive float NaN is not comparable to any primitive float, not even the Float NaN. Every primitive float zero is equal to every Float zero, regardless of sign.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.sci_exponent().abs()).

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for f64

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

Compares a primitive float to a Float.

The primitive float NaN is not comparable to any primitive float, not even the Float NaN. Every primitive float zero is equal to every Float zero, regardless of sign.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.sci_exponent().abs()).

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for i128

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

Compares a signed primitive integer to a Float.

No integer is comparable to NaN. Every integer is smaller than infinity and greater than negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for i16

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

Compares a signed primitive integer to a Float.

No integer is comparable to NaN. Every integer is smaller than infinity and greater than negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for i32

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

Compares a signed primitive integer to a Float.

No integer is comparable to NaN. Every integer is smaller than infinity and greater than negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for i64

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

Compares a signed primitive integer to a Float.

No integer is comparable to NaN. Every integer is smaller than infinity and greater than negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for i8

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

Compares a signed primitive integer to a Float.

No integer is comparable to NaN. Every integer is smaller than infinity and greater than negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for isize

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

Compares a signed primitive integer to a Float.

No integer is comparable to NaN. Every integer is smaller than infinity and greater than negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for u128

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

Compares an unsigned primitive integer to a Float.

No integer is comparable to NaN. Every integer is smaller than infinity and greater than negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for u16

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

Compares an unsigned primitive integer to a Float.

No integer is comparable to NaN. Every integer is smaller than infinity and greater than negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for u32

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

Compares an unsigned primitive integer to a Float.

No integer is comparable to NaN. Every integer is smaller than infinity and greater than negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for u64

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

Compares an unsigned primitive integer to a Float.

No integer is comparable to NaN. Every integer is smaller than infinity and greater than negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for u8

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

Compares an unsigned primitive integer to a Float.

No integer is comparable to NaN. Every integer is smaller than infinity and greater than negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Float> for usize

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

Compares an unsigned primitive integer to a Float.

No integer is comparable to NaN. Every integer is smaller than infinity and greater than negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Integer> for Float

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

Compares a Float to an Integer.

NaN is not comparable to any Integer. Infinity is greater than any Integer, and negative infinity is less. Both the Float zero and the Float negative zero are equal to the Integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NegativeInfinity};
use malachite_float::Float;
use malachite_nz::integer::Integer;

assert!(Float::from(80) < Integer::from(100));
assert!(Float::from(-80) > Integer::from(-100));
assert!(Float::INFINITY > Integer::from(100));
assert!(Float::NEGATIVE_INFINITY < Integer::from(-100));

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Natural> for Float

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

Compares a Float to a Natural.

NaN is not comparable to any Natural. Infinity is greater than any Natural, and negative infinity is less. Both the Float zero and the Float negative zero are equal to the Natural zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NegativeInfinity};
use malachite_float::Float;
use malachite_nz::natural::Natural;

assert!(Float::from(80) < Natural::from(100u32));
assert!(Float::INFINITY > Natural::from(100u32));
assert!(Float::NEGATIVE_INFINITY < Natural::from(100u32));

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<Rational> for Float

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

Compares a Float to a Rational.

NaN is not comparable to any Rational. Infinity is greater than any Rational, and negative infinity is less. Both the Float zero and the Float negative zero are equal to the Rational zero.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NegativeInfinity};
use malachite_float::Float;
use malachite_q::Rational;

assert!(Float::from(80) < Rational::from(100));
assert!(Float::from(-80) > Rational::from(-100));
assert!(Float::INFINITY > Rational::from(100));
assert!(Float::NEGATIVE_INFINITY < Rational::from(-100));
assert!(Float::from(1.0f64 / 3.0) < Rational::from_unsigneds(1u8, 3));

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<f32> for Float

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

Compares a Float to a primitive float.

The Float NaN is not comparable to any primitive float, not even the primitive float NaN. Every Float zero is equal to every primitive float zero, regardless of sign.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.sci_exponent().abs()).

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<f64> for Float

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

Compares a Float to a primitive float.

The Float NaN is not comparable to any primitive float, not even the primitive float NaN. Every Float zero is equal to every primitive float zero, regardless of sign.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.sci_exponent().abs()).

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<i128> for Float

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

Compares a Float to a signed primitive integer.

NaN is not comparable to any primitive integer. Infinity is greater than any primitive integer, and negative infinity is less. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<i16> for Float

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

Compares a Float to a signed primitive integer.

NaN is not comparable to any primitive integer. Infinity is greater than any primitive integer, and negative infinity is less. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<i32> for Float

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

Compares a Float to a signed primitive integer.

NaN is not comparable to any primitive integer. Infinity is greater than any primitive integer, and negative infinity is less. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<i64> for Float

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

Compares a Float to a signed primitive integer.

NaN is not comparable to any primitive integer. Infinity is greater than any primitive integer, and negative infinity is less. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<i8> for Float

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

Compares a Float to a signed primitive integer.

NaN is not comparable to any primitive integer. Infinity is greater than any primitive integer, and negative infinity is less. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<isize> for Float

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

Compares a Float to a signed primitive integer.

NaN is not comparable to any primitive integer. Infinity is greater than any primitive integer, and negative infinity is less. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<u128> for Float

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

Compares a Float to an unsigned primitive integer.

NaN is not comparable to any primitive integer. Infinity is greater than any primitive integer, and negative infinity is less. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<u16> for Float

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

Compares a Float to an unsigned primitive integer.

NaN is not comparable to any primitive integer. Infinity is greater than any primitive integer, and negative infinity is less. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<u32> for Float

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

Compares a Float to an unsigned primitive integer.

NaN is not comparable to any primitive integer. Infinity is greater than any primitive integer, and negative infinity is less. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<u64> for Float

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

Compares a Float to an unsigned primitive integer.

NaN is not comparable to any primitive integer. Infinity is greater than any primitive integer, and negative infinity is less. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<u8> for Float

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

Compares a Float to an unsigned primitive integer.

NaN is not comparable to any primitive integer. Infinity is greater than any primitive integer, and negative infinity is less. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd<usize> for Float

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

Compares a Float to an unsigned primitive integer.

NaN is not comparable to any primitive integer. Infinity is greater than any primitive integer, and negative infinity is less. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrd for Float

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

Compares two Floats.

This implementation follows the IEEE 754 standard. NaN is not comparable to anything, not even itself. Positive zero is equal to negative zero. Floats with different precisions are equal if they represent the same numeric value.

For different comparison behavior that provides a total order, consider using ComparableFloat or ComparableFloatRef.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, OneHalf, Zero
};
use malachite_float::Float;
use std::cmp::Ordering;
use std::str::FromStr;

assert_eq!(Float::NAN.partial_cmp(&Float::NAN), None);
assert_eq!(Float::ZERO.partial_cmp(&Float::NEGATIVE_ZERO), Some(Ordering::Equal));
assert_eq!(Float::ONE.partial_cmp(&Float::one_prec(100)), Some(Ordering::Equal));
assert!(Float::INFINITY > Float::ONE);
assert!(Float::NEGATIVE_INFINITY < Float::ONE);
assert!(Float::ONE_HALF < Float::ONE);
assert!(Float::ONE_HALF > Float::NEGATIVE_ONE);

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialOrdAbs<Float> for Integer

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

Compares the absolute values of an Integer and a Float.

No Integer is comparable to NaN. Every Integer is smaller in absolute value than infinity and negative infinity. The Integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NegativeInfinity};
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_float::Float;
use malachite_nz::integer::Integer;

assert!(Integer::from(100).gt_abs(&Float::from(80)));
assert!(Integer::from(100).lt_abs(&Float::INFINITY));
assert!(Integer::from(-100).lt_abs(&Float::INFINITY));
assert!(Integer::from(-100).lt_abs(&Float::NEGATIVE_INFINITY));

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for Natural

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

Compares a Natural to the absolute value of a Float.

No Natural is comparable to NaN. Every Natural is smaller in absolute value than infinity and negative infinity. The Natural zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NegativeInfinity};
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_float::Float;
use malachite_nz::natural::Natural;

assert!(Natural::from(100u32).gt_abs(&Float::from(80)));
assert!(Natural::from(100u32).lt_abs(&Float::INFINITY));
assert!(Natural::from(100u32).lt_abs(&Float::NEGATIVE_INFINITY));

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for Rational

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

Compares the absolute values of a Rational and a Float.

No Rational is comparable to NaN. Every Rational is smaller in absolute value than infinity and negative infinity. The Rational zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NegativeInfinity};
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_float::Float;
use malachite_q::Rational;

assert!(Rational::from(100).gt_abs(&Float::from(80)));
assert!(Rational::from(-100).gt_abs(&Float::from(-80)));
assert!(Rational::from(100).lt_abs(&Float::INFINITY));
assert!(Rational::from(-100).lt_abs(&Float::NEGATIVE_INFINITY));
assert!(Rational::from_unsigneds(1u8, 3).gt_abs(&Float::from(1.0f64 / 3.0)));

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for f32

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

Compares the absolute values of a primitive float and a Float.

The primitive float NaN is not comparable to any primitive float, not even the Float NaN. Every primitive float zero is equal to every Float zero, regardless of sign.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.sci_exponent().abs()).

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for f64

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

Compares the absolute values of a primitive float and a Float.

The primitive float NaN is not comparable to any primitive float, not even the Float NaN. Every primitive float zero is equal to every Float zero, regardless of sign.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.sci_exponent().abs()).

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for i128

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

Compares the absolute values of a signed primitive integer and a Float.

No primitive integer is comparable to NaN. Every primitive integer is smaller in absolute value than infinity and negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for i16

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

Compares the absolute values of a signed primitive integer and a Float.

No primitive integer is comparable to NaN. Every primitive integer is smaller in absolute value than infinity and negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for i32

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

Compares the absolute values of a signed primitive integer and a Float.

No primitive integer is comparable to NaN. Every primitive integer is smaller in absolute value than infinity and negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for i64

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

Compares the absolute values of a signed primitive integer and a Float.

No primitive integer is comparable to NaN. Every primitive integer is smaller in absolute value than infinity and negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for i8

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

Compares the absolute values of a signed primitive integer and a Float.

No primitive integer is comparable to NaN. Every primitive integer is smaller in absolute value than infinity and negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for isize

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

Compares the absolute values of a signed primitive integer and a Float.

No primitive integer is comparable to NaN. Every primitive integer is smaller in absolute value than infinity and negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for u128

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

Compares the absolute values of an unsigned primitive integer and a Float.

No primitive integer is comparable to NaN. Every primitive integer is smaller in absolute value than infinity and negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for u16

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

Compares the absolute values of an unsigned primitive integer and a Float.

No primitive integer is comparable to NaN. Every primitive integer is smaller in absolute value than infinity and negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for u32

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

Compares the absolute values of an unsigned primitive integer and a Float.

No primitive integer is comparable to NaN. Every primitive integer is smaller in absolute value than infinity and negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for u64

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

Compares the absolute values of an unsigned primitive integer and a Float.

No primitive integer is comparable to NaN. Every primitive integer is smaller in absolute value than infinity and negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for u8

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

Compares the absolute values of an unsigned primitive integer and a Float.

No primitive integer is comparable to NaN. Every primitive integer is smaller in absolute value than infinity and negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Float> for usize

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

Compares the absolute values of an unsigned primitive integer and a Float.

No primitive integer is comparable to NaN. Every primitive integer is smaller in absolute value than infinity and negative infinity. The integer zero is equal to both the Float zero and the Float negative zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits().

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Integer> for Float

fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>

Compares the absolute values of a Float and an Integer.

NaN is not comparable to any Integer. Infinity and negative infinity are greater in absolute value than any Integer. Both the Float zero and the Float negative zero are equal to the Integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NegativeInfinity};
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_float::Float;
use malachite_nz::integer::Integer;

assert!(Float::from(80).lt_abs(&Integer::from(100)));
assert!(Float::from(-80).lt_abs(&Integer::from(-100)));
assert!(Float::INFINITY.gt_abs(&Integer::from(100)));
assert!(Float::NEGATIVE_INFINITY.gt_abs(&Integer::from(-100)));

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for Float

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares the absolute value of a Float to a Natural.

NaN is not comparable to any Natural. Infinity and negative infinity are greater in absolute value than any Natural. Both the Float zero and the Float negative zero are equal to the Natural zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NegativeInfinity};
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_float::Float;
use malachite_nz::natural::Natural;

assert!(Float::from(80).lt_abs(&Natural::from(100u32)));
assert!(Float::INFINITY.gt_abs(&Natural::from(100u32)));
assert!(Float::NEGATIVE_INFINITY.gt_abs(&Natural::from(100u32)));

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Rational> for Float

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of a Float and a Rational.

NaN is not comparable to any Rational. Infinity and negative infinity are greater in absolute value than any Rational. Both the Float zero and the Float negative zero are equal to the Rational zero.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NegativeInfinity};
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_float::Float;
use malachite_q::Rational;

assert!(Float::from(80).lt_abs(&Rational::from(100)));
assert!(Float::from(-80).lt_abs(&Rational::from(-100)));
assert!(Float::INFINITY.gt_abs(&Rational::from(100)));
assert!(Float::NEGATIVE_INFINITY.gt_abs(&Rational::from(-100)));
assert!(Float::from(1.0f64 / 3.0).lt_abs(&Rational::from_unsigneds(1u8, 3)));

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<f32> for Float

fn partial_cmp_abs(&self, other: &f32) -> Option<Ordering>

Compares the absolute values of a Float and a primitive float.

The Float NaN is not comparable to any primitive float, not even the primitive float NaN. Every Float zero is equal to every primitive float zero, regardless of sign.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.sci_exponent().abs()).

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<f64> for Float

fn partial_cmp_abs(&self, other: &f64) -> Option<Ordering>

Compares the absolute values of a Float and a primitive float.

The Float NaN is not comparable to any primitive float, not even the primitive float NaN. Every Float zero is equal to every primitive float zero, regardless of sign.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.sci_exponent().abs()).

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<i128> for Float

fn partial_cmp_abs(&self, other: &i128) -> Option<Ordering>

Compares the absolute values of a Float and a signed primitive integer.

NaN is not comparable to any primitive integer. Infinity and negative infinity are greater in absolute value than any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<i16> for Float

fn partial_cmp_abs(&self, other: &i16) -> Option<Ordering>

Compares the absolute values of a Float and a signed primitive integer.

NaN is not comparable to any primitive integer. Infinity and negative infinity are greater in absolute value than any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<i32> for Float

fn partial_cmp_abs(&self, other: &i32) -> Option<Ordering>

Compares the absolute values of a Float and a signed primitive integer.

NaN is not comparable to any primitive integer. Infinity and negative infinity are greater in absolute value than any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<i64> for Float

fn partial_cmp_abs(&self, other: &i64) -> Option<Ordering>

Compares the absolute values of a Float and a signed primitive integer.

NaN is not comparable to any primitive integer. Infinity and negative infinity are greater in absolute value than any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<i8> for Float

fn partial_cmp_abs(&self, other: &i8) -> Option<Ordering>

Compares the absolute values of a Float and a signed primitive integer.

NaN is not comparable to any primitive integer. Infinity and negative infinity are greater in absolute value than any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<isize> for Float

fn partial_cmp_abs(&self, other: &isize) -> Option<Ordering>

Compares the absolute values of a Float and a signed primitive integer.

NaN is not comparable to any primitive integer. Infinity and negative infinity are greater in absolute value than any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<u128> for Float

fn partial_cmp_abs(&self, other: &u128) -> Option<Ordering>

Compares the absolute values of a Float and an unsigned primitive integer.

NaN is not comparable to any primitive integer. Infinity and negative infinity are greater in absolute value than any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<u16> for Float

fn partial_cmp_abs(&self, other: &u16) -> Option<Ordering>

Compares the absolute values of a Float and an unsigned primitive integer.

NaN is not comparable to any primitive integer. Infinity and negative infinity are greater in absolute value than any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<u32> for Float

fn partial_cmp_abs(&self, other: &u32) -> Option<Ordering>

Compares the absolute values of a Float and an unsigned primitive integer.

NaN is not comparable to any primitive integer. Infinity and negative infinity are greater in absolute value than any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<u64> for Float

fn partial_cmp_abs(&self, other: &u64) -> Option<Ordering>

Compares the absolute values of a Float and an unsigned primitive integer.

NaN is not comparable to any primitive integer. Infinity and negative infinity are greater in absolute value than any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<u8> for Float

fn partial_cmp_abs(&self, other: &u8) -> Option<Ordering>

Compares the absolute values of a Float and an unsigned primitive integer.

NaN is not comparable to any primitive integer. Infinity and negative infinity are greater in absolute value than any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<usize> for Float

fn partial_cmp_abs(&self, other: &usize) -> Option<Ordering>

Compares the absolute values of a Float and an unsigned primitive integer.

NaN is not comparable to any primitive integer. Infinity and negative infinity are greater in absolute value than any primitive integer. Both the Float zero and the Float negative zero are equal to the integer zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs for Float

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

Compares the absolute values of two Floats.

This implementation follows the IEEE 754 standard. NaN is not comparable to anything, not even itself. Floats with different precisions are equal if they represent the same numeric value.

For different comparison behavior that provides a total order, consider using ComparableFloat or ComparableFloatRef.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, OneHalf, Zero
};
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_float::Float;
use std::cmp::Ordering;
use std::str::FromStr;

assert_eq!(Float::NAN.partial_cmp_abs(&Float::NAN), None);
assert_eq!(Float::ZERO.partial_cmp_abs(&Float::NEGATIVE_ZERO), Some(Ordering::Equal));
assert_eq!(Float::ONE.partial_cmp_abs(&Float::one_prec(100)), Some(Ordering::Equal));
assert!(Float::INFINITY.gt_abs(&Float::ONE));
assert!(Float::NEGATIVE_INFINITY.gt_abs(&Float::ONE));
assert!(Float::ONE_HALF.lt_abs(&Float::ONE));
assert!(Float::ONE_HALF.lt_abs(&Float::NEGATIVE_ONE));

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PowerOf2<i64> for Float

fn power_of_2(pow: i64) -> Float

Raises 2 to an integer power, returning a Float with precision 1.

To get a Float with a higher precision, try Float::power_of_2_prec.

$f(k) = 2^k$.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_float::Float;

assert_eq!(Float::power_of_2(0i64).to_string(), "1.0");
assert_eq!(Float::power_of_2(3i64).to_string(), "8.0");
assert_eq!(Float::power_of_2(100i64).to_string(), "1.0e30");
assert_eq!(Float::power_of_2(-3i64).to_string(), "0.1");
assert_eq!(Float::power_of_2(-100i64).to_string(), "8.0e-31");

impl PowerOf2<u64> for Float

fn power_of_2(pow: u64) -> Float

Raises 2 to an integer power, returning a Float with precision 1.

To get a Float with a higher precision, try Float::power_of_2_prec.

$f(k) = 2^k$.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_float::Float;

assert_eq!(Float::power_of_2(0u64).to_string(), "1.0");
assert_eq!(Float::power_of_2(3u64).to_string(), "8.0");
assert_eq!(Float::power_of_2(100u64).to_string(), "1.0e30");

impl RawMantissaAndExponent<Natural, i64> for Float

fn raw_mantissa_and_exponent(self) -> (Natural, i64)

Returns the raw mantissa and exponent of a Float, taking the Float by value.

The raw exponent and raw mantissa are the actual bit patterns used to represent the components of self. When self is finite and nonzero, the raw mantissa is an integer whose number of significant bits is a multiple of the limb width, and which is equal to the absolute value of self multiplied by some integer power of 2. The raw exponent is one more than the floor of the base-2 logarithm of the absolute value of self.

The inverse operation is Self::from_raw_mantissa_and_exponent.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not finite or not zero.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::RawMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;
use malachite_q::Rational;

if Limb::WIDTH == u64::WIDTH {
    let (m, e) = Float::ONE.raw_mantissa_and_exponent();
    assert_eq!(m.to_string(), "9223372036854775808");
    assert_eq!(e, 1);

    let (m, e) = Float::from(std::f64::consts::PI).raw_mantissa_and_exponent();
    assert_eq!(m.to_string(), "14488038916154245120");
    assert_eq!(e, 2);

    let (m, e) = Float::from(Natural::from(3u32).pow(50u64)).raw_mantissa_and_exponent();
    assert_eq!(m.to_string(), "202070319366191015160784900114134073344");
    assert_eq!(e, 80);

    let (m, e) = Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0
        .raw_mantissa_and_exponent();
    assert_eq!(m.to_string(), "286514342137199872022965541161805021184");
    assert_eq!(e, -79);
}

fn raw_exponent(self) -> i64

Returns the raw exponent of a Float, taking the Float by value.

The raw exponent is one more than the floor of the base-2 logarithm of the absolute value of self.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not finite or not zero.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::RawMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(Float::ONE.raw_exponent(), 1);
assert_eq!(Float::from(std::f64::consts::PI).raw_exponent(), 2);
assert_eq!(Float::from(Natural::from(3u32).pow(50u64)).raw_exponent(), 80);
assert_eq!(
    Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0.raw_exponent(),
    -79
);

fn from_raw_mantissa_and_exponent( raw_mantissa: Natural, raw_exponent: i64 ) -> Float

Constructs a Float from its raw mantissa and exponent. The resulting Float is positive and has the smallest precision possible.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if raw_mantissa is zero, or if its number of significant bits is not divisible by the limb width.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::conversion::traits::RawMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;
use malachite_q::Rational;
use std::str::FromStr;

if Limb::WIDTH == u64::WIDTH {
    assert_eq!(
        Float::from_raw_mantissa_and_exponent(Natural::from(9223372036854775808u64), 1),
        1
    );
    assert_eq!(
        Float::from_raw_mantissa_and_exponent(Natural::from(14488038916154245120u64), 2),
        std::f64::consts::PI
    );
    assert_eq!(
        Float::from_raw_mantissa_and_exponent(
            Natural::from_str("202070319366191015160784900114134073344").unwrap(),
            80
        ),
        Natural::from(3u32).pow(50u64)
    );
    assert_eq!(
        Float::from_raw_mantissa_and_exponent(
            Natural::from_str("286514342137199872022965541161805021184").unwrap(),
            -79
        ),
        Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0
    );
}

fn raw_mantissa(self) -> M

Extracts the raw mantissa from a number.

impl<'a> RawMantissaAndExponent<Natural, i64, Float> for &'a Float

fn raw_mantissa_and_exponent(self) -> (Natural, i64)

Returns the raw mantissa and exponent of a Float, taking the Float by reference.

The raw exponent and raw mantissa are the actual bit patterns used to represent the components of self. When self is finite and nonzero, the raw mantissa is an integer whose number of significant bits is a multiple of the limb width, and which is equal to the absolute value of self multiplied by some integer power of 2. The raw exponent is one more than the floor of the base-2 logarithm of the absolute value of self.

The inverse operation is Float::from_raw_mantissa_and_exponent.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is f.significant_bits().

Panics

Panics if the Float is not finite or not zero.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::RawMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;
use malachite_q::Rational;

if Limb::WIDTH == u64::WIDTH {
    let (m, e) = (&Float::ONE).raw_mantissa_and_exponent();
    assert_eq!(m.to_string(), "9223372036854775808");
    assert_eq!(e, 1);

    let (m, e) = (&Float::from(std::f64::consts::PI)).raw_mantissa_and_exponent();
    assert_eq!(m.to_string(), "14488038916154245120");
    assert_eq!(e, 2);

    let (m, e) = (&Float::from(Natural::from(3u32).pow(50u64)))
        .raw_mantissa_and_exponent();
    assert_eq!(m.to_string(), "202070319366191015160784900114134073344");
    assert_eq!(e, 80);

    let (m, e) = (&Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0)
        .raw_mantissa_and_exponent();
    assert_eq!(m.to_string(), "286514342137199872022965541161805021184");
    assert_eq!(e, -79);
}

fn raw_exponent(self) -> i64

Returns the raw exponent of a Float, taking the Float by reference.

The raw exponent is one more than the floor of the base-2 logarithm of the absolute value of self.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not finite or not zero.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::RawMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!((&Float::ONE).raw_exponent(), 1);
assert_eq!((&Float::from(std::f64::consts::PI)).raw_exponent(), 2);
assert_eq!((&Float::from(Natural::from(3u32).pow(50u64))).raw_exponent(), 80);
assert_eq!(
    (&Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0).raw_exponent(),
    -79
);

fn from_raw_mantissa_and_exponent( raw_mantissa: Natural, raw_exponent: i64 ) -> Float

Constructs a Float from its raw mantissa and exponent. The resulting Float is positive and has the smallest precision possible.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if raw_mantissa is zero, or if its number of significant bits is not divisible by the limb width.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::conversion::traits::RawMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;
use malachite_q::Rational;
use std::str::FromStr;

if Limb::WIDTH == u64::WIDTH {
    assert_eq!(
        <&Float as RawMantissaAndExponent<_, _, _>>::from_raw_mantissa_and_exponent(
            Natural::from(9223372036854775808u64),
            1
        ),
        1
    );
    assert_eq!(
        <&Float as RawMantissaAndExponent<_, _, _>>::from_raw_mantissa_and_exponent(
            Natural::from(14488038916154245120u64),
            2
        ),
        std::f64::consts::PI
    );
    assert_eq!(
        <&Float as RawMantissaAndExponent<_, _, _>>::from_raw_mantissa_and_exponent(
            Natural::from_str("202070319366191015160784900114134073344").unwrap(),
            80
    ),
        Natural::from(3u32).pow(50u64)
    );
    assert_eq!(
        <&Float as RawMantissaAndExponent<_, _, _>>::from_raw_mantissa_and_exponent(
            Natural::from_str("286514342137199872022965541161805021184").unwrap(),
            -79
        ),
        Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0
    );
}

fn raw_mantissa(self) -> M

Extracts the raw mantissa from a number.

impl<'a> RoundingFrom<&'a Float> for Integer

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (Integer, Ordering)

Converts a Float to an Integer, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is NaN or infinite, the function will panic regardless of the rounding mode.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is f.complexity().

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is NaN or infinite.

Examples

use malachite_base::num::basic::traits::NegativeInfinity;
use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode;
use malachite_base::strings::ToDebugString;
use malachite_float::Float;
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::rounding_from(&Float::from(1.5), RoundingMode::Floor).to_debug_string(),
    "(1, Less)"
);
assert_eq!(
    Integer::rounding_from(&Float::from(1.5), RoundingMode::Ceiling).to_debug_string(),
    "(2, Greater)"
);
assert_eq!(
    Integer::rounding_from(&Float::from(1.5), RoundingMode::Nearest).to_debug_string(),
    "(2, Greater)"
);

assert_eq!(
    Integer::rounding_from(&Float::from(-1.5), RoundingMode::Floor).to_debug_string(),
    "(-2, Less)"
);
assert_eq!(
    Integer::rounding_from(&Float::from(-1.5), RoundingMode::Ceiling).to_debug_string(),
    "(-1, Greater)"
);
assert_eq!(
    Integer::rounding_from(&Float::from(-1.5), RoundingMode::Nearest).to_debug_string(),
    "(-2, Less)"
);

impl<'a> RoundingFrom<&'a Float> for Natural

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (Natural, Ordering)

Converts a Float to a Natural, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is negative (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN or positive infinity, the function will panic regardless of the rounding mode.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is f.complexity().

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is less than zero and rm is not Down, Ceiling, or Nearest, or if the Float is NaN or positive infinity.

Examples

use malachite_base::num::basic::traits::NegativeInfinity;
use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode;
use malachite_base::strings::ToDebugString;
use malachite_float::Float;
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::rounding_from(&Float::from(1.5), RoundingMode::Floor).to_debug_string(),
    "(1, Less)"
);
assert_eq!(
    Natural::rounding_from(&Float::from(1.5), RoundingMode::Ceiling).to_debug_string(),
    "(2, Greater)"
);
assert_eq!(
    Natural::rounding_from(&Float::from(1.5), RoundingMode::Nearest).to_debug_string(),
    "(2, Greater)"
);

assert_eq!(
    Natural::rounding_from(&Float::NEGATIVE_INFINITY, RoundingMode::Down)
        .to_debug_string(),
    "(0, Greater)"
);
assert_eq!(
    Natural::rounding_from(&Float::NEGATIVE_INFINITY, RoundingMode::Ceiling)
        .to_debug_string(),
    "(0, Greater)"
);
assert_eq!(
    Natural::rounding_from(&Float::NEGATIVE_INFINITY, RoundingMode::Nearest)
        .to_debug_string(),
    "(0, Greater)"
);

impl<'a> RoundingFrom<&'a Float> for f32

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (f32, Ordering)

Converts a Float to a primitive float, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value. (Although a NaN is not comparable to anything, converting a NaN to a NaN will also return Ordering::Equals, indicating an exact conversion.)

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not exactly equal to any float of the target type, and rm is Exact.

Examples

See here.

impl<'a> RoundingFrom<&'a Float> for f64

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (f64, Ordering)

Converts a Float to a primitive float, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value. (Although a NaN is not comparable to anything, converting a NaN to a NaN will also return Ordering::Equals, indicating an exact conversion.)

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not exactly equal to any float of the target type, and rm is Exact.

Examples

See here.

impl<'a> RoundingFrom<&'a Float> for i128

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (i128, Ordering)

Converts a Float to a signed primitive integer, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is less than the minimum representable value of the signed type (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the signed type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is smaller than the minimum representable value of the signed type and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the signed type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl<'a> RoundingFrom<&'a Float> for i16

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (i16, Ordering)

Converts a Float to a signed primitive integer, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is less than the minimum representable value of the signed type (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the signed type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is smaller than the minimum representable value of the signed type and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the signed type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl<'a> RoundingFrom<&'a Float> for i32

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (i32, Ordering)

Converts a Float to a signed primitive integer, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is less than the minimum representable value of the signed type (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the signed type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is smaller than the minimum representable value of the signed type and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the signed type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl<'a> RoundingFrom<&'a Float> for i64

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (i64, Ordering)

Converts a Float to a signed primitive integer, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is less than the minimum representable value of the signed type (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the signed type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is smaller than the minimum representable value of the signed type and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the signed type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl<'a> RoundingFrom<&'a Float> for i8

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (i8, Ordering)

Converts a Float to a signed primitive integer, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is less than the minimum representable value of the signed type (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the signed type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is smaller than the minimum representable value of the signed type and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the signed type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl<'a> RoundingFrom<&'a Float> for isize

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (isize, Ordering)

Converts a Float to a signed primitive integer, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is less than the minimum representable value of the signed type (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the signed type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is smaller than the minimum representable value of the signed type and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the signed type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl<'a> RoundingFrom<&'a Float> for u128

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (u128, Ordering)

Converts a Float to an unsigned primitive integer, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is negative (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the unsigned type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is less than zero and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the unsigned type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl<'a> RoundingFrom<&'a Float> for u16

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (u16, Ordering)

Converts a Float to an unsigned primitive integer, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is negative (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the unsigned type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is less than zero and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the unsigned type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl<'a> RoundingFrom<&'a Float> for u32

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (u32, Ordering)

Converts a Float to an unsigned primitive integer, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is negative (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the unsigned type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is less than zero and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the unsigned type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl<'a> RoundingFrom<&'a Float> for u64

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (u64, Ordering)

Converts a Float to an unsigned primitive integer, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is negative (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the unsigned type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is less than zero and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the unsigned type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl<'a> RoundingFrom<&'a Float> for u8

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (u8, Ordering)

Converts a Float to an unsigned primitive integer, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is negative (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the unsigned type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is less than zero and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the unsigned type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl<'a> RoundingFrom<&'a Float> for usize

fn rounding_from(f: &'a Float, rm: RoundingMode) -> (usize, Ordering)

Converts a Float to an unsigned primitive integer, using a specified RoundingMode and taking the Float by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is negative (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the unsigned type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is less than zero and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the unsigned type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl RoundingFrom<Float> for Integer

fn rounding_from(f: Float, rm: RoundingMode) -> (Integer, Ordering)

Converts a Float to an Integer, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is NaN or infinite, the function will panic regardless of the rounding mode.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is f.complexity().

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is NaN or infinite.

Examples

use malachite_base::num::basic::traits::NegativeInfinity;
use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode;
use malachite_base::strings::ToDebugString;
use malachite_float::Float;
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::rounding_from(Float::from(1.5), RoundingMode::Floor).to_debug_string(),
    "(1, Less)"
);
assert_eq!(
    Integer::rounding_from(Float::from(1.5), RoundingMode::Ceiling).to_debug_string(),
    "(2, Greater)"
);
assert_eq!(
    Integer::rounding_from(Float::from(1.5), RoundingMode::Nearest).to_debug_string(),
    "(2, Greater)"
);

assert_eq!(
    Integer::rounding_from(Float::from(-1.5), RoundingMode::Floor).to_debug_string(),
    "(-2, Less)"
);
assert_eq!(
    Integer::rounding_from(Float::from(-1.5), RoundingMode::Ceiling).to_debug_string(),
    "(-1, Greater)"
);
assert_eq!(
    Integer::rounding_from(Float::from(-1.5), RoundingMode::Nearest).to_debug_string(),
    "(-2, Less)"
);

impl RoundingFrom<Float> for Natural

fn rounding_from(f: Float, rm: RoundingMode) -> (Natural, Ordering)

Converts a Float to a Natural, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is negative (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN or positive infinity, the function will panic regardless of the rounding mode.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is f.complexity().

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is less than zero and rm is not Down, Ceiling, or Nearest, or if the Float is NaN or positive infinity.

Examples

use malachite_base::num::basic::traits::NegativeInfinity;
use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode;
use malachite_base::strings::ToDebugString;
use malachite_float::Float;
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::rounding_from(Float::from(1.5), RoundingMode::Floor).to_debug_string(),
    "(1, Less)"
);
assert_eq!(
    Natural::rounding_from(Float::from(1.5), RoundingMode::Ceiling).to_debug_string(),
    "(2, Greater)"
);
assert_eq!(
    Natural::rounding_from(Float::from(1.5), RoundingMode::Nearest).to_debug_string(),
    "(2, Greater)"
);

assert_eq!(
    Natural::rounding_from(Float::NEGATIVE_INFINITY, RoundingMode::Down).to_debug_string(),
    "(0, Greater)"
);
assert_eq!(
    Natural::rounding_from(Float::NEGATIVE_INFINITY, RoundingMode::Ceiling)
        .to_debug_string(),
    "(0, Greater)"
);
assert_eq!(
    Natural::rounding_from(Float::NEGATIVE_INFINITY, RoundingMode::Nearest)
        .to_debug_string(),
    "(0, Greater)"
);

impl RoundingFrom<Float> for f32

fn rounding_from(f: Float, rm: RoundingMode) -> (f32, Ordering)

Converts a Float to a primitive float, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value. (Although a NaN is not comparable to anything, converting a NaN to a NaN will also return Ordering::Equals, indicating an exact conversion.)

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not exactly equal to any float of the target type, and rm is Exact.

Examples

See here.

impl RoundingFrom<Float> for f64

fn rounding_from(f: Float, rm: RoundingMode) -> (f64, Ordering)

Converts a Float to a primitive float, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value. (Although a NaN is not comparable to anything, converting a NaN to a NaN will also return Ordering::Equals, indicating an exact conversion.)

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not exactly equal to any float of the target type, and rm is Exact.

Examples

See here.

impl RoundingFrom<Float> for i128

fn rounding_from(f: Float, rm: RoundingMode) -> (i128, Ordering)

Converts a Float to a signed primitive integer, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is less than the minimum representable value of the signed type (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the signed type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is smaller than the minimum representable value of the signed type and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the signed type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl RoundingFrom<Float> for i16

fn rounding_from(f: Float, rm: RoundingMode) -> (i16, Ordering)

Converts a Float to a signed primitive integer, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is less than the minimum representable value of the signed type (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the signed type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is smaller than the minimum representable value of the signed type and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the signed type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl RoundingFrom<Float> for i32

fn rounding_from(f: Float, rm: RoundingMode) -> (i32, Ordering)

Converts a Float to a signed primitive integer, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is less than the minimum representable value of the signed type (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the signed type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is smaller than the minimum representable value of the signed type and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the signed type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl RoundingFrom<Float> for i64

fn rounding_from(f: Float, rm: RoundingMode) -> (i64, Ordering)

Converts a Float to a signed primitive integer, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is less than the minimum representable value of the signed type (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the signed type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is smaller than the minimum representable value of the signed type and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the signed type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl RoundingFrom<Float> for i8

fn rounding_from(f: Float, rm: RoundingMode) -> (i8, Ordering)

Converts a Float to a signed primitive integer, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is less than the minimum representable value of the signed type (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the signed type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is smaller than the minimum representable value of the signed type and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the signed type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl RoundingFrom<Float> for isize

fn rounding_from(f: Float, rm: RoundingMode) -> (isize, Ordering)

Converts a Float to a signed primitive integer, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is less than the minimum representable value of the signed type (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the signed type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is smaller than the minimum representable value of the signed type and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the signed type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl RoundingFrom<Float> for u128

fn rounding_from(f: Float, rm: RoundingMode) -> (u128, Ordering)

Converts a Float to an unsigned primitive integer, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is negative (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the unsigned type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is less than zero and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the unsigned type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl RoundingFrom<Float> for u16

fn rounding_from(f: Float, rm: RoundingMode) -> (u16, Ordering)

Converts a Float to an unsigned primitive integer, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is negative (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the unsigned type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is less than zero and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the unsigned type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl RoundingFrom<Float> for u32

fn rounding_from(f: Float, rm: RoundingMode) -> (u32, Ordering)

Converts a Float to an unsigned primitive integer, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is negative (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the unsigned type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is less than zero and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the unsigned type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl RoundingFrom<Float> for u64

fn rounding_from(f: Float, rm: RoundingMode) -> (u64, Ordering)

Converts a Float to an unsigned primitive integer, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is negative (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the unsigned type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is less than zero and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the unsigned type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl RoundingFrom<Float> for u8

fn rounding_from(f: Float, rm: RoundingMode) -> (u8, Ordering)

Converts a Float to an unsigned primitive integer, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is negative (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the unsigned type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is less than zero and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the unsigned type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl RoundingFrom<Float> for usize

fn rounding_from(f: Float, rm: RoundingMode) -> (usize, Ordering)

Converts a Float to an unsigned primitive integer, using a specified RoundingMode and taking the Float by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the Float is negative (including negative infinity), then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Float is greater than the maximum representable value of the unsigned type (including infinity), then it will be rounded to the maximum value when the RoundingMode is Floor, Down, or Nearest. Otherwise, this function will panic.

If the Float is NaN, the function will panic regardless of the rounding mode.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if the Float is not an integer and rm is Exact, or if the Float is less than zero and rm is not Down, Ceiling, or Nearest, if the Float is greater than the maximum representable value of the unsigned type and rm is not Down, Floor, or Nearest, or if the Float is NaN.

Examples

See here.

impl SciMantissaAndExponent<Float, i64> for Float

fn sci_mantissa_and_exponent(self) -> (Float, i64)

Returns a Float’s scientific mantissa and exponent, taking the Float by value.

When $x$ is finite and nonzero, we can write $|x| = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational mantissa as a Float. $$ f(x) = (\frac{|x|}{2^{\lfloor \log_2 |x| \rfloor}}, \lfloor \log_2 |x| \rfloor). $$

Worst-case complexity

Constant time and additional memory.

Panics

Panics if self is zero or not finite.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::SciMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(Float::ONE.sci_mantissa_and_exponent(), (Float::ONE, 0));

let (m, e) = Float::from(std::f64::consts::PI).sci_mantissa_and_exponent();
assert_eq!(m.to_string(), "1.5707963267948966");
assert_eq!(e, 1);

let (m, e) = Float::from(Natural::from(3u32).pow(50u64)).sci_mantissa_and_exponent();
assert_eq!(m.to_string(), "1.187662594419065093441695");
assert_eq!(e, 79);

let (m, e) = Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0
    .sci_mantissa_and_exponent();
assert_eq!(m.to_string(), "1.683979953059212693885095551367");
assert_eq!(e, -80);

fn sci_exponent(self) -> i64

Returns a Float’s scientific exponent, taking the Float by value.

When $x$ is finite and nonzero, we can write $|x| = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$. $$ f(x) = \lfloor \log_2 |x| \rfloor. $$

Worst-case complexity

Constant time and additional memory.

Panics

Panics if self is zero or not finite.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::SciMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(Float::ONE.sci_exponent(), 0);
assert_eq!(Float::from(std::f64::consts::PI).sci_exponent(), 1);
assert_eq!(Float::from(Natural::from(3u32).pow(50u64)).sci_exponent(), 79);
assert_eq!(
    Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0.sci_exponent(),
    -80
);

fn from_sci_mantissa_and_exponent( sci_mantissa: Float, sci_exponent: i64 ) -> Option<Float>

Constructs a Float from its scientific mantissa and exponent.

When $x$ is finite and nonzero, we can write $|x| = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$.

$$ f(x) = 2^{e_i}m_i. $$

If the mantissa is zero or not finite, this function panics. If it is finite but not in the interval $[1, 2)$, this function returns None.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::{FromStringBase, SciMantissaAndExponent};
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(Float::from_sci_mantissa_and_exponent(Float::ONE, 0).unwrap(), 1);
assert_eq!(
    Float::from_sci_mantissa_and_exponent(
        Float::from_string_base(16, "0x1.921fb54442d18#53").unwrap(),
        1
    ).unwrap(),
    std::f64::consts::PI
);
assert_eq!(
    Float::from_sci_mantissa_and_exponent(
        Float::from_string_base(16, "0x1.300aa7e1b65fa13bc792#80").unwrap(),
        79
    ).unwrap(),
    Natural::from(3u32).pow(50u64)
);
assert_eq!(
    Float::from_sci_mantissa_and_exponent(
        Float::from_string_base(16, "0x1.af194f6982497a23f9dc546d6#100").unwrap(),
        -80
    ).unwrap(),
    Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0
);

fn sci_mantissa(self) -> M

Extracts the scientific mantissa from a number.

impl<'a> SciMantissaAndExponent<Float, i64, Float> for &'a Float

fn sci_mantissa_and_exponent(self) -> (Float, i64)

Returns a Float’s scientific mantissa and exponent, taking the Float by reference.

When $x$ is finite and nonzero, we can write $|x| = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational mantissa as a Float. $$ f(x) = (\frac{|x|}{2^{\lfloor \log_2 |x| \rfloor}}, \lfloor \log_2 |x| \rfloor). $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

Panics if self is zero or not finite.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::SciMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!((&Float::ONE).sci_mantissa_and_exponent(), (Float::ONE, 0));

let (m, e): (Float, i64) = (&Float::from(std::f64::consts::PI))
    .sci_mantissa_and_exponent();
assert_eq!(m.to_string(), "1.5707963267948966");
assert_eq!(e, 1);

let (m, e): (Float, i64) = (&Float::from(Natural::from(3u32).pow(50u64)))
    .sci_mantissa_and_exponent();
assert_eq!(m.to_string(), "1.187662594419065093441695");
assert_eq!(e, 79);

let (m, e): (Float, i64) =
    (&Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0)
        .sci_mantissa_and_exponent();
assert_eq!(m.to_string(), "1.683979953059212693885095551367");
assert_eq!(e, -80);

fn sci_exponent(self) -> i64

Returns a Float’s scientific exponent, taking the Float by reference.

When $x$ is finite and nonzero, we can write $|x| = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$. $$ f(x) = \lfloor \log_2 |x| \rfloor. $$

Worst-case complexity

Constant time and additional memory.

Panics

Panics if self is zero or not finite.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::SciMantissaAndExponent;
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(<&Float as SciMantissaAndExponent<Float, _, _>>::sci_exponent(&Float::ONE), 0);
assert_eq!(<&Float as SciMantissaAndExponent<Float, _, _>>::sci_exponent(
    &Float::from(std::f64::consts::PI)),
    1
);
assert_eq!(<&Float as SciMantissaAndExponent<Float, _, _>>::sci_exponent(
    &Float::from(Natural::from(3u32).pow(50u64))),
    79
);
assert_eq!(<&Float as SciMantissaAndExponent<Float, _, _>>::sci_exponent(
    &Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0),
    -80
);

fn from_sci_mantissa_and_exponent( sci_mantissa: Float, sci_exponent: i64 ) -> Option<Float>

Constructs a Float from its scientific mantissa and exponent.

When $x$ is finite and nonzero, we can write $|x| = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$.

$$ f(x) = 2^{e_i}m_i. $$

If the mantissa is zero or not finite, this function panics. If it is finite but not in the interval $[1, 2)$, this function returns None.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_base::num::conversion::traits::{FromStringBase, SciMantissaAndExponent};
use malachite_float::Float;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(Float::from_sci_mantissa_and_exponent(Float::ONE, 0).unwrap(), 1);
assert_eq!(
    <&Float as SciMantissaAndExponent<Float, _, _>>::from_sci_mantissa_and_exponent(
        Float::from_string_base(16, "0x1.921fb54442d18#53").unwrap(),
        1
    ).unwrap(),
    std::f64::consts::PI
);
assert_eq!(
    <&Float as SciMantissaAndExponent<Float, _, _>>::from_sci_mantissa_and_exponent(
        Float::from_string_base(16, "0x1.300aa7e1b65fa13bc792#80").unwrap(),
        79
    ).unwrap(),
    Natural::from(3u32).pow(50u64)
);
assert_eq!(
    <&Float as SciMantissaAndExponent<Float, _, _>>::from_sci_mantissa_and_exponent(
        Float::from_string_base(16, "0x1.af194f6982497a23f9dc546d6#100").unwrap(),
        -80
    ).unwrap(),
    Float::from_rational_prec(Rational::from(3u32).pow(-50i64), 100).0
);

fn sci_mantissa(self) -> M

Extracts the scientific mantissa from a number.

impl<'a> SciMantissaAndExponent<f32, i64, Float> for &'a Float

fn sci_mantissa_and_exponent(self) -> (f32, i64)

Returns a Float’s scientific mantissa and exponent, taking the Float by value.

When $x$ is finite and nonzero, we can write $|x| = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational mantissa as a primitive float. The conversion might not be exact, so we round to the nearest float using the Nearest rounding mode. To use other rounding modes, use sci_mantissa_and_exponent_round. $$ f(x) \approx (\frac{|x|}{2^{\lfloor \log_2 |x| \rfloor}}, \lfloor \log_2 |x| \rfloor). $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

Panics if self is zero or not finite.

Examples

See here.

fn from_sci_mantissa_and_exponent( sci_mantissa: f32, sci_exponent: i64 ) -> Option<Float>

Constructs a Float from its scientific mantissa and exponent.

When $x$ is finite and nonzero, we can write $|x| = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$.

$$ f(x) = 2^{e_i}m_i. $$

If the mantissa is zero or not finite, this function panics. If it is finite but not in the interval $[1, 2)$, this function returns None.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn sci_mantissa(self) -> M

Extracts the scientific mantissa from a number.

fn sci_exponent(self) -> E

Extracts the scientific exponent from a number.

impl<'a> SciMantissaAndExponent<f64, i64, Float> for &'a Float

fn sci_mantissa_and_exponent(self) -> (f64, i64)

Returns a Float’s scientific mantissa and exponent, taking the Float by value.

When $x$ is finite and nonzero, we can write $|x| = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational mantissa as a primitive float. The conversion might not be exact, so we round to the nearest float using the Nearest rounding mode. To use other rounding modes, use sci_mantissa_and_exponent_round. $$ f(x) \approx (\frac{|x|}{2^{\lfloor \log_2 |x| \rfloor}}, \lfloor \log_2 |x| \rfloor). $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

Panics if self is zero or not finite.

Examples

See here.

fn from_sci_mantissa_and_exponent( sci_mantissa: f64, sci_exponent: i64 ) -> Option<Float>

Constructs a Float from its scientific mantissa and exponent.

When $x$ is finite and nonzero, we can write $|x| = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$.

$$ f(x) = 2^{e_i}m_i. $$

If the mantissa is zero or not finite, this function panics. If it is finite but not in the interval $[1, 2)$, this function returns None.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn sci_mantissa(self) -> M

Extracts the scientific mantissa from a number.

fn sci_exponent(self) -> E

Extracts the scientific exponent from a number.

impl Sign for Float

fn sign(&self) -> Ordering

Returns the sign of a Float.

Returns Greater if the sign is positive and Less if the sign is negative. Never returns Equal. Positive infinity and positive zero have a positive sign, and negative infinity and negative zero have a negative sign.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if self is NaN.

Examples

use malachite_base::num::arithmetic::traits::Sign;
use malachite_base::num::basic::traits::{
    Infinity, NaN, NegativeInfinity, NegativeOne, NegativeZero, One, Zero
};
use malachite_float::Float;
use std::cmp::Ordering;

assert_eq!(Float::INFINITY.sign(), Ordering::Greater);
assert_eq!(Float::NEGATIVE_INFINITY.sign(), Ordering::Less);
assert_eq!(Float::ZERO.sign(), Ordering::Greater);
assert_eq!(Float::NEGATIVE_ZERO.sign(), Ordering::Less);
assert_eq!(Float::ONE.sign(), Ordering::Greater);
assert_eq!(Float::NEGATIVE_ONE.sign(), Ordering::Less);

impl<'a> SignificantBits for &'a Float

fn significant_bits(self) -> u64

Returns the number of significant bits of a Float. This is defined as follows:

$$ f(\text{NaN}) = f(\pm\infty) = f(\pm 0.0) = 1, $$

and, if $x$ is finite and nonzero,

$$ f(x) = p, $$

where $p$ is the precision of $x$.

See also the complexity function.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_base::num::logic::traits::SignificantBits;
use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::basic::traits::{NaN, One};
use malachite_float::Float;

assert_eq!(Float::NAN.significant_bits(), 1);
assert_eq!(Float::ONE.significant_bits(), 1);
assert_eq!(Float::one_prec(100).significant_bits(), 100);
assert_eq!(Float::from(std::f64::consts::PI).significant_bits(), 53);
assert_eq!(Float::power_of_2(100u64).significant_bits(), 1);
assert_eq!(Float::power_of_2(-100i64).significant_bits(), 1);

impl<'a, 'b> Sub<&'a Float> for &'b Float

fn sub(self, other: &'a Float) -> Float

Subtracts two Floats, taking both by reference.

If the output has a precision, it is the maximum of the precisions of the inputs. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

Special cases:

• $f(\text{NaN},x)=f(x,\text{NaN})=f(\infty,\infty)=f(-\infty,-\infty)=\text{NaN}$
• $f(\infty,x)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0)=0.0$
• $f(-0.0,0.0)=-0.0$
• $f(0.0,0.0)=f(-0.0,-0.0)=0.0$
• $f(x,0.0)=f(x,-0.0)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(0.0,x)=f(-0.0,x)=-x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,x)=0.0$ if $x$ is finite and nonzero

If you want to use a rounding mode other than Nearest, consider using Float::sub_prec instead. If you want to specify the output precision, consider using Float::sub_round. If you want both of these things, consider using Float::sub_prec_round.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_float::Float;

assert!((&Float::from(1.5) - &Float::NAN).is_nan());
assert_eq!(&Float::from(1.5) - &Float::INFINITY, Float::NEGATIVE_INFINITY);
assert_eq!(&Float::from(1.5) - &Float::NEGATIVE_INFINITY, Float::INFINITY);
assert!((&Float::INFINITY - &Float::INFINITY).is_nan());

assert_eq!(&Float::from(1.5) - &Float::from(2.5), -1.0);
assert_eq!(&Float::from(1.5) - &Float::from(-2.5), 4.0);
assert_eq!(&Float::from(-1.5) - &Float::from(2.5), -4.0);
assert_eq!(&Float::from(-1.5) - &Float::from(-2.5), 1.0);

type Output = Float

The resulting type after applying the - operator.

impl<'a, 'b> Sub<&'a Float> for &'b Rational

fn sub(self, other: &Float) -> Float

Subtracts a Rational by a Float, taking both by reference.

If the output has a precision, it is the precision of the input Float. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(x,\text{NaN})=\text{NaN}$
• $f(x,\infty)=-\infty$
• $f(x,-\infty)=\infty$
• $f(0,0.0)=-0.0$
• $f(0,-0.0)=0.0$
• $f(x,0.0)=f(x,-0.0)=x$
• $f(0,x)=-x$
• $f(x,x)=0.0$ if $x$ is nonzero

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((&Rational::exact_from(1.5) - &Float::NAN).is_nan());
assert_eq!(&Rational::exact_from(1.5) - &Float::INFINITY, Float::NEGATIVE_INFINITY);
assert_eq!(&Rational::exact_from(1.5) - &Float::NEGATIVE_INFINITY, Float::INFINITY);

assert_eq!(&Rational::exact_from(1.5) - &Float::from(2.5), -1.0);
assert_eq!(&Rational::exact_from(1.5) - &Float::from(-2.5), 4.0);
assert_eq!(&Rational::exact_from(-1.5) - &Float::from(2.5), -4.0);
assert_eq!(&Rational::exact_from(-1.5) - &Float::from(-2.5), 1.0);

type Output = Float

The resulting type after applying the - operator.

impl<'a> Sub<&'a Float> for Float

fn sub(self, other: &'a Float) -> Float

Subtracts two Floats, taking the first by value and the second by reference.

If the output has a precision, it is the maximum of the precisions of the inputs. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

Special cases:

• $f(\text{NaN},x)=f(x,\text{NaN})=f(\infty,\infty)=f(-\infty,-\infty)=\text{NaN}$
• $f(\infty,x)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0)=0.0$
• $f(-0.0,0.0)=-0.0$
• $f(0.0,0.0)=f(-0.0,-0.0)=0.0$
• $f(x,0.0)=f(x,-0.0)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(0.0,x)=f(-0.0,x)=-x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,x)=0.0$ if $x$ is finite and nonzero

If you want to use a rounding mode other than Nearest, consider using Float::sub_prec_val_ref instead. If you want to specify the output precision, consider using Float::sub_round_val_ref. If you want both of these things, consider using Float::sub_prec_round_val_ref.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is max(self.significant_bits(), other.significant_bits()), and $m$ is other.significant_bits().

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_float::Float;

assert!((Float::from(1.5) - &Float::NAN).is_nan());
assert_eq!(Float::from(1.5) - &Float::INFINITY, Float::NEGATIVE_INFINITY);
assert_eq!(Float::from(1.5) - &Float::NEGATIVE_INFINITY, Float::INFINITY);
assert!((Float::INFINITY - &Float::INFINITY).is_nan());

assert_eq!(Float::from(1.5) - &Float::from(2.5), -1.0);
assert_eq!(Float::from(1.5) - &Float::from(-2.5), 4.0);
assert_eq!(Float::from(-1.5) - &Float::from(2.5), -4.0);
assert_eq!(Float::from(-1.5) - &Float::from(-2.5), 1.0);

type Output = Float

The resulting type after applying the - operator.

impl<'a> Sub<&'a Float> for Rational

fn sub(self, other: &Float) -> Float

Subtracts a Rational by a Float, taking the Rational by value and the Float by reference.

If the output has a precision, it is the precision of the input Float. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(x,\text{NaN})=\text{NaN}$
• $f(x,\infty)=-\infty$
• $f(x,-\infty)=\infty$
• $f(0,0.0)=-0.0$
• $f(0,-0.0)=0.0$
• $f(x,0.0)=f(x,-0.0)=x$
• $f(0,x)=-x$
• $f(x,x)=0.0$ if $x$ is nonzero

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((Rational::exact_from(1.5) - &Float::NAN).is_nan());
assert_eq!(Rational::exact_from(1.5) - &Float::INFINITY, Float::NEGATIVE_INFINITY);
assert_eq!(Rational::exact_from(1.5) - &Float::NEGATIVE_INFINITY, Float::INFINITY);

assert_eq!(Rational::exact_from(1.5) - &Float::from(2.5), -1.0);
assert_eq!(Rational::exact_from(1.5) - &Float::from(-2.5), 4.0);
assert_eq!(Rational::exact_from(-1.5) - &Float::from(2.5), -4.0);
assert_eq!(Rational::exact_from(-1.5) - &Float::from(-2.5), 1.0);

type Output = Float

The resulting type after applying the - operator.

impl<'a, 'b> Sub<&'a Rational> for &'b Float

fn sub(self, other: &Rational) -> Float

Subtracts a Float by a Rational, taking both by reference.

If the output has a precision, it is the precision of the input Float. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(\text{NaN},x)=\text{NaN}$
• $f(\infty,x)=\infty$
• $f(-\infty,x)=-\infty$
• $f(0.0,0)=0.0$
• $f(-0.0,0)=-0.0$
• $f(x,0)=x$
• $f(0.0,x)=f(-0.0,x)=-x$
• $f(x,x)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::sub_rational_prec_ref_ref instead. If you want to specify the output precision, consider using Float::sub_rational_round_ref_ref. If you want both of these things, consider using Float::sub_rational_prec_round_ref_ref.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((&Float::NAN - Rational::exact_from(1.5)).is_nan());
assert_eq!(&Float::INFINITY - Rational::exact_from(1.5), Float::INFINITY);
assert_eq!(&Float::NEGATIVE_INFINITY - Rational::exact_from(1.5), Float::NEGATIVE_INFINITY);

assert_eq!(&Float::from(2.5) - &Rational::exact_from(1.5), 1.0);
assert_eq!(&Float::from(2.5) - &Rational::exact_from(-1.5), 4.0);
assert_eq!(&Float::from(-2.5) - &Rational::exact_from(1.5), -4.0);
assert_eq!(&Float::from(-2.5) - &Rational::exact_from(-1.5), -1.0);

type Output = Float

The resulting type after applying the - operator.

impl<'a> Sub<&'a Rational> for Float

fn sub(self, other: &Rational) -> Float

Subtracts a Float by a Rational, taking the first by value and the second by reference.

If the output has a precision, it is the precision of the input Float. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(\text{NaN},x)=\text{NaN}$
• $f(\infty,x)=\infty$
• $f(-\infty,x)=-\infty$
• $f(0.0,0)=0.0$
• $f(-0.0,0)=-0.0$
• $f(x,0)=x$
• $f(0.0,x)=f(-0.0,x)=-x$
• $f(x,x)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::sub_rational_prec_val_ref instead. If you want to specify the output precision, consider using Float::sub_rational_round_val_ref. If you want both of these things, consider using Float::sub_rational_prec_round_val_ref.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((Float::NAN - &Rational::exact_from(1.5)).is_nan());
assert_eq!(Float::INFINITY - &Rational::exact_from(1.5), Float::INFINITY);
assert_eq!(Float::NEGATIVE_INFINITY - &Rational::exact_from(1.5), Float::NEGATIVE_INFINITY);

assert_eq!(Float::from(2.5) - &Rational::exact_from(1.5), 1.0);
assert_eq!(Float::from(2.5) - &Rational::exact_from(-1.5), 4.0);
assert_eq!(Float::from(-2.5) - &Rational::exact_from(1.5), -4.0);
assert_eq!(Float::from(-2.5) - &Rational::exact_from(-1.5), -1.0);

type Output = Float

The resulting type after applying the - operator.

impl<'a> Sub<Float> for &'a Float

fn sub(self, other: Float) -> Float

Subtracts two Floats, taking the first by reference and the second by value.

If the output has a precision, it is the maximum of the precisions of the inputs. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

Special cases:

• $f(\text{NaN},x)=f(x,\text{NaN})=f(\infty,\infty)=f(-\infty,-\infty)=\text{NaN}$
• $f(\infty,x)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0)=0.0$
• $f(-0.0,0.0)=-0.0$
• $f(0.0,0.0)=f(-0.0,-0.0)=0.0$
• $f(x,0.0)=f(x,-0.0)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(0.0,x)=f(-0.0,x)=-x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,x)=0.0$ if $x$ is finite and nonzero

If you want to use a rounding mode other than Nearest, consider using Float::sub_prec_ref_val instead. If you want to specify the output precision, consider using Float::sub_round_ref_val. If you want both of these things, consider using Float::sub_prec_round_ref_val.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is max(self.significant_bits(), other.significant_bits()), and $m$ is self.significant_bits().

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_float::Float;

assert!((&Float::from(1.5) - Float::NAN).is_nan());
assert_eq!(&Float::from(1.5) - Float::INFINITY, Float::NEGATIVE_INFINITY);
assert_eq!(&Float::from(1.5) - Float::NEGATIVE_INFINITY, Float::INFINITY);
assert!((&Float::INFINITY - Float::INFINITY).is_nan());

assert_eq!(&Float::from(1.5) - Float::from(2.5), -1.0);
assert_eq!(&Float::from(1.5) - Float::from(-2.5), 4.0);
assert_eq!(&Float::from(-1.5) - Float::from(2.5), -4.0);
assert_eq!(&Float::from(-1.5) - Float::from(-2.5), 1.0);

type Output = Float

The resulting type after applying the - operator.

impl<'a> Sub<Float> for &'a Rational

fn sub(self, other: Float) -> Float

Subtracts a Rational by a Float, taking the Rational by value and the Float by reference.

If the output has a precision, it is the precision of the input Float. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(x,\text{NaN})=\text{NaN}$
• $f(x,\infty)=-\infty$
• $f(x,-\infty)=\infty$
• $f(0,0.0)=-0.0$
• $f(0,-0.0)=0.0$
• $f(x,0.0)=f(x,-0.0)=x$
• $f(0,x)=-x$
• $f(x,x)=0.0$ if $x$ is nonzero

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((&Rational::exact_from(1.5) - Float::NAN).is_nan());
assert_eq!(&Rational::exact_from(1.5) - Float::INFINITY, Float::NEGATIVE_INFINITY);
assert_eq!(&Rational::exact_from(1.5) - Float::NEGATIVE_INFINITY, Float::INFINITY);

assert_eq!(&Rational::exact_from(1.5) - Float::from(2.5), -1.0);
assert_eq!(&Rational::exact_from(1.5) - Float::from(-2.5), 4.0);
assert_eq!(&Rational::exact_from(-1.5) - Float::from(2.5), -4.0);
assert_eq!(&Rational::exact_from(-1.5) - Float::from(-2.5), 1.0);

type Output = Float

The resulting type after applying the - operator.

impl Sub<Float> for Rational

fn sub(self, other: Float) -> Float

Subtracts a Rational by a Float, taking both by value.

If the output has a precision, it is the precision of the input Float. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(x,\text{NaN})=\text{NaN}$
• $f(x,\infty)=-\infty$
• $f(x,-\infty)=\infty$
• $f(0,0.0)=-0.0$
• $f(0,-0.0)=0.0$
• $f(x,0.0)=f(x,-0.0)=x$
• $f(0,x)=-x$
• $f(x,x)=0.0$ if $x$ is nonzero

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((Rational::exact_from(1.5) - Float::NAN).is_nan());
assert_eq!(Rational::exact_from(1.5) - Float::INFINITY, Float::NEGATIVE_INFINITY);
assert_eq!(Rational::exact_from(1.5) - Float::NEGATIVE_INFINITY, Float::INFINITY);

assert_eq!(Rational::exact_from(1.5) - Float::from(2.5), -1.0);
assert_eq!(Rational::exact_from(1.5) - Float::from(-2.5), 4.0);
assert_eq!(Rational::exact_from(-1.5) - Float::from(2.5), -4.0);
assert_eq!(Rational::exact_from(-1.5) - Float::from(-2.5), 1.0);

type Output = Float

The resulting type after applying the - operator.

impl<'a> Sub<Rational> for &'a Float

fn sub(self, other: Rational) -> Float

Subtracts a Float by a Rational, taking the first by reference and the second by value.

If the output has a precision, it is the precision of the input Float. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(\text{NaN},x)=\text{NaN}$
• $f(\infty,x)=\infty$
• $f(-\infty,x)=-\infty$
• $f(0.0,0)=0.0$
• $f(-0.0,0)=-0.0$
• $f(x,0)=x$
• $f(0.0,x)=f(-0.0,x)=-x$
• $f(x,x)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::sub_rational_prec_ref_val instead. If you want to specify the output precision, consider using Float::sub_rational_round_ref_val. If you want both of these things, consider using Float::sub_rational_prec_round_ref_val.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((&Float::NAN - Rational::exact_from(1.5)).is_nan());
assert_eq!(&Float::INFINITY - Rational::exact_from(1.5), Float::INFINITY);
assert_eq!(&Float::NEGATIVE_INFINITY - Rational::exact_from(1.5), Float::NEGATIVE_INFINITY);

assert_eq!(&Float::from(2.5) - Rational::exact_from(1.5), 1.0);
assert_eq!(&Float::from(2.5) - Rational::exact_from(-1.5), 4.0);
assert_eq!(&Float::from(-2.5) - Rational::exact_from(1.5), -4.0);
assert_eq!(&Float::from(-2.5) - Rational::exact_from(-1.5), -1.0);

type Output = Float

The resulting type after applying the - operator.

impl Sub<Rational> for Float

fn sub(self, other: Rational) -> Float

Subtracts a Float by a Rational, taking both by value.

If the output has a precision, it is the precision of the input Float. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

Special cases:

• $f(\text{NaN},x)=\text{NaN}$
• $f(\infty,x)=\infty$
• $f(-\infty,x)=-\infty$
• $f(0.0,0)=0.0$
• $f(-0.0,0)=-0.0$
• $f(x,0)=x$
• $f(0.0,x)=f(-0.0,x)=-x$
• $f(x,x)=0.0$ if $x$ is nonzero

If you want to use a rounding mode other than Nearest, consider using Float::sub_rational_prec instead. If you want to specify the output precision, consider using Float::sub_rational_round. If you want both of these things, consider using Float::sub_rational_prec_round.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

assert!((Float::NAN - Rational::exact_from(1.5)).is_nan());
assert_eq!(Float::INFINITY - Rational::exact_from(1.5), Float::INFINITY);
assert_eq!(Float::NEGATIVE_INFINITY - Rational::exact_from(1.5), Float::NEGATIVE_INFINITY);

assert_eq!(Float::from(2.5) - Rational::exact_from(1.5), 1.0);
assert_eq!(Float::from(2.5) - Rational::exact_from(-1.5), 4.0);
assert_eq!(Float::from(-2.5) - Rational::exact_from(1.5), -4.0);
assert_eq!(Float::from(-2.5) - Rational::exact_from(-1.5), -1.0);

type Output = Float

The resulting type after applying the - operator.

impl Sub for Float

fn sub(self, other: Float) -> Float

Subtracts two Floats, taking both by value.

If the output has a precision, it is the maximum of the precisions of the inputs. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ f(x,y) = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

Special cases:

• $f(\text{NaN},x)=f(x,\text{NaN})=f(\infty,\infty)=f(-\infty,-\infty)=\text{NaN}$
• $f(\infty,x)=\infty$ if $x$ is not NaN or $\infty$
• $f(x,-\infty)=\infty$ if $x$ is not NaN or $-\infty$
• $f(-\infty,x)=-\infty$ if $x$ is not NaN or $-\infty$
• $f(x,\infty)=-\infty$ if $x$ is not NaN or $\infty$
• $f(0.0,-0.0)=0.0$
• $f(-0.0,0.0)=-0.0$
• $f(0.0,0.0)=f(-0.0,-0.0)=0.0$
• $f(x,0.0)=f(x,-0.0)=x$ if $x$ is not NaN and $x$ is nonzero
• $f(0.0,x)=f(-0.0,x)=-x$ if $x$ is not NaN and $x$ is nonzero
• $f(x,x)=0.0$ if $x$ is finite and nonzero

If you want to use a rounding mode other than Nearest, consider using Float::sub_prec instead. If you want to specify the output precision, consider using Float::sub_round. If you want both of these things, consider using Float::sub_prec_round.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_float::Float;

assert!((Float::from(1.5) - Float::NAN).is_nan());
assert_eq!(Float::from(1.5) - Float::INFINITY, Float::NEGATIVE_INFINITY);
assert_eq!(Float::from(1.5) - Float::NEGATIVE_INFINITY, Float::INFINITY);
assert!((Float::INFINITY - Float::INFINITY).is_nan());

assert_eq!(Float::from(1.5) - Float::from(2.5), -1.0);
assert_eq!(Float::from(1.5) - Float::from(-2.5), 4.0);
assert_eq!(Float::from(-1.5) - Float::from(2.5), -4.0);
assert_eq!(Float::from(-1.5) - Float::from(-2.5), 1.0);

type Output = Float

The resulting type after applying the - operator.

impl<'a> SubAssign<&'a Float> for Float

fn sub_assign(&mut self, other: &Float)

Subtracts a Float by a Float in place, taking the Float on the right-hand side by reference.

If the output has a precision, it is the maximum of the precisions of the inputs. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x\gets = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

Special cases: See the - documenation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::sub_prec_assign instead. If you want to specify the output precision, consider using Float::sub_round_assign. If you want both of these things, consider using Float::sub_prec_round_assign.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_float::Float;

let mut x = Float::from(1.5);
x -= &Float::NAN;
assert!(x.is_nan());

let mut x = Float::from(1.5);
x -= &Float::INFINITY;
assert_eq!(x, Float::NEGATIVE_INFINITY);

let mut x = Float::from(1.5);
x -= &Float::NEGATIVE_INFINITY;
assert_eq!(x, Float::INFINITY);

let mut x = Float::INFINITY;
x -= &Float::INFINITY;
assert!(x.is_nan());

let mut x = Float::from(1.5);
x -= &Float::from(2.5);
assert_eq!(x, -1.0);

let mut x = Float::from(1.5);
x -= &Float::from(-2.5);
assert_eq!(x, 4.0);

let mut x = Float::from(-1.5);
x -= &Float::from(2.5);
assert_eq!(x, -4.0);

let mut x = Float::from(-1.5);
x -= &Float::from(-2.5);
assert_eq!(x, 1.0);

impl<'a> SubAssign<&'a Rational> for Float

fn sub_assign(&mut self, other: &Rational)

Subtracts a Rational by a Float in place, taking the Rational by reference.

If the output has a precision, it is the precision of the input Float. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x\gets = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

See the - documentation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::sub_rational_prec_assign_ref instead. If you want to specify the output precision, consider using Float::sub_rational_round_assign_ref. If you want both of these things, consider using Float::sub_rational_prec_round_assign_ref.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

let mut x = Float::NAN;
x -= &Rational::exact_from(1.5);
assert!(x.is_nan());

let mut x = Float::INFINITY;
x -= &Rational::exact_from(1.5);
assert_eq!(x, Float::INFINITY);

let mut x = Float::NEGATIVE_INFINITY;
x -= &Rational::exact_from(1.5);
assert_eq!(x, Float::NEGATIVE_INFINITY);

let mut x = Float::from(2.5);
x -= &Rational::exact_from(1.5);
assert_eq!(x, 1.0);

let mut x = Float::from(2.5);
x -= &Rational::exact_from(-1.5);
assert_eq!(x, 4.0);

let mut x = Float::from(-2.5);
x -= &Rational::exact_from(1.5);
assert_eq!(x, -4.0);

let mut x = Float::from(-2.5);
x -= &Rational::exact_from(-1.5);
assert_eq!(x, -1.0);

impl SubAssign<Rational> for Float

fn sub_assign(&mut self, other: Rational)

Subtracts a Rational by a Float in place, taking the Rational by value.

If the output has a precision, it is the precision of the input Float. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x\gets = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the precision of the input Float.

See the - documentation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::sub_rational_prec_assign instead. If you want to specify the output precision, consider using Float::sub_rational_round_assign. If you want both of these things, consider using Float::sub_rational_prec_round_assign.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_float::Float;
use malachite_q::Rational;

let mut x = Float::NAN;
x -= Rational::exact_from(1.5);
assert!(x.is_nan());

let mut x = Float::INFINITY;
x -= Rational::exact_from(1.5);
assert_eq!(x, Float::INFINITY);

let mut x = Float::NEGATIVE_INFINITY;
x -= Rational::exact_from(1.5);
assert_eq!(x, Float::NEGATIVE_INFINITY);

let mut x = Float::from(2.5);
x -= Rational::exact_from(1.5);
assert_eq!(x, 1.0);

let mut x = Float::from(2.5);
x -= Rational::exact_from(-1.5);
assert_eq!(x, 4.0);

let mut x = Float::from(-2.5);
x -= Rational::exact_from(1.5);
assert_eq!(x, -4.0);

let mut x = Float::from(-2.5);
x -= Rational::exact_from(-1.5);
assert_eq!(x, -1.0);

impl SubAssign for Float

fn sub_assign(&mut self, other: Float)

Subtracts a Float by a Float in place, taking the Float on the right-hand side by value.

If the output has a precision, it is the maximum of the precisions of the inputs. If the difference is equidistant from two Floats with the specified precision, the Float with fewer 1s in its binary expansion is chosen. See RoundingMode for a description of the Nearest rounding mode.

$$ x\gets = x-y+\epsilon. $$

• If $x-y$ is infinite, zero, or NaN, $\epsilon$ may be ignored or assumed to be 0.
• If $x-y$ is finite and nonzero, then $|\epsilon| < 2^{\lfloor\log_2 |x-y|\rfloor-p}$, where $p$ is the maximum precision of the inputs.

Special cases: See the - documenation for information on special cases.

If you want to use a rounding mode other than Nearest, consider using Float::sub_prec_assign instead. If you want to specify the output precision, consider using Float::sub_round_assign. If you want both of these things, consider using Float::sub_prec_round_assign.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, NegativeInfinity};
use malachite_float::Float;

let mut x = Float::from(1.5);
x -= Float::NAN;
assert!(x.is_nan());

let mut x = Float::from(1.5);
x -= Float::INFINITY;
assert_eq!(x, Float::NEGATIVE_INFINITY);

let mut x = Float::from(1.5);
x -= Float::NEGATIVE_INFINITY;
assert_eq!(x, Float::INFINITY);

let mut x = Float::INFINITY;
x -= Float::INFINITY;
assert!(x.is_nan());

let mut x = Float::from(1.5);
x -= Float::from(2.5);
assert_eq!(x, -1.0);

let mut x = Float::from(1.5);
x -= Float::from(-2.5);
assert_eq!(x, 4.0);

let mut x = Float::from(-1.5);
x -= Float::from(2.5);
assert_eq!(x, -4.0);

let mut x = Float::from(-1.5);
x -= Float::from(-2.5);
assert_eq!(x, 1.0);

impl<'a> TryFrom<&'a Float> for Integer

fn try_from(f: &'a Float) -> Result<Integer, Self::Error>

Converts a Float to an Integer, taking the Float by reference. If the Float is not equal to an integer, an error is returned.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is f.complexity().

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, Zero};
use malachite_base::num::conversion::from::SignedFromFloatError::*;
use malachite_float::Float;
use malachite_nz::integer::Integer;

assert_eq!(Integer::try_from(&Float::ZERO).unwrap(), 0);
assert_eq!(Integer::try_from(&Float::from(123.0)).unwrap(), 123);
assert_eq!(Integer::try_from(&Float::from(-123.0)).unwrap(), -123);

assert_eq!(Integer::try_from(&Float::from(1.5)), Err(FloatNonIntegerOrOutOfRange));
assert_eq!(Integer::try_from(&Float::INFINITY), Err(FloatInfiniteOrNan));
assert_eq!(Integer::try_from(&Float::NAN), Err(FloatInfiniteOrNan));

type Error = SignedFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for Natural

fn try_from(f: &'a Float) -> Result<Natural, Self::Error>

Converts a Float to a Natural, taking the Float by reference. If the Float is not equal to a non-negative integer, an error is returned.

Both positive and negative zero convert to a Natural zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is f.complexity().

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, Zero};
use malachite_base::num::conversion::from::UnsignedFromFloatError::*;
use malachite_float::Float;
use malachite_nz::natural::Natural;

assert_eq!(Natural::try_from(&Float::ZERO).unwrap(), 0);
assert_eq!(Natural::try_from(&Float::from(123.0)).unwrap(), 123);

assert_eq!(Natural::try_from(&Float::from(-123.0)), Err(FloatNegative));
assert_eq!(Natural::try_from(&Float::from(1.5)), Err(FloatNonIntegerOrOutOfRange));
assert_eq!(Natural::try_from(&Float::INFINITY), Err(FloatInfiniteOrNan));
assert_eq!(Natural::try_from(&Float::NAN), Err(FloatInfiniteOrNan));

type Error = UnsignedFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for Rational

fn try_from(x: &'a Float) -> Result<Rational, Self::Error>

Converts a Float to a Rational, taking the Float by reference. If the Float is not finite, an error is returned.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is x.complexity().

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, Zero};
use malachite_float::conversion::rational_from_float::RationalFromFloatError;
use malachite_float::Float;
use malachite_q::Rational;

assert_eq!(Rational::try_from(&Float::ZERO).unwrap(), 0);
assert_eq!(Rational::try_from(&Float::from(1.5)).unwrap().to_string(), "3/2");
assert_eq!(Rational::try_from(&Float::from(-1.5)).unwrap().to_string(), "-3/2");

assert_eq!(Rational::try_from(&Float::INFINITY), Err(RationalFromFloatError));
assert_eq!(Rational::try_from(&Float::NAN), Err(RationalFromFloatError));

type Error = RationalFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for f32

fn try_from(f: &'a Float) -> Result<f32, Self::Error>

Converts a Float to a primitive float, taking the Float by reference. If the Float is not equal to a primitive float of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = FloatFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for f64

fn try_from(f: &'a Float) -> Result<f64, Self::Error>

Converts a Float to a primitive float, taking the Float by reference. If the Float is not equal to a primitive float of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = FloatFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for i128

fn try_from(f: &'a Float) -> Result<i128, Self::Error>

Converts a Float to a primitive signed integer, taking the Float by reference. If the Float is not equal to a signed primitive integer of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for i16

fn try_from(f: &'a Float) -> Result<i16, Self::Error>

Converts a Float to a primitive signed integer, taking the Float by reference. If the Float is not equal to a signed primitive integer of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for i32

fn try_from(f: &'a Float) -> Result<i32, Self::Error>

Converts a Float to a primitive signed integer, taking the Float by reference. If the Float is not equal to a signed primitive integer of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for i64

fn try_from(f: &'a Float) -> Result<i64, Self::Error>

Converts a Float to a primitive signed integer, taking the Float by reference. If the Float is not equal to a signed primitive integer of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for i8

fn try_from(f: &'a Float) -> Result<i8, Self::Error>

Converts a Float to a primitive signed integer, taking the Float by reference. If the Float is not equal to a signed primitive integer of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for isize

fn try_from(f: &'a Float) -> Result<isize, Self::Error>

Converts a Float to a primitive signed integer, taking the Float by reference. If the Float is not equal to a signed primitive integer of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for u128

fn try_from(f: &'a Float) -> Result<u128, Self::Error>

Converts a Float to a primitive unsigned integer, taking the Float by reference. If the Float is not equal to an unsigned primitive integer of the given type, an error is returned.

Both positive and negative zero convert to a primitive unsigned integer zero.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for u16

fn try_from(f: &'a Float) -> Result<u16, Self::Error>

Converts a Float to a primitive unsigned integer, taking the Float by reference. If the Float is not equal to an unsigned primitive integer of the given type, an error is returned.

Both positive and negative zero convert to a primitive unsigned integer zero.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for u32

fn try_from(f: &'a Float) -> Result<u32, Self::Error>

Converts a Float to a primitive unsigned integer, taking the Float by reference. If the Float is not equal to an unsigned primitive integer of the given type, an error is returned.

Both positive and negative zero convert to a primitive unsigned integer zero.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for u64

fn try_from(f: &'a Float) -> Result<u64, Self::Error>

Converts a Float to a primitive unsigned integer, taking the Float by reference. If the Float is not equal to an unsigned primitive integer of the given type, an error is returned.

Both positive and negative zero convert to a primitive unsigned integer zero.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for u8

fn try_from(f: &'a Float) -> Result<u8, Self::Error>

Converts a Float to a primitive unsigned integer, taking the Float by reference. If the Float is not equal to an unsigned primitive integer of the given type, an error is returned.

Both positive and negative zero convert to a primitive unsigned integer zero.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Float> for usize

fn try_from(f: &'a Float) -> Result<usize, Self::Error>

Converts a Float to a primitive unsigned integer, taking the Float by reference. If the Float is not equal to an unsigned primitive integer of the given type, an error is returned.

Both positive and negative zero convert to a primitive unsigned integer zero.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromFloatError

The type returned in the event of a conversion error.

impl<'a> TryFrom<&'a Rational> for Float

fn try_from(x: &'a Rational) -> Result<Float, Self::Error>

Converts a Rational to an Float, taking the Rational by reference. If the Rational’s denominator is not a power of 2, an error is returned.

The Float’s precision is the number of significant bits of the numerator of the Rational.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is x.significant_bits().

Examples

use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_q::conversion::primitive_float_from_rational::FloatFromRationalError;
use malachite_q::Rational;

assert_eq!(Float::try_from(&Rational::ZERO).unwrap(), 0);
assert_eq!(Float::try_from(&Rational::from_signeds(1, 8)).unwrap(), 0.125);
assert_eq!(Float::try_from(&Rational::from_signeds(-1, 8)).unwrap(), -0.125);

assert_eq!(Float::try_from(&Rational::from_signeds(1, 3)), Err(FloatFromRationalError));
assert_eq!(Float::try_from(&Rational::from_signeds(-1, 3)), Err(FloatFromRationalError));

type Error = FloatFromRationalError

The type returned in the event of a conversion error.

impl TryFrom<Float> for Integer

fn try_from(f: Float) -> Result<Integer, Self::Error>

Converts a Float to an Integer, taking the Float by value. If the Float is not equal to an integer, an error is returned.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is f.complexity().

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, Zero};
use malachite_base::num::conversion::from::SignedFromFloatError::*;
use malachite_float::Float;
use malachite_nz::integer::Integer;

assert_eq!(Integer::try_from(Float::ZERO).unwrap(), 0);
assert_eq!(Integer::try_from(Float::from(123.0)).unwrap(), 123);
assert_eq!(Integer::try_from(Float::from(-123.0)).unwrap(), -123);

assert_eq!(Integer::try_from(Float::from(1.5)), Err(FloatNonIntegerOrOutOfRange));
assert_eq!(Integer::try_from(Float::INFINITY), Err(FloatInfiniteOrNan));
assert_eq!(Integer::try_from(Float::NAN), Err(FloatInfiniteOrNan));

type Error = SignedFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for Natural

fn try_from(f: Float) -> Result<Natural, Self::Error>

Converts a Float to a Natural, taking the Float by value. If the Float is not equal to a non-negative integer, an error is returned.

Both positive and negative zero convert to a Natural zero.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is f.complexity().

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, Zero};
use malachite_base::num::conversion::from::UnsignedFromFloatError::*;
use malachite_float::Float;
use malachite_nz::natural::Natural;

assert_eq!(Natural::try_from(Float::ZERO).unwrap(), 0);
assert_eq!(Natural::try_from(Float::from(123.0)).unwrap(), 123);

assert_eq!(Natural::try_from(Float::from(-123.0)), Err(FloatNegative));
assert_eq!(Natural::try_from(Float::from(1.5)), Err(FloatNonIntegerOrOutOfRange));
assert_eq!(Natural::try_from(Float::INFINITY), Err(FloatInfiniteOrNan));
assert_eq!(Natural::try_from(Float::NAN), Err(FloatInfiniteOrNan));

type Error = UnsignedFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for Rational

fn try_from(x: Float) -> Result<Rational, Self::Error>

Converts a Float to a Rational, taking the Float by value. If the Float is not finite, an error is returned.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is x.complexity().

Examples

use malachite_base::num::basic::traits::{Infinity, NaN, Zero};
use malachite_float::conversion::rational_from_float::RationalFromFloatError;
use malachite_float::Float;
use malachite_q::Rational;

assert_eq!(Rational::try_from(Float::ZERO).unwrap(), 0);
assert_eq!(Rational::try_from(Float::from(1.5)).unwrap().to_string(), "3/2");
assert_eq!(Rational::try_from(Float::from(-1.5)).unwrap().to_string(), "-3/2");

assert_eq!(Rational::try_from(Float::INFINITY), Err(RationalFromFloatError));
assert_eq!(Rational::try_from(Float::NAN), Err(RationalFromFloatError));

type Error = RationalFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for f32

fn try_from(f: Float) -> Result<f32, Self::Error>

Converts a Float to a primitive float, taking the Float by value. If the Float is not equal to a primitive float of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = FloatFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for f64

fn try_from(f: Float) -> Result<f64, Self::Error>

Converts a Float to a primitive float, taking the Float by value. If the Float is not equal to a primitive float of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = FloatFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for i128

fn try_from(f: Float) -> Result<i128, Self::Error>

Converts a Float to a primitive signed integer, taking the Float by value. If the Float is not equal to a signed primitive integer of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for i16

fn try_from(f: Float) -> Result<i16, Self::Error>

Converts a Float to a primitive signed integer, taking the Float by value. If the Float is not equal to a signed primitive integer of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for i32

fn try_from(f: Float) -> Result<i32, Self::Error>

Converts a Float to a primitive signed integer, taking the Float by value. If the Float is not equal to a signed primitive integer of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for i64

fn try_from(f: Float) -> Result<i64, Self::Error>

Converts a Float to a primitive signed integer, taking the Float by value. If the Float is not equal to a signed primitive integer of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for i8

fn try_from(f: Float) -> Result<i8, Self::Error>

Converts a Float to a primitive signed integer, taking the Float by value. If the Float is not equal to a signed primitive integer of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for isize

fn try_from(f: Float) -> Result<isize, Self::Error>

Converts a Float to a primitive signed integer, taking the Float by value. If the Float is not equal to a signed primitive integer of the given type, an error is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for u128

fn try_from(f: Float) -> Result<u128, Self::Error>

Converts a Float to a primitive unsigned integer, taking the Float by value. If the Float is not equal to an unsigned primitive integer of the given type, an error is returned.

Both positive and negative zero convert to a primitive unsigned integer zero.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for u16

fn try_from(f: Float) -> Result<u16, Self::Error>

Converts a Float to a primitive unsigned integer, taking the Float by value. If the Float is not equal to an unsigned primitive integer of the given type, an error is returned.

Both positive and negative zero convert to a primitive unsigned integer zero.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for u32

fn try_from(f: Float) -> Result<u32, Self::Error>

Converts a Float to a primitive unsigned integer, taking the Float by value. If the Float is not equal to an unsigned primitive integer of the given type, an error is returned.

Both positive and negative zero convert to a primitive unsigned integer zero.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for u64

fn try_from(f: Float) -> Result<u64, Self::Error>

Converts a Float to a primitive unsigned integer, taking the Float by value. If the Float is not equal to an unsigned primitive integer of the given type, an error is returned.

Both positive and negative zero convert to a primitive unsigned integer zero.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for u8

fn try_from(f: Float) -> Result<u8, Self::Error>

Converts a Float to a primitive unsigned integer, taking the Float by value. If the Float is not equal to an unsigned primitive integer of the given type, an error is returned.

Both positive and negative zero convert to a primitive unsigned integer zero.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Float> for usize

fn try_from(f: Float) -> Result<usize, Self::Error>

Converts a Float to a primitive unsigned integer, taking the Float by value. If the Float is not equal to an unsigned primitive integer of the given type, an error is returned.

Both positive and negative zero convert to a primitive unsigned integer zero.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromFloatError

The type returned in the event of a conversion error.

impl TryFrom<Rational> for Float

fn try_from(x: Rational) -> Result<Float, Self::Error>

Converts a Rational to an Float, taking the Rational by value. If the Rational’s denominator is not a power of 2, an error is returned.

The Float’s precision is the number of significant bits of the numerator of the Rational.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is x.significant_bits().

Examples

use malachite_base::num::basic::traits::Zero;
use malachite_float::Float;
use malachite_q::conversion::primitive_float_from_rational::FloatFromRationalError;
use malachite_q::Rational;

assert_eq!(Float::try_from(Rational::ZERO).unwrap(), 0);
assert_eq!(Float::try_from(Rational::from_signeds(1, 8)).unwrap(), 0.125);
assert_eq!(Float::try_from(Rational::from_signeds(-1, 8)).unwrap(), -0.125);

assert_eq!(Float::try_from(Rational::from_signeds(1, 3)), Err(FloatFromRationalError));
assert_eq!(Float::try_from(Rational::from_signeds(-1, 3)), Err(FloatFromRationalError));

type Error = FloatFromRationalError

The type returned in the event of a conversion error.

impl Two for Float

The constant 2.0, with precision 1.

const TWO: Float = _

impl Zero for Float

The constant 0.0 (positive zero), with precision 1.

const ZERO: Float = _