smallint 0.2.2

A library for optimized arbitrary precision integers.
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
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

#![cfg(feature = "num-bigint")]

use num_bigint::BigInt;
use num_bigint::BigUint;
use num_bigint::Sign;

use core::mem::ManuallyDrop;

use crate::SmallInt;
use crate::SmallUint;

use crate::smallint::SmallIntType;
use crate::smallint::SmallUintType;

impl From<&BigInt> for SmallInt {
    fn from(b: &BigInt) -> Self {
        match b.try_into() {
            Ok(i) => Self(SmallIntType::Inline(i)),
            Err(_) => {
                let (sign, vec) = b.to_u32_digits();
                let mut slice = ManuallyDrop::new(vec.into_boxed_slice());
                let size = match sign {
                    Sign::Minus => -isize::try_from(slice.len()).unwrap(),
                    Sign::NoSign => panic!(
                        "Shouldn't happen; BigInts which store zero should convert to inline."
                    ),
                    Sign::Plus => isize::try_from(slice.len()).unwrap(),
                };
                Self(SmallIntType::Heap((slice.as_mut_ptr(), size)))
            }
        }
    }
}

impl From<&SmallInt> for BigInt {
    fn from(s: &SmallInt) -> Self {
        match s.0 {
            SmallIntType::Inline(i) => Self::from(i),
            SmallIntType::Heap((r, s)) => {
                let size = usize::try_from(s.abs()).unwrap();
                let sign = s.signum();
                let slice = unsafe { core::slice::from_raw_parts(r, size) };
                let bs = match sign {
                    0 => Sign::NoSign,
                    -1 => Sign::Minus,
                    1 => Sign::Plus,
                    _ => panic!("This shouldn't happen; There are only 3 signums."),
                };

                BigInt::new(bs, slice.to_vec())
            }
        }
    }
}

impl From<&BigUint> for SmallUint {
    fn from(b: &BigUint) -> Self {
        match b.try_into() {
            Ok(i) => Self(SmallUintType::Inline(i)),
            Err(_) => {
                let vec = b.to_u32_digits();
                let mut slice = ManuallyDrop::new(vec.into_boxed_slice());
                let size = slice.len();
                Self(SmallUintType::Heap((slice.as_mut_ptr(), size)))
            }
        }
    }
}

impl From<&SmallUint> for BigUint {
    fn from(s: &SmallUint) -> Self {
        match s.0 {
            SmallUintType::Inline(i) => Self::from(i),
            SmallUintType::Heap((r, s)) => {
                let slice = unsafe { core::slice::from_raw_parts(r, s) };

                BigUint::new(slice.to_vec())
            }
        }
    }
}