fixed-bigint 0.6.1

Fixed-size big integer implementation for Rust
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

//! `num_traits::PrimInt` for `HeaplessBigInt<T, CAP, Nct>`.
//!
//! A thin bridge: the bit-operation methods delegate to the already-implemented
//! `const_num_traits::PrimBits`, and `pow` to the shared `pow_impl`. Nct-only
//! (PrimInt supertrait-bundles `Num`, which is Nct on this carrier);
//! `reverse_bits`/`leading_ones`/`trailing_ones` use the trait defaults, same
//! as `FixedUInt`.

use super::HeaplessBigInt;
use super::pow::pow_impl;
use crate::MachineWord;
use const_num_traits::{CarryingMul, Nct, PrimBits};

impl<T, const CAP: usize> num_traits::PrimInt for HeaplessBigInt<T, CAP, Nct>
where
    T: MachineWord + CarryingMul<Unsigned = T, Output = T>,
{
    fn count_ones(self) -> u32 {
        PrimBits::count_ones(self)
    }
    fn count_zeros(self) -> u32 {
        PrimBits::count_zeros(self)
    }
    fn leading_zeros(self) -> u32 {
        PrimBits::leading_zeros(self)
    }
    fn trailing_zeros(self) -> u32 {
        PrimBits::trailing_zeros(self)
    }
    fn rotate_left(self, n: u32) -> Self {
        PrimBits::rotate_left(self, n)
    }
    fn rotate_right(self, n: u32) -> Self {
        PrimBits::rotate_right(self, n)
    }
    fn signed_shl(self, n: u32) -> Self {
        PrimBits::signed_shl(self, n)
    }
    fn signed_shr(self, n: u32) -> Self {
        PrimBits::signed_shr(self, n)
    }
    fn unsigned_shl(self, n: u32) -> Self {
        PrimBits::unsigned_shl(self, n)
    }
    fn unsigned_shr(self, n: u32) -> Self {
        PrimBits::unsigned_shr(self, n)
    }
    fn swap_bytes(self) -> Self {
        PrimBits::swap_bytes(self)
    }
    // Override the num_traits default: it reverses via shifts, and heapless's
    // `Shr` narrows `len`, so the default collapses to zero. PrimBits does it
    // limb-wise at the value width.
    fn reverse_bits(self) -> Self {
        PrimBits::reverse_bits(self)
    }
    fn from_be(x: Self) -> Self {
        PrimBits::from_be(x)
    }
    fn from_le(x: Self) -> Self {
        PrimBits::from_le(x)
    }
    fn to_be(self) -> Self {
        PrimBits::to_be(self)
    }
    fn to_le(self) -> Self {
        PrimBits::to_le(self)
    }
    fn pow(self, exp: u32) -> Self {
        pow_impl(self, exp)
    }
}