Skip to content

Commit 0cbecda

Browse files
matthiaskrgrmatthiaskrgr
authored
Rollup merge of rust-lang#100332 - eholk:stabilize-ilog, r=scottmcm
Rename integer log* methods to ilog* This reflects the concensus from the libs team as reported at rust-lang#70887 (comment). Joint work with `@yoshuawuyts.`
2 parents f9d6cc5 + 0fd4db3 commit 0cbecda

File tree

8 files changed

+134
-134
lines changed

8 files changed

+134
-134
lines changed

‎library/core/benches/num/int_log/mod.rs

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@ macro_rules! int_log_bench {
99
for n in 0..(<$t>::BITS / 8) {
1010
for i in 1..=(100 as $t) {
1111
let x = black_box(i << (n * 8));
12-
black_box(x.log10());
12+
black_box(x.ilog10());
1313
}
1414
}
1515
});
@@ -27,7 +27,7 @@ macro_rules! int_log_bench {
2727
.collect();
2828
bench.iter(|| {
2929
for x in &numbers {
30-
black_box(black_box(x).log10());
30+
black_box(black_box(x).ilog10());
3131
}
3232
});
3333
}
@@ -44,7 +44,7 @@ macro_rules! int_log_bench {
4444
.collect();
4545
bench.iter(|| {
4646
for x in &numbers {
47-
black_box(black_box(x).log10());
47+
black_box(black_box(x).ilog10());
4848
}
4949
});
5050
}

‎library/core/src/num/bignum.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -137,7 +137,7 @@ macro_rules! define_bignum {
137137
// Find the most significant non-zero digit.
138138
let msd = digits.iter().rposition(|&x| x != 0);
139139
match msd {
140-
Some(msd) => msd * digitbits + digits[msd].log2() as usize + 1,
140+
Some(msd) => msd * digitbits + digits[msd].ilog2() as usize + 1,
141141
// There are no non-zero digits, i.e., the number is zero.
142142
_ => 0,
143143
}

‎library/core/src/num/int_macros.rs

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -2204,7 +2204,7 @@ macro_rules! int_impl {
22042204
/// rounded down.
22052205
///
22062206
/// This method might not be optimized owing to implementation details;
2207-
/// `log2` can produce results more efficiently for base 2, and `log10`
2207+
/// `ilog2` can produce results more efficiently for base 2, and `ilog10`
22082208
/// can produce results more efficiently for base 10.
22092209
///
22102210
/// # Panics
@@ -2217,7 +2217,7 @@ macro_rules! int_impl {
22172217
///
22182218
/// ```
22192219
/// #![feature(int_log)]
2220-
#[doc = concat!("assert_eq!(5", stringify!($SelfT), ".log(5), 1);")]
2220+
#[doc = concat!("assert_eq!(5", stringify!($SelfT), ".ilog(5), 1);")]
22212221
/// ```
22222222
#[unstable(feature = "int_log", issue = "70887")]
22232223
#[must_use = "this returns the result of the operation, \
@@ -2226,8 +2226,8 @@ macro_rules! int_impl {
22262226
#[track_caller]
22272227
#[rustc_inherit_overflow_checks]
22282228
#[allow(arithmetic_overflow)]
2229-
pub const fn log(self, base: Self) -> u32 {
2230-
match self.checked_log(base) {
2229+
pub const fn ilog(self, base: Self) -> u32 {
2230+
match self.checked_ilog(base) {
22312231
Some(n) => n,
22322232
None => {
22332233
// In debug builds, trigger a panic on None.
@@ -2250,7 +2250,7 @@ macro_rules! int_impl {
22502250
///
22512251
/// ```
22522252
/// #![feature(int_log)]
2253-
#[doc = concat!("assert_eq!(2", stringify!($SelfT), ".log2(), 1);")]
2253+
#[doc = concat!("assert_eq!(2", stringify!($SelfT), ".ilog2(), 1);")]
22542254
/// ```
22552255
#[unstable(feature = "int_log", issue = "70887")]
22562256
#[must_use = "this returns the result of the operation, \
@@ -2259,8 +2259,8 @@ macro_rules! int_impl {
22592259
#[track_caller]
22602260
#[rustc_inherit_overflow_checks]
22612261
#[allow(arithmetic_overflow)]
2262-
pub const fn log2(self) -> u32 {
2263-
match self.checked_log2() {
2262+
pub const fn ilog2(self) -> u32 {
2263+
match self.checked_ilog2() {
22642264
Some(n) => n,
22652265
None => {
22662266
// In debug builds, trigger a panic on None.
@@ -2283,7 +2283,7 @@ macro_rules! int_impl {
22832283
///
22842284
/// ```
22852285
/// #![feature(int_log)]
2286-
#[doc = concat!("assert_eq!(10", stringify!($SelfT), ".log10(), 1);")]
2286+
#[doc = concat!("assert_eq!(10", stringify!($SelfT), ".ilog10(), 1);")]
22872287
/// ```
22882288
#[unstable(feature = "int_log", issue = "70887")]
22892289
#[must_use = "this returns the result of the operation, \
@@ -2292,8 +2292,8 @@ macro_rules! int_impl {
22922292
#[track_caller]
22932293
#[rustc_inherit_overflow_checks]
22942294
#[allow(arithmetic_overflow)]
2295-
pub const fn log10(self) -> u32 {
2296-
match self.checked_log10() {
2295+
pub const fn ilog10(self) -> u32 {
2296+
match self.checked_ilog10() {
22972297
Some(n) => n,
22982298
None => {
22992299
// In debug builds, trigger a panic on None.
@@ -2311,20 +2311,20 @@ macro_rules! int_impl {
23112311
/// Returns `None` if the number is negative or zero, or if the base is not at least 2.
23122312
///
23132313
/// This method might not be optimized owing to implementation details;
2314-
/// `checked_log2` can produce results more efficiently for base 2, and
2315-
/// `checked_log10` can produce results more efficiently for base 10.
2314+
/// `checked_ilog2` can produce results more efficiently for base 2, and
2315+
/// `checked_ilog10` can produce results more efficiently for base 10.
23162316
///
23172317
/// # Examples
23182318
///
23192319
/// ```
23202320
/// #![feature(int_log)]
2321-
#[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_log(5), Some(1));")]
2321+
#[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_ilog(5), Some(1));")]
23222322
/// ```
23232323
#[unstable(feature = "int_log", issue = "70887")]
23242324
#[must_use = "this returns the result of the operation, \
23252325
without modifying the original"]
23262326
#[inline]
2327-
pub const fn checked_log(self, base: Self) -> Option<u32> {
2327+
pub const fn checked_ilog(self, base: Self) -> Option<u32> {
23282328
if self <= 0 || base <= 1 {
23292329
None
23302330
} else {
@@ -2333,7 +2333,7 @@ macro_rules! int_impl {
23332333

23342334
// Optimization for 128 bit wide integers.
23352335
if Self::BITS == 128 {
2336-
let b = Self::log2(self) / (Self::log2(base) + 1);
2336+
let b = Self::ilog2(self) / (Self::ilog2(base) + 1);
23372337
n += b;
23382338
r /= base.pow(b as u32);
23392339
}
@@ -2354,13 +2354,13 @@ macro_rules! int_impl {
23542354
///
23552355
/// ```
23562356
/// #![feature(int_log)]
2357-
#[doc = concat!("assert_eq!(2", stringify!($SelfT), ".checked_log2(), Some(1));")]
2357+
#[doc = concat!("assert_eq!(2", stringify!($SelfT), ".checked_ilog2(), Some(1));")]
23582358
/// ```
23592359
#[unstable(feature = "int_log", issue = "70887")]
23602360
#[must_use = "this returns the result of the operation, \
23612361
without modifying the original"]
23622362
#[inline]
2363-
pub const fn checked_log2(self) -> Option<u32> {
2363+
pub const fn checked_ilog2(self) -> Option<u32> {
23642364
if self <= 0 {
23652365
None
23662366
} else {
@@ -2378,13 +2378,13 @@ macro_rules! int_impl {
23782378
///
23792379
/// ```
23802380
/// #![feature(int_log)]
2381-
#[doc = concat!("assert_eq!(10", stringify!($SelfT), ".checked_log10(), Some(1));")]
2381+
#[doc = concat!("assert_eq!(10", stringify!($SelfT), ".checked_ilog10(), Some(1));")]
23822382
/// ```
23832383
#[unstable(feature = "int_log", issue = "70887")]
23842384
#[must_use = "this returns the result of the operation, \
23852385
without modifying the original"]
23862386
#[inline]
2387-
pub const fn checked_log10(self) -> Option<u32> {
2387+
pub const fn checked_ilog10(self) -> Option<u32> {
23882388
if self > 0 {
23892389
Some(int_log10::$ActualT(self as $ActualT))
23902390
} else {

‎library/core/src/num/nonzero.rs

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -450,7 +450,7 @@ macro_rules! nonzero_unsigned_operations {
450450
/// Returns the base 2 logarithm of the number, rounded down.
451451
///
452452
/// This is the same operation as
453-
#[doc = concat!("[`", stringify!($Int), "::log2`],")]
453+
#[doc = concat!("[`", stringify!($Int), "::ilog2`],")]
454454
/// except that it has no failure cases to worry about
455455
/// since this value can never be zero.
456456
///
@@ -460,22 +460,22 @@ macro_rules! nonzero_unsigned_operations {
460460
/// #![feature(int_log)]
461461
#[doc = concat!("# use std::num::", stringify!($Ty), ";")]
462462
///
463-
#[doc = concat!("assert_eq!(", stringify!($Ty), "::new(7).unwrap().log2(), 2);")]
464-
#[doc = concat!("assert_eq!(", stringify!($Ty), "::new(8).unwrap().log2(), 3);")]
465-
#[doc = concat!("assert_eq!(", stringify!($Ty), "::new(9).unwrap().log2(), 3);")]
463+
#[doc = concat!("assert_eq!(", stringify!($Ty), "::new(7).unwrap().ilog2(), 2);")]
464+
#[doc = concat!("assert_eq!(", stringify!($Ty), "::new(8).unwrap().ilog2(), 3);")]
465+
#[doc = concat!("assert_eq!(", stringify!($Ty), "::new(9).unwrap().ilog2(), 3);")]
466466
/// ```
467467
#[unstable(feature = "int_log", issue = "70887")]
468468
#[must_use = "this returns the result of the operation, \
469469
without modifying the original"]
470470
#[inline]
471-
pub const fn log2(self) -> u32 {
471+
pub const fn ilog2(self) -> u32 {
472472
Self::BITS - 1 - self.leading_zeros()
473473
}
474474

475475
/// Returns the base 10 logarithm of the number, rounded down.
476476
///
477477
/// This is the same operation as
478-
#[doc = concat!("[`", stringify!($Int), "::log10`],")]
478+
#[doc = concat!("[`", stringify!($Int), "::ilog10`],")]
479479
/// except that it has no failure cases to worry about
480480
/// since this value can never be zero.
481481
///
@@ -485,15 +485,15 @@ macro_rules! nonzero_unsigned_operations {
485485
/// #![feature(int_log)]
486486
#[doc = concat!("# use std::num::", stringify!($Ty), ";")]
487487
///
488-
#[doc = concat!("assert_eq!(", stringify!($Ty), "::new(99).unwrap().log10(), 1);")]
489-
#[doc = concat!("assert_eq!(", stringify!($Ty), "::new(100).unwrap().log10(), 2);")]
490-
#[doc = concat!("assert_eq!(", stringify!($Ty), "::new(101).unwrap().log10(), 2);")]
488+
#[doc = concat!("assert_eq!(", stringify!($Ty), "::new(99).unwrap().ilog10(), 1);")]
489+
#[doc = concat!("assert_eq!(", stringify!($Ty), "::new(100).unwrap().ilog10(), 2);")]
490+
#[doc = concat!("assert_eq!(", stringify!($Ty), "::new(101).unwrap().ilog10(), 2);")]
491491
/// ```
492492
#[unstable(feature = "int_log", issue = "70887")]
493493
#[must_use = "this returns the result of the operation, \
494494
without modifying the original"]
495495
#[inline]
496-
pub const fn log10(self) -> u32 {
496+
pub const fn ilog10(self) -> u32 {
497497
super::int_log10::$Int(self.0)
498498
}
499499
}

‎library/core/src/num/uint_macros.rs

Lines changed: 20 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -700,7 +700,7 @@ macro_rules! uint_impl {
700700
///
701701
/// ```
702702
/// #![feature(int_log)]
703-
#[doc = concat!("assert_eq!(5", stringify!($SelfT), ".log(5), 1);")]
703+
#[doc = concat!("assert_eq!(5", stringify!($SelfT), ".ilog(5), 1);")]
704704
/// ```
705705
#[unstable(feature = "int_log", issue = "70887")]
706706
#[must_use = "this returns the result of the operation, \
@@ -709,8 +709,8 @@ macro_rules! uint_impl {
709709
#[track_caller]
710710
#[rustc_inherit_overflow_checks]
711711
#[allow(arithmetic_overflow)]
712-
pub const fn log(self, base: Self) -> u32 {
713-
match self.checked_log(base) {
712+
pub const fn ilog(self, base: Self) -> u32 {
713+
match self.checked_ilog(base) {
714714
Some(n) => n,
715715
None => {
716716
// In debug builds, trigger a panic on None.
@@ -733,7 +733,7 @@ macro_rules! uint_impl {
733733
///
734734
/// ```
735735
/// #![feature(int_log)]
736-
#[doc = concat!("assert_eq!(2", stringify!($SelfT), ".log2(), 1);")]
736+
#[doc = concat!("assert_eq!(2", stringify!($SelfT), ".ilog2(), 1);")]
737737
/// ```
738738
#[unstable(feature = "int_log", issue = "70887")]
739739
#[must_use = "this returns the result of the operation, \
@@ -742,8 +742,8 @@ macro_rules! uint_impl {
742742
#[track_caller]
743743
#[rustc_inherit_overflow_checks]
744744
#[allow(arithmetic_overflow)]
745-
pub const fn log2(self) -> u32 {
746-
match self.checked_log2() {
745+
pub const fn ilog2(self) -> u32 {
746+
match self.checked_ilog2() {
747747
Some(n) => n,
748748
None => {
749749
// In debug builds, trigger a panic on None.
@@ -766,7 +766,7 @@ macro_rules! uint_impl {
766766
///
767767
/// ```
768768
/// #![feature(int_log)]
769-
#[doc = concat!("assert_eq!(10", stringify!($SelfT), ".log10(), 1);")]
769+
#[doc = concat!("assert_eq!(10", stringify!($SelfT), ".ilog10(), 1);")]
770770
/// ```
771771
#[unstable(feature = "int_log", issue = "70887")]
772772
#[must_use = "this returns the result of the operation, \
@@ -775,8 +775,8 @@ macro_rules! uint_impl {
775775
#[track_caller]
776776
#[rustc_inherit_overflow_checks]
777777
#[allow(arithmetic_overflow)]
778-
pub const fn log10(self) -> u32 {
779-
match self.checked_log10() {
778+
pub const fn ilog10(self) -> u32 {
779+
match self.checked_ilog10() {
780780
Some(n) => n,
781781
None => {
782782
// In debug builds, trigger a panic on None.
@@ -794,20 +794,20 @@ macro_rules! uint_impl {
794794
/// Returns `None` if the number is zero, or if the base is not at least 2.
795795
///
796796
/// This method might not be optimized owing to implementation details;
797-
/// `checked_log2` can produce results more efficiently for base 2, and
798-
/// `checked_log10` can produce results more efficiently for base 10.
797+
/// `checked_ilog2` can produce results more efficiently for base 2, and
798+
/// `checked_ilog10` can produce results more efficiently for base 10.
799799
///
800800
/// # Examples
801801
///
802802
/// ```
803803
/// #![feature(int_log)]
804-
#[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_log(5), Some(1));")]
804+
#[doc = concat!("assert_eq!(5", stringify!($SelfT), ".checked_ilog(5), Some(1));")]
805805
/// ```
806806
#[unstable(feature = "int_log", issue = "70887")]
807807
#[must_use = "this returns the result of the operation, \
808808
without modifying the original"]
809809
#[inline]
810-
pub const fn checked_log(self, base: Self) -> Option<u32> {
810+
pub const fn checked_ilog(self, base: Self) -> Option<u32> {
811811
if self <= 0 || base <= 1 {
812812
None
813813
} else {
@@ -816,7 +816,7 @@ macro_rules! uint_impl {
816816

817817
// Optimization for 128 bit wide integers.
818818
if Self::BITS == 128 {
819-
let b = Self::log2(self) / (Self::log2(base) + 1);
819+
let b = Self::ilog2(self) / (Self::ilog2(base) + 1);
820820
n += b;
821821
r /= base.pow(b as u32);
822822
}
@@ -837,15 +837,15 @@ macro_rules! uint_impl {
837837
///
838838
/// ```
839839
/// #![feature(int_log)]
840-
#[doc = concat!("assert_eq!(2", stringify!($SelfT), ".checked_log2(), Some(1));")]
840+
#[doc = concat!("assert_eq!(2", stringify!($SelfT), ".checked_ilog2(), Some(1));")]
841841
/// ```
842842
#[unstable(feature = "int_log", issue = "70887")]
843843
#[must_use = "this returns the result of the operation, \
844844
without modifying the original"]
845845
#[inline]
846-
pub const fn checked_log2(self) -> Option<u32> {
846+
pub const fn checked_ilog2(self) -> Option<u32> {
847847
if let Some(x) = <$NonZeroT>::new(self) {
848-
Some(x.log2())
848+
Some(x.ilog2())
849849
} else {
850850
None
851851
}
@@ -859,15 +859,15 @@ macro_rules! uint_impl {
859859
///
860860
/// ```
861861
/// #![feature(int_log)]
862-
#[doc = concat!("assert_eq!(10", stringify!($SelfT), ".checked_log10(), Some(1));")]
862+
#[doc = concat!("assert_eq!(10", stringify!($SelfT), ".checked_ilog10(), Some(1));")]
863863
/// ```
864864
#[unstable(feature = "int_log", issue = "70887")]
865865
#[must_use = "this returns the result of the operation, \
866866
without modifying the original"]
867867
#[inline]
868-
pub const fn checked_log10(self) -> Option<u32> {
868+
pub const fn checked_ilog10(self) -> Option<u32> {
869869
if let Some(x) = <$NonZeroT>::new(self) {
870-
Some(x.log10())
870+
Some(x.ilog10())
871871
} else {
872872
None
873873
}

‎library/core/src/time.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1135,7 +1135,7 @@ impl fmt::Debug for Duration {
11351135
// 2. The postfix: can be "µs" so we have to count UTF8 characters.
11361136
let mut actual_w = prefix.len() + postfix.chars().count();
11371137
// 3. The integer part:
1138-
if let Some(log) = integer_part.checked_log10() {
1138+
if let Some(log) = integer_part.checked_ilog10() {
11391139
// integer_part is > 0, so has length log10(x)+1
11401140
actual_w += 1 + log as usize;
11411141
} else {

0 commit comments

Comments
 (0)