# Struct malachite_q::Rational

source · `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

source#### pub fn approx_log(&self) -> f64

#### pub fn approx_log(&self) -> f64

Calculates the approximate natural logarithm of a positive `Rational`

.

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

##### §Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

.

##### §Examples

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

source#### pub 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);
```

source#### pub 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

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

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

Compares two `Rational`

s according to their complexity.

Complexity is defined as follows: If two `Rational`

s have different denominators, then the
one with the larger denominator is more complex. If they have the same denominator, then the
one whose numerator is further from zero is more complex. Finally, if $q > 0$, then $q$ is
simpler than $-q$.

The `Rational`

s ordered by complexity look like this:
$$
0, 1, -1, 2, -2, \ldots, 1/2, -1/2, 3/2, -3/2, \ldots, 1/3, -1/3, 2/3, -2/3, \ldots, \ldots.
$$
This order is a well-order, and the order type of the `Rational`

s under this order is
$\omega^2$.

##### §Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

.

##### §Examples

```
use malachite_q::Rational;
use std::cmp::Ordering;
assert_eq!(
Rational::from_signeds(1, 2).cmp_complexity(&Rational::from_signeds(1, 3)),
Ordering::Less
);
assert_eq!(
Rational::from_signeds(1, 2).cmp_complexity(&Rational::from_signeds(3, 2)),
Ordering::Less
);
assert_eq!(
Rational::from_signeds(1, 2).cmp_complexity(&Rational::from_signeds(-1, 2)),
Ordering::Less
);
```

source§### impl Rational

### impl Rational

source#### pub 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");
```

source#### pub 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

source#### pub 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

source#### pub 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"
);
```

source#### pub 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

source#### pub 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"
);
```

source#### pub 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.

`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)$

`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

source#### pub 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

source#### pub 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]]");
```

source#### pub 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

source#### pub 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]]");
```

source#### pub 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.

`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

source#### pub 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

source#### pub const fn const_from_unsigneds(
numerator: Limb,
denominator: Limb
) -> Rational

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

Converts two`Limb`

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, Rational::from_unsigneds(2u32, 3));
```

source#### pub const fn const_from_signeds(
numerator: SignedLimb,
denominator: SignedLimb
) -> Rational

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

Converts two`SignedLimb`

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, Rational::from_signeds(-2, 3));
```

source#### pub 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);
```

source#### pub 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)$

`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);
```

source#### pub 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)$

`max(numerator.significant_bits(), denominator.significant_bits())`

.

##### §Panics

Panics if `denominator`

is zero.

##### §Examples

```
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!(Rational::from_unsigneds(4u32, 6).to_string(), "2/3");
assert_eq!(Rational::from_unsigneds(0u32, 6), 0);
```

source#### pub 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)$

`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);
```

source#### pub 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)$

`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);
```

source#### pub 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)$

`max(numerator.significant_bits(), denominator.significant_bits())`

.

##### §Panics

Panics if `denominator`

is zero.

##### §Examples

```
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!(Rational::from_signeds(4i8, 6).to_string(), "2/3");
assert_eq!(Rational::from_signeds(4i8, -6).to_string(), "-2/3");
assert_eq!(Rational::from_signeds(0i8, 6), 0);
assert_eq!(Rational::from_signeds(0i8, -6), 0);
```

source#### pub 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)$

`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_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"
);
```

source#### pub 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)$

`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_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"
);
```

source#### pub 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)$

`max(numerator.significant_bits(), denominator.significant_bits())`

.

##### §Panics

Panics if `denominator`

is zero.

##### §Examples

```
use malachite_base::num::basic::traits::Zero;
use malachite_q::Rational;
assert_eq!(Rational::from_sign_and_unsigneds(true, 4u32, 6).to_string(), "2/3");
assert_eq!(Rational::from_sign_and_unsigneds(false, 4u32, 6).to_string(), "-2/3");
```

source§### impl Rational

### impl Rational

source#### pub const fn const_from_unsigned(x: Limb) -> Rational

#### pub const fn const_from_unsigned(x: Limb) -> Rational

source#### pub 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

source#### pub 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::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::SciMantissaAndExponent;
use malachite_base::num::float::NiceFloat;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;
use std::cmp::Ordering;
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), RoundingMode::Down, Some((1.5, 1, Ordering::Equal)));
test(Rational::from(3u32), RoundingMode::Ceiling, Some((1.5, 1, Ordering::Equal)));
test(Rational::from(3u32), RoundingMode::Up, Some((1.5, 1, Ordering::Equal)));
test(Rational::from(3u32), RoundingMode::Nearest, Some((1.5, 1, Ordering::Equal)));
test(Rational::from(3u32), RoundingMode::Exact, Some((1.5, 1, Ordering::Equal)));
test(
Rational::from_signeds(1, 3),
RoundingMode::Floor,
Some((1.3333333, -2, Ordering::Less))
);
test(
Rational::from_signeds(1, 3),
RoundingMode::Down,
Some((1.3333333, -2, Ordering::Less))
);
test(
Rational::from_signeds(1, 3),
RoundingMode::Ceiling,
Some((1.3333334, -2, Ordering::Greater))
);
test(
Rational::from_signeds(1, 3),
RoundingMode::Up,
Some((1.3333334, -2, Ordering::Greater))
);
test(
Rational::from_signeds(1, 3),
RoundingMode::Nearest,
Some((1.3333334, -2, Ordering::Greater))
);
test(
Rational::from_signeds(1, 3),
RoundingMode::Exact,
None
);
test(
Rational::from_signeds(-1, 3),
RoundingMode::Floor,
Some((1.3333333, -2, Ordering::Less))
);
test(
Rational::from_signeds(-1, 3),
RoundingMode::Down,
Some((1.3333333, -2, Ordering::Less))
);
test(
Rational::from_signeds(-1, 3),
RoundingMode::Ceiling,
Some((1.3333334, -2, Ordering::Greater))
);
test(
Rational::from_signeds(-1, 3),
RoundingMode::Up,
Some((1.3333334, -2, Ordering::Greater))
);
test(
Rational::from_signeds(-1, 3),
RoundingMode::Nearest,
Some((1.3333334, -2, Ordering::Greater))
);
test(
Rational::from_signeds(-1, 3),
RoundingMode::Exact,
None
);
```

source#### pub 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::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::SciMantissaAndExponent;
use malachite_base::num::float::NiceFloat;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;
use std::cmp::Ordering;
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), RoundingMode::Down, Some((1.5, 1, Ordering::Equal)));
test(Rational::from(3u32), RoundingMode::Ceiling, Some((1.5, 1, Ordering::Equal)));
test(Rational::from(3u32), RoundingMode::Up, Some((1.5, 1, Ordering::Equal)));
test(Rational::from(3u32), RoundingMode::Nearest, Some((1.5, 1, Ordering::Equal)));
test(Rational::from(3u32), RoundingMode::Exact, Some((1.5, 1, Ordering::Equal)));
test(
Rational::from_signeds(1, 3),
RoundingMode::Floor,
Some((1.3333333, -2, Ordering::Less))
);
test(
Rational::from_signeds(1, 3),
RoundingMode::Down,
Some((1.3333333, -2, Ordering::Less))
);
test(
Rational::from_signeds(1, 3),
RoundingMode::Ceiling,
Some((1.3333334, -2, Ordering::Greater))
);
test(
Rational::from_signeds(1, 3),
RoundingMode::Up,
Some((1.3333334, -2, Ordering::Greater))
);
test(
Rational::from_signeds(1, 3),
RoundingMode::Nearest,
Some((1.3333334, -2, Ordering::Greater))
);
test(
Rational::from_signeds(1, 3),
RoundingMode::Exact,
None
);
```

source§### impl Rational

### impl Rational

source#### pub 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);
```

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

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

Mutates the denominator of a `Rational`

using a provided closure.

After the closure executes, this function reduces the `Rational`

.

##### §Panics

Panics if the closure sets the denominator to zero.

##### §Examples

```
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);
```

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

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

Mutates the numerator and denominator of a `Rational`

using a provided closure.

After the closure executes, this function reduces the `Rational`

.

##### §Panics

Panics if the closure sets the denominator to zero.

##### §Examples

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

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

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

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

. This function finds
the simplest `Rational`

which rounds to the target string according to the precision
implied by the string.

Use `FromSciStringOptions`

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

If the base is greater than 10, the higher digits are represented by the letters `'a'`

through `'z'`

or `'A'`

through `'Z'`

; the case doesn’t matter and doesn’t need to be
consistent.

Exponents are allowed, and are indicated using the character `'e'`

or `'E'`

. If the base is
15 or greater, an ambiguity arises where it may not be clear whether `'e'`

is a digit or an
exponent indicator. To resolve this ambiguity, always use a `'+'`

or `'-'`

sign after the
exponent indicator when the base is 15 or greater.

The exponent itself is always parsed using base 10.

Decimal (or other-base) points are allowed.

If the string is unparseable, `None`

is returned.

Here’s a more precise description of the function’s behavior. Suppose we are using base $b$,
and the literal value of the string (as parsed by
`from_sci_string`

) is $q$, and the implied scale is $s$
(meaning $s$ digits are provided after the point; if the string is `"123.456"`

, then $s$ is
3). Then this function computes $\epsilon = b^{-s}/2$ and finds the simplest `Rational`

in
the closed interval $[q - \epsilon, q + \epsilon]$. The simplest `Rational`

is the one
with minimal denominator; if there are multiple such `Rational`

s, the one with the
smallest absolute numerator is chosen.

The following discussion assumes base 10.

This method allows the function to convert `"0.333"`

to $1/3$, since $1/3$ is the simplest
`Rational`

in the interval $[0.3325, 0.3335]$. But note that if the scale of the input is
low, some unexpected behavior may occur. For example, `"0.1"`

will be converted into $1/7$
rather than $1/10$, since $1/7$ is the simplest `Rational`

in $[0.05, 0.15]$. If you’d
prefer that result be $1/10$, you have a few options:

- Use
`from_sci_string_with_options`

instead. This function interprets its input literally; it converts`"0.333"`

to $333/1000$. - Increase the scale of the input;
`"0.10"`

is converted to $1/10$. - Use
`from_sci_string_with_options`

, and round the result manually using functions like`round_to_multiple`

and`simplest_rational_in_closed_interval`

.

##### §Worst-case complexity

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

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

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

, and $m$ is `options.base`

.

##### §Examples

```
use malachite_base::num::conversion::string::options::FromSciStringOptions;
use malachite_base::rounding_modes::RoundingMode;
use malachite_q::Rational;
let mut options = FromSciStringOptions::default();
options.set_base(16);
assert_eq!(Rational::from_sci_string_simplest_with_options("ff", options).unwrap(), 255);
assert_eq!(
Rational::from_sci_string_simplest_with_options("ffE+5", options).unwrap(),
267386880
);
// 1/4105 is 0.000ff705..._16
assert_eq!(
Rational::from_sci_string_simplest_with_options("ffE-5", options).unwrap().to_string(),
"1/4105"
);
```

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

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

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

. This function finds
the simplest `Rational`

which rounds to the target string according to the precision
implied by the string.

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

instead.

Exponents are allowed, and are indicated using the character `'e'`

or `'E'`

.

The exponent itself is also parsed using base 10.

Decimal points are allowed.

If the string is unparseable, `None`

is returned.

Here’s a more precise description of the function’s behavior. Suppose that the literal value
of the string (as parsed by `from_sci_string`

) is $q$, and the
implied scale is $s$ (meaning $s$ digits are provided after the point; if the string is
`"123.456"`

, then $s$ is 3). Then this function computes $\epsilon = 10^{-s}/2$ and finds
the simplest `Rational`

in the closed interval $[q - \epsilon, q + \epsilon]$. The
simplest `Rational`

is the one with minimal denominator; if there are multiple such
`Rational`

s, the one with the smallest absolute numerator is chosen.

This method allows the function to convert `"0.333"`

to $1/3$, since $1/3$ is the simplest
`Rational`

in the interval $[0.3325, 0.3335]$. But note that if the scale of the input is
low, some unexpected behavior may occur. For example, `"0.1"`

will be converted into $1/7$
rather than $1/10$, since $1/7$ is the simplest `Rational`

in $[0.05, 0.15]$. If you’d
prefer that result be $1/10$, you have a few options:

- Use
`from_sci_string`

instead. This function interprets its input literally; it converts`"0.333"`

to $333/1000$. - Increase the scale of the input;
`"0.10"`

is converted to $1/10$. - Use
`from_sci_string`

, and round the result manually using functions like`round_to_multiple`

and`simplest_rational_in_closed_interval`

.

##### §Worst-case complexity

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

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

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

.

##### §Examples

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

source§### impl Rational

### impl Rational

source#### pub 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

source#### pub 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);
```

source#### pub 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);
```

source#### pub 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)"
);
```

source#### pub 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);
```

source#### pub 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);
```

source#### pub 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)"
);
```

source#### pub 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);
```

source#### pub 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);
```

source#### pub 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<'a> Abs for &'a Rational

### impl<'a> Abs for &'a 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<'a, 'b> Add<&'a Rational> for &'b Rational

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

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

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

Adds two `Rational`

s, taking both by reference.

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

##### §Worst-case complexity

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

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

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

.

##### §Examples

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

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

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

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

Adds two `Rational`

s, taking both by the first by value and the second by reference.

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

##### §Worst-case complexity

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

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

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

.

##### §Examples

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

### impl<'a> Add<Rational> for &'a 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)$

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

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

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

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

Adds a `Rational`

to a `Rational`

in place, taking the `Rational`

on the right-hand
side by reference.

$$ x \gets x + y. $$

##### §Worst-case complexity

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

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

`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)$

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

### impl<'a> Approximate for &'a 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)$

`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)$

`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)$

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

### impl<'a> Ceiling for &'a 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)$

`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)$

`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)$

`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<'a, 'b> CeilingLogBase<&'b Rational> for &'a Rational

### impl<'a, 'b> CeilingLogBase<&'b Rational> for &'a 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<'a> CeilingLogBase2 for &'a Rational

### impl<'a> CeilingLogBase2 for &'a 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<'a> CeilingLogBasePowerOf2<i64> for &'a Rational

### impl<'a> CeilingLogBasePowerOf2<i64> for &'a 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<'a, 'b> CheckedDiv<&'a Rational> for &'b Rational

### impl<'a, 'b> CheckedDiv<&'a Rational> for &'b Rational

source§#### fn checked_div(self, other: &'a Rational) -> Option<Rational>

#### fn checked_div(self, other: &'a 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)$

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

### impl<'a> CheckedDiv<&'a Rational> for Rational

source§#### fn checked_div(self, other: &'a Rational) -> Option<Rational>

#### fn checked_div(self, other: &'a 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)$

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

### impl<'a> CheckedDiv<Rational> for &'a 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)$

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

##### §Worst-case complexity

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

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

`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<'a, 'b> CheckedLogBase<&'b Rational> for &'a Rational

### impl<'a, 'b> CheckedLogBase<&'b Rational> for &'a 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<'a> CheckedLogBase2 for &'a Rational

### impl<'a> CheckedLogBase2 for &'a 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<'a> CheckedLogBasePowerOf2<i64> for &'a Rational

### impl<'a> CheckedLogBasePowerOf2<i64> for &'a 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<'a> CheckedRoot<i64> for &'a Rational

### impl<'a> CheckedRoot<i64> for &'a 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<'a> CheckedRoot<u64> for &'a Rational

### impl<'a> CheckedRoot<u64> for &'a 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.

##### §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<'a> CheckedSqrt for &'a Rational

### impl<'a> CheckedSqrt for &'a 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<'a> ContinuedFraction for &'a Rational

### impl<'a> ContinuedFraction for &'a 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<'a> Convergents for &'a Rational

### impl<'a> Convergents for &'a 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<'a> ConvertibleFrom<&'a Rational> for Integer

### impl<'a> ConvertibleFrom<&'a 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<'a> ConvertibleFrom<&'a Rational> for Natural

### impl<'a> ConvertibleFrom<&'a 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<'a> ConvertibleFrom<&'a Rational> for f32

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

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

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

source§### impl<'a> ConvertibleFrom<&'a Rational> for f64

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

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

#### fn convertible_from(value: &'a 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<'a, 'b> DenominatorsInClosedInterval<'a, 'b> for Rational

### impl<'a, 'b> DenominatorsInClosedInterval<'a, 'b> for Rational

source§#### fn denominators_in_closed_interval(
a: &'a Rational,
b: &'b Rational
) -> DenominatorsInClosedRationalInterval<'a, 'b> ⓘ

#### fn denominators_in_closed_interval( a: &'a Rational, b: &'b Rational ) -> DenominatorsInClosedRationalInterval<'a, 'b> ⓘ

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<'a, 'b>

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<'a, 'b> Div<&'a Rational> for &'b Rational

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

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

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

Divides a `Rational`

by another `Rational`

, taking both by reference.

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

##### §Worst-case complexity

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

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

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

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

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

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

Divides a `Rational`

by another `Rational`

, taking the first by value and the second by
reference.

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

##### §Worst-case complexity

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

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

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

### impl<'a> Div<Rational> for &'a 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)$

`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)$

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

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

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

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

Divides a `Rational`

by a `Rational`

in place, taking the `Rational`

on the right-hand
side by reference.

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

##### §Worst-case complexity

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

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

`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)$

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

### impl<'a> Floor for &'a 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)$

`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;
use std::str::FromStr;
assert_eq!((&Rational::ZERO).floor(), 0);
assert_eq!((&Rational::from_signeds(22, 7)).floor(), 3);
assert_eq!((&Rational::from_signeds(-22, 7)).floor(), -4);
```

#### type Output = Integer

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

`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)$

`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;
use std::str::FromStr;
let mut x = Rational::ZERO;
x.floor_assign();
assert_eq!(x, 0);
let mut x = Rational::from_signeds(22, 7);
x.floor_assign();
assert_eq!(x, 3);
let mut x = Rational::from_signeds(-22, 7);
x.floor_assign();
assert_eq!(x, -4);
```

source§### impl<'a, 'b> FloorLogBase<&'b Rational> for &'a Rational

### impl<'a, 'b> FloorLogBase<&'b Rational> for &'a 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<'a> FloorLogBase2 for &'a Rational

### impl<'a> FloorLogBase2 for &'a 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<'a> FloorLogBasePowerOf2<i64> for &'a Rational

### impl<'a> FloorLogBasePowerOf2<i64> for &'a 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<'a> From<&'a Integer> for Rational

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

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

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

Converts an `Integer`

to a `Rational`

, taking the `Integer`

by reference.

##### §Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

.

##### §Examples

```
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<'a> From<&'a Natural> for Rational

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

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

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

Converts a `Natural`

to a `Rational`

, taking the `Natural`

by reference.

##### §Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

.

##### §Examples

```
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_base::rounding_modes::RoundingMode;
use malachite_q::Rational;
assert_eq!(Rational::from_sci_string("123").unwrap(), 123);
assert_eq!(Rational::from_sci_string("0.1").unwrap().to_string(), "1/10");
assert_eq!(Rational::from_sci_string("0.10").unwrap().to_string(), "1/10");
assert_eq!(Rational::from_sci_string("0.333").unwrap().to_string(), "333/1000");
assert_eq!(Rational::from_sci_string("1.2e5").unwrap(), 120000);
assert_eq!(Rational::from_sci_string("1.2e-5").unwrap().to_string(), "3/250000");
let mut options = FromSciStringOptions::default();
options.set_base(16);
assert_eq!(Rational::from_sci_string_with_options("ff", options).unwrap(), 255);
assert_eq!(Rational::from_sci_string_with_options("ffE+5", options).unwrap(), 267386880);
assert_eq!(
Rational::from_sci_string_with_options("ffE-5", options).unwrap().to_string(),
"255/1048576"
);
```

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

### impl<'a> IsInteger for &'a 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<'a, 'b> Mul<&'a Rational> for &'b Rational

### impl<'a, 'b> Mul<&'a Rational> for &'b Rational

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

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

Multiplies two `Rational`

s, taking both by reference.

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

##### §Worst-case complexity

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

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

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

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

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

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

Multiplies two `Rational`

s, taking the first by value and the second by reference.

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

##### §Worst-case complexity

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

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

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

### impl<'a> Mul<Rational> for &'a 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)$

`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)$

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

### impl<'a> MulAssign<&'a Rational> for Rational

source§#### fn mul_assign(&mut self, other: &'a Rational)

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

Multiplies a `Rational`

by a `Rational`

in place, taking the `Rational`

on the
right-hand side by reference.

$$ x \gets xy. $$

##### §Worst-case complexity

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

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

`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)$

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

### impl<'a> Neg for &'a 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<'a> NextPowerOf2 for &'a Rational

### impl<'a> NextPowerOf2 for &'a 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;
use std::str::FromStr;
let mut x = Rational::from(123);
x.next_power_of_2_assign();
assert_eq!(x, 128);
let mut x = Rational::from_signeds(1, 10);
x.next_power_of_2_assign();
assert_eq!(x.to_string(), "1/8");
```

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

`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)$

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

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

### impl PartialEq for Rational

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

`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));
```

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### 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)$

`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));
```

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### 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)$

`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));
```

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### 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)$

`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));
```

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<Rational> for f32

### impl PartialOrd<Rational> for f32

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<Rational> for f64

### impl PartialOrd<Rational> for f64

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<Rational> for i128

### impl PartialOrd<Rational> for i128

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<Rational> for i16

### impl PartialOrd<Rational> for i16

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<Rational> for i32

### impl PartialOrd<Rational> for i32

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<Rational> for i64

### impl PartialOrd<Rational> for i64

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<Rational> for i8

### impl PartialOrd<Rational> for i8

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<Rational> for isize

### impl PartialOrd<Rational> for isize

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<Rational> for u128

### impl PartialOrd<Rational> for u128

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<Rational> for u16

### impl PartialOrd<Rational> for u16

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<Rational> for u32

### impl PartialOrd<Rational> for u32

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<Rational> for u64

### impl PartialOrd<Rational> for u64

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<Rational> for u8

### impl PartialOrd<Rational> for u8

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<Rational> for usize

### impl PartialOrd<Rational> for usize

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<f32> for Rational

### impl PartialOrd<f32> for Rational

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<f64> for Rational

### impl PartialOrd<f64> for Rational

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<i128> for Rational

### impl PartialOrd<i128> for Rational

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<i16> for Rational

### impl PartialOrd<i16> for Rational

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<i32> for Rational

### impl PartialOrd<i32> for Rational

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<i64> for Rational

### impl PartialOrd<i64> for Rational

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<i8> for Rational

### impl PartialOrd<i8> for Rational

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<isize> for Rational

### impl PartialOrd<isize> for Rational

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<u128> for Rational

### impl PartialOrd<u128> for Rational

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<u16> for Rational

### impl PartialOrd<u16> for Rational

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<u32> for Rational

### impl PartialOrd<u32> for Rational

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<u64> for Rational

### impl PartialOrd<u64> for Rational

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<u8> for Rational

### impl PartialOrd<u8> for Rational

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd<usize> for Rational

### impl PartialOrd<usize> for Rational

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl PartialOrd for Rational

### impl PartialOrd for Rational

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### 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)$

`max(self.significant_bits(), other.significant_bits())`

.

##### §Examples

```
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
use std::cmp::Ordering;
assert_eq!(
Rational::from_signeds(22, 7).partial_cmp_abs(&Integer::from(3)),
Some(Ordering::Greater)
);
assert_eq!(
Rational::from_signeds(-22, 7).partial_cmp_abs(&Integer::from(-3)),
Some(Ordering::Greater)
);
```

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

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

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

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

source§### impl PartialOrdAbs<Natural> for Rational

### impl PartialOrdAbs<Natural> for Rational

source§#### fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

#### fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares the absolute values of a `Rational`

and a `Natural`

.

##### §Worst-case complexity

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

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

`max(self.significant_bits(), other.significant_bits())`

.

##### §Examples

```
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::cmp::Ordering;
assert_eq!(
Rational::from_signeds(22, 7).partial_cmp_abs(&Natural::from(3u32)),
Some(Ordering::Greater)
);
assert_eq!(
Rational::from_signeds(-22, 7).partial_cmp_abs(&Natural::from(3u32)),
Some(Ordering::Greater)
);
```

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

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

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

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

source§### impl PartialOrdAbs<Rational> for Integer

### impl PartialOrdAbs<Rational> for Integer

source§#### fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

#### fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of an `Integer`

and a `Rational`

.

##### §Worst-case complexity

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

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

`max(self.significant_bits(), other.significant_bits())`

.

##### §Examples

```
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::integer::Integer;
use malachite_q::Rational;
use std::cmp::Ordering;
assert_eq!(
Integer::from(3).partial_cmp_abs(&Rational::from_signeds(22, 7)),
Some(Ordering::Less)
);
assert_eq!(
Integer::from(-3).partial_cmp_abs(&Rational::from_signeds(-22, 7)),
Some(Ordering::Less)
);
```

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

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

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

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

source§### impl PartialOrdAbs<Rational> for Natural

### impl PartialOrdAbs<Rational> for Natural

source§#### fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

#### fn partial_cmp_abs(&self, other: &Rational) -> Option<Ordering>

Compares the absolute values of a `Natural`

and a `Rational`

.

##### §Worst-case complexity

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

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

`max(self.significant_bits(), other.significant_bits())`

.

##### §Examples

```
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::natural::Natural;
use malachite_q::Rational;
use std::cmp::Ordering;
assert_eq!(
Natural::from(3u32).partial_cmp_abs(&Rational::from_signeds(22, 7)),
Some(Ordering::Less)
);
assert_eq!(
Natural::from(3u32).partial_cmp_abs(&Rational::from_signeds(-22, 7)),
Some(Ordering::Less)
);
```