rithm 14.6.0

Arbitrary precision arithmetic.
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

use traiter::numbers::{Endianness, FromBytes, One, Zeroable};

use crate::traits::HasSignBit;

use super::constants::MIDDLE_BYTE;
use super::contracts::is_valid_digit_bitness;
use super::digits::{
    negate_bytes, to_digits_sign, BinaryBaseFromBinaryDigits,
};
use super::types::{BigInt, Sign};

impl<
        Digit: BinaryBaseFromBinaryDigits<u8> + HasSignBit,
        const DIGIT_BITNESS: usize,
    > FromBytes for BigInt<Digit, DIGIT_BITNESS>
{
    fn from_bytes(bytes: &[u8], endianness: Endianness) -> Self {
        debug_assert!(is_valid_digit_bitness::<Digit, DIGIT_BITNESS>());
        let mut bytes = bytes.to_vec();
        match endianness {
            Endianness::Big => bytes.reverse(),
            Endianness::Little => {}
        }
        let most_significant_byte = bytes[bytes.len() - 1];
        let sign = if most_significant_byte >= MIDDLE_BYTE {
            negate_bytes(&mut bytes);
            -Sign::one()
        } else {
            to_digits_sign(&bytes)
        };
        Self {
            sign,
            digits: Digit::binary_base_from_binary_digits(
                &bytes[..bytes.len()
                    - usize::from(
                        bytes.len() > 1 && bytes[bytes.len() - 1].is_zero(),
                    )],
                u8::BITS as usize,
                DIGIT_BITNESS,
            ),
        }
    }
}