Struct malachite_nz::natural::Natural

pub struct Natural(_);

A natural (non-negative) integer.

Any Natural small enough to fit into a Limb is represented inline. Only Naturals outside this range incur the costs of heap-allocation. Here’s a diagram of a slice of Naturals (using 32-bit limbs) containing the first 8 values of Sylvester’s sequence:

Implementations

impl Natural

pub fn approx_log(&self) -> f64

Calculates the approximate natural logarithm of a nonzero Natural.

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::float::NiceFloat;
use malachite_nz::natural::Natural;

assert_eq!(NiceFloat(Natural::from(10u32).approx_log()), NiceFloat(2.3025850929940455));
assert_eq!(
    NiceFloat(Natural::from(10u32).pow(10000).approx_log()),
    NiceFloat(23025.850929940454)
);

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

impl Natural

pub fn cmp_normalized(&self, other: &Natural) -> Ordering

Returns a result of a comparison between two Naturals as if each had been multiplied by some power of 2 to bring it into the interval $[1, 2)$.

That is, the comparison is equivalent to a comparison between $f(x)$ and $f(y)$, where $$ f(n) = n2^{\lfloor\log_2 n \rfloor}. $$

The multiplication is not actually performed.

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

Panics

Panics if either argument is zero.

Examples

use malachite_nz::natural::Natural;
use std::cmp::Ordering;

// 1 == 1.0 * 2^0, 4 == 1.0 * 2^2
// 1.0 == 1.0
assert_eq!(Natural::from(1u32).cmp_normalized(&Natural::from(4u32)), Ordering::Equal);

// 5 == 1.25 * 2^2, 6 == 1.5 * 2^2
// 1.25 < 1.5
assert_eq!(Natural::from(5u32).cmp_normalized(&Natural::from(6u32)), Ordering::Less);

// 3 == 1.5 * 2^1, 17 == 1.0625 * 2^4
// 1.5 > 1.0625
assert_eq!(Natural::from(3u32).cmp_normalized(&Natural::from(17u32)), Ordering::Greater);

// 9 == 1.125 * 2^3, 36 == 1.125 * 2^5
// 1.125 == 1.125
assert_eq!(Natural::from(9u32).cmp_normalized(&Natural::from(36u32)), Ordering::Equal);

impl Natural

pub fn from_limbs_asc(xs: &[Limb]) -> Natural

Converts a slice of limbs to a Natural.

The limbs are in ascending order, so that less-significant limbs have lower indices in the input slice.

This function borrows the limbs. If taking ownership of limbs is possible, from_owned_limbs_asc is more efficient.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

This function is more efficient than from_limbs_desc.

Examples

extern crate malachite_base;

use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;

if Limb::WIDTH == u32::WIDTH {
    assert_eq!(Natural::from_limbs_asc(&[]), 0);
    assert_eq!(Natural::from_limbs_asc(&[123]), 123);
    // 10^12 = 232 * 2^32 + 3567587328
    assert_eq!(Natural::from_limbs_asc(&[3567587328, 232]), 1000000000000u64);
}

pub fn from_limbs_desc(xs: &[Limb]) -> Natural

Converts a slice of limbs to a Natural.

The limbs in descending order, so that less-significant limbs have higher indices in the input slice.

This function borrows the limbs. If taking ownership of the limbs is possible, from_owned_limbs_desc is more efficient.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

This function is less efficient than from_limbs_asc.

Examples

extern crate malachite_base;

use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;

if Limb::WIDTH == u32::WIDTH {
    assert_eq!(Natural::from_limbs_desc(&[]), 0);
    assert_eq!(Natural::from_limbs_desc(&[123]), 123);
    // 10^12 = 232 * 2^32 + 3567587328
    assert_eq!(Natural::from_limbs_desc(&[232, 3567587328]), 1000000000000u64);
}

pub fn from_owned_limbs_asc(xs: Vec<Limb>) -> Natural

Converts a Vec of limbs to a Natural.

The limbs are in ascending order, so that less-significant limbs have lower indices in the input Vec.

This function takes ownership of the limbs. If it’s necessary to borrow the limbs instead, use from_limbs_asc.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

This function is more efficient than from_limbs_desc.

Examples

extern crate malachite_base;

use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;

if Limb::WIDTH == u32::WIDTH {
    assert_eq!(Natural::from_owned_limbs_asc(vec![]), 0);
    assert_eq!(Natural::from_owned_limbs_asc(vec![123]), 123);
    // 10^12 = 232 * 2^32 + 3567587328
    assert_eq!(Natural::from_owned_limbs_asc(vec![3567587328, 232]), 1000000000000u64);
}

pub fn from_owned_limbs_desc(xs: Vec<Limb>) -> Natural

Converts a Vec of limbs to a Natural.

The limbs are in descending order, so that less-significant limbs have higher indices in the input Vec.

This function takes ownership of the limbs. If it’s necessary to borrow the limbs instead, use from_limbs_desc.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

This function is less efficient than from_limbs_asc.

Examples

extern crate malachite_base;

use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;

if Limb::WIDTH == u32::WIDTH {
    assert_eq!(Natural::from_owned_limbs_desc(vec![]), 0);
    assert_eq!(Natural::from_owned_limbs_desc(vec![123]), 123);
    // 10^12 = 232 * 2^32 + 3567587328
    assert_eq!(Natural::from_owned_limbs_desc(vec![232, 3567587328]), 1000000000000u64);
}

impl Natural

pub fn limb_count(&self) -> u64

Returns the number of limbs of a Natural.

Zero has 0 limbs.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;

if Limb::WIDTH == u32::WIDTH {
    assert_eq!(Natural::ZERO.limb_count(), 0);
    assert_eq!(Natural::from(123u32).limb_count(), 1);
    assert_eq!(Natural::from(10u32).pow(12).limb_count(), 2);
}

impl Natural

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

Returns a Natural’s scientific mantissa and exponent.

When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$. 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)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::SciMantissaAndExponent;
use malachite_base::num::float::NiceFloat;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

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

test(
    Natural::from(123u32),
    RoundingMode::Floor,
    Some((1.921875, 6)),
);
test(
    Natural::from(123u32),
    RoundingMode::Down,
    Some((1.921875, 6)),
);
test(
    Natural::from(123u32),
    RoundingMode::Ceiling,
    Some((1.921875, 6)),
);
test(Natural::from(123u32), RoundingMode::Up, Some((1.921875, 6)));
test(
    Natural::from(123u32),
    RoundingMode::Nearest,
    Some((1.921875, 6)),
);
test(
    Natural::from(123u32),
    RoundingMode::Exact,
    Some((1.921875, 6)),
);

test(
    Natural::from(1000000000u32),
    RoundingMode::Nearest,
    Some((1.8626451, 29)),
);
test(
    Natural::from(10u32).pow(52),
    RoundingMode::Nearest,
    Some((1.670478, 172)),
);

test(Natural::from(10u32).pow(52), RoundingMode::Exact, None);

pub fn from_sci_mantissa_and_exponent_with_rounding<T: PrimitiveFloat>(
    sci_mantissa: T,
    sci_exponent: u64,
    rm: RoundingMode
) -> Option<Natural>

Constructs a Natural from its scientific mantissa and exponent.

When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$. Here, the rational mantissa is provided as a float. If the mantissa is outside the range $[1, 2)$, None is returned.

Some combinations of mantissas and exponents do not specify a Natural, in which case the resulting value is rounded to a Natural using the specified rounding mode. If the rounding mode is Exact but the input does not exactly specify a Natural, None is returned.

$$ f(x, r) \approx 2^{e_s}m_s. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Panics

Panics if sci_mantissa is zero.

Examples

extern crate malachite_base;

use malachite_base::num::conversion::traits::SciMantissaAndExponent;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;
use std::str::FromStr;

let test = |mantissa: f32, exponent: u64, rm: RoundingMode, out: Option<Natural>| {
    assert_eq!(
        Natural::from_sci_mantissa_and_exponent_with_rounding(mantissa, exponent, rm),
        out
    );
};
test(1.5, 1, RoundingMode::Floor, Some(Natural::from(3u32)));
test(1.5, 1, RoundingMode::Down, Some(Natural::from(3u32)));
test(1.5, 1, RoundingMode::Ceiling, Some(Natural::from(3u32)));
test(1.5, 1, RoundingMode::Up, Some(Natural::from(3u32)));
test(1.5, 1, RoundingMode::Nearest, Some(Natural::from(3u32)));
test(1.5, 1, RoundingMode::Exact, Some(Natural::from(3u32)));

test(1.51, 1, RoundingMode::Floor, Some(Natural::from(3u32)));
test(1.51, 1, RoundingMode::Down, Some(Natural::from(3u32)));
test(1.51, 1, RoundingMode::Ceiling, Some(Natural::from(4u32)));
test(1.51, 1, RoundingMode::Up, Some(Natural::from(4u32)));
test(1.51, 1, RoundingMode::Nearest, Some(Natural::from(3u32)));
test(1.51, 1, RoundingMode::Exact, None);

test(
    1.670478,
    172,
    RoundingMode::Nearest,
    Some(
        Natural::from_str("10000000254586612611935772707803116801852191350456320").unwrap()
    ),
);

test(2.0, 1, RoundingMode::Floor, None);
test(10.0, 1, RoundingMode::Floor, None);
test(0.5, 1, RoundingMode::Floor, None);

impl Natural

pub fn to_limbs_asc(&self) -> Vec<Limb>

Returns the limbs of a Natural, in ascending order, so that less-significant limbs have lower indices in the output vector.

There are no trailing zero limbs.

This function borrows the Natural. If taking ownership is possible instead, into_limbs_asc is more efficient.

This function is more efficient than to_limbs_desc.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;

if Limb::WIDTH == u32::WIDTH {
    assert!(Natural::ZERO.to_limbs_asc().is_empty());
    assert_eq!(Natural::from(123u32).to_limbs_asc(), &[123]);
    // 10^12 = 232 * 2^32 + 3567587328
    assert_eq!(Natural::from(10u32).pow(12).to_limbs_asc(), &[3567587328, 232]);
}

pub fn to_limbs_desc(&self) -> Vec<Limb>

Returns the limbs of a Natural in descending order, so that less-significant limbs have higher indices in the output vector.

There are no leading zero limbs.

This function borrows the Natural. If taking ownership is possible instead, into_limbs_desc is more efficient.

This function is less efficient than to_limbs_asc.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;

if Limb::WIDTH == u32::WIDTH {
    assert!(Natural::ZERO.to_limbs_desc().is_empty());
    assert_eq!(Natural::from(123u32).to_limbs_desc(), &[123]);
    // 10^12 = 232 * 2^32 + 3567587328
    assert_eq!(Natural::from(10u32).pow(12).to_limbs_desc(), &[232, 3567587328]);
}

pub fn into_limbs_asc(self) -> Vec<Limb>

Returns the limbs of a Natural, in ascending order, so that less-significant limbs have lower indices in the output vector.

There are no trailing zero limbs.

This function takes ownership of the Natural. If it’s necessary to borrow instead, use to_limbs_asc.

This function is more efficient than into_limbs_desc.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;

if Limb::WIDTH == u32::WIDTH {
    assert!(Natural::ZERO.into_limbs_asc().is_empty());
    assert_eq!(Natural::from(123u32).into_limbs_asc(), &[123]);
    // 10^12 = 232 * 2^32 + 3567587328
    assert_eq!(Natural::from(10u32).pow(12).into_limbs_asc(), &[3567587328, 232]);
}

pub fn into_limbs_desc(self) -> Vec<Limb>

Returns the limbs of a Natural, in descending order, so that less-significant limbs have higher indices in the output vector.

There are no leading zero limbs.

This function takes ownership of the Natural. If it’s necessary to borrow instead, use to_limbs_desc.

This function is less efficient than into_limbs_asc.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;

if Limb::WIDTH == u32::WIDTH {
    assert!(Natural::ZERO.into_limbs_desc().is_empty());
    assert_eq!(Natural::from(123u32).into_limbs_desc(), &[123]);
    // 10^12 = 232 * 2^32 + 3567587328
    assert_eq!(Natural::from(10u32).pow(12).into_limbs_desc(), &[232, 3567587328]);
}

pub fn limbs(&self) -> LimbIterator<'_>

Returns a double-ended iterator over the limbs of a Natural.

The forward order is ascending, so that less-significant limbs appear first. There are no trailing zero limbs going forward, or leading zeros going backward.

If it’s necessary to get a Vec of all the limbs, consider using to_limbs_asc, to_limbs_desc, into_limbs_asc, or into_limbs_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate itertools;
extern crate malachite_base;

use itertools::Itertools;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use malachite_nz::platform::Limb;

if Limb::WIDTH == u32::WIDTH {
    assert!(Natural::ZERO.limbs().next().is_none());
    assert_eq!(Natural::from(123u32).limbs().collect_vec(), &[123]);
    // 10^12 = 232 * 2^32 + 3567587328
    assert_eq!(Natural::from(10u32).pow(12).limbs().collect_vec(), &[3567587328, 232]);

    assert!(Natural::ZERO.limbs().rev().next().is_none());
    assert_eq!(Natural::from(123u32).limbs().rev().collect_vec(), &[123]);
    // 10^12 = 232 * 2^32 + 3567587328
    assert_eq!(
        Natural::from(10u32).pow(12).limbs().rev().collect_vec(),
        &[232, 3567587328]
    );
}

impl Natural

pub fn trailing_zeros(&self) -> Option<u64>

Returns the number of trailing zeros in the binary expansion of a Natural (equivalently, the multiplicity of 2 in its prime factorization), or None is the Natural is 0.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.trailing_zeros(), None);
assert_eq!(Natural::from(3u32).trailing_zeros(), Some(0));
assert_eq!(Natural::from(72u32).trailing_zeros(), Some(3));
assert_eq!(Natural::from(100u32).trailing_zeros(), Some(2));
assert_eq!(Natural::from(10u32).pow(12).trailing_zeros(), Some(12));

Trait Implementations

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

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

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

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO + &Natural::from(123u32), 123);
assert_eq!(Natural::from(123u32) + &Natural::ZERO, 123);
assert_eq!(Natural::from(123u32) + &Natural::from(456u32), 579);
assert_eq!(
    Natural::from(10u32).pow(12) + &(Natural::from(10u32).pow(12) << 1),
    3000000000000u64
);

type Output = Natural

The resulting type after applying the + operator.

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

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

Adds two Naturals, taking both by reference.

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(&Natural::ZERO + &Natural::from(123u32), 123);
assert_eq!(&Natural::from(123u32) + &Natural::ZERO, 123);
assert_eq!(&Natural::from(123u32) + &Natural::from(456u32), 579);
assert_eq!(
    &Natural::from(10u32).pow(12) + &(Natural::from(10u32).pow(12) << 1),
    3000000000000u64
);

type Output = Natural

The resulting type after applying the + operator.

impl Add<Natural> for Natural

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

Adds two Naturals, taking both by value.

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$ (only if the underlying Vec needs to reallocate)

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO + Natural::from(123u32), 123);
assert_eq!(Natural::from(123u32) + Natural::ZERO, 123);
assert_eq!(Natural::from(123u32) + Natural::from(456u32), 579);
assert_eq!(
    Natural::from(10u32).pow(12) + (Natural::from(10u32).pow(12) << 1),
    3000000000000u64
);

type Output = Natural

The resulting type after applying the + operator.

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

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

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

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(&Natural::ZERO + Natural::from(123u32), 123);
assert_eq!(&Natural::from(123u32) + Natural::ZERO, 123);
assert_eq!(&Natural::from(123u32) + Natural::from(456u32), 579);
assert_eq!(
    &Natural::from(10u32).pow(12) + (Natural::from(10u32).pow(12) << 1),
    3000000000000u64
);

type Output = Natural

The resulting type after applying the + operator.

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

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

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

$$ x \gets x + y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut x = Natural::ZERO;
x += &Natural::from(10u32).pow(12);
x += &(Natural::from(10u32).pow(12) * Natural::from(2u32));
x += &(Natural::from(10u32).pow(12) * Natural::from(3u32));
x += &(Natural::from(10u32).pow(12) * Natural::from(4u32));
assert_eq!(x, 10000000000000u64);

impl AddAssign<Natural> for Natural

fn add_assign(&mut self, other: Natural)

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

$$ x \gets x + y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$ (only if the underlying Vec needs to reallocate)

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut x = Natural::ZERO;
x += Natural::from(10u32).pow(12);
x += Natural::from(10u32).pow(12) * Natural::from(2u32);
x += Natural::from(10u32).pow(12) * Natural::from(3u32);
x += Natural::from(10u32).pow(12) * Natural::from(4u32);
assert_eq!(x, 10000000000000u64);

impl<'a, 'b> AddMul<&'a Natural, &'b Natural> for Natural

fn add_mul(self, y: &'a Natural, z: &'b Natural) -> Natural

Adds a Natural and the product of two other Naturals, taking the first by value and the second and third by reference.

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

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{AddMul, Pow};
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(10u32).add_mul(&Natural::from(3u32), &Natural::from(4u32)), 22);
assert_eq!(
    Natural::from(10u32).pow(12)
        .add_mul(&Natural::from(0x10000u32), &Natural::from(10u32).pow(12)),
    65537000000000000u64
);

type Output = Natural

impl<'a, 'b, 'c> AddMul<&'a Natural, &'b Natural> for &'c Natural

fn add_mul(self, y: &'a Natural, z: &'b Natural) -> Natural

Adds a Natural and the product of two other Naturals, taking all three by reference.

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

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{AddMul, Pow};
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(10u32)).add_mul(&Natural::from(3u32), &Natural::from(4u32)), 22);
assert_eq!(
    (&Natural::from(10u32).pow(12))
        .add_mul(&Natural::from(0x10000u32), &Natural::from(10u32).pow(12)),
    65537000000000000u64
);

type Output = Natural

impl<'a> AddMul<&'a Natural, Natural> for Natural

fn add_mul(self, y: &'a Natural, z: Natural) -> Natural

Adds a Natural and the product of two other Naturals, taking the first and third by value and the second by reference.

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

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{AddMul, Pow};
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(10u32).add_mul(&Natural::from(3u32), Natural::from(4u32)), 22);
assert_eq!(
    Natural::from(10u32).pow(12)
        .add_mul(&Natural::from(0x10000u32), Natural::from(10u32).pow(12)),
    65537000000000000u64
);

type Output = Natural

impl<'a> AddMul<Natural, &'a Natural> for Natural

fn add_mul(self, y: Natural, z: &'a Natural) -> Natural

Adds a Natural and the product of two other Naturals, taking the first two by value and the third by reference.

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

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{AddMul, Pow};
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(10u32).add_mul(Natural::from(3u32), &Natural::from(4u32)), 22);
assert_eq!(
    Natural::from(10u32).pow(12)
        .add_mul(Natural::from(0x10000u32), &Natural::from(10u32).pow(12)),
    65537000000000000u64
);

type Output = Natural

impl<'a> AddMul<Natural, Natural> for Natural

fn add_mul(self, y: Natural, z: Natural) -> Natural

Adds a Natural and the product of two other Naturals, taking all three by value.

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

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{AddMul, Pow};
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(10u32).add_mul(Natural::from(3u32), Natural::from(4u32)), 22);
assert_eq!(
    Natural::from(10u32).pow(12)
        .add_mul(Natural::from(0x10000u32), Natural::from(10u32).pow(12)),
    65537000000000000u64
);

type Output = Natural

impl<'a, 'b> AddMulAssign<&'a Natural, &'b Natural> for Natural

fn add_mul_assign(&mut self, y: &'a Natural, z: &'b Natural)

Adds the product of two other Naturals to a Natural in place, taking both Naturals on the right-hand side by reference.

$x \gets x + yz$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{AddMulAssign, Pow};
use malachite_nz::natural::Natural;

let mut x = Natural::from(10u32);
x.add_mul_assign(&Natural::from(3u32), &Natural::from(4u32));
assert_eq!(x, 22);

let mut x = Natural::from(10u32).pow(12);
x.add_mul_assign(&Natural::from(0x10000u32), &Natural::from(10u32).pow(12));
assert_eq!(x, 65537000000000000u64);

impl<'a> AddMulAssign<&'a Natural, Natural> for Natural

fn add_mul_assign(&mut self, y: &'a Natural, z: Natural)

Adds the product of two other Naturals to a Natural in place, taking the first Natural on the right-hand side by reference and the second by value.

$x \gets x + yz$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{AddMulAssign, Pow};
use malachite_nz::natural::Natural;

let mut x = Natural::from(10u32);
x.add_mul_assign(&Natural::from(3u32), Natural::from(4u32));
assert_eq!(x, 22);

let mut x = Natural::from(10u32).pow(12);
x.add_mul_assign(&Natural::from(0x10000u32), Natural::from(10u32).pow(12));
assert_eq!(x, 65537000000000000u64);

impl<'a> AddMulAssign<Natural, &'a Natural> for Natural

fn add_mul_assign(&mut self, y: Natural, z: &'a Natural)

Adds the product of two other Naturals to a Natural in place, taking the first Natural on the right-hand side by value and the second by reference.

$x \gets x + yz$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{AddMulAssign, Pow};
use malachite_nz::natural::Natural;

let mut x = Natural::from(10u32);
x.add_mul_assign(Natural::from(3u32), &Natural::from(4u32));
assert_eq!(x, 22);

let mut x = Natural::from(10u32).pow(12);
x.add_mul_assign(Natural::from(0x10000u32), &Natural::from(10u32).pow(12));
assert_eq!(x, 65537000000000000u64);

impl AddMulAssign<Natural, Natural> for Natural

fn add_mul_assign(&mut self, y: Natural, z: Natural)

Adds the product of two other Naturals to a Natural in place, taking both Naturals on the right-hand side by value.

$x \gets x + yz$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{AddMulAssign, Pow};
use malachite_nz::natural::Natural;

let mut x = Natural::from(10u32);
x.add_mul_assign(Natural::from(3u32), Natural::from(4u32));
assert_eq!(x, 22);

let mut x = Natural::from(10u32).pow(12);
x.add_mul_assign(Natural::from(0x10000u32), Natural::from(10u32).pow(12));
assert_eq!(x, 65537000000000000u64);

impl Binary for Natural

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

Converts a Natural to a binary String.

Using the # format flag prepends "0b" to the string.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToBinaryString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(Natural::ZERO.to_binary_string(), "0");
assert_eq!(Natural::from(123u32).to_binary_string(), "1111011");
assert_eq!(
    Natural::from_str("1000000000000").unwrap().to_binary_string(),
    "1110100011010100101001010001000000000000"
);
assert_eq!(format!("{:011b}", Natural::from(123u32)), "00001111011");

assert_eq!(format!("{:#b}", Natural::ZERO), "0b0");
assert_eq!(format!("{:#b}", Natural::from(123u32)), "0b1111011");
assert_eq!(
    format!("{:#b}", Natural::from_str("1000000000000").unwrap()),
    "0b1110100011010100101001010001000000000000"
);
assert_eq!(format!("{:#011b}", Natural::from(123u32)), "0b001111011");

impl BitAccess for Natural

Provides functions for accessing and modifying the $i$th bit of a Natural, or the coefficient of $2^i$ in its binary expansion.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_base::num::logic::traits::BitAccess;
use malachite_nz::natural::Natural;

let mut x = Natural::ZERO;
x.assign_bit(2, true);
x.assign_bit(5, true);
x.assign_bit(6, true);
assert_eq!(x, 100);
x.assign_bit(2, false);
x.assign_bit(5, false);
x.assign_bit(6, false);
assert_eq!(x, 0);

let mut x = Natural::ZERO;
x.flip_bit(10);
assert_eq!(x, 1024);
x.flip_bit(10);
assert_eq!(x, 0);

fn get_bit(&self, index: u64) -> bool

Determines whether the $i$th bit of a Natural, or the coefficient of $2^i$ in its binary expansion, is 0 or 1.

false means 0 and true means 1. Getting bits beyond the Natural’s width is allowed; those bits are false.

Let $$ n = \sum_{i=0}^\infty 2^{b_i}, $$ where for all $i$, $b_i\in \{0, 1\}$; so finitely many of the bits are 1, and the rest are 0. Then $f(n, j) = (b_j = 1)$.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::logic::traits::BitAccess;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(123u32).get_bit(2), false);
assert_eq!(Natural::from(123u32).get_bit(3), true);
assert_eq!(Natural::from(123u32).get_bit(100), false);
assert_eq!(Natural::from(10u32).pow(12).get_bit(12), true);
assert_eq!(Natural::from(10u32).pow(12).get_bit(100), false);

fn set_bit(&mut self, index: u64)

Sets the $i$th bit of a Natural, or the coefficient of $2^i$ in its binary expansion, to 1.

Let $$ n = \sum_{i=0}^\infty 2^{b_i}, $$ where for all $i$, $b_i\in \{0, 1\}$; so finitely many of the bits are 1, and the rest are 0. Then $$ n \gets \begin{cases} n + 2^j & \text{if} \quad b_j = 0, \\ n & \text{otherwise}. \end{cases} $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is index.

Examples

extern crate malachite_base;

use malachite_base::num::logic::traits::BitAccess;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut x = Natural::ZERO;
x.set_bit(2);
x.set_bit(5);
x.set_bit(6);
assert_eq!(x, 100);

fn clear_bit(&mut self, index: u64)

Sets the $i$th bit of a Natural, or the coefficient of $2^i$ in its binary expansion, to 0.

Clearing bits beyond the Natural’s width is allowed; since those bits are already false, clearing them does nothing.

Let $$ n = \sum_{i=0}^\infty 2^{b_i}, $$ where for all $i$, $b_i\in \{0, 1\}$; so finitely many of the bits are 1, and the rest are 0. Then $$ n \gets \begin{cases} n - 2^j & \text{if} \quad b_j = 1, \\ n & \text{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 index.

Examples

extern crate malachite_base;

use malachite_base::num::logic::traits::BitAccess;
use malachite_nz::natural::Natural;

let mut x = Natural::from(0x7fu32);
x.clear_bit(0);
x.clear_bit(1);
x.clear_bit(3);
x.clear_bit(4);
assert_eq!(x, 100);

fn assign_bit(&mut self, index: u64, bit: bool)

Sets the bit at index to whichever value bit is.

fn flip_bit(&mut self, index: u64)

Sets the bit at index to the opposite of its original value.

impl<'a> BitAnd<&'a Natural> for Natural

fn bitand(self, other: &'a Natural) -> Natural

Takes the bitwise and of two Naturals, taking the first by value and the second by reference.

$$ f(x, y) = x \wedge y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(123u32) & &Natural::from(456u32), 72);
assert_eq!(
    Natural::from(10u32).pow(12) & &(Natural::from(10u32).pow(12) - Natural::ONE),
    999999995904u64
);

type Output = Natural

The resulting type after applying the & operator.

impl<'a, 'b> BitAnd<&'a Natural> for &'b Natural

fn bitand(self, other: &'a Natural) -> Natural

Takes the bitwise and of two Naturals, taking both by reference.

$$ f(x, y) = x \wedge y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;

assert_eq!(&Natural::from(123u32) & &Natural::from(456u32), 72);
assert_eq!(
    &Natural::from(10u32).pow(12) & &(Natural::from(10u32).pow(12) - Natural::ONE),
    999999995904u64
);

type Output = Natural

The resulting type after applying the & operator.

impl BitAnd<Natural> for Natural

fn bitand(self, other: Natural) -> Natural

Takes the bitwise and of two Naturals, taking both by value.

$$ f(x, y) = x \wedge y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(123u32) & Natural::from(456u32), 72);
assert_eq!(
    Natural::from(10u32).pow(12) & (Natural::from(10u32).pow(12) - Natural::ONE),
    999999995904u64
);

type Output = Natural

The resulting type after applying the & operator.

impl<'a> BitAnd<Natural> for &'a Natural

fn bitand(self, other: Natural) -> Natural

Takes the bitwise and of two Naturals, taking the first by reference and the seocnd by value.

$$ f(x, y) = x \wedge y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;

assert_eq!(&Natural::from(123u32) & Natural::from(456u32), 72);
assert_eq!(
    &Natural::from(10u32).pow(12) & (Natural::from(10u32).pow(12) - Natural::ONE),
    999999995904u64
);

type Output = Natural

The resulting type after applying the & operator.

impl<'a> BitAndAssign<&'a Natural> for Natural

fn bitand_assign(&mut self, other: &'a Natural)

Bitwise-ands a Natural with another Natural in place, taking the Natural on the right-hand side by reference.

$$ x \gets x \wedge y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

use malachite_nz::natural::Natural;

let mut x = Natural::from(u32::MAX);
x &= &Natural::from(0xf0ffffffu32);
x &= &Natural::from(0xfff0_ffffu32);
x &= &Natural::from(0xfffff0ffu32);
x &= &Natural::from(0xfffffff0u32);
assert_eq!(x, 0xf0f0_f0f0u32);

impl BitAndAssign<Natural> for Natural

fn bitand_assign(&mut self, other: Natural)

Bitwise-ands a Natural with another Natural in place, taking the Natural on the right-hand side by value.

$$ x \gets x \wedge y. $$

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;

let mut x = Natural::from(u32::MAX);
x &= Natural::from(0xf0ffffffu32);
x &= Natural::from(0xfff0_ffffu32);
x &= Natural::from(0xfffff0ffu32);
x &= Natural::from(0xfffffff0u32);
assert_eq!(x, 0xf0f0_f0f0u32);

impl BitBlockAccess for Natural

fn get_bits(&self, start: u64, end: u64) -> Natural

Extracts a block of adjacent bits from a Natural, taking the Natural by reference.

The first index is start and last index is end - 1.

Let $n$ be self, and let $p$ and $q$ be start and end, respectively.

Let $$ n = \sum_{i=0}^\infty 2^{b_i}, $$ where for all $i$, $b_i\in \{0, 1\}$; so finitely many of the bits are 1, and the rest are 0. Then $$ f(n, p, q) = \sum_{i=p}^{q-1} 2^{b_{i-p}}. $$

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 start > end.

Examples

extern crate malachite_base;

use malachite_base::num::logic::traits::BitBlockAccess;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(0xabcdef0112345678u64).get_bits(16, 48), 0xef011234u32);
assert_eq!(Natural::from(0xabcdef0112345678u64).get_bits(4, 16), 0x567u32);
assert_eq!(Natural::from(0xabcdef0112345678u64).get_bits(0, 100), 0xabcdef0112345678u64);
assert_eq!(Natural::from(0xabcdef0112345678u64).get_bits(10, 10), 0);

fn get_bits_owned(self, start: u64, end: u64) -> Natural

Extracts a block of adjacent bits from a Natural, taking the Natural by value.

The first index is start and last index is end - 1.

Let $n$ be self, and let $p$ and $q$ be start and end, respectively.

Let $$ n = \sum_{i=0}^\infty 2^{b_i}, $$ where for all $i$, $b_i\in \{0, 1\}$; so finitely many of the bits are 1, and the rest are 0. Then $$ f(n, p, q) = \sum_{i=p}^{q-1} 2^{b_{i-p}}. $$

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 start > end.

Examples

extern crate malachite_base;

use malachite_base::num::logic::traits::BitBlockAccess;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(0xabcdef0112345678u64).get_bits_owned(16, 48), 0xef011234u32);
assert_eq!(Natural::from(0xabcdef0112345678u64).get_bits_owned(4, 16), 0x567u32);
assert_eq!(
    Natural::from(0xabcdef0112345678u64).get_bits_owned(0, 100),
    0xabcdef0112345678u64
);
assert_eq!(Natural::from(0xabcdef0112345678u64).get_bits_owned(10, 10), 0);

fn assign_bits(&mut self, start: u64, end: u64, bits: &Natural)

Replaces a block of adjacent bits in a Natural with other bits.

The least-significant end - start bits of bits are assigned to bits start through end - 1, inclusive, of self.

Let $n$ be self and let $m$ be bits, and let $p$ and $q$ be start and end, respectively.

If bits has fewer bits than end - start, the high bits are interpreted as 0. Let $$ n = \sum_{i=0}^\infty 2^{b_i}, $$ where for all $i$, $b_i\in \{0, 1\}$; so finitely many of the bits are 1, and the rest are 0. Let $$ m = \sum_{i=0}^k 2^{d_i}, $$ where for all $i$, $d_i\in \{0, 1\}$. Also, let $p, q \in \mathbb{N}$, and let $W$ be max(self.significant_bits(), end + 1).

Then $$ n \gets \sum_{i=0}^{W-1} 2^{c_i}, $$ where $$ \{c_0, c_1, c_2, \ldots, c_ {W-1}\} = \{b_0, b_1, b_2, \ldots, b_{p-1}, d_0, d_1, \ldots, d_{p-q-1}, b_q, \ldots, b_ {W-1}\}. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is end.

Panics

Panics if start > end.

Examples

extern crate malachite_base;

use malachite_base::num::logic::traits::BitBlockAccess;
use malachite_nz::natural::Natural;

let mut n = Natural::from(123u32);
n.assign_bits(5, 7, &Natural::from(456u32));
assert_eq!(n, 27);

let mut n = Natural::from(123u32);
n.assign_bits(64, 128, &Natural::from(456u32));
assert_eq!(n.to_string(), "8411715297611555537019");

let mut n = Natural::from(123u32);
n.assign_bits(80, 100, &Natural::from(456u32));
assert_eq!(n.to_string(), "551270173744270903666016379");

type Bits = Natural

impl BitConvertible for Natural

fn to_bits_asc(&self) -> Vec<bool>

Returns a Vec containing the bits of a Natural in ascending order: least- to most-significant.

If the number is 0, the Vec is empty; otherwise, it ends with true.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::logic::traits::BitConvertible;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert!(Natural::ZERO.to_bits_asc().is_empty());
// 105 = 1101001b
assert_eq!(
    Natural::from(105u32).to_bits_asc(),
    &[true, false, false, true, false, true, true]
);

fn to_bits_desc(&self) -> Vec<bool>

Returns a Vec containing the bits of a Natural in descending order: most- to least-significant.

If the number is 0, the Vec is empty; otherwise, it begins with true.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::logic::traits::BitConvertible;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert!(Natural::ZERO.to_bits_desc().is_empty());
// 105 = 1101001b
assert_eq!(
    Natural::from(105u32).to_bits_desc(),
    &[true, true, false, true, false, false, true]
);

fn from_bits_asc<I: Iterator<Item = bool>>(xs: I) -> Natural

Converts an iterator of bits into a Natural. The bits should be in ascending order (least- to most-significant).

$$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^i [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is xs.count().

Examples

extern crate malachite_base;

use malachite_base::num::logic::traits::BitConvertible;
use malachite_nz::natural::Natural;
use std::iter::empty;

assert_eq!(Natural::from_bits_asc(empty()), 0);
// 105 = 1101001b
assert_eq!(
    Natural::from_bits_asc([true, false, false, true, false, true, true].iter().cloned()),
    105
);

fn from_bits_desc<I: Iterator<Item = bool>>(xs: I) -> Natural

Converts an iterator of bits into a Natural. The bits should be in descending order (most- to least-significant).

$$ f((b_i)_ {i=0}^{k-1}) = \sum_{i=0}^{k-1}2^{k-i-1} [b_i], $$ where braces denote the Iverson bracket, which converts a bit to 0 or 1.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is xs.count().

Examples

extern crate malachite_base;

use malachite_base::num::logic::traits::BitConvertible;
use malachite_nz::natural::Natural;
use std::iter::empty;

assert_eq!(Natural::from_bits_desc(empty()), 0);
// 105 = 1101001b
assert_eq!(
    Natural::from_bits_desc([true, true, false, true, false, false, true].iter().cloned()),
    105
);

impl<'a> BitIterable for &'a Natural

fn bits(self) -> NaturalBitIterator<'a>

Returns a double-ended iterator over the bits of a Natural.

The forward order is ascending, so that less significant bits appear first. There are no trailing false bits going forward, or leading falses going backward.

If it’s necessary to get a Vec of all the bits, consider using to_bits_asc or to_bits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_base::num::logic::traits::BitIterable;
use malachite_nz::natural::Natural;

assert!(Natural::ZERO.bits().next().is_none());
// 105 = 1101001b
assert_eq!(
    Natural::from(105u32).bits().collect::<Vec<bool>>(),
    &[true, false, false, true, false, true, true]
);

assert!(Natural::ZERO.bits().next_back().is_none());
// 105 = 1101001b
assert_eq!(
    Natural::from(105u32).bits().rev().collect::<Vec<bool>>(),
    &[true, true, false, true, false, false, true]
);

type BitIterator = NaturalBitIterator<'a>

impl<'a> BitOr<&'a Natural> for Natural

fn bitor(self, other: &'a Natural) -> Natural

Takes the bitwise or of two Naturals, taking the first by value and the second by reference.

$$ f(x, y) = x \vee y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(123u32) | &Natural::from(456u32), 507);
assert_eq!(
    Natural::from(10u32).pow(12) | &(Natural::from(10u32).pow(12) - Natural::ONE),
    1000000004095u64
);

type Output = Natural

The resulting type after applying the | operator.

impl<'a, 'b> BitOr<&'a Natural> for &'b Natural

fn bitor(self, other: &'a Natural) -> Natural

Takes the bitwise or of two Naturals, taking both by reference.

$$ f(x, y) = x \vee y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;

assert_eq!(&Natural::from(123u32) | &Natural::from(456u32), 507);
assert_eq!(
    &Natural::from(10u32).pow(12) | &(Natural::from(10u32).pow(12) - Natural::ONE),
    1000000004095u64
);

type Output = Natural

The resulting type after applying the | operator.

impl BitOr<Natural> for Natural

fn bitor(self, other: Natural) -> Natural

Takes the bitwise or of two Naturals, taking both by value.

$$ f(x, y) = x \vee y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(123u32) | Natural::from(456u32), 507);
assert_eq!(
    Natural::from(10u32).pow(12) | (Natural::from(10u32).pow(12) - Natural::ONE),
    1000000004095u64
);

type Output = Natural

The resulting type after applying the | operator.

impl<'a> BitOr<Natural> for &'a Natural

fn bitor(self, other: Natural) -> Natural

Takes the bitwise or of two Naturals, taking the first by reference and the second by value.

$$ f(x, y) = x \vee y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;

assert_eq!(&Natural::from(123u32) | Natural::from(456u32), 507);
assert_eq!(
    &Natural::from(10u32).pow(12) | (Natural::from(10u32).pow(12) - Natural::ONE),
    1000000004095u64
);

type Output = Natural

The resulting type after applying the | operator.

impl<'a> BitOrAssign<&'a Natural> for Natural

fn bitor_assign(&mut self, other: &'a Natural)

Bitwise-ors a Natural with another Natural in place, taking the Natural on the right-hand side by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

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

let mut x = Natural::ZERO;
x |= &Natural::from(0x0000000fu32);
x |= &Natural::from(0x00000f00u32);
x |= &Natural::from(0x000f_0000u32);
x |= &Natural::from(0x0f000000u32);
assert_eq!(x, 0x0f0f_0f0f);

impl BitOrAssign<Natural> for Natural

fn bitor_assign(&mut self, other: Natural)

Bitwise-ors a Natural with another Natural in place, taking the Natural on the right-hand side by value.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

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

let mut x = Natural::ZERO;
x |= Natural::from(0x0000000fu32);
x |= Natural::from(0x00000f00u32);
x |= Natural::from(0x000f_0000u32);
x |= Natural::from(0x0f000000u32);
assert_eq!(x, 0x0f0f_0f0f);

impl<'a> BitScan for &'a Natural

fn index_of_next_false_bit(self, start: u64) -> Option<u64>

Given a Natural and a starting index, searches the Natural for the smallest index of a false bit that is greater than or equal to the starting index.

Since every Natural has an implicit prefix of infinitely-many zeros, this function always returns a value.

Starting beyond the Natural’s width is allowed; the result is the starting index.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::logic::traits::BitScan;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(0xb00000000u64).index_of_next_false_bit(0), Some(0));
assert_eq!(Natural::from(0xb00000000u64).index_of_next_false_bit(20), Some(20));
assert_eq!(Natural::from(0xb00000000u64).index_of_next_false_bit(31), Some(31));
assert_eq!(Natural::from(0xb00000000u64).index_of_next_false_bit(32), Some(34));
assert_eq!(Natural::from(0xb00000000u64).index_of_next_false_bit(33), Some(34));
assert_eq!(Natural::from(0xb00000000u64).index_of_next_false_bit(34), Some(34));
assert_eq!(Natural::from(0xb00000000u64).index_of_next_false_bit(35), Some(36));
assert_eq!(Natural::from(0xb00000000u64).index_of_next_false_bit(100), Some(100));

fn index_of_next_true_bit(self, start: u64) -> Option<u64>

Given a Natural and a starting index, searches the Natural for the smallest index of a true bit that is greater than or equal to the starting index.

If the starting index is greater than or equal to the Natural’s width, the result is None since there are no true bits past that point.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::logic::traits::BitScan;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(0xb00000000u64).index_of_next_true_bit(0), Some(32));
assert_eq!(Natural::from(0xb00000000u64).index_of_next_true_bit(20), Some(32));
assert_eq!(Natural::from(0xb00000000u64).index_of_next_true_bit(31), Some(32));
assert_eq!(Natural::from(0xb00000000u64).index_of_next_true_bit(32), Some(32));
assert_eq!(Natural::from(0xb00000000u64).index_of_next_true_bit(33), Some(33));
assert_eq!(Natural::from(0xb00000000u64).index_of_next_true_bit(34), Some(35));
assert_eq!(Natural::from(0xb00000000u64).index_of_next_true_bit(35), Some(35));
assert_eq!(Natural::from(0xb00000000u64).index_of_next_true_bit(36), None);
assert_eq!(Natural::from(0xb00000000u64).index_of_next_true_bit(100), None);

impl<'a> BitXor<&'a Natural> for Natural

fn bitxor(self, other: &'a Natural) -> Natural

Takes the bitwise xor of two Naturals, taking the first by value and the second by reference.

$$ f(x, y) = x \oplus y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(123u32) ^ &Natural::from(456u32), 435);
assert_eq!(
    Natural::from(10u32).pow(12) ^ &(Natural::from(10u32).pow(12) - Natural::ONE),
    8191
);

type Output = Natural

The resulting type after applying the ^ operator.

impl<'a, 'b> BitXor<&'a Natural> for &'b Natural

fn bitxor(self, other: &'a Natural) -> Natural

Takes the bitwise xor of two Naturals, taking both by reference.

$$ f(x, y) = x \oplus y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;

assert_eq!(&Natural::from(123u32) ^ &Natural::from(456u32), 435);
assert_eq!(
    &Natural::from(10u32).pow(12) ^ &(Natural::from(10u32).pow(12) - Natural::ONE),
    8191
);

type Output = Natural

The resulting type after applying the ^ operator.

impl BitXor<Natural> for Natural

fn bitxor(self, other: Natural) -> Natural

Takes the bitwise xor of two Naturals, taking both by value.

$$ f(x, y) = x \oplus y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(123u32) ^ Natural::from(456u32), 435);
assert_eq!(
    Natural::from(10u32).pow(12) ^ (Natural::from(10u32).pow(12) - Natural::ONE),
    8191
);

type Output = Natural

The resulting type after applying the ^ operator.

impl<'a> BitXor<Natural> for &'a Natural

fn bitxor(self, other: Natural) -> Natural

Takes the bitwise xor of two Naturals, taking the first by reference and the second by value.

$$ f(x, y) = x \oplus y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;

assert_eq!(&Natural::from(123u32) ^ Natural::from(456u32), 435);
assert_eq!(
    &Natural::from(10u32).pow(12) ^ (Natural::from(10u32).pow(12) - Natural::ONE),
    8191
);

type Output = Natural

The resulting type after applying the ^ operator.

impl<'a> BitXorAssign<&'a Natural> for Natural

fn bitxor_assign(&mut self, other: &'a Natural)

Bitwise-xors a Natural with another Natural in place, taking the Natural on the right-hand side by reference.

$$ x \gets x \oplus y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

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

let mut x = Natural::ZERO;
x |= Natural::from(0x0000000fu32);
x |= Natural::from(0x00000f00u32);
x |= Natural::from(0x000f_0000u32);
x |= Natural::from(0x0f000000u32);
assert_eq!(x, 0x0f0f_0f0f);

impl BitXorAssign<Natural> for Natural

fn bitxor_assign(&mut self, other: Natural)

Bitwise-xors a Natural with another Natural in place, taking the Natural on the right-hand side by value.

$$ x \gets x \oplus y. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

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

let mut x = Natural::ZERO;
x ^= Natural::from(0x0000000fu32);
x ^= Natural::from(0x00000f00u32);
x ^= Natural::from(0x000f_0000u32);
x ^= Natural::from(0x0f000000u32);
assert_eq!(x, 0x0f0f_0f0f);

impl<'a> CeilingDivAssignNegMod<&'a Natural> for Natural

fn ceiling_div_assign_neg_mod(&mut self, other: &'a Natural) -> Natural

Divides a Natural by another Natural in place, taking the Natural on the right-hand side by reference and returning the remainder of the negative of the first number divided by the second.

The quotient and remainder satisfy $x = qy - r$ and $0 \leq r < y$.

$$ f(x, y) = y\left \lceil \frac{x}{y} \right \rceil - x, $$ $$ x \gets \left \lceil \frac{x}{y} \right \rceil. $$

Worst-case complexity

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

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

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

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingDivAssignNegMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 3 * 10 - 7 = 23
let mut x = Natural::from(23u32);
assert_eq!(x.ceiling_div_assign_neg_mod(&Natural::from(10u32)), 7);
assert_eq!(x, 3);

// 810000006724 * 1234567890987 - 704498996588 = 1000000000000000000000000
let mut x = Natural::from_str("1000000000000000000000000").unwrap();
assert_eq!(
    x.ceiling_div_assign_neg_mod(&Natural::from_str("1234567890987").unwrap()),
    704498996588u64,
);
assert_eq!(x, 810000006724u64);

type ModOutput = Natural

impl CeilingDivAssignNegMod<Natural> for Natural

fn ceiling_div_assign_neg_mod(&mut self, other: Natural) -> Natural

Divides a Natural by another Natural in place, taking the Natural on the right-hand side by value and returning the remainder of the negative of the first number divided by the second.

The quotient and remainder satisfy $x = qy - r$ and $0 \leq r < y$.

$$ f(x, y) = y\left \lceil \frac{x}{y} \right \rceil - x, $$ $$ x \gets \left \lceil \frac{x}{y} \right \rceil. $$

Worst-case complexity

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

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

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

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingDivAssignNegMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 3 * 10 - 7 = 23
let mut x = Natural::from(23u32);
assert_eq!(x.ceiling_div_assign_neg_mod(Natural::from(10u32)), 7);
assert_eq!(x, 3);

// 810000006724 * 1234567890987 - 704498996588 = 1000000000000000000000000
let mut x = Natural::from_str("1000000000000000000000000").unwrap();
assert_eq!(
    x.ceiling_div_assign_neg_mod(Natural::from_str("1234567890987").unwrap()),
    704498996588u64,
);
assert_eq!(x, 810000006724u64);

type ModOutput = Natural

impl<'a> CeilingDivNegMod<&'a Natural> for Natural

fn ceiling_div_neg_mod(self, other: &'a Natural) -> (Natural, Natural)

Divides a Natural by another Natural, taking the first by value and the second by reference and returning the ceiling of the quotient and the remainder of the negative of the first Natural divided by the second.

The quotient and remainder satisfy $x = qy - r$ and $0 \leq r < y$.

$$ f(x, y) = \left ( \left \lceil \frac{x}{y} \right \rceil, \space y\left \lceil \frac{x}{y} \right \rceil - x \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().

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingDivNegMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 3 * 10 - 7 = 23
assert_eq!(
    Natural::from(23u32).ceiling_div_neg_mod(&Natural::from(10u32)).to_debug_string(),
    "(3, 7)"
);

// 810000006724 * 1234567890987 - 704498996588 = 1000000000000000000000000
assert_eq!(
    Natural::from_str("1000000000000000000000000").unwrap()
            .ceiling_div_neg_mod(&Natural::from_str("1234567890987").unwrap())
            .to_debug_string(),
    "(810000006724, 704498996588)"
);

type DivOutput = Natural

type ModOutput = Natural

impl<'a, 'b> CeilingDivNegMod<&'b Natural> for &'a Natural

fn ceiling_div_neg_mod(self, other: &'b Natural) -> (Natural, Natural)

Divides a Natural by another Natural, taking both by reference and returning the ceiling of the quotient and the remainder of the negative of the first Natural divided by the second.

The quotient and remainder satisfy $x = qy - r$ and $0 \leq r < y$.

$$ f(x, y) = \left ( \left \lceil \frac{x}{y} \right \rceil, \space y\left \lceil \frac{x}{y} \right \rceil - x \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().

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingDivNegMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 3 * 10 - 7 = 23
assert_eq!(
    (&Natural::from(23u32)).ceiling_div_neg_mod(&Natural::from(10u32)).to_debug_string(),
    "(3, 7)"
);

// 810000006724 * 1234567890987 - 704498996588 = 1000000000000000000000000
assert_eq!(
    (&Natural::from_str("1000000000000000000000000").unwrap())
            .ceiling_div_neg_mod(&Natural::from_str("1234567890987").unwrap())
            .to_debug_string(),
    "(810000006724, 704498996588)"
);

type DivOutput = Natural

type ModOutput = Natural

impl CeilingDivNegMod<Natural> for Natural

fn ceiling_div_neg_mod(self, other: Natural) -> (Natural, Natural)

Divides a Natural by another Natural, taking both by value and returning the ceiling of the quotient and the remainder of the negative of the first Natural divided by the second.

The quotient and remainder satisfy $x = qy - r$ and $0 \leq r < y$.

$$ f(x, y) = \left ( \left \lceil \frac{x}{y} \right \rceil, \space y\left \lceil \frac{x}{y} \right \rceil - x \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().

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingDivNegMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 3 * 10 - 7 = 23
assert_eq!(
    Natural::from(23u32).ceiling_div_neg_mod(Natural::from(10u32)).to_debug_string(),
    "(3, 7)"
);

// 810000006724 * 1234567890987 - 704498996588 = 1000000000000000000000000
assert_eq!(
    Natural::from_str("1000000000000000000000000").unwrap()
            .ceiling_div_neg_mod(Natural::from_str("1234567890987").unwrap())
            .to_debug_string(),
    "(810000006724, 704498996588)"
);

type DivOutput = Natural

type ModOutput = Natural

impl<'a> CeilingDivNegMod<Natural> for &'a Natural

fn ceiling_div_neg_mod(self, other: Natural) -> (Natural, Natural)

Divides a Natural by another Natural, taking the first by reference and the second by value and returning the ceiling of the quotient and the remainder of the negative of the first Natural divided by the second.

The quotient and remainder satisfy $x = qy - r$ and $0 \leq r < y$.

$$ f(x, y) = \left ( \left \lceil \frac{x}{y} \right \rceil, \space y\left \lceil \frac{x}{y} \right \rceil - x \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().

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingDivNegMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 3 * 10 - 7 = 23
assert_eq!(
    (&Natural::from(23u32)).ceiling_div_neg_mod(Natural::from(10u32)).to_debug_string(),
    "(3, 7)"
);

// 810000006724 * 1234567890987 - 704498996588 = 1000000000000000000000000
assert_eq!(
    (&Natural::from_str("1000000000000000000000000").unwrap())
            .ceiling_div_neg_mod(Natural::from_str("1234567890987").unwrap())
            .to_debug_string(),
    "(810000006724, 704498996588)"
);

type DivOutput = Natural

type ModOutput = Natural

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

fn ceiling_log_base(self, base: &Natural) -> u64

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

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

Worst-case complexity

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

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

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

Panics

Panics if self is 0 or base is less than 2.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingLogBase;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(80u32).ceiling_log_base(&Natural::from(3u32)), 4);
assert_eq!(Natural::from(81u32).ceiling_log_base(&Natural::from(3u32)), 4);
assert_eq!(Natural::from(82u32).ceiling_log_base(&Natural::from(3u32)), 5);
assert_eq!(Natural::from(4294967296u64).ceiling_log_base(&Natural::from(10u32)), 10);

This is equivalent to fmpz_clog from fmpz/clog.c, FLINT 2.7.1.

type Output = u64

impl<'a> CeilingLogBase2 for &'a Natural

fn ceiling_log_base_2(self) -> u64

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

$f(x) = \lceil\log_2 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 0.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingLogBase2;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).ceiling_log_base_2(), 2);
assert_eq!(Natural::from(100u32).ceiling_log_base_2(), 7);

type Output = u64

impl<'a> CeilingLogBasePowerOf2<u64> for &'a Natural

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingLogBasePowerOf2;
use malachite_nz::natural::Natural;

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

type Output = u64

impl CeilingRoot<u64> for Natural

fn ceiling_root(self, exp: u64) -> Natural

Returns the ceiling of the $n$th root of a Natural, taking the Natural by value.

$f(x, n) = \lceil\sqrt[n]{x}\rceil$.

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.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingRoot;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(999u16).ceiling_root(3), 10);
assert_eq!(Natural::from(1000u16).ceiling_root(3), 10);
assert_eq!(Natural::from(1001u16).ceiling_root(3), 11);
assert_eq!(Natural::from(100000000000u64).ceiling_root(5), 159);

type Output = Natural

impl<'a> CeilingRoot<u64> for &'a Natural

fn ceiling_root(self, exp: u64) -> Natural

Returns the ceiling of the $n$th root of a Natural, taking the Natural by reference.

$f(x, n) = \lceil\sqrt[n]{x}\rceil$.

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.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingRoot;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(999u16).ceiling_root(3), 10);
assert_eq!(Natural::from(1000u16).ceiling_root(3), 10);
assert_eq!(Natural::from(1001u16).ceiling_root(3), 11);
assert_eq!(Natural::from(100000000000u64).ceiling_root(5), 159);

type Output = Natural

impl CeilingRootAssign<u64> for Natural

fn ceiling_root_assign(&mut self, exp: u64)

Replaces a Natural with the ceiling of its $n$th root.

$x \gets \lceil\sqrt[n]{x}\rceil$.

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.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingRootAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(999u16);
x.ceiling_root_assign(3);
assert_eq!(x, 10);

let mut x = Natural::from(1000u16);
x.ceiling_root_assign(3);
assert_eq!(x, 10);

let mut x = Natural::from(1001u16);
x.ceiling_root_assign(3);
assert_eq!(x, 11);

let mut x = Natural::from(100000000000u64);
x.ceiling_root_assign(5);
assert_eq!(x, 159);

impl CeilingSqrt for Natural

fn ceiling_sqrt(self) -> Natural

Returns the ceiling of the square root of a Natural, taking it by value.

$f(x) = \lceil\sqrt{x}\rceil$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingSqrt;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(99u8).ceiling_sqrt(), 10);
assert_eq!(Natural::from(100u8).ceiling_sqrt(), 10);
assert_eq!(Natural::from(101u8).ceiling_sqrt(), 11);
assert_eq!(Natural::from(1000000000u32).ceiling_sqrt(), 31623);
assert_eq!(Natural::from(10000000000u64).ceiling_sqrt(), 100000);

type Output = Natural

impl<'a> CeilingSqrt for &'a Natural

fn ceiling_sqrt(self) -> Natural

Returns the ceiling of the square root of a Natural, taking it by value.

$f(x) = \lceil\sqrt{x}\rceil$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingSqrt;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(99u8).ceiling_sqrt(), 10);
assert_eq!(Natural::from(100u8).ceiling_sqrt(), 10);
assert_eq!(Natural::from(101u8).ceiling_sqrt(), 11);
assert_eq!(Natural::from(1000000000u32).ceiling_sqrt(), 31623);
assert_eq!(Natural::from(10000000000u64).ceiling_sqrt(), 100000);

type Output = Natural

impl CeilingSqrtAssign for Natural

fn ceiling_sqrt_assign(&mut self)

Replaces a Natural with the ceiling of its square root.

$x \gets \lceil\sqrt{x}\rceil$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CeilingSqrtAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(99u8);
x.ceiling_sqrt_assign();
assert_eq!(x, 10);

let mut x = Natural::from(100u8);
x.ceiling_sqrt_assign();
assert_eq!(x, 10);

let mut x = Natural::from(101u8);
x.ceiling_sqrt_assign();
assert_eq!(x, 11);

let mut x = Natural::from(1000000000u32);
x.ceiling_sqrt_assign();
assert_eq!(x, 31623);

let mut x = Natural::from(10000000000u64);
x.ceiling_sqrt_assign();
assert_eq!(x, 100000);

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

fn checked_from(value: &'a Integer) -> Option<Natural>

Converts an Integer to a Natural, taking the Natural by reference. If the Integer is negative, None is returned.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::CheckedFrom;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert_eq!(Natural::checked_from(&Integer::from(123)).to_debug_string(), "Some(123)");
assert_eq!(Natural::checked_from(&Integer::from(-123)).to_debug_string(), "None");
assert_eq!(
    Natural::checked_from(&Integer::from(10u32).pow(12)).to_debug_string(),
    "Some(1000000000000)"
);
assert_eq!(
    Natural::checked_from(&(-Integer::from(10u32).pow(12))).to_debug_string(),
    "None"
);

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

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

Converts a Natural to a primitive float.

If the input isn’t exactly equal to some float, None is returned.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

See here.

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

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

Converts a Natural to a primitive float.

If the input isn’t exactly equal to some float, None is returned.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

See here.

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

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

Converts a Natural to a SignedLimb (the signed type whose width is the same as a limb’s), returning None if the Natural is too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

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

Converts a Natural to an isize or value of a signed primitive integer type that’s larger than a Limb, returning None if the Natural is too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

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

Converts a Natural to a value of an unsigned primitive integer type that’s larger than a Limb, returning None if the Natural is too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

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

Converts a Natural to an isize or value of a signed primitive integer type that’s larger than a Limb, returning None if the Natural is too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

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

Converts a Natural to a usize, returning None if the Natural is too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

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

Converts a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb, returning None if the Natural is too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

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

Converts a Natural to a value of a signed primitive integer type that’s smaller than a Limb, returning None if the Natural is too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

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

Converts a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb, returning None if the Natural is too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

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

Converts a Natural to a value of a signed primitive integer type that’s smaller than a Limb, returning None if the Natural is too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

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

Converts a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb, returning None if the Natural is too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

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

Converts a Natural to a value of a signed primitive integer type that’s smaller than a Limb, returning None if the Natural is too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

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

Converts a Natural to a Limb, returning None if the Natural is too large.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl CheckedFrom<Integer> for Natural

fn checked_from(value: Integer) -> Option<Natural>

Converts an Integer to a Natural, taking the Natural by value. If the Integer is negative, None is returned.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::CheckedFrom;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert_eq!(Natural::checked_from(Integer::from(123)).to_debug_string(), "Some(123)");
assert_eq!(Natural::checked_from(Integer::from(-123)).to_debug_string(), "None");
assert_eq!(
    Natural::checked_from(Integer::from(10u32).pow(12)).to_debug_string(),
    "Some(1000000000000)"
);
assert_eq!(Natural::checked_from(-Integer::from(10u32).pow(12)).to_debug_string(), "None");

impl CheckedFrom<f32> for Natural

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

Converts a floating-point value to a Natural type.

If the input isn’t exactly equal to some Natural, None is returned.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

See here.

impl CheckedFrom<f64> for Natural

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

Converts a floating-point value to a Natural type.

If the input isn’t exactly equal to some Natural, None is returned.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

See here.

impl CheckedFrom<i128> for Natural

fn checked_from(i: i128) -> Option<Natural>

Converts a signed primitive integer to a Natural. If the integer is negative, None is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl CheckedFrom<i16> for Natural

fn checked_from(i: i16) -> Option<Natural>

Converts a signed primitive integer to a Natural. If the integer is negative, None is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl CheckedFrom<i32> for Natural

fn checked_from(i: i32) -> Option<Natural>

Converts a signed primitive integer to a Natural. If the integer is negative, None is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl CheckedFrom<i64> for Natural

fn checked_from(i: i64) -> Option<Natural>

Converts a signed primitive integer to a Natural. If the integer is negative, None is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl CheckedFrom<i8> for Natural

fn checked_from(i: i8) -> Option<Natural>

Converts a signed primitive integer to a Natural. If the integer is negative, None is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl CheckedFrom<isize> for Natural

fn checked_from(i: isize) -> Option<Natural>

Converts a signed primitive integer to a Natural. If the integer is negative, None is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

fn checked_log_base(self, base: &Natural) -> Option<u64>

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

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

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

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

Panics

Panics if self is 0 or base is less than 2.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedLogBase;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(80u32).checked_log_base(&Natural::from(3u32)), None);
assert_eq!(Natural::from(81u32).checked_log_base(&Natural::from(3u32)), Some(4));
assert_eq!(Natural::from(82u32).checked_log_base(&Natural::from(3u32)), None);
assert_eq!(Natural::from(4294967296u64).checked_log_base(&Natural::from(10u32)), None);

type Output = u64

impl<'a> CheckedLogBase2 for &'a Natural

fn checked_log_base_2(self) -> Option<u64>

Returns the base-2 logarithm of a positive Natural. If the Natural 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 0.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedLogBase2;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(Natural::from(3u32).checked_log_base_2(), None);
assert_eq!(Natural::from(4u32).checked_log_base_2(), Some(2));
assert_eq!(
    Natural::from_str("1267650600228229401496703205376").unwrap().checked_log_base_2(),
    Some(100)
);

type Output = u64

impl<'a> CheckedLogBasePowerOf2<u64> for &'a Natural

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

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

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if self is 0 or pow is 0.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedLogBasePowerOf2;
use malachite_nz::natural::Natural;
use std::str::FromStr;

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

type Output = u64

impl CheckedRoot<u64> for Natural

fn checked_root(self, exp: u64) -> Option<Natural>

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedRoot;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(999u16).checked_root(3).to_debug_string(), "None");
assert_eq!(Natural::from(1000u16).checked_root(3).to_debug_string(), "Some(10)");
assert_eq!(Natural::from(1001u16).checked_root(3).to_debug_string(), "None");
assert_eq!(Natural::from(100000000000u64).checked_root(5).to_debug_string(), "None");
assert_eq!(Natural::from(10000000000u64).checked_root(5).to_debug_string(), "Some(100)");

type Output = Natural

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

fn checked_root(self, exp: u64) -> Option<Natural>

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedRoot;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(999u16)).checked_root(3).to_debug_string(), "None");
assert_eq!((&Natural::from(1000u16)).checked_root(3).to_debug_string(), "Some(10)");
assert_eq!((&Natural::from(1001u16)).checked_root(3).to_debug_string(), "None");
assert_eq!((&Natural::from(100000000000u64)).checked_root(5).to_debug_string(), "None");
assert_eq!(
    (&Natural::from(10000000000u64)).checked_root(5).to_debug_string(),
    "Some(100)"
);

type Output = Natural

impl CheckedSqrt for Natural

fn checked_sqrt(self) -> Option<Natural>

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedSqrt;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(99u8).checked_sqrt().to_debug_string(), "None");
assert_eq!(Natural::from(100u8).checked_sqrt().to_debug_string(), "Some(10)");
assert_eq!(Natural::from(101u8).checked_sqrt().to_debug_string(), "None");
assert_eq!(Natural::from(1000000000u32).checked_sqrt().to_debug_string(), "None");
assert_eq!(Natural::from(10000000000u64).checked_sqrt().to_debug_string(), "Some(100000)");

type Output = Natural

impl<'a> CheckedSqrt for &'a Natural

fn checked_sqrt(self) -> Option<Natural>

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CheckedSqrt;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(99u8)).checked_sqrt().to_debug_string(), "None");
assert_eq!((&Natural::from(100u8)).checked_sqrt().to_debug_string(), "Some(10)");
assert_eq!((&Natural::from(101u8)).checked_sqrt().to_debug_string(), "None");
assert_eq!((&Natural::from(1000000000u32)).checked_sqrt().to_debug_string(), "None");
assert_eq!(
    (&Natural::from(10000000000u64)).checked_sqrt().to_debug_string(),
    "Some(100000)"
);

type Output = Natural

impl<'a> CheckedSub<&'a Natural> for Natural

fn checked_sub(self, other: &'a Natural) -> Option<Natural>

Subtracts a Natural by another Natural, taking the first by value and the second by reference and returning None if the result is negative.

$$ f(x, y) = \begin{cases} \operatorname{Some}(x - y) & \text{if} \quad x \geq y, \\ \operatorname{None} & \text{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().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{CheckedSub, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.checked_sub(&Natural::from(123u32)).to_debug_string(), "None");
assert_eq!(
    Natural::from(123u32).checked_sub(&Natural::ZERO).to_debug_string(),
    "Some(123)"
);
assert_eq!(Natural::from(456u32).checked_sub(&Natural::from(123u32)).to_debug_string(),
    "Some(333)");
assert_eq!(
    (Natural::from(10u32).pow(12) * Natural::from(3u32))
            .checked_sub(&Natural::from(10u32).pow(12)).to_debug_string(),
    "Some(2000000000000)"
);

type Output = Natural

impl<'a, 'b> CheckedSub<&'a Natural> for &'b Natural

fn checked_sub(self, other: &'a Natural) -> Option<Natural>

Subtracts a Natural by another Natural, taking both by reference and returning None if the result is negative.

$$ f(x, y) = \begin{cases} \operatorname{Some}(x - y) & \text{if} \quad x \geq y, \\ \operatorname{None} & \text{otherwise}. \end{cases} $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{CheckedSub, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::ZERO).checked_sub(&Natural::from(123u32)).to_debug_string(), "None");
assert_eq!((&Natural::from(123u32)).checked_sub(&Natural::ZERO).to_debug_string(),
    "Some(123)");
assert_eq!((&Natural::from(456u32)).checked_sub(&Natural::from(123u32)).to_debug_string(),
    "Some(333)");
assert_eq!(
    (&(Natural::from(10u32).pow(12) * Natural::from(3u32)))
            .checked_sub(&Natural::from(10u32).pow(12)).to_debug_string(),
    "Some(2000000000000)"
);

type Output = Natural

impl CheckedSub<Natural> for Natural

fn checked_sub(self, other: Natural) -> Option<Natural>

Subtracts a Natural by another Natural, taking both by value and returning None if the result is negative.

$$ f(x, y) = \begin{cases} \operatorname{Some}(x - y) & \text{if} \quad x \geq y, \\ \operatorname{None} & \text{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().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{CheckedSub, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.checked_sub(Natural::from(123u32)).to_debug_string(), "None");
assert_eq!(
    Natural::from(123u32).checked_sub(Natural::ZERO).to_debug_string(),
    "Some(123)"
);
assert_eq!(
    Natural::from(456u32).checked_sub(Natural::from(123u32)).to_debug_string(),
    "Some(333)"
);
assert_eq!(
    (Natural::from(10u32).pow(12) * Natural::from(3u32))
            .checked_sub(Natural::from(10u32).pow(12)).to_debug_string(),
    "Some(2000000000000)"
);

type Output = Natural

impl<'a> CheckedSub<Natural> for &'a Natural

fn checked_sub(self, other: Natural) -> Option<Natural>

Subtracts a Natural by another Natural, taking the first by reference and the second by value and returning None if the result is negative.

$$ f(x, y) = \begin{cases} \operatorname{Some}(x - y) & \text{if} \quad x \geq y, \\ \operatorname{None} & \text{otherwise}. \end{cases} $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{CheckedSub, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::ZERO).checked_sub(Natural::from(123u32)).to_debug_string(), "None");
assert_eq!((&Natural::from(123u32)).checked_sub(Natural::ZERO).to_debug_string(),
    "Some(123)");
assert_eq!((&Natural::from(456u32)).checked_sub(Natural::from(123u32)).to_debug_string(),
    "Some(333)");
assert_eq!(
    (&(Natural::from(10u32).pow(12) * Natural::from(3u32)))
            .checked_sub(Natural::from(10u32).pow(12)).to_debug_string(),
    "Some(2000000000000)"
);

type Output = Natural

impl<'a, 'b> CheckedSubMul<&'a Natural, &'b Natural> for Natural

fn checked_sub_mul(self, y: &'a Natural, z: &'b Natural) -> Option<Natural>

Subtracts a Natural by the product of two other Naturals, taking the first by value and the second and third by reference and returning None if the result is negative.

$$ f(x, y, z) = \begin{cases} \operatorname{Some}(x - yz) & \text{if} \quad x \geq yz, \\ \operatorname{None} & \text{otherwise}. \end{cases} $$

Worst-case complexity

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

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

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

Panics

Panics if y * z is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{CheckedSubMul, Pow};
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::from(20u32).checked_sub_mul(&Natural::from(3u32), &Natural::from(4u32))
            .to_debug_string(),
    "Some(8)"
);
assert_eq!(
    Natural::from(10u32).checked_sub_mul(&Natural::from(3u32), &Natural::from(4u32))
            .to_debug_string(),
    "None"
);
assert_eq!(
    Natural::from(10u32).pow(12)
            .checked_sub_mul(&Natural::from(0x10000u32), &Natural::from(0x10000u32))
            .to_debug_string(),
    "Some(995705032704)"
);

type Output = Natural

impl<'a, 'b, 'c> CheckedSubMul<&'a Natural, &'b Natural> for &'c Natural

fn checked_sub_mul(self, y: &'a Natural, z: &'b Natural) -> Option<Natural>

Subtracts a Natural by the product of two other Naturals, taking all three by reference and returning None if the result is negative.

$$ f(x, y, z) = \begin{cases} \operatorname{Some}(x - yz) & \text{if} \quad x \geq yz, \\ \operatorname{None} & \text{otherwise}. \end{cases} $$

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{CheckedSubMul, Pow};
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!(
    (&Natural::from(20u32)).checked_sub_mul(&Natural::from(3u32), &Natural::from(4u32))
            .to_debug_string(),
    "Some(8)"
);
assert_eq!(
    (&Natural::from(10u32)).checked_sub_mul(&Natural::from(3u32), &Natural::from(4u32))
            .to_debug_string(),
    "None"
);
assert_eq!(
    (&Natural::from(10u32).pow(12))
            .checked_sub_mul(&Natural::from(0x10000u32), &Natural::from(0x10000u32))
            .to_debug_string(),
    "Some(995705032704)"
);

type Output = Natural

impl<'a> CheckedSubMul<&'a Natural, Natural> for Natural

fn checked_sub_mul(self, y: &'a Natural, z: Natural) -> Option<Natural>

Subtracts a Natural by the product of two other Naturals, taking the first and third by value and the second by reference and returning None if the result is negative.

$$ f(x, y, z) = \begin{cases} \operatorname{Some}(x - yz) & \text{if} \quad x \geq yz, \\ \operatorname{None} & \text{otherwise}. \end{cases} $$

Worst-case complexity

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

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

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

Panics

Panics if y * z is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{CheckedSubMul, Pow};
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::from(20u32).checked_sub_mul(&Natural::from(3u32), Natural::from(4u32))
            .to_debug_string(),
    "Some(8)"
);
assert_eq!(
    Natural::from(10u32).checked_sub_mul(&Natural::from(3u32), Natural::from(4u32))
            .to_debug_string(),
    "None"
);
assert_eq!(
    Natural::from(10u32).pow(12)
            .checked_sub_mul(&Natural::from(0x10000u32), Natural::from(0x10000u32))
            .to_debug_string(),
    "Some(995705032704)"
);

type Output = Natural

impl<'a> CheckedSubMul<Natural, &'a Natural> for Natural

fn checked_sub_mul(self, y: Natural, z: &'a Natural) -> Option<Natural>

Subtracts a Natural by the product of two other Naturals, taking the first two by value and the third by reference and returning None if the result is negative.

$$ f(x, y, z) = \begin{cases} \operatorname{Some}(x - yz) & \text{if} \quad x \geq yz, \\ \operatorname{None} & \text{otherwise}. \end{cases} $$

Worst-case complexity

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

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

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

Panics

Panics if y * z is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{CheckedSubMul, Pow};
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::from(20u32).checked_sub_mul(Natural::from(3u32), &Natural::from(4u32))
            .to_debug_string(),
    "Some(8)"
);
assert_eq!(
    Natural::from(10u32).checked_sub_mul(Natural::from(3u32), &Natural::from(4u32))
            .to_debug_string(),
    "None"
);
assert_eq!(
    Natural::from(10u32).pow(12)
            .checked_sub_mul(Natural::from(0x10000u32), &Natural::from(0x10000u32))
            .to_debug_string(),
    "Some(995705032704)"
);

type Output = Natural

impl CheckedSubMul<Natural, Natural> for Natural

fn checked_sub_mul(self, y: Natural, z: Natural) -> Option<Natural>

Subtracts a Natural by the product of two other Naturals, taking all three by value and returning None if the result is negative.

$$ f(x, y, z) = \begin{cases} \operatorname{Some}(x - yz) & \text{if} \quad x \geq yz, \\ \operatorname{None} & \text{otherwise}. \end{cases} $$

Worst-case complexity

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

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

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

Panics

Panics if y * z is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{CheckedSubMul, Pow};
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::from(20u32).checked_sub_mul(Natural::from(3u32), Natural::from(4u32))
            .to_debug_string(),
    "Some(8)"
);
assert_eq!(
    Natural::from(10u32).checked_sub_mul(Natural::from(3u32), Natural::from(4u32))
            .to_debug_string(),
    "None"
);
assert_eq!(
    Natural::from(10u32).pow(12)
            .checked_sub_mul(Natural::from(0x10000u32), Natural::from(0x10000u32))
            .to_debug_string(),
    "Some(995705032704)"
);

type Output = Natural

impl Clone for Natural

fn clone(&self) -> Natural

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Determines whether an Integer can be converted to a Natural (when the Integer is non-negative). Takes the Integer by reference.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::ConvertibleFrom;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert_eq!(Natural::convertible_from(&Integer::from(123)), true);
assert_eq!(Natural::convertible_from(&Integer::from(-123)), false);
assert_eq!(Natural::convertible_from(&Integer::from(10u32).pow(12)), true);
assert_eq!(Natural::convertible_from(&-Integer::from(10u32).pow(12)), false);

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

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

Determines whether a Natural can be exactly converted to a primitive float.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

See here.

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

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

Determines whether a Natural can be exactly converted to a primitive float.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

See here.

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

fn convertible_from(value: &Natural) -> bool

Determines whether a Natural can be converted to a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

fn convertible_from(value: &Natural) -> bool

Determines whether a Natural can be converted to a SignedLimb (the signed type whose width is the same as a limb’s).

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

fn convertible_from(value: &Natural) -> bool

Determines whether a Natural can be converted to a value of a primitive unsigned integer type that’s larger than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

fn convertible_from(value: &Natural) -> bool

Determines whether a Natural can be converted to a value of a signed primitive integer type that’s larger than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

fn convertible_from(value: &Natural) -> bool

Determines whether a Natural can be converted to a usize.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

fn convertible_from(value: &Natural) -> bool

Determines whether a Natural can be converted to an isize.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

fn convertible_from(value: &Natural) -> bool

Determines whether a Natural can be converted to a value of a primitive unsigned integer type that’s smaller than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

fn convertible_from(value: &Natural) -> bool

Determines whether a Natural can be converted to a value of a signed primitive integer type that’s smaller than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

fn convertible_from(value: &Natural) -> bool

Determines whether a Natural can be converted to a value of a primitive unsigned integer type that’s smaller than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

fn convertible_from(value: &Natural) -> bool

Determines whether a Natural can be converted to a value of a signed primitive integer type that’s smaller than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

fn convertible_from(value: &Natural) -> bool

Determines whether a Natural can be converted to a value of a primitive unsigned integer type that’s smaller than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

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

fn convertible_from(value: &Natural) -> bool

Determines whether a Natural can be converted to a value of a signed primitive integer type that’s smaller than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl ConvertibleFrom<Integer> for Natural

fn convertible_from(value: Integer) -> bool

Determines whether an Integer can be converted to a Natural (when the Integer is non-negative). Takes the Integer by value.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::ConvertibleFrom;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert_eq!(Natural::convertible_from(Integer::from(123)), true);
assert_eq!(Natural::convertible_from(Integer::from(-123)), false);
assert_eq!(Natural::convertible_from(Integer::from(10u32).pow(12)), true);
assert_eq!(Natural::convertible_from(-Integer::from(10u32).pow(12)), false);

impl ConvertibleFrom<f32> for Natural

fn convertible_from(value: f32) -> bool

Determines whether a floating-point value can be exactly converted to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl ConvertibleFrom<f64> for Natural

fn convertible_from(value: f64) -> bool

Determines whether a floating-point value can be exactly converted to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl ConvertibleFrom<i128> for Natural

fn convertible_from(i: i128) -> bool

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl ConvertibleFrom<i16> for Natural

fn convertible_from(i: i16) -> bool

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl ConvertibleFrom<i32> for Natural

fn convertible_from(i: i32) -> bool

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl ConvertibleFrom<i64> for Natural

fn convertible_from(i: i64) -> bool

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl ConvertibleFrom<i8> for Natural

fn convertible_from(i: i8) -> bool

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl ConvertibleFrom<isize> for Natural

fn convertible_from(i: isize) -> bool

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

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> CoprimeWith<&'a Natural> for Natural

fn coprime_with(self, other: &'a Natural) -> bool

Returns whether two Naturals are coprime; that is, whether they have no common factor other than 1. The first Natural is taken by value and the second by reference.

Every Natural is coprime with 1. No Natural is coprime with 0, except 1.

$f(x, y) = (\gcd(x, y) = 1)$.

$f(x, y) = ((k,m,n \in \N \land x=km \land y=kn) \implies k=1)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CoprimeWith;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).coprime_with(&Natural::from(5u32)), true);
assert_eq!(Natural::from(12u32).coprime_with(&Natural::from(90u32)), false);

impl<'a, 'b> CoprimeWith<&'b Natural> for &'a Natural

fn coprime_with(self, other: &'b Natural) -> bool

Returns whether two Naturals are coprime; that is, whether they have no common factor other than 1. Both Naturals are taken by reference.

Every Natural is coprime with 1. No Natural is coprime with 0, except 1.

$f(x, y) = (\gcd(x, y) = 1)$.

$f(x, y) = ((k,m,n \in \N \land x=km \land y=kn) \implies k=1)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CoprimeWith;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(3u32)).coprime_with(Natural::from(5u32)), true);
assert_eq!((&Natural::from(12u32)).coprime_with(Natural::from(90u32)), false);

impl CoprimeWith<Natural> for Natural

fn coprime_with(self, other: Natural) -> bool

Returns whether two Naturals are coprime; that is, whether they have no common factor other than 1. Both Naturals are taken by value.

Every Natural is coprime with 1. No Natural is coprime with 0, except 1.

$f(x, y) = (\gcd(x, y) = 1)$.

$f(x, y) = ((k,m,n \in \N \land x=km \land y=kn) \implies k=1)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CoprimeWith;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).coprime_with(Natural::from(5u32)), true);
assert_eq!(Natural::from(12u32).coprime_with(Natural::from(90u32)), false);

impl<'a> CoprimeWith<Natural> for &'a Natural

fn coprime_with(self, other: Natural) -> bool

Returns whether two Naturals are coprime; that is, whether they have no common factor other than 1. The first Natural is taken by reference and the second by value.

Every Natural is coprime with 1. No Natural is coprime with 0, except 1.

$f(x, y) = (\gcd(x, y) = 1)$.

$f(x, y) = ((k,m,n \in \N \land x=km \land y=kn) \implies k=1)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::CoprimeWith;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(3u32)).coprime_with(Natural::from(5u32)), true);
assert_eq!((&Natural::from(12u32)).coprime_with(Natural::from(90u32)), false);

impl CountOnes for &Natural

fn count_ones(self) -> u64

Counts the number of ones in the binary expansion of a Natural.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_base::num::logic::traits::CountOnes;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.count_ones(), 0);
// 105 = 1101001b
assert_eq!(Natural::from(105u32).count_ones(), 4);
// 10^12 = 1110100011010100101001010001000000000000b
assert_eq!(Natural::from(10u32).pow(12).count_ones(), 13);

impl Debug for Natural

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

Converts a Natural to a String.

This is the same as the Display::fmt implementation.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(Natural::ZERO.to_debug_string(), "0");
assert_eq!(Natural::from(123u32).to_debug_string(), "123");
assert_eq!(
    Natural::from_str("1000000000000").unwrap().to_debug_string(),
    "1000000000000"
);
assert_eq!(format!("{:05?}", Natural::from(123u32)), "00123");

impl Default for Natural

fn default() -> Natural

The default value of a Natural, 0.

impl Digits<Natural> for Natural

fn to_digits_asc(&self, base: &Natural) -> Vec<Natural>

Returns a Vec containing the digits of a Natural in ascending order (least- to most-significant).

If the Natural is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, b) = (d_i)_ {i=0}^{k-1}$, where $0 \leq d_i < b$ for all $i$, $k=0$ or $d_{k-1} \neq 0$, and

$$ \sum_{i=0}^{k-1}b^i d_i = x. $$

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

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::{Two, Zero};
use malachite_base::num::conversion::traits::Digits;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.to_digits_asc(&Natural::from(6u32)).to_debug_string(), "[]");
assert_eq!(Natural::TWO.to_digits_asc(&Natural::from(6u32)).to_debug_string(), "[2]");
assert_eq!(
    Natural::from(123456u32).to_digits_asc(&Natural::from(3u32)).to_debug_string(),
    "[0, 1, 1, 0, 0, 1, 1, 2, 0, 0, 2]"
);

fn to_digits_desc(&self, base: &Natural) -> Vec<Natural>

Returns a Vec containing the digits of a Natural in descending order (most- to least-significant).

If the Natural is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, b) = (d_i)_ {i=0}^{k-1}$, where $0 \leq d_i < b$ for all $i$, $k=0$ or $d_{k-1} \neq 0$, and

$$ \sum_{i=0}^{k-1}b^i d_{k-i-1} = x. $$

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

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::{Two, Zero};
use malachite_base::num::conversion::traits::Digits;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.to_digits_desc(&Natural::from(6u32)).to_debug_string(), "[]");
assert_eq!(Natural::TWO.to_digits_desc(&Natural::from(6u32)).to_debug_string(), "[2]");
assert_eq!(
    Natural::from(123456u32).to_digits_desc(&Natural::from(3u32)).to_debug_string(),
    "[2, 0, 0, 2, 1, 1, 0, 0, 1, 1, 0]"
);

fn from_digits_asc<I: Iterator<Item = Natural>>(
    base: &Natural,
    digits: I
) -> Option<Natural>

Converts an iterator of digits into a Natural.

The input digits are in ascending order (least- to most-significant). The function returns None if any of the digits are greater than or equal to the base.

$$ f((d_i)_ {i=0}^{k-1}, b) = \sum_{i=0}^{k-1}b^id_i. $$

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 digits.count(), and $m$ is base.significant_bits().

Panics

Panics if base is less than 2.

Examples

extern crate malachite_base;

use malachite_base::num::conversion::traits::Digits;
use malachite_base::strings::ToDebugString;
use malachite_base::vecs::vec_from_str;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    Natural::from_digits_asc(
        &Natural::from(64u32),
        vec_from_str::<Natural>("[0, 0, 0]").unwrap().into_iter()
    ).to_debug_string(),
    "Some(0)"
);
assert_eq!(
    Natural::from_digits_asc(
        &Natural::from(3u32),
        vec_from_str::<Natural>("[0, 1, 1, 0, 0, 1, 1, 2, 0, 0, 2]").unwrap().into_iter()
    ).to_debug_string(),
    "Some(123456)"
);
assert_eq!(
    Natural::from_digits_asc(
        &Natural::from(8u32),
        vec_from_str::<Natural>("[3, 7, 1]").unwrap().into_iter()
    ).to_debug_string(),
    "Some(123)"
);
assert_eq!(
    Natural::from_digits_asc(
        &Natural::from(8u32),
        vec_from_str::<Natural>("[1, 10, 3]").unwrap().into_iter()
    ).to_debug_string(),
    "None"
);

fn from_digits_desc<I: Iterator<Item = Natural>>(
    base: &Natural,
    digits: I
) -> Option<Natural>

Converts an iterator of digits into a Natural.

The input digits are in descending order (most- to least-significant). The function returns None if any of the digits are greater than or equal to the base.

$$ f((d_i)_ {i=0}^{k-1}, b) = \sum_{i=0}^{k-1}b^{k-i-1}d_i. $$

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 digits.count(), and $m$ is base.significant_bits().

Panics

Panics if base is less than 2.

Examples

extern crate malachite_base;

use malachite_base::num::conversion::traits::Digits;
use malachite_base::strings::ToDebugString;
use malachite_base::vecs::vec_from_str;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    Natural::from_digits_desc(
        &Natural::from(64u32),
        vec_from_str::<Natural>("[0, 0, 0]").unwrap().into_iter()
    ).to_debug_string(),
    "Some(0)"
);
assert_eq!(
    Natural::from_digits_desc(
        &Natural::from(3u32),
        vec_from_str::<Natural>("[2, 0, 0, 2, 1, 1, 0, 0, 1, 1, 0]").unwrap().into_iter()
    ).to_debug_string(),
    "Some(123456)"
);
assert_eq!(
    Natural::from_digits_desc(
        &Natural::from(8u32),
        vec_from_str::<Natural>("[1, 7, 3]").unwrap().into_iter()
    ).to_debug_string(),
    "Some(123)"
);
assert_eq!(
    Natural::from_digits_desc(
        &Natural::from(8u32),
        vec_from_str::<Natural>("[3, 10, 1]").unwrap().into_iter()
    ).to_debug_string(),
    "None"
);

impl Digits<u128> for Natural

fn to_digits_asc(&self, base: &u128) -> Vec<u128>

Returns a Vec containing the digits of a Natural in ascending order (least- to most-significant).

If the Natural is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, b) = (d_i)_ {i=0}^{k-1}$, where $0 \leq d_i < b$ for all $i$, $k=0$ or $d_{k-1} \neq 0$, and

$$ \sum_{i=0}^{k-1}b^i d_i = x. $$

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

Examples

See here.

fn to_digits_desc(&self, base: &u128) -> Vec<u128>

Returns a Vec containing the digits of a Natural in descending order (most- to least-significant).

If the Natural is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, b) = (d_i)_ {i=0}^{k-1}$, where $0 \leq d_i < b$ for all $i$, $k=0$ or $d_{k-1} \neq 0$, and

$$ \sum_{i=0}^{k-1}b^i d_{k-i-1} = x. $$

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

Examples

See here.

fn from_digits_asc<I: Iterator<Item = u128>>(
    base: &u128,
    digits: I
) -> Option<Natural>

Converts an iterator of digits into a Natural.

The input digits are in ascending order (least- to most-significant). The function returns None if any of the digits are greater than or equal to the base.

$$ f((d_i)_ {i=0}^{k-1}, b) = \sum_{i=0}^{k-1}b^id_i. $$

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if base is less than 2.

Examples

See here.

fn from_digits_desc<I: Iterator<Item = u128>>(
    base: &u128,
    digits: I
) -> Option<Natural>

Converts an iterator of digits into a Natural.

The input digits are in descending order (most- to least-significant). The function returns None if any of the digits are greater than or equal to the base.

$$ f((d_i)_ {i=0}^{k-1}, b) = \sum_{i=0}^{k-1}b^{k-i-1}d_i. $$

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if base is less than 2.

Examples

See here.

impl Digits<u16> for Natural

fn to_digits_asc(&self, base: &u16) -> Vec<u16>

Returns a Vec containing the digits of a Natural in ascending order (least- to most-significant).

If the Natural is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, b) = (d_i)_ {i=0}^{k-1}$, where $0 \leq d_i < b$ for all $i$, $k=0$ or $d_{k-1} \neq 0$, and

$$ \sum_{i=0}^{k-1}b^i d_i = x. $$

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

Examples

See here.

fn to_digits_desc(&self, base: &u16) -> Vec<u16>

Returns a Vec containing the digits of a Natural in descending order (most- to least-significant).

If the Natural is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, b) = (d_i)_ {i=0}^{k-1}$, where $0 \leq d_i < b$ for all $i$, $k=0$ or $d_{k-1} \neq 0$, and

$$ \sum_{i=0}^{k-1}b^i d_{k-i-1} = x. $$

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

Examples

See here.

fn from_digits_asc<I: Iterator<Item = u16>>(
    base: &u16,
    digits: I
) -> Option<Natural>

Converts an iterator of digits into a Natural.

The input digits are in ascending order (least- to most-significant). The function returns None if any of the digits are greater than or equal to the base.

$$ f((d_i)_ {i=0}^{k-1}, b) = \sum_{i=0}^{k-1}b^id_i. $$

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if base is less than 2.

Examples

See here.

fn from_digits_desc<I: Iterator<Item = u16>>(
    base: &u16,
    digits: I
) -> Option<Natural>

Converts an iterator of digits into a Natural.

The input digits are in descending order (most- to least-significant). The function returns None if any of the digits are greater than or equal to the base.

$$ f((d_i)_ {i=0}^{k-1}, b) = \sum_{i=0}^{k-1}b^{k-i-1}d_i. $$

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if base is less than 2.

Examples

See here.

impl Digits<u32> for Natural

fn to_digits_asc(&self, base: &u32) -> Vec<u32>

Returns a Vec containing the digits of a Natural in ascending order (least- to most-significant).

If the Natural is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, b) = (d_i)_ {i=0}^{k-1}$, where $0 \leq d_i < b$ for all $i$, $k=0$ or $d_{k-1} \neq 0$, and

$$ \sum_{i=0}^{k-1}b^i d_i = x. $$

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

Examples

See here.

fn to_digits_desc(&self, base: &u32) -> Vec<u32>

Returns a Vec containing the digits of a Natural in descending order (most- to least-significant).

If the Natural is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, b) = (d_i)_ {i=0}^{k-1}$, where $0 \leq d_i < b$ for all $i$, $k=0$ or $d_{k-1} \neq 0$, and

$$ \sum_{i=0}^{k-1}b^i d_{k-i-1} = x. $$

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

Examples

See here.

fn from_digits_asc<I: Iterator<Item = u32>>(
    base: &u32,
    digits: I
) -> Option<Natural>

Converts an iterator of digits into a Natural.

The input digits are in ascending order (least- to most-significant). The function returns None if any of the digits are greater than or equal to the base.

$$ f((d_i)_ {i=0}^{k-1}, b) = \sum_{i=0}^{k-1}b^id_i. $$

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if base is less than 2.

Examples

See here.

fn from_digits_desc<I: Iterator<Item = u32>>(
    base: &u32,
    digits: I
) -> Option<Natural>

Converts an iterator of digits into a Natural.

The input digits are in descending order (most- to least-significant). The function returns None if any of the digits are greater than or equal to the base.

$$ f((d_i)_ {i=0}^{k-1}, b) = \sum_{i=0}^{k-1}b^{k-i-1}d_i. $$

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if base is less than 2.

Examples

See here.

impl Digits<u64> for Natural

fn to_digits_asc(&self, base: &u64) -> Vec<u64>

Returns a Vec containing the digits of a Natural in ascending order (least- to most-significant).

If the Natural is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, b) = (d_i)_ {i=0}^{k-1}$, where $0 \leq d_i < b$ for all $i$, $k=0$ or $d_{k-1} \neq 0$, and

$$ \sum_{i=0}^{k-1}b^i d_i = x. $$

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

Examples

See here.

fn to_digits_desc(&self, base: &u64) -> Vec<u64>

Returns a Vec containing the digits of a Natural in descending order (most- to least-significant).

If the Natural is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, b) = (d_i)_ {i=0}^{k-1}$, where $0 \leq d_i < b$ for all $i$, $k=0$ or $d_{k-1} \neq 0$, and

$$ \sum_{i=0}^{k-1}b^i d_{k-i-1} = x. $$

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

Examples

See here.

fn from_digits_asc<I: Iterator<Item = u64>>(
    base: &u64,
    digits: I
) -> Option<Natural>

Converts an iterator of digits into a Natural.

The input digits are in ascending order (least- to most-significant). The function returns None if any of the digits are greater than or equal to the base.

$$ f((d_i)_ {i=0}^{k-1}, b) = \sum_{i=0}^{k-1}b^id_i. $$

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if base is less than 2.

Examples

See here.

fn from_digits_desc<I: Iterator<Item = u64>>(
    base: &u64,
    digits: I
) -> Option<Natural>

Converts an iterator of digits into a Natural.

The input digits are in descending order (most- to least-significant). The function returns None if any of the digits are greater than or equal to the base.

$$ f((d_i)_ {i=0}^{k-1}, b) = \sum_{i=0}^{k-1}b^{k-i-1}d_i. $$

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if base is less than 2.

Examples

See here.

impl Digits<u8> for Natural

fn to_digits_asc(&self, base: &u8) -> Vec<u8>

Returns a Vec containing the digits of a Natural in ascending order (least- to most-significant).

If the Natural is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, b) = (d_i)_ {i=0}^{k-1}$, where $0 \leq d_i < b$ for all $i$, $k=0$ or $d_{k-1} \neq 0$, and

$$ \sum_{i=0}^{k-1}b^i d_i = x. $$

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

Examples

See here.

fn to_digits_desc(&self, base: &u8) -> Vec<u8>

Returns a Vec containing the digits of a Natural in descending order (most- to least-significant).

If the Natural is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, b) = (d_i)_ {i=0}^{k-1}$, where $0 \leq d_i < b$ for all $i$, $k=0$ or $d_{k-1} \neq 0$, and

$$ \sum_{i=0}^{k-1}b^i d_{k-i-1} = x. $$

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

Examples

See here.

fn from_digits_asc<I: Iterator<Item = u8>>(
    base: &u8,
    digits: I
) -> Option<Natural>

Converts an iterator of digits into a Natural.

The input digits are in ascending order (least- to most-significant). The function returns None if any of the digits are greater than or equal to the base.

$$ f((d_i)_ {i=0}^{k-1}, b) = \sum_{i=0}^{k-1}b^id_i. $$

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if base is less than 2.

Examples

See here.

fn from_digits_desc<I: Iterator<Item = u8>>(
    base: &u8,
    digits: I
) -> Option<Natural>

Converts an iterator of digits into a Natural.

The input digits are in descending order (most- to least-significant). The function returns None if any of the digits are greater than or equal to the base.

$$ f((d_i)_ {i=0}^{k-1}, b) = \sum_{i=0}^{k-1}b^{k-i-1}d_i. $$

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if base is less than 2.

Examples

See here.

impl Digits<usize> for Natural

fn to_digits_asc(&self, base: &usize) -> Vec<usize>

Returns a Vec containing the digits of a Natural in ascending order (least- to most-significant).

If the Natural is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, b) = (d_i)_ {i=0}^{k-1}$, where $0 \leq d_i < b$ for all $i$, $k=0$ or $d_{k-1} \neq 0$, and

$$ \sum_{i=0}^{k-1}b^i d_i = x. $$

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

Examples

See here.

fn to_digits_desc(&self, base: &usize) -> Vec<usize>

Returns a Vec containing the digits of a Natural in descending order (most- to least-significant).

If the Natural is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, b) = (d_i)_ {i=0}^{k-1}$, where $0 \leq d_i < b$ for all $i$, $k=0$ or $d_{k-1} \neq 0$, and

$$ \sum_{i=0}^{k-1}b^i d_{k-i-1} = x. $$

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

Examples

See here.

fn from_digits_asc<I: Iterator<Item = usize>>(
    base: &usize,
    digits: I
) -> Option<Natural>

Converts an iterator of digits into a Natural.

The input digits are in ascending order (least- to most-significant). The function returns None if any of the digits are greater than or equal to the base.

$$ f((d_i)_ {i=0}^{k-1}, b) = \sum_{i=0}^{k-1}b^id_i. $$

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if base is less than 2.

Examples

See here.

fn from_digits_desc<I: Iterator<Item = usize>>(
    base: &usize,
    digits: I
) -> Option<Natural>

Converts an iterator of digits into a Natural.

The input digits are in descending order (most- to least-significant). The function returns None if any of the digits are greater than or equal to the base.

$$ f((d_i)_ {i=0}^{k-1}, b) = \sum_{i=0}^{k-1}b^{k-i-1}d_i. $$

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if base is less than 2.

Examples

See here.

impl Display for Natural

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

Converts a Natural to a String.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(Natural::ZERO.to_string(), "0");
assert_eq!(Natural::from(123u32).to_string(), "123");
assert_eq!(
    Natural::from_str("1000000000000").unwrap().to_string(),
    "1000000000000"
);
assert_eq!(format!("{:05}", Natural::from(123u32)), "00123");

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

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

Divides a Natural by another Natural, taking the first by value and the second by reference. The quotient is rounded towards negative infinity. The quotient and remainder (which is not computed) satisfy $x = qy + r$ and $0 \leq r < y$.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(Natural::from(23u32) / &Natural::from(10u32), 2);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    Natural::from_str("1000000000000000000000000").unwrap() /
            &Natural::from_str("1234567890987").unwrap(),
    810000006723u64
);

type Output = Natural

The resulting type after applying the / operator.

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

fn div(self, other: &'b Natural) -> Natural

Divides a Natural by another Natural, taking both by reference. The quotient is rounded towards negative infinity. The quotient and remainder (which is not computed) satisfy $x = qy + r$ and $0 \leq r < y$.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(&Natural::from(23u32) / &Natural::from(10u32), 2);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    &Natural::from_str("1000000000000000000000000").unwrap() /
    &Natural::from_str("1234567890987").unwrap(),
    810000006723u64
);

type Output = Natural

The resulting type after applying the / operator.

impl Div<Natural> for Natural

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

Divides a Natural by another Natural, taking both by value. The quotient is rounded towards negative infinity. The quotient and remainder (which is not computed) satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = \left \lfloor \frac{x}{y} \right \rfloor. $$

Worst-case complexity

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

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

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

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(Natural::from(23u32) / Natural::from(10u32), 2);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    Natural::from_str("1000000000000000000000000").unwrap() /
            Natural::from_str("1234567890987").unwrap(),
    810000006723u64
);

type Output = Natural

The resulting type after applying the / operator.

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

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

Divides a Natural by another Natural, taking the first by reference and the second by value. The quotient is rounded towards negative infinity. The quotient and remainder (which is not computed) satisfy $x = qy + r$ and $0 \leq r < y$.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(&Natural::from(23u32) / Natural::from(10u32), 2);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    &Natural::from_str("1000000000000000000000000").unwrap() /
            Natural::from_str("1234567890987").unwrap(),
    810000006723u64
);

type Output = Natural

The resulting type after applying the / operator.

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

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

Divides a Natural by another Natural in place, taking the Natural on the right-hand side by reference. The quotient is rounded towards negative infinity. The quotient and remainder (which is not computed) satisfy $x = qy + r$ and $0 \leq r < y$.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
let mut x = Natural::from(23u32);
x /= &Natural::from(10u32);
assert_eq!(x, 2);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
let mut x = Natural::from_str("1000000000000000000000000").unwrap();
x /= &Natural::from_str("1234567890987").unwrap();
assert_eq!(x, 810000006723u64);

impl DivAssign<Natural> for Natural

fn div_assign(&mut self, other: Natural)

Divides a Natural by another Natural in place, taking the Natural on the right-hand side by value. The quotient is rounded towards negative infinity. The quotient and remainder (which is not computed) satisfy $x = qy + r$ and $0 \leq r < y$.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
let mut x = Natural::from(23u32);
x /= Natural::from(10u32);
assert_eq!(x, 2);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
let mut x = Natural::from_str("1000000000000000000000000").unwrap();
x /= Natural::from_str("1234567890987").unwrap();
assert_eq!(x, 810000006723u64);

impl<'a> DivAssignMod<&'a Natural> for Natural

fn div_assign_mod(&mut self, other: &'a Natural) -> Natural

Divides a Natural by another Natural in place, taking the Natural on the right-hand side by value and returning the remainder. The quotient is rounded towards negative infinity.

The quotient and remainder satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor, $$ $$ x \gets \left \lfloor \frac{x}{y} \right \rfloor. $$

Worst-case complexity

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

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

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

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivAssignMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
let mut x = Natural::from(23u32);
assert_eq!(x.div_assign_mod(&Natural::from(10u32)), 3);
assert_eq!(x, 2);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
let mut x = Natural::from_str("1000000000000000000000000").unwrap();
assert_eq!(
    x.div_assign_mod(&Natural::from_str("1234567890987").unwrap()),
    530068894399u64
);
assert_eq!(x, 810000006723u64);

type ModOutput = Natural

impl DivAssignMod<Natural> for Natural

fn div_assign_mod(&mut self, other: Natural) -> Natural

Divides a Natural by another Natural in place, taking the Natural on the right-hand side by value and returning the remainder. The quotient is rounded towards negative infinity.

The quotient and remainder satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor, $$ $$ x \gets \left \lfloor \frac{x}{y} \right \rfloor. $$

Worst-case complexity

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

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

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

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivAssignMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
let mut x = Natural::from(23u32);
assert_eq!(x.div_assign_mod(Natural::from(10u32)), 3);
assert_eq!(x, 2);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
let mut x = Natural::from_str("1000000000000000000000000").unwrap();
assert_eq!(x.div_assign_mod(Natural::from_str("1234567890987").unwrap()), 530068894399u64);
assert_eq!(x, 810000006723u64);

type ModOutput = Natural

impl<'a> DivAssignRem<&'a Natural> for Natural

fn div_assign_rem(&mut self, other: &'a Natural) -> Natural

Divides a Natural by another Natural in place, taking the Natural on the right-hand side by reference and returning the remainder. The quotient is rounded towards zero.

The quotient and remainder satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor, $$ $$ x \gets \left \lfloor \frac{x}{y} \right \rfloor. $$

For Naturals, div_assign_rem is equivalent to div_assign_mod.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivAssignRem;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
let mut x = Natural::from(23u32);
assert_eq!(x.div_assign_rem(&Natural::from(10u32)), 3);
assert_eq!(x, 2);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
let mut x = Natural::from_str("1000000000000000000000000").unwrap();
assert_eq!(
    x.div_assign_rem(&Natural::from_str("1234567890987").unwrap()),
    530068894399u64
);
assert_eq!(x, 810000006723u64);

type RemOutput = Natural

impl DivAssignRem<Natural> for Natural

fn div_assign_rem(&mut self, other: Natural) -> Natural

Divides a Natural by another Natural in place, taking the Natural on the right-hand side by value and returning the remainder. The quotient is rounded towards zero.

The quotient and remainder satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor, $$ $$ x \gets \left \lfloor \frac{x}{y} \right \rfloor. $$

For Naturals, div_assign_rem is equivalent to div_assign_mod.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivAssignRem;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
let mut x = Natural::from(23u32);
assert_eq!(x.div_assign_rem(Natural::from(10u32)), 3);
assert_eq!(x, 2);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
let mut x = Natural::from_str("1000000000000000000000000").unwrap();
assert_eq!(x.div_assign_rem(Natural::from_str("1234567890987").unwrap()), 530068894399u64);
assert_eq!(x, 810000006723u64);

type RemOutput = Natural

impl<'a> DivExact<&'a Natural> for Natural

fn div_exact(self, other: &'a Natural) -> Natural

Divides a Natural by another Natural, taking the first by value and the second by reference. The first Natural must be exactly divisible by the second. If it isn’t, this function may panic or return a meaningless result.

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

If you are unsure whether the division will be exact, use self / &other instead. If you’re unsure and you want to know, use self.div_mod(&other) and check whether the remainder is zero. If you want a function that panics if the division is not exact, use self.div_round(&other, RoundingMode::Exact).

Worst-case complexity

$T(n) = 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 other is zero. May panic if self is not divisible by other.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivExact;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 123 * 456 = 56088
assert_eq!(Natural::from(56088u32).div_exact(&Natural::from(456u32)), 123);

// 123456789000 * 987654321000 = 121932631112635269000000
assert_eq!(
    Natural::from_str("121932631112635269000000").unwrap()
            .div_exact(&Natural::from_str("987654321000").unwrap()),
    123456789000u64
);

type Output = Natural

impl<'a, 'b> DivExact<&'b Natural> for &'a Natural

fn div_exact(self, other: &'b Natural) -> Natural

Divides a Natural by another Natural, taking both by reference. The first Natural must be exactly divisible by the second. If it isn’t, this function may panic or return a meaningless result.

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

If you are unsure whether the division will be exact, use &self / &other instead. If you’re unsure and you want to know, use (&self).div_mod(&other) and check whether the remainder is zero. If you want a function that panics if the division is not exact, use (&self).div_round(&other, RoundingMode::Exact).

Worst-case complexity

$T(n) = 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 other is zero. May panic if self is not divisible by other.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivExact;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 123 * 456 = 56088
assert_eq!((&Natural::from(56088u32)).div_exact(&Natural::from(456u32)), 123);

// 123456789000 * 987654321000 = 121932631112635269000000
assert_eq!(
    (&Natural::from_str("121932631112635269000000").unwrap())
            .div_exact(&Natural::from_str("987654321000").unwrap()),
    123456789000u64
);

type Output = Natural

impl DivExact<Natural> for Natural

fn div_exact(self, other: Natural) -> Natural

Divides a Natural by another Natural, taking both by value. The first Natural must be exactly divisible by the second. If it isn’t, this function may panic or return a meaningless result.

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

If you are unsure whether the division will be exact, use self / other instead. If you’re unsure and you want to know, use self.div_mod(other) and check whether the remainder is zero. If you want a function that panics if the division is not exact, use self.div_round(other, RoundingMode::Exact).

Worst-case complexity

$T(n) = 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 other is zero. May panic if self is not divisible by other.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivExact;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 123 * 456 = 56088
assert_eq!(Natural::from(56088u32).div_exact(Natural::from(456u32)), 123);

// 123456789000 * 987654321000 = 121932631112635269000000
assert_eq!(
    Natural::from_str("121932631112635269000000").unwrap()
            .div_exact(Natural::from_str("987654321000").unwrap()),
    123456789000u64
);

type Output = Natural

impl<'a> DivExact<Natural> for &'a Natural

fn div_exact(self, other: Natural) -> Natural

Divides a Natural by another Natural, taking the first by reference and the second by value. The first Natural must be exactly divisible by the second. If it isn’t, this function may panic or return a meaningless result.

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

If you are unsure whether the division will be exact, use &self / other instead. If you’re unsure and you want to know, use self.div_mod(other) and check whether the remainder is zero. If you want a function that panics if the division is not exact, use (&self).div_round(other, RoundingMode::Exact).

Worst-case complexity

$T(n) = 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 other is zero. May panic if self is not divisible by other.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivExact;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 123 * 456 = 56088
assert_eq!((&Natural::from(56088u32)).div_exact(Natural::from(456u32)), 123);

// 123456789000 * 987654321000 = 121932631112635269000000
assert_eq!(
    (&Natural::from_str("121932631112635269000000").unwrap())
            .div_exact(Natural::from_str("987654321000").unwrap()),
    123456789000u64
);

type Output = Natural

impl<'a> DivExactAssign<&'a Natural> for Natural

fn div_exact_assign(&mut self, other: &'a Natural)

Divides a Natural by another Natural in place, taking the Natural on the right-hand side by reference. The first Natural must be exactly divisible by the second. If it isn’t, this function may panic or return a meaningless result.

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

If you are unsure whether the division will be exact, use self /= &other instead. If you’re unsure and you want to know, use self.div_assign_mod(&other) and check whether the remainder is zero. If you want a function that panics if the division is not exact, use self.div_round_assign(&other, RoundingMode::Exact).

Worst-case complexity

$T(n) = 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 other is zero. May panic if self is not divisible by other.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivExactAssign;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 123 * 456 = 56088
let mut x = Natural::from(56088u32);
x.div_exact_assign(&Natural::from(456u32));
assert_eq!(x, 123);

// 123456789000 * 987654321000 = 121932631112635269000000
let mut x = Natural::from_str("121932631112635269000000").unwrap();
x.div_exact_assign(&Natural::from_str("987654321000").unwrap());
assert_eq!(x, 123456789000u64);

impl DivExactAssign<Natural> for Natural

fn div_exact_assign(&mut self, other: Natural)

Divides a Natural by another Natural in place, taking the Natural on the right-hand side by value. The first Natural must be exactly divisible by the second. If it isn’t, this function may panic or return a meaningless result.

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

If you are unsure whether the division will be exact, use self /= other instead. If you’re unsure and you want to know, use self.div_assign_mod(other) and check whether the remainder is zero. If you want a function that panics if the division is not exact, use self.div_round_assign(other, RoundingMode::Exact).

Worst-case complexity

$T(n) = 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 other is zero. May panic if self is not divisible by other.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivExactAssign;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 123 * 456 = 56088
let mut x = Natural::from(56088u32);
x.div_exact_assign(Natural::from(456u32));
assert_eq!(x, 123);

// 123456789000 * 987654321000 = 121932631112635269000000
let mut x = Natural::from_str("121932631112635269000000").unwrap();
x.div_exact_assign(Natural::from_str("987654321000").unwrap());
assert_eq!(x, 123456789000u64);

impl<'a> DivMod<&'a Natural> for Natural

fn div_mod(self, other: &'a Natural) -> (Natural, Natural)

Divides a Natural by another Natural, taking the first by value and the second by reference and returning the quotient and remainder. The quotient is rounded towards negative infinity.

The quotient and remainder satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = \left ( \left \lfloor \frac{x}{y} \right \rfloor, \space x - y\left \lfloor \frac{x}{y} \right \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().

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(
    Natural::from(23u32).div_mod(&Natural::from(10u32)).to_debug_string(),
    "(2, 3)"
);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    Natural::from_str("1000000000000000000000000").unwrap()
            .div_mod(&Natural::from_str("1234567890987").unwrap()).to_debug_string(),
    "(810000006723, 530068894399)"
);

type DivOutput = Natural

type ModOutput = Natural

impl<'a, 'b> DivMod<&'b Natural> for &'a Natural

fn div_mod(self, other: &'b Natural) -> (Natural, Natural)

Divides a Natural by another Natural, taking both by reference and returning the quotient and remainder. The quotient is rounded towards negative infinity.

The quotient and remainder satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = \left ( \left \lfloor \frac{x}{y} \right \rfloor, \space x - y\left \lfloor \frac{x}{y} \right \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().

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(
    (&Natural::from(23u32)).div_mod(&Natural::from(10u32)).to_debug_string(),
    "(2, 3)"
);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    (&Natural::from_str("1000000000000000000000000").unwrap())
            .div_mod(&Natural::from_str("1234567890987").unwrap()).to_debug_string(),
    "(810000006723, 530068894399)"
);

type DivOutput = Natural

type ModOutput = Natural

impl DivMod<Natural> for Natural

fn div_mod(self, other: Natural) -> (Natural, Natural)

Divides a Natural by another Natural, taking both by value and returning the quotient and remainder. The quotient is rounded towards negative infinity.

The quotient and remainder satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = \left ( \left \lfloor \frac{x}{y} \right \rfloor, \space x - y\left \lfloor \frac{x}{y} \right \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().

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(Natural::from(23u32).div_mod(Natural::from(10u32)).to_debug_string(), "(2, 3)");

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    Natural::from_str("1000000000000000000000000").unwrap()
            .div_mod(Natural::from_str("1234567890987").unwrap()).to_debug_string(),
    "(810000006723, 530068894399)"
);

type DivOutput = Natural

type ModOutput = Natural

impl<'a> DivMod<Natural> for &'a Natural

fn div_mod(self, other: Natural) -> (Natural, Natural)

Divides a Natural by another Natural, taking the first by reference and the second by value and returning the quotient and remainder. The quotient is rounded towards negative infinity.

The quotient and remainder satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = \left ( \left \lfloor \frac{x}{y} \right \rfloor, \space x - y\left \lfloor \frac{x}{y} \right \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().

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(
    (&Natural::from(23u32)).div_mod(Natural::from(10u32)).to_debug_string(),
    "(2, 3)"
);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    (&Natural::from_str("1000000000000000000000000").unwrap())
            .div_mod(Natural::from_str("1234567890987").unwrap()).to_debug_string(),
    "(810000006723, 530068894399)"
);

type DivOutput = Natural

type ModOutput = Natural

impl<'a> DivRem<&'a Natural> for Natural

fn div_rem(self, other: &'a Natural) -> (Natural, Natural)

Divides a Natural by another Natural, taking the first by value and the second by reference and returning the quotient and remainder. The quotient is rounded towards zero.

The quotient and remainder satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = \left ( \left \lfloor \frac{x}{y} \right \rfloor, \space x - y\left \lfloor \frac{x}{y} \right \rfloor \right ). $$

For Naturals, div_rem is equivalent to div_mod.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivRem;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(
    Natural::from(23u32).div_rem(&Natural::from(10u32)).to_debug_string(),
    "(2, 3)"
);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    Natural::from_str("1000000000000000000000000").unwrap()
            .div_rem(&Natural::from_str("1234567890987").unwrap()).to_debug_string(),
    "(810000006723, 530068894399)"
);

type DivOutput = Natural

type RemOutput = Natural

impl<'a, 'b> DivRem<&'b Natural> for &'a Natural

fn div_rem(self, other: &'b Natural) -> (Natural, Natural)

Divides a Natural by another Natural, taking both by reference and returning the quotient and remainder. The quotient is rounded towards zero.

The quotient and remainder satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = \left ( \left \lfloor \frac{x}{y} \right \rfloor, \space x - y\left \lfloor \frac{x}{y} \right \rfloor \right ). $$

For Naturals, div_rem is equivalent to div_mod.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivRem;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(
    (&Natural::from(23u32)).div_rem(&Natural::from(10u32)).to_debug_string(),
    "(2, 3)"
);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    (&Natural::from_str("1000000000000000000000000").unwrap())
            .div_rem(&Natural::from_str("1234567890987").unwrap()).to_debug_string(),
    "(810000006723, 530068894399)"
);

type DivOutput = Natural

type RemOutput = Natural

impl DivRem<Natural> for Natural

fn div_rem(self, other: Natural) -> (Natural, Natural)

Divides a Natural by another Natural, taking both by value and returning the quotient and remainder. The quotient is rounded towards zero.

The quotient and remainder satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = \left ( \left \lfloor \frac{x}{y} \right \rfloor, \space x - y\left \lfloor \frac{x}{y} \right \rfloor \right ). $$

For Naturals, div_rem is equivalent to div_mod.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivRem;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(Natural::from(23u32).div_rem(Natural::from(10u32)).to_debug_string(), "(2, 3)");

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    Natural::from_str("1000000000000000000000000").unwrap()
            .div_rem(Natural::from_str("1234567890987").unwrap()).to_debug_string(),
    "(810000006723, 530068894399)"
);

type DivOutput = Natural

type RemOutput = Natural

impl<'a> DivRem<Natural> for &'a Natural

fn div_rem(self, other: Natural) -> (Natural, Natural)

Divides a Natural by another Natural, taking the first by reference and the second by value and returning the quotient and remainder. The quotient is rounded towards zero.

The quotient and remainder satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = \left ( \left \lfloor \frac{x}{y} \right \rfloor, \space x - y\left \lfloor \frac{x}{y} \right \rfloor \right ). $$

For Naturals, div_rem is equivalent to div_mod.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivRem;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(
    (&Natural::from(23u32)).div_rem(Natural::from(10u32)).to_debug_string(),
    "(2, 3)"
);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    (&Natural::from_str("1000000000000000000000000").unwrap())
            .div_rem(Natural::from_str("1234567890987").unwrap()).to_debug_string(),
    "(810000006723, 530068894399)"
);

type DivOutput = Natural

type RemOutput = Natural

impl<'a> DivRound<&'a Natural> for Natural

fn div_round(self, other: &'a Natural, rm: RoundingMode) -> Natural

Divides a Natural by another Natural, taking the first by value and the second by reference and rounding according to a specified rounding mode.

Let $q = \frac{x}{y}$:

$$ f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor. $$

$$ f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil. $$

$$ f(x, y, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n) = 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 other is zero, or if rm is Exact but self is not divisible by other.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(10u32).div_round(&Natural::from(4u32), RoundingMode::Down), 2);
assert_eq!(
    Natural::from(10u32).pow(12).div_round(&Natural::from(3u32), RoundingMode::Floor),
    333333333333u64
);
assert_eq!(Natural::from(10u32).div_round(&Natural::from(4u32), RoundingMode::Up), 3);
assert_eq!(
    Natural::from(10u32).pow(12).div_round(&Natural::from(3u32), RoundingMode::Ceiling),
    333333333334u64);
assert_eq!(Natural::from(10u32).div_round(&Natural::from(5u32), RoundingMode::Exact), 2);
assert_eq!(Natural::from(10u32).div_round(&Natural::from(3u32), RoundingMode::Nearest), 3);
assert_eq!(Natural::from(20u32).div_round(&Natural::from(3u32), RoundingMode::Nearest), 7);
assert_eq!(Natural::from(10u32).div_round(&Natural::from(4u32), RoundingMode::Nearest), 2);
assert_eq!(Natural::from(14u32).div_round(&Natural::from(4u32), RoundingMode::Nearest), 4);

type Output = Natural

impl<'a, 'b> DivRound<&'b Natural> for &'a Natural

fn div_round(self, other: &'b Natural, rm: RoundingMode) -> Natural

Divides a Natural by another Natural, taking both by reference and rounding according to a specified rounding mode.

Let $q = \frac{x}{y}$:

$$ f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor. $$

$$ f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil. $$

$$ f(x, y, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n) = 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 other is zero, or if rm is Exact but self is not divisible by other.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(10u32)).div_round(&Natural::from(4u32), RoundingMode::Down), 2);
assert_eq!(
    (&Natural::from(10u32).pow(12)).div_round(&Natural::from(3u32), RoundingMode::Floor),
    333333333333u64
);
assert_eq!((&Natural::from(10u32)).div_round(&Natural::from(4u32), RoundingMode::Up), 3);
assert_eq!(
    (&Natural::from(10u32).pow(12)).div_round(&Natural::from(3u32), RoundingMode::Ceiling),
    333333333334u64);
assert_eq!(
    (&Natural::from(10u32)).div_round(&Natural::from(5u32), RoundingMode::Exact),
    2
);
assert_eq!(
    (&Natural::from(10u32)).div_round(&Natural::from(3u32), RoundingMode::Nearest),
    3
);
assert_eq!(
    (&Natural::from(20u32)).div_round(&Natural::from(3u32), RoundingMode::Nearest),
    7
);
assert_eq!(
    (&Natural::from(10u32)).div_round(&Natural::from(4u32), RoundingMode::Nearest),
    2
);
assert_eq!(
    (&Natural::from(14u32)).div_round(&Natural::from(4u32), RoundingMode::Nearest),
    4
);

type Output = Natural

impl DivRound<Natural> for Natural

fn div_round(self, other: Natural, rm: RoundingMode) -> Natural

Divides a Natural by another Natural, taking both by value and rounding according to a specified rounding mode.

Let $q = \frac{x}{y}$:

$$ f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor. $$

$$ f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil. $$

$$ f(x, y, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n) = 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 other is zero, or if rm is Exact but self is not divisible by other.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(10u32).div_round(Natural::from(4u32), RoundingMode::Down), 2);
assert_eq!(
    Natural::from(10u32).pow(12).div_round(Natural::from(3u32), RoundingMode::Floor),
    333333333333u64
);
assert_eq!(Natural::from(10u32).div_round(Natural::from(4u32), RoundingMode::Up), 3);
assert_eq!(
    Natural::from(10u32).pow(12).div_round(Natural::from(3u32), RoundingMode::Ceiling),
    333333333334u64);
assert_eq!(Natural::from(10u32).div_round(Natural::from(5u32), RoundingMode::Exact), 2);
assert_eq!(Natural::from(10u32).div_round(Natural::from(3u32), RoundingMode::Nearest), 3);
assert_eq!(Natural::from(20u32).div_round(Natural::from(3u32), RoundingMode::Nearest), 7);
assert_eq!(Natural::from(10u32).div_round(Natural::from(4u32), RoundingMode::Nearest), 2);
assert_eq!(Natural::from(14u32).div_round(Natural::from(4u32), RoundingMode::Nearest), 4);

type Output = Natural

impl<'a> DivRound<Natural> for &'a Natural

fn div_round(self, other: Natural, rm: RoundingMode) -> Natural

Divides a Natural by another Natural, taking the first by reference and the second by value and rounding according to a specified rounding mode.

Let $q = \frac{x}{y}$:

$$ f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor. $$

$$ f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil. $$

$$ f(x, y, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n) = 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 other is zero, or if rm is Exact but self is not divisible by other.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(10u32)).div_round(Natural::from(4u32), RoundingMode::Down), 2);
assert_eq!(
    (&Natural::from(10u32).pow(12)).div_round(Natural::from(3u32), RoundingMode::Floor),
    333333333333u64
);
assert_eq!((&Natural::from(10u32)).div_round(Natural::from(4u32), RoundingMode::Up), 3);
assert_eq!(
    (&Natural::from(10u32).pow(12)).div_round(Natural::from(3u32), RoundingMode::Ceiling),
    333333333334u64);
assert_eq!((&Natural::from(10u32)).div_round(Natural::from(5u32), RoundingMode::Exact), 2);
assert_eq!(
    (&Natural::from(10u32)).div_round(Natural::from(3u32), RoundingMode::Nearest),
    3
);
assert_eq!(
    (&Natural::from(20u32)).div_round(Natural::from(3u32), RoundingMode::Nearest),
    7
);
assert_eq!(
    (&Natural::from(10u32)).div_round(Natural::from(4u32), RoundingMode::Nearest),
    2
);
assert_eq!(
    (&Natural::from(14u32)).div_round(Natural::from(4u32), RoundingMode::Nearest),
    4
);

type Output = Natural

impl<'a> DivRoundAssign<&'a Natural> for Natural

fn div_round_assign(&mut self, other: &'a Natural, rm: RoundingMode)

Divides a Natural by another Natural in place, taking the Natural on the right-hand side by reference and rounding according to a specified rounding mode.

See the DivRound documentation for details.

Worst-case complexity

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

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

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

Panics

Panics if other is zero, or if rm is Exact but self is not divisible by other.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{DivRoundAssign, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

let mut n = Natural::from(10u32);
n.div_round_assign(&Natural::from(4u32), RoundingMode::Down);
assert_eq!(n, 2);

let mut n = Natural::from(10u32).pow(12);
n.div_round_assign(&Natural::from(3u32), RoundingMode::Floor);
assert_eq!(n, 333333333333u64);

let mut n = Natural::from(10u32);
n.div_round_assign(&Natural::from(4u32), RoundingMode::Up);
assert_eq!(n, 3);

let mut n = Natural::from(10u32).pow(12);
n.div_round_assign(&Natural::from(3u32), RoundingMode::Ceiling);
assert_eq!(n, 333333333334u64);

let mut n = Natural::from(10u32);
n.div_round_assign(&Natural::from(5u32), RoundingMode::Exact);
assert_eq!(n, 2);

let mut n = Natural::from(10u32);
n.div_round_assign(&Natural::from(3u32), RoundingMode::Nearest);
assert_eq!(n, 3);

let mut n = Natural::from(20u32);
n.div_round_assign(&Natural::from(3u32), RoundingMode::Nearest);
assert_eq!(n, 7);

let mut n = Natural::from(10u32);
n.div_round_assign(&Natural::from(4u32), RoundingMode::Nearest);
assert_eq!(n, 2);

let mut n = Natural::from(14u32);
n.div_round_assign(&Natural::from(4u32), RoundingMode::Nearest);
assert_eq!(n, 4);

impl DivRoundAssign<Natural> for Natural

fn div_round_assign(&mut self, other: Natural, rm: RoundingMode)

Divides a Natural by another Natural in place, taking the Natural on the right-hand side by value and rounding according to a specified rounding mode.

See the DivRound documentation for details.

Worst-case complexity

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

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

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

Panics

Panics if other is zero, or if rm is Exact but self is not divisible by other.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{DivRoundAssign, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

let mut n = Natural::from(10u32);
n.div_round_assign(Natural::from(4u32), RoundingMode::Down);
assert_eq!(n, 2);

let mut n = Natural::from(10u32).pow(12);
n.div_round_assign(Natural::from(3u32), RoundingMode::Floor);
assert_eq!(n, 333333333333u64);

let mut n = Natural::from(10u32);
n.div_round_assign(Natural::from(4u32), RoundingMode::Up);
assert_eq!(n, 3);

let mut n = Natural::from(10u32).pow(12);
n.div_round_assign(Natural::from(3u32), RoundingMode::Ceiling);
assert_eq!(n, 333333333334u64);

let mut n = Natural::from(10u32);
n.div_round_assign(Natural::from(5u32), RoundingMode::Exact);
assert_eq!(n, 2);

let mut n = Natural::from(10u32);
n.div_round_assign(Natural::from(3u32), RoundingMode::Nearest);
assert_eq!(n, 3);

let mut n = Natural::from(20u32);
n.div_round_assign(Natural::from(3u32), RoundingMode::Nearest);
assert_eq!(n, 7);

let mut n = Natural::from(10u32);
n.div_round_assign(Natural::from(4u32), RoundingMode::Nearest);
assert_eq!(n, 2);

let mut n = Natural::from(14u32);
n.div_round_assign(Natural::from(4u32), RoundingMode::Nearest);
assert_eq!(n, 4);

impl<'a> DivisibleBy<&'a Natural> for Natural

fn divisible_by(self, other: &'a Natural) -> bool

Returns whether a Natural is divisible by another Natural; in other words, whether the first is a multiple of the second. The first Naturals is taken by reference and the second by value.

This means that zero is divisible by any Natural, including zero; but a nonzero Natural is never divisible by zero.

It’s more efficient to use this function than to compute the remainder and check whether it’s zero.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivisibleBy;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(Natural::ZERO.divisible_by(&Natural::ZERO), true);
assert_eq!(Natural::from(100u32).divisible_by(&Natural::from(3u32)), false);
assert_eq!(Natural::from(102u32).divisible_by(&Natural::from(3u32)), true);
assert_eq!(
    Natural::from_str("1000000000000000000000000").unwrap()
            .divisible_by(&Natural::from_str("1000000000000").unwrap()),
    true
);

impl<'a, 'b> DivisibleBy<&'b Natural> for &'a Natural

fn divisible_by(self, other: &'b Natural) -> bool

Returns whether a Natural is divisible by another Natural; in other words, whether the first is a multiple of the second. Both Naturals are taken by reference.

This means that zero is divisible by any Natural, including zero; but a nonzero Natural is never divisible by zero.

It’s more efficient to use this function than to compute the remainder and check whether it’s zero.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivisibleBy;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!((&Natural::ZERO).divisible_by(&Natural::ZERO), true);
assert_eq!((&Natural::from(100u32)).divisible_by(&Natural::from(3u32)), false);
assert_eq!((&Natural::from(102u32)).divisible_by(&Natural::from(3u32)), true);
assert_eq!(
    (&Natural::from_str("1000000000000000000000000").unwrap())
            .divisible_by(&Natural::from_str("1000000000000").unwrap()),
    true
);

impl DivisibleBy<Natural> for Natural

fn divisible_by(self, other: Natural) -> bool

Returns whether a Natural is divisible by another Natural; in other words, whether the first is a multiple of the second. Both Naturals are taken by value.

This means that zero is divisible by any Natural, including zero; but a nonzero Natural is never divisible by zero.

It’s more efficient to use this function than to compute the remainder and check whether it’s zero.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivisibleBy;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(Natural::ZERO.divisible_by(Natural::ZERO), true);
assert_eq!(Natural::from(100u32).divisible_by(Natural::from(3u32)), false);
assert_eq!(Natural::from(102u32).divisible_by(Natural::from(3u32)), true);
assert_eq!(
    Natural::from_str("1000000000000000000000000").unwrap()
            .divisible_by(Natural::from_str("1000000000000").unwrap()),
    true
);

impl<'a> DivisibleBy<Natural> for &'a Natural

fn divisible_by(self, other: Natural) -> bool

Returns whether a Natural is divisible by another Natural; in other words, whether the first is a multiple of the second. The first Naturals are taken by reference and the second by value.

This means that zero is divisible by any Natural, including zero; but a nonzero Natural is never divisible by zero.

It’s more efficient to use this function than to compute the remainder and check whether it’s zero.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::DivisibleBy;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!((&Natural::ZERO).divisible_by(Natural::ZERO), true);
assert_eq!((&Natural::from(100u32)).divisible_by(Natural::from(3u32)), false);
assert_eq!((&Natural::from(102u32)).divisible_by(Natural::from(3u32)), true);
assert_eq!(
    (&Natural::from_str("1000000000000000000000000").unwrap())
            .divisible_by(Natural::from_str("1000000000000").unwrap()),
    true
);

impl<'a> DivisibleByPowerOf2 for &'a Natural

fn divisible_by_power_of_2(self, pow: u64) -> bool

Returns whether a Natural is divisible by $2^k$.

$f(x, k) = (2^k|x)$.

$f(x, k) = (\exists n \in \N : \ x = n2^k)$.

If self is 0, the result is always true; otherwise, it is equivalent to self.trailing_zeros().unwrap() <= pow, but more efficient.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{DivisibleByPowerOf2, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.divisible_by_power_of_2(100), true);
assert_eq!(Natural::from(100u32).divisible_by_power_of_2(2), true);
assert_eq!(Natural::from(100u32).divisible_by_power_of_2(3), false);
assert_eq!(Natural::from(10u32).pow(12).divisible_by_power_of_2(12), true);
assert_eq!(Natural::from(10u32).pow(12).divisible_by_power_of_2(13), false);

impl<'a, 'b> EqMod<&'a Integer, &'b Natural> for Integer

fn eq_mod(self, other: &'a Integer, m: &'b Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. The first number is taken by value and the second and third by reference.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    Integer::from(123).eq_mod(&Integer::from(223), &Natural::from(100u32)),
    true
);
assert_eq!(
    Integer::from_str("1000000987654").unwrap().eq_mod(
        &Integer::from_str("-999999012346").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    Integer::from_str("1000000987654").unwrap().eq_mod(
        &Integer::from_str("2000000987655").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl<'a> EqMod<&'a Integer, Natural> for Integer

fn eq_mod(self, other: &'a Integer, m: Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. The first and third numbers are taken by value and the second by reference.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    Integer::from(123).eq_mod(&Integer::from(223), Natural::from(100u32)),
    true
);
assert_eq!(
    Integer::from_str("1000000987654").unwrap().eq_mod(
        &Integer::from_str("-999999012346").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    Integer::from_str("1000000987654").unwrap().eq_mod(
        &Integer::from_str("2000000987655").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl<'a, 'b> EqMod<&'a Natural, &'b Natural> for Natural

fn eq_mod(self, other: &'a Natural, m: &'b Natural) -> bool

Returns whether a Natural is equivalent to another Natural modulo a third; that is, whether the difference between the first two is a multiple of the third. The first is taken by value and the second and third by reference.

Two Naturals are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    Natural::from(123u32).eq_mod(&Natural::from(223u32), &Natural::from(100u32)),
    true
);
assert_eq!(
    Natural::from_str("1000000987654").unwrap().eq_mod(
        &Natural::from_str("2000000987654").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    Natural::from_str("1000000987654").unwrap().eq_mod(
        &Natural::from_str("2000000987655").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl<'a> EqMod<&'a Natural, Natural> for Natural

fn eq_mod(self, other: &'a Natural, m: Natural) -> bool

Returns whether a Natural is equivalent to another Natural modulo a third; that is, whether the difference between the first two is a multiple of the third. The first and third are taken by value and the second by reference.

Two Naturals are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    Natural::from(123u32).eq_mod(&Natural::from(223u32), Natural::from(100u32)),
    true
);
assert_eq!(
    Natural::from_str("1000000987654").unwrap().eq_mod(
        &Natural::from_str("2000000987654").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    Natural::from_str("1000000987654").unwrap().eq_mod(
        &Natural::from_str("2000000987655").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl<'a, 'b, 'c> EqMod<&'b Integer, &'c Natural> for &'a Integer

fn eq_mod(self, other: &'b Integer, m: &'c Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. All three numbers are taken by reference.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    (&Integer::from(123)).eq_mod(&Integer::from(223), &Natural::from(100u32)),
    true
);
assert_eq!(
    (&Integer::from_str("1000000987654").unwrap()).eq_mod(
        &Integer::from_str("-999999012346").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    (&Integer::from_str("1000000987654").unwrap()).eq_mod(
        &Integer::from_str("2000000987655").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl<'a, 'b> EqMod<&'b Integer, Natural> for &'a Integer

fn eq_mod(self, other: &'b Integer, m: Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. The first two numbers are taken by reference and the third by value.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    (&Integer::from(123)).eq_mod(&Integer::from(223), Natural::from(100u32)),
    true
);
assert_eq!(
    (&Integer::from_str("1000000987654").unwrap()).eq_mod(
        &Integer::from_str("-999999012346").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    (&Integer::from_str("1000000987654").unwrap()).eq_mod(
        &Integer::from_str("2000000987655").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl<'a, 'b, 'c> EqMod<&'b Natural, &'c Natural> for &'a Natural

fn eq_mod(self, other: &'b Natural, m: &'c Natural) -> bool

Returns whether a Natural is equivalent to another Natural modulo a third; that is, whether the difference between the first two is a multiple of the third. All three are taken by reference.

Two Naturals are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    (&Natural::from(123u32)).eq_mod(&Natural::from(223u32), &Natural::from(100u32)),
    true
);
assert_eq!(
    (&Natural::from_str("1000000987654").unwrap()).eq_mod(
        &Natural::from_str("2000000987654").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    (&Natural::from_str("1000000987654").unwrap()).eq_mod(
        &Natural::from_str("2000000987655").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl<'a, 'b> EqMod<&'b Natural, Natural> for &'a Natural

fn eq_mod(self, other: &'b Natural, m: Natural) -> bool

Returns whether a Natural is equivalent to another Natural modulo a third; that is, whether the difference between the first two is a multiple of the third. The first and second are taken by reference and the third by value.

Two Naturals are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    (&Natural::from(123u32)).eq_mod(&Natural::from(223u32), Natural::from(100u32)),
    true
);
assert_eq!(
    (&Natural::from_str("1000000987654").unwrap()).eq_mod(
        &Natural::from_str("2000000987654").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    (&Natural::from_str("1000000987654").unwrap()).eq_mod(
        &Natural::from_str("2000000987655").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl<'a> EqMod<Integer, &'a Natural> for Integer

fn eq_mod(self, other: Integer, m: &'a Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. The first two numbers are taken by value and the third by reference.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    Integer::from(123).eq_mod(Integer::from(223), &Natural::from(100u32)),
    true
);
assert_eq!(
    Integer::from_str("1000000987654").unwrap().eq_mod(
        Integer::from_str("-999999012346").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    Integer::from_str("1000000987654").unwrap().eq_mod(
        Integer::from_str("2000000987655").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl<'a, 'b> EqMod<Integer, &'b Natural> for &'a Integer

fn eq_mod(self, other: Integer, m: &'b Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. The first and third numbers are taken by reference and the third by value.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    (&Integer::from(123)).eq_mod(Integer::from(223), &Natural::from(100u32)),
    true
);
assert_eq!(
    (&Integer::from_str("1000000987654").unwrap()).eq_mod(
        Integer::from_str("-999999012346").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    (&Integer::from_str("1000000987654").unwrap()).eq_mod(
        Integer::from_str("2000000987655").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl EqMod<Integer, Natural> for Integer

fn eq_mod(self, other: Integer, m: Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. All three numbers are taken by value.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    Integer::from(123).eq_mod(Integer::from(223), Natural::from(100u32)),
    true
);
assert_eq!(
    Integer::from_str("1000000987654").unwrap().eq_mod(
        Integer::from_str("-999999012346").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    Integer::from_str("1000000987654").unwrap().eq_mod(
        Integer::from_str("2000000987655").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl<'a> EqMod<Integer, Natural> for &'a Integer

fn eq_mod(self, other: Integer, m: Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. The first number is taken by reference and the second and third by value.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    (&Integer::from(123)).eq_mod(Integer::from(223), Natural::from(100u32)),
    true
);
assert_eq!(
    (&Integer::from_str("1000000987654").unwrap()).eq_mod(
        Integer::from_str("-999999012346").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    (&Integer::from_str("1000000987654").unwrap()).eq_mod(
        Integer::from_str("2000000987655").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl<'a> EqMod<Natural, &'a Natural> for Natural

fn eq_mod(self, other: Natural, m: &'a Natural) -> bool

Returns whether a Natural is equivalent to another Natural modulo a third; that is, whether the difference between the first two is a multiple of the third. The first two are taken by value and the third by reference.

Two Naturals are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    Natural::from(123u32).eq_mod(Natural::from(223u32), &Natural::from(100u32)),
    true
);
assert_eq!(
    Natural::from_str("1000000987654").unwrap().eq_mod(
        Natural::from_str("2000000987654").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    Natural::from_str("1000000987654").unwrap().eq_mod(
        Natural::from_str("2000000987655").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl<'a, 'b> EqMod<Natural, &'b Natural> for &'a Natural

fn eq_mod(self, other: Natural, m: &'b Natural) -> bool

Returns whether a Natural is equivalent to another Natural modulo a third; that is, whether the difference between the first two is a multiple of the third. The first and third are taken by reference and the second by value.

Two Naturals are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    (&Natural::from(123u32)).eq_mod(Natural::from(223u32), &Natural::from(100u32)),
    true
);
assert_eq!(
    (&Natural::from_str("1000000987654").unwrap()).eq_mod(
        Natural::from_str("2000000987654").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    (&Natural::from_str("1000000987654").unwrap()).eq_mod(
        Natural::from_str("2000000987655").unwrap(),
        &Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl EqMod<Natural, Natural> for Natural

fn eq_mod(self, other: Natural, m: Natural) -> bool

Returns whether a Natural is equivalent to another Natural modulo a third; that is, whether the difference between the first two is a multiple of the third. All three are taken by value.

Two Naturals are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    Natural::from(123u32).eq_mod(Natural::from(223u32), Natural::from(100u32)),
    true
);
assert_eq!(
    Natural::from_str("1000000987654").unwrap().eq_mod(
        Natural::from_str("2000000987654").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    Natural::from_str("1000000987654").unwrap().eq_mod(
        Natural::from_str("2000000987655").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl<'a> EqMod<Natural, Natural> for &'a Natural

fn eq_mod(self, other: Natural, m: Natural) -> bool

Returns whether a Natural is equivalent to another Natural modulo a third; that is, whether the difference between the first two is a multiple of the third. The first is taken by reference and the second and third by value.

Two Naturals are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    (&Natural::from(123u32)).eq_mod(Natural::from(223u32), Natural::from(100u32)),
    true
);
assert_eq!(
    (&Natural::from_str("1000000987654").unwrap()).eq_mod(
        Natural::from_str("2000000987654").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    true
);
assert_eq!(
    (&Natural::from_str("1000000987654").unwrap()).eq_mod(
        Natural::from_str("2000000987655").unwrap(),
        Natural::from_str("1000000000000").unwrap()
    ),
    false
);

impl<'a, 'b> EqModPowerOf2<&'b Natural> for &'a Natural

fn eq_mod_power_of_2(self, other: &'b Natural, pow: u64) -> bool

Returns whether one Natural is equal to another modulo $2^k$; that is, whether their $k$ least-significant bits are equal.

$f(x, y, k) = (x \equiv y \mod 2^k)$.

$f(x, y, k) = (\exists n \in \Z : x - y = n2^k)$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::EqModPowerOf2;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::ZERO).eq_mod_power_of_2(&Natural::from(256u32), 8), true);
assert_eq!(
    (&Natural::from(0b1101u32)).eq_mod_power_of_2(&Natural::from(0b10101u32), 3),
    true
);
assert_eq!(
    (&Natural::from(0b1101u32)).eq_mod_power_of_2(&Natural::from(0b10101u32), 4),
    false
);

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

fn floor_log_base(self, base: &Natural) -> u64

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

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

Worst-case complexity

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

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

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

Panics

Panics if self is 0 or base is less than 2.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::FloorLogBase;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(80u32).floor_log_base(&Natural::from(3u32)), 3);
assert_eq!(Natural::from(81u32).floor_log_base(&Natural::from(3u32)), 4);
assert_eq!(Natural::from(82u32).floor_log_base(&Natural::from(3u32)), 4);
assert_eq!(Natural::from(4294967296u64).floor_log_base(&Natural::from(10u32)), 9);

This is equivalent to fmpz_flog from fmpz/flog.c, FLINT 2.7.1.

type Output = u64

impl<'a> FloorLogBase2 for &'a Natural

fn floor_log_base_2(self) -> u64

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

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

Worst-case complexity

Constant time and additional memory.

Panics

Panics if self is 0.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::FloorLogBase2;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).floor_log_base_2(), 1);
assert_eq!(Natural::from(100u32).floor_log_base_2(), 6);

type Output = u64

impl<'a> FloorLogBasePowerOf2<u64> for &'a Natural

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

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

$f(x, k) = \lfloor\log_{2^k} x\rfloor$.

Worst-case complexity

Constant time and additional memory.

Panics

Panics if self is 0 or pow is 0.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::FloorLogBasePowerOf2;
use malachite_nz::natural::Natural;

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

type Output = u64

impl FloorRoot<u64> for Natural

fn floor_root(self, exp: u64) -> Natural

Returns the floor of the $n$th root of a Natural, taking the Natural by value.

$f(x, n) = \lfloor\sqrt[n]{x}\rfloor$.

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.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::FloorRoot;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(999u16).floor_root(3), 9);
assert_eq!(Natural::from(1000u16).floor_root(3), 10);
assert_eq!(Natural::from(1001u16).floor_root(3), 10);
assert_eq!(Natural::from(100000000000u64).floor_root(5), 158);

type Output = Natural

impl<'a> FloorRoot<u64> for &'a Natural

fn floor_root(self, exp: u64) -> Natural

Returns the floor of the $n$th root of a Natural, taking the Natural by reference.

$f(x, n) = \lfloor\sqrt[n]{x}\rfloor$.

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.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::FloorRoot;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(999u16)).floor_root(3), 9);
assert_eq!((&Natural::from(1000u16)).floor_root(3), 10);
assert_eq!((&Natural::from(1001u16)).floor_root(3), 10);
assert_eq!((&Natural::from(100000000000u64)).floor_root(5), 158);

type Output = Natural

impl FloorRootAssign<u64> for Natural

fn floor_root_assign(&mut self, exp: u64)

Replaces a Natural with the floor of its $n$th root.

$x \gets \lfloor\sqrt[n]{x}\rfloor$.

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.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::FloorRootAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(999u16);
x.floor_root_assign(3);
assert_eq!(x, 9);

let mut x = Natural::from(1000u16);
x.floor_root_assign(3);
assert_eq!(x, 10);

let mut x = Natural::from(1001u16);
x.floor_root_assign(3);
assert_eq!(x, 10);

let mut x = Natural::from(100000000000u64);
x.floor_root_assign(5);
assert_eq!(x, 158);

impl FloorSqrt for Natural

fn floor_sqrt(self) -> Natural

Returns the floor of the square root of a Natural, taking it by value.

$f(x) = \lfloor\sqrt{x}\rfloor$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::FloorSqrt;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(99u8).floor_sqrt(), 9);
assert_eq!(Natural::from(100u8).floor_sqrt(), 10);
assert_eq!(Natural::from(101u8).floor_sqrt(), 10);
assert_eq!(Natural::from(1000000000u32).floor_sqrt(), 31622);
assert_eq!(Natural::from(10000000000u64).floor_sqrt(), 100000);

type Output = Natural

impl<'a> FloorSqrt for &'a Natural

fn floor_sqrt(self) -> Natural

Returns the floor of the square root of a Natural, taking it by value.

$f(x) = \lfloor\sqrt{x}\rfloor$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::FloorSqrt;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(99u8)).floor_sqrt(), 9);
assert_eq!((&Natural::from(100u8)).floor_sqrt(), 10);
assert_eq!((&Natural::from(101u8)).floor_sqrt(), 10);
assert_eq!((&Natural::from(1000000000u32)).floor_sqrt(), 31622);
assert_eq!((&Natural::from(10000000000u64)).floor_sqrt(), 100000);

type Output = Natural

impl FloorSqrtAssign for Natural

fn floor_sqrt_assign(&mut self)

Replaces a Natural with the floor of its square root.

$x \gets \lfloor\sqrt{x}\rfloor$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::FloorSqrtAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(99u8);
x.floor_sqrt_assign();
assert_eq!(x, 9);

let mut x = Natural::from(100u8);
x.floor_sqrt_assign();
assert_eq!(x, 10);

let mut x = Natural::from(101u8);
x.floor_sqrt_assign();
assert_eq!(x, 10);

let mut x = Natural::from(1000000000u32);
x.floor_sqrt_assign();
assert_eq!(x, 31622);

let mut x = Natural::from(10000000000u64);
x.floor_sqrt_assign();
assert_eq!(x, 100000);

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

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

Converts a Natural to a primitive float.

If there are two nearest floats, the one whose least-significant bit is zero is chosen. If the Natural is larger than the maximum finite float, then the result is the maximum finite float.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

See here.

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

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

Converts a Natural to a primitive float.

If there are two nearest floats, the one whose least-significant bit is zero is chosen. If the Natural is larger than the maximum finite float, then the result is the maximum finite float.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

See here.

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

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

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert_eq!(Integer::from(&Natural::from(123u32)), 123);
assert_eq!(Integer::from(&Natural::from(10u32).pow(12)), 1000000000000u64);

impl From<Natural> for Integer

fn from(value: Natural) -> Integer

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

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert_eq!(Integer::from(Natural::from(123u32)), 123);
assert_eq!(Integer::from(Natural::from(10u32).pow(12)), 1000000000000u64);

impl From<f32> for Natural

fn from(value: f32) -> Natural

Converts a floating-point value to the nearest Natural.

Floating-point values exactly between two Naturals are rounded to the even one. The floating point value cannot be NaN or infinite, and it cannot round to a negative integer (so it must be greater than or equal to -0.5).

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Panics

Panics if value is NaN or infinite, or if it would round to a negative integer.

Examples

See here.

impl From<f64> for Natural

fn from(value: f64) -> Natural

Converts a floating-point value to the nearest Natural.

Floating-point values exactly between two Naturals are rounded to the even one. The floating point value cannot be NaN or infinite, and it cannot round to a negative integer (so it must be greater than or equal to -0.5).

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Panics

Panics if value is NaN or infinite, or if it would round to a negative integer.

Examples

See here.

impl From<u128> for Natural

fn from(u: u128) -> Natural

Converts an unsigned primitive integer to a Natural, where the integer’s width is larger than a Limb’s.

This implementation is general enough to also work for usize, regardless of whether it is equal in width to Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<u16> for Natural

fn from(u: u16) -> Natural

Converts an unsigned primitive integer to a Natural, where the integer’s width is smaller than a Limb’s.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<u32> for Natural

fn from(u: u32) -> Natural

Converts an unsigned primitive integer to a Natural, where the integer’s width is smaller than a Limb’s.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<u64> for Natural

fn from(u: u64) -> Natural

Converts a Limb to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<u8> for Natural

fn from(u: u8) -> Natural

Converts an unsigned primitive integer to a Natural, where the integer’s width is smaller than a Limb’s.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl From<usize> for Natural

fn from(u: usize) -> Natural

Converts an unsigned primitive integer to a Natural, where the integer’s width is larger than a Limb’s.

This implementation is general enough to also work for usize, regardless of whether it is equal in width to Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl FromSciString for Natural

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

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

Use FromSciStringOptions to specify the base (from 2 to 36, inclusive) and the rounding mode, in case rounding is necessary because the string represents a non-integer.

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. These are most useful in conjunction with exponents, but they may be used on their own. If the string represents a non-integer, the rounding mode specified in options is used to round to an integer.

If the string is unparseable, None is returned. None is also returned if the rounding mode in options is Exact, but rounding is necessary.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::conversion::string::options::FromSciStringOptions;
use malachite_base::num::conversion::traits::FromSciString;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from_sci_string("123").unwrap(), 123);
assert_eq!(Natural::from_sci_string("123.5").unwrap(), 124);
assert_eq!(Natural::from_sci_string("-123.5"), None);
assert_eq!(Natural::from_sci_string("1.23e10").unwrap(), 12300000000u64);

let mut options = FromSciStringOptions::default();
assert_eq!(Natural::from_sci_string_with_options("123.5", options).unwrap(), 124);

options.set_rounding_mode(RoundingMode::Floor);
assert_eq!(Natural::from_sci_string_with_options("123.5", options).unwrap(), 123);

options = FromSciStringOptions::default();
options.set_base(16);
assert_eq!(Natural::from_sci_string_with_options("ff", options).unwrap(), 255);

options = FromSciStringOptions::default();
options.set_base(36);
assert_eq!(Natural::from_sci_string_with_options("1e5", options).unwrap(), 1805);
assert_eq!(Natural::from_sci_string_with_options("1e+5", options).unwrap(), 60466176);
assert_eq!(Natural::from_sci_string_with_options("1e-5", options).unwrap(), 0);

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

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

impl FromStr for Natural

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

Converts an string to a Natural.

If the string does not represent a valid Natural, an Err is returned. To be valid, the string must be nonempty and only contain the chars '0' through '9'. Leading zeros are allowed.

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_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(Natural::from_str("123456").unwrap(), 123456);
assert_eq!(Natural::from_str("00123456").unwrap(), 123456);
assert_eq!(Natural::from_str("0").unwrap(), 0);

assert!(Natural::from_str("").is_err());
assert!(Natural::from_str("a").is_err());
assert!(Natural::from_str("-5").is_err());

type Err = ()

The associated error which can be returned from parsing.

impl FromStringBase for Natural

fn from_string_base(base: u8, s: &str) -> Option<Natural>

Converts an string, in a specified base, to a Natural.

If the string does not represent a valid Natural, an Err is returned. To be valid, the string must be nonempty and only contain the chars '0' through '9', 'a' through 'z', and 'A' through 'Z'; and only characters that represent digits smaller than the base are allowed. Leading zeros are always allowed.

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

Panics

Panics if base is less than 2 or greater than 36.

Examples

extern crate malachite_base;

use malachite_base::num::conversion::traits::{Digits, FromStringBase};
use malachite_nz::natural::Natural;

assert_eq!(Natural::from_string_base(10, "123456").unwrap(), 123456);
assert_eq!(Natural::from_string_base(10, "00123456").unwrap(), 123456);
assert_eq!(Natural::from_string_base(16, "0").unwrap(), 0);
assert_eq!(Natural::from_string_base(16, "deadbeef").unwrap(), 3735928559u32);
assert_eq!(Natural::from_string_base(16, "deAdBeEf").unwrap(), 3735928559u32);

assert!(Natural::from_string_base(10, "").is_none());
assert!(Natural::from_string_base(10, "a").is_none());
assert!(Natural::from_string_base(10, "-5").is_none());
assert!(Natural::from_string_base(2, "2").is_none());

impl<'a> Gcd<&'a Natural> for Natural

fn gcd(self, other: &'a Natural) -> Natural

Computes the GCD (greatest common divisor) of two Naturals, taking the first by value and the second by reference.

The GCD of 0 and $n$, for any $n$, is 0. In particular, $\gcd(0, 0) = 0$, which makes sense if we interpret “greatest” to mean “greatest by the divisibility order”.

$$ f(x, y) = \gcd(x, y). $$

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Gcd;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).gcd(&Natural::from(5u32)), 1);
assert_eq!(Natural::from(12u32).gcd(&Natural::from(90u32)), 6);

type Output = Natural

impl<'a, 'b> Gcd<&'a Natural> for &'b Natural

fn gcd(self, other: &'a Natural) -> Natural

Computes the GCD (greatest common divisor) of two Naturals, taking both by reference.

The GCD of 0 and $n$, for any $n$, is 0. In particular, $\gcd(0, 0) = 0$, which makes sense if we interpret “greatest” to mean “greatest by the divisibility order”.

$$ f(x, y) = \gcd(x, y). $$

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Gcd;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(3u32)).gcd(&Natural::from(5u32)), 1);
assert_eq!((&Natural::from(12u32)).gcd(&Natural::from(90u32)), 6);

type Output = Natural

impl Gcd<Natural> for Natural

fn gcd(self, other: Natural) -> Natural

Computes the GCD (greatest common divisor) of two Naturals, taking both by value.

The GCD of 0 and $n$, for any $n$, is 0. In particular, $\gcd(0, 0) = 0$, which makes sense if we interpret “greatest” to mean “greatest by the divisibility order”.

$$ f(x, y) = \gcd(x, y). $$

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Gcd;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).gcd(Natural::from(5u32)), 1);
assert_eq!(Natural::from(12u32).gcd(Natural::from(90u32)), 6);

type Output = Natural

impl<'a> Gcd<Natural> for &'a Natural

fn gcd(self, other: Natural) -> Natural

Computes the GCD (greatest common divisor) of two Naturals, taking the first by reference and the second by value.

The GCD of 0 and $n$, for any $n$, is 0. In particular, $\gcd(0, 0) = 0$, which makes sense if we interpret “greatest” to mean “greatest by the divisibility order”.

$$ f(x, y) = \gcd(x, y). $$

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Gcd;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(3u32)).gcd(Natural::from(5u32)), 1);
assert_eq!((&Natural::from(12u32)).gcd(Natural::from(90u32)), 6);

type Output = Natural

impl<'a> GcdAssign<&'a Natural> for Natural

fn gcd_assign(&mut self, other: &'a Natural)

Replaces a Natural by its GCD (greatest common divisor) with another Natural, taking the Natural on the right-hand side by reference.

$$ x \gets \gcd(x, y). $$

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::GcdAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(3u32);
x.gcd_assign(&Natural::from(5u32));
assert_eq!(x, 1);

let mut x = Natural::from(12u32);
x.gcd_assign(&Natural::from(90u32));
assert_eq!(x, 6);

impl GcdAssign<Natural> for Natural

fn gcd_assign(&mut self, other: Natural)

Replaces a Natural by its GCD (greatest common divisor) with another Natural, taking the Natural on the right-hand side by value.

$$ x \gets \gcd(x, y). $$

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::GcdAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(3u32);
x.gcd_assign(Natural::from(5u32));
assert_eq!(x, 1);

let mut x = Natural::from(12u32);
x.gcd_assign(Natural::from(90u32));
assert_eq!(x, 6);

impl<'a, 'b> HammingDistance<&'a Natural> for &'b Natural

fn hamming_distance(self, other: &'a Natural) -> u64

Determines the Hamming distance between two [Natural]s.

Both Naturals have infinitely many implicit leading zeros.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::One;
use malachite_base::num::logic::traits::HammingDistance;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(123u32).hamming_distance(&Natural::from(123u32)), 0);
// 105 = 1101001b, 123 = 1111011
assert_eq!(Natural::from(105u32).hamming_distance(&Natural::from(123u32)), 2);
let n = Natural::ONE << 100u32;
assert_eq!(n.hamming_distance(&(&n - Natural::ONE)), 101);

impl Hash for Natural

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<'a> IntegerMantissaAndExponent<Natural, u64, Natural> for &'a Natural

fn integer_mantissa_and_exponent(self) -> (Natural, u64)

Returns a Natural’s integer mantissa and exponent.

When $x$ is nonzero, we can write $x = 2^{e_i}m_i$, where $e_i$ is an integer and $m_i$ is an odd integer. $$ f(x) = (\frac{|x|}{2^{e_i}}, e_i), $$ where $e_i$ is the unique integer such that $x/2^{e_i}$ is an odd integer.

The inverse operation is from_integer_mantissa_and_exponent.

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

extern crate malachite_base;

use malachite_base::num::conversion::traits::IntegerMantissaAndExponent;
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::from(123u32).integer_mantissa_and_exponent(),
    (Natural::from(123u32), 0)
);
assert_eq!(
    Natural::from(100u32).integer_mantissa_and_exponent(),
    (Natural::from(25u32), 2)
);

fn integer_mantissa(self) -> Natural

Returns a Natural’s integer mantissa.

When $x$ is nonzero, we can write $x = 2^{e_i}m_i$, where $e_i$ is an integer and $m_i$ is an odd integer. $$ f(x) = \frac{|x|}{2^{e_i}}, $$ where $e_i$ is the unique integer such that $x/2^{e_i}$ is an odd integer.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if self is zero.

Examples

extern crate malachite_base;

use malachite_base::num::conversion::traits::IntegerMantissaAndExponent;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(123u32).integer_mantissa(), 123);
assert_eq!(Natural::from(100u32).integer_mantissa(), 25);

fn integer_exponent(self) -> u64

Returns a Natural’s integer exponent.

When $x$ is nonzero, we can write $x = 2^{e_i}m_i$, where $e_i$ is an integer and $m_i$ is an odd integer. $$ f(x) = e_i, $$ where $e_i$ is the unique integer such that $x/2^{e_i}$ is an odd integer.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Panics

Panics if self is zero.

Examples

extern crate malachite_base;

use malachite_base::num::conversion::traits::IntegerMantissaAndExponent;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(123u32).integer_exponent(), 0);
assert_eq!(Natural::from(100u32).integer_exponent(), 2);

fn from_integer_mantissa_and_exponent(
    integer_mantissa: Natural,
    integer_exponent: u64
) -> Option<Natural>

Constructs a Natural from its integer mantissa and exponent.

When $x$ is nonzero, we can write $x = 2^{e_i}m_i$, where $e_i$ is an integer and $m_i$ is an odd integer.

$$ f(x) = 2^{e_i}m_i. $$

The input does not have to be reduced; that is, the mantissa does not have to be odd.

The result is an Option, but for this trait implementation the result is always Some.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is integer_mantissa.significant_bits() + integer_exponent.

Examples

extern crate malachite_base;

use malachite_base::num::conversion::traits::IntegerMantissaAndExponent;
use malachite_nz::natural::Natural;

let n = <&Natural as IntegerMantissaAndExponent<_, _, _>>
    ::from_integer_mantissa_and_exponent(Natural::from(123u32), 0).unwrap();
assert_eq!(n, 123);
let n = <&Natural as IntegerMantissaAndExponent<_, _, _>>
    ::from_integer_mantissa_and_exponent(Natural::from(25u32), 2).unwrap();
assert_eq!(n, 100);

impl<'a> IsInteger for &'a Natural

fn is_integer(self) -> bool

Determines whether a Natural is an integer. It always returns true.

$f(x) = \textrm{true}$.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::{One, Zero};
use malachite_base::num::conversion::traits::IsInteger;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.is_integer(), true);
assert_eq!(Natural::ONE.is_integer(), true);
assert_eq!(Natural::from(100u32).is_integer(), true);

impl IsPowerOf2 for Natural

fn is_power_of_2(&self) -> bool

Determines whether a Natural is an integer power of 2.

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

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{IsPowerOf2, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(Natural::ZERO.is_power_of_2(), false);
assert_eq!(Natural::from(123u32).is_power_of_2(), false);
assert_eq!(Natural::from(0x80u32).is_power_of_2(), true);
assert_eq!(Natural::from(10u32).pow(12).is_power_of_2(), false);
assert_eq!(Natural::from_str("1099511627776").unwrap().is_power_of_2(), true);

impl<'a> Lcm<&'a Natural> for Natural

fn lcm(self, other: &'a Natural) -> Natural

Computes the LCM (least common multiple) of two Naturals, taking the first by value and the second by reference.

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

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Lcm;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).lcm(&Natural::from(5u32)), 15);
assert_eq!(Natural::from(12u32).lcm(&Natural::from(90u32)), 180);

type Output = Natural

impl<'a, 'b> Lcm<&'a Natural> for &'b Natural

fn lcm(self, other: &'a Natural) -> Natural

Computes the LCM (least common multiple) of two Naturals, taking both by reference.

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

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Lcm;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(3u32)).lcm(&Natural::from(5u32)), 15);
assert_eq!((&Natural::from(12u32)).lcm(&Natural::from(90u32)), 180);

type Output = Natural

impl Lcm<Natural> for Natural

fn lcm(self, other: Natural) -> Natural

Computes the LCM (least common multiple) of two Naturals, taking both by value.

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

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Lcm;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).lcm(Natural::from(5u32)), 15);
assert_eq!(Natural::from(12u32).lcm(Natural::from(90u32)), 180);

type Output = Natural

impl<'a> Lcm<Natural> for &'a Natural

fn lcm(self, other: Natural) -> Natural

Computes the LCM (least common multiple) of two Naturals, taking the first by reference and the second by value.

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

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Lcm;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(3u32)).lcm(Natural::from(5u32)), 15);
assert_eq!((&Natural::from(12u32)).lcm(Natural::from(90u32)), 180);

type Output = Natural

impl<'a> LcmAssign<&'a Natural> for Natural

fn lcm_assign(&mut self, other: &'a Natural)

Replaces a Natural by its LCM (least common multiple) with another Natural, taking the Natural on the right-hand side by reference.

$$ x \gets \operatorname{lcm}(x, y). $$

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::LcmAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(3u32);
x.lcm_assign(&Natural::from(5u32));
assert_eq!(x, 15);

let mut x = Natural::from(12u32);
x.lcm_assign(&Natural::from(90u32));
assert_eq!(x, 180);

impl LcmAssign<Natural> for Natural

fn lcm_assign(&mut self, other: Natural)

Replaces a Natural by its LCM (least common multiple) with another Natural, taking the Natural on the right-hand side by value.

$$ x \gets \operatorname{lcm}(x, y). $$

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::LcmAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(3u32);
x.lcm_assign(Natural::from(5u32));
assert_eq!(x, 15);

let mut x = Natural::from(12u32);
x.lcm_assign(Natural::from(90u32));
assert_eq!(x, 180);

impl LowMask for Natural

fn low_mask(bits: u64) -> Natural

Returns a Natural whose least significant $b$ bits are true and whose other bits are false.

$f(b) = 2^b - 1$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is bits.

Examples

extern crate malachite_base;

use malachite_base::num::logic::traits::LowMask;
use malachite_nz::natural::Natural;

assert_eq!(Natural::low_mask(0), 0);
assert_eq!(Natural::low_mask(3), 7);
assert_eq!(Natural::low_mask(100).to_string(), "1267650600228229401496703205375");

impl LowerHex for Natural

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

Converts a Natural to a hexadecimal String using lowercase characters.

Using the # format flag prepends "0x" to the string.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToLowerHexString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(Natural::ZERO.to_lower_hex_string(), "0");
assert_eq!(Natural::from(123u32).to_lower_hex_string(), "7b");
assert_eq!(
    Natural::from_str("1000000000000").unwrap().to_lower_hex_string(),
    "e8d4a51000"
);
assert_eq!(format!("{:07x}", Natural::from(123u32)), "000007b");

assert_eq!(format!("{:#x}", Natural::ZERO), "0x0");
assert_eq!(format!("{:#x}", Natural::from(123u32)), "0x7b");
assert_eq!(
    format!("{:#x}", Natural::from_str("1000000000000").unwrap()),
    "0xe8d4a51000"
);
assert_eq!(format!("{:#07x}", Natural::from(123u32)), "0x0007b");

impl Min for Natural

The minimum value of a Natural, 0.

const MIN: Natural = Natural(Small(0))

The minimum value of Self.

impl<'a> Mod<&'a Natural> for Natural

fn mod_op(self, other: &'a Natural) -> Natural

Divides a Natural by another Natural, taking the first by value and the second by reference and returning just the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor. $$

Worst-case complexity

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

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

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

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Mod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(Natural::from(23u32).mod_op(&Natural::from(10u32)), 3);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
     Natural::from_str("1000000000000000000000000").unwrap()
            .mod_op(&Natural::from_str("1234567890987").unwrap()),
     530068894399u64
);

type Output = Natural

impl<'a, 'b> Mod<&'b Natural> for &'a Natural

fn mod_op(self, other: &'b Natural) -> Natural

Divides a Natural by another Natural, taking both by reference and returning just the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor. $$

Worst-case complexity

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

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

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

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Mod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!((&Natural::from(23u32)).mod_op(&Natural::from(10u32)), 3);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
     (&Natural::from_str("1000000000000000000000000").unwrap())
         .mod_op(&Natural::from_str("1234567890987").unwrap()),
     530068894399u64
);

type Output = Natural

impl Mod<Natural> for Natural

fn mod_op(self, other: Natural) -> Natural

Divides a Natural by another Natural, taking both by value and returning just the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor. $$

This function is called mod_op rather than mod because mod is a Rust keyword.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Mod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(Natural::from(23u32).mod_op(Natural::from(10u32)), 3);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
     Natural::from_str("1000000000000000000000000").unwrap()
            .mod_op(Natural::from_str("1234567890987").unwrap()),
     530068894399u64
);

type Output = Natural

impl<'a> Mod<Natural> for &'a Natural

fn mod_op(self, other: Natural) -> Natural

Divides a Natural by another Natural, taking the first by reference and the second by value and returning just the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor. $$

Worst-case complexity

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

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

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

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Mod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!((&Natural::from(23u32)).mod_op(Natural::from(10u32)), 3);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
     (&Natural::from_str("1000000000000000000000000").unwrap())
         .mod_op(Natural::from_str("1234567890987").unwrap()),
     530068894399u64
);

type Output = Natural

impl<'a, 'b> ModAdd<&'a Natural, &'b Natural> for Natural

fn mod_add(self, other: &'a Natural, m: &'b Natural) -> Natural

Adds two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first Natural is taken by value and the second and third by reference.

$f(x, y, m) = z$, where $x, y, z < m$ and $x + y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModAdd;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.mod_add(&Natural::from(3u32), &Natural::from(5u32)), 3);
assert_eq!(Natural::from(7u32).mod_add(&Natural::from(5u32), &Natural::from(10u32)), 2);

This is equivalent to _fmpz_mod_addN from fmpz_mod/add.c, FLINT 2.7.1, where b is taken by value and c and m are taken by reference.

type Output = Natural

impl<'a> ModAdd<&'a Natural, Natural> for Natural

fn mod_add(self, other: &'a Natural, m: Natural) -> Natural

Adds two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first and third Naturals are taken by value and the second by reference.

$f(x, y, m) = z$, where $x, y, z < m$ and $x + y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModAdd;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.mod_add(&Natural::from(3u32), Natural::from(5u32)), 3);
assert_eq!(Natural::from(7u32).mod_add(&Natural::from(5u32), Natural::from(10u32)), 2);

This is equivalent to _fmpz_mod_addN from fmpz_mod/add.c, FLINT 2.7.1, where b and m are taken by value and c is taken by reference.

type Output = Natural

impl<'a, 'b, 'c> ModAdd<&'b Natural, &'c Natural> for &'a Natural

fn mod_add(self, other: &'b Natural, m: &'c Natural) -> Natural

Adds two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. All three Naturals are taken by reference.

$f(x, y, m) = z$, where $x, y, z < m$ and $x + y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModAdd;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::ZERO).mod_add(&Natural::from(3u32), &Natural::from(5u32)), 3);
assert_eq!((&Natural::from(7u32)).mod_add(&Natural::from(5u32), &Natural::from(10u32)), 2);

This is equivalent to _fmpz_mod_addN from fmpz_mod/add.c, FLINT 2.7.1, where b, c, and m are taken by reference.

type Output = Natural

impl<'a, 'b> ModAdd<&'b Natural, Natural> for &'a Natural

fn mod_add(self, other: &'b Natural, m: Natural) -> Natural

Adds two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first two Naturals are taken by reference and the third by value.

$f(x, y, m) = z$, where $x, y, z < m$ and $x + y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModAdd;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::ZERO).mod_add(&Natural::from(3u32), Natural::from(5u32)), 3);
assert_eq!((&Natural::from(7u32)).mod_add(&Natural::from(5u32), Natural::from(10u32)), 2);

This is equivalent to _fmpz_mod_addN from fmpz_mod/add.c, FLINT 2.7.1, where b and c are taken by reference and m is taken by value.

type Output = Natural

impl<'a> ModAdd<Natural, &'a Natural> for Natural

fn mod_add(self, other: Natural, m: &'a Natural) -> Natural

Adds two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first two Naturals are taken by value and the third by reference.

$f(x, y, m) = z$, where $x, y, z < m$ and $x + y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModAdd;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.mod_add(Natural::from(3u32), &Natural::from(5u32)), 3);
assert_eq!(Natural::from(7u32).mod_add(Natural::from(5u32), &Natural::from(10u32)), 2);

This is equivalent to _fmpz_mod_addN from fmpz_mod/add.c, FLINT 2.7.1, where b and c are taken by value and m is taken by reference.

type Output = Natural

impl<'a, 'b> ModAdd<Natural, &'b Natural> for &'a Natural

fn mod_add(self, other: Natural, m: &'b Natural) -> Natural

Adds two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first and third Naturals are taken by reference and the second by value.

$f(x, y, m) = z$, where $x, y, z < m$ and $x + y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModAdd;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::ZERO).mod_add(Natural::from(3u32), &Natural::from(5u32)), 3);
assert_eq!((&Natural::from(7u32)).mod_add(Natural::from(5u32), &Natural::from(10u32)), 2);

This is equivalent to _fmpz_mod_addN from fmpz_mod/add.c, FLINT 2.7.1, where b and m are taken by reference and c is taken by value.

type Output = Natural

impl ModAdd<Natural, Natural> for Natural

fn mod_add(self, other: Natural, m: Natural) -> Natural

Adds two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. All three Naturals are taken by value.

$f(x, y, m) = z$, where $x, y, z < m$ and $x + y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModAdd;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.mod_add(Natural::from(3u32), Natural::from(5u32)), 3);
assert_eq!(Natural::from(7u32).mod_add(Natural::from(5u32), Natural::from(10u32)), 2);

This is equivalent to _fmpz_mod_addN from fmpz_mod/add.c, FLINT 2.7.1, where b, c, and m are taken by value.

type Output = Natural

impl<'a> ModAdd<Natural, Natural> for &'a Natural

fn mod_add(self, other: Natural, m: Natural) -> Natural

Adds two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first Natural is taken by reference and the second and third by value.

$f(x, y, m) = z$, where $x, y, z < m$ and $x + y \equiv z \mod m$.

assert_eq!((&Natural::ZERO).mod_add(Natural::from(3u32), Natural::from(5u32)), 3); assert_eq!((&Natural::from(7u32)).mod_add(Natural::from(5u32), Natural::from(10u32)), 2);

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModAdd;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(
    (&Natural::ZERO).mod_add(Natural::from(3u32), Natural::from(5u32)).to_string(),
    "3"
);
assert_eq!(
    (&Natural::from(7u32)).mod_add(Natural::from(5u32), Natural::from(10u32)).to_string(),
    "2"
);

This is equivalent to _fmpz_mod_addN from fmpz_mod/add.c, FLINT 2.7.1, where b is taken by reference and c and m are taken by value.

type Output = Natural

impl<'a, 'b> ModAddAssign<&'a Natural, &'b Natural> for Natural

fn mod_add_assign(&mut self, other: &'a Natural, m: &'b Natural)

Adds two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. Both Naturals on the right-hand side are taken by reference.

$x \gets z$, where $x, y, z < m$ and $x + y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModAddAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut x = Natural::ZERO;
x.mod_add_assign(&Natural::from(3u32), &Natural::from(5u32));
assert_eq!(x, 3);

let mut x = Natural::from(7u32);
x.mod_add_assign(&Natural::from(5u32), &Natural::from(10u32));
assert_eq!(x, 2);

This is equivalent to _fmpz_mod_addN from fmpz_mod/add.c, FLINT 2.7.1, where b is taken by value, c and m are taken by reference, and a == b.

impl<'a> ModAddAssign<&'a Natural, Natural> for Natural

fn mod_add_assign(&mut self, other: &'a Natural, m: Natural)

Adds two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. The first Natural on the right-hand side is taken by reference and the second by value.

$x \gets z$, where $x, y, z < m$ and $x + y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModAddAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut x = Natural::ZERO;
x.mod_add_assign(&Natural::from(3u32), Natural::from(5u32));
assert_eq!(x, 3);

let mut x = Natural::from(7u32);
x.mod_add_assign(&Natural::from(5u32), Natural::from(10u32));
assert_eq!(x, 2);

This is equivalent to _fmpz_mod_addN from fmpz_mod/add.c, FLINT 2.7.1, where b and m are taken by value, c is taken by reference, and a == b.

impl<'a> ModAddAssign<Natural, &'a Natural> for Natural

fn mod_add_assign(&mut self, other: Natural, m: &'a Natural)

Adds two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. The first Natural on the right-hand side is taken by value and the second by reference.

$x \gets z$, where $x, y, z < m$ and $x + y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModAddAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut x = Natural::ZERO;
x.mod_add_assign(Natural::from(3u32), &Natural::from(5u32));
assert_eq!(x, 3);

let mut x = Natural::from(7u32);
x.mod_add_assign(Natural::from(5u32), &Natural::from(10u32));
assert_eq!(x, 2);

This is equivalent to _fmpz_mod_addN from fmpz_mod/add.c, FLINT 2.7.1, where b and c are taken by value, m is taken by reference, and a == b.

impl ModAddAssign<Natural, Natural> for Natural

fn mod_add_assign(&mut self, other: Natural, m: Natural)

Adds two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. Both Naturals on the right-hand side are taken by value.

$x \gets z$, where $x, y, z < m$ and $x + y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModAddAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut x = Natural::ZERO;
x.mod_add_assign(Natural::from(3u32), Natural::from(5u32));
assert_eq!(x, 3);

let mut x = Natural::from(7u32);
x.mod_add_assign(Natural::from(5u32), Natural::from(10u32));
assert_eq!(x, 2);

This is equivalent to _fmpz_mod_addN from fmpz_mod/add.c, FLINT 2.7.1, where b, c, and m are taken by value and a == b.

impl<'a> ModAssign<&'a Natural> for Natural

fn mod_assign(&mut self, other: &'a Natural)

Divides a Natural by another Natural, taking the second Natural by reference and replacing the first by the remainder.

If the quotient were computed, he quotient and remainder would satisfy $x = qy + r$ and $0 \leq r < y$.

$$ x \gets x - y\left \lfloor \frac{x}{y} \right \rfloor. $$

Worst-case complexity

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

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

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

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModAssign;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
let mut x = Natural::from(23u32);
x.mod_assign(&Natural::from(10u32));
assert_eq!(x, 3);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
let mut x = Natural::from_str("1000000000000000000000000").unwrap();
x.mod_assign(&Natural::from_str("1234567890987").unwrap());
assert_eq!(x, 530068894399u64);

impl ModAssign<Natural> for Natural

fn mod_assign(&mut self, other: Natural)

Divides a Natural by another Natural, taking the second Natural by value and replacing the first by the remainder.

If the quotient were computed, he quotient and remainder would satisfy $x = qy + r$ and $0 \leq r < y$.

$$ x \gets x - y\left \lfloor \frac{x}{y} \right \rfloor. $$

Worst-case complexity

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

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

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

Panics

Panics if other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModAssign;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
let mut x = Natural::from(23u32);
x.mod_assign(Natural::from(10u32));
assert_eq!(x, 3);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
let mut x = Natural::from_str("1000000000000000000000000").unwrap();
x.mod_assign(Natural::from_str("1234567890987").unwrap());
assert_eq!(x, 530068894399u64);

impl ModIsReduced<Natural> for Natural

fn mod_is_reduced(&self, m: &Natural) -> bool

Returns whether a Natural is reduced modulo another Natural $m$; in other words, whether it is less than $m$.

$m$ cannot be zero.

$f(x, m) = (x < m)$.

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 m is 0.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{ModIsReduced, Pow};
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.mod_is_reduced(&Natural::from(5u32)), true);
assert_eq!(
    Natural::from(10u32).pow(12).mod_is_reduced(&Natural::from(10u32).pow(12)),
    false
);
assert_eq!(
    Natural::from(10u32).pow(12)
        .mod_is_reduced(&(Natural::from(10u32).pow(12) + Natural::ONE)),
    true
);

impl<'a, 'b> ModMul<&'a Natural, &'b Natural> for Natural

fn mod_mul(self, other: &'a Natural, m: &'b Natural) -> Natural

Multiplies two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first Natural is taken by value and the second and third by reference.

$f(x, y, m) = z$, where $x, y, z < m$ and $xy \equiv z \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMul;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).mod_mul(&Natural::from(4u32), &Natural::from(15u32)), 12);
assert_eq!(Natural::from(7u32).mod_mul(&Natural::from(6u32), &Natural::from(10u32)), 2);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b is taken by value and c and m are taken by reference.

type Output = Natural

impl<'a> ModMul<&'a Natural, Natural> for Natural

fn mod_mul(self, other: &'a Natural, m: Natural) -> Natural

Multiplies two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first and third Naturals are taken by value and the second by reference.

$f(x, y, m) = z$, where $x, y, z < m$ and $xy \equiv z \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMul;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).mod_mul(&Natural::from(4u32), Natural::from(15u32)), 12);
assert_eq!(Natural::from(7u32).mod_mul(&Natural::from(6u32), Natural::from(10u32)), 2);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b and m are taken by value and c is taken by reference.

type Output = Natural

impl<'a, 'b, 'c> ModMul<&'b Natural, &'c Natural> for &'a Natural

fn mod_mul(self, other: &'b Natural, m: &'c Natural) -> Natural

Multiplies two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. All three Naturals are taken by reference.

$f(x, y, m) = z$, where $x, y, z < m$ and $xy \equiv z \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMul;
use malachite_nz::natural::Natural;

assert_eq!(
    (&Natural::from(3u32)).mod_mul(&Natural::from(4u32), &Natural::from(15u32)),
    12
);
assert_eq!((&Natural::from(7u32)).mod_mul(&Natural::from(6u32), &Natural::from(10u32)), 2);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b, c, and m are taken by reference.

type Output = Natural

impl<'a, 'b> ModMul<&'b Natural, Natural> for &'a Natural

fn mod_mul(self, other: &'b Natural, m: Natural) -> Natural

Multiplies two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first two Naturals are taken by reference and the third by value.

$f(x, y, m) = z$, where $x, y, z < m$ and $xy \equiv z \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMul;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(3u32)).mod_mul(&Natural::from(4u32), Natural::from(15u32)), 12);
assert_eq!((&Natural::from(7u32)).mod_mul(&Natural::from(6u32), Natural::from(10u32)), 2);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b and c are taken by reference and m is taken by value.

type Output = Natural

impl<'a> ModMul<Natural, &'a Natural> for Natural

fn mod_mul(self, other: Natural, m: &'a Natural) -> Natural

Multiplies two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first two Naturals are taken by value and the third by reference.

$f(x, y, m) = z$, where $x, y, z < m$ and $xy \equiv z \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMul;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).mod_mul(Natural::from(4u32), &Natural::from(15u32)), 12);
assert_eq!(Natural::from(7u32).mod_mul(Natural::from(6u32), &Natural::from(10u32)), 2);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b and c are taken by value and m is taken by reference.

type Output = Natural

impl<'a, 'b> ModMul<Natural, &'b Natural> for &'a Natural

fn mod_mul(self, other: Natural, m: &'b Natural) -> Natural

Multiplies two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first and third Naturals are taken by reference and the second by value.

$f(x, y, m) = z$, where $x, y, z < m$ and $xy \equiv z \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMul;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(3u32)).mod_mul(Natural::from(4u32), &Natural::from(15u32)), 12);
assert_eq!((&Natural::from(7u32)).mod_mul(Natural::from(6u32), &Natural::from(10u32)), 2);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b and m are taken by reference and c is taken by value.

type Output = Natural

impl ModMul<Natural, Natural> for Natural

fn mod_mul(self, other: Natural, m: Natural) -> Natural

Multiplies two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. All three Naturals are taken by value.

$f(x, y, m) = z$, where $x, y, z < m$ and $xy \equiv z \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMul;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).mod_mul(Natural::from(4u32), Natural::from(15u32)), 12);
assert_eq!(Natural::from(7u32).mod_mul(Natural::from(6u32), Natural::from(10u32)), 2);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b, c, and m are taken by value.

type Output = Natural

impl<'a> ModMul<Natural, Natural> for &'a Natural

fn mod_mul(self, other: Natural, m: Natural) -> Natural

Multiplies two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first Natural is taken by reference and the second and third by value.

$f(x, y, m) = z$, where $x, y, z < m$ and $xy \equiv z \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMul;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(3u32)).mod_mul(Natural::from(4u32), Natural::from(15u32)), 12);
assert_eq!((&Natural::from(7u32)).mod_mul(Natural::from(6u32), Natural::from(10u32)), 2);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b is taken by reference and c and m are taken by value.

type Output = Natural

impl<'a, 'b> ModMulAssign<&'a Natural, &'b Natural> for Natural

fn mod_mul_assign(&mut self, other: &'a Natural, m: &'b Natural)

Multiplies two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. Both Naturals on the right-hand side are taken by reference.

$x \gets z$, where $x, y, z < m$ and $xy \equiv z \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMulAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(3u32);
x.mod_mul_assign(&Natural::from(4u32), &Natural::from(15u32));
assert_eq!(x, 12);

let mut x = Natural::from(7u32);
x.mod_mul_assign(&Natural::from(6u32), &Natural::from(10u32));
assert_eq!(x, 2);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b is taken by value, c and m are taken by reference, and a == b.

impl<'a> ModMulAssign<&'a Natural, Natural> for Natural

fn mod_mul_assign(&mut self, other: &'a Natural, m: Natural)

Multiplies two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. The first Natural on the right-hand side is taken by reference and the second by value.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMulAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(3u32);
x.mod_mul_assign(&Natural::from(4u32), Natural::from(15u32));
assert_eq!(x, 12);

let mut x = Natural::from(7u32);
x.mod_mul_assign(&Natural::from(6u32), Natural::from(10u32));
assert_eq!(x, 2);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b and m are taken by value, c is taken by reference, and a == b.

impl<'a> ModMulAssign<Natural, &'a Natural> for Natural

fn mod_mul_assign(&mut self, other: Natural, m: &'a Natural)

Multiplies two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. The first Natural on the right-hand side is taken by value and the second by reference.

$x \gets z$, where $x, y, z < m$ and $xy \equiv z \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMulAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(3u32);
x.mod_mul_assign(Natural::from(4u32), &Natural::from(15u32));
assert_eq!(x, 12);

let mut x = Natural::from(7u32);
x.mod_mul_assign(Natural::from(6u32), &Natural::from(10u32));
assert_eq!(x, 2);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b and c are taken by value, m is taken by reference, and a == b.

impl ModMulAssign<Natural, Natural> for Natural

fn mod_mul_assign(&mut self, other: Natural, m: Natural)

Multiplies two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. Both Naturals on the right-hand side are taken by value.

$x \gets z$, where $x, y, z < m$ and $xy \equiv z \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMulAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(3u32);
x.mod_mul_assign(Natural::from(4u32), Natural::from(15u32));
assert_eq!(x, 12);

let mut x = Natural::from(7u32);
x.mod_mul_assign(Natural::from(6u32), Natural::from(10u32));
assert_eq!(x, 2);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b, c, and m are taken by value and a == b.

impl<'a, 'b> ModMulPrecomputed<&'a Natural, &'b Natural> for Natural

fn precompute_mod_mul_data(m: &&Natural) -> ModMulData

Precomputes data for modular multiplication. See mod_mul_precomputed and mod_mul_precomputed_assign.

Worst-case complexity

Constant time and additional memory.

This is equivalent to part of fmpz_mod_ctx_init from fmpz_mod/ctx_init.c, FLINT 2.7.1.

fn mod_mul_precomputed(
    self,
    other: &'a Natural,
    m: &'b Natural,
    data: &ModMulData
) -> Natural

Multiplies two Natural modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first Natural is taken by value and the second and third by reference.

Some precomputed data is provided; this speeds up computations involving several modular multiplications with the same modulus. The precomputed data should be obtained using precompute_mod_mul_data.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMulPrecomputed;
use malachite_nz::natural::Natural;

let data = ModMulPrecomputed::<Natural>::precompute_mod_mul_data(&Natural::from(10u32));
assert_eq!(
    Natural::from(6u8).mod_mul_precomputed(
        &Natural::from(7u32),
        &Natural::from(10u32),
        &data
    ),
    2
);
assert_eq!(
    Natural::from(9u8).mod_mul_precomputed(
        &Natural::from(9u32),
        &Natural::from(10u32),
        &data
    ),
    1
);
assert_eq!(
    Natural::from(4u8).mod_mul_precomputed(
        &Natural::from(7u32),
        &Natural::from(10u32),
        &data
    ),
    8
);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b is taken by value and c and m are taken by reference.

type Output = Natural

type Data = ModMulData

impl<'a> ModMulPrecomputed<&'a Natural, Natural> for Natural

fn precompute_mod_mul_data(m: &Natural) -> ModMulData

Precomputes data for modular multiplication. See mod_mul_precomputed and mod_mul_precomputed_assign.

Worst-case complexity

Constant time and additional memory.

This is equivalent to part of fmpz_mod_ctx_init from fmpz_mod/ctx_init.c, FLINT 2.7.1.

fn mod_mul_precomputed(
    self,
    other: &'a Natural,
    m: Natural,
    data: &ModMulData
) -> Natural

Multiplies two Natural modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first and third Naturals are taken by value and the second by reference.

Some precomputed data is provided; this speeds up computations involving several modular multiplications with the same modulus. The precomputed data should be obtained using precompute_mod_mul_data.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMulPrecomputed;
use malachite_nz::natural::Natural;

let data = ModMulPrecomputed::<Natural>::precompute_mod_mul_data(&Natural::from(10u32));
assert_eq!(
    Natural::from(6u8).mod_mul_precomputed(
        &Natural::from(7u32),
        Natural::from(10u32),
        &data
    ),
    2
);
assert_eq!(
    Natural::from(9u8).mod_mul_precomputed(
        &Natural::from(9u32),
        Natural::from(10u32),
        &data
    ),
    1
);
assert_eq!(
    Natural::from(4u8).mod_mul_precomputed(
        &Natural::from(7u32),
        Natural::from(10u32),
        &data
    ),
    8
);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b and m are taken by value and c is taken by reference.

type Output = Natural

type Data = ModMulData

impl<'a, 'b, 'c> ModMulPrecomputed<&'b Natural, &'c Natural> for &'a Natural

fn precompute_mod_mul_data(m: &&Natural) -> ModMulData

Precomputes data for modular multiplication. See mod_mul_precomputed and mod_mul_precomputed_assign.

Worst-case complexity

Constant time and additional memory.

This is equivalent to part of fmpz_mod_ctx_init from fmpz_mod/ctx_init.c, FLINT 2.7.1.

fn mod_mul_precomputed(
    self,
    other: &'b Natural,
    m: &'c Natural,
    data: &ModMulData
) -> Natural

Multiplies two Natural modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. All three Naturals are taken by reference.

Some precomputed data is provided; this speeds up computations involving several modular multiplications with the same modulus. The precomputed data should be obtained using precompute_mod_mul_data.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMulPrecomputed;
use malachite_nz::natural::Natural;

let data = ModMulPrecomputed::<Natural>::precompute_mod_mul_data(&Natural::from(10u32));
assert_eq!(
    (&Natural::from(6u8)).mod_mul_precomputed(
        &Natural::from(7u32),
        &Natural::from(10u32),
        &data
    ),
    2
);
assert_eq!(
    (&Natural::from(9u8)).mod_mul_precomputed(
        &Natural::from(9u32),
        &Natural::from(10u32),
        &data
    ),
    1
);
assert_eq!(
    (&Natural::from(4u8)).mod_mul_precomputed(
        &Natural::from(7u32),
        &Natural::from(10u32),
        &data
    ),
    8
);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b, c, and m are taken by reference.

type Output = Natural

type Data = ModMulData

impl<'a, 'b> ModMulPrecomputed<&'b Natural, Natural> for &'a Natural

fn precompute_mod_mul_data(m: &Natural) -> ModMulData

Precomputes data for modular multiplication. See mod_mul_precomputed and mod_mul_precomputed_assign.

Worst-case complexity

Constant time and additional memory.

This is equivalent to part of fmpz_mod_ctx_init from fmpz_mod/ctx_init.c, FLINT 2.7.1.

fn mod_mul_precomputed(
    self,
    other: &'b Natural,
    m: Natural,
    data: &ModMulData
) -> Natural

Multiplies two Natural modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first two Naturals are taken by reference and the third by value.

Some precomputed data is provided; this speeds up computations involving several modular multiplications with the same modulus. The precomputed data should be obtained using precompute_mod_mul_data.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMulPrecomputed;
use malachite_nz::natural::Natural;

let data = ModMulPrecomputed::<Natural>::precompute_mod_mul_data(&Natural::from(10u32));
assert_eq!(
    (&Natural::from(6u8)).mod_mul_precomputed(
        &Natural::from(7u32),
        Natural::from(10u32),
        &data
    ),
    2
);
assert_eq!(
    (&Natural::from(9u8)).mod_mul_precomputed(
        &Natural::from(9u32),
        Natural::from(10u32),
        &data
    ),
    1
);
assert_eq!(
    (&Natural::from(4u8)).mod_mul_precomputed(
        &Natural::from(7u32),
        Natural::from(10u32),
        &data
    ),
    8
);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b and c are taken by reference and m is taken by value.

type Output = Natural

type Data = ModMulData

impl<'a> ModMulPrecomputed<Natural, &'a Natural> for Natural

fn precompute_mod_mul_data(m: &&Natural) -> ModMulData

Precomputes data for modular multiplication. See mod_mul_precomputed and mod_mul_precomputed_assign.

Worst-case complexity

Constant time and additional memory.

This is equivalent to part of fmpz_mod_ctx_init from fmpz_mod/ctx_init.c, FLINT 2.7.1.

fn mod_mul_precomputed(
    self,
    other: Natural,
    m: &'a Natural,
    data: &ModMulData
) -> Natural

Multiplies two Natural modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first two Naturals are taken by value and the third by reference.

Some precomputed data is provided; this speeds up computations involving several modular multiplications with the same modulus. The precomputed data should be obtained using precompute_mod_mul_data.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMulPrecomputed;
use malachite_nz::natural::Natural;

let data = ModMulPrecomputed::<Natural>::precompute_mod_mul_data(&Natural::from(10u32));
assert_eq!(
    Natural::from(6u8).mod_mul_precomputed(
        Natural::from(7u32),
        &Natural::from(10u32),
        &data
    ),
    2
);
assert_eq!(
    Natural::from(9u8).mod_mul_precomputed(
        Natural::from(9u32),
        &Natural::from(10u32),
        &data
    ),
    1
);
assert_eq!(
    Natural::from(4u8).mod_mul_precomputed(
        Natural::from(7u32),
        &Natural::from(10u32),
        &data
    ),
    8
);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b and c are taken by value and m is taken by reference.

type Output = Natural

type Data = ModMulData

impl<'a, 'b> ModMulPrecomputed<Natural, &'b Natural> for &'a Natural

fn precompute_mod_mul_data(m: &&Natural) -> ModMulData

Precomputes data for modular multiplication. See mod_mul_precomputed and mod_mul_precomputed_assign.

Worst-case complexity

Constant time and additional memory.

This is equivalent to part of fmpz_mod_ctx_init from fmpz_mod/ctx_init.c, FLINT 2.7.1.

fn mod_mul_precomputed(
    self,
    other: Natural,
    m: &'b Natural,
    data: &ModMulData
) -> Natural

Multiplies two Natural modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first and third Naturals are taken by reference and the second by value.

Some precomputed data is provided; this speeds up computations involving several modular multiplications with the same modulus. The precomputed data should be obtained using precompute_mod_mul_data.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMulPrecomputed;
use malachite_nz::natural::Natural;

let data = ModMulPrecomputed::<Natural>::precompute_mod_mul_data(&Natural::from(10u32));
assert_eq!(
    (&Natural::from(6u8)).mod_mul_precomputed(
        Natural::from(7u32),
        &Natural::from(10u32),
        &data
    ),
    2
);
assert_eq!(
    (&Natural::from(9u8)).mod_mul_precomputed(
        Natural::from(9u32),
        &Natural::from(10u32),
        &data
    ),
    1
);
assert_eq!(
    (&Natural::from(4u8)).mod_mul_precomputed(
        Natural::from(7u32),
        &Natural::from(10u32),
        &data
    ),
    8
);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b and m are taken by reference and c is taken by value.

type Output = Natural

type Data = ModMulData

impl ModMulPrecomputed<Natural, Natural> for Natural

fn precompute_mod_mul_data(m: &Natural) -> ModMulData

Precomputes data for modular multiplication. See mod_mul_precomputed and mod_mul_precomputed_assign.

Worst-case complexity

Constant time and additional memory.

This is equivalent to part of fmpz_mod_ctx_init from fmpz_mod/ctx_init.c, FLINT 2.7.1.

fn mod_mul_precomputed(
    self,
    other: Natural,
    m: Natural,
    data: &ModMulData
) -> Natural

Multiplies two Natural modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. All three Naturals are taken by value.

Some precomputed data is provided; this speeds up computations involving several modular multiplications with the same modulus. The precomputed data should be obtained using precompute_mod_mul_data.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMulPrecomputed;
use malachite_nz::natural::Natural;

let data = ModMulPrecomputed::<Natural>::precompute_mod_mul_data(&Natural::from(10u32));
assert_eq!(
    Natural::from(6u8).mod_mul_precomputed(
        Natural::from(7u32),
        Natural::from(10u32),
        &data
    ),
    2
);
assert_eq!(
    Natural::from(9u8).mod_mul_precomputed(
        Natural::from(9u32),
        Natural::from(10u32),
        &data
    ),
    1
);
assert_eq!(
    Natural::from(4u8).mod_mul_precomputed(
        Natural::from(7u32),
        Natural::from(10u32),
        &data
    ),
    8
);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b, c, and m are taken by value.

type Output = Natural

type Data = ModMulData

impl<'a> ModMulPrecomputed<Natural, Natural> for &'a Natural

fn precompute_mod_mul_data(m: &Natural) -> ModMulData

Precomputes data for modular multiplication. See mod_mul_precomputed and mod_mul_precomputed_assign.

Worst-case complexity

Constant time and additional memory.

This is equivalent to part of fmpz_mod_ctx_init from fmpz_mod/ctx_init.c, FLINT 2.7.1.

fn mod_mul_precomputed(
    self,
    other: Natural,
    m: Natural,
    data: &ModMulData
) -> Natural

Multiplies two Natural modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first Natural is taken by reference and the second and third by value.

Some precomputed data is provided; this speeds up computations involving several modular multiplications with the same modulus. The precomputed data should be obtained using precompute_mod_mul_data.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModMulPrecomputed;
use malachite_nz::natural::Natural;

let data = ModMulPrecomputed::<Natural>::precompute_mod_mul_data(&Natural::from(10u32));
assert_eq!(
    (&Natural::from(6u8)).mod_mul_precomputed(
        Natural::from(7u32),
        Natural::from(10u32),
        &data
    ),
    2
);
assert_eq!(
    (&Natural::from(9u8)).mod_mul_precomputed(
        Natural::from(9u32),
        Natural::from(10u32),
        &data
    ),
    1
);
assert_eq!(
    (&Natural::from(4u8)).mod_mul_precomputed(
        Natural::from(7u32),
        Natural::from(10u32),
        &data
    ),
    8
);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b is taken by reference and c and m are taken by value.

type Output = Natural

type Data = ModMulData

impl<'a, 'b> ModMulPrecomputedAssign<&'a Natural, &'b Natural> for Natural

fn mod_mul_precomputed_assign(
    &mut self,
    other: &'a Natural,
    m: &'b Natural,
    data: &ModMulData
)

Multiplies two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. Both Naturals on the right-hand side are taken by reference.

Some precomputed data is provided; this speeds up computations involving several modular multiplications with the same modulus. The precomputed data should be obtained using precompute_mod_mul_data.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{ModMulPrecomputed, ModMulPrecomputedAssign};
use malachite_nz::natural::Natural;

let data = ModMulPrecomputed::<Natural>::precompute_mod_mul_data(&Natural::from(10u32));

let mut x = Natural::from(6u8);
x.mod_mul_precomputed_assign(&Natural::from(7u32), &Natural::from(10u32), &data);
assert_eq!(x, 2);

let mut x = Natural::from(9u8);
x.mod_mul_precomputed_assign(&Natural::from(9u32), &Natural::from(10u32), &data);
assert_eq!(x, 1);

let mut x = Natural::from(4u8);
x.mod_mul_precomputed_assign(&Natural::from(7u32), &Natural::from(10u32), &data);
assert_eq!(x, 8);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b is taken by value, c and m are taken by reference, and a == b.

impl<'a> ModMulPrecomputedAssign<&'a Natural, Natural> for Natural

fn mod_mul_precomputed_assign(
    &mut self,
    other: &'a Natural,
    m: Natural,
    data: &ModMulData
)

Multiplies two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. The first Natural on the right-hand side is taken by reference and the second by value.

Some precomputed data is provided; this speeds up computations involving several modular multiplications with the same modulus. The precomputed data should be obtained using precompute_mod_mul_data.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{ModMulPrecomputed, ModMulPrecomputedAssign};
use malachite_nz::natural::Natural;

let data = ModMulPrecomputed::<Natural>::precompute_mod_mul_data(&Natural::from(10u32));

let mut x = Natural::from(6u8);
x.mod_mul_precomputed_assign(&Natural::from(7u32), Natural::from(10u32), &data);
assert_eq!(x, 2);

let mut x = Natural::from(9u8);
x.mod_mul_precomputed_assign(&Natural::from(9u32), Natural::from(10u32), &data);
assert_eq!(x, 1);

let mut x = Natural::from(4u8);
x.mod_mul_precomputed_assign(&Natural::from(7u32), Natural::from(10u32), &data);
assert_eq!(x, 8);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b and m are taken by value, c is taken by reference, and a == b.

impl<'a> ModMulPrecomputedAssign<Natural, &'a Natural> for Natural

fn mod_mul_precomputed_assign(
    &mut self,
    other: Natural,
    m: &'a Natural,
    data: &ModMulData
)

Multiplies two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. The first Natural on the right-hand side is taken by value and the second by reference.

Some precomputed data is provided; this speeds up computations involving several modular multiplications with the same modulus. The precomputed data should be obtained using precompute_mod_mul_data.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{ModMulPrecomputed, ModMulPrecomputedAssign};
use malachite_nz::natural::Natural;

let data = ModMulPrecomputed::<Natural>::precompute_mod_mul_data(&Natural::from(10u32));

let mut x = Natural::from(6u8);
x.mod_mul_precomputed_assign(Natural::from(7u32), &Natural::from(10u32), &data);
assert_eq!(x, 2);

let mut x = Natural::from(9u8);
x.mod_mul_precomputed_assign(Natural::from(9u32), &Natural::from(10u32), &data);
assert_eq!(x, 1);

let mut x = Natural::from(4u8);
x.mod_mul_precomputed_assign(Natural::from(7u32), &Natural::from(10u32), &data);
assert_eq!(x, 8);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b and c are taken by value, m is taken by reference, and a == b.

impl ModMulPrecomputedAssign<Natural, Natural> for Natural

fn mod_mul_precomputed_assign(
    &mut self,
    other: Natural,
    m: Natural,
    data: &ModMulData
)

Multiplies two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. Both Naturals on the right-hand side are taken by value.

Some precomputed data is provided; this speeds up computations involving several modular multiplications with the same modulus. The precomputed data should be obtained using precompute_mod_mul_data.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{ModMulPrecomputed, ModMulPrecomputedAssign};
use malachite_nz::natural::Natural;

let data = ModMulPrecomputed::<Natural>::precompute_mod_mul_data(&Natural::from(10u32));

let mut x = Natural::from(6u8);
x.mod_mul_precomputed_assign(Natural::from(7u32), Natural::from(10u32), &data);
assert_eq!(x, 2);

let mut x = Natural::from(9u8);
x.mod_mul_precomputed_assign(Natural::from(9u32), Natural::from(10u32), &data);
assert_eq!(x, 1);

let mut x = Natural::from(4u8);
x.mod_mul_precomputed_assign(Natural::from(7u32), Natural::from(10u32), &data);
assert_eq!(x, 8);

This is equivalent to _fmpz_mod_mulN from fmpz_mod/mul.c, FLINT 2.7.1, where b, c, and m are taken by value and a == b.

impl<'a> ModNeg<&'a Natural> for Natural

fn mod_neg(self, m: &'a Natural) -> Natural

Negates a Natural modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{ModNeg, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.mod_neg(&Natural::from(5u32)), 0);
assert_eq!(Natural::from(7u32).mod_neg(&Natural::from(10u32)), 3);
assert_eq!(Natural::from(7u32).mod_neg(&Natural::from(10u32).pow(12)), 999999999993u64);

type Output = Natural

impl<'a, 'b> ModNeg<&'b Natural> for &'a Natural

fn mod_neg(self, m: &'b Natural) -> Natural

Negates a Natural modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{ModNeg, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::ZERO).mod_neg(&Natural::from(5u32)), 0);
assert_eq!((&Natural::from(7u32)).mod_neg(&Natural::from(10u32)), 3);
assert_eq!(
    (&Natural::from(7u32)).mod_neg(&Natural::from(10u32).pow(12)),
    999999999993u64
);

type Output = Natural

impl ModNeg<Natural> for Natural

fn mod_neg(self, m: Natural) -> Natural

Negates a Natural modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, m) = y$, where $x, y < m$ and $-x \equiv y \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{ModNeg, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.mod_neg(Natural::from(5u32)), 0);
assert_eq!(Natural::from(7u32).mod_neg(Natural::from(10u32)), 3);
assert_eq!(Natural::from(7u32).mod_neg(Natural::from(10u32).pow(12)), 999999999993u64);

type Output = Natural

impl<'a> ModNeg<Natural> for &'a Natural

fn mod_neg(self, m: Natural) -> Natural

Negates a Natural modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{ModNeg, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::ZERO).mod_neg(Natural::from(5u32)), 0);
assert_eq!((&Natural::from(7u32)).mod_neg(Natural::from(10u32)), 3);
assert_eq!((&Natural::from(7u32)).mod_neg(Natural::from(10u32).pow(12)), 999999999993u64);

type Output = Natural

impl<'a> ModNegAssign<&'a Natural> for Natural

fn mod_neg_assign(&mut self, m: &'a Natural)

Negates a Natural modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $-x \equiv y \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{ModNegAssign, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut n = Natural::ZERO;
n.mod_neg_assign(&Natural::from(5u32));
assert_eq!(n, 0);

let mut n = Natural::from(7u32);
n.mod_neg_assign(&Natural::from(10u32));
assert_eq!(n, 3);

let mut n = Natural::from(7u32);
n.mod_neg_assign(&Natural::from(10u32).pow(12));
assert_eq!(n, 999999999993u64);

impl ModNegAssign<Natural> for Natural

fn mod_neg_assign(&mut self, m: Natural)

Negates a Natural modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $-x \equiv y \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{ModNegAssign, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut n = Natural::ZERO;
n.mod_neg_assign(Natural::from(5u32));
assert_eq!(n, 0);

let mut n = Natural::from(7u32);
n.mod_neg_assign(Natural::from(10u32));
assert_eq!(n, 3);

let mut n = Natural::from(7u32);
n.mod_neg_assign(Natural::from(10u32).pow(12));
assert_eq!(n, 999999999993u64);

impl<'a, 'b> ModPow<&'a Natural, &'b Natural> for Natural

fn mod_pow(self, exp: &'a Natural, m: &'b Natural) -> Natural

Raises a Natural to a Natural power modulo a third Natural $m$. Assumes the input is already reduced mod $m$. The first Natural is taken by value and the second and third by reference.

$f(x, n, m) = y$, where $x, y < m$ and $x^n \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPow;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(4u32).mod_pow(&Natural::from(13u32), &Natural::from(497u32)), 445);
assert_eq!(
    Natural::from(10u32).mod_pow(&Natural::from(1000u32), &Natural::from(30u32)),
    10
);

type Output = Natural

impl<'a> ModPow<&'a Natural, Natural> for Natural

fn mod_pow(self, exp: &'a Natural, m: Natural) -> Natural

Raises a Natural to a Natural power modulo a third Natural $m$. Assumes the input is already reduced mod $m$. The first and third Naturals are taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $x^n \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPow;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(4u32).mod_pow(&Natural::from(13u32), Natural::from(497u32)), 445);
assert_eq!(Natural::from(10u32).mod_pow(&Natural::from(1000u32), Natural::from(30u32)), 10);

type Output = Natural

impl<'a, 'b, 'c> ModPow<&'b Natural, &'c Natural> for &'a Natural

fn mod_pow(self, exp: &'b Natural, m: &'c Natural) -> Natural

Raises a Natural to a Natural power modulo a third Natural $m$. Assumes the input is already reduced mod $m$. All three Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $x^n \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPow;
use malachite_nz::natural::Natural;

assert_eq!(
    (&Natural::from(4u32)).mod_pow(&Natural::from(13u32), &Natural::from(497u32)),
    445
);
assert_eq!(
    (&Natural::from(10u32)).mod_pow(&Natural::from(1000u32), &Natural::from(30u32)),
    10
);

type Output = Natural

impl<'a, 'b> ModPow<&'b Natural, Natural> for &'a Natural

fn mod_pow(self, exp: &'b Natural, m: Natural) -> Natural

Raises a Natural to a Natural power modulo a third Natural $m$. Assumes the input is already reduced mod $m$. The first two Naturals are taken by reference and the third by value.

$f(x, n, m) = y$, where $x, y < m$ and $x^n \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPow;
use malachite_nz::natural::Natural;

assert_eq!(
    (&Natural::from(4u32)).mod_pow(&Natural::from(13u32), Natural::from(497u32)),
    445
);
assert_eq!(
    (&Natural::from(10u32)).mod_pow(&Natural::from(1000u32), Natural::from(30u32)),
    10
);

type Output = Natural

impl<'a> ModPow<Natural, &'a Natural> for Natural

fn mod_pow(self, exp: Natural, m: &'a Natural) -> Natural

Raises a Natural to a Natural power modulo a third Natural $m$. Assumes the input is already reduced mod $m$. The first two Naturals are taken by value and the third by reference.

$f(x, n, m) = y$, where $x, y < m$ and $x^n \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPow;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(4u32).mod_pow(Natural::from(13u32), &Natural::from(497u32)), 445);
assert_eq!(Natural::from(10u32).mod_pow(Natural::from(1000u32), &Natural::from(30u32)), 10);

type Output = Natural

impl<'a, 'b> ModPow<Natural, &'b Natural> for &'a Natural

fn mod_pow(self, exp: Natural, m: &'b Natural) -> Natural

Raises a Natural to a Natural power modulo a third Natural $m$. Assumes the input is already reduced mod $m$. The first and third Naturals are taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $x^n \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPow;
use malachite_nz::natural::Natural;

assert_eq!(
    (&Natural::from(4u32)).mod_pow(Natural::from(13u32), &Natural::from(497u32)),
    445
);
assert_eq!(
    (&Natural::from(10u32)).mod_pow(Natural::from(1000u32), &Natural::from(30u32)),
    10
);

type Output = Natural

impl ModPow<Natural, Natural> for Natural

fn mod_pow(self, exp: Natural, m: Natural) -> Natural

Raises a Natural to a Natural power modulo a third Natural $m$. Assumes the input is already reduced mod $m$. All three Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $x^n \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPow;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(4u32).mod_pow(Natural::from(13u32), Natural::from(497u32)), 445);
assert_eq!(Natural::from(10u32).mod_pow(Natural::from(1000u32), Natural::from(30u32)), 10);

type Output = Natural

impl<'a> ModPow<Natural, Natural> for &'a Natural

fn mod_pow(self, exp: Natural, m: Natural) -> Natural

Raises a Natural to a Natural power modulo a third Natural$m$. Assumes the input is already reduced mod $m$. The first Natural is taken by reference and the second and third by value.

$f(x, n, m) = y$, where $x, y < m$ and $x^n \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPow;
use malachite_nz::natural::Natural;

assert_eq!(
    (&Natural::from(4u32)).mod_pow(Natural::from(13u32), Natural::from(497u32)),
    445
);
assert_eq!(
    (&Natural::from(10u32)).mod_pow(Natural::from(1000u32), Natural::from(30u32)),
    10
);

type Output = Natural

impl<'a, 'b> ModPowAssign<&'a Natural, &'b Natural> for Natural

fn mod_pow_assign(&mut self, exp: &'a Natural, m: &'b Natural)

Raises a Natural to a Natural power modulo a third Natural $m$, in place. Assumes the input is already reduced mod $m$. Both Naturals on the right-hand side are taken by reference.

$x \gets y$, where $x, y < m$ and $x^n \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(4u32);
x.mod_pow_assign(&Natural::from(13u32), &Natural::from(497u32));
assert_eq!(x, 445);

let mut x = Natural::from(10u32);
x.mod_pow_assign(&Natural::from(1000u32), &Natural::from(30u32));
assert_eq!(x, 10);

impl<'a> ModPowAssign<&'a Natural, Natural> for Natural

fn mod_pow_assign(&mut self, exp: &'a Natural, m: Natural)

Raises a Natural to a Natural power modulo a third Natural $m$, in place. Assumes the input is already reduced mod $m$. The first Natural on the right-hand side is taken by reference and the second by value.

$x \gets y$, where $x, y < m$ and $x^n \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(4u32);
x.mod_pow_assign(&Natural::from(13u32), Natural::from(497u32));
assert_eq!(x, 445);

let mut x = Natural::from(10u32);
x.mod_pow_assign(&Natural::from(1000u32), Natural::from(30u32));
assert_eq!(x, 10);

impl<'a> ModPowAssign<Natural, &'a Natural> for Natural

fn mod_pow_assign(&mut self, exp: Natural, m: &'a Natural)

Raises a Natural to a Natural power modulo a third Natural $m$, in place. Assumes the input is already reduced mod $m$. The first Natural on the right-hand side is taken by value and the second by reference.

$x \gets y$, where $x, y < m$ and $x^n \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(4u32);
x.mod_pow_assign(Natural::from(13u32), &Natural::from(497u32));
assert_eq!(x, 445);

let mut x = Natural::from(10u32);
x.mod_pow_assign(Natural::from(1000u32), &Natural::from(30u32));
assert_eq!(x, 10);

impl ModPowAssign<Natural, Natural> for Natural

fn mod_pow_assign(&mut self, exp: Natural, m: Natural)

Raises a Natural to a Natural power modulo a third Natural $m$, in place. Assumes the input is already reduced mod $m$. Both Naturals on the right-hand side are taken by value.

$x \gets y$, where $x, y < m$ and $x^n \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(4u32);
x.mod_pow_assign(Natural::from(13u32), Natural::from(497u32));
assert_eq!(x, 445);

let mut x = Natural::from(10u32);
x.mod_pow_assign(Natural::from(1000u32), Natural::from(30u32));
assert_eq!(x, 10);

impl ModPowerOf2 for Natural

fn mod_power_of_2(self, pow: u64) -> Natural

Divides a Natural by $2^k$, returning just the remainder. The Natural is taken by value.

If the quotient were computed, the quotient and remainder would satisfy $x = q2^k + r$ and $0 \leq r < 2^k$.

$$ f(x, k) = x - 2^k\left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2;
use malachite_nz::natural::Natural;

// 1 * 2^8 + 4 = 260
assert_eq!(Natural::from(260u32).mod_power_of_2(8), 4);

// 100 * 2^4 + 11 = 1611
assert_eq!(Natural::from(1611u32).mod_power_of_2(4), 11);

type Output = Natural

impl<'a> ModPowerOf2 for &'a Natural

fn mod_power_of_2(self, pow: u64) -> Natural

Divides a Natural by $2^k$, returning just the remainder. The Natural is taken by reference.

If the quotient were computed, the quotient and remainder would satisfy $x = q2^k + r$ and $0 \leq r < 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2;
use malachite_nz::natural::Natural;

// 1 * 2^8 + 4 = 260
assert_eq!((&Natural::from(260u32)).mod_power_of_2(8), 4);
// 100 * 2^4 + 11 = 1611
assert_eq!((&Natural::from(1611u32)).mod_power_of_2(4), 11);

type Output = Natural

impl<'a> ModPowerOf2Add<&'a Natural> for Natural

fn mod_power_of_2_add(self, other: &'a Natural, pow: u64) -> Natural

Adds two Naturals modulo $2^k$. Assumes the inputs are already reduced modulo $2^k$. The first Natural is taken by value and the second by reference.

$f(x, y, k) = z$, where $x, y, z < 2^k$ and $x + y \equiv z \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Add;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.mod_power_of_2_add(&Natural::from(2u32), 5), 2);
assert_eq!(Natural::from(10u32).mod_power_of_2_add(&Natural::from(14u32), 4), 8);

type Output = Natural

impl<'a, 'b> ModPowerOf2Add<&'a Natural> for &'b Natural

fn mod_power_of_2_add(self, other: &'a Natural, pow: u64) -> Natural

Adds two Naturals modulo $2^k$. Assumes the inputs are already reduced modulo $2^k$. Both Naturals are taken by reference.

$f(x, y, k) = z$, where $x, y, z < 2^k$ and $x + y \equiv z \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Add;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::ZERO).mod_power_of_2_add(&Natural::from(2u32), 5), 2);
assert_eq!((&Natural::from(10u32)).mod_power_of_2_add(&Natural::from(14u32), 4), 8);

type Output = Natural

impl ModPowerOf2Add<Natural> for Natural

fn mod_power_of_2_add(self, other: Natural, pow: u64) -> Natural

Adds two Naturals modulo $2^k$. Assumes the inputs are already reduced modulo $2^k$. Both Naturals are taken by value.

$f(x, y, k) = z$, where $x, y, z < 2^k$ and $x + y \equiv z \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Add;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.mod_power_of_2_add(Natural::from(2u32), 5), 2);
assert_eq!(Natural::from(10u32).mod_power_of_2_add(Natural::from(14u32), 4), 8);

type Output = Natural

impl<'a> ModPowerOf2Add<Natural> for &'a Natural

fn mod_power_of_2_add(self, other: Natural, pow: u64) -> Natural

Adds two Naturals modulo $2^k$. Assumes the inputs are already reduced modulo $2^k$. The first Natural is taken by reference and the second by value.

$f(x, y, k) = z$, where $x, y, z < 2^k$ and $x + y \equiv z \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Add;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::ZERO).mod_power_of_2_add(Natural::from(2u32), 5), 2);
assert_eq!((&Natural::from(10u32)).mod_power_of_2_add(Natural::from(14u32), 4), 8);

type Output = Natural

impl<'a> ModPowerOf2AddAssign<&'a Natural> for Natural

fn mod_power_of_2_add_assign(&mut self, other: &'a Natural, pow: u64)

Adds two Naturals modulo $2^k$, in place. Assumes the inputs are already reduced modulo $2^k$. The Natural on the right-hand side is taken by reference.

$x \gets z$, where $x, y, z < 2^k$ and $x + y \equiv z \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2AddAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut x = Natural::ZERO;
x.mod_power_of_2_add_assign(&Natural::from(2u32), 5);
assert_eq!(x, 2);

let mut x = Natural::from(10u32);
x.mod_power_of_2_add_assign(&Natural::from(14u32), 4);
assert_eq!(x, 8);

impl ModPowerOf2AddAssign<Natural> for Natural

fn mod_power_of_2_add_assign(&mut self, other: Natural, pow: u64)

Adds two Naturals modulo $2^k$, in place. Assumes the inputs are already reduced modulo $2^k$. The Natural on the right-hand side is taken by value.

$x \gets z$, where $x, y, z < 2^k$ and $x + y \equiv z \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2AddAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut x = Natural::ZERO;
x.mod_power_of_2_add_assign(Natural::from(2u32), 5);
assert_eq!(x, 2);

let mut x = Natural::from(10u32);
x.mod_power_of_2_add_assign(Natural::from(14u32), 4);
assert_eq!(x, 8);

impl ModPowerOf2Assign for Natural

fn mod_power_of_2_assign(&mut self, pow: u64)

Divides a Naturalby $2^k$, replacing the Natural by the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = q2^k + r$ and $0 \leq r < 2^k$.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Assign;
use malachite_nz::natural::Natural;

// 1 * 2^8 + 4 = 260
let mut x = Natural::from(260u32);
x.mod_power_of_2_assign(8);
assert_eq!(x, 4);

// 100 * 2^4 + 11 = 1611
let mut x = Natural::from(1611u32);
x.mod_power_of_2_assign(4);
assert_eq!(x, 11);

impl ModPowerOf2IsReduced for Natural

fn mod_power_of_2_is_reduced(&self, pow: u64) -> bool

Returns whether a Natural is reduced modulo 2^k$; in other words, whether it has no more than $k$ significant bits.

$f(x, k) = (x < 2^k)$.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{ModPowerOf2IsReduced, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.mod_power_of_2_is_reduced(5), true);
assert_eq!(Natural::from(10u32).pow(12).mod_power_of_2_is_reduced(39), false);
assert_eq!(Natural::from(10u32).pow(12).mod_power_of_2_is_reduced(40), true);

impl<'a> ModPowerOf2Mul<&'a Natural> for Natural

fn mod_power_of_2_mul(self, other: &'a Natural, pow: u64) -> Natural

Multiplies two Naturals modulo $2^k$. Assumes the inputs are already reduced modulo $2^k$. The first Natural is taken by value and the second by reference.

$f(x, y, k) = z$, where $x, y, z < 2^k$ and $xy \equiv z \mod 2^k$.

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Mul;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).mod_power_of_2_mul(&Natural::from(2u32), 5), 6);
assert_eq!(Natural::from(10u32).mod_power_of_2_mul(&Natural::from(14u32), 4), 12);

type Output = Natural

impl<'a, 'b> ModPowerOf2Mul<&'b Natural> for &'a Natural

fn mod_power_of_2_mul(self, other: &'b Natural, pow: u64) -> Natural

Multiplies two Naturals modulo $2^k$. Assumes the inputs are already reduced modulo $2^k$. Both Naturals are taken by reference.

$f(x, y, k) = z$, where $x, y, z < 2^k$ and $xy \equiv z \mod 2^k$.

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Mul;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(3u32)).mod_power_of_2_mul(&Natural::from(2u32), 5), 6);
assert_eq!((&Natural::from(10u32)).mod_power_of_2_mul(&Natural::from(14u32), 4), 12);

type Output = Natural

impl ModPowerOf2Mul<Natural> for Natural

fn mod_power_of_2_mul(self, other: Natural, pow: u64) -> Natural

Multiplies two Naturals modulo $2^k$. Assumes the inputs are already reduced modulo $2^k$. Both Naturals are taken by value.

$f(x, y, k) = z$, where $x, y, z < 2^k$ and $xy \equiv z \mod 2^k$.

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Mul;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).mod_power_of_2_mul(Natural::from(2u32), 5), 6);
assert_eq!(Natural::from(10u32).mod_power_of_2_mul(Natural::from(14u32), 4), 12);

type Output = Natural

impl<'a> ModPowerOf2Mul<Natural> for &'a Natural

fn mod_power_of_2_mul(self, other: Natural, pow: u64) -> Natural

Multiplies two Naturals modulo $2^k$. Assumes the inputs are already reduced modulo $2^k$. The first Natural is taken by reference and the second by value.

$f(x, y, k) = z$, where $x, y, z < 2^k$ and $xy \equiv z \mod 2^k$.

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Mul;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(3u32)).mod_power_of_2_mul(Natural::from(2u32), 5), 6);
assert_eq!((&Natural::from(10u32)).mod_power_of_2_mul(Natural::from(14u32), 4), 12);

type Output = Natural

impl<'a> ModPowerOf2MulAssign<&'a Natural> for Natural

fn mod_power_of_2_mul_assign(&mut self, other: &'a Natural, pow: u64)

Multiplies two Naturals modulo $2^k$, in place. Assumes the inputs are already reduced modulo $2^k$. The Natural on the right-hand side is taken by reference.

$x \gets z$, where $x, y, z < 2^k$ and $x + y \equiv z \mod 2^k$.

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2MulAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(3u32);
x.mod_power_of_2_mul_assign(&Natural::from(2u32), 5);
assert_eq!(x, 6);

let mut x = Natural::from(10u32);
x.mod_power_of_2_mul_assign(&Natural::from(14u32), 4);
assert_eq!(x, 12);

impl ModPowerOf2MulAssign<Natural> for Natural

fn mod_power_of_2_mul_assign(&mut self, other: Natural, pow: u64)

Multiplies two Naturals modulo $2^k$, in place. Assumes the inputs are already reduced modulo $2^k$. The Natural on the right-hand side is taken by value.

$x \gets z$, where $x, y, z < 2^k$ and $x + y \equiv z \mod 2^k$.

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2MulAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(3u32);
x.mod_power_of_2_mul_assign(Natural::from(2u32), 5);
assert_eq!(x, 6);

let mut x = Natural::from(10u32);
x.mod_power_of_2_mul_assign(Natural::from(14u32), 4);
assert_eq!(x, 12);

impl ModPowerOf2Neg for Natural

fn mod_power_of_2_neg(self, pow: u64) -> Natural

Negates a Natural modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, k) = y$, where $x, y < 2^k$ and $-x \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Neg;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.mod_power_of_2_neg(5), 0);
assert_eq!(Natural::ZERO.mod_power_of_2_neg(100), 0);
assert_eq!(Natural::from(100u32).mod_power_of_2_neg(8), 156);
assert_eq!(
    Natural::from(100u32).mod_power_of_2_neg(100).to_string(),
    "1267650600228229401496703205276"
);

type Output = Natural

impl<'a> ModPowerOf2Neg for &'a Natural

fn mod_power_of_2_neg(self, pow: u64) -> Natural

Negates a Natural modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, k) = y$, where $x, y < 2^k$ and $-x \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Neg;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::ZERO).mod_power_of_2_neg(5), 0);
assert_eq!((&Natural::ZERO).mod_power_of_2_neg(100), 0);
assert_eq!((&Natural::from(100u32)).mod_power_of_2_neg(8), 156);
assert_eq!(
    (&Natural::from(100u32)).mod_power_of_2_neg(100).to_string(),
    "1267650600228229401496703205276"
);

type Output = Natural

impl ModPowerOf2NegAssign for Natural

fn mod_power_of_2_neg_assign(&mut self, pow: u64)

Negates a Natural modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^p$ and $-x \equiv y \mod 2^p$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2NegAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut n = Natural::ZERO;
n.mod_power_of_2_neg_assign(5);
assert_eq!(n, 0);

let mut n = Natural::ZERO;
n.mod_power_of_2_neg_assign(100);
assert_eq!(n, 0);

let mut n = Natural::from(100u32);
n.mod_power_of_2_neg_assign(8);
assert_eq!(n, 156);

let mut n = Natural::from(100u32);
n.mod_power_of_2_neg_assign(100);
assert_eq!(n.to_string(), "1267650600228229401496703205276");

impl<'a> ModPowerOf2Pow<&'a Natural> for Natural

fn mod_power_of_2_pow(self, exp: &Natural, pow: u64) -> Natural

Raises a Natural to a Natural power modulo $2^k$. Assumes the input is already reduced mod $2^k$. The first Natural is taken by value and the second by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $x^n \equiv y \mod 2^k$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Pow;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).mod_power_of_2_pow(&Natural::from(10u32), 8), 169);
assert_eq!(
    Natural::from(11u32).mod_power_of_2_pow(&Natural::from(1000u32), 30),
    289109473
);

type Output = Natural

impl<'a, 'b> ModPowerOf2Pow<&'b Natural> for &'a Natural

fn mod_power_of_2_pow(self, exp: &Natural, pow: u64) -> Natural

Raises a Natural to a Natural power modulo $2^k$. Assumes the input is already reduced mod $2^k$. Both Naturals are taken by reference.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Pow;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(3u32)).mod_power_of_2_pow(&Natural::from(10u32), 8), 169);
assert_eq!(
    (&Natural::from(11u32)).mod_power_of_2_pow(&Natural::from(1000u32), 30),
    289109473
);

type Output = Natural

impl ModPowerOf2Pow<Natural> for Natural

fn mod_power_of_2_pow(self, exp: Natural, pow: u64) -> Natural

Raises a Natural to a Natural power modulo $2^k$. Assumes the input is already reduced mod $2^k$. Both Naturals are taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $x^n \equiv y \mod 2^k$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Pow;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(3u32).mod_power_of_2_pow(Natural::from(10u32), 8), 169);
assert_eq!(
    Natural::from(11u32).mod_power_of_2_pow(Natural::from(1000u32), 30),
    289109473
);

type Output = Natural

impl<'a> ModPowerOf2Pow<Natural> for &'a Natural

fn mod_power_of_2_pow(self, exp: Natural, pow: u64) -> Natural

Raises a Natural to a Natural power modulo $2^k$. Assumes the input is already reduced mod $2^k$. The first Natural is taken by reference and the second by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $x^n \equiv y \mod 2^k$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Pow;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(3u32)).mod_power_of_2_pow(Natural::from(10u32), 8), 169);
assert_eq!(
    (&Natural::from(11u32)).mod_power_of_2_pow(Natural::from(1000u32), 30),
    289109473
);

type Output = Natural

impl<'a> ModPowerOf2PowAssign<&'a Natural> for Natural

fn mod_power_of_2_pow_assign(&mut self, exp: &Natural, pow: u64)

Raises a Natural to a Natural power modulo $2^k$, in place. Assumes the input is already reduced mod $2^k$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < 2^k$ and $x^n \equiv y \mod 2^k$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2PowAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(3u32);
x.mod_power_of_2_pow_assign(&Natural::from(10u32), 8);
assert_eq!(x, 169);

let mut x = Natural::from(11u32);
x.mod_power_of_2_pow_assign(&Natural::from(1000u32), 30);
assert_eq!(x, 289109473);

impl ModPowerOf2PowAssign<Natural> for Natural

fn mod_power_of_2_pow_assign(&mut self, exp: Natural, pow: u64)

Raises a Natural to a Natural power modulo $2^k$, in place. Assumes the input is already reduced mod $2^k$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < 2^k$ and $x^n \equiv y \mod 2^k$.

Worst-case complexity

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

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

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

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2PowAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(3u32);
x.mod_power_of_2_pow_assign(Natural::from(10u32), 8);
assert_eq!(x, 169);

let mut x = Natural::from(11u32);
x.mod_power_of_2_pow_assign(Natural::from(1000u32), 30);
assert_eq!(x, 289109473);

impl ModPowerOf2Shl<i128> for Natural

fn mod_power_of_2_shl(self, bits: i128, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shl<i128> for &'a Natural

fn mod_power_of_2_shl(self, bits: i128, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shl<i16> for Natural

fn mod_power_of_2_shl(self, bits: i16, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shl<i16> for &'a Natural

fn mod_power_of_2_shl(self, bits: i16, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shl<i32> for Natural

fn mod_power_of_2_shl(self, bits: i32, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shl<i32> for &'a Natural

fn mod_power_of_2_shl(self, bits: i32, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shl<i64> for Natural

fn mod_power_of_2_shl(self, bits: i64, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shl<i64> for &'a Natural

fn mod_power_of_2_shl(self, bits: i64, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shl<i8> for Natural

fn mod_power_of_2_shl(self, bits: i8, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shl<i8> for &'a Natural

fn mod_power_of_2_shl(self, bits: i8, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shl<isize> for Natural

fn mod_power_of_2_shl(self, bits: isize, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shl<isize> for &'a Natural

fn mod_power_of_2_shl(self, bits: isize, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shl<u128> for Natural

fn mod_power_of_2_shl(self, bits: u128, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shl<u128> for &'a Natural

fn mod_power_of_2_shl(self, bits: u128, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shl<u16> for Natural

fn mod_power_of_2_shl(self, bits: u16, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shl<u16> for &'a Natural

fn mod_power_of_2_shl(self, bits: u16, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shl<u32> for Natural

fn mod_power_of_2_shl(self, bits: u32, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shl<u32> for &'a Natural

fn mod_power_of_2_shl(self, bits: u32, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shl<u64> for Natural

fn mod_power_of_2_shl(self, bits: u64, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shl<u64> for &'a Natural

fn mod_power_of_2_shl(self, bits: u64, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shl<u8> for Natural

fn mod_power_of_2_shl(self, bits: u8, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shl<u8> for &'a Natural

fn mod_power_of_2_shl(self, bits: u8, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shl<usize> for Natural

fn mod_power_of_2_shl(self, bits: usize, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shl<usize> for &'a Natural

fn mod_power_of_2_shl(self, bits: usize, pow: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2ShlAssign<i128> for Natural

fn mod_power_of_2_shl_assign(&mut self, bits: i128, pow: u64)

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShlAssign<i16> for Natural

fn mod_power_of_2_shl_assign(&mut self, bits: i16, pow: u64)

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShlAssign<i32> for Natural

fn mod_power_of_2_shl_assign(&mut self, bits: i32, pow: u64)

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShlAssign<i64> for Natural

fn mod_power_of_2_shl_assign(&mut self, bits: i64, pow: u64)

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShlAssign<i8> for Natural

fn mod_power_of_2_shl_assign(&mut self, bits: i8, pow: u64)

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShlAssign<isize> for Natural

fn mod_power_of_2_shl_assign(&mut self, bits: isize, pow: u64)

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $\lfloor 2^nx \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShlAssign<u128> for Natural

fn mod_power_of_2_shl_assign(&mut self, bits: u128, pow: u64)

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShlAssign<u16> for Natural

fn mod_power_of_2_shl_assign(&mut self, bits: u16, pow: u64)

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShlAssign<u32> for Natural

fn mod_power_of_2_shl_assign(&mut self, bits: u32, pow: u64)

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShlAssign<u64> for Natural

fn mod_power_of_2_shl_assign(&mut self, bits: u64, pow: u64)

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShlAssign<u8> for Natural

fn mod_power_of_2_shl_assign(&mut self, bits: u8, pow: u64)

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShlAssign<usize> for Natural

fn mod_power_of_2_shl_assign(&mut self, bits: usize, pow: u64)

Left-shifts a Natural (multiplies it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $2^nx \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2Shr<i128> for Natural

fn mod_power_of_2_shr(self, bits: i128, pow: u64) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shr<i128> for &'a Natural

fn mod_power_of_2_shr(self, bits: i128, pow: u64) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shr<i16> for Natural

fn mod_power_of_2_shr(self, bits: i16, pow: u64) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shr<i16> for &'a Natural

fn mod_power_of_2_shr(self, bits: i16, pow: u64) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shr<i32> for Natural

fn mod_power_of_2_shr(self, bits: i32, pow: u64) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shr<i32> for &'a Natural

fn mod_power_of_2_shr(self, bits: i32, pow: u64) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shr<i64> for Natural

fn mod_power_of_2_shr(self, bits: i64, pow: u64) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shr<i64> for &'a Natural

fn mod_power_of_2_shr(self, bits: i64, pow: u64) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shr<i8> for Natural

fn mod_power_of_2_shr(self, bits: i8, pow: u64) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shr<i8> for &'a Natural

fn mod_power_of_2_shr(self, bits: i8, pow: u64) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2Shr<isize> for Natural

fn mod_power_of_2_shr(self, bits: isize, pow: u64) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl<'a> ModPowerOf2Shr<isize> for &'a Natural

fn mod_power_of_2_shr(self, bits: isize, pow: u64) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, n, k) = y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

type Output = Natural

impl ModPowerOf2ShrAssign<i128> for Natural

fn mod_power_of_2_shr_assign(&mut self, bits: i128, pow: u64)

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShrAssign<i16> for Natural

fn mod_power_of_2_shr_assign(&mut self, bits: i16, pow: u64)

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShrAssign<i32> for Natural

fn mod_power_of_2_shr_assign(&mut self, bits: i32, pow: u64)

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShrAssign<i64> for Natural

fn mod_power_of_2_shr_assign(&mut self, bits: i64, pow: u64)

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShrAssign<i8> for Natural

fn mod_power_of_2_shr_assign(&mut self, bits: i8, pow: u64)

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2ShrAssign<isize> for Natural

fn mod_power_of_2_shr_assign(&mut self, bits: isize, pow: u64)

Right-shifts a Natural (divides it by a power of 2) modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

See here.

impl ModPowerOf2Square for Natural

fn mod_power_of_2_square(self, pow: u64) -> Natural

Squares a Natural modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by value.

$f(x, k) = y$, where $x, y < 2^k$ and $x^2 \equiv y \mod 2^k$.

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Square;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(Natural::ZERO.mod_power_of_2_square(2), 0);
assert_eq!(Natural::from(5u32).mod_power_of_2_square(3), 1);
assert_eq!(
    Natural::from_str("12345678987654321").unwrap().mod_power_of_2_square(64).to_string(),
    "16556040056090124897"
);

type Output = Natural

impl<'a> ModPowerOf2Square for &'a Natural

fn mod_power_of_2_square(self, pow: u64) -> Natural

Squares a Natural modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The Natural is taken by reference.

$f(x, k) = y$, where $x, y < 2^k$ and $x^2 \equiv y \mod 2^k$.

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Square;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!((&Natural::ZERO).mod_power_of_2_square(2), 0);
assert_eq!((&Natural::from(5u32)).mod_power_of_2_square(3), 1);
assert_eq!(
    (&Natural::from_str("12345678987654321").unwrap())
        .mod_power_of_2_square(64).to_string(),
    "16556040056090124897"
);

type Output = Natural

impl ModPowerOf2SquareAssign for Natural

fn mod_power_of_2_square_assign(&mut self, pow: u64)

Squares a Natural modulo $2^k$, in place. Assumes the input is already reduced modulo $2^k$.

$x \gets y$, where $x, y < 2^k$ and $x^2 \equiv y \mod 2^k$.

Worst-case complexity

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

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

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2SquareAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use std::str::FromStr;

let mut n = Natural::ZERO;
n.mod_power_of_2_square_assign(2);
assert_eq!(n, 0);

let mut n = Natural::from(5u32);
n.mod_power_of_2_square_assign(3);
assert_eq!(n, 1);

let mut n = Natural::from_str("12345678987654321").unwrap();
n.mod_power_of_2_square_assign(64);
assert_eq!(n.to_string(), "16556040056090124897");

impl<'a> ModPowerOf2Sub<&'a Natural> for Natural

fn mod_power_of_2_sub(self, other: &'a Natural, pow: u64) -> Natural

Subtracts two Naturals modulo $2^k$. Assumes the inputs are already reduced modulo $2^k$. The first Natural is taken by value and the second by reference.

$f(x, y, k) = z$, where $x, y, z < 2^k$ and $x - y \equiv z \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Sub;
use malachite_base::num::basic::traits::Two;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(10u32).mod_power_of_2_sub(&Natural::TWO, 4), 8);
assert_eq!(Natural::from(56u32).mod_power_of_2_sub(&Natural::from(123u32), 9), 445);

type Output = Natural

impl<'a, 'b> ModPowerOf2Sub<&'a Natural> for &'b Natural

fn mod_power_of_2_sub(self, other: &'a Natural, pow: u64) -> Natural

Subtracts two Natural modulo $2^k$. Assumes the inputs are already reduced modulo $2^k$. Both Naturals are taken by reference.

$f(x, y, k) = z$, where $x, y, z < 2^k$ and $x - y \equiv z \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Sub;
use malachite_base::num::basic::traits::Two;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(10u32)).mod_power_of_2_sub(&Natural::TWO, 4), 8);
assert_eq!((&Natural::from(56u32)).mod_power_of_2_sub(&Natural::from(123u32), 9), 445);

type Output = Natural

impl ModPowerOf2Sub<Natural> for Natural

fn mod_power_of_2_sub(self, other: Natural, pow: u64) -> Natural

Subtracts two Naturals modulo $2^k$. Assumes the inputs are already reduced modulo $2^k$. Both Naturals are taken by value.

$f(x, y, k) = z$, where $x, y, z < 2^k$ and $x - y \equiv z \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Sub;
use malachite_base::num::basic::traits::Two;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(10u32).mod_power_of_2_sub(Natural::TWO, 4), 8);
assert_eq!(Natural::from(56u32).mod_power_of_2_sub(Natural::from(123u32), 9), 445);

type Output = Natural

impl<'a> ModPowerOf2Sub<Natural> for &'a Natural

fn mod_power_of_2_sub(self, other: Natural, pow: u64) -> Natural

Subtracts two Naturals modulo $2^k$. Assumes the inputs are already reduced modulo $2^k$. The first Natural is taken by reference and the second by value.

$f(x, y, k) = z$, where $x, y, z < 2^k$ and $x - y \equiv z \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2Sub;
use malachite_base::num::basic::traits::Two;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(10u32)).mod_power_of_2_sub(Natural::TWO, 4), 8);
assert_eq!((&Natural::from(56u32)).mod_power_of_2_sub(Natural::from(123u32), 9), 445);

type Output = Natural

impl<'a> ModPowerOf2SubAssign<&'a Natural> for Natural

fn mod_power_of_2_sub_assign(&mut self, other: &'a Natural, pow: u64)

Subtracts two Natural modulo $2^k$, in place. Assumes the inputs are already reduced modulo $2^k$. The Natural on the right-hand side is taken by reference.

$x \gets z$, where $x, y, z < 2^k$ and $x - y \equiv z \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2SubAssign;
use malachite_base::num::basic::traits::Two;
use malachite_nz::natural::Natural;

let mut x = Natural::from(10u32);
x.mod_power_of_2_sub_assign(&Natural::TWO, 4);
assert_eq!(x, 8);

let mut x = Natural::from(56u32);
x.mod_power_of_2_sub_assign(&Natural::from(123u32), 9);
assert_eq!(x, 445);

impl ModPowerOf2SubAssign<Natural> for Natural

fn mod_power_of_2_sub_assign(&mut self, other: Natural, pow: u64)

Subtracts two Natural modulo $2^k$, in place. Assumes the inputs are already reduced modulo $2^k$. The Natural on the right-hand side is taken by value.

$x \gets z$, where $x, y, z < 2^k$ and $x - y \equiv z \mod 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModPowerOf2SubAssign;
use malachite_base::num::basic::traits::Two;
use malachite_nz::natural::Natural;

let mut x = Natural::from(10u32);
x.mod_power_of_2_sub_assign(Natural::TWO, 4);
assert_eq!(x, 8);

let mut x = Natural::from(56u32);
x.mod_power_of_2_sub_assign(Natural::from(123u32), 9);
assert_eq!(x, 445);

impl<'a> ModShl<i128, &'a Natural> for Natural

fn mod_shl(self, bits: i128, m: &'a Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShl<i128, &'b Natural> for &'a Natural

fn mod_shl(self, bits: i128, m: &'b Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl ModShl<i128, Natural> for Natural

fn mod_shl(self, bits: i128, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<i128, Natural> for &'a Natural

fn mod_shl(self, bits: i128, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<i16, &'a Natural> for Natural

fn mod_shl(self, bits: i16, m: &'a Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShl<i16, &'b Natural> for &'a Natural

fn mod_shl(self, bits: i16, m: &'b Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl ModShl<i16, Natural> for Natural

fn mod_shl(self, bits: i16, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<i16, Natural> for &'a Natural

fn mod_shl(self, bits: i16, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<i32, &'a Natural> for Natural

fn mod_shl(self, bits: i32, m: &'a Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShl<i32, &'b Natural> for &'a Natural

fn mod_shl(self, bits: i32, m: &'b Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl ModShl<i32, Natural> for Natural

fn mod_shl(self, bits: i32, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<i32, Natural> for &'a Natural

fn mod_shl(self, bits: i32, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<i64, &'a Natural> for Natural

fn mod_shl(self, bits: i64, m: &'a Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShl<i64, &'b Natural> for &'a Natural

fn mod_shl(self, bits: i64, m: &'b Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl ModShl<i64, Natural> for Natural

fn mod_shl(self, bits: i64, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<i64, Natural> for &'a Natural

fn mod_shl(self, bits: i64, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<i8, &'a Natural> for Natural

fn mod_shl(self, bits: i8, m: &'a Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShl<i8, &'b Natural> for &'a Natural

fn mod_shl(self, bits: i8, m: &'b Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl ModShl<i8, Natural> for Natural

fn mod_shl(self, bits: i8, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<i8, Natural> for &'a Natural

fn mod_shl(self, bits: i8, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<isize, &'a Natural> for Natural

fn mod_shl(self, bits: isize, m: &'a Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShl<isize, &'b Natural> for &'a Natural

fn mod_shl(self, bits: isize, m: &'b Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl ModShl<isize, Natural> for Natural

fn mod_shl(self, bits: isize, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<isize, Natural> for &'a Natural

fn mod_shl(self, bits: isize, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<u128, &'a Natural> for Natural

fn mod_shl(self, bits: u128, m: &'a Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShl<u128, &'b Natural> for &'a Natural

fn mod_shl(self, bits: u128, m: &'b Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl ModShl<u128, Natural> for Natural

fn mod_shl(self, bits: u128, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<u128, Natural> for &'a Natural

fn mod_shl(self, bits: u128, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<u16, &'a Natural> for Natural

fn mod_shl(self, bits: u16, m: &'a Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShl<u16, &'b Natural> for &'a Natural

fn mod_shl(self, bits: u16, m: &'b Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl ModShl<u16, Natural> for Natural

fn mod_shl(self, bits: u16, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<u16, Natural> for &'a Natural

fn mod_shl(self, bits: u16, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<u32, &'a Natural> for Natural

fn mod_shl(self, bits: u32, m: &'a Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShl<u32, &'b Natural> for &'a Natural

fn mod_shl(self, bits: u32, m: &'b Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl ModShl<u32, Natural> for Natural

fn mod_shl(self, bits: u32, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<u32, Natural> for &'a Natural

fn mod_shl(self, bits: u32, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<u64, &'a Natural> for Natural

fn mod_shl(self, bits: u64, m: &'a Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShl<u64, &'b Natural> for &'a Natural

fn mod_shl(self, bits: u64, m: &'b Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl ModShl<u64, Natural> for Natural

fn mod_shl(self, bits: u64, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<u64, Natural> for &'a Natural

fn mod_shl(self, bits: u64, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<u8, &'a Natural> for Natural

fn mod_shl(self, bits: u8, m: &'a Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShl<u8, &'b Natural> for &'a Natural

fn mod_shl(self, bits: u8, m: &'b Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl ModShl<u8, Natural> for Natural

fn mod_shl(self, bits: u8, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<u8, Natural> for &'a Natural

fn mod_shl(self, bits: u8, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<usize, &'a Natural> for Natural

fn mod_shl(self, bits: usize, m: &'a Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShl<usize, &'b Natural> for &'a Natural

fn mod_shl(self, bits: usize, m: &'b Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl ModShl<usize, Natural> for Natural

fn mod_shl(self, bits: usize, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShl<usize, Natural> for &'a Natural

fn mod_shl(self, bits: usize, m: Natural) -> Natural

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

type Output = Natural

impl<'a> ModShlAssign<i128, &'a Natural> for Natural

fn mod_shl_assign(&mut self, bits: i128, m: &'a Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

impl ModShlAssign<i128, Natural> for Natural

fn mod_shl_assign(&mut self, bits: i128, m: Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

impl<'a> ModShlAssign<i16, &'a Natural> for Natural

fn mod_shl_assign(&mut self, bits: i16, m: &'a Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

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

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

Examples

See here.

impl ModShlAssign<i16, Natural> for Natural

fn mod_shl_assign(&mut self, bits: i16, m: Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

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

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShlAssign<i32, &'a Natural> for Natural

fn mod_shl_assign(&mut self, bits: i32, m: &'a Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShlAssign<i32, Natural> for Natural

fn mod_shl_assign(&mut self, bits: i32, m: Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShlAssign<i64, &'a Natural> for Natural

fn mod_shl_assign(&mut self, bits: i64, m: &'a Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShlAssign<i64, Natural> for Natural

fn mod_shl_assign(&mut self, bits: i64, m: Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShlAssign<i8, &'a Natural> for Natural

fn mod_shl_assign(&mut self, bits: i8, m: &'a Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShlAssign<i8, Natural> for Natural

fn mod_shl_assign(&mut self, bits: i8, m: Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShlAssign<isize, &'a Natural> for Natural

fn mod_shl_assign(&mut self, bits: isize, m: &'a Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShlAssign<isize, Natural> for Natural

fn mod_shl_assign(&mut self, bits: isize, m: Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $\lfloor 2^nx \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShlAssign<u128, &'a Natural> for Natural

fn mod_shl_assign(&mut self, bits: u128, m: &'a Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShlAssign<u128, Natural> for Natural

fn mod_shl_assign(&mut self, bits: u128, m: Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShlAssign<u16, &'a Natural> for Natural

fn mod_shl_assign(&mut self, bits: u16, m: &'a Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShlAssign<u16, Natural> for Natural

fn mod_shl_assign(&mut self, bits: u16, m: Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShlAssign<u32, &'a Natural> for Natural

fn mod_shl_assign(&mut self, bits: u32, m: &'a Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShlAssign<u32, Natural> for Natural

fn mod_shl_assign(&mut self, bits: u32, m: Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShlAssign<u64, &'a Natural> for Natural

fn mod_shl_assign(&mut self, bits: u64, m: &'a Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShlAssign<u64, Natural> for Natural

fn mod_shl_assign(&mut self, bits: u64, m: Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShlAssign<u8, &'a Natural> for Natural

fn mod_shl_assign(&mut self, bits: u8, m: &'a Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShlAssign<u8, Natural> for Natural

fn mod_shl_assign(&mut self, bits: u8, m: Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShlAssign<usize, &'a Natural> for Natural

fn mod_shl_assign(&mut self, bits: usize, m: &'a Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShlAssign<usize, Natural> for Natural

fn mod_shl_assign(&mut self, bits: usize, m: Natural)

Left-shifts a Natural (multiplies it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $2^nx \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShr<i128, &'a Natural> for Natural

fn mod_shr(self, bits: i128, m: &'a Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShr<i128, &'b Natural> for &'a Natural

fn mod_shr(self, bits: i128, m: &'b Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl ModShr<i128, Natural> for Natural

fn mod_shr(self, bits: i128, m: Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a> ModShr<i128, Natural> for &'a Natural

fn mod_shr(self, bits: i128, m: Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a> ModShr<i16, &'a Natural> for Natural

fn mod_shr(self, bits: i16, m: &'a Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShr<i16, &'b Natural> for &'a Natural

fn mod_shr(self, bits: i16, m: &'b Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl ModShr<i16, Natural> for Natural

fn mod_shr(self, bits: i16, m: Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a> ModShr<i16, Natural> for &'a Natural

fn mod_shr(self, bits: i16, m: Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a> ModShr<i32, &'a Natural> for Natural

fn mod_shr(self, bits: i32, m: &'a Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShr<i32, &'b Natural> for &'a Natural

fn mod_shr(self, bits: i32, m: &'b Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl ModShr<i32, Natural> for Natural

fn mod_shr(self, bits: i32, m: Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a> ModShr<i32, Natural> for &'a Natural

fn mod_shr(self, bits: i32, m: Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a> ModShr<i64, &'a Natural> for Natural

fn mod_shr(self, bits: i64, m: &'a Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShr<i64, &'b Natural> for &'a Natural

fn mod_shr(self, bits: i64, m: &'b Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl ModShr<i64, Natural> for Natural

fn mod_shr(self, bits: i64, m: Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a> ModShr<i64, Natural> for &'a Natural

fn mod_shr(self, bits: i64, m: Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a> ModShr<i8, &'a Natural> for Natural

fn mod_shr(self, bits: i8, m: &'a Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShr<i8, &'b Natural> for &'a Natural

fn mod_shr(self, bits: i8, m: &'b Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl ModShr<i8, Natural> for Natural

fn mod_shr(self, bits: i8, m: Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a> ModShr<i8, Natural> for &'a Natural

fn mod_shr(self, bits: i8, m: Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a> ModShr<isize, &'a Natural> for Natural

fn mod_shr(self, bits: isize, m: &'a Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a, 'b> ModShr<isize, &'b Natural> for &'a Natural

fn mod_shr(self, bits: isize, m: &'b Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl ModShr<isize, Natural> for Natural

fn mod_shr(self, bits: isize, m: Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a> ModShr<isize, Natural> for &'a Natural

fn mod_shr(self, bits: isize, m: Natural) -> Natural

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, n, m) = y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

impl<'a> ModShrAssign<i128, &'a Natural> for Natural

fn mod_shr_assign(&mut self, bits: i128, m: &'a Natural)

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShrAssign<i128, Natural> for Natural

fn mod_shr_assign(&mut self, bits: i128, m: Natural)

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShrAssign<i16, &'a Natural> for Natural

fn mod_shr_assign(&mut self, bits: i16, m: &'a Natural)

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShrAssign<i16, Natural> for Natural

fn mod_shr_assign(&mut self, bits: i16, m: Natural)

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShrAssign<i32, &'a Natural> for Natural

fn mod_shr_assign(&mut self, bits: i32, m: &'a Natural)

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShrAssign<i32, Natural> for Natural

fn mod_shr_assign(&mut self, bits: i32, m: Natural)

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShrAssign<i64, &'a Natural> for Natural

fn mod_shr_assign(&mut self, bits: i64, m: &'a Natural)

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShrAssign<i64, Natural> for Natural

fn mod_shr_assign(&mut self, bits: i64, m: Natural)

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShrAssign<i8, &'a Natural> for Natural

fn mod_shr_assign(&mut self, bits: i8, m: &'a Natural)

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShrAssign<i8, Natural> for Natural

fn mod_shr_assign(&mut self, bits: i8, m: Natural)

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModShrAssign<isize, &'a Natural> for Natural

fn mod_shr_assign(&mut self, bits: isize, m: &'a Natural)

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl ModShrAssign<isize, Natural> for Natural

fn mod_shr_assign(&mut self, bits: isize, m: Natural)

Right-shifts a Natural (divides it by a power of 2) modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $\lfloor 2^{-n}x \rfloor \equiv y \mod m$.

Worst-case complexity

$T(n, m) = O(mn \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is m.significant_bits(), and $m$ is bits.

Examples

See here.

impl<'a> ModSquare<&'a Natural> for Natural

fn mod_square(self, m: &'a Natural) -> Natural

Squares a Natural modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by value and the second by reference.

$f(x, m) = y$, where $x, y < m$ and $x^2 \equiv y \mod m$.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSquare;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(2u32).mod_square(&Natural::from(10u32)), 4);
assert_eq!(Natural::from(100u32).mod_square(&Natural::from(497u32)), 60);

type Output = Natural

impl<'a, 'b> ModSquare<&'b Natural> for &'a Natural

fn mod_square(self, m: &'b Natural) -> Natural

Squares a Natural modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by reference.

$f(x, m) = y$, where $x, y < m$ and $x^2 \equiv y \mod m$.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSquare;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(2u32)).mod_square(&Natural::from(10u32)), 4);
assert_eq!((&Natural::from(100u32)).mod_square(&Natural::from(497u32)), 60);

type Output = Natural

impl ModSquare<Natural> for Natural

fn mod_square(self, m: Natural) -> Natural

Squares a Natural modulo another Natural $m$. Assumes the input is already reduced modulo $m$. Both Naturals are taken by value.

$f(x, m) = y$, where $x, y < m$ and $x^2 \equiv y \mod m$.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSquare;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(2u32).mod_square(Natural::from(10u32)), 4);
assert_eq!(Natural::from(100u32).mod_square(Natural::from(497u32)), 60);

type Output = Natural

impl<'a> ModSquare<Natural> for &'a Natural

fn mod_square(self, m: Natural) -> Natural

Squares a Natural modulo another Natural $m$. Assumes the input is already reduced modulo $m$. The first Natural is taken by reference and the second by value.

$f(x, m) = y$, where $x, y < m$ and $x^2 \equiv y \mod m$.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSquare;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(2u32)).mod_square(Natural::from(10u32)), 4);
assert_eq!((&Natural::from(100u32)).mod_square(Natural::from(497u32)), 60);

type Output = Natural

impl<'a> ModSquareAssign<&'a Natural> for Natural

fn mod_square_assign(&mut self, m: &'a Natural)

Squares a Natural modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by reference.

$x \gets y$, where $x, y < m$ and $x^2 \equiv y \mod m$.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSquareAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(2u32);
x.mod_square_assign(&Natural::from(10u32));
assert_eq!(x, 4);

let mut x = Natural::from(100u32);
x.mod_square_assign(&Natural::from(497u32));
assert_eq!(x, 60);

impl ModSquareAssign<Natural> for Natural

fn mod_square_assign(&mut self, m: Natural)

Squares a Natural modulo another Natural $m$, in place. Assumes the input is already reduced modulo $m$. The Natural on the right-hand side is taken by value.

$x \gets y$, where $x, y < m$ and $x^2 \equiv y \mod m$.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSquareAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(2u32);
x.mod_square_assign(Natural::from(10u32));
assert_eq!(x, 4);

let mut x = Natural::from(100u32);
x.mod_square_assign(Natural::from(497u32));
assert_eq!(x, 60);

impl<'a, 'b> ModSub<&'a Natural, &'b Natural> for Natural

fn mod_sub(self, other: &'a Natural, m: &'b Natural) -> Natural

Subtracts two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first Natural is taken by value and the second and third by reference.

$f(x, y, m) = z$, where $x, y, z < m$ and $x - y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSub;
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::from(4u32).mod_sub(&Natural::from(3u32), &Natural::from(5u32)).to_string(),
    "1"
);
assert_eq!(
    Natural::from(7u32).mod_sub(&Natural::from(9u32), &Natural::from(10u32)).to_string(),
    "8"
);

This is equivalent to _fmpz_mod_subN from fmpz_mod/sub.c, FLINT 2.7.1, where b is taken by value and c and m are taken by reference.

type Output = Natural

impl<'a> ModSub<&'a Natural, Natural> for Natural

fn mod_sub(self, other: &'a Natural, m: Natural) -> Natural

Subtracts two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first and third Naturals are taken by value and the second by reference.

$f(x, y, m) = z$, where $x, y, z < m$ and $x - y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSub;
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::from(4u32).mod_sub(&Natural::from(3u32), Natural::from(5u32)).to_string(),
    "1"
);
assert_eq!(
    Natural::from(7u32).mod_sub(&Natural::from(9u32), Natural::from(10u32)).to_string(),
    "8"
);

This isequivalent to _fmpz_mod_subN from fmpz_mod/sub.c, FLINT 2.7.1, where b and m are taken by value and c is taken by reference.

type Output = Natural

impl<'a, 'b, 'c> ModSub<&'b Natural, &'c Natural> for &'a Natural

fn mod_sub(self, other: &'b Natural, m: &'c Natural) -> Natural

Subtracts two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. All three Naturals are taken by reference.

$f(x, y, m) = z$, where $x, y, z < m$ and $x - y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSub;
use malachite_nz::natural::Natural;

assert_eq!(
    (&Natural::from(4u32)).mod_sub(&Natural::from(3u32), &Natural::from(5u32)).to_string(),
    "1"
);
assert_eq!(
    (&Natural::from(7u32)).mod_sub(&Natural::from(9u32), &Natural::from(10u32)).to_string(),
    "8"
);

This is equivalent to _fmpz_mod_subN from fmpz_mod/sub.c, FLINT 2.7.1, where b, c, and m are taken by reference.

type Output = Natural

impl<'a, 'b> ModSub<&'b Natural, Natural> for &'a Natural

fn mod_sub(self, other: &'b Natural, m: Natural) -> Natural

Subtracts two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first two Naturals are taken by reference and the third by value.

$f(x, y, m) = z$, where $x, y, z < m$ and $x - y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSub;
use malachite_nz::natural::Natural;

assert_eq!(
    (&Natural::from(4u32)).mod_sub(&Natural::from(3u32), Natural::from(5u32)).to_string(),
    "1"
);
assert_eq!(
    (&Natural::from(7u32)).mod_sub(&Natural::from(9u32), Natural::from(10u32)).to_string(),
    "8"
);

This is equivalent to _fmpz_mod_subN from fmpz_mod/sub.c, FLINT 2.7.1, where b and c are taken by reference and m is taken by value.

type Output = Natural

impl<'a> ModSub<Natural, &'a Natural> for Natural

fn mod_sub(self, other: Natural, m: &'a Natural) -> Natural

Subtracts two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first two Naturals are taken by value and the third by reference.

$f(x, y, m) = z$, where $x, y, z < m$ and $x - y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSub;
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::from(4u32).mod_sub(Natural::from(3u32), &Natural::from(5u32)).to_string(),
    "1"
);
assert_eq!(
    Natural::from(7u32).mod_sub(Natural::from(9u32), &Natural::from(10u32)).to_string(),
    "8"
);

This is equivalent to _fmpz_mod_subN from fmpz_mod/sub.c, FLINT 2.7.1, where b and c are taken by value and m is taken by reference.

type Output = Natural

impl<'a, 'b> ModSub<Natural, &'b Natural> for &'a Natural

fn mod_sub(self, other: Natural, m: &'b Natural) -> Natural

Subtracts two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first and third Naturals are taken by reference and the second by value.

$f(x, y, m) = z$, where $x, y, z < m$ and $x - y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSub;
use malachite_nz::natural::Natural;

assert_eq!(
    (&Natural::from(4u32)).mod_sub(Natural::from(3u32), &Natural::from(5u32)).to_string(),
    "1"
);
assert_eq!(
    (&Natural::from(7u32)).mod_sub(Natural::from(9u32), &Natural::from(10u32)).to_string(),
    "8"
);

This is equivalent to _fmpz_mod_subN from fmpz_mod/sub.c, FLINT 2.7.1, where b and m are taken by reference and c is taken by value.

type Output = Natural

impl ModSub<Natural, Natural> for Natural

fn mod_sub(self, other: Natural, m: Natural) -> Natural

Subtracts two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. All three Naturals are taken by value.

$f(x, y, m) = z$, where $x, y, z < m$ and $x - y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSub;
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::from(4u32).mod_sub(Natural::from(3u32), Natural::from(5u32)).to_string(),
    "1"
);
assert_eq!(
    Natural::from(7u32).mod_sub(Natural::from(9u32), Natural::from(10u32)).to_string(),
    "8"
);

This is equivalent to _fmpz_mod_subN from fmpz_mod/sub.c, FLINT 2.7.1, where b, c, and m are taken by value.

type Output = Natural

impl<'a> ModSub<Natural, Natural> for &'a Natural

fn mod_sub(self, other: Natural, m: Natural) -> Natural

Subtracts two Naturals modulo a third Natural $m$. Assumes the inputs are already reduced modulo $m$. The first Natural is taken by reference and the second and third by value.

$f(x, y, m) = z$, where $x, y, z < m$ and $x - y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSub;
use malachite_nz::natural::Natural;

assert_eq!(
    (&Natural::from(4u32)).mod_sub(Natural::from(3u32), Natural::from(5u32)).to_string(),
    "1"
);
assert_eq!(
    (&Natural::from(7u32)).mod_sub(Natural::from(9u32), Natural::from(10u32)).to_string(),
    "8"
);

This is equivalent to _fmpz_mod_subN from fmpz_mod/sub.c, FLINT 2.7.1, where b is taken by reference and c and m are taken by value.

type Output = Natural

impl<'a, 'b> ModSubAssign<&'a Natural, &'b Natural> for Natural

fn mod_sub_assign(&mut self, other: &'a Natural, m: &'b Natural)

Subtracts two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. Both Naturals on the right-hand side are taken by reference.

$x \gets z$, where $x, y, z < m$ and $x - y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSubAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(4u32);
x.mod_sub_assign(&Natural::from(3u32), &Natural::from(5u32));
assert_eq!(x.to_string(), "1");

let mut x = Natural::from(7u32);
x.mod_sub_assign(&Natural::from(9u32), &Natural::from(10u32));
assert_eq!(x.to_string(), "8");

This is equivalent to _fmpz_mod_subN from fmpz_mod/sub.c, FLINT 2.7.1, where b is taken by value, c and m are taken by reference, and a == b.

impl<'a> ModSubAssign<&'a Natural, Natural> for Natural

fn mod_sub_assign(&mut self, other: &'a Natural, m: Natural)

Subtracts two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. The first Natural on the right-hand side is taken by reference and the second by value.

$x \gets z$, where $x, y, z < m$ and $x - y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSubAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(4u32);
x.mod_sub_assign(&Natural::from(3u32), Natural::from(5u32));
assert_eq!(x.to_string(), "1");

let mut x = Natural::from(7u32);
x.mod_sub_assign(&Natural::from(9u32), Natural::from(10u32));
assert_eq!(x.to_string(), "8");

This is equivalent to _fmpz_mod_subN from fmpz_mod/sub.c, FLINT 2.7.1, where b and m are taken by value, c is taken by reference, and a == b.

impl<'a> ModSubAssign<Natural, &'a Natural> for Natural

fn mod_sub_assign(&mut self, other: Natural, m: &'a Natural)

Subtracts two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. The first Natural on the right-hand side is taken by value and the second by reference.

$x \gets z$, where $x, y, z < m$ and $x - y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSubAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(4u32);
x.mod_sub_assign(Natural::from(3u32), &Natural::from(5u32));
assert_eq!(x.to_string(), "1");

let mut x = Natural::from(7u32);
x.mod_sub_assign(Natural::from(9u32), &Natural::from(10u32));
assert_eq!(x.to_string(), "8");

This is equivalent to _fmpz_mod_subN from fmpz_mod/sub.c, FLINT 2.7.1, where b and c are taken by value, m is taken by reference, and a == b.

impl ModSubAssign<Natural, Natural> for Natural

fn mod_sub_assign(&mut self, other: Natural, m: Natural)

Subtracts two Naturals modulo a third Natural $m$, in place. Assumes the inputs are already reduced modulo $m$. Both Naturals on the right-hand side are taken by value.

$x \gets z$, where $x, y, z < m$ and $x - y \equiv z \mod m$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is m.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::ModSubAssign;
use malachite_nz::natural::Natural;

let mut x = Natural::from(4u32);
x.mod_sub_assign(Natural::from(3u32), Natural::from(5u32));
assert_eq!(x.to_string(), "1");

let mut x = Natural::from(7u32);
x.mod_sub_assign(Natural::from(9u32), Natural::from(10u32));
assert_eq!(x.to_string(), "8");

This is equivalent to _fmpz_mod_subN from fmpz_mod/sub.c, FLINT 2.7.1, where b, c, and m are taken by value and a == b.

impl<'a> Mul<&'a Natural> for Natural

fn mul(self, other: &'a Natural) -> Natural

Multiplies two Naturals, taking the first by value and the second by reference.

$$ f(x, y) = xy. $$

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(Natural::ONE * &Natural::from(123u32), 123);
assert_eq!(Natural::from(123u32) * &Natural::ZERO, 0);
assert_eq!(Natural::from(123u32) * &Natural::from(456u32), 56088);
assert_eq!(
    (Natural::from_str("123456789000").unwrap() * &Natural::from_str("987654321000")
           .unwrap()).to_string(),
    "121932631112635269000000"
);

type Output = Natural

The resulting type after applying the * operator.

impl<'a, 'b> Mul<&'a Natural> for &'b Natural

fn mul(self, other: &'a Natural) -> Natural

Multiplies two Naturals, taking both by reference.

$$ f(x, y) = xy. $$

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(&Natural::ONE * &Natural::from(123u32), 123);
assert_eq!(&Natural::from(123u32) * &Natural::ZERO, 0);
assert_eq!(&Natural::from(123u32) * &Natural::from(456u32), 56088);
assert_eq!(
    (&Natural::from_str("123456789000").unwrap() * &Natural::from_str("987654321000")
           .unwrap()).to_string(),
    "121932631112635269000000"
);

type Output = Natural

The resulting type after applying the * operator.

impl Mul<Natural> for Natural

fn mul(self, other: Natural) -> Natural

Multiplies two Naturals, taking both by value.

$$ f(x, y) = xy. $$

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(Natural::ONE * Natural::from(123u32), 123);
assert_eq!(Natural::from(123u32) * Natural::ZERO, 0);
assert_eq!(Natural::from(123u32) * Natural::from(456u32), 56088);
assert_eq!(
    (Natural::from_str("123456789000").unwrap() * Natural::from_str("987654321000")
           .unwrap()).to_string(),
    "121932631112635269000000"
);

type Output = Natural

The resulting type after applying the * operator.

impl<'a> Mul<Natural> for &'a Natural

fn mul(self, other: Natural) -> Natural

Multiplies two Naturals, taking the first by reference and the second by value.

$$ f(x, y) = xy. $$

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(&Natural::ONE * Natural::from(123u32), 123);
assert_eq!(&Natural::from(123u32) * Natural::ZERO, 0);
assert_eq!(&Natural::from(123u32) * Natural::from(456u32), 56088);
assert_eq!(
    (&Natural::from_str("123456789000").unwrap() * Natural::from_str("987654321000")
           .unwrap()).to_string(),
    "121932631112635269000000"
);

type Output = Natural

The resulting type after applying the * operator.

impl<'a> MulAssign<&'a Natural> for Natural

fn mul_assign(&mut self, other: &'a Natural)

Multiplies a Natural by a Natural in place, taking the Natural on the right-hand side by reference.

$$ x \gets = xy. $$

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;
use std::str::FromStr;

let mut x = Natural::ONE;
x *= &Natural::from_str("1000").unwrap();
x *= &Natural::from_str("2000").unwrap();
x *= &Natural::from_str("3000").unwrap();
x *= &Natural::from_str("4000").unwrap();
assert_eq!(x.to_string(), "24000000000000");

impl MulAssign<Natural> for Natural

fn mul_assign(&mut self, other: Natural)

Multiplies a Natural by a Natural in place, taking the Natural on the right-hand side by value.

$$ x \gets = xy. $$

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), other.significant_bits()).

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::One;
use malachite_nz::natural::Natural;
use std::str::FromStr;

let mut x = Natural::ONE;
x *= Natural::from_str("1000").unwrap();
x *= Natural::from_str("2000").unwrap();
x *= Natural::from_str("3000").unwrap();
x *= Natural::from_str("4000").unwrap();
assert_eq!(x.to_string(), "24000000000000");

impl Named for Natural

const NAME: &'static str = "Natural"

The name of this type, as given by the stringify macro.

See the documentation for impl_named for more details.

impl Neg for Natural

fn neg(self) -> Integer

Negates a Natural, taking it by value and returning an Integer.

$$ f(x) = -x. $$

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(-Natural::ZERO, 0);
assert_eq!(-Natural::from(123u32), -123);

type Output = Integer

The resulting type after applying the - operator.

impl<'a> Neg for &'a Natural

fn neg(self) -> Integer

Negates a Natural, taking it by reference and returning an Integer.

$$ f(x) = -x. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(-&Natural::ZERO, 0);
assert_eq!(-&Natural::from(123u32), -123);

type Output = Integer

The resulting type after applying the - operator.

impl<'a> NegMod<&'a Natural> for Natural

fn neg_mod(self, other: &'a Natural) -> Natural

Divides the negative of a Natural by another Natural, taking the first by value and the second by reference and returning just the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = qy - r$ and $0 \leq r < y$.

$$ f(x, y) = y\left \lceil \frac{x}{y} \right \rceil - x. $$

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::NegMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 3 * 10 - 7 = 23
assert_eq!(Natural::from(23u32).neg_mod(&Natural::from(10u32)), 7);

// 810000006724 * 1234567890987 - 704498996588 = 1000000000000000000000000
assert_eq!(
     Natural::from_str("1000000000000000000000000").unwrap()
            .neg_mod(&Natural::from_str("1234567890987").unwrap()),
     704498996588u64
);

type Output = Natural

impl<'a, 'b> NegMod<&'b Natural> for &'a Natural

fn neg_mod(self, other: &'b Natural) -> Natural

Divides the negative of a Natural by another Natural, taking both by reference and returning just the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = qy - r$ and $0 \leq r < y$.

$$ f(x, y) = y\left \lceil \frac{x}{y} \right \rceil - x. $$

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::NegMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 3 * 10 - 7 = 23
assert_eq!((&Natural::from(23u32)).neg_mod(&Natural::from(10u32)), 7);

// 810000006724 * 1234567890987 - 704498996588 = 1000000000000000000000000
assert_eq!(
     (&Natural::from_str("1000000000000000000000000").unwrap())
            .neg_mod(&Natural::from_str("1234567890987").unwrap()),
     704498996588u64
);

type Output = Natural

impl NegMod<Natural> for Natural

fn neg_mod(self, other: Natural) -> Natural

Divides the negative of a Natural by another Natural, taking both by value and returning just the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = qy - r$ and $0 \leq r < y$.

$$ f(x, y) = y\left \lceil \frac{x}{y} \right \rceil - x. $$

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::NegMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 3 * 10 - 7 = 23
assert_eq!(Natural::from(23u32).neg_mod(Natural::from(10u32)), 7);

// 810000006724 * 1234567890987 - 704498996588 = 1000000000000000000000000
assert_eq!(
     Natural::from_str("1000000000000000000000000").unwrap()
            .neg_mod(Natural::from_str("1234567890987").unwrap()),
     704498996588u64
);

type Output = Natural

impl<'a> NegMod<Natural> for &'a Natural

fn neg_mod(self, other: Natural) -> Natural

Divides the negative of a Natural by another Natural, taking the first by reference and the second by value and returning just the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = qy - r$ and $0 \leq r < y$.

$$ f(x, y) = y\left \lceil \frac{x}{y} \right \rceil - x. $$

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::NegMod;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 3 * 10 - 7 = 23
assert_eq!((&Natural::from(23u32)).neg_mod(Natural::from(10u32)), 7);

// 810000006724 * 1234567890987 - 704498996588 = 1000000000000000000000000
assert_eq!(
     (&Natural::from_str("1000000000000000000000000").unwrap())
            .neg_mod(Natural::from_str("1234567890987").unwrap()),
     704498996588u64
);

type Output = Natural

impl<'a> NegModAssign<&'a Natural> for Natural

fn neg_mod_assign(&mut self, other: &'a Natural)

Divides the negative of a Natural by another Natural, taking the second Naturals by reference and replacing the first by the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = qy - r$ and $0 \leq r < y$.

$$ x \gets y\left \lceil \frac{x}{y} \right \rceil - x. $$

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::NegModAssign;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 3 * 10 - 7 = 23
let mut x = Natural::from(23u32);
x.neg_mod_assign(&Natural::from(10u32));
assert_eq!(x, 7);

// 810000006724 * 1234567890987 - 704498996588 = 1000000000000000000000000
let mut x = Natural::from_str("1000000000000000000000000").unwrap();
x.neg_mod_assign(&Natural::from_str("1234567890987").unwrap());
assert_eq!(x, 704498996588u64);

impl NegModAssign<Natural> for Natural

fn neg_mod_assign(&mut self, other: Natural)

Divides the negative of a Natural by another Natural, taking the second Naturals by value and replacing the first by the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = qy - r$ and $0 \leq r < y$.

$$ x \gets y\left \lceil \frac{x}{y} \right \rceil - x. $$

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::NegModAssign;
use malachite_nz::natural::Natural;
use std::str::FromStr;

// 3 * 10 - 7 = 23
let mut x = Natural::from(23u32);
x.neg_mod_assign(Natural::from(10u32));
assert_eq!(x, 7);

// 810000006724 * 1234567890987 - 704498996588 = 1000000000000000000000000
let mut x = Natural::from_str("1000000000000000000000000").unwrap();
x.neg_mod_assign(Natural::from_str("1234567890987").unwrap());
assert_eq!(x, 704498996588u64);

impl NegModPowerOf2 for Natural

fn neg_mod_power_of_2(self, pow: u64) -> Natural

Divides the negative of a Natural by a $2^k$, returning just the remainder. The Natural is taken by value.

If the quotient were computed, the quotient and remainder would satisfy $x = q2^k - r$ and $0 \leq r < 2^k$.

$$ f(x, k) = 2^k\left \lceil \frac{x}{2^k} \right \rceil - x. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::NegModPowerOf2;
use malachite_nz::natural::Natural;

// 2 * 2^8 - 252 = 260
assert_eq!(Natural::from(260u32).neg_mod_power_of_2(8), 252);

// 101 * 2^4 - 5 = 1611
assert_eq!(Natural::from(1611u32).neg_mod_power_of_2(4), 5);

type Output = Natural

impl<'a> NegModPowerOf2 for &'a Natural

fn neg_mod_power_of_2(self, pow: u64) -> Natural

Divides the negative of a Natural by a $2^k$, returning just the remainder. The Natural is taken by reference.

If the quotient were computed, the quotient and remainder would satisfy $x = q2^k - r$ and $0 \leq r < 2^k$.

$$ f(x, k) = 2^k\left \lceil \frac{x}{2^k} \right \rceil - x. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::NegModPowerOf2;
use malachite_nz::natural::Natural;

// 2 * 2^8 - 252 = 260
assert_eq!((&Natural::from(260u32)).neg_mod_power_of_2(8), 252);
// 101 * 2^4 - 5 = 1611
assert_eq!((&Natural::from(1611u32)).neg_mod_power_of_2(4), 5);

type Output = Natural

impl NegModPowerOf2Assign for Natural

fn neg_mod_power_of_2_assign(&mut self, pow: u64)

Divides the negative of a Natural by $2^k$, returning just the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = q2^k - r$ and $0 \leq r < 2^k$.

$$ x \gets 2^k\left \lceil \frac{x}{2^k} \right \rceil - x. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::NegModPowerOf2Assign;
use malachite_nz::natural::Natural;

// 2 * 2^8 - 252 = 260
let mut x = Natural::from(260u32);
x.neg_mod_power_of_2_assign(8);
assert_eq!(x, 252);

// 101 * 2^4 - 5 = 1611
let mut x = Natural::from(1611u32);
x.neg_mod_power_of_2_assign(4);
assert_eq!(x, 5);

impl NextPowerOf2 for Natural

fn next_power_of_2(self) -> Natural

Finds the smallest power of 2 greater than or equal to a Natural. The Natural is taken by value.

$f(x) = 2^{\lceil \log_2 x \rceil}$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$ (only if the underlying Vec needs to reallocate)

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{NextPowerOf2, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.next_power_of_2(), 1);
assert_eq!(Natural::from(123u32).next_power_of_2(), 128);
assert_eq!(Natural::from(10u32).pow(12).next_power_of_2(), 1099511627776u64);

type Output = Natural

impl<'a> NextPowerOf2 for &'a Natural

fn next_power_of_2(self) -> Natural

Finds the smallest power of 2 greater than or equal to a Natural. The Natural 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().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{NextPowerOf2, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::ZERO).next_power_of_2(), 1);
assert_eq!((&Natural::from(123u32)).next_power_of_2(), 128);
assert_eq!((&Natural::from(10u32).pow(12)).next_power_of_2(), 1099511627776u64);

type Output = Natural

impl NextPowerOf2Assign for Natural

fn next_power_of_2_assign(&mut self)

Replaces a Natural with the smallest power of 2 greater than or equal to it.

$x \gets 2^{\lceil \log_2 x \rceil}$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$ (only if the underlying Vec needs to reallocate)

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{NextPowerOf2Assign, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut x = Natural::ZERO;
x.next_power_of_2_assign();
assert_eq!(x, 1);

let mut x = Natural::from(123u32);
x.next_power_of_2_assign();
assert_eq!(x, 128);

let mut x = Natural::from(10u32).pow(12);
x.next_power_of_2_assign();
assert_eq!(x, 1099511627776u64);

impl Not for Natural

fn not(self) -> Integer

Returns the bitwise negation of a Natural, taking it by value and returning an Integer.

The Natural is bitwise-negated as if it were represented in two’s complement.

$$ f(n) = -n - 1. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(!Natural::ZERO, -1);
assert_eq!(!Natural::from(123u32), -124);

type Output = Integer

The resulting type after applying the ! operator.

impl<'a> Not for &'a Natural

fn not(self) -> Integer

Returns the bitwise negation of a Natural, taking it by reference and returning an Integer.

The Natural is bitwise-negated as if it were represented in two’s complement.

$$ f(n) = -n - 1. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(!&Natural::ZERO, -1);
assert_eq!(!&Natural::from(123u32), -124);

type Output = Integer

The resulting type after applying the ! operator.

impl Octal for Natural

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Converts a Natural to an octal String.

Using the # format flag prepends "0o" to the string.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToOctalString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(Natural::ZERO.to_octal_string(), "0");
assert_eq!(Natural::from(123u32).to_octal_string(), "173");
assert_eq!(
    Natural::from_str("1000000000000").unwrap().to_octal_string(),
    "16432451210000"
);
assert_eq!(format!("{:07o}", Natural::from(123u32)), "0000173");

assert_eq!(format!("{:#o}", Natural::ZERO), "0o0");
assert_eq!(format!("{:#o}", Natural::from(123u32)), "0o173");
assert_eq!(
    format!("{:#o}", Natural::from_str("1000000000000").unwrap()),
    "0o16432451210000"
);
assert_eq!(format!("{:#07o}", Natural::from(123u32)), "0o00173");

impl One for Natural

The constant 1.

const ONE: Natural = Natural(Small(1))

impl Ord for Natural

fn cmp(&self, other: &Natural) -> Ordering

Compares two Naturals.

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;

assert!(Natural::from(123u32) > Natural::from(122u32));
assert!(Natural::from(123u32) >= Natural::from(122u32));
assert!(Natural::from(123u32) < Natural::from(124u32));
assert!(Natural::from(123u32) <= Natural::from(124u32));

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<'a> OverflowingFrom<&'a Natural> for usize

fn overflowing_from(value: &Natural) -> (usize, bool)

Converts a Natural to a usize, wrapping modulo $2^W$, where $W$ is the width of a limb.

The returned boolean value indicates whether wrapping occurred.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> OverflowingFrom<&'a Natural> for u8

fn overflowing_from(value: &Natural) -> (u8, bool)

Converts a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

The returned boolean value indicates whether wrapping occurred.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> OverflowingFrom<&'a Natural> for u128

fn overflowing_from(value: &Natural) -> (u128, bool)

Converts a Natural to a value of an unsigned primitive integer type that’s larger than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

The returned boolean value indicates whether wrapping occurred.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> OverflowingFrom<&'a Natural> for isize

fn overflowing_from(value: &Natural) -> (isize, bool)

Converts a Natural to an isize or a value of a signed primitive integer type that’s larger than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

The returned boolean value indicates whether wrapping occurred.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> OverflowingFrom<&'a Natural> for i8

fn overflowing_from(value: &Natural) -> (i8, bool)

Converts a Natural to a value of a signed primitive integer type that’s smaller than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

The returned boolean value indicates whether wrapping occurred.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> OverflowingFrom<&'a Natural> for u16

fn overflowing_from(value: &Natural) -> (u16, bool)

Converts a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

The returned boolean value indicates whether wrapping occurred.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> OverflowingFrom<&'a Natural> for i16

fn overflowing_from(value: &Natural) -> (i16, bool)

Converts a Natural to a value of a signed primitive integer type that’s smaller than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

The returned boolean value indicates whether wrapping occurred.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> OverflowingFrom<&'a Natural> for u32

fn overflowing_from(value: &Natural) -> (u32, bool)

Converts a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

The returned boolean value indicates whether wrapping occurred.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> OverflowingFrom<&'a Natural> for i32

fn overflowing_from(value: &Natural) -> (i32, bool)

Converts a Natural to a value of a signed primitive integer type that’s smaller than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

The returned boolean value indicates whether wrapping occurred.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> OverflowingFrom<&'a Natural> for u64

fn overflowing_from(value: &Natural) -> (u64, bool)

Converts a Natural to a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

The returned boolean value indicates whether wrapping occurred.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> OverflowingFrom<&'a Natural> for i64

fn overflowing_from(value: &Natural) -> (i64, bool)

Converts a Natural to a SignedLimb (the signed type whose width is the same as a limb’s), wrapping modulo $2^W$, where $W$ is the width of a limb.

The returned boolean value indicates whether wrapping occurred.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> OverflowingFrom<&'a Natural> for i128

fn overflowing_from(value: &Natural) -> (i128, bool)

Converts a Natural to an isize or a value of a signed primitive integer type that’s larger than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

The returned boolean value indicates whether wrapping occurred.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> Parity for &'a Natural

fn even(self) -> bool

Tests whether a Natural is even.

$f(x) = (2|x)$.

$f(x) = (\exists k \in \N : x = 2k)$.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Parity, Pow};
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.even(), true);
assert_eq!(Natural::from(123u32).even(), false);
assert_eq!(Natural::from(0x80u32).even(), true);
assert_eq!(Natural::from(10u32).pow(12).even(), true);
assert_eq!((Natural::from(10u32).pow(12) + Natural::ONE).even(), false);

fn odd(self) -> bool

Tests whether a Natural is odd.

$f(x) = (2\nmid x)$.

$f(x) = (\exists k \in \N : x = 2k+1)$.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Parity, Pow};
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.odd(), false);
assert_eq!(Natural::from(123u32).odd(), true);
assert_eq!(Natural::from(0x80u32).odd(), false);
assert_eq!(Natural::from(10u32).pow(12).odd(), false);
assert_eq!((Natural::from(10u32).pow(12) + Natural::ONE).odd(), true);

impl PartialEq<Integer> for Natural

fn eq(&self, other: &Integer) -> bool

Determines whether a Natural is equal to an Integer.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where n = min(self.significant_bits(), other.significant_bits())

Examples

use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert!(Natural::from(123u32) == Integer::from(123));
assert!(Natural::from(123u32) != Integer::from(5));

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Natural> for Natural

fn eq(&self, other: &Natural) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Natural) -> bool

This method tests for !=.

impl PartialEq<Natural> for f32

fn eq(&self, other: &Natural) -> bool

Determines whether a primitive float 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 other.significant_bits().

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Natural> for i16

fn eq(&self, other: &Natural) -> bool

Determines whether a signed primitive integer is equal to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Natural> for i32

fn eq(&self, other: &Natural) -> bool

Determines whether a signed primitive integer is equal to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Natural> for i64

fn eq(&self, other: &Natural) -> bool

Determines whether a signed primitive integer is equal to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Natural> for i128

fn eq(&self, other: &Natural) -> bool

Determines whether a signed primitive integer is equal to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Natural> for isize

fn eq(&self, other: &Natural) -> bool

Determines whether a signed primitive integer is equal to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Natural> for Integer

fn eq(&self, other: &Natural) -> bool

Determines whether an Integer is equal to a Natural.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where n = min(self.significant_bits(), other.significant_bits())

Examples

use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert!(Integer::from(123) == Natural::from(123u32));
assert!(Integer::from(123) != Natural::from(5u32));

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Natural> for f64

fn eq(&self, other: &Natural) -> bool

Determines whether a primitive float 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 other.significant_bits().

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Natural> for u8

fn eq(&self, other: &Natural) -> bool

Determines whether a value of an unsigned primitive integer type that’s smaller than a Limb is equal to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Natural> for u16

fn eq(&self, other: &Natural) -> bool

Determines whether a value of an unsigned primitive integer type that’s smaller than a Limb is equal to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Natural> for u32

fn eq(&self, other: &Natural) -> bool

Determines whether a value of an unsigned primitive integer type that’s smaller than a Limb is equal to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Natural> for u64

fn eq(&self, other: &Natural) -> bool

Determines whether a Limb is equal to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Natural> for u128

fn eq(&self, other: &Natural) -> bool

Determines whether a value of an unsigned primitive integer type that’s larger than a Limb is equal to a Natural.

This implementation is general enough to also work for usize, regardless of whether it is equal in width to Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Natural> for usize

fn eq(&self, other: &Natural) -> bool

Determines whether a value of an unsigned primitive integer type that’s larger than a Limb is equal to a Natural.

This implementation is general enough to also work for usize, regardless of whether it is equal in width to Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<Natural> for i8

fn eq(&self, other: &Natural) -> bool

Determines whether a signed primitive integer is equal to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<f32> for Natural

fn eq(&self, other: &f32) -> bool

Determines whether a Natural is equal to a primitive float.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<f64> for Natural

fn eq(&self, other: &f64) -> bool

Determines whether a Natural is equal to a primitive float.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<i128> for Natural

fn eq(&self, other: &i128) -> bool

Determines whether a Natural is equal to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<i16> for Natural

fn eq(&self, other: &i16) -> bool

Determines whether a Natural is equal to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<i32> for Natural

fn eq(&self, other: &i32) -> bool

Determines whether a Natural is equal to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<i64> for Natural

fn eq(&self, other: &i64) -> bool

Determines whether a Natural is equal to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<i8> for Natural

fn eq(&self, other: &i8) -> bool

Determines whether a Natural is equal to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<isize> for Natural

fn eq(&self, other: &isize) -> bool

Determines whether a Natural is equal to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<u128> for Natural

fn eq(&self, other: &u128) -> bool

Determines whether a Natural is equal to a value of an unsigned primitive integer type that’s larger than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<u16> for Natural

fn eq(&self, other: &u16) -> bool

Determines whether a Natural is equal to a value of an unsigned primitive integer type that’s smaller than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<u32> for Natural

fn eq(&self, other: &u32) -> bool

Determines whether a Natural is equal to a value of an unsigned primitive integer type that’s smaller than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<u64> for Natural

fn eq(&self, other: &u64) -> bool

Determines whether a Natural is equal to a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<u8> for Natural

fn eq(&self, other: &u8) -> bool

Determines whether a Natural is equal to a value of an unsigned primitive integer type that’s smaller than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<usize> for Natural

fn eq(&self, other: &usize) -> bool

Determines whether a Natural is equal to a usize.

Worst-case complexity

Constant time and additional memory.

See here.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<Integer> for Natural

fn partial_cmp(&self, other: &Integer) -> Option<Ordering>

Compares a Natural to an Integer.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where n = min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert!(Natural::from(123u32) > Integer::from(122));
assert!(Natural::from(123u32) >= Integer::from(122));
assert!(Natural::from(123u32) < Integer::from(124));
assert!(Natural::from(123u32) <= Integer::from(124));
assert!(Natural::from(123u32) > Integer::from(-123));
assert!(Natural::from(123u32) >= Integer::from(-123));

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for Natural

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares two Naturals.

See the documentation for the Ord implementation.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for f32

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares a primitive float 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 other.significant_bits().

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for i16

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares a signed primitive integer to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for i32

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares a signed primitive integer to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for i64

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares a signed primitive integer to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for i128

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares a signed primitive integer to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for isize

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares a signed primitive integer to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for Integer

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares an Integer to a Natural.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where n = min(self.significant_bits(), other.significant_bits()).

Examples

use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert!(Integer::from(123) > Natural::from(122u32));
assert!(Integer::from(123) >= Natural::from(122u32));
assert!(Integer::from(123) < Natural::from(124u32));
assert!(Integer::from(123) <= Natural::from(124u32));
assert!(Integer::from(-123) < Natural::from(123u32));
assert!(Integer::from(-123) <= Natural::from(123u32));

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for f64

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares a primitive float 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 other.significant_bits().

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for u8

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares a value of an unsigned primitive integer type that’s smaller than a Limb to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for u16

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares a value of an unsigned primitive integer type that’s smaller than a Limb to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for u32

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares a value of an unsigned primitive integer type that’s smaller than a Limb to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for u64

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares a Limb to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for u128

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares a value of an unsigned primitive integer type that’s larger than a Limb to a Natural. This implementation is general enough to also work for usize, regardless of whether it is equal in width to Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for usize

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares a value of an unsigned primitive integer type that’s larger than a Limb to a Natural. This implementation is general enough to also work for usize, regardless of whether it is equal in width to Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<Natural> for i8

fn partial_cmp(&self, other: &Natural) -> Option<Ordering>

Compares a signed primitive integer to a Natural.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<f32> for Natural

fn partial_cmp(&self, other: &f32) -> Option<Ordering>

Compares a Natural to a primitive float.

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().

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<f64> for Natural

fn partial_cmp(&self, other: &f64) -> Option<Ordering>

Compares a Natural to a primitive float.

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().

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i128> for Natural

fn partial_cmp(&self, other: &i128) -> Option<Ordering>

Compares a Natural to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i16> for Natural

fn partial_cmp(&self, other: &i16) -> Option<Ordering>

Compares a Natural to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i32> for Natural

fn partial_cmp(&self, other: &i32) -> Option<Ordering>

Compares a Natural to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i64> for Natural

fn partial_cmp(&self, other: &i64) -> Option<Ordering>

Compares a Natural to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<i8> for Natural

fn partial_cmp(&self, other: &i8) -> Option<Ordering>

Compares a Natural to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<isize> for Natural

fn partial_cmp(&self, other: &isize) -> Option<Ordering>

Compares a Natural to a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u128> for Natural

fn partial_cmp(&self, other: &u128) -> Option<Ordering>

Compares a Natural to a value of an unsigned primitive integer type that’s larger than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u16> for Natural

fn partial_cmp(&self, other: &u16) -> Option<Ordering>

Compares a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u32> for Natural

fn partial_cmp(&self, other: &u32) -> Option<Ordering>

Compares a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u64> for Natural

fn partial_cmp(&self, other: &u64) -> Option<Ordering>

Compares a Natural to a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<u8> for Natural

fn partial_cmp(&self, other: &u8) -> Option<Ordering>

Compares a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrd<usize> for Natural

fn partial_cmp(&self, other: &usize) -> Option<Ordering>

Compares a Natural to a usize.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl PartialOrdAbs<Integer> for Natural

fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>

Compares the absolute values of a Natural and an Integer.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

extern crate malachite_base;

use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert!(Natural::from(123u32).gt_abs(&Integer::from(122)));
assert!(Natural::from(123u32).ge_abs(&Integer::from(122)));
assert!(Natural::from(123u32).lt_abs(&Integer::from(124)));
assert!(Natural::from(123u32).le_abs(&Integer::from(124)));
assert!(Natural::from(123u32).lt_abs(&Integer::from(-124)));
assert!(Natural::from(123u32).le_abs(&Integer::from(-124)));

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for f32

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares the absolute value of a primitive float 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 other.significant_bits().

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for f64

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares the absolute value of a primitive float 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 other.significant_bits().

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for i32

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares the absolute value of a signed primitive integer to a Natural.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for i64

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares the absolute value of a signed primitive integer to a Natural.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for i128

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares the absolute value of a signed primitive integer to a Natural.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for isize

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares the absolute value of a signed primitive integer to a Natural.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for Integer

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares the absolute values of an Integer and a Natural.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is min(self.significant_bits(), other.significant_bits()).

Examples

extern crate malachite_base;

use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert!(Integer::from(123).gt_abs(&Natural::from(122u32)));
assert!(Integer::from(123).ge_abs(&Natural::from(122u32)));
assert!(Integer::from(123).lt_abs(&Natural::from(124u32)));
assert!(Integer::from(123).le_abs(&Natural::from(124u32)));
assert!(Integer::from(-124).gt_abs(&Natural::from(123u32)));
assert!(Integer::from(-124).ge_abs(&Natural::from(123u32)));

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for u8

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares a value of unsigned primitive integer type to a Natural.

Since both values are non-negative, this is the same as ordinary partial_cmp.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for u16

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares a value of unsigned primitive integer type to a Natural.

Since both values are non-negative, this is the same as ordinary partial_cmp.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for u32

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares a value of unsigned primitive integer type to a Natural.

Since both values are non-negative, this is the same as ordinary partial_cmp.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for u64

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares a value of unsigned primitive integer type to a Natural.

Since both values are non-negative, this is the same as ordinary partial_cmp.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for u128

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares a value of unsigned primitive integer type to a Natural.

Since both values are non-negative, this is the same as ordinary partial_cmp.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for usize

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares a value of unsigned primitive integer type to a Natural.

Since both values are non-negative, this is the same as ordinary partial_cmp.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for i8

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares the absolute value of a signed primitive integer to a Natural.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<Natural> for i16

fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>

Compares the absolute value of a signed primitive integer to a Natural.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<f32> for Natural

fn partial_cmp_abs(&self, other: &f32) -> Option<Ordering>

Compares a Natural to the absolute value of a primitive float.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<f64> for Natural

fn partial_cmp_abs(&self, other: &f64) -> Option<Ordering>

Compares a Natural to the absolute value of a primitive float.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<i128> for Natural

fn partial_cmp_abs(&self, other: &i128) -> Option<Ordering>

Compares a Natural to the absolute value of a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<i16> for Natural

fn partial_cmp_abs(&self, other: &i16) -> Option<Ordering>

Compares a Natural to the absolute value of a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<i32> for Natural

fn partial_cmp_abs(&self, other: &i32) -> Option<Ordering>

Compares a Natural to the absolute value of a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<i64> for Natural

fn partial_cmp_abs(&self, other: &i64) -> Option<Ordering>

Compares a Natural to the absolute value of a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<i8> for Natural

fn partial_cmp_abs(&self, other: &i8) -> Option<Ordering>

Compares a Natural to the absolute value of a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<isize> for Natural

fn partial_cmp_abs(&self, other: &isize) -> Option<Ordering>

Compares a Natural to the absolute value of a signed primitive integer.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<u128> for Natural

fn partial_cmp_abs(&self, other: &u128) -> Option<Ordering>

Compares a Natural to an unsigned primitive integer.

Since both values are non-negative, this is the same as ordinary partial_cmp.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<u16> for Natural

fn partial_cmp_abs(&self, other: &u16) -> Option<Ordering>

Compares a Natural to an unsigned primitive integer.

Since both values are non-negative, this is the same as ordinary partial_cmp.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<u32> for Natural

fn partial_cmp_abs(&self, other: &u32) -> Option<Ordering>

Compares a Natural to an unsigned primitive integer.

Since both values are non-negative, this is the same as ordinary partial_cmp.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<u64> for Natural

fn partial_cmp_abs(&self, other: &u64) -> Option<Ordering>

Compares a Natural to an unsigned primitive integer.

Since both values are non-negative, this is the same as ordinary partial_cmp.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<u8> for Natural

fn partial_cmp_abs(&self, other: &u8) -> Option<Ordering>

Compares a Natural to an unsigned primitive integer.

Since both values are non-negative, this is the same as ordinary partial_cmp.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl PartialOrdAbs<usize> for Natural

fn partial_cmp_abs(&self, other: &usize) -> Option<Ordering>

Compares a Natural to an unsigned primitive integer.

Since both values are non-negative, this is the same as ordinary partial_cmp.

Worst-case complexity

Constant time and additional memory.

See here.

fn lt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than the absolute value of another.

fn le_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is less than or equal to the absolute value of another.

fn gt_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than the absolute value of another.

fn ge_abs(&self, other: &Rhs) -> bool

Determines whether the absolute value of one number is greater than or equal to the absolute value of another.

impl Pow<u64> for Natural

fn pow(self, exp: u64) -> Natural

Raises a Natural to a power, taking the Natural by value.

$f(x, n) = x^n$.

Worst-case complexity

$T(n, m) = O(nm \log (nm) \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is exp.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    Natural::from(3u32).pow(100).to_string(),
    "515377520732011331036461129765621272702107522001"
);
assert_eq!(
    Natural::from_str("12345678987654321").unwrap().pow(3).to_string(),
    "1881676411868862234942354805142998028003108518161"
);

type Output = Natural

impl<'a> Pow<u64> for &'a Natural

fn pow(self, exp: u64) -> Natural

Raises a Natural to a power, taking the Natural by reference.

$f(x, n) = x^n$.

Worst-case complexity

$T(n, m) = O(nm \log (nm) \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is exp.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
    (&Natural::from(3u32)).pow(100).to_string(),
    "515377520732011331036461129765621272702107522001"
);
assert_eq!(
    (&Natural::from_str("12345678987654321").unwrap()).pow(3).to_string(),
    "1881676411868862234942354805142998028003108518161"
);

type Output = Natural

impl PowAssign<u64> for Natural

fn pow_assign(&mut self, exp: u64)

Raises a Natural to a power in place.

$x \gets x^n$.

Worst-case complexity

$T(n, m) = O(nm \log (nm) \log\log (nm))$

$M(n, m) = O(nm \log (nm))$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is exp.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::PowAssign;
use malachite_nz::natural::Natural;
use std::str::FromStr;

let mut x = Natural::from(3u32);
x.pow_assign(100);
assert_eq!(x.to_string(), "515377520732011331036461129765621272702107522001");

let mut x = Natural::from_str("12345678987654321").unwrap();
x.pow_assign(3);
assert_eq!(x.to_string(), "1881676411868862234942354805142998028003108518161");

impl PowerOf2<u64> for Natural

fn power_of_2(pow: u64) -> Natural

Raises 2 to an integer power.

$f(k) = 2^k$.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_nz::natural::Natural;

assert_eq!(Natural::power_of_2(0), 1);
assert_eq!(Natural::power_of_2(3), 8);
assert_eq!(Natural::power_of_2(100).to_string(), "1267650600228229401496703205376");

impl<'a> PowerOf2DigitIterable<Natural> for &'a Natural

fn power_of_2_digits(self, log_base: u64) -> NaturalPowerOf2DigitIterator<'a>

Returns a double-ended iterator over the base-$2^k$ digits of a Natural.

The base-2 logarithm of the base is specified. The type of each digit is Natural. The forward order is ascending, so that less significant digits appear first. There are no trailing zero digits going forward, or leading zero digits going backward.

If it’s necessary to get a Vec of all the digits, consider using to_power_of_2_digits_asc or to_power_of_2_digits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate itertools;
extern crate malachite_base;

use itertools::Itertools;
use malachite_base::num::basic::traits::Zero;
use malachite_base::num::conversion::traits::PowerOf2DigitIterable;
use malachite_nz::natural::Natural;

let n = Natural::ZERO;
assert!(PowerOf2DigitIterable::<Natural>::power_of_2_digits(&n, 2).next().is_none());

// 107 = 1223_4
let n = Natural::from(107u32);
assert_eq!(
    PowerOf2DigitIterable::<Natural>::power_of_2_digits(&n, 2).collect_vec(),
    vec![
        Natural::from(3u32),
        Natural::from(2u32),
        Natural::from(2u32),
        Natural::from(1u32)
    ]
);

let n = Natural::ZERO;
assert!(PowerOf2DigitIterable::<Natural>::power_of_2_digits(&n, 2)
    .next_back()
    .is_none());

// 107 = 1223_4
let n = Natural::from(107u32);
assert_eq!(
    PowerOf2DigitIterable::<Natural>::power_of_2_digits(&n, 2)
        .rev()
        .collect_vec(),
    vec![
        Natural::from(1u32),
        Natural::from(2u32),
        Natural::from(2u32),
        Natural::from(3u32)
    ]
);

type PowerOf2DigitIterator = NaturalPowerOf2DigitIterator<'a>

impl<'a> PowerOf2DigitIterable<u128> for &'a Natural

fn power_of_2_digits(
    self,
    log_base: u64
) -> NaturalPowerOf2DigitPrimitiveIterator<'a, u128>

Returns a double-ended iterator over the base-$2^k$ digits of a Natural.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. The forward order is ascending, so that less significant digits appear first. There are no trailing zero digits going forward, or leading zero digits going backward.

If it’s necessary to get a Vec of all the digits, consider using to_power_of_2_digits_asc or to_power_of_2_digits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type PowerOf2DigitIterator = NaturalPowerOf2DigitPrimitiveIterator<'a, u128>

impl<'a> PowerOf2DigitIterable<u16> for &'a Natural

fn power_of_2_digits(
    self,
    log_base: u64
) -> NaturalPowerOf2DigitPrimitiveIterator<'a, u16>

Returns a double-ended iterator over the base-$2^k$ digits of a Natural.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. The forward order is ascending, so that less significant digits appear first. There are no trailing zero digits going forward, or leading zero digits going backward.

If it’s necessary to get a Vec of all the digits, consider using to_power_of_2_digits_asc or to_power_of_2_digits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type PowerOf2DigitIterator = NaturalPowerOf2DigitPrimitiveIterator<'a, u16>

impl<'a> PowerOf2DigitIterable<u32> for &'a Natural

fn power_of_2_digits(
    self,
    log_base: u64
) -> NaturalPowerOf2DigitPrimitiveIterator<'a, u32>

Returns a double-ended iterator over the base-$2^k$ digits of a Natural.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. The forward order is ascending, so that less significant digits appear first. There are no trailing zero digits going forward, or leading zero digits going backward.

If it’s necessary to get a Vec of all the digits, consider using to_power_of_2_digits_asc or to_power_of_2_digits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type PowerOf2DigitIterator = NaturalPowerOf2DigitPrimitiveIterator<'a, u32>

impl<'a> PowerOf2DigitIterable<u64> for &'a Natural

fn power_of_2_digits(
    self,
    log_base: u64
) -> NaturalPowerOf2DigitPrimitiveIterator<'a, u64>

Returns a double-ended iterator over the base-$2^k$ digits of a Natural.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. The forward order is ascending, so that less significant digits appear first. There are no trailing zero digits going forward, or leading zero digits going backward.

If it’s necessary to get a Vec of all the digits, consider using to_power_of_2_digits_asc or to_power_of_2_digits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type PowerOf2DigitIterator = NaturalPowerOf2DigitPrimitiveIterator<'a, u64>

impl<'a> PowerOf2DigitIterable<u8> for &'a Natural

fn power_of_2_digits(
    self,
    log_base: u64
) -> NaturalPowerOf2DigitPrimitiveIterator<'a, u8>

Returns a double-ended iterator over the base-$2^k$ digits of a Natural.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. The forward order is ascending, so that less significant digits appear first. There are no trailing zero digits going forward, or leading zero digits going backward.

If it’s necessary to get a Vec of all the digits, consider using to_power_of_2_digits_asc or to_power_of_2_digits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type PowerOf2DigitIterator = NaturalPowerOf2DigitPrimitiveIterator<'a, u8>

impl<'a> PowerOf2DigitIterable<usize> for &'a Natural

fn power_of_2_digits(
    self,
    log_base: u64
) -> NaturalPowerOf2DigitPrimitiveIterator<'a, usize>

Returns a double-ended iterator over the base-$2^k$ digits of a Natural.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. The forward order is ascending, so that less significant digits appear first. There are no trailing zero digits going forward, or leading zero digits going backward.

If it’s necessary to get a Vec of all the digits, consider using to_power_of_2_digits_asc or to_power_of_2_digits_desc instead.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

type PowerOf2DigitIterator = NaturalPowerOf2DigitPrimitiveIterator<'a, usize>

impl<'a> PowerOf2DigitIterator<Natural> for NaturalPowerOf2DigitIterator<'a>

fn get(&self, index: u64) -> Natural

Retrieves the base-$2^k$ digits of a Natural by index.

$f(x, k, i) = d_i$, where $0 \leq d_i < 2^k$ for all $i$ and $$ \sum_{i=0}^\infty2^{ki}d_i = x. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is log_base.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_base::num::conversion::traits::{PowerOf2DigitIterable, PowerOf2DigitIterator};
use malachite_nz::natural::Natural;

let n = Natural::ZERO;
assert_eq!(PowerOf2DigitIterable::<Natural>::power_of_2_digits(&n, 2).get(0), 0);

// 107 = 1223_4
let n = Natural::from(107u32);
let digits = PowerOf2DigitIterable::<Natural>::power_of_2_digits(&n, 2);
assert_eq!(digits.get(0), 3);
assert_eq!(digits.get(1), 2);
assert_eq!(digits.get(2), 2);
assert_eq!(digits.get(3), 1);
assert_eq!(digits.get(4), 0);
assert_eq!(digits.get(100), 0);

impl PowerOf2Digits<Natural> for Natural

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<Natural>

Returns a Vec containing the base-$2^k$ digits of a Natural in ascending order: least- to most-significant.

The base-2 logarithm of the base is specified. The type of each digit is Natural. If the Natural is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = 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().

Panics

Panics if log_base is zero.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::{Two, Zero};
use malachite_base::num::conversion::traits::PowerOf2Digits;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!(
    PowerOf2Digits::<Natural>::to_power_of_2_digits_asc(&Natural::ZERO, 6)
            .to_debug_string(),
    "[]"
);
assert_eq!(
    PowerOf2Digits::<Natural>::to_power_of_2_digits_asc(&Natural::TWO, 6)
            .to_debug_string(),
    "[2]"
);

// 123_10 = 173_8
assert_eq!(
    PowerOf2Digits::<Natural>::to_power_of_2_digits_asc(&Natural::from(123u32), 3)
            .to_debug_string(),
    "[3, 7, 1]"
);

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<Natural>

Returns a Vec containing the base-$2^k$ digits of a Natural in descending order: most- to least-significant.

The base-2 logarithm of the base is specified. The type of each digit is Natural. If the Natural is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = 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().

Panics

Panics if log_base is zero.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::{Two, Zero};
use malachite_base::num::conversion::traits::PowerOf2Digits;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!(
    PowerOf2Digits::<Natural>::to_power_of_2_digits_desc(&Natural::ZERO, 6)
            .to_debug_string(),
    "[]"
);
assert_eq!(
    PowerOf2Digits::<Natural>::to_power_of_2_digits_desc(&Natural::TWO, 6)
            .to_debug_string(),
    "[2]"
);

// 123_10 = 173_8
assert_eq!(
    PowerOf2Digits::<Natural>::to_power_of_2_digits_desc(&Natural::from(123u32), 3)
            .to_debug_string(),
    "[1, 7, 3]"
);

fn from_power_of_2_digits_asc<I: Iterator<Item = Natural>>(
    log_base: u64,
    digits: I
) -> Option<Natural>

Converts an iterator of base-$2^k$ digits into a Natural.

The base-2 logarithm of the base is specified. The input digits are in ascending order: least- to most-significant. The type of each digit is Natural.

If some digit is greater than $2^k$, None is returned.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n, m) = O(nm)$

$M(n, m) = O(nm)$

where $T$ is time, $M$ is additional memory, $n$ is digits.count(), and $m$ is log_base.

Panics

Panics if log_base is zero.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::{One, Two, Zero};
use malachite_base::num::conversion::traits::PowerOf2Digits;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

let digits = &[Natural::ZERO, Natural::ZERO, Natural::ZERO];
assert_eq!(
    Natural::from_power_of_2_digits_asc(6, digits.iter().cloned()).to_debug_string(),
    "Some(0)"
);

let digits = &[Natural::TWO, Natural::ZERO];
assert_eq!(
    Natural::from_power_of_2_digits_asc(6, digits.iter().cloned()).to_debug_string(),
    "Some(2)"
);

let digits = &[Natural::from(3u32), Natural::from(7u32), Natural::ONE];
assert_eq!(
    Natural::from_power_of_2_digits_asc(3, digits.iter().cloned()).to_debug_string(),
    "Some(123)"
);

let digits = &[Natural::from(100u32)];
assert_eq!(
    Natural::from_power_of_2_digits_asc(3, digits.iter().cloned()).to_debug_string(),
    "None"
);

fn from_power_of_2_digits_desc<I: Iterator<Item = Natural>>(
    log_base: u64,
    digits: I
) -> Option<Natural>

Converts an iterator of base-$2^k$ digits into a Natural.

The base-2 logarithm of the base is specified. The input digits are in descending order: most- to least-significant. The type of each digit is Natural.

If some digit is greater than $2^k$, None is returned.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n, m) = O(nm)$

$M(n, m) = O(nm)$

where $T$ is time, $M$ is additional memory, $n$ is digits.count(), and $m$ is log_base.

Panics

Panics if log_base is zero.

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::{One, Two, Zero};
use malachite_base::num::conversion::traits::PowerOf2Digits;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

let digits = &[Natural::ZERO, Natural::ZERO, Natural::ZERO];
assert_eq!(
    Natural::from_power_of_2_digits_desc(6, digits.iter().cloned()).to_debug_string(),
    "Some(0)"
);

let digits = &[Natural::ZERO, Natural::TWO];
assert_eq!(
    Natural::from_power_of_2_digits_desc(6, digits.iter().cloned()).to_debug_string(),
    "Some(2)"
);

let digits = &[Natural::ONE, Natural::from(7u32), Natural::from(3u32)];
assert_eq!(
    Natural::from_power_of_2_digits_desc(3, digits.iter().cloned()).to_debug_string(),
    "Some(123)"
);

let digits = &[Natural::from(100u32)];
assert_eq!(
    Natural::from_power_of_2_digits_desc(3, digits.iter().cloned()).to_debug_string(),
    "None"
);

impl PowerOf2Digits<u128> for Natural

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u128>

Returns a Vec containing the base-$2^k$ digits of a Natural in ascending order: least- to most-significant.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. If the Natural is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = 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().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u128>

Returns a Vec containing the base-$2^k$ digits of a Natural in descending order: most- to least-significant.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. If the Natural is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = 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().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u128>>(
    log_base: u64,
    digits: I
) -> Option<Natural>

Converts an iterator of base-$2^k$ digits into a Natural.

The base-2 logarithm of the base is specified. The input digits are in ascending order: least- to most-significant. Each digit has primitive integer type, and log_base must be no larger than the width of that type.

If some digit is greater than $2^k$, None is returned.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is zero or greater than the width of the digit type.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u128>>(
    log_base: u64,
    digits: I
) -> Option<Natural>

Converts an iterator of base-$2^k$ digits into a Natural.

The base-2 logarithm of the base is specified. The input digits are in descending order: most- to least-significant. Each digit has primitive integer type, and log_base must be no larger than the width of that type.

If some digit is greater than $2^k$, None is returned.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is zero or greater than the width of the digit type.

Examples

See here.

impl PowerOf2Digits<u16> for Natural

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u16>

Returns a Vec containing the base-$2^k$ digits of a Natural in ascending order: least- to most-significant.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. If the Natural is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = 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().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u16>

Returns a Vec containing the base-$2^k$ digits of a Natural in descending order: most- to least-significant.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. If the Natural is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = 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().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u16>>(
    log_base: u64,
    digits: I
) -> Option<Natural>

Converts an iterator of base-$2^k$ digits into a Natural.

The base-2 logarithm of the base is specified. The input digits are in ascending order: least- to most-significant. Each digit has primitive integer type, and log_base must be no larger than the width of that type.

If some digit is greater than $2^k$, None is returned.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is zero or greater than the width of the digit type.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u16>>(
    log_base: u64,
    digits: I
) -> Option<Natural>

Converts an iterator of base-$2^k$ digits into a Natural.

The base-2 logarithm of the base is specified. The input digits are in descending order: most- to least-significant. Each digit has primitive integer type, and log_base must be no larger than the width of that type.

If some digit is greater than $2^k$, None is returned.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is zero or greater than the width of the digit type.

Examples

See here.

impl PowerOf2Digits<u32> for Natural

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u32>

Returns a Vec containing the base-$2^k$ digits of a Natural in ascending order: least- to most-significant.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. If the Natural is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = 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().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u32>

Returns a Vec containing the base-$2^k$ digits of a Natural in descending order: most- to least-significant.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. If the Natural is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = 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().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u32>>(
    log_base: u64,
    digits: I
) -> Option<Natural>

Converts an iterator of base-$2^k$ digits into a Natural.

The base-2 logarithm of the base is specified. The input digits are in ascending order: least- to most-significant. Each digit has primitive integer type, and log_base must be no larger than the width of that type.

If some digit is greater than $2^k$, None is returned.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is zero or greater than the width of the digit type.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u32>>(
    log_base: u64,
    digits: I
) -> Option<Natural>

Converts an iterator of base-$2^k$ digits into a Natural.

The base-2 logarithm of the base is specified. The input digits are in descending order: most- to least-significant. Each digit has primitive integer type, and log_base must be no larger than the width of that type.

If some digit is greater than $2^k$, None is returned.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is zero or greater than the width of the digit type.

Examples

See here.

impl PowerOf2Digits<u64> for Natural

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u64>

Returns a Vec containing the base-$2^k$ digits of a Natural in ascending order: least- to most-significant.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. If the Natural is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = 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().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u64>

Returns a Vec containing the base-$2^k$ digits of a Natural in descending order: most- to least-significant.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. If the Natural is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = 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().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u64>>(
    log_base: u64,
    digits: I
) -> Option<Natural>

Converts an iterator of base-$2^k$ digits into a Natural.

The base-2 logarithm of the base is specified. The input digits are in ascending order: least- to most-significant. Each digit has primitive integer type, and log_base must be no larger than the width of that type.

If some digit is greater than $2^k$, None is returned.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is zero or greater than the width of the digit type.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u64>>(
    log_base: u64,
    digits: I
) -> Option<Natural>

Converts an iterator of base-$2^k$ digits into a Natural.

The base-2 logarithm of the base is specified. The input digits are in descending order: most- to least-significant. Each digit has primitive integer type, and log_base must be no larger than the width of that type.

If some digit is greater than $2^k$, None is returned.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is zero or greater than the width of the digit type.

Examples

See here.

impl PowerOf2Digits<u8> for Natural

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<u8>

Returns a Vec containing the base-$2^k$ digits of a Natural in ascending order: least- to most-significant.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. If the Natural is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = 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().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<u8>

Returns a Vec containing the base-$2^k$ digits of a Natural in descending order: most- to least-significant.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. If the Natural is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = 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().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = u8>>(
    log_base: u64,
    digits: I
) -> Option<Natural>

Converts an iterator of base-$2^k$ digits into a Natural.

The base-2 logarithm of the base is specified. The input digits are in ascending order: least- to most-significant. Each digit has primitive integer type, and log_base must be no larger than the width of that type.

If some digit is greater than $2^k$, None is returned.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is zero or greater than the width of the digit type.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = u8>>(
    log_base: u64,
    digits: I
) -> Option<Natural>

Converts an iterator of base-$2^k$ digits into a Natural.

The base-2 logarithm of the base is specified. The input digits are in descending order: most- to least-significant. Each digit has primitive integer type, and log_base must be no larger than the width of that type.

If some digit is greater than $2^k$, None is returned.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is zero or greater than the width of the digit type.

Examples

See here.

impl PowerOf2Digits<usize> for Natural

fn to_power_of_2_digits_asc(&self, log_base: u64) -> Vec<usize>

Returns a Vec containing the base-$2^k$ digits of a Natural in ascending order: least- to most-significant.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. If the Natural is 0, the Vec is empty; otherwise, it ends with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_{n-1} \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{ki}d_i = 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().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn to_power_of_2_digits_desc(&self, log_base: u64) -> Vec<usize>

Returns a Vec containing the base-$2^k$ digits of a Natural in descending order: most- to least-significant.

The base-2 logarithm of the base is specified. Each digit has primitive integer type, and log_base must be no larger than the width of that type. If the Natural is 0, the Vec is empty; otherwise, it begins with a nonzero digit.

$f(x, k) = (d_i)_ {i=0}^{n-1}$, where $0 \leq d_i < 2^k$ for all $i$, $n=0$ or $d_0 \neq 0$, and

$$ \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i = 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().

Panics

Panics if log_base is greater than the width of the digit type, or if log_base is zero.

Examples

See here.

fn from_power_of_2_digits_asc<I: Iterator<Item = usize>>(
    log_base: u64,
    digits: I
) -> Option<Natural>

Converts an iterator of base-$2^k$ digits into a Natural.

The base-2 logarithm of the base is specified. The input digits are in ascending order: least- to most-significant. Each digit has primitive integer type, and log_base must be no larger than the width of that type.

If some digit is greater than $2^k$, None is returned.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{ki}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is zero or greater than the width of the digit type.

Examples

See here.

fn from_power_of_2_digits_desc<I: Iterator<Item = usize>>(
    log_base: u64,
    digits: I
) -> Option<Natural>

Converts an iterator of base-$2^k$ digits into a Natural.

The base-2 logarithm of the base is specified. The input digits are in descending order: most- to least-significant. Each digit has primitive integer type, and log_base must be no larger than the width of that type.

If some digit is greater than $2^k$, None is returned.

$$ f((d_i)_ {i=0}^{n-1}, k) = \sum_{i=0}^{n-1}2^{k (n-i-1)}d_i. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is digits.count().

Panics

Panics if log_base is zero or greater than the width of the digit type.

Examples

See here.

impl<'a> Rem<&'a Natural> for Natural

fn rem(self, other: &'a Natural) -> Natural

Divides a Natural by another Natural, taking the first by value and the second by reference and returning just the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor. $$

For Naturals, rem is equivalent to mod_op.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(Natural::from(23u32) % &Natural::from(10u32), 3);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    Natural::from_str("1000000000000000000000000").unwrap() %
            &Natural::from_str("1234567890987").unwrap(),
    530068894399u64
);

type Output = Natural

The resulting type after applying the % operator.

impl<'a, 'b> Rem<&'b Natural> for &'a Natural

fn rem(self, other: &'b Natural) -> Natural

Divides a Natural by another Natural, taking both by reference and returning just the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor. $$

For Naturals, rem is equivalent to mod_op.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(&Natural::from(23u32) % &Natural::from(10u32), 3);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    &Natural::from_str("1000000000000000000000000").unwrap() %
            &Natural::from_str("1234567890987").unwrap(),
    530068894399u64
);

type Output = Natural

The resulting type after applying the % operator.

impl Rem<Natural> for Natural

fn rem(self, other: Natural) -> Natural

Divides a Natural by another Natural, taking both by value and returning just the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor. $$

For Naturals, rem is equivalent to mod_op.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(Natural::from(23u32) % Natural::from(10u32), 3);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    Natural::from_str("1000000000000000000000000").unwrap() %
            Natural::from_str("1234567890987").unwrap(),
    530068894399u64
);

type Output = Natural

The resulting type after applying the % operator.

impl<'a> Rem<Natural> for &'a Natural

fn rem(self, other: Natural) -> Natural

Divides a Natural by another Natural, taking the first by reference and the second by value and returning just the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq r < y$.

$$ f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor. $$

For Naturals, rem is equivalent to mod_op.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
assert_eq!(&Natural::from(23u32) % Natural::from(10u32), 3);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
assert_eq!(
    &Natural::from_str("1000000000000000000000000").unwrap() %
            Natural::from_str("1234567890987").unwrap(),
    530068894399u64
);

type Output = Natural

The resulting type after applying the % operator.

impl<'a> RemAssign<&'a Natural> for Natural

fn rem_assign(&mut self, other: &'a Natural)

Divides a Natural by another Natural, taking the second Natural by reference and replacing the first by the remainder.

If the quotient were computed, he quotient and remainder would satisfy $x = qy + r$ and $0 \leq r < y$.

$$ x \gets x - y\left \lfloor \frac{x}{y} \right \rfloor. $$

For Naturals, rem_assign is equivalent to mod_assign.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
let mut x = Natural::from(23u32);
x %= &Natural::from(10u32);
assert_eq!(x, 3);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
let mut x = Natural::from_str("1000000000000000000000000").unwrap();
x %= &Natural::from_str("1234567890987").unwrap();
assert_eq!(x, 530068894399u64);

impl RemAssign<Natural> for Natural

fn rem_assign(&mut self, other: Natural)

Divides a Natural by another Natural, taking the second Natural by value and replacing the first by the remainder.

If the quotient were computed, he quotient and remainder would satisfy $x = qy + r$ and $0 \leq r < y$.

$$ x \gets x - y\left \lfloor \frac{x}{y} \right \rfloor. $$

For Naturals, rem_assign is equivalent to mod_assign.

Worst-case complexity

$T(n) = 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 other is zero.

Examples

extern crate malachite_base;

use malachite_nz::natural::Natural;
use std::str::FromStr;

// 2 * 10 + 3 = 23
let mut x = Natural::from(23u32);
x %= Natural::from(10u32);
assert_eq!(x, 3);

// 810000006723 * 1234567890987 + 530068894399 = 1000000000000000000000000
let mut x = Natural::from_str("1000000000000000000000000").unwrap();
x %= Natural::from_str("1234567890987").unwrap();
assert_eq!(x, 530068894399u64);

impl RemPowerOf2 for Natural

fn rem_power_of_2(self, pow: u64) -> Natural

Divides a Natural by $2^k$, returning just the remainder. The Natural is taken by value.

If the quotient were computed, the quotient and remainder would satisfy $x = q2^k + r$ and $0 \leq r < 2^k$.

$$ f(x, k) = x - 2^k\left \lfloor \frac{x}{2^k} \right \rfloor. $$

For Naturals, rem_power_of_2 is equivalent to mod_power_of_2.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RemPowerOf2;
use malachite_nz::natural::Natural;

// 1 * 2^8 + 4 = 260
assert_eq!(Natural::from(260u32).rem_power_of_2(8), 4);

// 100 * 2^4 + 11 = 1611
assert_eq!(Natural::from(1611u32).rem_power_of_2(4), 11);

type Output = Natural

impl<'a> RemPowerOf2 for &'a Natural

fn rem_power_of_2(self, pow: u64) -> Natural

Divides a Natural by $2^k$, returning just the remainder. The Natural is taken by reference.

If the quotient were computed, the quotient and remainder would satisfy $x = q2^k + r$ and $0 \leq r < 2^k$.

$$ f(x, k) = x - 2^k\left \lfloor \frac{x}{2^k} \right \rfloor. $$

For Naturals, rem_power_of_2 is equivalent to mod_power_of_2.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is pow.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RemPowerOf2;
use malachite_nz::natural::Natural;

// 1 * 2^8 + 4 = 260
assert_eq!((&Natural::from(260u32)).rem_power_of_2(8), 4);
// 100 * 2^4 + 11 = 1611
assert_eq!((&Natural::from(1611u32)).rem_power_of_2(4), 11);

type Output = Natural

impl RemPowerOf2Assign for Natural

fn rem_power_of_2_assign(&mut self, pow: u64)

Divides a Natural by $2^k$, replacing the first Natural by the remainder.

If the quotient were computed, the quotient and remainder would satisfy $x = q2^k + r$ and $0 \leq r < 2^k$.

$$ x \gets x - 2^k\left \lfloor \frac{x}{2^k} \right \rfloor. $$

For Naturals, rem_power_of_2_assign is equivalent to mod_power_of_2_assign.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RemPowerOf2Assign;
use malachite_nz::natural::Natural;

// 1 * 2^8 + 4 = 260
let mut x = Natural::from(260u32);
x.rem_power_of_2_assign(8);
assert_eq!(x, 4);

// 100 * 2^4 + 11 = 1611
let mut x = Natural::from(1611u32);
x.rem_power_of_2_assign(4);
assert_eq!(x, 11);

impl RootAssignRem<u64> for Natural

fn root_assign_rem(&mut self, exp: u64) -> Natural

Replaces a Natural with the floor of its $n$th root, and returns the remainder (the difference between the original Natural and the $n$th power of the floor).

$f(x, n) = x - \lfloor\sqrt[n]{x}\rfloor^n$,

$x \gets \lfloor\sqrt[n]{x}\rfloor$.

Worst-case complexity

$T(n) = O(n (\log n)^2 \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RootAssignRem;
use malachite_nz::natural::Natural;

let mut x = Natural::from(999u16);
assert_eq!(x.root_assign_rem(3), 270);
assert_eq!(x, 9);

let mut x = Natural::from(1000u16);
assert_eq!(x.root_assign_rem(3), 0);
assert_eq!(x, 10);

let mut x = Natural::from(1001u16);
assert_eq!(x.root_assign_rem(3), 1);
assert_eq!(x, 10);

let mut x = Natural::from(100000000000u64);
assert_eq!(x.root_assign_rem(5), 1534195232);
assert_eq!(x, 158);

type RemOutput = Natural

impl RootRem<u64> for Natural

fn root_rem(self, exp: u64) -> (Natural, Natural)

Returns the floor of the $n$th root of a Natural, and the remainder (the difference between the Natural and the $n$th power of the floor). The Natural is taken by value.

$f(x, n) = (\lfloor\sqrt[n]{x}\rfloor, x - \lfloor\sqrt[n]{x}\rfloor^n)$.

Worst-case complexity

$T(n) = O(n (\log n)^2 \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RootRem;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(999u16).root_rem(3).to_debug_string(), "(9, 270)");
assert_eq!(Natural::from(1000u16).root_rem(3).to_debug_string(), "(10, 0)");
assert_eq!(Natural::from(1001u16).root_rem(3).to_debug_string(), "(10, 1)");
assert_eq!(
    Natural::from(100000000000u64).root_rem(5).to_debug_string(),
    "(158, 1534195232)"
);

type RootOutput = Natural

type RemOutput = Natural

impl<'a> RootRem<u64> for &'a Natural

fn root_rem(self, exp: u64) -> (Natural, Natural)

Returns the floor of the $n$th root of a Natural, and the remainder (the difference between the Natural and the $n$th power of the floor). The Natural is taken by reference.

$f(x, n) = (\lfloor\sqrt[n]{x}\rfloor, x - \lfloor\sqrt[n]{x}\rfloor^n)$.

Worst-case complexity

$T(n) = O(n (\log n)^2 \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RootRem;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(999u16)).root_rem(3).to_debug_string(), "(9, 270)");
assert_eq!((&Natural::from(1000u16)).root_rem(3).to_debug_string(), "(10, 0)");
assert_eq!((&Natural::from(1001u16)).root_rem(3).to_debug_string(), "(10, 1)");
assert_eq!(
    (&Natural::from(100000000000u64)).root_rem(5).to_debug_string(),
    "(158, 1534195232)"
);

type RootOutput = Natural

type RemOutput = Natural

impl<'a> RoundToMultiple<&'a Natural> for Natural

fn round_to_multiple(self, other: &'a Natural, rm: RoundingMode) -> Natural

Rounds a Natural to a multiple of another Natural, according to a specified rounding mode. The first Natural is taken by value and the second by reference.

Let $q = \frac{x}{y}$:

$f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = y \lfloor q \rfloor.$

$f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = y \lceil q \rceil.$

$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, y, \mathrm{Exact}) = x$, but panics if $q \notin \N$.

The following two expressions are equivalent:

• x.round_to_multiple(other, RoundingMode::Exact)
• { assert!(x.divisible_by(other)); x }

but the latter should be used as it is clearer and more efficient.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

• If rm is Exact, but self is not a multiple of other.
• If self is nonzero, other is zero, and rm is trying to round away from zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(5u32).round_to_multiple(&Natural::ZERO, RoundingMode::Down), 0);

assert_eq!(
    Natural::from(10u32).round_to_multiple(&Natural::from(4u32), RoundingMode::Down),
    8
);
assert_eq!(
    Natural::from(10u32).round_to_multiple(&Natural::from(4u32), RoundingMode::Up),
    12
);
assert_eq!(
    Natural::from(10u32).round_to_multiple(&Natural::from(5u32), RoundingMode::Exact),
    10
);
assert_eq!(
    Natural::from(10u32).round_to_multiple(&Natural::from(3u32), RoundingMode::Nearest),
    9
);
assert_eq!(
    Natural::from(20u32).round_to_multiple(&Natural::from(3u32), RoundingMode::Nearest),
    21
);
assert_eq!(
    Natural::from(10u32).round_to_multiple(&Natural::from(4u32), RoundingMode::Nearest),
    8
);
assert_eq!(
    Natural::from(14u32).round_to_multiple(&Natural::from(4u32), RoundingMode::Nearest),
    16
);

type Output = Natural

impl<'a, 'b> RoundToMultiple<&'b Natural> for &'a Natural

fn round_to_multiple(self, other: &'b Natural, rm: RoundingMode) -> Natural

Rounds a Natural to a multiple of another Natural, according to a specified rounding mode. Both Naturals are taken by reference.

Let $q = \frac{x}{y}$:

$f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = y \lfloor q \rfloor.$

$f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = y \lceil q \rceil.$

$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, y, \mathrm{Exact}) = x$, but panics if $q \notin \N$.

The following two expressions are equivalent:

• x.round_to_multiple(other, RoundingMode::Exact)
• { assert!(x.divisible_by(other)); x }

but the latter should be used as it is clearer and more efficient.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

• If rm is Exact, but self is not a multiple of other.
• If self is nonzero, other is zero, and rm is trying to round away from zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(5u32)).round_to_multiple(&Natural::ZERO, RoundingMode::Down), 0);

assert_eq!(
    (&Natural::from(10u32)).round_to_multiple(&Natural::from(4u32), RoundingMode::Down),
    8
);
assert_eq!(
    (&Natural::from(10u32)).round_to_multiple(&Natural::from(4u32), RoundingMode::Up),
    12
);
assert_eq!(
    (&Natural::from(10u32)).round_to_multiple(&Natural::from(5u32), RoundingMode::Exact),
    10
);
assert_eq!(
    (&Natural::from(10u32)).round_to_multiple(&Natural::from(3u32), RoundingMode::Nearest),
    9
);
assert_eq!(
    (&Natural::from(20u32)).round_to_multiple(&Natural::from(3u32), RoundingMode::Nearest),
    21
);
assert_eq!(
    (&Natural::from(10u32)).round_to_multiple(&Natural::from(4u32), RoundingMode::Nearest),
    8
);
assert_eq!(
    (&Natural::from(14u32)).round_to_multiple(&Natural::from(4u32), RoundingMode::Nearest),
    16
);

type Output = Natural

impl RoundToMultiple<Natural> for Natural

fn round_to_multiple(self, other: Natural, rm: RoundingMode) -> Natural

Rounds a Natural to a multiple of another Natural, according to a specified rounding mode. Both Naturals are taken by value.

Let $q = \frac{x}{y}$:

$f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = y \lfloor q \rfloor.$

$f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = y \lceil q \rceil.$

$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, y, \mathrm{Exact}) = x$, but panics if $q \notin \N$.

The following two expressions are equivalent:

• x.round_to_multiple(other, RoundingMode::Exact)
• { assert!(x.divisible_by(other)); x }

but the latter should be used as it is clearer and more efficient.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

• If rm is Exact, but self is not a multiple of other.
• If self is nonzero, other is zero, and rm is trying to round away from zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(5u32).round_to_multiple(Natural::ZERO, RoundingMode::Down), 0);

assert_eq!(
    Natural::from(10u32).round_to_multiple(Natural::from(4u32), RoundingMode::Down),
    8
);
assert_eq!(
    Natural::from(10u32).round_to_multiple(Natural::from(4u32), RoundingMode::Up),
    12
);
assert_eq!(
    Natural::from(10u32).round_to_multiple(Natural::from(5u32), RoundingMode::Exact),
    10
);
assert_eq!(
    Natural::from(10u32).round_to_multiple(Natural::from(3u32), RoundingMode::Nearest),
    9
);
assert_eq!(
    Natural::from(20u32).round_to_multiple(Natural::from(3u32), RoundingMode::Nearest),
    21
);
assert_eq!(
    Natural::from(10u32).round_to_multiple(Natural::from(4u32), RoundingMode::Nearest),
    8
);
assert_eq!(
    Natural::from(14u32).round_to_multiple(Natural::from(4u32), RoundingMode::Nearest),
    16
);

type Output = Natural

impl<'a> RoundToMultiple<Natural> for &'a Natural

fn round_to_multiple(self, other: Natural, rm: RoundingMode) -> Natural

Rounds a Natural to a multiple of another Natural, according to a specified rounding mode. The first Natural is taken by reference and the second by value.

Let $q = \frac{x}{y}$:

$f(x, y, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = y \lfloor q \rfloor.$

$f(x, y, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = y \lceil q \rceil.$

$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, y, \mathrm{Exact}) = x$, but panics if $q \notin \N$.

The following two expressions are equivalent:

• x.round_to_multiple(other, RoundingMode::Exact)
• { assert!(x.divisible_by(other)); x }

but the latter should be used as it is clearer and more efficient.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

• If rm is Exact, but self is not a multiple of other.
• If self is nonzero, other is zero, and rm is trying to round away from zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(5u32)).round_to_multiple(Natural::ZERO, RoundingMode::Down), 0);

assert_eq!(
    (&Natural::from(10u32)).round_to_multiple(Natural::from(4u32), RoundingMode::Down),
    8
);
assert_eq!(
    (&Natural::from(10u32)).round_to_multiple(Natural::from(4u32), RoundingMode::Up),
    12
);
assert_eq!(
    (&Natural::from(10u32)).round_to_multiple(Natural::from(5u32), RoundingMode::Exact),
    10
);
assert_eq!(
    (&Natural::from(10u32)).round_to_multiple(Natural::from(3u32), RoundingMode::Nearest),
    9
);
assert_eq!(
    (&Natural::from(20u32)).round_to_multiple(Natural::from(3u32), RoundingMode::Nearest),
    21
);
assert_eq!(
    (&Natural::from(10u32)).round_to_multiple(Natural::from(4u32), RoundingMode::Nearest),
    8
);
assert_eq!(
    (&Natural::from(14u32)).round_to_multiple(Natural::from(4u32), RoundingMode::Nearest),
    16
);

type Output = Natural

impl<'a> RoundToMultipleAssign<&'a Natural> for Natural

fn round_to_multiple_assign(&mut self, other: &'a Natural, rm: RoundingMode)

Rounds a Natural to a multiple of another Natural in place, according to a specified rounding mode. The Natural on the right-hand side is taken by reference.

See the RoundToMultiple documentation for details.

The following two expressions are equivalent:

• x.round_to_multiple_assign(other, RoundingMode::Exact);
• assert!(x.divisible_by(other));

but the latter should be used as it is clearer and more efficient.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

• If rm is Exact, but self is not a multiple of other.
• If self is nonzero, other is zero, and rm is trying to round away from zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultipleAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

let mut x = Natural::from(5u32);
x.round_to_multiple_assign(&Natural::ZERO, RoundingMode::Down);
assert_eq!(x, 0);

let mut x = Natural::from(10u32);
x.round_to_multiple_assign(&Natural::from(4u32), RoundingMode::Down);
assert_eq!(x, 8);

let mut x = Natural::from(10u32);
x.round_to_multiple_assign(&Natural::from(4u32), RoundingMode::Up);
assert_eq!(x, 12);

let mut x = Natural::from(10u32);
x.round_to_multiple_assign(&Natural::from(5u32), RoundingMode::Exact);
assert_eq!(x, 10);

let mut x = Natural::from(10u32);
x.round_to_multiple_assign(&Natural::from(3u32), RoundingMode::Nearest);
assert_eq!(x, 9);

let mut x = Natural::from(20u32);
x.round_to_multiple_assign(&Natural::from(3u32), RoundingMode::Nearest);
assert_eq!(x, 21);

let mut x = Natural::from(10u32);
x.round_to_multiple_assign(&Natural::from(4u32), RoundingMode::Nearest);
assert_eq!(x, 8);

let mut x = Natural::from(14u32);
x.round_to_multiple_assign(&Natural::from(4u32), RoundingMode::Nearest);
assert_eq!(x, 16);

impl RoundToMultipleAssign<Natural> for Natural

fn round_to_multiple_assign(&mut self, other: Natural, rm: RoundingMode)

Rounds a Natural to a multiple of another Natural in place, according to a specified rounding mode. The Natural on the right-hand side is taken by value.

See the RoundToMultiple documentation for details.

The following two expressions are equivalent:

• x.round_to_multiple_assign(other, RoundingMode::Exact);
• assert!(x.divisible_by(other));

but the latter should be used as it is clearer and more efficient.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Panics

• If rm is Exact, but self is not a multiple of other.
• If self is nonzero, other is zero, and rm is trying to round away from zero.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultipleAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

let mut x = Natural::from(5u32);
x.round_to_multiple_assign(Natural::ZERO, RoundingMode::Down);
assert_eq!(x, 0);

let mut x = Natural::from(10u32);
x.round_to_multiple_assign(Natural::from(4u32), RoundingMode::Down);
assert_eq!(x, 8);

let mut x = Natural::from(10u32);
x.round_to_multiple_assign(Natural::from(4u32), RoundingMode::Up);
assert_eq!(x, 12);

let mut x = Natural::from(10u32);
x.round_to_multiple_assign(Natural::from(5u32), RoundingMode::Exact);
assert_eq!(x, 10);

let mut x = Natural::from(10u32);
x.round_to_multiple_assign(Natural::from(3u32), RoundingMode::Nearest);
assert_eq!(x, 9);

let mut x = Natural::from(20u32);
x.round_to_multiple_assign(Natural::from(3u32), RoundingMode::Nearest);
assert_eq!(x, 21);

let mut x = Natural::from(10u32);
x.round_to_multiple_assign(Natural::from(4u32), RoundingMode::Nearest);
assert_eq!(x, 8);

let mut x = Natural::from(14u32);
x.round_to_multiple_assign(Natural::from(4u32), RoundingMode::Nearest);
assert_eq!(x, 16);

impl RoundToMultipleOfPowerOf2<u64> for Natural

fn round_to_multiple_of_power_of_2(self, pow: u64, rm: RoundingMode) -> Natural

Rounds a Natural to a multiple of $2^k$ according to a specified rounding mode. The Natural is taken by value.

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, k, \mathrm{Floor}) = 2^k \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, k, \mathrm{Ceiling}) = 2^k \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, k, \mathrm{Exact}) = 2^k q$, but panics if $q \notin \Z$.

The following two expressions are equivalent:

• x.round_to_multiple_of_power_of_2(pow, RoundingMode::Exact)
• { assert!(x.divisible_by_power_of_2(pow)); x }

but the latter should be used as it is clearer and more efficient.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), pow / Limb::WIDTH).

Panics

Panics if rm is Exact, but self is not a multiple of the power of 2.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::from(10u32).round_to_multiple_of_power_of_2(2, RoundingMode::Floor),
    8
);
assert_eq!(
    Natural::from(10u32).round_to_multiple_of_power_of_2(2, RoundingMode::Ceiling),
    12
);
assert_eq!(
    Natural::from(10u32).round_to_multiple_of_power_of_2(2, RoundingMode::Down),
    8
);
assert_eq!(Natural::from(10u32).round_to_multiple_of_power_of_2(2, RoundingMode::Up), 12);
assert_eq!(
    Natural::from(10u32).round_to_multiple_of_power_of_2(2, RoundingMode::Nearest),
    8
);
assert_eq!(
    Natural::from(12u32).round_to_multiple_of_power_of_2(2, RoundingMode::Exact),
    12
);

type Output = Natural

impl<'a> RoundToMultipleOfPowerOf2<u64> for &'a Natural

fn round_to_multiple_of_power_of_2(self, pow: u64, rm: RoundingMode) -> Natural

Rounds a Natural to a multiple of $2^k$ according to a specified rounding mode. The Natural is taken by reference.

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, k, \mathrm{Floor}) = 2^k \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, k, \mathrm{Ceiling}) = 2^k \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, k, \mathrm{Exact}) = 2^k q$, but panics if $q \notin \Z$.

The following two expressions are equivalent:

• x.round_to_multiple_of_power_of_2(pow, RoundingMode::Exact)
• { assert!(x.divisible_by_power_of_2(pow)); x }

but the latter should be used as it is clearer and more efficient.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), pow / Limb::WIDTH).

Panics

Panics if rm is Exact, but self is not a multiple of the power of 2.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

assert_eq!(
    (&Natural::from(10u32)).round_to_multiple_of_power_of_2(2, RoundingMode::Floor),
    8
);
assert_eq!(
    (&Natural::from(10u32)).round_to_multiple_of_power_of_2(2, RoundingMode::Ceiling),
    12
);
assert_eq!(
    (&Natural::from(10u32)).round_to_multiple_of_power_of_2(2, RoundingMode::Down),
    8
);
assert_eq!(
    (&Natural::from(10u32)).round_to_multiple_of_power_of_2(2, RoundingMode::Up),
    12
);
assert_eq!(
    (&Natural::from(10u32)).round_to_multiple_of_power_of_2(2, RoundingMode::Nearest),
    8
);
assert_eq!(
    (&Natural::from(12u32)).round_to_multiple_of_power_of_2(2, RoundingMode::Exact),
    12
);

type Output = Natural

impl RoundToMultipleOfPowerOf2Assign<u64> for Natural

fn round_to_multiple_of_power_of_2_assign(&mut self, pow: u64, rm: RoundingMode)

Rounds a Natural to a multiple of $2^k$ in place, according to a specified rounding mode.

See the RoundToMultipleOfPowerOf2 documentation for details.

The following two expressions are equivalent:

• x.round_to_multiple_of_power_of_2_assign(pow, RoundingMode::Exact);
• assert!(x.divisible_by_power_of_2(pow));

but the latter should be used as it is clearer and more efficient.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is max(self.significant_bits(), pow / Limb::WIDTH).

Panics

Panics if rm is Exact, but self is not a multiple of the power of 2.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2Assign;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

let mut n = Natural::from(10u32);
n.round_to_multiple_of_power_of_2_assign(2, RoundingMode::Floor);
assert_eq!(n, 8);

let mut n = Natural::from(10u32);
n.round_to_multiple_of_power_of_2_assign(2, RoundingMode::Ceiling);
assert_eq!(n, 12);

let mut n = Natural::from(10u32);
n.round_to_multiple_of_power_of_2_assign(2, RoundingMode::Down);
assert_eq!(n, 8);

let mut n = Natural::from(10u32);
n.round_to_multiple_of_power_of_2_assign(2, RoundingMode::Up);
assert_eq!(n, 12);

let mut n = Natural::from(10u32);
n.round_to_multiple_of_power_of_2_assign(2, RoundingMode::Nearest);
assert_eq!(n, 8);

let mut n = Natural::from(12u32);
n.round_to_multiple_of_power_of_2_assign(2, RoundingMode::Exact);
assert_eq!(n, 12);

impl<'a> RoundingFrom<&'a Natural> for f32

fn rounding_from(value: &'a Natural, rm: RoundingMode) -> f32

Converts a Natural to a primitive float according to a specified RoundingMode.

• If the rounding mode is Floor or Down, the largest float less than or equal to the Natural is returned. If the Natural is greater than the maximum finite float, then the maximum finite float is returned.
• If the rounding mode is Ceiling or Up, the smallest float greater than or equal to the Natural is returned. If the Natural is greater than the maximum finite float, then positive infinity is returned.
• If the rounding mode is Nearest, then the nearest float is returned. If the Natural is exactly between two floats, the float with the zero least-significant bit in its representation is selected. If the Natural is greater than the maximum finite float, then the maximum finite float is returned.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits().

Panics

Panics if the rounding mode is Exact and value cannot be represented exactly.

Examples

See here.

impl<'a> RoundingFrom<&'a Natural> for f64

fn rounding_from(value: &'a Natural, rm: RoundingMode) -> f64

Converts a Natural to a primitive float according to a specified RoundingMode.

• If the rounding mode is Floor or Down, the largest float less than or equal to the Natural is returned. If the Natural is greater than the maximum finite float, then the maximum finite float is returned.
• If the rounding mode is Ceiling or Up, the smallest float greater than or equal to the Natural is returned. If the Natural is greater than the maximum finite float, then positive infinity is returned.
• If the rounding mode is Nearest, then the nearest float is returned. If the Natural is exactly between two floats, the float with the zero least-significant bit in its representation is selected. If the Natural is greater than the maximum finite float, then the maximum finite float is returned.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits().

Panics

Panics if the rounding mode is Exact and value cannot be represented exactly.

Examples

See here.

impl RoundingFrom<f32> for Natural

fn rounding_from(value: f32, rm: RoundingMode) -> Self

Converts a floating-point value to a Natural, using the specified rounding mode.

The floating-point value cannot be NaN or infinite, and it cannot round to a negative integer.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is value.sci_exponent().

Panics

Panics if value is NaN or infinite, if it would round to a negative integer, or if the rounding mode is Exact and value is not an integer.

Examples

See here.

impl RoundingFrom<f64> for Natural

fn rounding_from(value: f64, rm: RoundingMode) -> Self

Converts a floating-point value to a Natural, using the specified rounding mode.

The floating-point value cannot be NaN or infinite, and it cannot round to a negative integer.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is value.sci_exponent().

Panics

Panics if value is NaN or infinite, if it would round to a negative integer, or if the rounding mode is Exact and value is not an integer.

Examples

See here.

impl<'a> SaturatingFrom<&'a Integer> for Natural

fn saturating_from(value: &'a Integer) -> Natural

Converts an Integer to a Natural, taking the Natural by reference. If the Integer is negative, 0 is returned.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::SaturatingFrom;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert_eq!(Natural::saturating_from(&Integer::from(123)), 123);
assert_eq!(Natural::saturating_from(&Integer::from(-123)), 0);
assert_eq!(Natural::saturating_from(&Integer::from(10u32).pow(12)), 1000000000000u64);
assert_eq!(Natural::saturating_from(&-Integer::from(10u32).pow(12)), 0);

impl<'a> SaturatingFrom<&'a Natural> for usize

fn saturating_from(value: &Natural) -> usize

Converts a Natural to a usize. If the Natural is too large to fit in a usize, the largest representable value is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> SaturatingFrom<&'a Natural> for u8

fn saturating_from(value: &Natural) -> u8

Converts a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb. If the Natural is too large to fit in the output type, the largest representable value is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> SaturatingFrom<&'a Natural> for u128

fn saturating_from(value: &Natural) -> u128

Converts a Natural to a value of an unsigned primitive integer type that’s larger than a Limb. If the Natural is too large to fit in the output type, the largest representable value is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> SaturatingFrom<&'a Natural> for isize

fn saturating_from(value: &Natural) -> isize

Converts a Natural to an isize or a value of a signed primitive integer type that’s larger than a Limb, If the Natural is too large to fit in the output type, the largest representable value is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> SaturatingFrom<&'a Natural> for i8

fn saturating_from(value: &Natural) -> i8

Converts a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb. If the Natural is too large to fit in the output type, the largest representable value is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> SaturatingFrom<&'a Natural> for u16

fn saturating_from(value: &Natural) -> u16

Converts a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb. If the Natural is too large to fit in the output type, the largest representable value is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> SaturatingFrom<&'a Natural> for i16

fn saturating_from(value: &Natural) -> i16

Converts a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb. If the Natural is too large to fit in the output type, the largest representable value is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> SaturatingFrom<&'a Natural> for u32

fn saturating_from(value: &Natural) -> u32

Converts a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb. If the Natural is too large to fit in the output type, the largest representable value is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> SaturatingFrom<&'a Natural> for i32

fn saturating_from(value: &Natural) -> i32

Converts a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb. If the Natural is too large to fit in the output type, the largest representable value is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> SaturatingFrom<&'a Natural> for u64

fn saturating_from(value: &Natural) -> u64

Converts a Natural to a Limb.

If the Natural is too large to fit in a Limb, the maximum representable value is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> SaturatingFrom<&'a Natural> for i64

fn saturating_from(value: &Natural) -> i64

Converts a Natural to a SignedLimb (the signed type whose width is the same as a limb’s).

If the Natural is too large to fit in a SignedLimb, the largest representable value is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> SaturatingFrom<&'a Natural> for i128

fn saturating_from(value: &Natural) -> i128

Converts a Natural to an isize or a value of a signed primitive integer type that’s larger than a Limb, If the Natural is too large to fit in the output type, the largest representable value is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl SaturatingFrom<Integer> for Natural

fn saturating_from(value: Integer) -> Natural

Converts an Integer to a Natural, taking the Natural by value. If the Integer is negative, 0 is returned.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::SaturatingFrom;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert_eq!(Natural::saturating_from(Integer::from(123)), 123);
assert_eq!(Natural::saturating_from(Integer::from(-123)), 0);
assert_eq!(Natural::saturating_from(Integer::from(10u32).pow(12)), 1000000000000u64);
assert_eq!(Natural::saturating_from(-Integer::from(10u32).pow(12)), 0);

impl SaturatingFrom<i128> for Natural

fn saturating_from(i: i128) -> Natural

Converts a signed primitive primitive integer to a Natural. If the integer is negative, 0 is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl SaturatingFrom<i16> for Natural

fn saturating_from(i: i16) -> Natural

Converts a signed primitive primitive integer to a Natural. If the integer is negative, 0 is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl SaturatingFrom<i32> for Natural

fn saturating_from(i: i32) -> Natural

Converts a signed primitive primitive integer to a Natural. If the integer is negative, 0 is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl SaturatingFrom<i64> for Natural

fn saturating_from(i: i64) -> Natural

Converts a signed primitive primitive integer to a Natural. If the integer is negative, 0 is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl SaturatingFrom<i8> for Natural

fn saturating_from(i: i8) -> Natural

Converts a signed primitive primitive integer to a Natural. If the integer is negative, 0 is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl SaturatingFrom<isize> for Natural

fn saturating_from(i: isize) -> Natural

Converts a signed primitive primitive integer to a Natural. If the integer is negative, 0 is returned.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> SaturatingSub<&'a Natural> for Natural

fn saturating_sub(self, other: &'a Natural) -> Natural

Subtracts a Natural by another Natural, taking the first by value and the second by reference and returning 0 if the result is negative.

$$ f(x, y) = \max(x - y, 0). $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SaturatingSub};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.saturating_sub(&Natural::from(123u32)), 0);
assert_eq!(Natural::from(123u32).saturating_sub(&Natural::ZERO), 123);
assert_eq!(Natural::from(456u32).saturating_sub(&Natural::from(123u32)), 333);
assert_eq!(
    (Natural::from(10u32).pow(12) * Natural::from(3u32))
            .saturating_sub(&Natural::from(10u32).pow(12)),
    2000000000000u64
);

type Output = Natural

impl<'a, 'b> SaturatingSub<&'a Natural> for &'b Natural

fn saturating_sub(self, other: &'a Natural) -> Natural

Subtracts a Natural by another Natural, taking both by reference and returning 0 if the result is negative.

$$ f(x, y) = \max(x - y, 0). $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SaturatingSub};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::ZERO).saturating_sub(&Natural::from(123u32)), 0);
assert_eq!((&Natural::from(123u32)).saturating_sub(&Natural::ZERO), 123);
assert_eq!((&Natural::from(456u32)).saturating_sub(&Natural::from(123u32)), 333);
assert_eq!(
    (&(Natural::from(10u32).pow(12) * Natural::from(3u32)))
            .saturating_sub(&Natural::from(10u32).pow(12)),
    2000000000000u64
);

type Output = Natural

impl SaturatingSub<Natural> for Natural

fn saturating_sub(self, other: Natural) -> Natural

Subtracts a Natural by another Natural, taking both by value and returning 0 if the result is negative.

$$ f(x, y) = \max(x - y, 0). $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SaturatingSub};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.saturating_sub(Natural::from(123u32)), 0);
assert_eq!(Natural::from(123u32).saturating_sub(Natural::ZERO), 123);
assert_eq!(Natural::from(456u32).saturating_sub(Natural::from(123u32)), 333);
assert_eq!(
    (Natural::from(10u32).pow(12) * Natural::from(3u32))
            .saturating_sub(Natural::from(10u32).pow(12)),
    2000000000000u64
);

type Output = Natural

impl<'a> SaturatingSub<Natural> for &'a Natural

fn saturating_sub(self, other: Natural) -> Natural

Subtracts a Natural by another Natural, taking the first by reference and the second by value and returning 0 if the result is negative.

$$ f(x, y) = \max(x - y, 0). $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SaturatingSub};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::ZERO).saturating_sub(Natural::from(123u32)), 0);
assert_eq!((&Natural::from(123u32)).saturating_sub(Natural::ZERO), 123);
assert_eq!((&Natural::from(456u32)).saturating_sub(Natural::from(123u32)), 333);
assert_eq!(
    (&(Natural::from(10u32).pow(12) * Natural::from(3u32)))
        .saturating_sub(Natural::from(10u32).pow(12)),
    2000000000000u64
);

type Output = Natural

impl<'a> SaturatingSubAssign<&'a Natural> for Natural

fn saturating_sub_assign(&mut self, other: &'a Natural)

Subtracts a Natural by another Natural in place, taking the Natural on the right-hand side by reference and setting the left-hand side to 0 if the result is negative.

$$ x \gets \max(x - y, 0). $$

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 other is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::SaturatingSubAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut x = Natural::from(123u32);
x.saturating_sub_assign(&Natural::from(123u32));
assert_eq!(x, 0);

let mut x = Natural::from(123u32);
x.saturating_sub_assign(&Natural::ZERO);
assert_eq!(x, 123);

let mut x = Natural::from(456u32);
x.saturating_sub_assign(&Natural::from(123u32));
assert_eq!(x, 333);

let mut x = Natural::from(123u32);
x.saturating_sub_assign(&Natural::from(456u32));
assert_eq!(x, 0);

impl SaturatingSubAssign<Natural> for Natural

fn saturating_sub_assign(&mut self, other: Natural)

Subtracts a Natural by another Natural in place, taking the Natural on the right-hand side by value and setting the left-hand side to 0 if the result is negative.

$$ x \gets \max(x - y, 0). $$

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 other is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::SaturatingSubAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut x = Natural::from(123u32);
x.saturating_sub_assign(Natural::from(123u32));
assert_eq!(x, 0);

let mut x = Natural::from(123u32);
x.saturating_sub_assign(Natural::ZERO);
assert_eq!(x, 123);

let mut x = Natural::from(456u32);
x.saturating_sub_assign(Natural::from(123u32));
assert_eq!(x, 333);

let mut x = Natural::from(123u32);
x.saturating_sub_assign(Natural::from(456u32));
assert_eq!(x, 0);

impl<'a, 'b> SaturatingSubMul<&'a Natural, &'b Natural> for Natural

fn saturating_sub_mul(self, y: &'a Natural, z: &'b Natural) -> Natural

Subtracts a Natural by the product of two other Naturals, taking the first by value and the second and third by reference and returning 0 if the result is negative.

$$ f(x, y, z) = \max(x - yz, 0). $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SaturatingSubMul};
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::from(20u32).saturating_sub_mul(&Natural::from(3u32), &Natural::from(4u32)),
    8
);
assert_eq!(
    Natural::from(10u32).saturating_sub_mul(&Natural::from(3u32), &Natural::from(4u32)),
    0
);
assert_eq!(
    Natural::from(10u32).pow(12)
            .saturating_sub_mul(&Natural::from(0x10000u32), &Natural::from(0x10000u32)),
    995705032704u64
);

type Output = Natural

impl<'a> SaturatingSubMul<&'a Natural, Natural> for Natural

fn saturating_sub_mul(self, y: &'a Natural, z: Natural) -> Natural

Subtracts a Natural by the product of two other Naturals, taking the first and third by value and the second by reference and returning 0 if the result is negative.

$$ f(x, y, z) = \max(x - yz, 0). $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SaturatingSubMul};
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::from(20u32).saturating_sub_mul(&Natural::from(3u32), Natural::from(4u32)),
    8
);
assert_eq!(
    Natural::from(10u32).saturating_sub_mul(&Natural::from(3u32), Natural::from(4u32)),
    0
);
assert_eq!(
    Natural::from(10u32).pow(12)
            .saturating_sub_mul(&Natural::from(0x10000u32), Natural::from(0x10000u32)),
    995705032704u64
);

type Output = Natural

impl<'a, 'b, 'c> SaturatingSubMul<&'b Natural, &'c Natural> for &'a Natural

fn saturating_sub_mul(self, y: &'b Natural, z: &'c Natural) -> Natural

Subtracts a Natural by the product of two other Naturals, taking all three by reference and returning 0 if the result is negative.

$$ f(x, y, z) = \max(x - yz, 0). $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SaturatingSubMul};
use malachite_nz::natural::Natural;

assert_eq!(
    (&Natural::from(20u32)).saturating_sub_mul(&Natural::from(3u32), &Natural::from(4u32)),
    8
);
assert_eq!(
    (&Natural::from(10u32)).saturating_sub_mul(&Natural::from(3u32), &Natural::from(4u32)),
    0
);
assert_eq!(
    (&Natural::from(10u32).pow(12))
            .saturating_sub_mul(&Natural::from(0x10000u32), &Natural::from(0x10000u32)),
    995705032704u64
);

type Output = Natural

impl<'a> SaturatingSubMul<Natural, &'a Natural> for Natural

fn saturating_sub_mul(self, y: Natural, z: &'a Natural) -> Natural

Subtracts a Natural by the product of two other Naturals, taking the first two by value and the third by reference and returning 0 if the result is negative.

$$ f(x, y, z) = \max(x - yz, 0). $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SaturatingSubMul};
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::from(20u32).saturating_sub_mul(Natural::from(3u32), &Natural::from(4u32)),
    8
);
assert_eq!(
    Natural::from(10u32).saturating_sub_mul(Natural::from(3u32), &Natural::from(4u32)),
    0
);
assert_eq!(
    Natural::from(10u32).pow(12)
            .saturating_sub_mul(Natural::from(0x10000u32), &Natural::from(0x10000u32)),
    995705032704u64
);

type Output = Natural

impl SaturatingSubMul<Natural, Natural> for Natural

fn saturating_sub_mul(self, y: Natural, z: Natural) -> Natural

Subtracts a Natural by the product of two other Naturals, taking all three by value and returning 0 if the result is negative.

$$ f(x, y, z) = \max(x - yz, 0). $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SaturatingSubMul};
use malachite_nz::natural::Natural;

assert_eq!(
    Natural::from(20u32).saturating_sub_mul(Natural::from(3u32), Natural::from(4u32)),
    8
);
assert_eq!(
    Natural::from(10u32).saturating_sub_mul(Natural::from(3u32), Natural::from(4u32)),
    0
);
assert_eq!(
    Natural::from(10u32).pow(12)
            .saturating_sub_mul(Natural::from(0x10000u32), Natural::from(0x10000u32)),
    995705032704u64
);

type Output = Natural

impl<'a, 'b> SaturatingSubMulAssign<&'a Natural, &'b Natural> for Natural

fn saturating_sub_mul_assign(&mut self, y: &'a Natural, z: &'b Natural)

Subtracts a Natural by the product of two other Naturals in place, taking both Naturals on the right-hand side by reference and replacing the left-hand side Natural with 0 if the result is negative.

$$ x \gets \max(x - yz, 0). $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SaturatingSubMulAssign};
use malachite_nz::natural::Natural;

let mut x = Natural::from(20u32);
x.saturating_sub_mul_assign(&Natural::from(3u32), &Natural::from(4u32));
assert_eq!(x, 8);

let mut x = Natural::from(10u32);
x.saturating_sub_mul_assign(&Natural::from(3u32), &Natural::from(4u32));
assert_eq!(x, 0);

let mut x = Natural::from(10u32).pow(12);
x.saturating_sub_mul_assign(&Natural::from(0x10000u32), &Natural::from(0x10000u32));
assert_eq!(x, 995705032704u64);

impl<'a> SaturatingSubMulAssign<&'a Natural, Natural> for Natural

fn saturating_sub_mul_assign(&mut self, y: &'a Natural, z: Natural)

Subtracts a Natural by the product of two other Naturals in place, taking the first Natural on the right-hand side by reference and the second by value and replacing the left-hand side Natural with 0 if the result is negative.

$$ x \gets \max(x - yz, 0). $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SaturatingSubMulAssign};
use malachite_nz::natural::Natural;

let mut x = Natural::from(20u32);
x.saturating_sub_mul_assign(&Natural::from(3u32), Natural::from(4u32));
assert_eq!(x, 8);

let mut x = Natural::from(10u32);
x.saturating_sub_mul_assign(&Natural::from(3u32), Natural::from(4u32));
assert_eq!(x, 0);

let mut x = Natural::from(10u32).pow(12);
x.saturating_sub_mul_assign(&Natural::from(0x10000u32), Natural::from(0x10000u32));
assert_eq!(x, 995705032704u64);

impl<'a> SaturatingSubMulAssign<Natural, &'a Natural> for Natural

fn saturating_sub_mul_assign(&mut self, y: Natural, z: &'a Natural)

Subtracts a Natural by the product of two other Naturals in place, taking the first Natural on the right-hand side by value and the second by reference and replacing the left-hand side Natural with 0 if the result is negative.

$$ x \gets \max(x - yz, 0). $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SaturatingSubMulAssign};
use malachite_nz::natural::Natural;

let mut x = Natural::from(20u32);
x.saturating_sub_mul_assign(Natural::from(3u32), &Natural::from(4u32));
assert_eq!(x, 8);

let mut x = Natural::from(10u32);
x.saturating_sub_mul_assign(Natural::from(3u32), &Natural::from(4u32));
assert_eq!(x, 0);

let mut x = Natural::from(10u32).pow(12);
x.saturating_sub_mul_assign(Natural::from(0x10000u32), &Natural::from(0x10000u32));
assert_eq!(x, 995705032704u64);

impl SaturatingSubMulAssign<Natural, Natural> for Natural

fn saturating_sub_mul_assign(&mut self, y: Natural, z: Natural)

Subtracts a Natural by the product of two other Naturals in place, taking both Naturals on the right-hand side by value and replacing the left-hand side Natural with 0 if the result is negative.

$$ x \gets \max(x - yz, 0). $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SaturatingSubMulAssign};
use malachite_nz::natural::Natural;

let mut x = Natural::from(20u32);
x.saturating_sub_mul_assign(Natural::from(3u32), Natural::from(4u32));
assert_eq!(x, 8);

let mut x = Natural::from(10u32);
x.saturating_sub_mul_assign(Natural::from(3u32), Natural::from(4u32));
assert_eq!(x, 0);

let mut x = Natural::from(10u32).pow(12);
x.saturating_sub_mul_assign(Natural::from(0x10000u32), Natural::from(0x10000u32));
assert_eq!(x, 995705032704u64);

impl<'a> SciMantissaAndExponent<f32, u64, Natural> for &'a Natural

fn sci_mantissa_and_exponent(self) -> (f32, u64)

Returns a Natural’s scientific mantissa and exponent.

When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational mantissa as a float. The conversion might not be exact, so we round to the nearest float using the Nearest rounding mode. To use other rounding modes, use sci_mantissa_and_exponent_with_rounding. $$ f(x) \approx (\frac{x}{2^{\lfloor \log_2 x \rfloor}}, \lfloor \log_2 x \rfloor). $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

fn from_sci_mantissa_and_exponent(
    sci_mantissa: f32,
    sci_exponent: u64
) -> Option<Natural>

Constructs a Natural from its scientific mantissa and exponent.

When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$. Here, the rational mantissa is provided as a float. If the mantissa is outside the range $[1, 2)$, None is returned.

Some combinations of mantissas and exponents do not specify a Natural, in which case the resulting value is rounded to a Natural using the Nearest rounding mode. To specify other rounding modes, use from_sci_mantissa_and_exponent_with_rounding.

$$ f(x) \approx 2^{e_s}m_s. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is sci_exponent.

Examples

See here.

fn sci_mantissa(self) -> M

Extracts the scientific mantissa from a number.

fn sci_exponent(self) -> E

Extracts the scientific exponent from a number.

impl<'a> SciMantissaAndExponent<f64, u64, Natural> for &'a Natural

fn sci_mantissa_and_exponent(self) -> (f64, u64)

Returns a Natural’s scientific mantissa and exponent.

When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$. We represent the rational mantissa as a float. The conversion might not be exact, so we round to the nearest float using the Nearest rounding mode. To use other rounding modes, use sci_mantissa_and_exponent_with_rounding. $$ f(x) \approx (\frac{x}{2^{\lfloor \log_2 x \rfloor}}, \lfloor \log_2 x \rfloor). $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

See here.

fn from_sci_mantissa_and_exponent(
    sci_mantissa: f64,
    sci_exponent: u64
) -> Option<Natural>

Constructs a Natural from its scientific mantissa and exponent.

When $x$ is positive, we can write $x = 2^{e_s}m_s$, where $e_s$ is an integer and $m_s$ is a rational number with $1 \leq m_s < 2$. Here, the rational mantissa is provided as a float. If the mantissa is outside the range $[1, 2)$, None is returned.

Some combinations of mantissas and exponents do not specify a Natural, in which case the resulting value is rounded to a Natural using the Nearest rounding mode. To specify other rounding modes, use from_sci_mantissa_and_exponent_with_rounding.

$$ f(x) \approx 2^{e_s}m_s. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is sci_exponent.

Examples

See here.

fn sci_mantissa(self) -> M

Extracts the scientific mantissa from a number.

fn sci_exponent(self) -> E

Extracts the scientific exponent from a number.

impl Shl<i128> for Natural

fn shl(self, bits: i128) -> Natural

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), taking it by value.

$$ f(x, k) = \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl<'a> Shl<i128> for &'a Natural

fn shl(self, bits: i128) -> Natural

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), taking it by reference.

$$ f(x, k) = \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl Shl<i16> for Natural

fn shl(self, bits: i16) -> Natural

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), taking it by value.

$$ f(x, k) = \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl<'a> Shl<i16> for &'a Natural

fn shl(self, bits: i16) -> Natural

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), taking it by reference.

$$ f(x, k) = \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl Shl<i32> for Natural

fn shl(self, bits: i32) -> Natural

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), taking it by value.

$$ f(x, k) = \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl<'a> Shl<i32> for &'a Natural

fn shl(self, bits: i32) -> Natural

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), taking it by reference.

$$ f(x, k) = \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl Shl<i64> for Natural

fn shl(self, bits: i64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), taking it by value.

$$ f(x, k) = \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl<'a> Shl<i64> for &'a Natural

fn shl(self, bits: i64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), taking it by reference.

$$ f(x, k) = \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl Shl<i8> for Natural

fn shl(self, bits: i8) -> Natural

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), taking it by value.

$$ f(x, k) = \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl<'a> Shl<i8> for &'a Natural

fn shl(self, bits: i8) -> Natural

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), taking it by reference.

$$ f(x, k) = \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl Shl<isize> for Natural

fn shl(self, bits: isize) -> Natural

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), taking it by value.

$$ f(x, k) = \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl<'a> Shl<isize> for &'a Natural

fn shl(self, bits: isize) -> Natural

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), taking it by reference.

$$ f(x, k) = \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl Shl<u128> for Natural

fn shl(self, bits: u128) -> Natural

Left-shifts a Natural (multiplies it by a power of 2), taking it by value.

$f(x, k) = x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl<'a> Shl<u128> for &'a Natural

fn shl(self, bits: u128) -> Natural

Left-shifts a Natural (multiplies it by a power of 2), taking it by reference.

$f(x, k) = x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl Shl<u16> for Natural

fn shl(self, bits: u16) -> Natural

Left-shifts a Natural (multiplies it by a power of 2), taking it by value.

$f(x, k) = x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl<'a> Shl<u16> for &'a Natural

fn shl(self, bits: u16) -> Natural

Left-shifts a Natural (multiplies it by a power of 2), taking it by reference.

$f(x, k) = x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl Shl<u32> for Natural

fn shl(self, bits: u32) -> Natural

Left-shifts a Natural (multiplies it by a power of 2), taking it by value.

$f(x, k) = x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl<'a> Shl<u32> for &'a Natural

fn shl(self, bits: u32) -> Natural

Left-shifts a Natural (multiplies it by a power of 2), taking it by reference.

$f(x, k) = x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl Shl<u64> for Natural

fn shl(self, bits: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2), taking it by value.

$f(x, k) = x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl<'a> Shl<u64> for &'a Natural

fn shl(self, bits: u64) -> Natural

Left-shifts a Natural (multiplies it by a power of 2), taking it by reference.

$f(x, k) = x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl Shl<u8> for Natural

fn shl(self, bits: u8) -> Natural

Left-shifts a Natural (multiplies it by a power of 2), taking it by value.

$f(x, k) = x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl<'a> Shl<u8> for &'a Natural

fn shl(self, bits: u8) -> Natural

Left-shifts a Natural (multiplies it by a power of 2), taking it by reference.

$f(x, k) = x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl Shl<usize> for Natural

fn shl(self, bits: usize) -> Natural

Left-shifts a Natural (multiplies it by a power of 2), taking it by value.

$f(x, k) = x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl<'a> Shl<usize> for &'a Natural

fn shl(self, bits: usize) -> Natural

Left-shifts a Natural (multiplies it by a power of 2), taking it by reference.

$f(x, k) = x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.

Examples

See here.

type Output = Natural

The resulting type after applying the << operator.

impl ShlAssign<i128> for Natural

fn shl_assign(&mut self, bits: i128)

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), in place.

$$ x \gets \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

See here.

impl ShlAssign<i16> for Natural

fn shl_assign(&mut self, bits: i16)

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), in place.

$$ x \gets \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

See here.

impl ShlAssign<i32> for Natural

fn shl_assign(&mut self, bits: i32)

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), in place.

$$ x \gets \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

See here.

impl ShlAssign<i64> for Natural

fn shl_assign(&mut self, bits: i64)

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), in place.

$$ x \gets \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

See here.

impl ShlAssign<i8> for Natural

fn shl_assign(&mut self, bits: i8)

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), in place.

$$ x \gets \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

See here.

impl ShlAssign<isize> for Natural

fn shl_assign(&mut self, bits: isize)

Left-shifts a Natural (multiplies it by a power of 2 or divides it by a power of 2 and takes the floor), in place.

$$ x \gets \lfloor x2^k \rfloor. $$

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

See here.

impl ShlAssign<u128> for Natural

fn shl_assign(&mut self, bits: u128)

Left-shifts a Natural (multiplies it by a power of 2), in place.

$x \gets x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.s

Examples

See here.

impl ShlAssign<u16> for Natural

fn shl_assign(&mut self, bits: u16)

Left-shifts a Natural (multiplies it by a power of 2), in place.

$x \gets x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.s

Examples

See here.

impl ShlAssign<u32> for Natural

fn shl_assign(&mut self, bits: u32)

Left-shifts a Natural (multiplies it by a power of 2), in place.

$x \gets x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.s

Examples

See here.

impl ShlAssign<u64> for Natural

fn shl_assign(&mut self, bits: u64)

Left-shifts a Natural (multiplies it by a power of 2), in place.

$x \gets x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.s

Examples

See here.

impl ShlAssign<u8> for Natural

fn shl_assign(&mut self, bits: u8)

Left-shifts a Natural (multiplies it by a power of 2), in place.

$x \gets x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.s

Examples

See here.

impl ShlAssign<usize> for Natural

fn shl_assign(&mut self, bits: usize)

Left-shifts a Natural (multiplies it by a power of 2), in place.

$x \gets x2^k$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is bits.s

Examples

See here.

impl ShlRound<i128> for Natural

fn shl_round(self, bits: i128, rm: RoundingMode) -> Natural

Left-shifts a Natural (multiplies or divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

Let $q = x2^k$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

type Output = Natural

impl<'a> ShlRound<i128> for &'a Natural

fn shl_round(self, bits: i128, rm: RoundingMode) -> Natural

Left-shifts a Natural (multiplies or divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

Let $q = x2^k$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

type Output = Natural

impl ShlRound<i16> for Natural

fn shl_round(self, bits: i16, rm: RoundingMode) -> Natural

Left-shifts a Natural (multiplies or divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

Let $q = x2^k$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

type Output = Natural

impl<'a> ShlRound<i16> for &'a Natural

fn shl_round(self, bits: i16, rm: RoundingMode) -> Natural

Left-shifts a Natural (multiplies or divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

Let $q = x2^k$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

type Output = Natural

impl ShlRound<i32> for Natural

fn shl_round(self, bits: i32, rm: RoundingMode) -> Natural

Left-shifts a Natural (multiplies or divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

Let $q = x2^k$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

type Output = Natural

impl<'a> ShlRound<i32> for &'a Natural

fn shl_round(self, bits: i32, rm: RoundingMode) -> Natural

Left-shifts a Natural (multiplies or divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

Let $q = x2^k$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

type Output = Natural

impl ShlRound<i64> for Natural

fn shl_round(self, bits: i64, rm: RoundingMode) -> Natural

Left-shifts a Natural (multiplies or divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

Let $q = x2^k$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

type Output = Natural

impl<'a> ShlRound<i64> for &'a Natural

fn shl_round(self, bits: i64, rm: RoundingMode) -> Natural

Left-shifts a Natural (multiplies or divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

Let $q = x2^k$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

type Output = Natural

impl ShlRound<i8> for Natural

fn shl_round(self, bits: i8, rm: RoundingMode) -> Natural

Left-shifts a Natural (multiplies or divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

Let $q = x2^k$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

type Output = Natural

impl<'a> ShlRound<i8> for &'a Natural

fn shl_round(self, bits: i8, rm: RoundingMode) -> Natural

Left-shifts a Natural (multiplies or divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

Let $q = x2^k$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

type Output = Natural

impl ShlRound<isize> for Natural

fn shl_round(self, bits: isize, rm: RoundingMode) -> Natural

Left-shifts a Natural (multiplies or divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

Let $q = x2^k$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

type Output = Natural

impl<'a> ShlRound<isize> for &'a Natural

fn shl_round(self, bits: isize, rm: RoundingMode) -> Natural

Left-shifts a Natural (multiplies or divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

Let $q = x2^k$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

type Output = Natural

impl ShlRoundAssign<i128> for Natural

fn shl_round_assign(&mut self, bits: i128, rm: RoundingMode)

Left-shifts a Natural (multiplies or divides it by a power of 2) and rounds according to the specified rounding mode, in place.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

See the ShlRound documentation for details.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

impl ShlRoundAssign<i16> for Natural

fn shl_round_assign(&mut self, bits: i16, rm: RoundingMode)

Left-shifts a Natural (multiplies or divides it by a power of 2) and rounds according to the specified rounding mode, in place.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

See the ShlRound documentation for details.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

impl ShlRoundAssign<i32> for Natural

fn shl_round_assign(&mut self, bits: i32, rm: RoundingMode)

Left-shifts a Natural (multiplies or divides it by a power of 2) and rounds according to the specified rounding mode, in place.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

See the ShlRound documentation for details.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

impl ShlRoundAssign<i64> for Natural

fn shl_round_assign(&mut self, bits: i64, rm: RoundingMode)

Left-shifts a Natural (multiplies or divides it by a power of 2) and rounds according to the specified rounding mode, in place.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

See the ShlRound documentation for details.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

impl ShlRoundAssign<i8> for Natural

fn shl_round_assign(&mut self, bits: i8, rm: RoundingMode)

Left-shifts a Natural (multiplies or divides it by a power of 2) and rounds according to the specified rounding mode, in place.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

See the ShlRound documentation for details.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

impl ShlRoundAssign<isize> for Natural

fn shl_round_assign(&mut self, bits: isize, rm: RoundingMode)

Left-shifts a Natural (multiplies or divides it by a power of 2) and rounds according to the specified rounding mode, in place.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use bits > 0 || self.divisible_by_power_of_2(bits). Rounding might only be necessary if bits is negative.

See the ShlRound documentation for details.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is negative and rm is RoundingMode::Exact but self is not divisible by $2^{-k}$.

Examples

See here.

impl Shr<i128> for Natural

fn shr(self, bits: i128) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), taking it by value.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl<'a> Shr<i128> for &'a Natural

fn shr(self, bits: i128) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), taking it by reference.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl Shr<i16> for Natural

fn shr(self, bits: i16) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), taking it by value.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl<'a> Shr<i16> for &'a Natural

fn shr(self, bits: i16) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), taking it by reference.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl Shr<i32> for Natural

fn shr(self, bits: i32) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), taking it by value.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl<'a> Shr<i32> for &'a Natural

fn shr(self, bits: i32) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), taking it by reference.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl Shr<i64> for Natural

fn shr(self, bits: i64) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), taking it by value.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl<'a> Shr<i64> for &'a Natural

fn shr(self, bits: i64) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), taking it by reference.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl Shr<i8> for Natural

fn shr(self, bits: i8) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), taking it by value.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl<'a> Shr<i8> for &'a Natural

fn shr(self, bits: i8) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), taking it by reference.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl Shr<isize> for Natural

fn shr(self, bits: isize) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), taking it by value.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl<'a> Shr<isize> for &'a Natural

fn shr(self, bits: isize) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), taking it by reference.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl Shr<u128> for Natural

fn shr(self, bits: u128) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor), taking it by value.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl<'a> Shr<u128> for &'a Natural

fn shr(self, bits: u128) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor), taking it by reference.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl Shr<u16> for Natural

fn shr(self, bits: u16) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor), taking it by value.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl<'a> Shr<u16> for &'a Natural

fn shr(self, bits: u16) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor), taking it by reference.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl Shr<u32> for Natural

fn shr(self, bits: u32) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor), taking it by value.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl<'a> Shr<u32> for &'a Natural

fn shr(self, bits: u32) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor), taking it by reference.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl Shr<u64> for Natural

fn shr(self, bits: u64) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor), taking it by value.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl<'a> Shr<u64> for &'a Natural

fn shr(self, bits: u64) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor), taking it by reference.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl Shr<u8> for Natural

fn shr(self, bits: u8) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor), taking it by value.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl<'a> Shr<u8> for &'a Natural

fn shr(self, bits: u8) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor), taking it by reference.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl Shr<usize> for Natural

fn shr(self, bits: usize) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor), taking it by value.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl<'a> Shr<usize> for &'a Natural

fn shr(self, bits: usize) -> Natural

Right-shifts a Natural (divides it by a power of 2 and takes the floor), taking it by reference.

$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

type Output = Natural

The resulting type after applying the >> operator.

impl ShrAssign<i128> for Natural

fn shr_assign(&mut self, bits: i128)

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), in place.

$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

impl ShrAssign<i16> for Natural

fn shr_assign(&mut self, bits: i16)

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), in place.

$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

impl ShrAssign<i32> for Natural

fn shr_assign(&mut self, bits: i32)

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), in place.

$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

impl ShrAssign<i64> for Natural

fn shr_assign(&mut self, bits: i64)

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), in place.

$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

impl ShrAssign<i8> for Natural

fn shr_assign(&mut self, bits: i8)

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), in place.

$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

impl ShrAssign<isize> for Natural

fn shr_assign(&mut self, bits: isize)

Right-shifts a Natural (divides it by a power of 2 and takes the floor or multiplies it by a power of 2), in place.

$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

impl ShrAssign<u128> for Natural

fn shr_assign(&mut self, bits: u128)

Right-shifts a Natural (divides it by a power of 2 and takes the floor), in place.

$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

impl ShrAssign<u16> for Natural

fn shr_assign(&mut self, bits: u16)

Right-shifts a Natural (divides it by a power of 2 and takes the floor), in place.

$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

impl ShrAssign<u32> for Natural

fn shr_assign(&mut self, bits: u32)

Right-shifts a Natural (divides it by a power of 2 and takes the floor), in place.

$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

impl ShrAssign<u64> for Natural

fn shr_assign(&mut self, bits: u64)

Right-shifts a Natural (divides it by a power of 2 and takes the floor), in place.

$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

impl ShrAssign<u8> for Natural

fn shr_assign(&mut self, bits: u8)

Right-shifts a Natural (divides it by a power of 2 and takes the floor), in place.

$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

impl ShrAssign<usize> for Natural

fn shr_assign(&mut self, bits: usize)

Right-shifts a Natural (divides it by a power of 2 and takes the floor), in place.

$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory and $n$ is max(1, self.significant_bits() - bits).

Examples

See here.

impl ShrRound<i128> for Natural

fn shr_round(self, bits: i128, rm: RoundingMode) -> Natural

Shifts a Natural right (divides or multiplies it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl<'a> ShrRound<i128> for &'a Natural

fn shr_round(self, bits: i128, rm: RoundingMode) -> Natural

Shifts a Natural right (divides or multiplies it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl ShrRound<i16> for Natural

fn shr_round(self, bits: i16, rm: RoundingMode) -> Natural

Shifts a Natural right (divides or multiplies it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl<'a> ShrRound<i16> for &'a Natural

fn shr_round(self, bits: i16, rm: RoundingMode) -> Natural

Shifts a Natural right (divides or multiplies it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl ShrRound<i32> for Natural

fn shr_round(self, bits: i32, rm: RoundingMode) -> Natural

Shifts a Natural right (divides or multiplies it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl<'a> ShrRound<i32> for &'a Natural

fn shr_round(self, bits: i32, rm: RoundingMode) -> Natural

Shifts a Natural right (divides or multiplies it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl ShrRound<i64> for Natural

fn shr_round(self, bits: i64, rm: RoundingMode) -> Natural

Shifts a Natural right (divides or multiplies it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl<'a> ShrRound<i64> for &'a Natural

fn shr_round(self, bits: i64, rm: RoundingMode) -> Natural

Shifts a Natural right (divides or multiplies it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl ShrRound<i8> for Natural

fn shr_round(self, bits: i8, rm: RoundingMode) -> Natural

Shifts a Natural right (divides or multiplies it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl<'a> ShrRound<i8> for &'a Natural

fn shr_round(self, bits: i8, rm: RoundingMode) -> Natural

Shifts a Natural right (divides or multiplies it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl ShrRound<isize> for Natural

fn shr_round(self, bits: isize, rm: RoundingMode) -> Natural

Shifts a Natural right (divides or multiplies it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl<'a> ShrRound<isize> for &'a Natural

fn shr_round(self, bits: isize, rm: RoundingMode) -> Natural

Shifts a Natural right (divides or multiplies it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl ShrRound<u128> for Natural

fn shr_round(self, bits: u128, rm: RoundingMode) -> Natural

Shifts a Natural right (divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

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

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl<'a> ShrRound<u128> for &'a Natural

fn shr_round(self, bits: u128, rm: RoundingMode) -> Natural

Shifts a Natural right (divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(1, self.significant_bits() - bits).

Panics

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl ShrRound<u16> for Natural

fn shr_round(self, bits: u16, rm: RoundingMode) -> Natural

Shifts a Natural right (divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

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

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl<'a> ShrRound<u16> for &'a Natural

fn shr_round(self, bits: u16, rm: RoundingMode) -> Natural

Shifts a Natural right (divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(1, self.significant_bits() - bits).

Panics

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl ShrRound<u32> for Natural

fn shr_round(self, bits: u32, rm: RoundingMode) -> Natural

Shifts a Natural right (divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

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

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl<'a> ShrRound<u32> for &'a Natural

fn shr_round(self, bits: u32, rm: RoundingMode) -> Natural

Shifts a Natural right (divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(1, self.significant_bits() - bits).

Panics

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl ShrRound<u64> for Natural

fn shr_round(self, bits: u64, rm: RoundingMode) -> Natural

Shifts a Natural right (divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

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

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl<'a> ShrRound<u64> for &'a Natural

fn shr_round(self, bits: u64, rm: RoundingMode) -> Natural

Shifts a Natural right (divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(1, self.significant_bits() - bits).

Panics

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl ShrRound<u8> for Natural

fn shr_round(self, bits: u8, rm: RoundingMode) -> Natural

Shifts a Natural right (divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

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

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl<'a> ShrRound<u8> for &'a Natural

fn shr_round(self, bits: u8, rm: RoundingMode) -> Natural

Shifts a Natural right (divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(1, self.significant_bits() - bits).

Panics

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl ShrRound<usize> for Natural

fn shr_round(self, bits: usize, rm: RoundingMode) -> Natural

Shifts a Natural right (divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

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

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl<'a> ShrRound<usize> for &'a Natural

fn shr_round(self, bits: usize, rm: RoundingMode) -> Natural

Shifts a Natural right (divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$

$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(1, self.significant_bits() - bits).

Panics

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

type Output = Natural

impl ShrRoundAssign<i128> for Natural

fn shr_round_assign(&mut self, bits: i128, rm: RoundingMode)

Shifts a Natural right (divides or multiplies it by a power of 2) and rounds according to the specified rounding mode, in place.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

See the ShrRound documentation for details.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

impl ShrRoundAssign<i16> for Natural

fn shr_round_assign(&mut self, bits: i16, rm: RoundingMode)

Shifts a Natural right (divides or multiplies it by a power of 2) and rounds according to the specified rounding mode, in place.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

See the ShrRound documentation for details.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

impl ShrRoundAssign<i32> for Natural

fn shr_round_assign(&mut self, bits: i32, rm: RoundingMode)

Shifts a Natural right (divides or multiplies it by a power of 2) and rounds according to the specified rounding mode, in place.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

See the ShrRound documentation for details.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

impl ShrRoundAssign<i64> for Natural

fn shr_round_assign(&mut self, bits: i64, rm: RoundingMode)

Shifts a Natural right (divides or multiplies it by a power of 2) and rounds according to the specified rounding mode, in place.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

See the ShrRound documentation for details.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

impl ShrRoundAssign<i8> for Natural

fn shr_round_assign(&mut self, bits: i8, rm: RoundingMode)

Shifts a Natural right (divides or multiplies it by a power of 2) and rounds according to the specified rounding mode, in place.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

See the ShrRound documentation for details.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

impl ShrRoundAssign<isize> for Natural

fn shr_round_assign(&mut self, bits: isize, rm: RoundingMode)

Shifts a Natural right (divides or multiplies it by a power of 2) and rounds according to the specified rounding mode, in place.

Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

See the ShrRound documentation for details.

Worst-case complexity

$T(n, m) = O(n + m)$

$M(n, m) = O(n + m)$

where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits(), and $m$ is max(-bits, 0).

Panics

Let $k$ be bits. Panics if $k$ is positive and rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

impl ShrRoundAssign<u128> for Natural

fn shr_round_assign(&mut self, bits: u128, rm: RoundingMode)

Shifts a Natural right (divides it by a power of 2) and rounds according to the specified rounding mode, in place. Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>=. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

See the ShrRound documentation for details.

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

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

impl ShrRoundAssign<u16> for Natural

fn shr_round_assign(&mut self, bits: u16, rm: RoundingMode)

Shifts a Natural right (divides it by a power of 2) and rounds according to the specified rounding mode, in place. Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>=. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

See the ShrRound documentation for details.

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

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

impl ShrRoundAssign<u32> for Natural

fn shr_round_assign(&mut self, bits: u32, rm: RoundingMode)

Shifts a Natural right (divides it by a power of 2) and rounds according to the specified rounding mode, in place. Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>=. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

See the ShrRound documentation for details.

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

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

impl ShrRoundAssign<u64> for Natural

fn shr_round_assign(&mut self, bits: u64, rm: RoundingMode)

Shifts a Natural right (divides it by a power of 2) and rounds according to the specified rounding mode, in place. Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>=. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

See the ShrRound documentation for details.

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

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

impl ShrRoundAssign<u8> for Natural

fn shr_round_assign(&mut self, bits: u8, rm: RoundingMode)

Shifts a Natural right (divides it by a power of 2) and rounds according to the specified rounding mode, in place. Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>=. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

See the ShrRound documentation for details.

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

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

impl ShrRoundAssign<usize> for Natural

fn shr_round_assign(&mut self, bits: usize, rm: RoundingMode)

Shifts a Natural right (divides it by a power of 2) and rounds according to the specified rounding mode, in place. Passing RoundingMode::Floor or RoundingMode::Down is equivalent to using >>=. To test whether RoundingMode::Exact can be passed, use self.divisible_by_power_of_2(bits).

See the ShrRound documentation for details.

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

Let $k$ be bits. Panics if rm is RoundingMode::Exact but self is not divisible by $2^k$.

Examples

See here.

impl Sign for Natural

fn sign(&self) -> Ordering

Compares a Natural to zero.

Returns Greater or Equal depending on whether the Natural is positive or zero, respectively.

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Sign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;
use std::cmp::Ordering;

assert_eq!(Natural::ZERO.sign(), Ordering::Equal);
assert_eq!(Natural::from(123u32).sign(), Ordering::Greater);

impl<'a> SignificantBits for &'a Natural

fn significant_bits(self) -> u64

Returns the number of significant bits of a Natural.

$$ f(n) = \begin{cases} 0 & \text{if} \quad n = 0, \\ \lfloor \log_2 n \rfloor + 1 & \text{if} \quad n > 0. \end{cases} $$

Worst-case complexity

Constant time and additional memory.

Examples

extern crate malachite_base;

use malachite_base::num::logic::traits::SignificantBits;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.significant_bits(), 0);
assert_eq!(Natural::from(100u32).significant_bits(), 7);

impl SqrtAssignRem for Natural

fn sqrt_assign_rem(&mut self) -> Natural

Replaces a Natural with the floor of its square root and returns the remainder (the difference between the original Natural and the square of the floor).

$f(x) = x - \lfloor\sqrt{x}\rfloor^2$,

$x \gets \lfloor\sqrt{x}\rfloor$.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::SqrtAssignRem;
use malachite_nz::natural::Natural;

let mut x = Natural::from(99u8);
assert_eq!(x.sqrt_assign_rem(), 18);
assert_eq!(x, 9);

let mut x = Natural::from(100u8);
assert_eq!(x.sqrt_assign_rem(), 0);
assert_eq!(x, 10);

let mut x = Natural::from(101u8);
assert_eq!(x.sqrt_assign_rem(), 1);
assert_eq!(x, 10);

let mut x = Natural::from(1000000000u32);
assert_eq!(x.sqrt_assign_rem(), 49116);
assert_eq!(x, 31622);

let mut x = Natural::from(10000000000u64);
assert_eq!(x.sqrt_assign_rem(), 0);
assert_eq!(x, 100000);

type RemOutput = Natural

impl SqrtRem for Natural

fn sqrt_rem(self) -> (Natural, Natural)

Returns the floor of the square root of a Natural and the remainder (the difference between the Natural and the square of the floor). The Natural is taken by value.

$f(x) = (\lfloor\sqrt{x}\rfloor, x - \lfloor\sqrt{x}\rfloor^2)$.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::SqrtRem;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(99u8).sqrt_rem().to_debug_string(), "(9, 18)");
assert_eq!(Natural::from(100u8).sqrt_rem().to_debug_string(), "(10, 0)");
assert_eq!(Natural::from(101u8).sqrt_rem().to_debug_string(), "(10, 1)");
assert_eq!(Natural::from(1000000000u32).sqrt_rem().to_debug_string(), "(31622, 49116)");
assert_eq!(Natural::from(10000000000u64).sqrt_rem().to_debug_string(), "(100000, 0)");

type SqrtOutput = Natural

type RemOutput = Natural

impl<'a> SqrtRem for &'a Natural

fn sqrt_rem(self) -> (Natural, Natural)

Returns the floor of the square root of a Natural and the remainder (the difference between the Natural and the square of the floor). The Natural is taken by reference.

$f(x) = (\lfloor\sqrt{x}\rfloor, x - \lfloor\sqrt{x}\rfloor^2)$.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::SqrtRem;
use malachite_base::strings::ToDebugString;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(99u8)).sqrt_rem().to_debug_string(), "(9, 18)");
assert_eq!((&Natural::from(100u8)).sqrt_rem().to_debug_string(), "(10, 0)");
assert_eq!((&Natural::from(101u8)).sqrt_rem().to_debug_string(), "(10, 1)");
assert_eq!((&Natural::from(1000000000u32)).sqrt_rem().to_debug_string(), "(31622, 49116)");
assert_eq!((&Natural::from(10000000000u64)).sqrt_rem().to_debug_string(), "(100000, 0)");

type SqrtOutput = Natural

type RemOutput = Natural

impl Square for Natural

fn square(self) -> Natural

Squares a Natural, taking it by value.

$$ f(x) = x^2. $$

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Square;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::ZERO.square(), 0);
assert_eq!(Natural::from(123u32).square(), 15129);

type Output = Natural

impl<'a> Square for &'a Natural

fn square(self) -> Natural

Squares a Natural, taking it by reference.

$$ f(x) = x^2. $$

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Square;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!((&Natural::ZERO).square(), 0);
assert_eq!((&Natural::from(123u32)).square(), 15129);

type Output = Natural

impl SquareAssign for Natural

fn square_assign(&mut self)

Squares a Natural in place.

$$ x \gets x^2. $$

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::SquareAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

let mut x = Natural::ZERO;
x.square_assign();
assert_eq!(x, 0);

let mut x = Natural::from(123u32);
x.square_assign();
assert_eq!(x, 15129);

impl<'a> Sub<&'a Natural> for Natural

fn sub(self, other: &'a Natural) -> Natural

Subtracts a Natural by another Natural, taking the first by value and the second by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(123u32) - &Natural::ZERO, 123);
assert_eq!(Natural::from(456u32) - &Natural::from(123u32), 333);
assert_eq!(
    Natural::from(10u32).pow(12) * Natural::from(3u32) - &Natural::from(10u32).pow(12),
    2000000000000u64
);

type Output = Natural

The resulting type after applying the - operator.

impl<'a, 'b> Sub<&'a Natural> for &'b Natural

fn sub(self, other: &'a Natural) -> Natural

Subtracts a Natural by another Natural, taking both by reference.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(&Natural::from(123u32) - &Natural::ZERO, 123);
assert_eq!(&Natural::from(456u32) - &Natural::from(123u32), 333);
assert_eq!(
    &(Natural::from(10u32).pow(12) * Natural::from(3u32)) - &Natural::from(10u32).pow(12),
    2000000000000u64
);

type Output = Natural

The resulting type after applying the - operator.

impl Sub<Natural> for Natural

fn sub(self, other: Natural) -> Natural

Subtracts a Natural by another Natural, taking both by value.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(123u32) - Natural::ZERO, 123);
assert_eq!(Natural::from(456u32) - Natural::from(123u32), 333);
assert_eq!(
    Natural::from(10u32).pow(12) * Natural::from(3u32) - Natural::from(10u32).pow(12),
    2000000000000u64
);

type Output = Natural

The resulting type after applying the - operator.

impl<'a> Sub<Natural> for &'a Natural

fn sub(self, other: Natural) -> Natural

Subtracts a Natural by another Natural, taking the first by reference and the second by value.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::natural::Natural;

assert_eq!(&Natural::from(123u32) - Natural::ZERO, 123);
assert_eq!(&Natural::from(456u32) - Natural::from(123u32), 333);
assert_eq!(
    &(Natural::from(10u32).pow(12) * Natural::from(3u32)) - Natural::from(10u32).pow(12),
    2000000000000u64
);

type Output = Natural

The resulting type after applying the - operator.

impl<'a> SubAssign<&'a Natural> for Natural

fn sub_assign(&mut self, other: &'a Natural)

Subtracts a Natural by another Natural in place, taking the Natural on the right-hand side by reference.

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 other is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_nz::natural::Natural;

let mut x = Natural::from(10u32).pow(12) * Natural::from(10u32);
x -= &Natural::from(10u32).pow(12);
x -= &(Natural::from(10u32).pow(12) * Natural::from(2u32));
x -= &(Natural::from(10u32).pow(12) * Natural::from(3u32));
x -= &(Natural::from(10u32).pow(12) * Natural::from(4u32));
assert_eq!(x, 0);

impl SubAssign<Natural> for Natural

fn sub_assign(&mut self, other: Natural)

Subtracts a Natural by another Natural in place, taking the Natural on the right-hand side by value.

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 other is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::Pow;
use malachite_nz::natural::Natural;

let mut x = Natural::from(10u32).pow(12) * Natural::from(10u32);
x -= Natural::from(10u32).pow(12);
x -= Natural::from(10u32).pow(12) * Natural::from(2u32);
x -= Natural::from(10u32).pow(12) * Natural::from(3u32);
x -= Natural::from(10u32).pow(12) * Natural::from(4u32);
assert_eq!(x, 0);

impl<'a, 'b> SubMul<&'a Natural, &'b Natural> for Natural

fn sub_mul(self, y: &'a Natural, z: &'b Natural) -> Natural

Subtracts a Natural by the product of two other Naturals, taking the first by value and the second and third by reference.

$$ f(x, y, z) = x - yz. $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is x.significant_bits().

Panics

Panics if y * z is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SubMul};
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(20u32).sub_mul(&Natural::from(3u32), &Natural::from(4u32)), 8);
assert_eq!(
    Natural::from(10u32).pow(12)
            .sub_mul(&Natural::from(0x10000u32), &Natural::from(0x10000u32)),
    995705032704u64
);

type Output = Natural

impl<'a, 'b, 'c> SubMul<&'a Natural, &'b Natural> for &'c Natural

fn sub_mul(self, y: &'a Natural, z: &'b Natural) -> Natural

Subtracts a Natural by the product of two other Naturals, taking all three by reference.

$$ f(x, y, z) = x - yz. $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n, m) = O(m + n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is x.significant_bits().

Panics

Panics if y * z is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SubMul};
use malachite_nz::natural::Natural;

assert_eq!((&Natural::from(20u32)).sub_mul(&Natural::from(3u32), &Natural::from(4u32)), 8);
assert_eq!(
    (&Natural::from(10u32).pow(12))
            .sub_mul(&Natural::from(0x10000u32), &Natural::from(0x10000u32)),
    995705032704u64
);

type Output = Natural

impl<'a> SubMul<&'a Natural, Natural> for Natural

fn sub_mul(self, y: &'a Natural, z: Natural) -> Natural

Subtracts a Natural by the product of two other Naturals, taking the first and third by value and the second by reference.

$$ f(x, y, z) = x - yz. $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is x.significant_bits().

Panics

Panics if y * z is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SubMul};
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(20u32).sub_mul(&Natural::from(3u32), Natural::from(4u32)), 8);
assert_eq!(
    Natural::from(10u32).pow(12)
            .sub_mul(&Natural::from(0x10000u32), Natural::from(0x10000u32)),
    995705032704u64
);

type Output = Natural

impl<'a> SubMul<Natural, &'a Natural> for Natural

fn sub_mul(self, y: Natural, z: &'a Natural) -> Natural

Subtracts a Natural by the product of two other Naturals, taking the first two by value and the third by reference.

$$ f(x, y, z) = x - yz. $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is x.significant_bits().

Panics

Panics if y * z is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SubMul};
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(20u32).sub_mul(Natural::from(3u32), &Natural::from(4u32)), 8);
assert_eq!(
    Natural::from(10u32).pow(12)
            .sub_mul(Natural::from(0x10000u32), &Natural::from(0x10000u32)),
    995705032704u64
);

type Output = Natural

impl SubMul<Natural, Natural> for Natural

fn sub_mul(self, y: Natural, z: Natural) -> Natural

Subtracts a Natural by the product of two other Naturals, taking all three by value.

$$ f(x, y, z) = x - yz. $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is x.significant_bits().

Panics

Panics if y * z is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SubMul};
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(20u32).sub_mul(Natural::from(3u32), Natural::from(4u32)), 8);
assert_eq!(
    Natural::from(10u32).pow(12)
            .sub_mul(Natural::from(0x10000u32), Natural::from(0x10000u32)),
    995705032704u64
);

type Output = Natural

impl<'a, 'b> SubMulAssign<&'a Natural, &'b Natural> for Natural

fn sub_mul_assign(&mut self, y: &'a Natural, z: &'b Natural)

Subtracts a Natural by the product of two other Naturals in place, taking both Naturals on the right-hand side by reference.

$$ x \gets x - yz. $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is x.significant_bits().

Panics

Panics if y * z is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SubMulAssign};
use malachite_nz::natural::Natural;

let mut x = Natural::from(20u32);
x.sub_mul_assign(&Natural::from(3u32), &Natural::from(4u32));
assert_eq!(x, 8);

let mut x = Natural::from(10u32).pow(12);
x.sub_mul_assign(&Natural::from(0x10000u32), &Natural::from(0x10000u32));
assert_eq!(x, 995705032704u64);

impl<'a> SubMulAssign<&'a Natural, Natural> for Natural

fn sub_mul_assign(&mut self, y: &'a Natural, z: Natural)

Subtracts a Natural by the product of two other Naturals in place, taking the first Natural on the right-hand side by reference and the second by value.

$$ x \gets x - yz. $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is x.significant_bits().

Panics

Panics if y * z is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SubMulAssign};
use malachite_nz::natural::Natural;

let mut x = Natural::from(20u32);
x.sub_mul_assign(&Natural::from(3u32), Natural::from(4u32));
assert_eq!(x, 8);

let mut x = Natural::from(10u32).pow(12);
x.sub_mul_assign(&Natural::from(0x10000u32), Natural::from(0x10000u32));
assert_eq!(x, 995705032704u64);

impl<'a> SubMulAssign<Natural, &'a Natural> for Natural

fn sub_mul_assign(&mut self, y: Natural, z: &'a Natural)

Subtracts a Natural by the product of two other Naturals in place, taking the first Natural on the right-hand side by value and the second by reference.

$$ x \gets x - yz. $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is x.significant_bits().

Panics

Panics if y * z is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SubMulAssign};
use malachite_nz::natural::Natural;

let mut x = Natural::from(20u32);
x.sub_mul_assign(Natural::from(3u32), &Natural::from(4u32));
assert_eq!(x, 8);

let mut x = Natural::from(10u32).pow(12);
x.sub_mul_assign(Natural::from(0x10000u32), &Natural::from(0x10000u32));
assert_eq!(x, 995705032704u64);

impl SubMulAssign<Natural, Natural> for Natural

fn sub_mul_assign(&mut self, y: Natural, z: Natural)

Subtracts a Natural by the product of two other Naturals in place, taking both Naturals on the right-hand side by value.

$$ x \gets x - yz. $$

Worst-case complexity

$T(n, m) = O(m + n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, $n$ is max(y.significant_bits(), z.significant_bits()), and $m$ is x.significant_bits().

Panics

Panics if y * z is greater than self.

Examples

extern crate malachite_base;

use malachite_base::num::arithmetic::traits::{Pow, SubMulAssign};
use malachite_nz::natural::Natural;

let mut x = Natural::from(20u32);
x.sub_mul_assign(Natural::from(3u32), Natural::from(4u32));
assert_eq!(x, 8);

let mut x = Natural::from(10u32).pow(12);
x.sub_mul_assign(Natural::from(0x10000u32), Natural::from(0x10000u32));
assert_eq!(x, 995705032704u64);

impl ToSci for Natural

fn fmt_sci_valid(&self, options: ToSciOptions) -> bool

Determines whether a Natural can be converted to a string using to_sci and a particular set of options.

Worst-case complexity

$T(n) = O(n \log n \log\log n)$

$M(n) = O(n \log n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::conversion::string::options::ToSciOptions;
use malachite_base::num::conversion::traits::ToSci;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

let mut options = ToSciOptions::default();
assert!(Natural::from(123u8).fmt_sci_valid(options));
assert!(Natural::from(u128::MAX).fmt_sci_valid(options));
// u128::MAX has more than 16 significant digits
options.set_rounding_mode(RoundingMode::Exact);
assert!(!Natural::from(u128::MAX).fmt_sci_valid(options));
options.set_precision(50);
assert!(Natural::from(u128::MAX).fmt_sci_valid(options));

fn fmt_sci(&self, f: &mut Formatter<'_>, options: ToSciOptions) -> Result

Converts a Natural to a string using a specified base, possibly formatting the number using scientific notation.

See ToSciOptions for details on the available options. Note that setting neg_exp_threshold has no effect, since there is never a need to use negative exponents when representing a Natural.

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 options.rounding_mode is Exact, but the size options are such that the input must be rounded.

Examples

extern crate malachite_base;

use malachite_base::num::conversion::string::options::ToSciOptions;
use malachite_base::num::conversion::traits::ToSci;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::natural::Natural;

assert_eq!(format!("{}", Natural::from(u128::MAX).to_sci()), "3.402823669209385e38");
assert_eq!(Natural::from(u128::MAX).to_sci().to_string(), "3.402823669209385e38");

let n = Natural::from(123456u32);
let mut options = ToSciOptions::default();
assert_eq!(format!("{}", n.to_sci_with_options(options)), "123456");
assert_eq!(n.to_sci_with_options(options).to_string(), "123456");

options.set_precision(3);
assert_eq!(n.to_sci_with_options(options).to_string(), "1.23e5");

options.set_rounding_mode(RoundingMode::Ceiling);
assert_eq!(n.to_sci_with_options(options).to_string(), "1.24e5");

options.set_e_uppercase();
assert_eq!(n.to_sci_with_options(options).to_string(), "1.24E5");

options.set_force_exponent_plus_sign(true);
assert_eq!(n.to_sci_with_options(options).to_string(), "1.24E+5");

options = ToSciOptions::default();
options.set_base(36);
assert_eq!(n.to_sci_with_options(options).to_string(), "2n9c");

options.set_uppercase();
assert_eq!(n.to_sci_with_options(options).to_string(), "2N9C");

options.set_base(2);
options.set_precision(10);
assert_eq!(n.to_sci_with_options(options).to_string(), "1.1110001e16");

options.set_include_trailing_zeros(true);
assert_eq!(n.to_sci_with_options(options).to_string(), "1.111000100e16");

fn to_sci_with_options(&self, options: ToSciOptions) -> SciWrapper<'_, Self>

Converts a number to a string, possibly in scientific notation.

fn to_sci(&self) -> SciWrapper<'_, Self>

Converts a number to a string, possibly in scientific notation, using the default ToSciOptions.

impl ToStringBase for Natural

fn to_string_base(&self, base: u8) -> String

Converts a Natural to a String using a specified base.

Digits from 0 to 9 become chars from '0' to '9'. Digits from 10 to 35 become the lowercase chars 'a' to 'z'.

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 base is less than 2 or greater than 36.

Examples

extern crate malachite_base;

use malachite_base::num::conversion::traits::ToStringBase;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(1000u32).to_string_base(2), "1111101000");
assert_eq!(Natural::from(1000u32).to_string_base(10), "1000");
assert_eq!(Natural::from(1000u32).to_string_base(36), "rs");

fn to_string_base_upper(&self, base: u8) -> String

Converts a Natural to a String using a specified base.

Digits from 0 to 9 become chars from '0' to '9'. Digits from 10 to 35 become the uppercase chars 'A' to 'Z'.

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 base is less than 2 or greater than 36.

Examples

extern crate malachite_base;

use malachite_base::num::conversion::traits::ToStringBase;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(1000u32).to_string_base_upper(2), "1111101000");
assert_eq!(Natural::from(1000u32).to_string_base_upper(10), "1000");
assert_eq!(Natural::from(1000u32).to_string_base_upper(36), "RS");

impl Two for Natural

The constant 2.

const TWO: Natural = Natural(Small(2))

impl UpperHex for Natural

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Converts a Natural to a hexadecimal String using uppercase characters.

Using the # format flag prepends "0x" to the string.

Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits().

Examples

extern crate malachite_base;

use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToUpperHexString;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(Natural::ZERO.to_upper_hex_string(), "0");
assert_eq!(Natural::from(123u32).to_upper_hex_string(), "7B");
assert_eq!(
    Natural::from_str("1000000000000").unwrap().to_upper_hex_string(),
    "E8D4A51000"
);
assert_eq!(format!("{:07X}", Natural::from(123u32)), "000007B");

assert_eq!(format!("{:#X}", Natural::ZERO), "0x0");
assert_eq!(format!("{:#X}", Natural::from(123u32)), "0x7B");
assert_eq!(
    format!("{:#X}", Natural::from_str("1000000000000").unwrap()),
    "0xE8D4A51000"
);
assert_eq!(format!("{:#07X}", Natural::from(123u32)), "0x0007B");

impl<'a> WrappingFrom<&'a Natural> for u8

fn wrapping_from(value: &Natural) -> u8

Converts a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> WrappingFrom<&'a Natural> for i8

fn wrapping_from(value: &Natural) -> i8

Converts a Natural to a value of a signed primitive integer type that’s smaller than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> WrappingFrom<&'a Natural> for usize

fn wrapping_from(value: &Natural) -> usize

Converts a Natural to a usize or a value of an unsigned primitive integer type that’s larger than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> WrappingFrom<&'a Natural> for isize

fn wrapping_from(value: &Natural) -> isize

Converts a Natural to an isize or a value of a signed primitive integer type that’s larger than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> WrappingFrom<&'a Natural> for u16

fn wrapping_from(value: &Natural) -> u16

Converts a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> WrappingFrom<&'a Natural> for i16

fn wrapping_from(value: &Natural) -> i16

Converts a Natural to a value of a signed primitive integer type that’s smaller than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> WrappingFrom<&'a Natural> for u32

fn wrapping_from(value: &Natural) -> u32

Converts a Natural to a value of an unsigned primitive integer type that’s smaller than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> WrappingFrom<&'a Natural> for i32

fn wrapping_from(value: &Natural) -> i32

Converts a Natural to a value of a signed primitive integer type that’s smaller than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> WrappingFrom<&'a Natural> for u64

fn wrapping_from(value: &Natural) -> u64

Converts a Natural to a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> WrappingFrom<&'a Natural> for i64

fn wrapping_from(value: &Natural) -> i64

Converts a Natural to a SignedLimb (the signed type whose width is the same as a limb’s), wrapping modulo $2^W$, where $W$ is the width of a limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> WrappingFrom<&'a Natural> for u128

fn wrapping_from(value: &Natural) -> u128

Converts a Natural to a usize or a value of an unsigned primitive integer type that’s larger than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl<'a> WrappingFrom<&'a Natural> for i128

fn wrapping_from(value: &Natural) -> i128

Converts a Natural to an isize or a value of a signed primitive integer type that’s larger than a Limb, wrapping modulo $2^W$, where $W$ is the width of a limb.

Worst-case complexity

Constant time and additional memory.

Examples

See here.

impl Zero for Natural

The constant 0.

const ZERO: Natural = Natural(Small(0))

impl Eq for Natural

impl StructuralEq for Natural

impl StructuralPartialEq for Natural