fix: resolve new clippy warnings (TheAlgorithms#926)

Author: vil02

src/ciphers/aes.rs

@@ -318,7 +318,7 @@ fn key_expansion(init_key: &[Byte], num_rounds: usize) -> Vec<Byte> {
 }
 
 fn add_round_key(data: &mut [Byte], round_key: &[Byte]) {
-    assert!(data.len() % AES_BLOCK_SIZE == 0 && round_key.len() == AES_BLOCK_SIZE);
+    assert!(data.len().is_multiple_of(AES_BLOCK_SIZE) && round_key.len() == AES_BLOCK_SIZE);
     let num_blocks = data.len() / AES_BLOCK_SIZE;
     data.iter_mut()
         .zip(round_key.repeat(num_blocks))
@@ -348,7 +348,7 @@ fn mix_column_blocks(data: &mut [Byte], mode: AesMode) {
 }
 
 fn padding<T: Clone + Default>(data: &[T], block_size: usize) -> Vec<T> {
-    if data.len() % block_size == 0 {
+    if data.len().is_multiple_of(block_size) {
         Vec::from(data)
     } else {
         let num_blocks = data.len() / block_size + 1;

src/ciphers/blake2b.rs

@@ -55,7 +55,7 @@ fn add(a: &mut Word, b: Word) {
 
 #[inline]
 const fn ceil(dividend: usize, divisor: usize) -> usize {
-    (dividend / divisor) + ((dividend % divisor != 0) as usize)
+    (dividend / divisor) + (!dividend.is_multiple_of(divisor) as usize)
 }
 
 fn g(v: &mut [Word; 16], a: usize, b: usize, c: usize, d: usize, x: Word, y: Word) {

src/ciphers/diffie_hellman.rs

@@ -228,10 +228,7 @@ impl DiffieHellman {
     // Both parties now have the same shared secret key s which can be used for encryption or authentication.
 
     pub fn new(group: Option<u8>) -> Self {
-        let mut _group: u8 = 14;
-        if let Some(x) = group {
-            _group = x;
-        }
+        let _group = group.unwrap_or(14);
 
         if !PRIMES.contains_key(&_group) {
             panic!("group not in primes")

src/ciphers/sha3.rs

@@ -271,10 +271,10 @@ fn h2b(h: &[u8], n: usize) -> Vec<bool> {
 }
 
 fn b2h(s: &[bool]) -> Vec<u8> {
-    let m = if s.len() % U8BITS != 0 {
-        (s.len() / 8) + 1
-    } else {
+    let m = if s.len().is_multiple_of(U8BITS) {
         s.len() / 8
+    } else {
+        (s.len() / 8) + 1
     };
     let mut bytes = vec![0u8; m];
 

src/data_structures/probabilistic/bloom_filter.rs

@@ -109,7 +109,7 @@ pub struct MultiBinaryBloomFilter {
 
 impl MultiBinaryBloomFilter {
     pub fn with_dimensions(filter_size: usize, hash_count: usize) -> Self {
-        let bytes_count = filter_size / 8 + usize::from(filter_size % 8 > 0); // we need 8 times less entries in the array, since we are using bytes. Careful that we have at least one element though
+        let bytes_count = filter_size / 8 + usize::from(!filter_size.is_multiple_of(8)); // we need 8 times less entries in the array, since we are using bytes. Careful that we have at least one element though
         Self {
             filter_size,
             bytes: vec![0; bytes_count],

src/general/permutations/heap.rs

@@ -23,7 +23,7 @@ fn heap_recurse<T: Clone + Debug>(arr: &mut [T], k: usize, collector: &mut Vec<V
     // Heap's algorithm has a more clever way of permuting the elements so that we never need to swap back!
     for i in 0..k {
         // now deal with [a, b]
-        let swap_idx = if k % 2 == 0 { i } else { 0 };
+        let swap_idx = if k.is_multiple_of(2) { i } else { 0 };
         arr.swap(swap_idx, k - 1);
         heap_recurse(arr, k - 1, collector);
     }

src/machine_learning/loss_function/kl_divergence_loss.rs

@@ -16,7 +16,7 @@ pub fn kld_loss(actual: &[f64], predicted: &[f64]) -> f64 {
     let loss: f64 = actual
         .iter()
         .zip(predicted.iter())
-        .map(|(&a, &p)| ((a + eps) * ((a + eps) / (p + eps)).ln()))
+        .map(|(&a, &p)| (a + eps) * ((a + eps) / (p + eps)).ln())
         .sum();
     loss
 }

src/math/aliquot_sum.rs

@@ -11,7 +11,7 @@ pub fn aliquot_sum(number: u64) -> u64 {
         panic!("Input has to be positive.")
     }
 
-    (1..=number / 2).filter(|&d| number % d == 0).sum()
+    (1..=number / 2).filter(|&d| number.is_multiple_of(d)).sum()
 }
 
 #[cfg(test)]

src/math/collatz_sequence.rs

@@ -6,7 +6,7 @@ pub fn sequence(mut n: usize) -> Option<Vec<usize>> {
     let mut list: Vec<usize> = vec![];
     while n != 1 {
         list.push(n);
-        if n % 2 == 0 {
+        if n.is_multiple_of(2) {
             n /= 2;
         } else {
             n = 3 * n + 1;

src/math/factors.rs

@@ -7,7 +7,7 @@ pub fn factors(number: u64) -> Vec<u64> {
     let mut factors: Vec<u64> = Vec::new();
 
     for i in 1..=((number as f64).sqrt() as u64) {
-        if number % i == 0 {
+        if number.is_multiple_of(i) {
             factors.push(i);
             if i != number / i {
                 factors.push(number / i);