crypto-bigint 0.7.3

Pure Rust implementation of a big integer library which has been designed from the ground-up for use in cryptographic applications. Provides constant-time, no_std-friendly implementations of modern formulas using const generics.
Documentation 
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

use crate::{Int, Limb, Uint};

impl<const LIMBS: usize> Int<LIMBS> {
    /// Resize the representation of `self` to an [`Int<T>`].
    /// Warning: this operation may lead to loss of information.
    #[inline(always)]
    #[must_use]
    pub const fn resize<const T: usize>(&self) -> Int<T> {
        let mut limbs = [Limb::select(Limb::ZERO, Limb::MAX, self.is_negative()); T];
        let mut i = 0;
        let dim = if T < LIMBS { T } else { LIMBS };
        while i < dim {
            limbs[i] = self.0.limbs[i];
            i += 1;
        }
        *Uint { limbs }.as_int()
    }
}

#[cfg(test)]
mod tests {

    use crate::{I128, I256};

    #[test]
    fn scale_down() {
        assert_eq!(I256::MIN.resize::<{ I128::LIMBS }>(), I128::ZERO);
        assert_eq!(I256::MINUS_ONE.resize::<{ I128::LIMBS }>(), I128::MINUS_ONE);
        assert_eq!(I256::ZERO.resize::<{ I128::LIMBS }>(), I128::ZERO);
        assert_eq!(I256::ONE.resize::<{ I128::LIMBS }>(), I128::ONE);
        assert_eq!(I256::MAX.resize::<{ I128::LIMBS }>(), I128::MINUS_ONE);
    }

    #[test]
    fn scale_up() {
        assert_eq!(
            I128::MIN.resize::<{ I256::LIMBS }>(),
            I256::ZERO.wrapping_sub(&I256 {
                0: I128::MIN.0.resize()
            })
        );
        assert_eq!(I128::MINUS_ONE.resize::<{ I256::LIMBS }>(), I256::MINUS_ONE);
        assert_eq!(I128::ZERO.resize::<{ I256::LIMBS }>(), I256::ZERO);
        assert_eq!(I128::ONE.resize::<{ I256::LIMBS }>(), I256::ONE);
        assert_eq!(
            I128::MAX.resize::<{ I256::LIMBS }>(),
            *I128::MAX.0.resize().as_int()
        );
    }
}