Add bigint shr

Author: tgross35

src/float/div.rs

@@ -332,8 +332,8 @@ where
         b_significand,
     );
 
-    // Transform to a fixed-point representation. We know this is in the range [1.0, 2.0] since
-    // the explicit bit is set.
+    // Transform to a fixed-point representation by shifting the significand to the high bits. We
+    // know this is in the range [1.0, 2.0] since the explicit bit is set above.
     let b_uq1 = b_significand << (F::BITS - significand_bits - 1);
 
     println!("b_uq1: {:#034x}", b_uq1);
@@ -632,6 +632,9 @@ where
     F::from_repr(abs_result | quotient_sign)
 }
 
+/// Perform one iteration at any width.
+///
+/// Given
 fn iter_once<I>(x_uq0: I, b_uq1: I) -> I
 where
     I: Int + HInt,

src/int/big.rs

@@ -96,19 +96,56 @@ macro_rules! impl_common {
                 unimplemented!("only used to meet trait bounds")
             }
         }
-
-        impl ops::Shr<u32> for $ty {
-            type Output = Self;
-
-            fn shr(self, rhs: u32) -> Self::Output {
-                unimplemented!("only used to meet trait bounds")
-            }
-        }
     };
 }
 
 impl_common!(i256);
 impl_common!(u256);
+extern crate std;
+use std::dbg;
+
+impl ops::Shr<u32> for u256 {
+    type Output = Self;
+
+    fn shr(self, rhs: u32) -> Self::Output {
+        debug_assert!(rhs < Self::BITS, "attempted to shift right with overflow");
+
+        if rhs >= Self::BITS {
+            // Only happens when not in debug mode
+            return Self::ZERO;
+        }
+
+        if rhs == 0 {
+            return self;
+        }
+
+        let mut ret = self;
+        let byte_shift = rhs / 64;
+        let bit_shift = rhs % 64;
+
+        dbg!(self, rhs, byte_shift, bit_shift);
+
+        for idx in 0..4 {
+            let base_idx = idx + byte_shift as usize;
+            dbg!(base_idx);
+
+            let Some(base) = ret.0.get(base_idx) else {
+                continue;
+            };
+            dbg!(base);
+
+            let mut new_val = base >> bit_shift;
+
+            if let Some(new) = ret.0.get(base_idx + 1) {
+                new_val |= new.overflowing_shl(64 - bit_shift).0;
+            }
+
+            ret.0[idx] = new_val;
+        }
+
+        ret
+    }
+}
 
 macro_rules! word {
     (1, $val:expr) => {

testcrate/tests/big.rs

@@ -59,3 +59,65 @@ fn widen_mul_u128() {
     }
     assert!(errors.is_empty());
 }
+
+#[test]
+fn not_u128() {
+    assert_eq!(!u256::ZERO, u256::MAX);
+}
+
+#[test]
+fn shr_u128() {
+    let lo_a = [1, 2, 3, 10, u16::MAX as u128, u32::MAX as u128, u128::MAX];
+    let b = [0, 1, 2, 4, 10, 31, 32, 33, 64, 96, 127];
+
+    let mut errors = Vec::new();
+
+    for a in lo_a {
+        for b in b {
+            let res = a.widen() >> b;
+            let expected = (a >> b).widen();
+            if res != expected {
+                errors.push((a, b, res, expected));
+            }
+        }
+    }
+
+    for (a, b, res, expected) in &errors {
+        eprintln!(
+            "FAILURE: {a:#034x} >> {b} = {} got {}",
+            hexu(*expected),
+            hexu(*res),
+        );
+    }
+    assert!(errors.is_empty());
+}
+
+// #[test]
+// fn shr_u128() {
+//     let tests = [
+//         (u128::MAX / 2, 2_u128, u256([u64::MAX - 1, u64::MAX, 0, 0])),
+//         (u128::MAX, 2_u128, u256([u64::MAX - 1, u64::MAX, 1, 0])),
+//         (u128::MAX, u128::MAX, u256([1, 0, u64::MAX - 1, u64::MAX])),
+//         (u128::MIN, u128::MIN, u256::ZERO),
+//         (1234, 0, u256::ZERO),
+//         (0, 1234, u256::ZERO),
+//     ];
+
+//     let mut errors = Vec::new();
+//     for (i, (a, b, exp)) in tests.iter().copied().enumerate() {
+//         let res = a.widen_mul(b);
+//         assert_eq!(res, res_z);
+//         if res != exp {
+//             errors.push((i, a, b, exp, res));
+//         }
+//     }
+
+//     for (i, a, b, exp, res) in &errors {
+//         eprintln!(
+//             "FAILURE ({i}): {a:#034x} * {b:#034x} = {} got {}",
+//             hexu(*exp),
+//             hexu(*res)
+//         );
+//     }
+//     assert!(errors.is_empty());
+// }