Optimize .ilog({2,10}) to .ilog{2,10}()

Switch to faster methods when base is statically known.

Author: ChaiTRex

library/core/src/num/uint_macros.rs

@@ -1491,17 +1491,19 @@ macro_rules! uint_impl {
                       without modifying the original"]
         #[inline]
         pub const fn checked_ilog(self, base: Self) -> Option<u32> {
-            if self <= 0 || base <= 1 {
-                None
-            } else if self < base {
-                Some(0)
-            } else {
-                // Since base >= self, n >= 1
+            // Preconditions for calling inner function `slow_ilog`:
+            //
+            // 1: base >= 2
+            // 2: x >= 1
+            // 3: x >= base
+            #[inline(always)]
+            const fn slow_ilog(x: $SelfT, base: $SelfT) -> u32 {
+                // Since x >= base, n >= 1
                 let mut n = 1;
                 let mut r = base;
 
                 // Optimization for 128 bit wide integers.
-                if Self::BITS == 128 {
+                if <$SelfT>::BITS == 128 {
                     // The following is a correct lower bound for ⌊log(base,self)⌋ because
                     //
                     // log(base,self) = log(2,self) / log(2,base)
@@ -1510,15 +1512,59 @@ macro_rules! uint_impl {
                     // hence
                     //
                     // ⌊log(base,self)⌋ ≥ ⌊ ⌊log(2,self)⌋ / (⌊log(2,base)⌋ + 1) ⌋ .
-                    n = self.ilog2() / (base.ilog2() + 1);
+                    n = x.ilog2() / (base.ilog2() + 1);
                     r = base.pow(n);
                 }
 
-                while r <= self / base {
+                while r <= x / base {
                     n += 1;
                     r *= base;
                 }
-                Some(n)
+                n
+            }
+
+            if core::intrinsics::is_val_statically_known(self) {
+                if self <= 0 { // precondition 2
+                    None
+                } else if core::intrinsics::is_val_statically_known(base) {
+                    if base <= 1 { // precondition 1
+                        None
+                    } else if self < base { // precondition 3
+                        Some(0)
+                    } else if base == 2 {
+                        self.checked_ilog2()
+                    } else if base == 10 {
+                        self.checked_ilog10()
+                    } else { // all preconditions satisfied
+                        Some(slow_ilog(self, base))
+                    }
+                } else if base <= 1 { // precondition 1
+                    None
+                } else if self < base { // precondition 3
+                    Some(0)
+                } else { // all preconditions satisfied
+                    Some(slow_ilog(self, base))
+                }
+            } else if core::intrinsics::is_val_statically_known(base) {
+                if base <= 1 { // precondition 1
+                    None
+                } else if base == 2 {
+                    self.checked_ilog2()
+                } else if base == 10 {
+                    self.checked_ilog10()
+                } else if self <= 0 { // precondition 2
+                    None
+                } else if self < base { // precondition 3
+                    Some(0)
+                } else { // all preconditions satisfied
+                    Some(slow_ilog(self, base))
+                }
+            } else if self <= 0 || base <= 1 { // preconditions 1 and 2
+                None
+            } else if self < base { // precondition 3
+                Some(0)
+            } else { // all preconditions satisfied
+                Some(slow_ilog(self, base))
             }
         }