Struct Rational 

pub struct Rational { /* private fields */ }

A rational number.

Rationals whose numerator and denominator have 64 significant bits or fewer can be represented without any memory allocation. (Unless Malachite is compiled with 32_bit_limbs, in which case the limit is 32).

Implementations

impl Rational

pub fn approx_log(&self) -> f64

Calculates the approximate natural logarithm of a positive Rational.

$f(x) = (1+\varepsilon)(\log x)$, where $|\varepsilon| < 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

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 floor_log_base_2_abs(&self) -> i64

Returns the floor of the base-2 logarithm of the absolute value of a nonzero 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 is zero.

Examples

use malachite_q::Rational;

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

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

pub fn ceiling_log_base_2_abs(&self) -> i64

Returns the ceiling of the base-2 logarithm of the absolute value of a nonzero 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

use malachite_q::Rational;

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

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

impl Rational

pub fn cmp_complexity(&self, other: &Self) -> 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)),
    Less
);
assert_eq!(
    Rational::from_signeds(1, 2).cmp_complexity(&Rational::from_signeds(3, 2)),
    Less
);
assert_eq!(
    Rational::from_signeds(1, 2).cmp_complexity(&Rational::from_signeds(-1, 2)),
    Less
);

impl Rational

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

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

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, ) -> Self

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

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

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>, ) -> Self

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

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>, ) -> Self

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

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>, ) -> Self

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

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>, ) -> Self

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

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

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

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

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

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

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 try_from_float_simplest<T: PrimitiveFloat>( x: T, ) -> Result<Self, RationalFromPrimitiveFloatError>

where Self: TryFrom<T, Error = RationalFromPrimitiveFloatError>,

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.

If the floating point value is NaN or infinite, an error is returned.

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

Examples

use malachite_base::strings::ToDebugString;
use malachite_q::conversion::from_primitive_float::RationalFromPrimitiveFloatError;
use malachite_q::Rational;

assert_eq!(
    Rational::try_from_float_simplest(0.0).to_debug_string(),
    "Ok(0)"
);
assert_eq!(
    Rational::try_from_float_simplest(1.5).to_debug_string(),
    "Ok(3/2)"
);
assert_eq!(
    Rational::try_from_float_simplest(-1.5).to_debug_string(),
    "Ok(-3/2)"
);
assert_eq!(
    Rational::try_from_float_simplest(0.1f32).to_debug_string(),
    "Ok(1/10)"
);
assert_eq!(
    Rational::try_from_float_simplest(0.33333334f32).to_debug_string(),
    "Ok(1/3)"
);
assert_eq!(
    Rational::try_from_float_simplest(f32::NAN),
    Err(RationalFromPrimitiveFloatError)
);

impl Rational

pub const fn const_from_unsigneds(numerator: Limb, denominator: Limb) -> Self

Converts twoLimbs, representing a numerator and a denominator, to a Rational.

If denominator is zero, None is returned.

This function is const, so it may be used to define constants. When called at runtime, it is slower than Rational::from_unsigneds.

Worst-case complexity

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

$M(n) = O(n)$

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

Examples

use malachite_q::Rational;

const TWO_THIRDS: Rational = Rational::const_from_unsigneds(2, 3);
assert_eq!(TWO_THIRDS, Rational::from_unsigneds(2u32, 3));

const TWO_THIRDS_ALT: Rational = Rational::const_from_unsigneds(22, 33);
assert_eq!(TWO_THIRDS_ALT, Rational::from_unsigneds(2u32, 3));

pub const fn const_from_signeds( numerator: SignedLimb, denominator: SignedLimb, ) -> Self

Converts twoSignedLimbs, representing a numerator and a denominator, to a Rational.

If denominator is zero, None is returned.

This function is const, so it may be used to define constants. When called at runtime, it is slower than Rational::from_signeds.

Worst-case complexity

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

$M(n) = O(n)$

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

Examples

use malachite_q::Rational;

const NEGATIVE_TWO_THIRDS: Rational = Rational::const_from_signeds(-2, 3);
assert_eq!(NEGATIVE_TWO_THIRDS, Rational::from_signeds(-2, 3));

const NEGATIVE_TWO_THIRDS_ALT: Rational = Rational::const_from_signeds(-22, 33);
assert_eq!(NEGATIVE_TWO_THIRDS_ALT, Rational::from_signeds(-2, 3));

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

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

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) -> Self

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

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, ) -> Self

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(numerator.significant_bits(), denominator.significant_bits()).

Panics

Panics if denominator is zero.

Examples

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) -> Self

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

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) -> Self

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

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) -> Self

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(numerator.significant_bits(), denominator.significant_bits()).

Panics

Panics if denominator is zero.

Examples

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, ) -> Self

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

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, ) -> Self

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

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, ) -> Self

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(numerator.significant_bits(), denominator.significant_bits()).

Panics

Panics if denominator is zero.

Examples

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 const fn const_from_unsigned(x: Limb) -> Self

Converts a Limb to a Rational.

This function is const, so it may be used to define constants.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_q::Rational;

const TEN: Rational = Rational::const_from_unsigned(10);
assert_eq!(TEN, 10);

pub const fn const_from_signed(x: SignedLimb) -> Self

Converts a SignedLimb to a Rational.

This function is const, so it may be used to define constants.

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_q::Rational;

const TEN: Rational = Rational::const_from_signed(10);
assert_eq!(TEN, 10);

const NEGATIVE_TEN: Rational = Rational::const_from_signed(-10);
assert_eq!(NEGATIVE_TEN, -10);

impl Rational

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

Returns a Rational’s scientific mantissa and exponent, taking the Rational by value. An Ordering is also returned, indicating whether the returned mantissa and exponent represent a value that is less than, equal to, or greater than the absolute value of the Rational.

The Rational’s sign is ignored. This means that, for example, that rounding using Floor is equivalent to rounding using Down, even if the Rational is negative.

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

use malachite_base::num::float::NiceFloat;
use malachite_base::rounding_modes::RoundingMode::{self, *};
use malachite_q::Rational;
use std::cmp::Ordering::{self, *};

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

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

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

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

Returns a Rational’s scientific mantissa and exponent, taking the Rational by reference. An Ordering is also returned, indicating whether the returned mantissa and exponent represent a value that is less than, equal to, or greater than the original value.

When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational mantissa as a float. The conversion might not be exact, so we round to the nearest float using the provided rounding mode. If the rounding mode is Exact but the conversion is not exact, None is returned. $$ f(x, r) \approx \left (\frac{x}{2^{\lfloor \log_2 x \rfloor}}, \lfloor \log_2 x \rfloor\right ). $$

Worst-case complexity

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

use malachite_base::num::float::NiceFloat;
use malachite_base::rounding_modes::RoundingMode::{self, *};
use malachite_q::Rational;
use std::cmp::Ordering::{self, *};

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

test(
    Rational::from_signeds(1, 3),
    Floor,
    Some((1.3333333, -2, Less)),
);
test(
    Rational::from_signeds(1, 3),
    Down,
    Some((1.3333333, -2, Less)),
);
test(
    Rational::from_signeds(1, 3),
    Ceiling,
    Some((1.3333334, -2, Greater)),
);
test(
    Rational::from_signeds(1, 3),
    Up,
    Some((1.3333334, -2, Greater)),
);
test(
    Rational::from_signeds(1, 3),
    Nearest,
    Some((1.3333334, -2, Greater)),
);
test(Rational::from_signeds(1, 3), 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

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, and then returns whatever the closure returns.

After the closure executes, this function reduces the Rational.

Panics

Panics if the closure sets the denominator to zero.

Examples

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, and then returns whatever the closure returns.

After the closure executes, this function reduces the Rational.

Panics

Panics if the closure sets the denominator to zero.

Examples

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<Self>

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 $\varepsilon = b^{-s}/2$ and finds the simplest Rational in the closed interval $[q - \varepsilon, q + \varepsilon]$. 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

use malachite_base::num::conversion::string::options::FromSciStringOptions;
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<Self>

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 $\varepsilon = 10^{-s}/2$ and finds the simplest Rational in the closed interval $[q - \varepsilon, q + \varepsilon]$. 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

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

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

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

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 Abs for Rational

fn abs(self) -> Self

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

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

Worst-case complexity

Constant time and additional memory.

Examples

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

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 AbsDiff<&Rational> for &Rational

fn abs_diff(self, other: &Rational) -> Rational

Computes the absolute value of the difference between 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

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

assert_eq!(Rational::ONE_HALF.abs_diff(Rational::ONE_HALF), 0);
assert_eq!(
    (&Rational::from_signeds(22, 7))
        .abs_diff(&Rational::from_signeds(99, 100))
        .to_string(),
    "1507/700"
);
assert_eq!(
    (&Rational::from_signeds(22, 7))
        .abs_diff(&Rational::from_signeds(99, 100))
        .to_string(),
    "1507/700"
);

type Output = Rational

impl AbsDiff<&Rational> for Rational

fn abs_diff(self, other: &Self) -> Self

Computes the absolute value of the difference between two Rationals, 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

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

assert_eq!(Rational::ONE_HALF.abs_diff(&Rational::ONE_HALF), 0);
assert_eq!(
    Rational::from_signeds(22, 7)
        .abs_diff(&Rational::from_signeds(99, 100))
        .to_string(),
    "1507/700"
);
assert_eq!(
    Rational::from_signeds(22, 7)
        .abs_diff(&Rational::from_signeds(99, 100))
        .to_string(),
    "1507/700"
);

type Output = Rational

impl AbsDiff<Rational> for &Rational

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

Computes the absolute value of the difference between 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

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

assert_eq!(Rational::ONE_HALF.abs_diff(Rational::ONE_HALF), 0);
assert_eq!(
    (&Rational::from_signeds(22, 7))
        .abs_diff(Rational::from_signeds(99, 100))
        .to_string(),
    "1507/700"
);
assert_eq!(
    (&Rational::from_signeds(22, 7))
        .abs_diff(Rational::from_signeds(99, 100))
        .to_string(),
    "1507/700"
);

type Output = Rational

impl AbsDiff for Rational

fn abs_diff(self, other: Self) -> Self

Computes the absolute value of the difference between 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

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

assert_eq!(Rational::ONE_HALF.abs_diff(Rational::ONE_HALF), 0);
assert_eq!(
    Rational::from_signeds(22, 7)
        .abs_diff(Rational::from_signeds(99, 100))
        .to_string(),
    "1507/700"
);
assert_eq!(
    Rational::from_signeds(22, 7)
        .abs_diff(Rational::from_signeds(99, 100))
        .to_string(),
    "1507/700"
);

type Output = Rational

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

fn abs_diff_assign(&mut self, other: &'a Self)

Subtracts a Rational by another Rational in place and takes the absolute value, 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()).

Panics

Panics if other is greater than self.

Examples

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

let mut x = Rational::ONE_HALF;
x.abs_diff_assign(&Rational::ONE_HALF);
assert_eq!(x, 0);

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

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

impl AbsDiffAssign for Rational

fn abs_diff_assign(&mut self, other: Self)

Subtracts a Rational by another Rational in place and takes the absolute value, 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()).

Panics

Panics if other is greater than self.

Examples

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

let mut x = Rational::ONE_HALF;
x.abs_diff_assign(Rational::ONE_HALF);
assert_eq!(x, 0);

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

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

impl Add<&Rational> for &Rational

fn add(self, other: &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

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: &Self) -> Self

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

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

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 for Rational

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

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

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 AddAssign<&Rational> for Rational

fn add_assign(&mut self, other: &Self)

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

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 for Rational

fn add_assign(&mut self, other: Self)

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

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

use malachite_base::num::conversion::traits::ExactFrom;
use malachite_nz::natural::Natural;
use malachite_q::arithmetic::traits::Approximate;
use malachite_q::Rational;

assert_eq!(
    (&Rational::exact_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 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

use malachite_base::num::conversion::traits::ExactFrom;
use malachite_nz::natural::Natural;
use malachite_q::arithmetic::traits::Approximate;
use malachite_q::Rational;

assert_eq!(
    Rational::exact_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

use malachite_base::num::conversion::traits::ExactFrom;
use malachite_nz::natural::Natural;
use malachite_q::arithmetic::traits::ApproximateAssign;
use malachite_q::Rational;

let mut x = Rational::exact_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 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

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

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

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 CeilingLogBase<&Rational> for &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

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 CeilingLogBase2 for &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

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 CeilingLogBasePowerOf2<i64> for &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

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 CheckedDiv<&Rational> for &Rational

fn checked_div(self, other: &Rational) -> Option<Rational>

Divides a Rational by another Rational, taking both by reference. Returns None when the second Rational is zero, Some otherwise.

$$ f(x, y) = \begin{cases} \operatorname{Some}\left ( \frac{x}{y} \right ) & \text{if} \quad y \neq 0 \\ \text{None} & \text{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 max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::arithmetic::traits::CheckedDiv;
use malachite_base::num::basic::traits::{Two, Zero};
use malachite_q::Rational;

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

type Output = Rational

impl CheckedDiv<&Rational> for Rational

fn checked_div(self, other: &Self) -> Option<Self>

Divides a Rational by another Rational, taking the first by value and the second by reference. Returns None when the second Rational is zero, Some otherwise.

$$ f(x, y) = \begin{cases} \operatorname{Some}\left ( \frac{x}{y} \right ) & \text{if} \quad y \neq 0 \\ \text{None} & \text{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 max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::arithmetic::traits::CheckedDiv;
use malachite_base::num::basic::traits::{Two, Zero};
use malachite_q::Rational;

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

type Output = Rational

impl CheckedDiv<Rational> for &Rational

fn checked_div(self, other: Rational) -> Option<Rational>

Divides a Rational by another Rational, taking the first by reference and the second by value. Returns None when the second Rational is zero, Some otherwise.

$$ f(x, y) = \begin{cases} \operatorname{Some}\left ( \frac{x}{y} \right ) & \text{if} \quad y \neq 0 \\ \text{None} & \text{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 max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::arithmetic::traits::CheckedDiv;
use malachite_base::num::basic::traits::{Two, Zero};
use malachite_q::Rational;

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

type Output = Rational

impl CheckedDiv for Rational

fn checked_div(self, other: Self) -> Option<Self>

Divides a Rational by another Rational, taking both by value. Returns None when the second Rational is zero, Some otherwise.

$$ f(x, y) = \begin{cases} \operatorname{Some}\left ( \frac{x}{y} \right ) & \text{if} \quad y \neq 0 \\ \text{None} & \text{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 max(self.significant_bits(), other.significant_bits()).

Examples

use malachite_base::num::arithmetic::traits::CheckedDiv;
use malachite_base::num::basic::traits::{Two, Zero};
use malachite_q::Rational;

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

type Output = Rational

impl CheckedLogBase<&Rational> for &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

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 CheckedLogBase2 for &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

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 CheckedLogBasePowerOf2<i64> for &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

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

$$ f(x, n) = \begin{cases} \operatorname{Some}(sqrt[n]{x}) & \text{if} \quad \sqrt[n]{x} \in \mathbb{Q}, \\ \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

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<i64> for Rational

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

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 \mathbb{Q}, \\ \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

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

$$ f(x, n) = \begin{cases} \operatorname{Some}(sqrt[n]{x}) & \text{if} \quad \sqrt[n]{x} \in \mathbb{Q}, \\ \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

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 CheckedRoot<u64> for Rational

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

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 \mathbb{Q}, \\ \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

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

$$ f(x) = \begin{cases} \operatorname{Some}(sqrt{x}) & \text{if} \quad \sqrt{x} \in \mathbb{Q}, \\ \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

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 CheckedSqrt for Rational

fn checked_sqrt(self) -> Option<Self>

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 \mathbb{Q}, \\ \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

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 duplicate 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 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

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

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

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

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 ConvertibleFrom<&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

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 ConvertibleFrom<&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

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 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 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 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 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 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 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 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 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 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 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 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 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 ConvertibleFrom<f32> for Rational

fn convertible_from(x: f32) -> bool

Determines whether a primitive float can be converted to a Rational. (It can if it is finite.)

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl ConvertibleFrom<f64> for Rational

fn convertible_from(x: f64) -> bool

Determines whether a primitive float can be converted to a Rational. (It can if it is finite.)

Worst-case complexity

Constant time and additional memory.

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

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() -> Self

The default value of a Rational, 0.

impl DenominatorsInClosedInterval for Rational

fn denominators_in_closed_interval( a: Rational, b: Rational, ) -> DenominatorsInClosedRationalInterval

Returns an iterator of all denominators that appear in the Rationals contained in a closed interval.

For example, consider the interval $[1/3, 1/2]$. It contains no integers, so no Rationals with denominator 1. It does contain Rationals with denominators 2 and 3 (the endpoints). It contains none with denominator 4, but it does contain $2/5$. It contains none with denominator 6 (though $1/3$ and $1/2$ are $2/6$ and $3/6$, those representations are not reduced). It contains $3/7$, $3/8$, and $4/9$ but none with denominator 10 ($0.4$ does not count because it is $2/5$). It contains all denominators greater than 10, so the complete list is $2, 3, 5, 7, 8, 9, 11, 12, 13, \ldots$.

Worst-case complexity per iteration

$T(n, i) = O(n + \log i)$

$M(n, i) = O(n + \log i)$

where $T$ is time, $M$ is additional memory, $i$ is the iteration number, and $n$ is max(a.significant_bits(), b.significant_bits()).

Panics

Panics if $a \geq b$.

use malachite_base::iterators::prefix_to_string;
use malachite_base::num::basic::traits::{One, Two};
use malachite_q::arithmetic::traits::DenominatorsInClosedInterval;
use malachite_q::Rational;

assert_eq!(
    prefix_to_string(
        Rational::denominators_in_closed_interval(Rational::ONE, Rational::TWO),
        20
    ),
    "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, ...]"
);
assert_eq!(
    prefix_to_string(
        Rational::denominators_in_closed_interval(
            Rational::from_signeds(1, 3),
            Rational::from_signeds(1, 2)
        ),
        20
    ),
    "[2, 3, 5, 7, 8, 9, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, ...]"
);
assert_eq!(
    prefix_to_string(
        Rational::denominators_in_closed_interval(
            Rational::from_signeds(1, 1000001),
            Rational::from_signeds(1, 1000000)
        ),
        20
    ),
    "[1000000, 1000001, 2000001, 3000001, 3000002, 4000001, 4000003, 5000001, 5000002, \
    5000003, 5000004, 6000001, 6000005, 7000001, 7000002, 7000003, 7000004, 7000005, \
    7000006, 8000001, ...]"
);

type Denominators = DenominatorsInClosedRationalInterval

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

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 Div<&Rational> for &Rational

fn div(self, other: &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

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: &Self) -> Self

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

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

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 for Rational

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

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

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 DivAssign<&Rational> for Rational

fn div_assign(&mut self, other: &Self)

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

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 for Rational

fn div_assign(&mut self, other: Self)

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

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 EqAbs<Integer> for Rational

fn eq_abs(&self, other: &Integer) -> bool

Determines whether the absolute values of a Rational and an Integer are equal.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

use malachite_base::num::comparison::traits::EqAbs;
use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert_eq!(Rational::from(-123).eq_abs(&Integer::from(122)), false);
assert_eq!(Rational::from(-123).eq_abs(&Integer::from(124)), false);
assert_eq!(
    Rational::from_signeds(22, 7).eq_abs(&Integer::from(123)),
    false
);
assert_eq!(
    Rational::from_signeds(-22, 7).eq_abs(&Integer::from(123)),
    false
);
assert_eq!(Rational::from(123).eq_abs(&Integer::from(123)), true);
assert_eq!(Rational::from(-123).eq_abs(&Integer::from(123)), true);
assert_eq!(
    Rational::from_signeds(22, 7).eq_abs(&Integer::from(123)),
    false
);
assert_eq!(
    Rational::from_signeds(22, 7).eq_abs(&Integer::from(123)),
    false
);
assert_eq!(Rational::from(-123).eq_abs(&Integer::from(-122)), false);
assert_eq!(Rational::from(-123).eq_abs(&Integer::from(-124)), false);
assert_eq!(
    Rational::from_signeds(22, 7).eq_abs(&Integer::from(-123)),
    false
);
assert_eq!(
    Rational::from_signeds(-22, 7).eq_abs(&Integer::from(1 - 23)),
    false
);
assert_eq!(Rational::from(123).eq_abs(&Integer::from(-123)), true);
assert_eq!(Rational::from(-123).eq_abs(&Integer::from(-123)), true);
assert_eq!(
    Rational::from_signeds(22, 7).eq_abs(&Integer::from(-123)),
    false
);
assert_eq!(
    Rational::from_signeds(22, 7).eq_abs(&Integer::from(-123)),
    false
);

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Natural> for Rational

fn eq_abs(&self, other: &Natural) -> bool

Determines whether the absolute values of a Rational and a Natural are equal.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

use malachite_base::num::comparison::traits::EqAbs;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(Rational::from(-123).eq_abs(&Natural::from(122u32)), false);
assert_eq!(Rational::from(-123).eq_abs(&Natural::from(124u32)), false);
assert_eq!(
    Rational::from_signeds(22, 7).eq_abs(&Natural::from(123u32)),
    false
);
assert_eq!(
    Rational::from_signeds(-22, 7).eq_abs(&Natural::from(123u32)),
    false
);
assert_eq!(Rational::from(123).eq_abs(&Natural::from(123u32)), true);
assert_eq!(Rational::from(-123).eq_abs(&Natural::from(123u32)), true);
assert_eq!(
    Rational::from_signeds(22, 7).eq_abs(&Natural::from(123u32)),
    false
);
assert_eq!(
    Rational::from_signeds(22, 7).eq_abs(&Natural::from(123u32)),
    false
);

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for Integer

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a Rational and an Integer are equal.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

use malachite_base::num::comparison::traits::EqAbs;
use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert_eq!(Integer::from(122).eq_abs(&Rational::from(-123)), false);
assert_eq!(Integer::from(124).eq_abs(&Rational::from(-123)), false);
assert_eq!(
    Integer::from(124).eq_abs(&Rational::from_signeds(22, 7)),
    false
);
assert_eq!(
    Integer::from(124).eq_abs(&Rational::from_signeds(-22, 7)),
    false
);
assert_eq!(Integer::from(123).eq_abs(&Rational::from(123)), true);
assert_eq!(Integer::from(123).eq_abs(&Rational::from(-123)), true);
assert_eq!(
    Integer::from(123).eq_abs(&Rational::from_signeds(22, 7)),
    false
);
assert_eq!(
    Integer::from(123).eq_abs(&Rational::from_signeds(-22, 7)),
    false
);
assert_eq!(Integer::from(-122).eq_abs(&Rational::from(-123)), false);
assert_eq!(Integer::from(-124).eq_abs(&Rational::from(-123)), false);
assert_eq!(
    Integer::from(-124).eq_abs(&Rational::from_signeds(22, 7)),
    false
);
assert_eq!(
    Integer::from(-124).eq_abs(&Rational::from_signeds(-22, 7)),
    false
);
assert_eq!(Integer::from(-123).eq_abs(&Rational::from(123)), true);
assert_eq!(Integer::from(-123).eq_abs(&Rational::from(-123)), true);
assert_eq!(
    Integer::from(-123).eq_abs(&Rational::from_signeds(22, 7)),
    false
);
assert_eq!(
    Integer::from(-123).eq_abs(&Rational::from_signeds(-22, 7)),
    false
);

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for Natural

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a Rational and a Natural are equal.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

use malachite_base::num::comparison::traits::EqAbs;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(Natural::from(122u32).eq_abs(&Rational::from(-123)), false);
assert_eq!(Natural::from(124u32).eq_abs(&Rational::from(-123)), false);
assert_eq!(
    Natural::from(124u32).eq_abs(&Rational::from_signeds(22, 7)),
    false
);
assert_eq!(
    Natural::from(124u32).eq_abs(&Rational::from_signeds(-22, 7)),
    false
);
assert_eq!(Natural::from(123u32).eq_abs(&Rational::from(123)), true);
assert_eq!(Natural::from(123u32).eq_abs(&Rational::from(-123)), true);
assert_eq!(
    Natural::from(123u32).eq_abs(&Rational::from_signeds(22, 7)),
    false
);
assert_eq!(
    Natural::from(123u32).eq_abs(&Rational::from_signeds(-22, 7)),
    false
);

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for f32

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a primitive float and a Rational are equal.

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().abs(), other.significant_bits()), and $m$ is self.sci_exponent().abs().

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for f64

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a primitive float and a Rational are equal.

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().abs(), other.significant_bits()), and $m$ is self.sci_exponent().abs().

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for i128

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a primitive signed integer and an Rational are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for i16

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a primitive signed integer and an Rational are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for i32

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a primitive signed integer and an Rational are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for i64

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a primitive signed integer and an Rational are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for i8

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a primitive signed integer and an Rational are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for isize

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a primitive signed integer and an Rational are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for u128

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a primitive unsigned integer and a Rational are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for u16

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a primitive unsigned integer and a Rational are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for u32

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a primitive unsigned integer and a Rational are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for u64

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a primitive unsigned integer and a Rational are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for u8

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a primitive unsigned integer and a Rational are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<Rational> for usize

fn eq_abs(&self, other: &Rational) -> bool

Determines whether the absolute values of a primitive unsigned integer and a Rational are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<f32> for Rational

fn eq_abs(&self, other: &f32) -> bool

Determines whether the absolute values of a Rational and a primitive float are equal.

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().abs()), and $m$ is other.sci_exponent().abs().

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<f64> for Rational

fn eq_abs(&self, other: &f64) -> bool

Determines whether the absolute values of a Rational and a primitive float are equal.

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().abs()), and $m$ is other.sci_exponent().abs().

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<i128> for Rational

fn eq_abs(&self, other: &i128) -> bool

Determines whether the absolute values of a Rational and a primitive signed integer are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<i16> for Rational

fn eq_abs(&self, other: &i16) -> bool

Determines whether the absolute values of a Rational and a primitive signed integer are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<i32> for Rational

fn eq_abs(&self, other: &i32) -> bool

Determines whether the absolute values of a Rational and a primitive signed integer are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<i64> for Rational

fn eq_abs(&self, other: &i64) -> bool

Determines whether the absolute values of a Rational and a primitive signed integer are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<i8> for Rational

fn eq_abs(&self, other: &i8) -> bool

Determines whether the absolute values of a Rational and a primitive signed integer are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<isize> for Rational

fn eq_abs(&self, other: &isize) -> bool

Determines whether the absolute values of a Rational and a primitive signed integer are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<u128> for Rational

fn eq_abs(&self, other: &u128) -> bool

Determines whether the absolute values of a Rational and a primitive unsigned integer are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<u16> for Rational

fn eq_abs(&self, other: &u16) -> bool

Determines whether the absolute values of a Rational and a primitive unsigned integer are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<u32> for Rational

fn eq_abs(&self, other: &u32) -> bool

Determines whether the absolute values of a Rational and a primitive unsigned integer are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<u64> for Rational

fn eq_abs(&self, other: &u64) -> bool

Determines whether the absolute values of a Rational and a primitive unsigned integer are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<u8> for Rational

fn eq_abs(&self, other: &u8) -> bool

Determines whether the absolute values of a Rational and a primitive unsigned integer are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs<usize> for Rational

fn eq_abs(&self, other: &usize) -> bool

Determines whether the absolute values of a Rational and a primitive unsigned integer are equal.

Worst-case complexity

Constant time and additional memory.

See here.

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl EqAbs for Rational

fn eq_abs(&self, other: &Self) -> bool

Determines whether the absolute values of two Rationals are equal.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

use malachite_base::num::comparison::traits::EqAbs;
use malachite_q::Rational;

assert_eq!(
    Rational::from_signeds(-22, 7).eq_abs(&Rational::from_signeds(-23, 7)),
    false
);
assert_eq!(
    Rational::from_signeds(-22, 7).eq_abs(&Rational::from_signeds(-24, 7)),
    false
);
assert_eq!(
    Rational::from_signeds(22, 7).eq_abs(&Rational::from_signeds(22, 7)),
    true
);
assert_eq!(
    Rational::from_signeds(22, 7).eq_abs(&Rational::from_signeds(-22, 7)),
    true
);
assert_eq!(
    Rational::from_signeds(-22, 7).eq_abs(&Rational::from_signeds(22, 7)),
    true
);
assert_eq!(
    Rational::from_signeds(-22, 7).eq_abs(&Rational::from_signeds(-22, 7)),
    true
);

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

Compares the absolute values of two numbers for inequality, taking both by reference.

impl Floor for &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

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

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

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

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 FloorLogBase<&Rational> for &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

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 FloorLogBase2 for &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

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 FloorLogBasePowerOf2<i64> for &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

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 From<&Integer> for Rational

fn from(value: &Integer) -> Self

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

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) -> Self

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

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

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

impl From<Integer> for Rational

fn from(value: Integer) -> Self

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

Worst-case complexity

Constant time and additional memory.

Examples

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) -> Self

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

Worst-case complexity

Constant time and additional memory.

Examples

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

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

impl From<bool> for Rational

fn from(b: bool) -> Self

Converts a bool to 0 or 1.

This function is known as the Iverson bracket.

$$ f(P) = [P] = \begin{cases} 1 & \text{if} \quad P, \\ 0 & \text{otherwise}. \end{cases} $$

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_q::Rational;

assert_eq!(Rational::from(false), 0);
assert_eq!(Rational::from(true), 1);

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<Self>

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

use malachite_base::num::conversion::string::options::FromSciStringOptions;
use malachite_base::num::conversion::traits::FromSciString;
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<Self, ()>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IsInteger for &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

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(-100).is_integer(), true);
assert_eq!(Rational::from_signeds(22, 7).is_integer(), false);
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

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 Mul<&Rational> for &Rational

fn mul(self, other: &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

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: &Self) -> Self

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

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

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 for Rational

fn mul(self, other: Self) -> Self

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

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 MulAssign<&Rational> for Rational

fn mul_assign(&mut self, other: &Self)

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

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

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

Examples

use malachite_base::num::basic::traits::{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 for Rational

fn mul_assign(&mut self, other: Self)

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

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

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 Neg for Rational

fn neg(self) -> Self

Negates a Rational, taking it by value.

$$ f(x) = -x. $$

Worst-case complexity

Constant time and additional memory.

Examples

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

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: Self

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

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 NextPowerOf2 for Rational

fn next_power_of_2(self) -> Self

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

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

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

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: Self

impl OneHalf for Rational

The constant 1/2.

const ONE_HALF: Self

impl Ord for Rational

fn cmp(&self, other: &Self) -> 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

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

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl OrdAbs for Rational

fn cmp_abs(&self, other: &Self) -> 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

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),
    Greater
);
assert_eq!(
    Rational::from_str("-2/3")
        .unwrap()
        .cmp_abs(&Rational::ONE_HALF),
    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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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().abs(), other.significant_bits()), and $m$ is self.sci_exponent().abs().

Examples

See here.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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().abs(), other.significant_bits()), and $m$ is self.sci_exponent().abs().

Examples

See here.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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().abs()), and $m$ is other.sci_exponent().abs().

Examples

See here.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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().abs()), and $m$ is other.sci_exponent().abs().

Examples

See here.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for Rational

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

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

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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

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

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

Examples

See here.

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

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

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

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

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

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

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

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

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

Examples

See here.

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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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().abs()).

Examples

See here.

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

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

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

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

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

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

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

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

impl 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().abs()).

Examples

See here.

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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl 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

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

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

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

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

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

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

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

impl PartialOrd for Rational

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

Compares two Rationals.

See the documentation for the Ord implementation.

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

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

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

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

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

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

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

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

impl 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

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(Greater)
);
assert_eq!(
    Rational::from_signeds(-22, 7).partial_cmp_abs(&Integer::from(-3)),
    Some(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

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(Greater)
);
assert_eq!(
    Rational::from_signeds(-22, 7).partial_cmp_abs(&Natural::from(3u32)),
    Some(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 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

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(Less)
);
assert_eq!(
    Integer::from(-3).partial_cmp_abs(&Rational::from_signeds(-22, 7)),
    Some(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 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

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(Less)
);
assert_eq!(
    Natural::from(3u32).partial_cmp_abs(&Rational::from_signeds(-22, 7)),
    Some(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().abs(), 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().abs(), 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 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 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 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 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<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 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 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<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().abs()).

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<f64> for 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().abs()).

Examples

See here.

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

Determines whether the absolute value of one number is less than the absolute value of another.

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

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

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

Determines whether the absolute value of one number is greater than the absolute value of another.

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

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<i128> for 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 PartialOrdAbs for Rational

fn partial_cmp_abs(&self, other: &Self) -> 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 Pow<i64> for &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

use malachite_base::num::arithmetic::traits::Pow;
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<i64> for Rational

fn pow(self, exp: i64) -> Self

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

use malachite_base::num::arithmetic::traits::Pow;
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 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

use malachite_base::num::arithmetic::traits::Pow;
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 Pow<u64> for Rational

fn pow(self, exp: u64) -> Self

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

use malachite_base::num::arithmetic::traits::Pow;
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

use malachite_base::num::arithmetic::traits::PowAssign;
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

use malachite_base::num::arithmetic::traits::PowAssign;
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) -> Self

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

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) -> Self

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

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<'a> Product<&'a Rational> for Rational

fn product<I>(xs: I) -> Self

where I: Iterator<Item = &'a Self>,

Multiplies together all the Rationals in an iterator of Rational references.

$$ f((x_i)_ {i=0}^{n-1}) = \prod_ {i=0}^{n-1} x_i. $$

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 Rational::sum(xs.map(Rational::significant_bits)).

Examples

use malachite_base::vecs::vec_from_str;
use malachite_q::Rational;
use std::iter::Product;

assert_eq!(
    Rational::product(
        vec_from_str::<Rational>("[1, 2/3, 3/4, 4/5, 5/6, 6/7, 7/8, 8/9, 9/10]")
            .unwrap()
            .iter()
    )
    .to_string(),
    "1/5"
);

impl Product for Rational

fn product<I>(xs: I) -> Self

where I: Iterator<Item = Self>,

Multiplies together all the Rationals in an iterator.

$$ f((x_i)_ {i=0}^{n-1}) = \prod_ {i=0}^{n-1} x_i. $$

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is Rational::sum(xs.map(Rational::significant_bits)).

Examples

use malachite_base::vecs::vec_from_str;
use malachite_q::Rational;
use std::iter::Product;

assert_eq!(
    Rational::product(
        vec_from_str::<Rational>("[1, 2/3, 3/4, 4/5, 5/6, 6/7, 7/8, 8/9, 9/10]")
            .unwrap()
            .into_iter()
    )
    .to_string(),
    "1/5"
);

impl Reciprocal for &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

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 Reciprocal for Rational

fn reciprocal(self) -> Self

Reciprocates a Rational, taking it by value.

$$ f(x) = 1/x. $$

Worst-case complexity

Constant time and additional memory.

Examples

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

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 RoundToMultiple<&Rational> for &Rational

fn round_to_multiple( self, other: &Rational, rm: RoundingMode, ) -> (Rational, Ordering)

Rounds a Rational to an integer multiple of another Rational, according to a specified rounding mode. Both Rationals are taken by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original 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

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

assert_eq!(
    (&Rational::from(-5))
        .round_to_multiple(&Rational::ZERO, Down)
        .to_debug_string(),
    "(0, Greater)"
);

let q = Rational::exact_from(std::f64::consts::PI);
let hundredth = Rational::from_signeds(1, 100);
assert_eq!(
    (&q).round_to_multiple(&hundredth, Down).to_debug_string(),
    "(157/50, Less)"
);
assert_eq!(
    (&q).round_to_multiple(&hundredth, Floor).to_debug_string(),
    "(157/50, Less)"
);
assert_eq!(
    (&q).round_to_multiple(&hundredth, Up).to_debug_string(),
    "(63/20, Greater)"
);
assert_eq!(
    (&q).round_to_multiple(&hundredth, Ceiling)
        .to_debug_string(),
    "(63/20, Greater)"
);
assert_eq!(
    (&q).round_to_multiple(&hundredth, Nearest)
        .to_debug_string(),
    "(157/50, Less)"
);

type Output = Rational

impl RoundToMultiple<&Rational> for Rational

fn round_to_multiple(self, other: &Self, rm: RoundingMode) -> (Self, Ordering)

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. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original 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

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

assert_eq!(
    Rational::from(-5)
        .round_to_multiple(&Rational::ZERO, Down)
        .to_debug_string(),
    "(0, Greater)"
);

let q = Rational::exact_from(std::f64::consts::PI);
let hundredth = Rational::from_signeds(1, 100);
assert_eq!(
    q.clone()
        .round_to_multiple(&hundredth, Down)
        .to_debug_string(),
    "(157/50, Less)"
);
assert_eq!(
    q.clone()
        .round_to_multiple(&hundredth, Floor)
        .to_debug_string(),
    "(157/50, Less)"
);
assert_eq!(
    q.clone()
        .round_to_multiple(&hundredth, Up)
        .to_debug_string(),
    "(63/20, Greater)"
);
assert_eq!(
    q.clone()
        .round_to_multiple(&hundredth, Ceiling)
        .to_debug_string(),
    "(63/20, Greater)"
);
assert_eq!(
    q.clone()
        .round_to_multiple(&hundredth, Nearest)
        .to_debug_string(),
    "(157/50, Less)"
);

type Output = Rational

impl RoundToMultiple<Rational> for &Rational

fn round_to_multiple( self, other: Rational, rm: RoundingMode, ) -> (Rational, Ordering)

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. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original 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

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

assert_eq!(
    (&Rational::from(-5))
        .round_to_multiple(Rational::ZERO, Down)
        .to_debug_string(),
    "(0, Greater)"
);

let q = Rational::exact_from(std::f64::consts::PI);
let hundredth = Rational::from_signeds(1, 100);
assert_eq!(
    (&q).round_to_multiple(hundredth.clone(), Down)
        .to_debug_string(),
    "(157/50, Less)"
);
assert_eq!(
    (&q).round_to_multiple(hundredth.clone(), Floor)
        .to_debug_string(),
    "(157/50, Less)"
);
assert_eq!(
    (&q).round_to_multiple(hundredth.clone(), Up)
        .to_debug_string(),
    "(63/20, Greater)"
);
assert_eq!(
    (&q).round_to_multiple(hundredth.clone(), Ceiling)
        .to_debug_string(),
    "(63/20, Greater)"
);
assert_eq!(
    (&q).round_to_multiple(hundredth.clone(), Nearest)
        .to_debug_string(),
    "(157/50, Less)"
);

type Output = Rational

impl RoundToMultiple for Rational

fn round_to_multiple(self, other: Self, rm: RoundingMode) -> (Self, Ordering)

Rounds a Rational to an integer multiple of another Rational, according to a specified rounding mode. Both Rationals are taken by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original 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

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

assert_eq!(
    Rational::from(-5)
        .round_to_multiple(Rational::ZERO, Down)
        .to_debug_string(),
    "(0, Greater)"
);

let q = Rational::exact_from(std::f64::consts::PI);
let hundredth = Rational::from_signeds(1, 100);
assert_eq!(
    q.clone()
        .round_to_multiple(hundredth.clone(), Down)
        .to_debug_string(),
    "(157/50, Less)"
);
assert_eq!(
    q.clone()
        .round_to_multiple(hundredth.clone(), Floor)
        .to_debug_string(),
    "(157/50, Less)"
);
assert_eq!(
    q.clone()
        .round_to_multiple(hundredth.clone(), Up)
        .to_debug_string(),
    "(63/20, Greater)"
);
assert_eq!(
    q.clone()
        .round_to_multiple(hundredth.clone(), Ceiling)
        .to_debug_string(),
    "(63/20, Greater)"
);
assert_eq!(
    q.clone()
        .round_to_multiple(hundredth.clone(), Nearest)
        .to_debug_string(),
    "(157/50, Less)"
);

type Output = Rational

impl RoundToMultipleAssign<&Rational> for Rational

fn round_to_multiple_assign( &mut self, other: &Self, rm: RoundingMode, ) -> Ordering

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. An Ordering is returned, indicating whether the returned value is less than, equal to, or greater than the original 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

use malachite_base::num::arithmetic::traits::RoundToMultipleAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_q::Rational;
use std::cmp::Ordering::*;

let mut x = Rational::from(-5);
assert_eq!(x.round_to_multiple_assign(&Rational::ZERO, Down), Greater);
assert_eq!(x, 0);

let q = Rational::exact_from(std::f64::consts::PI);
let hundredth = Rational::from_signeds(1, 100);

let mut x = q.clone();
assert_eq!(x.round_to_multiple_assign(&hundredth, Down), Less);
assert_eq!(x.to_string(), "157/50");

let mut x = q.clone();
assert_eq!(x.round_to_multiple_assign(&hundredth, Floor), Less);
assert_eq!(x.to_string(), "157/50");

let mut x = q.clone();
assert_eq!(x.round_to_multiple_assign(&hundredth, Up), Greater);
assert_eq!(x.to_string(), "63/20");

let mut x = q.clone();
assert_eq!(x.round_to_multiple_assign(&hundredth, Ceiling), Greater);
assert_eq!(x.to_string(), "63/20");

let mut x = q.clone();
assert_eq!(x.round_to_multiple_assign(&hundredth, Nearest), Less);
assert_eq!(x.to_string(), "157/50");

impl RoundToMultipleAssign for Rational

fn round_to_multiple_assign( &mut self, other: Self, rm: RoundingMode, ) -> Ordering

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. An Ordering is returned, indicating whether the returned value is less than, equal to, or greater than the original 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

use malachite_base::num::arithmetic::traits::RoundToMultipleAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_q::Rational;
use std::cmp::Ordering::*;

let mut x = Rational::from(-5);
assert_eq!(x.round_to_multiple_assign(Rational::ZERO, Down), Greater);
assert_eq!(x, 0);

let q = Rational::exact_from(std::f64::consts::PI);
let hundredth = Rational::from_signeds(1, 100);

let mut x = q.clone();
assert_eq!(x.round_to_multiple_assign(hundredth.clone(), Down), Less);
assert_eq!(x.to_string(), "157/50");

let mut x = q.clone();
assert_eq!(x.round_to_multiple_assign(hundredth.clone(), Floor), Less);
assert_eq!(x.to_string(), "157/50");

let mut x = q.clone();
assert_eq!(x.round_to_multiple_assign(hundredth.clone(), Up), Greater);
assert_eq!(x.to_string(), "63/20");

let mut x = q.clone();
assert_eq!(
    x.round_to_multiple_assign(hundredth.clone(), Ceiling),
    Greater
);
assert_eq!(x.to_string(), "63/20");

let mut x = q.clone();
assert_eq!(x.round_to_multiple_assign(hundredth.clone(), Nearest), Less);
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, Ordering)

Rounds a Rational to an integer multiple of $2^k$ according to a specified rounding mode. The Rational is taken by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original 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

use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

let q = Rational::exact_from(std::f64::consts::PI);
assert_eq!(
    (&q).round_to_multiple_of_power_of_2(-3, Floor)
        .to_debug_string(),
    "(25/8, Less)"
);
assert_eq!(
    (&q).round_to_multiple_of_power_of_2(-3, Down)
        .to_debug_string(),
    "(25/8, Less)"
);
assert_eq!(
    (&q).round_to_multiple_of_power_of_2(-3, Ceiling)
        .to_debug_string(),
    "(13/4, Greater)"
);
assert_eq!(
    (&q).round_to_multiple_of_power_of_2(-3, Up)
        .to_debug_string(),
    "(13/4, Greater)"
);
assert_eq!(
    (&q).round_to_multiple_of_power_of_2(-3, Nearest)
        .to_debug_string(),
    "(25/8, Less)"
);

type Output = Rational

impl RoundToMultipleOfPowerOf2<i64> for Rational

fn round_to_multiple_of_power_of_2( self, pow: i64, rm: RoundingMode, ) -> (Self, Ordering)

Rounds a Rational to an integer multiple of $2^k$ according to a specified rounding mode. The Rational is taken by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original 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

use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;

let q = Rational::exact_from(std::f64::consts::PI);
assert_eq!(
    q.clone()
        .round_to_multiple_of_power_of_2(-3, Floor)
        .to_debug_string(),
    "(25/8, Less)"
);
assert_eq!(
    q.clone()
        .round_to_multiple_of_power_of_2(-3, Down)
        .to_debug_string(),
    "(25/8, Less)"
);
assert_eq!(
    q.clone()
        .round_to_multiple_of_power_of_2(-3, Ceiling)
        .to_debug_string(),
    "(13/4, Greater)"
);
assert_eq!(
    q.clone()
        .round_to_multiple_of_power_of_2(-3, Up)
        .to_debug_string(),
    "(13/4, Greater)"
);
assert_eq!(
    q.clone()
        .round_to_multiple_of_power_of_2(-3, Nearest)
        .to_debug_string(),
    "(25/8, Less)"
);

type Output = Rational

impl RoundToMultipleOfPowerOf2Assign<i64> for Rational

fn round_to_multiple_of_power_of_2_assign( &mut self, pow: i64, rm: RoundingMode, ) -> Ordering

Rounds a Rational to a multiple of $2^k$ in place, according to a specified rounding mode. An Ordering is returned, indicating whether the returned value is less than, equal to, or greater than the original value.

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

use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2Assign;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_q::Rational;
use std::cmp::Ordering::*;

let q = Rational::exact_from(std::f64::consts::PI);

let mut x = q.clone();
assert_eq!(x.round_to_multiple_of_power_of_2_assign(-3, Floor), Less);
assert_eq!(x.to_string(), "25/8");

let mut x = q.clone();
assert_eq!(x.round_to_multiple_of_power_of_2_assign(-3, Down), Less);
assert_eq!(x.to_string(), "25/8");

let mut x = q.clone();
assert_eq!(
    x.round_to_multiple_of_power_of_2_assign(-3, Ceiling),
    Greater
);
assert_eq!(x.to_string(), "13/4");

let mut x = q.clone();
assert_eq!(x.round_to_multiple_of_power_of_2_assign(-3, Up), Greater);
assert_eq!(x.to_string(), "13/4");

let mut x = q.clone();
assert_eq!(x.round_to_multiple_of_power_of_2_assign(-3, Nearest), Less);
assert_eq!(x.to_string(), "25/8");

impl RoundingFrom<&Rational> for Integer

fn rounding_from(x: &Rational, rm: RoundingMode) -> (Self, Ordering)

Converts a Rational to an Integer, using a specified RoundingMode and taking the Rational by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original 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

use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert_eq!(
    Integer::rounding_from(&Rational::from(123), Exact).to_debug_string(),
    "(123, Equal)"
);
assert_eq!(
    Integer::rounding_from(&Rational::from(-123), Exact).to_debug_string(),
    "(-123, Equal)"
);

assert_eq!(
    Integer::rounding_from(&Rational::from_signeds(22, 7), Floor).to_debug_string(),
    "(3, Less)"
);
assert_eq!(
    Integer::rounding_from(&Rational::from_signeds(22, 7), Down).to_debug_string(),
    "(3, Less)"
);
assert_eq!(
    Integer::rounding_from(&Rational::from_signeds(22, 7), Ceiling).to_debug_string(),
    "(4, Greater)"
);
assert_eq!(
    Integer::rounding_from(&Rational::from_signeds(22, 7), Up).to_debug_string(),
    "(4, Greater)"
);
assert_eq!(
    Integer::rounding_from(&Rational::from_signeds(22, 7), Nearest).to_debug_string(),
    "(3, Less)"
);

assert_eq!(
    Integer::rounding_from(Rational::from_signeds(-22, 7), Floor).to_debug_string(),
    "(-4, Less)"
);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(-22, 7), Down).to_debug_string(),
    "(-3, Greater)"
);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(-22, 7), Ceiling).to_debug_string(),
    "(-3, Greater)"
);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(-22, 7), Up).to_debug_string(),
    "(-4, Less)"
);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(-22, 7), Nearest).to_debug_string(),
    "(-3, Greater)"
);

impl RoundingFrom<&Rational> for Natural

fn rounding_from(x: &Rational, rm: RoundingMode) -> (Self, Ordering)

Converts a Rational to a Natural, using a specified RoundingMode and taking the Rational by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the 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

use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(
    Natural::rounding_from(&Rational::from(123), Exact).to_debug_string(),
    "(123, Equal)"
);

assert_eq!(
    Natural::rounding_from(&Rational::from_signeds(22, 7), Floor).to_debug_string(),
    "(3, Less)"
);
assert_eq!(
    Natural::rounding_from(&Rational::from_signeds(22, 7), Down).to_debug_string(),
    "(3, Less)"
);
assert_eq!(
    Natural::rounding_from(&Rational::from_signeds(22, 7), Ceiling).to_debug_string(),
    "(4, Greater)"
);
assert_eq!(
    Natural::rounding_from(&Rational::from_signeds(22, 7), Up).to_debug_string(),
    "(4, Greater)"
);
assert_eq!(
    Natural::rounding_from(&Rational::from_signeds(22, 7), Nearest).to_debug_string(),
    "(3, Less)"
);

assert_eq!(
    Natural::rounding_from(&Rational::from(-123), Down).to_debug_string(),
    "(0, Greater)"
);
assert_eq!(
    Natural::rounding_from(&Rational::from(-123), Ceiling).to_debug_string(),
    "(0, Greater)"
);
assert_eq!(
    Natural::rounding_from(&Rational::from(-123), Nearest).to_debug_string(),
    "(0, Greater)"
);

impl RoundingFrom<&Rational> for f32

fn rounding_from(value: &Rational, rm: RoundingMode) -> (f32, Ordering)

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 RoundingFrom<&Rational> for f64

fn rounding_from(value: &Rational, rm: RoundingMode) -> (f64, Ordering)

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 i128

fn rounding_from(value: &Rational, rm: RoundingMode) -> (i128, Ordering)

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, Ordering)

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, Ordering)

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, Ordering)

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 i8

fn rounding_from(value: &Rational, rm: RoundingMode) -> (i8, Ordering)

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, Ordering)

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 u128

fn rounding_from(value: &Rational, rm: RoundingMode) -> (u128, Ordering)

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, Ordering)

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, Ordering)

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, Ordering)

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 u8

fn rounding_from(value: &Rational, rm: RoundingMode) -> (u8, Ordering)

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, Ordering)

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) -> (Self, Ordering)

Converts a Rational to an Integer, using a specified RoundingMode and taking the Rational by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original 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

use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;
use malachite_q::Rational;

assert_eq!(
    Integer::rounding_from(Rational::from(123), Exact).to_debug_string(),
    "(123, Equal)"
);
assert_eq!(
    Integer::rounding_from(Rational::from(-123), Exact).to_debug_string(),
    "(-123, Equal)"
);

assert_eq!(
    Integer::rounding_from(Rational::from_signeds(22, 7), Floor).to_debug_string(),
    "(3, Less)"
);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(22, 7), Down).to_debug_string(),
    "(3, Less)"
);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(22, 7), Ceiling).to_debug_string(),
    "(4, Greater)"
);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(22, 7), Up).to_debug_string(),
    "(4, Greater)"
);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(22, 7), Nearest).to_debug_string(),
    "(3, Less)"
);

assert_eq!(
    Integer::rounding_from(Rational::from_signeds(-22, 7), Floor).to_debug_string(),
    "(-4, Less)"
);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(-22, 7), Down).to_debug_string(),
    "(-3, Greater)"
);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(-22, 7), Ceiling).to_debug_string(),
    "(-3, Greater)"
);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(-22, 7), Up).to_debug_string(),
    "(-4, Less)"
);
assert_eq!(
    Integer::rounding_from(Rational::from_signeds(-22, 7), Nearest).to_debug_string(),
    "(-3, Greater)"
);

impl RoundingFrom<Rational> for Natural

fn rounding_from(x: Rational, rm: RoundingMode) -> (Self, Ordering)

Converts a Rational to a Natural, using a specified RoundingMode and taking the Rational by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the 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

use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use malachite_q::Rational;

assert_eq!(
    Natural::rounding_from(Rational::from(123), Exact).to_debug_string(),
    "(123, Equal)"
);

assert_eq!(
    Natural::rounding_from(Rational::from_signeds(22, 7), Floor).to_debug_string(),
    "(3, Less)"
);
assert_eq!(
    Natural::rounding_from(Rational::from_signeds(22, 7), Down).to_debug_string(),
    "(3, Less)"
);
assert_eq!(
    Natural::rounding_from(Rational::from_signeds(22, 7), Ceiling).to_debug_string(),
    "(4, Greater)"
);
assert_eq!(
    Natural::rounding_from(Rational::from_signeds(22, 7), Up).to_debug_string(),
    "(4, Greater)"
);
assert_eq!(
    Natural::rounding_from(Rational::from_signeds(22, 7), Nearest).to_debug_string(),
    "(3, Less)"
);

assert_eq!(
    Natural::rounding_from(Rational::from(-123), Down).to_debug_string(),
    "(0, Greater)"
);
assert_eq!(
    Natural::rounding_from(Rational::from(-123), Ceiling).to_debug_string(),
    "(0, Greater)"
);
assert_eq!(
    Natural::rounding_from(Rational::from(-123), Nearest).to_debug_string(),
    "(0, Greater)"
);

impl RoundingFrom<Rational> for f32

fn rounding_from(value: Rational, rm: RoundingMode) -> (f32, Ordering)

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, Ordering)

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> 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_round. $$ 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_round. $$ 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 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 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_round. $$ 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_round. $$ 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> 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_round. $$ 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_round. $$ 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 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 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_round. $$ 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_round. $$ 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 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<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 Shl<i16> for &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<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 Shl<i32> for &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<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 Shl<i64> for &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<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 Shl<i8> for &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<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 Shl<isize> for &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<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 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 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 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 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 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 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 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 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 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 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 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 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 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 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<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 Shr<i16> for &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<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 Shr<i32> for &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<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 Shr<i64> for &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<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 Shr<i8> for &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<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 Shr<isize> for &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<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 Shr<u128> for &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<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 Shr<u16> for &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<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 Shr<u32> for &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<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 Shr<u64> for &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<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 Shr<u8> for &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<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 Shr<usize> for &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 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 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

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(), Equal);
assert_eq!(Rational::from_signeds(22, 7).sign(), Greater);
assert_eq!(Rational::from_signeds(-22, 7).sign(), Less);

impl SignificantBits for &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

use malachite_base::num::basic::traits::Zero;
use malachite_base::num::logic::traits::SignificantBits;
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: &Self, y: &Self) -> 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

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: &Self, y: &Self) -> 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

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

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 Square for Rational

fn square(self) -> Self

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

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

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 Sub<&Rational> for &Rational

fn sub(self, other: &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

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: &Self) -> Self

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

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

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 for Rational

fn sub(self, other: Self) -> Self

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

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 SubAssign<&Rational> for Rational

fn sub_assign(&mut self, other: &Self)

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

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 for Rational

fn sub_assign(&mut self, other: Self)

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

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<'a> Sum<&'a Rational> for Rational

fn sum<I>(xs: I) -> Self

where I: Iterator<Item = &'a Self>,

Adds up all the Rationals in an iterator of Rational references.

$$ f((x_i)_ {i=0}^{n-1}) = \sum_ {i=0}^{n-1} x_i. $$

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is Rational::sum(xs.map(Rational::significant_bits)).

Examples

use malachite_base::vecs::vec_from_str;
use malachite_q::Rational;
use std::iter::Sum;

assert_eq!(
    Rational::sum(
        vec_from_str::<Rational>("[0, 1, 2/3, 3/4, 4/5, 5/6, 6/7, 7/8, 8/9, 9/10]")
            .unwrap()
            .iter()
    )
    .to_string(),
    "19079/2520"
);

impl Sum for Rational

fn sum<I>(xs: I) -> Self

where I: Iterator<Item = Self>,

Adds up all the Rationals in an iterator.

$$ f((x_i)_ {i=0}^{n-1}) = \sum_ {i=0}^{n-1} x_i. $$

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is Rational::sum(xs.map(Rational::significant_bits)).

Examples

use malachite_base::vecs::vec_from_str;
use malachite_q::Rational;
use std::iter::Sum;

assert_eq!(
    Rational::sum(
        vec_from_str::<Rational>("[0, 1, 2/3, 3/4, 4/5, 5/6, 6/7, 7/8, 8/9, 9/10]")
            .unwrap()
            .into_iter()
    )
    .to_string(),
    "19079/2520"
);

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

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(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

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(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(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 TryFrom<&Rational> for Integer

fn try_from(x: &Rational) -> Result<Self, Self::Error>

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

use malachite_nz::integer::Integer;
use malachite_q::conversion::integer_from_rational::IntegerFromRationalError;
use malachite_q::Rational;

assert_eq!(Integer::try_from(&Rational::from(123)).unwrap(), 123);
assert_eq!(Integer::try_from(&Rational::from(-123)).unwrap(), -123);
assert_eq!(
    Integer::try_from(&Rational::from_signeds(22, 7)),
    Err(IntegerFromRationalError)
);

type Error = IntegerFromRationalError

The type returned in the event of a conversion error.

impl TryFrom<&Rational> for Natural

fn try_from(x: &Rational) -> Result<Self, Self::Error>

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

use malachite_nz::natural::Natural;
use malachite_q::conversion::natural_from_rational::NaturalFromRationalError;
use malachite_q::Rational;

assert_eq!(Natural::try_from(&Rational::from(123)).unwrap(), 123);
assert_eq!(
    Natural::try_from(&Rational::from(-123)),
    Err(NaturalFromRationalError)
);
assert_eq!(
    Natural::try_from(&Rational::from_signeds(22, 7)),
    Err(NaturalFromRationalError)
);

type Error = NaturalFromRationalError

The type returned in the event of a conversion error.

impl TryFrom<&Rational> for f32

fn try_from(value: &Rational) -> Result<f32, Self::Error>

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

See here.

type Error = FloatConversionError

The type returned in the event of a conversion error.

impl TryFrom<&Rational> for f64

fn try_from(value: &Rational) -> Result<f64, Self::Error>

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

See here.

type Error = FloatConversionError

The type returned in the event of a conversion error.

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

fn try_from(value: &Rational) -> Result<i128, SignedFromRationalError>

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromRationalError

The type returned in the event of a conversion error.

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

fn try_from(value: &Rational) -> Result<i16, SignedFromRationalError>

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromRationalError

The type returned in the event of a conversion error.

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

fn try_from(value: &Rational) -> Result<i32, SignedFromRationalError>

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromRationalError

The type returned in the event of a conversion error.

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

fn try_from(value: &Rational) -> Result<i64, SignedFromRationalError>

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromRationalError

The type returned in the event of a conversion error.

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

fn try_from(value: &Rational) -> Result<i8, SignedFromRationalError>

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromRationalError

The type returned in the event of a conversion error.

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

fn try_from(value: &Rational) -> Result<isize, SignedFromRationalError>

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = SignedFromRationalError

The type returned in the event of a conversion error.

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

fn try_from(value: &Rational) -> Result<u128, UnsignedFromRationalError>

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromRationalError

The type returned in the event of a conversion error.

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

fn try_from(value: &Rational) -> Result<u16, UnsignedFromRationalError>

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromRationalError

The type returned in the event of a conversion error.

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

fn try_from(value: &Rational) -> Result<u32, UnsignedFromRationalError>

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromRationalError

The type returned in the event of a conversion error.

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

fn try_from(value: &Rational) -> Result<u64, UnsignedFromRationalError>

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromRationalError

The type returned in the event of a conversion error.

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

fn try_from(value: &Rational) -> Result<u8, UnsignedFromRationalError>

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromRationalError

The type returned in the event of a conversion error.

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

fn try_from(value: &Rational) -> Result<usize, UnsignedFromRationalError>

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type Error = UnsignedFromRationalError

The type returned in the event of a conversion error.

impl TryFrom<Rational> for Integer

fn try_from(x: Rational) -> Result<Self, Self::Error>

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

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_nz::integer::Integer;
use malachite_q::conversion::integer_from_rational::IntegerFromRationalError;
use malachite_q::Rational;

assert_eq!(Integer::try_from(Rational::from(123)).unwrap(), 123);
assert_eq!(Integer::try_from(Rational::from(-123)).unwrap(), -123);
assert_eq!(
    Integer::try_from(Rational::from_signeds(22, 7)),
    Err(IntegerFromRationalError)
);

type Error = IntegerFromRationalError

The type returned in the event of a conversion error.

impl TryFrom<Rational> for Natural

fn try_from(x: Rational) -> Result<Self, Self::Error>

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

Worst-case complexity

Constant time and additional memory.

Examples

use malachite_nz::natural::Natural;
use malachite_q::conversion::natural_from_rational::NaturalFromRationalError;
use malachite_q::Rational;

assert_eq!(Natural::try_from(Rational::from(123)).unwrap(), 123);
assert_eq!(
    Natural::try_from(Rational::from(-123)),
    Err(NaturalFromRationalError)
);
assert_eq!(
    Natural::try_from(Rational::from_signeds(22, 7)),
    Err(NaturalFromRationalError)
);

type Error = NaturalFromRationalError

The type returned in the event of a conversion error.

impl TryFrom<Rational> for f32

fn try_from(value: Rational) -> Result<f32, Self::Error>

Converts a Rational to a primitive float, taking the Rational by value. If the input isn’t exactly equal to any float, an error 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.

type Error = FloatConversionError

The type returned in the event of a conversion error.

impl TryFrom<Rational> for f64

fn try_from(value: Rational) -> Result<f64, Self::Error>

Converts a Rational to a primitive float, taking the Rational by value. If the input isn’t exactly equal to any float, an error 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.

type Error = FloatConversionError

The type returned in the event of a conversion error.

impl TryFrom<f32> for Rational

fn try_from(value: f32) -> Result<Rational, Self::Error>

Converts a primitive float to the equivalent Rational. If the floating point value is NaN or infinite, an error is returned.

This conversion is literal. For example, Rational::try_from(0.1f32) evaluates to Some($13421773/134217728$). If you want $1/10$ instead, use try_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().

Examples

See here.

type Error = RationalFromPrimitiveFloatError

The type returned in the event of a conversion error.

impl TryFrom<f64> for Rational

fn try_from(value: f64) -> Result<Rational, Self::Error>

Converts a primitive float to the equivalent Rational. If the floating point value is NaN or infinite, an error is returned.

This conversion is literal. For example, Rational::try_from(0.1f32) evaluates to Some($13421773/134217728$). If you want $1/10$ instead, use try_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().

Examples

See here.

type Error = RationalFromPrimitiveFloatError

The type returned in the event of a conversion error.

impl Two for Rational

The constant 2.

const TWO: Self

impl Zero for Rational

The constant 0.

const ZERO: Self

impl Eq for Rational

impl StructuralPartialEq for Rational