refactor: delegate handling of hash maps to helper

Author: jolars

crates/eunoia/src/fitter/final_layout.rs

@@ -275,18 +275,10 @@ impl<'a, S: DiagramShape + Copy + 'static> CostFunction for DiagramCost<'a, S> {
         // Compute exclusive regions using shape-specific exact computation
         let exclusive_areas = S::compute_exclusive_regions(&shapes);
 
-        // Convert to vectors for loss computation
-        let mut fitted_vec = Vec::new();
-        let mut target_vec = Vec::new();
-
-        for (mask, &target_area) in &self.spec.exclusive_areas {
-            let fitted_area = exclusive_areas.get(mask).copied().unwrap_or(0.0);
-            fitted_vec.push(fitted_area);
-            target_vec.push(target_area);
-        }
-
-        // Use the configured loss function
-        let error = self.loss_type.compute(&fitted_vec, &target_vec);
+        // Use the configured loss function directly on HashMaps
+        let error = self
+            .loss_type
+            .compute(&exclusive_areas, &self.spec.exclusive_areas);
 
         Ok(error)
     }

crates/eunoia/src/loss.rs

@@ -3,6 +3,9 @@
 //! This module provides simple loss functions that measure the difference
 //! between fitted and target region areas.
 
+use crate::geometry::diagram::RegionMask;
+use std::collections::HashMap;
+
 /// Loss function type
 #[derive(Debug, Clone, Copy, PartialEq, Default)]
 pub enum LossType {
@@ -38,42 +41,51 @@ impl LossType {
         Self::MaxAbsolute
     }
 
-    /// Compute loss between fitted and target values
-    pub fn compute(&self, fitted: &[f64], target: &[f64]) -> f64 {
-        assert_eq!(
-            fitted.len(),
-            target.len(),
-            "Fitted and target vectors must have the same length"
-        );
+    /// Compute loss between fitted and target region areas
+    pub fn compute(
+        &self,
+        fitted: &HashMap<RegionMask, f64>,
+        target: &HashMap<RegionMask, f64>,
+    ) -> f64 {
+        // Collect all unique region masks from both fitted and target
+        let all_masks: std::collections::HashSet<RegionMask> =
+            fitted.keys().chain(target.keys()).copied().collect();
 
-        if fitted.is_empty() {
+        if all_masks.is_empty() {
             return 0.0;
         }
 
         match self {
             LossType::Sse => {
                 // Sum of squared errors
-                fitted
+                all_masks
                     .iter()
-                    .zip(target.iter())
-                    .map(|(f, t)| (f - t).powi(2))
+                    .map(|&mask| {
+                        let fitted_area = fitted.get(&mask).copied().unwrap_or(0.0);
+                        let target_area = target.get(&mask).copied().unwrap_or(0.0);
+                        (fitted_area - target_area).powi(2)
+                    })
                     .sum()
             }
             LossType::Rmse => {
                 // Root mean squared error
-                let sum_squared: f64 = fitted
+                let sum_squared: f64 = all_masks
                     .iter()
-                    .zip(target.iter())
-                    .map(|(f, t)| (f - t).powi(2))
+                    .map(|&mask| {
+                        let f = fitted.get(&mask).copied().unwrap_or(0.0);
+                        let t = target.get(&mask).copied().unwrap_or(0.0);
+                        (f - t).powi(2)
+                    })
                     .sum();
-                (sum_squared / fitted.len() as f64).sqrt()
+                (sum_squared / all_masks.len() as f64).sqrt()
             }
             LossType::Stress => {
                 // Stress: sum of squared relative errors
-                fitted
+                all_masks
                     .iter()
-                    .zip(target.iter())
-                    .map(|(f, t)| {
+                    .map(|&mask| {
+                        let f = fitted.get(&mask).copied().unwrap_or(0.0);
+                        let t = target.get(&mask).copied().unwrap_or(0.0);
                         if t.abs() < 1e-10 {
                             if f.abs() < 1e-10 {
                                 0.0
@@ -88,10 +100,13 @@ impl LossType {
             }
             LossType::MaxAbsolute => {
                 // Maximum absolute error
-                fitted
+                all_masks
                     .iter()
-                    .zip(target.iter())
-                    .map(|(f, t)| (f - t).abs())
+                    .map(|&mask| {
+                        let f = fitted.get(&mask).copied().unwrap_or(0.0);
+                        let t = target.get(&mask).copied().unwrap_or(0.0);
+                        (f - t).abs()
+                    })
                     .fold(0.0, f64::max)
             }
         }
@@ -105,8 +120,16 @@ mod tests {
     #[test]
     fn test_sse() {
         let loss = LossType::sse();
-        let fitted = vec![10.0, 20.0, 30.0];
-        let target = vec![12.0, 18.0, 28.0];
+
+        let mut fitted = HashMap::new();
+        fitted.insert(0b001, 10.0);
+        fitted.insert(0b010, 20.0);
+        fitted.insert(0b100, 30.0);
+
+        let mut target = HashMap::new();
+        target.insert(0b001, 12.0);
+        target.insert(0b010, 18.0);
+        target.insert(0b100, 28.0);
 
         // (10-12)² + (20-18)² + (30-28)² = 4 + 4 + 4 = 12
         assert_eq!(loss.compute(&fitted, &target), 12.0);
@@ -115,8 +138,16 @@ mod tests {
     #[test]
     fn test_rmse() {
         let loss = LossType::rmse();
-        let fitted = vec![10.0, 20.0, 30.0];
-        let target = vec![12.0, 18.0, 28.0];
+
+        let mut fitted = HashMap::new();
+        fitted.insert(0b001, 10.0);
+        fitted.insert(0b010, 20.0);
+        fitted.insert(0b100, 30.0);
+
+        let mut target = HashMap::new();
+        target.insert(0b001, 12.0);
+        target.insert(0b010, 18.0);
+        target.insert(0b100, 28.0);
 
         // sqrt((4 + 4 + 4) / 3) = sqrt(4) = 2.0
         assert_eq!(loss.compute(&fitted, &target), 2.0);
@@ -125,8 +156,14 @@ mod tests {
     #[test]
     fn test_stress() {
         let loss = LossType::stress();
-        let fitted = vec![10.0, 20.0];
-        let target = vec![12.0, 18.0];
+
+        let mut fitted = HashMap::new();
+        fitted.insert(0b001, 10.0);
+        fitted.insert(0b010, 20.0);
+
+        let mut target = HashMap::new();
+        target.insert(0b001, 12.0);
+        target.insert(0b010, 18.0);
 
         // ((10-12)/12)² + ((20-18)/18)² = (1/6)² + (1/9)² = 0.02778 + 0.01235 ≈ 0.04013
         let result = loss.compute(&fitted, &target);
@@ -136,24 +173,74 @@ mod tests {
     #[test]
     fn test_max_absolute() {
         let loss = LossType::max_absolute();
-        let fitted = vec![10.0, 20.0, 30.0];
-        let target = vec![8.0, 25.0, 28.0];
+
+        let mut fitted = HashMap::new();
+        fitted.insert(0b001, 10.0);
+        fitted.insert(0b010, 20.0);
+        fitted.insert(0b100, 30.0);
+
+        let mut target = HashMap::new();
+        target.insert(0b001, 8.0);
+        target.insert(0b010, 25.0);
+        target.insert(0b100, 28.0);
 
         // max(|10-8|, |20-25|, |30-28|) = max(2, 5, 2) = 5
         assert_eq!(loss.compute(&fitted, &target), 5.0);
     }
 
     #[test]
-    fn test_empty_vectors() {
+    fn test_empty_target() {
+        let loss = LossType::sse();
+        let fitted = HashMap::new();
+        let target = HashMap::new();
+        assert_eq!(loss.compute(&fitted, &target), 0.0);
+    }
+
+    #[test]
+    fn test_missing_fitted_area() {
         let loss = LossType::sse();
-        assert_eq!(loss.compute(&[], &[]), 0.0);
+
+        let fitted = HashMap::new(); // Empty - no fitted areas
+
+        let mut target = HashMap::new();
+        target.insert(0b001, 5.0);
+        target.insert(0b010, 3.0);
+
+        // (0-5)² + (0-3)² = 25 + 9 = 34
+        assert_eq!(loss.compute(&fitted, &target), 34.0);
+    }
+
+    #[test]
+    fn test_extra_fitted_area() {
+        let loss = LossType::sse();
+
+        let mut fitted = HashMap::new();
+        fitted.insert(0b001, 5.0);
+        fitted.insert(0b010, 3.0);
+        fitted.insert(0b100, 7.0); // Extra region not in target
+
+        let mut target = HashMap::new();
+        target.insert(0b001, 5.0);
+        target.insert(0b010, 3.0);
+        // 0b100 missing from target
+
+        // (5-5)² + (3-3)² + (7-0)² = 0 + 0 + 49 = 49
+        assert_eq!(loss.compute(&fitted, &target), 49.0);
     }
 
     #[test]
     fn test_stress_with_zero_target() {
         let loss = LossType::stress();
-        let fitted = vec![5.0, 0.0, 3.0];
-        let target = vec![0.0, 0.0, 3.0];
+
+        let mut fitted = HashMap::new();
+        fitted.insert(0b001, 5.0);
+        fitted.insert(0b010, 0.0);
+        fitted.insert(0b100, 3.0);
+
+        let mut target = HashMap::new();
+        target.insert(0b001, 0.0);
+        target.insert(0b010, 0.0);
+        target.insert(0b100, 3.0);
 
         // First: target=0, fitted=5: 5² = 25
         // Second: target=0, fitted=0: 0
@@ -175,11 +262,4 @@ mod tests {
         let cloned = loss;
         assert_eq!(loss, cloned);
     }
-
-    #[test]
-    #[should_panic(expected = "Fitted and target vectors must have the same length")]
-    fn test_mismatched_lengths() {
-        let loss = LossType::sse();
-        loss.compute(&[1.0, 2.0], &[1.0]);
-    }
 }