Struct malachite_q::Rational

pub struct Rational { /* private fields */ }

A rational number.

Implementations

impl Rational

pub fn approx_log(&self) -> f64

Calculates the approximate natural logarithm of a positive Rational.

$f(x) = (1+\epsilon)(\log x)$, where $|\epsilon| < 2^{-52}.$

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

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, PowerOf2};
use malachite_base::num::float::NiceFloat;
use malachite_q::Rational;

assert_eq!(NiceFloat(Rational::from(10i32).approx_log()), NiceFloat(2.3025850929940455));
assert_eq!(
    NiceFloat(Rational::from(10i32).pow(100u64).approx_log()),
    NiceFloat(230.25850929940455)
);
assert_eq!(
    NiceFloat(Rational::power_of_2(1000000u64).approx_log()),
    NiceFloat(693147.1805599453)
);
assert_eq!(
    NiceFloat(Rational::power_of_2(-1000000i64).approx_log()),
    NiceFloat(-693147.1805599453)
);

This is equivalent to fmpz_dlog from fmpz/dlog.c, FLINT 2.7.1.

impl Rational

pub fn cmp_complexity(&self, other: &Rational) -> Ordering

Compares two Rationals according to their complexity.

Complexity is defined as follows: If two Rationals have different denominators, then the one with the larger denominator is more complex. If they have the same denominator, then the one whose numerator is further from zero is more complex. Finally, if $q > 0$, then $q$ is simpler than $-q$.

The Rationals ordered by complexity look like this: $$ 0, 1, -1, 2, -2, \ldots, 1/2, -1/2, 3/2, -3/2, \ldots, 1/3, -1/3, 2/3, -2/3, \ldots, \ldots. $$ This order is a well-order, and the order type of the Rationals under this order is $\omega^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_q::Rational;
use std::cmp::Ordering;

assert_eq!(
    Rational::from_signeds(1, 2).cmp_complexity(&Rational::from_signeds(1, 3)),
    Ordering::Less
);
assert_eq!(
    Rational::from_signeds(1, 2).cmp_complexity(&Rational::from_signeds(3, 2)),
    Ordering::Less
);
assert_eq!(
    Rational::from_signeds(1, 2).cmp_complexity(&Rational::from_signeds(-1, 2)),
    Ordering::Less
);

impl Rational

pub fn from_continued_fraction<I: Iterator<Item = Natural>>(
    floor: Integer,
    xs: I
) -> Rational

Converts a finite continued fraction to a Rational, taking the inputs by value.

The input has two components. The first is the first value of the continued fraction, which may be any Integer and is equal to the floor of the Rational. The second is an iterator of the remaining values, which must all be positive. Using the standard notation for continued fractions, the first value is the number before the semicolon, and the second value contains the remaining numbers.

Each rational number has two continued fraction representations. Either one is a valid input.

$f(a_0, (a_1, a_2, a_3, \ldots)) = [a_0; a_1, a_2, a_3, \ldots]$.

Worst-case complexity

$T(n, m) = O((nm)^2 \log (nm) \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

where $T$ is time, $M$ is additional memory, $n$ is max(floor.significant_bits(), xs.map(Natural::significant_bits).max()), and $m$ is xs.count().

Panics

Panics if any Natural in xs is zero.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::basic::traits::Zero;
use malachite_base::vecs::vec_from_str;
use malachite_nz::integer::Integer;
use malachite_q::Rational;

let xs = vec_from_str("[1, 2]").unwrap().into_iter();
assert_eq!(Rational::from_continued_fraction(Integer::ZERO, xs).to_string(), "2/3");

let xs = vec_from_str("[7, 16]").unwrap().into_iter();
assert_eq!(Rational::from_continued_fraction(Integer::from(3), xs).to_string(), "355/113");

pub fn from_continued_fraction_ref<'a, I: Iterator<Item = &'a Natural>>(
    floor: &Integer,
    xs: I
) -> Rational

Converts a finite continued fraction to a Rational, taking the inputs by reference.

The input has two components. The first is the first value of the continued fraction, which may be any Integer and is equal to the floor of the Rational. The second is an iterator of the remaining values, which must all be positive. Using the standard notation for continued fractions, the first value is the number before the semicolon, and the second value contains the remaining numbers.

Each rational number has two continued fraction representations. Either one is a valid input.

$f(a_0, (a_1, a_2, a_3, \ldots)) = [a_0; a_1, a_2, a_3, \ldots]$.

Worst-case complexity

$T(n, m) = O((nm)^2 \log (nm) \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

where $T$ is time, $M$ is additional memory, $n$ is max(floor.significant_bits(), xs.map(Natural::significant_bits).max()), and $m$ is xs.count().

Panics

Panics if any Natural in xs is zero.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::basic::traits::Zero;
use malachite_base::vecs::vec_from_str;
use malachite_nz::integer::Integer;
use malachite_q::Rational;

let xs = vec_from_str("[1, 2]").unwrap();
assert_eq!(
    Rational::from_continued_fraction_ref(&Integer::ZERO, xs.iter()).to_string(),
    "2/3"
);

let xs = vec_from_str("[7, 16]").unwrap();
assert_eq!(
    Rational::from_continued_fraction_ref(&Integer::from(3), xs.iter()).to_string(),
    "355/113"
);

impl Rational

pub fn digits(&self, base: &Natural) -> (Vec<Natural>, RationalDigits)

Returns the base-$b$ digits of a Rational.

The output has two components. The first is a Vec of the digits of the integer portion of the Rational, least- to most-significant. The second is an iterator of the digits of the fractional portion.

The output is in its simplest form: the integer-portion digits do not end with a zero, and the fractional-portion digits do not end with infinitely many zeros or $(b-1)$s.

If the Rational has a small denominator, it may be more efficient to use to_digits or into_digits instead. These functions compute the entire repeating portion of the repeating digits.

For example, consider these two expressions:

• Rational::from_signeds(1, 7).digits(Natural::from(10u32)).1.nth(1000)
• Rational::from_signeds(1, 7).into_digits(Natural::from(10u32)).1[1000]

Both get the thousandth digit after the decimal point of 1/7. The first way explicitly calculates each digit after the decimal point, whereas the second way determines that 1/7 is 0.(142857), with the 142857 repeating, and takes 1000 % 6 == 4 to determine that the thousandth digit is 5. But when the Rational has a large denominator, the second way is less efficient.

Worst-case complexity per iteration

$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(), base.significant_bits()).

Panics

Panics if base is less than 2.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::iterators::prefix_to_string;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

let (before_point, after_point) = Rational::from(3u32).digits(&Natural::from(10u32));
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(prefix_to_string(after_point, 10), "[]");

let (before_point, after_point) =
        Rational::from_signeds(22, 7).digits(&Natural::from(10u32));
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(prefix_to_string(after_point, 10), "[1, 4, 2, 8, 5, 7, 1, 4, 2, 8, ...]");

impl Rational

pub fn from_digits(
    base: &Natural,
    before_point: Vec<Natural>,
    after_point: RationalSequence<Natural>
) -> Rational

Converts base-$b$ digits to a Rational. The inputs are taken by value.

The input consists of the digits of the integer portion of the Rational and the digits of the fractional portion. The integer-portion digits are ordered from least- to most-significant, and the fractional-portion digits from most- to least.

The fractional-portion digits may end in infinitely many zeros or $(b-1)$s; these are handled correctly.

Worst-case complexity

$T(n, m) = O(nm \log (nm)^2 \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

where $T$ is time, $M$ is additional memory, $n$ is max(before_point.len(), after_point.component_len()), and $m$ is base.significant_bits().

Panics

Panics if base is less than 2.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::rational_sequences::RationalSequence;
use malachite_base::vecs::vec_from_str;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

let before_point = vec_from_str("[3]").unwrap();
let after_point = RationalSequence::from_vecs(
    Vec::new(),
    vec_from_str("[1, 4, 2, 8, 5, 7]").unwrap(),
);
assert_eq!(
    Rational::from_digits(&Natural::from(10u32), before_point, after_point).to_string(),
    "22/7"
);

// 21.34565656...
let before_point = vec_from_str("[1, 2]").unwrap();
let after_point = RationalSequence::from_vecs(
    vec_from_str("[3, 4]").unwrap(),
    vec_from_str("[5, 6]").unwrap(),
);
assert_eq!(
    Rational::from_digits(&Natural::from(10u32), before_point, after_point).to_string(),
    "105661/4950"
);

pub fn from_digits_ref(
    base: &Natural,
    before_point: &[Natural],
    after_point: &RationalSequence<Natural>
) -> Rational

Converts base-$b$ digits to a Rational. The inputs are taken by reference.

The input consists of the digits of the integer portion of the Rational and the digits of the fractional portion. The integer-portion digits are ordered from least- to most-significant, and the fractional-portion digits from most- to least.

The fractional-portion digits may end in infinitely many zeros or $(b-1)$s; these are handled correctly.

Worst-case complexity

$T(n, m) = O(nm \log (nm)^2 \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

where $T$ is time, $M$ is additional memory, $n$ is max(before_point.len(), after_point.component_len()), and $m$ is base.significant_bits().

Panics

Panics if base is less than 2.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::rational_sequences::RationalSequence;
use malachite_base::vecs::vec_from_str;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

let before_point = vec_from_str("[3]").unwrap();
let after_point = RationalSequence::from_vecs(
    Vec::new(),
    vec_from_str("[1, 4, 2, 8, 5, 7]").unwrap(),
);
assert_eq!(
    Rational::from_digits_ref(&Natural::from(10u32), &before_point, &after_point)
        .to_string(),
    "22/7"
);

// 21.34565656...
let before_point = vec_from_str("[1, 2]").unwrap();
let after_point = RationalSequence::from_vecs(
    vec_from_str("[3, 4]").unwrap(),
    vec_from_str("[5, 6]").unwrap(),
);
assert_eq!(
    Rational::from_digits_ref(&Natural::from(10u32), &before_point, &after_point)
        .to_string(),
    "105661/4950"
);

impl Rational

pub fn from_power_of_2_digits(
    log_base: u64,
    before_point: Vec<Natural>,
    after_point: RationalSequence<Natural>
) -> Rational

Converts base-$2^k$ digits to a Rational. The inputs are taken by value.

The input consists of the digits of the integer portion of the Rational and the digits of the fractional portion. The integer-portion digits are ordered from least- to most-significant, and the fractional-portion digits from most- to least.

The fractional-portion digits may end in infinitely many zeros or $(2^k-1)$s; these are handled correctly.

Worst-case complexity

$T(n, m) = O(nm)$

$M(n, m) = O(nm)$

where $T$ is time, $M$ is additional memory, $n$ is max(before_point.len(), after_point.component_len()), and $m$ is base.significant_bits().

Panics

Panics if log_base is zero.

Examples

extern crate malachite_base;

use malachite_base::rational_sequences::RationalSequence;
use malachite_base::vecs::vec_from_str;
use malachite_q::Rational;

let before_point = vec_from_str("[1, 1]").unwrap();
let after_point = RationalSequence::from_vecs(
    vec_from_str("[0]").unwrap(),
    vec_from_str("[0, 0, 1]").unwrap(),
);
assert_eq!(
    Rational::from_power_of_2_digits(1, before_point, after_point).to_string(),
    "43/14"
);

// 21.34565656..._32
let before_point = vec_from_str("[1, 2]").unwrap();
let after_point = RationalSequence::from_vecs(
    vec_from_str("[3, 4]").unwrap(),
    vec_from_str("[5, 6]").unwrap(),
);
assert_eq!(
    Rational::from_power_of_2_digits(5, before_point, after_point).to_string(),
    "34096673/523776"
);

pub fn from_power_of_2_digits_ref(
    log_base: u64,
    before_point: &[Natural],
    after_point: &RationalSequence<Natural>
) -> Rational

Converts base-$2^k$ digits to a Rational. The inputs are taken by reference.

The input consists of the digits of the integer portion of the Rational and the digits of the fractional portion. The integer-portion digits are ordered from least- to most-significant, and the fractional-portion digits from most- to least.

The fractional-portion digits may end in infinitely many zeros or $(2^k-1)$s; these are handled correctly.

Worst-case complexity

$T(n, m) = O(nm)$

$M(n, m) = O(nm)$

where $T$ is time, $M$ is additional memory, $n$ is max(before_point.len(), after_point.component_len()), and $m$ is base.significant_bits().

Panics

Panics if log_base is zero.

Examples

extern crate malachite_base;

use malachite_base::rational_sequences::RationalSequence;
use malachite_base::vecs::vec_from_str;
use malachite_q::Rational;

let before_point = vec_from_str("[1, 1]").unwrap();
let after_point = RationalSequence::from_vecs(
    vec_from_str("[0]").unwrap(),
    vec_from_str("[0, 0, 1]").unwrap(),
);
assert_eq!(
    Rational::from_power_of_2_digits_ref(1, &before_point, &after_point).to_string(),
    "43/14"
);

// 21.34565656..._32
let before_point = vec_from_str("[1, 2]").unwrap();
let after_point = RationalSequence::from_vecs(
    vec_from_str("[3, 4]").unwrap(),
    vec_from_str("[5, 6]").unwrap(),
);
assert_eq!(
    Rational::from_power_of_2_digits_ref(5, &before_point, &after_point).to_string(),
    "34096673/523776"
);

impl Rational

pub fn power_of_2_digits(
    &self,
    log_base: u64
) -> (Vec<Natural>, RationalPowerOf2Digits)

Returns the base-$2^k$ digits of a Rational.

The output has two components. The first is a Vec of the digits of the integer portion of the Rational, least- to most-significant. The second is an iterator of the digits of the fractional portion.

The output is in its simplest form: the integer-portion digits do not end with a zero, and the fractional-portion digits do not end with infinitely many zeros or $(2^k-1)$s.

If the Rational has a small denominator, it may be more efficient to use to_power_of_2_digits or into_power_of_2_digits instead. These functions compute the entire repeating portion of the repeating digits.

For example, consider these two expressions:

• Rational::from_signeds(1, 7).power_of_2_digits(1).1.nth(1000)
• Rational::from_signeds(1, 7).into_power_of_2_digits(1).1[1000]

Both get the thousandth digit after the binary point of 1/7. The first way explicitly calculates each bit after the binary point, whereas the second way determines that 1/7 is 0.(001), with the 001 repeating, and takes 1000 % 3 == 1 to determine that the thousandth bit is 0. But when the Rational has a large denominator, the second way is less efficient.

Worst-case complexity per iteration

$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(), base).

Panics

Panics if log_base is zero.

Examples

extern crate malachite_base;

use malachite_base::iterators::prefix_to_string;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

let (before_point, after_point) = Rational::from(3u32).power_of_2_digits(1);
assert_eq!(before_point.to_debug_string(), "[1, 1]");
assert_eq!(prefix_to_string(after_point, 10), "[]");

let (before_point, after_point) = Rational::from_signeds(22, 7).power_of_2_digits(1);
assert_eq!(before_point.to_debug_string(), "[1, 1]");
assert_eq!(prefix_to_string(after_point, 10), "[0, 0, 1, 0, 0, 1, 0, 0, 1, 0, ...]");

let (before_point, after_point) = Rational::from_signeds(22, 7).power_of_2_digits(10);
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(
    prefix_to_string(after_point, 10),
    "[146, 292, 585, 146, 292, 585, 146, 292, 585, 146, ...]"
);

impl Rational

pub fn into_digits(
    self,
    base: &Natural
) -> (Vec<Natural>, RationalSequence<Natural>)

Returns the base-$b$ digits of a Rational, taking the Rational by value.

The output has two components. The first is a Vec of the digits of the integer portion of the Rational, least- to most-significant. The second is a RationalSequence of the digits of the fractional portion.

The output is in its simplest form: the integer-portion digits do not end with a zero, and the fractional-portion digits do not end with infinitely many zeros or $(b-1)$s.

The fractional portion may be very large; the length of the repeating part may be almost as large as the denominator. If the Rational has a large denominator, consider using digits instead, which returns an iterator. That function computes the fractional digits lazily and doesn’t need to compute the entire repeating part.

Worst-case complexity

$T(n, m) = O(m2^n)$

$M(n, m) = O(m2^n)$

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

Panics

Panics if base is less than 2.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

let (before_point, after_point) = Rational::from(3u32).into_digits(&Natural::from(10u32));
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(after_point.to_string(), "[]");

let (before_point, after_point) =
        Rational::from_signeds(22, 7).into_digits(&Natural::from(10u32));
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(after_point.to_string(), "[[1, 4, 2, 8, 5, 7]]");

pub fn to_digits(
    &self,
    base: &Natural
) -> (Vec<Natural>, RationalSequence<Natural>)

Returns the base-$b$ digits of a Rational, taking the Rational by reference.

The output has two components. The first is a Vec of the digits of the integer portion of the Rational, least- to most-significant. The second is a RationalSequence of the digits of the fractional portion.

The output is in its simplest form: the integer-portion digits do not end with a zero, and the fractional-portion digits do not end with infinitely many zeros or $(b-1)$s.

The fractional portion may be very large; the length of the repeating part may be almost as large as the denominator. If the Rational has a large denominator, consider using digits instead, which returns an iterator. That function computes the fractional digits lazily and doesn’t need to compute the entire repeating part.

Worst-case complexity

$T(n, m) = O(m2^n)$

$M(n, m) = O(m2^n)$

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

Panics

Panics if base is less than 2.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

let (before_point, after_point) = Rational::from(3u32).to_digits(&Natural::from(10u32));
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(after_point.to_string(), "[]");

let (before_point, after_point) =
        Rational::from_signeds(22, 7).to_digits(&Natural::from(10u32));
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(after_point.to_string(), "[[1, 4, 2, 8, 5, 7]]");

impl Rational

pub fn into_power_of_2_digits(
    self,
    log_base: u64
) -> (Vec<Natural>, RationalSequence<Natural>)

Returns the base-$2^k$ digits of a Rational, taking the Rational by value.

The output has two components. The first is a Vec of the digits of the integer portion of the Rational, least- to most-significant. The second is a RationalSequence of the digits of the fractional portion.

The output is in its simplest form: the integer-portion digits do not end with a zero, and the fractional-portion digits do not end with infinitely many zeros or $(2^k-1)$s.

The fractional portion may be very large; the length of the repeating part may be almost as large as the denominator. If the Rational has a large denominator, consider using power_of_2_digits instead, which returns an iterator. That function computes the fractional digits lazily and doesn’t need to compute the entire repeating part.

Worst-case complexity

$T(n, m) = O(m2^n)$

$M(n, m) = O(m2^n)$

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

Panics

Panics if log_base is zero.

Examples

extern crate malachite_base;

use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

let (before_point, after_point) = Rational::from(3u32).into_power_of_2_digits(1);
assert_eq!(before_point.to_debug_string(), "[1, 1]");
assert_eq!(after_point.to_string(), "[]");

let (before_point, after_point) = Rational::from_signeds(22, 7).into_power_of_2_digits(1);
assert_eq!(before_point.to_debug_string(), "[1, 1]");
assert_eq!(after_point.to_string(), "[[0, 0, 1]]");

let (before_point, after_point) = Rational::from_signeds(22, 7).into_power_of_2_digits(10);
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(after_point.to_string(), "[[146, 292, 585]]");

pub fn to_power_of_2_digits(
    &self,
    log_base: u64
) -> (Vec<Natural>, RationalSequence<Natural>)

Returns the base-$2^k$ digits of a Rational, taking the Rational by reference.

The output has two components. The first is a Vec of the digits of the integer portion of the Rational, least- to most-significant. The second is a RationalSequence of the digits of the fractional portion.

The output is in its simplest form: the integer-portion digits do not end with a zero, and the fractional-portion digits do not end with infinitely many zeros or $(2^k-1)$s.

The fractional portion may be very large; the length of the repeating part may be almost as large as the denominator. If the Rational has a large denominator, consider using power_of_2_digits instead, which returns an iterator. That function computes the fractional digits lazily and doesn’t need to compute the entire repeating part.

Worst-case complexity

$T(n, m) = O(m2^n)$

$M(n, m) = O(m2^n)$

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

Panics

Panics if log_base is zero.

Examples

extern crate malachite_base;

use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

let (before_point, after_point) = Rational::from(3u32).to_power_of_2_digits(1);
assert_eq!(before_point.to_debug_string(), "[1, 1]");
assert_eq!(after_point.to_string(), "[]");

let (before_point, after_point) = Rational::from_signeds(22, 7).to_power_of_2_digits(1);
assert_eq!(before_point.to_debug_string(), "[1, 1]");
assert_eq!(after_point.to_string(), "[[0, 0, 1]]");

let (before_point, after_point) = Rational::from_signeds(22, 7).to_power_of_2_digits(10);
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(after_point.to_string(), "[[146, 292, 585]]");

impl Rational

pub fn from_float_simplest<T: PrimitiveFloat>(x: T) -> Rational where
    Rational: From<T>, 

Converts a primitive float to the simplest Rational that rounds to that value.

To be more specific: Suppose the floating-point input is $x$. If $x$ is an integer, its Rational equivalent is returned. Otherwise, this function finds $a$ and $b$, which are the floating point predecessor and successor of $x$, and finds the simplest Rational in the open interval $(\frac{x + a}{2}, \frac{x + b}{2})$. “Simplicity” refers to low complexity. See Rational::cmp_complexity for a definition of complexity.

For example, 0.1f32 is converted to $1/10$ rather than to the exact value of the float, which is $13421773/134217728$. If you want the exact value, use Rational::from instead.

The floating point value cannot be NaN or infinite.

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is x.sci_exponent().

Panics

Panics if x is NaN or infinite.

Examples

use malachite_q::Rational;

assert_eq!(Rational::from_float_simplest(0.0), 0);
assert_eq!(Rational::from_float_simplest(1.5).to_string(), "3/2");
assert_eq!(Rational::from_float_simplest(-1.5).to_string(), "-3/2");
assert_eq!(Rational::from_float_simplest(0.1f32).to_string(), "1/10");
assert_eq!(Rational::from_float_simplest(0.33333334f32).to_string(), "1/3");

impl Rational

pub fn from_naturals(numerator: Natural, denominator: Natural) -> Rational

Converts two Naturals to a Rational, taking the Naturals by value.

The Naturals become the Rational’s numerator and denominator. Only non-negative Rationals can be produced with this function.

The denominator may not be zero.

The input Naturals may have common factors; this function reduces them.

Worst-case complexity

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

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

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

Panics

Panics if denominator is zero.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(
    Rational::from_naturals(Natural::from(4u32), Natural::from(6u32)).to_string(),
    "2/3"
);
assert_eq!(Rational::from_naturals(Natural::ZERO, Natural::from(6u32)), 0);

pub fn from_naturals_ref(numerator: &Natural, denominator: &Natural) -> Rational

Converts two Naturals to a Rational, taking the Naturals by reference.

The Naturals become the Rational’s numerator and denominator. Only non-negative Rationals can be produced with this function.

The denominator may not be zero.

The input Naturals may have common factors; this function reduces them.

Worst-case complexity

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

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

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

Panics

Panics if denominator is zero.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(
    Rational::from_naturals_ref(&Natural::from(4u32), &Natural::from(6u32)).to_string(),
    "2/3"
);
assert_eq!(Rational::from_naturals_ref(&Natural::ZERO, &Natural::from(6u32)), 0);

pub fn from_unsigneds<T: PrimitiveUnsigned>(
    numerator: T,
    denominator: T
) -> Rational where
    Natural: From<T>, 

Converts two unsigned primitive integers to a Rational.

The integers become the Rational’s numerator and denominator. Only non-negative Rationals can be produced with this function.

The denominator may not be zero.

The input integers may have common factors; this function reduces them.

Worst-case complexity

$T(n) = O(n^2)$

$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 denominator is zero.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!(Rational::from_unsigneds(4u32, 6).to_string(), "2/3");
assert_eq!(Rational::from_unsigneds(0u32, 6), 0);

pub fn from_integers(numerator: Integer, denominator: Integer) -> Rational

Converts two Integers to a Rational, taking the Integers by value.

The absolute values of the Integers become the Rational’s numerator and denominator. The sign of the Rational is the sign of the Integers’ quotient.

The denominator may not be zero.

The input Integers may have common factors; this function reduces them.

Worst-case complexity

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

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

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

Panics

Panics if denominator is zero.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert_eq!(
    Rational::from_integers(Integer::from(4), Integer::from(6)).to_string(),
    "2/3"
);
assert_eq!(
    Rational::from_integers(Integer::from(4), Integer::from(-6)).to_string(),
    "-2/3"
);
assert_eq!(Rational::from_integers(Integer::ZERO, Integer::from(6)), 0);
assert_eq!(Rational::from_integers(Integer::ZERO, Integer::from(-6)), 0);

pub fn from_integers_ref(numerator: &Integer, denominator: &Integer) -> Rational

Converts two Integers to a Rational, taking the Integers by reference.

The absolute values of the Integers become the Rational’s numerator and denominator. The sign of the Rational is the sign of the Integers’ quotient.

The denominator may not be zero.

The input Integers may have common factors; this function reduces them.

Worst-case complexity

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

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

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

Panics

Panics if denominator is zero.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert_eq!(
    Rational::from_integers_ref(&Integer::from(4), &Integer::from(6)).to_string(),
    "2/3"
);
assert_eq!(
    Rational::from_integers_ref(&Integer::from(4), &Integer::from(-6)).to_string(),
    "-2/3"
);
assert_eq!(Rational::from_integers_ref(&Integer::ZERO, &Integer::from(6)), 0);
assert_eq!(Rational::from_integers_ref(&Integer::ZERO, &Integer::from(-6)), 0);

pub fn from_signeds<T: PrimitiveSigned>(
    numerator: T,
    denominator: T
) -> Rational where
    Integer: From<T>, 

Converts two signed primitive integers to a [Rational].

The absolute values of the integers become the Rational’s numerator and denominator. The sign of the Rational is the sign of the integers’ quotient.

The denominator may not be zero.

The input integers may have common factors; this function reduces them.

Worst-case complexity

$T(n) = O(n^2)$

$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 denominator is zero.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!(Rational::from_signeds(4i8, 6).to_string(), "2/3");
assert_eq!(Rational::from_signeds(4i8, -6).to_string(), "-2/3");
assert_eq!(Rational::from_signeds(0i8, 6), 0);
assert_eq!(Rational::from_signeds(0i8, -6), 0);

pub fn from_sign_and_naturals(
    sign: bool,
    numerator: Natural,
    denominator: Natural
) -> Rational

Converts a sign and two Naturals to a Rational, taking the Naturals by value.

The Naturals become the Rational’s numerator and denominator, and the sign indicates whether the Rational should be non-negative. If the numerator is zero, then the Rational will be non-negative regardless of the sign.

The denominator may not be zero.

The input Naturals may have common factors; this function reduces them.

Worst-case complexity

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

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

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

Panics

Panics if denominator is zero.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(
    Rational::from_sign_and_naturals(
        true,
        Natural::from(4u32),
        Natural::from(6u32)
    ).to_string(),
    "2/3"
);
assert_eq!(
    Rational::from_sign_and_naturals(
        false,
        Natural::from(4u32),
        Natural::from(6u32)
    ).to_string(),
    "-2/3"
);

pub fn from_sign_and_naturals_ref(
    sign: bool,
    numerator: &Natural,
    denominator: &Natural
) -> Rational

Converts a sign and two Naturals to a Rational, taking the Naturals by reference.

The Naturals become the Rational’s numerator and denominator, and the sign indicates whether the Rational should be non-negative. If the numerator is zero, then the Rational will be non-negative regardless of the sign.

The denominator may not be zero.

The input Naturals may have common factors; this function reduces them.

Worst-case complexity

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

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

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

Panics

Panics if denominator is zero.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(
    Rational::from_sign_and_naturals_ref(
        true,
        &Natural::from(4u32),
        &Natural::from(6u32)
    ).to_string(),
    "2/3"
);
assert_eq!(
    Rational::from_sign_and_naturals_ref(
        false,
        &Natural::from(4u32),
        &Natural::from(6u32)
    ).to_string(),
    "-2/3"
);

pub fn from_sign_and_unsigneds<T: PrimitiveUnsigned>(
    sign: bool,
    numerator: T,
    denominator: T
) -> Rational where
    Natural: From<T>, 

Converts a sign and two primitive unsigned integers to a Rational.

The integers become the Rational’s numerator and denominator, and the sign indicates whether the Rational should be non-negative. If the numerator is zero, then the Rational will be non-negative regardless of the sign.

The denominator may not be zero.

The input integers may have common factors; this function reduces them.

Worst-case complexity

$T(n) = O(n^2)$

$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 denominator is zero.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!(Rational::from_sign_and_unsigneds(true, 4u32, 6).to_string(), "2/3");
assert_eq!(Rational::from_sign_and_unsigneds(false, 4u32, 6).to_string(), "-2/3");

impl Rational

pub fn sci_mantissa_and_exponent_with_rounding<T: PrimitiveFloat>(
    self,
    rm: RoundingMode
) -> Option<(T, i64)>

Returns a Rational’s scientific mantissa and exponent, taking the Rational by 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 \log n \log\log n)$

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

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

Examples

extern crate malachite_base;

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_q::Rational;

let test = |n: Rational, rm: RoundingMode, out: Option<(f32, i64)>| {
    assert_eq!(
        n.sci_mantissa_and_exponent_with_rounding(rm)
            .map(|(m, e)| (NiceFloat(m), e)),
        out.map(|(m, e)| (NiceFloat(m), e))
    );
};
test(Rational::from(3u32), RoundingMode::Down, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Ceiling, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Up, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Nearest, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Exact, Some((1.5, 1)));

test(Rational::from_signeds(1, 3), RoundingMode::Floor, Some((1.3333333, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Down, Some((1.3333333, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Ceiling, Some((1.3333334, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Up, Some((1.3333334, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Nearest, Some((1.3333334, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Exact, None);

pub fn sci_mantissa_and_exponent_with_rounding_ref<T: PrimitiveFloat>(
    &self,
    rm: RoundingMode
) -> Option<(T, i64)>

Returns a Rational’s scientific mantissa and exponent, taking the Rational by reference.

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 \log n \log\log n)$

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

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

Examples

extern crate malachite_base;

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_q::Rational;

let test = |n: Rational, rm: RoundingMode, out: Option<(f32, i64)>| {
    assert_eq!(
        (&n).sci_mantissa_and_exponent_with_rounding_ref(rm)
            .map(|(m, e)| (NiceFloat(m), e)),
        out.map(|(m, e)| (NiceFloat(m), e))
    );
};
test(Rational::from(3u32), RoundingMode::Down, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Ceiling, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Up, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Nearest, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Exact, Some((1.5, 1)));

test(Rational::from_signeds(1, 3), RoundingMode::Floor, Some((1.3333333, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Down, Some((1.3333333, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Ceiling, Some((1.3333334, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Up, Some((1.3333334, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Nearest, Some((1.3333334, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Exact, None);

impl Rational

pub fn mutate_numerator<F: FnOnce(&mut Natural) -> T, T>(&mut self, f: F) -> T

Mutates the numerator of a Rational using a provided closure, and then returns whatever the closure returns.

After the closure executes, this function reduces the Rational.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

let mut q = Rational::from_signeds(22, 7);
let ret = q.mutate_numerator(|x| {
    *x -= Natural::ONE;
    true
});
assert_eq!(q, 3);
assert_eq!(ret, true);

pub fn mutate_denominator<F: FnOnce(&mut Natural) -> T, T>(&mut self, f: F) -> T

Mutates the denominator of a Rational using a provided closure.

After the closure executes, this function reduces the Rational.

Panics

Panics if the closure sets the denominator to zero.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

let mut q = Rational::from_signeds(22, 7);
let ret = q.mutate_denominator(|x| {
    *x -= Natural::ONE;
    true
});
assert_eq!(q.to_string(), "11/3");
assert_eq!(ret, true);

pub fn mutate_numerator_and_denominator<F: FnOnce(&mut Natural, &mut Natural) -> T, T>(
    &mut self,
    f: F
) -> T

Mutates the numerator and denominator of a Rational using a provided closure.

After the closure executes, this function reduces the Rational.

Panics

Panics if the closure sets the denominator to zero.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

let mut q = Rational::from_signeds(22, 7);
let ret = q.mutate_numerator_and_denominator(|x, y| {
    *x -= Natural::ONE;
    *y -= Natural::ONE;
    true
});
assert_eq!(q.to_string(), "7/2");
assert_eq!(ret, true);

impl Rational

pub fn from_sci_string_simplest_with_options(
    s: &str,
    options: FromSciStringOptions
) -> Option<Rational>

Converts a string, possibly in scientfic notation, to a Rational. This function finds the simplest Rational which rounds to the target string according to the precision implied by the string.

Use FromSciStringOptions to specify the base (from 2 to 36, inclusive). The rounding mode option is ignored.

If the base is greater than 10, the higher digits are represented by the letters 'a' through 'z' or 'A' through 'Z'; the case doesn’t matter and doesn’t need to be consistent.

Exponents are allowed, and are indicated using the character 'e' or 'E'. If the base is 15 or greater, an ambiguity arises where it may not be clear whether 'e' is a digit or an exponent indicator. To resolve this ambiguity, always use a '+' or '-' sign after the exponent indicator when the base is 15 or greater.

The exponent itself is always parsed using base 10.

Decimal (or other-base) points are allowed.

If the string is unparseable, None is returned.

Here’s a more precise description of the function’s behavior. Suppose we are using base $b$, and the literal value of the string (as parsed by from_sci_string) is $q$, and the implied scale is $s$ (meaning $s$ digits are provided after the point; if the string is "123.456", then $s$ is 3). Then this function computes $\epsilon = b^{-s}/2$ and finds the simplest Rational in the closed interval $[q - \epsilon, q + \epsilon]$. The simplest Rational is the one with minimal denominator; if there are multiple such Rationals, the one with the smallest absolute numerator is chosen.

The following discussion assumes base 10.

This method allows the function to convert "0.333" to $1/3$, since $1/3$ is the simplest Rational in the interval $[0.3325, 0.3335]$. But note that if the scale of the input is low, some unexpected behavior may occur. For example, "0.1" will be converted into $1/7$ rather than $1/10$, since $1/7$ is the simplest Rational in $[0.05, 0.15]$. If you’d prefer that result be $1/10$, you have a few options:

• Use from_sci_string_with_options instead. This function interprets its input literally; it converts "0.333" to $333/1000$.
• Increase the scale of the input; "0.10" is converted to $1/10$.
• Use from_sci_string_with_options, and round the result manually using functions like round_to_multiple and simplest_rational_in_closed_interval.

Worst-case complexity

$T(n, m) = O(m^n n \log m (\log n + \log\log m))$

$M(n, m) = O(m^n n \log m)$

where $T$ is time, $M$ is additional memory, $n$ is s.len(), and $m$ is options.base.

Examples

extern crate malachite_base;

use malachite_base::num::conversion::string::options::FromSciStringOptions;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;

let mut options = FromSciStringOptions::default();
options.set_base(16);
assert_eq!(Rational::from_sci_string_simplest_with_options("ff", options).unwrap(), 255);
assert_eq!(
    Rational::from_sci_string_simplest_with_options("ffE+5", options).unwrap(),
    267386880
);
// 1/4105 is 0.000ff705..._16
assert_eq!(
    Rational::from_sci_string_simplest_with_options("ffE-5", options).unwrap().to_string(),
    "1/4105"
);

pub fn from_sci_string_simplest(s: &str) -> Option<Rational>

Converts a string, possibly in scientfic notation, to a Rational. This function finds the simplest Rational which rounds to the target string according to the precision implied by the string.

The string is parsed using base 10. To use other bases, try from_sci_string_simplest_with_options instead.

Exponents are allowed, and are indicated using the character 'e' or 'E'.

The exponent itself is also parsed using base 10.

Decimal points are allowed.

If the string is unparseable, None is returned.

Here’s a more precise description of the function’s behavior. Suppose that the literal value of the string (as parsed by from_sci_string) is $q$, and the implied scale is $s$ (meaning $s$ digits are provided after the point; if the string is "123.456", then $s$ is 3). Then this function computes $\epsilon = 10^{-s}/2$ and finds the simplest Rational in the closed interval $[q - \epsilon, q + \epsilon]$. The simplest Rational is the one with minimal denominator; if there are multiple such Rationals, the one with the smallest absolute numerator is chosen.

This method allows the function to convert "0.333" to $1/3$, since $1/3$ is the simplest Rational in the interval $[0.3325, 0.3335]$. But note that if the scale of the input is low, some unexpected behavior may occur. For example, "0.1" will be converted into $1/7$ rather than $1/10$, since $1/7$ is the simplest Rational in $[0.05, 0.15]$. If you’d prefer that result be $1/10$, you have a few options:

• Use from_sci_string instead. This function interprets its input literally; it converts "0.333" to $333/1000$.
• Increase the scale of the input; "0.10" is converted to $1/10$.
• Use from_sci_string, and round the result manually using functions like round_to_multiple and simplest_rational_in_closed_interval.

Worst-case complexity

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

$M(n) = O(10^n n)$

where $T$ is time, $M$ is additional memory, and $n$ is s.len().

Examples

use malachite_q::Rational;

assert_eq!(Rational::from_sci_string_simplest("123").unwrap(), 123);
assert_eq!(Rational::from_sci_string_simplest("0.1").unwrap().to_string(), "1/7");
assert_eq!(Rational::from_sci_string_simplest("0.10").unwrap().to_string(), "1/10");
assert_eq!(Rational::from_sci_string_simplest("0.333").unwrap().to_string(), "1/3");
assert_eq!(Rational::from_sci_string_simplest("1.2e5").unwrap(), 120000);
assert_eq!(Rational::from_sci_string_simplest("1.2e-5").unwrap().to_string(), "1/80000");

impl Rational

pub fn length_after_point_in_small_base(&self, base: u8) -> Option<u64>

When expanding a Rational in a small base $b$, determines how many digits after the decimal (or other-base) point are in the base-$b$ expansion.

If the expansion is non-terminating, this method returns None. This happens iff the Rational’s denominator has prime factors not present in $b$.

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 base is less than 2 or greater than 36.

Examples

use malachite_q::Rational;

// 3/8 is 0.375 in base 10.
assert_eq!(Rational::from_signeds(3, 8).length_after_point_in_small_base(10), Some(3));
// 1/20 is 0.05 in base 10.
assert_eq!(Rational::from_signeds(1, 20).length_after_point_in_small_base(10), Some(2));
// 1/7 is non-terminating in base 10.
assert_eq!(Rational::from_signeds(1, 7).length_after_point_in_small_base(10), None);
// 1/7 is 0.3 in base 21.
assert_eq!(Rational::from_signeds(1, 7).length_after_point_in_small_base(21), Some(1));

impl Rational

pub fn to_numerator(&self) -> Natural

Extracts the numerator of a Rational, taking the Rational by reference and cloning.

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_q::Rational;
use std::str::FromStr;

assert_eq!(Rational::from_str("2/3").unwrap().to_numerator(), 2);
assert_eq!(Rational::from_str("0").unwrap().to_numerator(), 0);

pub fn to_denominator(&self) -> Natural

Extracts the denominator of a Rational, taking the Rational by reference and cloning.

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_q::Rational;
use std::str::FromStr;

assert_eq!(Rational::from_str("2/3").unwrap().to_denominator(), 3);
assert_eq!(Rational::from_str("0").unwrap().to_denominator(), 1);

pub fn to_numerator_and_denominator(&self) -> (Natural, Natural)

Extracts the numerator and denominator of a Rational, taking the Rational by reference and cloning.

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

extern crate malachite_base;

use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(
    Rational::from_str("2/3").unwrap().to_numerator_and_denominator().to_debug_string(),
    "(2, 3)"
);
assert_eq!(
    Rational::from_str("0").unwrap().to_numerator_and_denominator().to_debug_string(),
    "(0, 1)"
);

pub fn into_numerator(self) -> Natural

Extracts the numerator of a Rational, taking the Rational by value.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(Rational::from_str("2/3").unwrap().into_numerator(), 2);
assert_eq!(Rational::from_str("0").unwrap().into_numerator(), 0);

pub fn into_denominator(self) -> Natural

Extracts the denominator of a Rational, taking the Rational by value.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(Rational::from_str("2/3").unwrap().into_denominator(), 3);
assert_eq!(Rational::from_str("0").unwrap().into_denominator(), 1);

pub fn into_numerator_and_denominator(self) -> (Natural, Natural)

Extracts the numerator and denominator of a Rational, taking the Rational by value.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(
    Rational::from_str("2/3").unwrap().into_numerator_and_denominator().to_debug_string(),
    "(2, 3)"
);
assert_eq!(
    Rational::from_str("0").unwrap().into_numerator_and_denominator().to_debug_string(),
    "(0, 1)"
);

pub const fn numerator_ref(&self) -> &Natural

Returns a reference to the numerator of a Rational.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(*Rational::from_str("2/3").unwrap().numerator_ref(), 2);
assert_eq!(*Rational::from_str("0").unwrap().numerator_ref(), 0);

pub const fn denominator_ref(&self) -> &Natural

Returns a reference to the denominator of a Rational.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(*Rational::from_str("2/3").unwrap().denominator_ref(), 3);
assert_eq!(*Rational::from_str("0").unwrap().denominator_ref(), 1);

pub const fn numerator_and_denominator_ref(&self) -> (&Natural, &Natural)

Returns references to the numeraror and denominator of a Rational.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(
    Rational::from_str("2/3").unwrap().numerator_and_denominator_ref().to_debug_string(),
    "(2, 3)"
);
assert_eq!(
    Rational::from_str("0").unwrap().numerator_and_denominator_ref().to_debug_string(),
    "(0, 1)"
);

Trait Implementations

impl Abs for Rational

fn abs(self) -> Rational

Takes the absolute value of a Rational, taking the Rational by value.

$$ f(x) = |x|. $$

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Abs;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!(Rational::ZERO.abs(), 0);
assert_eq!(Rational::from_signeds(22, 7).abs().to_string(), "22/7");
assert_eq!(Rational::from_signeds(-22, 7).abs().to_string(), "22/7");

type Output = Rational

impl<'a> Abs for &'a Rational

fn abs(self) -> Rational

Takes the absolute value of a Rational, taking the Rational by value.

$$ f(x) = |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

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Abs;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!((&Rational::ZERO).abs(), 0);
assert_eq!((&Rational::from_signeds(22, 7)).abs().to_string(), "22/7");
assert_eq!((&Rational::from_signeds(-22, 7)).abs().to_string(), "22/7");

type Output = Rational

impl AbsAssign for Rational

fn abs_assign(&mut self)

Replaces a Rational with its absolute value.

$$ x \gets |x|. $$

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::AbsAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

let mut x = Rational::ZERO;
x.abs_assign();
assert_eq!(x, 0);

let mut x = Rational::from_signeds(22, 7);
x.abs_assign();
assert_eq!(x.to_string(), "22/7");

let mut x = Rational::from_signeds(-22, 7);
x.abs_assign();
assert_eq!(x.to_string(), "22/7");

impl<'a> Add<&'a Rational> for Rational

fn add(self, other: &'a Rational) -> Rational

Adds two Rationals, taking both by the first by value and the second by reference.

$$ f(x, y) = x + y. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;

assert_eq!(Rational::ONE_HALF + &Rational::ONE_HALF, 1);
assert_eq!(
    (Rational::from_signeds(22, 7) + &Rational::from_signeds(99, 100)).to_string(),
    "2893/700"
);

type Output = Rational

The resulting type after applying the + operator.

impl<'a, 'b> Add<&'a Rational> for &'b Rational

fn add(self, other: &'a Rational) -> Rational

Adds two Rationals, taking both by reference.

$$ f(x, y) = x + y. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;

assert_eq!(&Rational::ONE_HALF + &Rational::ONE_HALF, 1);
assert_eq!(
    (&Rational::from_signeds(22, 7) + &Rational::from_signeds(99, 100)).to_string(),
    "2893/700"
);

type Output = Rational

The resulting type after applying the + operator.

impl Add<Rational> for Rational

fn add(self, other: Rational) -> Rational

Adds two Rationals, taking both by value.

$$ f(x, y) = x + y. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;

assert_eq!(Rational::ONE_HALF + Rational::ONE_HALF, 1);
assert_eq!(
    (Rational::from_signeds(22, 7) + Rational::from_signeds(99, 100)).to_string(),
    "2893/700"
);

type Output = Rational

The resulting type after applying the + operator.

impl<'a> Add<Rational> for &'a Rational

fn add(self, other: Rational) -> Rational

Adds two Rationals, taking the first by reference and the second by value

$$ f(x, y) = x + y. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;

assert_eq!(&Rational::ONE_HALF + Rational::ONE_HALF, 1);
assert_eq!(
    (&Rational::from_signeds(22, 7) + Rational::from_signeds(99, 100)).to_string(),
    "2893/700"
);

type Output = Rational

The resulting type after applying the + operator.

impl<'a> AddAssign<&'a Rational> for Rational

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

Adds a Rational to a Rational in place, taking the Rational on the right-hand side by reference.

$$ x \gets x + y. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;

let mut x = Rational::ONE_HALF;
x += &Rational::ONE_HALF;
assert_eq!(x, 1);

let mut x = Rational::from_signeds(22, 7);
x += &Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "2893/700");

impl AddAssign<Rational> for Rational

fn add_assign(&mut self, other: Rational)

Adds a Rational to a Rational in place, taking the Rational on the right-hand side by value.

$$ x \gets x + y. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;

let mut x = Rational::ONE_HALF;
x += Rational::ONE_HALF;
assert_eq!(x, 1);

let mut x = Rational::from_signeds(22, 7);
x += Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "2893/700");

impl Approximate for Rational

fn approximate(self, max_denominator: &Natural) -> Rational

Finds the best approximation of a Rational using a denominator no greater than a specified maximum, taking the Rational by value.

Let $f(x, d) = p/q$, with $p$ and $q$ relatively prime. Then the following properties hold:

• $q \leq d$
• For all $n \in \Z$ and all $m \in \Z$ with $0 < m \leq d$, $|x - p/q| \leq |x - n/m|$.
• If $|x - n/m| = |x - p/q|$, then $q \leq m$.
• If $|x - n/q| = |x - p/q|$, then $p$ is even and $n$ is either equal to $p$ or odd.

Worst-case complexity

$T(n) = O(n^2 \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

• If max_denominator is zero.

Examples

extern crate malachite_nz;

use malachite_nz::natural::Natural;
use malachite_q::arithmetic::traits::Approximate;
use malachite_q::Rational;

assert_eq!(
    Rational::from(std::f64::consts::PI).approximate(&Natural::from(1000u32)).to_string(),
    "355/113"
);
assert_eq!(
    Rational::from_signeds(333i32, 1000).approximate(&Natural::from(100u32)).to_string(),
    "1/3"
);

Implementation notes

This algorithm follows the description in https://en.wikipedia.org/wiki/Continued_fraction#Best_rational_approximations. One part of the algorithm not mentioned in that article is that if the last term $n$ in the continued fraction needs to be reduced, the optimal replacement term $m$ may be found using division.

impl<'a> Approximate for &'a Rational

fn approximate(self, max_denominator: &Natural) -> Rational

Finds the best approximation of a Rational using a denominator no greater than a specified maximum, taking the Rational by reference.

Let $f(x, d) = p/q$, with $p$ and $q$ relatively prime. Then the following properties hold:

• $q \leq d$
• For all $n \in \Z$ and all $m \in \Z$ with $0 < m \leq d$, $|x - p/q| \leq |x - n/m|$.
• If $|x - n/m| = |x - p/q|$, then $q \leq m$.
• If $|x - n/q| = |x - p/q|$, then $p$ is even and $n$ is either equal to $p$ or odd.

Worst-case complexity

$T(n) = O(n^2 \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

• If max_denominator is zero.

Examples

extern crate malachite_nz;

use malachite_nz::natural::Natural;
use malachite_q::arithmetic::traits::Approximate;
use malachite_q::Rational;

assert_eq!(
    (&Rational::from(std::f64::consts::PI)).approximate(&Natural::from(1000u32))
            .to_string(),
    "355/113"
);
assert_eq!(
    (&Rational::from_signeds(333i32, 1000)).approximate(&Natural::from(100u32))
            .to_string(),
    "1/3"
);

Implementation notes

This algorithm follows the description in https://en.wikipedia.org/wiki/Continued_fraction#Best_rational_approximations. One part of the algorithm not mentioned in that article is that if the last term $n$ in the continued fraction needs to be reduced, the optimal replacement term $m$ may be found using division.

impl ApproximateAssign for Rational

fn approximate_assign(&mut self, max_denominator: &Natural)

Finds the best approximation of a Rational using a denominator no greater than a specified maximum, mutating the Rational in place.

See Rational::approximate for more information.

Worst-case complexity

$T(n) = O(n^2 \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

• If max_denominator is zero.

Examples

extern crate malachite_nz;

use malachite_nz::natural::Natural;
use malachite_q::arithmetic::traits::ApproximateAssign;
use malachite_q::Rational;

let mut x = Rational::from(std::f64::consts::PI);
x.approximate_assign(&Natural::from(1000u32));
assert_eq!(x.to_string(), "355/113");

let mut x = Rational::from_signeds(333i32, 1000);
x.approximate_assign(&Natural::from(100u32));
assert_eq!(x.to_string(), "1/3");

impl Ceiling for Rational

fn ceiling(self) -> Integer

Finds the ceiling of a Rational, taking the Rational by value.

$$ f(x) = \lceil x \rceil. $$

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

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Ceiling;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!(Rational::ZERO.ceiling(), 0);
assert_eq!(Rational::from_signeds(22, 7).ceiling(), 4);
assert_eq!(Rational::from_signeds(-22, 7).ceiling(), -3);

type Output = Integer

impl<'a> Ceiling for &'a Rational

fn ceiling(self) -> Integer

Finds the ceiling of a Rational, taking the Rational by reference.

$$ f(x) = \lceil x \rceil. $$

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

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Ceiling;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!((&Rational::ZERO).ceiling(), 0);
assert_eq!((&Rational::from_signeds(22, 7)).ceiling(), 4);
assert_eq!((&Rational::from_signeds(-22, 7)).ceiling(), -3);

type Output = Integer

impl CeilingAssign for Rational

fn ceiling_assign(&mut self)

Replaces a Rational with its ceiling.

$$ x \gets \lceil x \rceil. $$

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

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

let mut x = Rational::ZERO;
x.ceiling_assign();
assert_eq!(x, 0);

let mut x = Rational::from_signeds(22, 7);
x.ceiling_assign();
assert_eq!(x, 4);

let mut x = Rational::from_signeds(-22, 7);
x.ceiling_assign();
assert_eq!(x, -3);

impl<'a, 'b> CeilingLogBase<&'b Rational> for &'a Rational

fn ceiling_log_base(self, base: &Rational) -> i64

Returns the ceiling of the base-$b$ logarithm of a positive Rational.

Note that this function may be slow if the base is very close to 1.

$f(x, b) = \lceil\log_b x\rceil$.

Worst-case complexity

$T(n, m) = O(nm \log (nm) \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

where $T$ is time, $M$ is additional memory, $n$ is base.significant_bits(), and $m$ is $|\log_b x|$, where $b$ is base and $x$ is x.

Panics

Panics if self less than or equal to zero or base is 1.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingLogBase;
use malachite_q::Rational;

assert_eq!(Rational::from(80u32).ceiling_log_base(&Rational::from(3u32)), 4);
assert_eq!(Rational::from(81u32).ceiling_log_base(&Rational::from(3u32)), 4);
assert_eq!(Rational::from(82u32).ceiling_log_base(&Rational::from(3u32)), 5);
assert_eq!(Rational::from(4294967296u64).ceiling_log_base(&Rational::from(10u32)), 10);
assert_eq!(
    Rational::from_signeds(936851431250i64, 1397).ceiling_log_base(&Rational::from(10u32)),
    9
);
assert_eq!(
    Rational::from_signeds(5153632, 16807)
            .ceiling_log_base(&Rational::from_signeds(22, 7)),
    5
);

type Output = i64

impl<'a> CeilingLogBase2 for &'a Rational

fn ceiling_log_base_2(self) -> i64

Returns the ceiling of the base-2 logarithm of a positive Rational.

$f(x) = \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 less than or equal to zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingLogBase2;
use malachite_q::Rational;

assert_eq!(Rational::from(3u32).ceiling_log_base_2(), 2);
assert_eq!(Rational::from_signeds(1, 3).ceiling_log_base_2(), -1);
assert_eq!(Rational::from_signeds(1, 4).ceiling_log_base_2(), -2);
assert_eq!(Rational::from_signeds(1, 5).ceiling_log_base_2(), -2);

type Output = i64

impl<'a> CeilingLogBasePowerOf2<i64> for &'a Rational

fn ceiling_log_base_power_of_2(self, pow: i64) -> i64

Returns the ceiling of the base-$2^k$ logarithm of a positive Rational.

$k$ may be negative.

$f(x, p) = \lceil\log_{2^p} x\rceil$.

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 less than or equal to 0 or pow is 0.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingLogBasePowerOf2;
use malachite_q::Rational;

assert_eq!(Rational::from(100).ceiling_log_base_power_of_2(2), 4);
assert_eq!(Rational::from(4294967296u64).ceiling_log_base_power_of_2(8), 4);

// 4^(-2) < 1/10 < 4^(-1)
assert_eq!(Rational::from_signeds(1, 10).ceiling_log_base_power_of_2(2), -1);
// (1/4)^2 < 1/10 < (1/4)^1
assert_eq!(Rational::from_signeds(1, 10).ceiling_log_base_power_of_2(-2), 2);

type Output = i64

impl<'a> CheckedFrom<&'a Rational> for Integer

fn checked_from(x: &Rational) -> Option<Integer>

Converts a Rational to an Integer, taking the Rational by reference. If the Rational is not an integer, None 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.significant_bits().

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::conversion::traits::CheckedFrom;
use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert_eq!(Integer::checked_from(&Rational::from(123)).unwrap(), 123);
assert_eq!(Integer::checked_from(&Rational::from(-123)).unwrap(), -123);
assert_eq!(Integer::checked_from(&Rational::from_signeds(22, 7)), None);

impl<'a> CheckedFrom<&'a Rational> for Natural

fn checked_from(x: &Rational) -> Option<Natural>

Converts a Rational to a Natural, taking the Rational by reference. If the Rational is negative or not an integer, None 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.significant_bits().

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::conversion::traits::CheckedFrom;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(Natural::checked_from(&Rational::from(123)).unwrap(), 123);
assert_eq!(Natural::checked_from(&Rational::from(-123)), None);
assert_eq!(Natural::checked_from(&Rational::from_signeds(22, 7)), None);

impl<'a> CheckedFrom<&'a Rational> for i8

fn checked_from(value: &Rational) -> Option<i8>

Converts a Rational to a signed primitive integer, returning None if the Rational cannot be represented.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> CheckedFrom<&'a Rational> for i16

fn checked_from(value: &Rational) -> Option<i16>

Converts a Rational to a signed primitive integer, returning None if the Rational cannot be represented.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> CheckedFrom<&'a Rational> for i32

fn checked_from(value: &Rational) -> Option<i32>

Converts a Rational to a signed primitive integer, returning None if the Rational cannot be represented.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> CheckedFrom<&'a Rational> for i64

fn checked_from(value: &Rational) -> Option<i64>

Converts a Rational to a signed primitive integer, returning None if the Rational cannot be represented.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> CheckedFrom<&'a Rational> for i128

fn checked_from(value: &Rational) -> Option<i128>

Converts a Rational to a signed primitive integer, returning None if the Rational cannot be represented.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> CheckedFrom<&'a Rational> for isize

fn checked_from(value: &Rational) -> Option<isize>

Converts a Rational to a signed primitive integer, returning None if the Rational cannot be represented.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> CheckedFrom<&'a Rational> for f32

fn checked_from(value: &'a Rational) -> Option<f32>

Converts a Rational to a primitive float, taking the Rational by reference. If the input isn’t exactly equal to any float, None is returned.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

See here.

impl<'a> CheckedFrom<&'a Rational> for f64

fn checked_from(value: &'a Rational) -> Option<f64>

Converts a Rational to a primitive float, taking the Rational by reference. If the input isn’t exactly equal to any float, None is returned.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

See here.

impl<'a> CheckedFrom<&'a Rational> for u8

fn checked_from(value: &Rational) -> Option<u8>

Converts a Rational to an unsigned primitive integer, returning None if the Rational cannot be represented.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> CheckedFrom<&'a Rational> for u16

fn checked_from(value: &Rational) -> Option<u16>

Converts a Rational to an unsigned primitive integer, returning None if the Rational cannot be represented.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> CheckedFrom<&'a Rational> for u32

fn checked_from(value: &Rational) -> Option<u32>

Converts a Rational to an unsigned primitive integer, returning None if the Rational cannot be represented.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> CheckedFrom<&'a Rational> for u64

fn checked_from(value: &Rational) -> Option<u64>

Converts a Rational to an unsigned primitive integer, returning None if the Rational cannot be represented.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> CheckedFrom<&'a Rational> for u128

fn checked_from(value: &Rational) -> Option<u128>

Converts a Rational to an unsigned primitive integer, returning None if the Rational cannot be represented.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> CheckedFrom<&'a Rational> for usize

fn checked_from(value: &Rational) -> Option<usize>

Converts a Rational to an unsigned primitive integer, returning None if the Rational cannot be represented.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl CheckedFrom<Rational> for Integer

fn checked_from(x: Rational) -> Option<Integer>

Converts a Rational to an Integer, taking the Rational by value. If the Rational is not an integer, None is returned.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::conversion::traits::CheckedFrom;
use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert_eq!(Integer::checked_from(Rational::from(123)).unwrap(), 123);
assert_eq!(Integer::checked_from(Rational::from(-123)).unwrap(), -123);
assert_eq!(Integer::checked_from(Rational::from_signeds(22, 7)), None);

impl CheckedFrom<Rational> for Natural

fn checked_from(x: Rational) -> Option<Natural>

Converts a Rational to a Natural, taking the Rational by value. If the Rational is negative or not an integer, None is returned.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::conversion::traits::CheckedFrom;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(Natural::checked_from(Rational::from(123)).unwrap(), 123);
assert_eq!(Natural::checked_from(Rational::from(-123)), None);
assert_eq!(Natural::checked_from(Rational::from_signeds(22, 7)), None);

impl CheckedFrom<Rational> for f32

fn checked_from(value: Rational) -> Option<f32>

Converts a Rational to a primitive float, taking the Rational by value. If the input isn’t exactly equal to any float, None is returned.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

See here.

impl CheckedFrom<Rational> for f64

fn checked_from(value: Rational) -> Option<f64>

Converts a Rational to a primitive float, taking the Rational by value. If the input isn’t exactly equal to any float, None is returned.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

See here.

impl<'a, 'b> CheckedLogBase<&'b Rational> for &'a Rational

fn checked_log_base(self, base: &Rational) -> Option<i64>

Returns the base-$b$ logarithm of a positive Rational. If the Rational is not a power of $b$, then None is returned.

Note that this function may be slow if the base is very close to 1.

$$ f(x, b) = \begin{cases} \operatorname{Some}(\log_b x) & \text{if} \quad \log_b x \in \Z, \\ \operatorname{None} & \textrm{otherwise}. \end{cases} $$

Worst-case complexity

$T(n, m) = O(nm \log (nm) \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

where $T$ is time, $M$ is additional memory, $n$ is base.significant_bits(), and $m$ is $|\log_b x|$, where $b$ is base and $x$ is x.

Panics

Panics if self less than or equal to zero or base is 1.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedLogBase;
use malachite_q::Rational;

assert_eq!(Rational::from(80u32).checked_log_base(&Rational::from(3u32)), None);
assert_eq!(Rational::from(81u32).checked_log_base(&Rational::from(3u32)), Some(4));
assert_eq!(Rational::from(82u32).checked_log_base(&Rational::from(3u32)), None);
assert_eq!(Rational::from(4294967296u64).checked_log_base(&Rational::from(10u32)), None);
assert_eq!(
    Rational::from_signeds(936851431250i64, 1397).checked_log_base(&Rational::from(10u32)),
    None
);
assert_eq!(
    Rational::from_signeds(5153632, 16807)
            .checked_log_base(&Rational::from_signeds(22, 7)),
    Some(5)
);

type Output = i64

impl<'a> CheckedLogBase2 for &'a Rational

fn checked_log_base_2(self) -> Option<i64>

Returns the base-2 logarithm of a positive Rational. If the Rational is not a power of 2, then None is returned.

$$ f(x) = \begin{cases} \operatorname{Some}(\log_2 x) & \text{if} \quad \log_2 x \in \Z, \\ \operatorname{None} & \textrm{otherwise}. \end{cases} $$

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 less than or equal to zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedLogBase2;
use malachite_q::Rational;

assert_eq!(Rational::from(3u32).checked_log_base_2(), None);
assert_eq!(Rational::from_signeds(1, 3).checked_log_base_2(), None);
assert_eq!(Rational::from_signeds(1, 4).checked_log_base_2(), Some(-2));
assert_eq!(Rational::from_signeds(1, 5).checked_log_base_2(), None);

type Output = i64

impl<'a> CheckedLogBasePowerOf2<i64> for &'a Rational

fn checked_log_base_power_of_2(self, pow: i64) -> Option<i64>

Returns the base-$2^k$ logarithm of a positive Rational. If the Rational is not a power of $2^k$, then None is returned.

$k$ may be negative.

$$ f(x, p) = \begin{cases} \operatorname{Some}(\log_{2^p} x) & \text{if} \quad \log_{2^p} x \in \Z, \\ \operatorname{None} & \textrm{otherwise}. \end{cases} $$

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 0 or pow is 0.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedLogBasePowerOf2;
use malachite_q::Rational;

assert_eq!(Rational::from(100).checked_log_base_power_of_2(2), None);
assert_eq!(Rational::from(4294967296u64).checked_log_base_power_of_2(8), Some(4));

// 4^(-2) < 1/10 < 4^(-1)
assert_eq!(Rational::from_signeds(1, 10).checked_log_base_power_of_2(2), None);
assert_eq!(Rational::from_signeds(1, 16).checked_log_base_power_of_2(2), Some(-2));
// (1/4)^2 < 1/10 < (1/4)^1
assert_eq!(Rational::from_signeds(1, 10).checked_log_base_power_of_2(-2), None);
assert_eq!(Rational::from_signeds(1, 16).checked_log_base_power_of_2(-2), Some(2));

type Output = i64

impl CheckedRoot<i64> for Rational

fn checked_root(self, pow: i64) -> Option<Rational>

Returns the the $n$th root of a Rational, or None if the Rational is not a perfect $n$th power. The Rational is taken by value.

$$ f(x, n) = \begin{cases} \operatorname{Some}(sqrt[n]{x}) & \text{if} \quad \sqrt[n]{x} \in ℚ, \\ \operatorname{None} & \textrm{otherwise}. \end{cases} $$

Worst-case complexity

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

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

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

Panics

Panics if exp is zero, if exp is even and self is negative, or if self is zero and exp is negative.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedRoot;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

assert_eq!(Rational::from(999i32).checked_root(3i64).to_debug_string(), "None");
assert_eq!(Rational::from(1000i32).checked_root(3i64).to_debug_string(), "Some(10)");
assert_eq!(Rational::from(1001i32).checked_root(3i64).to_debug_string(), "None");
assert_eq!(Rational::from(-1000i32).checked_root(3i64).to_debug_string(), "Some(-10)");
assert_eq!(Rational::from_signeds(22, 7).checked_root(3i64).to_debug_string(), "None");
assert_eq!(
    Rational::from_signeds(27, 8).checked_root(3i64).to_debug_string(),
    "Some(3/2)"
);
assert_eq!(
    Rational::from_signeds(-27, 8).checked_root(3i64).to_debug_string(),
    "Some(-3/2)"
);

assert_eq!(Rational::from(1000i32).checked_root(-3i64).to_debug_string(), "Some(1/10)");
assert_eq!(
    Rational::from_signeds(-27, 8).checked_root(-3i64).to_debug_string(),
    "Some(-2/3)"
);

type Output = Rational

impl<'a> CheckedRoot<i64> for &'a Rational

fn checked_root(self, pow: i64) -> Option<Rational>

Returns the the $n$th root of a Rational, or None if the Rational is not a perfect $n$th power. The Rational is taken by reference.

$$ f(x, n) = \begin{cases} \operatorname{Some}(sqrt[n]{x}) & \text{if} \quad \sqrt[n]{x} \in ℚ, \\ \operatorname{None} & \textrm{otherwise}. \end{cases} $$

Worst-case complexity

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

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

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

Panics

Panics if exp is zero, if exp is even and self is negative, or if self is zero and exp is negative.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedRoot;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

assert_eq!((&Rational::from(999i32)).checked_root(3i64).to_debug_string(), "None");
assert_eq!((&Rational::from(1000i32)).checked_root(3i64).to_debug_string(), "Some(10)");
assert_eq!((&Rational::from(1001i32)).checked_root(3i64).to_debug_string(), "None");
assert_eq!((&Rational::from(-1000i32)).checked_root(3i64).to_debug_string(), "Some(-10)");
assert_eq!((&Rational::from_signeds(22, 7)).checked_root(3i64).to_debug_string(), "None");
assert_eq!(
    (&Rational::from_signeds(27, 8)).checked_root(3i64).to_debug_string(),
    "Some(3/2)"
);
assert_eq!(
    (&Rational::from_signeds(-27, 8)).checked_root(3i64).to_debug_string(),
    "Some(-3/2)"
);

assert_eq!((&Rational::from(1000i32)).checked_root(-3i64).to_debug_string(), "Some(1/10)");
assert_eq!(
    (&Rational::from_signeds(-27, 8)).checked_root(-3i64).to_debug_string(),
    "Some(-2/3)"
);

type Output = Rational

impl CheckedRoot<u64> for Rational

fn checked_root(self, pow: u64) -> Option<Rational>

Returns the the $n$th root of a Rational, or None if the Rational is not a perfect $n$th power. The Rational is taken by value.

$$ f(x, n) = \begin{cases} \operatorname{Some}(sqrt[n]{x}) & \text{if} \quad \sqrt[n]{x} \in ℚ, \\ \operatorname{None} & \textrm{otherwise}. \end{cases} $$

Worst-case complexity

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

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

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

Panics

Panics if exp is zero, or if exp is even and self is negative.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedRoot;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

assert_eq!(Rational::from(999i32).checked_root(3u64).to_debug_string(), "None");
assert_eq!(Rational::from(1000i32).checked_root(3u64).to_debug_string(), "Some(10)");
assert_eq!(Rational::from(1001i32).checked_root(3u64).to_debug_string(), "None");
assert_eq!(Rational::from(-1000i32).checked_root(3u64).to_debug_string(), "Some(-10)");
assert_eq!(Rational::from_signeds(22, 7).checked_root(3u64).to_debug_string(), "None");
assert_eq!(
    Rational::from_signeds(27, 8).checked_root(3u64).to_debug_string(),
    "Some(3/2)"
);
assert_eq!(
    Rational::from_signeds(-27, 8).checked_root(3u64).to_debug_string(),
    "Some(-3/2)"
);

type Output = Rational

impl<'a> CheckedRoot<u64> for &'a Rational

fn checked_root(self, pow: u64) -> Option<Rational>

Returns the the $n$th root of a Rational, or None if the Rational is not a perfect $n$th power. The Rational is taken by reference.

$$ f(x, n) = \begin{cases} \operatorname{Some}(sqrt[n]{x}) & \text{if} \quad \sqrt[n]{x} \in ℚ, \\ \operatorname{None} & \textrm{otherwise}. \end{cases} $$

Worst-case complexity

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

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

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

Panics

Panics if exp is zero, or if exp is even and self is negative.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedRoot;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

assert_eq!(Rational::from(999i32).checked_root(3u64).to_debug_string(), "None");
assert_eq!(Rational::from(1000i32).checked_root(3u64).to_debug_string(), "Some(10)");
assert_eq!(Rational::from(1001i32).checked_root(3u64).to_debug_string(), "None");
assert_eq!(Rational::from(-1000i32).checked_root(3u64).to_debug_string(), "Some(-10)");
assert_eq!(Rational::from_signeds(22, 7).checked_root(3u64).to_debug_string(), "None");
assert_eq!(
    Rational::from_signeds(27, 8).checked_root(3u64).to_debug_string(),
    "Some(3/2)"
);
assert_eq!(
    Rational::from_signeds(-27, 8).checked_root(3u64).to_debug_string(),
    "Some(-3/2)"
);

type Output = Rational

impl CheckedSqrt for Rational

fn checked_sqrt(self) -> Option<Rational>

Returns the the square root of a Rational, or None if it is not a perfect square. The Rational is taken by value.

$$ f(x) = \begin{cases} \operatorname{Some}(sqrt{x}) & \text{if} \quad \sqrt{x} \in ℚ, \\ \operatorname{None} & \textrm{otherwise}. \end{cases} $$

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 self.significant_bits().

Panics

Panics if self is negative.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedSqrt;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

assert_eq!(Rational::from(99u8).checked_sqrt().to_debug_string(), "None");
assert_eq!(Rational::from(100u8).checked_sqrt().to_debug_string(), "Some(10)");
assert_eq!(Rational::from(101u8).checked_sqrt().to_debug_string(), "None");
assert_eq!(Rational::from_signeds(22, 7).checked_sqrt().to_debug_string(), "None");
assert_eq!(Rational::from_signeds(25, 9).checked_sqrt().to_debug_string(), "Some(5/3)");

type Output = Rational

impl<'a> CheckedSqrt for &'a Rational

fn checked_sqrt(self) -> Option<Rational>

Returns the the square root of a Rational, or None if it is not a perfect square. The Rational is taken by reference.

$$ f(x) = \begin{cases} \operatorname{Some}(sqrt{x}) & \text{if} \quad \sqrt{x} \in ℚ, \\ \operatorname{None} & \textrm{otherwise}. \end{cases} $$

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 self.significant_bits().

Panics

Panics if self is negative.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedSqrt;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

assert_eq!((&Rational::from(99u8)).checked_sqrt().to_debug_string(), "None");
assert_eq!((&Rational::from(100u8)).checked_sqrt().to_debug_string(), "Some(10)");
assert_eq!((&Rational::from(101u8)).checked_sqrt().to_debug_string(), "None");
assert_eq!((&Rational::from_signeds(22, 7)).checked_sqrt().to_debug_string(), "None");
assert_eq!((&Rational::from_signeds(25, 9)).checked_sqrt().to_debug_string(), "Some(5/3)");

type Output = Rational

impl Clone for Rational

fn clone(&self) -> Rational

Returns a copy of the value.

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

Performs copy-assignment from source.

impl ContinuedFraction for Rational

fn continued_fraction(self) -> (Integer, RationalContinuedFraction)

Returns the continued fraction of a Rational, taking the Rational by value.

The output has two components. The first is the first value of the continued fraction, which may be any Integer and is equal to the floor of the Rational. The second is an iterator that produces the remaining values, which are all positive. Using the standard notation for continued fractions, the first value is the number before the semicolon, and the second value produces the remaining numbers.

Each rational number has two continued fraction representations. The shorter of the two representations (the one that does not end in 1) is returned.

$f(x) = (a_0, (a_1, a_2, \ldots, a_3)),$ where $x = [a_0; a_1, a_2, \ldots, a_3]$ and $a_3 \neq 1$.

The output length is $O(n)$, where $n$ is self.significant_bits().

Worst-case complexity per iteration

$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 self.significant_bits().

Examples

extern crate itertools;
extern crate malachite_base;

use itertools::Itertools;
use malachite_base::strings::ToDebugString;
use malachite_q::conversion::traits::ContinuedFraction;
use malachite_q::Rational;

let (head, tail) = Rational::from_signeds(2, 3).continued_fraction();
let tail = tail.collect_vec();
assert_eq!(head, 0);
assert_eq!(tail.to_debug_string(), "[1, 2]");

let (head, tail) = Rational::from_signeds(355, 113).continued_fraction();
let tail = tail.collect_vec();
assert_eq!(head, 3);
assert_eq!(tail.to_debug_string(), "[7, 16]");

type CF = RationalContinuedFraction

impl<'a> ContinuedFraction for &'a Rational

fn continued_fraction(self) -> (Integer, RationalContinuedFraction)

Returns the continued fraction of a Rational, taking the Rational by reference.

The output has two components. The first is the first value of the continued fraction, which may be any Integer and is equal to the floor of the Rational. The second is an iterator that produces the remaining values, which are all positive. Using the standard notation for continued fractions, the first value is the number before the semicolon, and the second value produces the remaining numbers.

Each rational number has two continued fraction representations. The shorter of the two representations (the one that does not end in 1) is returned.

$f(x) = (a_0, (a_1, a_2, \ldots, a_3)),$ where $x = [a_0; a_1, a_2, \ldots, a_3]$ and $a_3 \neq 1$.

The output length is $O(n)$, where $n$ is self.significant_bits().

Worst-case complexity per iteration

$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 self.significant_bits().

Examples

extern crate itertools;
extern crate malachite_base;

use itertools::Itertools;
use malachite_base::strings::ToDebugString;
use malachite_q::conversion::traits::ContinuedFraction;
use malachite_q::Rational;

let (head, tail) = (&Rational::from_signeds(2, 3)).continued_fraction();
let tail = tail.collect_vec();
assert_eq!(head, 0);
assert_eq!(tail.to_debug_string(), "[1, 2]");

let (head, tail) = (&Rational::from_signeds(355, 113)).continued_fraction();
let tail = tail.collect_vec();
assert_eq!(head, 3);
assert_eq!(tail.to_debug_string(), "[7, 16]");

type CF = RationalContinuedFraction

impl Convergents for Rational

fn convergents(self) -> RationalConvergents

Returns the convergents of a Rational, taking the Rational by value.

The convergents of a number are the sequence of rational numbers whose continued fractions are the prefixes of the number’s continued fraction. The first convergent is the floor of the number. The sequence of convergents is finite iff the number is rational, in which case the last convergent is the number itself. Each convergent is closer to the number than the previous convergent is. The even-indexed convergents are less than or equal to the number, and the odd-indexed ones are greater than or equal to it.

$f(x) = ([a_0; a_1, a_2, \ldots, a_i])_{i=0}^{n}$, where $x = [a_0; a_1, a_2, \ldots, a_n]$ and $a_n \neq 1$.

The output length is $O(n)$, where $n$ is self.significant_bits().

Worst-case complexity per iteration

$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 self.significant_bits().

Examples

extern crate itertools;
extern crate malachite_base;

use itertools::Itertools;
use malachite_base::strings::ToDebugString;
use malachite_q::conversion::traits::Convergents;
use malachite_q::Rational;

assert_eq!(
    Rational::from_signeds(2, 3).convergents().collect_vec().to_debug_string(),
    "[0, 1, 2/3]"
);
assert_eq!(
    Rational::from_signeds(355, 113).convergents().collect_vec().to_debug_string(),
    "[3, 22/7, 355/113]",
);

type C = RationalConvergents

impl<'a> Convergents for &'a Rational

fn convergents(self) -> RationalConvergents

Returns the convergents of a Rational, taking the Rational by reference.

The convergents of a number are the sequence of rational numbers whose continued fractions are the prefixes of the number’s continued fraction. The first convergent is the floor of the number. The sequence of convergents is finite iff the number is rational, in which case the last convergent is the number itself. Each convergent is closer to the number than the previous convergent is. The even-indexed convergents are less than or equal to the number, and the odd-indexed ones are greater than or equal to it.

$f(x) = ([a_0; a_1, a_2, \ldots, a_i])_{i=0}^{n}$, where $x = [a_0; a_1, a_2, \ldots, a_n]$ and $a_n \neq 1$.

The output length is $O(n)$, where $n$ is self.significant_bits().

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 self.significant_bits().

Examples

extern crate itertools;
extern crate malachite_base;

use itertools::Itertools;
use malachite_base::strings::ToDebugString;
use malachite_q::conversion::traits::Convergents;
use malachite_q::Rational;

assert_eq!(
    (&Rational::from_signeds(2, 3)).convergents().collect_vec().to_debug_string(),
    "[0, 1, 2/3]"
);
assert_eq!(
    (&Rational::from_signeds(355, 113)).convergents().collect_vec().to_debug_string(),
    "[3, 22/7, 355/113]",
);

type C = RationalConvergents

impl<'a> ConvertibleFrom<&'a Rational> for Integer

fn convertible_from(x: &Rational) -> bool

Determines whether a Rational can be converted to an Integer, taking the Rational by reference.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::conversion::traits::ConvertibleFrom;
use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert_eq!(Integer::convertible_from(&Rational::from(123)), true);
assert_eq!(Integer::convertible_from(&Rational::from(-123)), true);
assert_eq!(Integer::convertible_from(&Rational::from_signeds(22, 7)), false);

impl<'a> ConvertibleFrom<&'a Rational> for Natural

fn convertible_from(x: &Rational) -> bool

Determines whether a Rational can be converted to a Natural (when the Rational is non-negative and an integer), taking the Rational by reference.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::conversion::traits::ConvertibleFrom;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(Natural::convertible_from(&Rational::from(123)), true);
assert_eq!(Natural::convertible_from(&Rational::from(-123)), false);
assert_eq!(Natural::convertible_from(&Rational::from_signeds(22, 7)), false);

impl<'a> ConvertibleFrom<&'a Rational> for i8

fn convertible_from(value: &Rational) -> bool

Determines whether a Rational can be converted to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Rational> for i16

fn convertible_from(value: &Rational) -> bool

Determines whether a Rational can be converted to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Rational> for i32

fn convertible_from(value: &Rational) -> bool

Determines whether a Rational can be converted to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Rational> for i64

fn convertible_from(value: &Rational) -> bool

Determines whether a Rational can be converted to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Rational> for i128

fn convertible_from(value: &Rational) -> bool

Determines whether a Rational can be converted to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Rational> for isize

fn convertible_from(value: &Rational) -> bool

Determines whether a Rational can be converted to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Rational> for f32

fn convertible_from(value: &'a Rational) -> bool

Determines whether a Rational can be exactly converted to a primitive float, taking the Rational by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

See here.

impl<'a> ConvertibleFrom<&'a Rational> for f64

fn convertible_from(value: &'a Rational) -> bool

Determines whether a Rational can be exactly converted to a primitive float, taking the Rational by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

See here.

impl<'a> ConvertibleFrom<&'a Rational> for u8

fn convertible_from(value: &Rational) -> bool

Determines whether a Rational can be converted to an unsigned primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Rational> for u16

fn convertible_from(value: &Rational) -> bool

Determines whether a Rational can be converted to an unsigned primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Rational> for u32

fn convertible_from(value: &Rational) -> bool

Determines whether a Rational can be converted to an unsigned primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Rational> for u64

fn convertible_from(value: &Rational) -> bool

Determines whether a Rational can be converted to an unsigned primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Rational> for u128

fn convertible_from(value: &Rational) -> bool

Determines whether a Rational can be converted to an unsigned primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> ConvertibleFrom<&'a Rational> for usize

fn convertible_from(value: &Rational) -> bool

Determines whether a Rational can be converted to an unsigned primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl ConvertibleFrom<Rational> for f32

fn convertible_from(value: Rational) -> bool

Determines whether a Rational can be exactly converted to a primitive float, taking the Rational by value.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

See here.

impl ConvertibleFrom<Rational> for f64

fn convertible_from(value: Rational) -> bool

Determines whether a Rational can be exactly converted to a primitive float, taking the Rational by value.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

See here.

impl Debug for Rational

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

Converts a Rational to a String.

This is the same implementation as for Display.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

assert_eq!(Rational::ZERO.to_debug_string(), "0");
assert_eq!(Rational::from(123).to_debug_string(), "123");
assert_eq!(Rational::from_signeds(22, 7).to_debug_string(), "22/7");

impl Default for Rational

fn default() -> Rational

The default value of a Rational, 0.

impl Display for Rational

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

Converts a Rational to a String.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(Rational::ZERO.to_string(), "0");
assert_eq!(Rational::from(123).to_string(), "123");
assert_eq!(Rational::from_str("22/7").unwrap().to_string(), "22/7");

impl<'a> Div<&'a Rational> for Rational

fn div(self, other: &'a Rational) -> Rational

Divides a Rational by another Rational, taking the first by value and the second by reference.

$$ f(x, y) = \frac{x}{y}. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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 the second Rational is zero.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Two;
use malachite_q::Rational;

assert_eq!(Rational::TWO / &Rational::TWO, 1);
assert_eq!(
    (Rational::from_signeds(22, 7) / &Rational::from_signeds(99, 100)).to_string(),
    "200/63"
);

type Output = Rational

The resulting type after applying the / operator.

impl<'a, 'b> Div<&'a Rational> for &'b Rational

fn div(self, other: &'a Rational) -> Rational

Divides a Rational by another Rational, taking both by reference.

$$ f(x, y) = \frac{x}{y}. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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 the second Rational is zero.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Two;
use malachite_q::Rational;

assert_eq!(&Rational::TWO / &Rational::TWO, 1);
assert_eq!(
    (&Rational::from_signeds(22, 7) / &Rational::from_signeds(99, 100)).to_string(),
    "200/63"
);

type Output = Rational

The resulting type after applying the / operator.

impl Div<Rational> for Rational

fn div(self, other: Rational) -> Rational

Divides a Rational by another Rational, taking both by value.

$$ f(x, y) = \frac{x}{y}. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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 the second Rational is zero.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Two;
use malachite_q::Rational;

assert_eq!(Rational::TWO / Rational::TWO, 1);
assert_eq!(
    (Rational::from_signeds(22, 7) / Rational::from_signeds(99, 100)).to_string(),
    "200/63"
);

type Output = Rational

The resulting type after applying the / operator.

impl<'a> Div<Rational> for &'a Rational

fn div(self, other: Rational) -> Rational

Divides a Rational by another Rational, taking the first by reference and the second by value.

$$ f(x, y) = \frac{x}{y}. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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 the second Rational is zero.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Two;
use malachite_q::Rational;

assert_eq!(&Rational::TWO / Rational::TWO, 1);
assert_eq!(
    (&Rational::from_signeds(22, 7) / Rational::from_signeds(99, 100)).to_string(),
    "200/63"
);

type Output = Rational

The resulting type after applying the / operator.

impl<'a> DivAssign<&'a Rational> for Rational

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

Divides a Rational by a Rational in place, taking the Rational on the right-hand side by reference.

$$ x \gets \frac{x}{y}. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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 the second Rational is zero.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Two;
use malachite_q::Rational;

let mut x = Rational::TWO;
x /= &Rational::TWO;
assert_eq!(x, 1);

let mut x = Rational::from_signeds(22, 7);
x /= &Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "200/63");

impl DivAssign<Rational> for Rational

fn div_assign(&mut self, other: Rational)

Divides a Rational by a Rational in place, taking the Rational on the right-hand side by value.

$$ x \gets \frac{x}{y}. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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 the second Rational is zero.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Two;
use malachite_q::Rational;

let mut x = Rational::TWO;
x /= Rational::TWO;
assert_eq!(x, 1);

let mut x = Rational::from_signeds(22, 7);
x /= Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "200/63");

impl Floor for Rational

fn floor(self) -> Integer

Finds the floor of a Rational, taking the Rational by value.

$$ f(x) = \lfloor x \rfloor. $$

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

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Floor;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!(Rational::ZERO.floor(), 0);
assert_eq!(Rational::from_signeds(22, 7).floor(), 3);
assert_eq!(Rational::from_signeds(-22, 7).floor(), -4);

type Output = Integer

impl<'a> Floor for &'a Rational

fn floor(self) -> Integer

Finds the floor of a Rational, taking the Rational by reference.

$$ f(x) = \lfloor x \rfloor. $$

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

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Floor;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!((&Rational::ZERO).floor(), 0);
assert_eq!((&Rational::from_signeds(22, 7)).floor(), 3);
assert_eq!((&Rational::from_signeds(-22, 7)).floor(), -4);

type Output = Integer

impl FloorAssign for Rational

fn floor_assign(&mut self)

Replaces a Rational with its floor.

$$ x \gets \lfloor x \rfloor. $$

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

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::FloorAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
use std::str::FromStr;

let mut x = Rational::ZERO;
x.floor_assign();
assert_eq!(x, 0);

let mut x = Rational::from_signeds(22, 7);
x.floor_assign();
assert_eq!(x, 3);

let mut x = Rational::from_signeds(-22, 7);
x.floor_assign();
assert_eq!(x, -4);

impl<'a, 'b> FloorLogBase<&'b Rational> for &'a Rational

fn floor_log_base(self, base: &Rational) -> i64

Returns the floor of the base-$b$ logarithm of a positive Rational.

Note that this function may be slow if the base is very close to 1.

$f(x, b) = \lfloor\log_b x\rfloor$.

Worst-case complexity

$T(n, m) = O(nm \log (nm) \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

where $T$ is time, $M$ is additional memory, $n$ is base.significant_bits(), and $m$ is $|\log_b x|$, where $b$ is base and $x$ is x.

Panics

Panics if self less than or equal to zero or base is 1.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::FloorLogBase;
use malachite_q::Rational;

assert_eq!(Rational::from(80u32).floor_log_base(&Rational::from(3u32)), 3);
assert_eq!(Rational::from(81u32).floor_log_base(&Rational::from(3u32)), 4);
assert_eq!(Rational::from(82u32).floor_log_base(&Rational::from(3u32)), 4);
assert_eq!(Rational::from(4294967296u64).floor_log_base(&Rational::from(10u32)), 9);
assert_eq!(
    Rational::from_signeds(936851431250i64, 1397).floor_log_base(&Rational::from(10u32)),
    8
);
assert_eq!(
    Rational::from_signeds(5153632, 16807).floor_log_base(&Rational::from_signeds(22, 7)),
    5
);

type Output = i64

impl<'a> FloorLogBase2 for &'a Rational

fn floor_log_base_2(self) -> i64

Returns the floor of the base-2 logarithm of a positive Rational.

$f(x) = \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 less than or equal to zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::FloorLogBase2;
use malachite_q::Rational;

assert_eq!(Rational::from(3u32).floor_log_base_2(), 1);
assert_eq!(Rational::from_signeds(1, 3).floor_log_base_2(), -2);
assert_eq!(Rational::from_signeds(1, 4).floor_log_base_2(), -2);
assert_eq!(Rational::from_signeds(1, 5).floor_log_base_2(), -3);

type Output = i64

impl<'a> FloorLogBasePowerOf2<i64> for &'a Rational

fn floor_log_base_power_of_2(self, pow: i64) -> i64

Returns the floor of the base-$2^k$ logarithm of a positive Rational.

$k$ may be negative.

$f(x, k) = \lfloor\log_{2^k} 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 less than or equal to 0 or pow is 0.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::FloorLogBasePowerOf2;
use malachite_q::Rational;

assert_eq!(Rational::from(100).floor_log_base_power_of_2(2), 3);
assert_eq!(Rational::from(4294967296u64).floor_log_base_power_of_2(8), 4);

// 4^(-2) < 1/10 < 4^(-1)
assert_eq!(Rational::from_signeds(1, 10).floor_log_base_power_of_2(2), -2);
// (1/4)^2 < 1/10 < (1/4)^1
assert_eq!(Rational::from_signeds(1, 10).floor_log_base_power_of_2(-2), 1);

type Output = i64

impl<'a> From<&'a Integer> for Rational

fn from(value: &'a Integer) -> Rational

Converts an Integer to a Rational, taking the Integer by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_nz;

use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert_eq!(Rational::from(&Integer::from(123)), 123);
assert_eq!(Rational::from(&Integer::from(-123)), -123);

impl<'a> From<&'a Natural> for Rational

fn from(value: &'a Natural) -> Rational

Converts a Natural to a Rational, taking the Natural by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_nz;

use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(Rational::from(&Natural::from(123u32)), 123);

impl<'a> From<&'a Rational> for f32

fn from(value: &'a Rational) -> f32

Converts a Rational to the nearest primitive float, taking the Rational by reference. If there are two nearest floats, the one whose least-significant bit is zero is chosen.

If the input is larger than the maximum finite value representable by the floating-point type, the result is the maximum finite float. If the input is smaller than the minimum (most negative) finite value, the result is the minimum finite float.

If the absolute value of the Rational is half of the smallest positive float or smaller, zero is returned. The sign of the zero is the same as the sign of the Rational.

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 value.significant_bits().

Examples

See here.

impl<'a> From<&'a Rational> for f64

fn from(value: &'a Rational) -> f64

Converts a Rational to the nearest primitive float, taking the Rational by reference. If there are two nearest floats, the one whose least-significant bit is zero is chosen.

If the input is larger than the maximum finite value representable by the floating-point type, the result is the maximum finite float. If the input is smaller than the minimum (most negative) finite value, the result is the minimum finite float.

If the absolute value of the Rational is half of the smallest positive float or smaller, zero is returned. The sign of the zero is the same as the sign of the Rational.

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 value.significant_bits().

Examples

See here.

impl From<Integer> for Rational

fn from(value: Integer) -> Rational

Converts an Integer to a Rational, taking the Integer by value.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_nz;

use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert_eq!(Rational::from(Integer::from(123)), 123);
assert_eq!(Rational::from(Integer::from(-123)), -123);

impl From<Natural> for Rational

fn from(value: Natural) -> Rational

Converts a Natural to a Rational, taking the Natural by value.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_nz;

use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(Rational::from(Natural::from(123u32)), 123);

impl From<Rational> for f32

fn from(value: Rational) -> f32

Converts a Rational to the nearest primitive float, taking the Rational by value. If there are two nearest floats, the one whose least-significant bit is zero is chosen.

If the input is larger than the maximum finite value representable by the floating-point type, the result is the maximum finite float. If the input is smaller than the minimum (most negative) finite value, the result is the minimum finite float.

If the absolute value of the Rational is half of the smallest positive float or smaller, zero is returned. The sign of the zero is the same as the sign of the Rational.

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 value.significant_bits().

Examples

See here.

impl From<Rational> for f64

fn from(value: Rational) -> f64

Converts a Rational to the nearest primitive float, taking the Rational by value. If there are two nearest floats, the one whose least-significant bit is zero is chosen.

If the input is larger than the maximum finite value representable by the floating-point type, the result is the maximum finite float. If the input is smaller than the minimum (most negative) finite value, the result is the minimum finite float.

If the absolute value of the Rational is half of the smallest positive float or smaller, zero is returned. The sign of the zero is the same as the sign of the Rational.

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 value.significant_bits().

Examples

See here.

impl From<f32> for Rational

fn from(value: f32) -> Rational

Converts a primitive float to the equivalent Rational. The floating point value cannot be NaN or infinite.

This conversion is literal. For example, Rational::from(0.1f32) evaluates to $13421773/134217728$. If you want $1/10$ instead, use from_float_simplest; that function returns the simplest Rational that rounds to the specified float.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is value.sci_exponent().abs().

Panics

Panics if value is NaN or infinite.

Examples

See here.

impl From<f64> for Rational

fn from(value: f64) -> Rational

Converts a primitive float to the equivalent Rational. The floating point value cannot be NaN or infinite.

This conversion is literal. For example, Rational::from(0.1f32) evaluates to $13421773/134217728$. If you want $1/10$ instead, use from_float_simplest; that function returns the simplest Rational that rounds to the specified float.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is value.sci_exponent().abs().

Panics

Panics if value is NaN or infinite.

Examples

See here.

impl From<i128> for Rational

fn from(i: i128) -> Rational

Converts a signed primitive integer to a Rational.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<i16> for Rational

fn from(i: i16) -> Rational

Converts a signed primitive integer to a Rational.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<i32> for Rational

fn from(i: i32) -> Rational

Converts a signed primitive integer to a Rational.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<i64> for Rational

fn from(i: i64) -> Rational

Converts a signed primitive integer to a Rational.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<i8> for Rational

fn from(i: i8) -> Rational

Converts a signed primitive integer to a Rational.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<isize> for Rational

fn from(i: isize) -> Rational

Converts a signed primitive integer to a Rational.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<u128> for Rational

fn from(u: u128) -> Rational

Converts an unsigned primitive integer to a Rational.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<u16> for Rational

fn from(u: u16) -> Rational

Converts an unsigned primitive integer to a Rational.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<u32> for Rational

fn from(u: u32) -> Rational

Converts an unsigned primitive integer to a Rational.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<u64> for Rational

fn from(u: u64) -> Rational

Converts an unsigned primitive integer to a Rational.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<u8> for Rational

fn from(u: u8) -> Rational

Converts an unsigned primitive integer to a Rational.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<usize> for Rational

fn from(u: usize) -> Rational

Converts an unsigned primitive integer to a Rational.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl FromSciString for Rational

fn from_sci_string_with_options(
    s: &str,
    options: FromSciStringOptions
) -> Option<Rational>

Converts a string, possibly in scientfic notation, to a Rational.

Use FromSciStringOptions to specify the base (from 2 to 36, inclusive). The rounding mode option is ignored.

If the base is greater than 10, the higher digits are represented by the letters 'a' through 'z' or 'A' through 'Z'; the case doesn’t matter and doesn’t need to be consistent.

Exponents are allowed, and are indicated using the character 'e' or 'E'. If the base is 15 or greater, an ambiguity arises where it may not be clear whether 'e' is a digit or an exponent indicator. To resolve this ambiguity, always use a '+' or '-' sign after the exponent indicator when the base is 15 or greater.

The exponent itself is always parsed using base 10.

Decimal (or other-base) points are allowed.

If the string is unparseable, None is returned.

This function is very literal; given "0.333", it will return $333/1000$ rather than $1/3$. If you’d prefer that it return $1/3$, consider using from_sci_string_simplest instead. However, that function has its quirks too: given "0.1", it will not return $1/10$ (see its documentation for an explanation of this behavior). This function does return $1/10$.

Worst-case complexity

$T(n, m) = O(m^n n \log m (\log n + \log\log m))$

$M(n, m) = O(m^n n \log m)$

where $T$ is time, $M$ is additional memory, $n$ is s.len(), and $m$ is options.base.

Examples

extern crate malachite_base;

use malachite_base::num::conversion::string::options::FromSciStringOptions;
use malachite_base::num::conversion::traits::FromSciString;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;

assert_eq!(Rational::from_sci_string("123").unwrap(), 123);
assert_eq!(Rational::from_sci_string("0.1").unwrap().to_string(), "1/10");
assert_eq!(Rational::from_sci_string("0.10").unwrap().to_string(), "1/10");
assert_eq!(Rational::from_sci_string("0.333").unwrap().to_string(), "333/1000");
assert_eq!(Rational::from_sci_string("1.2e5").unwrap(), 120000);
assert_eq!(Rational::from_sci_string("1.2e-5").unwrap().to_string(), "3/250000");

let mut options = FromSciStringOptions::default();
options.set_base(16);
assert_eq!(Rational::from_sci_string_with_options("ff", options).unwrap(), 255);
assert_eq!(Rational::from_sci_string_with_options("ffE+5", options).unwrap(), 267386880);
assert_eq!(
    Rational::from_sci_string_with_options("ffE-5", options).unwrap().to_string(),
    "255/1048576"
);

fn from_sci_string(s: &str) -> Option<Self>

Converts a &str, possibly in scientific notation, to a number, using the default FromSciStringOptions.

impl FromStr for Rational

fn from_str(s: &str) -> Result<Rational, ()>

Converts an string to a Rational.

If the string does not represent a valid Rational, an Err is returned. The numerator and denominator do not need to be in lowest terms, but the denominator must be nonzero. A negative sign is only allowed at the 0th position of the string.

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is s.len().

Examples

use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(Rational::from_str("123456").unwrap(), 123456);
assert_eq!(Rational::from_str("00123456").unwrap(), 123456);
assert_eq!(Rational::from_str("0").unwrap(), 0);
assert_eq!(Rational::from_str("-123456").unwrap(), -123456);
assert_eq!(Rational::from_str("-00123456").unwrap(), -123456);
assert_eq!(Rational::from_str("-0").unwrap(), 0);
assert_eq!(Rational::from_str("22/7").unwrap().to_string(), "22/7");
assert_eq!(Rational::from_str("01/02").unwrap().to_string(), "1/2");
assert_eq!(Rational::from_str("3/21").unwrap().to_string(), "1/7");
assert_eq!(Rational::from_str("-22/7").unwrap().to_string(), "-22/7");
assert_eq!(Rational::from_str("-01/02").unwrap().to_string(), "-1/2");
assert_eq!(Rational::from_str("-3/21").unwrap().to_string(), "-1/7");

assert!(Rational::from_str("").is_err());
assert!(Rational::from_str("a").is_err());
assert!(Rational::from_str("1/0").is_err());
assert!(Rational::from_str("/1").is_err());
assert!(Rational::from_str("1/").is_err());
assert!(Rational::from_str("--1").is_err());
assert!(Rational::from_str("1/-2").is_err());

type Err = ()

The associated error which can be returned from parsing.

impl Hash for Rational

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'a> IsInteger for &'a Rational

fn is_integer(self) -> bool

Determines whether a Rational is an integer.

$f(x) = x \in \Z$.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::{One, Zero};
use malachite_base::num::conversion::traits::IsInteger;
use malachite_q::Rational;

assert_eq!(Rational::ZERO.is_integer(), true);
assert_eq!(Rational::ONE.is_integer(), true);
assert_eq!(Rational::from(100).is_integer(), true);
assert_eq!(Rational::from_signeds(22, 7).is_integer(), false);

impl IsPowerOf2 for Rational

fn is_power_of_2(&self) -> bool

Determines whether a Rational is an integer power of 2.

$f(x) = (\exists n \in \Z : 2^n = x)$.

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

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::IsPowerOf2;
use malachite_q::Rational;

assert_eq!(Rational::from(0x80).is_power_of_2(), true);
assert_eq!(Rational::from_signeds(1, 8).is_power_of_2(), true);
assert_eq!(Rational::from_signeds(-1, 8).is_power_of_2(), false);
assert_eq!(Rational::from_signeds(22, 7).is_power_of_2(), false);

impl<'a> Mul<&'a Rational> for Rational

fn mul(self, other: &'a Rational) -> Rational

Multiplies two Rationals, taking the first by value and the second by reference.

$$ f(x, y) = xy. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::{OneHalf, Two};
use malachite_q::Rational;

assert_eq!(Rational::ONE_HALF * &Rational::TWO, 1);
assert_eq!(
    (Rational::from_signeds(22, 7) * &Rational::from_signeds(99, 100)).to_string(),
    "1089/350"
);

type Output = Rational

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'a Rational> for &'b Rational

fn mul(self, other: &'a Rational) -> Rational

Multiplies two Rationals, taking both by reference.

$$ f(x, y) = xy. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::{OneHalf, Two};
use malachite_q::Rational;

assert_eq!(&Rational::ONE_HALF * &Rational::TWO, 1);
assert_eq!(
    (&Rational::from_signeds(22, 7) * &Rational::from_signeds(99, 100)).to_string(),
    "1089/350"
);

type Output = Rational

The resulting type after applying the * operator.

impl Mul<Rational> for Rational

fn mul(self, other: Rational) -> Rational

Multiplies two Rationals, taking both by value.

$$ f(x, y) = xy. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::{OneHalf, Two};
use malachite_q::Rational;

assert_eq!(Rational::ONE_HALF * Rational::TWO, 1);
assert_eq!(
    (Rational::from_signeds(22, 7) * Rational::from_signeds(99, 100)).to_string(),
    "1089/350"
);

type Output = Rational

The resulting type after applying the * operator.

impl<'a> Mul<Rational> for &'a Rational

fn mul(self, other: Rational) -> Rational

Multiplies two Rationals, taking the first by reference and the second by value.

$$ f(x, y) = xy. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::{OneHalf, Two};
use malachite_q::Rational;

assert_eq!(&Rational::ONE_HALF * Rational::TWO, 1);
assert_eq!(
    (&Rational::from_signeds(22, 7) * Rational::from_signeds(99, 100)).to_string(),
    "1089/350"
);

type Output = Rational

The resulting type after applying the * operator.

impl<'a> MulAssign<&'a Rational> for Rational

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

Multiplies a Rational by a Rational in place, taking the Rational on the right-hand side by reference.

$$ x \gets xy. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::{OneHalf, Two};
use malachite_q::Rational;

let mut x = Rational::ONE_HALF;
x *= &Rational::TWO;
assert_eq!(x, 1);

let mut x = Rational::from_signeds(22, 7);
x *= &Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "1089/350");

impl MulAssign<Rational> for Rational

fn mul_assign(&mut self, other: Rational)

Multiplies a Rational by a Rational in place, taking the Rational on the right-hand side by value.

$$ x \gets xy. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::{OneHalf, Two};
use malachite_q::Rational;

let mut x = Rational::ONE_HALF;
x *= Rational::TWO;
assert_eq!(x, 1);

let mut x = Rational::from_signeds(22, 7);
x *= Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "1089/350");

impl Named for Rational

const NAME: &'static str = "Rational"

The name of this type, as given by the stringify macro.

See the documentation for impl_named for more details.

impl Neg for Rational

fn neg(self) -> Rational

Negates a Rational, taking it by value.

$$ f(x) = -x. $$

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!(-Rational::ZERO, 0);
assert_eq!((-Rational::from_signeds(22, 7)).to_string(), "-22/7");
assert_eq!((-Rational::from_signeds(-22, 7)).to_string(), "22/7");

type Output = Rational

The resulting type after applying the - operator.

impl<'a> Neg for &'a Rational

fn neg(self) -> Rational

Negates a Rational, taking it by reference.

$$ f(x) = -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

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!(-&Rational::ZERO, 0);
assert_eq!((-&Rational::from_signeds(22, 7)).to_string(), "-22/7");
assert_eq!((-&Rational::from_signeds(-22, 7)).to_string(), "22/7");

type Output = Rational

The resulting type after applying the - operator.

impl NegAssign for Rational

fn neg_assign(&mut self)

Negates a Rational in place.

$$ x \gets -x. $$

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::NegAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

let mut x = Rational::ZERO;
x.neg_assign();
assert_eq!(x, 0);

let mut x = Rational::from_signeds(22, 7);
x.neg_assign();
assert_eq!(x.to_string(), "-22/7");

let mut x = Rational::from_signeds(-22, 7);
x.neg_assign();
assert_eq!(x.to_string(), "22/7");

impl NegativeOne for Rational

The constant -1.

const NEGATIVE_ONE: Rational = Rational { sign: false, numerator: Natural::ONE, denominator: Natural::ONE, }

impl NextPowerOf2 for Rational

fn next_power_of_2(self) -> Rational

Finds the smallest power of 2 greater than or equal to a Rational. The Rational is taken by value.

$f(x) = 2^{\lceil \log_2 x \rceil}$.

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 less than or equal to zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::NextPowerOf2;
use malachite_q::Rational;

assert_eq!(Rational::from(123).next_power_of_2(), 128);
assert_eq!(Rational::from_signeds(1, 10).next_power_of_2().to_string(), "1/8");

type Output = Rational

impl<'a> NextPowerOf2 for &'a Rational

fn next_power_of_2(self) -> Rational

Finds the smallest power of 2 greater than or equal to a Rational. The Rational is taken by reference.

$f(x) = 2^{\lceil \log_2 x \rceil}$.

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 less than or equal to zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::NextPowerOf2;
use malachite_q::Rational;

assert_eq!((&Rational::from(123)).next_power_of_2(), 128);
assert_eq!((&Rational::from_signeds(1, 10)).next_power_of_2().to_string(), "1/8");

type Output = Rational

impl NextPowerOf2Assign for Rational

fn next_power_of_2_assign(&mut self)

Finds the smallest power of 2 greater than or equal to a Rational. The Rational is taken by reference.

$f(x) = 2^{\lceil \log_2 x \rceil}$.

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 less than or equal to zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::NextPowerOf2Assign;
use malachite_q::Rational;
use std::str::FromStr;

let mut x = Rational::from(123);
x.next_power_of_2_assign();
assert_eq!(x, 128);

let mut x = Rational::from_signeds(1, 10);
x.next_power_of_2_assign();
assert_eq!(x.to_string(), "1/8");

impl One for Rational

The constant 1.

const ONE: Rational = Rational { sign: true, numerator: Natural::ONE, denominator: Natural::ONE, }

impl OneHalf for Rational

The constant 1/2.

const ONE_HALF: Rational = Rational { sign: true, numerator: Natural::ONE, denominator: Natural::TWO, }

impl Ord for Rational

fn cmp(&self, other: &Rational) -> Ordering

Compares two Rationals.

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

extern crate malachite_base;

use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
use std::str::FromStr;

assert!(Rational::from_str("2/3").unwrap() > Rational::ONE_HALF);
assert!(Rational::from_str("-2/3").unwrap() < Rational::ONE_HALF);

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl OrdAbs for Rational

fn cmp_abs(&self, other: &Rational) -> Ordering

Compares the absolute values of two Rationals.

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

extern crate malachite_base;

use malachite_base::num::basic::traits::OneHalf;
use malachite_base::num::comparison::traits::OrdAbs;
use malachite_q::Rational;
use std::cmp::Ordering;
use std::str::FromStr;

assert_eq!(
    Rational::from_str("2/3").unwrap().cmp_abs(&Rational::ONE_HALF),
    Ordering::Greater
);
assert_eq!(
    Rational::from_str("-2/3").unwrap().cmp_abs(&Rational::ONE_HALF),
    Ordering::Greater
);

impl PartialEq<Integer> for Rational

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

Determines whether a Rational is equal to an Integer.

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

extern crate malachite_nz;

use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert!(Rational::from(-123) == Integer::from(-123));
assert!(Rational::from_signeds(22, 7) != Integer::from(5));

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

This method tests for !=.

impl PartialEq<Natural> for Rational

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

Determines whether a Rational is equal to a Natural.

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

extern crate malachite_nz;

use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert!(Rational::from(123) == Natural::from(123u32));
assert!(Rational::from_signeds(22, 7) != Natural::from(5u32));

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

This method tests for !=.

impl PartialEq<Rational> for Rational

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialEq<Rational> for Integer

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

Determines whether an Integer is equal to a Rational.

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

extern crate malachite_nz;

use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert!(Integer::from(-123) == Rational::from(-123));
assert!(Integer::from(5) != Rational::from_signeds(22, 7));

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

This method tests for !=.

impl PartialEq<Rational> for usize

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

Determines whether an unsigned primitive integer is equal to a Rational.

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 !=.

impl PartialEq<Rational> for i8

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

Determines whether a signed primitive integer is equal to a Rational.

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 !=.

impl PartialEq<Rational> for i16

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

Determines whether a signed primitive integer is equal to a Rational.

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 !=.

impl PartialEq<Rational> for i32

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

Determines whether a signed primitive integer is equal to a Rational.

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 !=.

impl PartialEq<Rational> for i64

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

Determines whether a signed primitive integer is equal to a Rational.

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 !=.

impl PartialEq<Rational> for i128

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

Determines whether a signed primitive integer is equal to a Rational.

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 !=.

impl PartialEq<Rational> for isize

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

Determines whether a signed primitive integer is equal to a Rational.

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 !=.

impl PartialEq<Rational> for Natural

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

Determines whether a Natural is equal to a Rational.

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

extern crate malachite_nz;

use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert!(Natural::from(123u32) == Rational::from(123));
assert!(Natural::from(5u32) != Rational::from_signeds(22, 7));

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

This method tests for !=.

impl PartialEq<Rational> for f32

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

Determines whether a primitive float is equal to a Rational.

Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

Examples

See here.

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

This method tests for !=.

impl PartialEq<Rational> for f64

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

Determines whether a primitive float is equal to a Rational.

Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

Examples

See here.

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

This method tests for !=.

impl PartialEq<Rational> for u8

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

Determines whether an unsigned primitive integer is equal to a Rational.

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 !=.

impl PartialEq<Rational> for u16

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

Determines whether an unsigned primitive integer is equal to a Rational.

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 !=.

impl PartialEq<Rational> for u32

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

Determines whether an unsigned primitive integer is equal to a Rational.

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 !=.

impl PartialEq<Rational> for u64

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

Determines whether an unsigned primitive integer is equal to a Rational.

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 !=.

impl PartialEq<Rational> for u128

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

Determines whether an unsigned primitive integer is equal to a Rational.

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 !=.

impl PartialEq<f32> for Rational

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

Determines whether a Rational is equal to a primitive float.

Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

Examples

See here.

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

This method tests for !=.

impl PartialEq<f64> for Rational

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

Determines whether a Rational is equal to a primitive float.

Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

Examples

See here.

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

This method tests for !=.

impl PartialEq<i128> for Rational

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

Determines whether a Rational is equal to a signed primitive integer.

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 !=.

impl PartialEq<i16> for Rational

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

Determines whether a Rational is equal to a signed primitive integer.

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 !=.

impl PartialEq<i32> for Rational

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

Determines whether a Rational is equal to a signed primitive integer.

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 !=.

impl PartialEq<i64> for Rational

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

Determines whether a Rational is equal to a signed primitive integer.

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 !=.

impl PartialEq<i8> for Rational

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

Determines whether a Rational is equal to a signed primitive integer.

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 !=.

impl PartialEq<isize> for Rational

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

Determines whether a Rational is equal to a signed primitive integer.

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 !=.

impl PartialEq<u128> for Rational

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

Determines whether a Rational is equal to an unsigned primitive integer.

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 !=.

impl PartialEq<u16> for Rational

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

Determines whether a Rational is equal to an unsigned primitive integer.

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 !=.

impl PartialEq<u32> for Rational

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

Determines whether a Rational is equal to an unsigned primitive integer.

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 !=.

impl PartialEq<u64> for Rational

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

Determines whether a Rational is equal to an unsigned primitive integer.

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 !=.

impl PartialEq<u8> for Rational

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

Determines whether a Rational is equal to an unsigned primitive integer.

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 !=.

impl PartialEq<usize> for Rational

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

Determines whether a Rational is equal to an unsigned primitive integer.

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 !=.

impl PartialOrd<Integer> for Rational

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

Compares a Rational to an Integer.

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

extern crate malachite_nz;

use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert!(Rational::from_signeds(22, 7) > Integer::from(3));
assert!(Rational::from_signeds(22, 7) < Integer::from(4));
assert!(Rational::from_signeds(-22, 7) < Integer::from(-3));
assert!(Rational::from_signeds(-22, 7) > Integer::from(-4));

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 Rational

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

Compares a Rational to a Natural.

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

extern crate malachite_nz;

use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert!(Rational::from_signeds(22, 7) > Natural::from(3u32));
assert!(Rational::from_signeds(22, 7) < Natural::from(4u32));

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 Rational

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

Compares two Rationals.

See the documentation for the Ord implementation.

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 Integer

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

Compares an Integer to a Rational.

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

extern crate malachite_nz;

use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert!(Integer::from(3) < Rational::from_signeds(22, 7));
assert!(Integer::from(4) > Rational::from_signeds(22, 7));
assert!(Integer::from(-3) > Rational::from_signeds(-22, 7));
assert!(Integer::from(-4) < Rational::from_signeds(-22, 7));

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 usize

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

Compares an unsigned primitive integer to a Rational.

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 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<Rational> for i8

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

Compares a signed primitive integer to a Rational.

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 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<Rational> for i16

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

Compares a signed primitive integer to a Rational.

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 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<Rational> for i32

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

Compares a signed primitive integer to a Rational.

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 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<Rational> for i64

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

Compares a signed primitive integer to a Rational.

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 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<Rational> for i128

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

Compares a signed primitive integer to a Rational.

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 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<Rational> for isize

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

Compares a signed primitive integer to a Rational.

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 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<Rational> for Natural

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

Compares a Natural to a Rational.

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

extern crate malachite_nz;

use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert!(Natural::from(3u32) < Rational::from_signeds(22, 7));
assert!(Natural::from(4u32) > Rational::from_signeds(22, 7));

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 f32

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

Compares a primitive float to a Rational.

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.sci_exponent(), 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<Rational> for f64

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

Compares a primitive float to a Rational.

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.sci_exponent(), 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<Rational> for u8

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

Compares an unsigned primitive integer to a Rational.

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 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<Rational> for u16

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

Compares an unsigned primitive integer to a Rational.

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 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<Rational> for u32

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

Compares an unsigned primitive integer to a Rational.

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 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<Rational> for u64

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

Compares an unsigned primitive integer to a Rational.

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 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<Rational> for u128

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

Compares an unsigned primitive integer to a Rational.

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 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<f32> for Rational

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

Compares a Rational to a primitive float.

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.sci_exponent()).

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 Rational

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

Compares a Rational to a primitive float.

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.sci_exponent()).

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 Rational

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

Compares a Rational to a signed primitive integer.

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 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 Rational

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

Compares a Rational to a signed primitive integer.

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 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 Rational

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

Compares a Rational to a signed primitive integer.

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 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 Rational

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

Compares a Rational to a signed primitive integer.

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 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 Rational

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

Compares a Rational to a signed primitive integer.

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 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 Rational

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

Compares a Rational to a signed primitive integer.

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 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 Rational

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

Compares a Rational to an unsigned primitive integer.

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 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 Rational

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

Compares a Rational to an unsigned primitive integer.

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 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 Rational

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

Compares a Rational to an unsigned primitive integer.

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 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 Rational

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

Compares a Rational to an unsigned primitive integer.

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 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 Rational

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

Compares a Rational to an unsigned primitive integer.

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 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 Rational

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

Compares a Rational to an unsigned primitive integer.

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 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 PartialOrdAbs<Integer> for Rational

fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>

Compares the absolute values of a Rational and an Integer.

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

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
use std::cmp::Ordering;

assert_eq!(
    Rational::from_signeds(22, 7).partial_cmp_abs(&Integer::from(3)),
    Some(Ordering::Greater)
);
assert_eq!(
    Rational::from_signeds(-22, 7).partial_cmp_abs(&Integer::from(-3)),
    Some(Ordering::Greater)
);

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 Rational

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares the absolute values of a Rational and a Natural.

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

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::cmp::Ordering;

assert_eq!(
    Rational::from_signeds(22, 7).partial_cmp_abs(&Natural::from(3u32)),
    Some(Ordering::Greater)
);
assert_eq!(
    Rational::from_signeds(-22, 7).partial_cmp_abs(&Natural::from(3u32)),
    Some(Ordering::Greater)
);

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 Rational

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of two Rationals.

See the documentation for the OrdAbs implementation.

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 Integer

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of an Integer and a Rational.

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

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
use std::cmp::Ordering;

assert_eq!(
    Integer::from(3).partial_cmp_abs(&Rational::from_signeds(22, 7)),
    Some(Ordering::Less)
);
assert_eq!(
    Integer::from(-3).partial_cmp_abs(&Rational::from_signeds(-22, 7)),
    Some(Ordering::Less)
);

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 usize

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of an unsigned primitive integer and a Rational.

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 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<Rational> for i8

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of a signed primitive integer and a Rational.

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 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<Rational> for i16

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of a signed primitive integer and a Rational.

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 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<Rational> for i32

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of a signed primitive integer and a Rational.

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 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<Rational> for i64

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of a signed primitive integer and a Rational.

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 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<Rational> for i128

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of a signed primitive integer and a Rational.

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 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<Rational> for isize

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of a signed primitive integer and a Rational.

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 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<Rational> for Natural

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of a Natural and a Rational.

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

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::cmp::Ordering;

assert_eq!(
    Natural::from(3u32).partial_cmp_abs(&Rational::from_signeds(22, 7)),
    Some(Ordering::Less)
);
assert_eq!(
    Natural::from(3u32).partial_cmp_abs(&Rational::from_signeds(-22, 7)),
    Some(Ordering::Less)
);

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 f32

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of a primitive float and a Rational.

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.sci_exponent(), 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<Rational> for f64

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of a primitive float and a Rational.

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.sci_exponent(), 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<Rational> for u8

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of an unsigned primitive integer and a Rational.

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 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<Rational> for u16

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of an unsigned primitive integer and a Rational.

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 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<Rational> for u32

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of an unsigned primitive integer and a Rational.

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 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<Rational> for u64

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of an unsigned primitive integer and a Rational.

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 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<Rational> for u128

fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of an unsigned primitive integer and a Rational.

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 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<f32> for Rational

fn partial_cmp_abs(&self, other: &f32) -> Option<Ordering>

Compares the absolute values of a Rational and a primitive float.

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.sci_exponent()).

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 Rational

fn partial_cmp_abs(&self, other: &f64) -> Option<Ordering>

Compares the absolute values of a Rational and a primitive float.

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.sci_exponent()).

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 Rational

fn partial_cmp_abs(&self, other: &i128) -> Option<Ordering>

Compares the absolute values of a Rational and a signed primitive integer.

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 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 Rational

fn partial_cmp_abs(&self, other: &i16) -> Option<Ordering>

Compares the absolute values of a Rational and a signed primitive integer.

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 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 Rational

fn partial_cmp_abs(&self, other: &i32) -> Option<Ordering>

Compares the absolute values of a Rational and a signed primitive integer.

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 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 Rational

fn partial_cmp_abs(&self, other: &i64) -> Option<Ordering>

Compares the absolute values of a Rational and a signed primitive integer.

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 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 Rational

fn partial_cmp_abs(&self, other: &i8) -> Option<Ordering>

Compares the absolute values of a Rational and a signed primitive integer.

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 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 Rational

fn partial_cmp_abs(&self, other: &isize) -> Option<Ordering>

Compares the absolute values of a Rational and a signed primitive integer.

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 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 Rational

fn partial_cmp_abs(&self, other: &u128) -> Option<Ordering>

Compares the absolute values of a Rational and an unsigned primitive integer.

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 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 Rational

fn partial_cmp_abs(&self, other: &u16) -> Option<Ordering>

Compares the absolute values of a Rational and an unsigned primitive integer.

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 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 Rational

fn partial_cmp_abs(&self, other: &u32) -> Option<Ordering>

Compares the absolute values of a Rational and an unsigned primitive integer.

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 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 Rational

fn partial_cmp_abs(&self, other: &u64) -> Option<Ordering>

Compares the absolute values of a Rational and an unsigned primitive integer.

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 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 Rational

fn partial_cmp_abs(&self, other: &u8) -> Option<Ordering>

Compares the absolute values of a Rational and an unsigned primitive integer.

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 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 Rational

fn partial_cmp_abs(&self, other: &usize) -> Option<Ordering>

Compares the absolute values of a Rational and an unsigned primitive integer.

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 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 Pow<i64> for Rational

fn pow(self, exp: i64) -> Rational

Raises a Rational to a power, taking the Rational by value.

$f(x, n) = x^n$.

Worst-case complexity

$T(n, m) = O(nm \log (nm) \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

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

Panics

Panics if self is zero and exp is negative.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!(Rational::from_signeds(22, 7).pow(3i64).to_string(), "10648/343");
assert_eq!(Rational::from_signeds(-22, 7).pow(3i64).to_string(), "-10648/343");
assert_eq!(Rational::from_signeds(-22, 7).pow(4i64).to_string(), "234256/2401");
assert_eq!(Rational::from_signeds(22, 7).pow(-3i64).to_string(), "343/10648");
assert_eq!(Rational::from_signeds(-22, 7).pow(-3i64).to_string(), "-343/10648");
assert_eq!(Rational::from_signeds(-22, 7).pow(-4i64).to_string(), "2401/234256");

type Output = Rational

impl<'a> Pow<i64> for &'a Rational

fn pow(self, exp: i64) -> Rational

Raises a Rational to a power, taking the Rational by reference.

$f(x, n) = x^n$.

Worst-case complexity

$T(n, m) = O(nm \log (nm) \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

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

Panics

Panics if self is zero and exp is negative.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!((&Rational::from_signeds(22, 7)).pow(3i64).to_string(), "10648/343");
assert_eq!((&Rational::from_signeds(-22, 7)).pow(3i64).to_string(), "-10648/343");
assert_eq!((&Rational::from_signeds(-22, 7)).pow(4i64).to_string(), "234256/2401");
assert_eq!((&Rational::from_signeds(22, 7)).pow(-3i64).to_string(), "343/10648");
assert_eq!((&Rational::from_signeds(-22, 7)).pow(-3i64).to_string(), "-343/10648");
assert_eq!((&Rational::from_signeds(-22, 7)).pow(-4i64).to_string(), "2401/234256");

type Output = Rational

impl Pow<u64> for Rational

fn pow(self, exp: u64) -> Rational

Raises a Rational to a power, taking the Rational by value.

$f(x, n) = x^n$.

Worst-case complexity

$T(n, m) = O(nm \log (nm) \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!(Rational::from_signeds(22, 7).pow(3u64).to_string(), "10648/343");
assert_eq!(Rational::from_signeds(-22, 7).pow(3u64).to_string(), "-10648/343");
assert_eq!(Rational::from_signeds(-22, 7).pow(4u64).to_string(), "234256/2401");

type Output = Rational

impl<'a> Pow<u64> for &'a Rational

fn pow(self, exp: u64) -> Rational

Raises a Rational to a power, taking the Rational by reference.

$f(x, n) = x^n$.

Worst-case complexity

$T(n, m) = O(nm \log (nm) \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!((&Rational::from_signeds(22, 7)).pow(3u64).to_string(), "10648/343");
assert_eq!((&Rational::from_signeds(-22, 7)).pow(3u64).to_string(), "-10648/343");
assert_eq!((&Rational::from_signeds(-22, 7)).pow(4u64).to_string(), "234256/2401");

type Output = Rational

impl PowAssign<i64> for Rational

fn pow_assign(&mut self, exp: i64)

Raises a Rational to a power in place.

$x \gets x^n$.

Worst-case complexity

$T(n, m) = O(nm \log (nm) \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

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

Panics

Panics if self is zero and exp is negative.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::PowAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

let mut x = Rational::from_signeds(22, 7);
x.pow_assign(3i64);
assert_eq!(x.to_string(), "10648/343");

let mut x = Rational::from_signeds(-22, 7);
x.pow_assign(3i64);
assert_eq!(x.to_string(), "-10648/343");

let mut x = Rational::from_signeds(22, 7);
x.pow_assign(4i64);
assert_eq!(x.to_string(), "234256/2401");

let mut x = Rational::from_signeds(22, 7);
x.pow_assign(-3i64);
assert_eq!(x.to_string(), "343/10648");

let mut x = Rational::from_signeds(-22, 7);
x.pow_assign(-3i64);
assert_eq!(x.to_string(), "-343/10648");

let mut x = Rational::from_signeds(22, 7);
x.pow_assign(-4i64);
assert_eq!(x.to_string(), "2401/234256");

impl PowAssign<u64> for Rational

fn pow_assign(&mut self, exp: u64)

Raises a Rational to a power in place.

$x \gets x^n$.

Worst-case complexity

$T(n, m) = O(nm \log (nm) \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::PowAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

let mut x = Rational::from_signeds(22, 7);
x.pow_assign(3u64);
assert_eq!(x.to_string(), "10648/343");

let mut x = Rational::from_signeds(-22, 7);
x.pow_assign(3u64);
assert_eq!(x.to_string(), "-10648/343");

let mut x = Rational::from_signeds(22, 7);
x.pow_assign(4u64);
assert_eq!(x.to_string(), "234256/2401");

impl PowerOf2<i64> for Rational

fn power_of_2(pow: i64) -> Rational

Raises 2 to an integer power.

$f(k) = 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.abs().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_q::Rational;

assert_eq!(Rational::power_of_2(0i64), 1);
assert_eq!(Rational::power_of_2(3i64), 8);
assert_eq!(Rational::power_of_2(100i64).to_string(), "1267650600228229401496703205376");
assert_eq!(Rational::power_of_2(-3i64).to_string(), "1/8");
assert_eq!(Rational::power_of_2(-100i64).to_string(), "1/1267650600228229401496703205376");

impl PowerOf2<u64> for Rational

fn power_of_2(pow: u64) -> Rational

Raises 2 to an integer power.

$f(k) = 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_q::Rational;

assert_eq!(Rational::power_of_2(0u64), 1);
assert_eq!(Rational::power_of_2(3u64), 8);
assert_eq!(Rational::power_of_2(100u64).to_string(), "1267650600228229401496703205376");

impl Reciprocal for Rational

fn reciprocal(self) -> Rational

Reciprocates a Rational, taking it by value.

$$ f(x) = 1/x. $$

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Reciprocal;
use malachite_q::Rational;

assert_eq!(Rational::from_signeds(22, 7).reciprocal().to_string(), "7/22");
assert_eq!(Rational::from_signeds(7, 22).reciprocal().to_string(), "22/7");

type Output = Rational

impl<'a> Reciprocal for &'a Rational

fn reciprocal(self) -> Rational

Reciprocates a Rational, taking it by reference.

$$ f(x) = 1/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

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Reciprocal;
use malachite_q::Rational;

assert_eq!((&Rational::from_signeds(22, 7)).reciprocal().to_string(), "7/22");
assert_eq!((&Rational::from_signeds(7, 22)).reciprocal().to_string(), "22/7");

type Output = Rational

impl ReciprocalAssign for Rational

fn reciprocal_assign(&mut self)

Reciprocates a Rational in place.

$$ x \gets 1/x. $$

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ReciprocalAssign;
use malachite_q::Rational;

let mut x = Rational::from_signeds(22, 7);
x.reciprocal_assign();
assert_eq!(x.to_string(), "7/22");

let mut x = Rational::from_signeds(7, 22);
x.reciprocal_assign();
assert_eq!(x.to_string(), "22/7");

impl<'a> RoundToMultiple<&'a Rational> for Rational

fn round_to_multiple(self, other: &'a Rational, rm: RoundingMode) -> Rational

Rounds a Rational to an integer multiple of another Rational, according to a specified rounding mode. The first Rational is taken by value and the second by reference.

Let $q = \frac{x}{y}$:

$f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = y \lfloor q \rfloor.$

$f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = y \lceil q \rceil.$

$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, y, \mathrm{Exact}) = x$, but panics if $q \notin \Z$.

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 self.significant_bits().

Panics

• If rm is Exact, but self is not a multiple of other.
• If self is nonzero, other is zero, and rm is trying to round away from zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;

assert_eq!(Rational::from(-5).round_to_multiple(&Rational::ZERO, RoundingMode::Down), 0);

let q = Rational::from(std::f64::consts::PI);
let hundredth = Rational::from_signeds(1, 100);
assert_eq!(
    q.clone().round_to_multiple(&hundredth, RoundingMode::Down).to_string(),
    "157/50"
);
assert_eq!(
    q.clone().round_to_multiple(&hundredth, RoundingMode::Floor).to_string(),
    "157/50"
);
assert_eq!(
    q.clone().round_to_multiple(&hundredth, RoundingMode::Up).to_string(),
    "63/20"
);
assert_eq!(
    q.clone().round_to_multiple(&hundredth, RoundingMode::Ceiling).to_string(),
    "63/20"
);
assert_eq!(
    q.clone().round_to_multiple(&hundredth, RoundingMode::Nearest).to_string(),
    "157/50"
);

type Output = Rational

impl<'a, 'b> RoundToMultiple<&'b Rational> for &'a Rational

fn round_to_multiple(self, other: &'b Rational, rm: RoundingMode) -> Rational

Rounds a Rational to an integer multiple of another Rational, according to a specified rounding mode. Both Rationals are taken by reference.

Let $q = \frac{x}{y}$:

$f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = y \lfloor q \rfloor.$

$f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = y \lceil q \rceil.$

$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, y, \mathrm{Exact}) = x$, but panics if $q \notin \Z$.

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 self.significant_bits().

Panics

• If rm is Exact, but self is not a multiple of other.
• If self is nonzero, other is zero, and rm is trying to round away from zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;

assert_eq!(Rational::from(-5).round_to_multiple(Rational::ZERO, RoundingMode::Down), 0);

let q = Rational::from(std::f64::consts::PI);
let hundredth = Rational::from_signeds(1, 100);
assert_eq!((&q).round_to_multiple(&hundredth, RoundingMode::Down).to_string(), "157/50");
assert_eq!((&q).round_to_multiple(&hundredth, RoundingMode::Floor).to_string(), "157/50");
assert_eq!((&q).round_to_multiple(&hundredth, RoundingMode::Up).to_string(), "63/20");
assert_eq!((&q).round_to_multiple(&hundredth, RoundingMode::Ceiling).to_string(), "63/20");
assert_eq!(
    (&q).round_to_multiple(&hundredth, RoundingMode::Nearest).to_string(),
    "157/50"
);

type Output = Rational

impl RoundToMultiple<Rational> for Rational

fn round_to_multiple(self, other: Rational, rm: RoundingMode) -> Rational

Rounds a Rational to an integer multiple of another Rational, according to a specified rounding mode. Both Rationals are taken by value.

Let $q = \frac{x}{y}$:

$f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = y \lfloor q \rfloor.$

$f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = y \lceil q \rceil.$

$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, y, \mathrm{Exact}) = x$, but panics if $q \notin \Z$.

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 self.significant_bits().

Panics

• If rm is Exact, but self is not a multiple of other.
• If self is nonzero, other is zero, and rm is trying to round away from zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;

assert_eq!(Rational::from(-5).round_to_multiple(Rational::ZERO, RoundingMode::Down), 0);

let q = Rational::from(std::f64::consts::PI);
let hundredth = Rational::from_signeds(1, 100);
assert_eq!(
    q.clone().round_to_multiple(hundredth.clone(), RoundingMode::Down).to_string(),
    "157/50"
);
assert_eq!(
    q.clone().round_to_multiple(hundredth.clone(), RoundingMode::Floor).to_string(),
    "157/50"
);
assert_eq!(
    q.clone().round_to_multiple(hundredth.clone(), RoundingMode::Up).to_string(),
    "63/20"
);
assert_eq!(
    q.clone().round_to_multiple(hundredth.clone(), RoundingMode::Ceiling).to_string(),
    "63/20"
);
assert_eq!(
    q.clone().round_to_multiple(hundredth.clone(), RoundingMode::Nearest).to_string(),
    "157/50"
);

type Output = Rational

impl<'a> RoundToMultiple<Rational> for &'a Rational

fn round_to_multiple(self, other: Rational, rm: RoundingMode) -> Rational

Rounds a Rational to an integer multiple of another Rational, according to a specified rounding mode. The first Rational is taken by reference and the second by value.

Let $q = \frac{x}{y}$:

$f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = y \lfloor q \rfloor.$

$f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = y \lceil q \rceil.$

$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, y, \mathrm{Exact}) = x$, but panics if $q \notin \Z$.

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 self.significant_bits().

Panics

• If rm is Exact, but self is not a multiple of other.
• If self is nonzero, other is zero, and rm is trying to round away from zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;

assert_eq!(Rational::from(-5).round_to_multiple(Rational::ZERO, RoundingMode::Down), 0);

let q = Rational::from(std::f64::consts::PI);
let hundredth = Rational::from_signeds(1, 100);
assert_eq!(
    (&q).round_to_multiple(hundredth.clone(), RoundingMode::Down).to_string(),
    "157/50"
);
assert_eq!(
    (&q).round_to_multiple(hundredth.clone(), RoundingMode::Floor).to_string(),
    "157/50"
);
assert_eq!(
    (&q).round_to_multiple(hundredth.clone(), RoundingMode::Up).to_string(),
    "63/20"
);
assert_eq!(
    (&q).round_to_multiple(hundredth.clone(), RoundingMode::Ceiling).to_string(),
    "63/20"
);
assert_eq!(
    (&q).round_to_multiple(hundredth.clone(), RoundingMode::Nearest).to_string(),
    "157/50"
);

type Output = Rational

impl<'a> RoundToMultipleAssign<&'a Rational> for Rational

fn round_to_multiple_assign(&mut self, other: &'a Rational, rm: RoundingMode)

Rounds a Rational to an integer multiple of another Rational in place, according to a specified rounding mode. The Rational on the right-hand side is taken by reference.

See the RoundToMultiple documentation for details.

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 self.significant_bits().

Panics

• If rm is Exact, but self is not a multiple of other.
• If self is nonzero, other is zero, and rm is trying to round away from zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultipleAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;

let mut x = Rational::from(-5);
x.round_to_multiple_assign(Rational::ZERO, RoundingMode::Down);
assert_eq!(x, 0);

let q = Rational::from(std::f64::consts::PI);
let hundredth = Rational::from_signeds(1, 100);

let mut x = q.clone();
x.round_to_multiple_assign(&hundredth, RoundingMode::Down);
assert_eq!(x.to_string(), "157/50");

let mut x = q.clone();
x.round_to_multiple_assign(&hundredth, RoundingMode::Floor);
assert_eq!(x.to_string(), "157/50");

let mut x = q.clone();
x.round_to_multiple_assign(&hundredth, RoundingMode::Up);
assert_eq!(x.to_string(), "63/20");

let mut x = q.clone();
x.round_to_multiple_assign(&hundredth, RoundingMode::Ceiling);
assert_eq!(x.to_string(), "63/20");

let mut x = q.clone();
x.round_to_multiple_assign(&hundredth, RoundingMode::Nearest);
assert_eq!(x.to_string(), "157/50");

impl RoundToMultipleAssign<Rational> for Rational

fn round_to_multiple_assign(&mut self, other: Rational, rm: RoundingMode)

Rounds a Rational to an integer multiple of another Rational in place, according to a specified rounding mode. The Rational on the right-hand side is taken by value.

See the RoundToMultiple documentation for details.

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 self.significant_bits().

Panics

• If rm is Exact, but self is not a multiple of other.
• If self is nonzero, other is zero, and rm is trying to round away from zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultipleAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;

let mut x = Rational::from(-5);
x.round_to_multiple_assign(Rational::ZERO, RoundingMode::Down);
assert_eq!(x, 0);

let q = Rational::from(std::f64::consts::PI);
let hundredth = Rational::from_signeds(1, 100);

let mut x = q.clone();
x.round_to_multiple_assign(hundredth.clone(), RoundingMode::Down);
assert_eq!(x.to_string(), "157/50");

let mut x = q.clone();
x.round_to_multiple_assign(hundredth.clone(), RoundingMode::Floor);
assert_eq!(x.to_string(), "157/50");

let mut x = q.clone();
x.round_to_multiple_assign(hundredth.clone(), RoundingMode::Up);
assert_eq!(x.to_string(), "63/20");

let mut x = q.clone();
x.round_to_multiple_assign(hundredth.clone(), RoundingMode::Ceiling);
assert_eq!(x.to_string(), "63/20");

let mut x = q.clone();
x.round_to_multiple_assign(hundredth.clone(), RoundingMode::Nearest);
assert_eq!(x.to_string(), "157/50");

impl RoundToMultipleOfPowerOf2<i64> for Rational

fn round_to_multiple_of_power_of_2(self, pow: i64, rm: RoundingMode) -> Rational

Rounds a Rational to an integer multiple of $2^k$ according to a specified rounding mode. The Rational is taken by value.

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = 2^k \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = 2^k \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = 2^k \lfloor q \rfloor.$

$f(x, k, \mathrm{Ceiling}) = 2^k \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, k, \mathrm{Exact}) = 2^k q$, but panics if $q \notin \Z$.

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(), pow / Limb::WIDTH).

Panics

Panics if rm is Exact, but self is not a multiple of the power of 2.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;

let q = Rational::from(std::f64::consts::PI);
assert_eq!(
    q.clone().round_to_multiple_of_power_of_2(-3, RoundingMode::Floor).to_string(),
    "25/8"
);
assert_eq!(
    q.clone().round_to_multiple_of_power_of_2(-3, RoundingMode::Down).to_string(),
    "25/8"
);
assert_eq!(
    q.clone().round_to_multiple_of_power_of_2(-3, RoundingMode::Ceiling).to_string(),
    "13/4"
);
assert_eq!(
    q.clone().round_to_multiple_of_power_of_2(-3, RoundingMode::Up).to_string(),
    "13/4"
);
assert_eq!(
    q.clone().round_to_multiple_of_power_of_2(-3, RoundingMode::Nearest).to_string(),
    "25/8"
);

type Output = Rational

impl<'a> RoundToMultipleOfPowerOf2<i64> for &'a Rational

fn round_to_multiple_of_power_of_2(self, pow: i64, rm: RoundingMode) -> Rational

Rounds a Rational to an integer multiple of $2^k$ according to a specified rounding mode. The Rational is taken by reference.

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = 2^k \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = 2^k \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = 2^k \lfloor q \rfloor.$

$f(x, k, \mathrm{Ceiling}) = 2^k \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, k, \mathrm{Exact}) = 2^k q$, but panics if $q \notin \Z$.

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(), pow / Limb::WIDTH).

Panics

Panics if rm is Exact, but self is not a multiple of the power of 2.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;

let q = Rational::from(std::f64::consts::PI);
assert_eq!(
    (&q).round_to_multiple_of_power_of_2(-3, RoundingMode::Floor).to_string(),
    "25/8"
);
assert_eq!(
    (&q).round_to_multiple_of_power_of_2(-3, RoundingMode::Down).to_string(),
    "25/8"
);
assert_eq!(
    (&q).round_to_multiple_of_power_of_2(-3, RoundingMode::Ceiling).to_string(),
    "13/4"
);
assert_eq!(
    (&q).round_to_multiple_of_power_of_2(-3, RoundingMode::Up).to_string(),
    "13/4"
);
assert_eq!(
    (&q).round_to_multiple_of_power_of_2(-3, RoundingMode::Nearest).to_string(),
    "25/8"
);

type Output = Rational

impl RoundToMultipleOfPowerOf2Assign<i64> for Rational

fn round_to_multiple_of_power_of_2_assign(&mut self, pow: i64, rm: RoundingMode)

Rounds a Rational to a multiple of $2^k$ in place, according to a specified rounding mode.

See the RoundToMultipleOfPowerOf2 documentation for details.

but the latter should be used as it is clearer and more efficient.

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(), pow / Limb::WIDTH).

Panics

Panics if rm is Exact, but self is not a multiple of the power of 2.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2Assign;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;

let q = Rational::from(std::f64::consts::PI);

let mut x = q.clone();
x.round_to_multiple_of_power_of_2_assign(-3, RoundingMode::Floor);
assert_eq!(x.to_string(), "25/8");

let mut x = q.clone();
x.round_to_multiple_of_power_of_2_assign(-3, RoundingMode::Down);
assert_eq!(x.to_string(), "25/8");

let mut x = q.clone();
x.round_to_multiple_of_power_of_2_assign(-3, RoundingMode::Ceiling);
assert_eq!(x.to_string(), "13/4");

let mut x = q.clone();
x.round_to_multiple_of_power_of_2_assign(-3, RoundingMode::Up);
assert_eq!(x.to_string(), "13/4");

let mut x = q.clone();
x.round_to_multiple_of_power_of_2_assign(-3, RoundingMode::Nearest);
assert_eq!(x.to_string(), "25/8");

impl<'a> RoundingFrom<&'a Rational> for Integer

fn rounding_from(x: &Rational, rm: RoundingMode) -> Integer

Converts a Rational to an Integer, using a specified RoundingMode and taking the Rational by reference.

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 x.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert_eq!(Integer::rounding_from(&Rational::from(123), RoundingMode::Exact), 123);
assert_eq!(Integer::rounding_from(&Rational::from(-123), RoundingMode::Exact), -123);

assert_eq!(Integer::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Floor), 3);
assert_eq!(Integer::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Down), 3);
assert_eq!(
    Integer::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Ceiling),
    4
);
assert_eq!(Integer::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Up), 4);
assert_eq!(
    Integer::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Nearest),
    3
);

assert_eq!(
    Integer::rounding_from(&Rational::from_signeds(-22, 7), RoundingMode::Floor),
    -4
);
assert_eq!(
    Integer::rounding_from(&Rational::from_signeds(-22, 7), RoundingMode::Down),
    -3
);
assert_eq!(
    Integer::rounding_from(&Rational::from_signeds(-22, 7), RoundingMode::Ceiling),
    -3
);
assert_eq!(Integer::rounding_from(&Rational::from_signeds(-22, 7), RoundingMode::Up), -4);
assert_eq!(
    Integer::rounding_from(&Rational::from_signeds(-22, 7), RoundingMode::Nearest),
    -3
);

impl<'a> RoundingFrom<&'a Rational> for Natural

fn rounding_from(x: &Rational, rm: RoundingMode) -> Natural

Converts a Rational to a Natural, using a specified RoundingMode and taking the Rational by reference.

If the Rational is negative, then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

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 x.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact, or if the Rational is less than zero and rm is not Down, Ceiling, or Nearest.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(Natural::rounding_from(&Rational::from(123), RoundingMode::Exact), 123);

assert_eq!(Natural::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Floor), 3);
assert_eq!(Natural::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Down), 3);
assert_eq!(
    Natural::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Ceiling),
    4
);
assert_eq!(Natural::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Up), 4);
assert_eq!(
    Natural::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Nearest),
    3
);

assert_eq!(Natural::rounding_from(&Rational::from(-123), RoundingMode::Down), 0);
assert_eq!(Natural::rounding_from(&Rational::from(-123), RoundingMode::Ceiling), 0);
assert_eq!(Natural::rounding_from(&Rational::from(-123), RoundingMode::Nearest), 0);

impl<'a> RoundingFrom<&'a Rational> for i8

fn rounding_from(value: &Rational, rm: RoundingMode) -> i8

Converts a Rational to a signed integer, using a specified RoundingMode.

If the Rational is smaller than the minimum value of the unsigned type, then it will be rounded to the minimum value when rm is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Rational is larger than the maximum value of the unsigned type, then it will be rounded to the maximum value when rm is Floor, Down, or Nearest. Otherwise, this function will panic.

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 value.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact, if the Rational is less than T::MIN and rm is not Down, Ceiling, or Nearest, or if the Rational is greater than T::MAX and rm is not Down, Floor, or Nearest.

Examples

See here.

impl<'a> RoundingFrom<&'a Rational> for i16

fn rounding_from(value: &Rational, rm: RoundingMode) -> i16

Converts a Rational to a signed integer, using a specified RoundingMode.

If the Rational is smaller than the minimum value of the unsigned type, then it will be rounded to the minimum value when rm is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Rational is larger than the maximum value of the unsigned type, then it will be rounded to the maximum value when rm is Floor, Down, or Nearest. Otherwise, this function will panic.

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 value.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact, if the Rational is less than T::MIN and rm is not Down, Ceiling, or Nearest, or if the Rational is greater than T::MAX and rm is not Down, Floor, or Nearest.

Examples

See here.

impl<'a> RoundingFrom<&'a Rational> for i32

fn rounding_from(value: &Rational, rm: RoundingMode) -> i32

Converts a Rational to a signed integer, using a specified RoundingMode.

If the Rational is smaller than the minimum value of the unsigned type, then it will be rounded to the minimum value when rm is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Rational is larger than the maximum value of the unsigned type, then it will be rounded to the maximum value when rm is Floor, Down, or Nearest. Otherwise, this function will panic.

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 value.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact, if the Rational is less than T::MIN and rm is not Down, Ceiling, or Nearest, or if the Rational is greater than T::MAX and rm is not Down, Floor, or Nearest.

Examples

See here.

impl<'a> RoundingFrom<&'a Rational> for i64

fn rounding_from(value: &Rational, rm: RoundingMode) -> i64

Converts a Rational to a signed integer, using a specified RoundingMode.

If the Rational is smaller than the minimum value of the unsigned type, then it will be rounded to the minimum value when rm is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Rational is larger than the maximum value of the unsigned type, then it will be rounded to the maximum value when rm is Floor, Down, or Nearest. Otherwise, this function will panic.

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 value.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact, if the Rational is less than T::MIN and rm is not Down, Ceiling, or Nearest, or if the Rational is greater than T::MAX and rm is not Down, Floor, or Nearest.

Examples

See here.

impl<'a> RoundingFrom<&'a Rational> for i128

fn rounding_from(value: &Rational, rm: RoundingMode) -> i128

Converts a Rational to a signed integer, using a specified RoundingMode.

If the Rational is smaller than the minimum value of the unsigned type, then it will be rounded to the minimum value when rm is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Rational is larger than the maximum value of the unsigned type, then it will be rounded to the maximum value when rm is Floor, Down, or Nearest. Otherwise, this function will panic.

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 value.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact, if the Rational is less than T::MIN and rm is not Down, Ceiling, or Nearest, or if the Rational is greater than T::MAX and rm is not Down, Floor, or Nearest.

Examples

See here.

impl<'a> RoundingFrom<&'a Rational> for isize

fn rounding_from(value: &Rational, rm: RoundingMode) -> isize

Converts a Rational to a signed integer, using a specified RoundingMode.

If the Rational is smaller than the minimum value of the unsigned type, then it will be rounded to the minimum value when rm is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Rational is larger than the maximum value of the unsigned type, then it will be rounded to the maximum value when rm is Floor, Down, or Nearest. Otherwise, this function will panic.

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 value.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact, if the Rational is less than T::MIN and rm is not Down, Ceiling, or Nearest, or if the Rational is greater than T::MAX and rm is not Down, Floor, or Nearest.

Examples

See here.

impl<'a> RoundingFrom<&'a Rational> for f32

fn rounding_from(value: &'a Rational, rm: RoundingMode) -> f32

Converts a Rational to a value of a primitive float according to a specified RoundingMode, taking the Rational by reference.

• If the rounding mode is Floor, the largest float less than or equal to the Rational is returned. If the Rational is greater than the maximum finite float, then the maximum finite float is returned. If it is smaller than the minimum finite float, then negative infinity is returned. If it is between zero and the minimum positive float, then positive zero is returned.
• If the rounding mode is Ceiling, the smallest float greater than or equal to the Rational is returned. If the Rational is greater than the maximum finite float, then positive infinity is returned. If it is smaller than the minimum finite float, then the minimum finite float is returned. If it is between zero and the maximum negative float, then negative zero is returned.
• If the rounding mode is Down, then the rounding proceeds as with Floor if the Rational is non-negative and as with Ceiling if the Rational is negative. If the Rational is between the maximum negative float and the minimum positive float, then positive zero is returned when the Rational is non-negative and negative zero otherwise.
• If the rounding mode is Up, then the rounding proceeds as with Ceiling if the Rational is non-negative and as with Floor if the Rational is negative. Positive zero is only returned when the Rational is zero, and negative zero is never returned.
• If the rounding mode is Nearest, then the nearest float is returned. If the Rational is exactly between two floats, the float with the zero least-significant bit in its representation is selected. If the Rational is greater than the maximum finite float, then the maximum finite float is returned. If the Rational is closer to zero than to any float (or if there is a tie between zero and another float), then positive or negative zero is returned, depending on the Rational’s sign.

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 value.significant_bits().

Panics

Panics if the rounding mode is Exact and value cannot be represented exactly.

Examples

See here.

impl<'a> RoundingFrom<&'a Rational> for f64

fn rounding_from(value: &'a Rational, rm: RoundingMode) -> f64

Converts a Rational to a value of a primitive float according to a specified RoundingMode, taking the Rational by reference.

• If the rounding mode is Floor, the largest float less than or equal to the Rational is returned. If the Rational is greater than the maximum finite float, then the maximum finite float is returned. If it is smaller than the minimum finite float, then negative infinity is returned. If it is between zero and the minimum positive float, then positive zero is returned.
• If the rounding mode is Ceiling, the smallest float greater than or equal to the Rational is returned. If the Rational is greater than the maximum finite float, then positive infinity is returned. If it is smaller than the minimum finite float, then the minimum finite float is returned. If it is between zero and the maximum negative float, then negative zero is returned.
• If the rounding mode is Down, then the rounding proceeds as with Floor if the Rational is non-negative and as with Ceiling if the Rational is negative. If the Rational is between the maximum negative float and the minimum positive float, then positive zero is returned when the Rational is non-negative and negative zero otherwise.
• If the rounding mode is Up, then the rounding proceeds as with Ceiling if the Rational is non-negative and as with Floor if the Rational is negative. Positive zero is only returned when the Rational is zero, and negative zero is never returned.
• If the rounding mode is Nearest, then the nearest float is returned. If the Rational is exactly between two floats, the float with the zero least-significant bit in its representation is selected. If the Rational is greater than the maximum finite float, then the maximum finite float is returned. If the Rational is closer to zero than to any float (or if there is a tie between zero and another float), then positive or negative zero is returned, depending on the Rational’s sign.

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 value.significant_bits().

Panics

Panics if the rounding mode is Exact and value cannot be represented exactly.

Examples

See here.

impl<'a> RoundingFrom<&'a Rational> for u8

fn rounding_from(value: &Rational, rm: RoundingMode) -> u8

Converts a Rational to an unsigned integer, using a specified RoundingMode.

If the Rational is negative, then it will be rounded to zero when rm is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Rational is larger than the maximum value of the unsigned type, then it will be rounded to the maximum value when rm is Floor, Down, or Nearest. Otherwise, this function will panic.

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 value.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact, if the Rational is less than zero and rm is not Down, Ceiling, or Nearest, or if the Rational is greater than T::MAX and rm is not Down, Floor, or Nearest.

Examples

See here.

impl<'a> RoundingFrom<&'a Rational> for u16

fn rounding_from(value: &Rational, rm: RoundingMode) -> u16

Converts a Rational to an unsigned integer, using a specified RoundingMode.

If the Rational is negative, then it will be rounded to zero when rm is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Rational is larger than the maximum value of the unsigned type, then it will be rounded to the maximum value when rm is Floor, Down, or Nearest. Otherwise, this function will panic.

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 value.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact, if the Rational is less than zero and rm is not Down, Ceiling, or Nearest, or if the Rational is greater than T::MAX and rm is not Down, Floor, or Nearest.

Examples

See here.

impl<'a> RoundingFrom<&'a Rational> for u32

fn rounding_from(value: &Rational, rm: RoundingMode) -> u32

Converts a Rational to an unsigned integer, using a specified RoundingMode.

If the Rational is negative, then it will be rounded to zero when rm is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Rational is larger than the maximum value of the unsigned type, then it will be rounded to the maximum value when rm is Floor, Down, or Nearest. Otherwise, this function will panic.

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 value.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact, if the Rational is less than zero and rm is not Down, Ceiling, or Nearest, or if the Rational is greater than T::MAX and rm is not Down, Floor, or Nearest.

Examples

See here.

impl<'a> RoundingFrom<&'a Rational> for u64

fn rounding_from(value: &Rational, rm: RoundingMode) -> u64

Converts a Rational to an unsigned integer, using a specified RoundingMode.

If the Rational is negative, then it will be rounded to zero when rm is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Rational is larger than the maximum value of the unsigned type, then it will be rounded to the maximum value when rm is Floor, Down, or Nearest. Otherwise, this function will panic.

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 value.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact, if the Rational is less than zero and rm is not Down, Ceiling, or Nearest, or if the Rational is greater than T::MAX and rm is not Down, Floor, or Nearest.

Examples

See here.

impl<'a> RoundingFrom<&'a Rational> for u128

fn rounding_from(value: &Rational, rm: RoundingMode) -> u128

Converts a Rational to an unsigned integer, using a specified RoundingMode.

If the Rational is negative, then it will be rounded to zero when rm is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Rational is larger than the maximum value of the unsigned type, then it will be rounded to the maximum value when rm is Floor, Down, or Nearest. Otherwise, this function will panic.

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 value.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact, if the Rational is less than zero and rm is not Down, Ceiling, or Nearest, or if the Rational is greater than T::MAX and rm is not Down, Floor, or Nearest.

Examples

See here.

impl<'a> RoundingFrom<&'a Rational> for usize

fn rounding_from(value: &Rational, rm: RoundingMode) -> usize

Converts a Rational to an unsigned integer, using a specified RoundingMode.

If the Rational is negative, then it will be rounded to zero when rm is Ceiling, Down, or Nearest. Otherwise, this function will panic.

If the Rational is larger than the maximum value of the unsigned type, then it will be rounded to the maximum value when rm is Floor, Down, or Nearest. Otherwise, this function will panic.

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 value.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact, if the Rational is less than zero and rm is not Down, Ceiling, or Nearest, or if the Rational is greater than T::MAX and rm is not Down, Floor, or Nearest.

Examples

See here.

impl RoundingFrom<Rational> for Integer

fn rounding_from(x: Rational, rm: RoundingMode) -> Integer

Converts a Rational to an Integer, using a specified RoundingMode and taking the Rational by value.

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 x.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert_eq!(Integer::rounding_from(Rational::from(123), RoundingMode::Exact), 123);
assert_eq!(Integer::rounding_from(Rational::from(-123), RoundingMode::Exact), -123);

assert_eq!(Integer::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Floor), 3);
assert_eq!(Integer::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Down), 3);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Ceiling),
    4
);
assert_eq!(Integer::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Up), 4);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Nearest),
    3
);

assert_eq!(
    Integer::rounding_from(Rational::from_signeds(-22, 7), RoundingMode::Floor),
    -4
);
assert_eq!(Integer::rounding_from(Rational::from_signeds(-22, 7), RoundingMode::Down), -3);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(-22, 7), RoundingMode::Ceiling),
    -3
);
assert_eq!(Integer::rounding_from(Rational::from_signeds(-22, 7), RoundingMode::Up), -4);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(-22, 7), RoundingMode::Nearest),
    -3
);

impl RoundingFrom<Rational> for Natural

fn rounding_from(x: Rational, rm: RoundingMode) -> Natural

Converts a Rational to a Natural, using a specified RoundingMode and taking the Rational by value.

If the Rational is negative, then it will be rounded to zero when the RoundingMode is Ceiling, Down, or Nearest. Otherwise, this function will panic.

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 x.significant_bits().

Panics

Panics if the Rational is not an integer and rm is Exact, or if the Rational is less than zero and rm is not Down, Ceiling, or Nearest.

Examples

extern crate malachite_base;
extern crate malachite_nz;

use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(Natural::rounding_from(Rational::from(123), RoundingMode::Exact), 123);

assert_eq!(Natural::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Floor), 3);
assert_eq!(Natural::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Down), 3);
assert_eq!(
    Natural::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Ceiling),
    4
);
assert_eq!(Natural::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Up), 4);
assert_eq!(
    Natural::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Nearest),
    3
);

assert_eq!(Natural::rounding_from(Rational::from(-123), RoundingMode::Down), 0);
assert_eq!(Natural::rounding_from(Rational::from(-123), RoundingMode::Ceiling), 0);
assert_eq!(Natural::rounding_from(Rational::from(-123), RoundingMode::Nearest), 0);

impl RoundingFrom<Rational> for f32

fn rounding_from(value: Rational, rm: RoundingMode) -> f32

Converts a Rational to a value of a primitive float according to a specified RoundingMode, taking the Rational by value.

• If the rounding mode is Floor, the largest float less than or equal to the Rational is returned. If the Rational is greater than the maximum finite float, then the maximum finite float is returned. If it is smaller than the minimum finite float, then negative infinity is returned. If it is between zero and the minimum positive float, then positive zero is returned.
• If the rounding mode is Ceiling, the smallest float greater than or equal to the Rational is returned. If the Rational is greater than the maximum finite float, then positive infinity is returned. If it is smaller than the minimum finite float, then the minimum finite float is returned. If it is between zero and the maximum negative float, then negative zero is returned.
• If the rounding mode is Down, then the rounding proceeds as with Floor if the Rational is non-negative and as with Ceiling if the Rational is negative. If the Rational is between the maximum negative float and the minimum positive float, then positive zero is returned when the Rational is non-negative and negative zero otherwise.
• If the rounding mode is Up, then the rounding proceeds as with Ceiling if the Rational is non-negative and as with Floor if the Rational is negative. Positive zero is only returned when the Rational is zero, and negative zero is never returned.
• If the rounding mode is Nearest, then the nearest float is returned. If the Rational is exactly between two floats, the float with the zero least-significant bit in its representation is selected. If the Rational is greater than the maximum finite float, then the maximum finite float is returned. If the Rational is closer to zero than to any float (or if there is a tie between zero and another float), then positive or negative zero is returned, depending on the Rational’s sign.

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 value.significant_bits().

Panics

Panics if the rounding mode is Exact and value cannot be represented exactly.

Examples

See here.

impl RoundingFrom<Rational> for f64

fn rounding_from(value: Rational, rm: RoundingMode) -> f64

Converts a Rational to a value of a primitive float according to a specified RoundingMode, taking the Rational by value.

• If the rounding mode is Floor, the largest float less than or equal to the Rational is returned. If the Rational is greater than the maximum finite float, then the maximum finite float is returned. If it is smaller than the minimum finite float, then negative infinity is returned. If it is between zero and the minimum positive float, then positive zero is returned.
• If the rounding mode is Ceiling, the smallest float greater than or equal to the Rational is returned. If the Rational is greater than the maximum finite float, then positive infinity is returned. If it is smaller than the minimum finite float, then the minimum finite float is returned. If it is between zero and the maximum negative float, then negative zero is returned.
• If the rounding mode is Down, then the rounding proceeds as with Floor if the Rational is non-negative and as with Ceiling if the Rational is negative. If the Rational is between the maximum negative float and the minimum positive float, then positive zero is returned when the Rational is non-negative and negative zero otherwise.
• If the rounding mode is Up, then the rounding proceeds as with Ceiling if the Rational is non-negative and as with Floor if the Rational is negative. Positive zero is only returned when the Rational is zero, and negative zero is never returned.
• If the rounding mode is Nearest, then the nearest float is returned. If the Rational is exactly between two floats, the float with the zero least-significant bit in its representation is selected. If the Rational is greater than the maximum finite float, then the maximum finite float is returned. If the Rational is closer to zero than to any float (or if there is a tie between zero and another float), then positive or negative zero is returned, depending on the Rational’s sign.

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 value.significant_bits().

Panics

Panics if the rounding mode is Exact and value cannot be represented exactly.

Examples

See here.

impl SciMantissaAndExponent<f32, i64, Rational> for Rational

fn sci_mantissa_and_exponent(self) -> (f32, i64)

Returns a Rational’s scientific mantissa and exponent, taking the Rational by 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 Nearest rounding mode. To use other rounding modes, use sci_mantissa_and_exponent_with_rounding. $$ f(x) \approx (\frac{x}{2^{\lfloor \log_2 x \rfloor}}, \lfloor \log_2 x \rfloor). $$

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 self.significant_bits().

Examples

See here.

fn sci_exponent(self) -> i64

Returns a Rational’s scientific exponent, taking the Rational by 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 Nearest rounding mode. To use other rounding modes, use sci_mantissa_and_exponent_with_rounding. $$ f(x) \approx \lfloor \log_2 x \rfloor. $$

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 self.significant_bits().

Examples

See here.

fn from_sci_mantissa_and_exponent(
    sci_mantissa: f32,
    sci_exponent: i64
) -> Option<Rational>

Constructs a Rational from its scientific mantissa and exponent.

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$. Here, the rational mantissa is provided as a float. If the mantissa is outside the range $[1, 2)$, None is returned.

All finite floats can be represented using Rationals, so no rounding is needed.

$$ f(x) \approx 2^{e_s}m_s. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

fn sci_mantissa(self) -> M

Extracts the scientific mantissa from a number.

impl<'a> SciMantissaAndExponent<f32, i64, Rational> for &'a Rational

fn sci_mantissa_and_exponent(self) -> (f32, i64)

Returns a Rational’s scientific mantissa and exponent, taking the Rational by reference.

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 Nearest rounding mode. To use other rounding modes, use sci_mantissa_and_exponent_with_rounding. $$ f(x) \approx (\frac{x}{2^{\lfloor \log_2 x \rfloor}}, \lfloor \log_2 x \rfloor). $$

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 self.significant_bits().

Examples

See here.

fn sci_exponent(self) -> i64

Returns a Rational’s scientific exponent, taking the Rational by reference.

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 Nearest rounding mode. To use other rounding modes, use sci_mantissa_and_exponent_with_rounding. $$ f(x) \approx \lfloor \log_2 x \rfloor. $$

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 self.significant_bits().

fn from_sci_mantissa_and_exponent(
    sci_mantissa: f32,
    sci_exponent: i64
) -> Option<Rational>

Constructs a Rational from its scientific mantissa and exponent.

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$. Here, the rational mantissa is provided as a float. If the mantissa is outside the range $[1, 2)$, None is returned.

All finite floats can be represented using Rationals, so no rounding is needed.

$$ f(x) \approx 2^{e_s}m_s. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

See here.

fn sci_mantissa(self) -> M

Extracts the scientific mantissa from a number.

impl SciMantissaAndExponent<f64, i64, Rational> for Rational

fn sci_mantissa_and_exponent(self) -> (f64, i64)

Returns a Rational’s scientific mantissa and exponent, taking the Rational by 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 Nearest rounding mode. To use other rounding modes, use sci_mantissa_and_exponent_with_rounding. $$ f(x) \approx (\frac{x}{2^{\lfloor \log_2 x \rfloor}}, \lfloor \log_2 x \rfloor). $$

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 self.significant_bits().

Examples

See here.

fn sci_exponent(self) -> i64

Returns a Rational’s scientific exponent, taking the Rational by 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 Nearest rounding mode. To use other rounding modes, use sci_mantissa_and_exponent_with_rounding. $$ f(x) \approx \lfloor \log_2 x \rfloor. $$

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 self.significant_bits().

Examples

See here.

fn from_sci_mantissa_and_exponent(
    sci_mantissa: f64,
    sci_exponent: i64
) -> Option<Rational>

Constructs a Rational from its scientific mantissa and exponent.

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$. Here, the rational mantissa is provided as a float. If the mantissa is outside the range $[1, 2)$, None is returned.

All finite floats can be represented using Rationals, so no rounding is needed.

$$ f(x) \approx 2^{e_s}m_s. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

fn sci_mantissa(self) -> M

Extracts the scientific mantissa from a number.

impl<'a> SciMantissaAndExponent<f64, i64, Rational> for &'a Rational

fn sci_mantissa_and_exponent(self) -> (f64, i64)

Returns a Rational’s scientific mantissa and exponent, taking the Rational by reference.

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 Nearest rounding mode. To use other rounding modes, use sci_mantissa_and_exponent_with_rounding. $$ f(x) \approx (\frac{x}{2^{\lfloor \log_2 x \rfloor}}, \lfloor \log_2 x \rfloor). $$

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 self.significant_bits().

Examples

See here.

fn sci_exponent(self) -> i64

Returns a Rational’s scientific exponent, taking the Rational by reference.

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 Nearest rounding mode. To use other rounding modes, use sci_mantissa_and_exponent_with_rounding. $$ f(x) \approx \lfloor \log_2 x \rfloor. $$

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 self.significant_bits().

fn from_sci_mantissa_and_exponent(
    sci_mantissa: f64,
    sci_exponent: i64
) -> Option<Rational>

Constructs a Rational from its scientific mantissa and exponent.

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$. Here, the rational mantissa is provided as a float. If the mantissa is outside the range $[1, 2)$, None is returned.

All finite floats can be represented using Rationals, so no rounding is needed.

$$ f(x) \approx 2^{e_s}m_s. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

See here.

fn sci_mantissa(self) -> M

Extracts the scientific mantissa from a number.

impl Shl<i128> for Rational

fn shl(self, bits: i128) -> Rational

Left-shifts a Rational (multiplies it or divides it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the << operator.

impl<'a> Shl<i128> for &'a Rational

fn shl(self, bits: i128) -> Rational

Left-shifts a Rational (multiplies or divides it by a power of 2), taking it by reference.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the << operator.

impl Shl<i16> for Rational

fn shl(self, bits: i16) -> Rational

Left-shifts a Rational (multiplies it or divides it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the << operator.

impl<'a> Shl<i16> for &'a Rational

fn shl(self, bits: i16) -> Rational

Left-shifts a Rational (multiplies or divides it by a power of 2), taking it by reference.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the << operator.

impl Shl<i32> for Rational

fn shl(self, bits: i32) -> Rational

Left-shifts a Rational (multiplies it or divides it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the << operator.

impl<'a> Shl<i32> for &'a Rational

fn shl(self, bits: i32) -> Rational

Left-shifts a Rational (multiplies or divides it by a power of 2), taking it by reference.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the << operator.

impl Shl<i64> for Rational

fn shl(self, bits: i64) -> Rational

Left-shifts a Rational (multiplies it or divides it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the << operator.

impl<'a> Shl<i64> for &'a Rational

fn shl(self, bits: i64) -> Rational

Left-shifts a Rational (multiplies or divides it by a power of 2), taking it by reference.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the << operator.

impl Shl<i8> for Rational

fn shl(self, bits: i8) -> Rational

Left-shifts a Rational (multiplies it or divides it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the << operator.

impl<'a> Shl<i8> for &'a Rational

fn shl(self, bits: i8) -> Rational

Left-shifts a Rational (multiplies or divides it by a power of 2), taking it by reference.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the << operator.

impl Shl<isize> for Rational

fn shl(self, bits: isize) -> Rational

Left-shifts a Rational (multiplies it or divides it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the << operator.

impl<'a> Shl<isize> for &'a Rational

fn shl(self, bits: isize) -> Rational

Left-shifts a Rational (multiplies or divides it by a power of 2), taking it by reference.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the << operator.

impl Shl<u128> for Rational

fn shl(self, bits: u128) -> Rational

Left-shifts a Rational (multiplies it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

type Output = Rational

The resulting type after applying the << operator.

impl<'a> Shl<u128> for &'a Rational

fn shl(self, bits: u128) -> Rational

Left-shifts a Rational (multiplies it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

type Output = Rational

The resulting type after applying the << operator.

impl Shl<u16> for Rational

fn shl(self, bits: u16) -> Rational

Left-shifts a Rational (multiplies it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

type Output = Rational

The resulting type after applying the << operator.

impl<'a> Shl<u16> for &'a Rational

fn shl(self, bits: u16) -> Rational

Left-shifts a Rational (multiplies it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

type Output = Rational

The resulting type after applying the << operator.

impl Shl<u32> for Rational

fn shl(self, bits: u32) -> Rational

Left-shifts a Rational (multiplies it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

type Output = Rational

The resulting type after applying the << operator.

impl<'a> Shl<u32> for &'a Rational

fn shl(self, bits: u32) -> Rational

Left-shifts a Rational (multiplies it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

type Output = Rational

The resulting type after applying the << operator.

impl Shl<u64> for Rational

fn shl(self, bits: u64) -> Rational

Left-shifts a Rational (multiplies it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

type Output = Rational

The resulting type after applying the << operator.

impl<'a> Shl<u64> for &'a Rational

fn shl(self, bits: u64) -> Rational

Left-shifts a Rational (multiplies it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

type Output = Rational

The resulting type after applying the << operator.

impl Shl<u8> for Rational

fn shl(self, bits: u8) -> Rational

Left-shifts a Rational (multiplies it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

type Output = Rational

The resulting type after applying the << operator.

impl<'a> Shl<u8> for &'a Rational

fn shl(self, bits: u8) -> Rational

Left-shifts a Rational (multiplies it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

type Output = Rational

The resulting type after applying the << operator.

impl Shl<usize> for Rational

fn shl(self, bits: usize) -> Rational

Left-shifts a Rational (multiplies it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

type Output = Rational

The resulting type after applying the << operator.

impl<'a> Shl<usize> for &'a Rational

fn shl(self, bits: usize) -> Rational

Left-shifts a Rational (multiplies it by a power of 2), taking it by value.

$$ f(x, k) = x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

type Output = Rational

The resulting type after applying the << operator.

impl ShlAssign<i128> for Rational

fn shl_assign(&mut self, bits: i128)

Left-shifts a Rational (multiplies or divides it by a power of 2), in place.

$$ x \gets x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShlAssign<i16> for Rational

fn shl_assign(&mut self, bits: i16)

Left-shifts a Rational (multiplies or divides it by a power of 2), in place.

$$ x \gets x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShlAssign<i32> for Rational

fn shl_assign(&mut self, bits: i32)

Left-shifts a Rational (multiplies or divides it by a power of 2), in place.

$$ x \gets x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShlAssign<i64> for Rational

fn shl_assign(&mut self, bits: i64)

Left-shifts a Rational (multiplies or divides it by a power of 2), in place.

$$ x \gets x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShlAssign<i8> for Rational

fn shl_assign(&mut self, bits: i8)

Left-shifts a Rational (multiplies or divides it by a power of 2), in place.

$$ x \gets x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShlAssign<isize> for Rational

fn shl_assign(&mut self, bits: isize)

Left-shifts a Rational (multiplies or divides it by a power of 2), in place.

$$ x \gets x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShlAssign<u128> for Rational

fn shl_assign(&mut self, bits: u128)

Left-shifts a Rational (multiplies it by a power of 2), in place.

$$ x \gets x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

impl ShlAssign<u16> for Rational

fn shl_assign(&mut self, bits: u16)

Left-shifts a Rational (multiplies it by a power of 2), in place.

$$ x \gets x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

impl ShlAssign<u32> for Rational

fn shl_assign(&mut self, bits: u32)

Left-shifts a Rational (multiplies it by a power of 2), in place.

$$ x \gets x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

impl ShlAssign<u64> for Rational

fn shl_assign(&mut self, bits: u64)

Left-shifts a Rational (multiplies it by a power of 2), in place.

$$ x \gets x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

impl ShlAssign<u8> for Rational

fn shl_assign(&mut self, bits: u8)

Left-shifts a Rational (multiplies it by a power of 2), in place.

$$ x \gets x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

impl ShlAssign<usize> for Rational

fn shl_assign(&mut self, bits: usize)

Left-shifts a Rational (multiplies it by a power of 2), in place.

$$ x \gets x2^k. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

Examples

See here.

impl Shr<i128> for Rational

fn shr(self, bits: i128) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by value.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl<'a> Shr<i128> for &'a Rational

fn shr(self, bits: i128) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl Shr<i16> for Rational

fn shr(self, bits: i16) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by value.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl<'a> Shr<i16> for &'a Rational

fn shr(self, bits: i16) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl Shr<i32> for Rational

fn shr(self, bits: i32) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by value.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl<'a> Shr<i32> for &'a Rational

fn shr(self, bits: i32) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl Shr<i64> for Rational

fn shr(self, bits: i64) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by value.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl<'a> Shr<i64> for &'a Rational

fn shr(self, bits: i64) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl Shr<i8> for Rational

fn shr(self, bits: i8) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by value.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl<'a> Shr<i8> for &'a Rational

fn shr(self, bits: i8) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl Shr<isize> for Rational

fn shr(self, bits: isize) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by value.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl<'a> Shr<isize> for &'a Rational

fn shr(self, bits: isize) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl Shr<u128> for Rational

fn shr(self, bits: u128) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by value.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl<'a> Shr<u128> for &'a Rational

fn shr(self, bits: u128) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl Shr<u16> for Rational

fn shr(self, bits: u16) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by value.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl<'a> Shr<u16> for &'a Rational

fn shr(self, bits: u16) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl Shr<u32> for Rational

fn shr(self, bits: u32) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by value.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl<'a> Shr<u32> for &'a Rational

fn shr(self, bits: u32) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl Shr<u64> for Rational

fn shr(self, bits: u64) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by value.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl<'a> Shr<u64> for &'a Rational

fn shr(self, bits: u64) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl Shr<u8> for Rational

fn shr(self, bits: u8) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by value.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl<'a> Shr<u8> for &'a Rational

fn shr(self, bits: u8) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl Shr<usize> for Rational

fn shr(self, bits: usize) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by value.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl<'a> Shr<usize> for &'a Rational

fn shr(self, bits: usize) -> Rational

Right-shifts a Rational (divides it by a power of 2), taking it by reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

type Output = Rational

The resulting type after applying the >> operator.

impl ShrAssign<i128> for Rational

fn shr_assign(&mut self, bits: i128)

Right-shifts a Rational (divides it by a power of 2), in reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShrAssign<i16> for Rational

fn shr_assign(&mut self, bits: i16)

Right-shifts a Rational (divides it by a power of 2), in reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShrAssign<i32> for Rational

fn shr_assign(&mut self, bits: i32)

Right-shifts a Rational (divides it by a power of 2), in reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShrAssign<i64> for Rational

fn shr_assign(&mut self, bits: i64)

Right-shifts a Rational (divides it by a power of 2), in reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShrAssign<i8> for Rational

fn shr_assign(&mut self, bits: i8)

Right-shifts a Rational (divides it by a power of 2), in reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShrAssign<isize> for Rational

fn shr_assign(&mut self, bits: isize)

Right-shifts a Rational (divides it by a power of 2), in reference.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShrAssign<u128> for Rational

fn shr_assign(&mut self, bits: u128)

Right-shifts a Rational (divides it by a power of 2), in place.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShrAssign<u16> for Rational

fn shr_assign(&mut self, bits: u16)

Right-shifts a Rational (divides it by a power of 2), in place.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShrAssign<u32> for Rational

fn shr_assign(&mut self, bits: u32)

Right-shifts a Rational (divides it by a power of 2), in place.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShrAssign<u64> for Rational

fn shr_assign(&mut self, bits: u64)

Right-shifts a Rational (divides it by a power of 2), in place.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShrAssign<u8> for Rational

fn shr_assign(&mut self, bits: u8)

Right-shifts a Rational (divides it by a power of 2), in place.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl ShrAssign<usize> for Rational

fn shr_assign(&mut self, bits: usize)

Right-shifts a Rational (divides it by a power of 2), in place.

$$ f(x, k) = \frac{x}{2^k}. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

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

See here.

impl Sign for Rational

fn sign(&self) -> Ordering

Compares a Rational to zero.

Returns Greater, Equal, or Less, depending on whether the Rational is positive, zero, or negative, respectively.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Sign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
use std::cmp::Ordering;

assert_eq!(Rational::ZERO.sign(), Ordering::Equal);
assert_eq!(Rational::from_signeds(22, 7).sign(), Ordering::Greater);
assert_eq!(Rational::from_signeds(-22, 7).sign(), Ordering::Less);

impl<'a> SignificantBits for &'a Rational

fn significant_bits(self) -> u64

Returns the sum of the bits needed to represent the numerator and denominator.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::logic::traits::SignificantBits;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
use std::str::FromStr;

assert_eq!(Rational::ZERO.significant_bits(), 1);
assert_eq!(Rational::from_str("-100/101").unwrap().significant_bits(), 14);

impl SimplestRationalInInterval for Rational

fn simplest_rational_in_open_interval(x: &Rational, y: &Rational) -> Rational

Finds the simplest Rational contained in an open interval.

Let $f(x, y) = p/q$, with $p$ and $q$ relatively prime. Then the following properties hold:

• $x < p/q < y$
• If $x < m/n < y$, then $n \geq q$
• If $x < m/q < y$, then $|p| \leq |m|$

Worst-case complexity

$T(n) = O(n^2 \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(), y.significant_bits()).

Panics

Panics if $x \geq y$.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_q::arithmetic::traits::SimplestRationalInInterval;
use malachite_q::Rational;

assert_eq!(
    Rational::simplest_rational_in_open_interval(
        &Rational::from_signeds(1, 3),
        &Rational::from_signeds(1, 2)
    ),
    Rational::from_signeds(2, 5)
);
assert_eq!(
    Rational::simplest_rational_in_open_interval(
        &Rational::from_signeds(-1, 3),
        &Rational::from_signeds(1, 3)
    ),
    Rational::ZERO
);
assert_eq!(
    Rational::simplest_rational_in_open_interval(
        &Rational::from_signeds(314, 100),
        &Rational::from_signeds(315, 100)
    ),
    Rational::from_signeds(22, 7)
);

fn simplest_rational_in_closed_interval(x: &Rational, y: &Rational) -> Rational

Finds the simplest Rational contained in a closed interval.

Let $f(x, y) = p/q$, with $p$ and $q$ relatively prime. Then the following properties hold:

• $x \leq p/q \leq y$
• If $x \leq m/n \leq y$, then $n \geq q$
• If $x \leq m/q \leq y$, then $|p| \leq |m|$

Worst-case complexity

$T(n) = O(n^2 \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(), y.significant_bits()).

Panics

Panics if $x > y$.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_q::arithmetic::traits::SimplestRationalInInterval;
use malachite_q::Rational;

assert_eq!(
    Rational::simplest_rational_in_closed_interval(
        &Rational::from_signeds(1, 3),
        &Rational::from_signeds(1, 2)
    ),
    Rational::from_signeds(1, 2)
);
assert_eq!(
    Rational::simplest_rational_in_closed_interval(
        &Rational::from_signeds(-1, 3),
        &Rational::from_signeds(1, 3)
    ),
    Rational::ZERO
);
assert_eq!(
    Rational::simplest_rational_in_closed_interval(
        &Rational::from_signeds(314, 100),
        &Rational::from_signeds(315, 100)
    ),
    Rational::from_signeds(22, 7)
);

impl Square for Rational

fn square(self) -> Rational

Squares a Rational, taking it by value.

$$ f(x) = x^2. $$

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 self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Square;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!(Rational::ZERO.square(), 0);
assert_eq!(Rational::from_signeds(22, 7).square().to_string(), "484/49");
assert_eq!(Rational::from_signeds(-22, 7).square().to_string(), "484/49");

type Output = Rational

impl<'a> Square for &'a Rational

fn square(self) -> Rational

Squares a Rational, taking it by reference.

$$ f(x) = x^2. $$

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 self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Square;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

assert_eq!((&Rational::ZERO).square(), 0);
assert_eq!((&Rational::from_signeds(22, 7)).square().to_string(), "484/49");
assert_eq!((&Rational::from_signeds(-22, 7)).square().to_string(), "484/49");

type Output = Rational

impl SquareAssign for Rational

fn square_assign(&mut self)

Squares a Rational in place.

$$ x \gets x^2. $$

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 self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::SquareAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;

let mut x = Rational::ZERO;
x.square_assign();
assert_eq!(x, 0);

let mut x = Rational::from_signeds(22, 7);
x.square_assign();
assert_eq!(x.to_string(), "484/49");

let mut x = Rational::from_signeds(-22, 7);
x.square_assign();
assert_eq!(x.to_string(), "484/49");

impl<'a> Sub<&'a Rational> for Rational

fn sub(self, other: &'a Rational) -> Rational

Subtracts a Rational by another Rational, taking the first by value and the second by reference.

$$ f(x, y) = x - y. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;

assert_eq!(Rational::ONE_HALF - &Rational::ONE_HALF, 0);
assert_eq!(
    (Rational::from_signeds(22, 7) - &Rational::from_signeds(99, 100)).to_string(),
    "1507/700"
);

type Output = Rational

The resulting type after applying the - operator.

impl<'a, 'b> Sub<&'a Rational> for &'b Rational

fn sub(self, other: &'a Rational) -> Rational

Subtracts a Rational by another Rational, taking both by reference.

$$ f(x, y) = x - y. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;

assert_eq!(&Rational::ONE_HALF - &Rational::ONE_HALF, 0);
assert_eq!(
    (&Rational::from_signeds(22, 7) - &Rational::from_signeds(99, 100)).to_string(),
    "1507/700"
);

type Output = Rational

The resulting type after applying the - operator.

impl Sub<Rational> for Rational

fn sub(self, other: Rational) -> Rational

Subtracts a Rational by another Rational, taking both by value.

$$ f(x, y) = x - y. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;

assert_eq!(Rational::ONE_HALF - Rational::ONE_HALF, 0);
assert_eq!(
    (Rational::from_signeds(22, 7) - Rational::from_signeds(99, 100)).to_string(),
    "1507/700"
);

type Output = Rational

The resulting type after applying the - operator.

impl<'a> Sub<Rational> for &'a Rational

fn sub(self, other: Rational) -> Rational

Subtracts a Rational by another Rational, taking the first by reference and the second by value.

$$ f(x, y) = x - y. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;

assert_eq!(&Rational::ONE_HALF - Rational::ONE_HALF, 0);
assert_eq!(
    (&Rational::from_signeds(22, 7) - Rational::from_signeds(99, 100)).to_string(),
    "1507/700"
);

type Output = Rational

The resulting type after applying the - operator.

impl<'a> SubAssign<&'a Rational> for Rational

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

Subtracts a Rational by another Rational in place, taking the Rational on the right-hand side by reference.

$$ x \gets x - y. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;

let mut x = Rational::ONE_HALF;
x -= &Rational::ONE_HALF;
assert_eq!(x, 0);

let mut x = Rational::from_signeds(22, 7);
x -= &Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "1507/700");

impl SubAssign<Rational> for Rational

fn sub_assign(&mut self, other: Rational)

Subtracts a Rational by another Rational in place, taking the Rational on the right-hand side by value.

$$ x \gets x - y. $$

Worst-case complexity

$T(n) = O(n (\log n)^2 \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

extern crate malachite_base;

use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;

let mut x = Rational::ONE_HALF;
x -= Rational::ONE_HALF;
assert_eq!(x, 0);

let mut x = Rational::from_signeds(22, 7);
x -= Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "1507/700");

impl ToSci for Rational

fn fmt_sci_valid(&self, options: ToSciOptions) -> bool

Determines whether a Rational can be converted to a string using to_sci and a particular set of options.

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(), s), where s depends on the size type specified in options.

• If options has scale specified, then s is options.scale.
• If options has precision specified, then s is options.precision.
• If options has size_complete specified, then s is self.denominator (not the log of the denominator!). This reflects the fact that setting size_complete might result in a very long string.

Examples

extern crate malachite_base;

use malachite_base::num::conversion::string::options::ToSciOptions;
use malachite_base::num::conversion::traits::ToSci;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;

let mut options = ToSciOptions::default();
assert!(Rational::from(123u8).fmt_sci_valid(options));
assert!(Rational::from(u128::MAX).fmt_sci_valid(options));
// u128::MAX has more than 16 significant digits
options.set_rounding_mode(RoundingMode::Exact);
assert!(!Rational::from(u128::MAX).fmt_sci_valid(options));
options.set_precision(50);
assert!(Rational::from(u128::MAX).fmt_sci_valid(options));

let mut options = ToSciOptions::default();
options.set_size_complete();
// 1/3 is non-terminating in base 10...
assert!(!Rational::from_signeds(1, 3).fmt_sci_valid(options));
options.set_size_complete();

// ...but is terminating in base 36
options.set_base(36);
assert!(Rational::from_signeds(1, 3).fmt_sci_valid(options));

fn fmt_sci(&self, f: &mut Formatter<'_>, options: ToSciOptions) -> Result

Converts a Rational to a string using a specified base, possibly formatting the number using scientific notation.

See ToSciOptions for details on the available options.

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(), s), where s depends on the size type specified in options.

• If options has scale specified, then s is options.scale.
• If options has precision specified, then s is options.precision.
• If options has size_complete specified, then s is self.denominator (not the log of the denominator!). This reflects the fact that setting size_complete might result in a very long string.

Panics

Panics if options.rounding_mode is Exact, but the size options are such that the input must be rounded.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::conversion::string::options::ToSciOptions;
use malachite_base::num::conversion::traits::ToSci;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;

let q = Rational::from_signeds(22, 7);
let mut options = ToSciOptions::default();
assert_eq!(q.to_sci_with_options(options).to_string(), "3.142857142857143");

options.set_precision(3);
assert_eq!(q.to_sci_with_options(options).to_string(), "3.14");

options.set_rounding_mode(RoundingMode::Ceiling);
assert_eq!(q.to_sci_with_options(options).to_string(), "3.15");

options = ToSciOptions::default();
options.set_base(20);
assert_eq!(q.to_sci_with_options(options).to_string(), "3.2h2h2h2h2h2h2h3");

options.set_uppercase();
assert_eq!(q.to_sci_with_options(options).to_string(), "3.2H2H2H2H2H2H2H3");

options.set_base(2);
options.set_rounding_mode(RoundingMode::Floor);
options.set_precision(19);
assert_eq!(q.to_sci_with_options(options).to_string(), "11.001001001001001");

options.set_include_trailing_zeros(true);
assert_eq!(q.to_sci_with_options(options).to_string(), "11.00100100100100100");

let q = Rational::from_unsigneds(936851431250u64, 1397u64);
let mut options = ToSciOptions::default();
options.set_precision(6);
assert_eq!(q.to_sci_with_options(options).to_string(), "6.70617e8");

options.set_e_uppercase();
assert_eq!(q.to_sci_with_options(options).to_string(), "6.70617E8");

options.set_force_exponent_plus_sign(true);
assert_eq!(q.to_sci_with_options(options).to_string(), "6.70617E+8");

let q = Rational::from_signeds(123i64, 45678909876i64);
let mut options = ToSciOptions::default();
assert_eq!(q.to_sci_with_options(options).to_string(), "2.692708743135418e-9");

options.set_neg_exp_threshold(-10);
assert_eq!(q.to_sci_with_options(options).to_string(), "0.000000002692708743135418");

let q = Rational::power_of_2(-30i64);
let mut options = ToSciOptions::default();
assert_eq!(q.to_sci_with_options(options).to_string(), "9.313225746154785e-10");

options.set_size_complete();
assert_eq!(q.to_sci_with_options(options).to_string(), "9.31322574615478515625e-10");

fn to_sci_with_options(&self, options: ToSciOptions) -> SciWrapper<'_, Self>

Converts a number to a string, possibly in scientific notation.

fn to_sci(&self) -> SciWrapper<'_, Self>

Converts a number to a string, possibly in scientific notation, using the default ToSciOptions.

impl Two for Rational

The constant 2.

const TWO: Rational = Rational { sign: true, numerator: Natural::TWO, denominator: Natural::ONE, }

impl Zero for Rational

The constant 0.

const ZERO: Rational = Rational { sign: true, numerator: Natural::ZERO, denominator: Natural::ONE, }

impl Eq for Rational

impl StructuralEq for Rational

impl StructuralPartialEq for Rational