Struct malachite_nz::integer::Integer
source · [−]pub struct Integer { /* private fields */ }
Expand description
An integer.
Any Integer
whose absolute value is small enough to fit into a Limb
is
represented inline. Only integers outside this range incur the costs of heap-allocation.
Implementations
sourceimpl Integer
impl Integer
sourcepub const fn unsigned_abs_ref(&self) -> &Natural
pub const fn unsigned_abs_ref(&self) -> &Natural
Finds the absolute value of an Integer
, taking the Integer
by reference and
returning a reference to the internal Natural
absolute value.
$$ f(x) = |x|. $$
Worst-case complexity
Constant time and additional memory.
Examples
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
assert_eq!(*Integer::ZERO.unsigned_abs_ref(), 0);
assert_eq!(*Integer::from(123).unsigned_abs_ref(), 123);
assert_eq!(*Integer::from(-123).unsigned_abs_ref(), 123);
sourcepub fn mutate_unsigned_abs<F: FnOnce(&mut Natural) -> T, T>(&mut self, f: F) -> T
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);
sourceimpl Integer
impl Integer
sourcepub fn from_sign_and_abs(sign: bool, abs: Natural) -> Integer
pub fn from_sign_and_abs(sign: bool, abs: Natural) -> Integer
Converts a sign and a Natural
to an Integer
, taking the Natural
by value. The
Natural
becomes the Integer
’s absolute value, and the sign indicates whether the
Integer
should be non-negative. If the Natural
is zero, then the Integer
will
be non-negative regardless of the sign.
Worst-case complexity
Constant time and additional memory.
Examples
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
assert_eq!(Integer::from_sign_and_abs(true, Natural::from(123u32)), 123);
assert_eq!(Integer::from_sign_and_abs(false, Natural::from(123u32)), -123);
sourcepub fn from_sign_and_abs_ref(sign: bool, abs: &Natural) -> Integer
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);
sourceimpl Integer
impl Integer
sourcepub fn from_twos_complement_limbs_asc(xs: &[Limb]) -> Integer
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
extern crate malachite_base;
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
);
}
sourcepub fn from_twos_complement_limbs_desc(xs: &[Limb]) -> Integer
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
extern crate malachite_base;
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
);
}
sourcepub fn from_owned_twos_complement_limbs_asc(xs: Vec<Limb>) -> Integer
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
extern crate malachite_base;
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
);
}
sourcepub fn from_owned_twos_complement_limbs_desc(xs: Vec<Limb>) -> Integer
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
extern crate malachite_base;
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
);
}
sourceimpl Integer
impl Integer
sourcepub fn to_twos_complement_limbs_asc(&self) -> Vec<Limb>
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
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::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]
);
}
sourcepub fn to_twos_complement_limbs_desc(&self) -> Vec<Limb>
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 BigInteger
s 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
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::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]
);
}
sourcepub fn into_twos_complement_limbs_asc(self) -> Vec<Limb>
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
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::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]
);
}
sourcepub fn into_twos_complement_limbs_desc(self) -> Vec<Limb>
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 BigInteger
s 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
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::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]
);
}
sourcepub fn twos_complement_limbs(&self) -> TwosComplementLimbIterator<'_>ⓘNotable traits for TwosComplementLimbIterator<'a>impl<'a> Iterator for TwosComplementLimbIterator<'a> type Item = Limb;
pub fn twos_complement_limbs(&self) -> TwosComplementLimbIterator<'_>ⓘNotable traits for TwosComplementLimbIterator<'a>impl<'a> Iterator for TwosComplementLimbIterator<'a> type Item = Limb;
Returns a double-ended iterator over the twos-complement limbs of an
Integer
.
The forward order is ascending, so that less significant limbs appear first. There may be a most-significant sign-extension limb.
If it’s necessary to get a Vec
of all the twos_complement limbs, consider using
to_twos_complement_limbs_asc
,
to_twos_complement_limbs_desc
,
into_twos_complement_limbs_asc
, or
into_twos_complement_limbs_desc
instead.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate itertools;
extern crate malachite_base;
use itertools::Itertools;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::integers::PrimitiveInt;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::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]
);
}
sourceimpl Integer
impl Integer
sourcepub fn checked_count_ones(&self) -> Option<u64>
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
extern crate malachite_base;
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));
sourceimpl Integer
impl Integer
sourcepub fn checked_count_zeros(&self) -> Option<u64>
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
extern crate malachite_base;
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));
sourceimpl Integer
impl Integer
sourcepub fn trailing_zeros(&self) -> Option<u64>
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
extern crate malachite_base;
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
sourceimpl<'a> Abs for &'a Integer
impl<'a> Abs for &'a Integer
sourcefn abs(self) -> Integer
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);
type Output = Integer
sourceimpl Abs for Integer
impl Abs for Integer
sourcefn abs(self) -> Integer
fn abs(self) -> Integer
Takes the absolute value of an Integer
, taking the Integer
by value.
$$ f(x) = |x|. $$
Worst-case complexity
Constant time and additional memory.
Examples
use malachite_base::num::arithmetic::traits::Abs;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
assert_eq!(Integer::ZERO.abs(), 0);
assert_eq!(Integer::from(123).abs(), 123);
assert_eq!(Integer::from(-123).abs(), 123);
type Output = Integer
sourceimpl AbsAssign for Integer
impl AbsAssign for Integer
sourcefn abs_assign(&mut self)
fn abs_assign(&mut self)
Replaces an Integer
with its absolute value.
$$ x \gets |x|. $$
Worst-case complexity
Constant time and additional memory.
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);
sourceimpl<'a, 'b> Add<&'a Integer> for &'b Integer
impl<'a, 'b> Add<&'a Integer> for &'b Integer
sourcefn add(self, other: &'a Integer) -> Integer
fn add(self, other: &'a Integer) -> Integer
Adds two Integer
s, 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
);
sourceimpl<'a> Add<&'a Integer> for Integer
impl<'a> Add<&'a Integer> for Integer
sourcefn add(self, other: &'a Integer) -> Integer
fn add(self, other: &'a Integer) -> Integer
Adds two Integer
s, 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
);
sourceimpl<'a> Add<Integer> for &'a Integer
impl<'a> Add<Integer> for &'a Integer
sourcefn add(self, other: Integer) -> Integer
fn add(self, other: Integer) -> Integer
Adds two Integer
s, 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
);
sourceimpl Add<Integer> for Integer
impl Add<Integer> for Integer
sourcefn add(self, other: Integer) -> Integer
fn add(self, other: Integer) -> Integer
Adds two Integer
s, 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
);
sourceimpl<'a> AddAssign<&'a Integer> for Integer
impl<'a> AddAssign<&'a Integer> for Integer
sourcefn add_assign(&mut self, other: &'a Integer)
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);
sourceimpl AddAssign<Integer> for Integer
impl AddAssign<Integer> for Integer
sourcefn add_assign(&mut self, other: Integer)
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);
sourceimpl<'a, 'b, 'c> AddMul<&'a Integer, &'b Integer> for &'c Integer
impl<'a, 'b, 'c> AddMul<&'a Integer, &'b Integer> for &'c Integer
sourcefn add_mul(self, y: &'a Integer, z: &'b Integer) -> Integer
fn add_mul(self, y: &'a Integer, z: &'b Integer) -> Integer
Adds an Integer
and the product of two other Integer
s, taking all three by
reference.
$f(x, y, z) = x + yz$.
Worst-case complexity
$T(n, m) = O(m + n \log n \log\log n)$
$M(n, m) = O(m + n \log n)$
where $T$ is time, $M$ is additional memory, $n$ is
max(y.significant_bits(), z.significant_bits())
, and $m$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{AddMul, Pow};
use malachite_nz::integer::Integer;
assert_eq!(
(&Integer::from(10u32)).add_mul(&Integer::from(3u32), &Integer::from(4u32)),
22
);
assert_eq!(
(&-Integer::from(10u32).pow(12))
.add_mul(&Integer::from(0x10000), &-Integer::from(10u32).pow(12)),
-65537000000000000i64
);
type Output = Integer
sourceimpl<'a, 'b> AddMul<&'a Integer, &'b Integer> for Integer
impl<'a, 'b> AddMul<&'a Integer, &'b Integer> for Integer
sourcefn add_mul(self, y: &'a Integer, z: &'b Integer) -> Integer
fn add_mul(self, y: &'a Integer, z: &'b Integer) -> Integer
Adds an Integer
and the product of two other Integer
s, taking the first by value
and the second and third by reference.
$f(x, y, z) = x + yz$.
Worst-case complexity
$T(n, m) = O(m + n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, $n$ is
max(y.significant_bits(), z.significant_bits())
, and $m$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{AddMul, Pow};
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(10u32).add_mul(&Integer::from(3u32), &Integer::from(4u32)), 22);
assert_eq!(
(-Integer::from(10u32).pow(12))
.add_mul(&Integer::from(0x10000), &-Integer::from(10u32).pow(12)),
-65537000000000000i64
);
type Output = Integer
sourceimpl<'a> AddMul<&'a Integer, Integer> for Integer
impl<'a> AddMul<&'a Integer, Integer> for Integer
sourcefn add_mul(self, y: &'a Integer, z: Integer) -> Integer
fn add_mul(self, y: &'a Integer, z: Integer) -> Integer
Adds an Integer
and the product of two other Integer
s, taking the first and third
by value and the second by reference.
$f(x, y, z) = x + yz$.
Worst-case complexity
$T(n, m) = O(m + n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, $n$ is
max(y.significant_bits(), z.significant_bits())
, and $m$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{AddMul, Pow};
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(10u32).add_mul(&Integer::from(3u32), Integer::from(4u32)), 22);
assert_eq!(
(-Integer::from(10u32).pow(12))
.add_mul(&Integer::from(0x10000), -Integer::from(10u32).pow(12)),
-65537000000000000i64
);
type Output = Integer
sourceimpl<'a> AddMul<Integer, &'a Integer> for Integer
impl<'a> AddMul<Integer, &'a Integer> for Integer
sourcefn add_mul(self, y: Integer, z: &'a Integer) -> Integer
fn add_mul(self, y: Integer, z: &'a Integer) -> Integer
Adds an Integer
and the product of two other Integer
s, taking the first two by
value and the third by reference.
$f(x, y, z) = x + yz$.
Worst-case complexity
$T(n, m) = O(m + n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, $n$ is
max(y.significant_bits(), z.significant_bits())
, and $m$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{AddMul, Pow};
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(10u32).add_mul(Integer::from(3u32), &Integer::from(4u32)), 22);
assert_eq!(
(-Integer::from(10u32).pow(12))
.add_mul(Integer::from(0x10000), &-Integer::from(10u32).pow(12)),
-65537000000000000i64
);
type Output = Integer
sourceimpl AddMul<Integer, Integer> for Integer
impl AddMul<Integer, Integer> for Integer
sourcefn add_mul(self, y: Integer, z: Integer) -> Integer
fn add_mul(self, y: Integer, z: Integer) -> Integer
Adds an Integer
and the product of two other Integer
s, taking all three by value.
$f(x, y, z) = x + yz$.
Worst-case complexity
$T(n, m) = O(m + n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, $n$ is
max(y.significant_bits(), z.significant_bits())
, and $m$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{AddMul, Pow};
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(10u32).add_mul(Integer::from(3u32), Integer::from(4u32)), 22);
assert_eq!(
(-Integer::from(10u32).pow(12))
.add_mul(Integer::from(0x10000), -Integer::from(10u32).pow(12)),
-65537000000000000i64
);
type Output = Integer
sourceimpl<'a, 'b> AddMulAssign<&'a Integer, &'b Integer> for Integer
impl<'a, 'b> AddMulAssign<&'a Integer, &'b Integer> for Integer
sourcefn add_mul_assign(&mut self, y: &'a Integer, z: &'b Integer)
fn add_mul_assign(&mut self, y: &'a Integer, z: &'b Integer)
Adds the product of two other Integer
s to an Integer
in place, taking both
Integer
s on the right-hand side by reference.
$x \gets x + yz$.
Worst-case complexity
$T(n, m) = O(m + n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, $n$ is
max(y.significant_bits(), z.significant_bits())
, and $m$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{AddMulAssign, Pow};
use malachite_nz::integer::Integer;
let mut x = Integer::from(10u32);
x.add_mul_assign(&Integer::from(3u32), &Integer::from(4u32));
assert_eq!(x, 22);
let mut x = -Integer::from(10u32).pow(12);
x.add_mul_assign(&Integer::from(0x10000), &-Integer::from(10u32).pow(12));
assert_eq!(x, -65537000000000000i64);
sourceimpl<'a> AddMulAssign<&'a Integer, Integer> for Integer
impl<'a> AddMulAssign<&'a Integer, Integer> for Integer
sourcefn add_mul_assign(&mut self, y: &'a Integer, z: Integer)
fn add_mul_assign(&mut self, y: &'a Integer, z: Integer)
Adds the product of two other Integer
s 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
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{AddMulAssign, Pow};
use malachite_nz::integer::Integer;
let mut x = Integer::from(10u32);
x.add_mul_assign(&Integer::from(3u32), Integer::from(4u32));
assert_eq!(x, 22);
let mut x = -Integer::from(10u32).pow(12);
x.add_mul_assign(&Integer::from(0x10000), -Integer::from(10u32).pow(12));
assert_eq!(x, -65537000000000000i64);
sourceimpl<'a> AddMulAssign<Integer, &'a Integer> for Integer
impl<'a> AddMulAssign<Integer, &'a Integer> for Integer
sourcefn add_mul_assign(&mut self, y: Integer, z: &'a Integer)
fn add_mul_assign(&mut self, y: Integer, z: &'a Integer)
Adds the product of two other Integer
s 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
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{AddMulAssign, Pow};
use malachite_nz::integer::Integer;
let mut x = Integer::from(10u32);
x.add_mul_assign(Integer::from(3u32), &Integer::from(4u32));
assert_eq!(x, 22);
let mut x = -Integer::from(10u32).pow(12);
x.add_mul_assign(Integer::from(0x10000), &-Integer::from(10u32).pow(12));
assert_eq!(x, -65537000000000000i64);
sourceimpl AddMulAssign<Integer, Integer> for Integer
impl AddMulAssign<Integer, Integer> for Integer
sourcefn add_mul_assign(&mut self, y: Integer, z: Integer)
fn add_mul_assign(&mut self, y: Integer, z: Integer)
Adds the product of two other Integer
s to an Integer
in place, taking both
Integer
s on the right-hand side by value.
$x \gets x + yz$.
Worst-case complexity
$T(n, m) = O(m + n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, $n$ is
max(y.significant_bits(), z.significant_bits())
, and $m$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{AddMulAssign, Pow};
use malachite_nz::integer::Integer;
let mut x = Integer::from(10u32);
x.add_mul_assign(Integer::from(3u32), Integer::from(4u32));
assert_eq!(x, 22);
let mut x = -Integer::from(10u32).pow(12);
x.add_mul_assign(Integer::from(0x10000), -Integer::from(10u32).pow(12));
assert_eq!(x, -65537000000000000i64);
sourceimpl Binary for Integer
impl Binary for Integer
sourcefn fmt(&self, f: &mut Formatter<'_>) -> Result
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
extern crate malachite_base;
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");
sourceimpl BitAccess for Integer
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
extern crate malachite_base;
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);
sourcefn get_bit(&self, index: u64) -> bool
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
extern crate malachite_base;
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);
sourcefn set_bit(&mut self, index: u64)
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
extern crate malachite_base;
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);
sourcefn clear_bit(&mut self, index: u64)
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
extern crate malachite_base;
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);
sourcefn assign_bit(&mut self, index: u64, bit: bool)
fn assign_bit(&mut self, index: u64, bit: bool)
Sets the bit at index
to whichever value bit
is. Read more
sourceimpl<'a, 'b> BitAnd<&'a Integer> for &'b Integer
impl<'a, 'b> BitAnd<&'a Integer> for &'b Integer
sourcefn bitand(self, other: &'a Integer) -> Integer
fn bitand(self, other: &'a Integer) -> Integer
Takes the bitwise and of two Integer
s, 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
extern crate malachite_base;
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
);
sourceimpl<'a> BitAnd<&'a Integer> for Integer
impl<'a> BitAnd<&'a Integer> for Integer
sourcefn bitand(self, other: &'a Integer) -> Integer
fn bitand(self, other: &'a Integer) -> Integer
Takes the bitwise and of two Integer
s, 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
extern crate malachite_base;
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
);
sourceimpl<'a> BitAnd<Integer> for &'a Integer
impl<'a> BitAnd<Integer> for &'a Integer
sourcefn bitand(self, other: Integer) -> Integer
fn bitand(self, other: Integer) -> Integer
Takes the bitwise and of two Integer
s, 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
extern crate malachite_base;
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
);
sourceimpl BitAnd<Integer> for Integer
impl BitAnd<Integer> for Integer
sourcefn bitand(self, other: Integer) -> Integer
fn bitand(self, other: Integer) -> Integer
Takes the bitwise and of two Integer
s, 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
extern crate malachite_base;
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
);
sourceimpl<'a> BitAndAssign<&'a Integer> for Integer
impl<'a> BitAndAssign<&'a Integer> for Integer
sourcefn bitand_assign(&mut self, other: &'a Integer)
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
extern crate malachite_base;
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);
sourceimpl BitAndAssign<Integer> for Integer
impl BitAndAssign<Integer> for Integer
sourcefn bitand_assign(&mut self, other: Integer)
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
extern crate malachite_base;
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);
sourceimpl BitBlockAccess for Integer
impl BitBlockAccess for Integer
sourcefn get_bits(&self, start: u64, end: u64) -> Natural
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
extern crate malachite_base;
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);
sourcefn get_bits_owned(self, start: u64, end: u64) -> Natural
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
extern crate malachite_base;
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);
sourcefn assign_bits(&mut self, start: u64, end: u64, bits: &Natural)
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
extern crate malachite_base;
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");
type Bits = Natural
sourceimpl BitConvertible for Integer
impl BitConvertible for Integer
sourcefn to_bits_asc(&self) -> Vec<bool>
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
extern crate malachite_base;
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]
);
sourcefn to_bits_desc(&self) -> Vec<bool>
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 BigInteger
s 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
extern crate malachite_base;
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]
);
sourcefn from_bits_asc<I: Iterator<Item = bool>>(xs: I) -> Integer
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
extern crate malachite_base;
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
);
sourcefn from_bits_desc<I: Iterator<Item = bool>>(xs: I) -> Integer
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
extern crate malachite_base;
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
);
sourceimpl<'a> BitIterable for &'a Integer
impl<'a> BitIterable for &'a Integer
sourcefn bits(self) -> IntegerBitIterator<'a>ⓘNotable traits for IntegerBitIterator<'a>impl<'a> Iterator for IntegerBitIterator<'a> type Item = bool;
fn bits(self) -> IntegerBitIterator<'a>ⓘNotable traits for IntegerBitIterator<'a>impl<'a> Iterator for IntegerBitIterator<'a> type Item = bool;
Returns a double-ended iterator over the bits of an Integer
.
The forward order is ascending, so that less significant bits appear first. There are no trailing false bits going forward, or leading falses going backward, except for possibly a most-significant sign-extension bit.
If it’s necessary to get a Vec
of all the bits, consider using
to_bits_asc
or
to_bits_desc
instead.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate itertools;
extern crate malachite_base;
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]
);
type BitIterator = IntegerBitIterator<'a>
sourceimpl<'a, 'b> BitOr<&'a Integer> for &'b Integer
impl<'a, 'b> BitOr<&'a Integer> for &'b Integer
sourcefn bitor(self, other: &'a Integer) -> Integer
fn bitor(self, other: &'a Integer) -> Integer
Takes the bitwise or of two Integer
s, taking both by reference.
$$ f(x, y) = x \vee y. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::One;
use malachite_nz::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
);
sourceimpl<'a> BitOr<&'a Integer> for Integer
impl<'a> BitOr<&'a Integer> for Integer
sourcefn bitor(self, other: &'a Integer) -> Integer
fn bitor(self, other: &'a Integer) -> Integer
Takes the bitwise or of two Integer
s, 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
extern crate malachite_base;
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
);
sourceimpl<'a> BitOr<Integer> for &'a Integer
impl<'a> BitOr<Integer> for &'a Integer
sourcefn bitor(self, other: Integer) -> Integer
fn bitor(self, other: Integer) -> Integer
Takes the bitwise or of two Integer
s, 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
extern crate malachite_base;
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
);
sourceimpl BitOr<Integer> for Integer
impl BitOr<Integer> for Integer
sourcefn bitor(self, other: Integer) -> Integer
fn bitor(self, other: Integer) -> Integer
Takes the bitwise or of two Integer
s, 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
extern crate malachite_base;
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
);
sourceimpl<'a> BitOrAssign<&'a Integer> for Integer
impl<'a> BitOrAssign<&'a Integer> for Integer
sourcefn bitor_assign(&mut self, other: &'a Integer)
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
extern crate malachite_base;
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);
sourceimpl BitOrAssign<Integer> for Integer
impl BitOrAssign<Integer> for Integer
sourcefn bitor_assign(&mut self, other: Integer)
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
extern crate malachite_base;
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);
sourceimpl<'a> BitScan for &'a Integer
impl<'a> BitScan for &'a Integer
sourcefn index_of_next_false_bit(self, starting_index: u64) -> Option<u64>
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
extern crate malachite_base;
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);
sourcefn index_of_next_true_bit(self, starting_index: u64) -> Option<u64>
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
extern crate malachite_base;
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));
sourceimpl<'a, 'b> BitXor<&'a Integer> for &'b Integer
impl<'a, 'b> BitXor<&'a Integer> for &'b Integer
sourcefn bitxor(self, other: &'a Integer) -> Integer
fn bitxor(self, other: &'a Integer) -> Integer
Takes the bitwise xor of two Integer
s, 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
extern crate malachite_base;
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
);
sourceimpl<'a> BitXor<&'a Integer> for Integer
impl<'a> BitXor<&'a Integer> for Integer
sourcefn bitxor(self, other: &'a Integer) -> Integer
fn bitxor(self, other: &'a Integer) -> Integer
Takes the bitwise xor of two Integer
s, 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
extern crate malachite_base;
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
);
sourceimpl<'a> BitXor<Integer> for &'a Integer
impl<'a> BitXor<Integer> for &'a Integer
sourcefn bitxor(self, other: Integer) -> Integer
fn bitxor(self, other: Integer) -> Integer
Takes the bitwise xor of two Integer
s, 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
extern crate malachite_base;
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
);
sourceimpl BitXor<Integer> for Integer
impl BitXor<Integer> for Integer
sourcefn bitxor(self, other: Integer) -> Integer
fn bitxor(self, other: Integer) -> Integer
Takes the bitwise xor of two Integer
s, 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
extern crate malachite_base;
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
);
sourceimpl<'a> BitXorAssign<&'a Integer> for Integer
impl<'a> BitXorAssign<&'a Integer> for Integer
sourcefn bitxor_assign(&mut self, other: &'a Integer)
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
extern crate malachite_base;
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);
sourceimpl BitXorAssign<Integer> for Integer
impl BitXorAssign<Integer> for Integer
sourcefn bitxor_assign(&mut self, other: Integer)
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
extern crate malachite_base;
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);
sourceimpl<'a> CeilingDivAssignMod<&'a Integer> for Integer
impl<'a> CeilingDivAssignMod<&'a Integer> for Integer
sourcefn ceiling_div_assign_mod(&mut self, other: &'a Integer) -> Integer
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
extern crate malachite_base;
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);
type ModOutput = Integer
sourceimpl CeilingDivAssignMod<Integer> for Integer
impl CeilingDivAssignMod<Integer> for Integer
sourcefn ceiling_div_assign_mod(&mut self, other: Integer) -> Integer
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
extern crate malachite_base;
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);
type ModOutput = Integer
sourceimpl<'a> CeilingDivMod<&'a Integer> for Integer
impl<'a> CeilingDivMod<&'a Integer> for Integer
sourcefn ceiling_div_mod(self, other: &'a Integer) -> (Integer, Integer)
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
extern crate malachite_base;
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)"
);
type DivOutput = Integer
type ModOutput = Integer
sourceimpl<'a, 'b> CeilingDivMod<&'b Integer> for &'a Integer
impl<'a, 'b> CeilingDivMod<&'b Integer> for &'a Integer
sourcefn ceiling_div_mod(self, other: &'b Integer) -> (Integer, Integer)
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
extern crate malachite_base;
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)"
);
type DivOutput = Integer
type ModOutput = Integer
sourceimpl<'a> CeilingDivMod<Integer> for &'a Integer
impl<'a> CeilingDivMod<Integer> for &'a Integer
sourcefn ceiling_div_mod(self, other: Integer) -> (Integer, Integer)
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
extern crate malachite_base;
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)"
);
type DivOutput = Integer
type ModOutput = Integer
sourceimpl CeilingDivMod<Integer> for Integer
impl CeilingDivMod<Integer> for Integer
sourcefn ceiling_div_mod(self, other: Integer) -> (Integer, Integer)
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
extern crate malachite_base;
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)"
);
type DivOutput = Integer
type ModOutput = Integer
sourceimpl<'a> CeilingMod<&'a Integer> for Integer
impl<'a> CeilingMod<&'a Integer> for Integer
sourcefn ceiling_mod(self, other: &'a Integer) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl<'a, 'b> CeilingMod<&'b Integer> for &'a Integer
impl<'a, 'b> CeilingMod<&'b Integer> for &'a Integer
sourcefn ceiling_mod(self, other: &'b Integer) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl<'a> CeilingMod<Integer> for &'a Integer
impl<'a> CeilingMod<Integer> for &'a Integer
sourcefn ceiling_mod(self, other: Integer) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl CeilingMod<Integer> for Integer
impl CeilingMod<Integer> for Integer
sourcefn ceiling_mod(self, other: Integer) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl<'a> CeilingModAssign<&'a Integer> for Integer
impl<'a> CeilingModAssign<&'a Integer> for Integer
sourcefn ceiling_mod_assign(&mut self, other: &'a Integer)
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
extern crate malachite_base;
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);
sourceimpl CeilingModAssign<Integer> for Integer
impl CeilingModAssign<Integer> for Integer
sourcefn ceiling_mod_assign(&mut self, other: Integer)
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
extern crate malachite_base;
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);
sourceimpl<'a> CeilingModPowerOf2 for &'a Integer
impl<'a> CeilingModPowerOf2 for &'a Integer
sourcefn ceiling_mod_power_of_2(self, pow: u64) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl CeilingModPowerOf2 for Integer
impl CeilingModPowerOf2 for Integer
sourcefn ceiling_mod_power_of_2(self, pow: u64) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl CeilingModPowerOf2Assign for Integer
impl CeilingModPowerOf2Assign for Integer
sourcefn ceiling_mod_power_of_2_assign(&mut self, pow: u64)
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
extern crate malachite_base;
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);
sourceimpl<'a> CeilingRoot<u64> for &'a Integer
impl<'a> CeilingRoot<u64> for &'a Integer
sourcefn ceiling_root(self, exp: u64) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl CeilingRoot<u64> for Integer
impl CeilingRoot<u64> for Integer
sourcefn ceiling_root(self, exp: u64) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl CeilingRootAssign<u64> for Integer
impl CeilingRootAssign<u64> for Integer
sourcefn ceiling_root_assign(&mut self, exp: u64)
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
extern crate malachite_base;
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);
sourceimpl<'a> CeilingSqrt for &'a Integer
impl<'a> CeilingSqrt for &'a Integer
sourcefn ceiling_sqrt(self) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl CeilingSqrt for Integer
impl CeilingSqrt for Integer
sourcefn ceiling_sqrt(self) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl CeilingSqrtAssign for Integer
impl CeilingSqrtAssign for Integer
sourcefn ceiling_sqrt_assign(&mut self)
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
extern crate malachite_base;
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);
sourceimpl<'a> CheckedFrom<&'a Integer> for Natural
impl<'a> CheckedFrom<&'a Integer> for Natural
sourcefn checked_from(value: &'a Integer) -> Option<Natural>
fn checked_from(value: &'a Integer) -> Option<Natural>
Converts an Integer
to a Natural
, taking the Natural
by reference. If the
Integer
is negative, None
is returned.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::CheckedFrom;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
assert_eq!(Natural::checked_from(&Integer::from(123)).to_debug_string(), "Some(123)");
assert_eq!(Natural::checked_from(&Integer::from(-123)).to_debug_string(), "None");
assert_eq!(
Natural::checked_from(&Integer::from(10u32).pow(12)).to_debug_string(),
"Some(1000000000000)"
);
assert_eq!(
Natural::checked_from(&(-Integer::from(10u32).pow(12))).to_debug_string(),
"None"
);
sourceimpl<'a> CheckedFrom<&'a Integer> for f32
impl<'a> CheckedFrom<&'a Integer> for f32
sourcefn checked_from(value: &'a Integer) -> Option<f32>
fn checked_from(value: &'a Integer) -> Option<f32>
Converts an Integer
to a primitive float.
If the input isn’t exactly equal to some float, None
is returned.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Examples
See here.
sourceimpl<'a> CheckedFrom<&'a Integer> for f64
impl<'a> CheckedFrom<&'a Integer> for f64
sourcefn checked_from(value: &'a Integer) -> Option<f64>
fn checked_from(value: &'a Integer) -> Option<f64>
Converts an Integer
to a primitive float.
If the input isn’t exactly equal to some float, None
is returned.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Examples
See here.
sourceimpl<'a> CheckedFrom<&'a Integer> for i128
impl<'a> CheckedFrom<&'a Integer> for i128
sourcefn checked_from(value: &Integer) -> Option<i128>
fn checked_from(value: &Integer) -> Option<i128>
Converts an Integer
to a signed primitive integer, returning None
if the
Integer
cannot be represented.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> CheckedFrom<&'a Integer> for i16
impl<'a> CheckedFrom<&'a Integer> for i16
sourcefn checked_from(value: &Integer) -> Option<i16>
fn checked_from(value: &Integer) -> Option<i16>
Converts an Integer
to a signed primitive integer, returning None
if the
Integer
cannot be represented.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> CheckedFrom<&'a Integer> for i32
impl<'a> CheckedFrom<&'a Integer> for i32
sourcefn checked_from(value: &Integer) -> Option<i32>
fn checked_from(value: &Integer) -> Option<i32>
Converts an Integer
to a signed primitive integer, returning None
if the
Integer
cannot be represented.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> CheckedFrom<&'a Integer> for i64
impl<'a> CheckedFrom<&'a Integer> for i64
sourcefn checked_from(value: &Integer) -> Option<i64>
fn checked_from(value: &Integer) -> Option<i64>
Converts an Integer
to a signed primitive integer, returning None
if the
Integer
cannot be represented.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> CheckedFrom<&'a Integer> for i8
impl<'a> CheckedFrom<&'a Integer> for i8
sourcefn checked_from(value: &Integer) -> Option<i8>
fn checked_from(value: &Integer) -> Option<i8>
Converts an Integer
to a signed primitive integer, returning None
if the
Integer
cannot be represented.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> CheckedFrom<&'a Integer> for isize
impl<'a> CheckedFrom<&'a Integer> for isize
sourcefn checked_from(value: &Integer) -> Option<isize>
fn checked_from(value: &Integer) -> Option<isize>
Converts an Integer
to a signed primitive integer, returning None
if the
Integer
cannot be represented.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> CheckedFrom<&'a Integer> for u128
impl<'a> CheckedFrom<&'a Integer> for u128
sourcefn checked_from(value: &Integer) -> Option<u128>
fn checked_from(value: &Integer) -> Option<u128>
Converts an Integer
to an unsigned primitive integer, returning None
if the
Integer
cannot be represented.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> CheckedFrom<&'a Integer> for u16
impl<'a> CheckedFrom<&'a Integer> for u16
sourcefn checked_from(value: &Integer) -> Option<u16>
fn checked_from(value: &Integer) -> Option<u16>
Converts an Integer
to an unsigned primitive integer, returning None
if the
Integer
cannot be represented.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> CheckedFrom<&'a Integer> for u32
impl<'a> CheckedFrom<&'a Integer> for u32
sourcefn checked_from(value: &Integer) -> Option<u32>
fn checked_from(value: &Integer) -> Option<u32>
Converts an Integer
to an unsigned primitive integer, returning None
if the
Integer
cannot be represented.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> CheckedFrom<&'a Integer> for u64
impl<'a> CheckedFrom<&'a Integer> for u64
sourcefn checked_from(value: &Integer) -> Option<u64>
fn checked_from(value: &Integer) -> Option<u64>
Converts an Integer
to an unsigned primitive integer, returning None
if the
Integer
cannot be represented.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> CheckedFrom<&'a Integer> for u8
impl<'a> CheckedFrom<&'a Integer> for u8
sourcefn checked_from(value: &Integer) -> Option<u8>
fn checked_from(value: &Integer) -> Option<u8>
Converts an Integer
to an unsigned primitive integer, returning None
if the
Integer
cannot be represented.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> CheckedFrom<&'a Integer> for usize
impl<'a> CheckedFrom<&'a Integer> for usize
sourcefn checked_from(value: &Integer) -> Option<usize>
fn checked_from(value: &Integer) -> Option<usize>
Converts an Integer
to an unsigned primitive integer, returning None
if the
Integer
cannot be represented.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl CheckedFrom<Integer> for Natural
impl CheckedFrom<Integer> for Natural
sourcefn checked_from(value: Integer) -> Option<Natural>
fn checked_from(value: Integer) -> Option<Natural>
Converts an Integer
to a Natural
, taking the Natural
by value. If the
Integer
is negative, None
is returned.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::CheckedFrom;
use malachite_base::strings::ToDebugString;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
assert_eq!(Natural::checked_from(Integer::from(123)).to_debug_string(), "Some(123)");
assert_eq!(Natural::checked_from(Integer::from(-123)).to_debug_string(), "None");
assert_eq!(
Natural::checked_from(Integer::from(10u32).pow(12)).to_debug_string(),
"Some(1000000000000)"
);
assert_eq!(Natural::checked_from(-Integer::from(10u32).pow(12)).to_debug_string(), "None");
sourceimpl CheckedFrom<f32> for Integer
impl CheckedFrom<f32> for Integer
sourcefn checked_from(value: f32) -> Option<Integer>
fn checked_from(value: f32) -> Option<Integer>
Converts a primitive float to an Integer
.
If the input isn’t exactly equal to some Integer
, None
is returned.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.sci_exponent()
.
Examples
See here.
sourceimpl CheckedFrom<f64> for Integer
impl CheckedFrom<f64> for Integer
sourcefn checked_from(value: f64) -> Option<Integer>
fn checked_from(value: f64) -> Option<Integer>
Converts a primitive float to an Integer
.
If the input isn’t exactly equal to some Integer
, None
is returned.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.sci_exponent()
.
Examples
See here.
sourceimpl<'a, 'b> CheckedHammingDistance<&'a Integer> for &'b Integer
impl<'a, 'b> CheckedHammingDistance<&'a Integer> for &'b Integer
sourcefn checked_hamming_distance(self, other: &Integer) -> Option<u64>
fn checked_hamming_distance(self, other: &Integer) -> Option<u64>
Determines the Hamming distance between two Integer
s.
The two Integer
s 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
extern crate malachite_base;
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);
sourceimpl<'a> CheckedRoot<u64> for &'a Integer
impl<'a> CheckedRoot<u64> for &'a Integer
sourcefn checked_root(self, exp: u64) -> Option<Integer>
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
extern crate malachite_base;
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)"
);
type Output = Integer
sourceimpl CheckedRoot<u64> for Integer
impl CheckedRoot<u64> for Integer
sourcefn checked_root(self, exp: u64) -> Option<Integer>
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
extern crate malachite_base;
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)");
type Output = Integer
sourceimpl<'a> CheckedSqrt for &'a Integer
impl<'a> CheckedSqrt for &'a Integer
sourcefn checked_sqrt(self) -> Option<Integer>
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
extern crate malachite_base;
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)"
);
type Output = Integer
sourceimpl CheckedSqrt for Integer
impl CheckedSqrt for Integer
sourcefn checked_sqrt(self) -> Option<Integer>
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
extern crate malachite_base;
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)");
type Output = Integer
sourceimpl<'a> ConvertibleFrom<&'a Integer> for Natural
impl<'a> ConvertibleFrom<&'a Integer> for Natural
sourcefn convertible_from(value: &'a Integer) -> bool
fn convertible_from(value: &'a Integer) -> bool
Determines whether an Integer
can be converted to a Natural
(when the Integer
is non-negative). Takes the Integer
by reference.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::ConvertibleFrom;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
assert_eq!(Natural::convertible_from(&Integer::from(123)), true);
assert_eq!(Natural::convertible_from(&Integer::from(-123)), false);
assert_eq!(Natural::convertible_from(&Integer::from(10u32).pow(12)), true);
assert_eq!(Natural::convertible_from(&-Integer::from(10u32).pow(12)), false);
sourceimpl<'a> ConvertibleFrom<&'a Integer> for f32
impl<'a> ConvertibleFrom<&'a Integer> for f32
sourcefn convertible_from(value: &'a Integer) -> bool
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()
.
Examples
See here.
sourceimpl<'a> ConvertibleFrom<&'a Integer> for f64
impl<'a> ConvertibleFrom<&'a Integer> for f64
sourcefn convertible_from(value: &'a Integer) -> bool
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()
.
Examples
See here.
sourceimpl<'a> ConvertibleFrom<&'a Integer> for i128
impl<'a> ConvertibleFrom<&'a Integer> for i128
sourcefn convertible_from(value: &Integer) -> bool
fn convertible_from(value: &Integer) -> bool
Determines whether an Integer
can be converted to a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> ConvertibleFrom<&'a Integer> for i16
impl<'a> ConvertibleFrom<&'a Integer> for i16
sourcefn convertible_from(value: &Integer) -> bool
fn convertible_from(value: &Integer) -> bool
Determines whether an Integer
can be converted to a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> ConvertibleFrom<&'a Integer> for i32
impl<'a> ConvertibleFrom<&'a Integer> for i32
sourcefn convertible_from(value: &Integer) -> bool
fn convertible_from(value: &Integer) -> bool
Determines whether an Integer
can be converted to a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> ConvertibleFrom<&'a Integer> for i64
impl<'a> ConvertibleFrom<&'a Integer> for i64
sourcefn convertible_from(value: &Integer) -> bool
fn convertible_from(value: &Integer) -> bool
Determines whether an Integer
can be converted to a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> ConvertibleFrom<&'a Integer> for i8
impl<'a> ConvertibleFrom<&'a Integer> for i8
sourcefn convertible_from(value: &Integer) -> bool
fn convertible_from(value: &Integer) -> bool
Determines whether an Integer
can be converted to a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> ConvertibleFrom<&'a Integer> for isize
impl<'a> ConvertibleFrom<&'a Integer> for isize
sourcefn convertible_from(value: &Integer) -> bool
fn convertible_from(value: &Integer) -> bool
Determines whether an Integer
can be converted to a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> ConvertibleFrom<&'a Integer> for u128
impl<'a> ConvertibleFrom<&'a Integer> for u128
sourcefn convertible_from(value: &Integer) -> bool
fn convertible_from(value: &Integer) -> bool
Determines whether an Integer
can be converted to an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> ConvertibleFrom<&'a Integer> for u16
impl<'a> ConvertibleFrom<&'a Integer> for u16
sourcefn convertible_from(value: &Integer) -> bool
fn convertible_from(value: &Integer) -> bool
Determines whether an Integer
can be converted to an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> ConvertibleFrom<&'a Integer> for u32
impl<'a> ConvertibleFrom<&'a Integer> for u32
sourcefn convertible_from(value: &Integer) -> bool
fn convertible_from(value: &Integer) -> bool
Determines whether an Integer
can be converted to an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> ConvertibleFrom<&'a Integer> for u64
impl<'a> ConvertibleFrom<&'a Integer> for u64
sourcefn convertible_from(value: &Integer) -> bool
fn convertible_from(value: &Integer) -> bool
Determines whether an Integer
can be converted to an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> ConvertibleFrom<&'a Integer> for u8
impl<'a> ConvertibleFrom<&'a Integer> for u8
sourcefn convertible_from(value: &Integer) -> bool
fn convertible_from(value: &Integer) -> bool
Determines whether an Integer
can be converted to an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> ConvertibleFrom<&'a Integer> for usize
impl<'a> ConvertibleFrom<&'a Integer> for usize
sourcefn convertible_from(value: &Integer) -> bool
fn convertible_from(value: &Integer) -> bool
Determines whether an Integer
can be converted to an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl ConvertibleFrom<Integer> for Natural
impl ConvertibleFrom<Integer> for Natural
sourcefn convertible_from(value: Integer) -> bool
fn convertible_from(value: Integer) -> bool
Determines whether an Integer
can be converted to a Natural
(when the Integer
is non-negative). Takes the Integer
by value.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::ConvertibleFrom;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
assert_eq!(Natural::convertible_from(Integer::from(123)), true);
assert_eq!(Natural::convertible_from(Integer::from(-123)), false);
assert_eq!(Natural::convertible_from(Integer::from(10u32).pow(12)), true);
assert_eq!(Natural::convertible_from(-Integer::from(10u32).pow(12)), false);
sourceimpl ConvertibleFrom<f32> for Integer
impl ConvertibleFrom<f32> for Integer
sourcefn convertible_from(value: f32) -> bool
fn convertible_from(value: f32) -> bool
Determines whether a primitive float can be exactly converted to an Integer
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl ConvertibleFrom<f64> for Integer
impl ConvertibleFrom<f64> for Integer
sourcefn convertible_from(value: f64) -> bool
fn convertible_from(value: f64) -> bool
Determines whether a primitive float can be exactly converted to an Integer
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl Debug for Integer
impl Debug for Integer
sourcefn fmt(&self, f: &mut Formatter<'_>) -> Result
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
extern crate malachite_base;
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");
sourceimpl Display for Integer
impl Display for Integer
sourcefn fmt(&self, f: &mut Formatter<'_>) -> Result
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
extern crate malachite_base;
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");
sourceimpl<'a> Div<&'a Integer> for Integer
impl<'a> Div<&'a Integer> for Integer
sourcefn div(self, other: &'a Integer) -> Integer
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);
sourceimpl<'a, 'b> Div<&'b Integer> for &'a Integer
impl<'a, 'b> Div<&'b Integer> for &'a Integer
sourcefn div(self, other: &'b Integer) -> Integer
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);
sourceimpl<'a> Div<Integer> for &'a Integer
impl<'a> Div<Integer> for &'a Integer
sourcefn div(self, other: Integer) -> Integer
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);
sourceimpl Div<Integer> for Integer
impl Div<Integer> for Integer
sourcefn div(self, other: Integer) -> Integer
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);
sourceimpl<'a> DivAssign<&'a Integer> for Integer
impl<'a> DivAssign<&'a Integer> for Integer
sourcefn div_assign(&mut self, other: &'a Integer)
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);
sourceimpl DivAssign<Integer> for Integer
impl DivAssign<Integer> for Integer
sourcefn div_assign(&mut self, other: Integer)
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);
sourceimpl<'a> DivAssignMod<&'a Integer> for Integer
impl<'a> DivAssignMod<&'a Integer> for Integer
sourcefn div_assign_mod(&mut self, other: &'a Integer) -> Integer
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
extern crate malachite_base;
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);
type ModOutput = Integer
sourceimpl DivAssignMod<Integer> for Integer
impl DivAssignMod<Integer> for Integer
sourcefn div_assign_mod(&mut self, other: Integer) -> Integer
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
extern crate malachite_base;
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);
type ModOutput = Integer
sourceimpl<'a> DivAssignRem<&'a Integer> for Integer
impl<'a> DivAssignRem<&'a Integer> for Integer
sourcefn div_assign_rem(&mut self, other: &'a Integer) -> Integer
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
extern crate malachite_base;
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);
type RemOutput = Integer
sourceimpl DivAssignRem<Integer> for Integer
impl DivAssignRem<Integer> for Integer
sourcefn div_assign_rem(&mut self, other: Integer) -> Integer
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
extern crate malachite_base;
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);
type RemOutput = Integer
sourceimpl<'a> DivExact<&'a Integer> for Integer
impl<'a> DivExact<&'a Integer> for Integer
sourcefn div_exact(self, other: &'a Integer) -> Integer
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
extern crate malachite_base;
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
);
type Output = Integer
sourceimpl<'a, 'b> DivExact<&'b Integer> for &'a Integer
impl<'a, 'b> DivExact<&'b Integer> for &'a Integer
sourcefn div_exact(self, other: &'b Integer) -> Integer
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
extern crate malachite_base;
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
);
type Output = Integer
sourceimpl<'a> DivExact<Integer> for &'a Integer
impl<'a> DivExact<Integer> for &'a Integer
sourcefn div_exact(self, other: Integer) -> Integer
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
extern crate malachite_base;
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
);
type Output = Integer
sourceimpl DivExact<Integer> for Integer
impl DivExact<Integer> for Integer
sourcefn div_exact(self, other: Integer) -> Integer
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
extern crate malachite_base;
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
);
type Output = Integer
sourceimpl<'a> DivExactAssign<&'a Integer> for Integer
impl<'a> DivExactAssign<&'a Integer> for Integer
sourcefn div_exact_assign(&mut self, other: &'a Integer)
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
extern crate malachite_base;
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);
sourceimpl DivExactAssign<Integer> for Integer
impl DivExactAssign<Integer> for Integer
sourcefn div_exact_assign(&mut self, other: Integer)
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
extern crate malachite_base;
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);
sourceimpl<'a> DivMod<&'a Integer> for Integer
impl<'a> DivMod<&'a Integer> for Integer
sourcefn div_mod(self, other: &'a Integer) -> (Integer, Integer)
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
extern crate malachite_base;
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)");
type DivOutput = Integer
type ModOutput = Integer
sourceimpl<'a, 'b> DivMod<&'b Integer> for &'a Integer
impl<'a, 'b> DivMod<&'b Integer> for &'a Integer
sourcefn div_mod(self, other: &'b Integer) -> (Integer, Integer)
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
extern crate malachite_base;
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)"
);
type DivOutput = Integer
type ModOutput = Integer
sourceimpl<'a> DivMod<Integer> for &'a Integer
impl<'a> DivMod<Integer> for &'a Integer
sourcefn div_mod(self, other: Integer) -> (Integer, Integer)
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
extern crate malachite_base;
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)");
type DivOutput = Integer
type ModOutput = Integer
sourceimpl DivMod<Integer> for Integer
impl DivMod<Integer> for Integer
sourcefn div_mod(self, other: Integer) -> (Integer, Integer)
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
extern crate malachite_base;
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)");
type DivOutput = Integer
type ModOutput = Integer
sourceimpl<'a> DivRem<&'a Integer> for Integer
impl<'a> DivRem<&'a Integer> for Integer
sourcefn div_rem(self, other: &'a Integer) -> (Integer, Integer)
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
extern crate malachite_base;
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)");
type DivOutput = Integer
type RemOutput = Integer
sourceimpl<'a, 'b> DivRem<&'b Integer> for &'a Integer
impl<'a, 'b> DivRem<&'b Integer> for &'a Integer
sourcefn div_rem(self, other: &'b Integer) -> (Integer, Integer)
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
extern crate malachite_base;
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)"
);
type DivOutput = Integer
type RemOutput = Integer
sourceimpl<'a> DivRem<Integer> for &'a Integer
impl<'a> DivRem<Integer> for &'a Integer
sourcefn div_rem(self, other: Integer) -> (Integer, Integer)
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
extern crate malachite_base;
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)");
type DivOutput = Integer
type RemOutput = Integer
sourceimpl DivRem<Integer> for Integer
impl DivRem<Integer> for Integer
sourcefn div_rem(self, other: Integer) -> (Integer, Integer)
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
extern crate malachite_base;
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)");
type DivOutput = Integer
type RemOutput = Integer
sourceimpl<'a> DivRound<&'a Integer> for Integer
impl<'a> DivRound<&'a Integer> for Integer
sourcefn div_round(self, other: &'a Integer, rm: RoundingMode) -> Integer
fn div_round(self, other: &'a Integer, rm: RoundingMode) -> Integer
Divides an Integer
by another Integer
, taking the first by value and the second by
reference and rounding according to a specified rounding mode.
Let $q = \frac{x}{y}$:
$$ f(x, y, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor. $$
$$ f(x, y, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil. $$
$$ f(x, y, \mathrm{Floor}) = \lfloor q \rfloor. $$
$$ f(x, y, \mathrm{Ceiling}) = \lceil q \rceil. $$
$$ f(x, y, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n \log n \log \log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if other
is zero, or if rm
is Exact
but self
is not divisible by other
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(-10).div_round(&Integer::from(4), RoundingMode::Down), -2);
assert_eq!(
(-Integer::from(10u32).pow(12)).div_round(&Integer::from(3), RoundingMode::Floor),
-333333333334i64
);
assert_eq!(Integer::from(-10).div_round(&Integer::from(4), RoundingMode::Up), -3);
assert_eq!(
(-Integer::from(10u32).pow(12)).div_round(&Integer::from(3), RoundingMode::Ceiling),
-333333333333i64
);
assert_eq!(Integer::from(-10).div_round(&Integer::from(5), RoundingMode::Exact), -2);
assert_eq!(Integer::from(-10).div_round(&Integer::from(3), RoundingMode::Nearest), -3);
assert_eq!(Integer::from(-20).div_round(&Integer::from(3), RoundingMode::Nearest), -7);
assert_eq!(Integer::from(-10).div_round(&Integer::from(4), RoundingMode::Nearest), -2);
assert_eq!(Integer::from(-14).div_round(&Integer::from(4), RoundingMode::Nearest), -4);
assert_eq!(Integer::from(-10).div_round(&Integer::from(-4), RoundingMode::Down), 2);
assert_eq!(
(-Integer::from(10u32).pow(12)).div_round(&Integer::from(-3), RoundingMode::Floor),
333333333333i64
);
assert_eq!(Integer::from(-10).div_round(&Integer::from(-4), RoundingMode::Up), 3);
assert_eq!(
(-Integer::from(10u32).pow(12)).div_round(&Integer::from(-3), RoundingMode::Ceiling),
333333333334i64
);
assert_eq!(Integer::from(-10).div_round(&Integer::from(-5), RoundingMode::Exact), 2);
assert_eq!(Integer::from(-10).div_round(&Integer::from(-3), RoundingMode::Nearest), 3);
assert_eq!(Integer::from(-20).div_round(&Integer::from(-3), RoundingMode::Nearest), 7);
assert_eq!(Integer::from(-10).div_round(&Integer::from(-4), RoundingMode::Nearest), 2);
assert_eq!(Integer::from(-14).div_round(&Integer::from(-4), RoundingMode::Nearest), 4);
type Output = Integer
sourceimpl<'a, 'b> DivRound<&'b Integer> for &'a Integer
impl<'a, 'b> DivRound<&'b Integer> for &'a Integer
sourcefn div_round(self, other: &'b Integer, rm: RoundingMode) -> Integer
fn div_round(self, other: &'b Integer, rm: RoundingMode) -> Integer
Divides an Integer
by another Integer
, taking both by reference and rounding
according to a specified rounding mode.
Let $q = \frac{x}{y}$:
$$ f(x, y, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor. $$
$$ f(x, y, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil. $$
$$ f(x, y, \mathrm{Floor}) = \lfloor q \rfloor. $$
$$ f(x, y, \mathrm{Ceiling}) = \lceil q \rceil. $$
$$ f(x, y, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n \log n \log \log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if other
is zero, or if rm
is Exact
but self
is not divisible by other
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
assert_eq!((&Integer::from(-10)).div_round(&Integer::from(4), RoundingMode::Down), -2);
assert_eq!(
(&-Integer::from(10u32).pow(12)).div_round(&Integer::from(3), RoundingMode::Floor),
-333333333334i64
);
assert_eq!(Integer::from(-10).div_round(&Integer::from(4), RoundingMode::Up), -3);
assert_eq!(
(&-Integer::from(10u32).pow(12)).div_round(&Integer::from(3), RoundingMode::Ceiling),
-333333333333i64
);
assert_eq!((&Integer::from(-10)).div_round(&Integer::from(5), RoundingMode::Exact), -2);
assert_eq!((&Integer::from(-10)).div_round(&Integer::from(3), RoundingMode::Nearest), -3);
assert_eq!((&Integer::from(-20)).div_round(&Integer::from(3), RoundingMode::Nearest), -7);
assert_eq!((&Integer::from(-10)).div_round(&Integer::from(4), RoundingMode::Nearest), -2);
assert_eq!((&Integer::from(-14)).div_round(&Integer::from(4), RoundingMode::Nearest), -4);
assert_eq!((&Integer::from(-10)).div_round(&Integer::from(-4), RoundingMode::Down), 2);
assert_eq!(
(&-Integer::from(10u32).pow(12)).div_round(&Integer::from(-3), RoundingMode::Floor),
333333333333i64
);
assert_eq!(Integer::from(-10).div_round(&Integer::from(-4), RoundingMode::Up), 3);
assert_eq!(
(&-Integer::from(10u32).pow(12)).div_round(&Integer::from(-3), RoundingMode::Ceiling),
333333333334i64
);
assert_eq!((&Integer::from(-10)).div_round(&Integer::from(-5), RoundingMode::Exact), 2);
assert_eq!((&Integer::from(-10)).div_round(&Integer::from(-3), RoundingMode::Nearest), 3);
assert_eq!((&Integer::from(-20)).div_round(&Integer::from(-3), RoundingMode::Nearest), 7);
assert_eq!((&Integer::from(-10)).div_round(&Integer::from(-4), RoundingMode::Nearest), 2);
assert_eq!((&Integer::from(-14)).div_round(&Integer::from(-4), RoundingMode::Nearest), 4);
type Output = Integer
sourceimpl<'a> DivRound<Integer> for &'a Integer
impl<'a> DivRound<Integer> for &'a Integer
sourcefn div_round(self, other: Integer, rm: RoundingMode) -> Integer
fn div_round(self, other: Integer, rm: RoundingMode) -> Integer
Divides an Integer
by another Integer
, taking the first by reference and the second
by value and rounding according to a specified rounding mode.
Let $q = \frac{x}{y}$:
$$ f(x, y, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor. $$
$$ f(x, y, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil. $$
$$ f(x, y, \mathrm{Floor}) = \lfloor q \rfloor. $$
$$ f(x, y, \mathrm{Ceiling}) = \lceil q \rceil. $$
$$ f(x, y, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n \log n \log \log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if other
is zero, or if rm
is Exact
but self
is not divisible by other
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
assert_eq!((&Integer::from(-10)).div_round(Integer::from(4), RoundingMode::Down), -2);
assert_eq!(
(&-Integer::from(10u32).pow(12)).div_round(Integer::from(3), RoundingMode::Floor),
-333333333334i64
);
assert_eq!(Integer::from(-10).div_round(Integer::from(4), RoundingMode::Up), -3);
assert_eq!(
(&-Integer::from(10u32).pow(12)).div_round(Integer::from(3), RoundingMode::Ceiling),
-333333333333i64
);
assert_eq!((&Integer::from(-10)).div_round(Integer::from(5), RoundingMode::Exact), -2);
assert_eq!((&Integer::from(-10)).div_round(Integer::from(3), RoundingMode::Nearest), -3);
assert_eq!((&Integer::from(-20)).div_round(Integer::from(3), RoundingMode::Nearest), -7);
assert_eq!((&Integer::from(-10)).div_round(Integer::from(4), RoundingMode::Nearest), -2);
assert_eq!((&Integer::from(-14)).div_round(Integer::from(4), RoundingMode::Nearest), -4);
assert_eq!((&Integer::from(-10)).div_round(Integer::from(-4), RoundingMode::Down), 2);
assert_eq!(
(&-Integer::from(10u32).pow(12)).div_round(Integer::from(-3), RoundingMode::Floor),
333333333333i64
);
assert_eq!(Integer::from(-10).div_round(Integer::from(-4), RoundingMode::Up), 3);
assert_eq!(
(&-Integer::from(10u32).pow(12)).div_round(Integer::from(-3), RoundingMode::Ceiling),
333333333334i64
);
assert_eq!((&Integer::from(-10)).div_round(Integer::from(-5), RoundingMode::Exact), 2);
assert_eq!((&Integer::from(-10)).div_round(Integer::from(-3), RoundingMode::Nearest), 3);
assert_eq!((&Integer::from(-20)).div_round(Integer::from(-3), RoundingMode::Nearest), 7);
assert_eq!((&Integer::from(-10)).div_round(Integer::from(-4), RoundingMode::Nearest), 2);
assert_eq!((&Integer::from(-14)).div_round(Integer::from(-4), RoundingMode::Nearest), 4);
type Output = Integer
sourceimpl DivRound<Integer> for Integer
impl DivRound<Integer> for Integer
sourcefn div_round(self, other: Integer, rm: RoundingMode) -> Integer
fn div_round(self, other: Integer, rm: RoundingMode) -> Integer
Divides an Integer
by another Integer
, taking both by value and rounding according
to a specified rounding mode.
Let $q = \frac{x}{y}$:
$$ f(x, y, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor. $$
$$ f(x, y, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil. $$
$$ f(x, y, \mathrm{Floor}) = \lfloor q \rfloor. $$
$$ f(x, y, \mathrm{Ceiling}) = \lceil q \rceil. $$
$$ f(x, y, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n \log n \log \log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if other
is zero, or if rm
is Exact
but self
is not divisible by other
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{DivRound, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(-10).div_round(Integer::from(4), RoundingMode::Down), -2);
assert_eq!(
(-Integer::from(10u32).pow(12)).div_round(Integer::from(3), RoundingMode::Floor),
-333333333334i64
);
assert_eq!(Integer::from(-10).div_round(Integer::from(4), RoundingMode::Up), -3);
assert_eq!(
(-Integer::from(10u32).pow(12)).div_round(Integer::from(3), RoundingMode::Ceiling),
-333333333333i64
);
assert_eq!(Integer::from(-10).div_round(Integer::from(5), RoundingMode::Exact), -2);
assert_eq!(Integer::from(-10).div_round(Integer::from(3), RoundingMode::Nearest), -3);
assert_eq!(Integer::from(-20).div_round(Integer::from(3), RoundingMode::Nearest), -7);
assert_eq!(Integer::from(-10).div_round(Integer::from(4), RoundingMode::Nearest), -2);
assert_eq!(Integer::from(-14).div_round(Integer::from(4), RoundingMode::Nearest), -4);
assert_eq!(Integer::from(-10).div_round(Integer::from(-4), RoundingMode::Down), 2);
assert_eq!(
(-Integer::from(10u32).pow(12)).div_round(Integer::from(-3), RoundingMode::Floor),
333333333333i64
);
assert_eq!(Integer::from(-10).div_round(Integer::from(-4), RoundingMode::Up), 3);
assert_eq!(
(-Integer::from(10u32).pow(12)).div_round(Integer::from(-3), RoundingMode::Ceiling),
333333333334i64
);
assert_eq!(Integer::from(-10).div_round(Integer::from(-5), RoundingMode::Exact), 2);
assert_eq!(Integer::from(-10).div_round(Integer::from(-3), RoundingMode::Nearest), 3);
assert_eq!(Integer::from(-20).div_round(Integer::from(-3), RoundingMode::Nearest), 7);
assert_eq!(Integer::from(-10).div_round(Integer::from(-4), RoundingMode::Nearest), 2);
assert_eq!(Integer::from(-14).div_round(Integer::from(-4), RoundingMode::Nearest), 4);
type Output = Integer
sourceimpl<'a> DivRoundAssign<&'a Integer> for Integer
impl<'a> DivRoundAssign<&'a Integer> for Integer
sourcefn div_round_assign(&mut self, other: &'a Integer, rm: RoundingMode)
fn div_round_assign(&mut self, other: &'a Integer, rm: RoundingMode)
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.
See the DivRound
documentation for
details.
Worst-case complexity
$T(n) = O(n \log n \log \log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if other
is zero, or if rm
is Exact
but self
is not divisible by other
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{DivRoundAssign, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
let mut n = Integer::from(-10);
n.div_round_assign(&Integer::from(4), RoundingMode::Down);
assert_eq!(n, -2);
let mut n = -Integer::from(10u32).pow(12);
n.div_round_assign(&Integer::from(3), RoundingMode::Floor);
assert_eq!(n, -333333333334i64);
let mut n = Integer::from(-10);
n.div_round_assign(&Integer::from(4), RoundingMode::Up);
assert_eq!(n, -3);
let mut n = -Integer::from(10u32).pow(12);
n.div_round_assign(&Integer::from(3), RoundingMode::Ceiling);
assert_eq!(n, -333333333333i64);
let mut n = Integer::from(-10);
n.div_round_assign(&Integer::from(5), RoundingMode::Exact);
assert_eq!(n, -2);
let mut n = Integer::from(-10);
n.div_round_assign(Integer::from(3), RoundingMode::Nearest);
assert_eq!(n, -3);
let mut n = Integer::from(-20);
n.div_round_assign(&Integer::from(3), RoundingMode::Nearest);
assert_eq!(n, -7);
let mut n = Integer::from(-10);
n.div_round_assign(&Integer::from(4), RoundingMode::Nearest);
assert_eq!(n, -2);
let mut n = Integer::from(-14);
n.div_round_assign(&Integer::from(4), RoundingMode::Nearest);
assert_eq!(n, -4);
let mut n = Integer::from(-10);
n.div_round_assign(&Integer::from(-4), RoundingMode::Down);
assert_eq!(n, 2);
let mut n = -Integer::from(10u32).pow(12);
n.div_round_assign(&Integer::from(-3), RoundingMode::Floor);
assert_eq!(n, 333333333333i64);
let mut n = Integer::from(-10);
n.div_round_assign(&Integer::from(-4), RoundingMode::Up);
assert_eq!(n, 3);
let mut n = -Integer::from(10u32).pow(12);
n.div_round_assign(&Integer::from(-3), RoundingMode::Ceiling);
assert_eq!(n, 333333333334i64);
let mut n = Integer::from(-10);
n.div_round_assign(&Integer::from(-5), RoundingMode::Exact);
assert_eq!(n, 2);
let mut n = Integer::from(-10);
n.div_round_assign(&Integer::from(-3), RoundingMode::Nearest);
assert_eq!(n, 3);
let mut n = Integer::from(-20);
n.div_round_assign(&Integer::from(-3), RoundingMode::Nearest);
assert_eq!(n, 7);
let mut n = Integer::from(-10);
n.div_round_assign(&Integer::from(-4), RoundingMode::Nearest);
assert_eq!(n, 2);
let mut n = Integer::from(-14);
n.div_round_assign(&Integer::from(-4), RoundingMode::Nearest);
assert_eq!(n, 4);
sourceimpl DivRoundAssign<Integer> for Integer
impl DivRoundAssign<Integer> for Integer
sourcefn div_round_assign(&mut self, other: Integer, rm: RoundingMode)
fn div_round_assign(&mut self, other: Integer, rm: RoundingMode)
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.
See the DivRound
documentation for
details.
Worst-case complexity
$T(n) = O(n \log n \log \log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if other
is zero, or if rm
is Exact
but self
is not divisible by other
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{DivRoundAssign, Pow};
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
let mut n = Integer::from(-10);
n.div_round_assign(Integer::from(4), RoundingMode::Down);
assert_eq!(n, -2);
let mut n = -Integer::from(10u32).pow(12);
n.div_round_assign(Integer::from(3), RoundingMode::Floor);
assert_eq!(n, -333333333334i64);
let mut n = Integer::from(-10);
n.div_round_assign(Integer::from(4), RoundingMode::Up);
assert_eq!(n, -3);
let mut n = -Integer::from(10u32).pow(12);
n.div_round_assign(Integer::from(3), RoundingMode::Ceiling);
assert_eq!(n, -333333333333i64);
let mut n = Integer::from(-10);
n.div_round_assign(Integer::from(5), RoundingMode::Exact);
assert_eq!(n, -2);
let mut n = Integer::from(-10);
n.div_round_assign(Integer::from(3), RoundingMode::Nearest);
assert_eq!(n, -3);
let mut n = Integer::from(-20);
n.div_round_assign(Integer::from(3), RoundingMode::Nearest);
assert_eq!(n, -7);
let mut n = Integer::from(-10);
n.div_round_assign(Integer::from(4), RoundingMode::Nearest);
assert_eq!(n, -2);
let mut n = Integer::from(-14);
n.div_round_assign(Integer::from(4), RoundingMode::Nearest);
assert_eq!(n, -4);
let mut n = Integer::from(-10);
n.div_round_assign(Integer::from(-4), RoundingMode::Down);
assert_eq!(n, 2);
let mut n = -Integer::from(10u32).pow(12);
n.div_round_assign(Integer::from(-3), RoundingMode::Floor);
assert_eq!(n, 333333333333i64);
let mut n = Integer::from(-10);
n.div_round_assign(Integer::from(-4), RoundingMode::Up);
assert_eq!(n, 3);
let mut n = -Integer::from(10u32).pow(12);
n.div_round_assign(Integer::from(-3), RoundingMode::Ceiling);
assert_eq!(n, 333333333334i64);
let mut n = Integer::from(-10);
n.div_round_assign(Integer::from(-5), RoundingMode::Exact);
assert_eq!(n, 2);
let mut n = Integer::from(-10);
n.div_round_assign(Integer::from(-3), RoundingMode::Nearest);
assert_eq!(n, 3);
let mut n = Integer::from(-20);
n.div_round_assign(Integer::from(-3), RoundingMode::Nearest);
assert_eq!(n, 7);
let mut n = Integer::from(-10);
n.div_round_assign(Integer::from(-4), RoundingMode::Nearest);
assert_eq!(n, 2);
let mut n = Integer::from(-14);
n.div_round_assign(Integer::from(-4), RoundingMode::Nearest);
assert_eq!(n, 4);
sourceimpl<'a> DivisibleBy<&'a Integer> for Integer
impl<'a> DivisibleBy<&'a Integer> for Integer
sourcefn divisible_by(self, other: &'a Integer) -> bool
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
extern crate malachite_base;
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
);
sourceimpl<'a, 'b> DivisibleBy<&'b Integer> for &'a Integer
impl<'a, 'b> DivisibleBy<&'b Integer> for &'a Integer
sourcefn divisible_by(self, other: &'b Integer) -> bool
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 Integer
s 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
extern crate malachite_base;
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
);
sourceimpl<'a> DivisibleBy<Integer> for &'a Integer
impl<'a> DivisibleBy<Integer> for &'a Integer
sourcefn divisible_by(self, other: Integer) -> bool
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
extern crate malachite_base;
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
);
sourceimpl DivisibleBy<Integer> for Integer
impl DivisibleBy<Integer> for Integer
sourcefn divisible_by(self, other: Integer) -> bool
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 Integer
s 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
extern crate malachite_base;
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
);
sourceimpl<'a> DivisibleByPowerOf2 for &'a Integer
impl<'a> DivisibleByPowerOf2 for &'a Integer
sourcefn divisible_by_power_of_2(self, pow: u64) -> bool
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
extern crate malachite_base;
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);
sourceimpl<'a, 'b> EqMod<&'a Integer, &'b Natural> for Integer
impl<'a, 'b> EqMod<&'a Integer, &'b Natural> for Integer
sourcefn eq_mod(self, other: &'a Integer, m: &'b Natural) -> bool
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 Integer
s is a multiple of the
Natural
. The first number is taken by value and the second and third by reference.
Two Integer
s are equal to each other modulo 0 iff they are equal.
$f(x, y, m) = (x \equiv y \mod m)$.
$f(x, y, m) = (\exists k \in \Z : x - y = km)$.
Worst-case complexity
$T(n) = O(n \log n \log \log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;
assert_eq!(
Integer::from(123).eq_mod(&Integer::from(223), &Natural::from(100u32)),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
&Integer::from_str("-999999012346").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
&Integer::from_str("2000000987655").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
false
);
sourceimpl<'a> EqMod<&'a Integer, Natural> for Integer
impl<'a> EqMod<&'a Integer, Natural> for Integer
sourcefn eq_mod(self, other: &'a Integer, m: Natural) -> bool
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 Integer
s is a multiple of the
Natural
. The first and third numbers are taken by value and the second by reference.
Two Integer
s are equal to each other modulo 0 iff they are equal.
$f(x, y, m) = (x \equiv y \mod m)$.
$f(x, y, m) = (\exists k \in \Z : x - y = km)$.
Worst-case complexity
$T(n) = O(n \log n \log \log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;
assert_eq!(
Integer::from(123).eq_mod(&Integer::from(223), Natural::from(100u32)),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
&Integer::from_str("-999999012346").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
&Integer::from_str("2000000987655").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
false
);
sourceimpl<'a, 'b, 'c> EqMod<&'b Integer, &'c Natural> for &'a Integer
impl<'a, 'b, 'c> EqMod<&'b Integer, &'c Natural> for &'a Integer
sourcefn eq_mod(self, other: &'b Integer, m: &'c Natural) -> bool
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 Integer
s is a multiple of the
Natural
. All three numbers are taken by reference.
Two Integer
s are equal to each other modulo 0 iff they are equal.
$f(x, y, m) = (x \equiv y \mod m)$.
$f(x, y, m) = (\exists k \in \Z : x - y = km)$.
Worst-case complexity
$T(n) = O(n \log n \log \log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;
assert_eq!(
(&Integer::from(123)).eq_mod(&Integer::from(223), &Natural::from(100u32)),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
&Integer::from_str("-999999012346").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
&Integer::from_str("2000000987655").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
false
);
sourceimpl<'a, 'b> EqMod<&'b Integer, Natural> for &'a Integer
impl<'a, 'b> EqMod<&'b Integer, Natural> for &'a Integer
sourcefn eq_mod(self, other: &'b Integer, m: Natural) -> bool
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 Integer
s is a multiple of the
Natural
. The first two numbers are taken by reference and the third by value.
Two Integer
s are equal to each other modulo 0 iff they are equal.
$f(x, y, m) = (x \equiv y \mod m)$.
$f(x, y, m) = (\exists k \in \Z : x - y = km)$.
Worst-case complexity
$T(n) = O(n \log n \log \log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;
assert_eq!(
(&Integer::from(123)).eq_mod(&Integer::from(223), Natural::from(100u32)),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
&Integer::from_str("-999999012346").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
&Integer::from_str("2000000987655").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
false
);
sourceimpl<'a> EqMod<Integer, &'a Natural> for Integer
impl<'a> EqMod<Integer, &'a Natural> for Integer
sourcefn eq_mod(self, other: Integer, m: &'a Natural) -> bool
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 Integer
s is a multiple of the
Natural
. The first two numbers are taken by value and the third by reference.
Two Integer
s are equal to each other modulo 0 iff they are equal.
$f(x, y, m) = (x \equiv y \mod m)$.
$f(x, y, m) = (\exists k \in \Z : x - y = km)$.
Worst-case complexity
$T(n) = O(n \log n \log \log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;
assert_eq!(
Integer::from(123).eq_mod(Integer::from(223), &Natural::from(100u32)),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
Integer::from_str("-999999012346").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
Integer::from_str("2000000987655").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
false
);
sourceimpl<'a, 'b> EqMod<Integer, &'b Natural> for &'a Integer
impl<'a, 'b> EqMod<Integer, &'b Natural> for &'a Integer
sourcefn eq_mod(self, other: Integer, m: &'b Natural) -> bool
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 Integer
s is a multiple of the
Natural
. The first and third numbers are taken by reference and the third by value.
Two Integer
s are equal to each other modulo 0 iff they are equal.
$f(x, y, m) = (x \equiv y \mod m)$.
$f(x, y, m) = (\exists k \in \Z : x - y = km)$.
Worst-case complexity
$T(n) = O(n \log n \log \log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;
assert_eq!(
(&Integer::from(123)).eq_mod(Integer::from(223), &Natural::from(100u32)),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
Integer::from_str("-999999012346").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
Integer::from_str("2000000987655").unwrap(),
&Natural::from_str("1000000000000").unwrap()
),
false
);
sourceimpl<'a> EqMod<Integer, Natural> for &'a Integer
impl<'a> EqMod<Integer, Natural> for &'a Integer
sourcefn eq_mod(self, other: Integer, m: Natural) -> bool
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 Integer
s is a multiple of the
Natural
. The first number is taken by reference and the second and third by value.
Two Integer
s are equal to each other modulo 0 iff they are equal.
$f(x, y, m) = (x \equiv y \mod m)$.
$f(x, y, m) = (\exists k \in \Z : x - y = km)$.
Worst-case complexity
$T(n) = O(n \log n \log \log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;
assert_eq!(
(&Integer::from(123)).eq_mod(Integer::from(223), Natural::from(100u32)),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
Integer::from_str("-999999012346").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
(&Integer::from_str("1000000987654").unwrap()).eq_mod(
Integer::from_str("2000000987655").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
false
);
sourceimpl EqMod<Integer, Natural> for Integer
impl EqMod<Integer, Natural> for Integer
sourcefn eq_mod(self, other: Integer, m: Natural) -> bool
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 Integer
s is a multiple of the
Natural
. All three numbers are taken by value.
Two Integer
s are equal to each other modulo 0 iff they are equal.
$f(x, y, m) = (x \equiv y \mod m)$.
$f(x, y, m) = (\exists k \in \Z : x - y = km)$.
Worst-case complexity
$T(n) = O(n \log n \log \log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::EqMod;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
use std::str::FromStr;
assert_eq!(
Integer::from(123).eq_mod(Integer::from(223), Natural::from(100u32)),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
Integer::from_str("-999999012346").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
true
);
assert_eq!(
Integer::from_str("1000000987654").unwrap().eq_mod(
Integer::from_str("2000000987655").unwrap(),
Natural::from_str("1000000000000").unwrap()
),
false
);
sourceimpl<'a, 'b> EqModPowerOf2<&'b Integer> for &'a Integer
impl<'a, 'b> EqModPowerOf2<&'b Integer> for &'a Integer
sourcefn eq_mod_power_of_2(self, other: &'b Integer, pow: u64) -> bool
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
extern crate malachite_base;
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);
sourceimpl<'a, 'b> ExtendedGcd<&'a Integer> for &'b Integer
impl<'a, 'b> ExtendedGcd<&'a Integer> for &'b Integer
sourcefn extended_gcd(self, other: &'a Integer) -> (Natural, Integer, Integer)
fn extended_gcd(self, other: &'a Integer) -> (Natural, Integer, Integer)
Computes the GCD (greatest common divisor) of two Integer
s $a$ and $b$, and also the
coefficients $x$ and $y$ in Bézout’s identity $ax+by=\gcd(a,b)$. Both Integer
s 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
extern crate malachite_base;
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)"
);
type Gcd = Natural
type Cofactor = Integer
sourceimpl<'a> ExtendedGcd<&'a Integer> for Integer
impl<'a> ExtendedGcd<&'a Integer> for Integer
sourcefn extended_gcd(self, other: &'a Integer) -> (Natural, Integer, Integer)
fn extended_gcd(self, other: &'a Integer) -> (Natural, Integer, Integer)
Computes the GCD (greatest common divisor) of two Integer
s $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
extern crate malachite_base;
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)"
);
type Gcd = Natural
type Cofactor = Integer
sourceimpl<'a> ExtendedGcd<Integer> for &'a Integer
impl<'a> ExtendedGcd<Integer> for &'a Integer
sourcefn extended_gcd(self, other: Integer) -> (Natural, Integer, Integer)
fn extended_gcd(self, other: Integer) -> (Natural, Integer, Integer)
Computes the GCD (greatest common divisor) of two Integer
s $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
extern crate malachite_base;
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)"
);
type Gcd = Natural
type Cofactor = Integer
sourceimpl ExtendedGcd<Integer> for Integer
impl ExtendedGcd<Integer> for Integer
sourcefn extended_gcd(self, other: Integer) -> (Natural, Integer, Integer)
fn extended_gcd(self, other: Integer) -> (Natural, Integer, Integer)
Computes the GCD (greatest common divisor) of two Integer
s $a$ and $b$, and also the
coefficients $x$ and $y$ in Bézout’s identity $ax+by=\gcd(a,b)$. Both Integer
s 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
extern crate malachite_base;
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)"
);
type Gcd = Natural
type Cofactor = Integer
sourceimpl<'a> FloorRoot<u64> for &'a Integer
impl<'a> FloorRoot<u64> for &'a Integer
sourcefn floor_root(self, exp: u64) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl FloorRoot<u64> for Integer
impl FloorRoot<u64> for Integer
sourcefn floor_root(self, exp: u64) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl FloorRootAssign<u64> for Integer
impl FloorRootAssign<u64> for Integer
sourcefn floor_root_assign(&mut self, exp: u64)
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
extern crate malachite_base;
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);
sourceimpl<'a> FloorSqrt for &'a Integer
impl<'a> FloorSqrt for &'a Integer
sourcefn floor_sqrt(self) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl FloorSqrt for Integer
impl FloorSqrt for Integer
sourcefn floor_sqrt(self) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl FloorSqrtAssign for Integer
impl FloorSqrtAssign for Integer
sourcefn floor_sqrt_assign(&mut self)
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
extern crate malachite_base;
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);
sourceimpl<'a> From<&'a Integer> for f32
impl<'a> From<&'a Integer> for f32
sourcefn from(value: &'a Integer) -> f32
fn from(value: &'a Integer) -> f32
Converts an Integer
to a primitive float.
If there are two nearest floats, the one whose least-significant bit is zero is
chosen. If the Integer
is larger than the maximum finite float, then the result
is the maximum finite float.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Examples
See here.
sourceimpl<'a> From<&'a Integer> for f64
impl<'a> From<&'a Integer> for f64
sourcefn from(value: &'a Integer) -> f64
fn from(value: &'a Integer) -> f64
Converts an Integer
to a primitive float.
If there are two nearest floats, the one whose least-significant bit is zero is
chosen. If the Integer
is larger than the maximum finite float, then the result
is the maximum finite float.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Examples
See here.
sourceimpl<'a> From<&'a Natural> for Integer
impl<'a> From<&'a Natural> for Integer
sourcefn from(value: &'a Natural) -> Integer
fn from(value: &'a Natural) -> Integer
Converts a Natural
to an Integer
, taking the Natural
by reference.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
assert_eq!(Integer::from(&Natural::from(123u32)), 123);
assert_eq!(Integer::from(&Natural::from(10u32).pow(12)), 1000000000000u64);
sourceimpl From<Natural> for Integer
impl From<Natural> for Integer
sourcefn from(value: Natural) -> Integer
fn from(value: Natural) -> Integer
Converts a Natural
to an Integer
, taking the Natural
by value.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
assert_eq!(Integer::from(Natural::from(123u32)), 123);
assert_eq!(Integer::from(Natural::from(10u32).pow(12)), 1000000000000u64);
sourceimpl From<f32> for Integer
impl From<f32> for Integer
sourcefn from(value: f32) -> Integer
fn from(value: f32) -> Integer
Converts a primitive float to the nearest Integer
.
Floating-point values exactly between two Integer
s are rounded to the even one.
The floating point value cannot be NaN or infinite.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.sci_exponent()
.
Panics
Panics if value
is NaN or infinite.
Examples
See here.
sourceimpl From<f64> for Integer
impl From<f64> for Integer
sourcefn from(value: f64) -> Integer
fn from(value: f64) -> Integer
Converts a primitive float to the nearest Integer
.
Floating-point values exactly between two Integer
s are rounded to the even one.
The floating point value cannot be NaN or infinite.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.sci_exponent()
.
Panics
Panics if value
is NaN or infinite.
Examples
See here.
sourceimpl FromSciString for Integer
impl FromSciString for Integer
sourcefn from_sci_string_with_options(
s: &str,
options: FromSciStringOptions
) -> Option<Integer>
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
extern crate malachite_base;
use malachite_base::num::conversion::string::options::FromSciStringOptions;
use malachite_base::num::conversion::traits::FromSciString;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::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);
sourcefn from_sci_string(s: &str) -> Option<Self>
fn from_sci_string(s: &str) -> Option<Self>
Converts a &str
, possibly in scientific notation, to a number, using the default
FromSciStringOptions
. Read more
sourceimpl FromStr for Integer
impl FromStr for Integer
sourcefn from_str(s: &str) -> Result<Integer, ()>
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 char
s '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());
sourceimpl FromStringBase for Integer
impl FromStringBase for Integer
sourcefn from_string_base(base: u8, s: &str) -> Option<Integer>
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 char
s '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
extern crate malachite_base;
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!(
Integer::from_string_base(16, "deadbeef").unwrap(),
3735928559i64
);
assert_eq!(
Integer::from_string_base(16, "deAdBeEf").unwrap(),
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!(
Integer::from_string_base(16, "-deadbeef").unwrap(),
-3735928559i64
);
assert_eq!(
Integer::from_string_base(16, "-deAdBeEf").unwrap(),
-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());
sourceimpl<'a> IsInteger for &'a Integer
impl<'a> IsInteger for &'a Integer
sourcefn is_integer(self) -> bool
fn is_integer(self) -> bool
Determines whether an Integer
is an integer. It always returns true
.
$f(x) = \textrm{true}$.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::{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);
sourceimpl<'a, 'b> JacobiSymbol<&'a Integer> for &'b Integer
impl<'a, 'b> JacobiSymbol<&'a Integer> for &'b Integer
sourcefn jacobi_symbol(self, other: &'a Integer) -> i8
fn jacobi_symbol(self, other: &'a Integer) -> i8
Computes the Jacobi symbol of two Integer
s, 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
extern crate malachite_base;
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);
sourceimpl<'a> JacobiSymbol<&'a Integer> for Integer
impl<'a> JacobiSymbol<&'a Integer> for Integer
sourcefn jacobi_symbol(self, other: &'a Integer) -> i8
fn jacobi_symbol(self, other: &'a Integer) -> i8
Computes the Jacobi symbol of two Integer
s, 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
extern crate malachite_base;
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);
sourceimpl<'a> JacobiSymbol<Integer> for &'a Integer
impl<'a> JacobiSymbol<Integer> for &'a Integer
sourcefn jacobi_symbol(self, other: Integer) -> i8
fn jacobi_symbol(self, other: Integer) -> i8
Computes the Jacobi symbol of two Integer
s, 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
extern crate malachite_base;
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);
sourceimpl JacobiSymbol<Integer> for Integer
impl JacobiSymbol<Integer> for Integer
sourcefn jacobi_symbol(self, other: Integer) -> i8
fn jacobi_symbol(self, other: Integer) -> i8
Computes the Jacobi symbol of two Integer
s, 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
extern crate malachite_base;
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);
sourceimpl<'a, 'b> KroneckerSymbol<&'a Integer> for &'b Integer
impl<'a, 'b> KroneckerSymbol<&'a Integer> for &'b Integer
sourcefn kronecker_symbol(self, other: &'a Integer) -> i8
fn kronecker_symbol(self, other: &'a Integer) -> i8
Computes the Kronecker symbol of two Integer
s, 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
extern crate malachite_base;
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);
sourceimpl<'a> KroneckerSymbol<&'a Integer> for Integer
impl<'a> KroneckerSymbol<&'a Integer> for Integer
sourcefn kronecker_symbol(self, other: &'a Integer) -> i8
fn kronecker_symbol(self, other: &'a Integer) -> i8
Computes the Kronecker symbol of two Integer
s, 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
extern crate malachite_base;
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);
sourceimpl<'a> KroneckerSymbol<Integer> for &'a Integer
impl<'a> KroneckerSymbol<Integer> for &'a Integer
sourcefn kronecker_symbol(self, other: Integer) -> i8
fn kronecker_symbol(self, other: Integer) -> i8
Computes the Kronecker symbol of two Integer
s, 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
extern crate malachite_base;
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);
sourceimpl KroneckerSymbol<Integer> for Integer
impl KroneckerSymbol<Integer> for Integer
sourcefn kronecker_symbol(self, other: Integer) -> i8
fn kronecker_symbol(self, other: Integer) -> i8
Computes the Kronecker symbol of two Integer
s, 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
extern crate malachite_base;
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);
sourceimpl<'a, 'b> LegendreSymbol<&'a Integer> for &'b Integer
impl<'a, 'b> LegendreSymbol<&'a Integer> for &'b Integer
sourcefn legendre_symbol(self, other: &'a Integer) -> i8
fn legendre_symbol(self, other: &'a Integer) -> i8
Computes the Legendre symbol of two Integer
s, 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
extern crate malachite_base;
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);
sourceimpl<'a> LegendreSymbol<&'a Integer> for Integer
impl<'a> LegendreSymbol<&'a Integer> for Integer
sourcefn legendre_symbol(self, other: &'a Integer) -> i8
fn legendre_symbol(self, other: &'a Integer) -> i8
Computes the Legendre symbol of two Integer
s, 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
extern crate malachite_base;
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);
sourceimpl<'a> LegendreSymbol<Integer> for &'a Integer
impl<'a> LegendreSymbol<Integer> for &'a Integer
sourcefn legendre_symbol(self, other: Integer) -> i8
fn legendre_symbol(self, other: Integer) -> i8
Computes the Legendre symbol of two Integer
s, 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
extern crate malachite_base;
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);
sourceimpl LegendreSymbol<Integer> for Integer
impl LegendreSymbol<Integer> for Integer
sourcefn legendre_symbol(self, other: Integer) -> i8
fn legendre_symbol(self, other: Integer) -> i8
Computes the Legendre symbol of two Integer
s, 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
extern crate malachite_base;
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);
sourceimpl LowMask for Integer
impl LowMask for Integer
sourcefn low_mask(bits: u64) -> Integer
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
extern crate malachite_base;
use malachite_base::num::logic::traits::LowMask;
use malachite_nz::integer::Integer;
assert_eq!(Integer::low_mask(0), 0);
assert_eq!(Integer::low_mask(3), 7);
assert_eq!(Integer::low_mask(100).to_string(), "1267650600228229401496703205375");
sourceimpl LowerHex for Integer
impl LowerHex for Integer
sourcefn fmt(&self, f: &mut Formatter<'_>) -> Result
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
extern crate malachite_base;
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");
sourceimpl<'a> Mod<&'a Integer> for Integer
impl<'a> Mod<&'a Integer> for Integer
sourcefn mod_op(self, other: &'a Integer) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl<'a, 'b> Mod<&'b Integer> for &'a Integer
impl<'a, 'b> Mod<&'b Integer> for &'a Integer
sourcefn mod_op(self, other: &'b Integer) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl<'a> Mod<Integer> for &'a Integer
impl<'a> Mod<Integer> for &'a Integer
sourcefn mod_op(self, other: Integer) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl Mod<Integer> for Integer
impl Mod<Integer> for Integer
sourcefn mod_op(self, other: Integer) -> Integer
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
extern crate malachite_base;
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);
type Output = Integer
sourceimpl<'a> ModAssign<&'a Integer> for Integer
impl<'a> ModAssign<&'a Integer> for Integer
sourcefn mod_assign(&mut self, other: &'a Integer)
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
extern crate malachite_base;
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);
sourceimpl ModAssign<Integer> for Integer
impl ModAssign<Integer> for Integer
sourcefn mod_assign(&mut self, other: Integer)
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
extern crate malachite_base;
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);
sourceimpl<'a> ModPowerOf2 for &'a Integer
impl<'a> ModPowerOf2 for &'a Integer
sourcefn mod_power_of_2(self, pow: u64) -> Natural
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
extern crate malachite_base;
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);
type Output = Natural
sourceimpl ModPowerOf2 for Integer
impl ModPowerOf2 for Integer
sourcefn mod_power_of_2(self, pow: u64) -> Natural
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
extern crate malachite_base;
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);
type Output = Natural
sourceimpl ModPowerOf2Assign for Integer
impl ModPowerOf2Assign for Integer
sourcefn mod_power_of_2_assign(&mut self, pow: u64)
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
extern crate malachite_base;
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);
sourceimpl<'a, 'b> Mul<&'a Integer> for &'b Integer
impl<'a, 'b> Mul<&'a Integer> for &'b Integer
sourcefn mul(self, other: &'a Integer) -> Integer
fn mul(self, other: &'a Integer) -> Integer
Multiplies two Integer
s, taking both by reference.
$$ f(x, y) = xy. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::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"
);
sourceimpl<'a> Mul<&'a Integer> for Integer
impl<'a> Mul<&'a Integer> for Integer
sourcefn mul(self, other: &'a Integer) -> Integer
fn mul(self, other: &'a Integer) -> Integer
Multiplies two Integer
s, taking the first by value and the second by reference.
$$ f(x, y) = xy. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::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"
);
sourceimpl<'a> Mul<Integer> for &'a Integer
impl<'a> Mul<Integer> for &'a Integer
sourcefn mul(self, other: Integer) -> Integer
fn mul(self, other: Integer) -> Integer
Multiplies two Integer
s, taking the first by reference and the second by value.
$$ f(x, y) = xy. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::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"
);
sourceimpl Mul<Integer> for Integer
impl Mul<Integer> for Integer
sourcefn mul(self, other: Integer) -> Integer
fn mul(self, other: Integer) -> Integer
Multiplies two Integer
s, taking both by value.
$$ f(x, y) = xy. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::{One, Zero};
use malachite_nz::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"
);
sourceimpl<'a> MulAssign<&'a Integer> for Integer
impl<'a> MulAssign<&'a Integer> for Integer
sourcefn mul_assign(&mut self, other: &'a Integer)
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
extern crate malachite_base;
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);
sourceimpl MulAssign<Integer> for Integer
impl MulAssign<Integer> for Integer
sourcefn mul_assign(&mut self, other: Integer)
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
extern crate malachite_base;
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);
sourceimpl Named for Integer
impl Named for Integer
sourceconst NAME: &'static str = _
const NAME: &'static str = _
The name of this type, as given by the stringify
macro.
See the documentation for impl_named
for more details.
sourceimpl<'a> Neg for &'a Integer
impl<'a> Neg for &'a Integer
sourcefn neg(self) -> Integer
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
extern crate malachite_base;
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);
sourceimpl Neg for Integer
impl Neg for Integer
sourcefn neg(self) -> Integer
fn neg(self) -> Integer
Negates an Integer
, taking it by value.
$$ f(x) = -x. $$
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
assert_eq!(-Integer::ZERO, 0);
assert_eq!(-Integer::from(123), -123);
assert_eq!(-Integer::from(-123), 123);
sourceimpl NegAssign for Integer
impl NegAssign for Integer
sourcefn neg_assign(&mut self)
fn neg_assign(&mut self)
Negates an Integer
in place.
$$ x \gets -x. $$
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
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);
sourceimpl<'a> Not for &'a Integer
impl<'a> Not for &'a Integer
sourcefn not(self) -> Integer
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
extern crate malachite_base;
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);
sourceimpl Not for Integer
impl Not for Integer
sourcefn not(self) -> Integer
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
extern crate malachite_base;
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);
sourceimpl NotAssign for Integer
impl NotAssign for Integer
sourcefn not_assign(&mut self)
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
extern crate malachite_base;
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);
sourceimpl Octal for Integer
impl Octal for Integer
sourcefn fmt(&self, f: &mut Formatter<'_>) -> Result
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
extern crate malachite_base;
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");
sourceimpl Ord for Integer
impl Ord for Integer
sourcefn cmp(&self, other: &Integer) -> Ordering
fn cmp(&self, other: &Integer) -> Ordering
Compares two Integer
s.
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 · sourcefn max(self, other: Self) -> Self
fn max(self, other: Self) -> Self
Compares and returns the maximum of two values. Read more
1.21.0 · sourcefn min(self, other: Self) -> Self
fn min(self, other: Self) -> Self
Compares and returns the minimum of two values. Read more
1.50.0 · sourcefn clamp(self, min: Self, max: Self) -> Self where
Self: PartialOrd<Self>,
fn clamp(self, min: Self, max: Self) -> Self where
Self: PartialOrd<Self>,
Restrict a value to a certain interval. Read more
sourceimpl OrdAbs for Integer
impl OrdAbs for Integer
sourcefn cmp_abs(&self, other: &Integer) -> Ordering
fn cmp_abs(&self, other: &Integer) -> Ordering
Compares the absolute values of two Integer
s.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is
min(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::integer::Integer;
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)));
sourceimpl<'a> OverflowingFrom<&'a Integer> for i128
impl<'a> OverflowingFrom<&'a Integer> for i128
sourcefn overflowing_from(value: &Integer) -> (i128, bool)
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.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> OverflowingFrom<&'a Integer> for i16
impl<'a> OverflowingFrom<&'a Integer> for i16
sourcefn overflowing_from(value: &Integer) -> (i16, bool)
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.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> OverflowingFrom<&'a Integer> for i32
impl<'a> OverflowingFrom<&'a Integer> for i32
sourcefn overflowing_from(value: &Integer) -> (i32, bool)
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.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> OverflowingFrom<&'a Integer> for i64
impl<'a> OverflowingFrom<&'a Integer> for i64
sourcefn overflowing_from(value: &Integer) -> (i64, bool)
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.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> OverflowingFrom<&'a Integer> for i8
impl<'a> OverflowingFrom<&'a Integer> for i8
sourcefn overflowing_from(value: &Integer) -> (i8, bool)
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.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> OverflowingFrom<&'a Integer> for isize
impl<'a> OverflowingFrom<&'a Integer> for isize
sourcefn overflowing_from(value: &Integer) -> (isize, bool)
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.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> OverflowingFrom<&'a Integer> for u128
impl<'a> OverflowingFrom<&'a Integer> for u128
sourcefn overflowing_from(value: &Integer) -> (u128, bool)
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.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> OverflowingFrom<&'a Integer> for u16
impl<'a> OverflowingFrom<&'a Integer> for u16
sourcefn overflowing_from(value: &Integer) -> (u16, bool)
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.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> OverflowingFrom<&'a Integer> for u32
impl<'a> OverflowingFrom<&'a Integer> for u32
sourcefn overflowing_from(value: &Integer) -> (u32, bool)
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.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> OverflowingFrom<&'a Integer> for u64
impl<'a> OverflowingFrom<&'a Integer> for u64
sourcefn overflowing_from(value: &Integer) -> (u64, bool)
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.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> OverflowingFrom<&'a Integer> for u8
impl<'a> OverflowingFrom<&'a Integer> for u8
sourcefn overflowing_from(value: &Integer) -> (u8, bool)
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.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> OverflowingFrom<&'a Integer> for usize
impl<'a> OverflowingFrom<&'a Integer> for usize
sourcefn overflowing_from(value: &Integer) -> (usize, bool)
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.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> Parity for &'a Integer
impl<'a> Parity for &'a Integer
sourcefn even(self) -> bool
fn even(self) -> bool
Tests whether an Integer
is even.
$f(x) = (2|x)$.
$f(x) = (\exists k \in \N : x = 2k)$.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
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);
sourcefn odd(self) -> bool
fn odd(self) -> bool
Tests whether an Integer
is odd.
$f(x) = (2\nmid x)$.
$f(x) = (\exists k \in \N : x = 2k+1)$.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
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);
sourceimpl PartialEq<Integer> for Natural
impl PartialEq<Integer> for Natural
sourcefn eq(&self, other: &Integer) -> bool
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));
sourceimpl PartialEq<Integer> for f32
impl PartialEq<Integer> for f32
sourceimpl PartialEq<Integer> for f64
impl PartialEq<Integer> for f64
sourceimpl PartialEq<Natural> for Integer
impl PartialEq<Natural> for Integer
sourcefn eq(&self, other: &Natural) -> bool
fn eq(&self, other: &Natural) -> bool
Determines whether an Integer
is equal to a Natural
.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where n = min(self.significant_bits(), other.significant_bits())
Examples
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
assert!(Integer::from(123) == Natural::from(123u32));
assert!(Integer::from(123) != Natural::from(5u32));
sourceimpl PartialEq<f32> for Integer
impl PartialEq<f32> for Integer
sourceimpl PartialEq<f64> for Integer
impl PartialEq<f64> for Integer
sourceimpl PartialOrd<Integer> for Integer
impl PartialOrd<Integer> for Integer
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for Natural
impl PartialOrd<Integer> for Natural
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares a Natural
to an Integer
.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where n = min(self.significant_bits(), other.significant_bits())
.
Examples
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
assert!(Natural::from(123u32) > Integer::from(122));
assert!(Natural::from(123u32) >= Integer::from(122));
assert!(Natural::from(123u32) < Integer::from(124));
assert!(Natural::from(123u32) <= Integer::from(124));
assert!(Natural::from(123u32) > Integer::from(-123));
assert!(Natural::from(123u32) >= Integer::from(-123));
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for f32
impl PartialOrd<Integer> for f32
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares a primitive float to an Integer
.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where n = other.significant_bits()
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for f64
impl PartialOrd<Integer> for f64
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares a primitive float to an Integer
.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where n = other.significant_bits()
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for i128
impl PartialOrd<Integer> for i128
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares a signed primitive integer to an Integer
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for i16
impl PartialOrd<Integer> for i16
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares a signed primitive integer to an Integer
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for i32
impl PartialOrd<Integer> for i32
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares a signed primitive integer to an Integer
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for i64
impl PartialOrd<Integer> for i64
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares a signed primitive integer to an Integer
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for i8
impl PartialOrd<Integer> for i8
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares a signed primitive integer to an Integer
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for isize
impl PartialOrd<Integer> for isize
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares a signed primitive integer to an Integer
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for u128
impl PartialOrd<Integer> for u128
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares an unsigned primitive integer to an Integer
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for u16
impl PartialOrd<Integer> for u16
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares an unsigned primitive integer to an Integer
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for u32
impl PartialOrd<Integer> for u32
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares an unsigned primitive integer to an Integer
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for u64
impl PartialOrd<Integer> for u64
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares an unsigned primitive integer to an Integer
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for u8
impl PartialOrd<Integer> for u8
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares an unsigned primitive integer to an Integer
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Integer> for usize
impl PartialOrd<Integer> for usize
sourcefn partial_cmp(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp(&self, other: &Integer) -> Option<Ordering>
Compares an unsigned primitive integer to an Integer
.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<Natural> for Integer
impl PartialOrd<Natural> for Integer
sourcefn partial_cmp(&self, other: &Natural) -> Option<Ordering>
fn partial_cmp(&self, other: &Natural) -> Option<Ordering>
Compares an Integer
to a Natural
.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where n = min(self.significant_bits(), other.significant_bits())
.
Examples
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
assert!(Integer::from(123) > Natural::from(122u32));
assert!(Integer::from(123) >= Natural::from(122u32));
assert!(Integer::from(123) < Natural::from(124u32));
assert!(Integer::from(123) <= Natural::from(124u32));
assert!(Integer::from(-123) < Natural::from(123u32));
assert!(Integer::from(-123) <= Natural::from(123u32));
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<f32> for Integer
impl PartialOrd<f32> for Integer
sourcefn partial_cmp(&self, other: &f32) -> Option<Ordering>
fn partial_cmp(&self, other: &f32) -> Option<Ordering>
Compares an Integer
to a primitive float.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where n = self.significant_bits()
.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<f64> for Integer
impl PartialOrd<f64> for Integer
sourcefn partial_cmp(&self, other: &f64) -> Option<Ordering>
fn partial_cmp(&self, other: &f64) -> Option<Ordering>
Compares an Integer
to a primitive float.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where n = self.significant_bits()
.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<i128> for Integer
impl PartialOrd<i128> for Integer
sourcefn partial_cmp(&self, other: &i128) -> Option<Ordering>
fn partial_cmp(&self, other: &i128) -> Option<Ordering>
Compares an Integer
to a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<i16> for Integer
impl PartialOrd<i16> for Integer
sourcefn partial_cmp(&self, other: &i16) -> Option<Ordering>
fn partial_cmp(&self, other: &i16) -> Option<Ordering>
Compares an Integer
to a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<i32> for Integer
impl PartialOrd<i32> for Integer
sourcefn partial_cmp(&self, other: &i32) -> Option<Ordering>
fn partial_cmp(&self, other: &i32) -> Option<Ordering>
Compares an Integer
to a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<i64> for Integer
impl PartialOrd<i64> for Integer
sourcefn partial_cmp(&self, other: &i64) -> Option<Ordering>
fn partial_cmp(&self, other: &i64) -> Option<Ordering>
Compares an Integer
to a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<i8> for Integer
impl PartialOrd<i8> for Integer
sourcefn partial_cmp(&self, other: &i8) -> Option<Ordering>
fn partial_cmp(&self, other: &i8) -> Option<Ordering>
Compares an Integer
to a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<isize> for Integer
impl PartialOrd<isize> for Integer
sourcefn partial_cmp(&self, other: &isize) -> Option<Ordering>
fn partial_cmp(&self, other: &isize) -> Option<Ordering>
Compares an Integer
to a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<u128> for Integer
impl PartialOrd<u128> for Integer
sourcefn partial_cmp(&self, other: &u128) -> Option<Ordering>
fn partial_cmp(&self, other: &u128) -> Option<Ordering>
Compares an Integer
to an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<u16> for Integer
impl PartialOrd<u16> for Integer
sourcefn partial_cmp(&self, other: &u16) -> Option<Ordering>
fn partial_cmp(&self, other: &u16) -> Option<Ordering>
Compares an Integer
to an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<u32> for Integer
impl PartialOrd<u32> for Integer
sourcefn partial_cmp(&self, other: &u32) -> Option<Ordering>
fn partial_cmp(&self, other: &u32) -> Option<Ordering>
Compares an Integer
to an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<u64> for Integer
impl PartialOrd<u64> for Integer
sourcefn partial_cmp(&self, other: &u64) -> Option<Ordering>
fn partial_cmp(&self, other: &u64) -> Option<Ordering>
Compares an Integer
to an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<u8> for Integer
impl PartialOrd<u8> for Integer
sourcefn partial_cmp(&self, other: &u8) -> Option<Ordering>
fn partial_cmp(&self, other: &u8) -> Option<Ordering>
Compares an Integer
to an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrd<usize> for Integer
impl PartialOrd<usize> for Integer
sourcefn partial_cmp(&self, other: &usize) -> Option<Ordering>
fn partial_cmp(&self, other: &usize) -> Option<Ordering>
Compares an Integer
to an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl PartialOrdAbs<Integer> for Integer
impl PartialOrdAbs<Integer> for Integer
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Integer> for Natural
impl PartialOrdAbs<Integer> for Natural
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of a Natural
and an Integer
.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is
min(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
assert!(Natural::from(123u32).gt_abs(&Integer::from(122)));
assert!(Natural::from(123u32).ge_abs(&Integer::from(122)));
assert!(Natural::from(123u32).lt_abs(&Integer::from(124)));
assert!(Natural::from(123u32).le_abs(&Integer::from(124)));
assert!(Natural::from(123u32).lt_abs(&Integer::from(-124)));
assert!(Natural::from(123u32).le_abs(&Integer::from(-124)));
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Integer> for f32
impl PartialOrdAbs<Integer> for f32
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of a primitive float and an Integer
.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits()
.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Integer> for f64
impl PartialOrdAbs<Integer> for f64
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of a primitive float and an Integer
.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is other.significant_bits()
.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Integer> for i128
impl PartialOrdAbs<Integer> for i128
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of a signed primitive integer and an Integer
.
Worst-case complexity
Constant time and additional memory.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Integer> for i16
impl PartialOrdAbs<Integer> for i16
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of a signed primitive integer and an Integer
.
Worst-case complexity
Constant time and additional memory.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Integer> for i32
impl PartialOrdAbs<Integer> for i32
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of a signed primitive integer and an Integer
.
Worst-case complexity
Constant time and additional memory.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Integer> for i64
impl PartialOrdAbs<Integer> for i64
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of a signed primitive integer and an Integer
.
Worst-case complexity
Constant time and additional memory.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Integer> for i8
impl PartialOrdAbs<Integer> for i8
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of a signed primitive integer and an Integer
.
Worst-case complexity
Constant time and additional memory.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Integer> for isize
impl PartialOrdAbs<Integer> for isize
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of a signed primitive integer and an Integer
.
Worst-case complexity
Constant time and additional memory.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Integer> for u128
impl PartialOrdAbs<Integer> for u128
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of an unsigned primitive integer and an Integer
.
Worst-case complexity
Constant time and additional memory.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Integer> for u16
impl PartialOrdAbs<Integer> for u16
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of an unsigned primitive integer and an Integer
.
Worst-case complexity
Constant time and additional memory.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Integer> for u32
impl PartialOrdAbs<Integer> for u32
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of an unsigned primitive integer and an Integer
.
Worst-case complexity
Constant time and additional memory.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Integer> for u64
impl PartialOrdAbs<Integer> for u64
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of an unsigned primitive integer and an Integer
.
Worst-case complexity
Constant time and additional memory.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Integer> for u8
impl PartialOrdAbs<Integer> for u8
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of an unsigned primitive integer and an Integer
.
Worst-case complexity
Constant time and additional memory.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Integer> for usize
impl PartialOrdAbs<Integer> for usize
sourcefn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Integer) -> Option<Ordering>
Compares the absolute values of an unsigned primitive integer and an Integer
.
Worst-case complexity
Constant time and additional memory.
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<Natural> for Integer
impl PartialOrdAbs<Natural> for Integer
sourcefn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &Natural) -> Option<Ordering>
Compares the absolute values of an Integer
and a Natural
.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is
min(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::comparison::traits::PartialOrdAbs;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
assert!(Integer::from(123).gt_abs(&Natural::from(122u32)));
assert!(Integer::from(123).ge_abs(&Natural::from(122u32)));
assert!(Integer::from(123).lt_abs(&Natural::from(124u32)));
assert!(Integer::from(123).le_abs(&Natural::from(124u32)));
assert!(Integer::from(-124).gt_abs(&Natural::from(123u32)));
assert!(Integer::from(-124).ge_abs(&Natural::from(123u32)));
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<f32> for Integer
impl PartialOrdAbs<f32> for Integer
sourcefn partial_cmp_abs(&self, other: &f32) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &f32) -> Option<Ordering>
Compares the absolute values of an Integer
and a primitive float.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<f64> for Integer
impl PartialOrdAbs<f64> for Integer
sourcefn partial_cmp_abs(&self, other: &f64) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &f64) -> Option<Ordering>
Compares the absolute values of an Integer
and a primitive float.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<i128> for Integer
impl PartialOrdAbs<i128> for Integer
sourcefn partial_cmp_abs(&self, other: &i128) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &i128) -> Option<Ordering>
Compares the absolute values of an Integer
and a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<i16> for Integer
impl PartialOrdAbs<i16> for Integer
sourcefn partial_cmp_abs(&self, other: &i16) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &i16) -> Option<Ordering>
Compares the absolute values of an Integer
and a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<i32> for Integer
impl PartialOrdAbs<i32> for Integer
sourcefn partial_cmp_abs(&self, other: &i32) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &i32) -> Option<Ordering>
Compares the absolute values of an Integer
and a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<i64> for Integer
impl PartialOrdAbs<i64> for Integer
sourcefn partial_cmp_abs(&self, other: &i64) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &i64) -> Option<Ordering>
Compares the absolute values of an Integer
and a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<i8> for Integer
impl PartialOrdAbs<i8> for Integer
sourcefn partial_cmp_abs(&self, other: &i8) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &i8) -> Option<Ordering>
Compares the absolute values of an Integer
and a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<isize> for Integer
impl PartialOrdAbs<isize> for Integer
sourcefn partial_cmp_abs(&self, other: &isize) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &isize) -> Option<Ordering>
Compares the absolute values of an Integer
and a signed primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<u128> for Integer
impl PartialOrdAbs<u128> for Integer
sourcefn partial_cmp_abs(&self, other: &u128) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &u128) -> Option<Ordering>
Compares the absolute values of an Integer
and an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<u16> for Integer
impl PartialOrdAbs<u16> for Integer
sourcefn partial_cmp_abs(&self, other: &u16) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &u16) -> Option<Ordering>
Compares the absolute values of an Integer
and an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<u32> for Integer
impl PartialOrdAbs<u32> for Integer
sourcefn partial_cmp_abs(&self, other: &u32) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &u32) -> Option<Ordering>
Compares the absolute values of an Integer
and an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<u64> for Integer
impl PartialOrdAbs<u64> for Integer
sourcefn partial_cmp_abs(&self, other: &u64) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &u64) -> Option<Ordering>
Compares the absolute values of an Integer
and an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<u8> for Integer
impl PartialOrdAbs<u8> for Integer
sourcefn partial_cmp_abs(&self, other: &u8) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &u8) -> Option<Ordering>
Compares the absolute values of an Integer
and an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl PartialOrdAbs<usize> for Integer
impl PartialOrdAbs<usize> for Integer
sourcefn partial_cmp_abs(&self, other: &usize) -> Option<Ordering>
fn partial_cmp_abs(&self, other: &usize) -> Option<Ordering>
Compares the absolute values of an Integer
and an unsigned primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourcefn lt_abs(&self, other: &Rhs) -> bool
fn lt_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than the absolute value of another. Read more
sourcefn le_abs(&self, other: &Rhs) -> bool
fn le_abs(&self, other: &Rhs) -> bool
Determines whether the absolute value of one number is less than or equal to the absolute value of another. Read more
sourceimpl<'a> Pow<u64> for &'a Integer
impl<'a> Pow<u64> for &'a Integer
sourcefn pow(self, exp: u64) -> Integer
fn pow(self, exp: u64) -> Integer
Raises an Integer
to a power, taking the Integer
by reference.
$f(x, n) = x^n$.
Worst-case complexity
$T(n, m) = O(nm \log (nm) \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and $m$ is
exp
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_nz::integer::Integer;
use std::str::FromStr;
assert_eq!(
(&Integer::from(-3)).pow(100).to_string(),
"515377520732011331036461129765621272702107522001"
);
assert_eq!(
(&Integer::from_str("-12345678987654321").unwrap()).pow(3).to_string(),
"-1881676411868862234942354805142998028003108518161"
);
type Output = Integer
sourceimpl Pow<u64> for Integer
impl Pow<u64> for Integer
sourcefn pow(self, exp: u64) -> Integer
fn pow(self, exp: u64) -> Integer
Raises an Integer
to a power, taking the Integer
by value.
$f(x, n) = x^n$.
Worst-case complexity
$T(n, m) = O(nm \log (nm) \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and $m$ is
exp
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_nz::integer::Integer;
use std::str::FromStr;
assert_eq!(
Integer::from(-3).pow(100).to_string(),
"515377520732011331036461129765621272702107522001"
);
assert_eq!(
Integer::from_str("-12345678987654321").unwrap().pow(3).to_string(),
"-1881676411868862234942354805142998028003108518161"
);
type Output = Integer
sourceimpl PowAssign<u64> for Integer
impl PowAssign<u64> for Integer
sourcefn pow_assign(&mut self, exp: u64)
fn pow_assign(&mut self, exp: u64)
Raises an Integer
to a power in place.
$x \gets x^n$.
Worst-case complexity
$T(n, m) = O(nm \log (nm) \log\log (nm))$
$M(n, m) = O(nm \log (nm))$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and $m$ is
exp
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::PowAssign;
use malachite_nz::integer::Integer;
use std::str::FromStr;
let mut x = Integer::from(-3);
x.pow_assign(100);
assert_eq!(x.to_string(), "515377520732011331036461129765621272702107522001");
let mut x = Integer::from_str("-12345678987654321").unwrap();
x.pow_assign(3);
assert_eq!(x.to_string(), "-1881676411868862234942354805142998028003108518161");
sourceimpl PowerOf2<u64> for Integer
impl PowerOf2<u64> for Integer
sourcefn power_of_2(pow: u64) -> Integer
fn power_of_2(pow: u64) -> Integer
Raises 2 to an integer power.
$f(k) = 2^k$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is pow
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::PowerOf2;
use malachite_nz::integer::Integer;
assert_eq!(Integer::power_of_2(0), 1);
assert_eq!(Integer::power_of_2(3), 8);
assert_eq!(Integer::power_of_2(100).to_string(), "1267650600228229401496703205376");
sourceimpl<'a> Rem<&'a Integer> for Integer
impl<'a> Rem<&'a Integer> for Integer
sourcefn rem(self, other: &'a Integer) -> Integer
fn rem(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 first
Integer
.
If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq |r| < |y|$.
$$ f(x, y) = x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \right \rfloor. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if other
is zero.
Examples
use malachite_nz::integer::Integer;
// 2 * 10 + 3 = 23
assert_eq!(Integer::from(23) % &Integer::from(10), 3);
// -3 * -10 + -7 = 23
assert_eq!(Integer::from(23) % &Integer::from(-10), 3);
// -3 * 10 + 7 = -23
assert_eq!(Integer::from(-23) % &Integer::from(10), -3);
// 2 * -10 + -3 = -23
assert_eq!(Integer::from(-23) % &Integer::from(-10), -3);
sourceimpl<'a, 'b> Rem<&'b Integer> for &'a Integer
impl<'a, 'b> Rem<&'b Integer> for &'a Integer
sourcefn rem(self, other: &'b Integer) -> Integer
fn rem(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 first Integer
.
If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq |r| < |y|$.
$$ f(x, y) = x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \right \rfloor. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if other
is zero.
Examples
use malachite_nz::integer::Integer;
// 2 * 10 + 3 = 23
assert_eq!(&Integer::from(23) % &Integer::from(10), 3);
// -3 * -10 + -7 = 23
assert_eq!(&Integer::from(23) % &Integer::from(-10), 3);
// -3 * 10 + 7 = -23
assert_eq!(&Integer::from(-23) % &Integer::from(10), -3);
// 2 * -10 + -3 = -23
assert_eq!(&Integer::from(-23) % &Integer::from(-10), -3);
sourceimpl<'a> Rem<Integer> for &'a Integer
impl<'a> Rem<Integer> for &'a Integer
sourcefn rem(self, other: Integer) -> Integer
fn rem(self, other: Integer) -> Integer
Divides an Integer
by another Integer
, taking the first by reference and the second
by value and returning just the remainder. The remainder has the same sign as the first
Integer
.
If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq |r| < |y|$.
$$ f(x, y) = x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \right \rfloor. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if other
is zero.
Examples
use malachite_nz::integer::Integer;
// 2 * 10 + 3 = 23
assert_eq!(&Integer::from(23) % Integer::from(10), 3);
// -3 * -10 + -7 = 23
assert_eq!(&Integer::from(23) % Integer::from(-10), 3);
// -3 * 10 + 7 = -23
assert_eq!(&Integer::from(-23) % Integer::from(10), -3);
// 2 * -10 + -3 = -23
assert_eq!(&Integer::from(-23) % Integer::from(-10), -3);
sourceimpl Rem<Integer> for Integer
impl Rem<Integer> for Integer
sourcefn rem(self, other: Integer) -> Integer
fn rem(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 first Integer
.
If the quotient were computed, the quotient and remainder would satisfy $x = qy + r$ and $0 \leq |r| < |y|$.
$$ f(x, y) = x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \right \rfloor. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if other
is zero.
Examples
use malachite_nz::integer::Integer;
// 2 * 10 + 3 = 23
assert_eq!(Integer::from(23) % Integer::from(10), 3);
// -3 * -10 + -7 = 23
assert_eq!(Integer::from(23) % Integer::from(-10), 3);
// -3 * 10 + 7 = -23
assert_eq!(Integer::from(-23) % Integer::from(10), -3);
// 2 * -10 + -3 = -23
assert_eq!(Integer::from(-23) % Integer::from(-10), -3);
sourceimpl<'a> RemAssign<&'a Integer> for Integer
impl<'a> RemAssign<&'a Integer> for Integer
sourcefn rem_assign(&mut self, other: &'a Integer)
fn rem_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 first
Integer
.
If the quotient were computed, he quotient and remainder would satisfy $x = qy + r$ and $0 \leq |r| < |y|$.
$$ x \gets x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \right \rfloor. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if other
is zero.
Examples
use malachite_nz::integer::Integer;
// 2 * 10 + 3 = 23
let mut x = Integer::from(23);
x %= &Integer::from(10);
assert_eq!(x, 3);
// -3 * -10 + -7 = 23
let mut x = Integer::from(23);
x %= &Integer::from(-10);
assert_eq!(x, 3);
// -3 * 10 + 7 = -23
let mut x = Integer::from(-23);
x %= &Integer::from(10);
assert_eq!(x, -3);
// 2 * -10 + -3 = -23
let mut x = Integer::from(-23);
x %= &Integer::from(-10);
assert_eq!(x, -3);
sourceimpl RemAssign<Integer> for Integer
impl RemAssign<Integer> for Integer
sourcefn rem_assign(&mut self, other: Integer)
fn rem_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 first
Integer
.
If the quotient were computed, he quotient and remainder would satisfy $x = qy + r$ and $0 \leq |r| < |y|$.
$$ x \gets x - y \operatorname{sgn}(xy) \left \lfloor \left | \frac{x}{y} \right | \right \rfloor. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if other
is zero.
Examples
use malachite_nz::integer::Integer;
// 2 * 10 + 3 = 23
let mut x = Integer::from(23);
x %= Integer::from(10);
assert_eq!(x, 3);
// -3 * -10 + -7 = 23
let mut x = Integer::from(23);
x %= Integer::from(-10);
assert_eq!(x, 3);
// -3 * 10 + 7 = -23
let mut x = Integer::from(-23);
x %= Integer::from(10);
assert_eq!(x, -3);
// 2 * -10 + -3 = -23
let mut x = Integer::from(-23);
x %= Integer::from(-10);
assert_eq!(x, -3);
sourceimpl<'a> RemPowerOf2 for &'a Integer
impl<'a> RemPowerOf2 for &'a Integer
sourcefn rem_power_of_2(self, pow: u64) -> Integer
fn rem_power_of_2(self, pow: u64) -> Integer
Divides an Integer
by $2^k$, taking it by reference and returning just the remainder.
The remainder has the same sign as the first number.
If the quotient were computed, the quotient and remainder would satisfy $x = q2^k + r$ and $0 \leq |r| < 2^k$.
$$ f(x, k) = x - 2^k\operatorname{sgn}(x)\left \lfloor \frac{|x|}{2^k} \right \rfloor. $$
Unlike
mod_power_of_2
,
this function always returns zero or a number with the same sign as self
.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is pow
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::RemPowerOf2;
use malachite_nz::integer::Integer;
// 1 * 2^8 + 4 = 260
assert_eq!((&Integer::from(260)).rem_power_of_2(8), 4);
// -100 * 2^4 + -11 = -1611
assert_eq!((&Integer::from(-1611)).rem_power_of_2(4), -11);
type Output = Integer
sourceimpl RemPowerOf2 for Integer
impl RemPowerOf2 for Integer
sourcefn rem_power_of_2(self, pow: u64) -> Integer
fn rem_power_of_2(self, pow: u64) -> Integer
Divides an Integer
by $2^k$, taking it by value and returning just the remainder. The
remainder has the same sign as the first number.
If the quotient were computed, the quotient and remainder would satisfy $x = q2^k + r$ and $0 \leq |r| < 2^k$.
$$ f(x, k) = x - 2^k\operatorname{sgn}(x)\left \lfloor \frac{|x|}{2^k} \right \rfloor. $$
Unlike
mod_power_of_2
,
this function always returns zero or a number with the same sign as self
.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is pow
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::RemPowerOf2;
use malachite_nz::integer::Integer;
// 1 * 2^8 + 4 = 260
assert_eq!(Integer::from(260).rem_power_of_2(8), 4);
// -100 * 2^4 + -11 = -1611
assert_eq!(Integer::from(-1611).rem_power_of_2(4), -11);
type Output = Integer
sourceimpl RemPowerOf2Assign for Integer
impl RemPowerOf2Assign for Integer
sourcefn rem_power_of_2_assign(&mut self, pow: u64)
fn rem_power_of_2_assign(&mut self, pow: u64)
Divides an Integer
by $2^k$, replacing the Integer
by the remainder. The remainder
has the same sign as the Integer
.
If the quotient were computed, he quotient and remainder would satisfy $x = q2^k + r$ and $0 \leq r < 2^k$.
$$ x \gets x - 2^k\operatorname{sgn}(x)\left \lfloor \frac{|x|}{2^k} \right \rfloor. $$
Unlike mod_power_of_2_assign
, this function
does never changes the sign of self
, except possibly to set self
to 0.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is pow
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::RemPowerOf2Assign;
use malachite_nz::integer::Integer;
// 1 * 2^8 + 4 = 260
let mut x = Integer::from(260);
x.rem_power_of_2_assign(8);
assert_eq!(x, 4);
// -100 * 2^4 + -11 = -1611
let mut x = Integer::from(-1611);
x.rem_power_of_2_assign(4);
assert_eq!(x, -11);
sourceimpl<'a> RoundToMultiple<&'a Integer> for Integer
impl<'a> RoundToMultiple<&'a Integer> for Integer
sourcefn round_to_multiple(self, other: &'a Integer, rm: RoundingMode) -> Integer
fn round_to_multiple(self, other: &'a Integer, rm: RoundingMode) -> Integer
Rounds an Integer
to a multiple of another Integer
, according to a specified
rounding mode. The first Integer
is taken by value and the second by reference.
Let $q = \frac{x}{|y|}$:
$f(x, y, \mathrm{Down}) = \operatorname{sgn}(q) |y| \lfloor |q| \rfloor.$
$f(x, y, \mathrm{Up}) = \operatorname{sgn}(q) |y| \lceil |q| \rceil.$
$f(x, y, \mathrm{Floor}) = |y| \lfloor q \rfloor.$
$f(x, y, \mathrm{Ceiling}) = |y| \lceil q \rceil.$
$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
The following two expressions are equivalent:
x.round_to_multiple(other, RoundingMode::Exact)
{ assert!(x.divisible_by(other)); x }
but the latter should be used as it is clearer and more efficient.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
- If
rm
isExact
, butself
is not a multiple ofother
. - If
self
is nonzero,other
is zero, andrm
is trying to round away from zero.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(-5).round_to_multiple(&Integer::ZERO, RoundingMode::Down), 0);
assert_eq!(Integer::from(-10).round_to_multiple(&Integer::from(4), RoundingMode::Down), -8);
assert_eq!(Integer::from(-10).round_to_multiple(&Integer::from(4), RoundingMode::Up), -12);
assert_eq!(
Integer::from(-10).round_to_multiple(&Integer::from(5), RoundingMode::Exact),
-10);
assert_eq!(
Integer::from(-10).round_to_multiple(&Integer::from(3), RoundingMode::Nearest),
-9);
assert_eq!(
Integer::from(-20).round_to_multiple(&Integer::from(3), RoundingMode::Nearest),
-21);
assert_eq!(
Integer::from(-10).round_to_multiple(&Integer::from(4), RoundingMode::Nearest),
-8);
assert_eq!(
Integer::from(-14).round_to_multiple(&Integer::from(4), RoundingMode::Nearest),
-16
);
assert_eq!(
Integer::from(-10).round_to_multiple(&Integer::from(-4), RoundingMode::Down),
-8
);
assert_eq!(Integer::from(-10).round_to_multiple(&Integer::from(-4), RoundingMode::Up), -12);
assert_eq!(
Integer::from(-10).round_to_multiple(&Integer::from(-5), RoundingMode::Exact),
-10
);
assert_eq!(
Integer::from(-10).round_to_multiple(&Integer::from(-3), RoundingMode::Nearest),
-9
);
assert_eq!(
Integer::from(-20).round_to_multiple(&Integer::from(-3), RoundingMode::Nearest),
-21
);
assert_eq!(
Integer::from(-10).round_to_multiple(&Integer::from(-4), RoundingMode::Nearest),
-8
);
assert_eq!(
Integer::from(-14).round_to_multiple(&Integer::from(-4), RoundingMode::Nearest),
-16
);
type Output = Integer
sourceimpl<'a, 'b> RoundToMultiple<&'b Integer> for &'a Integer
impl<'a, 'b> RoundToMultiple<&'b Integer> for &'a Integer
sourcefn round_to_multiple(self, other: &'b Integer, rm: RoundingMode) -> Integer
fn round_to_multiple(self, other: &'b Integer, rm: RoundingMode) -> Integer
Rounds an Integer
to a multiple of another Integer
, according to a specified
rounding mode. Both Integer
s are taken by reference.
Let $q = \frac{x}{|y|}$:
$f(x, y, \mathrm{Down}) = \operatorname{sgn}(q) |y| \lfloor |q| \rfloor.$
$f(x, y, \mathrm{Up}) = \operatorname{sgn}(q) |y| \lceil |q| \rceil.$
$f(x, y, \mathrm{Floor}) = |y| \lfloor q \rfloor.$
$f(x, y, \mathrm{Ceiling}) = |y| \lceil q \rceil.$
$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
The following two expressions are equivalent:
x.round_to_multiple(other, RoundingMode::Exact)
{ assert!(x.divisible_by(other)); x }
but the latter should be used as it is clearer and more efficient.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
- If
rm
isExact
, butself
is not a multiple ofother
. - If
self
is nonzero,other
is zero, andrm
is trying to round away from zero.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
assert_eq!((&Integer::from(-5)).round_to_multiple(&Integer::ZERO, RoundingMode::Down), 0);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(&Integer::from(4), RoundingMode::Down),
-8
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(&Integer::from(4), RoundingMode::Up),
-12
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(&Integer::from(5), RoundingMode::Exact),
-10);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(&Integer::from(3), RoundingMode::Nearest),
-9);
assert_eq!(
(&Integer::from(-20)).round_to_multiple(&Integer::from(3), RoundingMode::Nearest),
-21);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(&Integer::from(4), RoundingMode::Nearest),
-8);
assert_eq!(
(&Integer::from(-14)).round_to_multiple(&Integer::from(4), RoundingMode::Nearest),
-16
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(&Integer::from(-4), RoundingMode::Down),
-8
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(&Integer::from(-4), RoundingMode::Up),
-12
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(&Integer::from(-5), RoundingMode::Exact),
-10
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(&Integer::from(-3), RoundingMode::Nearest),
-9
);
assert_eq!(
(&Integer::from(-20)).round_to_multiple(&Integer::from(-3), RoundingMode::Nearest),
-21
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(&Integer::from(-4), RoundingMode::Nearest),
-8
);
assert_eq!(
(&Integer::from(-14)).round_to_multiple(&Integer::from(-4), RoundingMode::Nearest),
-16
);
type Output = Integer
sourceimpl<'a> RoundToMultiple<Integer> for &'a Integer
impl<'a> RoundToMultiple<Integer> for &'a Integer
sourcefn round_to_multiple(self, other: Integer, rm: RoundingMode) -> Integer
fn round_to_multiple(self, other: Integer, rm: RoundingMode) -> Integer
Rounds an Integer
to a multiple of another Integer
, according to a specified
rounding mode. The first Integer
is taken by reference and the second by value.
Let $q = \frac{x}{|y|}$:
$f(x, y, \mathrm{Down}) = \operatorname{sgn}(q) |y| \lfloor |q| \rfloor.$
$f(x, y, \mathrm{Up}) = \operatorname{sgn}(q) |y| \lceil |q| \rceil.$
$f(x, y, \mathrm{Floor}) = |y| \lfloor q \rfloor.$
$f(x, y, \mathrm{Ceiling}) = |y| \lceil q \rceil.$
$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
The following two expressions are equivalent:
x.round_to_multiple(other, RoundingMode::Exact)
{ assert!(x.divisible_by(other)); x }
but the latter should be used as it is clearer and more efficient.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
- If
rm
isExact
, butself
is not a multiple ofother
. - If
self
is nonzero,other
is zero, andrm
is trying to round away from zero.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
assert_eq!((&Integer::from(-5)).round_to_multiple(Integer::ZERO, RoundingMode::Down), 0);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(Integer::from(4), RoundingMode::Down),
-8
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(Integer::from(4), RoundingMode::Up),
-12
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(Integer::from(5), RoundingMode::Exact),
-10);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(Integer::from(3), RoundingMode::Nearest),
-9);
assert_eq!(
(&Integer::from(-20)).round_to_multiple(Integer::from(3), RoundingMode::Nearest),
-21);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(Integer::from(4), RoundingMode::Nearest),
-8);
assert_eq!(
(&Integer::from(-14)).round_to_multiple(Integer::from(4), RoundingMode::Nearest),
-16
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(Integer::from(-4), RoundingMode::Down),
-8
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(Integer::from(-4), RoundingMode::Up),
-12
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(Integer::from(-5), RoundingMode::Exact),
-10
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(Integer::from(-3), RoundingMode::Nearest),
-9
);
assert_eq!(
(&Integer::from(-20)).round_to_multiple(Integer::from(-3), RoundingMode::Nearest),
-21
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple(Integer::from(-4), RoundingMode::Nearest),
-8
);
assert_eq!(
(&Integer::from(-14)).round_to_multiple(Integer::from(-4), RoundingMode::Nearest),
-16
);
type Output = Integer
sourceimpl RoundToMultiple<Integer> for Integer
impl RoundToMultiple<Integer> for Integer
sourcefn round_to_multiple(self, other: Integer, rm: RoundingMode) -> Integer
fn round_to_multiple(self, other: Integer, rm: RoundingMode) -> Integer
Rounds an Integer
to a multiple of another Integer
, according to a specified
rounding mode. Both Integer
s are taken by value.
Let $q = \frac{x}{|y|}$:
$f(x, y, \mathrm{Down}) = \operatorname{sgn}(q) |y| \lfloor |q| \rfloor.$
$f(x, y, \mathrm{Up}) = \operatorname{sgn}(q) |y| \lceil |q| \rceil.$
$f(x, y, \mathrm{Floor}) = |y| \lfloor q \rfloor.$
$f(x, y, \mathrm{Ceiling}) = |y| \lceil q \rceil.$
$$ f(x, y, \mathrm{Nearest}) = \begin{cases} y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ y \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ y \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, y, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
The following two expressions are equivalent:
x.round_to_multiple(other, RoundingMode::Exact)
{ assert!(x.divisible_by(other)); x }
but the latter should be used as it is clearer and more efficient.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
- If
rm
isExact
, butself
is not a multiple ofother
. - If
self
is nonzero,other
is zero, andrm
is trying to round away from zero.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::RoundToMultiple;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(-5).round_to_multiple(Integer::ZERO, RoundingMode::Down), 0);
assert_eq!(Integer::from(-10).round_to_multiple(Integer::from(4), RoundingMode::Down), -8);
assert_eq!(Integer::from(-10).round_to_multiple(Integer::from(4), RoundingMode::Up), -12);
assert_eq!(
Integer::from(-10).round_to_multiple(Integer::from(5), RoundingMode::Exact),
-10);
assert_eq!(
Integer::from(-10).round_to_multiple(Integer::from(3), RoundingMode::Nearest),
-9);
assert_eq!(
Integer::from(-20).round_to_multiple(Integer::from(3), RoundingMode::Nearest),
-21);
assert_eq!(
Integer::from(-10).round_to_multiple(Integer::from(4), RoundingMode::Nearest),
-8);
assert_eq!(
Integer::from(-14).round_to_multiple(Integer::from(4), RoundingMode::Nearest),
-16
);
assert_eq!(Integer::from(-10).round_to_multiple(Integer::from(-4), RoundingMode::Down), -8);
assert_eq!(Integer::from(-10).round_to_multiple(Integer::from(-4), RoundingMode::Up), -12);
assert_eq!(
Integer::from(-10).round_to_multiple(Integer::from(-5), RoundingMode::Exact),
-10
);
assert_eq!(
Integer::from(-10).round_to_multiple(Integer::from(-3), RoundingMode::Nearest),
-9
);
assert_eq!(
Integer::from(-20).round_to_multiple(Integer::from(-3), RoundingMode::Nearest),
-21
);
assert_eq!(
Integer::from(-10).round_to_multiple(Integer::from(-4), RoundingMode::Nearest),
-8
);
assert_eq!(
Integer::from(-14).round_to_multiple(Integer::from(-4), RoundingMode::Nearest),
-16
);
type Output = Integer
sourceimpl<'a> RoundToMultipleAssign<&'a Integer> for Integer
impl<'a> RoundToMultipleAssign<&'a Integer> for Integer
sourcefn round_to_multiple_assign(&mut self, other: &'a Integer, rm: RoundingMode)
fn round_to_multiple_assign(&mut self, other: &'a Integer, rm: RoundingMode)
Rounds an Integer
to a multiple of another Integer
in place, according to a
specified rounding mode. The Integer
on the right-hand side is taken by reference.
See the RoundToMultiple
documentation for details.
The following two expressions are equivalent:
x.round_to_multiple_assign(other, RoundingMode::Exact);
assert!(x.divisible_by(other));
but the latter should be used as it is clearer and more efficient.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
- If
rm
isExact
, butself
is not a multiple ofother
. - If
self
is nonzero,other
is zero, andrm
is trying to round away from zero.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::RoundToMultipleAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
let mut x = Integer::from(-5);
x.round_to_multiple_assign(&Integer::ZERO, RoundingMode::Down);
assert_eq!(x, 0);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(&Integer::from(4), RoundingMode::Down);
assert_eq!(x, -8);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(&Integer::from(4), RoundingMode::Up);
assert_eq!(x, -12);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(&Integer::from(5), RoundingMode::Exact);
assert_eq!(x, -10);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(&Integer::from(3), RoundingMode::Nearest);
assert_eq!(x, -9);
let mut x = Integer::from(-20);
x.round_to_multiple_assign(&Integer::from(3), RoundingMode::Nearest);
assert_eq!(x, -21);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(&Integer::from(4), RoundingMode::Nearest);
assert_eq!(x, -8);
let mut x = Integer::from(-14);
x.round_to_multiple_assign(&Integer::from(4), RoundingMode::Nearest);
assert_eq!(x, -16);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(&Integer::from(-4), RoundingMode::Down);
assert_eq!(x, -8);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(&Integer::from(-4), RoundingMode::Up);
assert_eq!(x, -12);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(&Integer::from(-5), RoundingMode::Exact);
assert_eq!(x, -10);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(&Integer::from(-3), RoundingMode::Nearest);
assert_eq!(x, -9);
let mut x = Integer::from(-20);
x.round_to_multiple_assign(&Integer::from(-3), RoundingMode::Nearest);
assert_eq!(x, -21);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(&Integer::from(-4), RoundingMode::Nearest);
assert_eq!(x, -8);
let mut x = Integer::from(-14);
x.round_to_multiple_assign(&Integer::from(-4), RoundingMode::Nearest);
assert_eq!(x, -16);
sourceimpl RoundToMultipleAssign<Integer> for Integer
impl RoundToMultipleAssign<Integer> for Integer
sourcefn round_to_multiple_assign(&mut self, other: Integer, rm: RoundingMode)
fn round_to_multiple_assign(&mut self, other: Integer, rm: RoundingMode)
Rounds an Integer
to a multiple of another Integer
in place, according to a
specified rounding mode. The Integer
on the right-hand side is taken by value.
See the RoundToMultiple
documentation for details.
The following two expressions are equivalent:
x.round_to_multiple_assign(other, RoundingMode::Exact);
assert!(x.divisible_by(other));
but the latter should be used as it is clearer and more efficient.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
- If
rm
isExact
, butself
is not a multiple ofother
. - If
self
is nonzero,other
is zero, andrm
is trying to round away from zero.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::RoundToMultipleAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
let mut x = Integer::from(-5);
x.round_to_multiple_assign(Integer::ZERO, RoundingMode::Down);
assert_eq!(x, 0);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(Integer::from(4), RoundingMode::Down);
assert_eq!(x, -8);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(Integer::from(4), RoundingMode::Up);
assert_eq!(x, -12);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(Integer::from(5), RoundingMode::Exact);
assert_eq!(x, -10);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(Integer::from(3), RoundingMode::Nearest);
assert_eq!(x, -9);
let mut x = Integer::from(-20);
x.round_to_multiple_assign(Integer::from(3), RoundingMode::Nearest);
assert_eq!(x, -21);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(Integer::from(4), RoundingMode::Nearest);
assert_eq!(x, -8);
let mut x = Integer::from(-14);
x.round_to_multiple_assign(Integer::from(4), RoundingMode::Nearest);
assert_eq!(x, -16);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(Integer::from(-4), RoundingMode::Down);
assert_eq!(x, -8);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(Integer::from(-4), RoundingMode::Up);
assert_eq!(x, -12);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(Integer::from(-5), RoundingMode::Exact);
assert_eq!(x, -10);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(Integer::from(-3), RoundingMode::Nearest);
assert_eq!(x, -9);
let mut x = Integer::from(-20);
x.round_to_multiple_assign(Integer::from(-3), RoundingMode::Nearest);
assert_eq!(x, -21);
let mut x = Integer::from(-10);
x.round_to_multiple_assign(Integer::from(-4), RoundingMode::Nearest);
assert_eq!(x, -8);
let mut x = Integer::from(-14);
x.round_to_multiple_assign(Integer::from(-4), RoundingMode::Nearest);
assert_eq!(x, -16);
sourceimpl<'a> RoundToMultipleOfPowerOf2<u64> for &'a Integer
impl<'a> RoundToMultipleOfPowerOf2<u64> for &'a Integer
sourcefn round_to_multiple_of_power_of_2(self, pow: u64, rm: RoundingMode) -> Integer
fn round_to_multiple_of_power_of_2(self, pow: u64, rm: RoundingMode) -> Integer
Rounds an Integer
to a multiple of $2^k$ according to a specified rounding mode. The
Integer
is taken by reference.
Let $q = \frac{x}{2^k}$:
$f(x, k, \mathrm{Down}) = 2^k \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, k, \mathrm{Up}) = 2^k \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, k, \mathrm{Floor}) = 2^k \lfloor q \rfloor.$
$f(x, k, \mathrm{Ceiling}) = 2^k \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, k, \mathrm{Exact}) = 2^k q$, but panics if $q \notin \Z$.
The following two expressions are equivalent:
x.round_to_multiple_of_power_of_2(pow, RoundingMode::Exact)
{ assert!(x.divisible_by_power_of_2(pow)); x }
but the latter should be used as it is clearer and more efficient.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), pow / Limb::WIDTH)
.
Panics
Panics if rm
is Exact
, but self
is not a multiple of the power of 2.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
assert_eq!(
(&Integer::from(10)).round_to_multiple_of_power_of_2(2, RoundingMode::Floor),
8
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple_of_power_of_2(2, RoundingMode::Ceiling),
-8
);
assert_eq!(
(&Integer::from(10)).round_to_multiple_of_power_of_2(2, RoundingMode::Down),
8
);
assert_eq!(
(&Integer::from(-10)).round_to_multiple_of_power_of_2(2, RoundingMode::Up),
-12
);
assert_eq!(
(&Integer::from(10)).round_to_multiple_of_power_of_2(2, RoundingMode::Nearest),
8
);
assert_eq!(
(&Integer::from(-12)).round_to_multiple_of_power_of_2(2, RoundingMode::Exact),
-12
);
type Output = Integer
sourceimpl RoundToMultipleOfPowerOf2<u64> for Integer
impl RoundToMultipleOfPowerOf2<u64> for Integer
sourcefn round_to_multiple_of_power_of_2(self, pow: u64, rm: RoundingMode) -> Integer
fn round_to_multiple_of_power_of_2(self, pow: u64, rm: RoundingMode) -> Integer
Rounds an Integer
to a multiple of $2^k$ according to a specified rounding mode. The
Integer
is taken by value.
Let $q = \frac{x}{2^k}$:
$f(x, k, \mathrm{Down}) = 2^k \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, k, \mathrm{Up}) = 2^k \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, k, \mathrm{Floor}) = 2^k \lfloor q \rfloor.$
$f(x, k, \mathrm{Ceiling}) = 2^k \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2} \\ 2^k \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even} \\ 2^k \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd.} \end{cases} $$
$f(x, k, \mathrm{Exact}) = 2^k q$, but panics if $q \notin \Z$.
The following two expressions are equivalent:
x.round_to_multiple_of_power_of_2(pow, RoundingMode::Exact)
{ assert!(x.divisible_by_power_of_2(pow)); x }
but the latter should be used as it is clearer and more efficient.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), pow / Limb::WIDTH)
.
Panics
Panics if rm
is Exact
, but self
is not a multiple of the power of 2.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(10).round_to_multiple_of_power_of_2(2, RoundingMode::Floor), 8);
assert_eq!(
Integer::from(-10).round_to_multiple_of_power_of_2(2, RoundingMode::Ceiling),
-8
);
assert_eq!(Integer::from(10).round_to_multiple_of_power_of_2(2, RoundingMode::Down), 8);
assert_eq!(Integer::from(-10).round_to_multiple_of_power_of_2(2, RoundingMode::Up), -12);
assert_eq!(
Integer::from(10).round_to_multiple_of_power_of_2(2, RoundingMode::Nearest),
8
);
assert_eq!(
Integer::from(-12).round_to_multiple_of_power_of_2(2, RoundingMode::Exact),
-12
);
type Output = Integer
sourceimpl RoundToMultipleOfPowerOf2Assign<u64> for Integer
impl RoundToMultipleOfPowerOf2Assign<u64> for Integer
sourcefn round_to_multiple_of_power_of_2_assign(&mut self, pow: u64, rm: RoundingMode)
fn round_to_multiple_of_power_of_2_assign(&mut self, pow: u64, rm: RoundingMode)
Rounds an Integer
to a multiple of $2^k$ in place, according to a specified rounding
mode.
See the RoundToMultipleOfPowerOf2
documentation for details.
The following two expressions are equivalent:
x.round_to_multiple_of_power_of_2_assign(pow, RoundingMode::Exact);
assert!(x.divisible_by_power_of_2(pow));
but the latter should be used as it is clearer and more efficient.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), pow / Limb::WIDTH)
.
Panics
Panics if rm
is Exact
, but self
is not a multiple of the power of 2.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::RoundToMultipleOfPowerOf2Assign;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
let mut n = Integer::from(10);
n.round_to_multiple_of_power_of_2_assign(2, RoundingMode::Floor);
assert_eq!(n, 8);
let mut n = Integer::from(-10);
n.round_to_multiple_of_power_of_2_assign(2, RoundingMode::Ceiling);
assert_eq!(n, -8);
let mut n = Integer::from(10);
n.round_to_multiple_of_power_of_2_assign(2, RoundingMode::Down);
assert_eq!(n, 8);
let mut n = Integer::from(-10);
n.round_to_multiple_of_power_of_2_assign(2, RoundingMode::Up);
assert_eq!(n, -12);
let mut n = Integer::from(10);
n.round_to_multiple_of_power_of_2_assign(2, RoundingMode::Nearest);
assert_eq!(n, 8);
let mut n = Integer::from(-12);
n.round_to_multiple_of_power_of_2_assign(2, RoundingMode::Exact);
assert_eq!(n, -12);
sourceimpl<'a> RoundingFrom<&'a Integer> for f32
impl<'a> RoundingFrom<&'a Integer> for f32
sourcefn rounding_from(value: &'a Integer, rm: RoundingMode) -> f32
fn rounding_from(value: &'a Integer, rm: RoundingMode) -> f32
Converts an Integer
to a primitive float according to a specified
RoundingMode
.
- If the rounding mode is
Floor
the largest float less than or equal to theInteger
is returned. If theInteger
is greater than the maximum finite float, then the maximum finite float is returned. If it is smaller than the minimum finite float, then negative infinity is returned. - If the rounding mode is
Ceiling
, the smallest float greater than or equal to theInteger
is returned. If theInteger
is greater than the maximum finite float, then positive infinity is returned. If it is smaller than the minimum finite float, then the minimum finite float is returned. - If the rounding mode is
Down
, then the rounding proceeds as withFloor
if theInteger
is non-negative and as withCeiling
if theInteger
is negative. - If the rounding mode is
Up
, then the rounding proceeds as withCeiling
if theInteger
is non-negative and as withFloor
if theInteger
is negative. - If the rounding mode is
Nearest
, then the nearest float is returned. If theInteger
is exactly between two floats, the float with the zero least-significant bit in its representation is selected. If theInteger
is greater than the maximum finite float, then the maximum finite float is returned.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Panics
Panics if the rounding mode is Exact
and value
cannot be represented exactly.
Examples
See here.
sourceimpl<'a> RoundingFrom<&'a Integer> for f64
impl<'a> RoundingFrom<&'a Integer> for f64
sourcefn rounding_from(value: &'a Integer, rm: RoundingMode) -> f64
fn rounding_from(value: &'a Integer, rm: RoundingMode) -> f64
Converts an Integer
to a primitive float according to a specified
RoundingMode
.
- If the rounding mode is
Floor
the largest float less than or equal to theInteger
is returned. If theInteger
is greater than the maximum finite float, then the maximum finite float is returned. If it is smaller than the minimum finite float, then negative infinity is returned. - If the rounding mode is
Ceiling
, the smallest float greater than or equal to theInteger
is returned. If theInteger
is greater than the maximum finite float, then positive infinity is returned. If it is smaller than the minimum finite float, then the minimum finite float is returned. - If the rounding mode is
Down
, then the rounding proceeds as withFloor
if theInteger
is non-negative and as withCeiling
if theInteger
is negative. - If the rounding mode is
Up
, then the rounding proceeds as withCeiling
if theInteger
is non-negative and as withFloor
if theInteger
is negative. - If the rounding mode is
Nearest
, then the nearest float is returned. If theInteger
is exactly between two floats, the float with the zero least-significant bit in its representation is selected. If theInteger
is greater than the maximum finite float, then the maximum finite float is returned.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is value.significant_bits()
.
Panics
Panics if the rounding mode is Exact
and value
cannot be represented exactly.
Examples
See here.
sourceimpl RoundingFrom<f32> for Integer
impl RoundingFrom<f32> for Integer
sourcefn rounding_from(value: f32, rm: RoundingMode) -> Self
fn rounding_from(value: f32, rm: RoundingMode) -> Self
Converts a primitive float to an Integer
, using the specified rounding mode.
The floating-point value cannot be NaN or infinite.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.sci_exponent()
.
Panics
Panics if value
is NaN or infinite or if the rounding mode is Exact
and value
is not an integer.
Examples
See here.
sourceimpl RoundingFrom<f64> for Integer
impl RoundingFrom<f64> for Integer
sourcefn rounding_from(value: f64, rm: RoundingMode) -> Self
fn rounding_from(value: f64, rm: RoundingMode) -> Self
Converts a primitive float to an Integer
, using the specified rounding mode.
The floating-point value cannot be NaN or infinite.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is value.sci_exponent()
.
Panics
Panics if value
is NaN or infinite or if the rounding mode is Exact
and value
is not an integer.
Examples
See here.
sourceimpl<'a> SaturatingFrom<&'a Integer> for Natural
impl<'a> SaturatingFrom<&'a Integer> for Natural
sourcefn saturating_from(value: &'a Integer) -> Natural
fn saturating_from(value: &'a Integer) -> Natural
Converts an Integer
to a Natural
, taking the Natural
by reference. If the
Integer
is negative, 0 is returned.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::SaturatingFrom;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
assert_eq!(Natural::saturating_from(&Integer::from(123)), 123);
assert_eq!(Natural::saturating_from(&Integer::from(-123)), 0);
assert_eq!(Natural::saturating_from(&Integer::from(10u32).pow(12)), 1000000000000u64);
assert_eq!(Natural::saturating_from(&-Integer::from(10u32).pow(12)), 0);
sourceimpl<'a> SaturatingFrom<&'a Integer> for i128
impl<'a> SaturatingFrom<&'a Integer> for i128
sourcefn saturating_from(value: &Integer) -> i128
fn saturating_from(value: &Integer) -> i128
Converts an Integer
to a signed primitive integer.
If the Integer
cannot be represented by the output type, then either the
maximum or the minimum representable value is returned, whichever is closer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> SaturatingFrom<&'a Integer> for i16
impl<'a> SaturatingFrom<&'a Integer> for i16
sourcefn saturating_from(value: &Integer) -> i16
fn saturating_from(value: &Integer) -> i16
Converts an Integer
to a signed primitive integer.
If the Integer
cannot be represented by the output type, then either the
maximum or the minimum representable value is returned, whichever is closer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> SaturatingFrom<&'a Integer> for i32
impl<'a> SaturatingFrom<&'a Integer> for i32
sourcefn saturating_from(value: &Integer) -> i32
fn saturating_from(value: &Integer) -> i32
Converts an Integer
to a signed primitive integer.
If the Integer
cannot be represented by the output type, then either the
maximum or the minimum representable value is returned, whichever is closer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> SaturatingFrom<&'a Integer> for i64
impl<'a> SaturatingFrom<&'a Integer> for i64
sourcefn saturating_from(value: &Integer) -> i64
fn saturating_from(value: &Integer) -> i64
Converts an Integer
to a signed primitive integer.
If the Integer
cannot be represented by the output type, then either the
maximum or the minimum representable value is returned, whichever is closer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> SaturatingFrom<&'a Integer> for i8
impl<'a> SaturatingFrom<&'a Integer> for i8
sourcefn saturating_from(value: &Integer) -> i8
fn saturating_from(value: &Integer) -> i8
Converts an Integer
to a signed primitive integer.
If the Integer
cannot be represented by the output type, then either the
maximum or the minimum representable value is returned, whichever is closer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> SaturatingFrom<&'a Integer> for isize
impl<'a> SaturatingFrom<&'a Integer> for isize
sourcefn saturating_from(value: &Integer) -> isize
fn saturating_from(value: &Integer) -> isize
Converts an Integer
to a signed primitive integer.
If the Integer
cannot be represented by the output type, then either the
maximum or the minimum representable value is returned, whichever is closer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> SaturatingFrom<&'a Integer> for u128
impl<'a> SaturatingFrom<&'a Integer> for u128
sourcefn saturating_from(value: &Integer) -> u128
fn saturating_from(value: &Integer) -> u128
Converts an Integer
to an unsigned primitive integer.
If the Integer
cannot be represented by the output type, then either zero or
the maximum representable value is returned, whichever is closer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> SaturatingFrom<&'a Integer> for u16
impl<'a> SaturatingFrom<&'a Integer> for u16
sourcefn saturating_from(value: &Integer) -> u16
fn saturating_from(value: &Integer) -> u16
Converts an Integer
to an unsigned primitive integer.
If the Integer
cannot be represented by the output type, then either zero or
the maximum representable value is returned, whichever is closer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> SaturatingFrom<&'a Integer> for u32
impl<'a> SaturatingFrom<&'a Integer> for u32
sourcefn saturating_from(value: &Integer) -> u32
fn saturating_from(value: &Integer) -> u32
Converts an Integer
to an unsigned primitive integer.
If the Integer
cannot be represented by the output type, then either zero or
the maximum representable value is returned, whichever is closer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> SaturatingFrom<&'a Integer> for u64
impl<'a> SaturatingFrom<&'a Integer> for u64
sourcefn saturating_from(value: &Integer) -> u64
fn saturating_from(value: &Integer) -> u64
Converts an Integer
to an unsigned primitive integer.
If the Integer
cannot be represented by the output type, then either zero or
the maximum representable value is returned, whichever is closer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> SaturatingFrom<&'a Integer> for u8
impl<'a> SaturatingFrom<&'a Integer> for u8
sourcefn saturating_from(value: &Integer) -> u8
fn saturating_from(value: &Integer) -> u8
Converts an Integer
to an unsigned primitive integer.
If the Integer
cannot be represented by the output type, then either zero or
the maximum representable value is returned, whichever is closer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> SaturatingFrom<&'a Integer> for usize
impl<'a> SaturatingFrom<&'a Integer> for usize
sourcefn saturating_from(value: &Integer) -> usize
fn saturating_from(value: &Integer) -> usize
Converts an Integer
to an unsigned primitive integer.
If the Integer
cannot be represented by the output type, then either zero or
the maximum representable value is returned, whichever is closer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl SaturatingFrom<Integer> for Natural
impl SaturatingFrom<Integer> for Natural
sourcefn saturating_from(value: Integer) -> Natural
fn saturating_from(value: Integer) -> Natural
Converts an Integer
to a Natural
, taking the Natural
by value. If the
Integer
is negative, 0 is returned.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::conversion::traits::SaturatingFrom;
use malachite_nz::integer::Integer;
use malachite_nz::natural::Natural;
assert_eq!(Natural::saturating_from(Integer::from(123)), 123);
assert_eq!(Natural::saturating_from(Integer::from(-123)), 0);
assert_eq!(Natural::saturating_from(Integer::from(10u32).pow(12)), 1000000000000u64);
assert_eq!(Natural::saturating_from(-Integer::from(10u32).pow(12)), 0);
sourceimpl<'a> Shl<i128> for &'a Integer
impl<'a> Shl<i128> for &'a Integer
sourcefn shl(self, bits: i128) -> Integer
fn shl(self, bits: i128) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), taking it by reference.
$$ f(x, k) = \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl Shl<i128> for Integer
impl Shl<i128> for Integer
sourcefn shl(self, bits: i128) -> Integer
fn shl(self, bits: i128) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), taking it by value.
$$ f(x, k) = \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl<'a> Shl<i16> for &'a Integer
impl<'a> Shl<i16> for &'a Integer
sourcefn shl(self, bits: i16) -> Integer
fn shl(self, bits: i16) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), taking it by reference.
$$ f(x, k) = \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl Shl<i16> for Integer
impl Shl<i16> for Integer
sourcefn shl(self, bits: i16) -> Integer
fn shl(self, bits: i16) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), taking it by value.
$$ f(x, k) = \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl<'a> Shl<i32> for &'a Integer
impl<'a> Shl<i32> for &'a Integer
sourcefn shl(self, bits: i32) -> Integer
fn shl(self, bits: i32) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), taking it by reference.
$$ f(x, k) = \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl Shl<i32> for Integer
impl Shl<i32> for Integer
sourcefn shl(self, bits: i32) -> Integer
fn shl(self, bits: i32) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), taking it by value.
$$ f(x, k) = \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl<'a> Shl<i64> for &'a Integer
impl<'a> Shl<i64> for &'a Integer
sourcefn shl(self, bits: i64) -> Integer
fn shl(self, bits: i64) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), taking it by reference.
$$ f(x, k) = \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl Shl<i64> for Integer
impl Shl<i64> for Integer
sourcefn shl(self, bits: i64) -> Integer
fn shl(self, bits: i64) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), taking it by value.
$$ f(x, k) = \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl<'a> Shl<i8> for &'a Integer
impl<'a> Shl<i8> for &'a Integer
sourcefn shl(self, bits: i8) -> Integer
fn shl(self, bits: i8) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), taking it by reference.
$$ f(x, k) = \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl Shl<i8> for Integer
impl Shl<i8> for Integer
sourcefn shl(self, bits: i8) -> Integer
fn shl(self, bits: i8) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), taking it by value.
$$ f(x, k) = \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl<'a> Shl<isize> for &'a Integer
impl<'a> Shl<isize> for &'a Integer
sourcefn shl(self, bits: isize) -> Integer
fn shl(self, bits: isize) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), taking it by reference.
$$ f(x, k) = \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl Shl<isize> for Integer
impl Shl<isize> for Integer
sourcefn shl(self, bits: isize) -> Integer
fn shl(self, bits: isize) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), taking it by value.
$$ f(x, k) = \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl<'a> Shl<u128> for &'a Integer
impl<'a> Shl<u128> for &'a Integer
sourcefn shl(self, bits: u128) -> Integer
fn shl(self, bits: u128) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2), taking it by reference.
$$ f(x, k) = x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl Shl<u128> for Integer
impl Shl<u128> for Integer
sourcefn shl(self, bits: u128) -> Integer
fn shl(self, bits: u128) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2), taking it by value.
$$ f(x, k) = x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl<'a> Shl<u16> for &'a Integer
impl<'a> Shl<u16> for &'a Integer
sourcefn shl(self, bits: u16) -> Integer
fn shl(self, bits: u16) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2), taking it by reference.
$$ f(x, k) = x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl Shl<u16> for Integer
impl Shl<u16> for Integer
sourcefn shl(self, bits: u16) -> Integer
fn shl(self, bits: u16) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2), taking it by value.
$$ f(x, k) = x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl<'a> Shl<u32> for &'a Integer
impl<'a> Shl<u32> for &'a Integer
sourcefn shl(self, bits: u32) -> Integer
fn shl(self, bits: u32) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2), taking it by reference.
$$ f(x, k) = x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl Shl<u32> for Integer
impl Shl<u32> for Integer
sourcefn shl(self, bits: u32) -> Integer
fn shl(self, bits: u32) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2), taking it by value.
$$ f(x, k) = x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl<'a> Shl<u64> for &'a Integer
impl<'a> Shl<u64> for &'a Integer
sourcefn shl(self, bits: u64) -> Integer
fn shl(self, bits: u64) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2), taking it by reference.
$$ f(x, k) = x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl Shl<u64> for Integer
impl Shl<u64> for Integer
sourcefn shl(self, bits: u64) -> Integer
fn shl(self, bits: u64) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2), taking it by value.
$$ f(x, k) = x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl<'a> Shl<u8> for &'a Integer
impl<'a> Shl<u8> for &'a Integer
sourcefn shl(self, bits: u8) -> Integer
fn shl(self, bits: u8) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2), taking it by reference.
$$ f(x, k) = x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl Shl<u8> for Integer
impl Shl<u8> for Integer
sourcefn shl(self, bits: u8) -> Integer
fn shl(self, bits: u8) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2), taking it by value.
$$ f(x, k) = x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl<'a> Shl<usize> for &'a Integer
impl<'a> Shl<usize> for &'a Integer
sourcefn shl(self, bits: usize) -> Integer
fn shl(self, bits: usize) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2), taking it by reference.
$$ f(x, k) = x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl Shl<usize> for Integer
impl Shl<usize> for Integer
sourcefn shl(self, bits: usize) -> Integer
fn shl(self, bits: usize) -> Integer
Left-shifts an Integer
(multiplies it by a power of 2), taking it by value.
$$ f(x, k) = x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl ShlAssign<i128> for Integer
impl ShlAssign<i128> for Integer
sourcefn shl_assign(&mut self, bits: i128)
fn shl_assign(&mut self, bits: i128)
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), in place.
$$ x \gets \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl ShlAssign<i16> for Integer
impl ShlAssign<i16> for Integer
sourcefn shl_assign(&mut self, bits: i16)
fn shl_assign(&mut self, bits: i16)
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), in place.
$$ x \gets \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl ShlAssign<i32> for Integer
impl ShlAssign<i32> for Integer
sourcefn shl_assign(&mut self, bits: i32)
fn shl_assign(&mut self, bits: i32)
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), in place.
$$ x \gets \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl ShlAssign<i64> for Integer
impl ShlAssign<i64> for Integer
sourcefn shl_assign(&mut self, bits: i64)
fn shl_assign(&mut self, bits: i64)
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), in place.
$$ x \gets \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl ShlAssign<i8> for Integer
impl ShlAssign<i8> for Integer
sourcefn shl_assign(&mut self, bits: i8)
fn shl_assign(&mut self, bits: i8)
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), in place.
$$ x \gets \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl ShlAssign<isize> for Integer
impl ShlAssign<isize> for Integer
sourcefn shl_assign(&mut self, bits: isize)
fn shl_assign(&mut self, bits: isize)
Left-shifts an Integer
(multiplies it by a power of 2 or divides it by a power
of 2 and takes the floor), in place.
$$ x \gets \lfloor x2^k \rfloor. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl ShlAssign<u128> for Integer
impl ShlAssign<u128> for Integer
sourcefn shl_assign(&mut self, bits: u128)
fn shl_assign(&mut self, bits: u128)
Left-shifts an Integer
(multiplies it by a power of 2), in place.
$$ x \gets x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl ShlAssign<u16> for Integer
impl ShlAssign<u16> for Integer
sourcefn shl_assign(&mut self, bits: u16)
fn shl_assign(&mut self, bits: u16)
Left-shifts an Integer
(multiplies it by a power of 2), in place.
$$ x \gets x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl ShlAssign<u32> for Integer
impl ShlAssign<u32> for Integer
sourcefn shl_assign(&mut self, bits: u32)
fn shl_assign(&mut self, bits: u32)
Left-shifts an Integer
(multiplies it by a power of 2), in place.
$$ x \gets x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl ShlAssign<u64> for Integer
impl ShlAssign<u64> for Integer
sourcefn shl_assign(&mut self, bits: u64)
fn shl_assign(&mut self, bits: u64)
Left-shifts an Integer
(multiplies it by a power of 2), in place.
$$ x \gets x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl ShlAssign<u8> for Integer
impl ShlAssign<u8> for Integer
sourcefn shl_assign(&mut self, bits: u8)
fn shl_assign(&mut self, bits: u8)
Left-shifts an Integer
(multiplies it by a power of 2), in place.
$$ x \gets x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl ShlAssign<usize> for Integer
impl ShlAssign<usize> for Integer
sourcefn shl_assign(&mut self, bits: usize)
fn shl_assign(&mut self, bits: usize)
Left-shifts an Integer
(multiplies it by a power of 2), in place.
$$ x \gets x2^k. $$
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is bits
.
Examples
See here.
sourceimpl<'a> ShlRound<i128> for &'a Integer
impl<'a> ShlRound<i128> for &'a Integer
sourcefn shl_round(self, bits: i128, rm: RoundingMode) -> Integer
fn shl_round(self, bits: i128, rm: RoundingMode) -> Integer
Left-shifts an Integer
(multiplies or divides it by a power of 2), taking it by
reference, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be necessary
if bits
is negative.
Let $q = x2^k$:
$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is negative and rm
is RoundingMode::Exact
but
self
is not divisible by $2^{-k}$.
Examples
See here.
type Output = Integer
sourceimpl ShlRound<i128> for Integer
impl ShlRound<i128> for Integer
sourcefn shl_round(self, bits: i128, rm: RoundingMode) -> Integer
fn shl_round(self, bits: i128, rm: RoundingMode) -> Integer
Left-shifts an Integer
(multiplies or divides it by a power of 2), taking it by
value, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be necessary
if bits
is negative.
Let $q = x2^k$:
$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is negative and rm
is RoundingMode::Exact
but
self
is not divisible by $2^{-k}$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShlRound<i16> for &'a Integer
impl<'a> ShlRound<i16> for &'a Integer
sourcefn shl_round(self, bits: i16, rm: RoundingMode) -> Integer
fn shl_round(self, bits: i16, rm: RoundingMode) -> Integer
Left-shifts an Integer
(multiplies or divides it by a power of 2), taking it by
reference, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be necessary
if bits
is negative.
Let $q = x2^k$:
$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is negative and rm
is RoundingMode::Exact
but
self
is not divisible by $2^{-k}$.
Examples
See here.
type Output = Integer
sourceimpl ShlRound<i16> for Integer
impl ShlRound<i16> for Integer
sourcefn shl_round(self, bits: i16, rm: RoundingMode) -> Integer
fn shl_round(self, bits: i16, rm: RoundingMode) -> Integer
Left-shifts an Integer
(multiplies or divides it by a power of 2), taking it by
value, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be necessary
if bits
is negative.
Let $q = x2^k$:
$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is negative and rm
is RoundingMode::Exact
but
self
is not divisible by $2^{-k}$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShlRound<i32> for &'a Integer
impl<'a> ShlRound<i32> for &'a Integer
sourcefn shl_round(self, bits: i32, rm: RoundingMode) -> Integer
fn shl_round(self, bits: i32, rm: RoundingMode) -> Integer
Left-shifts an Integer
(multiplies or divides it by a power of 2), taking it by
reference, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be necessary
if bits
is negative.
Let $q = x2^k$:
$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is negative and rm
is RoundingMode::Exact
but
self
is not divisible by $2^{-k}$.
Examples
See here.
type Output = Integer
sourceimpl ShlRound<i32> for Integer
impl ShlRound<i32> for Integer
sourcefn shl_round(self, bits: i32, rm: RoundingMode) -> Integer
fn shl_round(self, bits: i32, rm: RoundingMode) -> Integer
Left-shifts an Integer
(multiplies or divides it by a power of 2), taking it by
value, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be necessary
if bits
is negative.
Let $q = x2^k$:
$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is negative and rm
is RoundingMode::Exact
but
self
is not divisible by $2^{-k}$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShlRound<i64> for &'a Integer
impl<'a> ShlRound<i64> for &'a Integer
sourcefn shl_round(self, bits: i64, rm: RoundingMode) -> Integer
fn shl_round(self, bits: i64, rm: RoundingMode) -> Integer
Left-shifts an Integer
(multiplies or divides it by a power of 2), taking it by
reference, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be necessary
if bits
is negative.
Let $q = x2^k$:
$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is negative and rm
is RoundingMode::Exact
but
self
is not divisible by $2^{-k}$.
Examples
See here.
type Output = Integer
sourceimpl ShlRound<i64> for Integer
impl ShlRound<i64> for Integer
sourcefn shl_round(self, bits: i64, rm: RoundingMode) -> Integer
fn shl_round(self, bits: i64, rm: RoundingMode) -> Integer
Left-shifts an Integer
(multiplies or divides it by a power of 2), taking it by
value, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be necessary
if bits
is negative.
Let $q = x2^k$:
$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is negative and rm
is RoundingMode::Exact
but
self
is not divisible by $2^{-k}$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShlRound<i8> for &'a Integer
impl<'a> ShlRound<i8> for &'a Integer
sourcefn shl_round(self, bits: i8, rm: RoundingMode) -> Integer
fn shl_round(self, bits: i8, rm: RoundingMode) -> Integer
Left-shifts an Integer
(multiplies or divides it by a power of 2), taking it by
reference, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be necessary
if bits
is negative.
Let $q = x2^k$:
$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is negative and rm
is RoundingMode::Exact
but
self
is not divisible by $2^{-k}$.
Examples
See here.
type Output = Integer
sourceimpl ShlRound<i8> for Integer
impl ShlRound<i8> for Integer
sourcefn shl_round(self, bits: i8, rm: RoundingMode) -> Integer
fn shl_round(self, bits: i8, rm: RoundingMode) -> Integer
Left-shifts an Integer
(multiplies or divides it by a power of 2), taking it by
value, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be necessary
if bits
is negative.
Let $q = x2^k$:
$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is negative and rm
is RoundingMode::Exact
but
self
is not divisible by $2^{-k}$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShlRound<isize> for &'a Integer
impl<'a> ShlRound<isize> for &'a Integer
sourcefn shl_round(self, bits: isize, rm: RoundingMode) -> Integer
fn shl_round(self, bits: isize, rm: RoundingMode) -> Integer
Left-shifts an Integer
(multiplies or divides it by a power of 2), taking it by
reference, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be necessary
if bits
is negative.
Let $q = x2^k$:
$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is negative and rm
is RoundingMode::Exact
but
self
is not divisible by $2^{-k}$.
Examples
See here.
type Output = Integer
sourceimpl ShlRound<isize> for Integer
impl ShlRound<isize> for Integer
sourcefn shl_round(self, bits: isize, rm: RoundingMode) -> Integer
fn shl_round(self, bits: isize, rm: RoundingMode) -> Integer
Left-shifts an Integer
(multiplies or divides it by a power of 2), taking it by
value, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be necessary
if bits
is negative.
Let $q = x2^k$:
$f(x, k, \mathrm{Down}) = f(x, y, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, k, \mathrm{Up}) = f(x, y, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, k, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, k, \mathrm{Exact}) = q$, but panics if $q \notin \N$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is negative and rm
is RoundingMode::Exact
but
self
is not divisible by $2^{-k}$.
Examples
See here.
type Output = Integer
sourceimpl ShlRoundAssign<i128> for Integer
impl ShlRoundAssign<i128> for Integer
sourcefn shl_round_assign(&mut self, bits: i128, rm: RoundingMode)
fn shl_round_assign(&mut self, bits: i128, rm: RoundingMode)
Left-shifts an Integer
(multiplies or divides it by a power of 2) and rounds
according to the specified rounding mode, in place.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be
necessary if bits
is negative.
See the ShlRound
documentation for details.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl ShlRoundAssign<i16> for Integer
impl ShlRoundAssign<i16> for Integer
sourcefn shl_round_assign(&mut self, bits: i16, rm: RoundingMode)
fn shl_round_assign(&mut self, bits: i16, rm: RoundingMode)
Left-shifts an Integer
(multiplies or divides it by a power of 2) and rounds
according to the specified rounding mode, in place.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be
necessary if bits
is negative.
See the ShlRound
documentation for details.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl ShlRoundAssign<i32> for Integer
impl ShlRoundAssign<i32> for Integer
sourcefn shl_round_assign(&mut self, bits: i32, rm: RoundingMode)
fn shl_round_assign(&mut self, bits: i32, rm: RoundingMode)
Left-shifts an Integer
(multiplies or divides it by a power of 2) and rounds
according to the specified rounding mode, in place.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be
necessary if bits
is negative.
See the ShlRound
documentation for details.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl ShlRoundAssign<i64> for Integer
impl ShlRoundAssign<i64> for Integer
sourcefn shl_round_assign(&mut self, bits: i64, rm: RoundingMode)
fn shl_round_assign(&mut self, bits: i64, rm: RoundingMode)
Left-shifts an Integer
(multiplies or divides it by a power of 2) and rounds
according to the specified rounding mode, in place.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be
necessary if bits
is negative.
See the ShlRound
documentation for details.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl ShlRoundAssign<i8> for Integer
impl ShlRoundAssign<i8> for Integer
sourcefn shl_round_assign(&mut self, bits: i8, rm: RoundingMode)
fn shl_round_assign(&mut self, bits: i8, rm: RoundingMode)
Left-shifts an Integer
(multiplies or divides it by a power of 2) and rounds
according to the specified rounding mode, in place.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be
necessary if bits
is negative.
See the ShlRound
documentation for details.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl ShlRoundAssign<isize> for Integer
impl ShlRoundAssign<isize> for Integer
sourcefn shl_round_assign(&mut self, bits: isize, rm: RoundingMode)
fn shl_round_assign(&mut self, bits: isize, rm: RoundingMode)
Left-shifts an Integer
(multiplies or divides it by a power of 2) and rounds
according to the specified rounding mode, in place.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use
bits > 0 || self.divisible_by_power_of_2(bits)
. Rounding might only be
necessary if bits
is negative.
See the ShlRound
documentation for details.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(bits, 0)
.
Examples
See here.
sourceimpl<'a> Shr<i128> for &'a Integer
impl<'a> Shr<i128> for &'a Integer
sourcefn shr(self, bits: i128) -> Integer
fn shr(self, bits: i128) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), taking it by reference.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl Shr<i128> for Integer
impl Shr<i128> for Integer
sourcefn shr(self, bits: i128) -> Integer
fn shr(self, bits: i128) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), taking it by value.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl<'a> Shr<i16> for &'a Integer
impl<'a> Shr<i16> for &'a Integer
sourcefn shr(self, bits: i16) -> Integer
fn shr(self, bits: i16) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), taking it by reference.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl Shr<i16> for Integer
impl Shr<i16> for Integer
sourcefn shr(self, bits: i16) -> Integer
fn shr(self, bits: i16) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), taking it by value.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl<'a> Shr<i32> for &'a Integer
impl<'a> Shr<i32> for &'a Integer
sourcefn shr(self, bits: i32) -> Integer
fn shr(self, bits: i32) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), taking it by reference.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl Shr<i32> for Integer
impl Shr<i32> for Integer
sourcefn shr(self, bits: i32) -> Integer
fn shr(self, bits: i32) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), taking it by value.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl<'a> Shr<i64> for &'a Integer
impl<'a> Shr<i64> for &'a Integer
sourcefn shr(self, bits: i64) -> Integer
fn shr(self, bits: i64) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), taking it by reference.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl Shr<i64> for Integer
impl Shr<i64> for Integer
sourcefn shr(self, bits: i64) -> Integer
fn shr(self, bits: i64) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), taking it by value.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl<'a> Shr<i8> for &'a Integer
impl<'a> Shr<i8> for &'a Integer
sourcefn shr(self, bits: i8) -> Integer
fn shr(self, bits: i8) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), taking it by reference.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl Shr<i8> for Integer
impl Shr<i8> for Integer
sourcefn shr(self, bits: i8) -> Integer
fn shr(self, bits: i8) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), taking it by value.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl<'a> Shr<isize> for &'a Integer
impl<'a> Shr<isize> for &'a Integer
sourcefn shr(self, bits: isize) -> Integer
fn shr(self, bits: isize) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), taking it by reference.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl Shr<isize> for Integer
impl Shr<isize> for Integer
sourcefn shr(self, bits: isize) -> Integer
fn shr(self, bits: isize) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), taking it by value.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl<'a> Shr<u128> for &'a Integer
impl<'a> Shr<u128> for &'a Integer
sourcefn shr(self, bits: u128) -> Integer
fn shr(self, bits: u128) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor),
taking it by reference.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl Shr<u128> for Integer
impl Shr<u128> for Integer
sourcefn shr(self, bits: u128) -> Integer
fn shr(self, bits: u128) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor),
taking it by value.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl<'a> Shr<u16> for &'a Integer
impl<'a> Shr<u16> for &'a Integer
sourcefn shr(self, bits: u16) -> Integer
fn shr(self, bits: u16) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor),
taking it by reference.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl Shr<u16> for Integer
impl Shr<u16> for Integer
sourcefn shr(self, bits: u16) -> Integer
fn shr(self, bits: u16) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor),
taking it by value.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl<'a> Shr<u32> for &'a Integer
impl<'a> Shr<u32> for &'a Integer
sourcefn shr(self, bits: u32) -> Integer
fn shr(self, bits: u32) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor),
taking it by reference.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl Shr<u32> for Integer
impl Shr<u32> for Integer
sourcefn shr(self, bits: u32) -> Integer
fn shr(self, bits: u32) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor),
taking it by value.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl<'a> Shr<u64> for &'a Integer
impl<'a> Shr<u64> for &'a Integer
sourcefn shr(self, bits: u64) -> Integer
fn shr(self, bits: u64) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor),
taking it by reference.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl Shr<u64> for Integer
impl Shr<u64> for Integer
sourcefn shr(self, bits: u64) -> Integer
fn shr(self, bits: u64) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor),
taking it by value.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl<'a> Shr<u8> for &'a Integer
impl<'a> Shr<u8> for &'a Integer
sourcefn shr(self, bits: u8) -> Integer
fn shr(self, bits: u8) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor),
taking it by reference.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl Shr<u8> for Integer
impl Shr<u8> for Integer
sourcefn shr(self, bits: u8) -> Integer
fn shr(self, bits: u8) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor),
taking it by value.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl<'a> Shr<usize> for &'a Integer
impl<'a> Shr<usize> for &'a Integer
sourcefn shr(self, bits: usize) -> Integer
fn shr(self, bits: usize) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor),
taking it by reference.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl Shr<usize> for Integer
impl Shr<usize> for Integer
sourcefn shr(self, bits: usize) -> Integer
fn shr(self, bits: usize) -> Integer
Right-shifts an Integer
(divides it by a power of 2 and takes the floor),
taking it by value.
$$ f(x, k) = \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl ShrAssign<i128> for Integer
impl ShrAssign<i128> for Integer
sourcefn shr_assign(&mut self, bits: i128)
fn shr_assign(&mut self, bits: i128)
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), in place.
$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl ShrAssign<i16> for Integer
impl ShrAssign<i16> for Integer
sourcefn shr_assign(&mut self, bits: i16)
fn shr_assign(&mut self, bits: i16)
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), in place.
$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl ShrAssign<i32> for Integer
impl ShrAssign<i32> for Integer
sourcefn shr_assign(&mut self, bits: i32)
fn shr_assign(&mut self, bits: i32)
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), in place.
$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl ShrAssign<i64> for Integer
impl ShrAssign<i64> for Integer
sourcefn shr_assign(&mut self, bits: i64)
fn shr_assign(&mut self, bits: i64)
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), in place.
$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl ShrAssign<i8> for Integer
impl ShrAssign<i8> for Integer
sourcefn shr_assign(&mut self, bits: i8)
fn shr_assign(&mut self, bits: i8)
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), in place.
$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl ShrAssign<isize> for Integer
impl ShrAssign<isize> for Integer
sourcefn shr_assign(&mut self, bits: isize)
fn shr_assign(&mut self, bits: isize)
Right-shifts an Integer
(divides it by a power of 2 and takes the floor or
multiplies it by a power of 2), in place.
$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl ShrAssign<u128> for Integer
impl ShrAssign<u128> for Integer
sourcefn shr_assign(&mut self, bits: u128)
fn shr_assign(&mut self, bits: u128)
Right-shifts an Integer
(divides it by a power of 2 and takes the floor), in
place.
$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl ShrAssign<u16> for Integer
impl ShrAssign<u16> for Integer
sourcefn shr_assign(&mut self, bits: u16)
fn shr_assign(&mut self, bits: u16)
Right-shifts an Integer
(divides it by a power of 2 and takes the floor), in
place.
$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl ShrAssign<u32> for Integer
impl ShrAssign<u32> for Integer
sourcefn shr_assign(&mut self, bits: u32)
fn shr_assign(&mut self, bits: u32)
Right-shifts an Integer
(divides it by a power of 2 and takes the floor), in
place.
$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl ShrAssign<u64> for Integer
impl ShrAssign<u64> for Integer
sourcefn shr_assign(&mut self, bits: u64)
fn shr_assign(&mut self, bits: u64)
Right-shifts an Integer
(divides it by a power of 2 and takes the floor), in
place.
$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl ShrAssign<u8> for Integer
impl ShrAssign<u8> for Integer
sourcefn shr_assign(&mut self, bits: u8)
fn shr_assign(&mut self, bits: u8)
Right-shifts an Integer
(divides it by a power of 2 and takes the floor), in
place.
$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl ShrAssign<usize> for Integer
impl ShrAssign<usize> for Integer
sourcefn shr_assign(&mut self, bits: usize)
fn shr_assign(&mut self, bits: usize)
Right-shifts an Integer
(divides it by a power of 2 and takes the floor), in
place.
$$ x \gets \left \lfloor \frac{x}{2^k} \right \rfloor. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is
max(1, self.significant_bits() - bits)
.
Examples
See here.
sourceimpl<'a> ShrRound<i128> for &'a Integer
impl<'a> ShrRound<i128> for &'a Integer
sourcefn shr_round(self, bits: i128, rm: RoundingMode) -> Integer
fn shr_round(self, bits: i128, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides or multiplies it by a power of 2), taking it
by reference, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl ShrRound<i128> for Integer
impl ShrRound<i128> for Integer
sourcefn shr_round(self, bits: i128, rm: RoundingMode) -> Integer
fn shr_round(self, bits: i128, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides or multiplies it by a power of 2), taking it
by value, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShrRound<i16> for &'a Integer
impl<'a> ShrRound<i16> for &'a Integer
sourcefn shr_round(self, bits: i16, rm: RoundingMode) -> Integer
fn shr_round(self, bits: i16, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides or multiplies it by a power of 2), taking it
by reference, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl ShrRound<i16> for Integer
impl ShrRound<i16> for Integer
sourcefn shr_round(self, bits: i16, rm: RoundingMode) -> Integer
fn shr_round(self, bits: i16, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides or multiplies it by a power of 2), taking it
by value, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShrRound<i32> for &'a Integer
impl<'a> ShrRound<i32> for &'a Integer
sourcefn shr_round(self, bits: i32, rm: RoundingMode) -> Integer
fn shr_round(self, bits: i32, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides or multiplies it by a power of 2), taking it
by reference, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl ShrRound<i32> for Integer
impl ShrRound<i32> for Integer
sourcefn shr_round(self, bits: i32, rm: RoundingMode) -> Integer
fn shr_round(self, bits: i32, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides or multiplies it by a power of 2), taking it
by value, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShrRound<i64> for &'a Integer
impl<'a> ShrRound<i64> for &'a Integer
sourcefn shr_round(self, bits: i64, rm: RoundingMode) -> Integer
fn shr_round(self, bits: i64, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides or multiplies it by a power of 2), taking it
by reference, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl ShrRound<i64> for Integer
impl ShrRound<i64> for Integer
sourcefn shr_round(self, bits: i64, rm: RoundingMode) -> Integer
fn shr_round(self, bits: i64, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides or multiplies it by a power of 2), taking it
by value, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShrRound<i8> for &'a Integer
impl<'a> ShrRound<i8> for &'a Integer
sourcefn shr_round(self, bits: i8, rm: RoundingMode) -> Integer
fn shr_round(self, bits: i8, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides or multiplies it by a power of 2), taking it
by reference, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl ShrRound<i8> for Integer
impl ShrRound<i8> for Integer
sourcefn shr_round(self, bits: i8, rm: RoundingMode) -> Integer
fn shr_round(self, bits: i8, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides or multiplies it by a power of 2), taking it
by value, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShrRound<isize> for &'a Integer
impl<'a> ShrRound<isize> for &'a Integer
sourcefn shr_round(self, bits: isize, rm: RoundingMode) -> Integer
fn shr_round(self, bits: isize, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides or multiplies it by a power of 2), taking it
by reference, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl ShrRound<isize> for Integer
impl ShrRound<isize> for Integer
sourcefn shr_round(self, bits: isize, rm: RoundingMode) -> Integer
fn shr_round(self, bits: isize, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides or multiplies it by a power of 2), taking it
by value, and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShrRound<u128> for &'a Integer
impl<'a> ShrRound<u128> for &'a Integer
sourcefn shr_round(self, bits: u128, rm: RoundingMode) -> Integer
fn shr_round(self, bits: u128, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides it by a power of 2), taking it by reference,
and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl ShrRound<u128> for Integer
impl ShrRound<u128> for Integer
sourcefn shr_round(self, bits: u128, rm: RoundingMode) -> Integer
fn shr_round(self, bits: u128, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides it by a power of 2), taking it by value, and
rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShrRound<u16> for &'a Integer
impl<'a> ShrRound<u16> for &'a Integer
sourcefn shr_round(self, bits: u16, rm: RoundingMode) -> Integer
fn shr_round(self, bits: u16, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides it by a power of 2), taking it by reference,
and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl ShrRound<u16> for Integer
impl ShrRound<u16> for Integer
sourcefn shr_round(self, bits: u16, rm: RoundingMode) -> Integer
fn shr_round(self, bits: u16, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides it by a power of 2), taking it by value, and
rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShrRound<u32> for &'a Integer
impl<'a> ShrRound<u32> for &'a Integer
sourcefn shr_round(self, bits: u32, rm: RoundingMode) -> Integer
fn shr_round(self, bits: u32, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides it by a power of 2), taking it by reference,
and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl ShrRound<u32> for Integer
impl ShrRound<u32> for Integer
sourcefn shr_round(self, bits: u32, rm: RoundingMode) -> Integer
fn shr_round(self, bits: u32, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides it by a power of 2), taking it by value, and
rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShrRound<u64> for &'a Integer
impl<'a> ShrRound<u64> for &'a Integer
sourcefn shr_round(self, bits: u64, rm: RoundingMode) -> Integer
fn shr_round(self, bits: u64, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides it by a power of 2), taking it by reference,
and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl ShrRound<u64> for Integer
impl ShrRound<u64> for Integer
sourcefn shr_round(self, bits: u64, rm: RoundingMode) -> Integer
fn shr_round(self, bits: u64, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides it by a power of 2), taking it by value, and
rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShrRound<u8> for &'a Integer
impl<'a> ShrRound<u8> for &'a Integer
sourcefn shr_round(self, bits: u8, rm: RoundingMode) -> Integer
fn shr_round(self, bits: u8, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides it by a power of 2), taking it by reference,
and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl ShrRound<u8> for Integer
impl ShrRound<u8> for Integer
sourcefn shr_round(self, bits: u8, rm: RoundingMode) -> Integer
fn shr_round(self, bits: u8, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides it by a power of 2), taking it by value, and
rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl<'a> ShrRound<usize> for &'a Integer
impl<'a> ShrRound<usize> for &'a Integer
sourcefn shr_round(self, bits: usize, rm: RoundingMode) -> Integer
fn shr_round(self, bits: usize, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides it by a power of 2), taking it by reference,
and rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl ShrRound<usize> for Integer
impl ShrRound<usize> for Integer
sourcefn shr_round(self, bits: usize, rm: RoundingMode) -> Integer
fn shr_round(self, bits: usize, rm: RoundingMode) -> Integer
Shifts an Integer
right (divides it by a power of 2), taking it by value, and
rounds according to the specified rounding mode.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
Let $q = \frac{x}{2^p}$:
$f(x, p, \mathrm{Down}) = \operatorname{sgn}(q) \lfloor |q| \rfloor.$
$f(x, p, \mathrm{Up}) = \operatorname{sgn}(q) \lceil |q| \rceil.$
$f(x, p, \mathrm{Floor}) = \lfloor q \rfloor.$
$f(x, p, \mathrm{Ceiling}) = \lceil q \rceil.$
$$ f(x, p, \mathrm{Nearest}) = \begin{cases} \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor < \frac{1}{2}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor > \frac{1}{2}, \\ \lfloor q \rfloor & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is even}, \\ \lceil q \rceil & \text{if} \quad q - \lfloor q \rfloor = \frac{1}{2} \ \text{and} \ \lfloor q \rfloor \ \text{is odd}. \end{cases} $$
$f(x, p, \mathrm{Exact}) = q$, but panics if $q \notin \Z$.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
type Output = Integer
sourceimpl ShrRoundAssign<i128> for Integer
impl ShrRoundAssign<i128> for Integer
sourcefn shr_round_assign(&mut self, bits: i128, rm: RoundingMode)
fn shr_round_assign(&mut self, bits: i128, rm: RoundingMode)
Shifts an Integer
right (divides or multiplies it by a power of 2) and rounds
according to the specified rounding mode, in place.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
See the ShrRound
documentation for details.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
sourceimpl ShrRoundAssign<i16> for Integer
impl ShrRoundAssign<i16> for Integer
sourcefn shr_round_assign(&mut self, bits: i16, rm: RoundingMode)
fn shr_round_assign(&mut self, bits: i16, rm: RoundingMode)
Shifts an Integer
right (divides or multiplies it by a power of 2) and rounds
according to the specified rounding mode, in place.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
See the ShrRound
documentation for details.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
sourceimpl ShrRoundAssign<i32> for Integer
impl ShrRoundAssign<i32> for Integer
sourcefn shr_round_assign(&mut self, bits: i32, rm: RoundingMode)
fn shr_round_assign(&mut self, bits: i32, rm: RoundingMode)
Shifts an Integer
right (divides or multiplies it by a power of 2) and rounds
according to the specified rounding mode, in place.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
See the ShrRound
documentation for details.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
sourceimpl ShrRoundAssign<i64> for Integer
impl ShrRoundAssign<i64> for Integer
sourcefn shr_round_assign(&mut self, bits: i64, rm: RoundingMode)
fn shr_round_assign(&mut self, bits: i64, rm: RoundingMode)
Shifts an Integer
right (divides or multiplies it by a power of 2) and rounds
according to the specified rounding mode, in place.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
See the ShrRound
documentation for details.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
sourceimpl ShrRoundAssign<i8> for Integer
impl ShrRoundAssign<i8> for Integer
sourcefn shr_round_assign(&mut self, bits: i8, rm: RoundingMode)
fn shr_round_assign(&mut self, bits: i8, rm: RoundingMode)
Shifts an Integer
right (divides or multiplies it by a power of 2) and rounds
according to the specified rounding mode, in place.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
See the ShrRound
documentation for details.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
sourceimpl ShrRoundAssign<isize> for Integer
impl ShrRoundAssign<isize> for Integer
sourcefn shr_round_assign(&mut self, bits: isize, rm: RoundingMode)
fn shr_round_assign(&mut self, bits: isize, rm: RoundingMode)
Shifts an Integer
right (divides or multiplies it by a power of 2) and rounds
according to the specified rounding mode, in place.
Passing RoundingMode::Floor
is equivalent to using >>
. To test whether
RoundingMode::Exact
can be passed, use self.divisible_by_power_of_2(bits)
.
See the ShrRound
documentation for details.
Worst-case complexity
$T(n, m) = O(n + m)$
$M(n, m) = O(n + m)$
where $T$ is time, $M$ is additional memory, $n$ is self.significant_bits()
, and
$m$ is max(-bits, 0)
.
Panics
Let $k$ be bits
. Panics if $k$ is positive and rm
is RoundingMode::Exact
but
self
is not divisible by $2^k$.
Examples
See here.
sourceimpl ShrRoundAssign<u128> for Integer
impl ShrRoundAssign<u128> for Integer
sourcefn shr_round_assign(&mut self, bits: u128, rm: RoundingMode)
fn shr_round_assign(&mut self, bits: u128, rm: RoundingMode)
Shifts a Natural
right (divides it by a power of 2) and rounds according to the
specified rounding mode, in place. Passing RoundingMode::Floor
is equivalent to
using >>=
. To test whether RoundingMode::Exact
can be passed, use
self.divisible_by_power_of_2(bits)
.
See the ShrRound
documentation for details.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
sourceimpl ShrRoundAssign<u16> for Integer
impl ShrRoundAssign<u16> for Integer
sourcefn shr_round_assign(&mut self, bits: u16, rm: RoundingMode)
fn shr_round_assign(&mut self, bits: u16, rm: RoundingMode)
Shifts a Natural
right (divides it by a power of 2) and rounds according to the
specified rounding mode, in place. Passing RoundingMode::Floor
is equivalent to
using >>=
. To test whether RoundingMode::Exact
can be passed, use
self.divisible_by_power_of_2(bits)
.
See the ShrRound
documentation for details.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
sourceimpl ShrRoundAssign<u32> for Integer
impl ShrRoundAssign<u32> for Integer
sourcefn shr_round_assign(&mut self, bits: u32, rm: RoundingMode)
fn shr_round_assign(&mut self, bits: u32, rm: RoundingMode)
Shifts a Natural
right (divides it by a power of 2) and rounds according to the
specified rounding mode, in place. Passing RoundingMode::Floor
is equivalent to
using >>=
. To test whether RoundingMode::Exact
can be passed, use
self.divisible_by_power_of_2(bits)
.
See the ShrRound
documentation for details.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
sourceimpl ShrRoundAssign<u64> for Integer
impl ShrRoundAssign<u64> for Integer
sourcefn shr_round_assign(&mut self, bits: u64, rm: RoundingMode)
fn shr_round_assign(&mut self, bits: u64, rm: RoundingMode)
Shifts a Natural
right (divides it by a power of 2) and rounds according to the
specified rounding mode, in place. Passing RoundingMode::Floor
is equivalent to
using >>=
. To test whether RoundingMode::Exact
can be passed, use
self.divisible_by_power_of_2(bits)
.
See the ShrRound
documentation for details.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
sourceimpl ShrRoundAssign<u8> for Integer
impl ShrRoundAssign<u8> for Integer
sourcefn shr_round_assign(&mut self, bits: u8, rm: RoundingMode)
fn shr_round_assign(&mut self, bits: u8, rm: RoundingMode)
Shifts a Natural
right (divides it by a power of 2) and rounds according to the
specified rounding mode, in place. Passing RoundingMode::Floor
is equivalent to
using >>=
. To test whether RoundingMode::Exact
can be passed, use
self.divisible_by_power_of_2(bits)
.
See the ShrRound
documentation for details.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
sourceimpl ShrRoundAssign<usize> for Integer
impl ShrRoundAssign<usize> for Integer
sourcefn shr_round_assign(&mut self, bits: usize, rm: RoundingMode)
fn shr_round_assign(&mut self, bits: usize, rm: RoundingMode)
Shifts a Natural
right (divides it by a power of 2) and rounds according to the
specified rounding mode, in place. Passing RoundingMode::Floor
is equivalent to
using >>=
. To test whether RoundingMode::Exact
can be passed, use
self.divisible_by_power_of_2(bits)
.
See the ShrRound
documentation for details.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(1)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Let $k$ be bits
. Panics if rm
is RoundingMode::Exact
but self
is not
divisible by $2^k$.
Examples
See here.
sourceimpl Sign for Integer
impl Sign for Integer
sourcefn sign(&self) -> Ordering
fn sign(&self) -> Ordering
Compares an Integer
to zero.
Returns Greater
, Equal
, or Less
, depending on whether the Integer
is positive,
zero, or negative, respectively.
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Sign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
use std::cmp::Ordering;
assert_eq!(Integer::ZERO.sign(), Ordering::Equal);
assert_eq!(Integer::from(123).sign(), Ordering::Greater);
assert_eq!(Integer::from(-123).sign(), Ordering::Less);
sourceimpl<'a> SignificantBits for &'a Integer
impl<'a> SignificantBits for &'a Integer
sourcefn significant_bits(self) -> u64
fn significant_bits(self) -> u64
Returns the number of significant bits of an Integer
’s absolute value.
$$ f(n) = \begin{cases} 0 & \text{if} \quad n = 0, \\ \lfloor \log_2 |n| \rfloor + 1 & \text{otherwise}. \end{cases} $$
Worst-case complexity
Constant time and additional memory.
Examples
extern crate malachite_base;
use malachite_base::num::logic::traits::SignificantBits;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
assert_eq!(Integer::ZERO.significant_bits(), 0);
assert_eq!(Integer::from(100).significant_bits(), 7);
assert_eq!(Integer::from(-100).significant_bits(), 7);
sourceimpl<'a> Square for &'a Integer
impl<'a> Square for &'a Integer
sourcefn square(self) -> Integer
fn square(self) -> Integer
Squares an Integer
, taking it by reference.
$$ f(x) = x^2. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Square;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
assert_eq!((&Integer::ZERO).square(), 0);
assert_eq!((&Integer::from(123)).square(), 15129);
assert_eq!((&Integer::from(-123)).square(), 15129);
type Output = Integer
sourceimpl Square for Integer
impl Square for Integer
sourcefn square(self) -> Integer
fn square(self) -> Integer
Squares an Integer
, taking it by value.
$$ f(x) = x^2. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Square;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
assert_eq!(Integer::ZERO.square(), 0);
assert_eq!(Integer::from(123).square(), 15129);
assert_eq!(Integer::from(-123).square(), 15129);
type Output = Integer
sourceimpl SquareAssign for Integer
impl SquareAssign for Integer
sourcefn square_assign(&mut self)
fn square_assign(&mut self)
Squares an Integer
in place.
$$ x \gets x^2. $$
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::SquareAssign;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
let mut x = Integer::ZERO;
x.square_assign();
assert_eq!(x, 0);
let mut x = Integer::from(123);
x.square_assign();
assert_eq!(x, 15129);
let mut x = Integer::from(-123);
x.square_assign();
assert_eq!(x, 15129);
sourceimpl<'a, 'b> Sub<&'a Integer> for &'b Integer
impl<'a, 'b> Sub<&'a Integer> for &'b Integer
sourcefn sub(self, other: &'a Integer) -> Integer
fn sub(self, other: &'a Integer) -> Integer
Subtracts an Integer
by another Integer
, taking both by reference.
$$ f(x, y) = x - y. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
assert_eq!(&Integer::ZERO - &Integer::from(123), -123);
assert_eq!(&Integer::from(123) - &Integer::ZERO, 123);
assert_eq!(&Integer::from(456) - &Integer::from(-123), 579);
assert_eq!(
&-Integer::from(10u32).pow(12) -
&(-Integer::from(10u32).pow(12) * Integer::from(2u32)),
1000000000000u64
);
sourceimpl<'a> Sub<&'a Integer> for Integer
impl<'a> Sub<&'a Integer> for Integer
sourcefn sub(self, other: &'a Integer) -> Integer
fn sub(self, other: &'a Integer) -> Integer
Subtracts an Integer
by another Integer
, taking the first by value and the second
by reference.
$$ f(x, y) = x - y. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
assert_eq!(Integer::ZERO - &Integer::from(123), -123);
assert_eq!(Integer::from(123) - &Integer::ZERO, 123);
assert_eq!(Integer::from(456) - &Integer::from(-123), 579);
assert_eq!(
-Integer::from(10u32).pow(12) - &(-Integer::from(10u32).pow(12) * Integer::from(2u32)),
1000000000000u64
);
sourceimpl<'a> Sub<Integer> for &'a Integer
impl<'a> Sub<Integer> for &'a Integer
sourcefn sub(self, other: Integer) -> Integer
fn sub(self, other: Integer) -> Integer
Subtracts an Integer
by another Integer
, taking the first by reference and the
second by value.
$$ f(x, y) = x - y. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
assert_eq!(&Integer::ZERO - Integer::from(123), -123);
assert_eq!(&Integer::from(123) - Integer::ZERO, 123);
assert_eq!(&Integer::from(456) - Integer::from(-123), 579);
assert_eq!(
&-Integer::from(10u32).pow(12) - -Integer::from(10u32).pow(12) * Integer::from(2u32),
1000000000000u64
);
sourceimpl Sub<Integer> for Integer
impl Sub<Integer> for Integer
sourcefn sub(self, other: Integer) -> Integer
fn sub(self, other: Integer) -> Integer
Subtracts an Integer
by another Integer
, taking both by value.
$$ f(x, y) = x - y. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$ (only if the underlying Vec
needs to reallocate)
where $T$ is time, $M$ is additional memory, and $n$ is
min(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
assert_eq!(Integer::ZERO - Integer::from(123), -123);
assert_eq!(Integer::from(123) - Integer::ZERO, 123);
assert_eq!(Integer::from(456) - Integer::from(-123), 579);
assert_eq!(
-Integer::from(10u32).pow(12) - -Integer::from(10u32).pow(12) * Integer::from(2u32),
1000000000000u64
);
sourceimpl<'a> SubAssign<&'a Integer> for Integer
impl<'a> SubAssign<&'a Integer> for Integer
sourcefn sub_assign(&mut self, other: &'a Integer)
fn sub_assign(&mut self, other: &'a Integer)
Subtracts an Integer
by another Integer
in place, taking the Integer
on the
right-hand side by reference.
$$ x \gets x - y. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is
max(self.significant_bits(), other.significant_bits())
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
let mut x = Integer::ZERO;
x -= &(-Integer::from(10u32).pow(12));
x -= &(Integer::from(10u32).pow(12) * Integer::from(2u32));
x -= &(-Integer::from(10u32).pow(12) * Integer::from(3u32));
x -= &(Integer::from(10u32).pow(12) * Integer::from(4u32));
assert_eq!(x, -2000000000000i64);
sourceimpl SubAssign<Integer> for Integer
impl SubAssign<Integer> for Integer
sourcefn sub_assign(&mut self, other: Integer)
fn sub_assign(&mut self, other: Integer)
Subtracts an Integer
by another Integer
in place, taking the Integer
on the
right-hand side by value.
$$ x \gets x - y. $$
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$ (only if the underlying Vec
needs to reallocate)
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::Pow;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
let mut x = Integer::ZERO;
x -= -Integer::from(10u32).pow(12);
x -= Integer::from(10u32).pow(12) * Integer::from(2u32);
x -= -Integer::from(10u32).pow(12) * Integer::from(3u32);
x -= Integer::from(10u32).pow(12) * Integer::from(4u32);
assert_eq!(x, -2000000000000i64);
sourceimpl<'a, 'b, 'c> SubMul<&'a Integer, &'b Integer> for &'c Integer
impl<'a, 'b, 'c> SubMul<&'a Integer, &'b Integer> for &'c Integer
sourcefn sub_mul(self, y: &'a Integer, z: &'b Integer) -> Integer
fn sub_mul(self, y: &'a Integer, z: &'b Integer) -> Integer
Subtracts an Integer
by the product of two other Integer
s, taking all three by
reference.
$f(x, y, z) = x - yz$.
Worst-case complexity
$T(n, m) = O(m + n \log n \log\log n)$
$M(n, m) = O(m + n \log n)$
where $T$ is time, $M$ is additional memory, $n$ is
max(y.significant_bits(), z.significant_bits())
, and $m$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{Pow, SubMul};
use malachite_nz::integer::Integer;
assert_eq!((&Integer::from(10u32)).sub_mul(&Integer::from(3u32), &Integer::from(-4)), 22);
assert_eq!(
(&-Integer::from(10u32).pow(12))
.sub_mul(&Integer::from(-0x10000), &-Integer::from(10u32).pow(12)),
-65537000000000000i64
);
type Output = Integer
sourceimpl<'a, 'b> SubMul<&'a Integer, &'b Integer> for Integer
impl<'a, 'b> SubMul<&'a Integer, &'b Integer> for Integer
sourcefn sub_mul(self, y: &'a Integer, z: &'b Integer) -> Integer
fn sub_mul(self, y: &'a Integer, z: &'b Integer) -> Integer
Subtracts an Integer
by the product of two other Integer
s, taking the first by
value and the second and third by reference.
$f(x, y, z) = x - yz$.
Worst-case complexity
$T(n, m) = O(m + n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, $n$ is
max(y.significant_bits(), z.significant_bits())
, and $m$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{Pow, SubMul};
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(10u32).sub_mul(&Integer::from(3u32), &Integer::from(-4)), 22);
assert_eq!(
(-Integer::from(10u32).pow(12))
.sub_mul(&Integer::from(-0x10000), &-Integer::from(10u32).pow(12)),
-65537000000000000i64
);
type Output = Integer
sourceimpl<'a> SubMul<&'a Integer, Integer> for Integer
impl<'a> SubMul<&'a Integer, Integer> for Integer
sourcefn sub_mul(self, y: &'a Integer, z: Integer) -> Integer
fn sub_mul(self, y: &'a Integer, z: Integer) -> Integer
Subtracts an Integer
by the product of two other Integer
s, taking the first and
third by value and the second by reference.
$f(x, y, z) = x - yz$.
Worst-case complexity
$T(n, m) = O(m + n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, $n$ is
max(y.significant_bits(), z.significant_bits())
, and $m$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{Pow, SubMul};
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(10u32).sub_mul(&Integer::from(3u32), Integer::from(-4)), 22);
assert_eq!(
(-Integer::from(10u32).pow(12))
.sub_mul(&Integer::from(-0x10000), -Integer::from(10u32).pow(12)),
-65537000000000000i64
);
type Output = Integer
sourceimpl<'a> SubMul<Integer, &'a Integer> for Integer
impl<'a> SubMul<Integer, &'a Integer> for Integer
sourcefn sub_mul(self, y: Integer, z: &'a Integer) -> Integer
fn sub_mul(self, y: Integer, z: &'a Integer) -> Integer
Subtracts an Integer
by the product of two other Integer
s, taking the first two by
value and the third by reference.
$f(x, y, z) = x - yz$.
Worst-case complexity
$T(n, m) = O(m + n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, $n$ is
max(y.significant_bits(), z.significant_bits())
, and $m$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{Pow, SubMul};
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(10u32).sub_mul(Integer::from(3u32), &Integer::from(-4)), 22);
assert_eq!(
(-Integer::from(10u32).pow(12))
.sub_mul(Integer::from(-0x10000), &-Integer::from(10u32).pow(12)),
-65537000000000000i64
);
type Output = Integer
sourceimpl SubMul<Integer, Integer> for Integer
impl SubMul<Integer, Integer> for Integer
sourcefn sub_mul(self, y: Integer, z: Integer) -> Integer
fn sub_mul(self, y: Integer, z: Integer) -> Integer
Subtracts an Integer
by the product of two other Integer
s, taking all three by
value.
$f(x, y, z) = x - yz$.
Worst-case complexity
$T(n, m) = O(m + n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, $n$ is
max(y.significant_bits(), z.significant_bits())
, and $m$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{Pow, SubMul};
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(10u32).sub_mul(Integer::from(3u32), Integer::from(-4)), 22);
assert_eq!(
(-Integer::from(10u32).pow(12))
.sub_mul(Integer::from(-0x10000), -Integer::from(10u32).pow(12)),
-65537000000000000i64
);
type Output = Integer
sourceimpl<'a, 'b> SubMulAssign<&'a Integer, &'b Integer> for Integer
impl<'a, 'b> SubMulAssign<&'a Integer, &'b Integer> for Integer
sourcefn sub_mul_assign(&mut self, y: &'a Integer, z: &'b Integer)
fn sub_mul_assign(&mut self, y: &'a Integer, z: &'b Integer)
Subtracts the product of two other Integer
s from an Integer
in place, taking both
Integer
s on the right-hand side by reference.
$x \gets x - yz$.
Worst-case complexity
$T(n, m) = O(m + n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, $n$ is
max(y.significant_bits(), z.significant_bits())
, and $m$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{Pow, SubMulAssign};
use malachite_nz::integer::Integer;
let mut x = Integer::from(10u32);
x.sub_mul_assign(&Integer::from(3u32), &Integer::from(-4));
assert_eq!(x, 22);
let mut x = -Integer::from(10u32).pow(12);
x.sub_mul_assign(&Integer::from(-0x10000), &(-Integer::from(10u32).pow(12)));
assert_eq!(x, -65537000000000000i64);
sourceimpl<'a> SubMulAssign<&'a Integer, Integer> for Integer
impl<'a> SubMulAssign<&'a Integer, Integer> for Integer
sourcefn sub_mul_assign(&mut self, y: &'a Integer, z: Integer)
fn sub_mul_assign(&mut self, y: &'a Integer, z: Integer)
Subtracts the product of two other Integer
s from 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
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{Pow, SubMulAssign};
use malachite_nz::integer::Integer;
let mut x = Integer::from(10u32);
x.sub_mul_assign(&Integer::from(3u32), Integer::from(-4));
assert_eq!(x, 22);
let mut x = -Integer::from(10u32).pow(12);
x.sub_mul_assign(&Integer::from(-0x10000), -Integer::from(10u32).pow(12));
assert_eq!(x, -65537000000000000i64);
sourceimpl<'a> SubMulAssign<Integer, &'a Integer> for Integer
impl<'a> SubMulAssign<Integer, &'a Integer> for Integer
sourcefn sub_mul_assign(&mut self, y: Integer, z: &'a Integer)
fn sub_mul_assign(&mut self, y: Integer, z: &'a Integer)
Subtracts the product of two other Integer
s from 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
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{Pow, SubMulAssign};
use malachite_nz::integer::Integer;
let mut x = Integer::from(10u32);
x.sub_mul_assign(Integer::from(3u32), &Integer::from(-4));
assert_eq!(x, 22);
let mut x = -Integer::from(10u32).pow(12);
x.sub_mul_assign(Integer::from(-0x10000), &(-Integer::from(10u32).pow(12)));
assert_eq!(x, -65537000000000000i64);
sourceimpl SubMulAssign<Integer, Integer> for Integer
impl SubMulAssign<Integer, Integer> for Integer
sourcefn sub_mul_assign(&mut self, y: Integer, z: Integer)
fn sub_mul_assign(&mut self, y: Integer, z: Integer)
Subtracts the product of two other Integer
s from an Integer
in place, taking both
Integer
s on the right-hand side by value.
$x \gets x - yz$.
Worst-case complexity
$T(n, m) = O(m + n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, $n$ is
max(y.significant_bits(), z.significant_bits())
, and $m$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::arithmetic::traits::{Pow, SubMulAssign};
use malachite_nz::integer::Integer;
let mut x = Integer::from(10u32);
x.sub_mul_assign(Integer::from(3u32), Integer::from(-4));
assert_eq!(x, 22);
let mut x = -Integer::from(10u32).pow(12);
x.sub_mul_assign(Integer::from(-0x10000), -Integer::from(10u32).pow(12));
assert_eq!(x, -65537000000000000i64);
sourceimpl ToSci for Integer
impl ToSci for Integer
sourcefn fmt_sci_valid(&self, options: ToSciOptions) -> bool
fn fmt_sci_valid(&self, options: ToSciOptions) -> bool
Determines whether an Integer
can be converted to a string using
to_sci
and a particular set of options.
Worst-case complexity
$T(n) = O(n \log n \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::conversion::string::options::ToSciOptions;
use malachite_base::num::conversion::traits::ToSci;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
let mut options = ToSciOptions::default();
assert!(Integer::from(123).fmt_sci_valid(options));
assert!(Integer::from(u128::MAX).fmt_sci_valid(options));
// u128::MAX has more than 16 significant digits
options.set_rounding_mode(RoundingMode::Exact);
assert!(!Integer::from(u128::MAX).fmt_sci_valid(options));
options.set_precision(50);
assert!(Integer::from(u128::MAX).fmt_sci_valid(options));
sourcefn fmt_sci(&self, f: &mut Formatter<'_>, options: ToSciOptions) -> Result
fn fmt_sci(&self, f: &mut Formatter<'_>, options: ToSciOptions) -> Result
Converts an Integer
to a string using a specified base, possibly formatting the number
using scientific notation.
See ToSciOptions
for details on the available options. Note that setting
neg_exp_threshold
has no effect, since there is never a need to use negative exponents
when representing an Integer
.
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if options.rounding_mode
is Exact
, but the size options are such that the input
must be rounded.
Examples
extern crate malachite_base;
use malachite_base::num::conversion::string::options::ToSciOptions;
use malachite_base::num::conversion::traits::ToSci;
use malachite_base::rounding_modes::RoundingMode;
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(u128::MAX).to_sci().to_string(), "3.402823669209385e38");
assert_eq!(Integer::from(i128::MIN).to_sci().to_string(), "-1.701411834604692e38");
let n = Integer::from(123456u32);
let mut options = ToSciOptions::default();
assert_eq!(n.to_sci_with_options(options).to_string(), "123456");
options.set_precision(3);
assert_eq!(n.to_sci_with_options(options).to_string(), "1.23e5");
options.set_rounding_mode(RoundingMode::Ceiling);
assert_eq!(n.to_sci_with_options(options).to_string(), "1.24e5");
options.set_e_uppercase();
assert_eq!(n.to_sci_with_options(options).to_string(), "1.24E5");
options.set_force_exponent_plus_sign(true);
assert_eq!(n.to_sci_with_options(options).to_string(), "1.24E+5");
options = ToSciOptions::default();
options.set_base(36);
assert_eq!(n.to_sci_with_options(options).to_string(), "2n9c");
options.set_uppercase();
assert_eq!(n.to_sci_with_options(options).to_string(), "2N9C");
options.set_base(2);
options.set_precision(10);
assert_eq!(n.to_sci_with_options(options).to_string(), "1.1110001e16");
options.set_include_trailing_zeros(true);
assert_eq!(n.to_sci_with_options(options).to_string(), "1.111000100e16");
sourcefn to_sci_with_options(&self, options: ToSciOptions) -> SciWrapper<'_, Self>
fn to_sci_with_options(&self, options: ToSciOptions) -> SciWrapper<'_, Self>
Converts a number to a string, possibly in scientific notation.
sourcefn to_sci(&self) -> SciWrapper<'_, Self>
fn to_sci(&self) -> SciWrapper<'_, Self>
Converts a number to a string, possibly in scientific notation, using the default
ToSciOptions
. Read more
sourceimpl ToStringBase for Integer
impl ToStringBase for Integer
sourcefn to_string_base(&self, base: u8) -> String
fn to_string_base(&self, base: u8) -> String
Converts an Integer
to a String
using a specified base.
Digits from 0 to 9 become char
s from '0'
to '9'
. Digits from 10 to 35 become the
lowercase char
s 'a'
to 'z'
.
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if base
is less than 2 or greater than 36.
Examples
extern crate malachite_base;
use malachite_base::num::conversion::traits::ToStringBase;
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(1000).to_string_base(2), "1111101000");
assert_eq!(Integer::from(1000).to_string_base(10), "1000");
assert_eq!(Integer::from(1000).to_string_base(36), "rs");
assert_eq!(Integer::from(-1000).to_string_base(2), "-1111101000");
assert_eq!(Integer::from(-1000).to_string_base(10), "-1000");
assert_eq!(Integer::from(-1000).to_string_base(36), "-rs");
sourcefn to_string_base_upper(&self, base: u8) -> String
fn to_string_base_upper(&self, base: u8) -> String
Converts an Integer
to a String
using a specified base.
Digits from 0 to 9 become char
s from '0'
to '9'
. Digits from 10 to 35 become the
uppercase char
s 'A'
to 'Z'
.
Worst-case complexity
$T(n) = O(n (\log n)^2 \log\log n)$
$M(n) = O(n \log n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Panics
Panics if base
is less than 2 or greater than 36.
Examples
extern crate malachite_base;
use malachite_base::num::conversion::traits::ToStringBase;
use malachite_nz::integer::Integer;
assert_eq!(Integer::from(1000).to_string_base_upper(2), "1111101000");
assert_eq!(Integer::from(1000).to_string_base_upper(10), "1000");
assert_eq!(Integer::from(1000).to_string_base_upper(36), "RS");
assert_eq!(Integer::from(-1000).to_string_base_upper(2), "-1111101000");
assert_eq!(Integer::from(-1000).to_string_base_upper(10), "-1000");
assert_eq!(Integer::from(-1000).to_string_base_upper(36), "-RS");
sourceimpl<'a> UnsignedAbs for &'a Integer
impl<'a> UnsignedAbs for &'a Integer
sourcefn unsigned_abs(self) -> Natural
fn unsigned_abs(self) -> Natural
Takes the absolute value of an Integer
, taking the Integer
by reference and
converting the result to a Natural
.
$$ 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::UnsignedAbs;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
assert_eq!((&Integer::ZERO).unsigned_abs(), 0);
assert_eq!((&Integer::from(123)).unsigned_abs(), 123);
assert_eq!((&Integer::from(-123)).unsigned_abs(), 123);
type Output = Natural
sourceimpl UnsignedAbs for Integer
impl UnsignedAbs for Integer
sourcefn unsigned_abs(self) -> Natural
fn unsigned_abs(self) -> Natural
Takes the absolute value of an Integer
, taking the Integer
by value and converting
the result to a Natural
.
$$ f(x) = |x|. $$
Worst-case complexity
Constant time and additional memory.
Examples
use malachite_base::num::arithmetic::traits::UnsignedAbs;
use malachite_base::num::basic::traits::Zero;
use malachite_nz::integer::Integer;
assert_eq!(Integer::ZERO.unsigned_abs(), 0);
assert_eq!(Integer::from(123).unsigned_abs(), 123);
assert_eq!(Integer::from(-123).unsigned_abs(), 123);
type Output = Natural
sourceimpl UpperHex for Integer
impl UpperHex for Integer
sourcefn fmt(&self, f: &mut Formatter<'_>) -> Result
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Converts an Integer
to a hexadecimal String
using uppercase characters.
Using the #
format flag prepends "0x"
to the string.
Worst-case complexity
$T(n) = O(n)$
$M(n) = O(n)$
where $T$ is time, $M$ is additional memory, and $n$ is self.significant_bits()
.
Examples
extern crate malachite_base;
use malachite_base::num::basic::traits::Zero;
use malachite_base::strings::ToUpperHexString;
use malachite_nz::integer::Integer;
use std::str::FromStr;
assert_eq!(Integer::ZERO.to_upper_hex_string(), "0");
assert_eq!(Integer::from(123).to_upper_hex_string(), "7B");
assert_eq!(
Integer::from_str("1000000000000")
.unwrap()
.to_upper_hex_string(),
"E8D4A51000"
);
assert_eq!(format!("{:07X}", Integer::from(123)), "000007B");
assert_eq!(Integer::from(-123).to_upper_hex_string(), "-7B");
assert_eq!(
Integer::from_str("-1000000000000")
.unwrap()
.to_upper_hex_string(),
"-E8D4A51000"
);
assert_eq!(format!("{:07X}", Integer::from(-123)), "-00007B");
assert_eq!(format!("{:#X}", Integer::ZERO), "0x0");
assert_eq!(format!("{:#X}", Integer::from(123)), "0x7B");
assert_eq!(
format!("{:#X}", Integer::from_str("1000000000000").unwrap()),
"0xE8D4A51000"
);
assert_eq!(format!("{:#07X}", Integer::from(123)), "0x0007B");
assert_eq!(format!("{:#X}", Integer::from(-123)), "-0x7B");
assert_eq!(
format!("{:#X}", Integer::from_str("-1000000000000").unwrap()),
"-0xE8D4A51000"
);
assert_eq!(format!("{:#07X}", Integer::from(-123)), "-0x007B");
sourceimpl<'a> WrappingFrom<&'a Integer> for i128
impl<'a> WrappingFrom<&'a Integer> for i128
sourcefn wrapping_from(value: &Integer) -> i128
fn wrapping_from(value: &Integer) -> i128
Converts an Integer
to a signed primitive integer, wrapping modulo $2^W$, where
$W$ is the width of the primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> WrappingFrom<&'a Integer> for i16
impl<'a> WrappingFrom<&'a Integer> for i16
sourcefn wrapping_from(value: &Integer) -> i16
fn wrapping_from(value: &Integer) -> i16
Converts an Integer
to a signed primitive integer, wrapping modulo $2^W$, where
$W$ is the width of the primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> WrappingFrom<&'a Integer> for i32
impl<'a> WrappingFrom<&'a Integer> for i32
sourcefn wrapping_from(value: &Integer) -> i32
fn wrapping_from(value: &Integer) -> i32
Converts an Integer
to a signed primitive integer, wrapping modulo $2^W$, where
$W$ is the width of the primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> WrappingFrom<&'a Integer> for i64
impl<'a> WrappingFrom<&'a Integer> for i64
sourcefn wrapping_from(value: &Integer) -> i64
fn wrapping_from(value: &Integer) -> i64
Converts an Integer
to a signed primitive integer, wrapping modulo $2^W$, where
$W$ is the width of the primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> WrappingFrom<&'a Integer> for i8
impl<'a> WrappingFrom<&'a Integer> for i8
sourcefn wrapping_from(value: &Integer) -> i8
fn wrapping_from(value: &Integer) -> i8
Converts an Integer
to a signed primitive integer, wrapping modulo $2^W$, where
$W$ is the width of the primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> WrappingFrom<&'a Integer> for isize
impl<'a> WrappingFrom<&'a Integer> for isize
sourcefn wrapping_from(value: &Integer) -> isize
fn wrapping_from(value: &Integer) -> isize
Converts an Integer
to a signed primitive integer, wrapping modulo $2^W$, where
$W$ is the width of the primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> WrappingFrom<&'a Integer> for u128
impl<'a> WrappingFrom<&'a Integer> for u128
sourcefn wrapping_from(value: &Integer) -> u128
fn wrapping_from(value: &Integer) -> u128
Converts an Integer
to an unsigned primitive integer, wrapping modulo $2^W$,
where $W$ is the width of the primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> WrappingFrom<&'a Integer> for u16
impl<'a> WrappingFrom<&'a Integer> for u16
sourcefn wrapping_from(value: &Integer) -> u16
fn wrapping_from(value: &Integer) -> u16
Converts an Integer
to an unsigned primitive integer, wrapping modulo $2^W$,
where $W$ is the width of the primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> WrappingFrom<&'a Integer> for u32
impl<'a> WrappingFrom<&'a Integer> for u32
sourcefn wrapping_from(value: &Integer) -> u32
fn wrapping_from(value: &Integer) -> u32
Converts an Integer
to an unsigned primitive integer, wrapping modulo $2^W$,
where $W$ is the width of the primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> WrappingFrom<&'a Integer> for u64
impl<'a> WrappingFrom<&'a Integer> for u64
sourcefn wrapping_from(value: &Integer) -> u64
fn wrapping_from(value: &Integer) -> u64
Converts an Integer
to an unsigned primitive integer, wrapping modulo $2^W$,
where $W$ is the width of the primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> WrappingFrom<&'a Integer> for u8
impl<'a> WrappingFrom<&'a Integer> for u8
sourcefn wrapping_from(value: &Integer) -> u8
fn wrapping_from(value: &Integer) -> u8
Converts an Integer
to an unsigned primitive integer, wrapping modulo $2^W$,
where $W$ is the width of the primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
sourceimpl<'a> WrappingFrom<&'a Integer> for usize
impl<'a> WrappingFrom<&'a Integer> for usize
sourcefn wrapping_from(value: &Integer) -> usize
fn wrapping_from(value: &Integer) -> usize
Converts an Integer
to an unsigned primitive integer, wrapping modulo $2^W$,
where $W$ is the width of the primitive integer.
Worst-case complexity
Constant time and additional memory.
Examples
See here.
impl Eq for Integer
impl StructuralEq for Integer
impl StructuralPartialEq for Integer
Auto Trait Implementations
impl RefUnwindSafe for Integer
impl Send for Integer
impl Sync for Integer
impl Unpin for Integer
impl UnwindSafe for Integer
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more