cargo clippied factor_bench and rollback the conversion for u128 (big_uint represents u128 nums with u64s and bit shifting)

Author: asder8215

src/uu/factor/benches/factor_bench.rs

@@ -11,7 +11,7 @@ use uucore::benchmark::run_util_function;
 #[divan::bench]
 fn factor_single_u64(bencher: Bencher) {
     bencher
-        .with_inputs(|| 1000000 as u64)
+        .with_inputs(|| 1000000_u64)
         .bench_values(|single_u64| {
             black_box(run_util_function(uumain, &[&single_u64.to_string()]));
         });
@@ -21,9 +21,9 @@ fn factor_single_u64(bencher: Bencher) {
 #[divan::bench]
 fn factor_multiple_u64s(bencher: Bencher) {
     bencher
-        .with_inputs(|| (2 as u64, 1000000 as u64))
+        .with_inputs(|| (2_u64, 1000000_u64))
         .bench_values(|(start_u64, end_u64)| {
-            for u64_digit in start_u64..end_u64 + 1 {
+            for u64_digit in start_u64..=end_u64 {
                 black_box(run_util_function(uumain, &[&u64_digit.to_string()]));
             }
         });
@@ -33,7 +33,7 @@ fn factor_multiple_u64s(bencher: Bencher) {
 #[divan::bench]
 fn factor_single_u128(bencher: Bencher) {
     bencher
-        .with_inputs(|| 18446744073709551616 as u128)
+        .with_inputs(|| 18446744073709551616_u128)
         .bench_values(|single_u128| {
             black_box(run_util_function(uumain, &[&single_u128.to_string()]));
         });
@@ -45,10 +45,10 @@ fn factor_multiple_u128s(bencher: Bencher) {
     bencher
         .with_inputs(|| {
             // this is a range of 1 million different u128 integers
-            (18446744073709551616 as u128, 18446744073710551616 as u128)
+            (18446744073709551616_u128, 18446744073710551616_u128)
         })
         .bench_values(|(start_u128, end_u128)| {
-            for u128_digit in start_u128..end_u128 + 1 {
+            for u128_digit in start_u128..=end_u128 {
                 black_box(run_util_function(uumain, &[&u128_digit.to_string()]));
             }
         });
@@ -61,7 +61,7 @@ fn factor_single_big_uint(bencher: Bencher) {
     bencher
         .with_inputs(|| "340_282_366_920_938_463_463_374_607_431_768_211_456")
         .bench_values(|single_big_uint| {
-            black_box(run_util_function(uumain, &[&single_big_uint.to_string()]));
+            black_box(run_util_function(uumain, &[single_big_uint]));
         });
 }
 
@@ -70,11 +70,11 @@ fn factor_single_big_uint(bencher: Bencher) {
 fn factor_multiple_big_uint(bencher: Bencher) {
     // max u128 value is 340_282_366_920_938_463_463_374_607_431_768_211_455
     bencher
-        .with_inputs(|| (768_211_456, 769_211_456))
+        .with_inputs(|| (768_211_456_u64, 769_211_456_u64))
         .bench_values(|(start_big_uint, end_big_uint)| {
-            for digit in start_big_uint..end_big_uint + 1 {
-                let big_uint_str = format!("340282366920938463463374607431768211456{}", digit);
-                black_box(run_util_function(uumain, &[&big_uint_str.to_string()]));
+            for digit in start_big_uint..=end_big_uint {
+                let big_uint_str = format!("340282366920938463463374607431768211456{digit}");
+                black_box(run_util_function(uumain, &[&big_uint_str]));
             }
         });
 }

src/uu/factor/src/factor.rs

@@ -45,10 +45,13 @@ fn print_factors_str(
         }
         // use num_prime's factorize128 algorithm for u128 integers
         else if x <= BigUint::from_u128(u128::MAX).unwrap() {
-            // if it's a u128 integer, BigUint will have two u64 digits
-            // in its Vec<u64>, which index 0 is treated as u64::MAX
-            let big_uint_u64s = x.clone().to_u64_digits();
-            let x = u64::MAX as u128 + big_uint_u64s[1] as u128;
+            let rx = num_str.trim().parse::<u128>();
+            let Ok(x) = rx else {
+                // return Ok(). it's non-fatal and we should try the next number.
+                show_warning!("{}: {}", num_str.maybe_quote(), rx.unwrap_err());
+                set_exit_code(1);
+                return Ok(());
+            };
             let prime_factors = num_prime::nt_funcs::factorize128(x);
             write_result_u128(w, &x, prime_factors, print_exponents)
                 .map_err_context(|| translate!("factor-error-write-error"))?;