Struct malachite_nz::integer::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) -> Integer

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

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

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

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<'a> Abs for &'a 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<'a> AbsDiff<&'a Integer> for Integer

source §

fn abs_diff(self, other: &'a Integer) -> 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<'a> AbsDiff<Integer> for &'a 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: Integer) -> 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 Integer)

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: Integer)

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<'a, 'b> Add<&'a Integer> for &'b Integer

source §

fn add(self, other: &'a 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<'a> Add<&'a Integer> for Integer

source §

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

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<'a> Add<Integer> for &'a 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: Integer) -> Integer

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<'a, 'b, 'c> AddMul<&'a Integer, &'b Integer> for &'c Integer

source §

fn add_mul(self, y: &'a Integer, z: &'b 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 Integer, z: &'b Integer) -> Integer

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: Integer, z: &'a Integer) -> Integer

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: Integer, z: Integer) -> Integer

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 Integer, k: &'a Integer) -> Integer

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: Integer, k: Integer) -> Integer

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<'a, 'b> BitAnd<&'a Integer> for &'b Integer

source §

fn bitand(self, other: &'a 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<'a> BitAnd<&'a Integer> for Integer

source §

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

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<'a> BitAnd<Integer> for &'a 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: Integer) -> Integer

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<'a> BitAndAssign<&'a Integer> for Integer

source §

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

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: Integer)

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

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

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<'a, 'b> BitOr<&'a Integer> for &'b Integer

source §

fn bitor(self, other: &'a 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 Integer) -> Integer

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<'a> BitOr<Integer> for &'a 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: Integer) -> Integer

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

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: Integer)

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<'a> BitScan for &'a 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<'a, 'b> BitXor<&'a Integer> for &'b Integer

source §

fn bitxor(self, other: &'a 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<'a> BitXor<&'a Integer> for Integer

source §

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

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<'a> BitXor<Integer> for &'a 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: Integer) -> Integer

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<'a> BitXorAssign<&'a Integer> for Integer

source §

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

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: Integer)

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<'a> CeilingDivAssignMod<&'a Integer> for Integer

source §

fn ceiling_div_assign_mod(&mut self, other: &'a Integer) -> Integer

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: Integer) -> Integer

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<'a, 'b> CeilingDivMod<&'b Integer> for &'a Integer

source §

fn ceiling_div_mod(self, other: &'b 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: &'a Integer) -> (Integer, Integer)

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<'a> CeilingMod<&'a Integer> for Integer

source §

fn ceiling_mod(self, other: &'a Integer) -> Integer

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<'a> CeilingMod<Integer> for &'a 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: Integer) -> Integer

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<'a> CeilingModAssign<&'a Integer> for Integer

source §

fn ceiling_mod_assign(&mut self, other: &'a Integer)

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: Integer)

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<'a> CeilingModPowerOf2 for &'a 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<'a> CeilingRoot<u64> for &'a 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) -> Integer

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<'a> CeilingSqrt for &'a 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) -> Integer

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<'a, 'b> CheckedDiv<&'b Integer> for &'a Integer

source §

fn checked_div(self, other: &'b 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<'a> CheckedDiv<&'a Integer> for Integer

source §

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

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<'a> CheckedDiv<Integer> for &'a 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: Integer) -> Option<Integer>

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<'a, 'b> CheckedHammingDistance<&'a Integer> for &'b 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<'a> CheckedRoot<u64> for &'a 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<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 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<'a> CheckedSqrt for &'a 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<Integer>

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 copy 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() -> Integer

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

source §

fn div(self, other: &'b 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<'a> Div<&'a Integer> for Integer

source §

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

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<'a> Div<Integer> for &'a 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: Integer) -> Integer

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

source §

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

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: Integer)

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<'a> DivAssignMod<&'a Integer> for Integer

source §

fn div_assign_mod(&mut self, other: &'a Integer) -> Integer

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: Integer) -> Integer

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<'a> DivAssignRem<&'a Integer> for Integer

source §

fn div_assign_rem(&mut self, other: &'a Integer) -> Integer

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: Integer) -> Integer

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<'a> DivExact<&'a Integer> for Integer

source §

fn div_exact(self, other: &'a Integer) -> Integer

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<'a> DivExact<Integer> for &'a 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: Integer) -> Integer

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<'a> DivExactAssign<&'a Integer> for Integer

source §

fn div_exact_assign(&mut self, other: &'a Integer)

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: Integer)

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<'a, 'b> DivMod<&'b Integer> for &'a Integer

source §

fn div_mod(self, other: &'b 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<'a, 'b> DivRound<&'b Integer> for &'a Integer

source §

fn div_round(self, other: &'b 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<'a> DivRound<&'a Integer> for Integer

source §

fn div_round(self, other: &'a Integer, rm: RoundingMode) -> (Integer, 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<'a> DivRound<Integer> for &'a 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: Integer, rm: RoundingMode) -> (Integer, 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<'a> DivRoundAssign<&'a Integer> for Integer

source §

fn div_round_assign(&mut self, other: &'a Integer, 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: Integer, 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<'a, 'b> DivisibleBy<&'b Integer> for &'a Integer

source §

fn divisible_by(self, other: &'b 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<'a> DivisibleBy<&'a Integer> for Integer

source §

fn divisible_by(self, other: &'a 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 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<'a> DivisibleBy<Integer> for &'a 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: 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 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<'a> DivisibleByPowerOf2 for &'a 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<'a, 'b> EqModPowerOf2<&'b Integer> for &'a Integer

source §

fn eq_mod_power_of_2(self, other: &'b 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<'a, 'b> ExtendedGcd<&'a Integer> for &'b Integer

source §

fn extended_gcd(self, other: &'a 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<'a> ExtendedGcd<&'a Integer> for Integer

source §

fn extended_gcd(self, other: &'a 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 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<'a> ExtendedGcd<Integer> for &'a 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: 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 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<'a> FloorRoot<u64> for &'a 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) -> Integer

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<'a> FloorSqrt for &'a 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) -> Integer

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

Converts a Natural to an Integer, taking the Natural by reference.

§Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

§Examples

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

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

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

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<Integer, ()>

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

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 leading '-'; 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<'a> JacobiSymbol<&'a Integer> for Integer

source §

fn jacobi_symbol(self, other: &'a Integer) -> 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<'a> JacobiSymbol<Integer> for &'a 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: Integer) -> 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<'a, 'b> KroneckerSymbol<&'a Integer> for &'b Integer

source §

fn kronecker_symbol(self, other: &'a 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<'a> KroneckerSymbol<&'a Integer> for Integer

source §

fn kronecker_symbol(self, other: &'a Integer) -> 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<'a> KroneckerSymbol<Integer> for &'a 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: Integer) -> 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<'a, 'b> LegendreSymbol<&'a Integer> for &'b Integer

source §

fn legendre_symbol(self, other: &'a 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<'a> LegendreSymbol<&'a Integer> for Integer

source §

fn legendre_symbol(self, other: &'a Integer) -> 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);

Struct malachite_nz::integer::IntegerCopy 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) -> Integer

§Worst-case complexity

§Examples

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

§Worst-case complexity

§Examples

impl Integer

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

§Worst-case complexity

§Examples

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

§Worst-case complexity

§Examples

impl Integer

pub fn from_twos_complement_limbs_asc(xs: &[Limb]) -> Integer

§Worst-case complexity

§Examples

pub fn from_twos_complement_limbs_desc(xs: &[Limb]) -> Integer

§Worst-case complexity

§Examples

pub fn from_owned_twos_complement_limbs_asc(xs: Vec<Limb>) -> Integer

§Worst-case complexity

§Examples

pub fn from_owned_twos_complement_limbs_desc(xs: Vec<Limb>) -> Integer

§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<'a> Abs for &'a Integer

fn abs(self) -> Integer

§Worst-case complexity

§Examples

type Output = Integer

impl Abs for Integer

fn abs(self) -> Integer

§Worst-case complexity

§Examples

type Output = Integer

impl AbsAssign for Integer

fn abs_assign(&mut self)

§Worst-case complexity

Struct malachite_nz::integer::Integer