Struct malachite_q::Rational
source · [−]pub struct Rational { /* private fields */ }
Expand description
A rational number.
Implementations
sourceimpl Rational
impl Rational
sourcepub fn approx_log(&self) -> f64
pub fn approx_log(&self) -> f64
Calculates the approximate natural logarithm of a positive Rational
.
$f(x) = (1+\epsilon)(\log x)$, where $|\epsilon| < 2^{-52}.$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{Pow, PowerOf2};
use malachite_base::num::float::NiceFloat;
use malachite_q::Rational;
assert_eq!(NiceFloat(Rational::from(10i32).approx_log()), NiceFloat(2.3025850929940455));
assert_eq!(
NiceFloat(Rational::from(10i32).pow(100u64).approx_log()),
NiceFloat(230.25850929940455)
);
assert_eq!(
NiceFloat(Rational::power_of_2(1000000u64).approx_log()),
NiceFloat(693147.1805599453)
);
assert_eq!(
NiceFloat(Rational::power_of_2(-1000000i64).approx_log()),
NiceFloat(-693147.1805599453)
);
This is equivalent to fmpz_dlog
from fmpz/dlog.c
, FLINT 2.7.1.
sourceimpl Rational
impl Rational
sourcepub fn cmp_complexity(&self, other: &Rational) -> Ordering
pub fn cmp_complexity(&self, other: &Rational) -> Ordering
Compares two Rational
s according to their complexity.
Complexity is defined as follows: If two Rational
s 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 Rational
s 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 Rational
s under this order is
$\omega^2$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
use malachite_q::Rational;
use std::cmp::Ordering;
assert_eq!(
Rational::from_signeds(1, 2).cmp_complexity(&Rational::from_signeds(1, 3)),
Ordering::Less
);
assert_eq!(
Rational::from_signeds(1, 2).cmp_complexity(&Rational::from_signeds(3, 2)),
Ordering::Less
);
assert_eq!(
Rational::from_signeds(1, 2).cmp_complexity(&Rational::from_signeds(-1, 2)),
Ordering::Less
);
sourceimpl Rational
impl Rational
sourcepub fn from_continued_fraction<I: Iterator<Item = Natural>>(
floor: Integer,
xs: I
) -> Rational
pub fn from_continued_fraction<I: Iterator<Item = Natural>>(
floor: Integer,
xs: I
) -> Rational
Converts a finite continued fraction to a Rational
, taking the inputs by value.
The input has two components. The first is the first value of the continued fraction, which
may be any Integer
and is equal to the floor of the
Rational
. The second is an iterator of the remaining values, which must all be
positive. Using the standard notation for continued fractions, the first value is the
number before the semicolon, and the second value contains the remaining numbers.
Each rational number has two continued fraction representations. Either one is a valid input.
$f(a_0, (a_1, a_2, a_3, \ldots)) = [a_0; a_1, a_2, a_3, \ldots]$.
Worst-case complexity
$T(n, m) = O((nm)^2 \log (nm) \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is
max(floor.significant_bits(), xs.map(Natural::significant_bits).max())
, and $m$ is
xs.count()
.
Panics
Panics if any Natural
in xs
is zero.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::basic::traits::Zero;
use malachite_base::vecs::vec_from_str;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
let xs = vec_from_str("[1, 2]").unwrap().into_iter();
assert_eq!(Rational::from_continued_fraction(Integer::ZERO, xs).to_string(), "2/3");
let xs = vec_from_str("[7, 16]").unwrap().into_iter();
assert_eq!(Rational::from_continued_fraction(Integer::from(3), xs).to_string(), "355/113");
sourcepub fn from_continued_fraction_ref<'a, I: Iterator<Item = &'a Natural>>(
floor: &Integer,
xs: I
) -> Rational
pub fn from_continued_fraction_ref<'a, I: Iterator<Item = &'a Natural>>(
floor: &Integer,
xs: I
) -> Rational
Converts a finite continued fraction to a Rational
, taking the inputs by reference.
The input has two components. The first is the first value of the continued fraction, which
may be any Integer
and is equal to the floor of the
Rational
. The second is an iterator of the remaining values, which must all be
positive. Using the standard notation for continued fractions, the first value is the
number before the semicolon, and the second value contains the remaining numbers.
Each rational number has two continued fraction representations. Either one is a valid input.
$f(a_0, (a_1, a_2, a_3, \ldots)) = [a_0; a_1, a_2, a_3, \ldots]$.
Worst-case complexity
$T(n, m) = O((nm)^2 \log (nm) \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is
max(floor.significant_bits(), xs.map(Natural::significant_bits).max())
, and $m$ is
xs.count()
.
Panics
Panics if any Natural
in xs
is zero.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::basic::traits::Zero;
use malachite_base::vecs::vec_from_str;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
let xs = vec_from_str("[1, 2]").unwrap();
assert_eq!(
Rational::from_continued_fraction_ref(&Integer::ZERO, xs.iter()).to_string(),
"2/3"
);
let xs = vec_from_str("[7, 16]").unwrap();
assert_eq!(
Rational::from_continued_fraction_ref(&Integer::from(3), xs.iter()).to_string(),
"355/113"
);
sourceimpl Rational
impl Rational
sourcepub fn digits(&self, base: &Natural) -> (Vec<Natural>, RationalDigits)
pub fn digits(&self, base: &Natural) -> (Vec<Natural>, RationalDigits)
Returns the base-$b$ digits of a Rational
.
The output has two components. The first is a Vec
of the digits of the integer portion
of the Rational
, least- to most-significant. The second is an iterator of the digits of
the fractional portion.
The output is in its simplest form: the integer-portion digits do not end with a zero, and the fractional-portion digits do not end with infinitely many zeros or $(b-1)$s.
If the Rational
has a small denominator, it may be more efficient to use
to_digits
or into_digits
instead. These
functions compute the entire repeating portion of the repeating digits.
For example, consider these two expressions:
Rational::from_signeds(1, 7).digits(Natural::from(10u32)).1.nth(1000)
Rational::from_signeds(1, 7).into_digits(Natural::from(10u32)).1[1000]
Both get the thousandth digit after the decimal point of 1/7
. The first way explicitly
calculates each digit after the decimal point, whereas the second way determines that 1/7
is 0.(142857)
, with the 142857
repeating, and takes 1000 % 6 == 4
to determine that
the thousandth digit is 5. But when the Rational
has a large denominator, the second
way is less efficient.
Worst-case complexity per iteration
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), base.significant_bits())
.
Panics
Panics if base
is less than 2.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::iterators::prefix_to_string;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
let (before_point, after_point) = Rational::from(3u32).digits(&Natural::from(10u32));
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(prefix_to_string(after_point, 10), "[]");
let (before_point, after_point) =
Rational::from_signeds(22, 7).digits(&Natural::from(10u32));
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(prefix_to_string(after_point, 10), "[1, 4, 2, 8, 5, 7, 1, 4, 2, 8, ...]");
sourceimpl Rational
impl Rational
sourcepub fn from_digits(
base: &Natural,
before_point: Vec<Natural>,
after_point: RationalSequence<Natural>
) -> Rational
pub fn from_digits(
base: &Natural,
before_point: Vec<Natural>,
after_point: RationalSequence<Natural>
) -> Rational
Converts base-$b$ digits to a Rational
. The inputs are taken by value.
The input consists of the digits of the integer portion of the Rational
and the digits
of the fractional portion. The integer-portion digits are ordered from least- to
most-significant, and the fractional-portion digits from most- to least.
The fractional-portion digits may end in infinitely many zeros or $(b-1)$s; these are handled correctly.
Worst-case complexity
$T(n, m) = O(nm \log (nm)^2 \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is
max(before_point.len(), after_point.component_len())
, and $m$ is
base.significant_bits()
.
Panics
Panics if base
is less than 2.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::rational_sequences::RationalSequence;
use malachite_base::vecs::vec_from_str;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
let before_point = vec_from_str("[3]").unwrap();
let after_point = RationalSequence::from_vecs(
Vec::new(),
vec_from_str("[1, 4, 2, 8, 5, 7]").unwrap(),
);
assert_eq!(
Rational::from_digits(&Natural::from(10u32), before_point, after_point).to_string(),
"22/7"
);
// 21.34565656...
let before_point = vec_from_str("[1, 2]").unwrap();
let after_point = RationalSequence::from_vecs(
vec_from_str("[3, 4]").unwrap(),
vec_from_str("[5, 6]").unwrap(),
);
assert_eq!(
Rational::from_digits(&Natural::from(10u32), before_point, after_point).to_string(),
"105661/4950"
);
sourcepub fn from_digits_ref(
base: &Natural,
before_point: &[Natural],
after_point: &RationalSequence<Natural>
) -> Rational
pub fn from_digits_ref(
base: &Natural,
before_point: &[Natural],
after_point: &RationalSequence<Natural>
) -> Rational
Converts base-$b$ digits to a Rational
. The inputs are taken by reference.
The input consists of the digits of the integer portion of the Rational
and the digits
of the fractional portion. The integer-portion digits are ordered from least- to
most-significant, and the fractional-portion digits from most- to least.
The fractional-portion digits may end in infinitely many zeros or $(b-1)$s; these are handled correctly.
Worst-case complexity
$T(n, m) = O(nm \log (nm)^2 \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is
max(before_point.len(), after_point.component_len())
, and $m$ is
base.significant_bits()
.
Panics
Panics if base
is less than 2.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::rational_sequences::RationalSequence;
use malachite_base::vecs::vec_from_str;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
let before_point = vec_from_str("[3]").unwrap();
let after_point = RationalSequence::from_vecs(
Vec::new(),
vec_from_str("[1, 4, 2, 8, 5, 7]").unwrap(),
);
assert_eq!(
Rational::from_digits_ref(&Natural::from(10u32), &before_point, &after_point)
.to_string(),
"22/7"
);
// 21.34565656...
let before_point = vec_from_str("[1, 2]").unwrap();
let after_point = RationalSequence::from_vecs(
vec_from_str("[3, 4]").unwrap(),
vec_from_str("[5, 6]").unwrap(),
);
assert_eq!(
Rational::from_digits_ref(&Natural::from(10u32), &before_point, &after_point)
.to_string(),
"105661/4950"
);
sourceimpl Rational
impl Rational
sourcepub fn from_power_of_2_digits(
log_base: u64,
before_point: Vec<Natural>,
after_point: RationalSequence<Natural>
) -> Rational
pub fn from_power_of_2_digits(
log_base: u64,
before_point: Vec<Natural>,
after_point: RationalSequence<Natural>
) -> Rational
Converts base-$2^k$ digits to a Rational
. The inputs are taken by value.
The input consists of the digits of the integer portion of the Rational
and the digits
of the fractional portion. The integer-portion digits are ordered from least- to
most-significant, and the fractional-portion digits from most- to least.
The fractional-portion digits may end in infinitely many zeros or $(2^k-1)$s; these are handled correctly.
Worst-case complexity
$T(n, m) = O(nm)$
$M(n, m) = O(nm)$
where $T$ is time, $M$ is additional memory, $n$ is
max(before_point.len(), after_point.component_len())
, and $m$ is
base.significant_bits()
.
Panics
Panics if log_base
is zero.
Examples
extern crate malachite_base;
use malachite_base::rational_sequences::RationalSequence;
use malachite_base::vecs::vec_from_str;
use malachite_q::Rational;
let before_point = vec_from_str("[1, 1]").unwrap();
let after_point = RationalSequence::from_vecs(
vec_from_str("[0]").unwrap(),
vec_from_str("[0, 0, 1]").unwrap(),
);
assert_eq!(
Rational::from_power_of_2_digits(1, before_point, after_point).to_string(),
"43/14"
);
// 21.34565656..._32
let before_point = vec_from_str("[1, 2]").unwrap();
let after_point = RationalSequence::from_vecs(
vec_from_str("[3, 4]").unwrap(),
vec_from_str("[5, 6]").unwrap(),
);
assert_eq!(
Rational::from_power_of_2_digits(5, before_point, after_point).to_string(),
"34096673/523776"
);
sourcepub fn from_power_of_2_digits_ref(
log_base: u64,
before_point: &[Natural],
after_point: &RationalSequence<Natural>
) -> Rational
pub fn from_power_of_2_digits_ref(
log_base: u64,
before_point: &[Natural],
after_point: &RationalSequence<Natural>
) -> Rational
Converts base-$2^k$ digits to a Rational
. The inputs are taken by reference.
The input consists of the digits of the integer portion of the Rational
and the digits
of the fractional portion. The integer-portion digits are ordered from least- to
most-significant, and the fractional-portion digits from most- to least.
The fractional-portion digits may end in infinitely many zeros or $(2^k-1)$s; these are handled correctly.
Worst-case complexity
$T(n, m) = O(nm)$
$M(n, m) = O(nm)$
where $T$ is time, $M$ is additional memory, $n$ is
max(before_point.len(), after_point.component_len())
, and $m$ is
base.significant_bits()
.
Panics
Panics if log_base
is zero.
Examples
extern crate malachite_base;
use malachite_base::rational_sequences::RationalSequence;
use malachite_base::vecs::vec_from_str;
use malachite_q::Rational;
let before_point = vec_from_str("[1, 1]").unwrap();
let after_point = RationalSequence::from_vecs(
vec_from_str("[0]").unwrap(),
vec_from_str("[0, 0, 1]").unwrap(),
);
assert_eq!(
Rational::from_power_of_2_digits_ref(1, &before_point, &after_point).to_string(),
"43/14"
);
// 21.34565656..._32
let before_point = vec_from_str("[1, 2]").unwrap();
let after_point = RationalSequence::from_vecs(
vec_from_str("[3, 4]").unwrap(),
vec_from_str("[5, 6]").unwrap(),
);
assert_eq!(
Rational::from_power_of_2_digits_ref(5, &before_point, &after_point).to_string(),
"34096673/523776"
);
sourceimpl Rational
impl Rational
sourcepub fn power_of_2_digits(
&self,
log_base: u64
) -> (Vec<Natural>, RationalPowerOf2Digits)
pub fn power_of_2_digits(
&self,
log_base: u64
) -> (Vec<Natural>, RationalPowerOf2Digits)
Returns the base-$2^k$ digits of a Rational
.
The output has two components. The first is a Vec
of the digits of the integer portion
of the Rational
, least- to most-significant. The second is an iterator of the digits of
the fractional portion.
The output is in its simplest form: the integer-portion digits do not end with a zero, and the fractional-portion digits do not end with infinitely many zeros or $(2^k-1)$s.
If the Rational
has a small denominator, it may be more efficient to use
to_power_of_2_digits
or
into_power_of_2_digits
instead. These functions
compute the entire repeating portion of the repeating digits.
For example, consider these two expressions:
Rational::from_signeds(1, 7).power_of_2_digits(1).1.nth(1000)
Rational::from_signeds(1, 7).into_power_of_2_digits(1).1[1000]
Both get the thousandth digit after the binary point of 1/7
. The first way explicitly
calculates each bit after the binary point, whereas the second way determines that 1/7
is
0.(001)
, with the 001
repeating, and takes 1000 % 3 == 1
to determine that the
thousandth bit is 0. But when the Rational
has a large denominator, the second way is
less efficient.
Worst-case complexity per iteration
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), base)
.
Panics
Panics if log_base
is zero.
Examples
extern crate malachite_base;
use malachite_base::iterators::prefix_to_string;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
let (before_point, after_point) = Rational::from(3u32).power_of_2_digits(1);
assert_eq!(before_point.to_debug_string(), "[1, 1]");
assert_eq!(prefix_to_string(after_point, 10), "[]");
let (before_point, after_point) = Rational::from_signeds(22, 7).power_of_2_digits(1);
assert_eq!(before_point.to_debug_string(), "[1, 1]");
assert_eq!(prefix_to_string(after_point, 10), "[0, 0, 1, 0, 0, 1, 0, 0, 1, 0, ...]");
let (before_point, after_point) = Rational::from_signeds(22, 7).power_of_2_digits(10);
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(
prefix_to_string(after_point, 10),
"[146, 292, 585, 146, 292, 585, 146, 292, 585, 146, ...]"
);
sourceimpl Rational
impl Rational
sourcepub fn into_digits(
self,
base: &Natural
) -> (Vec<Natural>, RationalSequence<Natural>)
pub fn into_digits(
self,
base: &Natural
) -> (Vec<Natural>, RationalSequence<Natural>)
Returns the base-$b$ digits of a Rational
, taking the Rational
by value.
The output has two components. The first is a Vec
of the digits of the integer portion
of the Rational
, least- to most-significant. The second is a
RationalSequence
of the digits of
the fractional portion.
The output is in its simplest form: the integer-portion digits do not end with a zero, and the fractional-portion digits do not end with infinitely many zeros or $(b-1)$s.
The fractional portion may be very large; the length of the repeating part may be almost as
large as the denominator. If the Rational
has a large denominator, consider using
digits
instead, which returns an iterator. That function computes the
fractional digits lazily and doesn’t need to compute the entire repeating part.
Worst-case complexity
$T(n, m) = O(m2^n)$
$M(n, m) = O(m2^n)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and $m$ is
base.significant_bits()
.
Panics
Panics if base
is less than 2.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
let (before_point, after_point) = Rational::from(3u32).into_digits(&Natural::from(10u32));
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(after_point.to_string(), "[]");
let (before_point, after_point) =
Rational::from_signeds(22, 7).into_digits(&Natural::from(10u32));
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(after_point.to_string(), "[[1, 4, 2, 8, 5, 7]]");
sourcepub fn to_digits(
&self,
base: &Natural
) -> (Vec<Natural>, RationalSequence<Natural>)
pub fn to_digits(
&self,
base: &Natural
) -> (Vec<Natural>, RationalSequence<Natural>)
Returns the base-$b$ digits of a Rational
, taking the Rational
by reference.
The output has two components. The first is a Vec
of the digits of the integer portion
of the Rational
, least- to most-significant. The second is a
RationalSequence
of the digits of
the fractional portion.
The output is in its simplest form: the integer-portion digits do not end with a zero, and the fractional-portion digits do not end with infinitely many zeros or $(b-1)$s.
The fractional portion may be very large; the length of the repeating part may be almost as
large as the denominator. If the Rational
has a large denominator, consider using
digits
instead, which returns an iterator. That function computes the
fractional digits lazily and doesn’t need to compute the entire repeating part.
Worst-case complexity
$T(n, m) = O(m2^n)$
$M(n, m) = O(m2^n)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and $m$ is
base.significant_bits()
.
Panics
Panics if base
is less than 2.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
let (before_point, after_point) = Rational::from(3u32).to_digits(&Natural::from(10u32));
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(after_point.to_string(), "[]");
let (before_point, after_point) =
Rational::from_signeds(22, 7).to_digits(&Natural::from(10u32));
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(after_point.to_string(), "[[1, 4, 2, 8, 5, 7]]");
sourceimpl Rational
impl Rational
sourcepub fn into_power_of_2_digits(
self,
log_base: u64
) -> (Vec<Natural>, RationalSequence<Natural>)
pub fn into_power_of_2_digits(
self,
log_base: u64
) -> (Vec<Natural>, RationalSequence<Natural>)
Returns the base-$2^k$ digits of a Rational
, taking the Rational
by value.
The output has two components. The first is a Vec
of the digits of the integer portion
of the Rational
, least- to most-significant. The second is a
RationalSequence
of the digits of
the fractional portion.
The output is in its simplest form: the integer-portion digits do not end with a zero, and the fractional-portion digits do not end with infinitely many zeros or $(2^k-1)$s.
The fractional portion may be very large; the length of the repeating part may be almost as
large as the denominator. If the Rational
has a large denominator, consider using
power_of_2_digits
instead, which returns an iterator. That
function computes the fractional digits lazily and doesn’t need to compute the entire
repeating part.
Worst-case complexity
$T(n, m) = O(m2^n)$
$M(n, m) = O(m2^n)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and $m$ is
log_base
.
Panics
Panics if log_base
is zero.
Examples
extern crate malachite_base;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
let (before_point, after_point) = Rational::from(3u32).into_power_of_2_digits(1);
assert_eq!(before_point.to_debug_string(), "[1, 1]");
assert_eq!(after_point.to_string(), "[]");
let (before_point, after_point) = Rational::from_signeds(22, 7).into_power_of_2_digits(1);
assert_eq!(before_point.to_debug_string(), "[1, 1]");
assert_eq!(after_point.to_string(), "[[0, 0, 1]]");
let (before_point, after_point) = Rational::from_signeds(22, 7).into_power_of_2_digits(10);
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(after_point.to_string(), "[[146, 292, 585]]");
sourcepub fn to_power_of_2_digits(
&self,
log_base: u64
) -> (Vec<Natural>, RationalSequence<Natural>)
pub fn to_power_of_2_digits(
&self,
log_base: u64
) -> (Vec<Natural>, RationalSequence<Natural>)
Returns the base-$2^k$ digits of a Rational
, taking the Rational
by reference.
The output has two components. The first is a Vec
of the digits of the integer portion
of the Rational
, least- to most-significant. The second is a
RationalSequence
of the digits of
the fractional portion.
The output is in its simplest form: the integer-portion digits do not end with a zero, and the fractional-portion digits do not end with infinitely many zeros or $(2^k-1)$s.
The fractional portion may be very large; the length of the repeating part may be almost as
large as the denominator. If the Rational
has a large denominator, consider using
power_of_2_digits
instead, which returns an iterator. That
function computes the fractional digits lazily and doesn’t need to compute the entire
repeating part.
Worst-case complexity
$T(n, m) = O(m2^n)$
$M(n, m) = O(m2^n)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and $m$ is
log_base
.
Panics
Panics if log_base
is zero.
Examples
extern crate malachite_base;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
let (before_point, after_point) = Rational::from(3u32).to_power_of_2_digits(1);
assert_eq!(before_point.to_debug_string(), "[1, 1]");
assert_eq!(after_point.to_string(), "[]");
let (before_point, after_point) = Rational::from_signeds(22, 7).to_power_of_2_digits(1);
assert_eq!(before_point.to_debug_string(), "[1, 1]");
assert_eq!(after_point.to_string(), "[[0, 0, 1]]");
let (before_point, after_point) = Rational::from_signeds(22, 7).to_power_of_2_digits(10);
assert_eq!(before_point.to_debug_string(), "[3]");
assert_eq!(after_point.to_string(), "[[146, 292, 585]]");
sourceimpl Rational
impl Rational
sourcepub fn try_from_float_simplest<T: PrimitiveFloat>(
x: T
) -> Result<Rational, RationalFromPrimitiveFloatError>where
Rational: TryFrom<T, Error = RationalFromPrimitiveFloatError>,
pub fn try_from_float_simplest<T: PrimitiveFloat>(
x: T
) -> Result<Rational, RationalFromPrimitiveFloatError>where
Rational: 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 cannot be NaN or infinite, and 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)
);
sourceimpl Rational
impl Rational
sourcepub fn from_naturals(numerator: Natural, denominator: Natural) -> Rational
pub fn from_naturals(numerator: Natural, denominator: Natural) -> Rational
Converts two Natural
s to a Rational
, taking the
Natural
s by value.
The Natural
s become the Rational
’s numerator and denominator. Only non-negative
Rational
s can be produced with this function.
The denominator may not be zero.
The input Natural
s may have common factors; this
function reduces them.
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(numerator.significant_bits(), denominator.significant_bits())
.
Panics
Panics if denominator
is zero.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert_eq!(
Rational::from_naturals(Natural::from(4u32), Natural::from(6u32)).to_string(),
"2/3"
);
assert_eq!(Rational::from_naturals(Natural::ZERO, Natural::from(6u32)), 0);
sourcepub fn from_naturals_ref(numerator: &Natural, denominator: &Natural) -> Rational
pub fn from_naturals_ref(numerator: &Natural, denominator: &Natural) -> Rational
Converts two Natural
s to a Rational
, taking the
Natural
s by reference.
The Natural
s become the Rational
’s numerator and
denominator. Only non-negative Rational
s can be produced with this function.
The denominator may not be zero.
The input Natural
s may have common factors; this
function reduces them.
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(numerator.significant_bits(), denominator.significant_bits())
.
Panics
Panics if denominator
is zero.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert_eq!(
Rational::from_naturals_ref(&Natural::from(4u32), &Natural::from(6u32)).to_string(),
"2/3"
);
assert_eq!(Rational::from_naturals_ref(&Natural::ZERO, &Natural::from(6u32)), 0);
sourcepub fn from_unsigneds<T: PrimitiveUnsigned>(
numerator: T,
denominator: T
) -> Rationalwhere
Natural: From<T>,
pub fn from_unsigneds<T: PrimitiveUnsigned>(
numerator: T,
denominator: T
) -> Rationalwhere
Natural: From<T>,
Converts two unsigned primitive integers to a Rational
.
The integers become the Rational
’s numerator and denominator. Only non-negative
Rational
s can be produced with this function.
The denominator may not be zero.
The input integers may have common factors; this function reduces them.
Worst-case complexity
$T(n) = O(n^2)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Panics
Panics if denominator
is zero.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!(Rational::from_unsigneds(4u32, 6).to_string(), "2/3");
assert_eq!(Rational::from_unsigneds(0u32, 6), 0);
sourcepub fn from_integers(numerator: Integer, denominator: Integer) -> Rational
pub fn from_integers(numerator: Integer, denominator: Integer) -> Rational
Converts two Integer
s to a Rational
, taking the
Integer
s by value.
The absolute values of the Integer
s become the
Rational
’s numerator and denominator. The sign of the Rational
is the sign of the
Integer
s’ quotient.
The denominator may not be zero.
The input Integer
s may have common factors; this
function reduces them.
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(numerator.significant_bits(), denominator.significant_bits())
.
Panics
Panics if denominator
is zero.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
assert_eq!(
Rational::from_integers(Integer::from(4), Integer::from(6)).to_string(),
"2/3"
);
assert_eq!(
Rational::from_integers(Integer::from(4), Integer::from(-6)).to_string(),
"-2/3"
);
assert_eq!(Rational::from_integers(Integer::ZERO, Integer::from(6)), 0);
assert_eq!(Rational::from_integers(Integer::ZERO, Integer::from(-6)), 0);
sourcepub fn from_integers_ref(numerator: &Integer, denominator: &Integer) -> Rational
pub fn from_integers_ref(numerator: &Integer, denominator: &Integer) -> Rational
Converts two Integer
s to a Rational
, taking the
Integer
s by reference.
The absolute values of the Integer
s become the
Rational
’s numerator and denominator. The sign of the Rational
is the sign of the
Integer
s’ quotient.
The denominator may not be zero.
The input Integer
s may have common factors; this
function reduces them.
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(numerator.significant_bits(), denominator.significant_bits())
.
Panics
Panics if denominator
is zero.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
assert_eq!(
Rational::from_integers_ref(&Integer::from(4), &Integer::from(6)).to_string(),
"2/3"
);
assert_eq!(
Rational::from_integers_ref(&Integer::from(4), &Integer::from(-6)).to_string(),
"-2/3"
);
assert_eq!(Rational::from_integers_ref(&Integer::ZERO, &Integer::from(6)), 0);
assert_eq!(Rational::from_integers_ref(&Integer::ZERO, &Integer::from(-6)), 0);
sourcepub fn from_signeds<T: PrimitiveSigned>(numerator: T, denominator: T) -> Rationalwhere
Integer: From<T>,
pub fn from_signeds<T: PrimitiveSigned>(numerator: T, denominator: T) -> Rationalwhere
Integer: From<T>,
Converts two signed primitive integers to a [Rational]
.
The absolute values of the integers become the Rational
’s numerator and denominator.
The sign of the Rational
is the sign of the integers’ quotient.
The denominator may not be zero.
The input integers may have common factors; this function reduces them.
Worst-case complexity
$T(n) = O(n^2)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Panics
Panics if denominator
is zero.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!(Rational::from_signeds(4i8, 6).to_string(), "2/3");
assert_eq!(Rational::from_signeds(4i8, -6).to_string(), "-2/3");
assert_eq!(Rational::from_signeds(0i8, 6), 0);
assert_eq!(Rational::from_signeds(0i8, -6), 0);
sourcepub fn from_sign_and_naturals(
sign: bool,
numerator: Natural,
denominator: Natural
) -> Rational
pub fn from_sign_and_naturals(
sign: bool,
numerator: Natural,
denominator: Natural
) -> Rational
Converts a sign and two Natural
s to a Rational
,
taking the Natural
s by value.
The Natural
s 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 Natural
s may have common factors; this
function reduces them.
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(numerator.significant_bits(), denominator.significant_bits())
.
Panics
Panics if denominator
is zero.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert_eq!(
Rational::from_sign_and_naturals(
true,
Natural::from(4u32),
Natural::from(6u32)
).to_string(),
"2/3"
);
assert_eq!(
Rational::from_sign_and_naturals(
false,
Natural::from(4u32),
Natural::from(6u32)
).to_string(),
"-2/3"
);
sourcepub fn from_sign_and_naturals_ref(
sign: bool,
numerator: &Natural,
denominator: &Natural
) -> Rational
pub fn from_sign_and_naturals_ref(
sign: bool,
numerator: &Natural,
denominator: &Natural
) -> Rational
Converts a sign and two Natural
s to a Rational
,
taking the Natural
s by reference.
The Natural
s 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 Natural
s may have common factors; this
function reduces them.
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(numerator.significant_bits(), denominator.significant_bits())
.
Panics
Panics if denominator
is zero.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert_eq!(
Rational::from_sign_and_naturals_ref(
true,
&Natural::from(4u32),
&Natural::from(6u32)
).to_string(),
"2/3"
);
assert_eq!(
Rational::from_sign_and_naturals_ref(
false,
&Natural::from(4u32),
&Natural::from(6u32)
).to_string(),
"-2/3"
);
sourcepub fn from_sign_and_unsigneds<T: PrimitiveUnsigned>(
sign: bool,
numerator: T,
denominator: T
) -> Rationalwhere
Natural: From<T>,
pub fn from_sign_and_unsigneds<T: PrimitiveUnsigned>(
sign: bool,
numerator: T,
denominator: T
) -> Rationalwhere
Natural: From<T>,
Converts a sign and two primitive unsigned integers to a Rational
.
The integers become the Rational
’s numerator and denominator, and the sign indicates
whether the Rational
should be non-negative. If the numerator is zero, then the
Rational
will be non-negative regardless of the sign.
The denominator may not be zero.
The input integers may have common factors; this function reduces them.
Worst-case complexity
$T(n) = O(n^2)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Panics
Panics if denominator
is zero.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!(Rational::from_sign_and_unsigneds(true, 4u32, 6).to_string(), "2/3");
assert_eq!(Rational::from_sign_and_unsigneds(false, 4u32, 6).to_string(), "-2/3");
sourceimpl Rational
impl Rational
sourcepub fn sci_mantissa_and_exponent_with_rounding<T: PrimitiveFloat>(
self,
rm: RoundingMode
) -> Option<(T, i64)>
pub fn sci_mantissa_and_exponent_with_rounding<T: PrimitiveFloat>(
self,
rm: RoundingMode
) -> Option<(T, i64)>
Returns a Rational
’s scientific mantissa and exponent, taking the Rational
by
value.
When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is
a rational number with $1 \leq m_s < 2$. We represent the rational mantissa as a float. The
conversion might not be exact, so we round to the nearest float using the provided rounding
mode. If the rounding mode is Exact
but the conversion is not exact, None
is returned.
$$
f(x, r) \approx \left (\frac{x}{2^{\lfloor \log_2 x \rfloor}},
\lfloor \log_2 x \rfloor\right ).
$$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::SciMantissaAndExponent;
use malachite_base::num::float::NiceFloat;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;
let test = |n: Rational, rm: RoundingMode, out: Option<(f32, i64)>| {
assert_eq!(
n.sci_mantissa_and_exponent_with_rounding(rm)
.map(|(m, e)| (NiceFloat(m), e)),
out.map(|(m, e)| (NiceFloat(m), e))
);
};
test(Rational::from(3u32), RoundingMode::Down, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Ceiling, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Up, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Nearest, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Exact, Some((1.5, 1)));
test(Rational::from_signeds(1, 3), RoundingMode::Floor, Some((1.3333333, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Down, Some((1.3333333, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Ceiling, Some((1.3333334, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Up, Some((1.3333334, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Nearest, Some((1.3333334, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Exact, None);
sourcepub fn sci_mantissa_and_exponent_with_rounding_ref<T: PrimitiveFloat>(
&self,
rm: RoundingMode
) -> Option<(T, i64)>
pub fn sci_mantissa_and_exponent_with_rounding_ref<T: PrimitiveFloat>(
&self,
rm: RoundingMode
) -> Option<(T, i64)>
Returns a Rational
’s scientific mantissa and exponent, taking the Rational
by
reference.
When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is
a rational number with $1 \leq m_s < 2$. We represent the rational mantissa as a float. The
conversion might not be exact, so we round to the nearest float using the provided rounding
mode. If the rounding mode is Exact
but the conversion is not exact, None
is returned.
$$
f(x, r) \approx \left (\frac{x}{2^{\lfloor \log_2 x \rfloor}},
\lfloor \log_2 x \rfloor\right ).
$$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::SciMantissaAndExponent;
use malachite_base::num::float::NiceFloat;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;
let test = |n: Rational, rm: RoundingMode, out: Option<(f32, i64)>| {
assert_eq!(
(&n).sci_mantissa_and_exponent_with_rounding_ref(rm)
.map(|(m, e)| (NiceFloat(m), e)),
out.map(|(m, e)| (NiceFloat(m), e))
);
};
test(Rational::from(3u32), RoundingMode::Down, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Ceiling, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Up, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Nearest, Some((1.5, 1)));
test(Rational::from(3u32), RoundingMode::Exact, Some((1.5, 1)));
test(Rational::from_signeds(1, 3), RoundingMode::Floor, Some((1.3333333, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Down, Some((1.3333333, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Ceiling, Some((1.3333334, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Up, Some((1.3333334, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Nearest, Some((1.3333334, -2)));
test(Rational::from_signeds(1, 3), RoundingMode::Exact, None);
sourceimpl Rational
impl Rational
sourcepub fn mutate_numerator<F: FnOnce(&mut Natural) -> T, T>(&mut self, f: F) -> T
pub fn mutate_numerator<F: FnOnce(&mut Natural) -> T, T>(&mut self, f: F) -> T
Mutates the numerator of a Rational
using a provided closure, and then returns
whatever the closure returns.
After the closure executes, this function reduces the Rational
.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
let mut q = Rational::from_signeds(22, 7);
let ret = q.mutate_numerator(|x| {
*x -= Natural::ONE;
true
});
assert_eq!(q, 3);
assert_eq!(ret, true);
sourcepub fn mutate_denominator<F: FnOnce(&mut Natural) -> T, T>(&mut self, f: F) -> T
pub fn mutate_denominator<F: FnOnce(&mut Natural) -> T, T>(&mut self, f: F) -> T
Mutates the denominator of a Rational
using a provided closure.
After the closure executes, this function reduces the Rational
.
Panics
Panics if the closure sets the denominator to zero.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
let mut q = Rational::from_signeds(22, 7);
let ret = q.mutate_denominator(|x| {
*x -= Natural::ONE;
true
});
assert_eq!(q.to_string(), "11/3");
assert_eq!(ret, true);
sourcepub fn mutate_numerator_and_denominator<F: FnOnce(&mut Natural, &mut Natural) -> T, T>(
&mut self,
f: F
) -> T
pub fn mutate_numerator_and_denominator<F: FnOnce(&mut Natural, &mut Natural) -> T, T>(
&mut self,
f: F
) -> T
Mutates the numerator and denominator of a Rational
using a provided closure.
After the closure executes, this function reduces the Rational
.
Panics
Panics if the closure sets the denominator to zero.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
let mut q = Rational::from_signeds(22, 7);
let ret = q.mutate_numerator_and_denominator(|x, y| {
*x -= Natural::ONE;
*y -= Natural::ONE;
true
});
assert_eq!(q.to_string(), "7/2");
assert_eq!(ret, true);
sourceimpl Rational
impl Rational
sourcepub fn from_sci_string_simplest_with_options(
s: &str,
options: FromSciStringOptions
) -> Option<Rational>
pub fn from_sci_string_simplest_with_options(
s: &str,
options: FromSciStringOptions
) -> Option<Rational>
Converts a string, possibly in scientfic notation, to a Rational
. This function finds
the simplest Rational
which rounds to the target string according to the precision
implied by the string.
Use
FromSciStringOptions
to specify the base (from 2 to 36, inclusive). The rounding mode option is ignored.
If the base is greater than 10, the higher digits are represented by the letters 'a'
through 'z'
or 'A'
through 'Z'
; the case doesn’t matter and doesn’t need to be
consistent.
Exponents are allowed, and are indicated using the character 'e'
or 'E'
. If the base is
15 or greater, an ambiguity arises where it may not be clear whether 'e'
is a digit or
an exponent indicator. To resolve this ambiguity, always use a '+'
or '-'
sign after
the exponent indicator when the base is 15 or greater.
The exponent itself is always parsed using base 10.
Decimal (or other-base) points are allowed.
If the string is unparseable, None
is returned.
Here’s a more precise description of the function’s behavior. Suppose we are using base
$b$, and the literal value of the string (as parsed by
from_sci_string
) is $q$, and the implied scale is $s$
(meaning $s$ digits are provided after the point; if the string is "123.456"
, then $s$ is
3). Then this function computes $\epsilon = b^{-s}/2$ and finds the simplest Rational
in the closed interval $[q - \epsilon, q + \epsilon]$. The simplest Rational
is the one
with minimal denominator; if there are multiple such Rational
s, 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 likeround_to_multiple
andsimplest_rational_in_closed_interval
.
Worst-case complexity
$T(n, m) = O(m^n n \log m (\log n + \log\log m))$
$M(n, m) = O(m^n n \log m)$
where $T$ is time, $M$ is additional memory, $n$ is s.len()
, and $m$ is options.base
.
Examples
extern crate malachite_base;
use malachite_base::num::conversion::string::options::FromSciStringOptions;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;
let mut options = FromSciStringOptions::default();
options.set_base(16);
assert_eq!(Rational::from_sci_string_simplest_with_options("ff", options).unwrap(), 255);
assert_eq!(
Rational::from_sci_string_simplest_with_options("ffE+5", options).unwrap(),
267386880
);
// 1/4105 is 0.000ff705..._16
assert_eq!(
Rational::from_sci_string_simplest_with_options("ffE-5", options).unwrap().to_string(),
"1/4105"
);
sourcepub fn from_sci_string_simplest(s: &str) -> Option<Rational>
pub fn from_sci_string_simplest(s: &str) -> Option<Rational>
Converts a string, possibly in scientfic notation, to a Rational
. This function finds
the simplest Rational
which rounds to the target string according to the precision
implied by the string.
The string is parsed using base 10. To use other bases, try
from_sci_string_simplest_with_options
instead.
Exponents are allowed, and are indicated using the character 'e'
or 'E'
.
The exponent itself is also parsed using base 10.
Decimal points are allowed.
If the string is unparseable, None
is returned.
Here’s a more precise description of the function’s behavior. Suppose that the literal
value of the string (as parsed by from_sci_string
) is $q$,
and the implied scale is $s$ (meaning $s$ digits are provided after the point; if the
string is "123.456"
, then $s$ is 3). Then this function computes $\epsilon = 10^{-s}/2$
and finds the simplest Rational
in the closed interval $[q - \epsilon, q + \epsilon]$.
The simplest Rational
is the one with minimal denominator; if there are multiple such
Rational
s, 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 likeround_to_multiple
andsimplest_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");
sourceimpl Rational
impl Rational
sourcepub fn length_after_point_in_small_base(&self, base: u8) -> Option<u64>
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));
sourceimpl Rational
impl Rational
sourcepub fn to_numerator(&self) -> Natural
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);
sourcepub fn to_denominator(&self) -> Natural
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);
sourcepub fn to_numerator_and_denominator(&self) -> (Natural, Natural)
pub fn to_numerator_and_denominator(&self) -> (Natural, Natural)
Extracts the numerator and denominator of a Rational
, taking the Rational
by
reference and cloning.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
use std::str::FromStr;
assert_eq!(
Rational::from_str("2/3").unwrap().to_numerator_and_denominator().to_debug_string(),
"(2, 3)"
);
assert_eq!(
Rational::from_str("0").unwrap().to_numerator_and_denominator().to_debug_string(),
"(0, 1)"
);
sourcepub fn into_numerator(self) -> Natural
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);
sourcepub fn into_denominator(self) -> Natural
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);
sourcepub fn into_numerator_and_denominator(self) -> (Natural, Natural)
pub fn into_numerator_and_denominator(self) -> (Natural, Natural)
Extracts the numerator and denominator of a Rational
, taking the Rational
by value.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
use std::str::FromStr;
assert_eq!(
Rational::from_str("2/3").unwrap().into_numerator_and_denominator().to_debug_string(),
"(2, 3)"
);
assert_eq!(
Rational::from_str("0").unwrap().into_numerator_and_denominator().to_debug_string(),
"(0, 1)"
);
sourcepub const fn numerator_ref(&self) -> &Natural
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);
sourcepub const fn denominator_ref(&self) -> &Natural
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);
sourcepub const fn numerator_and_denominator_ref(&self) -> (&Natural, &Natural)
pub const fn numerator_and_denominator_ref(&self) -> (&Natural, &Natural)
Returns references to the numeraror and denominator of a Rational
.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
use std::str::FromStr;
assert_eq!(
Rational::from_str("2/3").unwrap().numerator_and_denominator_ref().to_debug_string(),
"(2, 3)"
);
assert_eq!(
Rational::from_str("0").unwrap().numerator_and_denominator_ref().to_debug_string(),
"(0, 1)"
);
Trait Implementations
sourceimpl<'a> Abs for &'a Rational
impl<'a> Abs for &'a Rational
sourcefn abs(self) -> Rational
fn abs(self) -> Rational
Takes the absolute value of a Rational
, taking the Rational
by value.
$$ f(x) = |x|. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Abs;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!((&Rational::ZERO).abs(), 0);
assert_eq!((&Rational::from_signeds(22, 7)).abs().to_string(), "22/7");
assert_eq!((&Rational::from_signeds(-22, 7)).abs().to_string(), "22/7");
type Output = Rational
sourceimpl Abs for Rational
impl Abs for Rational
sourcefn abs(self) -> Rational
fn abs(self) -> Rational
Takes the absolute value of a Rational
, taking the Rational
by value.
$$ f(x) = |x|. $$
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Abs;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!(Rational::ZERO.abs(), 0);
assert_eq!(Rational::from_signeds(22, 7).abs().to_string(), "22/7");
assert_eq!(Rational::from_signeds(-22, 7).abs().to_string(), "22/7");
type Output = Rational
sourceimpl AbsAssign for Rational
impl AbsAssign for Rational
sourcefn abs_assign(&mut self)
fn abs_assign(&mut self)
Replaces a Rational
with its absolute value.
$$ x \gets |x|. $$
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::AbsAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
let mut x = Rational::ZERO;
x.abs_assign();
assert_eq!(x, 0);
let mut x = Rational::from_signeds(22, 7);
x.abs_assign();
assert_eq!(x.to_string(), "22/7");
let mut x = Rational::from_signeds(-22, 7);
x.abs_assign();
assert_eq!(x.to_string(), "22/7");
sourceimpl<'a, 'b> Add<&'a Rational> for &'b Rational
impl<'a, 'b> Add<&'a Rational> for &'b Rational
sourcefn add(self, other: &'a Rational) -> Rational
fn add(self, other: &'a Rational) -> Rational
Adds two Rational
s, taking both by reference.
$$ f(x, y) = x + y. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
assert_eq!(&Rational::ONE_HALF + &Rational::ONE_HALF, 1);
assert_eq!(
(&Rational::from_signeds(22, 7) + &Rational::from_signeds(99, 100)).to_string(),
"2893/700"
);
sourceimpl<'a> Add<&'a Rational> for Rational
impl<'a> Add<&'a Rational> for Rational
sourcefn add(self, other: &'a Rational) -> Rational
fn add(self, other: &'a Rational) -> Rational
Adds two Rational
s, taking both by the first by value and the second by reference.
$$ f(x, y) = x + y. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
assert_eq!(Rational::ONE_HALF + &Rational::ONE_HALF, 1);
assert_eq!(
(Rational::from_signeds(22, 7) + &Rational::from_signeds(99, 100)).to_string(),
"2893/700"
);
sourceimpl<'a> Add<Rational> for &'a Rational
impl<'a> Add<Rational> for &'a Rational
sourcefn add(self, other: Rational) -> Rational
fn add(self, other: Rational) -> Rational
Adds two Rational
s, taking the first by reference and the second by value
$$ f(x, y) = x + y. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
assert_eq!(&Rational::ONE_HALF + Rational::ONE_HALF, 1);
assert_eq!(
(&Rational::from_signeds(22, 7) + Rational::from_signeds(99, 100)).to_string(),
"2893/700"
);
sourceimpl Add<Rational> for Rational
impl Add<Rational> for Rational
sourcefn add(self, other: Rational) -> Rational
fn add(self, other: Rational) -> Rational
Adds two Rational
s, taking both by value.
$$ f(x, y) = x + y. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
assert_eq!(Rational::ONE_HALF + Rational::ONE_HALF, 1);
assert_eq!(
(Rational::from_signeds(22, 7) + Rational::from_signeds(99, 100)).to_string(),
"2893/700"
);
sourceimpl<'a> AddAssign<&'a Rational> for Rational
impl<'a> AddAssign<&'a Rational> for Rational
sourcefn add_assign(&mut self, other: &'a Rational)
fn add_assign(&mut self, other: &'a Rational)
Adds a Rational
to a Rational
in place, taking the Rational
on the right-hand
side by reference.
$$ x \gets x + y. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
let mut x = Rational::ONE_HALF;
x += &Rational::ONE_HALF;
assert_eq!(x, 1);
let mut x = Rational::from_signeds(22, 7);
x += &Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "2893/700");
sourceimpl AddAssign<Rational> for Rational
impl AddAssign<Rational> for Rational
sourcefn add_assign(&mut self, other: Rational)
fn add_assign(&mut self, other: Rational)
Adds a Rational
to a Rational
in place, taking the Rational
on the right-hand
side by value.
$$ x \gets x + y. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
let mut x = Rational::ONE_HALF;
x += Rational::ONE_HALF;
assert_eq!(x, 1);
let mut x = Rational::from_signeds(22, 7);
x += Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "2893/700");
sourceimpl<'a> Approximate for &'a Rational
impl<'a> Approximate for &'a Rational
sourcefn approximate(self, max_denominator: &Natural) -> 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.
sourceimpl Approximate for Rational
impl Approximate for Rational
sourcefn approximate(self, max_denominator: &Natural) -> 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.
sourceimpl ApproximateAssign for Rational
impl ApproximateAssign for Rational
sourcefn approximate_assign(&mut self, max_denominator: &Natural)
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");
sourceimpl<'a> Ceiling for &'a Rational
impl<'a> Ceiling for &'a Rational
sourcefn ceiling(self) -> Integer
fn ceiling(self) -> Integer
Finds the ceiling of a Rational
, taking the Rational
by reference.
$$ f(x) = \lceil x \rceil. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Ceiling;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!((&Rational::ZERO).ceiling(), 0);
assert_eq!((&Rational::from_signeds(22, 7)).ceiling(), 4);
assert_eq!((&Rational::from_signeds(-22, 7)).ceiling(), -3);
type Output = Integer
sourceimpl Ceiling for Rational
impl Ceiling for Rational
sourcefn ceiling(self) -> Integer
fn ceiling(self) -> Integer
Finds the ceiling of a Rational
, taking the Rational
by value.
$$ f(x) = \lceil x \rceil. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Ceiling;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!(Rational::ZERO.ceiling(), 0);
assert_eq!(Rational::from_signeds(22, 7).ceiling(), 4);
assert_eq!(Rational::from_signeds(-22, 7).ceiling(), -3);
type Output = Integer
sourceimpl CeilingAssign for Rational
impl CeilingAssign for Rational
sourcefn ceiling_assign(&mut self)
fn ceiling_assign(&mut self)
Replaces a Rational
with its ceiling.
$$ x \gets \lceil x \rceil. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::CeilingAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
let mut x = Rational::ZERO;
x.ceiling_assign();
assert_eq!(x, 0);
let mut x = Rational::from_signeds(22, 7);
x.ceiling_assign();
assert_eq!(x, 4);
let mut x = Rational::from_signeds(-22, 7);
x.ceiling_assign();
assert_eq!(x, -3);
sourceimpl<'a, 'b> CeilingLogBase<&'b Rational> for &'a Rational
impl<'a, 'b> CeilingLogBase<&'b Rational> for &'a Rational
sourcefn ceiling_log_base(self, base: &Rational) -> i64
fn ceiling_log_base(self, base: &Rational) -> i64
Returns the ceiling of the base-$b$ logarithm of a positive Rational
.
Note that this function may be slow if the base is very close to 1.
$f(x, b) = \lceil\log_b x\rceil$.
Worst-case complexity
$T(n, m) = O(nm \log (nm) \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is base.significant_bits()
, and $m$ is
$|\log_b x|$, where $b$ is base
and $x$ is x
.
Panics
Panics if self
less than or equal to zero or base
is 1.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::CeilingLogBase;
use malachite_q::Rational;
assert_eq!(Rational::from(80u32).ceiling_log_base(&Rational::from(3u32)), 4);
assert_eq!(Rational::from(81u32).ceiling_log_base(&Rational::from(3u32)), 4);
assert_eq!(Rational::from(82u32).ceiling_log_base(&Rational::from(3u32)), 5);
assert_eq!(Rational::from(4294967296u64).ceiling_log_base(&Rational::from(10u32)), 10);
assert_eq!(
Rational::from_signeds(936851431250i64, 1397).ceiling_log_base(&Rational::from(10u32)),
9
);
assert_eq!(
Rational::from_signeds(5153632, 16807)
.ceiling_log_base(&Rational::from_signeds(22, 7)),
5
);
type Output = i64
sourceimpl<'a> CeilingLogBase2 for &'a Rational
impl<'a> CeilingLogBase2 for &'a Rational
sourcefn ceiling_log_base_2(self) -> i64
fn ceiling_log_base_2(self) -> i64
Returns the ceiling of the base-2 logarithm of a positive Rational
.
$f(x) = \lfloor\log_2 x\rfloor$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if self
less than or equal to zero.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::CeilingLogBase2;
use malachite_q::Rational;
assert_eq!(Rational::from(3u32).ceiling_log_base_2(), 2);
assert_eq!(Rational::from_signeds(1, 3).ceiling_log_base_2(), -1);
assert_eq!(Rational::from_signeds(1, 4).ceiling_log_base_2(), -2);
assert_eq!(Rational::from_signeds(1, 5).ceiling_log_base_2(), -2);
type Output = i64
sourceimpl<'a> CeilingLogBasePowerOf2<i64> for &'a Rational
impl<'a> CeilingLogBasePowerOf2<i64> for &'a Rational
sourcefn ceiling_log_base_power_of_2(self, pow: i64) -> i64
fn ceiling_log_base_power_of_2(self, pow: i64) -> i64
Returns the ceiling of the base-$2^k$ logarithm of a positive Rational
.
$k$ may be negative.
$f(x, p) = \lceil\log_{2^p} x\rceil$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if self
is less than or equal to 0 or pow
is 0.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::CeilingLogBasePowerOf2;
use malachite_q::Rational;
assert_eq!(Rational::from(100).ceiling_log_base_power_of_2(2), 4);
assert_eq!(Rational::from(4294967296u64).ceiling_log_base_power_of_2(8), 4);
// 4^(-2) < 1/10 < 4^(-1)
assert_eq!(Rational::from_signeds(1, 10).ceiling_log_base_power_of_2(2), -1);
// (1/4)^2 < 1/10 < (1/4)^1
assert_eq!(Rational::from_signeds(1, 10).ceiling_log_base_power_of_2(-2), 2);
type Output = i64
sourceimpl<'a, 'b> CheckedLogBase<&'b Rational> for &'a Rational
impl<'a, 'b> CheckedLogBase<&'b Rational> for &'a Rational
sourcefn checked_log_base(self, base: &Rational) -> Option<i64>
fn checked_log_base(self, base: &Rational) -> Option<i64>
Returns the base-$b$ logarithm of a positive Rational
. If the Rational
is not a
power of $b$, then None
is returned.
Note that this function may be slow if the base is very close to 1.
$$ f(x, b) = \begin{cases} \operatorname{Some}(\log_b x) & \text{if} \quad \log_b x \in \Z, \\ \operatorname{None} & \textrm{otherwise}. \end{cases} $$
Worst-case complexity
$T(n, m) = O(nm \log (nm) \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is base.significant_bits()
, and $m$ is
$|\log_b x|$, where $b$ is base
and $x$ is x
.
Panics
Panics if self
less than or equal to zero or base
is 1.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::CheckedLogBase;
use malachite_q::Rational;
assert_eq!(Rational::from(80u32).checked_log_base(&Rational::from(3u32)), None);
assert_eq!(Rational::from(81u32).checked_log_base(&Rational::from(3u32)), Some(4));
assert_eq!(Rational::from(82u32).checked_log_base(&Rational::from(3u32)), None);
assert_eq!(Rational::from(4294967296u64).checked_log_base(&Rational::from(10u32)), None);
assert_eq!(
Rational::from_signeds(936851431250i64, 1397).checked_log_base(&Rational::from(10u32)),
None
);
assert_eq!(
Rational::from_signeds(5153632, 16807)
.checked_log_base(&Rational::from_signeds(22, 7)),
Some(5)
);
type Output = i64
sourceimpl<'a> CheckedLogBase2 for &'a Rational
impl<'a> CheckedLogBase2 for &'a Rational
sourcefn checked_log_base_2(self) -> Option<i64>
fn checked_log_base_2(self) -> Option<i64>
Returns the base-2 logarithm of a positive Rational
. If the Rational
is not a power
of 2, then None
is returned.
$$ f(x) = \begin{cases} \operatorname{Some}(\log_2 x) & \text{if} \quad \log_2 x \in \Z, \\ \operatorname{None} & \textrm{otherwise}. \end{cases} $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if self
is less than or equal to zero.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::CheckedLogBase2;
use malachite_q::Rational;
assert_eq!(Rational::from(3u32).checked_log_base_2(), None);
assert_eq!(Rational::from_signeds(1, 3).checked_log_base_2(), None);
assert_eq!(Rational::from_signeds(1, 4).checked_log_base_2(), Some(-2));
assert_eq!(Rational::from_signeds(1, 5).checked_log_base_2(), None);
type Output = i64
sourceimpl<'a> CheckedLogBasePowerOf2<i64> for &'a Rational
impl<'a> CheckedLogBasePowerOf2<i64> for &'a Rational
sourcefn checked_log_base_power_of_2(self, pow: i64) -> Option<i64>
fn checked_log_base_power_of_2(self, pow: i64) -> Option<i64>
Returns the base-$2^k$ logarithm of a positive Rational
. If the Rational
is not a
power of $2^k$, then None
is returned.
$k$ may be negative.
$$ f(x, p) = \begin{cases} \operatorname{Some}(\log_{2^p} x) & \text{if} \quad \log_{2^p} x \in \Z, \\ \operatorname{None} & \textrm{otherwise}. \end{cases} $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if self
is 0 or pow
is 0.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::CheckedLogBasePowerOf2;
use malachite_q::Rational;
assert_eq!(Rational::from(100).checked_log_base_power_of_2(2), None);
assert_eq!(Rational::from(4294967296u64).checked_log_base_power_of_2(8), Some(4));
// 4^(-2) < 1/10 < 4^(-1)
assert_eq!(Rational::from_signeds(1, 10).checked_log_base_power_of_2(2), None);
assert_eq!(Rational::from_signeds(1, 16).checked_log_base_power_of_2(2), Some(-2));
// (1/4)^2 < 1/10 < (1/4)^1
assert_eq!(Rational::from_signeds(1, 10).checked_log_base_power_of_2(-2), None);
assert_eq!(Rational::from_signeds(1, 16).checked_log_base_power_of_2(-2), Some(2));
type Output = i64
sourceimpl<'a> CheckedRoot<i64> for &'a Rational
impl<'a> CheckedRoot<i64> for &'a Rational
sourcefn checked_root(self, pow: i64) -> Option<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
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::CheckedRoot;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
assert_eq!((&Rational::from(999i32)).checked_root(3i64).to_debug_string(), "None");
assert_eq!((&Rational::from(1000i32)).checked_root(3i64).to_debug_string(), "Some(10)");
assert_eq!((&Rational::from(1001i32)).checked_root(3i64).to_debug_string(), "None");
assert_eq!((&Rational::from(-1000i32)).checked_root(3i64).to_debug_string(), "Some(-10)");
assert_eq!((&Rational::from_signeds(22, 7)).checked_root(3i64).to_debug_string(), "None");
assert_eq!(
(&Rational::from_signeds(27, 8)).checked_root(3i64).to_debug_string(),
"Some(3/2)"
);
assert_eq!(
(&Rational::from_signeds(-27, 8)).checked_root(3i64).to_debug_string(),
"Some(-3/2)"
);
assert_eq!((&Rational::from(1000i32)).checked_root(-3i64).to_debug_string(), "Some(1/10)");
assert_eq!(
(&Rational::from_signeds(-27, 8)).checked_root(-3i64).to_debug_string(),
"Some(-2/3)"
);
type Output = Rational
sourceimpl CheckedRoot<i64> for Rational
impl CheckedRoot<i64> for Rational
sourcefn checked_root(self, pow: i64) -> Option<Rational>
fn checked_root(self, pow: i64) -> Option<Rational>
Returns the the $n$th root of a Rational
, or None
if the Rational
is not a
perfect $n$th power. The Rational
is taken by value.
$$ f(x, n) = \begin{cases} \operatorname{Some}(sqrt[n]{x}) & \text{if} \quad \sqrt[n]{x} \in \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
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::CheckedRoot;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
assert_eq!(Rational::from(999i32).checked_root(3i64).to_debug_string(), "None");
assert_eq!(Rational::from(1000i32).checked_root(3i64).to_debug_string(), "Some(10)");
assert_eq!(Rational::from(1001i32).checked_root(3i64).to_debug_string(), "None");
assert_eq!(Rational::from(-1000i32).checked_root(3i64).to_debug_string(), "Some(-10)");
assert_eq!(Rational::from_signeds(22, 7).checked_root(3i64).to_debug_string(), "None");
assert_eq!(
Rational::from_signeds(27, 8).checked_root(3i64).to_debug_string(),
"Some(3/2)"
);
assert_eq!(
Rational::from_signeds(-27, 8).checked_root(3i64).to_debug_string(),
"Some(-3/2)"
);
assert_eq!(Rational::from(1000i32).checked_root(-3i64).to_debug_string(), "Some(1/10)");
assert_eq!(
Rational::from_signeds(-27, 8).checked_root(-3i64).to_debug_string(),
"Some(-2/3)"
);
type Output = Rational
sourceimpl<'a> CheckedRoot<u64> for &'a Rational
impl<'a> CheckedRoot<u64> for &'a Rational
sourcefn checked_root(self, pow: u64) -> Option<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
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::CheckedRoot;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
assert_eq!(Rational::from(999i32).checked_root(3u64).to_debug_string(), "None");
assert_eq!(Rational::from(1000i32).checked_root(3u64).to_debug_string(), "Some(10)");
assert_eq!(Rational::from(1001i32).checked_root(3u64).to_debug_string(), "None");
assert_eq!(Rational::from(-1000i32).checked_root(3u64).to_debug_string(), "Some(-10)");
assert_eq!(Rational::from_signeds(22, 7).checked_root(3u64).to_debug_string(), "None");
assert_eq!(
Rational::from_signeds(27, 8).checked_root(3u64).to_debug_string(),
"Some(3/2)"
);
assert_eq!(
Rational::from_signeds(-27, 8).checked_root(3u64).to_debug_string(),
"Some(-3/2)"
);
type Output = Rational
sourceimpl CheckedRoot<u64> for Rational
impl CheckedRoot<u64> for Rational
sourcefn checked_root(self, pow: u64) -> Option<Rational>
fn checked_root(self, pow: u64) -> Option<Rational>
Returns the the $n$th root of a Rational
, or None
if the Rational
is not a
perfect $n$th power. The Rational
is taken by value.
$$ f(x, n) = \begin{cases} \operatorname{Some}(sqrt[n]{x}) & \text{if} \quad \sqrt[n]{x} \in \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
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::CheckedRoot;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
assert_eq!(Rational::from(999i32).checked_root(3u64).to_debug_string(), "None");
assert_eq!(Rational::from(1000i32).checked_root(3u64).to_debug_string(), "Some(10)");
assert_eq!(Rational::from(1001i32).checked_root(3u64).to_debug_string(), "None");
assert_eq!(Rational::from(-1000i32).checked_root(3u64).to_debug_string(), "Some(-10)");
assert_eq!(Rational::from_signeds(22, 7).checked_root(3u64).to_debug_string(), "None");
assert_eq!(
Rational::from_signeds(27, 8).checked_root(3u64).to_debug_string(),
"Some(3/2)"
);
assert_eq!(
Rational::from_signeds(-27, 8).checked_root(3u64).to_debug_string(),
"Some(-3/2)"
);
type Output = Rational
sourceimpl<'a> CheckedSqrt for &'a Rational
impl<'a> CheckedSqrt for &'a Rational
sourcefn checked_sqrt(self) -> Option<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
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::CheckedSqrt;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
assert_eq!((&Rational::from(99u8)).checked_sqrt().to_debug_string(), "None");
assert_eq!((&Rational::from(100u8)).checked_sqrt().to_debug_string(), "Some(10)");
assert_eq!((&Rational::from(101u8)).checked_sqrt().to_debug_string(), "None");
assert_eq!((&Rational::from_signeds(22, 7)).checked_sqrt().to_debug_string(), "None");
assert_eq!((&Rational::from_signeds(25, 9)).checked_sqrt().to_debug_string(), "Some(5/3)");
type Output = Rational
sourceimpl CheckedSqrt for Rational
impl CheckedSqrt for Rational
sourcefn checked_sqrt(self) -> Option<Rational>
fn checked_sqrt(self) -> Option<Rational>
Returns the the square root of a Rational
, or None
if it is not a perfect square. The
Rational
is taken by value.
$$ f(x) = \begin{cases} \operatorname{Some}(sqrt{x}) & \text{if} \quad \sqrt{x} \in \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
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::CheckedSqrt;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
assert_eq!(Rational::from(99u8).checked_sqrt().to_debug_string(), "None");
assert_eq!(Rational::from(100u8).checked_sqrt().to_debug_string(), "Some(10)");
assert_eq!(Rational::from(101u8).checked_sqrt().to_debug_string(), "None");
assert_eq!(Rational::from_signeds(22, 7).checked_sqrt().to_debug_string(), "None");
assert_eq!(Rational::from_signeds(25, 9).checked_sqrt().to_debug_string(), "Some(5/3)");
type Output = Rational
sourceimpl<'a> ContinuedFraction for &'a Rational
impl<'a> ContinuedFraction for &'a Rational
sourcefn continued_fraction(self) -> (Integer, RationalContinuedFraction)
fn continued_fraction(self) -> (Integer, RationalContinuedFraction)
Returns the continued fraction of a Rational
, taking the Rational
by reference.
The output has two components. The first is the first value of the continued fraction,
which may be any Integer
and is equal to the floor of
the Rational
. The second is an iterator that produces the remaining values, which are
all positive. Using the standard notation for continued fractions, the first value is the
number before the semicolon, and the second value produces the remaining numbers.
Each rational number has two continued fraction representations. The shorter of the two representations (the one that does not end in 1) is returned.
$f(x) = (a_0, (a_1, a_2, \ldots, a_3)),$ where $x = [a_0; a_1, a_2, \ldots, a_3]$ and $a_3 \neq 1$.
The output length is $O(n)$, where $n$ is self.significant_bits()
.
Worst-case complexity per iteration
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate itertools;
extern crate malachite_base;
use itertools::Itertools;
use malachite_base::strings::ToDebugString;
use malachite_q::conversion::traits::ContinuedFraction;
use malachite_q::Rational;
let (head, tail) = (&Rational::from_signeds(2, 3)).continued_fraction();
let tail = tail.collect_vec();
assert_eq!(head, 0);
assert_eq!(tail.to_debug_string(), "[1, 2]");
let (head, tail) = (&Rational::from_signeds(355, 113)).continued_fraction();
let tail = tail.collect_vec();
assert_eq!(head, 3);
assert_eq!(tail.to_debug_string(), "[7, 16]");
type CF = RationalContinuedFraction
sourceimpl ContinuedFraction for Rational
impl ContinuedFraction for Rational
sourcefn continued_fraction(self) -> (Integer, RationalContinuedFraction)
fn continued_fraction(self) -> (Integer, RationalContinuedFraction)
Returns the continued fraction of a Rational
, taking the Rational
by value.
The output has two components. The first is the first value of the continued fraction,
which may be any Integer
and is equal to the floor of
the Rational
. The second is an iterator that produces the remaining values, which are
all positive. Using the standard notation for continued fractions, the first value is the
number before the semicolon, and the second value produces the remaining numbers.
Each rational number has two continued fraction representations. The shorter of the two representations (the one that does not end in 1) is returned.
$f(x) = (a_0, (a_1, a_2, \ldots, a_3)),$ where $x = [a_0; a_1, a_2, \ldots, a_3]$ and $a_3 \neq 1$.
The output length is $O(n)$, where $n$ is self.significant_bits()
.
Worst-case complexity per iteration
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate itertools;
extern crate malachite_base;
use itertools::Itertools;
use malachite_base::strings::ToDebugString;
use malachite_q::conversion::traits::ContinuedFraction;
use malachite_q::Rational;
let (head, tail) = Rational::from_signeds(2, 3).continued_fraction();
let tail = tail.collect_vec();
assert_eq!(head, 0);
assert_eq!(tail.to_debug_string(), "[1, 2]");
let (head, tail) = Rational::from_signeds(355, 113).continued_fraction();
let tail = tail.collect_vec();
assert_eq!(head, 3);
assert_eq!(tail.to_debug_string(), "[7, 16]");
type CF = RationalContinuedFraction
sourceimpl<'a> Convergents for &'a Rational
impl<'a> Convergents for &'a Rational
sourcefn convergents(self) -> RationalConvergentsⓘNotable traits for RationalConvergentsimpl Iterator for RationalConvergents type Item = Rational;
fn convergents(self) -> RationalConvergentsⓘNotable traits for RationalConvergentsimpl Iterator for RationalConvergents type Item = Rational;
Returns the convergents of a Rational
, taking the Rational
by reference.
The convergents of a number are the sequence of rational numbers whose continued fractions are the prefixes of the number’s continued fraction. The first convergent is the floor of the number. The sequence of convergents is finite iff the number is rational, in which case the last convergent is the number itself. Each convergent is closer to the number than the previous convergent is. The even-indexed convergents are less than or equal to the number, and the odd-indexed ones are greater than or equal to it.
$f(x) = ([a_0; a_1, a_2, \ldots, a_i])_{i=0}^{n}$, where $x = [a_0; a_1, a_2, \ldots, a_n]$ and $a_n \neq 1$.
The output length is $O(n)$, where $n$ is self.significant_bits()
.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate itertools;
extern crate malachite_base;
use itertools::Itertools;
use malachite_base::strings::ToDebugString;
use malachite_q::conversion::traits::Convergents;
use malachite_q::Rational;
assert_eq!(
(&Rational::from_signeds(2, 3)).convergents().collect_vec().to_debug_string(),
"[0, 1, 2/3]"
);
assert_eq!(
(&Rational::from_signeds(355, 113)).convergents().collect_vec().to_debug_string(),
"[3, 22/7, 355/113]",
);
type C = RationalConvergents
sourceimpl Convergents for Rational
impl Convergents for Rational
sourcefn convergents(self) -> RationalConvergentsⓘNotable traits for RationalConvergentsimpl Iterator for RationalConvergents type Item = Rational;
fn convergents(self) -> RationalConvergentsⓘNotable traits for RationalConvergentsimpl Iterator for RationalConvergents type Item = Rational;
Returns the convergents of a Rational
, taking the Rational
by value.
The convergents of a number are the sequence of rational numbers whose continued fractions are the prefixes of the number’s continued fraction. The first convergent is the floor of the number. The sequence of convergents is finite iff the number is rational, in which case the last convergent is the number itself. Each convergent is closer to the number than the previous convergent is. The even-indexed convergents are less than or equal to the number, and the odd-indexed ones are greater than or equal to it.
$f(x) = ([a_0; a_1, a_2, \ldots, a_i])_{i=0}^{n}$, where $x = [a_0; a_1, a_2, \ldots, a_n]$ and $a_n \neq 1$.
The output length is $O(n)$, where $n$ is self.significant_bits()
.
Worst-case complexity per iteration
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate itertools;
extern crate malachite_base;
use itertools::Itertools;
use malachite_base::strings::ToDebugString;
use malachite_q::conversion::traits::Convergents;
use malachite_q::Rational;
assert_eq!(
Rational::from_signeds(2, 3).convergents().collect_vec().to_debug_string(),
"[0, 1, 2/3]"
);
assert_eq!(
Rational::from_signeds(355, 113).convergents().collect_vec().to_debug_string(),
"[3, 22/7, 355/113]",
);
type C = RationalConvergents
sourceimpl<'a> ConvertibleFrom<&'a Rational> for Integer
impl<'a> ConvertibleFrom<&'a Rational> for Integer
sourcefn convertible_from(x: &Rational) -> bool
fn convertible_from(x: &Rational) -> bool
Determines whether a Rational
can be converted to an
Integer
, taking the Rational
by reference.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::conversion::traits::ConvertibleFrom;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
assert_eq!(Integer::convertible_from(&Rational::from(123)), true);
assert_eq!(Integer::convertible_from(&Rational::from(-123)), true);
assert_eq!(Integer::convertible_from(&Rational::from_signeds(22, 7)), false);
sourceimpl<'a> ConvertibleFrom<&'a Rational> for Natural
impl<'a> ConvertibleFrom<&'a Rational> for Natural
sourcefn convertible_from(x: &Rational) -> bool
fn convertible_from(x: &Rational) -> bool
Determines whether a Rational
can be converted to a
Natural
(when the Rational
is non-negative and an
integer), taking the Rational
by reference.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::conversion::traits::ConvertibleFrom;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert_eq!(Natural::convertible_from(&Rational::from(123)), true);
assert_eq!(Natural::convertible_from(&Rational::from(-123)), false);
assert_eq!(Natural::convertible_from(&Rational::from_signeds(22, 7)), false);
sourceimpl<'a> ConvertibleFrom<&'a Rational> for f32
impl<'a> ConvertibleFrom<&'a Rational> for f32
sourcefn convertible_from(value: &'a Rational) -> bool
fn convertible_from(value: &'a Rational) -> bool
Determines whether a Rational
can be exactly converted to a primitive float,
taking the Rational
by reference.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Examples
See here.
sourceimpl<'a> ConvertibleFrom<&'a Rational> for f64
impl<'a> ConvertibleFrom<&'a Rational> for f64
sourcefn convertible_from(value: &'a Rational) -> bool
fn convertible_from(value: &'a Rational) -> bool
Determines whether a Rational
can be exactly converted to a primitive float,
taking the Rational
by reference.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Examples
See here.
sourceimpl<'a> ConvertibleFrom<&'a Rational> for i128
impl<'a> ConvertibleFrom<&'a Rational> for i128
sourcefn convertible_from(value: &Rational) -> bool
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.
sourceimpl<'a> ConvertibleFrom<&'a Rational> for i16
impl<'a> ConvertibleFrom<&'a Rational> for i16
sourcefn convertible_from(value: &Rational) -> bool
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.
sourceimpl<'a> ConvertibleFrom<&'a Rational> for i32
impl<'a> ConvertibleFrom<&'a Rational> for i32
sourcefn convertible_from(value: &Rational) -> bool
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.
sourceimpl<'a> ConvertibleFrom<&'a Rational> for i64
impl<'a> ConvertibleFrom<&'a Rational> for i64
sourcefn convertible_from(value: &Rational) -> bool
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.
sourceimpl<'a> ConvertibleFrom<&'a Rational> for i8
impl<'a> ConvertibleFrom<&'a Rational> for i8
sourcefn convertible_from(value: &Rational) -> bool
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.
sourceimpl<'a> ConvertibleFrom<&'a Rational> for isize
impl<'a> ConvertibleFrom<&'a Rational> for isize
sourcefn convertible_from(value: &Rational) -> bool
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.
sourceimpl<'a> ConvertibleFrom<&'a Rational> for u128
impl<'a> ConvertibleFrom<&'a Rational> for u128
sourcefn convertible_from(value: &Rational) -> bool
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.
sourceimpl<'a> ConvertibleFrom<&'a Rational> for u16
impl<'a> ConvertibleFrom<&'a Rational> for u16
sourcefn convertible_from(value: &Rational) -> bool
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.
sourceimpl<'a> ConvertibleFrom<&'a Rational> for u32
impl<'a> ConvertibleFrom<&'a Rational> for u32
sourcefn convertible_from(value: &Rational) -> bool
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.
sourceimpl<'a> ConvertibleFrom<&'a Rational> for u64
impl<'a> ConvertibleFrom<&'a Rational> for u64
sourcefn convertible_from(value: &Rational) -> bool
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.
sourceimpl<'a> ConvertibleFrom<&'a Rational> for u8
impl<'a> ConvertibleFrom<&'a Rational> for u8
sourcefn convertible_from(value: &Rational) -> bool
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.
sourceimpl<'a> ConvertibleFrom<&'a Rational> for usize
impl<'a> ConvertibleFrom<&'a Rational> for usize
sourcefn convertible_from(value: &Rational) -> bool
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.
sourceimpl ConvertibleFrom<Rational> for f32
impl ConvertibleFrom<Rational> for f32
sourcefn convertible_from(value: Rational) -> bool
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.
sourceimpl ConvertibleFrom<Rational> for f64
impl ConvertibleFrom<Rational> for f64
sourcefn convertible_from(value: Rational) -> bool
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.
sourceimpl Debug for Rational
impl Debug for Rational
sourcefn fmt(&self, f: &mut Formatter<'_>) -> Result
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Converts a Rational
to a String
.
This is the same implementation as for Display
.
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToDebugString;
use malachite_q::Rational;
assert_eq!(Rational::ZERO.to_debug_string(), "0");
assert_eq!(Rational::from(123).to_debug_string(), "123");
assert_eq!(Rational::from_signeds(22, 7).to_debug_string(), "22/7");
sourceimpl<'a, 'b> DenominatorsInClosedInterval<'a, 'b> for Rational
impl<'a, 'b> DenominatorsInClosedInterval<'a, 'b> for Rational
sourcefn denominators_in_closed_interval(
a: &'a Rational,
b: &'b Rational
) -> DenominatorsInClosedRationalInterval<'a, 'b>ⓘNotable traits for DenominatorsInClosedRationalInterval<'a, 'b>impl<'a, 'b> Iterator for DenominatorsInClosedRationalInterval<'a, 'b> type Item = Natural;
fn denominators_in_closed_interval(
a: &'a Rational,
b: &'b Rational
) -> DenominatorsInClosedRationalInterval<'a, 'b>ⓘNotable traits for DenominatorsInClosedRationalInterval<'a, 'b>impl<'a, 'b> Iterator for DenominatorsInClosedRationalInterval<'a, 'b> type Item = Natural;
Returns an iterator of all denominators that appear in the Rational
s contained in a
closed interval.
For example, consider the interval $[1/3, 1/2]$. It contains no integers, so no
Rational
s with denominator 1. It does contain Rational
s 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$.
extern crate malachite_base;
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, 3000001, 3000002, 4000001, 4000003, 5000001, 5000002, 5000003, \
5000004, 6000001, 6000005, 7000001, 7000002, 7000003, 7000004, 7000005, 7000006, \
8000001, 8000003, ...]"
);
type Denominators = DenominatorsInClosedRationalInterval<'a, 'b>
sourceimpl Display for Rational
impl Display for Rational
sourcefn fmt(&self, f: &mut Formatter<'_>) -> Result
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Converts a Rational
to a String
.
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
use std::str::FromStr;
assert_eq!(Rational::ZERO.to_string(), "0");
assert_eq!(Rational::from(123).to_string(), "123");
assert_eq!(Rational::from_str("22/7").unwrap().to_string(), "22/7");
sourceimpl<'a, 'b> Div<&'a Rational> for &'b Rational
impl<'a, 'b> Div<&'a Rational> for &'b Rational
sourcefn div(self, other: &'a Rational) -> Rational
fn div(self, other: &'a Rational) -> Rational
Divides a Rational
by another Rational
, taking both by reference.
$$ f(x, y) = \frac{x}{y}. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Panics
Panics if the second Rational
is zero.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::Two;
use malachite_q::Rational;
assert_eq!(&Rational::TWO / &Rational::TWO, 1);
assert_eq!(
(&Rational::from_signeds(22, 7) / &Rational::from_signeds(99, 100)).to_string(),
"200/63"
);
sourceimpl<'a> Div<&'a Rational> for Rational
impl<'a> Div<&'a Rational> for Rational
sourcefn div(self, other: &'a Rational) -> Rational
fn div(self, other: &'a Rational) -> Rational
Divides a Rational
by another Rational
, taking the first by value and the second by
reference.
$$ f(x, y) = \frac{x}{y}. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Panics
Panics if the second Rational
is zero.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::Two;
use malachite_q::Rational;
assert_eq!(Rational::TWO / &Rational::TWO, 1);
assert_eq!(
(Rational::from_signeds(22, 7) / &Rational::from_signeds(99, 100)).to_string(),
"200/63"
);
sourceimpl<'a> Div<Rational> for &'a Rational
impl<'a> Div<Rational> for &'a Rational
sourcefn div(self, other: Rational) -> Rational
fn div(self, other: Rational) -> Rational
Divides a Rational
by another Rational
, taking the first by reference and the second
by value.
$$ f(x, y) = \frac{x}{y}. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Panics
Panics if the second Rational
is zero.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::Two;
use malachite_q::Rational;
assert_eq!(&Rational::TWO / Rational::TWO, 1);
assert_eq!(
(&Rational::from_signeds(22, 7) / Rational::from_signeds(99, 100)).to_string(),
"200/63"
);
sourceimpl Div<Rational> for Rational
impl Div<Rational> for Rational
sourcefn div(self, other: Rational) -> Rational
fn div(self, other: Rational) -> Rational
Divides a Rational
by another Rational
, taking both by value.
$$ f(x, y) = \frac{x}{y}. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Panics
Panics if the second Rational
is zero.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::Two;
use malachite_q::Rational;
assert_eq!(Rational::TWO / Rational::TWO, 1);
assert_eq!(
(Rational::from_signeds(22, 7) / Rational::from_signeds(99, 100)).to_string(),
"200/63"
);
sourceimpl<'a> DivAssign<&'a Rational> for Rational
impl<'a> DivAssign<&'a Rational> for Rational
sourcefn div_assign(&mut self, other: &'a Rational)
fn div_assign(&mut self, other: &'a Rational)
Divides a Rational
by a Rational
in place, taking the Rational
on the right-hand
side by reference.
$$ x \gets \frac{x}{y}. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Panics
Panics if the second Rational
is zero.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::Two;
use malachite_q::Rational;
let mut x = Rational::TWO;
x /= &Rational::TWO;
assert_eq!(x, 1);
let mut x = Rational::from_signeds(22, 7);
x /= &Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "200/63");
sourceimpl DivAssign<Rational> for Rational
impl DivAssign<Rational> for Rational
sourcefn div_assign(&mut self, other: Rational)
fn div_assign(&mut self, other: Rational)
Divides a Rational
by a Rational
in place, taking the Rational
on the right-hand
side by value.
$$ x \gets \frac{x}{y}. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Panics
Panics if the second Rational
is zero.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::Two;
use malachite_q::Rational;
let mut x = Rational::TWO;
x /= Rational::TWO;
assert_eq!(x, 1);
let mut x = Rational::from_signeds(22, 7);
x /= Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "200/63");
sourceimpl<'a> Floor for &'a Rational
impl<'a> Floor for &'a Rational
sourcefn floor(self) -> Integer
fn floor(self) -> Integer
Finds the floor of a Rational
, taking the Rational
by reference.
$$ f(x) = \lfloor x \rfloor. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Floor;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
use std::str::FromStr;
assert_eq!((&Rational::ZERO).floor(), 0);
assert_eq!((&Rational::from_signeds(22, 7)).floor(), 3);
assert_eq!((&Rational::from_signeds(-22, 7)).floor(), -4);
type Output = Integer
sourceimpl Floor for Rational
impl Floor for Rational
sourcefn floor(self) -> Integer
fn floor(self) -> Integer
Finds the floor of a Rational
, taking the Rational
by value.
$$ f(x) = \lfloor x \rfloor. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Floor;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!(Rational::ZERO.floor(), 0);
assert_eq!(Rational::from_signeds(22, 7).floor(), 3);
assert_eq!(Rational::from_signeds(-22, 7).floor(), -4);
type Output = Integer
sourceimpl FloorAssign for Rational
impl FloorAssign for Rational
sourcefn floor_assign(&mut self)
fn floor_assign(&mut self)
Replaces a Rational
with its floor.
$$ x \gets \lfloor x \rfloor. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::FloorAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
use std::str::FromStr;
let mut x = Rational::ZERO;
x.floor_assign();
assert_eq!(x, 0);
let mut x = Rational::from_signeds(22, 7);
x.floor_assign();
assert_eq!(x, 3);
let mut x = Rational::from_signeds(-22, 7);
x.floor_assign();
assert_eq!(x, -4);
sourceimpl<'a, 'b> FloorLogBase<&'b Rational> for &'a Rational
impl<'a, 'b> FloorLogBase<&'b Rational> for &'a Rational
sourcefn floor_log_base(self, base: &Rational) -> i64
fn floor_log_base(self, base: &Rational) -> i64
Returns the floor of the base-$b$ logarithm of a positive Rational
.
Note that this function may be slow if the base is very close to 1.
$f(x, b) = \lfloor\log_b x\rfloor$.
Worst-case complexity
$T(n, m) = O(nm \log (nm) \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is base.significant_bits()
, and $m$ is
$|\log_b x|$, where $b$ is base
and $x$ is x
.
Panics
Panics if self
less than or equal to zero or base
is 1.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::FloorLogBase;
use malachite_q::Rational;
assert_eq!(Rational::from(80u32).floor_log_base(&Rational::from(3u32)), 3);
assert_eq!(Rational::from(81u32).floor_log_base(&Rational::from(3u32)), 4);
assert_eq!(Rational::from(82u32).floor_log_base(&Rational::from(3u32)), 4);
assert_eq!(Rational::from(4294967296u64).floor_log_base(&Rational::from(10u32)), 9);
assert_eq!(
Rational::from_signeds(936851431250i64, 1397).floor_log_base(&Rational::from(10u32)),
8
);
assert_eq!(
Rational::from_signeds(5153632, 16807).floor_log_base(&Rational::from_signeds(22, 7)),
5
);
type Output = i64
sourceimpl<'a> FloorLogBase2 for &'a Rational
impl<'a> FloorLogBase2 for &'a Rational
sourcefn floor_log_base_2(self) -> i64
fn floor_log_base_2(self) -> i64
Returns the floor of the base-2 logarithm of a positive Rational
.
$f(x) = \lfloor\log_2 x\rfloor$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if self
less than or equal to zero.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::FloorLogBase2;
use malachite_q::Rational;
assert_eq!(Rational::from(3u32).floor_log_base_2(), 1);
assert_eq!(Rational::from_signeds(1, 3).floor_log_base_2(), -2);
assert_eq!(Rational::from_signeds(1, 4).floor_log_base_2(), -2);
assert_eq!(Rational::from_signeds(1, 5).floor_log_base_2(), -3);
type Output = i64
sourceimpl<'a> FloorLogBasePowerOf2<i64> for &'a Rational
impl<'a> FloorLogBasePowerOf2<i64> for &'a Rational
sourcefn floor_log_base_power_of_2(self, pow: i64) -> i64
fn floor_log_base_power_of_2(self, pow: i64) -> i64
Returns the floor of the base-$2^k$ logarithm of a positive Rational
.
$k$ may be negative.
$f(x, k) = \lfloor\log_{2^k} x\rfloor$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if self
is less than or equal to 0 or pow
is 0.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::FloorLogBasePowerOf2;
use malachite_q::Rational;
assert_eq!(Rational::from(100).floor_log_base_power_of_2(2), 3);
assert_eq!(Rational::from(4294967296u64).floor_log_base_power_of_2(8), 4);
// 4^(-2) < 1/10 < 4^(-1)
assert_eq!(Rational::from_signeds(1, 10).floor_log_base_power_of_2(2), -2);
// (1/4)^2 < 1/10 < (1/4)^1
assert_eq!(Rational::from_signeds(1, 10).floor_log_base_power_of_2(-2), 1);
type Output = i64
sourceimpl<'a> From<&'a Integer> for Rational
impl<'a> From<&'a Integer> for Rational
sourcefn from(value: &'a Integer) -> Rational
fn from(value: &'a Integer) -> Rational
Converts an Integer
to a Rational
, taking the
Integer
by reference.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Examples
extern crate malachite_nz;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
assert_eq!(Rational::from(&Integer::from(123)), 123);
assert_eq!(Rational::from(&Integer::from(-123)), -123);
sourceimpl<'a> From<&'a Natural> for Rational
impl<'a> From<&'a Natural> for Rational
sourcefn from(value: &'a Natural) -> Rational
fn from(value: &'a Natural) -> Rational
Converts a Natural
to a Rational
, taking the
Natural
by reference.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Examples
extern crate malachite_nz;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert_eq!(Rational::from(&Natural::from(123u32)), 123);
sourceimpl From<Integer> for Rational
impl From<Integer> for Rational
sourcefn from(value: Integer) -> Rational
fn from(value: Integer) -> Rational
Converts an Integer
to a Rational
, taking the
Integer
by value.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_nz;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
assert_eq!(Rational::from(Integer::from(123)), 123);
assert_eq!(Rational::from(Integer::from(-123)), -123);
sourceimpl From<Natural> for Rational
impl From<Natural> for Rational
sourcefn from(value: Natural) -> Rational
fn from(value: Natural) -> Rational
Converts a Natural
to a Rational
, taking the
Natural
by value.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_nz;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert_eq!(Rational::from(Natural::from(123u32)), 123);
sourceimpl FromSciString for Rational
impl FromSciString for Rational
sourcefn from_sci_string_with_options(
s: &str,
options: FromSciStringOptions
) -> Option<Rational>
fn from_sci_string_with_options(
s: &str,
options: FromSciStringOptions
) -> Option<Rational>
Converts a string, possibly in scientfic notation, to a Rational
.
Use
FromSciStringOptions
to specify the base (from 2 to 36, inclusive). The rounding mode option is ignored.
If the base is greater than 10, the higher digits are represented by the letters 'a'
through 'z'
or 'A'
through 'Z'
; the case doesn’t matter and doesn’t need to be
consistent.
Exponents are allowed, and are indicated using the character 'e'
or 'E'
. If the base is
15 or greater, an ambiguity arises where it may not be clear whether 'e'
is a digit or
an exponent indicator. To resolve this ambiguity, always use a '+'
or '-'
sign after
the exponent indicator when the base is 15 or greater.
The exponent itself is always parsed using base 10.
Decimal (or other-base) points are allowed.
If the string is unparseable, None
is returned.
This function is very literal; given "0.333"
, it will return $333/1000$ rather than
$1/3$. If you’d prefer that it return $1/3$, consider using
from_sci_string_simplest
instead. However, that
function has its quirks too: given "0.1"
, it will not return $1/10$ (see its
documentation for an explanation of this behavior). This function does return $1/10$.
Worst-case complexity
$T(n, m) = O(m^n n \log m (\log n + \log\log m))$
$M(n, m) = O(m^n n \log m)$
where $T$ is time, $M$ is additional memory, $n$ is s.len()
, and $m$ is options.base
.
Examples
extern crate malachite_base;
use malachite_base::num::conversion::string::options::FromSciStringOptions;
use malachite_base::num::conversion::traits::FromSciString;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;
assert_eq!(Rational::from_sci_string("123").unwrap(), 123);
assert_eq!(Rational::from_sci_string("0.1").unwrap().to_string(), "1/10");
assert_eq!(Rational::from_sci_string("0.10").unwrap().to_string(), "1/10");
assert_eq!(Rational::from_sci_string("0.333").unwrap().to_string(), "333/1000");
assert_eq!(Rational::from_sci_string("1.2e5").unwrap(), 120000);
assert_eq!(Rational::from_sci_string("1.2e-5").unwrap().to_string(), "3/250000");
let mut options = FromSciStringOptions::default();
options.set_base(16);
assert_eq!(Rational::from_sci_string_with_options("ff", options).unwrap(), 255);
assert_eq!(Rational::from_sci_string_with_options("ffE+5", options).unwrap(), 267386880);
assert_eq!(
Rational::from_sci_string_with_options("ffE-5", options).unwrap().to_string(),
"255/1048576"
);
sourcefn from_sci_string(s: &str) -> Option<Self>
fn from_sci_string(s: &str) -> Option<Self>
&str
, possibly in scientific notation, to a number, using the default
FromSciStringOptions
. Read moresourceimpl FromStr for Rational
impl FromStr for Rational
sourcefn from_str(s: &str) -> Result<Rational, ()>
fn from_str(s: &str) -> Result<Rational, ()>
Converts an string to a Rational
.
If the string does not represent a valid Rational
, an Err
is returned. The numerator
and denominator do not need to be in lowest terms, but the denominator must be nonzero. A
negative sign is only allowed at the 0th position of the string.
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is s.len()
.
Examples
use malachite_q::Rational;
use std::str::FromStr;
assert_eq!(Rational::from_str("123456").unwrap(), 123456);
assert_eq!(Rational::from_str("00123456").unwrap(), 123456);
assert_eq!(Rational::from_str("0").unwrap(), 0);
assert_eq!(Rational::from_str("-123456").unwrap(), -123456);
assert_eq!(Rational::from_str("-00123456").unwrap(), -123456);
assert_eq!(Rational::from_str("-0").unwrap(), 0);
assert_eq!(Rational::from_str("22/7").unwrap().to_string(), "22/7");
assert_eq!(Rational::from_str("01/02").unwrap().to_string(), "1/2");
assert_eq!(Rational::from_str("3/21").unwrap().to_string(), "1/7");
assert_eq!(Rational::from_str("-22/7").unwrap().to_string(), "-22/7");
assert_eq!(Rational::from_str("-01/02").unwrap().to_string(), "-1/2");
assert_eq!(Rational::from_str("-3/21").unwrap().to_string(), "-1/7");
assert!(Rational::from_str("").is_err());
assert!(Rational::from_str("a").is_err());
assert!(Rational::from_str("1/0").is_err());
assert!(Rational::from_str("/1").is_err());
assert!(Rational::from_str("1/").is_err());
assert!(Rational::from_str("--1").is_err());
assert!(Rational::from_str("1/-2").is_err());
sourceimpl<'a> IsInteger for &'a Rational
impl<'a> IsInteger for &'a Rational
sourcefn is_integer(self) -> bool
fn is_integer(self) -> bool
Determines whether a Rational
is an integer.
$f(x) = x \in \Z$.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::{One, Zero};
use malachite_base::num::conversion::traits::IsInteger;
use malachite_q::Rational;
assert_eq!(Rational::ZERO.is_integer(), true);
assert_eq!(Rational::ONE.is_integer(), true);
assert_eq!(Rational::from(100).is_integer(), true);
assert_eq!(Rational::from_signeds(22, 7).is_integer(), false);
sourceimpl IsPowerOf2 for Rational
impl IsPowerOf2 for Rational
sourcefn is_power_of_2(&self) -> bool
fn is_power_of_2(&self) -> bool
Determines whether a Rational
is an integer power of 2.
$f(x) = (\exists n \in \Z : 2^n = x)$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::IsPowerOf2;
use malachite_q::Rational;
assert_eq!(Rational::from(0x80).is_power_of_2(), true);
assert_eq!(Rational::from_signeds(1, 8).is_power_of_2(), true);
assert_eq!(Rational::from_signeds(-1, 8).is_power_of_2(), false);
assert_eq!(Rational::from_signeds(22, 7).is_power_of_2(), false);
sourceimpl<'a, 'b> Mul<&'a Rational> for &'b Rational
impl<'a, 'b> Mul<&'a Rational> for &'b Rational
sourcefn mul(self, other: &'a Rational) -> Rational
fn mul(self, other: &'a Rational) -> Rational
Multiplies two Rational
s, taking both by reference.
$$ f(x, y) = xy. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::{OneHalf, Two};
use malachite_q::Rational;
assert_eq!(&Rational::ONE_HALF * &Rational::TWO, 1);
assert_eq!(
(&Rational::from_signeds(22, 7) * &Rational::from_signeds(99, 100)).to_string(),
"1089/350"
);
sourceimpl<'a> Mul<&'a Rational> for Rational
impl<'a> Mul<&'a Rational> for Rational
sourcefn mul(self, other: &'a Rational) -> Rational
fn mul(self, other: &'a Rational) -> Rational
Multiplies two Rational
s, taking the first by value and the second by reference.
$$ f(x, y) = xy. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::{OneHalf, Two};
use malachite_q::Rational;
assert_eq!(Rational::ONE_HALF * &Rational::TWO, 1);
assert_eq!(
(Rational::from_signeds(22, 7) * &Rational::from_signeds(99, 100)).to_string(),
"1089/350"
);
sourceimpl<'a> Mul<Rational> for &'a Rational
impl<'a> Mul<Rational> for &'a Rational
sourcefn mul(self, other: Rational) -> Rational
fn mul(self, other: Rational) -> Rational
Multiplies two Rational
s, taking the first by reference and the second by value.
$$ f(x, y) = xy. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::{OneHalf, Two};
use malachite_q::Rational;
assert_eq!(&Rational::ONE_HALF * Rational::TWO, 1);
assert_eq!(
(&Rational::from_signeds(22, 7) * Rational::from_signeds(99, 100)).to_string(),
"1089/350"
);
sourceimpl Mul<Rational> for Rational
impl Mul<Rational> for Rational
sourcefn mul(self, other: Rational) -> Rational
fn mul(self, other: Rational) -> Rational
Multiplies two Rational
s, taking both by value.
$$ f(x, y) = xy. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::{OneHalf, Two};
use malachite_q::Rational;
assert_eq!(Rational::ONE_HALF * Rational::TWO, 1);
assert_eq!(
(Rational::from_signeds(22, 7) * Rational::from_signeds(99, 100)).to_string(),
"1089/350"
);
sourceimpl<'a> MulAssign<&'a Rational> for Rational
impl<'a> MulAssign<&'a Rational> for Rational
sourcefn mul_assign(&mut self, other: &'a Rational)
fn mul_assign(&mut self, other: &'a Rational)
Multiplies a Rational
by a Rational
in place, taking the Rational
on the
right-hand side by reference.
$$ x \gets xy. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::{OneHalf, Two};
use malachite_q::Rational;
let mut x = Rational::ONE_HALF;
x *= &Rational::TWO;
assert_eq!(x, 1);
let mut x = Rational::from_signeds(22, 7);
x *= &Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "1089/350");
sourceimpl MulAssign<Rational> for Rational
impl MulAssign<Rational> for Rational
sourcefn mul_assign(&mut self, other: Rational)
fn mul_assign(&mut self, other: Rational)
Multiplies a Rational
by a Rational
in place, taking the Rational
on the
right-hand side by value.
$$ x \gets xy. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::{OneHalf, Two};
use malachite_q::Rational;
let mut x = Rational::ONE_HALF;
x *= Rational::TWO;
assert_eq!(x, 1);
let mut x = Rational::from_signeds(22, 7);
x *= Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "1089/350");
sourceimpl Named for Rational
impl Named for Rational
sourceconst NAME: &'static str = _
const NAME: &'static str = _
The name of this type, as given by the stringify
macro.
See the documentation for impl_named
for more details.
sourceimpl<'a> Neg for &'a Rational
impl<'a> Neg for &'a Rational
sourcefn neg(self) -> Rational
fn neg(self) -> Rational
Negates a Rational
, taking it by reference.
$$ f(x) = -x. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!(-&Rational::ZERO, 0);
assert_eq!((-&Rational::from_signeds(22, 7)).to_string(), "-22/7");
assert_eq!((-&Rational::from_signeds(-22, 7)).to_string(), "22/7");
sourceimpl Neg for Rational
impl Neg for Rational
sourcefn neg(self) -> Rational
fn neg(self) -> Rational
Negates a Rational
, taking it by value.
$$ f(x) = -x. $$
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!(-Rational::ZERO, 0);
assert_eq!((-Rational::from_signeds(22, 7)).to_string(), "-22/7");
assert_eq!((-Rational::from_signeds(-22, 7)).to_string(), "22/7");
sourceimpl NegAssign for Rational
impl NegAssign for Rational
sourcefn neg_assign(&mut self)
fn neg_assign(&mut self)
Negates a Rational
in place.
$$ x \gets -x. $$
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::NegAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
let mut x = Rational::ZERO;
x.neg_assign();
assert_eq!(x, 0);
let mut x = Rational::from_signeds(22, 7);
x.neg_assign();
assert_eq!(x.to_string(), "-22/7");
let mut x = Rational::from_signeds(-22, 7);
x.neg_assign();
assert_eq!(x.to_string(), "22/7");
sourceimpl<'a> NextPowerOf2 for &'a Rational
impl<'a> NextPowerOf2 for &'a Rational
sourcefn next_power_of_2(self) -> Rational
fn next_power_of_2(self) -> Rational
Finds the smallest power of 2 greater than or equal to a Rational
. The Rational
is
taken by reference.
$f(x) = 2^{\lceil \log_2 x \rceil}$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if self
is less than or equal to zero.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::NextPowerOf2;
use malachite_q::Rational;
assert_eq!((&Rational::from(123)).next_power_of_2(), 128);
assert_eq!((&Rational::from_signeds(1, 10)).next_power_of_2().to_string(), "1/8");
type Output = Rational
sourceimpl NextPowerOf2 for Rational
impl NextPowerOf2 for Rational
sourcefn next_power_of_2(self) -> Rational
fn next_power_of_2(self) -> Rational
Finds the smallest power of 2 greater than or equal to a Rational
. The Rational
is
taken by value.
$f(x) = 2^{\lceil \log_2 x \rceil}$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if self
is less than or equal to zero.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::NextPowerOf2;
use malachite_q::Rational;
assert_eq!(Rational::from(123).next_power_of_2(), 128);
assert_eq!(Rational::from_signeds(1, 10).next_power_of_2().to_string(), "1/8");
type Output = Rational
sourceimpl NextPowerOf2Assign for Rational
impl NextPowerOf2Assign for Rational
sourcefn next_power_of_2_assign(&mut self)
fn next_power_of_2_assign(&mut self)
Finds the smallest power of 2 greater than or equal to a Rational
. The Rational
is
taken by reference.
$f(x) = 2^{\lceil \log_2 x \rceil}$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if self
is less than or equal to zero.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::NextPowerOf2Assign;
use malachite_q::Rational;
use std::str::FromStr;
let mut x = Rational::from(123);
x.next_power_of_2_assign();
assert_eq!(x, 128);
let mut x = Rational::from_signeds(1, 10);
x.next_power_of_2_assign();
assert_eq!(x.to_string(), "1/8");
sourceimpl Ord for Rational
impl Ord for Rational
sourcefn cmp(&self, other: &Rational) -> Ordering
fn cmp(&self, other: &Rational) -> Ordering
Compares two Rational
s.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
use std::str::FromStr;
assert!(Rational::from_str("2/3").unwrap() > Rational::ONE_HALF);
assert!(Rational::from_str("-2/3").unwrap() < Rational::ONE_HALF);
1.21.0 · sourceconst fn max(self, other: Self) -> Self
const fn max(self, other: Self) -> Self
1.21.0 · sourceconst fn min(self, other: Self) -> Self
const fn min(self, other: Self) -> Self
1.50.0 · sourceconst fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: PartialOrd<Self>,
const fn clamp(self, min: Self, max: Self) -> Selfwhere
Self: PartialOrd<Self>,
sourceimpl OrdAbs for Rational
impl OrdAbs for Rational
sourcefn cmp_abs(&self, other: &Rational) -> Ordering
fn cmp_abs(&self, other: &Rational) -> Ordering
Compares the absolute values of two Rational
s.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::OneHalf;
use malachite_base::num::comparison::traits::OrdAbs;
use malachite_q::Rational;
use std::cmp::Ordering;
use std::str::FromStr;
assert_eq!(
Rational::from_str("2/3").unwrap().cmp_abs(&Rational::ONE_HALF),
Ordering::Greater
);
assert_eq!(
Rational::from_str("-2/3").unwrap().cmp_abs(&Rational::ONE_HALF),
Ordering::Greater
);
sourceimpl PartialEq<Integer> for Rational
impl PartialEq<Integer> for Rational
sourcefn eq(&self, other: &Integer) -> bool
fn eq(&self, other: &Integer) -> bool
Determines whether a Rational
is equal to an
Integer
.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is
min(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_nz;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
assert!(Rational::from(-123) == Integer::from(-123));
assert!(Rational::from_signeds(22, 7) != Integer::from(5));
sourceimpl PartialEq<Natural> for Rational
impl PartialEq<Natural> for Rational
sourcefn eq(&self, other: &Natural) -> bool
fn eq(&self, other: &Natural) -> bool
Determines whether a Rational
is equal to a
Natural
.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is
min(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_nz;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert!(Rational::from(123) == Natural::from(123u32));
assert!(Rational::from_signeds(22, 7) != Natural::from(5u32));
sourceimpl PartialEq<Rational> for Integer
impl PartialEq<Rational> for Integer
sourcefn eq(&self, other: &Rational) -> bool
fn eq(&self, other: &Rational) -> bool
Determines whether an Integer
is equal to a
Rational
.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is
min(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_nz;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
assert!(Integer::from(-123) == Rational::from(-123));
assert!(Integer::from(5) != Rational::from_signeds(22, 7));
sourceimpl PartialEq<Rational> for Natural
impl PartialEq<Rational> for Natural
sourcefn eq(&self, other: &Rational) -> bool
fn eq(&self, other: &Rational) -> bool
Determines whether a Natural
is equal to a
Rational
.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is
min(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_nz;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert!(Natural::from(123u32) == Rational::from(123));
assert!(Natural::from(5u32) != Rational::from_signeds(22, 7));
sourceimpl PartialEq<Rational> for f32
impl PartialEq<Rational> for f32
sourcefn eq(&self, other: &Rational) -> bool
fn eq(&self, other: &Rational) -> bool
Determines whether a primitive float is equal to a Rational
.
Worst-case complexity
$T(n) = O(n)$
$M(m) = O(m)$
where $T$ is time, $M$ is additional memory, $n$ is
max(self.sci_exponent(), other.significant_bits())
, and $m$ is
self.sci_exponent()
.
Examples
See here.
sourceimpl PartialEq<Rational> for f64
impl PartialEq<Rational> for f64
sourcefn eq(&self, other: &Rational) -> bool
fn eq(&self, other: &Rational) -> bool
Determines whether a primitive float is equal to a Rational
.
Worst-case complexity
$T(n) = O(n)$
$M(m) = O(m)$
where $T$ is time, $M$ is additional memory, $n$ is
max(self.sci_exponent(), other.significant_bits())
, and $m$ is
self.sci_exponent()
.
Examples
See here.
sourceimpl PartialEq<Rational> for i128
impl PartialEq<Rational> for i128
sourceimpl PartialEq<Rational> for i16
impl PartialEq<Rational> for i16
sourceimpl PartialEq<Rational> for i32
impl PartialEq<Rational> for i32
sourceimpl PartialEq<Rational> for i64
impl PartialEq<Rational> for i64
sourceimpl PartialEq<Rational> for i8
impl PartialEq<Rational> for i8
sourceimpl PartialEq<Rational> for isize
impl PartialEq<Rational> for isize
sourceimpl PartialEq<Rational> for u128
impl PartialEq<Rational> for u128
sourceimpl PartialEq<Rational> for u16
impl PartialEq<Rational> for u16
sourceimpl PartialEq<Rational> for u32
impl PartialEq<Rational> for u32
sourceimpl PartialEq<Rational> for u64
impl PartialEq<Rational> for u64
sourceimpl PartialEq<Rational> for u8
impl PartialEq<Rational> for u8
sourceimpl PartialEq<Rational> for usize
impl PartialEq<Rational> for usize
sourceimpl PartialEq<f32> for Rational
impl PartialEq<f32> for Rational
sourcefn eq(&self, other: &f32) -> bool
fn eq(&self, other: &f32) -> bool
Determines whether a Rational
is equal to a primitive float.
Worst-case complexity
$T(n) = O(n)$
$M(m) = O(m)$
where $T$ is time, $M$ is additional memory, $n$ is
max(self.significant_bits(), other.sci_exponent())
, and $m$ is
other.sci_exponent()
.
Examples
See here.
sourceimpl PartialEq<f64> for Rational
impl PartialEq<f64> for Rational
sourcefn eq(&self, other: &f64) -> bool
fn eq(&self, other: &f64) -> bool
Determines whether a Rational
is equal to a primitive float.
Worst-case complexity
$T(n) = O(n)$
$M(m) = O(m)$
where $T$ is time, $M$ is additional memory, $n$ is
max(self.significant_bits(), other.sci_exponent())
, and $m$ is
other.sci_exponent()
.
Examples
See here.
sourceimpl PartialEq<i128> for Rational
impl PartialEq<i128> for Rational
sourceimpl PartialEq<i16> for Rational
impl PartialEq<i16> for Rational
sourceimpl PartialEq<i32> for Rational
impl PartialEq<i32> for Rational
sourceimpl PartialEq<i64> for Rational
impl PartialEq<i64> for Rational
sourceimpl PartialEq<i8> for Rational
impl PartialEq<i8> for Rational
sourceimpl PartialEq<isize> for Rational
impl PartialEq<isize> for Rational
sourceimpl PartialEq<u128> for Rational
impl PartialEq<u128> for Rational
sourceimpl PartialEq<u16> for Rational
impl PartialEq<u16> for Rational
sourceimpl PartialEq<u32> for Rational
impl PartialEq<u32> for Rational
sourceimpl PartialEq<u64> for Rational
impl PartialEq<u64> for Rational
sourceimpl PartialEq<u8> for Rational
impl PartialEq<u8> for Rational
sourceimpl PartialEq<usize> for Rational
impl PartialEq<usize> for Rational
sourceimpl PartialOrd<Integer> for Rational
impl PartialOrd<Integer> for Rational
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares a Rational
to an Integer
.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_nz;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
assert!(Rational::from_signeds(22, 7) > Integer::from(3));
assert!(Rational::from_signeds(22, 7) < Integer::from(4));
assert!(Rational::from_signeds(-22, 7) < Integer::from(-3));
assert!(Rational::from_signeds(-22, 7) > Integer::from(-4));
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Natural> for Rational
impl PartialOrd<Natural> for Rational
sourcefn partial_cmp(&self, other: &Natural) -> Option<Ordering>
fn partial_cmp(&self, other: &Natural) -> Option<Ordering>
Compares a Rational
to a Natural
.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_nz;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert!(Rational::from_signeds(22, 7) > Natural::from(3u32));
assert!(Rational::from_signeds(22, 7) < Natural::from(4u32));
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for Integer
impl PartialOrd<Rational> for Integer
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
Compares an Integer
to a Rational
.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_nz;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
assert!(Integer::from(3) < Rational::from_signeds(22, 7));
assert!(Integer::from(4) > Rational::from_signeds(22, 7));
assert!(Integer::from(-3) > Rational::from_signeds(-22, 7));
assert!(Integer::from(-4) < Rational::from_signeds(-22, 7));
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for Natural
impl PartialOrd<Rational> for Natural
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
Compares a Natural
to a Rational
.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_nz;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert!(Natural::from(3u32) < Rational::from_signeds(22, 7));
assert!(Natural::from(4u32) > Rational::from_signeds(22, 7));
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for Rational
impl PartialOrd<Rational> for Rational
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for f32
impl PartialOrd<Rational> for f32
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
Compares a primitive float to a Rational
.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(other.sci_exponent(), self.significant_bits())
.
Examples
See here.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for f64
impl PartialOrd<Rational> for f64
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp(&self, other: &Rational) -> Option<Ordering>
Compares a primitive float to a Rational
.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(other.sci_exponent(), self.significant_bits())
.
Examples
See here.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for i128
impl PartialOrd<Rational> for i128
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for i16
impl PartialOrd<Rational> for i16
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for i32
impl PartialOrd<Rational> for i32
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for i64
impl PartialOrd<Rational> for i64
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for i8
impl PartialOrd<Rational> for i8
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for isize
impl PartialOrd<Rational> for isize
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for u128
impl PartialOrd<Rational> for u128
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for u16
impl PartialOrd<Rational> for u16
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for u32
impl PartialOrd<Rational> for u32
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for u64
impl PartialOrd<Rational> for u64
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for u8
impl PartialOrd<Rational> for u8
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<Rational> for usize
impl PartialOrd<Rational> for usize
sourcefn partial_cmp(&self, other: &Rational) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<f32> for Rational
impl PartialOrd<f32> for Rational
sourcefn partial_cmp(&self, other: &f32) -> Option<Ordering>
fn partial_cmp(&self, other: &f32) -> Option<Ordering>
Compares a Rational
to a primitive float.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.sci_exponent())
.
Examples
See here.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<f64> for Rational
impl PartialOrd<f64> for Rational
sourcefn partial_cmp(&self, other: &f64) -> Option<Ordering>
fn partial_cmp(&self, other: &f64) -> Option<Ordering>
Compares a Rational
to a primitive float.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.sci_exponent())
.
Examples
See here.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<i128> for Rational
impl PartialOrd<i128> for Rational
sourcefn partial_cmp(&self, other: &i128) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<i16> for Rational
impl PartialOrd<i16> for Rational
sourcefn partial_cmp(&self, other: &i16) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<i32> for Rational
impl PartialOrd<i32> for Rational
sourcefn partial_cmp(&self, other: &i32) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<i64> for Rational
impl PartialOrd<i64> for Rational
sourcefn partial_cmp(&self, other: &i64) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<i8> for Rational
impl PartialOrd<i8> for Rational
sourcefn partial_cmp(&self, other: &i8) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<isize> for Rational
impl PartialOrd<isize> for Rational
sourcefn partial_cmp(&self, other: &isize) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<u128> for Rational
impl PartialOrd<u128> for Rational
sourcefn partial_cmp(&self, other: &u128) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<u16> for Rational
impl PartialOrd<u16> for Rational
sourcefn partial_cmp(&self, other: &u16) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<u32> for Rational
impl PartialOrd<u32> for Rational
sourcefn partial_cmp(&self, other: &u32) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<u64> for Rational
impl PartialOrd<u64> for Rational
sourcefn partial_cmp(&self, other: &u64) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<u8> for Rational
impl PartialOrd<u8> for Rational
sourcefn partial_cmp(&self, other: &u8) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrd<usize> for Rational
impl PartialOrd<usize> for Rational
sourcefn partial_cmp(&self, other: &usize) -> Option<Ordering>
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.
1.0.0 · sourceconst fn le(&self, other: &Rhs) -> bool
const fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moresourceimpl PartialOrdAbs<Integer> for Rational
impl PartialOrdAbs<Integer> for Rational
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of a Rational
and an
Integer
.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
use std::cmp::Ordering;
assert_eq!(
Rational::from_signeds(22, 7).partial_cmp_abs(&Integer::from(3)),
Some(Ordering::Greater)
);
assert_eq!(
Rational::from_signeds(-22, 7).partial_cmp_abs(&Integer::from(-3)),
Some(Ordering::Greater)
);
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Natural> for Rational
impl PartialOrdAbs<Natural> for Rational
sourcefn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>
Compares the absolute values of a Rational
and a
Natural
.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::cmp::Ordering;
assert_eq!(
Rational::from_signeds(22, 7).partial_cmp_abs(&Natural::from(3u32)),
Some(Ordering::Greater)
);
assert_eq!(
Rational::from_signeds(-22, 7).partial_cmp_abs(&Natural::from(3u32)),
Some(Ordering::Greater)
);
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for Integer
impl PartialOrdAbs<Rational> for Integer
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
Compares the absolute values of an Integer
and a
Rational
.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
use std::cmp::Ordering;
assert_eq!(
Integer::from(3).partial_cmp_abs(&Rational::from_signeds(22, 7)),
Some(Ordering::Less)
);
assert_eq!(
Integer::from(-3).partial_cmp_abs(&Rational::from_signeds(-22, 7)),
Some(Ordering::Less)
);
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for Natural
impl PartialOrdAbs<Rational> for Natural
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
Compares the absolute values of a Natural
and a
Rational
.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::cmp::Ordering;
assert_eq!(
Natural::from(3u32).partial_cmp_abs(&Rational::from_signeds(22, 7)),
Some(Ordering::Less)
);
assert_eq!(
Natural::from(3u32).partial_cmp_abs(&Rational::from_signeds(-22, 7)),
Some(Ordering::Less)
);
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for Rational
impl PartialOrdAbs<Rational> for Rational
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for f32
impl PartialOrdAbs<Rational> for f32
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
Compares the absolute values of a primitive float and a Rational
.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.sci_exponent(), other.significant_bits())
.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for f64
impl PartialOrdAbs<Rational> for f64
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
Compares the absolute values of a primitive float and a Rational
.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.sci_exponent(), other.significant_bits())
.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for i128
impl PartialOrdAbs<Rational> for i128
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for i16
impl PartialOrdAbs<Rational> for i16
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for i32
impl PartialOrdAbs<Rational> for i32
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for i64
impl PartialOrdAbs<Rational> for i64
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for i8
impl PartialOrdAbs<Rational> for i8
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for isize
impl PartialOrdAbs<Rational> for isize
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for u128
impl PartialOrdAbs<Rational> for u128
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for u16
impl PartialOrdAbs<Rational> for u16
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for u32
impl PartialOrdAbs<Rational> for u32
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for u64
impl PartialOrdAbs<Rational> for u64
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for u8
impl PartialOrdAbs<Rational> for u8
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<Rational> for usize
impl PartialOrdAbs<Rational> for usize
sourcefn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<f32> for Rational
impl PartialOrdAbs<f32> for Rational
sourcefn partial_cmp_abs(&self, other: &f32) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &f32) -> Option<Ordering>
Compares the absolute values of a Rational
and a primitive float.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.sci_exponent())
.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<f64> for Rational
impl PartialOrdAbs<f64> for Rational
sourcefn partial_cmp_abs(&self, other: &f64) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &f64) -> Option<Ordering>
Compares the absolute values of a Rational
and a primitive float.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.sci_exponent())
.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<i128> for Rational
impl PartialOrdAbs<i128> for Rational
sourcefn partial_cmp_abs(&self, other: &i128) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<i16> for Rational
impl PartialOrdAbs<i16> for Rational
sourcefn partial_cmp_abs(&self, other: &i16) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<i32> for Rational
impl PartialOrdAbs<i32> for Rational
sourcefn partial_cmp_abs(&self, other: &i32) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<i64> for Rational
impl PartialOrdAbs<i64> for Rational
sourcefn partial_cmp_abs(&self, other: &i64) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<i8> for Rational
impl PartialOrdAbs<i8> for Rational
sourcefn partial_cmp_abs(&self, other: &i8) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<isize> for Rational
impl PartialOrdAbs<isize> for Rational
sourcefn partial_cmp_abs(&self, other: &isize) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<u128> for Rational
impl PartialOrdAbs<u128> for Rational
sourcefn partial_cmp_abs(&self, other: &u128) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<u16> for Rational
impl PartialOrdAbs<u16> for Rational
sourcefn partial_cmp_abs(&self, other: &u16) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<u32> for Rational
impl PartialOrdAbs<u32> for Rational
sourcefn partial_cmp_abs(&self, other: &u32) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<u64> for Rational
impl PartialOrdAbs<u64> for Rational
sourcefn partial_cmp_abs(&self, other: &u64) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<u8> for Rational
impl PartialOrdAbs<u8> for Rational
sourcefn partial_cmp_abs(&self, other: &u8) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl PartialOrdAbs<usize> for Rational
impl PartialOrdAbs<usize> for Rational
sourcefn partial_cmp_abs(&self, other: &usize) -> Option<Ordering>
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.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
sourceimpl<'a> Pow<i64> for &'a Rational
impl<'a> Pow<i64> for &'a Rational
sourcefn pow(self, exp: i64) -> Rational
fn pow(self, exp: i64) -> Rational
Raises a Rational
to a power, taking the Rational
by reference.
$f(x, n) = x^n$.
Worst-case complexity
$T(n, m) = O(nm \log (nm) \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and $m$ is
exp.abs()
.
Panics
Panics if self
is zero and exp
is negative.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!((&Rational::from_signeds(22, 7)).pow(3i64).to_string(), "10648/343");
assert_eq!((&Rational::from_signeds(-22, 7)).pow(3i64).to_string(), "-10648/343");
assert_eq!((&Rational::from_signeds(-22, 7)).pow(4i64).to_string(), "234256/2401");
assert_eq!((&Rational::from_signeds(22, 7)).pow(-3i64).to_string(), "343/10648");
assert_eq!((&Rational::from_signeds(-22, 7)).pow(-3i64).to_string(), "-343/10648");
assert_eq!((&Rational::from_signeds(-22, 7)).pow(-4i64).to_string(), "2401/234256");
type Output = Rational
sourceimpl Pow<i64> for Rational
impl Pow<i64> for Rational
sourcefn pow(self, exp: i64) -> Rational
fn pow(self, exp: i64) -> Rational
Raises a Rational
to a power, taking the Rational
by value.
$f(x, n) = x^n$.
Worst-case complexity
$T(n, m) = O(nm \log (nm) \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and $m$ is
exp.abs()
.
Panics
Panics if self
is zero and exp
is negative.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!(Rational::from_signeds(22, 7).pow(3i64).to_string(), "10648/343");
assert_eq!(Rational::from_signeds(-22, 7).pow(3i64).to_string(), "-10648/343");
assert_eq!(Rational::from_signeds(-22, 7).pow(4i64).to_string(), "234256/2401");
assert_eq!(Rational::from_signeds(22, 7).pow(-3i64).to_string(), "343/10648");
assert_eq!(Rational::from_signeds(-22, 7).pow(-3i64).to_string(), "-343/10648");
assert_eq!(Rational::from_signeds(-22, 7).pow(-4i64).to_string(), "2401/234256");
type Output = Rational
sourceimpl<'a> Pow<u64> for &'a Rational
impl<'a> Pow<u64> for &'a Rational
sourcefn pow(self, exp: u64) -> Rational
fn pow(self, exp: u64) -> Rational
Raises a Rational
to a power, taking the Rational
by reference.
$f(x, n) = x^n$.
Worst-case complexity
$T(n, m) = O(nm \log (nm) \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and $m$ is
exp
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!((&Rational::from_signeds(22, 7)).pow(3u64).to_string(), "10648/343");
assert_eq!((&Rational::from_signeds(-22, 7)).pow(3u64).to_string(), "-10648/343");
assert_eq!((&Rational::from_signeds(-22, 7)).pow(4u64).to_string(), "234256/2401");
type Output = Rational
sourceimpl Pow<u64> for Rational
impl Pow<u64> for Rational
sourcefn pow(self, exp: u64) -> Rational
fn pow(self, exp: u64) -> Rational
Raises a Rational
to a power, taking the Rational
by value.
$f(x, n) = x^n$.
Worst-case complexity
$T(n, m) = O(nm \log (nm) \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and $m$ is
exp
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!(Rational::from_signeds(22, 7).pow(3u64).to_string(), "10648/343");
assert_eq!(Rational::from_signeds(-22, 7).pow(3u64).to_string(), "-10648/343");
assert_eq!(Rational::from_signeds(-22, 7).pow(4u64).to_string(), "234256/2401");
type Output = Rational
sourceimpl PowAssign<i64> for Rational
impl PowAssign<i64> for Rational
sourcefn pow_assign(&mut self, exp: i64)
fn pow_assign(&mut self, exp: i64)
Raises a Rational
to a power in place.
$x \gets x^n$.
Worst-case complexity
$T(n, m) = O(nm \log (nm) \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and $m$ is
exp.abs()
.
Panics
Panics if self
is zero and exp
is negative.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::PowAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
let mut x = Rational::from_signeds(22, 7);
x.pow_assign(3i64);
assert_eq!(x.to_string(), "10648/343");
let mut x = Rational::from_signeds(-22, 7);
x.pow_assign(3i64);
assert_eq!(x.to_string(), "-10648/343");
let mut x = Rational::from_signeds(22, 7);
x.pow_assign(4i64);
assert_eq!(x.to_string(), "234256/2401");
let mut x = Rational::from_signeds(22, 7);
x.pow_assign(-3i64);
assert_eq!(x.to_string(), "343/10648");
let mut x = Rational::from_signeds(-22, 7);
x.pow_assign(-3i64);
assert_eq!(x.to_string(), "-343/10648");
let mut x = Rational::from_signeds(22, 7);
x.pow_assign(-4i64);
assert_eq!(x.to_string(), "2401/234256");
sourceimpl PowAssign<u64> for Rational
impl PowAssign<u64> for Rational
sourcefn pow_assign(&mut self, exp: u64)
fn pow_assign(&mut self, exp: u64)
Raises a Rational
to a power in place.
$x \gets x^n$.
Worst-case complexity
$T(n, m) = O(nm \log (nm) \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and $m$ is
exp
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::PowAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
let mut x = Rational::from_signeds(22, 7);
x.pow_assign(3u64);
assert_eq!(x.to_string(), "10648/343");
let mut x = Rational::from_signeds(-22, 7);
x.pow_assign(3u64);
assert_eq!(x.to_string(), "-10648/343");
let mut x = Rational::from_signeds(22, 7);
x.pow_assign(4u64);
assert_eq!(x.to_string(), "234256/2401");
sourceimpl PowerOf2<i64> for Rational
impl PowerOf2<i64> for Rational
sourcefn power_of_2(pow: i64) -> Rational
fn power_of_2(pow: i64) -> Rational
Raises 2 to an integer power.
$f(k) = 2^k$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is pow.abs()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_q::Rational;
assert_eq!(Rational::power_of_2(0i64), 1);
assert_eq!(Rational::power_of_2(3i64), 8);
assert_eq!(Rational::power_of_2(100i64).to_string(), "1267650600228229401496703205376");
assert_eq!(Rational::power_of_2(-3i64).to_string(), "1/8");
assert_eq!(Rational::power_of_2(-100i64).to_string(), "1/1267650600228229401496703205376");
sourceimpl PowerOf2<u64> for Rational
impl PowerOf2<u64> for Rational
sourcefn power_of_2(pow: u64) -> Rational
fn power_of_2(pow: u64) -> Rational
Raises 2 to an integer power.
$f(k) = 2^k$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is pow
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_q::Rational;
assert_eq!(Rational::power_of_2(0u64), 1);
assert_eq!(Rational::power_of_2(3u64), 8);
assert_eq!(Rational::power_of_2(100u64).to_string(), "1267650600228229401496703205376");
sourceimpl<'a> Reciprocal for &'a Rational
impl<'a> Reciprocal for &'a Rational
sourcefn reciprocal(self) -> Rational
fn reciprocal(self) -> Rational
Reciprocates a Rational
, taking it by reference.
$$ f(x) = 1/x. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Reciprocal;
use malachite_q::Rational;
assert_eq!((&Rational::from_signeds(22, 7)).reciprocal().to_string(), "7/22");
assert_eq!((&Rational::from_signeds(7, 22)).reciprocal().to_string(), "22/7");
type Output = Rational
sourceimpl Reciprocal for Rational
impl Reciprocal for Rational
sourcefn reciprocal(self) -> Rational
fn reciprocal(self) -> Rational
Reciprocates a Rational
, taking it by value.
$$ f(x) = 1/x. $$
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Reciprocal;
use malachite_q::Rational;
assert_eq!(Rational::from_signeds(22, 7).reciprocal().to_string(), "7/22");
assert_eq!(Rational::from_signeds(7, 22).reciprocal().to_string(), "22/7");
type Output = Rational
sourceimpl ReciprocalAssign for Rational
impl ReciprocalAssign for Rational
sourcefn reciprocal_assign(&mut self)
fn reciprocal_assign(&mut self)
Reciprocates a Rational
in place.
$$ x \gets 1/x. $$
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::ReciprocalAssign;
use malachite_q::Rational;
let mut x = Rational::from_signeds(22, 7);
x.reciprocal_assign();
assert_eq!(x.to_string(), "7/22");
let mut x = Rational::from_signeds(7, 22);
x.reciprocal_assign();
assert_eq!(x.to_string(), "22/7");
sourceimpl<'a> RoundToMultiple<&'a Rational> for Rational
impl<'a> RoundToMultiple<&'a Rational> for Rational
sourcefn round_to_multiple(self, other: &'a Rational, rm: RoundingMode) -> Rational
fn round_to_multiple(self, other: &'a Rational, rm: RoundingMode) -> Rational
Rounds a Rational
to an integer multiple of another Rational
, according to a
specified rounding mode. The first Rational
is taken by value and the second by
reference.
Let $q = \frac{x}{y}$:
$f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = y \lfloor q \rfloor.$
$f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = y \lceil q \rceil.$
$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, y, \mathrm{Exact}) = x$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
- If
rm
isExact
, butself
is not a multiple ofother
. - If
self
is nonzero,other
is zero, andrm
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_q::Rational;
assert_eq!(Rational::from(-5).round_to_multiple(&Rational::ZERO, RoundingMode::Down), 0);
let q = Rational::exact_from(std::f64::consts::PI);
let hundredth = Rational::from_signeds(1, 100);
assert_eq!(
q.clone().round_to_multiple(&hundredth, RoundingMode::Down).to_string(),
"157/50"
);
assert_eq!(
q.clone().round_to_multiple(&hundredth, RoundingMode::Floor).to_string(),
"157/50"
);
assert_eq!(
q.clone().round_to_multiple(&hundredth, RoundingMode::Up).to_string(),
"63/20"
);
assert_eq!(
q.clone().round_to_multiple(&hundredth, RoundingMode::Ceiling).to_string(),
"63/20"
);
assert_eq!(
q.clone().round_to_multiple(&hundredth, RoundingMode::Nearest).to_string(),
"157/50"
);
type Output = Rational
sourceimpl<'a, 'b> RoundToMultiple<&'b Rational> for &'a Rational
impl<'a, 'b> RoundToMultiple<&'b Rational> for &'a Rational
sourcefn round_to_multiple(self, other: &'b Rational, rm: RoundingMode) -> Rational
fn round_to_multiple(self, other: &'b Rational, rm: RoundingMode) -> Rational
Rounds a Rational
to an integer multiple of another Rational
, according to a
specified rounding mode. Both Rational
s are taken by reference.
Let $q = \frac{x}{y}$:
$f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = y \lfloor q \rfloor.$
$f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = y \lceil q \rceil.$
$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, y, \mathrm{Exact}) = x$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
- If
rm
isExact
, butself
is not a multiple ofother
. - If
self
is nonzero,other
is zero, andrm
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_q::Rational;
assert_eq!(Rational::from(-5).round_to_multiple(Rational::ZERO, RoundingMode::Down), 0);
let q = Rational::exact_from(std::f64::consts::PI);
let hundredth = Rational::from_signeds(1, 100);
assert_eq!((&q).round_to_multiple(&hundredth, RoundingMode::Down).to_string(), "157/50");
assert_eq!((&q).round_to_multiple(&hundredth, RoundingMode::Floor).to_string(), "157/50");
assert_eq!((&q).round_to_multiple(&hundredth, RoundingMode::Up).to_string(), "63/20");
assert_eq!((&q).round_to_multiple(&hundredth, RoundingMode::Ceiling).to_string(), "63/20");
assert_eq!(
(&q).round_to_multiple(&hundredth, RoundingMode::Nearest).to_string(),
"157/50"
);
type Output = Rational
sourceimpl<'a> RoundToMultiple<Rational> for &'a Rational
impl<'a> RoundToMultiple<Rational> for &'a Rational
sourcefn round_to_multiple(self, other: Rational, rm: RoundingMode) -> Rational
fn round_to_multiple(self, other: Rational, rm: RoundingMode) -> Rational
Rounds a Rational
to an integer multiple of another Rational
, according to a
specified rounding mode. The first Rational
is taken by reference and the second by
value.
Let $q = \frac{x}{y}$:
$f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = y \lfloor q \rfloor.$
$f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = y \lceil q \rceil.$
$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, y, \mathrm{Exact}) = x$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
- If
rm
isExact
, butself
is not a multiple ofother
. - If
self
is nonzero,other
is zero, andrm
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_q::Rational;
assert_eq!(Rational::from(-5).round_to_multiple(Rational::ZERO, RoundingMode::Down), 0);
let q = Rational::exact_from(std::f64::consts::PI);
let hundredth = Rational::from_signeds(1, 100);
assert_eq!(
(&q).round_to_multiple(hundredth.clone(), RoundingMode::Down).to_string(),
"157/50"
);
assert_eq!(
(&q).round_to_multiple(hundredth.clone(), RoundingMode::Floor).to_string(),
"157/50"
);
assert_eq!(
(&q).round_to_multiple(hundredth.clone(), RoundingMode::Up).to_string(),
"63/20"
);
assert_eq!(
(&q).round_to_multiple(hundredth.clone(), RoundingMode::Ceiling).to_string(),
"63/20"
);
assert_eq!(
(&q).round_to_multiple(hundredth.clone(), RoundingMode::Nearest).to_string(),
"157/50"
);
type Output = Rational
sourceimpl RoundToMultiple<Rational> for Rational
impl RoundToMultiple<Rational> for Rational
sourcefn round_to_multiple(self, other: Rational, rm: RoundingMode) -> Rational
fn round_to_multiple(self, other: Rational, rm: RoundingMode) -> Rational
Rounds a Rational
to an integer multiple of another Rational
, according to a
specified rounding mode. Both Rational
s are taken by value.
Let $q = \frac{x}{y}$:
$f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = y \lfloor q \rfloor.$
$f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = y \lceil q \rceil.$
$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, y, \mathrm{Exact}) = x$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
- If
rm
isExact
, butself
is not a multiple ofother
. - If
self
is nonzero,other
is zero, andrm
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_q::Rational;
assert_eq!(Rational::from(-5).round_to_multiple(Rational::ZERO, RoundingMode::Down), 0);
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(), RoundingMode::Down).to_string(),
"157/50"
);
assert_eq!(
q.clone().round_to_multiple(hundredth.clone(), RoundingMode::Floor).to_string(),
"157/50"
);
assert_eq!(
q.clone().round_to_multiple(hundredth.clone(), RoundingMode::Up).to_string(),
"63/20"
);
assert_eq!(
q.clone().round_to_multiple(hundredth.clone(), RoundingMode::Ceiling).to_string(),
"63/20"
);
assert_eq!(
q.clone().round_to_multiple(hundredth.clone(), RoundingMode::Nearest).to_string(),
"157/50"
);
type Output = Rational
sourceimpl<'a> RoundToMultipleAssign<&'a Rational> for Rational
impl<'a> RoundToMultipleAssign<&'a Rational> for Rational
sourcefn round_to_multiple_assign(&mut self, other: &'a Rational, rm: RoundingMode)
fn round_to_multiple_assign(&mut self, other: &'a Rational, rm: RoundingMode)
Rounds a Rational
to an integer multiple of another Rational
in place, according to
a specified rounding mode. The Rational
on the right-hand side is taken by reference.
See the RoundToMultiple
documentation for details.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
- If
rm
isExact
, butself
is not a multiple ofother
. - If
self
is nonzero,other
is zero, andrm
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;
let mut x = Rational::from(-5);
x.round_to_multiple_assign(Rational::ZERO, RoundingMode::Down);
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();
x.round_to_multiple_assign(&hundredth, RoundingMode::Down);
assert_eq!(x.to_string(), "157/50");
let mut x = q.clone();
x.round_to_multiple_assign(&hundredth, RoundingMode::Floor);
assert_eq!(x.to_string(), "157/50");
let mut x = q.clone();
x.round_to_multiple_assign(&hundredth, RoundingMode::Up);
assert_eq!(x.to_string(), "63/20");
let mut x = q.clone();
x.round_to_multiple_assign(&hundredth, RoundingMode::Ceiling);
assert_eq!(x.to_string(), "63/20");
let mut x = q.clone();
x.round_to_multiple_assign(&hundredth, RoundingMode::Nearest);
assert_eq!(x.to_string(), "157/50");
sourceimpl RoundToMultipleAssign<Rational> for Rational
impl RoundToMultipleAssign<Rational> for Rational
sourcefn round_to_multiple_assign(&mut self, other: Rational, rm: RoundingMode)
fn round_to_multiple_assign(&mut self, other: Rational, rm: RoundingMode)
Rounds a Rational
to an integer multiple of another Rational
in place, according to
a specified rounding mode. The Rational
on the right-hand side is taken by value.
See the RoundToMultiple
documentation for details.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
- If
rm
isExact
, butself
is not a multiple ofother
. - If
self
is nonzero,other
is zero, andrm
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;
let mut x = Rational::from(-5);
x.round_to_multiple_assign(Rational::ZERO, RoundingMode::Down);
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();
x.round_to_multiple_assign(hundredth.clone(), RoundingMode::Down);
assert_eq!(x.to_string(), "157/50");
let mut x = q.clone();
x.round_to_multiple_assign(hundredth.clone(), RoundingMode::Floor);
assert_eq!(x.to_string(), "157/50");
let mut x = q.clone();
x.round_to_multiple_assign(hundredth.clone(), RoundingMode::Up);
assert_eq!(x.to_string(), "63/20");
let mut x = q.clone();
x.round_to_multiple_assign(hundredth.clone(), RoundingMode::Ceiling);
assert_eq!(x.to_string(), "63/20");
let mut x = q.clone();
x.round_to_multiple_assign(hundredth.clone(), RoundingMode::Nearest);
assert_eq!(x.to_string(), "157/50");
sourceimpl<'a> RoundToMultipleOfPowerOf2<i64> for &'a Rational
impl<'a> RoundToMultipleOfPowerOf2<i64> for &'a Rational
sourcefn round_to_multiple_of_power_of_2(self, pow: i64, rm: RoundingMode) -> Rational
fn round_to_multiple_of_power_of_2(self, pow: i64, rm: RoundingMode) -> Rational
Rounds a Rational
to an integer multiple of $2^k$ according to a specified rounding
mode. The Rational
is taken by reference.
Let $q = \frac{x}{2^k}$:
$f(x, k, \mathrm{Down}) = 2^k \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, k, \mathrm{Up}) = 2^k \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, k, \mathrm{Floor}) = 2^k \lfloor q \rfloor.$
$f(x, k, \mathrm{Ceiling}) = 2^k \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, k, \mathrm{Exact}) = 2^k q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), pow / Limb::WIDTH)
.
Panics
Panics if rm
is Exact
, but self
is not a multiple of the power of 2.
Examples
use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;
let q = Rational::exact_from(std::f64::consts::PI);
assert_eq!(
(&q).round_to_multiple_of_power_of_2(-3, RoundingMode::Floor).to_string(),
"25/8"
);
assert_eq!(
(&q).round_to_multiple_of_power_of_2(-3, RoundingMode::Down).to_string(),
"25/8"
);
assert_eq!(
(&q).round_to_multiple_of_power_of_2(-3, RoundingMode::Ceiling).to_string(),
"13/4"
);
assert_eq!(
(&q).round_to_multiple_of_power_of_2(-3, RoundingMode::Up).to_string(),
"13/4"
);
assert_eq!(
(&q).round_to_multiple_of_power_of_2(-3, RoundingMode::Nearest).to_string(),
"25/8"
);
type Output = Rational
sourceimpl RoundToMultipleOfPowerOf2<i64> for Rational
impl RoundToMultipleOfPowerOf2<i64> for Rational
sourcefn round_to_multiple_of_power_of_2(self, pow: i64, rm: RoundingMode) -> Rational
fn round_to_multiple_of_power_of_2(self, pow: i64, rm: RoundingMode) -> Rational
Rounds a Rational
to an integer multiple of $2^k$ according to a specified rounding
mode. The Rational
is taken by value.
Let $q = \frac{x}{2^k}$:
$f(x, k, \mathrm{Down}) = 2^k \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, k, \mathrm{Up}) = 2^k \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, k, \mathrm{Floor}) = 2^k \lfloor q \rfloor.$
$f(x, k, \mathrm{Ceiling}) = 2^k \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, k, \mathrm{Exact}) = 2^k q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), pow / Limb::WIDTH)
.
Panics
Panics if rm
is Exact
, but self
is not a multiple of the power of 2.
Examples
use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_base::rounding_modes::RoundingMode;
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, RoundingMode::Floor).to_string(),
"25/8"
);
assert_eq!(
q.clone().round_to_multiple_of_power_of_2(-3, RoundingMode::Down).to_string(),
"25/8"
);
assert_eq!(
q.clone().round_to_multiple_of_power_of_2(-3, RoundingMode::Ceiling).to_string(),
"13/4"
);
assert_eq!(
q.clone().round_to_multiple_of_power_of_2(-3, RoundingMode::Up).to_string(),
"13/4"
);
assert_eq!(
q.clone().round_to_multiple_of_power_of_2(-3, RoundingMode::Nearest).to_string(),
"25/8"
);
type Output = Rational
sourceimpl RoundToMultipleOfPowerOf2Assign<i64> for Rational
impl RoundToMultipleOfPowerOf2Assign<i64> for Rational
sourcefn round_to_multiple_of_power_of_2_assign(&mut self, pow: i64, rm: RoundingMode)
fn round_to_multiple_of_power_of_2_assign(&mut self, pow: i64, rm: RoundingMode)
Rounds a Rational
to a multiple of $2^k$ in place, according to a specified rounding
mode.
See the RoundToMultipleOfPowerOf2
documentation for details.
but the latter should be used as it is clearer and more efficient.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), pow / Limb::WIDTH)
.
Panics
Panics if rm
is Exact
, but self
is not a multiple of the power of 2.
Examples
use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2Assign;
use malachite_base::num::conversion::traits::ExactFrom;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;
let q = Rational::exact_from(std::f64::consts::PI);
let mut x = q.clone();
x.round_to_multiple_of_power_of_2_assign(-3, RoundingMode::Floor);
assert_eq!(x.to_string(), "25/8");
let mut x = q.clone();
x.round_to_multiple_of_power_of_2_assign(-3, RoundingMode::Down);
assert_eq!(x.to_string(), "25/8");
let mut x = q.clone();
x.round_to_multiple_of_power_of_2_assign(-3, RoundingMode::Ceiling);
assert_eq!(x.to_string(), "13/4");
let mut x = q.clone();
x.round_to_multiple_of_power_of_2_assign(-3, RoundingMode::Up);
assert_eq!(x.to_string(), "13/4");
let mut x = q.clone();
x.round_to_multiple_of_power_of_2_assign(-3, RoundingMode::Nearest);
assert_eq!(x.to_string(), "25/8");
sourceimpl<'a> RoundingFrom<&'a Rational> for Integer
impl<'a> RoundingFrom<&'a Rational> for Integer
sourcefn rounding_from(x: &Rational, rm: RoundingMode) -> Integer
fn rounding_from(x: &Rational, rm: RoundingMode) -> Integer
Converts a Rational
to an Integer
, using a
specified RoundingMode
and taking the
Rational
by reference.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is x.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
assert_eq!(Integer::rounding_from(&Rational::from(123), RoundingMode::Exact), 123);
assert_eq!(Integer::rounding_from(&Rational::from(-123), RoundingMode::Exact), -123);
assert_eq!(Integer::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Floor), 3);
assert_eq!(Integer::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Down), 3);
assert_eq!(
Integer::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Ceiling),
4
);
assert_eq!(Integer::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Up), 4);
assert_eq!(
Integer::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Nearest),
3
);
assert_eq!(
Integer::rounding_from(&Rational::from_signeds(-22, 7), RoundingMode::Floor),
-4
);
assert_eq!(
Integer::rounding_from(&Rational::from_signeds(-22, 7), RoundingMode::Down),
-3
);
assert_eq!(
Integer::rounding_from(&Rational::from_signeds(-22, 7), RoundingMode::Ceiling),
-3
);
assert_eq!(Integer::rounding_from(&Rational::from_signeds(-22, 7), RoundingMode::Up), -4);
assert_eq!(
Integer::rounding_from(&Rational::from_signeds(-22, 7), RoundingMode::Nearest),
-3
);
sourceimpl<'a> RoundingFrom<&'a Rational> for Natural
impl<'a> RoundingFrom<&'a Rational> for Natural
sourcefn rounding_from(x: &Rational, rm: RoundingMode) -> Natural
fn rounding_from(x: &Rational, rm: RoundingMode) -> Natural
Converts a Rational
to a Natural
, using a
specified RoundingMode
and taking the
Rational
by reference.
If the Rational
is negative, then it will be rounded to zero when the
RoundingMode
is Ceiling
, Down
, or
Nearest
. Otherwise, this function will panic.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is x.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
, or if the Rational
is
less than zero and rm
is not Down
, Ceiling
, or Nearest
.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert_eq!(Natural::rounding_from(&Rational::from(123), RoundingMode::Exact), 123);
assert_eq!(Natural::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Floor), 3);
assert_eq!(Natural::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Down), 3);
assert_eq!(
Natural::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Ceiling),
4
);
assert_eq!(Natural::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Up), 4);
assert_eq!(
Natural::rounding_from(&Rational::from_signeds(22, 7), RoundingMode::Nearest),
3
);
assert_eq!(Natural::rounding_from(&Rational::from(-123), RoundingMode::Down), 0);
assert_eq!(Natural::rounding_from(&Rational::from(-123), RoundingMode::Ceiling), 0);
assert_eq!(Natural::rounding_from(&Rational::from(-123), RoundingMode::Nearest), 0);
sourceimpl<'a> RoundingFrom<&'a Rational> for f32
impl<'a> RoundingFrom<&'a Rational> for f32
sourcefn rounding_from(value: &'a Rational, rm: RoundingMode) -> f32
fn rounding_from(value: &'a Rational, rm: RoundingMode) -> f32
Converts a Rational
to a value of a primitive float according to a specified
RoundingMode
, taking the
Rational
by reference.
- If the rounding mode is
Floor
, the largest float less than or equal to theRational
is returned. If theRational
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 theRational
is returned. If theRational
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 withFloor
if theRational
is non-negative and as withCeiling
if theRational
is negative. If theRational
is between the maximum negative float and the minimum positive float, then positive zero is returned when theRational
is non-negative and negative zero otherwise. - If the rounding mode is
Up
, then the rounding proceeds as withCeiling
if theRational
is non-negative and as withFloor
if theRational
is negative. Positive zero is only returned when theRational
is zero, and negative zero is never returned. - If the rounding mode is
Nearest
, then the nearest float is returned. If theRational
is exactly between two floats, the float with the zero least-significant bit in its representation is selected. If theRational
is greater than the maximum finite float, then the maximum finite float is returned. If theRational
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 theRational
’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.
sourceimpl<'a> RoundingFrom<&'a Rational> for f64
impl<'a> RoundingFrom<&'a Rational> for f64
sourcefn rounding_from(value: &'a Rational, rm: RoundingMode) -> f64
fn rounding_from(value: &'a Rational, rm: RoundingMode) -> f64
Converts a Rational
to a value of a primitive float according to a specified
RoundingMode
, taking the
Rational
by reference.
- If the rounding mode is
Floor
, the largest float less than or equal to theRational
is returned. If theRational
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 theRational
is returned. If theRational
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 withFloor
if theRational
is non-negative and as withCeiling
if theRational
is negative. If theRational
is between the maximum negative float and the minimum positive float, then positive zero is returned when theRational
is non-negative and negative zero otherwise. - If the rounding mode is
Up
, then the rounding proceeds as withCeiling
if theRational
is non-negative and as withFloor
if theRational
is negative. Positive zero is only returned when theRational
is zero, and negative zero is never returned. - If the rounding mode is
Nearest
, then the nearest float is returned. If theRational
is exactly between two floats, the float with the zero least-significant bit in its representation is selected. If theRational
is greater than the maximum finite float, then the maximum finite float is returned. If theRational
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 theRational
’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.
sourceimpl<'a> RoundingFrom<&'a Rational> for i128
impl<'a> RoundingFrom<&'a Rational> for i128
sourcefn rounding_from(value: &Rational, rm: RoundingMode) -> i128
fn rounding_from(value: &Rational, rm: RoundingMode) -> i128
Converts a Rational
to a signed integer, using a specified
RoundingMode
.
If the Rational
is smaller than the minimum value of the unsigned type, then it
will be rounded to the minimum value when rm
is Ceiling
, Down
, or Nearest
.
Otherwise, this function will panic.
If the Rational
is larger than the maximum value of the unsigned type, then it
will be rounded to the maximum value when rm
is Floor
, Down
, or Nearest
.
Otherwise, this function will panic.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
, if the
Rational
is less than T::MIN
and rm
is not Down
, Ceiling
, or Nearest
,
or if the Rational
is greater than T::MAX
and rm
is not Down
, Floor
, or
Nearest
.
Examples
See here.
sourceimpl<'a> RoundingFrom<&'a Rational> for i16
impl<'a> RoundingFrom<&'a Rational> for i16
sourcefn rounding_from(value: &Rational, rm: RoundingMode) -> i16
fn rounding_from(value: &Rational, rm: RoundingMode) -> i16
Converts a Rational
to a signed integer, using a specified
RoundingMode
.
If the Rational
is smaller than the minimum value of the unsigned type, then it
will be rounded to the minimum value when rm
is Ceiling
, Down
, or Nearest
.
Otherwise, this function will panic.
If the Rational
is larger than the maximum value of the unsigned type, then it
will be rounded to the maximum value when rm
is Floor
, Down
, or Nearest
.
Otherwise, this function will panic.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
, if the
Rational
is less than T::MIN
and rm
is not Down
, Ceiling
, or Nearest
,
or if the Rational
is greater than T::MAX
and rm
is not Down
, Floor
, or
Nearest
.
Examples
See here.
sourceimpl<'a> RoundingFrom<&'a Rational> for i32
impl<'a> RoundingFrom<&'a Rational> for i32
sourcefn rounding_from(value: &Rational, rm: RoundingMode) -> i32
fn rounding_from(value: &Rational, rm: RoundingMode) -> i32
Converts a Rational
to a signed integer, using a specified
RoundingMode
.
If the Rational
is smaller than the minimum value of the unsigned type, then it
will be rounded to the minimum value when rm
is Ceiling
, Down
, or Nearest
.
Otherwise, this function will panic.
If the Rational
is larger than the maximum value of the unsigned type, then it
will be rounded to the maximum value when rm
is Floor
, Down
, or Nearest
.
Otherwise, this function will panic.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
, if the
Rational
is less than T::MIN
and rm
is not Down
, Ceiling
, or Nearest
,
or if the Rational
is greater than T::MAX
and rm
is not Down
, Floor
, or
Nearest
.
Examples
See here.
sourceimpl<'a> RoundingFrom<&'a Rational> for i64
impl<'a> RoundingFrom<&'a Rational> for i64
sourcefn rounding_from(value: &Rational, rm: RoundingMode) -> i64
fn rounding_from(value: &Rational, rm: RoundingMode) -> i64
Converts a Rational
to a signed integer, using a specified
RoundingMode
.
If the Rational
is smaller than the minimum value of the unsigned type, then it
will be rounded to the minimum value when rm
is Ceiling
, Down
, or Nearest
.
Otherwise, this function will panic.
If the Rational
is larger than the maximum value of the unsigned type, then it
will be rounded to the maximum value when rm
is Floor
, Down
, or Nearest
.
Otherwise, this function will panic.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
, if the
Rational
is less than T::MIN
and rm
is not Down
, Ceiling
, or Nearest
,
or if the Rational
is greater than T::MAX
and rm
is not Down
, Floor
, or
Nearest
.
Examples
See here.
sourceimpl<'a> RoundingFrom<&'a Rational> for i8
impl<'a> RoundingFrom<&'a Rational> for i8
sourcefn rounding_from(value: &Rational, rm: RoundingMode) -> i8
fn rounding_from(value: &Rational, rm: RoundingMode) -> i8
Converts a Rational
to a signed integer, using a specified
RoundingMode
.
If the Rational
is smaller than the minimum value of the unsigned type, then it
will be rounded to the minimum value when rm
is Ceiling
, Down
, or Nearest
.
Otherwise, this function will panic.
If the Rational
is larger than the maximum value of the unsigned type, then it
will be rounded to the maximum value when rm
is Floor
, Down
, or Nearest
.
Otherwise, this function will panic.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
, if the
Rational
is less than T::MIN
and rm
is not Down
, Ceiling
, or Nearest
,
or if the Rational
is greater than T::MAX
and rm
is not Down
, Floor
, or
Nearest
.
Examples
See here.
sourceimpl<'a> RoundingFrom<&'a Rational> for isize
impl<'a> RoundingFrom<&'a Rational> for isize
sourcefn rounding_from(value: &Rational, rm: RoundingMode) -> isize
fn rounding_from(value: &Rational, rm: RoundingMode) -> isize
Converts a Rational
to a signed integer, using a specified
RoundingMode
.
If the Rational
is smaller than the minimum value of the unsigned type, then it
will be rounded to the minimum value when rm
is Ceiling
, Down
, or Nearest
.
Otherwise, this function will panic.
If the Rational
is larger than the maximum value of the unsigned type, then it
will be rounded to the maximum value when rm
is Floor
, Down
, or Nearest
.
Otherwise, this function will panic.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
, if the
Rational
is less than T::MIN
and rm
is not Down
, Ceiling
, or Nearest
,
or if the Rational
is greater than T::MAX
and rm
is not Down
, Floor
, or
Nearest
.
Examples
See here.
sourceimpl<'a> RoundingFrom<&'a Rational> for u128
impl<'a> RoundingFrom<&'a Rational> for u128
sourcefn rounding_from(value: &Rational, rm: RoundingMode) -> u128
fn rounding_from(value: &Rational, rm: RoundingMode) -> u128
Converts a Rational
to an unsigned integer, using a specified
RoundingMode
.
If the Rational
is negative, then it will be rounded to zero when rm
is
Ceiling
, Down
, or Nearest
. Otherwise, this function will panic.
If the Rational
is larger than the maximum value of the unsigned type, then it
will be rounded to the maximum value when rm
is Floor
, Down
, or Nearest
.
Otherwise, this function will panic.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
, if the
Rational
is less than zero and rm
is not Down
, Ceiling
, or
Nearest
, or if the Rational
is greater than T::MAX
and rm
is not
Down
, Floor
, or Nearest
.
Examples
See here.
sourceimpl<'a> RoundingFrom<&'a Rational> for u16
impl<'a> RoundingFrom<&'a Rational> for u16
sourcefn rounding_from(value: &Rational, rm: RoundingMode) -> u16
fn rounding_from(value: &Rational, rm: RoundingMode) -> u16
Converts a Rational
to an unsigned integer, using a specified
RoundingMode
.
If the Rational
is negative, then it will be rounded to zero when rm
is
Ceiling
, Down
, or Nearest
. Otherwise, this function will panic.
If the Rational
is larger than the maximum value of the unsigned type, then it
will be rounded to the maximum value when rm
is Floor
, Down
, or Nearest
.
Otherwise, this function will panic.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
, if the
Rational
is less than zero and rm
is not Down
, Ceiling
, or
Nearest
, or if the Rational
is greater than T::MAX
and rm
is not
Down
, Floor
, or Nearest
.
Examples
See here.
sourceimpl<'a> RoundingFrom<&'a Rational> for u32
impl<'a> RoundingFrom<&'a Rational> for u32
sourcefn rounding_from(value: &Rational, rm: RoundingMode) -> u32
fn rounding_from(value: &Rational, rm: RoundingMode) -> u32
Converts a Rational
to an unsigned integer, using a specified
RoundingMode
.
If the Rational
is negative, then it will be rounded to zero when rm
is
Ceiling
, Down
, or Nearest
. Otherwise, this function will panic.
If the Rational
is larger than the maximum value of the unsigned type, then it
will be rounded to the maximum value when rm
is Floor
, Down
, or Nearest
.
Otherwise, this function will panic.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
, if the
Rational
is less than zero and rm
is not Down
, Ceiling
, or
Nearest
, or if the Rational
is greater than T::MAX
and rm
is not
Down
, Floor
, or Nearest
.
Examples
See here.
sourceimpl<'a> RoundingFrom<&'a Rational> for u64
impl<'a> RoundingFrom<&'a Rational> for u64
sourcefn rounding_from(value: &Rational, rm: RoundingMode) -> u64
fn rounding_from(value: &Rational, rm: RoundingMode) -> u64
Converts a Rational
to an unsigned integer, using a specified
RoundingMode
.
If the Rational
is negative, then it will be rounded to zero when rm
is
Ceiling
, Down
, or Nearest
. Otherwise, this function will panic.
If the Rational
is larger than the maximum value of the unsigned type, then it
will be rounded to the maximum value when rm
is Floor
, Down
, or Nearest
.
Otherwise, this function will panic.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
, if the
Rational
is less than zero and rm
is not Down
, Ceiling
, or
Nearest
, or if the Rational
is greater than T::MAX
and rm
is not
Down
, Floor
, or Nearest
.
Examples
See here.
sourceimpl<'a> RoundingFrom<&'a Rational> for u8
impl<'a> RoundingFrom<&'a Rational> for u8
sourcefn rounding_from(value: &Rational, rm: RoundingMode) -> u8
fn rounding_from(value: &Rational, rm: RoundingMode) -> u8
Converts a Rational
to an unsigned integer, using a specified
RoundingMode
.
If the Rational
is negative, then it will be rounded to zero when rm
is
Ceiling
, Down
, or Nearest
. Otherwise, this function will panic.
If the Rational
is larger than the maximum value of the unsigned type, then it
will be rounded to the maximum value when rm
is Floor
, Down
, or Nearest
.
Otherwise, this function will panic.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
, if the
Rational
is less than zero and rm
is not Down
, Ceiling
, or
Nearest
, or if the Rational
is greater than T::MAX
and rm
is not
Down
, Floor
, or Nearest
.
Examples
See here.
sourceimpl<'a> RoundingFrom<&'a Rational> for usize
impl<'a> RoundingFrom<&'a Rational> for usize
sourcefn rounding_from(value: &Rational, rm: RoundingMode) -> usize
fn rounding_from(value: &Rational, rm: RoundingMode) -> usize
Converts a Rational
to an unsigned integer, using a specified
RoundingMode
.
If the Rational
is negative, then it will be rounded to zero when rm
is
Ceiling
, Down
, or Nearest
. Otherwise, this function will panic.
If the Rational
is larger than the maximum value of the unsigned type, then it
will be rounded to the maximum value when rm
is Floor
, Down
, or Nearest
.
Otherwise, this function will panic.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
, if the
Rational
is less than zero and rm
is not Down
, Ceiling
, or
Nearest
, or if the Rational
is greater than T::MAX
and rm
is not
Down
, Floor
, or Nearest
.
Examples
See here.
sourceimpl RoundingFrom<Rational> for Integer
impl RoundingFrom<Rational> for Integer
sourcefn rounding_from(x: Rational, rm: RoundingMode) -> Integer
fn rounding_from(x: Rational, rm: RoundingMode) -> Integer
Converts a Rational
to an Integer
, using a
specified RoundingMode
and taking the
Rational
by value.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is x.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
assert_eq!(Integer::rounding_from(Rational::from(123), RoundingMode::Exact), 123);
assert_eq!(Integer::rounding_from(Rational::from(-123), RoundingMode::Exact), -123);
assert_eq!(Integer::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Floor), 3);
assert_eq!(Integer::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Down), 3);
assert_eq!(
Integer::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Ceiling),
4
);
assert_eq!(Integer::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Up), 4);
assert_eq!(
Integer::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Nearest),
3
);
assert_eq!(
Integer::rounding_from(Rational::from_signeds(-22, 7), RoundingMode::Floor),
-4
);
assert_eq!(Integer::rounding_from(Rational::from_signeds(-22, 7), RoundingMode::Down), -3);
assert_eq!(
Integer::rounding_from(Rational::from_signeds(-22, 7), RoundingMode::Ceiling),
-3
);
assert_eq!(Integer::rounding_from(Rational::from_signeds(-22, 7), RoundingMode::Up), -4);
assert_eq!(
Integer::rounding_from(Rational::from_signeds(-22, 7), RoundingMode::Nearest),
-3
);
sourceimpl RoundingFrom<Rational> for Natural
impl RoundingFrom<Rational> for Natural
sourcefn rounding_from(x: Rational, rm: RoundingMode) -> Natural
fn rounding_from(x: Rational, rm: RoundingMode) -> Natural
Converts a Rational
to a Natural
, using a
specified RoundingMode
and taking the
Rational
by value.
If the Rational
is negative, then it will be rounded to zero when the
RoundingMode
is Ceiling
, Down
, or
Nearest
. Otherwise, this function will panic.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is x.significant_bits()
.
Panics
Panics if the Rational
is not an integer and rm
is Exact
, or if the Rational
is
less than zero and rm
is not Down
, Ceiling
, or Nearest
.
Examples
extern crate malachite_base;
extern crate malachite_nz;
use malachite_base::num::conversion::traits::RoundingFrom;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert_eq!(Natural::rounding_from(Rational::from(123), RoundingMode::Exact), 123);
assert_eq!(Natural::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Floor), 3);
assert_eq!(Natural::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Down), 3);
assert_eq!(
Natural::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Ceiling),
4
);
assert_eq!(Natural::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Up), 4);
assert_eq!(
Natural::rounding_from(Rational::from_signeds(22, 7), RoundingMode::Nearest),
3
);
assert_eq!(Natural::rounding_from(Rational::from(-123), RoundingMode::Down), 0);
assert_eq!(Natural::rounding_from(Rational::from(-123), RoundingMode::Ceiling), 0);
assert_eq!(Natural::rounding_from(Rational::from(-123), RoundingMode::Nearest), 0);
sourceimpl RoundingFrom<Rational> for f32
impl RoundingFrom<Rational> for f32
sourcefn rounding_from(value: Rational, rm: RoundingMode) -> f32
fn rounding_from(value: Rational, rm: RoundingMode) -> f32
Converts a Rational
to a value of a primitive float according to a specified
RoundingMode
, taking the
Rational
by value.
- If the rounding mode is
Floor
, the largest float less than or equal to theRational
is returned. If theRational
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 theRational
is returned. If theRational
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 withFloor
if theRational
is non-negative and as withCeiling
if theRational
is negative. If theRational
is between the maximum negative float and the minimum positive float, then positive zero is returned when theRational
is non-negative and negative zero otherwise. - If the rounding mode is
Up
, then the rounding proceeds as withCeiling
if theRational
is non-negative and as withFloor
if theRational
is negative. Positive zero is only returned when theRational
is zero, and negative zero is never returned. - If the rounding mode is
Nearest
, then the nearest float is returned. If theRational
is exactly between two floats, the float with the zero least-significant bit in its representation is selected. If theRational
is greater than the maximum finite float, then the maximum finite float is returned. If theRational
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 theRational
’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.
sourceimpl RoundingFrom<Rational> for f64
impl RoundingFrom<Rational> for f64
sourcefn rounding_from(value: Rational, rm: RoundingMode) -> f64
fn rounding_from(value: Rational, rm: RoundingMode) -> f64
Converts a Rational
to a value of a primitive float according to a specified
RoundingMode
, taking the
Rational
by value.
- If the rounding mode is
Floor
, the largest float less than or equal to theRational
is returned. If theRational
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 theRational
is returned. If theRational
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 withFloor
if theRational
is non-negative and as withCeiling
if theRational
is negative. If theRational
is between the maximum negative float and the minimum positive float, then positive zero is returned when theRational
is non-negative and negative zero otherwise. - If the rounding mode is
Up
, then the rounding proceeds as withCeiling
if theRational
is non-negative and as withFloor
if theRational
is negative. Positive zero is only returned when theRational
is zero, and negative zero is never returned. - If the rounding mode is
Nearest
, then the nearest float is returned. If theRational
is exactly between two floats, the float with the zero least-significant bit in its representation is selected. If theRational
is greater than the maximum finite float, then the maximum finite float is returned. If theRational
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 theRational
’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.
sourceimpl<'a> SciMantissaAndExponent<f32, i64, Rational> for &'a Rational
impl<'a> SciMantissaAndExponent<f32, i64, Rational> for &'a Rational
sourcefn sci_mantissa_and_exponent(self) -> (f32, i64)
fn sci_mantissa_and_exponent(self) -> (f32, i64)
Returns a Rational
’s scientific mantissa and exponent, taking the Rational
by reference.
When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and
$m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational
mantissa as a float. The conversion might not be exact, so we round to the nearest
float using the Nearest
rounding mode. To use other rounding modes, use
sci_mantissa_and_exponent_with_rounding
.
$$
f(x) \approx (\frac{x}{2^{\lfloor \log_2 x \rfloor}}, \lfloor \log_2 x \rfloor).
$$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
See here.
sourcefn sci_exponent(self) -> i64
fn sci_exponent(self) -> i64
Returns a Rational
’s scientific exponent, taking the Rational
by reference.
When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and
$m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational
mantissa as a float. The conversion might not be exact, so we round to the nearest
float using the Nearest
rounding mode. To use other rounding modes, use
sci_mantissa_and_exponent_with_rounding
.
$$
f(x) \approx \lfloor \log_2 x \rfloor.
$$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
sourcefn from_sci_mantissa_and_exponent(
sci_mantissa: f32,
sci_exponent: i64
) -> Option<Rational>
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 Rational
s, 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.
sourcefn sci_mantissa(self) -> M
fn sci_mantissa(self) -> M
sourceimpl SciMantissaAndExponent<f32, i64, Rational> for Rational
impl SciMantissaAndExponent<f32, i64, Rational> for Rational
sourcefn sci_mantissa_and_exponent(self) -> (f32, i64)
fn sci_mantissa_and_exponent(self) -> (f32, i64)
Returns a Rational
’s scientific mantissa and exponent, taking the Rational
by value.
When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and
$m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational
mantissa as a float. The conversion might not be exact, so we round to the nearest
float using the Nearest
rounding mode. To use other rounding modes, use
sci_mantissa_and_exponent_with_rounding
.
$$
f(x) \approx (\frac{x}{2^{\lfloor \log_2 x \rfloor}}, \lfloor \log_2 x \rfloor).
$$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
See here.
sourcefn sci_exponent(self) -> i64
fn sci_exponent(self) -> i64
Returns a Rational
’s scientific exponent, taking the Rational
by value.
When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and
$m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational
mantissa as a float. The conversion might not be exact, so we round to the nearest
float using the Nearest
rounding mode. To use other rounding modes, use
sci_mantissa_and_exponent_with_rounding
.
$$
f(x) \approx \lfloor \log_2 x \rfloor.
$$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
See here.
sourcefn from_sci_mantissa_and_exponent(
sci_mantissa: f32,
sci_exponent: i64
) -> Option<Rational>
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 Rational
s, 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
.
sourcefn sci_mantissa(self) -> M
fn sci_mantissa(self) -> M
sourceimpl<'a> SciMantissaAndExponent<f64, i64, Rational> for &'a Rational
impl<'a> SciMantissaAndExponent<f64, i64, Rational> for &'a Rational
sourcefn sci_mantissa_and_exponent(self) -> (f64, i64)
fn sci_mantissa_and_exponent(self) -> (f64, i64)
Returns a Rational
’s scientific mantissa and exponent, taking the Rational
by reference.
When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and
$m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational
mantissa as a float. The conversion might not be exact, so we round to the nearest
float using the Nearest
rounding mode. To use other rounding modes, use
sci_mantissa_and_exponent_with_rounding
.
$$
f(x) \approx (\frac{x}{2^{\lfloor \log_2 x \rfloor}}, \lfloor \log_2 x \rfloor).
$$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
See here.
sourcefn sci_exponent(self) -> i64
fn sci_exponent(self) -> i64
Returns a Rational
’s scientific exponent, taking the Rational
by reference.
When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and
$m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational
mantissa as a float. The conversion might not be exact, so we round to the nearest
float using the Nearest
rounding mode. To use other rounding modes, use
sci_mantissa_and_exponent_with_rounding
.
$$
f(x) \approx \lfloor \log_2 x \rfloor.
$$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
sourcefn from_sci_mantissa_and_exponent(
sci_mantissa: f64,
sci_exponent: i64
) -> Option<Rational>
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 Rational
s, 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.
sourcefn sci_mantissa(self) -> M
fn sci_mantissa(self) -> M
sourceimpl SciMantissaAndExponent<f64, i64, Rational> for Rational
impl SciMantissaAndExponent<f64, i64, Rational> for Rational
sourcefn sci_mantissa_and_exponent(self) -> (f64, i64)
fn sci_mantissa_and_exponent(self) -> (f64, i64)
Returns a Rational
’s scientific mantissa and exponent, taking the Rational
by value.
When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and
$m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational
mantissa as a float. The conversion might not be exact, so we round to the nearest
float using the Nearest
rounding mode. To use other rounding modes, use
sci_mantissa_and_exponent_with_rounding
.
$$
f(x) \approx (\frac{x}{2^{\lfloor \log_2 x \rfloor}}, \lfloor \log_2 x \rfloor).
$$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
See here.
sourcefn sci_exponent(self) -> i64
fn sci_exponent(self) -> i64
Returns a Rational
’s scientific exponent, taking the Rational
by value.
When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and
$m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational
mantissa as a float. The conversion might not be exact, so we round to the nearest
float using the Nearest
rounding mode. To use other rounding modes, use
sci_mantissa_and_exponent_with_rounding
.
$$
f(x) \approx \lfloor \log_2 x \rfloor.
$$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
See here.
sourcefn from_sci_mantissa_and_exponent(
sci_mantissa: f64,
sci_exponent: i64
) -> Option<Rational>
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 Rational
s, 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
.
sourcefn sci_mantissa(self) -> M
fn sci_mantissa(self) -> M
sourceimpl<'a> Shl<i128> for &'a Rational
impl<'a> Shl<i128> for &'a Rational
sourcefn shl(self, bits: i128) -> 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.
sourceimpl Shl<i128> for Rational
impl Shl<i128> for Rational
sourcefn shl(self, bits: i128) -> 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.
sourceimpl<'a> Shl<i16> for &'a Rational
impl<'a> Shl<i16> for &'a Rational
sourcefn shl(self, bits: i16) -> 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.
sourceimpl Shl<i16> for Rational
impl Shl<i16> for Rational
sourcefn shl(self, bits: i16) -> 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.
sourceimpl<'a> Shl<i32> for &'a Rational
impl<'a> Shl<i32> for &'a Rational
sourcefn shl(self, bits: i32) -> 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.
sourceimpl Shl<i32> for Rational
impl Shl<i32> for Rational
sourcefn shl(self, bits: i32) -> 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.
sourceimpl<'a> Shl<i64> for &'a Rational
impl<'a> Shl<i64> for &'a Rational
sourcefn shl(self, bits: i64) -> 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.
sourceimpl Shl<i64> for Rational
impl Shl<i64> for Rational
sourcefn shl(self, bits: i64) -> 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.
sourceimpl<'a> Shl<i8> for &'a Rational
impl<'a> Shl<i8> for &'a Rational
sourcefn shl(self, bits: i8) -> 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.
sourceimpl Shl<i8> for Rational
impl Shl<i8> for Rational
sourcefn shl(self, bits: i8) -> 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.
sourceimpl<'a> Shl<isize> for &'a Rational
impl<'a> Shl<isize> for &'a Rational
sourcefn shl(self, bits: isize) -> 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.
sourceimpl Shl<isize> for Rational
impl Shl<isize> for Rational
sourcefn shl(self, bits: isize) -> 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.
sourceimpl<'a> Shl<u128> for &'a Rational
impl<'a> Shl<u128> for &'a Rational
sourcefn shl(self, bits: u128) -> 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.
sourceimpl Shl<u128> for Rational
impl Shl<u128> for Rational
sourcefn shl(self, bits: u128) -> 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.
sourceimpl<'a> Shl<u16> for &'a Rational
impl<'a> Shl<u16> for &'a Rational
sourcefn shl(self, bits: u16) -> 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.
sourceimpl Shl<u16> for Rational
impl Shl<u16> for Rational
sourcefn shl(self, bits: u16) -> 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.
sourceimpl<'a> Shl<u32> for &'a Rational
impl<'a> Shl<u32> for &'a Rational
sourcefn shl(self, bits: u32) -> 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.
sourceimpl Shl<u32> for Rational
impl Shl<u32> for Rational
sourcefn shl(self, bits: u32) -> 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.
sourceimpl<'a> Shl<u64> for &'a Rational
impl<'a> Shl<u64> for &'a Rational
sourcefn shl(self, bits: u64) -> 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.
sourceimpl Shl<u64> for Rational
impl Shl<u64> for Rational
sourcefn shl(self, bits: u64) -> 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.
sourceimpl<'a> Shl<u8> for &'a Rational
impl<'a> Shl<u8> for &'a Rational
sourcefn shl(self, bits: u8) -> 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.
sourceimpl Shl<u8> for Rational
impl Shl<u8> for Rational
sourcefn shl(self, bits: u8) -> 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.
sourceimpl<'a> Shl<usize> for &'a Rational
impl<'a> Shl<usize> for &'a Rational
sourcefn shl(self, bits: usize) -> 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.
sourceimpl Shl<usize> for Rational
impl Shl<usize> for Rational
sourcefn shl(self, bits: usize) -> 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.
sourceimpl ShlAssign<i128> for Rational
impl ShlAssign<i128> for Rational
sourcefn shl_assign(&mut self, bits: i128)
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.
sourceimpl ShlAssign<i16> for Rational
impl ShlAssign<i16> for Rational
sourcefn shl_assign(&mut self, bits: i16)
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.
sourceimpl ShlAssign<i32> for Rational
impl ShlAssign<i32> for Rational
sourcefn shl_assign(&mut self, bits: i32)
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.
sourceimpl ShlAssign<i64> for Rational
impl ShlAssign<i64> for Rational
sourcefn shl_assign(&mut self, bits: i64)
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.
sourceimpl ShlAssign<i8> for Rational
impl ShlAssign<i8> for Rational
sourcefn shl_assign(&mut self, bits: i8)
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.
sourceimpl ShlAssign<isize> for Rational
impl ShlAssign<isize> for Rational
sourcefn shl_assign(&mut self, bits: isize)
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.
sourceimpl ShlAssign<u128> for Rational
impl ShlAssign<u128> for Rational
sourcefn shl_assign(&mut self, bits: u128)
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.
sourceimpl ShlAssign<u16> for Rational
impl ShlAssign<u16> for Rational
sourcefn shl_assign(&mut self, bits: u16)
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.
sourceimpl ShlAssign<u32> for Rational
impl ShlAssign<u32> for Rational
sourcefn shl_assign(&mut self, bits: u32)
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.
sourceimpl ShlAssign<u64> for Rational
impl ShlAssign<u64> for Rational
sourcefn shl_assign(&mut self, bits: u64)
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.
sourceimpl ShlAssign<u8> for Rational
impl ShlAssign<u8> for Rational
sourcefn shl_assign(&mut self, bits: u8)
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.
sourceimpl ShlAssign<usize> for Rational
impl ShlAssign<usize> for Rational
sourcefn shl_assign(&mut self, bits: usize)
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.
sourceimpl<'a> Shr<i128> for &'a Rational
impl<'a> Shr<i128> for &'a Rational
sourcefn shr(self, bits: i128) -> 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.
sourceimpl Shr<i128> for Rational
impl Shr<i128> for Rational
sourcefn shr(self, bits: i128) -> 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.
sourceimpl<'a> Shr<i16> for &'a Rational
impl<'a> Shr<i16> for &'a Rational
sourcefn shr(self, bits: i16) -> 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.
sourceimpl Shr<i16> for Rational
impl Shr<i16> for Rational
sourcefn shr(self, bits: i16) -> 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.
sourceimpl<'a> Shr<i32> for &'a Rational
impl<'a> Shr<i32> for &'a Rational
sourcefn shr(self, bits: i32) -> 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.
sourceimpl Shr<i32> for Rational
impl Shr<i32> for Rational
sourcefn shr(self, bits: i32) -> 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.
sourceimpl<'a> Shr<i64> for &'a Rational
impl<'a> Shr<i64> for &'a Rational
sourcefn shr(self, bits: i64) -> 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.
sourceimpl Shr<i64> for Rational
impl Shr<i64> for Rational
sourcefn shr(self, bits: i64) -> 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.
sourceimpl<'a> Shr<i8> for &'a Rational
impl<'a> Shr<i8> for &'a Rational
sourcefn shr(self, bits: i8) -> 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.
sourceimpl Shr<i8> for Rational
impl Shr<i8> for Rational
sourcefn shr(self, bits: i8) -> 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.
sourceimpl<'a> Shr<isize> for &'a Rational
impl<'a> Shr<isize> for &'a Rational
sourcefn shr(self, bits: isize) -> 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.
sourceimpl Shr<isize> for Rational
impl Shr<isize> for Rational
sourcefn shr(self, bits: isize) -> 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.
sourceimpl<'a> Shr<u128> for &'a Rational
impl<'a> Shr<u128> for &'a Rational
sourcefn shr(self, bits: u128) -> 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.
sourceimpl Shr<u128> for Rational
impl Shr<u128> for Rational
sourcefn shr(self, bits: u128) -> 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.
sourceimpl<'a> Shr<u16> for &'a Rational
impl<'a> Shr<u16> for &'a Rational
sourcefn shr(self, bits: u16) -> 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.
sourceimpl Shr<u16> for Rational
impl Shr<u16> for Rational
sourcefn shr(self, bits: u16) -> 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.
sourceimpl<'a> Shr<u32> for &'a Rational
impl<'a> Shr<u32> for &'a Rational
sourcefn shr(self, bits: u32) -> 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.
sourceimpl Shr<u32> for Rational
impl Shr<u32> for Rational
sourcefn shr(self, bits: u32) -> 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.
sourceimpl<'a> Shr<u64> for &'a Rational
impl<'a> Shr<u64> for &'a Rational
sourcefn shr(self, bits: u64) -> 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.
sourceimpl Shr<u64> for Rational
impl Shr<u64> for Rational
sourcefn shr(self, bits: u64) -> 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.
sourceimpl<'a> Shr<u8> for &'a Rational
impl<'a> Shr<u8> for &'a Rational
sourcefn shr(self, bits: u8) -> 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.
sourceimpl Shr<u8> for Rational
impl Shr<u8> for Rational
sourcefn shr(self, bits: u8) -> 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.
sourceimpl<'a> Shr<usize> for &'a Rational
impl<'a> Shr<usize> for &'a Rational
sourcefn shr(self, bits: usize) -> 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.
sourceimpl Shr<usize> for Rational
impl Shr<usize> for Rational
sourcefn shr(self, bits: usize) -> 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.
sourceimpl ShrAssign<i128> for Rational
impl ShrAssign<i128> for Rational
sourcefn shr_assign(&mut self, bits: i128)
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.
sourceimpl ShrAssign<i16> for Rational
impl ShrAssign<i16> for Rational
sourcefn shr_assign(&mut self, bits: i16)
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.
sourceimpl ShrAssign<i32> for Rational
impl ShrAssign<i32> for Rational
sourcefn shr_assign(&mut self, bits: i32)
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.
sourceimpl ShrAssign<i64> for Rational
impl ShrAssign<i64> for Rational
sourcefn shr_assign(&mut self, bits: i64)
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.
sourceimpl ShrAssign<i8> for Rational
impl ShrAssign<i8> for Rational
sourcefn shr_assign(&mut self, bits: i8)
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.
sourceimpl ShrAssign<isize> for Rational
impl ShrAssign<isize> for Rational
sourcefn shr_assign(&mut self, bits: isize)
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.
sourceimpl ShrAssign<u128> for Rational
impl ShrAssign<u128> for Rational
sourcefn shr_assign(&mut self, bits: u128)
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.
sourceimpl ShrAssign<u16> for Rational
impl ShrAssign<u16> for Rational
sourcefn shr_assign(&mut self, bits: u16)
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.
sourceimpl ShrAssign<u32> for Rational
impl ShrAssign<u32> for Rational
sourcefn shr_assign(&mut self, bits: u32)
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.
sourceimpl ShrAssign<u64> for Rational
impl ShrAssign<u64> for Rational
sourcefn shr_assign(&mut self, bits: u64)
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.
sourceimpl ShrAssign<u8> for Rational
impl ShrAssign<u8> for Rational
sourcefn shr_assign(&mut self, bits: u8)
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.
sourceimpl ShrAssign<usize> for Rational
impl ShrAssign<usize> for Rational
sourcefn shr_assign(&mut self, bits: usize)
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.
sourceimpl Sign for Rational
impl Sign for Rational
sourcefn sign(&self) -> Ordering
fn sign(&self) -> Ordering
Compares a Rational
to zero.
Returns Greater
, Equal
, or Less
, depending on whether the Rational
is positive,
zero, or negative, respectively.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Sign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
use std::cmp::Ordering;
assert_eq!(Rational::ZERO.sign(), Ordering::Equal);
assert_eq!(Rational::from_signeds(22, 7).sign(), Ordering::Greater);
assert_eq!(Rational::from_signeds(-22, 7).sign(), Ordering::Less);
sourceimpl<'a> SignificantBits for &'a Rational
impl<'a> SignificantBits for &'a Rational
sourcefn significant_bits(self) -> u64
fn significant_bits(self) -> u64
Returns the sum of the bits needed to represent the numerator and denominator.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::logic::traits::SignificantBits;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
use std::str::FromStr;
assert_eq!(Rational::ZERO.significant_bits(), 1);
assert_eq!(Rational::from_str("-100/101").unwrap().significant_bits(), 14);
sourceimpl SimplestRationalInInterval for Rational
impl SimplestRationalInInterval for Rational
sourcefn simplest_rational_in_open_interval(x: &Rational, y: &Rational) -> Rational
fn simplest_rational_in_open_interval(x: &Rational, y: &Rational) -> Rational
Finds the simplest Rational
contained in an open interval.
Let $f(x, y) = p/q$, with $p$ and $q$ relatively prime. Then the following properties hold:
- $x < p/q < y$
- If $x < m/n < y$, then $n \geq q$
- If $x < m/q < y$, then $|p| \leq |m|$
Worst-case complexity
$T(n) = O(n^2 \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(x.significant_bits(), y.significant_bits())
.
Panics
Panics if $x \geq y$.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::Zero;
use malachite_q::arithmetic::traits::SimplestRationalInInterval;
use malachite_q::Rational;
assert_eq!(
Rational::simplest_rational_in_open_interval(
&Rational::from_signeds(1, 3),
&Rational::from_signeds(1, 2)
),
Rational::from_signeds(2, 5)
);
assert_eq!(
Rational::simplest_rational_in_open_interval(
&Rational::from_signeds(-1, 3),
&Rational::from_signeds(1, 3)
),
Rational::ZERO
);
assert_eq!(
Rational::simplest_rational_in_open_interval(
&Rational::from_signeds(314, 100),
&Rational::from_signeds(315, 100)
),
Rational::from_signeds(22, 7)
);
sourcefn simplest_rational_in_closed_interval(x: &Rational, y: &Rational) -> Rational
fn simplest_rational_in_closed_interval(x: &Rational, y: &Rational) -> Rational
Finds the simplest Rational
contained in a closed interval.
Let $f(x, y) = p/q$, with $p$ and $q$ relatively prime. Then the following properties hold:
- $x \leq p/q \leq y$
- If $x \leq m/n \leq y$, then $n \geq q$
- If $x \leq m/q \leq y$, then $|p| \leq |m|$
Worst-case complexity
$T(n) = O(n^2 \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(x.significant_bits(), y.significant_bits())
.
Panics
Panics if $x > y$.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::Zero;
use malachite_q::arithmetic::traits::SimplestRationalInInterval;
use malachite_q::Rational;
assert_eq!(
Rational::simplest_rational_in_closed_interval(
&Rational::from_signeds(1, 3),
&Rational::from_signeds(1, 2)
),
Rational::from_signeds(1, 2)
);
assert_eq!(
Rational::simplest_rational_in_closed_interval(
&Rational::from_signeds(-1, 3),
&Rational::from_signeds(1, 3)
),
Rational::ZERO
);
assert_eq!(
Rational::simplest_rational_in_closed_interval(
&Rational::from_signeds(314, 100),
&Rational::from_signeds(315, 100)
),
Rational::from_signeds(22, 7)
);
sourceimpl<'a> Square for &'a Rational
impl<'a> Square for &'a Rational
sourcefn square(self) -> Rational
fn square(self) -> Rational
Squares a Rational
, taking it by reference.
$$ f(x) = x^2. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Square;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!((&Rational::ZERO).square(), 0);
assert_eq!((&Rational::from_signeds(22, 7)).square().to_string(), "484/49");
assert_eq!((&Rational::from_signeds(-22, 7)).square().to_string(), "484/49");
type Output = Rational
sourceimpl Square for Rational
impl Square for Rational
sourcefn square(self) -> Rational
fn square(self) -> Rational
Squares a Rational
, taking it by value.
$$ f(x) = x^2. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Square;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!(Rational::ZERO.square(), 0);
assert_eq!(Rational::from_signeds(22, 7).square().to_string(), "484/49");
assert_eq!(Rational::from_signeds(-22, 7).square().to_string(), "484/49");
type Output = Rational
sourceimpl SquareAssign for Rational
impl SquareAssign for Rational
sourcefn square_assign(&mut self)
fn square_assign(&mut self)
Squares a Rational
in place.
$$ x \gets x^2. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::SquareAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
let mut x = Rational::ZERO;
x.square_assign();
assert_eq!(x, 0);
let mut x = Rational::from_signeds(22, 7);
x.square_assign();
assert_eq!(x.to_string(), "484/49");
let mut x = Rational::from_signeds(-22, 7);
x.square_assign();
assert_eq!(x.to_string(), "484/49");
sourceimpl<'a, 'b> Sub<&'a Rational> for &'b Rational
impl<'a, 'b> Sub<&'a Rational> for &'b Rational
sourcefn sub(self, other: &'a Rational) -> Rational
fn sub(self, other: &'a Rational) -> Rational
Subtracts a Rational
by another Rational
, taking both by reference.
$$ f(x, y) = x - y. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
assert_eq!(&Rational::ONE_HALF - &Rational::ONE_HALF, 0);
assert_eq!(
(&Rational::from_signeds(22, 7) - &Rational::from_signeds(99, 100)).to_string(),
"1507/700"
);
sourceimpl<'a> Sub<&'a Rational> for Rational
impl<'a> Sub<&'a Rational> for Rational
sourcefn sub(self, other: &'a Rational) -> Rational
fn sub(self, other: &'a Rational) -> Rational
Subtracts a Rational
by another Rational
, taking the first by value and the second
by reference.
$$ f(x, y) = x - y. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
assert_eq!(Rational::ONE_HALF - &Rational::ONE_HALF, 0);
assert_eq!(
(Rational::from_signeds(22, 7) - &Rational::from_signeds(99, 100)).to_string(),
"1507/700"
);
sourceimpl<'a> Sub<Rational> for &'a Rational
impl<'a> Sub<Rational> for &'a Rational
sourcefn sub(self, other: Rational) -> Rational
fn sub(self, other: Rational) -> Rational
Subtracts a Rational
by another Rational
, taking the first by reference and the
second by value.
$$ f(x, y) = x - y. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
assert_eq!(&Rational::ONE_HALF - Rational::ONE_HALF, 0);
assert_eq!(
(&Rational::from_signeds(22, 7) - Rational::from_signeds(99, 100)).to_string(),
"1507/700"
);
sourceimpl Sub<Rational> for Rational
impl Sub<Rational> for Rational
sourcefn sub(self, other: Rational) -> Rational
fn sub(self, other: Rational) -> Rational
Subtracts a Rational
by another Rational
, taking both by value.
$$ f(x, y) = x - y. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
assert_eq!(Rational::ONE_HALF - Rational::ONE_HALF, 0);
assert_eq!(
(Rational::from_signeds(22, 7) - Rational::from_signeds(99, 100)).to_string(),
"1507/700"
);
sourceimpl<'a> SubAssign<&'a Rational> for Rational
impl<'a> SubAssign<&'a Rational> for Rational
sourcefn sub_assign(&mut self, other: &'a Rational)
fn sub_assign(&mut self, other: &'a Rational)
Subtracts a Rational
by another Rational
in place, taking the Rational
on the
right-hand side by reference.
$$ x \gets x - y. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
let mut x = Rational::ONE_HALF;
x -= &Rational::ONE_HALF;
assert_eq!(x, 0);
let mut x = Rational::from_signeds(22, 7);
x -= &Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "1507/700");
sourceimpl SubAssign<Rational> for Rational
impl SubAssign<Rational> for Rational
sourcefn sub_assign(&mut self, other: Rational)
fn sub_assign(&mut self, other: Rational)
Subtracts a Rational
by another Rational
in place, taking the Rational
on the
right-hand side by value.
$$ x \gets x - y. $$
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
let mut x = Rational::ONE_HALF;
x -= Rational::ONE_HALF;
assert_eq!(x, 0);
let mut x = Rational::from_signeds(22, 7);
x -= Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "1507/700");
sourceimpl ToSci for Rational
impl ToSci for Rational
sourcefn fmt_sci_valid(&self, options: ToSciOptions) -> bool
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
hasscale
specified, thens
isoptions.scale
. - If
options
hasprecision
specified, thens
isoptions.precision
. - If
options
hassize_complete
specified, thens
isself.denominator
(not the log of the denominator!). This reflects the fact that settingsize_complete
might result in a very long string.
Examples
extern crate malachite_base;
use malachite_base::num::conversion::string::options::ToSciOptions;
use malachite_base::num::conversion::traits::ToSci;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;
let mut options = ToSciOptions::default();
assert!(Rational::from(123u8).fmt_sci_valid(options));
assert!(Rational::from(u128::MAX).fmt_sci_valid(options));
// u128::MAX has more than 16 significant digits
options.set_rounding_mode(RoundingMode::Exact);
assert!(!Rational::from(u128::MAX).fmt_sci_valid(options));
options.set_precision(50);
assert!(Rational::from(u128::MAX).fmt_sci_valid(options));
let mut options = ToSciOptions::default();
options.set_size_complete();
// 1/3 is non-terminating in base 10...
assert!(!Rational::from_signeds(1, 3).fmt_sci_valid(options));
options.set_size_complete();
// ...but is terminating in base 36
options.set_base(36);
assert!(Rational::from_signeds(1, 3).fmt_sci_valid(options));
sourcefn fmt_sci(&self, f: &mut Formatter<'_>, options: ToSciOptions) -> Result
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
hasscale
specified, thens
isoptions.scale
. - If
options
hasprecision
specified, thens
isoptions.precision
. - If
options
hassize_complete
specified, thens
isself.denominator
(not the log of the denominator!). This reflects the fact that settingsize_complete
might result in a very long string.
Panics
Panics if options.rounding_mode
is Exact
, but the size options are such that the input
must be rounded.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_base::num::conversion::string::options::ToSciOptions;
use malachite_base::num::conversion::traits::ToSci;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;
let q = Rational::from_signeds(22, 7);
let mut options = ToSciOptions::default();
assert_eq!(q.to_sci_with_options(options).to_string(), "3.142857142857143");
options.set_precision(3);
assert_eq!(q.to_sci_with_options(options).to_string(), "3.14");
options.set_rounding_mode(RoundingMode::Ceiling);
assert_eq!(q.to_sci_with_options(options).to_string(), "3.15");
options = ToSciOptions::default();
options.set_base(20);
assert_eq!(q.to_sci_with_options(options).to_string(), "3.2h2h2h2h2h2h2h3");
options.set_uppercase();
assert_eq!(q.to_sci_with_options(options).to_string(), "3.2H2H2H2H2H2H2H3");
options.set_base(2);
options.set_rounding_mode(RoundingMode::Floor);
options.set_precision(19);
assert_eq!(q.to_sci_with_options(options).to_string(), "11.001001001001001");
options.set_include_trailing_zeros(true);
assert_eq!(q.to_sci_with_options(options).to_string(), "11.00100100100100100");
let q = Rational::from_unsigneds(936851431250u64, 1397u64);
let mut options = ToSciOptions::default();
options.set_precision(6);
assert_eq!(q.to_sci_with_options(options).to_string(), "6.70617e8");
options.set_e_uppercase();
assert_eq!(q.to_sci_with_options(options).to_string(), "6.70617E8");
options.set_force_exponent_plus_sign(true);
assert_eq!(q.to_sci_with_options(options).to_string(), "6.70617E+8");
let q = Rational::from_signeds(123i64, 45678909876i64);
let mut options = ToSciOptions::default();
assert_eq!(q.to_sci_with_options(options).to_string(), "2.692708743135418e-9");
options.set_neg_exp_threshold(-10);
assert_eq!(q.to_sci_with_options(options).to_string(), "0.000000002692708743135418");
let q = Rational::power_of_2(-30i64);
let mut options = ToSciOptions::default();
assert_eq!(q.to_sci_with_options(options).to_string(), "9.313225746154785e-10");
options.set_size_complete();
assert_eq!(q.to_sci_with_options(options).to_string(), "9.31322574615478515625e-10");
sourcefn to_sci_with_options(&self, options: ToSciOptions) -> SciWrapper<'_, Self>
fn to_sci_with_options(&self, options: ToSciOptions) -> SciWrapper<'_, Self>
sourcefn to_sci(&self) -> SciWrapper<'_, Self>
fn to_sci(&self) -> SciWrapper<'_, Self>
ToSciOptions
. Read moresourceimpl<'a> TryFrom<&'a Rational> for Integer
impl<'a> TryFrom<&'a Rational> for Integer
sourcefn try_from(x: &Rational) -> Result<Integer, Self::Error>
fn try_from(x: &Rational) -> Result<Integer, 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
type Error = IntegerFromRationalError
sourceimpl<'a> TryFrom<&'a Rational> for Natural
impl<'a> TryFrom<&'a Rational> for Natural
sourcefn try_from(x: &Rational) -> Result<Natural, Self::Error>
fn try_from(x: &Rational) -> Result<Natural, 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
type Error = NaturalFromRationalError
sourceimpl<'a> TryFrom<&'a Rational> for f32
impl<'a> TryFrom<&'a Rational> for f32
sourcefn try_from(value: &'a Rational) -> Result<f32, Self::Error>
fn try_from(value: &'a 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 = PrimitiveFloatFromRationalError
type Error = PrimitiveFloatFromRationalError
sourceimpl<'a> TryFrom<&'a Rational> for f64
impl<'a> TryFrom<&'a Rational> for f64
sourcefn try_from(value: &'a Rational) -> Result<f64, Self::Error>
fn try_from(value: &'a 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 = PrimitiveFloatFromRationalError
type Error = PrimitiveFloatFromRationalError
sourceimpl<'a> TryFrom<&'a Rational> for i128
impl<'a> TryFrom<&'a Rational> for i128
sourcefn try_from(value: &Rational) -> Result<i128, SignedFromRationalError>
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
type Error = SignedFromRationalError
sourceimpl<'a> TryFrom<&'a Rational> for i16
impl<'a> TryFrom<&'a Rational> for i16
sourcefn try_from(value: &Rational) -> Result<i16, SignedFromRationalError>
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
type Error = SignedFromRationalError
sourceimpl<'a> TryFrom<&'a Rational> for i32
impl<'a> TryFrom<&'a Rational> for i32
sourcefn try_from(value: &Rational) -> Result<i32, SignedFromRationalError>
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
type Error = SignedFromRationalError
sourceimpl<'a> TryFrom<&'a Rational> for i64
impl<'a> TryFrom<&'a Rational> for i64
sourcefn try_from(value: &Rational) -> Result<i64, SignedFromRationalError>
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
type Error = SignedFromRationalError
sourceimpl<'a> TryFrom<&'a Rational> for i8
impl<'a> TryFrom<&'a Rational> for i8
sourcefn try_from(value: &Rational) -> Result<i8, SignedFromRationalError>
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
type Error = SignedFromRationalError
sourceimpl<'a> TryFrom<&'a Rational> for isize
impl<'a> TryFrom<&'a Rational> for isize
sourcefn try_from(value: &Rational) -> Result<isize, SignedFromRationalError>
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
type Error = SignedFromRationalError
sourceimpl<'a> TryFrom<&'a Rational> for u128
impl<'a> TryFrom<&'a Rational> for u128
sourcefn try_from(value: &Rational) -> Result<u128, UnsignedFromRationalError>
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
type Error = UnsignedFromRationalError
sourceimpl<'a> TryFrom<&'a Rational> for u16
impl<'a> TryFrom<&'a Rational> for u16
sourcefn try_from(value: &Rational) -> Result<u16, UnsignedFromRationalError>
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
type Error = UnsignedFromRationalError
sourceimpl<'a> TryFrom<&'a Rational> for u32
impl<'a> TryFrom<&'a Rational> for u32
sourcefn try_from(value: &Rational) -> Result<u32, UnsignedFromRationalError>
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
type Error = UnsignedFromRationalError
sourceimpl<'a> TryFrom<&'a Rational> for u64
impl<'a> TryFrom<&'a Rational> for u64
sourcefn try_from(value: &Rational) -> Result<u64, UnsignedFromRationalError>
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
type Error = UnsignedFromRationalError
sourceimpl<'a> TryFrom<&'a Rational> for u8
impl<'a> TryFrom<&'a Rational> for u8
sourcefn try_from(value: &Rational) -> Result<u8, UnsignedFromRationalError>
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
type Error = UnsignedFromRationalError
sourceimpl<'a> TryFrom<&'a Rational> for usize
impl<'a> TryFrom<&'a Rational> for usize
sourcefn try_from(value: &Rational) -> Result<usize, UnsignedFromRationalError>
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
type Error = UnsignedFromRationalError
sourceimpl TryFrom<Rational> for Integer
impl TryFrom<Rational> for Integer
sourcefn try_from(x: Rational) -> Result<Integer, Self::Error>
fn try_from(x: Rational) -> Result<Integer, 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
extern crate malachite_nz;
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
type Error = IntegerFromRationalError
sourceimpl TryFrom<Rational> for Natural
impl TryFrom<Rational> for Natural
sourcefn try_from(x: Rational) -> Result<Natural, Self::Error>
fn try_from(x: Rational) -> Result<Natural, 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
type Error = NaturalFromRationalError
sourceimpl TryFrom<Rational> for f32
impl TryFrom<Rational> for f32
sourcefn try_from(value: Rational) -> Result<f32, Self::Error>
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 = PrimitiveFloatFromRationalError
type Error = PrimitiveFloatFromRationalError
sourceimpl TryFrom<Rational> for f64
impl TryFrom<Rational> for f64
sourcefn try_from(value: Rational) -> Result<f64, Self::Error>
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 = PrimitiveFloatFromRationalError
type Error = PrimitiveFloatFromRationalError
sourceimpl TryFrom<f32> for Rational
impl TryFrom<f32> for Rational
sourcefn try_from(value: f32) -> Result<Rational, Self::Error>
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, and 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
type Error = RationalFromPrimitiveFloatError
sourceimpl TryFrom<f64> for Rational
impl TryFrom<f64> for Rational
sourcefn try_from(value: f64) -> Result<Rational, Self::Error>
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, and 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.