/rust/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.8/src/biguint/shift.rs

Source
use super::BigUint;

use crate::big_digit::{self, BigDigits};

use alloc::borrow::Cow;
use alloc::vec::Vec;
use core::mem;
use core::ops::{Shl, ShlAssign, Shr, ShrAssign};
use num_traits::{PrimInt, Zero};

#[inline]
pub(super) fn biguint_shl<T: PrimInt>(n: Cow<'_, BigUint>, shift: T) -> BigUint {
    if shift < T::zero() {
        panic!("attempt to shift left with negative");
    }
    if n.is_zero() {
        return n.into_owned();
    }
    let bits = T::from(big_digit::BITS).unwrap();
    let digits = (shift / bits).to_usize().expect("capacity overflow");
    let shift = (shift % bits).to_u8().unwrap();
    biguint_shl2(n, digits, shift)
}

fn biguint_shl2(n: Cow<'_, BigUint>, digits: usize, shift: u8) -> BigUint {
    let mut data = match digits {
        0 => n.into_owned().data,
        _ => {
            let len = digits.saturating_add(n.data.len() + 1);
            let mut data = Vec::with_capacity(len);
            data.resize(digits, 0);
            data.extend(n.data.iter());
            BigDigits::from_vec(data)
        }
    };

    if shift > 0 {
        let mut carry = 0;
        let carry_shift = big_digit::BITS - shift;
        for elem in data[digits..].iter_mut() {
            let new_carry = *elem >> carry_shift;
            *elem = (*elem << shift) | carry;
            carry = new_carry;
        }
        if carry != 0 {
            data.push(carry);
        }
    }

    BigUint { data }
}

#[inline]
fn biguint_shr<T: PrimInt>(n: Cow<'_, BigUint>, shift: T) -> BigUint {
    if shift < T::zero() {
        panic!("attempt to shift right with negative");
    }
    if n.is_zero() {
        return n.into_owned();
    }
    let bits = T::from(big_digit::BITS).unwrap();
    let digits = (shift / bits).to_usize().unwrap_or(usize::MAX);
    let shift = (shift % bits).to_u8().unwrap();
    biguint_shr2(n, digits, shift)
}

fn biguint_shr2(n: Cow<'_, BigUint>, digits: usize, shift: u8) -> BigUint {
    if digits >= n.data.len() {
        return match n {
            Cow::Borrowed(_) => BigUint::ZERO,
            Cow::Owned(mut n) => {
                n.set_zero();
                n
            }
        };
    }
    let mut data = match n {
        Cow::Borrowed(n) => BigDigits::from_slice(&n.data[digits..]),
        Cow::Owned(mut n) => {
            n.data.drain_front(digits);
            n.data.shrink();
            n.data
        }
    };

    if shift > 0 {
        let mut borrow = 0;
        let borrow_shift = big_digit::BITS - shift;
        for elem in data.iter_mut().rev() {
            let new_borrow = *elem << borrow_shift;
            *elem = (*elem >> shift) | borrow;
            borrow = new_borrow;
        }
        // Assuming we were normal before, only one
        // most-significant digit might be off now.
        if !data.is_normal() {
            data.pop();
        }
    }

    BigUint { data }
}

macro_rules! impl_shift {
    (@ref $Shx:ident :: $shx:ident, $ShxAssign:ident :: $shx_assign:ident, $rhs:ty) => {
        impl $Shx<&$rhs> for BigUint {
            type Output = BigUint;

            #[inline]
            fn $shx(self, rhs: &$rhs) -> BigUint {
                $Shx::$shx(self, *rhs)
            }
        }
        impl $Shx<&$rhs> for &BigUint {
            type Output = BigUint;

            #[inline]
            fn $shx(self, rhs: &$rhs) -> BigUint {
                $Shx::$shx(self, *rhs)
            }
        }
        impl $ShxAssign<&$rhs> for BigUint {
            #[inline]
            fn $shx_assign(&mut self, rhs: &$rhs) {
                $ShxAssign::$shx_assign(self, *rhs);
            }
        }
    };
    ($($rhs:ty),+) => {$(
        impl Shl<$rhs> for BigUint {
            type Output = BigUint;

            #[inline]
            fn shl(self, rhs: $rhs) -> BigUint {
                biguint_shl(Cow::Owned(self), rhs)
            }
        }
        impl Shl<$rhs> for &BigUint {
            type Output = BigUint;

            #[inline]
            fn shl(self, rhs: $rhs) -> BigUint {
                biguint_shl(Cow::Borrowed(self), rhs)
            }
        }
        impl ShlAssign<$rhs> for BigUint {
            #[inline]
            fn shl_assign(&mut self, rhs: $rhs) {
                let n = mem::replace(self, Self::ZERO);
                *self = n << rhs;
            }
        }
        impl_shift! { @ref Shl::shl, ShlAssign::shl_assign, $rhs }

        impl Shr<$rhs> for BigUint {
            type Output = BigUint;

            #[inline]
            fn shr(self, rhs: $rhs) -> BigUint {
                biguint_shr(Cow::Owned(self), rhs)
            }
        }
        impl Shr<$rhs> for &BigUint {
            type Output = BigUint;

            #[inline]
            fn shr(self, rhs: $rhs) -> BigUint {
                biguint_shr(Cow::Borrowed(self), rhs)
            }
        }
        impl ShrAssign<$rhs> for BigUint {
            #[inline]
            fn shr_assign(&mut self, rhs: $rhs) {
                let n = mem::replace(self, Self::ZERO);
                *self = n >> rhs;
            }
        }
        impl_shift! { @ref Shr::shr, ShrAssign::shr_assign, $rhs }
    )*};
}

impl_shift! { u8, u16, u32, u64, u128, usize }
impl_shift! { i8, i16, i32, i64, i128, isize }

Line	Count	Source
1		use super::BigUint;
2
3		use crate::big_digit::{self, BigDigits};
4
5		use alloc::borrow::Cow;
6		use alloc::vec::Vec;
7		use core::mem;
8		use core::ops::{Shl, ShlAssign, Shr, ShrAssign};
9		use num_traits::{PrimInt, Zero};
10
11		#[inline]
12	0	pub(super) fn biguint_shl<T: PrimInt>(n: Cow<'_, BigUint>, shift: T) -> BigUint {
13	0	if shift < T::zero() {
14	0	panic!("attempt to shift left with negative");
15	0	}
16	0	if n.is_zero() {
17	0	return n.into_owned();
18	0	}
19	0	let bits = T::from(big_digit::BITS).unwrap();
20	0	let digits = (shift / bits).to_usize().expect("capacity overflow");
21	0	let shift = (shift % bits).to_u8().unwrap();
22	0	biguint_shl2(n, digits, shift)
23	0	} Unexecuted instantiation: num_bigint::biguint::shift::biguint_shl::<usize> Unexecuted instantiation: num_bigint::biguint::shift::biguint_shl::<i32> Unexecuted instantiation: num_bigint::biguint::shift::biguint_shl::<u32> Unexecuted instantiation: num_bigint::biguint::shift::biguint_shl::<u64>
24
25	0	fn biguint_shl2(n: Cow<'_, BigUint>, digits: usize, shift: u8) -> BigUint {
26	0	let mut data = match digits {
27	0	0 => n.into_owned().data,
28		_ => {
29	0	let len = digits.saturating_add(n.data.len() + 1);
30	0	let mut data = Vec::with_capacity(len);
31	0	data.resize(digits, 0);
32	0	data.extend(n.data.iter());
33	0	BigDigits::from_vec(data)
34		}
35		};
36
37	0	if shift > 0 {
38	0	let mut carry = 0;
39	0	let carry_shift = big_digit::BITS - shift;
40	0	for elem in data[digits..].iter_mut() {
41	0	let new_carry = *elem >> carry_shift;
42	0	elem = (elem << shift) \| carry;
43	0	carry = new_carry;
44	0	}
45	0	if carry != 0 {
46	0	data.push(carry);
47	0	}
48	0	}
49
50	0	BigUint { data }
51	0	}
52
53		#[inline]
54	0	fn biguint_shr<T: PrimInt>(n: Cow<'_, BigUint>, shift: T) -> BigUint {
55	0	if shift < T::zero() {
56	0	panic!("attempt to shift right with negative");
57	0	}
58	0	if n.is_zero() {
59	0	return n.into_owned();
60	0	}
61	0	let bits = T::from(big_digit::BITS).unwrap();
62	0	let digits = (shift / bits).to_usize().unwrap_or(usize::MAX);
63	0	let shift = (shift % bits).to_u8().unwrap();
64	0	biguint_shr2(n, digits, shift)
65	0	} Unexecuted instantiation: num_bigint::biguint::shift::biguint_shr::<usize> Unexecuted instantiation: num_bigint::biguint::shift::biguint_shr::<i32> Unexecuted instantiation: num_bigint::biguint::shift::biguint_shr::<u32> Unexecuted instantiation: num_bigint::biguint::shift::biguint_shr::<u64>
66
67	0	fn biguint_shr2(n: Cow<'_, BigUint>, digits: usize, shift: u8) -> BigUint {
68	0	if digits >= n.data.len() {
69	0	return match n {
70	0	Cow::Borrowed(_) => BigUint::ZERO,
71	0	Cow::Owned(mut n) => {
72	0	n.set_zero();
73	0	n
74		}
75		};
76	0	}
77	0	let mut data = match n {
78	0	Cow::Borrowed(n) => BigDigits::from_slice(&n.data[digits..]),
79	0	Cow::Owned(mut n) => {
80	0	n.data.drain_front(digits);
81	0	n.data.shrink();
82	0	n.data
83		}
84		};
85
86	0	if shift > 0 {
87	0	let mut borrow = 0;
88	0	let borrow_shift = big_digit::BITS - shift;
89	0	for elem in data.iter_mut().rev() {
90	0	let new_borrow = *elem << borrow_shift;
91	0	elem = (elem >> shift) \| borrow;
92	0	borrow = new_borrow;
93	0	}
94		// Assuming we were normal before, only one
95		// most-significant digit might be off now.
96	0	if !data.is_normal() {
97	0	data.pop();
98	0	}
99	0	}
100
101	0	BigUint { data }
102	0	}
103
104		macro_rules! impl_shift {
105		(@ref $Shx:ident :: $shx:ident, $ShxAssign:ident :: $shx_assign:ident, $rhs:ty) => {
106		impl $Shx<&$rhs> for BigUint {
107		type Output = BigUint;
108
109		#[inline]
110	0	fn $shx(self, rhs: &$rhs) -> BigUint {
111	0	$Shx::$shx(self, *rhs)
112	0	} Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<&usize>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<&usize>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<&i8>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<&i8>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<&i16>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<&i16>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<&i32>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<&i32>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<&i64>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<&i64>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<&i128>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<&i128>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<&isize>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<&isize>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<&u8>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<&u16>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<&u16>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<&u32>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<&u32>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<&u64>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<&u64>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<&u128>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<&u128>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<&u8>>::shl
113		}
114		impl $Shx<&$rhs> for &BigUint {
115		type Output = BigUint;
116
117		#[inline]
118	0	fn $shx(self, rhs: &$rhs) -> BigUint {
119	0	$Shx::$shx(self, *rhs)
120	0	} Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<&u128>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<&usize>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<&usize>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<&i8>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<&i8>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<&i16>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<&i16>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<&i32>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<&i32>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<&i64>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<&i64>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<&i128>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<&i128>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<&isize>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<&isize>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<&u8>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<&u16>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<&u16>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<&u32>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<&u32>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<&u64>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<&u64>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<&u128>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<&u8>>::shl
121		}
122		impl $ShxAssign<&$rhs> for BigUint {
123		#[inline]
124	0	fn $shx_assign(&mut self, rhs: &$rhs) {
125	0	$ShxAssign::$shx_assign(self, *rhs);
126	0	} Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<&u128>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<&usize>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<&usize>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<&i8>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<&i8>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<&i16>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<&i16>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<&i32>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<&i32>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<&i64>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<&i64>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<&i128>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<&i128>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<&isize>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<&isize>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<&u8>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<&u8>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<&u16>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<&u16>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<&u32>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<&u32>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<&u64>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<&u64>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<&u128>>::shl_assign
127		}
128		};
129		($($rhs:ty),+) => {$(
130		impl Shl<$rhs> for BigUint {
131		type Output = BigUint;
132
133		#[inline]
134	0	fn shl(self, rhs: $rhs) -> BigUint {
135	0	biguint_shl(Cow::Owned(self), rhs)
136	0	} Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<u32>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<u64>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<usize>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<u8>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<i8>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<isize>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<i16>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<i32>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<i64>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<i128>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<u16>>::shl Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shl<u128>>::shl
137		}
138		impl Shl<$rhs> for &BigUint {
139		type Output = BigUint;
140
141		#[inline]
142	0	fn shl(self, rhs: $rhs) -> BigUint {
143	0	biguint_shl(Cow::Borrowed(self), rhs)
144	0	} Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<i32>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<usize>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<i8>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<isize>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<i16>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<i64>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<i128>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<u16>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<u8>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<u32>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<u64>>::shl Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shl<u128>>::shl
145		}
146		impl ShlAssign<$rhs> for BigUint {
147		#[inline]
148	0	fn shl_assign(&mut self, rhs: $rhs) {
149	0	let n = mem::replace(self, Self::ZERO);
150	0	*self = n << rhs;
151	0	} Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<u32>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<usize>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<u8>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<isize>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<i8>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<i16>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<i32>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<i64>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<i128>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<u16>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<u64>>::shl_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShlAssign<u128>>::shl_assign
152		}
153		impl_shift! { @ref Shl::shl, ShlAssign::shl_assign, $rhs }
154
155		impl Shr<$rhs> for BigUint {
156		type Output = BigUint;
157
158		#[inline]
159	0	fn shr(self, rhs: $rhs) -> BigUint {
160	0	biguint_shr(Cow::Owned(self), rhs)
161	0	} Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<i32>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<u32>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<u64>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<usize>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<isize>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<u8>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<i8>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<i16>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<i64>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<i128>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<u16>>::shr Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::Shr<u128>>::shr
162		}
163		impl Shr<$rhs> for &BigUint {
164		type Output = BigUint;
165
166		#[inline]
167	0	fn shr(self, rhs: $rhs) -> BigUint {
168	0	biguint_shr(Cow::Borrowed(self), rhs)
169	0	} Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<u64>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<i128>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<isize>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<i8>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<i16>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<i32>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<i64>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<u8>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<u16>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<u32>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<u128>>::shr Unexecuted instantiation: <&num_bigint::biguint::BigUint as core::ops::bit::Shr<usize>>::shr
170		}
171		impl ShrAssign<$rhs> for BigUint {
172		#[inline]
173	0	fn shr_assign(&mut self, rhs: $rhs) {
174	0	let n = mem::replace(self, Self::ZERO);
175	0	*self = n >> rhs;
176	0	} Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<usize>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<i128>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<isize>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<i8>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<i16>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<i32>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<i64>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<u8>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<u16>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<u32>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<u64>>::shr_assign Unexecuted instantiation: <num_bigint::biguint::BigUint as core::ops::bit::ShrAssign<u128>>::shr_assign
177		}
178		impl_shift! { @ref Shr::shr, ShrAssign::shr_assign, $rhs }
179		)*};
180		}
181
182		impl_shift! { u8, u16, u32, u64, u128, usize }
183		impl_shift! { i8, i16, i32, i64, i128, isize }

Coverage Report

Created: 2026-07-16 07:17