const_num_bigint 0.2.1

const bigint
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
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
123
124
125
126
127
128
129
130
131
132
133
134

//! const
//!
//! ```
//!     use const_num_bigint::*;
//!     use std::str::FromStr;
//!     const TEST_INT : &'static BigInt = bigint!("123");
//!     let bigint = BigInt::from_str("123").unwrap();
//!     assert!(&bigint==TEST_INT);
//!     const TEST_INT2 : &'static BigInt = bigint!("-123");
//!     let bigint2 = BigInt::from_str("-123").unwrap();
//!     assert!(&bigint2==TEST_INT2);
//!     const TEST_INT3 : &'static BigInt =
//!         bigint!("123123123123123123123123123123123123123123123123123123123123123123123123123123");
//!     let bigint3 = BigInt::from_str(
//!         "123123123123123123123123123123123123123123123123123123123123123123123123123123"
//!     ).unwrap();
//!     assert!(&bigint3==TEST_INT3);
//!     const TEST_UINT : &'static BigUint = biguint!(
//!         "123123123123123123123123123123123123123123123123123123123123123123123123123123"
//!     );
//!     let biguint = BigUint::from_str(
//!         "123123123123123123123123123123123123123123123123123123123123123123123123123123"
//!     ).unwrap();
//!     assert!(&biguint==TEST_UINT);
//!     assert!(&biguint==
//!         biguint!("123123123123123123123123123123123123123123123123123123123123123123123123123123")
//!     );
//!     let pi_str = include_str!("pi.num");
//!     let biguint_pi = BigUint::from_str(pi_str).unwrap();
//!     assert!(&biguint_pi==
//!         biguint_file!("src/pi.num")
//!     );
//! ```
//!
//!

pub use const_num_bigint_derive::*;
use const_std_vec::ConstVec;
pub use num_bigint::*;
use std::mem::transmute;

pub struct ConstBigInt {
    _sign: Sign,
    _data: ConstBigUint,
}

pub struct ConstBigUint {
    _data: ConstVec<usize>,
}

impl ConstBigUint {
    #[inline]
    pub const fn new(arr: &'static [usize]) -> Self {
        ConstBigUint {
            _data: ConstVec::new(arr),
        }
    }
    #[inline]
    pub const fn to_biguint(&'static self) -> &'static BigUint {
        unsafe { transmute(self) }
    }
}

impl ConstBigInt {
    #[inline]
    pub const fn new(sign: Sign, arr: &'static [usize]) -> Self {
        ConstBigInt {
            _sign: sign,
            _data: ConstBigUint::new(arr),
        }
    }
    #[inline]
    pub const fn to_bigint(&'static self) -> &'static BigInt {
        unsafe { transmute(self) }
    }
}

#[cfg(target_pointer_width = "64")]
#[macro_export]
macro_rules! from_slice {
    ($($lo:expr,$hi:expr),*) => {
        {
            [ $( ($lo) + (($hi)<<32) ),* ]
        }
    };
    ( $firstlo:expr $(,$hi:expr,$lo:expr)* ) => {
        {
            [ ($firstlo) $( + (($hi)<<32) , ($lo) )* ]
        }
    };
}

#[cfg(target_pointer_width = "32")]
#[macro_export]
macro_rules! from_slice {
    ( $firstlo:expr $(,$hi:expr,$lo:expr)* ) => {
        {
            [ ($firstlo) $( , ($hi) , ($lo) )* ]
        }
    };
    ($($lo:expr,$hi:expr),*) => {
        {
            [ $( ($lo) , ($hi) ),* ]
        }
    };
}

#[macro_export]
macro_rules! bigint {
    ( $num:expr ) => {
        $crate::bigint_with_crate!($crate, $num)
    };
}

#[macro_export]
macro_rules! bigint_file {
    ( $num:expr ) => {
        $crate::bigint_file_with_crate!($crate, $num)
    };
}

#[macro_export]
macro_rules! biguint {
    ( $num:expr ) => {
        $crate::biguint_with_crate!($crate, $num)
    };
}

#[macro_export]
macro_rules! biguint_file {
    ( $num:expr ) => {
        $crate::biguint_file_with_crate!($crate, $num)
    };
}