# Struct malachite_nz::integer::Integer

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

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

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

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

##### 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§

### impl Integer

source

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

Converts a slice of limbs to an Integer, in ascending order, so that less significant limbs have lower indices in the input slice.

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 non-negative, and if the bit is one it is negative. If the slice is empty, zero is returned.

This function borrows a slice. If taking ownership of a Vec is possible instead, from_owned_twos_complement_limbs_asc is more efficient.

This function is more efficient than from_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 xs.len().

##### Examples
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_twos_complement_limbs_asc(&[]), 0);
assert_eq!(Integer::from_twos_complement_limbs_asc(&[123]), 123);
assert_eq!(Integer::from_twos_complement_limbs_asc(&[4294967173]), -123);
// 10^12 = 232 * 2^32 + 3567587328
assert_eq!(
Integer::from_twos_complement_limbs_asc(&[3567587328, 232]),
1000000000000u64
);
assert_eq!(
Integer::from_twos_complement_limbs_asc(&[727379968, 4294967063]),
-1000000000000i64
);
}
source

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

Converts a slice of limbs to an Integer, in descending order, so that less significant limbs have higher indices in the input slice.

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 non-negative, and if the bit is one it is negative. If the slice is empty, zero is returned.

This function borrows a slice. If taking ownership of a Vec is possible instead, from_owned_twos_complement_limbs_desc is more efficient.

This function is less efficient than from_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 xs.len().

##### Examples
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_twos_complement_limbs_desc(&[]), 0);
assert_eq!(Integer::from_twos_complement_limbs_desc(&[123]), 123);
assert_eq!(Integer::from_twos_complement_limbs_desc(&[4294967173]), -123);
// 10^12 = 232 * 2^32 + 3567587328
assert_eq!(
Integer::from_twos_complement_limbs_desc(&[232, 3567587328]),
1000000000000u64
);
assert_eq!(
Integer::from_twos_complement_limbs_desc(&[4294967063, 727379968]),
-1000000000000i64
);
}
source

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

Converts a slice of limbs to an Integer, in ascending order, so that less significant limbs have lower indices in the input slice.

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 non-negative, and if the bit is one it is negative. If the slice is empty, zero is returned.

This function takes ownership of a Vec. If it’s necessary to borrow a slice instead, use from_twos_complement_limbs_asc

This function is more efficient than from_owned_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 xs.len().

##### Examples
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_asc(vec![]), 0);
assert_eq!(Integer::from_owned_twos_complement_limbs_asc(vec![123]), 123);
assert_eq!(Integer::from_owned_twos_complement_limbs_asc(vec![4294967173]), -123);
// 10^12 = 232 * 2^32 + 3567587328
assert_eq!(
Integer::from_owned_twos_complement_limbs_asc(vec![3567587328, 232]),
1000000000000i64
);
assert_eq!(
Integer::from_owned_twos_complement_limbs_asc(vec![727379968, 4294967063]),
-1000000000000i64
);
}
source

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

Converts a slice of limbs to an Integer, in descending order, so that less significant limbs have higher indices in the input slice.

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 non-negative, and if the bit is one it is negative. If the slice is empty, zero is returned.

This function takes ownership of a Vec. If it’s necessary to borrow a slice instead, use from_twos_complement_limbs_desc.

This function is less efficient than from_owned_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 xs.len().

##### Examples
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.

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

### 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§

### impl Abs for Integer

source§

#### fn abs(self) -> Integer

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

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

##### 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§

### impl AbsAssign for Integer

source§

#### fn abs_assign(&mut self)

Replaces an Integer with its absolute value.

$$x \gets |x|.$$

##### Examples
use malachite_base::num::arithmetic::traits::AbsAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

let mut x = Integer::ZERO;
x.abs_assign();
assert_eq!(x, 0);

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

let mut x = Integer::from(-123);
x.abs_assign();
assert_eq!(x, 123);
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
);
§

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

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

#### type Output = Integer

The resulting type after applying the + operator.
source§

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

#### type Output = Integer

The resulting type after applying the + operator.
source§

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

source§

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

Adds an Integer to an Integer in place, taking the Integer on the right-hand side by reference.

$$x \gets x + y.$$

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

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

let mut x = Integer::ZERO;
x += &(-Integer::from(10u32).pow(12));
x += &(Integer::from(10u32).pow(12) * Integer::from(2u32));
x += &(-Integer::from(10u32).pow(12) * Integer::from(3u32));
x += &(Integer::from(10u32).pow(12) * Integer::from(4u32));
assert_eq!(x, 2000000000000u64);
source§

source§

#### fn add_assign(&mut self, other: Integer)

Adds an Integer to an Integer in place, taking the Integer on the right-hand side by value.

$$x \gets x + y.$$

##### Worst-case complexity

$T(n) = O(n)$

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

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;

let mut x = Integer::ZERO;
x += -Integer::from(10u32).pow(12);
x += Integer::from(10u32).pow(12) * Integer::from(2u32);
x += -Integer::from(10u32).pow(12) * Integer::from(3u32);
x += Integer::from(10u32).pow(12) * Integer::from(4u32);
assert_eq!(x, 2000000000000u64);
source§

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

source§

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

Adds an Integer and the product of two other Integers, taking the first and third by value and the second by reference.

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

##### Worst-case complexity

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

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

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

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

assert_eq!(
(-Integer::from(10u32).pow(12))
-65537000000000000i64
);
§

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!(
22
);
assert_eq!(
(&-Integer::from(10u32).pow(12))
-65537000000000000i64
);
§

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).pow(12))
-65537000000000000i64
);
§

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).pow(12))
-65537000000000000i64
);
§

source§

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).pow(12))
-65537000000000000i64
);
§

source§

### impl<'a> AddMulAssign<&'a Integer> for Integer

source§

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

Adds the product of two other Integers to an Integer in place, taking the first Integer on the right-hand side by reference and the second by value.

$x \gets x + yz$.

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::arithmetic::traits::{AddMulAssign, Pow};
use malachite_nz::integer::Integer;

let mut x = Integer::from(10u32);
assert_eq!(x, 22);

let mut x = -Integer::from(10u32).pow(12);
assert_eq!(x, -65537000000000000i64);
source§

### impl<'a, 'b> AddMulAssign<&'a Integer, &'b Integer> for Integer

source§

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

Adds the product of two other Integers to an Integer in place, taking both Integers on the right-hand side by reference.

$x \gets x + yz$.

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::arithmetic::traits::{AddMulAssign, Pow};
use malachite_nz::integer::Integer;

let mut x = Integer::from(10u32);
assert_eq!(x, 22);

let mut x = -Integer::from(10u32).pow(12);
assert_eq!(x, -65537000000000000i64);
source§

### impl<'a> AddMulAssign<Integer, &'a Integer> for Integer

source§

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

Adds the product of two other Integers to an Integer in place, taking the first Integer on the right-hand side by value and the second by reference.

$x \gets x + yz$.

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::arithmetic::traits::{AddMulAssign, Pow};
use malachite_nz::integer::Integer;

let mut x = Integer::from(10u32);
assert_eq!(x, 22);

let mut x = -Integer::from(10u32).pow(12);
assert_eq!(x, -65537000000000000i64);
source§

source§

#### fn add_mul_assign(&mut self, y: Integer, z: Integer)

Adds the product of two other Integers to an Integer in place, taking both Integers on the right-hand side by value.

$x \gets x + yz$.

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::arithmetic::traits::{AddMulAssign, Pow};
use malachite_nz::integer::Integer;

let mut x = Integer::from(10u32);
assert_eq!(x, 22);

let mut x = -Integer::from(10u32).pow(12);
assert_eq!(x, -65537000000000000i64);
source§

### impl Binary for Integer

source§

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

Converts an Integer to a binary String.

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

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

##### Examples
use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToBinaryString;
use malachite_nz::integer::Integer;
use std::str::FromStr;

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

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

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::logic::traits::BitAccess;
use malachite_base::num::basic::traits::{NegativeOne, Zero};
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::logic::traits::BitAccess;
use malachite_base::num::basic::traits::Zero;
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;
use std::str::FromStr;

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

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

#### 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;
use std::str::FromStr;

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

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

#### 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 malachite_base::num::basic::traits::Zero;
use malachite_base::num::logic::traits::BitBlockAccess;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

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 malachite_base::num::basic::traits::Zero;
use malachite_base::num::logic::traits::BitBlockAccess;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

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

source§

### impl BitConvertible for Integer

source§

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

Returns a Vec containing the twos-complement bits of an Integer in ascending order: least- to most-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 trailing false bits if the Integer is positive or trailing 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 function is more efficient than to_bits_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::logic::traits::BitConvertible;
use malachite_base::num::basic::traits::Zero;
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::logic::traits::BitConvertible;
use malachite_base::num::basic::traits::Zero;
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 malachite_base::num::logic::traits::BitConvertible;
use malachite_nz::integer::Integer;
use std::iter::empty;

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 malachite_base::num::logic::traits::BitConvertible;
use malachite_nz::integer::Integer;
use std::iter::empty;

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.

##### 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§

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

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

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

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

#### 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;
use std::str::FromStr;

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

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

#### 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;
use std::str::FromStr;

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

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

#### 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_base::num::basic::traits::NegativeOne;
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_base::num::basic::traits::NegativeOne;
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§

### 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§

### 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§

### impl<'a> CeilingDivMod<&'a Integer> for Integer

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

§

source§

### impl<'a> CeilingDivMod<Integer> for &'a Integer

source§

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

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

### impl CeilingDivMod for Integer

source§

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

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

### impl<'a, 'b> CeilingMod<&'b Integer> for &'a Integer

source§

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

Divides an Integer by another Integer, taking both 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§

### 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§

### 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§

### 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§

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

source§

### impl CeilingModPowerOf2 for Integer

source§

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

Divides an Integer by $2^k$, taking it by value 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);
§

source§

### impl CeilingModPowerOf2Assign for Integer

source§

#### fn ceiling_mod_power_of_2_assign(&mut self, pow: u64)

Divides an Integer by $2^k$, replacing the Integer by the remainder. The remainder is non-positive.

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

$$x \gets x - 2^k\left \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::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§

### 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§

### 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§

### 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§

### 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> 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§

### 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§

### 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§

### 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§

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

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

source§

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

Determines whether an Integer can be exactly converted to a primitive float.

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

See here.

source§

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

source§

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

Determines whether an Integer can be exactly converted to a primitive float.

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

See here.

source§

### impl<'a> ConvertibleFrom<&'a Integer> for i128

source§

#### fn convertible_from(value: &Integer) -> bool

Determines whether an Integer can be converted to a signed primitive integer.

See here.

source§

### impl<'a> ConvertibleFrom<&'a Integer> for i16

source§

#### fn convertible_from(value: &Integer) -> bool

Determines whether an Integer can be converted to a signed primitive integer.

See here.

source§

### impl<'a> ConvertibleFrom<&'a Integer> for i32

source§

#### fn convertible_from(value: &Integer) -> bool

Determines whether an Integer can be converted to a signed primitive integer.

See here.

source§

### impl<'a> ConvertibleFrom<&'a Integer> for i64

source§

#### fn convertible_from(value: &Integer) -> bool

Determines whether an Integer can be converted to a signed primitive integer.

See here.

source§

### impl<'a> ConvertibleFrom<&'a Integer> for i8

source§

#### fn convertible_from(value: &Integer) -> bool

Determines whether an Integer can be converted to a signed primitive integer.

See here.

source§

### impl<'a> ConvertibleFrom<&'a Integer> for isize

source§

#### fn convertible_from(value: &Integer) -> bool

Determines whether an Integer can be converted to a signed primitive integer.

See here.

source§

### impl<'a> ConvertibleFrom<&'a Integer> for u128

source§

#### fn convertible_from(value: &Integer) -> bool

Determines whether an Integer can be converted to an unsigned primitive integer.

See here.

source§

### impl<'a> ConvertibleFrom<&'a Integer> for u16

source§

#### fn convertible_from(value: &Integer) -> bool

Determines whether an Integer can be converted to an unsigned primitive integer.

See here.

source§

### impl<'a> ConvertibleFrom<&'a Integer> for u32

source§

#### fn convertible_from(value: &Integer) -> bool

Determines whether an Integer can be converted to an unsigned primitive integer.

See here.

source§

### impl<'a> ConvertibleFrom<&'a Integer> for u64

source§

#### fn convertible_from(value: &Integer) -> bool

Determines whether an Integer can be converted to an unsigned primitive integer.

See here.

source§

### impl<'a> ConvertibleFrom<&'a Integer> for u8

source§

#### fn convertible_from(value: &Integer) -> bool

Determines whether an Integer can be converted to an unsigned primitive integer.

See here.

source§

### impl<'a> ConvertibleFrom<&'a Integer> for usize

source§

#### fn convertible_from(value: &Integer) -> bool

Determines whether an Integer can be converted to an unsigned primitive integer.

See here.

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.

##### 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§

#### fn convertible_from(value: f32) -> bool

Determines whether a primitive float can be exactly converted to an Integer.

See here.

source§

### impl ConvertibleFrom<f64> for Integer

source§

#### fn convertible_from(value: f64) -> bool

Determines whether a primitive float can be exactly converted to an Integer.

See here.

source§

### impl Debug for Integer

source§

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

Converts an Integer to a String.

This is the same as the Display::fmt implementation.

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;
use std::str::FromStr;

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 malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
use std::str::FromStr;

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

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

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

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

#### 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§

### 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§

### 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§

### 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_base::strings::ToDebugString;
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§

### impl<'a, 'b> DivExact<&'b Integer> for &'a Integer

source§

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

Divides an Integer by another Integer, taking both 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, RoundingMode::Exact).

##### Panics

Panics if other is zero. May panic if self is not divisible by other.

##### Examples
use malachite_base::num::arithmetic::traits::DivExact;
use malachite_nz::integer::Integer;
use std::str::FromStr;

// -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§

### 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, RoundingMode::Exact).

##### Worst-case complexity

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

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

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

##### Panics

Panics if other is zero. May panic if self is not divisible by other.

##### Examples
use malachite_base::num::arithmetic::traits::DivExact;
use malachite_nz::integer::Integer;
use std::str::FromStr;

// -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§

### 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, RoundingMode::Exact).

##### Worst-case complexity

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

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

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

##### Panics

Panics if other is zero. May panic if self is not divisible by other.

##### Examples
use malachite_base::num::arithmetic::traits::DivExact;
use malachite_nz::integer::Integer;
use std::str::FromStr;

// -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§

### 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, RoundingMode::Exact).

##### Worst-case complexity

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

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

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

##### Panics

Panics if other is zero. May panic if self is not divisible by other.

##### Examples
use malachite_base::num::arithmetic::traits::DivExact;
use malachite_nz::integer::Integer;
use std::str::FromStr;

// -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§

### 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, RoundingMode::Exact).

##### Worst-case complexity

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

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

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

##### Panics

Panics if other is zero. May panic if self is not divisible by other.

##### Examples
use malachite_base::num::arithmetic::traits::DivExactAssign;
use malachite_nz::integer::Integer;
use std::str::FromStr;

// -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, RoundingMode::Exact).

##### Worst-case complexity

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

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

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

##### Panics

Panics if other is zero. May panic if self is not divisible by other.

##### Examples
use malachite_base::num::arithmetic::traits::DivExactAssign;
use malachite_nz::integer::Integer;
use std::str::FromStr;

// -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)"
);
§

§

source§

### impl<'a> DivMod<&'a Integer> for Integer

source§

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

Divides an Integer by another Integer, taking the first by value and the second 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)");
§

§

source§

### impl<'a> DivMod<Integer> for &'a Integer

source§

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

Divides an Integer by another Integer, taking the first by reference and the second by value 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)");
§

§

source§

### impl DivMod for Integer

source§

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

Divides an Integer by another Integer, taking both by value 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)");
§

§

source§

### impl<'a, 'b> DivRem<&'b Integer> for &'a Integer

source§

#### fn div_rem(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 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) = \left ( \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \right \rfloor, \space x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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::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§

### impl<'a> DivRem<&'a Integer> for Integer

source§

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

Divides an Integer by another Integer, taking the first by value and the second by reference and returning the quotient and 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) = \left ( \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \right \rfloor, \space x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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::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§

### impl<'a> DivRem<Integer> for &'a Integer

source§

#### fn div_rem(self, other: Integer) -> (Integer, Integer)

Divides an Integer by another Integer, taking the first by reference and the second by value and returning the quotient and 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) = \left ( \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \right \rfloor, \space x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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::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§

### impl DivRem for Integer

source§

#### fn div_rem(self, other: Integer) -> (Integer, Integer)

Divides an Integer by another Integer, taking both by value and returning the quotient and 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) = \left ( \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \right \rfloor, \space x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \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::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§

### 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 malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
use std::cmp::Ordering;

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

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

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 malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
use std::cmp::Ordering;

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

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

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 malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
use std::cmp::Ordering;

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

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

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 malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
use std::cmp::Ordering;

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

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

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 malachite_base::num::arithmetic::traits::{DivRoundAssign, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
use std::cmp::Ordering;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

let mut n = Integer::from(-14);
assert_eq!(
n.div_round_assign(&Integer::from(-4), RoundingMode::Nearest),
Ordering::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 malachite_base::num::arithmetic::traits::{DivRoundAssign, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
use std::cmp::Ordering;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

let mut n = Integer::from(-14);
assert_eq!(
n.div_round_assign(Integer::from(-4), RoundingMode::Nearest),
Ordering::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 malachite_base::num::arithmetic::traits::DivisibleBy;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
use std::str::FromStr;

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 malachite_base::num::arithmetic::traits::DivisibleBy;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
use std::str::FromStr;

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 malachite_base::num::arithmetic::traits::DivisibleBy;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
use std::str::FromStr;

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 malachite_base::num::arithmetic::traits::DivisibleBy;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
use std::str::FromStr;

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

source§

#### fn eq_mod(self, other: &'b Integer, m: &'c Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. All three numbers are taken by reference.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
(&Integer::from(123)).eq_mod(&Integer::from(223), &Natural::from(100u32)),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
&Integer::from_str("-999999012346").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
&Integer::from_str("2000000987655").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
false
);
source§

### impl<'a, 'b> EqMod<&'a Integer, &'b Natural> for Integer

source§

#### fn eq_mod(self, other: &'a Integer, m: &'b Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. The first number is taken by value and the second and third by reference.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
Integer::from(123).eq_mod(&Integer::from(223), &Natural::from(100u32)),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
&Integer::from_str("-999999012346").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
&Integer::from_str("2000000987655").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
false
);
source§

### impl<'a, 'b> EqMod<&'b Integer, Natural> for &'a Integer

source§

#### fn eq_mod(self, other: &'b Integer, m: Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. The first two numbers are taken by reference and the third by value.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
(&Integer::from(123)).eq_mod(&Integer::from(223), Natural::from(100u32)),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
&Integer::from_str("-999999012346").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
&Integer::from_str("2000000987655").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
false
);
source§

### impl<'a> EqMod<&'a Integer, Natural> for Integer

source§

#### fn eq_mod(self, other: &'a Integer, m: Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. The first and third numbers are taken by value and the second by reference.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
Integer::from(123).eq_mod(&Integer::from(223), Natural::from(100u32)),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
&Integer::from_str("-999999012346").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
&Integer::from_str("2000000987655").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
false
);
source§

### impl<'a, 'b> EqMod<Integer, &'b Natural> for &'a Integer

source§

#### fn eq_mod(self, other: Integer, m: &'b Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. The first and third numbers are taken by reference and the third by value.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
(&Integer::from(123)).eq_mod(Integer::from(223), &Natural::from(100u32)),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
Integer::from_str("-999999012346").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
Integer::from_str("2000000987655").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
false
);
source§

### impl<'a> EqMod<Integer, &'a Natural> for Integer

source§

#### fn eq_mod(self, other: Integer, m: &'a Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. The first two numbers are taken by value and the third by reference.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
Integer::from(123).eq_mod(Integer::from(223), &Natural::from(100u32)),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
Integer::from_str("-999999012346").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
Integer::from_str("2000000987655").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
false
);
source§

### impl<'a> EqMod<Integer, Natural> for &'a Integer

source§

#### fn eq_mod(self, other: Integer, m: Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. The first number is taken by reference and the second and third by value.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
(&Integer::from(123)).eq_mod(Integer::from(223), Natural::from(100u32)),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
Integer::from_str("-999999012346").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
Integer::from_str("2000000987655").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
false
);
source§

### impl EqMod<Integer, Natural> for Integer

source§

#### fn eq_mod(self, other: Integer, m: Natural) -> bool

Returns whether an Integer is equivalent to another Integer modulo a Natural; that is, whether the difference between the two Integers is a multiple of the Natural. All three numbers are taken by value.

Two Integers are equal to each other modulo 0 iff they are equal.

$f(x, y, m) = (x \equiv y \mod m)$.

$f(x, y, m) = (\exists k \in \Z : x - y = km)$.

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;

assert_eq!(
Integer::from(123).eq_mod(Integer::from(223), Natural::from(100u32)),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
Integer::from_str("-999999012346").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
Integer::from_str("2000000987655").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
false
);
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§

### 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§

### 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§

### 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§

### 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§

### 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§

### 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§

### 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§

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

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

##### Examples
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(false), 0);
assert_eq!(Integer::from(true), 1);
source§

### impl From<i128> for Integer

source§

#### fn from(i: i128) -> Integer

Converts a signed primitive integer to an Integer.

See here.

source§

### impl From<i16> for Integer

source§

#### fn from(i: i16) -> Integer

Converts a signed primitive integer to an Integer.

See here.

source§

### impl From<i32> for Integer

source§

#### fn from(i: i32) -> Integer

Converts a signed primitive integer to an Integer.

See here.

source§

### impl From<i64> for Integer

source§

#### fn from(i: i64) -> Integer

Converts a signed primitive integer to an Integer.

See here.

source§

### impl From<i8> for Integer

source§

#### fn from(i: i8) -> Integer

Converts a signed primitive integer to an Integer.

See here.

source§

### impl From<isize> for Integer

source§

#### fn from(i: isize) -> Integer

Converts a signed primitive integer to an Integer.

See here.

source§

### impl From<u128> for Integer

source§

#### fn from(u: u128) -> Integer

Converts an unsigned primitive integer to an Integer.

See here.

source§

### impl From<u16> for Integer

source§

#### fn from(u: u16) -> Integer

Converts an unsigned primitive integer to an Integer.

See here.

source§

### impl From<u32> for Integer

source§

#### fn from(u: u32) -> Integer

Converts an unsigned primitive integer to an Integer.

See here.

source§

### impl From<u64> for Integer

source§

#### fn from(u: u64) -> Integer

Converts an unsigned primitive integer to an Integer.

See here.

source§

### impl From<u8> for Integer

source§

#### fn from(u: u8) -> Integer

Converts an unsigned primitive integer to an Integer.

See here.

source§

### impl From<usize> for Integer

source§

#### fn from(u: usize) -> Integer

Converts an unsigned primitive integer to an Integer.

See here.

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(RoundingMode::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 malachite_nz::integer::Integer;
use std::str::FromStr;

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

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

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

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

##### Panics

Panics if base is less than 2 or greater than 36.

##### Examples
use malachite_base::num::conversion::traits::{Digits, FromStringBase};
use malachite_nz::integer::Integer;

assert_eq!(Integer::from_string_base(10, "123456").unwrap(), 123456);
assert_eq!(Integer::from_string_base(10, "00123456").unwrap(), 123456);
assert_eq!(Integer::from_string_base(16, "0").unwrap(), 0);
assert_eq!(
3735928559i64
);
assert_eq!(
3735928559i64
);
assert_eq!(Integer::from_string_base(10, "-123456").unwrap(), -123456);
assert_eq!(Integer::from_string_base(10, "-00123456").unwrap(), -123456);
assert_eq!(Integer::from_string_base(16, "-0").unwrap(), 0);
assert_eq!(
-3735928559i64
);
assert_eq!(
-3735928559i64
);

assert!(Integer::from_string_base(10, "").is_none());
assert!(Integer::from_string_base(10, "a").is_none());
assert!(Integer::from_string_base(2, "2").is_none());
assert!(Integer::from_string_base(2, "-2").is_none());
source§

### impl Hash for Integer

source§

#### fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · source§

#### fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

### impl<'a> IsInteger for &'a Integer

source§

#### fn is_integer(self) -> bool

Determines whether an Integer is an integer. It always returns true.

$f(x) = \textrm{true}$.

##### Examples
use malachite_base::num::basic::traits::{NegativeOne, One, Zero};
use malachite_base::num::conversion::traits::IsInteger;
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.is_integer(), true);
assert_eq!(Integer::ONE.is_integer(), true);
assert_eq!(Integer::from(100).is_integer(), true);
assert_eq!(Integer::NEGATIVE_ONE.is_integer(), true);
assert_eq!(Integer::from(-100).is_integer(), true);
source§

### impl<'a, 'b> JacobiSymbol<&'a Integer> for &'b Integer

source§

#### fn jacobi_symbol(self, other: &'a Integer) -> i8

Computes the Jacobi 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()).

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

### impl<'a> LegendreSymbol<Integer> for &'a Integer

source§

#### fn legendre_symbol(self, other: Integer) -> i8

Computes the Legendre symbol of two Integers, taking the first by reference and the second by value.

This implementation is identical to that of JacobiSymbol, since there is no computational benefit to requiring that the denominator be prime.

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

##### Worst-case complexity

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

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

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

##### Panics

Panics if self is negative or if other is even.

##### Examples
use malachite_base::num::arithmetic::traits::LegendreSymbol;
use malachite_nz::integer::Integer;

assert_eq!((&Integer::from(10)).legendre_symbol(Integer::from(5)), 0);
assert_eq!((&Integer::from(7)).legendre_symbol(Integer::from(5)), -1);
assert_eq!((&Integer::from(11)).legendre_symbol(Integer::from(5)), 1);
assert_eq!((&Integer::from(-7)).legendre_symbol(Integer::from(5)), -1);
assert_eq!((&Integer::from(-11)).legendre_symbol(Integer::from(5)), 1);
source§

### impl LegendreSymbol for Integer

source§

#### fn legendre_symbol(self, other: Integer) -> i8

Computes the Legendre symbol of two Integers, taking both by value.

This implementation is identical to that of JacobiSymbol, since there is no computational benefit to requiring that the denominator be prime.

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

##### Worst-case complexity

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

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

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

##### Panics

Panics if self is negative or if other is even.

##### Examples
use malachite_base::num::arithmetic::traits::LegendreSymbol;
use malachite_nz::integer::Integer;

assert_eq!(Integer::from(10).legendre_symbol(Integer::from(5)), 0);
assert_eq!(Integer::from(7).legendre_symbol(Integer::from(5)), -1);
assert_eq!(Integer::from(11).legendre_symbol(Integer::from(5)), 1);
assert_eq!(Integer::from(-7).legendre_symbol(Integer::from(5)), -1);
assert_eq!(Integer::from(-11).legendre_symbol(Integer::from(5)), 1);
source§

source§

#### fn low_mask(bits: u64) -> Integer

Returns an Integer whose least significant $b$ bits are true and whose other bits are false.

$f(b) = 2^b - 1$.

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

##### Examples
use malachite_base::num::logic::traits::LowMask;
use malachite_nz::integer::Integer;

assert_eq!(Integer::low_mask(100).to_string(), "1267650600228229401496703205375");
source§

### impl LowerHex for Integer

source§

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

Converts an Integer to a hexadecimal String using lowercase characters.

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

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

##### Examples
use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToLowerHexString;
use malachite_nz::integer::Integer;
use std::str::FromStr;

assert_eq!(Integer::ZERO.to_lower_hex_string(), "0");
assert_eq!(Integer::from(123).to_lower_hex_string(), "7b");
assert_eq!(
Integer::from_str("1000000000000")
.unwrap()
.to_lower_hex_string(),
"e8d4a51000"
);
assert_eq!(format!("{:07x}", Integer::from(123)), "000007b");
assert_eq!(Integer::from(-123).to_lower_hex_string(), "-7b");
assert_eq!(
Integer::from_str("-1000000000000")
.unwrap()
.to_lower_hex_string(),
"-e8d4a51000"
);
assert_eq!(format!("{:07x}", Integer::from(-123)), "-00007b");

assert_eq!(format!("{:#x}", Integer::ZERO), "0x0");
assert_eq!(format!("{:#x}", Integer::from(123)), "0x7b");
assert_eq!(
format!("{:#x}", Integer::from_str("1000000000000").unwrap()),
"0xe8d4a51000"
);
assert_eq!(format!("{:#07x}", Integer::from(123)), "0x0007b");
assert_eq!(format!("{:#x}", Integer::from(-123)), "-0x7b");
assert_eq!(
format!("{:#x}", Integer::from_str("-1000000000000").unwrap()),
"-0xe8d4a51000"
);
assert_eq!(format!("{:#07x}", Integer::from(-123)), "-0x007b");
source§

### impl<'a, 'b> Mod<&'b Integer> for &'a Integer

source§

#### fn mod_op(self, other: &'b Integer) -> Integer

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

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

$$f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor.$$

This function is called mod_op rather than mod because mod is a Rust keyword.

##### Worst-case complexity

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

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

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

##### Panics

Panics if other is zero.

##### Examples
use malachite_base::num::arithmetic::traits::Mod;
use malachite_nz::integer::Integer;

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

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

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

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

source§

### impl<'a> Mod<&'a Integer> for Integer

source§

#### fn mod_op(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 same sign as the second Integer.

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

$$f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor.$$

This function is called mod_op rather than mod because mod is a Rust keyword.

##### Worst-case complexity

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

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

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

##### Panics

Panics if other is zero.

##### Examples
use malachite_base::num::arithmetic::traits::Mod;
use malachite_nz::integer::Integer;

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

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

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

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

source§

### impl<'a> Mod<Integer> for &'a Integer

source§

#### fn mod_op(self, other: Integer) -> Integer

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

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

$$f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor.$$

This function is called mod_op rather than mod because mod is a Rust keyword.

##### Worst-case complexity

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

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

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

##### Panics

Panics if other is zero.

##### Examples
use malachite_base::num::arithmetic::traits::Mod;
use malachite_nz::integer::Integer;

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

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

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

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

source§

### impl Mod for Integer

source§

#### fn mod_op(self, other: Integer) -> Integer

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

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

$$f(x, y) = x - y\left \lfloor \frac{x}{y} \right \rfloor.$$

This function is called mod_op rather than mod because mod is a Rust keyword.

##### Worst-case complexity

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

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

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

##### Panics

Panics if other is zero.

##### Examples
use malachite_base::num::arithmetic::traits::Mod;
use malachite_nz::integer::Integer;

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

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

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

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

source§

### impl<'a> ModAssign<&'a Integer> for Integer

source§

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

Divides an Integer by another Integer, taking the second Integer by reference and replacing the first by the remainder. The remainder has the same sign as the second Integer.

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

$$x \gets x - y\left \lfloor \frac{x}{y} \right \rfloor.$$

##### Worst-case complexity

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

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

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

##### Panics

Panics if other is zero.

##### Examples
use malachite_base::num::arithmetic::traits::ModAssign;
use malachite_nz::integer::Integer;

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

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

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

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

### impl ModAssign for Integer

source§

#### fn mod_assign(&mut self, other: Integer)

Divides an Integer by another Integer, taking the second Integer by value and replacing the first by the remainder. The remainder has the same sign as the second Integer.

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

$$x \gets x - y\left \lfloor \frac{x}{y} \right \rfloor.$$

##### Worst-case complexity

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

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

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

##### Panics

Panics if other is zero.

##### Examples
use malachite_base::num::arithmetic::traits::ModAssign;
use malachite_nz::integer::Integer;

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

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

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

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

### impl<'a> ModPowerOf2 for &'a Integer

source§

#### fn mod_power_of_2(self, pow: u64) -> Natural

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

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

$$f(x, k) = x - 2^k\left \lfloor \frac{x}{2^k} \right \rfloor.$$

Unlike rem_power_of_2, this function always returns a non-negative number.

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

##### Examples
use malachite_base::num::arithmetic::traits::ModPowerOf2;
use malachite_nz::integer::Integer;

// 1 * 2^8 + 4 = 260
assert_eq!((&Integer::from(260)).mod_power_of_2(8), 4);
// -101 * 2^4 + 5 = -1611
assert_eq!((&Integer::from(-1611)).mod_power_of_2(4), 5);
§

source§

### impl ModPowerOf2 for Integer

source§

#### fn mod_power_of_2(self, pow: u64) -> Natural

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

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

$$f(x, k) = x - 2^k\left \lfloor \frac{x}{2^k} \right \rfloor.$$

Unlike rem_power_of_2, this function always returns a non-negative number.

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

##### Examples
use malachite_base::num::arithmetic::traits::ModPowerOf2;
use malachite_nz::integer::Integer;

// 1 * 2^8 + 4 = 260
assert_eq!(Integer::from(260).mod_power_of_2(8), 4);

// -101 * 2^4 + 5 = -1611
assert_eq!(Integer::from(-1611).mod_power_of_2(4), 5);
§

source§

### impl ModPowerOf2Assign for Integer

source§

#### fn mod_power_of_2_assign(&mut self, pow: u64)

Divides an Integer by $2^k$, replacing the Integer by the remainder. The remainder is non-negative.

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

$$x \gets x - 2^k\left \lfloor \frac{x}{2^k} \right \rfloor.$$

Unlike rem_power_of_2_assign, this function always assigns a non-negative number.

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

##### Examples
use malachite_base::num::arithmetic::traits::ModPowerOf2Assign;
use malachite_nz::integer::Integer;

// 1 * 2^8 + 4 = 260
let mut x = Integer::from(260);
x.mod_power_of_2_assign(8);
assert_eq!(x, 4);

// -101 * 2^4 + 5 = -1611
let mut x = Integer::from(-1611);
x.mod_power_of_2_assign(4);
assert_eq!(x, 5);
source§

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

source§

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

Multiplies two Integers, taking both by reference.

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

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::integer::Integer;
use std::str::FromStr;

assert_eq!(&Integer::ONE * &Integer::from(123), 123);
assert_eq!(&Integer::from(123) * &Integer::ZERO, 0);
assert_eq!(&Integer::from(123) * &Integer::from(-456), -56088);
assert_eq!(
(&Integer::from(-123456789000i64) * &Integer::from(-987654321000i64)).to_string(),
"121932631112635269000000"
);
§

#### type Output = Integer

The resulting type after applying the * operator.
source§

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

source§

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

Multiplies two Integers, taking the first by value and the second by reference.

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

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::integer::Integer;
use std::str::FromStr;

assert_eq!(Integer::ONE * &Integer::from(123), 123);
assert_eq!(Integer::from(123) * &Integer::ZERO, 0);
assert_eq!(Integer::from(123) * &Integer::from(-456), -56088);
assert_eq!(
(Integer::from(-123456789000i64) * &Integer::from(-987654321000i64)).to_string(),
"121932631112635269000000"
);
§

#### type Output = Integer

The resulting type after applying the * operator.
source§

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

source§

#### fn mul(self, other: Integer) -> Integer

Multiplies two Integers, taking the first by reference and the second by value.

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

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::integer::Integer;
use std::str::FromStr;

assert_eq!(&Integer::ONE * Integer::from(123), 123);
assert_eq!(&Integer::from(123) * Integer::ZERO, 0);
assert_eq!(&Integer::from(123) * Integer::from(-456), -56088);
assert_eq!(
(&Integer::from(-123456789000i64) * Integer::from(-987654321000i64)).to_string(),
"121932631112635269000000"
);
§

#### type Output = Integer

The resulting type after applying the * operator.
source§

### impl Mul for Integer

source§

#### fn mul(self, other: Integer) -> Integer

Multiplies two Integers, taking both by value.

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

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::integer::Integer;
use std::str::FromStr;

assert_eq!(Integer::ONE * Integer::from(123), 123);
assert_eq!(Integer::from(123) * Integer::ZERO, 0);
assert_eq!(Integer::from(123) * Integer::from(-456), -56088);
assert_eq!(
(Integer::from(-123456789000i64) * Integer::from(-987654321000i64)).to_string(),
"121932631112635269000000"
);
§

#### type Output = Integer

The resulting type after applying the * operator.
source§

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

source§

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

Multiplies an Integer by an Integer in place, taking the Integer on the right-hand side by reference.

$$x \gets = xy.$$

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::basic::traits::NegativeOne;
use malachite_nz::integer::Integer;
use std::str::FromStr;

let mut x = Integer::NEGATIVE_ONE;
x *= &Integer::from(1000);
x *= &Integer::from(2000);
x *= &Integer::from(3000);
x *= &Integer::from(4000);
assert_eq!(x, -24000000000000i64);
source§

### impl MulAssign for Integer

source§

#### fn mul_assign(&mut self, other: Integer)

Multiplies an Integer by an Integer in place, taking the Integer on the right-hand side by value.

$$x \gets = xy.$$

##### Worst-case complexity

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

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

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

##### Examples
use malachite_base::num::basic::traits::NegativeOne;
use malachite_nz::integer::Integer;
use std::str::FromStr;

let mut x = Integer::NEGATIVE_ONE;
x *= Integer::from(1000);
x *= Integer::from(2000);
x *= Integer::from(3000);
x *= Integer::from(4000);
assert_eq!(x, -24000000000000i64);
source§

### impl Named for Integer

source§

#### const NAME: &'static str = "Integer"

The name of this type, as given by the stringify macro.

See the documentation for impl_named for more details.

source§

### impl<'a> Neg for &'a Integer

source§

#### fn neg(self) -> Integer

Negates an Integer, taking it by reference.

$$f(x) = -x.$$

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

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

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

#### type Output = Integer

The resulting type after applying the - operator.
source§

### impl Neg for Integer

source§

#### fn neg(self) -> Integer

Negates an Integer, taking it by value.

$$f(x) = -x.$$

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

assert_eq!(-Integer::ZERO, 0);
assert_eq!(-Integer::from(123), -123);
assert_eq!(-Integer::from(-123), 123);
§

#### type Output = Integer

The resulting type after applying the - operator.
source§

### impl NegAssign for Integer

source§

#### fn neg_assign(&mut self)

Negates an Integer in place.

$$x \gets -x.$$

##### Examples
use malachite_base::num::arithmetic::traits::NegAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;

let mut x = Integer::ZERO;
x.neg_assign();
assert_eq!(x, 0);

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

let mut x = Integer::from(-123);
x.neg_assign();
assert_eq!(x, 123);
source§

The constant -1.

source§

source§

### impl<'a> Not for &'a Integer

source§

#### fn not(self) -> Integer

Returns the bitwise negation of an Integer, taking it by reference.

$$f(n) = -n - 1.$$

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

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

assert_eq!(!&Integer::ZERO, -1);
assert_eq!(!&Integer::from(123), -124);
assert_eq!(!&Integer::from(-123), 122);
§

#### type Output = Integer

The resulting type after applying the ! operator.
source§

### impl Not for Integer

source§

#### fn not(self) -> Integer

Returns the bitwise negation of an Integer, taking it by value.

$$f(n) = -n - 1.$$

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

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

assert_eq!(!Integer::ZERO, -1);
assert_eq!(!Integer::from(123), -124);
assert_eq!(!Integer::from(-123), 122);
§

#### type Output = Integer

The resulting type after applying the ! operator.
source§

### impl NotAssign for Integer

source§

#### fn not_assign(&mut self)

Replaces an Integer with its bitwise negation.

$$n \gets -n - 1.$$

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

##### Examples
use malachite_base::num::basic::traits::Zero;
use malachite_base::num::logic::traits::NotAssign;
use malachite_nz::integer::Integer;

let mut x = Integer::ZERO;
x.not_assign();
assert_eq!(x, -1);

let mut x = Integer::from(123);
x.not_assign();
assert_eq!(x, -124);

let mut x = Integer::from(-123);
x.not_assign();
assert_eq!(x, 122);
source§

### impl Octal for Integer

source§

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

Converts an Integer to an octal String.

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

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(n)$

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

##### Examples
use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToOctalString;
use malachite_nz::integer::Integer;
use std::str::FromStr;

assert_eq!(Integer::ZERO.to_octal_string(), "0");
assert_eq!(Integer::from(123).to_octal_string(), "173");
assert_eq!(
Integer::from_str("1000000000000")
.unwrap()
.to_octal_string(),
"16432451210000"
);
assert_eq!(format!("{:07o}", Integer::from(123)), "0000173");
assert_eq!(Integer::from(-123).to_octal_string(), "-173");
assert_eq!(
Integer::from_str("-1000000000000")
.unwrap()
.to_octal_string(),
"-16432451210000"
);
assert_eq!(format!("{:07o}", Integer::from(-123)), "-000173");

assert_eq!(format!("{:#o}", Integer::ZERO), "0o0");
assert_eq!(format!("{:#o}", Integer::from(123)), "0o173");
assert_eq!(
format!("{:#o}", Integer::from_str("1000000000000").unwrap()),
"0o16432451210000"
);
assert_eq!(format!("{:#07o}", Integer::from(123)), "0o00173");
assert_eq!(format!("{:#o}", Integer::from(-123)), "-0o173");
assert_eq!(
format!("{:#o}", Integer::from_str("-1000000000000").unwrap()),
"-0o16432451210000"
);
assert_eq!(format!("{:#07o}", Integer::from(-123)), "-0o0173");
source§

The constant 1.

source§

source§

### impl Ord for Integer

source§

#### fn cmp(&self, other: &Integer) -> Ordering

Compares two Integers.

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

##### Examples
use malachite_nz::integer::Integer;

assert!(Integer::from(-123) < Integer::from(-122));
assert!(Integer::from(-123) <= Integer::from(-122));
assert!(Integer::from(-123) > Integer::from(-124));
assert!(Integer::from(-123) >= Integer::from(-124));
1.21.0 · source§

#### fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

#### fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

#### fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

### impl OrdAbs for Integer

source§

#### fn cmp_abs(&self, other: &Integer) -> Ordering

Compares the absolute values of two Integers.

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

##### Examples
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::integer::Integer;

assert!(Integer::from(-123).lt_abs(&Integer::from(-124)));
assert!(Integer::from(-123).le_abs(&Integer::from(-124)));
assert!(Integer::from(-124).gt_abs(&Integer::from(-123)));
assert!(Integer::from(-124).ge_abs(&Integer::from(-123)));
source§

### impl<'a> OverflowingFrom<&'a Integer> for i128

source§

#### fn overflowing_from(value: &Integer) -> (i128, bool)

Converts an Integer to a signed primitive integer, wrapping modulo $2^W$, where $W$ is the width of the primitive integer.

The returned boolean value indicates whether wrapping occurred.

See here.

source§

### impl<'a> OverflowingFrom<&'a Integer> for i16

source§

#### fn overflowing_from(value: &Integer) -> (i16, bool)

Converts an Integer to a signed primitive integer, wrapping modulo $2^W$, where $W$ is the width of the primitive integer.

The returned boolean value indicates whether wrapping occurred.

See here.

source§

### impl<'a> OverflowingFrom<&'a Integer> for i32

source§

#### fn overflowing_from(value: &Integer) -> (i32, bool)

Converts an Integer to a signed primitive integer, wrapping modulo $2^W$, where $W$ is the width of the primitive integer.

The returned boolean value indicates whether wrapping occurred.

See here.

source§

### impl<'a> OverflowingFrom<&'a Integer> for i64

source§

#### fn overflowing_from(value: &Integer) -> (i64, bool)

Converts an Integer to a signed primitive integer, wrapping modulo $2^W$, where $W$ is the width of the primitive integer.

The returned boolean value indicates whether wrapping occurred.

See here.

source§

### impl<'a> OverflowingFrom<&'a Integer> for i8

source§

#### fn overflowing_from(value: &Integer) -> (i8, bool)

Converts an Integer to a signed primitive integer, wrapping modulo $2^W$, where $W$ is the width of the primitive integer.

The returned boolean value indicates whether wrapping occurred.

See here.

source§

### impl<'a> OverflowingFrom<&'a Integer> for isize

source§

#### fn overflowing_from(value: &Integer) -> (isize, bool)

Converts an Integer to a signed primitive integer, wrapping modulo $2^W$, where $W$ is the width of the primitive integer.

The returned boolean value indicates whether wrapping occurred.

See here.

source§

### impl<'a> OverflowingFrom<&'a Integer> for u128

source§

#### fn overflowing_from(value: &Integer) -> (u128, bool)

Converts an Integer to an unsigned primitive integer, wrapping modulo $2^W$, where $W$ is the width of the primitive integer.

The returned boolean value indicates whether wrapping occurred.

See here.

source§

### impl<'a> OverflowingFrom<&'a Integer> for u16

source§

#### fn overflowing_from(value: &Integer) -> (u16, bool)

Converts an Integer to an unsigned primitive integer, wrapping modulo $2^W$, where $W$ is the width of the primitive integer.

The returned boolean value indicates whether wrapping occurred.

See here.

source§

### impl<'a> OverflowingFrom<&'a Integer> for u32

source§

#### fn overflowing_from(value: &Integer) -> (u32, bool)

Converts an Integer to an unsigned primitive integer, wrapping modulo $2^W$, where $W$ is the width of the primitive integer.

The returned boolean value indicates whether wrapping occurred.

See here.

source§

### impl<'a> OverflowingFrom<&'a Integer> for u64

source§

#### fn overflowing_from(value: &Integer) -> (u64, bool)

Converts an Integer to an unsigned primitive integer, wrapping modulo $2^W$, where $W$ is the width of the primitive integer.

The returned boolean value indicates whether wrapping occurred.

See here.

source§

### impl<'a> OverflowingFrom<&'a Integer> for u8

source§

#### fn overflowing_from(value: &Integer) -> (u8, bool)

Converts an Integer to an unsigned primitive integer, wrapping modulo $2^W$, where $W$ is the width of the primitive integer.

The returned boolean value indicates whether wrapping occurred.

See here.

source§

### impl<'a> OverflowingFrom<&'a Integer> for usize

source§

#### fn overflowing_from(value: &Integer) -> (usize, bool)

Converts an Integer to an unsigned primitive integer, wrapping modulo $2^W$, where $W$ is the width of the primitive integer.

The returned boolean value indicates whether wrapping occurred.

See here.

source§

### impl<'a> Parity for &'a Integer

source§

#### fn even(self) -> bool

Tests whether an Integer is even.

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

$f(x) = (\exists k \in \N : x = 2k)$.

##### Examples
use malachite_base::num::arithmetic::traits::{Parity, Pow};
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.even(), true);
assert_eq!(Integer::from(123).even(), false);
assert_eq!(Integer::from(-0x80).even(), true);
assert_eq!(Integer::from(10u32).pow(12).even(), true);
assert_eq!((-Integer::from(10u32).pow(12) - Integer::ONE).even(), false);
source§

#### fn odd(self) -> bool

Tests whether an Integer is odd.

$f(x) = (2\nmid x)$.

$f(x) = (\exists k \in \N : x = 2k+1)$.

##### Examples
use malachite_base::num::arithmetic::traits::{Parity, Pow};
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::integer::Integer;

assert_eq!(Integer::ZERO.odd(), false);
assert_eq!(Integer::from(123).odd(), true);
assert_eq!(Integer::from(-0x80).odd(), false);
assert_eq!(Integer::from(10u32).pow(12).odd(), false);
assert_eq!((-Integer::from(10u32).pow(12) - Integer::ONE).odd(), true);
source§

### impl PartialEq<Integer> for Natural

source§

#### fn eq(&self, other: &Integer) -> bool

Determines whether a Natural is equal to an Integer.

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

where n = min(self.significant_bits(), other.significant_bits())

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

assert!(Natural::from(123u32) == Integer::from(123));
assert!(Natural::from(123u32) != Integer::from(5));
1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

### impl PartialEq<Integer> for f32

source§

#### fn eq(&self, other: &Integer) -> bool

Determines whether a primitive float is equal to an Integer.

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

See here.

1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

### impl PartialEq<Integer> for f64

source§

#### fn eq(&self, other: &Integer) -> bool

Determines whether a primitive float is equal to an Integer.

##### Worst-case complexity

$T(n) = O(n)$

$M(n) = O(1)$

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

See here.

1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

### impl PartialEq<Integer> for i128

source§

#### fn eq(&self, other: &Integer) -> bool

Determines whether a signed primitive integer is equal to an Integer.

See here.

1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

### impl PartialEq<Integer> for i16

source§

#### fn eq(&self, other: &Integer) -> bool

Determines whether a signed primitive integer is equal to an Integer.

See here.

1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

### impl PartialEq<Integer> for i32

source§

#### fn eq(&self, other: &Integer) -> bool

Determines whether a signed primitive integer is equal to an Integer.

See here.

1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

### impl PartialEq<Integer> for i64

source§

#### fn eq(&self, other: &Integer) -> bool

Determines whether a signed primitive integer is equal to an Integer.

See here.

1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

### impl PartialEq<Integer> for i8

source§

#### fn eq(&self, other: &Integer) -> bool

Determines whether a signed primitive integer is equal to an Integer.

See here.

1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

### impl PartialEq<Integer> for isize

source§

#### fn eq(&self, other: &Integer) -> bool

Determines whether a signed primitive integer is equal to an Integer.

See here.

1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

### impl PartialEq<Integer> for u128

source§

#### fn eq(&self, other: &Integer) -> bool

Determines whether an unsigned primitive integer is equal to an Integer.

See here.

1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

source§