symtest-cli 1.3.2__tar.gz → 1.3.3__tar.gz

{symtest_cli-1.3.2/src/symtest_cli.egg-info → symtest_cli-1.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: symtest-cli
-Version: 1.3.2
+Version: 1.3.3
 Summary: Regression testing for CLI applications, with multi-step workflows and numerical file comparison.
 Home-page: https://github.com/ozil111/symtest-cli
 Author: Xiaotong Wang

{symtest_cli-1.3.2 → symtest_cli-1.3.3}/docs/user_manual.md

@@ -248,7 +248,7 @@ test_cases:
 | `xfail_reason` | 否 | xfail 的原因说明，报告中将展示此文本（如 "Bug #42 尚未修复"） |
 | `xfail_quiet` | 否 | 设为 `true` 时，xfailed 状态下报告中不输出 Command Output（stdout/stderr 大段输出），仅保留命令、返回码、失败原因等元信息 |
 | `depends_on` | 否 | 依赖的测试用例名称列表（如 `["A", "B"]`）。当前用例必须等待所有依赖用例通过后才执行。依赖失败时自动 skip 当前用例及下游。支持并行和顺序两种 runner |
-| `env` | 否 | case 级环境变量字典（如 `{"UEL_SYSID_SCALE": "1.0"}`），仅在执行该 case（序列模式为所有 step）时注入子进程，见 [Case 级环境变量](#case-级环境变量env) |
+| `env` | 否 | case 级环境变量字典（如 `{"MYAPP_SCALE": "1.0"}`），仅在执行该 case（序列模式为所有 step）时注入子进程，见 [Case 级环境变量](#case-级环境变量env) |
 | `expected.return_code` | 否 | 期望返回码 |
 | `expected.output_contains` | 否 | 输出需包含的字符串列表 |
 | `expected.output_matches` | 否 | 输出需匹配的正则表达式（单个字符串） |
@@ -262,11 +262,11 @@ test_cases:
 
 ```json
 {
-    "name": "UEL 缩放测试",
+    "name": "case 级环境变量示例",
     "command": "solver",
     "args": ["-i", "input.dat"],
     "env": {
-        "UEL_SYSID_SCALE": "1.0",
+        "MYAPP_SCALE": "1.0",
         "OMP_NUM_THREADS": "8"
     },
     "expected": { "return_code": 0 }
@@ -276,11 +276,11 @@ test_cases:
 ### YAML
 
 ```yaml
-- name: UEL 缩放测试
+- name: case 级环境变量示例
   command: solver
   args: ["-i", "input.dat"]
   env:
-    UEL_SYSID_SCALE: "1.0"
+    MYAPP_SCALE: "1.0"
   expected: { return_code: 0 }
 ```
 
@@ -291,7 +291,7 @@ test_cases:
 ```json
 {
     "name": "多步骤+环境变量",
-    "env": { "UEL_SYSID_SCALE": "1.0" },
+    "env": { "MYAPP_SCALE": "1.0" },
     "steps": [
         { "command": "python", "args": ["./step1.py"], "expected": { "return_code": 0 } },
         { "command": "python", "args": ["./step2.py"], "expected": { "return_code": 0 } }
@@ -814,7 +814,7 @@ symtest run test_cases.json --last-failed
 
 # 断点续跑：跳过已通过的步骤，从失败步骤继续
 symtest run test_cases.json --resume
-symtest run test_cases.json --resume -t BS-U_01
+symtest run test_cases.json --resume -t long_pipeline
 
 # 比较失败时更新基线文件（交互运行需输入 yes）
 symtest run test_cases.json --update-baseline
@@ -865,11 +865,11 @@ symtest run config.json
 **信任模型**：`--resume` **不校验工作区产物**（输入文件、前置步骤生成的文件等）。使用 `--resume` 即表示用户确认输入文件未被修改。如果怀疑工作区被污染，应不带 `--resume` 全量重跑。
 
 ```bash
-# 首次全量运行，BS-U_01 的 step 4 失败（总耗时 72s）
+# 首次全量运行，long_pipeline 的 step 4 失败（总耗时 72s）
 symtest run config.json
 
-# 修复后只重跑 BS-U_01，跳过 step 1-3（仅耗时 ~0.14s）
-symtest run config.json -t BS-U_01 --resume
+# 修复后只重跑 long_pipeline，跳过 step 1-3（仅耗时 ~0.14s）
+symtest run config.json -t long_pipeline --resume
 
 # 全部通过后，跑一次全量确认无回归
 symtest run config.json
@@ -1742,7 +1742,16 @@ CSV 比较按行列结构逐单元格比对；数值单元格在容差范围内
 | `mean_abs_error` | 平均绝对误差 |
 | `rms_abs_error` | 均方根绝对误差（RMSE） |
 
-统计是**流式**计算的，不依赖差异截断，覆盖全体数值单元格。仅失败的比较输出统计，通过的比较不输出。
+统计是**流式**计算的，不依赖差异截断，覆盖全体数值单元格。默认仅失败的比较输出统计，通过的比较不输出。
+
+如需让**通过**的用例也输出统计信息（例如用于监控容差余量），可改用 `--error-analysis-all`（它会隐含启用 `--error-analysis`）：
+
+```bash
+# 对所有用例（含通过的）输出误差统计
+symtest run config.json --error-analysis-all
+```
+
+启用后，每个**通过**的用例会在 Detailed Results 区块中以 `error_stats (baseline vs actual):` 的形式列出上述统计量（与失败用例的 `error_stats` 字段一致）。通过用例的统计也同时写入 `--output json` 的 `assertion_results[].error_stats`，便于程序化消费。仅当 `--error-analysis-all` 启用时才会对通过用例产生额外输出，未启用时行为不变。
 
 **CLI 用法**：
 
@@ -1750,6 +1759,9 @@ CSV 比较按行列结构逐单元格比对；数值单元格在容差范围内
 # 启用误差分析
 symtest run config.json --error-analysis
 
+# 启用误差分析并对通过的用例也输出统计
+symtest run config.json --error-analysis-all
+
 # 与比较参数组合使用
 symtest run config.json --error-analysis --csv-rtol 1e-4 --csv-data-filter '>0'
 ```
@@ -2005,8 +2017,8 @@ comparator = ComparatorFactory.create_comparator("foo")
 ```json
 {
   "type": "hourglass_tangent",
-  "script": "case/.../analyze_HG-M1_D1_A1e-4_tangent.py",
-  "case_dir": "case/.../WP31_pure/HG-M1_D1_A1e-4",
+  "script": "case/.../analyze_case01_tangent.py",
+  "case_dir": "case/.../case01",
   "pass_threshold": 1e-6,
   "timeout": 600
 }
@@ -2083,9 +2095,9 @@ python tests/run_all.py --scope unit --extra "-v -k assertions"
 
 `--extra` 接收的字符串会经 `shlex` 拆分后追加到 pytest 命令行。脚本通过当前解释器（`sys.executable -m pytest`）调用 pytest，确保使用激活的环境而非 PATH 中首个 `pytest`。
 
-测试环境需先激活 conda 环境：
+测试环境需先激活你的 Python 环境（如 conda）：
 
 ```bash
-conda activate xiaotong
+conda activate <你的环境名>
 python tests/run_all.py
 ```

{symtest_cli-1.3.2 → symtest_cli-1.3.3}/docs/user_manual_en.md

@@ -248,7 +248,7 @@ test_cases:
 | `xfail_reason` | No | Reason text for xfail, displayed in the report (e.g., "Bug #42 not yet fixed") |
 | `xfail_quiet` | No | When `true`, suppress Command Output (stdout/stderr) for xfailed cases in the report; only command, return code, and failure reason metadata retained |
 | `depends_on` | No | List of test case names this case depends on (e.g., `["A", "B"]`). The case will wait until all dependencies pass before executing. On dependency failure, the case and its downstream are auto-skipped. Works with both parallel and sequential runners |
-| `env` | No | Case-level environment variable mapping (e.g. `{"UEL_SYSID_SCALE": "1.0"}`), injected into the subprocess only when this case runs (all steps in sequence mode). See [Case-Level Environment Variables](#case-level-environment-variables-env) |
+| `env` | No | Case-level environment variable mapping (e.g. `{"MYAPP_SCALE": "1.0"}`), injected into the subprocess only when this case runs (all steps in sequence mode). See [Case-Level Environment Variables](#case-level-environment-variables-env) |
 | `expected.return_code` | No | Expected return code |
 | `expected.output_contains` | No | List of strings the output must contain |
 | `expected.output_matches` | No | Regex pattern the output must match (single string) |
@@ -299,11 +299,11 @@ Use the `env` field (same level as `name`) to inject environment variables into
 
 ```json
 {
-    "name": "UEL scale test",
+    "name": "Case-level env test",
     "command": "solver",
     "args": ["-i", "input.dat"],
     "env": {
-        "UEL_SYSID_SCALE": "1.0",
+        "MYAPP_SCALE": "1.0",
         "OMP_NUM_THREADS": "8"
     },
     "expected": { "return_code": 0 }
@@ -313,11 +313,11 @@ Use the `env` field (same level as `name`) to inject environment variables into
 ### YAML
 
 ```yaml
-- name: UEL scale test
+- name: Case-level env test
   command: solver
   args: ["-i", "input.dat"]
   env:
-    UEL_SYSID_SCALE: "1.0"
+    MYAPP_SCALE: "1.0"
   expected: { return_code: 0 }
 ```
 
@@ -328,7 +328,7 @@ Use the `env` field (same level as `name`) to inject environment variables into
 ```json
 {
     "name": "multi-step with env",
-    "env": { "UEL_SYSID_SCALE": "1.0" },
+    "env": { "MYAPP_SCALE": "1.0" },
     "steps": [
         { "command": "python", "args": ["./step1.py"], "expected": { "return_code": 0 } },
         { "command": "python", "args": ["./step2.py"], "expected": { "return_code": 0 } }
@@ -814,7 +814,7 @@ symtest run test_cases.json --last-failed
 
 # Resume: skip passed steps, continue from failed step
 symtest run test_cases.json --resume
-symtest run test_cases.json --resume -t BS-U_01
+symtest run test_cases.json --resume -t long_pipeline
 
 # Update baseline files on comparison failure (type yes interactively)
 symtest run test_cases.json --update-baseline
@@ -865,11 +865,11 @@ symtest run config.json
 **Trust model**: `--resume` does **not verify workspace artifacts** (input files, files generated by prior steps, etc.). Using `--resume` means the user confirms input files are unmodified. If workspace contamination is suspected, rerun fully without `--resume`.
 
 ```bash
-# First full run, BS-U_01 step 4 fails (total 72s)
+# First full run, long_pipeline step 4 fails (total 72s)
 symtest run config.json
 
-# After fixing, rerun only BS-U_01, skipping steps 1-3 (~0.14s only)
-symtest run config.json -t BS-U_01 --resume
+# After fixing, rerun only long_pipeline, skipping steps 1-3 (~0.14s only)
+symtest run config.json -t long_pipeline --resume
 
 # After all pass, do one full run to confirm no regressions
 symtest run config.json
@@ -1740,7 +1740,16 @@ When enabled, each failed file comparison appends `error_stats` to the Compare F
 | `mean_abs_error` | Mean absolute error |
 | `rms_abs_error` | Root-mean-square absolute error (RMSE) |
 
-Statistics are computed **in streaming fashion**, independent of the difference truncation, covering all numeric cells. Only failed comparisons output statistics; passed comparisons do not.
+Statistics are computed **in streaming fashion**, independent of the difference truncation, covering all numeric cells. By default only failed comparisons output statistics; passed comparisons do not.
+
+To also output statistics for **passed** cases (e.g. to monitor tolerance headroom), use `--error-analysis-all` instead (it implicitly enables `--error-analysis`):
+
+```bash
+# Output error statistics for all cases (including passed ones)
+symtest run config.json --error-analysis-all
+```
+
+When enabled, each **passed** case lists the above statistics in the Detailed Results section as `error_stats:`. For passed cases the statistics are also written to the `assertion_results[].error_stats` field of the `--output json` report for programmatic consumption. Statistics for passed cases are produced only when `--error-analysis-all` is enabled; otherwise behavior is unchanged.
 
 **CLI Usage**:
 
@@ -1748,6 +1757,9 @@ Statistics are computed **in streaming fashion**, independent of the difference
 # Enable error analysis
 symtest run config.json --error-analysis
 
+# Enable error analysis and also output statistics for passed cases
+symtest run config.json --error-analysis-all
+
 # Combine with comparison parameters
 symtest run config.json --error-analysis --csv-rtol 1e-4 --csv-data-filter '>0'
 ```
@@ -2003,8 +2015,8 @@ comparator = ComparatorFactory.create_comparator("foo")
 ```json
 {
   "type": "hourglass_tangent",
-  "script": "case/.../analyze_HG-M1_D1_A1e-4_tangent.py",
-  "case_dir": "case/.../WP31_pure/HG-M1_D1_A1e-4",
+  "script": "case/.../analyze_case01_tangent.py",
+  "case_dir": "case/.../case01",
   "pass_threshold": 1e-6,
   "timeout": 600
 }
@@ -2081,9 +2093,9 @@ python tests/run_all.py --scope unit --extra "-v -k assertions"
 
 `--extra` accepts a string that is split via `shlex` and appended to the pytest command line. The script invokes pytest through the current interpreter (`sys.executable -m pytest`), ensuring the activated environment is used rather than the first `pytest` found on PATH.
 
-Activate the conda environment before running tests:
+Activate your Python environment (e.g. conda) before running tests:
 
 ```bash
-conda activate xiaotong
+conda activate <your-env>
 python tests/run_all.py
 ```

{symtest_cli-1.3.2 → symtest_cli-1.3.3}/src/symtest/__init__.py

@@ -16,7 +16,7 @@ runtime.  Library users can enable console logging explicitly::
     setup_console_logging(level=logging.DEBUG)
 """
 
-__version__ = "1.3.2"
+__version__ = "1.3.3"
 __author__ = "Xiaotong Wang"
 __email__ = "xiaotongwang98@gmail.com"
 

{symtest_cli-1.3.2 → symtest_cli-1.3.3}/src/symtest/cli.py

@@ -130,6 +130,9 @@ Examples:
                            help='Enable streaming error statistics for numerical file comparisons '
                                 '(CSV/H5): total_numeric_cells, mismatched_cells, '
                                 'max_abs/rel_error, mean/rms_abs_error')
+    run_parser.add_argument('--error-analysis-all', action='store_true',
+                           help='Like --error-analysis, but also report error statistics for '
+                                'PASSED file comparisons in the report (implies --error-analysis)')
     run_parser.add_argument('--plugin-dir', action='append', default=None,
                            dest='plugin_dirs',
                            help='Add a directory for workspace-level comparator plugins '
@@ -273,6 +276,9 @@ def run_tests(args):
     update_baseline = getattr(args, 'update_baseline', False)
     update_history = getattr(args, 'update_history', False)
     error_analysis = getattr(args, 'error_analysis', False)
+    error_analysis_all = getattr(args, 'error_analysis_all', False)
+    if error_analysis_all:
+        error_analysis = True
     last_failed = getattr(args, 'last_failed', False)
     resume = getattr(args, 'resume', False)
     plugin_dirs = getattr(args, 'plugin_dirs', None)
@@ -294,6 +300,7 @@ def run_tests(args):
                     update_baseline=update_baseline,
                     update_history=update_history,
                     error_analysis=error_analysis,
+                    error_analysis_all=error_analysis_all,
                     last_failed=last_failed,
                     resume=resume,
                     plugin_dirs=plugin_dirs,
@@ -312,6 +319,7 @@ def run_tests(args):
                     update_baseline=update_baseline,
                     update_history=update_history,
                     error_analysis=error_analysis,
+                    error_analysis_all=error_analysis_all,
                     last_failed=last_failed,
                     resume=resume,
                     plugin_dirs=plugin_dirs,
@@ -333,6 +341,7 @@ def run_tests(args):
                     update_baseline=update_baseline,
                     update_history=update_history,
                     error_analysis=error_analysis,
+                    error_analysis_all=error_analysis_all,
                     last_failed=last_failed,
                     resume=resume,
                     plugin_dirs=plugin_dirs,
@@ -349,6 +358,7 @@ def run_tests(args):
                     update_baseline=update_baseline,
                     update_history=update_history,
                     error_analysis=error_analysis,
+                    error_analysis_all=error_analysis_all,
                     last_failed=last_failed,
                     resume=resume,
                     plugin_dirs=plugin_dirs,

{symtest_cli-1.3.2 → symtest_cli-1.3.3}/src/symtest/core/base_runner.py

@@ -23,6 +23,7 @@ class BaseRunner(ABC):
                  update_baseline: bool = False,
                  update_history: bool = False,
                  error_analysis: bool = False,
+                 error_analysis_all: bool = False,
                  last_failed: bool = False,
                  resume: bool = False,
                  plugin_dirs: Optional[List[str]] = None):
@@ -45,7 +46,8 @@ class BaseRunner(ABC):
         self.regression_threshold = regression_threshold
         self.update_baseline = update_baseline
         self.update_history = update_history
-        self.error_analysis = error_analysis
+        self.error_analysis = error_analysis or error_analysis_all
+        self.error_analysis_all = error_analysis_all
         self.last_failed = last_failed
         self.resume = resume
 
@@ -62,6 +64,7 @@ class BaseRunner(ABC):
             "xfailed": 0,
             "xpassed": 0,
             "updated": 0,
+            "error_analysis_all": error_analysis_all,
             "details": []
         }
         self.assertions = Assertions()

{symtest_cli-1.3.2 → symtest_cli-1.3.3}/src/symtest/core/execution.py

@@ -294,6 +294,7 @@ def _dispatch_file_compare(
             return {
                 "assertion": "compare_files",
                 "passed": True,
+                "error_stats": cf_result.get("error_stats"),
                 "compare_failures": [],
                 "baseline_updated": [baseline_path],
                 "message": "",
@@ -301,6 +302,7 @@ def _dispatch_file_compare(
         return {
             "assertion": "compare_files",
             "passed": True,
+            "error_stats": cf_result.get("error_stats"),
             "compare_failures": [],
             "baseline_updated": [],
             "message": "",
@@ -325,7 +327,9 @@ def _execute_command_once(
     output_max_chars: int = DEFAULT_OUTPUT_MAX_CHARS,
 ) -> TestResultData:
     """Execute a single command once (no retry logic)."""
-    start_time = time.time()
+    # perf_counter: high-resolution monotonic clock; on Windows, time.time()
+    # has ~15.6ms granularity and can yield duration == 0.0 for fast commands.
+    start_time = time.perf_counter()
     cmd_list = _normalize_cmd_list(case["command"], [str(arg) for arg in case["args"]])
     timeout_limit = case.get("timeout", 3600)
 
@@ -434,7 +438,7 @@ def _execute_command_once(
         result["failure_kind"] = "execution_error"
         result["next_action_hint"] = _build_next_action_hint("execution_error")
     finally:
-        result["duration"] = time.time() - start_time
+        result["duration"] = time.perf_counter() - start_time
 
     return result
 

{symtest_cli-1.3.2 → symtest_cli-1.3.3}/src/symtest/core/parallel_runner.py

@@ -95,10 +95,11 @@ class ParallelRunner(BaseRunner):
             **kwargs: 透传给 BaseRunner 的额外参数
                 (test_case_filter, test_case_tag_filter, history_dir, regression_threshold)
         """
+        error_analysis_all = kwargs.get('error_analysis_all', False)
         super().__init__(config_file, workspace, **kwargs)
         self.max_workers = max_workers
         self.execution_mode = execution_mode
-        self.error_analysis = error_analysis
+        self.error_analysis = error_analysis or error_analysis_all
         self.lock = threading.Lock()  # 用于线程安全的结果更新
         
     def run_tests(self) -> bool:

{symtest_cli-1.3.2 → symtest_cli-1.3.3}/src/symtest/file_comparator/csv_comparator.py

@@ -10,10 +10,11 @@
 
 import csv
 import io
-import math
 import re
+import numpy as np
 from .text_comparator import TextComparator
 from .result import Difference
+from .numeric_compare import compare_numeric, parse_data_filter
 
 class CsvComparator(TextComparator):
     """
@@ -107,16 +108,13 @@ class CsvComparator(TextComparator):
         differences = []
         max_diffs = 10
 
-        # ── Error analysis accumulators ──
-        total_numeric_cells = 0
-        mismatched_cells = 0
-        sum_abs_error = 0.0
-        sum_sq_abs_error = 0.0
-        max_abs_error = None
-        max_abs_error_at = None
-        max_rel_error = None
-        max_rel_error_at = None
-        
+        # ── Numeric core accumulators ──
+        # error_analysis mode collects ALL filtered numeric cells (matching or not)
+        # and delegates statistics to the shared numeric core.
+        stats_exp = []
+        stats_act = []
+        stats_pos = []  # (row, col) 0-based, aligned with stats_exp/stats_act
+
         # Check row count
         if len(content1) != len(content2):
             differences.append(Difference(
@@ -140,42 +138,65 @@ class CsvComparator(TextComparator):
                 if not self.error_analysis and len(differences) >= max_diffs:
                     break
             
-            # Compare column values
+            # Collect numeric cells in this row (for delegated closeness check)
+            row_exp = []
+            row_act = []
+            row_pos = []  # (row, col) 0-based
             for j, (cell1, cell2) in enumerate(zip(row1, row2)):
-                if cell1 != cell2:
-                    # Try numeric tolerance comparison
-                    try:
-                        num1 = float(cell1)
-                        num2 = float(cell2)
-                        # Apply data filter
-                        if self.filter_func:
-                            if not (self.filter_func(num1) and self.filter_func(num2)):
-                                continue
-                        total_numeric_cells += 1
-                        abs_err = abs(num2 - num1)
-                        if math.isclose(num1, num2, rel_tol=self.rtol, abs_tol=self.atol):
-                            continue  # Within tolerance
-
-                        # Mismatched numeric cell
-                        mismatched_cells += 1
-                        sum_abs_error += abs_err
-                        sum_sq_abs_error += abs_err * abs_err
-                        rel_err = abs_err / max(abs(num1), 1e-300) if abs(num1) > 0 else float("inf")
-
-                        if max_abs_error is None or abs_err > max_abs_error:
-                            max_abs_error = abs_err
-                            max_abs_error_at = f"row {i+1}, column {j+1}"
-                        if max_rel_error is None or rel_err > max_rel_error:
-                            max_rel_error = rel_err
-                            max_rel_error_at = f"row {i+1}, column {j+1}"
-                    except (ValueError, TypeError):
-                        pass  # Non-numeric, fall through
-
-                    if len(differences) < max_diffs:
+                num1 = num2 = None
+                try:
+                    num1 = float(cell1)
+                    num2 = float(cell2)
+                except (ValueError, TypeError):
+                    pass  # Non-numeric
+
+                is_numeric = num1 is not None and num2 is not None
+                passes_filter = True
+                if is_numeric and self.filter_func:
+                    # vectorized filter applied element-wise on scalar input
+                    if not (bool(self.filter_func(np.asarray(num1))) and
+                            bool(self.filter_func(np.asarray(num2)))):
+                        passes_filter = False
+
+                if is_numeric and passes_filter:
+                    # Counted as a numeric cell (regardless of text equality)
+                    row_exp.append(num1)
+                    row_act.append(num2)
+                    row_pos.append((i, j))
+                    if self.error_analysis:
+                        stats_exp.append(num1)
+                        stats_act.append(num2)
+                        stats_pos.append((i, j))
+
+                if cell1 == cell2:
+                    continue
+                if is_numeric:
+                    # Numeric cell: within-tolerance decisions are made below via the core.
+                    # Filtered-out numeric cells are skipped entirely (no difference).
+                    continue
+
+                # Non-numeric text mismatch
+                if len(differences) < max_diffs:
+                    differences.append(Difference(
+                        position=f"row {i+1}, column {j+1}",
+                        expected=cell1,
+                        actual=cell2,
+                        diff_type="cell_mismatch"
+                    ))
+
+            # Determine closeness for this row's numeric cells via the shared core.
+            if row_exp:
+                row_res = compare_numeric(
+                    row_exp, row_act, rtol=self.rtol, atol=self.atol,
+                    filter_func=self.filter_func, collect_stats=False,
+                )
+                for k, is_mismatch in enumerate(row_res.mismatch_mask):
+                    if is_mismatch and len(differences) < max_diffs:
+                        ri, cj = row_pos[k]
                         differences.append(Difference(
-                            position=f"row {i+1}, column {j+1}",
-                            expected=cell1,
-                            actual=cell2,
+                            position=f"row {ri+1}, column {cj+1}",
+                            expected=content1[ri][cj],
+                            actual=content2[ri][cj],
                             diff_type="cell_mismatch"
                         ))
 
@@ -184,17 +205,31 @@ class CsvComparator(TextComparator):
 
         truncated = len(differences) >= max_diffs
 
-        # ── Store error stats ──
-        if self.error_analysis and total_numeric_cells > 0:
+        # ── Store error stats via the shared numeric core ──
+        if self.error_analysis and stats_exp:
+            res = compare_numeric(
+                stats_exp, stats_act, rtol=self.rtol, atol=self.atol,
+                filter_func=self.filter_func, collect_stats=True,
+            )
+            max_abs_error = res.max_abs_error
+            max_rel_error = res.max_rel_error
+            max_abs_error_at = None
+            max_rel_error_at = None
+            if max_abs_error is not None:
+                ri, cj = stats_pos[res.max_abs_error_index]
+                max_abs_error_at = f"row {ri+1}, column {cj+1}"
+            if max_rel_error is not None:
+                ri, cj = stats_pos[res.max_rel_error_index]
+                max_rel_error_at = f"row {ri+1}, column {cj+1}"
             self._error_stats = {
-                "total_numeric_cells": total_numeric_cells,
-                "mismatched_cells": mismatched_cells,
+                "total_numeric_cells": res.total,
+                "mismatched_cells": res.mismatched,
                 "max_abs_error": max_abs_error,
                 "max_abs_error_at": max_abs_error_at,
                 "max_rel_error": max_rel_error,
                 "max_rel_error_at": max_rel_error_at,
-                "mean_abs_error": sum_abs_error / mismatched_cells if mismatched_cells > 0 else 0.0,
-                "rms_abs_error": math.sqrt(sum_sq_abs_error / mismatched_cells) if mismatched_cells > 0 else 0.0,
+                "mean_abs_error": res.mean_abs_error,
+                "rms_abs_error": res.rms_abs_error,
             }
 
         if not differences:
@@ -202,40 +237,5 @@ class CsvComparator(TextComparator):
         return False, differences, truncated
 
     def _parse_filter(self):
-        """Parse data filter string and return a scalar filter function"""
-        if not self.data_filter:
-            return None
-        self.logger.debug(f"Parsing data filter: {self.data_filter}")
-        try:
-            match = re.match(
-                r"^(abs)?([><]=?|==)([-+]?\d*\.?\d+(?:[eE][-+]?\d+)?)$",
-                self.data_filter.replace(" ", ""),
-            )
-            if not match:
-                self.logger.warning(
-                    f"Invalid data filter format: {self.data_filter}. Ignoring filter."
-                )
-                return None
-            use_abs, op, value_str = match.groups()
-            value = float(value_str)
-            op_map = {
-                ">": lambda x: x > value,
-                ">=": lambda x: x >= value,
-                "<": lambda x: x < value,
-                "<=": lambda x: x <= value,
-                "==": lambda x: x == value,
-            }
-
-            def filter_func(x):
-                target = abs(x) if use_abs else x
-                return op_map[op](target)
-
-            self.logger.debug(
-                f"Created filter function for pattern: {use_abs or ''}{op}{value}"
-            )
-            return filter_func
-        except Exception as e:
-            self.logger.error(
-                f"Failed to parse data filter '{self.data_filter}': {e}. Ignoring filter."
-            )
-            return None
+        """Parse data filter string and return a filter function (delegates to numeric core)"""
+        return parse_data_filter(self.data_filter, logger=self.logger)