1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
use crate::natural::Natural;
use malachite_base::num::arithmetic::traits::{
ModPowerOf2Neg, ModPowerOf2NegAssign, NegModPowerOf2, NegModPowerOf2Assign,
};
impl ModPowerOf2Neg for Natural {
type Output = Natural;
/// Negates a [`Natural`] modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The
/// [`Natural`] is taken by value.
///
/// $f(x, k) = y$, where $x, y < 2^k$ and $-x \equiv y \mod 2^k$.
///
/// # Worst-case complexity
/// $T(n) = O(n)$
///
/// $M(n) = O(n)$
///
/// where $T$ is time, $M$ is additional memory, and $n$ is `pow`.
///
/// # Examples
/// ```
/// extern crate malachite_base;
///
/// use malachite_base::num::arithmetic::traits::ModPowerOf2Neg;
/// use malachite_base::num::basic::traits::Zero;
/// use malachite_nz::natural::Natural;
///
/// assert_eq!(Natural::ZERO.mod_power_of_2_neg(5), 0);
/// assert_eq!(Natural::ZERO.mod_power_of_2_neg(100), 0);
/// assert_eq!(Natural::from(100u32).mod_power_of_2_neg(8), 156);
/// assert_eq!(
/// Natural::from(100u32).mod_power_of_2_neg(100).to_string(),
/// "1267650600228229401496703205276"
/// );
/// ```
#[inline]
fn mod_power_of_2_neg(mut self, pow: u64) -> Natural {
self.neg_mod_power_of_2_assign(pow);
self
}
}
impl<'a> ModPowerOf2Neg for &'a Natural {
type Output = Natural;
/// Negates a [`Natural`] modulo $2^k$. Assumes the input is already reduced modulo $2^k$. The
/// [`Natural`] is taken by reference.
///
/// $f(x, k) = y$, where $x, y < 2^k$ and $-x \equiv y \mod 2^k$.
///
/// # Worst-case complexity
/// $T(n) = O(n)$
///
/// $M(n) = O(n)$
///
/// where $T$ is time, $M$ is additional memory, and $n$ is `pow`.
///
/// # Examples
/// ```
/// extern crate malachite_base;
///
/// use malachite_base::num::arithmetic::traits::ModPowerOf2Neg;
/// use malachite_base::num::basic::traits::Zero;
/// use malachite_nz::natural::Natural;
///
/// assert_eq!((&Natural::ZERO).mod_power_of_2_neg(5), 0);
/// assert_eq!((&Natural::ZERO).mod_power_of_2_neg(100), 0);
/// assert_eq!((&Natural::from(100u32)).mod_power_of_2_neg(8), 156);
/// assert_eq!(
/// (&Natural::from(100u32)).mod_power_of_2_neg(100).to_string(),
/// "1267650600228229401496703205276"
/// );
/// ```
#[inline]
fn mod_power_of_2_neg(self, pow: u64) -> Natural {
self.neg_mod_power_of_2(pow)
}
}
impl ModPowerOf2NegAssign for Natural {
/// Negates a [`Natural`] modulo $2^k$, in place. Assumes the input is already reduced modulo
/// $2^k$.
///
/// $x \gets y$, where $x, y < 2^p$ and $-x \equiv y \mod 2^p$.
///
/// # Worst-case complexity
/// $T(n) = O(n)$
///
/// $M(n) = O(n)$
///
/// where $T$ is time, $M$ is additional memory, and $n$ is `pow`.
///
/// # Examples
/// ```
/// extern crate malachite_base;
///
/// use malachite_base::num::arithmetic::traits::ModPowerOf2NegAssign;
/// use malachite_base::num::basic::traits::Zero;
/// use malachite_nz::natural::Natural;
///
/// let mut n = Natural::ZERO;
/// n.mod_power_of_2_neg_assign(5);
/// assert_eq!(n, 0);
///
/// let mut n = Natural::ZERO;
/// n.mod_power_of_2_neg_assign(100);
/// assert_eq!(n, 0);
///
/// let mut n = Natural::from(100u32);
/// n.mod_power_of_2_neg_assign(8);
/// assert_eq!(n, 156);
///
/// let mut n = Natural::from(100u32);
/// n.mod_power_of_2_neg_assign(100);
/// assert_eq!(n.to_string(), "1267650600228229401496703205276");
/// ```
#[inline]
fn mod_power_of_2_neg_assign(&mut self, pow: u64) {
self.neg_mod_power_of_2_assign(pow);
}
}