Struct Integer

Source

pub struct Integer { /* private fields */ }

Expand description

An integer.

Any Integer whose absolute value is small enough to fit into a Limb is represented inline. Only integers outside this range incur the costs of heap-allocation.

Implementations§

Source §

impl Integer

Source

pub const fn unsigned_abs_ref(&self) -> &Natural

Finds the absolute value of an Integer, taking the Integer by reference and returning a reference to the internal Natural absolute value.

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

§Worst-case complexity

Constant time and additional memory.

§Examples

use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(*Integer::ZERO.unsigned_abs_ref(), 0);
assert_eq!(*Integer::from(123).unsigned_abs_ref(), 123);
assert_eq!(*Integer::from(-123).unsigned_abs_ref(), 123);

Source

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

Mutates the absolute value of an Integer using a provided closure, and then returns whatever the closure returns.

This function is similar to the unsigned_abs_ref function, which returns a reference to the absolute value. A function that returns a mutable reference would be too dangerous, as it could leave the Integer in an invalid state (specifically, with a negative sign but a zero absolute value). So rather than returning a mutable reference, this function allows mutation of the absolute value using a closure. After the closure executes, this function ensures that the Integer remains valid.

There is only constant time and memory overhead on top of the time and memory used by the closure.

§Examples

use malachite_base::num::arithmetic::traits::DivAssignMod;
use malachite_base::num::basic::traits::Two;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

let mut n = Integer::from(-123);
let remainder = n.mutate_unsigned_abs(|x| x.div_assign_mod(Natural::TWO));
assert_eq!(n, -61);
assert_eq!(remainder, 1);

let mut n = Integer::from(-123);
n.mutate_unsigned_abs(|x| *x >>= 10);
assert_eq!(n, 0);

Source §

impl Integer

Source

pub fn from_sign_and_abs(sign: bool, abs: Natural) -> Self

Converts a sign and a Natural to an Integer, taking the Natural by value. The Natural becomes the Integer’s absolute value, and the sign indicates whether the Integer should be non-negative. If the Natural is zero, then the Integer will be non-negative regardless of the sign.

§Worst-case complexity

Constant time and additional memory.

§Examples

use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert_eq!(Integer::from_sign_and_abs(true, Natural::from(123u32)), 123);
assert_eq!(
    Integer::from_sign_and_abs(false, Natural::from(123u32)),
    -123
);

Source

pub fn from_sign_and_abs_ref(sign: bool, abs: &Natural) -> Self

Converts a sign and an Natural to an Integer, taking the Natural by reference. The Natural becomes the Integer’s absolute value, and the sign indicates whether the Integer should be non-negative. If the Natural is zero, then the Integer will be non-negative regardless of the sign.

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

§Examples

use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert_eq!(
    Integer::from_sign_and_abs_ref(true, &Natural::from(123u32)),
    123
);
assert_eq!(
    Integer::from_sign_and_abs_ref(false, &Natural::from(123u32)),
    -123
);

Source §

impl Integer

Source

pub const fn const_from_unsigned(x: Limb) -> Self

Converts a Limb to an Integer.

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

§Worst-case complexity

Constant time and additional memory.

§Examples

use malachite_nz::integer::Integer;

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

Source

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

Converts a SignedLimb to an Integer.

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

§Worst-case complexity

Constant time and additional memory.

§Examples

use malachite_nz::integer::Integer;

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

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

Source §

use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_nz::integer::Integer;
use malachite_nz::platform::Limb;

if Limb::WIDTH == u32::WIDTH {
    assert_eq!(Integer::from_owned_twos_complement_limbs_desc(vec![]), 0);
    assert_eq!(
        Integer::from_owned_twos_complement_limbs_desc(vec![123]),
        123
    );
    assert_eq!(
        Integer::from_owned_twos_complement_limbs_desc(vec![4294967173]),
        -123
    );
    // 10^12 = 232 * 2^32 + 3567587328
    assert_eq!(
        Integer::from_owned_twos_complement_limbs_desc(vec![232, 3567587328]),
        1000000000000i64
    );
    assert_eq!(
        Integer::from_owned_twos_complement_limbs_desc(vec![4294967063, 727379968]),
        -1000000000000i64
    );
}

Source §

impl Integer

Source

pub fn to_twos_complement_limbs_asc(&self) -> Vec<Limb> ⓘ

Returns the limbs of an Integer, in ascending order, so that less significant limbs have lower indices in the output vector.

The limbs are in two’s complement, and the most significant bit of the limbs indicates the sign; if the bit is zero, the Integer is positive, and if the bit is one it is negative. There are no trailing zero limbs if the Integer is positive or trailing Limb::MAX limbs if the Integer is negative, except as necessary to include the correct sign bit. Zero is a special case: it contains no limbs.

This function borrows self. If taking ownership of self is possible, into_twos_complement_limbs_asc is more efficient.

This function is more efficient than to_twos_complement_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

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
use malachite_nz::platform::Limb;

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

Source

pub fn to_twos_complement_limbs_desc(&self) -> Vec<Limb> ⓘ

Returns the limbs of an Integer, in descending order, so that less significant limbs have higher indices in the output vector.

The limbs are in two’s complement, and the most significant bit of the limbs indicates the sign; if the bit is zero, the Integer is positive, and if the bit is one it is negative. There are no leading zero limbs if the Integer is non-negative or leading Limb::MAX limbs if the Integer is negative, except as necessary to include the correct sign bit. Zero is a special case: it contains no limbs.

This is similar to how BigIntegers in Java are represented.

This function borrows self. If taking ownership of self is possible, into_twos_complement_limbs_desc is more efficient.

This function is less efficient than to_twos_complement_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

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
use malachite_nz::platform::Limb;

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

Source

pub fn into_twos_complement_limbs_asc(self) -> Vec<Limb> ⓘ

Returns the limbs of an Integer, in ascending order, so that less significant limbs have lower indices in the output vector.

The limbs are in two’s complement, and the most significant bit of the limbs indicates the sign; if the bit is zero, the Integer is positive, and if the bit is one it is negative. There are no trailing zero limbs if the Integer is positive or trailing Limb::MAX limbs if the Integer is negative, except as necessary to include the correct sign bit. Zero is a special case: it contains no limbs.

This function takes ownership of self. If it’s necessary to borrow self instead, use to_twos_complement_limbs_asc.

This function is more efficient than into_twos_complement_limbs_desc.

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

§Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
use malachite_nz::platform::Limb;

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

Source

pub fn into_twos_complement_limbs_desc(self) -> Vec<Limb> ⓘ

Returns the limbs of an Integer, in descending order, so that less significant limbs have higher indices in the output vector.

The limbs are in two’s complement, and the most significant bit of the limbs indicates the sign; if the bit is zero, the Integer is positive, and if the bit is one it is negative. There are no leading zero limbs if the Integer is non-negative or leading Limb::MAX limbs if the Integer is negative, except as necessary to include the correct sign bit. Zero is a special case: it contains no limbs.

This is similar to how BigIntegers in Java are represented.

This function takes ownership of self. If it’s necessary to borrow self instead, use to_twos_complement_limbs_desc.

This function is less efficient than into_twos_complement_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

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
use malachite_nz::platform::Limb;

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

Source

pub fn twos_complement_limbs(&self) -> TwosComplementLimbIterator<'_> ⓘ

Returns a double-ended iterator over the twos-complement limbs of an Integer.

The forward order is ascending, so that less significant limbs appear first. There may be a most-significant sign-extension limb.

If it’s necessary to get a Vec of all the twos_complement limbs, consider using to_twos_complement_limbs_asc, to_twos_complement_limbs_desc, into_twos_complement_limbs_asc, or into_twos_complement_limbs_desc instead.

§Worst-case complexity

Constant time and additional memory.

§Examples

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::integer::Integer;
use malachite_nz::platform::Limb;

if Limb::WIDTH == u32::WIDTH {
    assert!(Integer::ZERO.twos_complement_limbs().next().is_none());
    assert_eq!(
        Integer::from(123).twos_complement_limbs().collect_vec(),
        &[123]
    );
    assert_eq!(
        Integer::from(-123).twos_complement_limbs().collect_vec(),
        &[4294967173]
    );
    // 10^12 = 232 * 2^32 + 3567587328
    assert_eq!(
        Integer::from(10u32)
            .pow(12)
            .twos_complement_limbs()
            .collect_vec(),
        &[3567587328, 232]
    );
    // Sign-extension for a non-negative `Integer`
    assert_eq!(
        Integer::from(4294967295i64)
            .twos_complement_limbs()
            .collect_vec(),
        &[4294967295, 0]
    );
    assert_eq!(
        (-Integer::from(10u32).pow(12))
            .twos_complement_limbs()
            .collect_vec(),
        &[727379968, 4294967063]
    );
    // Sign-extension for a negative `Integer`
    assert_eq!(
        (-Integer::from(4294967295i64))
            .twos_complement_limbs()
            .collect_vec(),
        &[1, 4294967295]
    );

    assert!(Integer::ZERO.twos_complement_limbs().next_back().is_none());
    assert_eq!(
        Integer::from(123)
            .twos_complement_limbs()
            .rev()
            .collect_vec(),
        &[123]
    );
    assert_eq!(
        Integer::from(-123)
            .twos_complement_limbs()
            .rev()
            .collect_vec(),
        &[4294967173]
    );
    // 10^12 = 232 * 2^32 + 3567587328
    assert_eq!(
        Integer::from(10u32)
            .pow(12)
            .twos_complement_limbs()
            .rev()
            .collect_vec(),
        &[232, 3567587328]
    );
    // Sign-extension for a non-negative `Integer`
    assert_eq!(
        Integer::from(4294967295i64)
            .twos_complement_limbs()
            .rev()
            .collect_vec(),
        &[0, 4294967295]
    );
    assert_eq!(
        (-Integer::from(10u32).pow(12))
            .twos_complement_limbs()
            .rev()
            .collect_vec(),
        &[4294967063, 727379968]
    );
    // Sign-extension for a negative `Integer`
    assert_eq!(
        (-Integer::from(4294967295i64))
            .twos_complement_limbs()
            .rev()
            .collect_vec(),
        &[4294967295, 1]
    );
}

Source

pub fn twos_complement_limb_count(&self) -> u64

Returns the number of twos-complement limbs of an Integer. There may be a most-significant sign-extension limb, which is included in the count.

Zero has 0 limbs.

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

§Examples

use malachite_base::num::arithmetic::traits::{Pow, PowerOf2};
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::integer::Integer;
use malachite_nz::platform::Limb;

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

    let n = Integer::power_of_2(Limb::WIDTH - 1);
    assert_eq!((&n - Integer::ONE).twos_complement_limb_count(), 1);
    assert_eq!(n.twos_complement_limb_count(), 2);
    assert_eq!((&n + Integer::ONE).twos_complement_limb_count(), 2);
    assert_eq!((-(&n - Integer::ONE)).twos_complement_limb_count(), 1);
    assert_eq!((-&n).twos_complement_limb_count(), 1);
    assert_eq!((-(&n + Integer::ONE)).twos_complement_limb_count(), 2);
}

Source §

impl Integer

Source

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

Counts the number of ones in the binary expansion of an Integer. If the Integer is negative, then the number of ones is infinite, so 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 self.significant_bits().

§Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.checked_count_ones(), Some(0));
// 105 = 1101001b
assert_eq!(Integer::from(105).checked_count_ones(), Some(4));
assert_eq!(Integer::from(-105).checked_count_ones(), None);
// 10^12 = 1110100011010100101001010001000000000000b
assert_eq!(Integer::from(10u32).pow(12).checked_count_ones(), Some(13));

Source §

impl Integer

Source

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

Counts the number of zeros in the binary expansion of an Integer. If the Integer is non-negative, then the number of zeros is infinite, so 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 self.significant_bits().

§Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.checked_count_zeros(), None);
// -105 = 10010111 in two's complement
assert_eq!(Integer::from(-105).checked_count_zeros(), Some(3));
assert_eq!(Integer::from(105).checked_count_zeros(), None);
// -10^12 = 10001011100101011010110101111000000000000 in two's complement
assert_eq!(
    (-Integer::from(10u32).pow(12)).checked_count_zeros(),
    Some(24)
);

Source §

impl Integer

Source

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

Returns the number of trailing zeros in the binary expansion of an Integer (equivalently, the multiplicity of 2 in its prime factorization), or None is the Integer 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

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

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

Trait Implementations§

Source §

impl Abs for &Integer

Source §

fn abs(self) -> Integer

Takes the absolute value of an Integer, taking the Integer by reference.

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

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

§Examples

use malachite_base::num::arithmetic::traits::Abs;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!((&Integer::ZERO).abs(), 0);
assert_eq!((&Integer::from(123)).abs(), 123);
assert_eq!((&Integer::from(-123)).abs(), 123);

Source §

$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

use malachite_base::num::arithmetic::traits::{AbsDiff, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!((&Integer::from(123)).abs_diff(&Integer::ZERO), 123);
assert_eq!((&Integer::ZERO).abs_diff(&Integer::from(123)), 123);
assert_eq!((&Integer::from(456)).abs_diff(&Integer::from(-123)), 579);
assert_eq!((&Integer::from(123)).abs_diff(&Integer::from(-456)), 579);
assert_eq!(
    (&(Integer::from(10).pow(12) * Integer::from(3))).abs_diff(&Integer::from(10).pow(12)),
    2000000000000u64
);
assert_eq!(
    (&(-Integer::from(10).pow(12)))
        .abs_diff(&(-Integer::from(10).pow(12) * Integer::from(3))),
    2000000000000u64
);

Source §

type Output = Natural

Source §

impl AbsDiff<&Integer> for Integer

Source §

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

Computes the absolute value of the difference between two Integers, taking the first by value and the second by reference. A Natural is returned.

$$ f(x, y) = |x - y|. $$

§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

use malachite_base::num::arithmetic::traits::{AbsDiff, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(123).abs_diff(&Integer::ZERO), 123);
assert_eq!(Integer::ZERO.abs_diff(&Integer::from(123)), 123);
assert_eq!(Integer::from(456).abs_diff(&Integer::from(-123)), 579);
assert_eq!(Integer::from(123).abs_diff(&Integer::from(-456)), 579);
assert_eq!(
    (Integer::from(10).pow(12) * Integer::from(3)).abs_diff(&Integer::from(10).pow(12)),
    2000000000000u64
);
assert_eq!(
    (-Integer::from(10).pow(12)).abs_diff(&(-Integer::from(10).pow(12) * Integer::from(3))),
    2000000000000u64
);

Source §

type Output = Natural

Source §

impl AbsDiff<Integer> for &Integer

Source §

fn abs_diff(self, other: Integer) -> Natural

Computes the absolute value of the difference between two Integers, taking the first by reference and the second by value. A Natural is returned.

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

use malachite_base::num::arithmetic::traits::{AbsDiff, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!((&Integer::from(123)).abs_diff(Integer::ZERO), 123);
assert_eq!((&Integer::ZERO).abs_diff(Integer::from(123)), 123);
assert_eq!((&Integer::from(456)).abs_diff(Integer::from(-123)), 579);
assert_eq!((&Integer::from(123)).abs_diff(Integer::from(-456)), 579);
assert_eq!(
    (&(Integer::from(10).pow(12) * Integer::from(3))).abs_diff(Integer::from(10).pow(12)),
    2000000000000u64
);
assert_eq!(
    (&(-Integer::from(10).pow(12))).abs_diff(-Integer::from(10).pow(12) * Integer::from(3)),
    2000000000000u64
);

Source §

type Output = Natural

Source §

impl AbsDiff for Integer

Source §

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

Computes the absolute value of the difference between two Integers, taking both by value. A Natural is returned.

$$ f(x, y) = |x - y|. $$

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

§Examples

use malachite_base::num::arithmetic::traits::{AbsDiff, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(123).abs_diff(Integer::ZERO), 123);
assert_eq!(Integer::ZERO.abs_diff(Integer::from(123)), 123);
assert_eq!(Integer::from(456).abs_diff(Integer::from(-123)), 579);
assert_eq!(Integer::from(123).abs_diff(Integer::from(-456)), 579);
assert_eq!(
    (Integer::from(10).pow(12) * Integer::from(3)).abs_diff(Integer::from(10).pow(12)),
    2000000000000u64
);
assert_eq!(
    (-Integer::from(10).pow(12)).abs_diff(-Integer::from(10).pow(12) * Integer::from(3)),
    2000000000000u64
);

Source §

type Output = Natural

Source §

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

Source §

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

Subtracts an Integer by another Integer in place and takes the absolute value, taking the Integer on the right-hand side by reference.

$$ x \gets |x - y|. $$

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

§Panics

Panics if other is greater than self.

§Examples

use malachite_base::num::arithmetic::traits::{AbsDiffAssign, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

let mut x = Integer::from(123);
x.abs_diff_assign(&Integer::ZERO);
assert_eq!(x, 123);

let mut x = Integer::ZERO;
x.abs_diff_assign(&Integer::from(123));
assert_eq!(x, 123);

let mut x = Integer::from(456);
x.abs_diff_assign(&Integer::from(-123));
assert_eq!(x, 579);

let mut x = Integer::from(-123);
x.abs_diff_assign(&Integer::from(456));
assert_eq!(x, 579);

let mut x = Integer::from(10).pow(12) * Integer::from(3);
x.abs_diff_assign(&Integer::from(10u32).pow(12));
assert_eq!(x, 2000000000000u64);

let mut x = -Integer::from(10u32).pow(12);
x.abs_diff_assign(&(-(Integer::from(10).pow(12) * Integer::from(3))));
assert_eq!(x, 2000000000000u64);

Source §

impl AbsDiffAssign for Integer

Source §

fn abs_diff_assign(&mut self, other: Self)

Subtracts an Integer by another Integer in place and takes the absolute value, taking the Integer on the right-hand side by value.

$$ x \gets |x - y|. $$

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

§Panics

Panics if other is greater than self.

§Examples

use malachite_base::num::arithmetic::traits::{AbsDiffAssign, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

let mut x = Integer::from(123);
x.abs_diff_assign(Integer::ZERO);
assert_eq!(x, 123);

let mut x = Integer::ZERO;
x.abs_diff_assign(Integer::from(123));
assert_eq!(x, 123);

let mut x = Integer::from(456);
x.abs_diff_assign(Integer::from(-123));
assert_eq!(x, 579);

let mut x = Integer::from(-123);
x.abs_diff_assign(Integer::from(456));
assert_eq!(x, 579);

let mut x = Integer::from(10).pow(12) * Integer::from(3);
x.abs_diff_assign(Integer::from(10u32).pow(12));
assert_eq!(x, 2000000000000u64);

let mut x = -Integer::from(10u32).pow(12);
x.abs_diff_assign(-(Integer::from(10).pow(12) * Integer::from(3)));
assert_eq!(x, 2000000000000u64);

Source §

impl Add<&Integer> for &Integer

Source §

fn add(self, other: &Integer) -> Integer

Adds two Integers, 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

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(&Integer::ZERO + &Integer::from(123), 123);
assert_eq!(&Integer::from(-123) + &Integer::ZERO, -123);
assert_eq!(&Integer::from(-123) + &Integer::from(456), 333);
assert_eq!(
    &-Integer::from(10u32).pow(12) + &(Integer::from(10u32).pow(12) << 1),
    1000000000000u64
);

Source §

type Output = Integer

The resulting type after applying the + operator.

Source §

impl Add<&Integer> for Integer

Source §

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

Adds two Integers, 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

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO + &Integer::from(123), 123);
assert_eq!(Integer::from(-123) + &Integer::ZERO, -123);
assert_eq!(Integer::from(-123) + &Integer::from(456), 333);
assert_eq!(
    -Integer::from(10u32).pow(12) + &(Integer::from(10u32).pow(12) << 1),
    1000000000000u64
);

Source §

type Output = Integer

The resulting type after applying the + operator.

Source §

impl Add<Integer> for &Integer

Source §

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

Adds two Integers, 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

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(&Integer::ZERO + Integer::from(123), 123);
assert_eq!(&Integer::from(-123) + Integer::ZERO, -123);
assert_eq!(&Integer::from(-123) + Integer::from(456), 333);
assert_eq!(
    &-Integer::from(10u32).pow(12) + (Integer::from(10u32).pow(12) << 1),
    1000000000000u64
);

Source §

type Output = Integer

The resulting type after applying the + operator.

Source §

impl Add for Integer

Source §

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

Adds two Integers, 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

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO + Integer::from(123), 123);
assert_eq!(Integer::from(-123) + Integer::ZERO, -123);
assert_eq!(Integer::from(-123) + Integer::from(456), 333);
assert_eq!(
    -Integer::from(10u32).pow(12) + (Integer::from(10u32).pow(12) << 1),
    1000000000000u64
);

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

§Examples

use malachite_base::num::arithmetic::traits::{AddMul, Pow};
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(10u32).add_mul(&Integer::from(3u32), Integer::from(4u32)),
    22
);
assert_eq!(
    (-Integer::from(10u32).pow(12))
        .add_mul(&Integer::from(0x10000), -Integer::from(10u32).pow(12)),
    -65537000000000000i64
);

Source §

type Output = Integer

Source §

impl AddMul<&Integer, &Integer> for &Integer

Source §

fn add_mul(self, y: &Integer, z: &Integer) -> Integer

Adds an Integer and the product of two other Integers, 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

use malachite_base::num::arithmetic::traits::{AddMul, Pow};
use malachite_nz::integer::Integer;

assert_eq!(
    (&Integer::from(10u32)).add_mul(&Integer::from(3u32), &Integer::from(4u32)),
    22
);
assert_eq!(
    (&-Integer::from(10u32).pow(12))
        .add_mul(&Integer::from(0x10000), &-Integer::from(10u32).pow(12)),
    -65537000000000000i64
);

Source §

type Output = Integer

Source §

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

Source §

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

Adds an Integer and the product of two other Integers, 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

use malachite_base::num::arithmetic::traits::{AddMul, Pow};
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(10u32).add_mul(&Integer::from(3u32), &Integer::from(4u32)),
    22
);
assert_eq!(
    (-Integer::from(10u32).pow(12))
        .add_mul(&Integer::from(0x10000), &-Integer::from(10u32).pow(12)),
    -65537000000000000i64
);

Source §

type Output = Integer

Source §

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

Source §

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

Adds an Integer and the product of two other Integers, 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

use malachite_base::num::arithmetic::traits::{AddMul, Pow};
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(10u32).add_mul(Integer::from(3u32), &Integer::from(4u32)),
    22
);
assert_eq!(
    (-Integer::from(10u32).pow(12))
        .add_mul(Integer::from(0x10000), &-Integer::from(10u32).pow(12)),
    -65537000000000000i64
);

Source §

type Output = Integer

Source §

impl AddMul for Integer

Source §

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

Adds an Integer and the product of two other Integers, 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

use malachite_base::num::arithmetic::traits::{AddMul, Pow};
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(10u32).add_mul(Integer::from(3u32), Integer::from(4u32)),
    22
);
assert_eq!(
    (-Integer::from(10u32).pow(12))
        .add_mul(Integer::from(0x10000), -Integer::from(10u32).pow(12)),
    -65537000000000000i64
);

Source §

use core::str::FromStr;
use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToBinaryString;
use malachite_nz::integer::Integer;

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

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

Source §

impl<'a> BinomialCoefficient<&'a Integer> for Integer

Source §

fn binomial_coefficient(n: &'a Self, k: &'a Self) -> Self

Computes the binomial coefficient of two Integers, taking both by reference.

The second argument must be non-negative, but the first may be negative. If it is, the identity $\binom{-n}{k} = (-1)^k \binom{n+k-1}{k}$ is used.

$$ f(n, k) = \begin{cases} \binom{n}{k} & \text{if} \quad n \geq 0, \\ (-1)^k \binom{-n+k-1}{k} & \text{if} \quad n < 0. \end{cases} $$

§Worst-case complexity

TODO

§Panics

Panics if $k$ is negative.

§Examples

use malachite_base::num::arithmetic::traits::BinomialCoefficient;
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::binomial_coefficient(&Integer::from(4), &Integer::from(0)),
    1
);
assert_eq!(
    Integer::binomial_coefficient(&Integer::from(4), &Integer::from(1)),
    4
);
assert_eq!(
    Integer::binomial_coefficient(&Integer::from(4), &Integer::from(2)),
    6
);
assert_eq!(
    Integer::binomial_coefficient(&Integer::from(4), &Integer::from(3)),
    4
);
assert_eq!(
    Integer::binomial_coefficient(&Integer::from(4), &Integer::from(4)),
    1
);
assert_eq!(
    Integer::binomial_coefficient(&Integer::from(10), &Integer::from(5)),
    252
);
assert_eq!(
    Integer::binomial_coefficient(&Integer::from(100), &Integer::from(50)).to_string(),
    "100891344545564193334812497256"
);

assert_eq!(
    Integer::binomial_coefficient(&Integer::from(-3), &Integer::from(0)),
    1
);
assert_eq!(
    Integer::binomial_coefficient(&Integer::from(-3), &Integer::from(1)),
    -3
);
assert_eq!(
    Integer::binomial_coefficient(&Integer::from(-3), &Integer::from(2)),
    6
);
assert_eq!(
    Integer::binomial_coefficient(&Integer::from(-3), &Integer::from(3)),
    -10
);

Source §

impl BinomialCoefficient for Integer

Source §

fn binomial_coefficient(n: Self, k: Self) -> Self

Computes the binomial coefficient of two Integers, taking both by value.

The second argument must be non-negative, but the first may be negative. If it is, the identity $\binom{-n}{k} = (-1)^k \binom{n+k-1}{k}$ is used.

$$ f(n, k) = \begin{cases} \binom{n}{k} & \text{if} \quad n \geq 0, \\ (-1)^k \binom{-n+k-1}{k} & \text{if} \quad n < 0. \end{cases} $$

§Worst-case complexity

TODO

§Panics

Panics if $k$ is negative.

§Examples

use malachite_base::num::arithmetic::traits::BinomialCoefficient;
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::binomial_coefficient(Integer::from(4), Integer::from(0)),
    1
);
assert_eq!(
    Integer::binomial_coefficient(Integer::from(4), Integer::from(1)),
    4
);
assert_eq!(
    Integer::binomial_coefficient(Integer::from(4), Integer::from(2)),
    6
);
assert_eq!(
    Integer::binomial_coefficient(Integer::from(4), Integer::from(3)),
    4
);
assert_eq!(
    Integer::binomial_coefficient(Integer::from(4), Integer::from(4)),
    1
);
assert_eq!(
    Integer::binomial_coefficient(Integer::from(10), Integer::from(5)),
    252
);
assert_eq!(
    Integer::binomial_coefficient(Integer::from(100), Integer::from(50)).to_string(),
    "100891344545564193334812497256"
);

assert_eq!(
    Integer::binomial_coefficient(Integer::from(-3), Integer::from(0)),
    1
);
assert_eq!(
    Integer::binomial_coefficient(Integer::from(-3), Integer::from(1)),
    -3
);
assert_eq!(
    Integer::binomial_coefficient(Integer::from(-3), Integer::from(2)),
    6
);
assert_eq!(
    Integer::binomial_coefficient(Integer::from(-3), Integer::from(3)),
    -10
);

Source §

impl BitAccess for Integer

Provides functions for accessing and modifying the $i$th bit of a Integer, or the coefficient of $2^i$ in its two’s complement binary expansion.

§Examples

use malachite_base::num::basic::traits::{NegativeOne, Zero};
use malachite_base::num::logic::traits::BitAccess;
use malachite_nz::integer::Integer;

let mut x = Integer::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 = Integer::from(-0x100);
x.assign_bit(2, true);
x.assign_bit(5, true);
x.assign_bit(6, true);
assert_eq!(x, -156);
x.assign_bit(2, false);
x.assign_bit(5, false);
x.assign_bit(6, false);
assert_eq!(x, -256);

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

let mut x = Integer::NEGATIVE_ONE;
x.flip_bit(10);
assert_eq!(x, -1025);
x.flip_bit(10);
assert_eq!(x, -1);

Source §

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

Determines whether the $i$th bit of an Integer, or the coefficient of $2^i$ in its two’s complement binary expansion, is 0 or 1.

false means 0 and true means 1. Getting bits beyond the Integer’s width is allowed; those bits are false if the Integer is non-negative and true if it is negative.

If $n \geq 0$, let $$ n = \sum_{i=0}^\infty 2^{b_i}; $$ but if $n < 0$, let $$ -n - 1 = \sum_{i=0}^\infty 2^{1 - b_i}, $$ where for all $i$, $b_i\in \{0, 1\}$.

$f(n, i) = (b_i = 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

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::logic::traits::BitAccess;
use malachite_nz::integer::Integer;

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

Source §

fn set_bit(&mut self, index: u64)

Sets the $i$th bit of an Integer, or the coefficient of $2^i$ in its two’s complement binary expansion, to 1.

If $n \geq 0$, let $$ n = \sum_{i=0}^\infty 2^{b_i}; $$ but if $n < 0$, let $$ -n - 1 = \sum_{i=0}^\infty 2^{1 - b_i}, $$ where for all $i$, $b_i\in \{0, 1\}$. $$ 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

use malachite_base::num::basic::traits::Zero;
use malachite_base::num::logic::traits::BitAccess;
use malachite_nz::integer::Integer;

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

let mut x = Integer::from(-0x100);
x.set_bit(2);
x.set_bit(5);
x.set_bit(6);
assert_eq!(x, -156);

Source §

fn clear_bit(&mut self, index: u64)

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

If $n \geq 0$, let $$ n = \sum_{i=0}^\infty 2^{b_i}; $$ but if $n < 0$, let $$ -n - 1 = \sum_{i=0}^\infty 2^{1 - b_i}, $$ where for all $i$, $b_i\in \{0, 1\}$. $$ 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(n)$

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

§Examples

use malachite_base::num::logic::traits::BitAccess;
use malachite_nz::integer::Integer;

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

let mut x = Integer::from(-156);
x.clear_bit(2);
x.clear_bit(5);
x.clear_bit(6);
assert_eq!(x, -256);

Source §

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

Sets the bit at index to whichever value bit is. Read more

Source §

fn flip_bit(&mut self, index: u64)

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

Source §

impl BitAnd<&Integer> for &Integer

Source §

fn bitand(self, other: &Integer) -> Integer

Takes the bitwise and of two Integers, 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 max(self.significant_bits(), other.significant_bits()).

§Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::integer::Integer;

assert_eq!(&Integer::from(-123) & &Integer::from(-456), -512);
assert_eq!(
    &-Integer::from(10u32).pow(12) & &-(Integer::from(10u32).pow(12) + Integer::ONE),
    -1000000004096i64
);

Source §

type Output = Integer

The resulting type after applying the & operator.

Source §

impl BitAnd<&Integer> for Integer

Source §

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

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

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

§Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

§Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(-123) & &Integer::from(-456), -512);
assert_eq!(
    -Integer::from(10u32).pow(12) & &-(Integer::from(10u32).pow(12) + Integer::ONE),
    -1000000004096i64
);

Source §

type Output = Integer

The resulting type after applying the & operator.

Source §

impl BitAnd<Integer> for &Integer

Source §

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

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

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

§Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

§Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::integer::Integer;

assert_eq!(&Integer::from(-123) & Integer::from(-456), -512);
assert_eq!(
    &-Integer::from(10u32).pow(12) & -(Integer::from(10u32).pow(12) + Integer::ONE),
    -1000000004096i64
);

Source §

type Output = Integer

The resulting type after applying the & operator.

Source §

impl BitAnd for Integer

Source §

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

Takes the bitwise and of two Integers, 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 max(self.significant_bits(), other.significant_bits()).

§Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(-123) & Integer::from(-456), -512);
assert_eq!(
    -Integer::from(10u32).pow(12) & -(Integer::from(10u32).pow(12) + Integer::ONE),
    -1000000004096i64
);

Source §

type Output = Integer

The resulting type after applying the & operator.

Source §

impl BitAndAssign<&Integer> for Integer

Source §

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

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

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

§Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

§Examples

use malachite_base::num::basic::traits::NegativeOne;
use malachite_nz::integer::Integer;

let mut x = Integer::NEGATIVE_ONE;
x &= &Integer::from(0x70ffffff);
x &= &Integer::from(0x7ff0_ffff);
x &= &Integer::from(0x7ffff0ff);
x &= &Integer::from(0x7ffffff0);
assert_eq!(x, 0x70f0f0f0);

Source §

impl BitAndAssign for Integer

Source §

fn bitand_assign(&mut self, other: Self)

Bitwise-ands an Integer with another Integer in place, taking the Integer 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 max(self.significant_bits(), other.significant_bits()).

§Examples

use malachite_base::num::basic::traits::NegativeOne;
use malachite_nz::integer::Integer;

let mut x = Integer::NEGATIVE_ONE;
x &= Integer::from(0x70ffffff);
x &= Integer::from(0x7ff0_ffff);
x &= Integer::from(0x7ffff0ff);
x &= Integer::from(0x7ffffff0);
assert_eq!(x, 0x70f0f0f0);

Source §

impl BitBlockAccess for Integer

Source §

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

Extracts a block of adjacent two’s complement bits from an Integer, taking the Integer 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.

If $n \geq 0$, let $$ n = \sum_{i=0}^\infty 2^{b_i}; $$ but if $n < 0$, let $$ -n - 1 = \sum_{i=0}^\infty 2^{1 - b_i}, $$ where for all $i$, $b_i\in \{0, 1\}$. 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 max(self.significant_bits(), end).

§Panics

Panics if start > end.

§Examples

use core::str::FromStr;
use malachite_base::num::basic::traits::Zero;
use malachite_base::num::logic::traits::BitBlockAccess;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert_eq!(
    (-Natural::from(0xabcdef0112345678u64)).get_bits(16, 48),
    Natural::from(0x10feedcbu32)
);
assert_eq!(
    Integer::from(0xabcdef0112345678u64).get_bits(4, 16),
    Natural::from(0x567u32)
);
assert_eq!(
    (-Natural::from(0xabcdef0112345678u64)).get_bits(0, 100),
    Natural::from_str("1267650600215849587758112418184").unwrap()
);
assert_eq!(
    Integer::from(0xabcdef0112345678u64).get_bits(10, 10),
    Natural::ZERO
);

Source §

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

Extracts a block of adjacent two’s complement bits from an Integer, taking the Integer 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.

If $n \geq 0$, let $$ n = \sum_{i=0}^\infty 2^{b_i}; $$ but if $n < 0$, let $$ -n - 1 = \sum_{i=0}^\infty 2^{1 - b_i}, $$ where for all $i$, $b_i\in \{0, 1\}$. 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 max(self.significant_bits(), end).

§Panics

Panics if start > end.

§Examples

use core::str::FromStr;
use malachite_base::num::basic::traits::Zero;
use malachite_base::num::logic::traits::BitBlockAccess;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert_eq!(
    (-Natural::from(0xabcdef0112345678u64)).get_bits_owned(16, 48),
    Natural::from(0x10feedcbu32)
);
assert_eq!(
    Integer::from(0xabcdef0112345678u64).get_bits_owned(4, 16),
    Natural::from(0x567u32)
);
assert_eq!(
    (-Natural::from(0xabcdef0112345678u64)).get_bits_owned(0, 100),
    Natural::from_str("1267650600215849587758112418184").unwrap()
);
assert_eq!(
    Integer::from(0xabcdef0112345678u64).get_bits_owned(10, 10),
    Natural::ZERO
);

Source §

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

Replaces a block of adjacent two’s complement bits in an Integer 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.

Let $$ m = \sum_{i=0}^k 2^{d_i}, $$ where for all $i$, $d_i\in \{0, 1\}$.

If $n \geq 0$, let $$ n = \sum_{i=0}^\infty 2^{b_i}; $$ but if $n < 0$, let $$ -n - 1 = \sum_{i=0}^\infty 2^{1 - b_i}, $$ where for all $i$, $b_i\in \{0, 1\}$. Then $$ n \gets \sum_{i=0}^\infty 2^{c_i}, $$ where $$ \{c_0, c_1, c_2, \ldots \} = \{b_0, b_1, b_2, \ldots, b_{p-1}, d_0, d_1, \ldots, d_{p-q-1}, b_q, b_{q+1}, \ldots \}. $$

§Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

§Panics

Panics if start > end.

§Examples

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

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

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

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

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

§Examples

use malachite_base::num::basic::traits::Zero;
use malachite_base::num::logic::traits::BitConvertible;
use malachite_nz::integer::Integer;

assert!(Integer::ZERO.to_bits_asc().is_empty());
// 105 = 01101001b, with a leading false bit to indicate sign
assert_eq!(
    Integer::from(105).to_bits_asc(),
    &[true, false, false, true, false, true, true, false]
);
// -105 = 10010111 in two's complement, with a leading true bit to indicate sign
assert_eq!(
    Integer::from(-105).to_bits_asc(),
    &[true, true, true, false, true, false, false, true]
);

Source §

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

Returns a Vec containing the twos-complement bits of an Integer in descending order: most- to least-significant.

The most significant bit indicates the sign; if the bit is false, the Integer is positive, and if the bit is true it is negative. There are no leading false bits if the Integer is positive or leading true bits if the Integer is negative, except as necessary to include the correct sign bit. Zero is a special case: it contains no bits.

This is similar to how BigIntegers in Java are represented.

This function is less efficient than to_bits_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

use malachite_base::num::basic::traits::Zero;
use malachite_base::num::logic::traits::BitConvertible;
use malachite_nz::integer::Integer;

assert!(Integer::ZERO.to_bits_desc().is_empty());
// 105 = 01101001b, with a leading false bit to indicate sign
assert_eq!(
    Integer::from(105).to_bits_desc(),
    &[false, true, true, false, true, false, false, true]
);
// -105 = 10010111 in two's complement, with a leading true bit to indicate sign
assert_eq!(
    Integer::from(-105).to_bits_desc(),
    &[true, false, false, true, false, true, true, true]
);

Source §

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

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

Let $k$ be bits.count(). If $k = 0$ or $b_{k-1}$ is false, then $$ 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.

If $b_{k-1}$ is true, then $$ f((b_i)_ {i=0}^{k-1}) = \left ( \sum_{i=0}^{k-1}2^i [b_i] \right ) - 2^k. $$

§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

use core::iter::empty;
use malachite_base::num::logic::traits::BitConvertible;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from_bits_asc(empty()), 0);
// 105 = 1101001b
assert_eq!(
    Integer::from_bits_asc(
        [true, false, false, true, false, true, true, false]
            .iter()
            .cloned()
    ),
    105
);
// -105 = 10010111 in two's complement, with a leading true bit to indicate sign
assert_eq!(
    Integer::from_bits_asc(
        [true, true, true, false, true, false, false, true]
            .iter()
            .cloned()
    ),
    -105
);

Source §

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

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

If bits is empty or $b_0$ is false, then $$ 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.

If $b_0$ is true, then $$ f((b_i)_ {i=0}^{k-1}) = \left ( \sum_{i=0}^{k-1}2^{k-i-1} [b_i] \right ) - 2^k. $$

§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

use core::iter::empty;
use malachite_base::num::logic::traits::BitConvertible;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from_bits_desc(empty()), 0);
// 105 = 1101001b
assert_eq!(
    Integer::from_bits_desc(
        [false, true, true, false, true, false, false, true]
            .iter()
            .cloned()
    ),
    105
);
// -105 = 10010111 in two's complement, with a leading true bit to indicate sign
assert_eq!(
    Integer::from_bits_desc(
        [true, false, false, true, false, true, true, true]
            .iter()
            .cloned()
    ),
    -105
);

Source §

impl<'a> BitIterable for &'a Integer

Source §

fn bits(self) -> IntegerBitIterator<'a> ⓘ

Returns a double-ended iterator over the bits of an Integer.

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, except for possibly a most-significant sign-extension bit.

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

use itertools::Itertools;
use malachite_base::num::basic::traits::Zero;
use malachite_base::num::logic::traits::BitIterable;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.bits().next(), None);
// 105 = 01101001b, with a leading false bit to indicate sign
assert_eq!(
    Integer::from(105).bits().collect_vec(),
    &[true, false, false, true, false, true, true, false]
);
// -105 = 10010111 in two's complement, with a leading true bit to indicate sign
assert_eq!(
    Integer::from(-105).bits().collect_vec(),
    &[true, true, true, false, true, false, false, true]
);

assert_eq!(Integer::ZERO.bits().next_back(), None);
// 105 = 01101001b, with a leading false bit to indicate sign
assert_eq!(
    Integer::from(105).bits().rev().collect_vec(),
    &[false, true, true, false, true, false, false, true]
);
// -105 = 10010111 in two's complement, with a leading true bit to indicate sign
assert_eq!(
    Integer::from(-105).bits().rev().collect_vec(),
    &[true, false, false, true, false, true, true, true]
);

Source §

type BitIterator = IntegerBitIterator<'a>

Source §

impl BitOr<&Integer> for &Integer

Source §

fn bitor(self, other: &Integer) -> Integer

Takes the bitwise or of two Integers, 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

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::integer::Integer;

assert_eq!(&Integer::from(-123) | &Integer::from(-456), -67);
assert_eq!(
    &-Integer::from(10u32).pow(12) | &-(Integer::from(10u32).pow(12) + Integer::ONE),
    -999999995905i64
);

Source §

type Output = Integer

The resulting type after applying the | operator.

Source §

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

Source §

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

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

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

§Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

§Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(-123) | &Integer::from(-456), -67);
assert_eq!(
    -Integer::from(10u32).pow(12) | &-(Integer::from(10u32).pow(12) + Integer::ONE),
    -999999995905i64
);

Source §

type Output = Integer

The resulting type after applying the | operator.

Source §

impl BitOr<Integer> for &Integer

Source §

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

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

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

§Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

§Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::integer::Integer;

assert_eq!(&Integer::from(-123) | Integer::from(-456), -67);
assert_eq!(
    &-Integer::from(10u32).pow(12) | -(Integer::from(10u32).pow(12) + Integer::ONE),
    -999999995905i64
);

Source §

type Output = Integer

The resulting type after applying the | operator.

Source §

impl BitOr for Integer

Source §

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

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

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

§Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

§Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(-123) | Integer::from(-456), -67);
assert_eq!(
    -Integer::from(10u32).pow(12) | -(Integer::from(10u32).pow(12) + Integer::ONE),
    -999999995905i64
);

Source §

type Output = Integer

The resulting type after applying the | operator.

Source §

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

Source §

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

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

§Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

§Examples

use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

let mut x = Integer::ZERO;
x |= &Integer::from(0x0000000f);
x |= &Integer::from(0x00000f00);
x |= &Integer::from(0x000f_0000);
x |= &Integer::from(0x0f000000);
assert_eq!(x, 0x0f0f_0f0f);

Source §

impl BitOrAssign for Integer

Source §

fn bitor_assign(&mut self, other: Self)

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

§Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

§Examples

use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

let mut x = Integer::ZERO;
x |= Integer::from(0x0000000f);
x |= Integer::from(0x00000f00);
x |= Integer::from(0x000f_0000);
x |= Integer::from(0x0f000000);
assert_eq!(x, 0x0f0f_0f0f);

Source §

impl BitScan for &Integer

Source §

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

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

If the [Integer] is negative, and the starting index is too large and there are no more false bits above it, 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 self.significant_bits().

§Examples

use malachite_base::num::logic::traits::BitScan;
use malachite_nz::integer::Integer;

assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_false_bit(0),
    Some(0)
);
assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_false_bit(20),
    Some(20)
);
assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_false_bit(31),
    Some(31)
);
assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_false_bit(32),
    Some(34)
);
assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_false_bit(33),
    Some(34)
);
assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_false_bit(34),
    Some(34)
);
assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_false_bit(35),
    None
);
assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_false_bit(100),
    None
);

Source §

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

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

If the Integer is non-negative, and the starting index is too large and there are no more true bits above it, 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 self.significant_bits().

§Examples

use malachite_base::num::logic::traits::BitScan;
use malachite_nz::integer::Integer;

assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_true_bit(0),
    Some(32)
);
assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_true_bit(20),
    Some(32)
);
assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_true_bit(31),
    Some(32)
);
assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_true_bit(32),
    Some(32)
);
assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_true_bit(33),
    Some(33)
);
assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_true_bit(34),
    Some(35)
);
assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_true_bit(35),
    Some(35)
);
assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_true_bit(36),
    Some(36)
);
assert_eq!(
    (-Integer::from(0x500000000u64)).index_of_next_true_bit(100),
    Some(100)
);

Source §

impl BitXor<&Integer> for &Integer

Source §

fn bitxor(self, other: &Integer) -> Integer

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

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

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

§Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::integer::Integer;

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

Source §

type Output = Integer

The resulting type after applying the ^ operator.

Source §

impl BitXor<&Integer> for Integer

Source §

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

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

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

§Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

§Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::integer::Integer;

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

Source §

type Output = Integer

The resulting type after applying the ^ operator.

Source §

impl BitXor<Integer> for &Integer

Source §

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

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

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

§Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

§Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::integer::Integer;

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

Source §

type Output = Integer

The resulting type after applying the ^ operator.

Source §

impl BitXor for Integer

Source §

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

Takes the bitwise xor of two Integers, 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 max(self.significant_bits(), other.significant_bits()).

§Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(-123) ^ Integer::from(-456), 445);
assert_eq!(
    -Integer::from(10u32).pow(12) ^ -(Integer::from(10u32).pow(12) + Integer::ONE),
    8191
);

Source §

type Output = Integer

The resulting type after applying the ^ operator.

Source §

impl BitXorAssign<&Integer> for Integer

Source §

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

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

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

§Worst-case complexity

$T(n) = O(n)$

$M(m) = O(m)$

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

§Examples

use malachite_nz::integer::Integer;

let mut x = Integer::from(u32::MAX);
x ^= &Integer::from(0x0000000f);
x ^= &Integer::from(0x00000f00);
x ^= &Integer::from(0x000f_0000);
x ^= &Integer::from(0x0f000000);
assert_eq!(x, 0xf0f0_f0f0u32);

Source §

impl BitXorAssign for Integer

Source §

fn bitxor_assign(&mut self, other: Self)

Bitwise-xors an Integer with another Integer in place, taking the Integer 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 max(self.significant_bits(), other.significant_bits()).

§Examples

use malachite_nz::integer::Integer;

let mut x = Integer::from(u32::MAX);
x ^= Integer::from(0x0000000f);
x ^= Integer::from(0x00000f00);
x ^= Integer::from(0x000f_0000);
x ^= Integer::from(0x0f000000);
assert_eq!(x, 0xf0f0_f0f0u32);

Source §

impl CeilingDivAssignMod<&Integer> for Integer

Source §

fn ceiling_div_assign_mod(&mut self, other: &Self) -> Self

Divides an Integer by another Integer in place, taking the Integer on the right-hand side by reference and returning the remainder. The quotient is rounded towards positive infinity and the remainder has the opposite sign as the second Integer.

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

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

use malachite_base::num::arithmetic::traits::CeilingDivAssignMod;
use malachite_nz::integer::Integer;

// 3 * 10 + -7 = 23
let mut x = Integer::from(23);
assert_eq!(x.ceiling_div_assign_mod(&Integer::from(10)), -7);
assert_eq!(x, 3);

// -2 * -10 + 3 = 23
let mut x = Integer::from(23);
assert_eq!(x.ceiling_div_assign_mod(&Integer::from(-10)), 3);
assert_eq!(x, -2);

// -2 * 10 + -3 = -23
let mut x = Integer::from(-23);
assert_eq!(x.ceiling_div_assign_mod(&Integer::from(10)), -3);
assert_eq!(x, -2);

// 3 * -10 + 7 = -23
let mut x = Integer::from(-23);
assert_eq!(x.ceiling_div_assign_mod(&Integer::from(-10)), 7);
assert_eq!(x, 3);

Source §

type ModOutput = Integer

Source §

impl CeilingDivAssignMod for Integer

Source §

fn ceiling_div_assign_mod(&mut self, other: Self) -> Self

Divides an Integer by another Integer in place, taking the Integer on the right-hand side by value and returning the remainder. The quotient is rounded towards positive infinity and the remainder has the opposite sign as the second Integer.

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

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

use malachite_base::num::arithmetic::traits::CeilingDivAssignMod;
use malachite_nz::integer::Integer;

// 3 * 10 + -7 = 23
let mut x = Integer::from(23);
assert_eq!(x.ceiling_div_assign_mod(Integer::from(10)), -7);
assert_eq!(x, 3);

// -2 * -10 + 3 = 23
let mut x = Integer::from(23);
assert_eq!(x.ceiling_div_assign_mod(Integer::from(-10)), 3);
assert_eq!(x, -2);

// -2 * 10 + -3 = -23
let mut x = Integer::from(-23);
assert_eq!(x.ceiling_div_assign_mod(Integer::from(10)), -3);
assert_eq!(x, -2);

// 3 * -10 + 7 = -23
let mut x = Integer::from(-23);
assert_eq!(x.ceiling_div_assign_mod(Integer::from(-10)), 7);
assert_eq!(x, 3);

Source §

type ModOutput = Integer

Source §

impl CeilingDivMod<&Integer> for &Integer

Source §

fn ceiling_div_mod(self, other: &Integer) -> (Integer, Integer)

Divides an Integer by another Integer, taking both by reference and returning the quotient and remainder. The quotient is rounded towards positive infinity and the remainder has the opposite sign as the second Integer.

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 x - y\left \lceil \frac{x}{y} \right \rceil \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

use malachite_base::num::arithmetic::traits::CeilingDivMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// 3 * 10 + -7 = 23
assert_eq!(
    (&Integer::from(23))
        .ceiling_div_mod(&Integer::from(10))
        .to_debug_string(),
    "(3, -7)"
);

// -2 * -10 + 3 = 23
assert_eq!(
    (&Integer::from(23))
        .ceiling_div_mod(&Integer::from(-10))
        .to_debug_string(),
    "(-2, 3)"
);

// -2 * 10 + -3 = -23
assert_eq!(
    (&Integer::from(-23))
        .ceiling_div_mod(&Integer::from(10))
        .to_debug_string(),
    "(-2, -3)"
);

// 3 * -10 + 7 = -23
assert_eq!(
    (&Integer::from(-23))
        .ceiling_div_mod(&Integer::from(-10))
        .to_debug_string(),
    "(3, 7)"
);

Source §

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

Divides an Integer by another Integer, taking both the first by value and the second by reference and returning the quotient and remainder. The quotient is rounded towards positive infinity and the remainder has the opposite sign as the second Integer.

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 x - y\left \lceil \frac{x}{y} \right \rceil \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

use malachite_base::num::arithmetic::traits::CeilingDivMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// 3 * 10 + -7 = 23
assert_eq!(
    Integer::from(23)
        .ceiling_div_mod(&Integer::from(10))
        .to_debug_string(),
    "(3, -7)"
);

// -2 * -10 + 3 = 23
assert_eq!(
    Integer::from(23)
        .ceiling_div_mod(&Integer::from(-10))
        .to_debug_string(),
    "(-2, 3)"
);

// -2 * 10 + -3 = -23
assert_eq!(
    Integer::from(-23)
        .ceiling_div_mod(&Integer::from(10))
        .to_debug_string(),
    "(-2, -3)"
);

// 3 * -10 + 7 = -23
assert_eq!(
    Integer::from(-23)
        .ceiling_div_mod(&Integer::from(-10))
        .to_debug_string(),
    "(3, 7)"
);

Panics if other is zero.

§Examples

use malachite_base::num::arithmetic::traits::CeilingDivMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// 3 * 10 + -7 = 23
assert_eq!(
    (&Integer::from(23))
        .ceiling_div_mod(Integer::from(10))
        .to_debug_string(),
    "(3, -7)"
);

// -2 * -10 + 3 = 23
assert_eq!(
    (&Integer::from(23))
        .ceiling_div_mod(Integer::from(-10))
        .to_debug_string(),
    "(-2, 3)"
);

// -2 * 10 + -3 = -23
assert_eq!(
    (&Integer::from(-23))
        .ceiling_div_mod(Integer::from(10))
        .to_debug_string(),
    "(-2, -3)"
);

// 3 * -10 + 7 = -23
assert_eq!(
    (&Integer::from(-23))
        .ceiling_div_mod(Integer::from(-10))
        .to_debug_string(),
    "(3, 7)"
);

Panics if other is zero.

§Examples

use malachite_base::num::arithmetic::traits::CeilingDivMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// 3 * 10 + -7 = 23
assert_eq!(
    Integer::from(23)
        .ceiling_div_mod(Integer::from(10))
        .to_debug_string(),
    "(3, -7)"
);

// -2 * -10 + 3 = 23
assert_eq!(
    Integer::from(23)
        .ceiling_div_mod(Integer::from(-10))
        .to_debug_string(),
    "(-2, 3)"
);

// -2 * 10 + -3 = -23
assert_eq!(
    Integer::from(-23)
        .ceiling_div_mod(Integer::from(10))
        .to_debug_string(),
    "(-2, -3)"
);

// 3 * -10 + 7 = -23
assert_eq!(
    Integer::from(-23)
        .ceiling_div_mod(Integer::from(-10))
        .to_debug_string(),
    "(3, 7)"
);

Panics if other is zero.

§Examples

use malachite_base::num::arithmetic::traits::CeilingMod;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!((&Integer::from(23)).ceiling_mod(&Integer::from(10)), -7);

// -3 * -10 + -7 = 23
assert_eq!((&Integer::from(23)).ceiling_mod(&Integer::from(-10)), 3);

// -3 * 10 + 7 = -23
assert_eq!((&Integer::from(-23)).ceiling_mod(&Integer::from(10)), -3);

// 2 * -10 + -3 = -23
assert_eq!((&Integer::from(-23)).ceiling_mod(&Integer::from(-10)), 7);

Source §

type Output = Integer

Source §

impl CeilingMod<&Integer> for Integer

Source §

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

Divides an Integer by another Integer, taking the first by value and the second by reference and returning just the remainder. The remainder has the opposite sign as the second Integer.

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

use malachite_base::num::arithmetic::traits::CeilingMod;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(Integer::from(23).ceiling_mod(&Integer::from(10)), -7);

// -3 * -10 + -7 = 23
assert_eq!(Integer::from(23).ceiling_mod(&Integer::from(-10)), 3);

// -3 * 10 + 7 = -23
assert_eq!(Integer::from(-23).ceiling_mod(&Integer::from(10)), -3);

// 2 * -10 + -3 = -23
assert_eq!(Integer::from(-23).ceiling_mod(&Integer::from(-10)), 7);

Source §

type Output = Integer

Source §

impl CeilingMod<Integer> for &Integer

Source §

fn ceiling_mod(self, other: Integer) -> Integer

Divides an Integer by another Integer, taking the first by reference and the second by value and returning just the remainder. The remainder has the opposite sign as the second Integer.

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

use malachite_base::num::arithmetic::traits::CeilingMod;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!((&Integer::from(23)).ceiling_mod(Integer::from(10)), -7);

// -3 * -10 + -7 = 23
assert_eq!((&Integer::from(23)).ceiling_mod(Integer::from(-10)), 3);

// -3 * 10 + 7 = -23
assert_eq!((&Integer::from(-23)).ceiling_mod(Integer::from(10)), -3);

// 2 * -10 + -3 = -23
assert_eq!((&Integer::from(-23)).ceiling_mod(Integer::from(-10)), 7);

Source §

type Output = Integer

Source §

impl CeilingMod for Integer

Source §

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

Divides an Integer by another Integer, taking both by value and returning just the remainder. The remainder has the opposite sign as the second Integer.

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

use malachite_base::num::arithmetic::traits::CeilingMod;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(Integer::from(23).ceiling_mod(Integer::from(10)), -7);

// -3 * -10 + -7 = 23
assert_eq!(Integer::from(23).ceiling_mod(Integer::from(-10)), 3);

// -3 * 10 + 7 = -23
assert_eq!(Integer::from(-23).ceiling_mod(Integer::from(10)), -3);

// 2 * -10 + -3 = -23
assert_eq!(Integer::from(-23).ceiling_mod(Integer::from(-10)), 7);

Source §

type Output = Integer

Source §

impl CeilingModAssign<&Integer> for Integer

Source §

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

Divides an Integer by another Integer, taking the Integer on the right-hand side by reference and replacing the first number by the remainder. The remainder has the opposite sign as the second number.

If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq |r| < |y|$.

$$ x \gets x - y\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

use malachite_base::num::arithmetic::traits::CeilingModAssign;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
let mut x = Integer::from(23);
x.ceiling_mod_assign(&Integer::from(10));
assert_eq!(x, -7);

// -3 * -10 + -7 = 23
let mut x = Integer::from(23);
x.ceiling_mod_assign(&Integer::from(-10));
assert_eq!(x, 3);

// -3 * 10 + 7 = -23
let mut x = Integer::from(-23);
x.ceiling_mod_assign(&Integer::from(10));
assert_eq!(x, -3);

// 2 * -10 + -3 = -23
let mut x = Integer::from(-23);
x.ceiling_mod_assign(&Integer::from(-10));
assert_eq!(x, 7);

Source §

impl CeilingModAssign for Integer

Source §

fn ceiling_mod_assign(&mut self, other: Self)

Divides an Integer by another Integer, taking the Integer on the right-hand side by value and replacing the first number by the remainder. The remainder has the opposite sign as the second number.

If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq |r| < |y|$.

$$ x \gets x - y\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

use malachite_base::num::arithmetic::traits::CeilingModAssign;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
let mut x = Integer::from(23);
x.ceiling_mod_assign(Integer::from(10));
assert_eq!(x, -7);

// -3 * -10 + -7 = 23
let mut x = Integer::from(23);
x.ceiling_mod_assign(Integer::from(-10));
assert_eq!(x, 3);

// -3 * 10 + 7 = -23
let mut x = Integer::from(-23);
x.ceiling_mod_assign(Integer::from(10));
assert_eq!(x, -3);

// 2 * -10 + -3 = -23
let mut x = Integer::from(-23);
x.ceiling_mod_assign(Integer::from(-10));
assert_eq!(x, 7);

Source §

impl CeilingModPowerOf2 for &Integer

Source §

fn ceiling_mod_power_of_2(self, pow: u64) -> Integer

Divides an Integer by $2^k$, taking it by reference and returning just the remainder. The remainder is non-positive.

If the quotient were computed, the quotient and remainder would satisfy $x = q2^k + r$ and $0 \leq -r < 2^k$.

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

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

§Examples

use malachite_base::num::arithmetic::traits::CeilingModPowerOf2;
use malachite_nz::integer::Integer;

// 2 * 2^8 + -252 = 260
assert_eq!((&Integer::from(260)).ceiling_mod_power_of_2(8), -252);
// -100 * 2^4 + -11 = -1611
assert_eq!((&Integer::from(-1611)).ceiling_mod_power_of_2(4), -11);

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

§Examples

use malachite_base::num::arithmetic::traits::CeilingModPowerOf2;
use malachite_nz::integer::Integer;

// 2 * 2^8 + -252 = 260
assert_eq!(Integer::from(260).ceiling_mod_power_of_2(8), -252);

// -100 * 2^4 + -11 = -1611
assert_eq!(Integer::from(-1611).ceiling_mod_power_of_2(4), -11);

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

§Examples

use malachite_base::num::arithmetic::traits::CeilingModPowerOf2Assign;
use malachite_nz::integer::Integer;

// 2 * 2^8 + -252 = 260
let mut x = Integer::from(260);
x.ceiling_mod_power_of_2_assign(8);
assert_eq!(x, -252);

// -100 * 2^4 + -11 = -1611
let mut x = Integer::from(-1611);
x.ceiling_mod_power_of_2_assign(4);
assert_eq!(x, -11);

Source §

impl CeilingRoot<u64> for &Integer

Source §

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

Returns the ceiling of the $n$th root of an Integer, taking the Integer 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, or if exp is even and self is negative.

§Examples

use malachite_base::num::arithmetic::traits::CeilingRoot;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(999).ceiling_root(3), 10);
assert_eq!(Integer::from(1000).ceiling_root(3), 10);
assert_eq!(Integer::from(1001).ceiling_root(3), 11);
assert_eq!(Integer::from(100000000000i64).ceiling_root(5), 159);
assert_eq!(Integer::from(-100000000000i64).ceiling_root(5), -158);

Source §

type Output = Integer

Source §

impl CeilingRoot<u64> for Integer

Source §

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

Returns the ceiling of the $n$th root of an Integer, taking the Integer 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, or if exp is even and self is negative.

§Examples

use malachite_base::num::arithmetic::traits::CeilingRoot;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(999).ceiling_root(3), 10);
assert_eq!(Integer::from(1000).ceiling_root(3), 10);
assert_eq!(Integer::from(1001).ceiling_root(3), 11);
assert_eq!(Integer::from(100000000000i64).ceiling_root(5), 159);
assert_eq!(Integer::from(-100000000000i64).ceiling_root(5), -158);

Source §

type Output = Integer

Source §

impl CeilingRootAssign<u64> for Integer

Source §

fn ceiling_root_assign(&mut self, exp: u64)

Replaces an Integer 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, or if exp is even and self is negative.

§Examples

use malachite_base::num::arithmetic::traits::CeilingRootAssign;
use malachite_nz::integer::Integer;

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

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

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

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

let mut x = Integer::from(-100000000000i64);
x.ceiling_root_assign(5);
assert_eq!(x, -158);

Source §

impl CeilingSqrt for &Integer

Source §

fn ceiling_sqrt(self) -> Integer

Returns the ceiling of the square root of an Integer, taking it by reference.

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

§Panics

Panics if self is negative.

§Examples

use malachite_base::num::arithmetic::traits::CeilingSqrt;
use malachite_nz::integer::Integer;

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

Source §

type Output = Integer

Source §

impl CeilingSqrt for Integer

Source §

fn ceiling_sqrt(self) -> Self

Returns the ceiling of the square root of an Integer, 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().

§Panics

Panics if self is negative.

§Examples

use malachite_base::num::arithmetic::traits::CeilingSqrt;
use malachite_nz::integer::Integer;

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

Source §

type Output = Integer

Source §

impl CeilingSqrtAssign for Integer

Source §

fn ceiling_sqrt_assign(&mut self)

Replaces an Integer 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().

§Panics

Panics if self is negative.

§Examples

use malachite_base::num::arithmetic::traits::CeilingSqrtAssign;
use malachite_nz::integer::Integer;

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

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

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

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

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

Source §

impl CheckedDiv<&Integer> for &Integer

Source §

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

Divides an Integer by another Integer, 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$. Returns None when the second Integer is zero, Some otherwise.

$$ f(x, y) = \begin{cases} \operatorname{Some}\left ( \left \lfloor \frac{x}{y} \right \rfloor \right ) & \text{if} \quad y \neq 0 \\ \text{None} & \text{otherwise} \end{cases} $$

§Worst-case complexity

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

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

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

§Panics

Panics if other is zero.

§Examples

use malachite_base::num::arithmetic::traits::CheckedDiv;
use malachite_base::num::basic::traits::{One, Zero};
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// -2 * -10 + 3 = 23
assert_eq!(
    (&Integer::from(23))
        .checked_div(&Integer::from(-10))
        .to_debug_string(),
    "Some(-2)"
);
assert_eq!((&Integer::ONE).checked_div(&Integer::ZERO), None);

Source §

type Output = Integer

Source §

impl CheckedDiv<&Integer> for Integer

Source §

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

Divides an Integer by another Integer, 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$. Returns None when the second Integer is zero, Some otherwise.

$$ f(x, y) = \begin{cases} \operatorname{Some}\left ( \left \lfloor \frac{x}{y} \right \rfloor \right ) & \text{if} \quad y \neq 0 \\ \text{None} & \text{otherwise} \end{cases} $$

§Worst-case complexity

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

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

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

§Panics

Panics if other is zero.

§Examples

use malachite_base::num::arithmetic::traits::CheckedDiv;
use malachite_base::num::basic::traits::{One, Zero};
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// -2 * -10 + 3 = 23
assert_eq!(
    Integer::from(23)
        .checked_div(&Integer::from(-10))
        .to_debug_string(),
    "Some(-2)"
);
assert_eq!(Integer::ONE.checked_div(&Integer::ZERO), None);

Source §

type Output = Integer

Source §

impl CheckedDiv<Integer> for &Integer

Source §

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

Divides an Integer by another Integer, 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$. Returns None when the second Integer is zero, Some otherwise.

$$ f(x, y) = \begin{cases} \operatorname{Some}\left ( \left \lfloor \frac{x}{y} \right \rfloor \right ) & \text{if} \quad y \neq 0 \\ \text{None} & \text{otherwise} \end{cases} $$

§Worst-case complexity

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

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

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

§Panics

Panics if other is zero.

§Examples

use malachite_base::num::arithmetic::traits::CheckedDiv;
use malachite_base::num::basic::traits::{One, Zero};
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// -2 * -10 + 3 = 23
assert_eq!(
    (&Integer::from(23))
        .checked_div(Integer::from(-10))
        .to_debug_string(),
    "Some(-2)"
);
assert_eq!((&Integer::ONE).checked_div(Integer::ZERO), None);

Source §

type Output = Integer

Source §

impl CheckedDiv for Integer

Source §

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

Divides an Integer by another Integer, 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$. Returns None when the second Integer is zero, Some otherwise.

$$ f(x, y) = \begin{cases} \operatorname{Some}\left ( \left \lfloor \frac{x}{y} \right \rfloor \right ) & \text{if} \quad y \neq 0 \\ \text{None} & \text{otherwise} \end{cases} $$

§Worst-case complexity

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

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

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

§Panics

Panics if other is zero.

§Examples

use malachite_base::num::arithmetic::traits::CheckedDiv;
use malachite_base::num::basic::traits::{One, Zero};
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// -2 * -10 + 3 = 23
assert_eq!(
    Integer::from(23)
        .checked_div(Integer::from(-10))
        .to_debug_string(),
    "Some(-2)"
);
assert_eq!(Integer::ONE.checked_div(Integer::ZERO), None);

Source §

type Output = Integer

Source §

impl CheckedHammingDistance<&Integer> for &Integer

Source §

fn checked_hamming_distance(self, other: &Integer) -> Option<u64>

Determines the Hamming distance between two Integers.

The two Integers have infinitely many leading zeros or infinitely many leading ones, depending on their signs. If they are both non-negative or both negative, the Hamming distance is finite. If one is non-negative and the other is negative, the Hamming distance is infinite, so 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 max(self.significant_bits(), other.significant_bits()).

§Examples

use malachite_base::num::logic::traits::CheckedHammingDistance;
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(123).checked_hamming_distance(&Integer::from(123)),
    Some(0)
);
// 105 = 1101001b, 123 = 1111011
assert_eq!(
    Integer::from(-105).checked_hamming_distance(&Integer::from(-123)),
    Some(2)
);
assert_eq!(
    Integer::from(-105).checked_hamming_distance(&Integer::from(123)),
    None
);

Source §

impl CheckedRoot<u64> for &Integer

Source §

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

Returns the the $n$th root of an Integer, or None if the Integer is not a perfect $n$th power. The Integer 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, or if exp is even and self is negative.

§Examples

use malachite_base::num::arithmetic::traits::CheckedRoot;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

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

Source §

type Output = Integer

Source §

impl CheckedRoot<u64> for Integer

Source §

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

Returns the the $n$th root of an Integer, or None if the Integer is not a perfect $n$th power. The Integer 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, or if exp is even and self is negative.

§Examples

use malachite_base::num::arithmetic::traits::CheckedRoot;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(999).checked_root(3).to_debug_string(), "None");
assert_eq!(
    Integer::from(1000).checked_root(3).to_debug_string(),
    "Some(10)"
);
assert_eq!(
    Integer::from(1001).checked_root(3).to_debug_string(),
    "None"
);
assert_eq!(
    Integer::from(100000000000i64)
        .checked_root(5)
        .to_debug_string(),
    "None"
);
assert_eq!(
    Integer::from(-100000000000i64)
        .checked_root(5)
        .to_debug_string(),
    "None"
);
assert_eq!(
    Integer::from(10000000000i64)
        .checked_root(5)
        .to_debug_string(),
    "Some(100)"
);
assert_eq!(
    Integer::from(-10000000000i64)
        .checked_root(5)
        .to_debug_string(),
    "Some(-100)"
);

Source §

type Output = Integer

Source §

impl CheckedSqrt for &Integer

Source §

fn checked_sqrt(self) -> Option<Integer>

Returns the the square root of an Integer, or None if it is not a perfect square. The Integer is taken by reference.

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

§Panics

Panics if self is negative.

§Examples

use malachite_base::num::arithmetic::traits::CheckedSqrt;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

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

Source §

type Output = Integer

Source §

impl CheckedSqrt for Integer

Source §

fn checked_sqrt(self) -> Option<Self>

Returns the the square root of an Integer, or None if it is not a perfect square. The Integer 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().

§Panics

Panics if self is negative.

§Examples

use malachite_base::num::arithmetic::traits::CheckedSqrt;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

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

Source §

type Output = Integer

Source §

impl Clone for Integer

Source §

fn clone(&self) -> Integer

Returns a duplicate of the value. Read more

1.0.0 · Source§

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

Performs copy-assignment from source. Read more

Source §

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

Source §

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

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 Integer> for f64

Source §

impl ConvertibleFrom<Integer> for Natural

Source §

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

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

Source §

impl ConvertibleFrom<f32> for Integer

Source §

§Worst-case complexity

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

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

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

§Examples

use core::str::FromStr;
use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.to_debug_string(), "0");

assert_eq!(Integer::from(123).to_debug_string(), "123");
assert_eq!(
    Integer::from_str("1000000000000")
        .unwrap()
        .to_debug_string(),
    "1000000000000"
);
assert_eq!(format!("{:05?}", Integer::from(123)), "00123");

assert_eq!(Integer::from(-123).to_debug_string(), "-123");
assert_eq!(
    Integer::from_str("-1000000000000")
        .unwrap()
        .to_debug_string(),
    "-1000000000000"
);
assert_eq!(format!("{:05?}", Integer::from(-123)), "-0123");

Source §

impl Default for Integer

Source §

fn default() -> Self

The default value of an Integer, 0.

Source §

impl Display for Integer

Source §

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

Converts an Integer to a String.

§Worst-case complexity

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

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

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

§Examples

use core::str::FromStr;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.to_string(), "0");

assert_eq!(Integer::from(123).to_string(), "123");
assert_eq!(
    Integer::from_str("1000000000000").unwrap().to_string(),
    "1000000000000"
);
assert_eq!(format!("{:05}", Integer::from(123)), "00123");

assert_eq!(Integer::from(-123).to_string(), "-123");
assert_eq!(
    Integer::from_str("-1000000000000").unwrap().to_string(),
    "-1000000000000"
);
assert_eq!(format!("{:05}", Integer::from(-123)), "-0123");

Source §

impl Div<&Integer> for &Integer

Source §

fn div(self, other: &Integer) -> Integer

Divides an Integer by another Integer, taking both by reference. The quotient is rounded towards zero. The quotient and remainder (which is not computed) satisfy $x = qy + r$ and $0 \leq |r| < |y|$.

$$ f(x, y) = \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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

use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(&Integer::from(23) / &Integer::from(10), 2);

// -2 * -10 + 3 = 23
assert_eq!(&Integer::from(23) / &Integer::from(-10), -2);

// -2 * 10 + -3 = -23
assert_eq!(&Integer::from(-23) / &Integer::from(10), -2);

// 2 * -10 + -3 = -23
assert_eq!(&Integer::from(-23) / &Integer::from(-10), 2);

Source §

type Output = Integer

The resulting type after applying the / operator.

Source §

impl Div<&Integer> for Integer

Source §

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

Divides an Integer by another Integer, taking the first by value and the second by reference. The quotient is rounded towards zero. The quotient and remainder (which is not computed) satisfy $x = qy + r$ and $0 \leq |r| < |y|$.

$$ f(x, y) = \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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

use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(Integer::from(23) / &Integer::from(10), 2);

// -2 * -10 + 3 = 23
assert_eq!(Integer::from(23) / &Integer::from(-10), -2);

// -2 * 10 + -3 = -23
assert_eq!(Integer::from(-23) / &Integer::from(10), -2);

// 2 * -10 + -3 = -23
assert_eq!(Integer::from(-23) / &Integer::from(-10), 2);

Source §

type Output = Integer

The resulting type after applying the / operator.

Source §

impl Div<Integer> for &Integer

Source §

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

Divides an Integer by another Integer, taking the first by reference and the second by value. The quotient is rounded towards zero. The quotient and remainder (which is not computed) satisfy $x = qy + r$ and $0 \leq |r| < |y|$.

$$ f(x, y) = \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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

use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(&Integer::from(23) / Integer::from(10), 2);

// -2 * -10 + 3 = 23
assert_eq!(&Integer::from(23) / Integer::from(-10), -2);

// -2 * 10 + -3 = -23
assert_eq!(&Integer::from(-23) / Integer::from(10), -2);

// 2 * -10 + -3 = -23
assert_eq!(&Integer::from(-23) / Integer::from(-10), 2);

Source §

type Output = Integer

The resulting type after applying the / operator.

Source §

impl Div for Integer

Source §

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

Divides an Integer by another Integer, taking both by value. The quotient is rounded towards zero. The quotient and remainder (which is not computed) satisfy $x = qy + r$ and $0 \leq |r| < |y|$.

$$ f(x, y) = \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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

use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(Integer::from(23) / Integer::from(10), 2);

// -2 * -10 + 3 = 23
assert_eq!(Integer::from(23) / Integer::from(-10), -2);

// -2 * 10 + -3 = -23
assert_eq!(Integer::from(-23) / Integer::from(10), -2);

// 2 * -10 + -3 = -23
assert_eq!(Integer::from(-23) / Integer::from(-10), 2);

Source §

type Output = Integer

The resulting type after applying the / operator.

Source §

impl DivAssign<&Integer> for Integer

Source §

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

Divides an Integer by another Integer in place, taking the Integer on the right-hand side by reference. The quotient is rounded towards zero. The quotient and remainder (which is not computed) satisfy $x = qy + r$ and $0 \leq |r| < |y|$.

$$ x \gets \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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

use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
let mut x = Integer::from(23);
x /= &Integer::from(10);
assert_eq!(x, 2);

// -2 * -10 + 3 = 23
let mut x = Integer::from(23);
x /= &Integer::from(-10);
assert_eq!(x, -2);

// -2 * 10 + -3 = -23
let mut x = Integer::from(-23);
x /= &Integer::from(10);
assert_eq!(x, -2);

// 2 * -10 + -3 = -23
let mut x = Integer::from(-23);
x /= &Integer::from(-10);
assert_eq!(x, 2);

Source §

impl DivAssign for Integer

Source §

fn div_assign(&mut self, other: Self)

Divides an Integer by another Integer in place, taking the Integer on the right-hand side by value. The quotient is rounded towards zero. The quotient and remainder (which is not computed) satisfy $x = qy + r$ and $0 \leq |r| < |y|$.

$$ x \gets \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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

use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
let mut x = Integer::from(23);
x /= Integer::from(10);
assert_eq!(x, 2);

// -2 * -10 + 3 = 23
let mut x = Integer::from(23);
x /= Integer::from(-10);
assert_eq!(x, -2);

// -2 * 10 + -3 = -23
let mut x = Integer::from(-23);
x /= Integer::from(10);
assert_eq!(x, -2);

// 2 * -10 + -3 = -23
let mut x = Integer::from(-23);
x /= Integer::from(-10);
assert_eq!(x, 2);

Source §

impl DivAssignMod<&Integer> for Integer

Source §

fn div_assign_mod(&mut self, other: &Self) -> Self

Divides an Integer by another Integer in place, taking the Integer on the right-hand side by reference and returning the remainder. The quotient is rounded towards negative infinity, and the remainder has the same sign as the second Integer.

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

use malachite_base::num::arithmetic::traits::DivAssignMod;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
let mut x = Integer::from(23);
assert_eq!(x.div_assign_mod(&Integer::from(10)), 3);
assert_eq!(x, 2);

// -3 * -10 + -7 = 23
let mut x = Integer::from(23);
assert_eq!(x.div_assign_mod(&Integer::from(-10)), -7);
assert_eq!(x, -3);

// -3 * 10 + 7 = -23
let mut x = Integer::from(-23);
assert_eq!(x.div_assign_mod(&Integer::from(10)), 7);
assert_eq!(x, -3);

// 2 * -10 + -3 = -23
let mut x = Integer::from(-23);
assert_eq!(x.div_assign_mod(&Integer::from(-10)), -3);
assert_eq!(x, 2);

Source §

type ModOutput = Integer

Source §

impl DivAssignMod for Integer

Source §

fn div_assign_mod(&mut self, other: Self) -> Self

Divides an Integer by another Integer in place, taking the Integer on the right-hand side by value and returning the remainder. The quotient is rounded towards negative infinity, and the remainder has the same sign as the second Integer.

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

use malachite_base::num::arithmetic::traits::DivAssignMod;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
let mut x = Integer::from(23);
assert_eq!(x.div_assign_mod(Integer::from(10)), 3);
assert_eq!(x, 2);

// -3 * -10 + -7 = 23
let mut x = Integer::from(23);
assert_eq!(x.div_assign_mod(Integer::from(-10)), -7);
assert_eq!(x, -3);

// -3 * 10 + 7 = -23
let mut x = Integer::from(-23);
assert_eq!(x.div_assign_mod(Integer::from(10)), 7);
assert_eq!(x, -3);

// 2 * -10 + -3 = -23
let mut x = Integer::from(-23);
assert_eq!(x.div_assign_mod(Integer::from(-10)), -3);
assert_eq!(x, 2);

Source §

type ModOutput = Integer

Source §

impl DivAssignRem<&Integer> for Integer

Source §

fn div_assign_rem(&mut self, other: &Self) -> Self

Divides an Integer by another Integer in place, taking the Integer on the right-hand side by reference and returning the remainder. The quotient is rounded towards zero and the remainder has the same sign as the first Integer.

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

$$ f(x, y) = x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \right \rfloor, $$ $$ x \gets \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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

use malachite_base::num::arithmetic::traits::DivAssignRem;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
let mut x = Integer::from(23);
assert_eq!(x.div_assign_rem(&Integer::from(10)), 3);
assert_eq!(x, 2);

// -2 * -10 + 3 = 23
let mut x = Integer::from(23);
assert_eq!(x.div_assign_rem(&Integer::from(-10)), 3);
assert_eq!(x, -2);

// -2 * 10 + -3 = -23
let mut x = Integer::from(-23);
assert_eq!(x.div_assign_rem(&Integer::from(10)), -3);
assert_eq!(x, -2);

// 2 * -10 + -3 = -23
let mut x = Integer::from(-23);
assert_eq!(x.div_assign_rem(&Integer::from(-10)), -3);
assert_eq!(x, 2);

Source §

type RemOutput = Integer

Source §

impl DivAssignRem for Integer

Source §

fn div_assign_rem(&mut self, other: Self) -> Self

Divides an Integer by another Integer in place, taking the Integer on the right-hand side by value and returning the remainder. The quotient is rounded towards zero and the remainder has the same sign as the first Integer.

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

$$ f(x, y) = x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \right \rfloor, $$ $$ x \gets \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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

use malachite_base::num::arithmetic::traits::DivAssignRem;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
let mut x = Integer::from(23);
assert_eq!(x.div_assign_rem(Integer::from(10)), 3);
assert_eq!(x, 2);

// -2 * -10 + 3 = 23
let mut x = Integer::from(23);
assert_eq!(x.div_assign_rem(Integer::from(-10)), 3);
assert_eq!(x, -2);

// -2 * 10 + -3 = -23
let mut x = Integer::from(-23);
assert_eq!(x.div_assign_rem(Integer::from(10)), -3);
assert_eq!(x, -2);

// 2 * -10 + -3 = -23
let mut x = Integer::from(-23);
assert_eq!(x.div_assign_rem(Integer::from(-10)), -3);
assert_eq!(x, 2);

use core::str::FromStr;
use malachite_base::num::arithmetic::traits::DivExact;
use malachite_nz::integer::Integer;

// -123 * 456 = -56088
assert_eq!(
    (&Integer::from(-56088)).div_exact(&Integer::from(456)),
    -123
);

// -123456789000 * -987654321000 = 121932631112635269000000
assert_eq!(
    (&Integer::from_str("121932631112635269000000").unwrap())
        .div_exact(&Integer::from_str("-987654321000").unwrap()),
    -123456789000i64
);

Source §

type Output = Integer

Source §

impl DivExact<&Integer> for Integer

Source §

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

Divides an Integer by another Integer, taking the first by value and the second by reference. The first Integer 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, 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

use core::str::FromStr;
use malachite_base::num::arithmetic::traits::DivExact;
use malachite_nz::integer::Integer;

// -123 * 456 = -56088
assert_eq!(Integer::from(-56088).div_exact(&Integer::from(456)), -123);

// -123456789000 * -987654321000 = 121932631112635269000000
assert_eq!(
    Integer::from_str("121932631112635269000000")
        .unwrap()
        .div_exact(&Integer::from_str("-987654321000").unwrap()),
    -123456789000i64
);

Source §

type Output = Integer

Source §

impl DivExact<Integer> for &Integer

Source §

fn div_exact(self, other: Integer) -> Integer

Divides an Integer by another Integer, taking the first by reference and the second by value. The first Integer 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, 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

use core::str::FromStr;
use malachite_base::num::arithmetic::traits::DivExact;
use malachite_nz::integer::Integer;

// -123 * 456 = -56088
assert_eq!((&Integer::from(-56088)).div_exact(Integer::from(456)), -123);

// -123456789000 * -987654321000 = 121932631112635269000000
assert_eq!(
    (&Integer::from_str("121932631112635269000000").unwrap())
        .div_exact(Integer::from_str("-987654321000").unwrap()),
    -123456789000i64
);

Source §

type Output = Integer

Source §

impl DivExact for Integer

Source §

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

Divides an Integer by another Integer, taking both by value. The first Integer 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, 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

use core::str::FromStr;
use malachite_base::num::arithmetic::traits::DivExact;
use malachite_nz::integer::Integer;

// -123 * 456 = -56088
assert_eq!(Integer::from(-56088).div_exact(Integer::from(456)), -123);

// -123456789000 * -987654321000 = 121932631112635269000000
assert_eq!(
    Integer::from_str("121932631112635269000000")
        .unwrap()
        .div_exact(Integer::from_str("-987654321000").unwrap()),
    -123456789000i64
);

Source §

type Output = Integer

Source §

impl DivExactAssign<&Integer> for Integer

Source §

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

Divides an Integer by another Integer in place, taking the Integer on the right-hand side by reference. The first Integer 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, 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

use core::str::FromStr;
use malachite_base::num::arithmetic::traits::DivExactAssign;
use malachite_nz::integer::Integer;

// -123 * 456 = -56088
let mut x = Integer::from(-56088);
x.div_exact_assign(&Integer::from(456));
assert_eq!(x, -123);

// -123456789000 * -987654321000 = 121932631112635269000000
let mut x = Integer::from_str("121932631112635269000000").unwrap();
x.div_exact_assign(&Integer::from_str("-987654321000").unwrap());
assert_eq!(x, -123456789000i64);

Source §

impl DivExactAssign for Integer

Source §

fn div_exact_assign(&mut self, other: Self)

Divides an Integer by another Integer in place, taking the Integer on the right-hand side by value. The first Integer 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, 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

use core::str::FromStr;
use malachite_base::num::arithmetic::traits::DivExactAssign;
use malachite_nz::integer::Integer;

// -123 * 456 = -56088
let mut x = Integer::from(-56088);
x.div_exact_assign(Integer::from(456));
assert_eq!(x, -123);

// -123456789000 * -987654321000 = 121932631112635269000000
let mut x = Integer::from_str("121932631112635269000000").unwrap();
x.div_exact_assign(Integer::from_str("-987654321000").unwrap());
assert_eq!(x, -123456789000i64);

Source §

impl DivMod<&Integer> for &Integer

Source §

fn div_mod(self, other: &Integer) -> (Integer, Integer)

Divides an Integer by another Integer, taking both by reference and returning the quotient and remainder. The quotient is rounded towards negative infinity, and the remainder has the same sign as the second Integer.

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

use malachite_base::num::arithmetic::traits::DivMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(
    (&Integer::from(23))
        .div_mod(&Integer::from(10))
        .to_debug_string(),
    "(2, 3)"
);

// -3 * -10 + -7 = 23
assert_eq!(
    (&Integer::from(23))
        .div_mod(&Integer::from(-10))
        .to_debug_string(),
    "(-3, -7)"
);

// -3 * 10 + 7 = -23
assert_eq!(
    (&Integer::from(-23))
        .div_mod(&Integer::from(10))
        .to_debug_string(),
    "(-3, 7)"
);

// 2 * -10 + -3 = -23
assert_eq!(
    (&Integer::from(-23))
        .div_mod(&Integer::from(-10))
        .to_debug_string(),
    "(2, -3)"
);

Panics if other is zero.

§Examples

use malachite_base::num::arithmetic::traits::DivMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(
    Integer::from(23)
        .div_mod(&Integer::from(10))
        .to_debug_string(),
    "(2, 3)"
);

// -3 * -10 + -7 = 23
assert_eq!(
    Integer::from(23)
        .div_mod(&Integer::from(-10))
        .to_debug_string(),
    "(-3, -7)"
);

// -3 * 10 + 7 = -23
assert_eq!(
    Integer::from(-23)
        .div_mod(&Integer::from(10))
        .to_debug_string(),
    "(-3, 7)"
);

// 2 * -10 + -3 = -23
assert_eq!(
    Integer::from(-23)
        .div_mod(&Integer::from(-10))
        .to_debug_string(),
    "(2, -3)"
);

Panics if other is zero.

§Examples

use malachite_base::num::arithmetic::traits::DivMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(
    (&Integer::from(23))
        .div_mod(Integer::from(10))
        .to_debug_string(),
    "(2, 3)"
);

// -3 * -10 + -7 = 23
assert_eq!(
    (&Integer::from(23))
        .div_mod(Integer::from(-10))
        .to_debug_string(),
    "(-3, -7)"
);

// -3 * 10 + 7 = -23
assert_eq!(
    (&Integer::from(-23))
        .div_mod(Integer::from(10))
        .to_debug_string(),
    "(-3, 7)"
);

// 2 * -10 + -3 = -23
assert_eq!(
    (&Integer::from(-23))
        .div_mod(Integer::from(-10))
        .to_debug_string(),
    "(2, -3)"
);

Panics if other is zero.

§Examples

use malachite_base::num::arithmetic::traits::DivMod;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(
    Integer::from(23)
        .div_mod(Integer::from(10))
        .to_debug_string(),
    "(2, 3)"
);

// -3 * -10 + -7 = 23
assert_eq!(
    Integer::from(23)
        .div_mod(Integer::from(-10))
        .to_debug_string(),
    "(-3, -7)"
);

// -3 * 10 + 7 = -23
assert_eq!(
    Integer::from(-23)
        .div_mod(Integer::from(10))
        .to_debug_string(),
    "(-3, 7)"
);

// 2 * -10 + -3 = -23
assert_eq!(
    Integer::from(-23)
        .div_mod(Integer::from(-10))
        .to_debug_string(),
    "(2, -3)"
);

Panics if other is zero.

§Examples

use malachite_base::num::arithmetic::traits::DivRem;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(
    (&Integer::from(23))
        .div_rem(&Integer::from(10))
        .to_debug_string(),
    "(2, 3)"
);

// -2 * -10 + 3 = 23
assert_eq!(
    (&Integer::from(23))
        .div_rem(&Integer::from(-10))
        .to_debug_string(),
    "(-2, 3)"
);

// -2 * 10 + -3 = -23
assert_eq!(
    (&Integer::from(-23))
        .div_rem(&Integer::from(10))
        .to_debug_string(),
    "(-2, -3)"
);

// 2 * -10 + -3 = -23
assert_eq!(
    (&Integer::from(-23))
        .div_rem(&Integer::from(-10))
        .to_debug_string(),
    "(2, -3)"
);

Panics if other is zero.

§Examples

use malachite_base::num::arithmetic::traits::DivRem;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(
    Integer::from(23)
        .div_rem(&Integer::from(10))
        .to_debug_string(),
    "(2, 3)"
);

// -2 * -10 + 3 = 23
assert_eq!(
    Integer::from(23)
        .div_rem(&Integer::from(-10))
        .to_debug_string(),
    "(-2, 3)"
);

// -2 * 10 + -3 = -23
assert_eq!(
    Integer::from(-23)
        .div_rem(&Integer::from(10))
        .to_debug_string(),
    "(-2, -3)"
);

// 2 * -10 + -3 = -23
assert_eq!(
    Integer::from(-23)
        .div_rem(&Integer::from(-10))
        .to_debug_string(),
    "(2, -3)"
);

Panics if other is zero.

§Examples

use malachite_base::num::arithmetic::traits::DivRem;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(
    (&Integer::from(23))
        .div_rem(Integer::from(10))
        .to_debug_string(),
    "(2, 3)"
);

// -2 * -10 + 3 = 23
assert_eq!(
    (&Integer::from(23))
        .div_rem(Integer::from(-10))
        .to_debug_string(),
    "(-2, 3)"
);

// -2 * 10 + -3 = -23
assert_eq!(
    (&Integer::from(-23))
        .div_rem(Integer::from(10))
        .to_debug_string(),
    "(-2, -3)"
);

// 2 * -10 + -3 = -23
assert_eq!(
    (&Integer::from(-23))
        .div_rem(Integer::from(-10))
        .to_debug_string(),
    "(2, -3)"
);

Panics if other is zero.

§Examples

use malachite_base::num::arithmetic::traits::DivRem;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(
    Integer::from(23)
        .div_rem(Integer::from(10))
        .to_debug_string(),
    "(2, 3)"
);

// -2 * -10 + 3 = 23
assert_eq!(
    Integer::from(23)
        .div_rem(Integer::from(-10))
        .to_debug_string(),
    "(-2, 3)"
);

// -2 * 10 + -3 = -23
assert_eq!(
    Integer::from(-23)
        .div_rem(Integer::from(10))
        .to_debug_string(),
    "(-2, -3)"
);

// 2 * -10 + -3 = -23
assert_eq!(
    Integer::from(-23)
        .div_rem(Integer::from(-10))
        .to_debug_string(),
    "(2, -3)"
);

Source §

type DivOutput = Integer

Source §

type RemOutput = Integer

Source §

impl DivRound<&Integer> for &Integer

Source §

fn div_round(self, other: &Integer, rm: RoundingMode) -> (Integer, Ordering)

Divides an Integer by another Integer, taking both by reference and rounding according to a specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Let $q = \frac{x}{y}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$$ g(x, y, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor. $$

$$ g(x, y, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil. $$

$$ g(x, y, \mathrm{Floor}) = \lfloor q \rfloor. $$

$$ g(x, y, \mathrm{Ceiling}) = \lceil q \rceil. $$

$$ g(x, y, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & 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} $$

$g(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.

Then $f(x, y, r) = (g(x, y, r), \operatorname{cmp}(g(x, y, r), q))$.

§Worst-case complexity

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

use core::cmp::Ordering::*;
use malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_nz::integer::Integer;

assert_eq!(
    (&Integer::from(-10)).div_round(&Integer::from(4), Down),
    (Integer::from(-2), Greater)
);
assert_eq!(
    (&-Integer::from(10u32).pow(12)).div_round(&Integer::from(3), Floor),
    (Integer::from(-333333333334i64), Less)
);
assert_eq!(
    Integer::from(-10).div_round(&Integer::from(4), Up),
    (Integer::from(-3), Less)
);
assert_eq!(
    (&-Integer::from(10u32).pow(12)).div_round(&Integer::from(3), Ceiling),
    (Integer::from(-333333333333i64), Greater)
);
assert_eq!(
    (&Integer::from(-10)).div_round(&Integer::from(5), Exact),
    (Integer::from(-2), Equal)
);
assert_eq!(
    (&Integer::from(-10)).div_round(&Integer::from(3), Nearest),
    (Integer::from(-3), Greater)
);
assert_eq!(
    (&Integer::from(-20)).div_round(&Integer::from(3), Nearest),
    (Integer::from(-7), Less)
);
assert_eq!(
    (&Integer::from(-10)).div_round(&Integer::from(4), Nearest),
    (Integer::from(-2), Greater)
);
assert_eq!(
    (&Integer::from(-14)).div_round(&Integer::from(4), Nearest),
    (Integer::from(-4), Less)
);

assert_eq!(
    (&Integer::from(-10)).div_round(&Integer::from(-4), Down),
    (Integer::from(2), Less)
);
assert_eq!(
    (&-Integer::from(10u32).pow(12)).div_round(&Integer::from(-3), Floor),
    (Integer::from(333333333333i64), Less)
);
assert_eq!(
    (&Integer::from(-10)).div_round(&Integer::from(-4), Up),
    (Integer::from(3), Greater)
);
assert_eq!(
    (&-Integer::from(10u32).pow(12)).div_round(&Integer::from(-3), Ceiling),
    (Integer::from(333333333334i64), Greater)
);
assert_eq!(
    (&Integer::from(-10)).div_round(&Integer::from(-5), Exact),
    (Integer::from(2), Equal)
);
assert_eq!(
    (&Integer::from(-10)).div_round(&Integer::from(-3), Nearest),
    (Integer::from(3), Less)
);
assert_eq!(
    (&Integer::from(-20)).div_round(&Integer::from(-3), Nearest),
    (Integer::from(7), Greater)
);
assert_eq!(
    (&Integer::from(-10)).div_round(&Integer::from(-4), Nearest),
    (Integer::from(2), Less)
);
assert_eq!(
    (&Integer::from(-14)).div_round(&Integer::from(-4), Nearest),
    (Integer::from(4), Greater)
);

Source §

type Output = Integer

Source §

impl DivRound<&Integer> for Integer

Source §

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

Divides an Integer by another Integer, taking the first by value and the second by reference and rounding according to a specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Let $q = \frac{x}{y}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$$ g(x, y, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor. $$

$$ g(x, y, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil. $$

$$ g(x, y, \mathrm{Floor}) = \lfloor q \rfloor. $$

$$ g(x, y, \mathrm{Ceiling}) = \lceil q \rceil. $$

$$ g(x, y, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & 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} $$

$g(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.

Then $f(x, y, r) = (g(x, y, r), \operatorname{cmp}(g(x, y, r), q))$.

§Worst-case complexity

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

use core::cmp::Ordering::*;
use malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(-10).div_round(&Integer::from(4), Down),
    (Integer::from(-2), Greater)
);
assert_eq!(
    (-Integer::from(10u32).pow(12)).div_round(&Integer::from(3), Floor),
    (Integer::from(-333333333334i64), Less)
);
assert_eq!(
    Integer::from(-10).div_round(&Integer::from(4), Up),
    (Integer::from(-3), Less)
);
assert_eq!(
    (-Integer::from(10u32).pow(12)).div_round(&Integer::from(3), Ceiling),
    (Integer::from(-333333333333i64), Greater)
);
assert_eq!(
    Integer::from(-10).div_round(&Integer::from(5), Exact),
    (Integer::from(-2), Equal)
);
assert_eq!(
    Integer::from(-10).div_round(&Integer::from(3), Nearest),
    (Integer::from(-3), Greater)
);
assert_eq!(
    Integer::from(-20).div_round(&Integer::from(3), Nearest),
    (Integer::from(-7), Less)
);
assert_eq!(
    Integer::from(-10).div_round(&Integer::from(4), Nearest),
    (Integer::from(-2), Greater)
);
assert_eq!(
    Integer::from(-14).div_round(&Integer::from(4), Nearest),
    (Integer::from(-4), Less)
);

assert_eq!(
    Integer::from(-10).div_round(&Integer::from(-4), Down),
    (Integer::from(2), Less)
);
assert_eq!(
    (-Integer::from(10u32).pow(12)).div_round(&Integer::from(-3), Floor),
    (Integer::from(333333333333i64), Less)
);
assert_eq!(
    Integer::from(-10).div_round(&Integer::from(-4), Up),
    (Integer::from(3), Greater)
);
assert_eq!(
    (-Integer::from(10u32).pow(12)).div_round(&Integer::from(-3), Ceiling),
    (Integer::from(333333333334i64), Greater)
);
assert_eq!(
    Integer::from(-10).div_round(&Integer::from(-5), Exact),
    (Integer::from(2), Equal)
);
assert_eq!(
    Integer::from(-10).div_round(&Integer::from(-3), Nearest),
    (Integer::from(3), Less)
);
assert_eq!(
    Integer::from(-20).div_round(&Integer::from(-3), Nearest),
    (Integer::from(7), Greater)
);
assert_eq!(
    Integer::from(-10).div_round(&Integer::from(-4), Nearest),
    (Integer::from(2), Less)
);
assert_eq!(
    Integer::from(-14).div_round(&Integer::from(-4), Nearest),
    (Integer::from(4), Greater)
);

Source §

type Output = Integer

Source §

impl DivRound<Integer> for &Integer

Source §

fn div_round(self, other: Integer, rm: RoundingMode) -> (Integer, Ordering)

Divides an Integer by another Integer, taking the first by reference and the second by value and rounding according to a specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Let $q = \frac{x}{y}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$$ g(x, y, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor. $$

$$ g(x, y, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil. $$

$$ g(x, y, \mathrm{Floor}) = \lfloor q \rfloor. $$

$$ g(x, y, \mathrm{Ceiling}) = \lceil q \rceil. $$

$$ g(x, y, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & 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} $$

$g(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.

Then $f(x, y, r) = (g(x, y, r), \operatorname{cmp}(g(x, y, r), q))$.

§Worst-case complexity

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

use core::cmp::Ordering::*;
use malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_nz::integer::Integer;

assert_eq!(
    (&Integer::from(-10)).div_round(Integer::from(4), Down),
    (Integer::from(-2), Greater)
);
assert_eq!(
    (&-Integer::from(10u32).pow(12)).div_round(Integer::from(3), Floor),
    (Integer::from(-333333333334i64), Less)
);
assert_eq!(
    Integer::from(-10).div_round(Integer::from(4), Up),
    (Integer::from(-3), Less)
);
assert_eq!(
    (&-Integer::from(10u32).pow(12)).div_round(Integer::from(3), Ceiling),
    (Integer::from(-333333333333i64), Greater)
);
assert_eq!(
    (&Integer::from(-10)).div_round(Integer::from(5), Exact),
    (Integer::from(-2), Equal)
);
assert_eq!(
    (&Integer::from(-10)).div_round(Integer::from(3), Nearest),
    (Integer::from(-3), Greater)
);
assert_eq!(
    (&Integer::from(-20)).div_round(Integer::from(3), Nearest),
    (Integer::from(-7), Less)
);
assert_eq!(
    (&Integer::from(-10)).div_round(Integer::from(4), Nearest),
    (Integer::from(-2), Greater)
);
assert_eq!(
    (&Integer::from(-14)).div_round(Integer::from(4), Nearest),
    (Integer::from(-4), Less)
);

assert_eq!(
    (&Integer::from(-10)).div_round(Integer::from(-4), Down),
    (Integer::from(2), Less)
);
assert_eq!(
    (&-Integer::from(10u32).pow(12)).div_round(Integer::from(-3), Floor),
    (Integer::from(333333333333i64), Less)
);
assert_eq!(
    (&Integer::from(-10)).div_round(Integer::from(-4), Up),
    (Integer::from(3), Greater)
);
assert_eq!(
    (&-Integer::from(10u32).pow(12)).div_round(Integer::from(-3), Ceiling),
    (Integer::from(333333333334i64), Greater)
);
assert_eq!(
    (&Integer::from(-10)).div_round(Integer::from(-5), Exact),
    (Integer::from(2), Equal)
);
assert_eq!(
    (&Integer::from(-10)).div_round(Integer::from(-3), Nearest),
    (Integer::from(3), Less)
);
assert_eq!(
    (&Integer::from(-20)).div_round(Integer::from(-3), Nearest),
    (Integer::from(7), Greater)
);
assert_eq!(
    (&Integer::from(-10)).div_round(Integer::from(-4), Nearest),
    (Integer::from(2), Less)
);
assert_eq!(
    (&Integer::from(-14)).div_round(Integer::from(-4), Nearest),
    (Integer::from(4), Greater)
);

Source §

type Output = Integer

Source §

impl DivRound for Integer

Source §

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

Divides an Integer by another Integer, taking both by value and rounding according to a specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Let $q = \frac{x}{y}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$$ g(x, y, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor. $$

$$ g(x, y, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil. $$

$$ g(x, y, \mathrm{Floor}) = \lfloor q \rfloor. $$

$$ g(x, y, \mathrm{Ceiling}) = \lceil q \rceil. $$

$$ g(x, y, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & 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} $$

$g(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.

Then $f(x, y, r) = (g(x, y, r), \operatorname{cmp}(g(x, y, r), q))$.

§Worst-case complexity

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

use core::cmp::Ordering::*;
use malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(-10).div_round(Integer::from(4), Down),
    (Integer::from(-2), Greater)
);
assert_eq!(
    (-Integer::from(10u32).pow(12)).div_round(Integer::from(3), Floor),
    (Integer::from(-333333333334i64), Less)
);
assert_eq!(
    Integer::from(-10).div_round(Integer::from(4), Up),
    (Integer::from(-3), Less)
);
assert_eq!(
    (-Integer::from(10u32).pow(12)).div_round(Integer::from(3), Ceiling),
    (Integer::from(-333333333333i64), Greater)
);
assert_eq!(
    Integer::from(-10).div_round(Integer::from(5), Exact),
    (Integer::from(-2), Equal)
);
assert_eq!(
    Integer::from(-10).div_round(Integer::from(3), Nearest),
    (Integer::from(-3), Greater)
);
assert_eq!(
    Integer::from(-20).div_round(Integer::from(3), Nearest),
    (Integer::from(-7), Less)
);
assert_eq!(
    Integer::from(-10).div_round(Integer::from(4), Nearest),
    (Integer::from(-2), Greater)
);
assert_eq!(
    Integer::from(-14).div_round(Integer::from(4), Nearest),
    (Integer::from(-4), Less)
);

assert_eq!(
    Integer::from(-10).div_round(Integer::from(-4), Down),
    (Integer::from(2), Less)
);
assert_eq!(
    (-Integer::from(10u32).pow(12)).div_round(Integer::from(-3), Floor),
    (Integer::from(333333333333i64), Less)
);
assert_eq!(
    Integer::from(-10).div_round(Integer::from(-4), Up),
    (Integer::from(3), Greater)
);
assert_eq!(
    (-Integer::from(10u32).pow(12)).div_round(Integer::from(-3), Ceiling),
    (Integer::from(333333333334i64), Greater)
);
assert_eq!(
    Integer::from(-10).div_round(Integer::from(-5), Exact),
    (Integer::from(2), Equal)
);
assert_eq!(
    Integer::from(-10).div_round(Integer::from(-3), Nearest),
    (Integer::from(3), Less)
);
assert_eq!(
    Integer::from(-20).div_round(Integer::from(-3), Nearest),
    (Integer::from(7), Greater)
);
assert_eq!(
    Integer::from(-10).div_round(Integer::from(-4), Nearest),
    (Integer::from(2), Less)
);
assert_eq!(
    Integer::from(-14).div_round(Integer::from(-4), Nearest),
    (Integer::from(4), Greater)
);

Source §

type Output = Integer

Source §

impl DivRoundAssign<&Integer> for Integer

Source §

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

Divides an Integer by another Integer in place, taking the Integer on the right-hand side by reference and rounding according to a specified rounding mode. An Ordering is returned, indicating whether the assigned value is less than, equal to, or greater than the exact value.

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

use core::cmp::Ordering::*;
use malachite_base::num::arithmetic::traits::{DivRoundAssign, Pow};
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_nz::integer::Integer;

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(&Integer::from(4), Down), Greater);
assert_eq!(n, -2);

let mut n = -Integer::from(10u32).pow(12);
assert_eq!(n.div_round_assign(&Integer::from(3), Floor), Less);
assert_eq!(n, -333333333334i64);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(&Integer::from(4), Up), Less);
assert_eq!(n, -3);

let mut n = -Integer::from(10u32).pow(12);
assert_eq!(n.div_round_assign(&Integer::from(3), Ceiling), Greater);
assert_eq!(n, -333333333333i64);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(&Integer::from(5), Exact), Equal);
assert_eq!(n, -2);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(&Integer::from(3), Nearest), Greater);
assert_eq!(n, -3);

let mut n = Integer::from(-20);
assert_eq!(n.div_round_assign(&Integer::from(3), Nearest), Less);
assert_eq!(n, -7);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(&Integer::from(4), Nearest), Greater);
assert_eq!(n, -2);

let mut n = Integer::from(-14);
assert_eq!(n.div_round_assign(&Integer::from(4), Nearest), Less);
assert_eq!(n, -4);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(&Integer::from(-4), Down), Less);
assert_eq!(n, 2);

let mut n = -Integer::from(10u32).pow(12);
assert_eq!(n.div_round_assign(&Integer::from(-3), Floor), Less);
assert_eq!(n, 333333333333i64);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(&Integer::from(-4), Up), Greater);
assert_eq!(n, 3);

let mut n = -Integer::from(10u32).pow(12);
assert_eq!(n.div_round_assign(&Integer::from(-3), Ceiling), Greater);
assert_eq!(n, 333333333334i64);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(&Integer::from(-5), Exact), Equal);
assert_eq!(n, 2);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(&Integer::from(-3), Nearest), Less);
assert_eq!(n, 3);

let mut n = Integer::from(-20);
assert_eq!(n.div_round_assign(&Integer::from(-3), Nearest), Greater);
assert_eq!(n, 7);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(&Integer::from(-4), Nearest), Less);
assert_eq!(n, 2);

let mut n = Integer::from(-14);
assert_eq!(n.div_round_assign(&Integer::from(-4), Nearest), Greater);
assert_eq!(n, 4);

Source §

impl DivRoundAssign for Integer

Source §

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

Divides an Integer by another Integer in place, taking the Integer on the right-hand side by value and rounding according to a specified rounding mode. An Ordering is returned, indicating whether the assigned value is less than, equal to, or greater than the exact value.

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

use core::cmp::Ordering::*;
use malachite_base::num::arithmetic::traits::{DivRoundAssign, Pow};
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_nz::integer::Integer;

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(Integer::from(4), Down), Greater);
assert_eq!(n, -2);

let mut n = -Integer::from(10u32).pow(12);
assert_eq!(n.div_round_assign(Integer::from(3), Floor), Less);
assert_eq!(n, -333333333334i64);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(Integer::from(4), Up), Less);
assert_eq!(n, -3);

let mut n = -Integer::from(10u32).pow(12);
assert_eq!(n.div_round_assign(Integer::from(3), Ceiling), Greater);
assert_eq!(n, -333333333333i64);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(Integer::from(5), Exact), Equal);
assert_eq!(n, -2);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(Integer::from(3), Nearest), Greater);
assert_eq!(n, -3);

let mut n = Integer::from(-20);
assert_eq!(n.div_round_assign(Integer::from(3), Nearest), Less);
assert_eq!(n, -7);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(Integer::from(4), Nearest), Greater);
assert_eq!(n, -2);

let mut n = Integer::from(-14);
assert_eq!(n.div_round_assign(Integer::from(4), Nearest), Less);
assert_eq!(n, -4);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(Integer::from(-4), Down), Less);
assert_eq!(n, 2);

let mut n = -Integer::from(10u32).pow(12);
assert_eq!(n.div_round_assign(Integer::from(-3), Floor), Less);
assert_eq!(n, 333333333333i64);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(Integer::from(-4), Up), Greater);
assert_eq!(n, 3);

let mut n = -Integer::from(10u32).pow(12);
assert_eq!(n.div_round_assign(Integer::from(-3), Ceiling), Greater);
assert_eq!(n, 333333333334i64);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(Integer::from(-5), Exact), Equal);
assert_eq!(n, 2);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(Integer::from(-3), Nearest), Less);
assert_eq!(n, 3);

let mut n = Integer::from(-20);
assert_eq!(n.div_round_assign(Integer::from(-3), Nearest), Greater);
assert_eq!(n, 7);

let mut n = Integer::from(-10);
assert_eq!(n.div_round_assign(Integer::from(-4), Nearest), Less);
assert_eq!(n, 2);

let mut n = Integer::from(-14);
assert_eq!(n.div_round_assign(Integer::from(-4), Nearest), Greater);
assert_eq!(n, 4);

Source §

impl DivisibleBy<&Integer> for &Integer

Source §

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

Returns whether an Integer is divisible by another Integer; in other words, whether the first is a multiple of the second. Both Integers are taken by reference.

This means that zero is divisible by any Integer, including zero; but a nonzero Integer 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

use core::str::FromStr;
use malachite_base::num::arithmetic::traits::DivisibleBy;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!((&Integer::ZERO).divisible_by(&Integer::ZERO), true);
assert_eq!(
    (&Integer::from(-100)).divisible_by(&Integer::from(-3)),
    false
);
assert_eq!((&Integer::from(102)).divisible_by(&Integer::from(-3)), true);
assert_eq!(
    (&Integer::from_str("-1000000000000000000000000").unwrap())
        .divisible_by(&Integer::from_str("1000000000000").unwrap()),
    true
);

Source §

impl DivisibleBy<&Integer> for Integer

Source §

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

Returns whether an Integer is divisible by another Integer; in other words, whether the first is a multiple of the second. The first Integer is taken by value and the second by reference.

This means that zero is divisible by any Integer, including zero; but a nonzero Integer 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

use core::str::FromStr;
use malachite_base::num::arithmetic::traits::DivisibleBy;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.divisible_by(&Integer::ZERO), true);
assert_eq!(Integer::from(-100).divisible_by(&Integer::from(-3)), false);
assert_eq!(Integer::from(102).divisible_by(&Integer::from(-3)), true);
assert_eq!(
    Integer::from_str("-1000000000000000000000000")
        .unwrap()
        .divisible_by(&Integer::from_str("1000000000000").unwrap()),
    true
);

Source §

impl DivisibleBy<Integer> for &Integer

Source §

fn divisible_by(self, other: Integer) -> bool

Returns whether an Integer is divisible by another Integer; in other words, whether the first is a multiple of the second. The first Integer is taken by reference and the second by value.

This means that zero is divisible by any Integer, including zero; but a nonzero Integer 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

use core::str::FromStr;
use malachite_base::num::arithmetic::traits::DivisibleBy;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!((&Integer::ZERO).divisible_by(Integer::ZERO), true);
assert_eq!(
    (&Integer::from(-100)).divisible_by(Integer::from(-3)),
    false
);
assert_eq!((&Integer::from(102)).divisible_by(Integer::from(-3)), true);
assert_eq!(
    (&Integer::from_str("-1000000000000000000000000").unwrap())
        .divisible_by(Integer::from_str("1000000000000").unwrap()),
    true
);

Source §

impl DivisibleBy for Integer

Source §

fn divisible_by(self, other: Self) -> bool

Returns whether an Integer is divisible by another Integer; in other words, whether the first is a multiple of the second. Both Integers are taken by value.

This means that zero is divisible by any Integer, including zero; but a nonzero Integer 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

use core::str::FromStr;
use malachite_base::num::arithmetic::traits::DivisibleBy;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.divisible_by(Integer::ZERO), true);
assert_eq!(Integer::from(-100).divisible_by(Integer::from(-3)), false);
assert_eq!(Integer::from(102).divisible_by(Integer::from(-3)), true);
assert_eq!(
    Integer::from_str("-1000000000000000000000000")
        .unwrap()
        .divisible_by(Integer::from_str("1000000000000").unwrap()),
    true
);

Source §

impl DivisibleByPowerOf2 for &Integer

Source §

fn divisible_by_power_of_2(self, pow: u64) -> bool

Returns whether an Integer 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

use malachite_base::num::arithmetic::traits::{DivisibleByPowerOf2, Pow};
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.divisible_by_power_of_2(100), true);
assert_eq!(Integer::from(-100).divisible_by_power_of_2(2), true);
assert_eq!(Integer::from(100u32).divisible_by_power_of_2(3), false);
assert_eq!(
    (-Integer::from(10u32).pow(12)).divisible_by_power_of_2(12),
    true
);
assert_eq!(
    (-Integer::from(10u32).pow(12)).divisible_by_power_of_2(13),
    false
);

Source §

impl EqAbs<Integer> for Natural

Source §

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

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

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

§Examples

use malachite_base::num::comparison::traits::EqAbs;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert_eq!(Natural::from(122u32).eq_abs(&Integer::from(-123)), false);
assert_eq!(Natural::from(124u32).eq_abs(&Integer::from(-123)), false);
assert_eq!(Natural::from(123u32).eq_abs(&Integer::from(123)), true);
assert_eq!(Natural::from(123u32).eq_abs(&Integer::from(-123)), true);

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

§Examples

use malachite_base::num::comparison::traits::EqAbs;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

assert_eq!(Integer::from(-123).eq_abs(&Natural::from(122u32)), false);
assert_eq!(Integer::from(-123).eq_abs(&Natural::from(124u32)), false);
assert_eq!(Integer::from(123).eq_abs(&Natural::from(123u32)), true);
assert_eq!(Integer::from(-123).eq_abs(&Natural::from(123u32)), true);

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

§Examples

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

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

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

§Examples

use core::str::FromStr;
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;

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

Source §

impl EqModPowerOf2<&Integer> for &Integer

Source §

fn eq_mod_power_of_2(self, other: &Integer, pow: u64) -> bool

Returns whether one Integer is equal to another modulo $2^k$; that is, whether their $k$ least-significant bits (in two’s complement) 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

use malachite_base::num::arithmetic::traits::EqModPowerOf2;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::ZERO.eq_mod_power_of_2(&Integer::from(-256), 8),
    true
);
assert_eq!(
    Integer::from(-0b1101).eq_mod_power_of_2(&Integer::from(0b11011), 3),
    true
);
assert_eq!(
    Integer::from(-0b1101).eq_mod_power_of_2(&Integer::from(0b11011), 4),
    false
);

Source §

impl ExtendedGcd<&Integer> for &Integer

Source §

fn extended_gcd(self, other: &Integer) -> (Natural, Integer, Integer)

Computes the GCD (greatest common divisor) of two Integers $a$ and $b$, and also the coefficients $x$ and $y$ in Bézout’s identity $ax+by=\gcd(a,b)$. Both Integers are taken by reference.

The are infinitely many $x$, $y$ that satisfy the identity for any $a$, $b$, so the full specification is more detailed:

$f(0, 0) = (0, 0, 0)$.
$f(a, ak) = (a, 1, 0)$ if $a > 0$ and $k \neq 1$.
$f(a, ak) = (-a, -1, 0)$ if $a < 0$ and $k \neq 1$.
$f(bk, b) = (b, 0, 1)$ if $b > 0$.
$f(bk, b) = (-b, 0, -1)$ if $b < 0$.
$f(a, b) = (g, x, y)$ if $a \neq 0$ and $b \neq 0$ and $\gcd(a, b) \neq \min(|a|, |b|)$, where $g = \gcd(a, b) \geq 0$, $ax + by = g$, $x \leq \lfloor b/g \rfloor$, and $y \leq \lfloor a/g \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 max(self.significant_bits(), other.significant_bits()).

§Examples

use malachite_base::num::arithmetic::traits::ExtendedGcd;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

assert_eq!(
    (&Integer::from(3))
        .extended_gcd(&Integer::from(5))
        .to_debug_string(),
    "(1, 2, -1)"
);
assert_eq!(
    (&Integer::from(240))
        .extended_gcd(&Integer::from(46))
        .to_debug_string(),
    "(2, -9, 47)"
);
assert_eq!(
    (&Integer::from(-111))
        .extended_gcd(&Integer::from(300))
        .to_debug_string(),
    "(3, 27, 10)"
);

Source §

type Gcd = Natural

Source §

type Cofactor = Integer

Source §

impl ExtendedGcd<&Integer> for Integer

Source §

fn extended_gcd(self, other: &Self) -> (Natural, Self, Self)

Computes the GCD (greatest common divisor) of two Integers $a$ and $b$, and also the coefficients $x$ and $y$ in Bézout’s identity $ax+by=\gcd(a,b)$. The first Integer is taken by value and the second by reference.

The are infinitely many $x$, $y$ that satisfy the identity for any $a$, $b$, so the full specification is more detailed:

$f(0, 0) = (0, 0, 0)$.
$f(a, ak) = (a, 1, 0)$ if $a > 0$ and $k \neq 1$.
$f(a, ak) = (-a, -1, 0)$ if $a < 0$ and $k \neq 1$.
$f(bk, b) = (b, 0, 1)$ if $b > 0$.
$f(bk, b) = (-b, 0, -1)$ if $b < 0$.
$f(a, b) = (g, x, y)$ if $a \neq 0$ and $b \neq 0$ and $\gcd(a, b) \neq \min(|a|, |b|)$, where $g = \gcd(a, b) \geq 0$, $ax + by = g$, $x \leq \lfloor b/g \rfloor$, and $y \leq \lfloor a/g \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 max(self.significant_bits(), other.significant_bits()).

§Examples

use malachite_base::num::arithmetic::traits::ExtendedGcd;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(3)
        .extended_gcd(&Integer::from(5))
        .to_debug_string(),
    "(1, 2, -1)"
);
assert_eq!(
    Integer::from(240)
        .extended_gcd(&Integer::from(46))
        .to_debug_string(),
    "(2, -9, 47)"
);
assert_eq!(
    Integer::from(-111)
        .extended_gcd(&Integer::from(300))
        .to_debug_string(),
    "(3, 27, 10)"
);

Source §

type Gcd = Natural

Source §

type Cofactor = Integer

Source §

impl ExtendedGcd<Integer> for &Integer

Source §

fn extended_gcd(self, other: Integer) -> (Natural, Integer, Integer)

Computes the GCD (greatest common divisor) of two Integers $a$ and $b$, and also the coefficients $x$ and $y$ in Bézout’s identity $ax+by=\gcd(a,b)$. The first Integer is taken by reference and the second by value.

The are infinitely many $x$, $y$ that satisfy the identity for any $a$, $b$, so the full specification is more detailed:

$f(0, 0) = (0, 0, 0)$.
$f(a, ak) = (a, 1, 0)$ if $a > 0$ and $k \neq 1$.
$f(a, ak) = (-a, -1, 0)$ if $a < 0$ and $k \neq 1$.
$f(bk, b) = (b, 0, 1)$ if $b > 0$.
$f(bk, b) = (-b, 0, -1)$ if $b < 0$.
$f(a, b) = (g, x, y)$ if $a \neq 0$ and $b \neq 0$ and $\gcd(a, b) \neq \min(|a|, |b|)$, where $g = \gcd(a, b) \geq 0$, $ax + by = g$, $x \leq \lfloor b/g \rfloor$, and $y \leq \lfloor a/g \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 max(self.significant_bits(), other.significant_bits()).

§Examples

use malachite_base::num::arithmetic::traits::ExtendedGcd;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

assert_eq!(
    (&Integer::from(3))
        .extended_gcd(Integer::from(5))
        .to_debug_string(),
    "(1, 2, -1)"
);
assert_eq!(
    (&Integer::from(240))
        .extended_gcd(Integer::from(46))
        .to_debug_string(),
    "(2, -9, 47)"
);
assert_eq!(
    (&Integer::from(-111))
        .extended_gcd(Integer::from(300))
        .to_debug_string(),
    "(3, 27, 10)"
);

Source §

type Gcd = Natural

Source §

type Cofactor = Integer

Source §

impl ExtendedGcd for Integer

Source §

fn extended_gcd(self, other: Self) -> (Natural, Self, Self)

Computes the GCD (greatest common divisor) of two Integers $a$ and $b$, and also the coefficients $x$ and $y$ in Bézout’s identity $ax+by=\gcd(a,b)$. Both Integers are taken by value.

The are infinitely many $x$, $y$ that satisfy the identity for any $a$, $b$, so the full specification is more detailed:

$f(0, 0) = (0, 0, 0)$.
$f(a, ak) = (a, 1, 0)$ if $a > 0$ and $k \neq 1$.
$f(a, ak) = (-a, -1, 0)$ if $a < 0$ and $k \neq 1$.
$f(bk, b) = (b, 0, 1)$ if $b > 0$.
$f(bk, b) = (-b, 0, -1)$ if $b < 0$.
$f(a, b) = (g, x, y)$ if $a \neq 0$ and $b \neq 0$ and $\gcd(a, b) \neq \min(|a|, |b|)$, where $g = \gcd(a, b) \geq 0$, $ax + by = g$, $x \leq \lfloor b/g \rfloor$, and $y \leq \lfloor a/g \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 max(self.significant_bits(), other.significant_bits()).

§Examples

use malachite_base::num::arithmetic::traits::ExtendedGcd;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(3)
        .extended_gcd(Integer::from(5))
        .to_debug_string(),
    "(1, 2, -1)"
);
assert_eq!(
    Integer::from(240)
        .extended_gcd(Integer::from(46))
        .to_debug_string(),
    "(2, -9, 47)"
);
assert_eq!(
    Integer::from(-111)
        .extended_gcd(Integer::from(300))
        .to_debug_string(),
    "(3, 27, 10)"
);

Source §

type Gcd = Natural

Source §

type Cofactor = Integer

Source §

impl FloorRoot<u64> for &Integer

Source §

fn floor_root(self, exp: u64) -> Integer

Returns the floor of the $n$th root of an Integer, taking the Integer 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, or if exp is even and self is negative.

§Examples

use malachite_base::num::arithmetic::traits::FloorRoot;
use malachite_nz::integer::Integer;

assert_eq!((&Integer::from(999)).floor_root(3), 9);
assert_eq!((&Integer::from(1000)).floor_root(3), 10);
assert_eq!((&Integer::from(1001)).floor_root(3), 10);
assert_eq!((&Integer::from(100000000000i64)).floor_root(5), 158);
assert_eq!((&Integer::from(-100000000000i64)).floor_root(5), -159);

Source §

type Output = Integer

Source §

impl FloorRoot<u64> for Integer

Source §

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

Returns the floor of the $n$th root of an Integer, taking the Integer 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, or if exp is even and self is negative.

§Examples

use malachite_base::num::arithmetic::traits::FloorRoot;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(999).floor_root(3), 9);
assert_eq!(Integer::from(1000).floor_root(3), 10);
assert_eq!(Integer::from(1001).floor_root(3), 10);
assert_eq!(Integer::from(100000000000i64).floor_root(5), 158);
assert_eq!(Integer::from(-100000000000i64).floor_root(5), -159);

Source §

type Output = Integer

Source §

impl FloorRootAssign<u64> for Integer

Source §

fn floor_root_assign(&mut self, exp: u64)

Replaces an Integer 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, or if exp is even and self is negative.

§Examples

use malachite_base::num::arithmetic::traits::FloorRootAssign;
use malachite_nz::integer::Integer;

let mut x = Integer::from(999);
x.floor_root_assign(3);
assert_eq!(x, 9);

let mut x = Integer::from(1000);
x.floor_root_assign(3);
assert_eq!(x, 10);

let mut x = Integer::from(1001);
x.floor_root_assign(3);
assert_eq!(x, 10);

let mut x = Integer::from(100000000000i64);
x.floor_root_assign(5);
assert_eq!(x, 158);

let mut x = Integer::from(-100000000000i64);
x.floor_root_assign(5);
assert_eq!(x, -159);

Source §

impl FloorSqrt for &Integer

Source §

fn floor_sqrt(self) -> Integer

Returns the floor of the square root of an Integer, taking it by reference.

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

§Panics

Panics if self is negative.

§Examples

use malachite_base::num::arithmetic::traits::FloorSqrt;
use malachite_nz::integer::Integer;

assert_eq!((&Integer::from(99)).floor_sqrt(), 9);
assert_eq!((&Integer::from(100)).floor_sqrt(), 10);
assert_eq!((&Integer::from(101)).floor_sqrt(), 10);
assert_eq!((&Integer::from(1000000000)).floor_sqrt(), 31622);
assert_eq!((&Integer::from(10000000000u64)).floor_sqrt(), 100000);

Source §

type Output = Integer

Source §

impl FloorSqrt for Integer

Source §

fn floor_sqrt(self) -> Self

Returns the floor of the square root of an Integer, 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().

§Panics

Panics if self is negative.

§Examples

use malachite_base::num::arithmetic::traits::FloorSqrt;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(99).floor_sqrt(), 9);
assert_eq!(Integer::from(100).floor_sqrt(), 10);
assert_eq!(Integer::from(101).floor_sqrt(), 10);
assert_eq!(Integer::from(1000000000).floor_sqrt(), 31622);
assert_eq!(Integer::from(10000000000u64).floor_sqrt(), 100000);

Source §

type Output = Integer

Source §

impl FloorSqrtAssign for Integer

Source §

fn floor_sqrt_assign(&mut self)

Replaces an Integer 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().

§Panics

Panics if self is negative.

§Examples

use malachite_base::num::arithmetic::traits::FloorSqrtAssign;
use malachite_nz::integer::Integer;

let mut x = Integer::from(99);
x.floor_sqrt_assign();
assert_eq!(x, 9);

let mut x = Integer::from(100);
x.floor_sqrt_assign();
assert_eq!(x, 10);

let mut x = Integer::from(101);
x.floor_sqrt_assign();
assert_eq!(x, 10);

let mut x = Integer::from(1000000000);
x.floor_sqrt_assign();
assert_eq!(x, 31622);

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

Source §

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

Source §

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

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

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

Source §

impl From<Natural> for Integer

Source §

fn from(value: Natural) -> Self

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

§Worst-case complexity

Constant time and additional memory.

§Examples

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

Source §

impl From<bool> for Integer

Source §

fn from(b: bool) -> Self

Converts a bool to 0 or 1.

This function is known as the Iverson bracket.

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

§Worst-case complexity

Constant time and additional memory.

§Examples

use malachite_nz::integer::Integer;

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

Source §

impl FromSciString for Integer

Source §

fn from_sci_string_with_options( s: &str, options: FromSciStringOptions, ) -> Option<Self>

Converts a string, possibly in scientfic notation, to an Integer.

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

use malachite_base::num::conversion::string::options::FromSciStringOptions;
use malachite_base::num::conversion::traits::FromSciString;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from_sci_string("123").unwrap(), 123);
assert_eq!(Integer::from_sci_string("123.5").unwrap(), 124);
assert_eq!(Integer::from_sci_string("-123.5").unwrap(), -124);
assert_eq!(Integer::from_sci_string("1.23e10").unwrap(), 12300000000i64);

let mut options = FromSciStringOptions::default();
assert_eq!(
    Integer::from_sci_string_with_options("123.5", options).unwrap(),
    124
);

options.set_rounding_mode(Floor);
assert_eq!(
    Integer::from_sci_string_with_options("123.5", options).unwrap(),
    123
);

options = FromSciStringOptions::default();
options.set_base(16);
assert_eq!(
    Integer::from_sci_string_with_options("ff", options).unwrap(),
    255
);

Source §

fn from_sci_string(s: &str) -> Option<Self>

Converts a &str, possibly in scientific notation, to a number, using the default FromSciStringOptions.

Source §

impl FromStr for Integer

Source §

fn from_str(s: &str) -> Result<Self, ()>

Converts an string to an Integer.

If the string does not represent a valid Integer, an Err is returned. To be valid, the string must be nonempty and only contain the chars '0' through '9', with an optional leading '-'. Leading zeros are allowed, as is the string "-0". The string "-" is not.

§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 core::str::FromStr;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from_str("123456").unwrap(), 123456);
assert_eq!(Integer::from_str("00123456").unwrap(), 123456);
assert_eq!(Integer::from_str("0").unwrap(), 0);
assert_eq!(Integer::from_str("-123456").unwrap(), -123456);
assert_eq!(Integer::from_str("-00123456").unwrap(), -123456);
assert_eq!(Integer::from_str("-0").unwrap(), 0);

assert!(Integer::from_str("").is_err());
assert!(Integer::from_str("a").is_err());

Source §

type Err = ()

The associated error which can be returned from parsing.

Source §

impl FromStringBase for Integer

Source §

fn from_string_base(base: u8, s: &str) -> Option<Self>

Converts an string, in a specified base, to an Integer.

If the string does not represent a valid Integer, 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', with an optional single leading '-' or '+'; and only characters that represent digits smaller than the base are allowed. Leading zeros are allowed, as is the string "-0". The string "-" is not.

§Worst-case complexity

$T(n) = O(n (\log n)^2 \log\log 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 max(self.significant_bits(), other.significant_bits()).

§Panics

Panics if self is negative or if other is even.

§Examples

use malachite_base::num::arithmetic::traits::JacobiSymbol;
use malachite_nz::integer::Integer;

assert_eq!((&Integer::from(10)).jacobi_symbol(&Integer::from(5)), 0);
assert_eq!((&Integer::from(7)).jacobi_symbol(&Integer::from(5)), -1);
assert_eq!((&Integer::from(11)).jacobi_symbol(&Integer::from(5)), 1);
assert_eq!((&Integer::from(11)).jacobi_symbol(&Integer::from(9)), 1);
assert_eq!((&Integer::from(-7)).jacobi_symbol(&Integer::from(5)), -1);
assert_eq!((&Integer::from(-11)).jacobi_symbol(&Integer::from(5)), 1);
assert_eq!((&Integer::from(-11)).jacobi_symbol(&Integer::from(9)), 1);

Source §

impl JacobiSymbol<&Integer> for Integer

Source §

fn jacobi_symbol(self, other: &Self) -> i8

Computes the Jacobi symbol of two Integers, taking the first by value and the second by reference.

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

§Worst-case complexity

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

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

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

§Panics

Panics if self is negative or if other is even.

§Examples

use malachite_base::num::arithmetic::traits::JacobiSymbol;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(10).jacobi_symbol(&Integer::from(5)), 0);
assert_eq!(Integer::from(7).jacobi_symbol(&Integer::from(5)), -1);
assert_eq!(Integer::from(11).jacobi_symbol(&Integer::from(5)), 1);
assert_eq!(Integer::from(11).jacobi_symbol(&Integer::from(9)), 1);
assert_eq!(Integer::from(-7).jacobi_symbol(&Integer::from(5)), -1);
assert_eq!(Integer::from(-11).jacobi_symbol(&Integer::from(5)), 1);
assert_eq!(Integer::from(-11).jacobi_symbol(&Integer::from(9)), 1);

Source §

impl JacobiSymbol<Integer> for &Integer

Source §

fn jacobi_symbol(self, other: Integer) -> i8

Computes the Jacobi symbol of two Integers, taking the first by reference and the second by value.

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

§Worst-case complexity

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

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

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

§Panics

Panics if self is negative or if other is even.

§Examples

use malachite_base::num::arithmetic::traits::JacobiSymbol;
use malachite_nz::integer::Integer;

assert_eq!((&Integer::from(10)).jacobi_symbol(Integer::from(5)), 0);
assert_eq!((&Integer::from(7)).jacobi_symbol(Integer::from(5)), -1);
assert_eq!((&Integer::from(11)).jacobi_symbol(Integer::from(5)), 1);
assert_eq!((&Integer::from(11)).jacobi_symbol(Integer::from(9)), 1);
assert_eq!((&Integer::from(-7)).jacobi_symbol(Integer::from(5)), -1);
assert_eq!((&Integer::from(-11)).jacobi_symbol(Integer::from(5)), 1);
assert_eq!((&Integer::from(-11)).jacobi_symbol(Integer::from(9)), 1);

Source §

impl JacobiSymbol for Integer

Source §

fn jacobi_symbol(self, other: Self) -> i8

Computes the Jacobi symbol of two Integers, taking both by value.

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

§Worst-case complexity

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

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

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

§Panics

Panics if self is negative or if other is even.

§Examples

use malachite_base::num::arithmetic::traits::JacobiSymbol;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(10).jacobi_symbol(Integer::from(5)), 0);
assert_eq!(Integer::from(7).jacobi_symbol(Integer::from(5)), -1);
assert_eq!(Integer::from(11).jacobi_symbol(Integer::from(5)), 1);
assert_eq!(Integer::from(11).jacobi_symbol(Integer::from(9)), 1);
assert_eq!(Integer::from(-7).jacobi_symbol(Integer::from(5)), -1);
assert_eq!(Integer::from(-11).jacobi_symbol(Integer::from(5)), 1);
assert_eq!(Integer::from(-11).jacobi_symbol(Integer::from(9)), 1);

Source §

impl KroneckerSymbol<&Integer> for &Integer

Source §

fn kronecker_symbol(self, other: &Integer) -> i8

Computes the Kronecker symbol of two Integers, taking both by reference.

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

§Worst-case complexity

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

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

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

§Examples

use malachite_base::num::arithmetic::traits::KroneckerSymbol;
use malachite_nz::integer::Integer;

assert_eq!((&Integer::from(10)).kronecker_symbol(&Integer::from(5)), 0);
assert_eq!((&Integer::from(7)).kronecker_symbol(&Integer::from(5)), -1);
assert_eq!((&Integer::from(11)).kronecker_symbol(&Integer::from(5)), 1);
assert_eq!((&Integer::from(11)).kronecker_symbol(&Integer::from(9)), 1);
assert_eq!((&Integer::from(11)).kronecker_symbol(&Integer::from(8)), -1);
assert_eq!((&Integer::from(-7)).kronecker_symbol(&Integer::from(5)), -1);
assert_eq!((&Integer::from(-11)).kronecker_symbol(&Integer::from(5)), 1);
assert_eq!((&Integer::from(-11)).kronecker_symbol(&Integer::from(9)), 1);
assert_eq!(
    (&Integer::from(-11)).kronecker_symbol(&Integer::from(8)),
    -1
);
assert_eq!(
    (&Integer::from(-11)).kronecker_symbol(&Integer::from(-8)),
    1
);

Source §

impl KroneckerSymbol<&Integer> for Integer

Source §

fn kronecker_symbol(self, other: &Self) -> i8

Computes the Kronecker symbol of two Integers, taking the first by value and the second by reference.

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

§Worst-case complexity

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

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

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

§Examples

use malachite_base::num::arithmetic::traits::KroneckerSymbol;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(10).kronecker_symbol(&Integer::from(5)), 0);
assert_eq!(Integer::from(7).kronecker_symbol(&Integer::from(5)), -1);
assert_eq!(Integer::from(11).kronecker_symbol(&Integer::from(5)), 1);
assert_eq!(Integer::from(11).kronecker_symbol(&Integer::from(9)), 1);
assert_eq!(Integer::from(11).kronecker_symbol(&Integer::from(8)), -1);
assert_eq!(Integer::from(-7).kronecker_symbol(&Integer::from(5)), -1);
assert_eq!(Integer::from(-11).kronecker_symbol(&Integer::from(5)), 1);
assert_eq!(Integer::from(-11).kronecker_symbol(&Integer::from(9)), 1);
assert_eq!(Integer::from(-11).kronecker_symbol(&Integer::from(8)), -1);
assert_eq!(Integer::from(-11).kronecker_symbol(&Integer::from(-8)), 1);

Source §

impl KroneckerSymbol<Integer> for &Integer

Source §

fn kronecker_symbol(self, other: Integer) -> i8

Computes the Kronecker symbol of two Integers, taking the first by reference and the second value.

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

§Worst-case complexity

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

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

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

§Examples

use malachite_base::num::arithmetic::traits::KroneckerSymbol;
use malachite_nz::integer::Integer;

assert_eq!((&Integer::from(10)).kronecker_symbol(Integer::from(5)), 0);
assert_eq!((&Integer::from(7)).kronecker_symbol(Integer::from(5)), -1);
assert_eq!((&Integer::from(11)).kronecker_symbol(Integer::from(5)), 1);
assert_eq!((&Integer::from(11)).kronecker_symbol(Integer::from(9)), 1);
assert_eq!((&Integer::from(11)).kronecker_symbol(Integer::from(8)), -1);
assert_eq!((&Integer::from(-7)).kronecker_symbol(Integer::from(5)), -1);
assert_eq!((&Integer::from(-11)).kronecker_symbol(Integer::from(5)), 1);
assert_eq!((&Integer::from(-11)).kronecker_symbol(Integer::from(9)), 1);
assert_eq!((&Integer::from(-11)).kronecker_symbol(Integer::from(8)), -1);
assert_eq!((&Integer::from(-11)).kronecker_symbol(Integer::from(-8)), 1);

Source §

impl KroneckerSymbol for Integer

Source §

fn kronecker_symbol(self, other: Self) -> i8

Computes the Kronecker symbol of two Integers, taking both by value.

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

§Worst-case complexity

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

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

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

§Examples

use malachite_base::num::arithmetic::traits::KroneckerSymbol;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(10).kronecker_symbol(Integer::from(5)), 0);
assert_eq!(Integer::from(7).kronecker_symbol(Integer::from(5)), -1);
assert_eq!(Integer::from(11).kronecker_symbol(Integer::from(5)), 1);
assert_eq!(Integer::from(11).kronecker_symbol(Integer::from(9)), 1);
assert_eq!(Integer::from(11).kronecker_symbol(Integer::from(8)), -1);
assert_eq!(Integer::from(-7).kronecker_symbol(Integer::from(5)), -1);
assert_eq!(Integer::from(-11).kronecker_symbol(Integer::from(5)), 1);
assert_eq!(Integer::from(-11).kronecker_symbol(Integer::from(9)), 1);
assert_eq!(Integer::from(-11).kronecker_symbol(Integer::from(8)), -1);
assert_eq!(Integer::from(-11).kronecker_symbol(Integer::from(-8)), 1);

Source §

impl LegendreSymbol<&Integer> for &Integer

Source §

fn legendre_symbol(self, other: &Integer) -> i8

Computes the Legendre symbol of two Integers, taking both by reference.

This implementation is identical to that of JacobiSymbol, since there is no computational benefit to requiring that the denominator be prime.

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

§Worst-case complexity

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

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

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

§Panics

Panics if self is negative or if other is even.

§Examples

use malachite_base::num::arithmetic::traits::LegendreSymbol;
use malachite_nz::integer::Integer;

assert_eq!((&Integer::from(10)).legendre_symbol(&Integer::from(5)), 0);
assert_eq!((&Integer::from(7)).legendre_symbol(&Integer::from(5)), -1);
assert_eq!((&Integer::from(11)).legendre_symbol(&Integer::from(5)), 1);
assert_eq!((&Integer::from(-7)).legendre_symbol(&Integer::from(5)), -1);
assert_eq!((&Integer::from(-11)).legendre_symbol(&Integer::from(5)), 1);

Source §

impl LegendreSymbol<&Integer> for Integer

Source §

fn legendre_symbol(self, other: &Self) -> i8

Computes the Legendre symbol of two Integers, taking the first by value and the second by reference.

This implementation is identical to that of JacobiSymbol, since there is no computational benefit to requiring that the denominator be prime.

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

§Worst-case complexity

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

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

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

§Panics

Panics if self is negative or if other is even.

§Examples

use malachite_base::num::arithmetic::traits::LegendreSymbol;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(10).legendre_symbol(&Integer::from(5)), 0);
assert_eq!(Integer::from(7).legendre_symbol(&Integer::from(5)), -1);
assert_eq!(Integer::from(11).legendre_symbol(&Integer::from(5)), 1);
assert_eq!(Integer::from(-7).legendre_symbol(&Integer::from(5)), -1);
assert_eq!(Integer::from(-11).legendre_symbol(&Integer::from(5)), 1);

Source §

impl LegendreSymbol<Integer> for &Integer

Source §

fn legendre_symbol(self, other: Integer) -> i8

Computes the Legendre symbol of two Integers, taking the first by reference and the second by value.

This implementation is identical to that of JacobiSymbol, since there is no computational benefit to requiring that the denominator be prime.

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

§Worst-case complexity

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

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

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

§Panics

Panics if self is negative or if other is even.

§Examples

use malachite_base::num::arithmetic::traits::LegendreSymbol;
use malachite_nz::integer::Integer;

assert_eq!((&Integer::from(10)).legendre_symbol(Integer::from(5)), 0);
assert_eq!((&Integer::from(7)).legendre_symbol(Integer::from(5)), -1);
assert_eq!((&Integer::from(11)).legendre_symbol(Integer::from(5)), 1);
assert_eq!((&Integer::from(-7)).legendre_symbol(Integer::from(5)), -1);
assert_eq!((&Integer::from(-11)).legendre_symbol(Integer::from(5)), 1);

Source §

impl LegendreSymbol for Integer

Source §

fn legendre_symbol(self, other: Self) -> i8

Computes the Legendre symbol of two Integers, taking both by value.

This implementation is identical to that of JacobiSymbol, since there is no computational benefit to requiring that the denominator be prime.

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

§Worst-case complexity

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

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

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

§Panics

Panics if self is negative or if other is even.

§Examples

use malachite_base::num::arithmetic::traits::LegendreSymbol;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(10).legendre_symbol(Integer::from(5)), 0);
assert_eq!(Integer::from(7).legendre_symbol(Integer::from(5)), -1);
assert_eq!(Integer::from(11).legendre_symbol(Integer::from(5)), 1);
assert_eq!(Integer::from(-7).legendre_symbol(Integer::from(5)), -1);
assert_eq!(Integer::from(-11).legendre_symbol(Integer::from(5)), 1);

Source §

impl LowMask for Integer

Source §

fn low_mask(bits: u64) -> Self

Returns an Integer 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

use malachite_base::num::logic::traits::LowMask;
use malachite_nz::integer::Integer;

assert_eq!(Integer::low_mask(0), 0);
assert_eq!(Integer::low_mask(3), 7);
assert_eq!(
    Integer::low_mask(100).to_string(),
    "1267650600228229401496703205375"
);

Source §

impl LowerHex for Integer

Source §

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

Converts an Integer 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

use core::str::FromStr;
use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToLowerHexString;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.to_lower_hex_string(), "0");
assert_eq!(Integer::from(123).to_lower_hex_string(), "7b");
assert_eq!(
    Integer::from_str("1000000000000")
        .unwrap()
        .to_lower_hex_string(),
    "e8d4a51000"
);
assert_eq!(format!("{:07x}", Integer::from(123)), "000007b");
assert_eq!(Integer::from(-123).to_lower_hex_string(), "-7b");
assert_eq!(
    Integer::from_str("-1000000000000")
        .unwrap()
        .to_lower_hex_string(),
    "-e8d4a51000"
);
assert_eq!(format!("{:07x}", Integer::from(-123)), "-00007b");

assert_eq!(format!("{:#x}", Integer::ZERO), "0x0");
assert_eq!(format!("{:#x}", Integer::from(123)), "0x7b");
assert_eq!(
    format!("{:#x}", Integer::from_str("1000000000000").unwrap()),
    "0xe8d4a51000"
);
assert_eq!(format!("{:#07x}", Integer::from(123)), "0x0007b");
assert_eq!(format!("{:#x}", Integer::from(-123)), "-0x7b");
assert_eq!(
    format!("{:#x}", Integer::from_str("-1000000000000").unwrap()),
    "-0xe8d4a51000"
);
assert_eq!(format!("{:#07x}", Integer::from(-123)), "-0x007b");

Source §

impl Mod<&Integer> for &Integer

Source §

fn mod_op(self, other: &Integer) -> Integer

Divides an Integer by another Integer, taking both by reference and returning just the remainder. The remainder has the same sign as the second Integer.

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

use malachite_base::num::arithmetic::traits::Mod;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!((&Integer::from(23)).mod_op(&Integer::from(10)), 3);

// -3 * -10 + -7 = 23
assert_eq!((&Integer::from(23)).mod_op(&Integer::from(-10)), -7);

// -3 * 10 + 7 = -23
assert_eq!((&Integer::from(-23)).mod_op(&Integer::from(10)), 7);

// 2 * -10 + -3 = -23
assert_eq!((&Integer::from(-23)).mod_op(&Integer::from(-10)), -3);

Source §

type Output = Integer

Source §

impl Mod<&Integer> for Integer

Source §

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

Divides an Integer by another Integer, taking the first by value and the second by reference and returning just the remainder. The remainder has the same sign as the second Integer.

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

use malachite_base::num::arithmetic::traits::Mod;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(Integer::from(23).mod_op(&Integer::from(10)), 3);

// -3 * -10 + -7 = 23
assert_eq!(Integer::from(23).mod_op(&Integer::from(-10)), -7);

// -3 * 10 + 7 = -23
assert_eq!(Integer::from(-23).mod_op(&Integer::from(10)), 7);

// 2 * -10 + -3 = -23
assert_eq!(Integer::from(-23).mod_op(&Integer::from(-10)), -3);

Source §

type Output = Integer

Source §

impl Mod<Integer> for &Integer

Source §

fn mod_op(self, other: Integer) -> Integer

Divides an Integer by another Integer, taking the first by reference and the second by value and returning just the remainder. The remainder has the same sign as the second Integer.

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

use malachite_base::num::arithmetic::traits::Mod;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!((&Integer::from(23)).mod_op(Integer::from(10)), 3);

// -3 * -10 + -7 = 23
assert_eq!((&Integer::from(23)).mod_op(Integer::from(-10)), -7);

// -3 * 10 + 7 = -23
assert_eq!((&Integer::from(-23)).mod_op(Integer::from(10)), 7);

// 2 * -10 + -3 = -23
assert_eq!((&Integer::from(-23)).mod_op(Integer::from(-10)), -3);

Source §

type Output = Integer

Source §

impl Mod for Integer

Source §

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

Divides an Integer by another Integer, taking both by value and returning just the remainder. The remainder has the same sign as the second Integer.

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

use malachite_base::num::arithmetic::traits::Mod;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(Integer::from(23).mod_op(Integer::from(10)), 3);

// -3 * -10 + -7 = 23
assert_eq!(Integer::from(23).mod_op(Integer::from(-10)), -7);

// -3 * 10 + 7 = -23
assert_eq!(Integer::from(-23).mod_op(Integer::from(10)), 7);

// 2 * -10 + -3 = -23
assert_eq!(Integer::from(-23).mod_op(Integer::from(-10)), -3);

Source §

type Output = Integer

Source §

impl ModAssign<&Integer> for Integer

Source §

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

Divides an Integer by another Integer, taking the second Integer by reference and replacing the first by the remainder. The remainder has the same sign as the second Integer.

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

use malachite_base::num::arithmetic::traits::ModAssign;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
let mut x = Integer::from(23);
x.mod_assign(&Integer::from(10));
assert_eq!(x, 3);

// -3 * -10 + -7 = 23
let mut x = Integer::from(23);
x.mod_assign(&Integer::from(-10));
assert_eq!(x, -7);

// -3 * 10 + 7 = -23
let mut x = Integer::from(-23);
x.mod_assign(&Integer::from(10));
assert_eq!(x, 7);

// 2 * -10 + -3 = -23
let mut x = Integer::from(-23);
x.mod_assign(&Integer::from(-10));
assert_eq!(x, -3);

Source §

impl ModAssign for Integer

Source §

fn mod_assign(&mut self, other: Self)

Divides an Integer by another Integer, taking the second Integer by value and replacing the first by the remainder. The remainder has the same sign as the second Integer.

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

use malachite_base::num::arithmetic::traits::ModAssign;
use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
let mut x = Integer::from(23);
x.mod_assign(Integer::from(10));
assert_eq!(x, 3);

// -3 * -10 + -7 = 23
let mut x = Integer::from(23);
x.mod_assign(Integer::from(-10));
assert_eq!(x, -7);

// -3 * 10 + 7 = -23
let mut x = Integer::from(-23);
x.mod_assign(Integer::from(10));
assert_eq!(x, 7);

// 2 * -10 + -3 = -23
let mut x = Integer::from(-23);
x.mod_assign(Integer::from(-10));
assert_eq!(x, -3);

Source §

impl ModPowerOf2 for &Integer

Source §

fn mod_power_of_2(self, pow: u64) -> Natural

Divides an Integer by $2^k$, taking it by reference and returning just the remainder. The remainder is non-negative.

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

Unlike rem_power_of_2, this function always returns a non-negative number.

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

§Examples

use malachite_base::num::arithmetic::traits::ModPowerOf2;
use malachite_nz::integer::Integer;

// 1 * 2^8 + 4 = 260
assert_eq!((&Integer::from(260)).mod_power_of_2(8), 4);
// -101 * 2^4 + 5 = -1611
assert_eq!((&Integer::from(-1611)).mod_power_of_2(4), 5);

Source §

type Output = Natural

Source §

impl ModPowerOf2 for Integer

Source §

fn mod_power_of_2(self, pow: u64) -> Natural

Divides an Integer by $2^k$, taking it by value and returning just the remainder. The remainder is non-negative.

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

Unlike rem_power_of_2, this function always returns a non-negative number.

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

§Examples

use malachite_base::num::arithmetic::traits::ModPowerOf2;
use malachite_nz::integer::Integer;

// 1 * 2^8 + 4 = 260
assert_eq!(Integer::from(260).mod_power_of_2(8), 4);

// -101 * 2^4 + 5 = -1611
assert_eq!(Integer::from(-1611).mod_power_of_2(4), 5);

Source §

type Output = Natural

Source §

impl ModPowerOf2Assign for Integer

Source §

fn mod_power_of_2_assign(&mut self, pow: u64)

Divides an Integer by $2^k$, replacing the Integer by the remainder. The remainder is non-negative.

If the quotient were computed, he 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. $$

Unlike rem_power_of_2_assign, this function always assigns a non-negative number.

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

§Examples

use malachite_base::num::arithmetic::traits::ModPowerOf2Assign;
use malachite_nz::integer::Integer;

// 1 * 2^8 + 4 = 260
let mut x = Integer::from(260);
x.mod_power_of_2_assign(8);
assert_eq!(x, 4);

// -101 * 2^4 + 5 = -1611
let mut x = Integer::from(-1611);
x.mod_power_of_2_assign(4);
assert_eq!(x, 5);

Source §

impl Mul<&Integer> for &Integer

Source §

fn mul(self, other: &Integer) -> Integer

Multiplies two Integers, 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

use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::integer::Integer;

assert_eq!(&Integer::ONE * &Integer::from(123), 123);
assert_eq!(&Integer::from(123) * &Integer::ZERO, 0);
assert_eq!(&Integer::from(123) * &Integer::from(-456), -56088);
assert_eq!(
    (&Integer::from(-123456789000i64) * &Integer::from(-987654321000i64)).to_string(),
    "121932631112635269000000"
);

Source §

type Output = Integer

The resulting type after applying the * operator.

Source §

impl Mul<&Integer> for Integer

Source §

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

Multiplies two Integers, 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

use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::integer::Integer;

assert_eq!(Integer::ONE * &Integer::from(123), 123);
assert_eq!(Integer::from(123) * &Integer::ZERO, 0);
assert_eq!(Integer::from(123) * &Integer::from(-456), -56088);
assert_eq!(
    (Integer::from(-123456789000i64) * &Integer::from(-987654321000i64)).to_string(),
    "121932631112635269000000"
);

Source §

type Output = Integer

The resulting type after applying the * operator.

Source §

impl Mul<Integer> for &Integer

Source §

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

Multiplies two Integers, 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

use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::integer::Integer;

assert_eq!(&Integer::ONE * Integer::from(123), 123);
assert_eq!(&Integer::from(123) * Integer::ZERO, 0);
assert_eq!(&Integer::from(123) * Integer::from(-456), -56088);
assert_eq!(
    (&Integer::from(-123456789000i64) * Integer::from(-987654321000i64)).to_string(),
    "121932631112635269000000"
);

Source §

type Output = Integer

The resulting type after applying the * operator.

Source §

impl Mul for Integer

Source §

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

Multiplies two Integers, 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

use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::integer::Integer;

assert_eq!(Integer::ONE * Integer::from(123), 123);
assert_eq!(Integer::from(123) * Integer::ZERO, 0);
assert_eq!(Integer::from(123) * Integer::from(-456), -56088);
assert_eq!(
    (Integer::from(-123456789000i64) * Integer::from(-987654321000i64)).to_string(),
    "121932631112635269000000"
);

Source §

type Output = Integer

The resulting type after applying the * operator.

Source §

impl MulAssign<&Integer> for Integer

Source §

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

Multiplies an Integer by an Integer in place, taking the Integer 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

use malachite_base::num::basic::traits::NegativeOne;
use malachite_nz::integer::Integer;

let mut x = Integer::NEGATIVE_ONE;
x *= &Integer::from(1000);
x *= &Integer::from(2000);
x *= &Integer::from(3000);
x *= &Integer::from(4000);
assert_eq!(x, -24000000000000i64);

Source §

impl MulAssign for Integer

Source §

fn mul_assign(&mut self, other: Self)

Multiplies an Integer by an Integer in place, taking the Integer 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

use malachite_base::num::basic::traits::NegativeOne;
use malachite_nz::integer::Integer;

let mut x = Integer::NEGATIVE_ONE;
x *= Integer::from(1000);
x *= Integer::from(2000);
x *= Integer::from(3000);
x *= Integer::from(4000);
assert_eq!(x, -24000000000000i64);

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

§Examples

use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(-&Integer::ZERO, 0);
assert_eq!(-&Integer::from(123), -123);
assert_eq!(-&Integer::from(-123), 123);

The resulting type after applying the - operator.

Source §

impl NegAssign for Integer

Source §

fn neg_assign(&mut self)

Negates an Integer in place.

$$ x \gets -x. $$

§Worst-case complexity

Constant time and additional memory.

§Examples

use malachite_base::num::arithmetic::traits::NegAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

let mut x = Integer::ZERO;
x.neg_assign();
assert_eq!(x, 0);

let mut x = Integer::from(123);
x.neg_assign();
assert_eq!(x, -123);

let mut x = Integer::from(-123);
x.neg_assign();
assert_eq!(x, 123);

Source §

impl NegativeOne for Integer

The constant -1.

Source §

const NEGATIVE_ONE: Self

Source §

impl Not for &Integer

Source §

fn not(self) -> Integer

Returns the bitwise negation of an Integer, taking it by reference.

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

use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(!&Integer::ZERO, -1);
assert_eq!(!&Integer::from(123), -124);
assert_eq!(!&Integer::from(-123), 122);

Source §

type Output = Integer

The resulting type after applying the ! operator.

Source §

impl Not for Integer

Source §

fn not(self) -> Self

Returns the bitwise negation of an Integer, taking it by value.

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

use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(!Integer::ZERO, -1);
assert_eq!(!Integer::from(123), -124);
assert_eq!(!Integer::from(-123), 122);

Source §

type Output = Integer

The resulting type after applying the ! operator.

Source §

impl NotAssign for Integer

Source §

fn not_assign(&mut self)

Replaces an Integer with its bitwise negation.

$$ n \gets -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

use malachite_base::num::basic::traits::Zero;
use malachite_base::num::logic::traits::NotAssign;
use malachite_nz::integer::Integer;

let mut x = Integer::ZERO;
x.not_assign();
assert_eq!(x, -1);

let mut x = Integer::from(123);
x.not_assign();
assert_eq!(x, -124);

let mut x = Integer::from(-123);
x.not_assign();
assert_eq!(x, 122);

Source §

impl Octal for Integer

Source §

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

Converts an Integer 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

use core::str::FromStr;
use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToOctalString;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.to_octal_string(), "0");
assert_eq!(Integer::from(123).to_octal_string(), "173");
assert_eq!(
    Integer::from_str("1000000000000")
        .unwrap()
        .to_octal_string(),
    "16432451210000"
);
assert_eq!(format!("{:07o}", Integer::from(123)), "0000173");
assert_eq!(Integer::from(-123).to_octal_string(), "-173");
assert_eq!(
    Integer::from_str("-1000000000000")
        .unwrap()
        .to_octal_string(),
    "-16432451210000"
);
assert_eq!(format!("{:07o}", Integer::from(-123)), "-000173");

assert_eq!(format!("{:#o}", Integer::ZERO), "0o0");
assert_eq!(format!("{:#o}", Integer::from(123)), "0o173");
assert_eq!(
    format!("{:#o}", Integer::from_str("1000000000000").unwrap()),
    "0o16432451210000"
);
assert_eq!(format!("{:#07o}", Integer::from(123)), "0o00173");
assert_eq!(format!("{:#o}", Integer::from(-123)), "-0o173");
assert_eq!(
    format!("{:#o}", Integer::from_str("-1000000000000").unwrap()),
    "-0o16432451210000"
);
assert_eq!(format!("{:#07o}", Integer::from(-123)), "-0o0173");

Source §

impl One for Integer

The constant 1.

use malachite_nz::integer::Integer;

assert!(Integer::from(-123) < Integer::from(-122));
assert!(Integer::from(-123) <= Integer::from(-122));
assert!(Integer::from(-123) > Integer::from(-124));
assert!(Integer::from(-123) >= Integer::from(-124));

1.21.0 · Source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more

1.21.0 · Source§

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

Compares and returns the minimum of two values. Read more

1.50.0 · Source§

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

Restrict a value to a certain interval. Read more

Source §

impl OrdAbs for Integer

Source §

fn cmp_abs(&self, other: &Self) -> Ordering

Compares the absolute values of two Integers.

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

§Examples

use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::integer::Integer;

assert!(Integer::from(-123).lt_abs(&Integer::from(-124)));
assert!(Integer::from(-123).le_abs(&Integer::from(-124)));
assert!(Integer::from(-124).gt_abs(&Integer::from(-123)));
assert!(Integer::from(-124).ge_abs(&Integer::from(-123)));

Source §

impl Parity for &Integer

Source §

fn even(self) -> bool

Tests whether an Integer is even.

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

$f(x) = (\exists k \in \N : x = 2k)$.

§Worst-case complexity

Constant time and additional memory.

§Examples

use malachite_base::num::arithmetic::traits::{Parity, Pow};
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.even(), true);
assert_eq!(Integer::from(123).even(), false);
assert_eq!(Integer::from(-0x80).even(), true);
assert_eq!(Integer::from(10u32).pow(12).even(), true);
assert_eq!((-Integer::from(10u32).pow(12) - Integer::ONE).even(), false);

Source §

fn odd(self) -> bool

Tests whether an Integer 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

use malachite_base::num::arithmetic::traits::{Parity, Pow};
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.odd(), false);
assert_eq!(Integer::from(123).odd(), true);
assert_eq!(Integer::from(-0x80).odd(), false);
assert_eq!(Integer::from(10u32).pow(12).odd(), false);
assert_eq!((-Integer::from(10u32).pow(12) - Integer::ONE).odd(), true);

Source §

impl PartialEq<Integer> for Natural

Source §

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

1.0.0 · Source§

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

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

Source §

impl PartialEq<Integer> for f32

Source §

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

Determines whether a primitive float is equal to an Integer.

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

§Examples

See here.

1.0.0 · Source§

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

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

Source §

impl PartialEq<Integer> for f64

Source §

impl PartialEq<Natural> for Integer

Source §

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

1.0.0 · Source§

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

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

Source §

impl PartialEq<f32> for Integer

Source §

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

Determines whether an Integer 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.

1.0.0 · Source§

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

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

Source §

impl PartialEq<f64> for Integer

Source §

impl PartialEq for Integer

Source §

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

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

1.0.0 · Source§

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

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

Source §

impl PartialOrd<Integer> for Natural

Source §

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

1.0.0 · Source§

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

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

1.0.0 · Source§

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

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

1.0.0 · Source§

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

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

1.0.0 · Source§

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

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

Source §

impl PartialOrd<Integer> for f32

Source §

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

Compares a primitive float to an Integer.

§Worst-case complexity

$T(n) = O(n)$

Source §

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

Compares a primitive float to an Integer.

§Worst-case complexity

$T(n) = O(n)$

Source §

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

Compares a signed primitive integer to an Integer.

Source §

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

Compares a signed primitive integer to an Integer.

Source §

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

Compares a signed primitive integer to an Integer.

Source §

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

Compares a signed primitive integer to an Integer.

Source §

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

Compares a signed primitive integer to an Integer.

Source §

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

Compares a signed primitive integer to an Integer.

Source §

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

Compares an unsigned primitive integer to an Integer.

Source §

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

Compares an unsigned primitive integer to an Integer.

Source §

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

Compares an unsigned primitive integer to an Integer.

Source §

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

Compares an unsigned primitive integer to an Integer.

Source §

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

Compares an unsigned primitive integer to an Integer.

Source §

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

Compares an unsigned primitive integer to an Integer.

Source §

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

1.0.0 · Source§

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

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

1.0.0 · Source§

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

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

1.0.0 · Source§

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

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

1.0.0 · Source§

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

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

Source §

impl PartialOrd<f32> for Integer

Source §

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

Compares an Integer to a primitive float.

§Worst-case complexity

$T(n) = O(n)$

Source §

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

Compares an Integer to a primitive float.

§Worst-case complexity

$T(n) = O(n)$

Source §

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

Compares an Integer to a signed primitive integer.

Source §

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

Compares an Integer to a signed primitive integer.

Source §

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

Compares an Integer to a signed primitive integer.

Source §

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

Compares an Integer to a signed primitive integer.

Source §

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

Compares an Integer to a signed primitive integer.

Source §

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

Compares an Integer to a signed primitive integer.

Source §

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

Compares an Integer to an unsigned primitive integer.

Source §

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

Compares an Integer to an unsigned primitive integer.

Source §

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

Compares an Integer to an unsigned primitive integer.

Source §

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

Compares an Integer to an unsigned primitive integer.

Source §

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

Compares an Integer to an unsigned primitive integer.

Source §

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

Compares an Integer to an unsigned primitive integer.

Source §

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

Compares two Integers.

See the documentation for the Ord implementation.

1.0.0 · Source§

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

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

1.0.0 · Source§

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

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

1.0.0 · Source§

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

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

1.0.0 · Source§

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

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

Source §

impl PartialOrdAbs<Integer> for Natural

Source §

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

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

Source §

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

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

Source §

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. Read more

Source §

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

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

Source §

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. Read more

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

Source §

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. Read more

Source §

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

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

Source §

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. Read more

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

Source §

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. Read more

Source §

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

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

Source §

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. Read more

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. Read more

Source §

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

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

Source §

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. Read more

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. Read more

Source §

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

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

Source §

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. Read more

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. Read more

Source §

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

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

Source §

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. Read more

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. Read more

Source §

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

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

Source §

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. Read more

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. Read more

Source §

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

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

Source §

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. Read more

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. Read more

Source §

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

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

Source §

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. Read more

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. Read more

Source §

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

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

Source §

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. Read more

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. Read more

Source §

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

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

Source §

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. Read more

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. Read more

Source §

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

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

Source §

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. Read more

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. Read more

Source §

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

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

Source §

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. Read more

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. Read more

Source §

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

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

Source §

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. Read more

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. Read more

Source §

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

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

Source §

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. Read more

Source §

impl PartialOrdAbs<Natural> for Integer

Source §

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

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

Source §

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

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

Source §

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. Read more

Source §

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

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

Source §

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. Read more

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

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

Source §

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. Read more

Source §

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

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

Source §

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. Read more

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

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

Source §

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. Read more

Source §

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

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

Source §

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. Read more

Source §

impl PartialOrdAbs<i128> for Integer

Source §

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

Compares the absolute values of an Integer and a signed primitive integer.

Source §

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

Compares the absolute values of an Integer and a signed primitive integer.

Source §

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

Compares the absolute values of an Integer and a signed primitive integer.

Source §

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

Compares the absolute values of an Integer and a signed primitive integer.

Source §

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

Compares the absolute values of an Integer and a signed primitive integer.

Source §

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

Compares the absolute values of an Integer and a signed primitive integer.

Source §

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

Compares the absolute values of an Integer and an unsigned primitive integer.

Source §

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

Compares the absolute values of an Integer and an unsigned primitive integer.

Source §

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

Compares the absolute values of an Integer and an unsigned primitive integer.

Source §

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

Compares the absolute values of an Integer and an unsigned primitive integer.

Source §

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

Compares the absolute values of an Integer and an unsigned primitive integer.

Source §

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

Compares the absolute values of an Integer and an unsigned primitive integer.

Source §

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

Compares the absolute values of two Integers.

See the documentation for the OrdAbs implementation.

Source §

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

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

Source §

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. Read more

Source §

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

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

Source §

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. Read more

Source §

impl Pow<u64> for &Integer

Source §

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

Raises an Integer to a power, taking the Integer by reference.

$f(x, n) = x^n$.

§Worst-case complexity

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

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

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

§Examples

use core::str::FromStr;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_nz::integer::Integer;

assert_eq!(
    (&Integer::from(-3)).pow(100).to_string(),
    "515377520732011331036461129765621272702107522001"
);
assert_eq!(
    (&Integer::from_str("-12345678987654321").unwrap())
        .pow(3)
        .to_string(),
    "-1881676411868862234942354805142998028003108518161"
);

Source §

type Output = Integer

Source §

impl Pow<u64> for Integer

Source §

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

Raises an Integer to a power, taking the Integer by value.

$f(x, n) = x^n$.

§Worst-case complexity

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

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

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

§Examples

use core::str::FromStr;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(-3).pow(100).to_string(),
    "515377520732011331036461129765621272702107522001"
);
assert_eq!(
    Integer::from_str("-12345678987654321")
        .unwrap()
        .pow(3)
        .to_string(),
    "-1881676411868862234942354805142998028003108518161"
);

Source §

use core::iter::Product;
use malachite_base::vecs::vec_from_str;
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::product(
        vec_from_str::<Integer>("[2, -3, 5, 7]")
            .unwrap()
            .into_iter()
    ),
    -210
);

Source §

impl Rem<&Integer> for &Integer

Source §

fn rem(self, other: &Integer) -> Integer

Divides an Integer by another Integer, taking both by reference and returning just the remainder. The remainder has the same sign as the first Integer.

If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq |r| < |y|$.

$$ f(x, y) = x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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

use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(&Integer::from(23) % &Integer::from(10), 3);

// -3 * -10 + -7 = 23
assert_eq!(&Integer::from(23) % &Integer::from(-10), 3);

// -3 * 10 + 7 = -23
assert_eq!(&Integer::from(-23) % &Integer::from(10), -3);

// 2 * -10 + -3 = -23
assert_eq!(&Integer::from(-23) % &Integer::from(-10), -3);

Source §

type Output = Integer

The resulting type after applying the % operator.

Source §

impl Rem<&Integer> for Integer

Source §

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

Divides an Integer by another Integer, taking the first by value and the second by reference and returning just the remainder. The remainder has the same sign as the first Integer.

If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq |r| < |y|$.

$$ f(x, y) = x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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

use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(Integer::from(23) % &Integer::from(10), 3);

// -3 * -10 + -7 = 23
assert_eq!(Integer::from(23) % &Integer::from(-10), 3);

// -3 * 10 + 7 = -23
assert_eq!(Integer::from(-23) % &Integer::from(10), -3);

// 2 * -10 + -3 = -23
assert_eq!(Integer::from(-23) % &Integer::from(-10), -3);

Source §

type Output = Integer

The resulting type after applying the % operator.

Source §

impl Rem<Integer> for &Integer

Source §

fn rem(self, other: Integer) -> Integer

Divides an Integer by another Integer, taking the first by reference and the second by value and returning just the remainder. The remainder has the same sign as the first Integer.

If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq |r| < |y|$.

$$ f(x, y) = x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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

use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(&Integer::from(23) % Integer::from(10), 3);

// -3 * -10 + -7 = 23
assert_eq!(&Integer::from(23) % Integer::from(-10), 3);

// -3 * 10 + 7 = -23
assert_eq!(&Integer::from(-23) % Integer::from(10), -3);

// 2 * -10 + -3 = -23
assert_eq!(&Integer::from(-23) % Integer::from(-10), -3);

Source §

type Output = Integer

The resulting type after applying the % operator.

Source §

impl Rem for Integer

Source §

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

Divides an Integer by another Integer, taking both by value and returning just the remainder. The remainder has the same sign as the first Integer.

If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq |r| < |y|$.

$$ f(x, y) = x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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

use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
assert_eq!(Integer::from(23) % Integer::from(10), 3);

// -3 * -10 + -7 = 23
assert_eq!(Integer::from(23) % Integer::from(-10), 3);

// -3 * 10 + 7 = -23
assert_eq!(Integer::from(-23) % Integer::from(10), -3);

// 2 * -10 + -3 = -23
assert_eq!(Integer::from(-23) % Integer::from(-10), -3);

Source §

type Output = Integer

The resulting type after applying the % operator.

Source §

impl RemAssign<&Integer> for Integer

Source §

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

Divides an Integer by another Integer, taking the second Integer by reference and replacing the first by the remainder. The remainder has the same sign as the first Integer.

If the quotient were computed, he quotient and remainder would satisfy $x = qy + r$ and $0 \leq |r| < |y|$.

$$ x \gets x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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

use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
let mut x = Integer::from(23);
x %= &Integer::from(10);
assert_eq!(x, 3);

// -3 * -10 + -7 = 23
let mut x = Integer::from(23);
x %= &Integer::from(-10);
assert_eq!(x, 3);

// -3 * 10 + 7 = -23
let mut x = Integer::from(-23);
x %= &Integer::from(10);
assert_eq!(x, -3);

// 2 * -10 + -3 = -23
let mut x = Integer::from(-23);
x %= &Integer::from(-10);
assert_eq!(x, -3);

Source §

impl RemAssign for Integer

Source §

fn rem_assign(&mut self, other: Self)

Divides an Integer by another Integer, taking the second Integer by value and replacing the first by the remainder. The remainder has the same sign as the first Integer.

If the quotient were computed, he quotient and remainder would satisfy $x = qy + r$ and $0 \leq |r| < |y|$.

$$ x \gets x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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

use malachite_nz::integer::Integer;

// 2 * 10 + 3 = 23
let mut x = Integer::from(23);
x %= Integer::from(10);
assert_eq!(x, 3);

// -3 * -10 + -7 = 23
let mut x = Integer::from(23);
x %= Integer::from(-10);
assert_eq!(x, 3);

// -3 * 10 + 7 = -23
let mut x = Integer::from(-23);
x %= Integer::from(10);
assert_eq!(x, -3);

// 2 * -10 + -3 = -23
let mut x = Integer::from(-23);
x %= Integer::from(-10);
assert_eq!(x, -3);

Source §

impl RemPowerOf2 for &Integer

Source §

fn rem_power_of_2(self, pow: u64) -> Integer

Divides an Integer by $2^k$, taking it by reference and returning just the remainder. The remainder has the same sign as the first number.

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\operatorname{sgn}(x)\left \lfloor \frac{|x|}{2^k} \right \rfloor. $$

Unlike mod_power_of_2, this function always returns zero or a number with the same sign as self.

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

§Examples

use malachite_base::num::arithmetic::traits::RemPowerOf2;
use malachite_nz::integer::Integer;

// 1 * 2^8 + 4 = 260
assert_eq!((&Integer::from(260)).rem_power_of_2(8), 4);
// -100 * 2^4 + -11 = -1611
assert_eq!((&Integer::from(-1611)).rem_power_of_2(4), -11);

Source §

type Output = Integer

Source §

impl RemPowerOf2 for Integer

Source §

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

Divides an Integer by $2^k$, taking it by value and returning just the remainder. The remainder has the same sign as the first number.

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\operatorname{sgn}(x)\left \lfloor \frac{|x|}{2^k} \right \rfloor. $$

Unlike mod_power_of_2, this function always returns zero or a number with the same sign as self.

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

§Examples

use malachite_base::num::arithmetic::traits::RemPowerOf2;
use malachite_nz::integer::Integer;

// 1 * 2^8 + 4 = 260
assert_eq!(Integer::from(260).rem_power_of_2(8), 4);

// -100 * 2^4 + -11 = -1611
assert_eq!(Integer::from(-1611).rem_power_of_2(4), -11);

Source §

type Output = Integer

Source §

impl RemPowerOf2Assign for Integer

Source §

fn rem_power_of_2_assign(&mut self, pow: u64)

Divides an Integer by $2^k$, replacing the Integer by the remainder. The remainder has the same sign as the Integer.

If the quotient were computed, he quotient and remainder would satisfy $x = q2^k + r$ and $0 \leq r < 2^k$.

$$ x \gets x - 2^k\operatorname{sgn}(x)\left \lfloor \frac{|x|}{2^k} \right \rfloor. $$

Unlike mod_power_of_2_assign, this function does never changes the sign of self, except possibly to set self to 0.

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

§Examples

use malachite_base::num::arithmetic::traits::RemPowerOf2Assign;
use malachite_nz::integer::Integer;

// 1 * 2^8 + 4 = 260
let mut x = Integer::from(260);
x.rem_power_of_2_assign(8);
assert_eq!(x, 4);

// -100 * 2^4 + -11 = -1611
let mut x = Integer::from(-1611);
x.rem_power_of_2_assign(4);
assert_eq!(x, -11);

Source §

impl RoundToMultiple<&Integer> for &Integer

Source §

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

Rounds an Integer to a multiple of another Integer, according to a specified rounding mode. Both Integers are taken by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

Let $q = \frac{x}{|y|}$:

$f(x, y, \mathrm{Down}) = \operatorname{sgn}(q) |y| \lfloor |q| \rfloor.$

$f(x, y, \mathrm{Up}) = \operatorname{sgn}(q) |y| \lceil |q| \rceil.$

$f(x, y, \mathrm{Floor}) = |y| \lfloor q \rfloor.$

$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}) = q$, but panics if $q \notin \Z$.

The following two expressions are equivalent:

x.round_to_multiple(other, 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

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

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

assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(&Integer::from(4), Down)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(&Integer::from(4), Up)
        .to_debug_string(),
    "(-12, Less)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(&Integer::from(5), Exact)
        .to_debug_string(),
    "(-10, Equal)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(&Integer::from(3), Nearest)
        .to_debug_string(),
    "(-9, Greater)"
);
assert_eq!(
    (&Integer::from(-20))
        .round_to_multiple(&Integer::from(3), Nearest)
        .to_debug_string(),
    "(-21, Less)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(&Integer::from(4), Nearest)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    (&Integer::from(-14))
        .round_to_multiple(&Integer::from(4), Nearest)
        .to_debug_string(),
    "(-16, Less)"
);

assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(&Integer::from(-4), Down)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(&Integer::from(-4), Up)
        .to_debug_string(),
    "(-12, Less)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(&Integer::from(-5), Exact)
        .to_debug_string(),
    "(-10, Equal)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(&Integer::from(-3), Nearest)
        .to_debug_string(),
    "(-9, Greater)"
);
assert_eq!(
    (&Integer::from(-20))
        .round_to_multiple(&Integer::from(-3), Nearest)
        .to_debug_string(),
    "(-21, Less)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(&Integer::from(-4), Nearest)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    (&Integer::from(-14))
        .round_to_multiple(&Integer::from(-4), Nearest)
        .to_debug_string(),
    "(-16, Less)"
);

Source §

type Output = Integer

Source §

impl RoundToMultiple<&Integer> for Integer

Source §

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

Rounds an Integer to a multiple of another Integer, according to a specified rounding mode. The first Integer is taken by value and the second by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

Let $q = \frac{x}{|y|}$:

$f(x, y, \mathrm{Down}) = \operatorname{sgn}(q) |y| \lfloor |q| \rfloor.$

$f(x, y, \mathrm{Up}) = \operatorname{sgn}(q) |y| \lceil |q| \rceil.$

$f(x, y, \mathrm{Floor}) = |y| \lfloor q \rfloor.$

$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}) = q$, but panics if $q \notin \Z$.

The following two expressions are equivalent:

x.round_to_multiple(other, 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

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

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

assert_eq!(
    Integer::from(-10)
        .round_to_multiple(&Integer::from(4), Down)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(&Integer::from(4), Up)
        .to_debug_string(),
    "(-12, Less)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(&Integer::from(5), Exact)
        .to_debug_string(),
    "(-10, Equal)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(&Integer::from(3), Nearest)
        .to_debug_string(),
    "(-9, Greater)"
);
assert_eq!(
    Integer::from(-20)
        .round_to_multiple(&Integer::from(3), Nearest)
        .to_debug_string(),
    "(-21, Less)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(&Integer::from(4), Nearest)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    Integer::from(-14)
        .round_to_multiple(&Integer::from(4), Nearest)
        .to_debug_string(),
    "(-16, Less)"
);

assert_eq!(
    Integer::from(-10)
        .round_to_multiple(&Integer::from(-4), Down)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(&Integer::from(-4), Up)
        .to_debug_string(),
    "(-12, Less)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(&Integer::from(-5), Exact)
        .to_debug_string(),
    "(-10, Equal)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(&Integer::from(-3), Nearest)
        .to_debug_string(),
    "(-9, Greater)"
);
assert_eq!(
    Integer::from(-20)
        .round_to_multiple(&Integer::from(-3), Nearest)
        .to_debug_string(),
    "(-21, Less)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(&Integer::from(-4), Nearest)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    Integer::from(-14)
        .round_to_multiple(&Integer::from(-4), Nearest)
        .to_debug_string(),
    "(-16, Less)"
);

Source §

type Output = Integer

Source §

impl RoundToMultiple<Integer> for &Integer

Source §

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

Rounds an Integer to a multiple of another Integer, according to a specified rounding mode. The first Integer is taken by reference and the second by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

Let $q = \frac{x}{|y|}$:

$f(x, y, \mathrm{Down}) = \operatorname{sgn}(q) |y| \lfloor |q| \rfloor.$

$f(x, y, \mathrm{Up}) = \operatorname{sgn}(q) |y| \lceil |q| \rceil.$

$f(x, y, \mathrm{Floor}) = |y| \lfloor q \rfloor.$

$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}) = q$, but panics if $q \notin \Z$.

The following two expressions are equivalent:

x.round_to_multiple(other, 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

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

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

assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(Integer::from(4), Down)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(Integer::from(4), Up)
        .to_debug_string(),
    "(-12, Less)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(Integer::from(5), Exact)
        .to_debug_string(),
    "(-10, Equal)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(Integer::from(3), Nearest)
        .to_debug_string(),
    "(-9, Greater)"
);
assert_eq!(
    (&Integer::from(-20))
        .round_to_multiple(Integer::from(3), Nearest)
        .to_debug_string(),
    "(-21, Less)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(Integer::from(4), Nearest)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    (&Integer::from(-14))
        .round_to_multiple(Integer::from(4), Nearest)
        .to_debug_string(),
    "(-16, Less)"
);

assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(Integer::from(-4), Down)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(Integer::from(-4), Up)
        .to_debug_string(),
    "(-12, Less)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(Integer::from(-5), Exact)
        .to_debug_string(),
    "(-10, Equal)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(Integer::from(-3), Nearest)
        .to_debug_string(),
    "(-9, Greater)"
);
assert_eq!(
    (&Integer::from(-20))
        .round_to_multiple(Integer::from(-3), Nearest)
        .to_debug_string(),
    "(-21, Less)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple(Integer::from(-4), Nearest)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    (&Integer::from(-14))
        .round_to_multiple(Integer::from(-4), Nearest)
        .to_debug_string(),
    "(-16, Less)"
);

Source §

type Output = Integer

Source §

impl RoundToMultiple for Integer

Source §

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

Rounds an Integer to a multiple of another Integer, according to a specified rounding mode. Both Integers are taken by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

Let $q = \frac{x}{|y|}$:

$f(x, y, \mathrm{Down}) = \operatorname{sgn}(q) |y| \lfloor |q| \rfloor.$

$f(x, y, \mathrm{Up}) = \operatorname{sgn}(q) |y| \lceil |q| \rceil.$

$f(x, y, \mathrm{Floor}) = |y| \lfloor q \rfloor.$

$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}) = q$, but panics if $q \notin \Z$.

The following two expressions are equivalent:

x.round_to_multiple(other, 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

use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

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

assert_eq!(
    Integer::from(-10)
        .round_to_multiple(Integer::from(4), Down)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(Integer::from(4), Up)
        .to_debug_string(),
    "(-12, Less)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(Integer::from(5), Exact)
        .to_debug_string(),
    "(-10, Equal)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(Integer::from(3), Nearest)
        .to_debug_string(),
    "(-9, Greater)"
);
assert_eq!(
    Integer::from(-20)
        .round_to_multiple(Integer::from(3), Nearest)
        .to_debug_string(),
    "(-21, Less)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(Integer::from(4), Nearest)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    Integer::from(-14)
        .round_to_multiple(Integer::from(4), Nearest)
        .to_debug_string(),
    "(-16, Less)"
);

assert_eq!(
    Integer::from(-10)
        .round_to_multiple(Integer::from(-4), Down)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(Integer::from(-4), Up)
        .to_debug_string(),
    "(-12, Less)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(Integer::from(-5), Exact)
        .to_debug_string(),
    "(-10, Equal)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(Integer::from(-3), Nearest)
        .to_debug_string(),
    "(-9, Greater)"
);
assert_eq!(
    Integer::from(-20)
        .round_to_multiple(Integer::from(-3), Nearest)
        .to_debug_string(),
    "(-21, Less)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple(Integer::from(-4), Nearest)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    Integer::from(-14)
        .round_to_multiple(Integer::from(-4), Nearest)
        .to_debug_string(),
    "(-16, Less)"
);

Source §

type Output = Integer

Source §

impl RoundToMultipleAssign<&Integer> for Integer

Source §

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

Rounds an Integer to a multiple of another Integer in place, according to a specified rounding mode. The Integer on the right-hand side is taken by reference. An Ordering is returned, indicating whether the returned value is less than, equal to, or greater than the original value.

See the RoundToMultiple documentation for details.

The following two expressions are equivalent:

x.round_to_multiple_assign(other, 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

use core::cmp::Ordering::*;
use malachite_base::num::arithmetic::traits::RoundToMultipleAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_nz::integer::Integer;

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

let mut x = Integer::from(-10);
assert_eq!(x.round_to_multiple_assign(&Integer::from(4), Down), Greater);
assert_eq!(x, -8);

let mut x = Integer::from(-10);
assert_eq!(x.round_to_multiple_assign(&Integer::from(4), Up), Less);
assert_eq!(x, -12);

let mut x = Integer::from(-10);
assert_eq!(x.round_to_multiple_assign(&Integer::from(5), Exact), Equal);
assert_eq!(x, -10);

let mut x = Integer::from(-10);
assert_eq!(
    x.round_to_multiple_assign(&Integer::from(3), Nearest),
    Greater
);
assert_eq!(x, -9);

let mut x = Integer::from(-20);
assert_eq!(x.round_to_multiple_assign(&Integer::from(3), Nearest), Less);
assert_eq!(x, -21);

let mut x = Integer::from(-10);
assert_eq!(
    x.round_to_multiple_assign(&Integer::from(4), Nearest),
    Greater
);
assert_eq!(x, -8);

let mut x = Integer::from(-14);
assert_eq!(x.round_to_multiple_assign(&Integer::from(4), Nearest), Less);
assert_eq!(x, -16);

let mut x = Integer::from(-10);
assert_eq!(
    x.round_to_multiple_assign(&Integer::from(-4), Down),
    Greater
);
assert_eq!(x, -8);

let mut x = Integer::from(-10);
assert_eq!(x.round_to_multiple_assign(&Integer::from(-4), Up), Less);
assert_eq!(x, -12);

let mut x = Integer::from(-10);
assert_eq!(x.round_to_multiple_assign(&Integer::from(-5), Exact), Equal);
assert_eq!(x, -10);

let mut x = Integer::from(-10);
assert_eq!(
    x.round_to_multiple_assign(&Integer::from(-3), Nearest),
    Greater
);
assert_eq!(x, -9);

let mut x = Integer::from(-20);
assert_eq!(
    x.round_to_multiple_assign(&Integer::from(-3), Nearest),
    Less
);
assert_eq!(x, -21);

let mut x = Integer::from(-10);
assert_eq!(
    x.round_to_multiple_assign(&Integer::from(-4), Nearest),
    Greater
);
assert_eq!(x, -8);

let mut x = Integer::from(-14);
assert_eq!(
    x.round_to_multiple_assign(&Integer::from(-4), Nearest),
    Less
);
assert_eq!(x, -16);

Source §

impl RoundToMultipleAssign for Integer

Source §

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

Rounds an Integer to a multiple of another Integer in place, according to a specified rounding mode. The Integer on the right-hand side is taken by value. An Ordering is returned, indicating whether the returned value is less than, equal to, or greater than the original value.

See the RoundToMultiple documentation for details.

The following two expressions are equivalent:

x.round_to_multiple_assign(other, 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

use core::cmp::Ordering::*;
use malachite_base::num::arithmetic::traits::RoundToMultipleAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_nz::integer::Integer;

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

let mut x = Integer::from(-10);
assert_eq!(x.round_to_multiple_assign(Integer::from(4), Down), Greater);
assert_eq!(x, -8);

let mut x = Integer::from(-10);
assert_eq!(x.round_to_multiple_assign(Integer::from(4), Up), Less);
assert_eq!(x, -12);

let mut x = Integer::from(-10);
assert_eq!(x.round_to_multiple_assign(Integer::from(5), Exact), Equal);
assert_eq!(x, -10);

let mut x = Integer::from(-10);
assert_eq!(
    x.round_to_multiple_assign(Integer::from(3), Nearest),
    Greater
);
assert_eq!(x, -9);

let mut x = Integer::from(-20);
assert_eq!(x.round_to_multiple_assign(Integer::from(3), Nearest), Less);
assert_eq!(x, -21);

let mut x = Integer::from(-10);
assert_eq!(
    x.round_to_multiple_assign(Integer::from(4), Nearest),
    Greater
);
assert_eq!(x, -8);

let mut x = Integer::from(-14);
assert_eq!(x.round_to_multiple_assign(Integer::from(4), Nearest), Less);
assert_eq!(x, -16);

let mut x = Integer::from(-10);
assert_eq!(x.round_to_multiple_assign(Integer::from(-4), Down), Greater);
assert_eq!(x, -8);

let mut x = Integer::from(-10);
assert_eq!(x.round_to_multiple_assign(Integer::from(-4), Up), Less);
assert_eq!(x, -12);

let mut x = Integer::from(-10);
assert_eq!(x.round_to_multiple_assign(Integer::from(-5), Exact), Equal);
assert_eq!(x, -10);

let mut x = Integer::from(-10);
assert_eq!(
    x.round_to_multiple_assign(Integer::from(-3), Nearest),
    Greater
);
assert_eq!(x, -9);

let mut x = Integer::from(-20);
assert_eq!(x.round_to_multiple_assign(Integer::from(-3), Nearest), Less);
assert_eq!(x, -21);

let mut x = Integer::from(-10);
assert_eq!(
    x.round_to_multiple_assign(Integer::from(-4), Nearest),
    Greater
);
assert_eq!(x, -8);

let mut x = Integer::from(-14);
assert_eq!(x.round_to_multiple_assign(Integer::from(-4), Nearest), Less);
assert_eq!(x, -16);

Source §

impl RoundToMultipleOfPowerOf2<u64> for &Integer

Source §

fn round_to_multiple_of_power_of_2( self, pow: u64, rm: RoundingMode, ) -> (Integer, Ordering)

Rounds an Integer to a multiple of $2^k$ according to a specified rounding mode. The Integer is taken by reference. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = 2^k \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = 2^k \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = 2^k \lfloor q \rfloor.$

$f(x, k, \mathrm{Ceiling}) = 2^k \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, k, \mathrm{Exact}) = 2^k q$, but panics if $q \notin \Z$.

The following two expressions are equivalent:

x.round_to_multiple_of_power_of_2(pow, 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

use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

assert_eq!(
    (&Integer::from(10))
        .round_to_multiple_of_power_of_2(2, Floor)
        .to_debug_string(),
    "(8, Less)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple_of_power_of_2(2, Ceiling)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    (&Integer::from(10))
        .round_to_multiple_of_power_of_2(2, Down)
        .to_debug_string(),
    "(8, Less)"
);
assert_eq!(
    (&Integer::from(-10))
        .round_to_multiple_of_power_of_2(2, Up)
        .to_debug_string(),
    "(-12, Less)"
);
assert_eq!(
    (&Integer::from(10))
        .round_to_multiple_of_power_of_2(2, Nearest)
        .to_debug_string(),
    "(8, Less)"
);
assert_eq!(
    (&Integer::from(-12))
        .round_to_multiple_of_power_of_2(2, Exact)
        .to_debug_string(),
    "(-12, Equal)"
);

Source §

type Output = Integer

Source §

impl RoundToMultipleOfPowerOf2<u64> for Integer

Source §

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

Rounds an Integer to a multiple of $2^k$ according to a specified rounding mode. The Integer is taken by value. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

Let $q = \frac{x}{2^k}$:

$f(x, k, \mathrm{Down}) = 2^k \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = 2^k \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = 2^k \lfloor q \rfloor.$

$f(x, k, \mathrm{Ceiling}) = 2^k \lceil q \rceil.$

$$ f(x, k, \mathrm{Nearest}) = \begin{cases} 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$

$f(x, k, \mathrm{Exact}) = 2^k q$, but panics if $q \notin \Z$.

The following two expressions are equivalent:

x.round_to_multiple_of_power_of_2(pow, 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

use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(10)
        .round_to_multiple_of_power_of_2(2, Floor)
        .to_debug_string(),
    "(8, Less)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple_of_power_of_2(2, Ceiling)
        .to_debug_string(),
    "(-8, Greater)"
);
assert_eq!(
    Integer::from(10)
        .round_to_multiple_of_power_of_2(2, Down)
        .to_debug_string(),
    "(8, Less)"
);
assert_eq!(
    Integer::from(-10)
        .round_to_multiple_of_power_of_2(2, Up)
        .to_debug_string(),
    "(-12, Less)"
);
assert_eq!(
    Integer::from(10)
        .round_to_multiple_of_power_of_2(2, Nearest)
        .to_debug_string(),
    "(8, Less)"
);
assert_eq!(
    Integer::from(-12)
        .round_to_multiple_of_power_of_2(2, Exact)
        .to_debug_string(),
    "(-12, Equal)"
);

Source §

type Output = Integer

impl<'a> RoundingFrom<&'a Integer> for f32

Source §

fn rounding_from(value: &'a Integer, rm: RoundingMode) -> (f32, Ordering)

Converts an Integer to a primitive float according to a specified RoundingMode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the rounding mode is Floor the largest float less than or equal to the Integer is returned. If the Integer is greater than the maximum finite float, then the maximum finite float is returned. If it is smaller than the minimum finite float, then $-\infty$ is returned.
If the rounding mode is Ceiling, the smallest float greater than or equal to the Integer is returned. If the Integer is greater than the maximum finite float, then $\infty$ is returned. If it is smaller than the minimum finite float, then the minimum finite float is returned.
If the rounding mode is Down, then the rounding proceeds as with Floor if the Integer is non-negative and as with Ceiling if the Integer is negative.
If the rounding mode is Up, then the rounding proceeds as with Ceiling if the Integer is non-negative and as with Floor if the Integer is negative.
If the rounding mode is Nearest, then the nearest float is returned. If the Integer is exactly between two floats, the float with the zero least-significant bit in its representation is selected. If the Integer is greater than the maximum finite float, then $\infty$ is returned. If the Integer is smaller than the minimum finite float, then $-\infty$ 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.

Source §

impl<'a> RoundingFrom<&'a Integer> for f64

Source §

fn rounding_from(value: &'a Integer, rm: RoundingMode) -> (f64, Ordering)

Converts an Integer to a primitive float according to a specified RoundingMode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the original value.

If the rounding mode is Floor the largest float less than or equal to the Integer is returned. If the Integer is greater than the maximum finite float, then the maximum finite float is returned. If it is smaller than the minimum finite float, then $-\infty$ is returned.
If the rounding mode is Ceiling, the smallest float greater than or equal to the Integer is returned. If the Integer is greater than the maximum finite float, then $\infty$ is returned. If it is smaller than the minimum finite float, then the minimum finite float is returned.
If the rounding mode is Down, then the rounding proceeds as with Floor if the Integer is non-negative and as with Ceiling if the Integer is negative.
If the rounding mode is Up, then the rounding proceeds as with Ceiling if the Integer is non-negative and as with Floor if the Integer is negative.
If the rounding mode is Nearest, then the nearest float is returned. If the Integer is exactly between two floats, the float with the zero least-significant bit in its representation is selected. If the Integer is greater than the maximum finite float, then $\infty$ is returned. If the Integer is smaller than the minimum finite float, then $-\infty$ is returned.

Constant time and additional memory.

§Examples

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

Source §

impl SaturatingFrom<Integer> for Natural

Source §

fn saturating_from(value: Integer) -> Self

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

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

Source §

impl<'a> Shl<i128> for &Integer

Source §

fn shl(self, bits: i128) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl Shl<i128> for Integer

Source §

fn shl(self, bits: i128) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl<'a> Shl<i16> for &Integer

Source §

fn shl(self, bits: i16) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl Shl<i16> for Integer

Source §

fn shl(self, bits: i16) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl<'a> Shl<i32> for &Integer

Source §

fn shl(self, bits: i32) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl Shl<i32> for Integer

Source §

fn shl(self, bits: i32) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl<'a> Shl<i64> for &Integer

Source §

fn shl(self, bits: i64) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl Shl<i64> for Integer

Source §

fn shl(self, bits: i64) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl<'a> Shl<i8> for &Integer

Source §

fn shl(self, bits: i8) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl Shl<i8> for Integer

Source §

fn shl(self, bits: i8) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl<'a> Shl<isize> for &Integer

Source §

fn shl(self, bits: isize) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl Shl<isize> for Integer

Source §

fn shl(self, bits: isize) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl<'a> Shl<u128> for &Integer

Source §

fn shl(self, bits: u128) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl Shl<u128> for Integer

Source §

fn shl(self, bits: u128) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl<'a> Shl<u16> for &Integer

Source §

fn shl(self, bits: u16) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl Shl<u16> for Integer

Source §

fn shl(self, bits: u16) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl<'a> Shl<u32> for &Integer

Source §

fn shl(self, bits: u32) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl Shl<u32> for Integer

Source §

fn shl(self, bits: u32) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl<'a> Shl<u64> for &Integer

Source §

fn shl(self, bits: u64) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl Shl<u64> for Integer

Source §

fn shl(self, bits: u64) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl<'a> Shl<u8> for &Integer

Source §

fn shl(self, bits: u8) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl Shl<u8> for Integer

Source §

fn shl(self, bits: u8) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl<'a> Shl<usize> for &Integer

Source §

fn shl(self, bits: usize) -> Integer

Left-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the << operator.

Source §

impl Shl<usize> for Integer

Source §

fn shl(self, bits: usize) -> Integer

Left-shifts an Integer (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.

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

Source §

impl<'a> ShlRound<i128> for &Integer

Source §

fn shl_round(self, bits: i128, rm: RoundingMode) -> (Integer, Ordering)

Left-shifts an Integer (multiplies or divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is non-negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$g(x, k, \mathrm{Down}) = g(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$g(x, k, \mathrm{Up}) = g(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ g(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} $$

$g(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^{-k}$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShlRound<i128> for Integer

Source §

fn shl_round(self, bits: i128, rm: RoundingMode) -> (Integer, Ordering)

Left-shifts an Integer (multiplies or divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is non-negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$g(x, k, \mathrm{Down}) = g(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$g(x, k, \mathrm{Up}) = g(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ g(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} $$

$g(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^{-k}$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShlRound<i16> for &Integer

Source §

fn shl_round(self, bits: i16, rm: RoundingMode) -> (Integer, Ordering)

Left-shifts an Integer (multiplies or divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is non-negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$g(x, k, \mathrm{Down}) = g(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$g(x, k, \mathrm{Up}) = g(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ g(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} $$

$g(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^{-k}$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShlRound<i16> for Integer

Source §

fn shl_round(self, bits: i16, rm: RoundingMode) -> (Integer, Ordering)

Left-shifts an Integer (multiplies or divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is non-negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$g(x, k, \mathrm{Down}) = g(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$g(x, k, \mathrm{Up}) = g(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ g(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} $$

$g(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^{-k}$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShlRound<i32> for &Integer

Source §

fn shl_round(self, bits: i32, rm: RoundingMode) -> (Integer, Ordering)

Left-shifts an Integer (multiplies or divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is non-negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$g(x, k, \mathrm{Down}) = g(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$g(x, k, \mathrm{Up}) = g(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ g(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} $$

$g(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^{-k}$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShlRound<i32> for Integer

Source §

fn shl_round(self, bits: i32, rm: RoundingMode) -> (Integer, Ordering)

Left-shifts an Integer (multiplies or divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is non-negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$g(x, k, \mathrm{Down}) = g(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$g(x, k, \mathrm{Up}) = g(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ g(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} $$

$g(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^{-k}$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShlRound<i64> for &Integer

Source §

fn shl_round(self, bits: i64, rm: RoundingMode) -> (Integer, Ordering)

Left-shifts an Integer (multiplies or divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is non-negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$g(x, k, \mathrm{Down}) = g(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$g(x, k, \mathrm{Up}) = g(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ g(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} $$

$g(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^{-k}$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShlRound<i64> for Integer

Source §

fn shl_round(self, bits: i64, rm: RoundingMode) -> (Integer, Ordering)

Left-shifts an Integer (multiplies or divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is non-negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$g(x, k, \mathrm{Down}) = g(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$g(x, k, \mathrm{Up}) = g(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ g(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} $$

$g(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^{-k}$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShlRound<i8> for &Integer

Source §

fn shl_round(self, bits: i8, rm: RoundingMode) -> (Integer, Ordering)

Left-shifts an Integer (multiplies or divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is non-negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$g(x, k, \mathrm{Down}) = g(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$g(x, k, \mathrm{Up}) = g(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ g(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} $$

$g(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^{-k}$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShlRound<i8> for Integer

Source §

fn shl_round(self, bits: i8, rm: RoundingMode) -> (Integer, Ordering)

Left-shifts an Integer (multiplies or divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is non-negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$g(x, k, \mathrm{Down}) = g(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$g(x, k, \mathrm{Up}) = g(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ g(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} $$

$g(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^{-k}$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShlRound<isize> for &Integer

Source §

fn shl_round(self, bits: isize, rm: RoundingMode) -> (Integer, Ordering)

Left-shifts an Integer (multiplies or divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is non-negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$g(x, k, \mathrm{Down}) = g(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$g(x, k, \mathrm{Up}) = g(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ g(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} $$

$g(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^{-k}$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShlRound<isize> for Integer

Source §

fn shl_round(self, bits: isize, rm: RoundingMode) -> (Integer, Ordering)

Left-shifts an Integer (multiplies or divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is non-negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$g(x, k, \mathrm{Down}) = g(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$

$g(x, k, \mathrm{Up}) = g(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$

$$ g(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} $$

$g(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^{-k}$.

§Examples

See here.

Source §

See here.

Source §

impl<'a> Shr<i128> for &Integer

Source §

fn shr(self, bits: i128) -> Integer

Right-shifts an Integer (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(1)$

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

§Examples

See here.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl Shr<i128> for Integer

Source §

fn shr(self, bits: i128) -> Integer

Right-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl<'a> Shr<i16> for &Integer

Source §

fn shr(self, bits: i16) -> Integer

Right-shifts an Integer (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(1)$

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

§Examples

See here.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl Shr<i16> for Integer

Source §

fn shr(self, bits: i16) -> Integer

Right-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl<'a> Shr<i32> for &Integer

Source §

fn shr(self, bits: i32) -> Integer

Right-shifts an Integer (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(1)$

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

§Examples

See here.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl Shr<i32> for Integer

Source §

fn shr(self, bits: i32) -> Integer

Right-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl<'a> Shr<i64> for &Integer

Source §

fn shr(self, bits: i64) -> Integer

Right-shifts an Integer (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(1)$

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

§Examples

See here.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl Shr<i64> for Integer

Source §

fn shr(self, bits: i64) -> Integer

Right-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl<'a> Shr<i8> for &Integer

Source §

fn shr(self, bits: i8) -> Integer

Right-shifts an Integer (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(1)$

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

§Examples

See here.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl Shr<i8> for Integer

Source §

fn shr(self, bits: i8) -> Integer

Right-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl<'a> Shr<isize> for &Integer

Source §

fn shr(self, bits: isize) -> Integer

Right-shifts an Integer (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(1)$

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

§Examples

See here.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl Shr<isize> for Integer

Source §

fn shr(self, bits: isize) -> Integer

Right-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl<'a> Shr<u128> for &Integer

Source §

fn shr(self, bits: u128) -> Integer

Right-shifts an Integer (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(1)$

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

§Examples

See here.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl Shr<u128> for Integer

Source §

fn shr(self, bits: u128) -> Integer

Right-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl<'a> Shr<u16> for &Integer

Source §

fn shr(self, bits: u16) -> Integer

Right-shifts an Integer (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(1)$

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

§Examples

See here.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl Shr<u16> for Integer

Source §

fn shr(self, bits: u16) -> Integer

Right-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl<'a> Shr<u32> for &Integer

Source §

fn shr(self, bits: u32) -> Integer

Right-shifts an Integer (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(1)$

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

§Examples

See here.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl Shr<u32> for Integer

Source §

fn shr(self, bits: u32) -> Integer

Right-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl<'a> Shr<u64> for &Integer

Source §

fn shr(self, bits: u64) -> Integer

Right-shifts an Integer (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(1)$

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

§Examples

See here.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl Shr<u64> for Integer

Source §

fn shr(self, bits: u64) -> Integer

Right-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl<'a> Shr<u8> for &Integer

Source §

fn shr(self, bits: u8) -> Integer

Right-shifts an Integer (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(1)$

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

§Examples

See here.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl Shr<u8> for Integer

Source §

fn shr(self, bits: u8) -> Integer

Right-shifts an Integer (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.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl<'a> Shr<usize> for &Integer

Source §

fn shr(self, bits: usize) -> Integer

Right-shifts an Integer (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(1)$

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

§Examples

See here.

Source §

type Output = Integer

The resulting type after applying the >> operator.

Source §

impl Shr<usize> for Integer

Source §

fn shr(self, bits: usize) -> Integer

Right-shifts an Integer (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).

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

Source §

impl<'a> ShrRound<i128> for &Integer

Source §

fn shr_round(self, bits: i128, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides or multiplies it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShrRound<i128> for Integer

Source §

fn shr_round(self, bits: i128, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides or multiplies it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShrRound<i16> for &Integer

Source §

fn shr_round(self, bits: i16, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides or multiplies it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShrRound<i16> for Integer

Source §

fn shr_round(self, bits: i16, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides or multiplies it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShrRound<i32> for &Integer

Source §

fn shr_round(self, bits: i32, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides or multiplies it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShrRound<i32> for Integer

Source §

fn shr_round(self, bits: i32, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides or multiplies it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShrRound<i64> for &Integer

Source §

fn shr_round(self, bits: i64, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides or multiplies it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShrRound<i64> for Integer

Source §

fn shr_round(self, bits: i64, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides or multiplies it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShrRound<i8> for &Integer

Source §

fn shr_round(self, bits: i8, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides or multiplies it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShrRound<i8> for Integer

Source §

fn shr_round(self, bits: i8, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides or multiplies it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShrRound<isize> for &Integer

Source §

fn shr_round(self, bits: isize, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides or multiplies it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShrRound<isize> for Integer

Source §

fn shr_round(self, bits: isize, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides or multiplies it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShrRound<u128> for &Integer

Source §

fn shr_round(self, bits: u128, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShrRound<u128> for Integer

Source §

fn shr_round(self, bits: u128, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShrRound<u16> for &Integer

Source §

fn shr_round(self, bits: u16, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShrRound<u16> for Integer

Source §

fn shr_round(self, bits: u16, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShrRound<u32> for &Integer

Source §

fn shr_round(self, bits: u32, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShrRound<u32> for Integer

Source §

fn shr_round(self, bits: u32, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShrRound<u64> for &Integer

Source §

fn shr_round(self, bits: u64, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShrRound<u64> for Integer

Source §

fn shr_round(self, bits: u64, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShrRound<u8> for &Integer

Source §

fn shr_round(self, bits: u8, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShrRound<u8> for Integer

Source §

fn shr_round(self, bits: u8, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl<'a> ShrRound<usize> for &Integer

Source §

fn shr_round(self, bits: usize, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides it by a power of 2), taking it by reference, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShrRound<usize> for Integer

Source §

fn shr_round(self, bits: usize, rm: RoundingMode) -> (Integer, Ordering)

Shifts an Integer right (divides it by a power of 2), taking it by value, and rounds according to the specified rounding mode. An Ordering is also returned, indicating whether the returned value is less than, equal to, or greater than the exact value.

Passing Floor is equivalent to using >>. To test whether Exact can be passed, use self.divisible_by_power_of_2(bits).

Let $q = \frac{x}{2^k}$, and let $g$ be the function that just returns the first element of the pair, without the Ordering:

$f(x, k, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$

$f(x, k, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$

$f(x, k, \mathrm{Floor}) = \lfloor q \rfloor.$

$f(x, k, \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 \Z$.

Then

$f(x, k, r) = (g(x, k, r), \operatorname{cmp}(g(x, k, r), q))$.

§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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

type Output = Integer

Source §

impl ShrRoundAssign<i128> for Integer

Source §

fn shr_round_assign(&mut self, bits: i128, rm: RoundingMode) -> Ordering

Shifts an Integer right (divides or multiplies it by a power of 2) and rounds according to the specified rounding mode, in place. An Ordering is returned, indicating whether the assigned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

impl ShrRoundAssign<i16> for Integer

Source §

fn shr_round_assign(&mut self, bits: i16, rm: RoundingMode) -> Ordering

Shifts an Integer right (divides or multiplies it by a power of 2) and rounds according to the specified rounding mode, in place. An Ordering is returned, indicating whether the assigned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

impl ShrRoundAssign<i32> for Integer

Source §

fn shr_round_assign(&mut self, bits: i32, rm: RoundingMode) -> Ordering

Shifts an Integer right (divides or multiplies it by a power of 2) and rounds according to the specified rounding mode, in place. An Ordering is returned, indicating whether the assigned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

impl ShrRoundAssign<i64> for Integer

Source §

fn shr_round_assign(&mut self, bits: i64, rm: RoundingMode) -> Ordering

Shifts an Integer right (divides or multiplies it by a power of 2) and rounds according to the specified rounding mode, in place. An Ordering is returned, indicating whether the assigned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

impl ShrRoundAssign<i8> for Integer

Source §

fn shr_round_assign(&mut self, bits: i8, rm: RoundingMode) -> Ordering

Shifts an Integer right (divides or multiplies it by a power of 2) and rounds according to the specified rounding mode, in place. An Ordering is returned, indicating whether the assigned value is less than, equal to, or greater than the exact value. If bits is negative, then the returned Ordering is always Equal, even if the higher bits of the result are lost.

Passing Floor is equivalent to using >>. To test whether 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 Exact but self is not divisible by $2^k$.

§Examples

See here.

Source §

impl ShrRoundAssign<isize> for Integer

Source §

fn shr_round_assign(&mut self, bits: isize, rm: RoundingMode) -> Ordering

fn sign(&self) -> Ordering

Compares an Integer to zero.

Returns Greater, Equal, or Less, depending on whether the Integer is positive, zero, or negative, respectively.

§Worst-case complexity

Constant time and additional memory.

§Examples

use core::cmp::Ordering::*;
use malachite_base::num::arithmetic::traits::Sign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.sign(), Equal);
assert_eq!(Integer::from(123).sign(), Greater);
assert_eq!(Integer::from(-123).sign(), Less);

Source §

impl SignificantBits for &Integer

Source §

fn significant_bits(self) -> u64

Returns the number of significant bits of an Integer’s absolute value.

$$ f(n) = \begin{cases} 0 & \text{if} \quad n = 0, \\ \lfloor \log_2 |n| \rfloor + 1 & \text{otherwise}. \end{cases} $$

§Worst-case complexity

Constant time and additional memory.

§Examples

use malachite_base::num::basic::traits::Zero;
use malachite_base::num::logic::traits::SignificantBits;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.significant_bits(), 0);
assert_eq!(Integer::from(100).significant_bits(), 7);
assert_eq!(Integer::from(-100).significant_bits(), 7);

Source §

impl Square for &Integer

Source §

fn square(self) -> Integer

Squares an Integer, taking it by reference.

$$ f(x) = x^2. $$

§Worst-case complexity

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

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

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

§Examples

use malachite_base::num::arithmetic::traits::Square;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!((&Integer::ZERO).square(), 0);
assert_eq!((&Integer::from(123)).square(), 15129);
assert_eq!((&Integer::from(-123)).square(), 15129);

Source §

type Output = Integer

Source §

impl Square for Integer

Source §

fn square(self) -> Self

Squares an Integer, taking it by value.

$$ f(x) = x^2. $$

§Worst-case complexity

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

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

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

§Examples

use malachite_base::num::arithmetic::traits::Square;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.square(), 0);
assert_eq!(Integer::from(123).square(), 15129);
assert_eq!(Integer::from(-123).square(), 15129);

Source §

type Output = Integer

Source §

impl SquareAssign for Integer

Source §

fn square_assign(&mut self)

Squares an Integer in place.

$$ x \gets x^2. $$

§Worst-case complexity

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

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

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

§Examples

use malachite_base::num::arithmetic::traits::SquareAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

let mut x = Integer::ZERO;
x.square_assign();
assert_eq!(x, 0);

let mut x = Integer::from(123);
x.square_assign();
assert_eq!(x, 15129);

let mut x = Integer::from(-123);
x.square_assign();
assert_eq!(x, 15129);

Source §

impl Sub<&Integer> for &Integer

Source §

fn sub(self, other: &Integer) -> Integer

Subtracts an Integer by another Integer, 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

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(&Integer::ZERO - &Integer::from(123), -123);
assert_eq!(&Integer::from(123) - &Integer::ZERO, 123);
assert_eq!(&Integer::from(456) - &Integer::from(-123), 579);
assert_eq!(
    &-Integer::from(10u32).pow(12) - &(-Integer::from(10u32).pow(12) * Integer::from(2u32)),
    1000000000000u64
);

Source §

type Output = Integer

The resulting type after applying the - operator.

Source §

impl Sub<&Integer> for Integer

Source §

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

Subtracts an Integer by another Integer, 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

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO - &Integer::from(123), -123);
assert_eq!(Integer::from(123) - &Integer::ZERO, 123);
assert_eq!(Integer::from(456) - &Integer::from(-123), 579);
assert_eq!(
    -Integer::from(10u32).pow(12) - &(-Integer::from(10u32).pow(12) * Integer::from(2u32)),
    1000000000000u64
);

Source §

type Output = Integer

The resulting type after applying the - operator.

Source §

impl Sub<Integer> for &Integer

Source §

fn sub(self, other: Integer) -> Integer

Subtracts an Integer by another Integer, 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

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(&Integer::ZERO - Integer::from(123), -123);
assert_eq!(&Integer::from(123) - Integer::ZERO, 123);
assert_eq!(&Integer::from(456) - Integer::from(-123), 579);
assert_eq!(
    &-Integer::from(10u32).pow(12) - -Integer::from(10u32).pow(12) * Integer::from(2u32),
    1000000000000u64
);

Source §

type Output = Integer

The resulting type after applying the - operator.

Source §

impl Sub for Integer

Source §

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

Subtracts an Integer by another Integer, 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

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO - Integer::from(123), -123);
assert_eq!(Integer::from(123) - Integer::ZERO, 123);
assert_eq!(Integer::from(456) - Integer::from(-123), 579);
assert_eq!(
    -Integer::from(10u32).pow(12) - -Integer::from(10u32).pow(12) * Integer::from(2u32),
    1000000000000u64
);

Source §

type Output = Integer

The resulting type after applying the - operator.

Source §

impl SubAssign<&Integer> for Integer

Source §

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

Subtracts an Integer by another Integer in place, taking the Integer 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

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

let mut x = Integer::ZERO;
x -= &(-Integer::from(10u32).pow(12));
x -= &(Integer::from(10u32).pow(12) * Integer::from(2u32));
x -= &(-Integer::from(10u32).pow(12) * Integer::from(3u32));
x -= &(Integer::from(10u32).pow(12) * Integer::from(4u32));
assert_eq!(x, -2000000000000i64);

Source §

impl SubAssign for Integer

Source §

fn sub_assign(&mut self, other: Self)

Subtracts an Integer by another Integer in place, taking the Integer 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)

§Examples

use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

let mut x = Integer::ZERO;
x -= -Integer::from(10u32).pow(12);
x -= Integer::from(10u32).pow(12) * Integer::from(2u32);
x -= -Integer::from(10u32).pow(12) * Integer::from(3u32);
x -= Integer::from(10u32).pow(12) * Integer::from(4u32);
assert_eq!(x, -2000000000000i64);

Source §

impl<'a> SubMul<&'a Integer> for Integer

Source §

fn sub_mul(self, y: &'a Self, z: Self) -> Self

Subtracts an Integer by the product of two other Integers, 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

use malachite_base::num::arithmetic::traits::{Pow, SubMul};
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(10u32).sub_mul(&Integer::from(3u32), Integer::from(-4)),
    22
);
assert_eq!(
    (-Integer::from(10u32).pow(12))
        .sub_mul(&Integer::from(-0x10000), -Integer::from(10u32).pow(12)),
    -65537000000000000i64
);

Source §

type Output = Integer

Source §

impl SubMul<&Integer, &Integer> for &Integer

Source §

fn sub_mul(self, y: &Integer, z: &Integer) -> Integer

Subtracts an Integer by the product of two other Integers, 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

use malachite_base::num::arithmetic::traits::{Pow, SubMul};
use malachite_nz::integer::Integer;

assert_eq!(
    (&Integer::from(10u32)).sub_mul(&Integer::from(3u32), &Integer::from(-4)),
    22
);
assert_eq!(
    (&-Integer::from(10u32).pow(12))
        .sub_mul(&Integer::from(-0x10000), &-Integer::from(10u32).pow(12)),
    -65537000000000000i64
);

Source §

type Output = Integer

Source §

impl SubMul<&Integer, &Integer> for Integer

Source §

fn sub_mul(self, y: &Self, z: &Self) -> Self

Subtracts an Integer by the product of two other Integers, 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

use malachite_base::num::arithmetic::traits::{Pow, SubMul};
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(10u32).sub_mul(&Integer::from(3u32), &Integer::from(-4)),
    22
);
assert_eq!(
    (-Integer::from(10u32).pow(12))
        .sub_mul(&Integer::from(-0x10000), &-Integer::from(10u32).pow(12)),
    -65537000000000000i64
);

Source §

type Output = Integer

Source §

impl<'a> SubMul<Integer, &'a Integer> for Integer

Source §

fn sub_mul(self, y: Self, z: &'a Self) -> Self

Subtracts an Integer by the product of two other Integers, 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

use malachite_base::num::arithmetic::traits::{Pow, SubMul};
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(10u32).sub_mul(Integer::from(3u32), &Integer::from(-4)),
    22
);
assert_eq!(
    (-Integer::from(10u32).pow(12))
        .sub_mul(Integer::from(-0x10000), &-Integer::from(10u32).pow(12)),
    -65537000000000000i64
);

Source §

type Output = Integer

Source §

impl SubMul for Integer

Source §

fn sub_mul(self, y: Self, z: Self) -> Self

Subtracts an Integer by the product of two other Integers, 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

use malachite_base::num::arithmetic::traits::{Pow, SubMul};
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(10u32).sub_mul(Integer::from(3u32), Integer::from(-4)),
    22
);
assert_eq!(
    (-Integer::from(10u32).pow(12))
        .sub_mul(Integer::from(-0x10000), -Integer::from(10u32).pow(12)),
    -65537000000000000i64
);

Source §

use core::iter::Sum;
use malachite_base::vecs::vec_from_str;
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::sum(
        vec_from_str::<Integer>("[2, -3, 5, 7]")
            .unwrap()
            .into_iter()
    ),
    11
);

Source §

impl ToSci for Integer

Source §

fn fmt_sci_valid(&self, options: ToSciOptions) -> bool

Determines whether an Integer 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

use malachite_base::num::conversion::string::options::ToSciOptions;
use malachite_base::num::conversion::traits::ToSci;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_nz::integer::Integer;

let mut options = ToSciOptions::default();
assert!(Integer::from(123).fmt_sci_valid(options));
assert!(Integer::from(u128::MAX).fmt_sci_valid(options));
// u128::MAX has more than 16 significant digits
options.set_rounding_mode(Exact);
assert!(!Integer::from(u128::MAX).fmt_sci_valid(options));
options.set_precision(50);
assert!(Integer::from(u128::MAX).fmt_sci_valid(options));

Source §

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

Converts an Integer 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 an Integer.

§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

use malachite_base::num::conversion::string::options::ToSciOptions;
use malachite_base::num::conversion::traits::ToSci;
use malachite_base::rounding_modes::RoundingMode::*;
use malachite_nz::integer::Integer;

assert_eq!(
    Integer::from(u128::MAX).to_sci().to_string(),
    "3.402823669209385e38"
);
assert_eq!(
    Integer::from(i128::MIN).to_sci().to_string(),
    "-1.701411834604692e38"
);

let n = Integer::from(123456u32);
let mut options = ToSciOptions::default();
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(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");

Source §

fn to_sci_with_options(&self, options: ToSciOptions) -> SciWrapper<'_, Self>

Converts a number to a string, possibly in scientific notation.

Source §

fn to_sci(&self) -> SciWrapper<'_, Self>

Converts a number to a string, possibly in scientific notation, using the default ToSciOptions.

Source §

impl ToStringBase for Integer

Source §

fn to_string_base(&self, base: u8) -> String

Converts an Integer 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

use malachite_base::num::conversion::traits::ToStringBase;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(1000).to_string_base(2), "1111101000");
assert_eq!(Integer::from(1000).to_string_base(10), "1000");
assert_eq!(Integer::from(1000).to_string_base(36), "rs");

assert_eq!(Integer::from(-1000).to_string_base(2), "-1111101000");
assert_eq!(Integer::from(-1000).to_string_base(10), "-1000");
assert_eq!(Integer::from(-1000).to_string_base(36), "-rs");

Source §

fn to_string_base_upper(&self, base: u8) -> String

Converts an Integer 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

use malachite_base::num::conversion::traits::ToStringBase;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(1000).to_string_base_upper(2), "1111101000");
assert_eq!(Integer::from(1000).to_string_base_upper(10), "1000");
assert_eq!(Integer::from(1000).to_string_base_upper(36), "RS");

assert_eq!(Integer::from(-1000).to_string_base_upper(2), "-1111101000");
assert_eq!(Integer::from(-1000).to_string_base_upper(10), "-1000");
assert_eq!(Integer::from(-1000).to_string_base_upper(36), "-RS");

Source §

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

Source §

fn try_from(value: &'a Integer) -> Result<Self, Self::Error>

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

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

§Examples

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

assert_eq!(
    Natural::try_from(&Integer::from(123)).to_debug_string(),
    "Ok(123)"
);
assert_eq!(
    Natural::try_from(&Integer::from(-123)).to_debug_string(),
    "Err(NaturalFromIntegerError)"
);
assert_eq!(
    Natural::try_from(&Integer::from(10u32).pow(12)).to_debug_string(),
    "Ok(1000000000000)"
);
assert_eq!(
    Natural::try_from(&(-Integer::from(10u32).pow(12))).to_debug_string(),
    "Err(NaturalFromIntegerError)"
);

Source §

type Error = NaturalFromIntegerError

The type returned in the event of a conversion error.

Source §

impl<'a> TryFrom<&'a Integer> for f32

Source §

fn try_from(value: &'a Integer) -> Result<f32, Self::Error>

Converts an Integer to a primitive float.

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

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

§Examples

See here.

Source §

type Error = PrimitiveFloatFromIntegerError

The type returned in the event of a conversion error.

Source §

impl<'a> TryFrom<&'a Integer> for f64

Source §

fn try_from(value: &'a Integer) -> Result<f64, Self::Error>

Converts an Integer to a primitive float.

Source §

fn try_from(value: Integer) -> Result<Self, Self::Error>

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

§Worst-case complexity

Constant time and additional memory.

§Examples

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

assert_eq!(
    Natural::try_from(Integer::from(123)).to_debug_string(),
    "Ok(123)"
);
assert_eq!(
    Natural::try_from(Integer::from(-123)).to_debug_string(),
    "Err(NaturalFromIntegerError)"
);
assert_eq!(
    Natural::try_from(Integer::from(10u32).pow(12)).to_debug_string(),
    "Ok(1000000000000)"
);
assert_eq!(
    Natural::try_from(-Integer::from(10u32).pow(12)).to_debug_string(),
    "Err(NaturalFromIntegerError)"
);

Source §

type Error = NaturalFromIntegerError

The type returned in the event of a conversion error.

Source §

impl TryFrom<f32> for Integer

Source §

fn try_from(value: f32) -> Result<Integer, Self::Error>

Converts a primitive float to an Integer.

If the input isn’t exactly equal to some Integer, an error is returned.

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

§Examples

See here.

Source §

type Error = SignedFromFloatError

The type returned in the event of a conversion error.

Source §

impl TryFrom<f64> for Integer

Source §

fn try_from(value: f64) -> Result<Integer, Self::Error>

Converts a primitive float to an Integer.

If the input isn’t exactly equal to some Integer, an error is returned.

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

§Examples

See here.

Source §

type Error = SignedFromFloatError

Source §

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

Converts an Integer 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

use core::str::FromStr;
use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToUpperHexString;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.to_upper_hex_string(), "0");
assert_eq!(Integer::from(123).to_upper_hex_string(), "7B");
assert_eq!(
    Integer::from_str("1000000000000")
        .unwrap()
        .to_upper_hex_string(),
    "E8D4A51000"
);
assert_eq!(format!("{:07X}", Integer::from(123)), "000007B");
assert_eq!(Integer::from(-123).to_upper_hex_string(), "-7B");
assert_eq!(
    Integer::from_str("-1000000000000")
        .unwrap()
        .to_upper_hex_string(),
    "-E8D4A51000"
);
assert_eq!(format!("{:07X}", Integer::from(-123)), "-00007B");

assert_eq!(format!("{:#X}", Integer::ZERO), "0x0");
assert_eq!(format!("{:#X}", Integer::from(123)), "0x7B");
assert_eq!(
    format!("{:#X}", Integer::from_str("1000000000000").unwrap()),
    "0xE8D4A51000"
);
assert_eq!(format!("{:#07X}", Integer::from(123)), "0x0007B");
assert_eq!(format!("{:#X}", Integer::from(-123)), "-0x7B");
assert_eq!(
    format!("{:#X}", Integer::from_str("-1000000000000").unwrap()),
    "-0xE8D4A51000"
);
assert_eq!(format!("{:#07X}", Integer::from(-123)), "-0x007B");

Source §

impl Zero for Integer

The constant 0.

Source §

const ZERO: Self

Source §

impl Eq for Integer

Source §

impl StructuralPartialEq for Integer

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more

Should always be Self

Source §

impl<T, U> SaturatingInto for T
where U: SaturatingFrom<T>,

Source §

use malachite_base::strings::ToOctalString;

assert_eq!(50u64.to_octal_string(), "62");
assert_eq!((-100i16).to_octal_string(), "177634");

Source §

impl<T> ToOwned for T
where T: Clone,

Source §

type Owned = T

The resulting type after obtaining ownership.

Source §

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

Source §

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

Source §

impl<T> ToString for T
where T: Display + ?Sized,

Source §

fn to_string(&self) -> String

Converts the given value to a String. Read more

Source §

impl<T> ToUpperHexString for T
where T: UpperHex,

Source §

fn to_upper_hex_string(&self) -> String

Returns the String produced by Ts UpperHex implementation.

§Examples

use malachite_base::strings::ToUpperHexString;

assert_eq!(50u64.to_upper_hex_string(), "32");
assert_eq!((-100i16).to_upper_hex_string(), "FF9C");

Source §

impl<T, U> TryFrom for T
where U: Into<T>,

Source §

type Error = Infallible

The type returned in the event of a conversion error.

Source §

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Source §

Integer

Struct Integer Copy item path

Implementations§

impl Integer

pub const fn unsigned_abs_ref(&self) -> &Natural

§Worst-case complexity

§Examples

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

§Examples

impl Integer

pub fn from_sign_and_abs(sign: bool, abs: Natural) -> Self

§Worst-case complexity

§Examples

pub fn from_sign_and_abs_ref(sign: bool, abs: &Natural) -> Self

§Worst-case complexity

§Examples

impl Integer

pub const fn const_from_unsigned(x: Limb) -> Self

§Worst-case complexity

§Examples

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

§Worst-case complexity

§Examples

impl Integer

pub fn from_twos_complement_limbs_asc(xs: &[Limb]) -> Self

§Worst-case complexity

§Examples

pub fn from_twos_complement_limbs_desc(xs: &[Limb]) -> Self

§Worst-case complexity

§Examples

pub fn from_owned_twos_complement_limbs_asc(xs: Vec<Limb>) -> Self

§Worst-case complexity

§Examples

pub fn from_owned_twos_complement_limbs_desc(xs: Vec<Limb>) -> Self

§Worst-case complexity

§Examples

impl Integer

pub fn to_twos_complement_limbs_asc(&self) -> Vec<Limb> ⓘ

§Worst-case complexity

§Examples

pub fn to_twos_complement_limbs_desc(&self) -> Vec<Limb> ⓘ

§Worst-case complexity

§Examples

pub fn into_twos_complement_limbs_asc(self) -> Vec<Limb> ⓘ

§Worst-case complexity

§Examples

pub fn into_twos_complement_limbs_desc(self) -> Vec<Limb> ⓘ

§Worst-case complexity

§Examples

pub fn twos_complement_limbs(&self) -> TwosComplementLimbIterator<'_> ⓘ

§Worst-case complexity

§Examples

pub fn twos_complement_limb_count(&self) -> u64

§Worst-case complexity

§Examples

impl Integer

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

§Worst-case complexity

§Examples

impl Integer

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

§Worst-case complexity

§Examples

impl Integer

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

§Worst-case complexity

§Examples

Trait Implementations§

impl Abs for &Integer

fn abs(self) -> Integer

§Worst-case complexity

§Examples

type Output = Integer

impl Abs for Integer

fn abs(self) -> Self

§Worst-case complexity

§Examples

type Output = Integer

impl AbsAssign for Integer

fn abs_assign(&mut self)

Struct Integer