also implement left shifts for {u,i}256

Author: quaternic

libm/src/math/support/big.rs

@@ -109,14 +109,6 @@ macro_rules! impl_common {
             }
         }
 
-        impl ops::Shl<u32> for $ty {
-            type Output = Self;
-
-            fn shl(self, _rhs: u32) -> Self::Output {
-                unimplemented!("only used to meet trait bounds")
-            }
-        }
-
         impl ops::Add<Self> for $ty {
             type Output = Self;
 
@@ -149,6 +141,32 @@ macro_rules! impl_common {
             }
         }
 
+        impl ops::Shl<u32> for $ty {
+            type Output = Self;
+
+            fn shl(mut self, rhs: u32) -> Self::Output {
+                debug_assert!(rhs < Self::BITS, "attempt to shift left with overflow");
+
+                let half_bits = Self::BITS / 2;
+                let low_mask = half_bits - 1;
+                let s = rhs & low_mask;
+
+                let lo = self.lo;
+                let hi = self.hi;
+
+                self.lo = lo << s;
+
+                if rhs & half_bits == 0 {
+                    self.hi = (lo >> (low_mask ^ s) >> 1) as _;
+                    self.hi |= hi << s;
+                } else {
+                    self.hi = self.lo as _;
+                    self.lo = 0;
+                }
+                self
+            }
+        }
+
         impl ops::Shr<u32> for $ty {
             type Output = Self;
 

libm/src/math/support/big/tests.rs

@@ -298,3 +298,41 @@ fn i256_ord() {
         assert!([wx, wx + _1, wx + _2, wy - _2, wy - _1, wy].is_sorted());
     }
 }
+
+#[test]
+fn u256_shifts() {
+    let _1 = u256::ONE;
+    for k in 0..255 {
+        let x = _1 << k;
+        let x2 = _1 << (k + 1);
+        assert!(x < x2);
+        assert_eq!(x << 1, x2);
+        assert_eq!(x + x, x2);
+        assert_eq!(x >> k, _1);
+        assert_eq!(x2 >> (k + 1), _1);
+    }
+}
+#[test]
+fn i256_shifts() {
+    let _1 = i256::ONE;
+    for k in 0..254 {
+        let x = _1 << k;
+        let x2 = _1 << (k + 1);
+        assert!(x < x2);
+        assert_eq!(x << 1, x2);
+        assert_eq!(x + x, x2);
+        assert_eq!(x >> k, _1);
+        assert_eq!(x2 >> (k + 1), _1);
+    }
+
+    let min = _1 << 255;
+    assert_eq!(min, i256::MIN);
+    let mut x = min;
+    for k in 0..255 {
+        assert_eq!(x, min >> k);
+        let y = x >> 1;
+        assert_eq!(y + y, x);
+        assert!(x < y);
+        x = y;
+    }
+}