platform-specific expected values for cross-platform CI

- CI runs tests on both Ubuntu and macOS
- Each platform has its own expected values: `testdata/{test}/linux.csv` and `macos.csv`
- Comparison uses relative tolerance (1e-12) to handle float formatting differences
- gen-expected workflow regenerates values on both platforms when needed
- Remove merge script (platforms diverge too much to merge meaningfully)

Author: ryan-williams

.github/workflows/ci.yml

@@ -10,6 +10,18 @@ env:
   RUST_LOG: info
 jobs:
   test:
+    strategy:
+      matrix:
+        os: [ubuntu-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: Swatinem/rust-cache@v2
+
+      - run: cargo build
+      - run: cargo test -- --nocapture
+
+  build-wasm:
     runs-on: ubuntu-latest
     permissions:
       contents: write
@@ -23,9 +35,6 @@ jobs:
       - name: Build WASM
         run: wasm-pack build --target web
 
-      - run: cargo build
-      - run: cargo test -- --nocapture
-
       - name: Push dist branch
         if: github.ref == 'refs/heads/main' && github.event_name == 'push'
         uses: runsascoded/npm-dist@v1.1

.github/workflows/gen-expected.yml

@@ -37,7 +37,7 @@ jobs:
           name: macos-testdata
           path: testdata/*/macos.csv
 
-  merge:
+  commit:
     needs: [gen-ubuntu, gen-macos]
     runs-on: ubuntu-latest
     steps:
@@ -46,50 +46,33 @@ jobs:
       - uses: actions/download-artifact@v4
         with:
           name: ubuntu-testdata
-          path: artifacts/ubuntu
+          path: testdata
 
       - uses: actions/download-artifact@v4
         with:
           name: macos-testdata
-          path: artifacts/macos
+          path: testdata
 
-      - name: Show artifacts
-        run: find artifacts -type f | head -20
-
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.12'
-
-      - name: Merge expected values
+      - name: Show generated files
         run: |
-          python scripts/merge_expected.py --batch \
-            artifacts/ubuntu \
-            artifacts/macos \
-            testdata
-
-      - name: Show merged files
-        run: |
-          echo "=== Merged expected.csv files ==="
-          find testdata -name 'expected.csv' | while read f; do
+          echo "=== Generated expected value files ==="
+          find testdata -name '*.csv' -type f | sort | while read f; do
             echo "--- $f ---"
             head -3 "$f"
             echo "..."
           done
 
-      - name: Commit merged testdata
+      - name: Commit testdata
         run: |
           git config user.name "github-actions[bot]"
           git config user.email "github-actions[bot]@users.noreply.github.com"
 
-          # Remove old platform-specific files
-          git rm -f testdata/*/linux.csv testdata/*/macos.csv 2>/dev/null || true
-
-          git add testdata/*/expected.csv
+          git add testdata/*/linux.csv testdata/*/macos.csv
           git status
 
           if git diff --staged --quiet; then
             echo "No changes to commit"
           else
-            git commit -m "Regenerate merged expected values from Ubuntu + macOS"
+            git commit -m "Regenerate platform-specific expected values"
             git push
           fi

scripts/merge_expected.py

@@ -56,26 +56,15 @@ pub use csv_io::*;
 // CSV load/save functionality - only available in tests (polars is a dev-dependency)
 #[cfg(test)]
 mod csv_io {
-    /// Count decimal places in a numeric string (for precision-aware comparison)
-    pub fn decimal_places(s: &str) -> usize {
-        if let Some(dot_pos) = s.find('.') {
-            s.len() - dot_pos - 1
+    /// Compare f64 to expected string with relative tolerance
+    pub fn float_eq(actual: f64, expected_str: &str) -> bool {
+        let expected: f64 = expected_str.parse().expect("Failed to parse expected value");
+        if expected == 0.0 {
+            actual.abs() < 1e-14
         } else {
-            0
+            ((actual - expected) / expected).abs() < 1e-12
         }
     }
-
-    /// Round f64 to specified decimal places, return as string
-    pub fn round_to_string(val: f64, places: usize) -> String {
-        format!("{:.prec$}", val, prec = places)
-    }
-
-    /// Compare f64 to expected string, rounding actual to same precision as expected
-    pub fn precision_eq(actual: f64, expected_str: &str) -> bool {
-        let places = decimal_places(expected_str);
-        let rounded_actual = round_to_string(actual, places);
-        rounded_actual == expected_str
-    }
     use std::collections::BTreeMap;
     use std::path::Path;
     use super::*;
@@ -231,18 +220,15 @@ mod csv_io {
             Ok(ExpectedHistory { col_names, steps })
         }
 
-        /// Compare actual HistoryStep against expected, using precision from expected strings
+        /// Compare actual HistoryStep against expected with relative tolerance
         pub fn check_step(&self, step_idx: usize, actual: &HistoryStep) -> Result<(), String> {
             let expected = &self.steps[step_idx];
 
             // Check error
-            if !precision_eq(actual.error, &expected.error) {
+            if !float_eq(actual.error, &expected.error) {
                 return Err(format!(
-                    "Step {} error mismatch:\n  expected: {}\n  actual:   {} (rounded: {})",
-                    step_idx,
-                    expected.error,
-                    actual.error,
-                    round_to_string(actual.error, decimal_places(&expected.error))
+                    "Step {} error mismatch:\n  expected: {}\n  actual:   {}",
+                    step_idx, expected.error, actual.error
                 ));
             }
 
@@ -256,16 +242,11 @@ mod csv_io {
             }
 
             for (i, (actual_val, expected_str)) in actual_vals.iter().zip(expected.shape_vals.iter()).enumerate() {
-                if !precision_eq(*actual_val, expected_str) {
+                if !float_eq(*actual_val, expected_str) {
                     let col_name = self.col_names.get(i + 1).map(|s| s.as_str()).unwrap_or("?");
                     return Err(format!(
-                        "Step {} column {} ({}) mismatch:\n  expected: {}\n  actual:   {} (rounded: {})",
-                        step_idx,
-                        i,
-                        col_name,
-                        expected_str,
-                        actual_val,
-                        round_to_string(*actual_val, decimal_places(expected_str))
+                        "Step {} column {} ({}) mismatch:\n  expected: {}\n  actual:   {}",
+                        step_idx, i, col_name, expected_str, actual_val
                     ));
                 }
             }

src/optimization/history.rs

@@ -160,8 +160,10 @@ mod tests {
             info!("Wrote expecteds to {}", platform_path);
             info!("{}", df);
         } else {
-            // Test mode: compare against merged expected.csv with precision-aware comparison
-            let expected_path = format!("testdata/{}/expected.csv", name);
+            // Test mode: compare against platform-specific expected values
+            let os = env::consts::OS;
+            let os = if os == "macos" { "macos" } else { "linux" };
+            let expected_path = format!("testdata/{}/{}.csv", name, os);
             let expected = ExpectedHistory::load(&expected_path)
                 .unwrap_or_else(|e| panic!("Failed to load {}: {}", expected_path, e));