refactor: Simplify variable usage in karatsuba_multiply function for clarity

Author: weilycoder

weilycoder/poly/karatsuba.hpp

@@ -36,19 +36,13 @@ void karatsuba_multiply(InputIt a_begin, InputIt a_end, InputIt b_begin, InputIt
   size_t half_size = std::max(a_size, b_size) / 2;
 
   // Split the polynomials
-  auto a_low_begin = a_begin;
-  auto a_low_end = (a_size > half_size) ? a_begin + half_size : a_end;
-  auto a_high_begin = (a_size > half_size) ? a_begin + half_size : a_end;
-  auto a_high_end = a_end;
-  auto b_low_begin = b_begin;
-  auto b_low_end = (b_size > half_size) ? b_begin + half_size : b_end;
-  auto b_high_begin = (b_size > half_size) ? b_begin + half_size : b_end;
-  auto b_high_end = b_end;
+  auto a_mid = (a_size > half_size) ? a_begin + half_size : a_end;
+  auto b_mid = (b_size > half_size) ? b_begin + half_size : b_end;
 
-  size_t a_low_size = std::distance(a_low_begin, a_low_end);
-  size_t b_low_size = std::distance(b_low_begin, b_low_end);
-  size_t a_high_size = std::distance(a_high_begin, a_high_end);
-  size_t b_high_size = std::distance(b_high_begin, b_high_end);
+  size_t a_low_size = std::distance(a_begin, a_mid);
+  size_t b_low_size = std::distance(b_begin, b_mid);
+  size_t a_high_size = std::distance(a_mid, a_end);
+  size_t b_high_size = std::distance(b_mid, b_end);
   size_t a_max_size = std::max(a_low_size, a_high_size);
   size_t b_max_size = std::max(b_low_size, b_high_size);
   size_t part_size = a_max_size + b_max_size - 1;
@@ -58,21 +52,21 @@ void karatsuba_multiply(InputIt a_begin, InputIt a_end, InputIt b_begin, InputIt
   std::vector<T> z2(part_size);
 
   // z0 = a_low * b_low
-  karatsuba_multiply(a_low_begin, a_low_end, b_low_begin, b_low_end, z0.begin());
+  karatsuba_multiply(a_begin, a_mid, b_begin, b_mid, z0.begin());
   // z2 = a_high * b_high
-  karatsuba_multiply(a_high_begin, a_high_end, b_high_begin, b_high_end, z2.begin());
+  karatsuba_multiply(a_mid, a_end, b_mid, b_end, z2.begin());
 
   // z1 = (a_low + a_high) * (b_low + b_high) - z0 - z2
   std::vector<T> a_sum(std::max(a_low_size, a_high_size));
   for (size_t i = 0; i < a_low_size; ++i)
-    a_sum[i] += a_low_begin[i];
+    a_sum[i] += a_begin[i];
   for (size_t i = 0; i < a_high_size; ++i)
-    a_sum[i] += a_high_begin[i];
+    a_sum[i] += a_mid[i];
   std::vector<T> b_sum(std::max(b_low_size, b_high_size));
   for (size_t i = 0; i < b_low_size; ++i)
-    b_sum[i] += b_low_begin[i];
+    b_sum[i] += b_begin[i];
   for (size_t i = 0; i < b_high_size; ++i)
-    b_sum[i] += b_high_begin[i];
+    b_sum[i] += b_mid[i];
   karatsuba_multiply(a_sum.begin(), a_sum.end(), b_sum.begin(), b_sum.end(),
                      z1.begin());
   for (size_t i = 0; i < part_size; ++i)