Use mul_add for numeric ops and minor cleanups

Replace many manual multiplications/additions with f64::mul_add for improved precision/performance and reduce unnecessary cloning and duplication. Changes: use mul_add in moarstats.rs and stats.rs for variance, sums of squares, mutual information and entropy calculations; deduplicate and move format_output_str in describegpt.rs and avoid an extra clone when building PrepareContextOutput; remove an unnecessary pos.clone() in join.rs when seeking the second CSV reader. These edits improve numeric stability and remove small inefficiencies across the codebase.

Author: jqnatividad

src/cmd/describegpt.rs

@@ -2794,6 +2794,16 @@ fn process_phase_output(
     base_url: &str,
     output_format: OutputFormat,
 ) -> CliResult<()> {
+    // For non-dictionary types, format output
+    fn format_output_str(str: &str) -> String {
+        str.replace("\\n", "\n")
+            .replace("\\t", "\t")
+            .replace("\\\"", "\"")
+            .replace("\\'", "'")
+            .replace("\\`", "`")
+            + "\n\n"
+    }
+
     // Skip outputting dictionary when using --prompt (but still generate it for context)
     if kind == PromptType::Dictionary && args.flag_prompt.is_some() {
         let (stats_records, ordered_col_names) = parse_stats_csv(&analysis_results.stats)?;
@@ -2921,16 +2931,6 @@ fn process_phase_output(
         return Ok(());
     }
 
-    // For non-dictionary types, format output
-    fn format_output_str(str: &str) -> String {
-        str.replace("\\n", "\n")
-            .replace("\\t", "\t")
-            .replace("\\\"", "\"")
-            .replace("\\'", "'")
-            .replace("\\`", "`")
-            + "\n\n"
-    }
-
     let is_sql_response = kind == PromptType::Prompt
         && args.flag_sql_results.is_some()
         && completion_response.response.contains("```sql");
@@ -5176,7 +5176,7 @@ pub fn run(argv: &[&str]) -> CliResult<()> {
 
         let output = PrepareContextOutput {
             phases,
-            analysis_results: analysis_results.clone(),
+            analysis_results,
             model,
             max_tokens: args.flag_max_tokens,
         };

src/cmd/join.rs

@@ -375,7 +375,7 @@ impl<R: io::Read + io::Seek, W: io::Write> IoState<R, W> {
         let mut row1 = csv::ByteRecord::new();
         let rdr2_has_headers = self.rdr2.has_headers();
         while self.rdr1.read_byte_record(&mut row1)? {
-            self.rdr2.seek(pos.clone())?;
+            self.rdr2.seek(pos)?;
             if rdr2_has_headers {
                 // Read and skip the header row, since CSV readers disable
                 // the header skipping logic after being seeked.

src/cmd/moarstats.rs

@@ -1399,9 +1399,9 @@ fn update_correlation_state(state: &mut CorrelationState, x: f64, y: f64) {
     let delta_x_new = x - state.mean_x;
     let delta_y_new = y - state.mean_y;
 
-    state.m2_x += delta_x * delta_x_new;
-    state.m2_y += delta_y * delta_y_new;
-    state.cxy += delta_x * delta_y_new;
+    state.m2_x = delta_x.mul_add(delta_x_new, state.m2_x);
+    state.m2_y = delta_y.mul_add(delta_y_new, state.m2_y);
+    state.cxy = delta_x.mul_add(delta_y_new, state.cxy);
 }
 
 /// Merge two correlation states (for aggregating across chunks)
@@ -1734,7 +1734,7 @@ fn compute_mutual_information_from_counts(
         let p_y = y_counts.get(y_val).copied().unwrap_or(0) as f64 / total_f64;
 
         if p_x > 0.0 && p_y > 0.0 && p_xy > 0.0 {
-            mi += p_xy * (p_xy / (p_x * p_y)).log2();
+            mi = p_xy.mul_add((p_xy / (p_x * p_y)).log2(), mi);
         }
     }
 
@@ -1756,7 +1756,7 @@ fn compute_entropy_from_counts(counts: &HashMap<String, u64>, total: u64) -> Opt
     for count in counts.values() {
         if *count > 0 {
             let p = *count as f64 / total_f64;
-            entropy -= p * p.log2();
+            entropy = p.mul_add(-p.log2(), entropy);
         }
     }
 
@@ -1877,7 +1877,8 @@ where
                     .max_winsorized
                     .map_or(winsorized_val, |m| m.max(winsorized_val)),
             );
-            stats.sum_squares_winsorized += winsorized_val * winsorized_val;
+            stats.sum_squares_winsorized =
+                winsorized_val.mul_add(winsorized_val, stats.sum_squares_winsorized);
 
             // For trimmed mean, only include values within thresholds
             if val >= field_info.lower_threshold && val <= field_info.upper_threshold {
@@ -1886,42 +1887,42 @@ where
                 // Track trimmed min/max and sum of squares
                 stats.min_trimmed = Some(stats.min_trimmed.map_or(val, |m| m.min(val)));
                 stats.max_trimmed = Some(stats.max_trimmed.map_or(val, |m| m.max(val)));
-                stats.sum_squares_trimmed += val * val;
+                stats.sum_squares_trimmed = val.mul_add(val, stats.sum_squares_trimmed);
             }
 
             // Count outliers and track statistics based on fence comparisons
             if val < field_info.lower_outer {
                 stats.counts[0] += 1; // extreme_lower
                 stats.counts[5] += 1; // total
                 stats.sum_outliers += val;
-                stats.sum_squares_outliers += val * val;
+                stats.sum_squares_outliers = val.mul_add(val, stats.sum_squares_outliers);
                 stats.min_outliers = Some(stats.min_outliers.map_or(val, |m| m.min(val)));
                 stats.max_outliers = Some(stats.max_outliers.map_or(val, |m| m.max(val)));
             } else if val < field_info.lower_inner {
                 stats.counts[1] += 1; // mild_lower
                 stats.counts[5] += 1; // total
                 stats.sum_outliers += val;
-                stats.sum_squares_outliers += val * val;
+                stats.sum_squares_outliers = val.mul_add(val, stats.sum_squares_outliers);
                 stats.min_outliers = Some(stats.min_outliers.map_or(val, |m| m.min(val)));
                 stats.max_outliers = Some(stats.max_outliers.map_or(val, |m| m.max(val)));
             } else if val <= field_info.upper_inner {
                 stats.counts[2] += 1; // normal
                 stats.sum_normal += val;
-                stats.sum_squares_normal += val * val;
+                stats.sum_squares_normal = val.mul_add(val, stats.sum_squares_normal);
                 stats.min_normal = Some(stats.min_normal.map_or(val, |m| m.min(val)));
                 stats.max_normal = Some(stats.max_normal.map_or(val, |m| m.max(val)));
             } else if val <= field_info.upper_outer {
                 stats.counts[3] += 1; // mild_upper
                 stats.counts[5] += 1; // total
                 stats.sum_outliers += val;
-                stats.sum_squares_outliers += val * val;
+                stats.sum_squares_outliers = val.mul_add(val, stats.sum_squares_outliers);
                 stats.min_outliers = Some(stats.min_outliers.map_or(val, |m| m.min(val)));
                 stats.max_outliers = Some(stats.max_outliers.map_or(val, |m| m.max(val)));
             } else {
                 stats.counts[4] += 1; // extreme_upper
                 stats.counts[5] += 1; // total
                 stats.sum_outliers += val;
-                stats.sum_squares_outliers += val * val;
+                stats.sum_squares_outliers = val.mul_add(val, stats.sum_squares_outliers);
                 stats.min_outliers = Some(stats.min_outliers.map_or(val, |m| m.min(val)));
                 stats.max_outliers = Some(stats.max_outliers.map_or(val, |m| m.max(val)));
             }
@@ -2332,7 +2333,8 @@ fn count_all_outliers_from_reader(
                     .max_winsorized
                     .map_or(winsorized_val, |m| m.max(winsorized_val)),
             );
-            stats.sum_squares_winsorized += winsorized_val * winsorized_val;
+            stats.sum_squares_winsorized =
+                winsorized_val.mul_add(winsorized_val, stats.sum_squares_winsorized);
 
             // For trimmed mean, only include values within thresholds
             if val >= field_info.lower_threshold && val <= field_info.upper_threshold {
@@ -2341,42 +2343,42 @@ fn count_all_outliers_from_reader(
                 // Track trimmed min/max and sum of squares
                 stats.min_trimmed = Some(stats.min_trimmed.map_or(val, |m| m.min(val)));
                 stats.max_trimmed = Some(stats.max_trimmed.map_or(val, |m| m.max(val)));
-                stats.sum_squares_trimmed += val * val;
+                stats.sum_squares_trimmed = val.mul_add(val, stats.sum_squares_trimmed);
             }
 
             // Count outliers and track statistics based on fence comparisons
             if val < field_info.lower_outer {
                 stats.counts[0] += 1; // extreme_lower
                 stats.counts[5] += 1; // total
                 stats.sum_outliers += val;
-                stats.sum_squares_outliers += val * val;
+                stats.sum_squares_outliers = val.mul_add(val, stats.sum_squares_outliers);
                 stats.min_outliers = Some(stats.min_outliers.map_or(val, |m| m.min(val)));
                 stats.max_outliers = Some(stats.max_outliers.map_or(val, |m| m.max(val)));
             } else if val < field_info.lower_inner {
                 stats.counts[1] += 1; // mild_lower
                 stats.counts[5] += 1; // total
                 stats.sum_outliers += val;
-                stats.sum_squares_outliers += val * val;
+                stats.sum_squares_outliers = val.mul_add(val, stats.sum_squares_outliers);
                 stats.min_outliers = Some(stats.min_outliers.map_or(val, |m| m.min(val)));
                 stats.max_outliers = Some(stats.max_outliers.map_or(val, |m| m.max(val)));
             } else if val <= field_info.upper_inner {
                 stats.counts[2] += 1; // normal
                 stats.sum_normal += val;
-                stats.sum_squares_normal += val * val;
+                stats.sum_squares_normal = val.mul_add(val, stats.sum_squares_normal);
                 stats.min_normal = Some(stats.min_normal.map_or(val, |m| m.min(val)));
                 stats.max_normal = Some(stats.max_normal.map_or(val, |m| m.max(val)));
             } else if val <= field_info.upper_outer {
                 stats.counts[3] += 1; // mild_upper
                 stats.counts[5] += 1; // total
                 stats.sum_outliers += val;
-                stats.sum_squares_outliers += val * val;
+                stats.sum_squares_outliers = val.mul_add(val, stats.sum_squares_outliers);
                 stats.min_outliers = Some(stats.min_outliers.map_or(val, |m| m.min(val)));
                 stats.max_outliers = Some(stats.max_outliers.map_or(val, |m| m.max(val)));
             } else {
                 stats.counts[4] += 1; // extreme_upper
                 stats.counts[5] += 1; // total
                 stats.sum_outliers += val;
-                stats.sum_squares_outliers += val * val;
+                stats.sum_squares_outliers = val.mul_add(val, stats.sum_squares_outliers);
                 stats.min_outliers = Some(stats.min_outliers.map_or(val, |m| m.min(val)));
                 stats.max_outliers = Some(stats.max_outliers.map_or(val, |m| m.max(val)));
             }

src/cmd/stats.rs

@@ -2663,13 +2663,13 @@ impl WeightedOnlineStats {
         self.sum_weights += w;
 
         let delta = x - self.weighted_mean;
-        self.weighted_mean += (w / self.sum_weights) * delta;
+        self.weighted_mean = (w / self.sum_weights).mul_add(delta, self.weighted_mean);
         let delta2 = x - self.weighted_mean;
-        self.sum_squared_diffs += w * delta * delta2;
+        self.sum_squared_diffs = (w * delta).mul_add(delta2, self.sum_squared_diffs);
 
         // Accumulate weighted logs for geometric mean (only if x > 0)
         if x > 0.0 {
-            self.sum_weighted_logs += w * x.ln();
+            self.sum_weighted_logs = w.mul_add(x.ln(), self.sum_weighted_logs);
             self.sum_weights_positive += w;
         }