Implement Display, FromStr and Hash (#44)

* Implement Display, FromStr and Hash

* Renovate actions

* Fix CI

Author: kaidokert

.github/workflows/coverage.yml

@@ -1,16 +1,19 @@
 name: coverage
 
-# on: [ push, pull_request ]
 on: [ push ]
 
 jobs:
   build:
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
       with:
         fetch-depth: 0
+
+    - name: Install Rust toolchain
+      uses: dtolnay/rust-toolchain@stable
+
     - name: Push to coveralls.io
       env:
         COVERALLS_REPO_TOKEN: ${{ secrets.COVERALLS_REPO_TOKEN }}

.github/workflows/pre-commit.yaml

@@ -6,10 +6,10 @@ jobs:
   pre-commit:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - uses: actions/setup-python@v2
     - uses: actions-rs/toolchain@v1
       with:
           toolchain: stable
           components: rustfmt, clippy
-    - uses: pre-commit/action@v2.0.0
+    - uses: pre-commit/action@v3.0.1

.github/workflows/rust.yml

@@ -7,11 +7,14 @@ env:
 
 jobs:
   build:
-
     runs-on: ubuntu-latest
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
+
+    - name: Install Rust toolchain
+      uses: dtolnay/rust-toolchain@stable
+
     - name: Build
       run: cargo build --verbose
     - name: Run tests

.pre-commit-config.yaml

@@ -14,7 +14,7 @@
 
 repos:
 -   repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v3.4.0
+    rev: v5.0.0
     hooks:
     -   id: trailing-whitespace
     -   id: end-of-file-fixer

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fixed-bigint"
-version = "0.1.14"
+version = "0.1.15"
 authors = ["kaidokert <kaidokert@gmail.com>"]
 documentation = "https://docs.rs/fixed-bigint"
 edition = "2018"

src/fixeduint/prim_int_impl.rs

@@ -41,11 +41,11 @@ impl<T: MachineWord, const N: usize> num_traits::PrimInt for FixedUInt<T, N> {
         let b = self << (Self::BIT_SIZE - bits as usize);
         a | b
     }
-    fn signed_shl(self, _: u32) -> Self {
-        todo!()
+    fn signed_shl(self, bits: u32) -> Self {
+        self.unsigned_shl(bits)
     }
-    fn signed_shr(self, _: u32) -> Self {
-        todo!()
+    fn signed_shr(self, bits: u32) -> Self {
+        self.unsigned_shr(bits)
     }
     fn unsigned_shl(self, bits: u32) -> Self {
         core::ops::Shl::<u32>::shl(self, bits)

src/fixeduint/string_conversion.rs

@@ -1,4 +1,5 @@
-use num_traits::Zero;
+use core::fmt::Write;
+use num_traits::{Num, ToPrimitive, Zero};
 
 use super::{make_empty_error, make_overflow_err, make_parse_int_err, FixedUInt, MachineWord};
 
@@ -55,3 +56,49 @@ where
         self.hex_fmt(formatter, false)
     }
 }
+
+impl<T: MachineWord, const N: usize> core::fmt::Display for FixedUInt<T, N> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        const MAX_DIGITS: usize = 20;
+
+        if self.is_zero() {
+            return f.write_char('0');
+        }
+
+        // 20 is sized for u64
+        let mut digit_blocks = [[0u8; MAX_DIGITS]; N];
+        let mut digit_count = 0;
+        let mut number = *self;
+        let ten = Self::from(10u8);
+
+        // Extract digits into our storage
+        while !number.is_zero() && digit_count < N * MAX_DIGITS {
+            let (quotient, remainder) = number.div_rem(&ten);
+            let digit = remainder.to_u8().unwrap();
+
+            let block_idx = digit_count / MAX_DIGITS;
+            let digit_idx = digit_count % MAX_DIGITS;
+            digit_blocks[block_idx][digit_idx] = b'0' + digit;
+
+            digit_count += 1;
+            number = quotient;
+        }
+
+        // Write digits in reverse order
+        for i in (0..digit_count).rev() {
+            let block_idx = i / MAX_DIGITS;
+            let digit_idx = i % MAX_DIGITS;
+            f.write_char(digit_blocks[block_idx][digit_idx] as char)?;
+        }
+
+        Ok(())
+    }
+}
+
+impl<T: MachineWord, const N: usize> core::str::FromStr for FixedUInt<T, N> {
+    type Err = core::num::ParseIntError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Self::from_str_radix(s, 10)
+    }
+}

src/fixeduint/to_from_bytes.rs

@@ -1,10 +1,9 @@
 use super::MachineWord;
 
 #[cfg(feature = "use-unsafe")]
-use core::{
-    borrow::{Borrow, BorrowMut},
-    hash::Hash,
-};
+use core::borrow::{Borrow, BorrowMut};
+
+use core::hash::Hash;
 
 #[cfg(feature = "zeroize")]
 use zeroize::DefaultIsZeroes;
@@ -76,10 +75,9 @@ impl<T: MachineWord, const N: usize> AsMut<[u8]> for BytesHolder<T, N> {
         self.as_byte_slice_mut()
     }
 }
-#[cfg(feature = "use-unsafe")]
 impl<T: MachineWord, const N: usize> Hash for BytesHolder<T, N> {
-    fn hash<H: core::hash::Hasher>(&self, _state: &mut H) {
-        todo!()
+    fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
+        self.array.hash(state)
     }
 }
 

src/machineword.rs

@@ -28,6 +28,7 @@ pub trait MachineWord:
     + num_traits::FromBytes
     + num_traits::ToBytes
     + Default
+    + core::hash::Hash
 {
     type DoubleWord: num_traits::PrimInt;
     fn to_double(self) -> Self::DoubleWord;

tests/integer.rs

@@ -37,7 +37,10 @@ fn test_divides() {
     fn divides<T: num_integer::Integer + From<u8>>() {
         let tests = [(6u8, 3u8, true), (8, 2, true), (8, 1, true), (17, 2, false)];
         for &(multiple, multiplier, expected) in &tests {
-            assert_eq!(multiple.is_multiple_of(&multiplier), expected);
+            assert_eq!(
+                num_integer::Integer::is_multiple_of(&multiple, &multiplier),
+                expected
+            );
             assert_eq!(multiple.divides(&multiplier), expected);
         }
         let divrem = [