pub struct Rational { /* private fields */ }
Expand description
A rational number.
Rational
s whose numerator and denominator have 64 significant bits or fewer can be represented
without any memory allocation. (Unless Malachite is compiled with 32_bit_limbs
, in which case
the limit is 32).
Implementations§
Source§impl 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+\varepsilon)(\log x)$, where $|\varepsilon| < 2^{-52}.$
§Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
§Examples
use malachite_base::num::arithmetic::traits::{Pow, PowerOf2};
use malachite_base::num::float::NiceFloat;
use malachite_q::Rational;
assert_eq!(
NiceFloat(Rational::from(10i32).approx_log()),
NiceFloat(2.3025850929940455)
);
assert_eq!(
NiceFloat(Rational::from(10i32).pow(100u64).approx_log()),
NiceFloat(230.25850929940455)
);
assert_eq!(
NiceFloat(Rational::power_of_2(1000000u64).approx_log()),
NiceFloat(693147.1805599453)
);
assert_eq!(
NiceFloat(Rational::power_of_2(-1000000i64).approx_log()),
NiceFloat(-693147.1805599453)
);
This is equivalent to fmpz_dlog
from fmpz/dlog.c
, FLINT 2.7.1.
Source§impl Rational
impl Rational
Sourcepub fn floor_log_base_2_abs(&self) -> i64
pub fn floor_log_base_2_abs(&self) -> i64
Returns the floor of the base-2 logarithm of the absolute value of a nonzero Rational
.
$f(x) = \lfloor\log_2 |x|\rfloor$.
§Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
§Panics
Panics if self
is zero.
§Examples
use malachite_q::Rational;
assert_eq!(Rational::from(3u32).floor_log_base_2_abs(), 1);
assert_eq!(Rational::from_signeds(1, 3).floor_log_base_2_abs(), -2);
assert_eq!(Rational::from_signeds(1, 4).floor_log_base_2_abs(), -2);
assert_eq!(Rational::from_signeds(1, 5).floor_log_base_2_abs(), -3);
assert_eq!(Rational::from(-3).floor_log_base_2_abs(), 1);
assert_eq!(Rational::from_signeds(-1, 3).floor_log_base_2_abs(), -2);
assert_eq!(Rational::from_signeds(-1, 4).floor_log_base_2_abs(), -2);
assert_eq!(Rational::from_signeds(-1, 5).floor_log_base_2_abs(), -3);
Sourcepub fn ceiling_log_base_2_abs(&self) -> i64
pub fn ceiling_log_base_2_abs(&self) -> i64
Returns the ceiling of the base-2 logarithm of the absolute value of a nonzero Rational
.
$f(x) = \lfloor\log_2 |x|\rfloor$.
§Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
§Panics
Panics if self
less than or equal to zero.
§Examples
use malachite_q::Rational;
assert_eq!(Rational::from(3u32).ceiling_log_base_2_abs(), 2);
assert_eq!(Rational::from_signeds(1, 3).ceiling_log_base_2_abs(), -1);
assert_eq!(Rational::from_signeds(1, 4).ceiling_log_base_2_abs(), -2);
assert_eq!(Rational::from_signeds(1, 5).ceiling_log_base_2_abs(), -2);
assert_eq!(Rational::from(-3).ceiling_log_base_2_abs(), 2);
assert_eq!(Rational::from_signeds(-1, 3).ceiling_log_base_2_abs(), -1);
assert_eq!(Rational::from_signeds(-1, 4).ceiling_log_base_2_abs(), -2);
assert_eq!(Rational::from_signeds(-1, 5).ceiling_log_base_2_abs(), -2);
Source§impl 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)),
Less
);
assert_eq!(
Rational::from_signeds(1, 2).cmp_complexity(&Rational::from_signeds(3, 2)),
Less
);
assert_eq!(
Rational::from_signeds(1, 2).cmp_complexity(&Rational::from_signeds(-1, 2)),
Less
);
Source§impl 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
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
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"
);
Source§impl 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
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, ...]"
);
Source§impl 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
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
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"
);
Source§impl 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
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
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"
);
Source§impl 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
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, ...]"
);
Source§impl 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
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
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]]");
Source§impl 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
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
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]]");
Source§impl Rational
impl Rational
Sourcepub fn try_from_float_simplest<T: PrimitiveFloat>(
x: T,
) -> Result<Rational, RationalFromPrimitiveFloatError>
pub fn try_from_float_simplest<T: PrimitiveFloat>( x: T, ) -> Result<Rational, 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)
);
Source§impl Rational
impl Rational
Sourcepub const fn const_from_unsigneds(
numerator: Limb,
denominator: Limb,
) -> Rational
pub const fn const_from_unsigneds( numerator: Limb, denominator: Limb, ) -> Rational
Converts twoLimb
s, representing a numerator and a denominator, to a
Rational
.
If denominator
is zero, None
is returned.
This function is const, so it may be used to define constants. When called at runtime, it is
slower than Rational::from_unsigneds
.
§Worst-case complexity
$T(n) = O(n^2)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is max(numerator.significant_bits(), denominator.significant_bits())
.
§Examples
use malachite_q::Rational;
const TWO_THIRDS: Rational = Rational::const_from_unsigneds(2, 3);
assert_eq!(TWO_THIRDS, Rational::from_unsigneds(2u32, 3));
const TWO_THIRDS_ALT: Rational = Rational::const_from_unsigneds(22, 33);
assert_eq!(TWO_THIRDS_ALT, Rational::from_unsigneds(2u32, 3));
Sourcepub const fn const_from_signeds(
numerator: SignedLimb,
denominator: SignedLimb,
) -> Rational
pub const fn const_from_signeds( numerator: SignedLimb, denominator: SignedLimb, ) -> Rational
Converts twoSignedLimb
s, representing a numerator and a denominator, to a
Rational
.
If denominator
is zero, None
is returned.
This function is const, so it may be used to define constants. When called at runtime, it is
slower than Rational::from_signeds
.
§Worst-case complexity
$T(n) = O(n^2)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is max(numerator.significant_bits(), denominator.significant_bits())
.
§Examples
use malachite_q::Rational;
const NEGATIVE_TWO_THIRDS: Rational = Rational::const_from_signeds(-2, 3);
assert_eq!(NEGATIVE_TWO_THIRDS, Rational::from_signeds(-2, 3));
const NEGATIVE_TWO_THIRDS_ALT: Rational = Rational::const_from_signeds(-22, 33);
assert_eq!(NEGATIVE_TWO_THIRDS_ALT, Rational::from_signeds(-2, 3));
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
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
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,
) -> Rational
pub fn from_unsigneds<T: PrimitiveUnsigned>( numerator: T, denominator: T, ) -> Rational
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(numerator.significant_bits(), denominator.significant_bits())
.
§Panics
Panics if denominator
is zero.
§Examples
use malachite_q::Rational;
assert_eq!(Rational::from_unsigneds(4u32, 6).to_string(), "2/3");
assert_eq!(Rational::from_unsigneds(0u32, 6), 0);
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
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
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,
) -> Rational
pub fn from_signeds<T: PrimitiveSigned>( numerator: T, denominator: T, ) -> Rational
Converts two signed primitive integers to a [Rational]
.
The absolute values of the integers become the Rational
’s numerator and denominator. The
sign of the Rational
is the sign of the integers’ quotient.
The denominator may not be zero.
The input integers may have common factors; this function reduces them.
§Worst-case complexity
$T(n) = O(n^2)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is max(numerator.significant_bits(), denominator.significant_bits())
.
§Panics
Panics if denominator
is zero.
§Examples
use malachite_q::Rational;
assert_eq!(Rational::from_signeds(4i8, 6).to_string(), "2/3");
assert_eq!(Rational::from_signeds(4i8, -6).to_string(), "-2/3");
assert_eq!(Rational::from_signeds(0i8, 6), 0);
assert_eq!(Rational::from_signeds(0i8, -6), 0);
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
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
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,
) -> Rational
pub fn from_sign_and_unsigneds<T: PrimitiveUnsigned>( sign: bool, numerator: T, denominator: T, ) -> Rational
Converts a sign and two primitive unsigned integers to a Rational
.
The integers become the Rational
’s numerator and denominator, and the sign indicates
whether the Rational
should be non-negative. If the numerator is zero, then the
Rational
will be non-negative regardless of the sign.
The denominator may not be zero.
The input integers may have common factors; this function reduces them.
§Worst-case complexity
$T(n) = O(n^2)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is max(numerator.significant_bits(), denominator.significant_bits())
.
§Panics
Panics if denominator
is zero.
§Examples
use malachite_q::Rational;
assert_eq!(
Rational::from_sign_and_unsigneds(true, 4u32, 6).to_string(),
"2/3"
);
assert_eq!(
Rational::from_sign_and_unsigneds(false, 4u32, 6).to_string(),
"-2/3"
);
Source§impl Rational
impl Rational
Sourcepub const fn const_from_unsigned(x: Limb) -> Rational
pub const fn const_from_unsigned(x: Limb) -> Rational
Sourcepub const fn const_from_signed(x: SignedLimb) -> Rational
pub const fn const_from_signed(x: SignedLimb) -> Rational
Converts a SignedLimb
to a Rational
.
This function is const, so it may be used to define constants.
§Worst-case complexity
Constant time and additional memory.
§Examples
use malachite_q::Rational;
const TEN: Rational = Rational::const_from_signed(10);
assert_eq!(TEN, 10);
const NEGATIVE_TEN: Rational = Rational::const_from_signed(-10);
assert_eq!(NEGATIVE_TEN, -10);
Source§impl Rational
impl Rational
Sourcepub fn sci_mantissa_and_exponent_round<T: PrimitiveFloat>(
self,
rm: RoundingMode,
) -> Option<(T, i64, Ordering)>
pub fn sci_mantissa_and_exponent_round<T: PrimitiveFloat>( self, rm: RoundingMode, ) -> Option<(T, i64, Ordering)>
Returns a Rational
’s scientific mantissa and exponent, taking the Rational
by value.
An Ordering
is also returned, indicating whether the returned mantissa and exponent
represent a value that is less than, equal to, or greater than the absolute value of the
Rational
.
The Rational
’s sign is ignored. This means that, for example, that rounding using
Floor
is equivalent to rounding using Down
, even if the Rational
is negative.
When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is
a rational number with $1 \leq m_s < 2$. We represent the rational mantissa as a float. The
conversion might not be exact, so we round to the nearest float using the provided rounding
mode. If the rounding mode is Exact
but the conversion is not exact, None
is returned.
$$
f(x, r) \approx \left (\frac{x}{2^{\lfloor \log_2 x \rfloor}},
\lfloor \log_2 x \rfloor\right ).
$$
§Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
§Examples
use malachite_base::num::float::NiceFloat;
use malachite_base::rounding_modes::RoundingMode::{self, *};
use malachite_q::Rational;
use std::cmp::Ordering::{self, *};
let test = |n: Rational, rm: RoundingMode, out: Option<(f32, i64, Ordering)>| {
assert_eq!(
n.sci_mantissa_and_exponent_round(rm)
.map(|(m, e, o)| (NiceFloat(m), e, o)),
out.map(|(m, e, o)| (NiceFloat(m), e, o))
);
};
test(Rational::from(3u32), Down, Some((1.5, 1, Equal)));
test(Rational::from(3u32), Ceiling, Some((1.5, 1, Equal)));
test(Rational::from(3u32), Up, Some((1.5, 1, Equal)));
test(Rational::from(3u32), Nearest, Some((1.5, 1, Equal)));
test(Rational::from(3u32), Exact, Some((1.5, 1, Equal)));
test(
Rational::from_signeds(1, 3),
Floor,
Some((1.3333333, -2, Less)),
);
test(
Rational::from_signeds(1, 3),
Down,
Some((1.3333333, -2, Less)),
);
test(
Rational::from_signeds(1, 3),
Ceiling,
Some((1.3333334, -2, Greater)),
);
test(
Rational::from_signeds(1, 3),
Up,
Some((1.3333334, -2, Greater)),
);
test(
Rational::from_signeds(1, 3),
Nearest,
Some((1.3333334, -2, Greater)),
);
test(Rational::from_signeds(1, 3), Exact, None);
test(
Rational::from_signeds(-1, 3),
Floor,
Some((1.3333333, -2, Less)),
);
test(
Rational::from_signeds(-1, 3),
Down,
Some((1.3333333, -2, Less)),
);
test(
Rational::from_signeds(-1, 3),
Ceiling,
Some((1.3333334, -2, Greater)),
);
test(
Rational::from_signeds(-1, 3),
Up,
Some((1.3333334, -2, Greater)),
);
test(
Rational::from_signeds(-1, 3),
Nearest,
Some((1.3333334, -2, Greater)),
);
test(Rational::from_signeds(-1, 3), Exact, None);
Sourcepub fn sci_mantissa_and_exponent_round_ref<T: PrimitiveFloat>(
&self,
rm: RoundingMode,
) -> Option<(T, i64, Ordering)>
pub fn sci_mantissa_and_exponent_round_ref<T: PrimitiveFloat>( &self, rm: RoundingMode, ) -> Option<(T, i64, Ordering)>
Returns a Rational
’s scientific mantissa and exponent, taking the Rational
by
reference. An Ordering
is also returned, indicating whether the returned mantissa and
exponent represent a value that is less than, equal to, or greater than the original value.
When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is
a rational number with $1 \leq m_s < 2$. We represent the rational mantissa as a float. The
conversion might not be exact, so we round to the nearest float using the provided rounding
mode. If the rounding mode is Exact
but the conversion is not exact, None
is returned.
$$
f(x, r) \approx \left (\frac{x}{2^{\lfloor \log_2 x \rfloor}},
\lfloor \log_2 x \rfloor\right ).
$$
§Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
§Examples
use malachite_base::num::float::NiceFloat;
use malachite_base::rounding_modes::RoundingMode::{self, *};
use malachite_q::Rational;
use std::cmp::Ordering::{self, *};
let test = |n: Rational, rm: RoundingMode, out: Option<(f32, i64, Ordering)>| {
assert_eq!(
n.sci_mantissa_and_exponent_round_ref(rm)
.map(|(m, e, o)| (NiceFloat(m), e, o)),
out.map(|(m, e, o)| (NiceFloat(m), e, o))
);
};
test(Rational::from(3u32), Down, Some((1.5, 1, Equal)));
test(Rational::from(3u32), Ceiling, Some((1.5, 1, Equal)));
test(Rational::from(3u32), Up, Some((1.5, 1, Equal)));
test(Rational::from(3u32), Nearest, Some((1.5, 1, Equal)));
test(Rational::from(3u32), Exact, Some((1.5, 1, Equal)));
test(
Rational::from_signeds(1, 3),
Floor,
Some((1.3333333, -2, Less)),
);
test(
Rational::from_signeds(1, 3),
Down,
Some((1.3333333, -2, Less)),
);
test(
Rational::from_signeds(1, 3),
Ceiling,
Some((1.3333334, -2, Greater)),
);
test(
Rational::from_signeds(1, 3),
Up,
Some((1.3333334, -2, Greater)),
);
test(
Rational::from_signeds(1, 3),
Nearest,
Some((1.3333334, -2, Greater)),
);
test(Rational::from_signeds(1, 3), Exact, None);
Source§impl 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
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, and then returns
whatever the closure returns.
After the closure executes, this function reduces the Rational
.
§Panics
Panics if the closure sets the denominator to zero.
§Examples
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
let mut q = Rational::from_signeds(22, 7);
let ret = q.mutate_denominator(|x| {
*x -= Natural::ONE;
true
});
assert_eq!(q.to_string(), "11/3");
assert_eq!(ret, true);
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, and then
returns whatever the closure returns.
After the closure executes, this function reduces the Rational
.
§Panics
Panics if the closure sets the denominator to zero.
§Examples
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
let mut q = Rational::from_signeds(22, 7);
let ret = q.mutate_numerator_and_denominator(|x, y| {
*x -= Natural::ONE;
*y -= Natural::ONE;
true
});
assert_eq!(q.to_string(), "7/2");
assert_eq!(ret, true);
Source§impl 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 $\varepsilon = b^{-s}/2$ and finds the simplest Rational
in the closed interval $[q - \varepsilon, q + \varepsilon]$. The simplest Rational
is
the one with minimal denominator; if there are multiple such 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
use malachite_base::num::conversion::string::options::FromSciStringOptions;
use malachite_q::Rational;
let mut options = FromSciStringOptions::default();
options.set_base(16);
assert_eq!(
Rational::from_sci_string_simplest_with_options("ff", options).unwrap(),
255
);
assert_eq!(
Rational::from_sci_string_simplest_with_options("ffE+5", options).unwrap(),
267386880
);
// 1/4105 is 0.000ff705..._16
assert_eq!(
Rational::from_sci_string_simplest_with_options("ffE-5", options)
.unwrap()
.to_string(),
"1/4105"
);
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 $\varepsilon = 10^{-s}/2$ and finds
the simplest Rational
in the closed interval $[q - \varepsilon, q + \varepsilon]$. The
simplest Rational
is the one with minimal denominator; if there are multiple such
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"
);
Source§impl 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)
);
Source§impl 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
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
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
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§
Source§impl Abs for &Rational
impl Abs for &Rational
Source§fn abs(self) -> Rational
fn abs(self) -> Rational
Takes the absolute value of a Rational
, taking the Rational
by reference.
$$ f(x) = |x|. $$
§Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
§Examples
use malachite_base::num::arithmetic::traits::Abs;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!((&Rational::ZERO).abs(), 0);
assert_eq!((&Rational::from_signeds(22, 7)).abs().to_string(), "22/7");
assert_eq!((&Rational::from_signeds(-22, 7)).abs().to_string(), "22/7");
type Output = Rational
Source§impl Abs for Rational
impl Abs for Rational
Source§fn 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
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
Source§impl AbsAssign for Rational
impl AbsAssign for Rational
Source§fn abs_assign(&mut self)
fn abs_assign(&mut self)
Replaces a Rational
with its absolute value.
$$ x \gets |x|. $$
§Examples
use malachite_base::num::arithmetic::traits::AbsAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
let mut x = Rational::ZERO;
x.abs_assign();
assert_eq!(x, 0);
let mut x = Rational::from_signeds(22, 7);
x.abs_assign();
assert_eq!(x.to_string(), "22/7");
let mut x = Rational::from_signeds(-22, 7);
x.abs_assign();
assert_eq!(x.to_string(), "22/7");
Source§impl AbsDiff<&Rational> for &Rational
impl AbsDiff<&Rational> for &Rational
Source§fn abs_diff(self, other: &Rational) -> Rational
fn abs_diff(self, other: &Rational) -> Rational
Computes the absolute value of the difference between 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
use malachite_base::num::arithmetic::traits::AbsDiff;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
assert_eq!(Rational::ONE_HALF.abs_diff(Rational::ONE_HALF), 0);
assert_eq!(
(&Rational::from_signeds(22, 7))
.abs_diff(&Rational::from_signeds(99, 100))
.to_string(),
"1507/700"
);
assert_eq!(
(&Rational::from_signeds(22, 7))
.abs_diff(&Rational::from_signeds(99, 100))
.to_string(),
"1507/700"
);
type Output = Rational
Source§impl AbsDiff<&Rational> for Rational
impl AbsDiff<&Rational> for Rational
Source§fn abs_diff(self, other: &Rational) -> Rational
fn abs_diff(self, other: &Rational) -> Rational
Computes the absolute value of the difference between two Rational
s, taking the first by
value and the second by reference.
$$ f(x, y) = |x - y|. $$
§Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits())
.
§Examples
use malachite_base::num::arithmetic::traits::AbsDiff;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
assert_eq!(Rational::ONE_HALF.abs_diff(&Rational::ONE_HALF), 0);
assert_eq!(
Rational::from_signeds(22, 7)
.abs_diff(&Rational::from_signeds(99, 100))
.to_string(),
"1507/700"
);
assert_eq!(
Rational::from_signeds(22, 7)
.abs_diff(&Rational::from_signeds(99, 100))
.to_string(),
"1507/700"
);
type Output = Rational
Source§impl AbsDiff<Rational> for &Rational
impl AbsDiff<Rational> for &Rational
Source§fn abs_diff(self, other: Rational) -> Rational
fn abs_diff(self, other: Rational) -> Rational
Computes the absolute value of the difference between 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
use malachite_base::num::arithmetic::traits::AbsDiff;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
assert_eq!(Rational::ONE_HALF.abs_diff(Rational::ONE_HALF), 0);
assert_eq!(
(&Rational::from_signeds(22, 7))
.abs_diff(Rational::from_signeds(99, 100))
.to_string(),
"1507/700"
);
assert_eq!(
(&Rational::from_signeds(22, 7))
.abs_diff(Rational::from_signeds(99, 100))
.to_string(),
"1507/700"
);
type Output = Rational
Source§impl AbsDiff for Rational
impl AbsDiff for Rational
Source§fn abs_diff(self, other: Rational) -> Rational
fn abs_diff(self, other: Rational) -> Rational
Computes the absolute value of the difference between 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
use malachite_base::num::arithmetic::traits::AbsDiff;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
assert_eq!(Rational::ONE_HALF.abs_diff(Rational::ONE_HALF), 0);
assert_eq!(
Rational::from_signeds(22, 7)
.abs_diff(Rational::from_signeds(99, 100))
.to_string(),
"1507/700"
);
assert_eq!(
Rational::from_signeds(22, 7)
.abs_diff(Rational::from_signeds(99, 100))
.to_string(),
"1507/700"
);
type Output = Rational
Source§impl<'a> AbsDiffAssign<&'a Rational> for Rational
impl<'a> AbsDiffAssign<&'a Rational> for Rational
Source§fn abs_diff_assign(&mut self, other: &'a Rational)
fn abs_diff_assign(&mut self, other: &'a Rational)
Subtracts a Rational
by another Rational
in place and takes the absolute value,
taking the Rational
on the right-hand side by reference.
$$ x \gets |x - y|. $$
§Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits())
.
§Panics
Panics if other
is greater than self
.
§Examples
use malachite_base::num::arithmetic::traits::AbsDiffAssign;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
let mut x = Rational::ONE_HALF;
x.abs_diff_assign(&Rational::ONE_HALF);
assert_eq!(x, 0);
let mut x = Rational::from_signeds(22, 7);
x.abs_diff_assign(&Rational::from_signeds(99, 100));
assert_eq!(x.to_string(), "1507/700");
let mut x = Rational::from_signeds(99, 100);
x.abs_diff_assign(&Rational::from_signeds(22, 7));
assert_eq!(x.to_string(), "1507/700");
Source§impl AbsDiffAssign for Rational
impl AbsDiffAssign for Rational
Source§fn abs_diff_assign(&mut self, other: Rational)
fn abs_diff_assign(&mut self, other: Rational)
Subtracts a Rational
by another Rational
in place and takes the absolute value,
taking the Rational
on the right-hand side by value.
$$ x \gets |x - y|. $$
§Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits())
.
§Panics
Panics if other
is greater than self
.
§Examples
use malachite_base::num::arithmetic::traits::AbsDiffAssign;
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
let mut x = Rational::ONE_HALF;
x.abs_diff_assign(Rational::ONE_HALF);
assert_eq!(x, 0);
let mut x = Rational::from_signeds(22, 7);
x.abs_diff_assign(Rational::from_signeds(99, 100));
assert_eq!(x.to_string(), "1507/700");
let mut x = Rational::from_signeds(99, 100);
x.abs_diff_assign(Rational::from_signeds(22, 7));
assert_eq!(x.to_string(), "1507/700");
Source§impl Add<&Rational> for &Rational
impl Add<&Rational> for &Rational
Source§fn add(self, other: &Rational) -> Rational
fn add(self, other: &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
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"
);
Source§impl Add<&Rational> for Rational
impl Add<&Rational> for Rational
Source§fn add(self, other: &Rational) -> Rational
fn add(self, other: &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
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"
);
Source§impl Add<Rational> for &Rational
impl Add<Rational> for &Rational
Source§fn 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
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"
);
Source§impl Add for Rational
impl Add for Rational
Source§fn 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
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"
);
Source§impl AddAssign<&Rational> for Rational
impl AddAssign<&Rational> for Rational
Source§fn 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 reference.
$$ x \gets x + y. $$
§Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits())
.
§Examples
use malachite_base::num::basic::traits::OneHalf;
use malachite_q::Rational;
let mut x = Rational::ONE_HALF;
x += &Rational::ONE_HALF;
assert_eq!(x, 1);
let mut x = Rational::from_signeds(22, 7);
x += &Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "2893/700");
Source§impl AddAssign for Rational
impl AddAssign for Rational
Source§fn 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
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");
Source§impl Approximate for &Rational
impl Approximate for &Rational
Source§fn 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.
Source§impl Approximate for Rational
impl Approximate for Rational
Source§fn 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.
Source§impl ApproximateAssign for Rational
impl ApproximateAssign for Rational
Source§fn 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");
Source§impl Ceiling for &Rational
impl Ceiling for &Rational
Source§fn 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
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
Source§impl Ceiling for Rational
impl Ceiling for Rational
Source§fn 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
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
Source§impl CeilingAssign for Rational
impl CeilingAssign for Rational
Source§fn 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
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);
Source§impl CeilingLogBase<&Rational> for &Rational
impl CeilingLogBase<&Rational> for &Rational
Source§fn 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
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
Source§impl CeilingLogBase2 for &Rational
impl CeilingLogBase2 for &Rational
Source§fn 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
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
Source§impl CeilingLogBasePowerOf2<i64> for &Rational
impl CeilingLogBasePowerOf2<i64> for &Rational
Source§fn 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
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
Source§impl CheckedDiv<&Rational> for &Rational
impl CheckedDiv<&Rational> for &Rational
Source§fn checked_div(self, other: &Rational) -> Option<Rational>
fn checked_div(self, other: &Rational) -> Option<Rational>
Divides a Rational
by another Rational
, taking both by reference. Returns None
when the second Rational
is zero, Some
otherwise.
$$ f(x, y) = \begin{cases} \operatorname{Some}\left ( \frac{x}{y} \right ) & \text{if} \quad y \neq 0 \\ \text{None} & \text{otherwise} \end{cases} $$
§Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits())
.
§Examples
use malachite_base::num::arithmetic::traits::CheckedDiv;
use malachite_base::num::basic::traits::{Two, Zero};
use malachite_q::Rational;
assert_eq!((&Rational::TWO).checked_div(&Rational::TWO).unwrap(), 1);
assert_eq!((&Rational::TWO).checked_div(&Rational::ZERO), None);
assert_eq!(
(&Rational::from_signeds(22, 7))
.checked_div(&Rational::from_signeds(99, 100))
.unwrap()
.to_string(),
"200/63"
);
type Output = Rational
Source§impl CheckedDiv<&Rational> for Rational
impl CheckedDiv<&Rational> for Rational
Source§fn checked_div(self, other: &Rational) -> Option<Rational>
fn checked_div(self, other: &Rational) -> Option<Rational>
Divides a Rational
by another Rational
, taking the first by value and the second by
reference. Returns None
when the second Rational
is zero, Some
otherwise.
$$ f(x, y) = \begin{cases} \operatorname{Some}\left ( \frac{x}{y} \right ) & \text{if} \quad y \neq 0 \\ \text{None} & \text{otherwise} \end{cases} $$
§Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits())
.
§Examples
use malachite_base::num::arithmetic::traits::CheckedDiv;
use malachite_base::num::basic::traits::{Two, Zero};
use malachite_q::Rational;
assert_eq!(Rational::TWO.checked_div(&Rational::TWO).unwrap(), 1);
assert_eq!(Rational::TWO.checked_div(&Rational::ZERO), None);
assert_eq!(
(Rational::from_signeds(22, 7).checked_div(&Rational::from_signeds(99, 100)))
.unwrap()
.to_string(),
"200/63"
);
type Output = Rational
Source§impl CheckedDiv<Rational> for &Rational
impl CheckedDiv<Rational> for &Rational
Source§fn checked_div(self, other: Rational) -> Option<Rational>
fn checked_div(self, other: Rational) -> Option<Rational>
Divides a Rational
by another Rational
, taking the first by reference and the second
by value. Returns None
when the second Rational
is zero, Some
otherwise.
$$ f(x, y) = \begin{cases} \operatorname{Some}\left ( \frac{x}{y} \right ) & \text{if} \quad y \neq 0 \\ \text{None} & \text{otherwise} \end{cases} $$
§Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits())
.
§Examples
use malachite_base::num::arithmetic::traits::CheckedDiv;
use malachite_base::num::basic::traits::{Two, Zero};
use malachite_q::Rational;
assert_eq!((&Rational::TWO).checked_div(Rational::TWO).unwrap(), 1);
assert_eq!((&Rational::TWO).checked_div(Rational::ZERO), None);
assert_eq!(
(&Rational::from_signeds(22, 7))
.checked_div(Rational::from_signeds(99, 100))
.unwrap()
.to_string(),
"200/63"
);
type Output = Rational
Source§impl CheckedDiv for Rational
impl CheckedDiv for Rational
Source§fn checked_div(self, other: Rational) -> Option<Rational>
fn checked_div(self, other: Rational) -> Option<Rational>
Divides a Rational
by another Rational
, taking both by value. Returns None
when
the second Rational
is zero, Some
otherwise.
$$ f(x, y) = \begin{cases} \operatorname{Some}\left ( \frac{x}{y} \right ) & \text{if} \quad y \neq 0 \\ \text{None} & \text{otherwise} \end{cases} $$
§Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits())
.
§Examples
use malachite_base::num::arithmetic::traits::CheckedDiv;
use malachite_base::num::basic::traits::{Two, Zero};
use malachite_q::Rational;
assert_eq!(Rational::TWO.checked_div(Rational::TWO).unwrap(), 1);
assert_eq!(Rational::TWO.checked_div(Rational::ZERO), None);
assert_eq!(
(Rational::from_signeds(22, 7).checked_div(Rational::from_signeds(99, 100)))
.unwrap()
.to_string(),
"200/63"
);
type Output = Rational
Source§impl CheckedLogBase<&Rational> for &Rational
impl CheckedLogBase<&Rational> for &Rational
Source§fn 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
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
Source§impl CheckedLogBase2 for &Rational
impl CheckedLogBase2 for &Rational
Source§fn 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
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
Source§impl CheckedLogBasePowerOf2<i64> for &Rational
impl CheckedLogBasePowerOf2<i64> for &Rational
Source§fn 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
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
Source§impl CheckedRoot<i64> for &Rational
impl CheckedRoot<i64> for &Rational
Source§fn 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
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
Source§impl CheckedRoot<i64> for Rational
impl CheckedRoot<i64> for Rational
Source§fn 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
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
Source§impl CheckedRoot<u64> for &Rational
impl CheckedRoot<u64> for &Rational
Source§fn 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
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
Source§impl CheckedRoot<u64> for Rational
impl CheckedRoot<u64> for Rational
Source§fn 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
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
Source§impl CheckedSqrt for &Rational
impl CheckedSqrt for &Rational
Source§fn 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
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
Source§impl CheckedSqrt for Rational
impl CheckedSqrt for Rational
Source§fn 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
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
Source§impl ContinuedFraction for &Rational
impl ContinuedFraction for &Rational
Source§fn 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
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
Source§impl ContinuedFraction for Rational
impl ContinuedFraction for Rational
Source§fn 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
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
Source§impl Convergents for &Rational
impl Convergents for &Rational
Source§fn convergents(self) -> RationalConvergents ⓘ
fn convergents(self) -> RationalConvergents ⓘ
Returns the convergents of a Rational
, taking the Rational
by reference.
The convergents of a number are the sequence of rational numbers whose continued fractions are the prefixes of the number’s continued fraction. The first convergent is the floor of the number. The sequence of convergents is finite iff the number is rational, in which case the last convergent is the number itself. Each convergent is closer to the number than the previous convergent is. The even-indexed convergents are less than or equal to the number, and the odd-indexed ones are greater than or equal to it.
$f(x) = ([a_0; a_1, a_2, \ldots, a_i])_{i=0}^{n}$, where $x = [a_0; a_1, a_2, \ldots, a_n]$ and $a_n \neq 1$.
The output length is $O(n)$, where $n$ is self.significant_bits()
.
§Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
§Examples
use itertools::Itertools;
use malachite_base::strings::ToDebugString;
use malachite_q::conversion::traits::Convergents;
use malachite_q::Rational;
assert_eq!(
(&Rational::from_signeds(2, 3))
.convergents()
.collect_vec()
.to_debug_string(),
"[0, 1, 2/3]"
);
assert_eq!(
(&Rational::from_signeds(355, 113))
.convergents()
.collect_vec()
.to_debug_string(),
"[3, 22/7, 355/113]",
);
type C = RationalConvergents
Source§impl Convergents for Rational
impl Convergents for Rational
Source§fn convergents(self) -> RationalConvergents ⓘ
fn convergents(self) -> RationalConvergents ⓘ
Returns the convergents of a Rational
, taking the Rational
by value.
The convergents of a number are the sequence of rational numbers whose continued fractions are the prefixes of the number’s continued fraction. The first convergent is the floor of the number. The sequence of convergents is finite iff the number is rational, in which case the last convergent is the number itself. Each convergent is closer to the number than the previous convergent is. The even-indexed convergents are less than or equal to the number, and the odd-indexed ones are greater than or equal to it.
$f(x) = ([a_0; a_1, a_2, \ldots, a_i])_{i=0}^{n}$, where $x = [a_0; a_1, a_2, \ldots, a_n]$ and $a_n \neq 1$.
The output length is $O(n)$, where $n$ is self.significant_bits()
.
§Worst-case complexity per iteration
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
§Examples
use itertools::Itertools;
use malachite_base::strings::ToDebugString;
use malachite_q::conversion::traits::Convergents;
use malachite_q::Rational;
assert_eq!(
Rational::from_signeds(2, 3)
.convergents()
.collect_vec()
.to_debug_string(),
"[0, 1, 2/3]"
);
assert_eq!(
Rational::from_signeds(355, 113)
.convergents()
.collect_vec()
.to_debug_string(),
"[3, 22/7, 355/113]",
);
type C = RationalConvergents
Source§impl ConvertibleFrom<&Rational> for Integer
impl ConvertibleFrom<&Rational> for Integer
Source§fn 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
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
);
Source§impl ConvertibleFrom<&Rational> for Natural
impl ConvertibleFrom<&Rational> for Natural
Source§fn 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
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
);
Source§impl ConvertibleFrom<&Rational> for f32
impl ConvertibleFrom<&Rational> for f32
Source§fn convertible_from(value: &Rational) -> bool
fn convertible_from(value: &Rational) -> bool
Source§impl ConvertibleFrom<&Rational> for f64
impl ConvertibleFrom<&Rational> for f64
Source§fn convertible_from(value: &Rational) -> bool
fn convertible_from(value: &Rational) -> bool
Source§impl<'a> ConvertibleFrom<&'a Rational> for i128
impl<'a> ConvertibleFrom<&'a Rational> for i128
Source§impl<'a> ConvertibleFrom<&'a Rational> for i16
impl<'a> ConvertibleFrom<&'a Rational> for i16
Source§impl<'a> ConvertibleFrom<&'a Rational> for i32
impl<'a> ConvertibleFrom<&'a Rational> for i32
Source§impl<'a> ConvertibleFrom<&'a Rational> for i64
impl<'a> ConvertibleFrom<&'a Rational> for i64
Source§impl<'a> ConvertibleFrom<&'a Rational> for i8
impl<'a> ConvertibleFrom<&'a Rational> for i8
Source§impl<'a> ConvertibleFrom<&'a Rational> for isize
impl<'a> ConvertibleFrom<&'a Rational> for isize
Source§impl<'a> ConvertibleFrom<&'a Rational> for u128
impl<'a> ConvertibleFrom<&'a Rational> for u128
Source§impl<'a> ConvertibleFrom<&'a Rational> for u16
impl<'a> ConvertibleFrom<&'a Rational> for u16
Source§impl<'a> ConvertibleFrom<&'a Rational> for u32
impl<'a> ConvertibleFrom<&'a Rational> for u32
Source§impl<'a> ConvertibleFrom<&'a Rational> for u64
impl<'a> ConvertibleFrom<&'a Rational> for u64
Source§impl<'a> ConvertibleFrom<&'a Rational> for u8
impl<'a> ConvertibleFrom<&'a Rational> for u8
Source§impl<'a> ConvertibleFrom<&'a Rational> for usize
impl<'a> ConvertibleFrom<&'a Rational> for usize
Source§impl ConvertibleFrom<Rational> for f32
impl ConvertibleFrom<Rational> for f32
Source§fn convertible_from(value: Rational) -> bool
fn convertible_from(value: Rational) -> bool
Source§impl ConvertibleFrom<Rational> for f64
impl ConvertibleFrom<Rational> for f64
Source§fn convertible_from(value: Rational) -> bool
fn convertible_from(value: Rational) -> bool
Source§impl ConvertibleFrom<f32> for Rational
impl ConvertibleFrom<f32> for Rational
Source§impl ConvertibleFrom<f64> for Rational
impl ConvertibleFrom<f64> for Rational
Source§impl Debug for Rational
impl Debug for Rational
Source§fn 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
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");
Source§impl DenominatorsInClosedInterval for Rational
impl DenominatorsInClosedInterval for Rational
Source§fn denominators_in_closed_interval(
a: Rational,
b: Rational,
) -> DenominatorsInClosedRationalInterval ⓘ
fn denominators_in_closed_interval( a: Rational, b: Rational, ) -> DenominatorsInClosedRationalInterval ⓘ
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$.
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
Source§impl Display for Rational
impl Display for Rational
Source§fn 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
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");
Source§impl Div<&Rational> for &Rational
impl Div<&Rational> for &Rational
Source§fn div(self, other: &Rational) -> Rational
fn div(self, other: &Rational) -> Rational
Divides a Rational
by another Rational
, taking both by reference.
$$ f(x, y) = \frac{x}{y}. $$
§Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits())
.
§Panics
Panics if the second Rational
is zero.
§Examples
use malachite_base::num::basic::traits::Two;
use malachite_q::Rational;
assert_eq!(&Rational::TWO / &Rational::TWO, 1);
assert_eq!(
(&Rational::from_signeds(22, 7) / &Rational::from_signeds(99, 100)).to_string(),
"200/63"
);
Source§impl Div<&Rational> for Rational
impl Div<&Rational> for Rational
Source§fn div(self, other: &Rational) -> Rational
fn div(self, other: &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
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"
);
Source§impl Div<Rational> for &Rational
impl Div<Rational> for &Rational
Source§fn 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
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"
);
Source§impl Div for Rational
impl Div for Rational
Source§fn 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
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"
);
Source§impl DivAssign<&Rational> for Rational
impl DivAssign<&Rational> for Rational
Source§fn 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 reference.
$$ x \gets \frac{x}{y}. $$
§Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits())
.
§Panics
Panics if the second Rational
is zero.
§Examples
use malachite_base::num::basic::traits::Two;
use malachite_q::Rational;
let mut x = Rational::TWO;
x /= &Rational::TWO;
assert_eq!(x, 1);
let mut x = Rational::from_signeds(22, 7);
x /= &Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "200/63");
Source§impl DivAssign for Rational
impl DivAssign for Rational
Source§fn 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
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");
Source§impl EqAbs<Integer> for Rational
impl EqAbs<Integer> for Rational
Source§fn eq_abs(&self, other: &Integer) -> bool
fn eq_abs(&self, other: &Integer) -> bool
Determines whether the absolute values of a Rational
and an Integer
are equal.
§Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits())
.
§Examples
use malachite_base::num::comparison::traits::EqAbs;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
assert_eq!(Rational::from(-123).eq_abs(&Integer::from(122)), false);
assert_eq!(Rational::from(-123).eq_abs(&Integer::from(124)), false);
assert_eq!(
Rational::from_signeds(22, 7).eq_abs(&Integer::from(123)),
false
);
assert_eq!(
Rational::from_signeds(-22, 7).eq_abs(&Integer::from(123)),
false
);
assert_eq!(Rational::from(123).eq_abs(&Integer::from(123)), true);
assert_eq!(Rational::from(-123).eq_abs(&Integer::from(123)), true);
assert_eq!(
Rational::from_signeds(22, 7).eq_abs(&Integer::from(123)),
false
);
assert_eq!(
Rational::from_signeds(22, 7).eq_abs(&Integer::from(123)),
false
);
assert_eq!(Rational::from(-123).eq_abs(&Integer::from(-122)), false);
assert_eq!(Rational::from(-123).eq_abs(&Integer::from(-124)), false);
assert_eq!(
Rational::from_signeds(22, 7).eq_abs(&Integer::from(-123)),
false
);
assert_eq!(
Rational::from_signeds(-22, 7).eq_abs(&Integer::from(1 - 23)),
false
);
assert_eq!(Rational::from(123).eq_abs(&Integer::from(-123)), true);
assert_eq!(Rational::from(-123).eq_abs(&Integer::from(-123)), true);
assert_eq!(
Rational::from_signeds(22, 7).eq_abs(&Integer::from(-123)),
false
);
assert_eq!(
Rational::from_signeds(22, 7).eq_abs(&Integer::from(-123)),
false
);
Source§impl EqAbs<Natural> for Rational
impl EqAbs<Natural> for Rational
Source§fn eq_abs(&self, other: &Natural) -> bool
fn eq_abs(&self, other: &Natural) -> bool
Determines whether the absolute values of a Rational
and a Natural
are equal.
§Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits())
.
§Examples
use malachite_base::num::comparison::traits::EqAbs;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert_eq!(Rational::from(-123).eq_abs(&Natural::from(122u32)), false);
assert_eq!(Rational::from(-123).eq_abs(&Natural::from(124u32)), false);
assert_eq!(
Rational::from_signeds(22, 7).eq_abs(&Natural::from(123u32)),
false
);
assert_eq!(
Rational::from_signeds(-22, 7).eq_abs(&Natural::from(123u32)),
false
);
assert_eq!(Rational::from(123).eq_abs(&Natural::from(123u32)), true);
assert_eq!(Rational::from(-123).eq_abs(&Natural::from(123u32)), true);
assert_eq!(
Rational::from_signeds(22, 7).eq_abs(&Natural::from(123u32)),
false
);
assert_eq!(
Rational::from_signeds(22, 7).eq_abs(&Natural::from(123u32)),
false
);
Source§impl EqAbs<Rational> for Integer
impl EqAbs<Rational> for Integer
Source§fn eq_abs(&self, other: &Rational) -> bool
fn eq_abs(&self, other: &Rational) -> bool
Determines whether the absolute values of a Rational
and an Integer
are equal.
§Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits())
.
§Examples
use malachite_base::num::comparison::traits::EqAbs;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
assert_eq!(Integer::from(122).eq_abs(&Rational::from(-123)), false);
assert_eq!(Integer::from(124).eq_abs(&Rational::from(-123)), false);
assert_eq!(
Integer::from(124).eq_abs(&Rational::from_signeds(22, 7)),
false
);
assert_eq!(
Integer::from(124).eq_abs(&Rational::from_signeds(-22, 7)),
false
);
assert_eq!(Integer::from(123).eq_abs(&Rational::from(123)), true);
assert_eq!(Integer::from(123).eq_abs(&Rational::from(-123)), true);
assert_eq!(
Integer::from(123).eq_abs(&Rational::from_signeds(22, 7)),
false
);
assert_eq!(
Integer::from(123).eq_abs(&Rational::from_signeds(-22, 7)),
false
);
assert_eq!(Integer::from(-122).eq_abs(&Rational::from(-123)), false);
assert_eq!(Integer::from(-124).eq_abs(&Rational::from(-123)), false);
assert_eq!(
Integer::from(-124).eq_abs(&Rational::from_signeds(22, 7)),
false
);
assert_eq!(
Integer::from(-124).eq_abs(&Rational::from_signeds(-22, 7)),
false
);
assert_eq!(Integer::from(-123).eq_abs(&Rational::from(123)), true);
assert_eq!(Integer::from(-123).eq_abs(&Rational::from(-123)), true);
assert_eq!(
Integer::from(-123).eq_abs(&Rational::from_signeds(22, 7)),
false
);
assert_eq!(
Integer::from(-123).eq_abs(&Rational::from_signeds(-22, 7)),
false
);
Source§impl EqAbs<Rational> for Natural
impl EqAbs<Rational> for Natural
Source§fn eq_abs(&self, other: &Rational) -> bool
fn eq_abs(&self, other: &Rational) -> bool
Determines whether the absolute values of a Rational
and a Natural
are equal.
§Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits())
.
§Examples
use malachite_base::num::comparison::traits::EqAbs;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert_eq!(Natural::from(122u32).eq_abs(&Rational::from(-123)), false);
assert_eq!(Natural::from(124u32).eq_abs(&Rational::from(-123)), false);
assert_eq!(
Natural::from(124u32).eq_abs(&Rational::from_signeds(22, 7)),
false
);
assert_eq!(
Natural::from(124u32).eq_abs(&Rational::from_signeds(-22, 7)),
false
);
assert_eq!(Natural::from(123u32).eq_abs(&Rational::from(123)), true);
assert_eq!(Natural::from(123u32).eq_abs(&Rational::from(-123)), true);
assert_eq!(
Natural::from(123u32).eq_abs(&Rational::from_signeds(22, 7)),
false
);
assert_eq!(
Natural::from(123u32).eq_abs(&Rational::from_signeds(-22, 7)),
false
);
Source§impl EqAbs for Rational
impl EqAbs for Rational
Source§fn eq_abs(&self, other: &Rational) -> bool
fn eq_abs(&self, other: &Rational) -> bool
Determines whether the absolute values of two Rational
s are equal.
§Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits())
.
§Examples
use malachite_base::num::comparison::traits::EqAbs;
use malachite_q::Rational;
assert_eq!(
Rational::from_signeds(-22, 7).eq_abs(&Rational::from_signeds(-23, 7)),
false
);
assert_eq!(
Rational::from_signeds(-22, 7).eq_abs(&Rational::from_signeds(-24, 7)),
false
);
assert_eq!(
Rational::from_signeds(22, 7).eq_abs(&Rational::from_signeds(22, 7)),
true
);
assert_eq!(
Rational::from_signeds(22, 7).eq_abs(&Rational::from_signeds(-22, 7)),
true
);
assert_eq!(
Rational::from_signeds(-22, 7).eq_abs(&Rational::from_signeds(22, 7)),
true
);
assert_eq!(
Rational::from_signeds(-22, 7).eq_abs(&Rational::from_signeds(-22, 7)),
true
);
Source§impl Floor for &Rational
impl Floor for &Rational
Source§fn 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
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
Source§impl Floor for Rational
impl Floor for Rational
Source§fn 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
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
Source§impl FloorAssign for Rational
impl FloorAssign for Rational
Source§fn 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
use malachite_base::num::arithmetic::traits::FloorAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
let mut x = Rational::ZERO;
x.floor_assign();
assert_eq!(x, 0);
let mut x = Rational::from_signeds(22, 7);
x.floor_assign();
assert_eq!(x, 3);
let mut x = Rational::from_signeds(-22, 7);
x.floor_assign();
assert_eq!(x, -4);
Source§impl FloorLogBase<&Rational> for &Rational
impl FloorLogBase<&Rational> for &Rational
Source§fn 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
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
Source§impl FloorLogBase2 for &Rational
impl FloorLogBase2 for &Rational
Source§fn 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
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
Source§impl FloorLogBasePowerOf2<i64> for &Rational
impl FloorLogBasePowerOf2<i64> for &Rational
Source§fn 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
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
Source§impl From<&Integer> for Rational
impl From<&Integer> for Rational
Source§fn from(value: &Integer) -> Rational
fn from(value: &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
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);
Source§impl From<&Natural> for Rational
impl From<&Natural> for Rational
Source§fn from(value: &Natural) -> Rational
fn from(value: &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
use malachite_nz::natural::Natural;
use malachite_q::Rational;
assert_eq!(Rational::from(&Natural::from(123u32)), 123);
Source§impl From<Integer> for Rational
impl From<Integer> for Rational
Source§fn 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
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);
Source§impl From<bool> for Rational
impl From<bool> for Rational
Source§fn from(b: bool) -> Rational
fn from(b: bool) -> Rational
Converts a bool
to 0 or 1.
This function is known as the Iverson bracket.
$$ f(P) = [P] = \begin{cases} 1 & \text{if} \quad P, \\ 0 & \text{otherwise}. \end{cases} $$
§Worst-case complexity
Constant time and additional memory.
§Examples
use malachite_q::Rational;
assert_eq!(Rational::from(false), 0);
assert_eq!(Rational::from(true), 1);
Source§impl FromSciString for Rational
impl FromSciString for Rational
Source§fn 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
use malachite_base::num::conversion::string::options::FromSciStringOptions;
use malachite_base::num::conversion::traits::FromSciString;
use malachite_q::Rational;
assert_eq!(Rational::from_sci_string("123").unwrap(), 123);
assert_eq!(
Rational::from_sci_string("0.1").unwrap().to_string(),
"1/10"
);
assert_eq!(
Rational::from_sci_string("0.10").unwrap().to_string(),
"1/10"
);
assert_eq!(
Rational::from_sci_string("0.333").unwrap().to_string(),
"333/1000"
);
assert_eq!(Rational::from_sci_string("1.2e5").unwrap(), 120000);
assert_eq!(
Rational::from_sci_string("1.2e-5").unwrap().to_string(),
"3/250000"
);
let mut options = FromSciStringOptions::default();
options.set_base(16);
assert_eq!(
Rational::from_sci_string_with_options("ff", options).unwrap(),
255
);
assert_eq!(
Rational::from_sci_string_with_options("ffE+5", options).unwrap(),
267386880
);
assert_eq!(
Rational::from_sci_string_with_options("ffE-5", options)
.unwrap()
.to_string(),
"255/1048576"
);
Source§fn 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
.Source§impl FromStr for Rational
impl FromStr for Rational
Source§fn 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());
Source§impl IsInteger for &Rational
impl IsInteger for &Rational
Source§fn 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
use malachite_base::num::basic::traits::{One, Zero};
use malachite_base::num::conversion::traits::IsInteger;
use malachite_q::Rational;
assert_eq!(Rational::ZERO.is_integer(), true);
assert_eq!(Rational::ONE.is_integer(), true);
assert_eq!(Rational::from(100).is_integer(), true);
assert_eq!(Rational::from(-100).is_integer(), true);
assert_eq!(Rational::from_signeds(22, 7).is_integer(), false);
assert_eq!(Rational::from_signeds(-22, 7).is_integer(), false);
Source§impl IsPowerOf2 for Rational
impl IsPowerOf2 for Rational
Source§fn 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
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);
Source§impl Mul<&Rational> for &Rational
impl Mul<&Rational> for &Rational
Source§fn mul(self, other: &Rational) -> Rational
fn mul(self, other: &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
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"
);
Source§impl Mul<&Rational> for Rational
impl Mul<&Rational> for Rational
Source§fn mul(self, other: &Rational) -> Rational
fn mul(self, other: &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
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"
);
Source§impl Mul<Rational> for &Rational
impl Mul<Rational> for &Rational
Source§fn 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
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"
);
Source§impl Mul for Rational
impl Mul for Rational
Source§fn 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
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"
);
Source§impl MulAssign<&Rational> for Rational
impl MulAssign<&Rational> for Rational
Source§fn 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 reference.
$$ x \gets xy. $$
§Worst-case complexity
$T(n) = O(n (\log n)^3 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits())
.
§Examples
use malachite_base::num::basic::traits::{OneHalf, Two};
use malachite_q::Rational;
let mut x = Rational::ONE_HALF;
x *= &Rational::TWO;
assert_eq!(x, 1);
let mut x = Rational::from_signeds(22, 7);
x *= &Rational::from_signeds(99, 100);
assert_eq!(x.to_string(), "1089/350");
Source§impl MulAssign for Rational
impl MulAssign for Rational
Source§fn 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
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");
Source§impl Neg for &Rational
impl Neg for &Rational
Source§fn 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
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");
Source§impl Neg for Rational
impl Neg for Rational
Source§fn 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
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");
Source§impl NegAssign for Rational
impl NegAssign for Rational
Source§fn 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
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");
Source§impl NegativeOne for Rational
The constant -1.
impl NegativeOne for Rational
The constant -1.
const NEGATIVE_ONE: Rational
Source§impl NextPowerOf2 for &Rational
impl NextPowerOf2 for &Rational
Source§fn 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
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
Source§impl NextPowerOf2 for Rational
impl NextPowerOf2 for Rational
Source§fn 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
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
Source§impl NextPowerOf2Assign for Rational
impl NextPowerOf2Assign for Rational
Source§fn 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
use malachite_base::num::arithmetic::traits::NextPowerOf2Assign;
use malachite_q::Rational;
let mut x = Rational::from(123);
x.next_power_of_2_assign();
assert_eq!(x, 128);
let mut x = Rational::from_signeds(1, 10);
x.next_power_of_2_assign();
assert_eq!(x.to_string(), "1/8");
Source§impl Ord for Rational
impl Ord for Rational
Source§fn 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
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 · Source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
Source§impl OrdAbs for Rational
impl OrdAbs for Rational
Source§fn 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
use malachite_base::num::basic::traits::OneHalf;
use malachite_base::num::comparison::traits::OrdAbs;
use malachite_q::Rational;
use std::cmp::Ordering::*;
use std::str::FromStr;
assert_eq!(
Rational::from_str("2/3")
.unwrap()
.cmp_abs(&Rational::ONE_HALF),
Greater
);
assert_eq!(
Rational::from_str("-2/3")
.unwrap()
.cmp_abs(&Rational::ONE_HALF),
Greater
);
Source§impl PartialEq<Integer> for Rational
impl PartialEq<Integer> for Rational
Source§fn 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
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));
Source§impl PartialEq<Natural> for Rational
impl PartialEq<Natural> for Rational
Source§fn 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
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));
Source§impl PartialEq<Rational> for Integer
impl PartialEq<Rational> for Integer
Source§fn 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
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));
Source§impl PartialEq<Rational> for Natural
impl PartialEq<Rational> for Natural
Source§fn 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
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));
Source§impl PartialOrd<Integer> for Rational
impl PartialOrd<Integer> for Rational
Source§fn 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
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));
Source§impl PartialOrd<Natural> for Rational
impl PartialOrd<Natural> for Rational
Source§fn 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
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));
Source§impl PartialOrd<Rational> for Integer
impl PartialOrd<Rational> for Integer
Source§fn 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
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));
Source§impl PartialOrd<Rational> for Natural
impl PartialOrd<Rational> for Natural
Source§fn 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
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));
Source§impl PartialOrd<Rational> for f32
impl PartialOrd<Rational> for f32
Source§impl PartialOrd<Rational> for f64
impl PartialOrd<Rational> for f64
Source§impl PartialOrd<Rational> for i128
impl PartialOrd<Rational> for i128
Source§impl PartialOrd<Rational> for i16
impl PartialOrd<Rational> for i16
Source§impl PartialOrd<Rational> for i32
impl PartialOrd<Rational> for i32
Source§impl PartialOrd<Rational> for i64
impl PartialOrd<Rational> for i64
Source§impl PartialOrd<Rational> for i8
impl PartialOrd<Rational> for i8
Source§impl PartialOrd<Rational> for isize
impl PartialOrd<Rational> for isize
Source§impl PartialOrd<Rational> for u128
impl PartialOrd<Rational> for u128
Source§impl PartialOrd<Rational> for u16
impl PartialOrd<Rational> for u16
Source§impl PartialOrd<Rational> for u32
impl PartialOrd<Rational> for u32
Source§impl PartialOrd<Rational> for u64
impl PartialOrd<Rational> for u64
Source§impl PartialOrd<Rational> for u8
impl PartialOrd<Rational> for u8
Source§impl PartialOrd<Rational> for usize
impl PartialOrd<Rational> for usize
Source§impl PartialOrd<f32> for Rational
impl PartialOrd<f32> for Rational
Source§impl PartialOrd<f64> for Rational
impl PartialOrd<f64> for Rational
Source§impl PartialOrd<i128> for Rational
impl PartialOrd<i128> for Rational
Source§impl PartialOrd<i16> for Rational
impl PartialOrd<i16> for Rational
Source§impl PartialOrd<i32> for Rational
impl PartialOrd<i32> for Rational
Source§impl PartialOrd<i64> for Rational
impl PartialOrd<i64> for Rational
Source§impl PartialOrd<i8> for Rational
impl PartialOrd<i8> for Rational
Source§impl PartialOrd<isize> for Rational
impl PartialOrd<isize> for Rational
Source§impl PartialOrd<u128> for Rational
impl PartialOrd<u128> for Rational
Source§impl PartialOrd<u16> for Rational
impl PartialOrd<u16> for Rational
Source§impl PartialOrd<u32> for Rational
impl PartialOrd<u32> for Rational
Source§impl PartialOrd<u64> for Rational
impl PartialOrd<u64> for Rational
Source§impl PartialOrd<u8> for Rational
impl PartialOrd<u8> for Rational
Source§impl PartialOrd<usize> for Rational
impl PartialOrd<usize> for Rational
Source§impl PartialOrd for Rational
impl PartialOrd for Rational
Source§impl PartialOrdAbs<Integer> for Rational
impl PartialOrdAbs<Integer> for Rational
Source§fn 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
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(&Inte