snarkvm_console_types_integers/
from_bits.rs

1// Copyright (c) 2019-2025 Provable Inc.
2// This file is part of the snarkVM library.
3
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at:
7
8// http://www.apache.org/licenses/LICENSE-2.0
9
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15
16use super::*;
17
18impl<E: Environment, I: IntegerType> FromBits for Integer<E, I> {
19    /// Initializes a new integer from a list of **little-endian** bits.
20    fn from_bits_le(bits_le: &[bool]) -> Result<Self> {
21        Ok(Self::new(I::from_bits_le(bits_le)?))
22    }
23
24    /// Initializes a new integer from a list of **big-endian** bits.
25    fn from_bits_be(bits_be: &[bool]) -> Result<Self> {
26        Ok(Self::new(I::from_bits_be(bits_be)?))
27    }
28}
29
30#[cfg(test)]
31mod tests {
32    use super::*;
33    use snarkvm_console_network_environment::Console;
34
35    type CurrentEnvironment = Console;
36
37    const ITERATIONS: usize = 100;
38
39    fn check_from_bits_le<I: IntegerType>(rng: &mut TestRng) -> Result<()> {
40        for i in 0..ITERATIONS {
41            // Sample a random value.
42            let expected: I = Uniform::rand(rng);
43
44            let expected = Integer::<CurrentEnvironment, I>::new(expected);
45            let given_bits = expected.to_bits_le();
46            assert_eq!(Integer::<CurrentEnvironment, I>::size_in_bits(), given_bits.len());
47
48            let candidate = Integer::<CurrentEnvironment, I>::from_bits_le(&given_bits)?;
49            assert_eq!(expected, candidate);
50
51            // Add excess zero bits.
52            let candidate = [given_bits, vec![false; i]].concat();
53
54            let candidate = Integer::<CurrentEnvironment, I>::from_bits_le(&candidate)?;
55            assert_eq!(expected, candidate);
56            assert_eq!(Integer::<CurrentEnvironment, I>::size_in_bits(), candidate.to_bits_le().len());
57        }
58        Ok(())
59    }
60
61    fn check_from_bits_be<I: IntegerType>(rng: &mut TestRng) -> Result<()> {
62        for i in 0..ITERATIONS {
63            // Sample a random value.
64            let expected: I = Uniform::rand(rng);
65
66            let expected = Integer::<CurrentEnvironment, I>::new(expected);
67            let given_bits = expected.to_bits_be();
68            assert_eq!(Integer::<CurrentEnvironment, I>::size_in_bits(), given_bits.len());
69
70            let candidate = Integer::<CurrentEnvironment, I>::from_bits_be(&given_bits)?;
71            assert_eq!(expected, candidate);
72
73            // Add excess zero bits.
74            let candidate = [vec![false; i], given_bits].concat();
75
76            let candidate = Integer::<CurrentEnvironment, I>::from_bits_be(&candidate)?;
77            assert_eq!(expected, candidate);
78            assert_eq!(Integer::<CurrentEnvironment, I>::size_in_bits(), candidate.to_bits_be().len());
79        }
80        Ok(())
81    }
82
83    #[test]
84    fn test_from_bits_le() -> Result<()> {
85        let mut rng = TestRng::default();
86
87        check_from_bits_le::<u8>(&mut rng)?;
88        check_from_bits_le::<u16>(&mut rng)?;
89        check_from_bits_le::<u32>(&mut rng)?;
90        check_from_bits_le::<u64>(&mut rng)?;
91        check_from_bits_le::<u128>(&mut rng)?;
92
93        check_from_bits_le::<i8>(&mut rng)?;
94        check_from_bits_le::<i16>(&mut rng)?;
95        check_from_bits_le::<i32>(&mut rng)?;
96        check_from_bits_le::<i64>(&mut rng)?;
97        check_from_bits_le::<i128>(&mut rng)?;
98
99        Ok(())
100    }
101
102    #[test]
103    fn test_from_bits_be() -> Result<()> {
104        let mut rng = TestRng::default();
105
106        check_from_bits_be::<u8>(&mut rng)?;
107        check_from_bits_be::<u16>(&mut rng)?;
108        check_from_bits_be::<u32>(&mut rng)?;
109        check_from_bits_be::<u64>(&mut rng)?;
110        check_from_bits_be::<u128>(&mut rng)?;
111
112        check_from_bits_be::<i8>(&mut rng)?;
113        check_from_bits_be::<i16>(&mut rng)?;
114        check_from_bits_be::<i32>(&mut rng)?;
115        check_from_bits_be::<i64>(&mut rng)?;
116        check_from_bits_be::<i128>(&mut rng)?;
117
118        Ok(())
119    }
120}