scientific-computing-system 2.2.8__tar.gz → 2.2.11__tar.gz

{scientific_computing_system-2.2.8 → scientific_computing_system-2.2.11}/CHANGELOG.md

@@ -5,6 +5,30 @@ All notable changes to **scientific-computing-system** will be documented in thi
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [v2.2.11] - 2026-10-17
+
+### Scientific validation CI and overflow resilience
+
+- Restore the 100% branch-coverage contract for numeric drift and residual overflow detection through explicit extreme-input regressions and removal of unreachable redundant checks.
+- Stabilize OOD reference means and standard deviations for large, finite observations; prevent NaN-derived false negatives and reject unrepresentable centered differences.
+- Keep ordinary OOD thresholds, constant-reference semantics, and normal sample behavior unchanged.
+
+## [v2.2.10] - 2026-10-17
+
+### Fail-closed scientific moment diagnostics
+
+- Refuse distribution-drift PASS when arithmetic overflow makes finite-input sample means, variances, or standardized shifts non-finite.
+- Refuse residual-diagnostic PASS (or uncaught overflow) when derived residual means, centered differences, squares, or dependence statistics are not representable.
+- Preserve explicit warnings for well-defined zero-variance mismatches; add focused regressions for extreme and ordinary numerical inputs.
+
+## [v2.2.9] - 2026-10-17
+
+### Scientific numerical tolerance overflow protection
+
+- Reject derived infinite tolerances for independent-method agreement and conservation checks instead of silently returning PASS.
+- Reject expanded OOD bounds that overflow to infinity when user-provided margins are finite.
+- Add regression tests for overflow conditions and ordinary finite thresholds.
+
 ## [v2.2.8] - 2026-10-17
 
 ### Scientific validation fail-closed thresholds

{scientific_computing_system-2.2.8 → scientific_computing_system-2.2.11}/CITATION.cff

@@ -5,7 +5,7 @@ title: "scientific-computing-system"
 # Keep `version` in lockstep with pyproject.toml [project].version and
 # src/cds/_version.py. scripts/check_version_discipline.py and
 # scripts/check_version_lockstep.py enforce this.
-version: 2.2.8
+version: 2.2.11
 authors:
   - name: "Furox-Art"
     email: "furkanarkn1451@gmail.com"
@@ -50,5 +50,5 @@ preferred-citation:
   authors:
     - name: "Furox-Art"
   year: 2026
-  version: 2.2.8
+  version: 2.2.11
   url: "https://github.com/Furox-Art/scientific-computing-system"

{scientific_computing_system-2.2.8 → scientific_computing_system-2.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: scientific-computing-system
-Version: 2.2.8
+Version: 2.2.11
 Summary: A pure-Python computational science platform for numerical methods, modeling, validation, uncertainty, scientific workflows, dimensional analysis, and optional research-data backends. Zero runtime dependencies.
 Project-URL: Homepage, https://github.com/Furox-Art/scientific-computing-system
 Project-URL: Repository, https://github.com/Furox-Art/scientific-computing-system

{scientific_computing_system-2.2.8 → scientific_computing_system-2.2.11}/codemeta.json

@@ -2,7 +2,7 @@
   "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
   "@type": "SoftwareSourceCode",
   "name": "scientific-computing-system",
-  "version": "2.2.8",
+  "version": "2.2.11",
   "description": "Pure-Python computational science platform for numerical methods, modeling, validation, uncertainty, and scientific workflows. Zero runtime dependencies. This is the front door; scientific-computing-system-2.0 is the NumPy build of the same work.",
   "license": "https://spdx.org/licenses/MIT",
   "codeRepository": "https://github.com/Furox-Art/scientific-computing-system",

{scientific_computing_system-2.2.8 → scientific_computing_system-2.2.11}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scientific-computing-system",
-  "version": "2.2.8",
+  "version": "2.2.11",
   "description": "Scientific Computing System launcher - a thin Node wrapper that forwards to the pure-Python `cds` CLI. This npm package ships NO Python code: it requires the Python distribution to be installed (`pip install scientific-computing-system`), otherwise `scs` exits non-zero with an actionable message.",
   "main": "index.js",
   "bin": {

{scientific_computing_system-2.2.8 → scientific_computing_system-2.2.11}/pyproject.toml

@@ -2,7 +2,7 @@
 # Distribution name. Formerly published as "cognitive-discovery-system";
 # the import name stays `cds`. Keep the old PyPI project alive as an alias.
 name = "scientific-computing-system"
-version = "2.2.8"
+version = "2.2.11"
 description = "A pure-Python computational science platform for numerical methods, modeling, validation, uncertainty, scientific workflows, dimensional analysis, and optional research-data backends. Zero runtime dependencies."
 readme = "README.md"
 license = "MIT"

{scientific_computing_system-2.2.8 → scientific_computing_system-2.2.11}/src/cds/_version.py

@@ -5,5 +5,5 @@ from __future__ import annotations
 
 __all__ = ["__version__", "version", "__version_tuple__", "version_tuple"]
 
-__version__ = version = "2.2.8"
-__version_tuple__ = version_tuple = (2, 2, 8)
+__version__ = version = "2.2.11"
+__version_tuple__ = version_tuple = (2, 2, 11)

{scientific_computing_system-2.2.8 → scientific_computing_system-2.2.11}/src/cds/validation/checks.py

@@ -47,6 +47,8 @@ def cross_method_agreement(
         )
     delta = abs(primary - secondary)
     tolerance = atol + rtol * max(abs(primary), abs(secondary))
+    if not math.isfinite(tolerance):
+        raise ValueError("derived cross-method tolerance must be finite")
     status = CheckStatus.PASS if delta <= tolerance else CheckStatus.FAIL
     message = (
         "independent methods agree"
@@ -148,6 +150,8 @@ def check_conservation(
         )
     delta = abs(after - before)
     tolerance = atol + rtol * max(abs(before), abs(after))
+    if not math.isfinite(tolerance):
+        raise ValueError("derived conservation tolerance must be finite")
     status = CheckStatus.PASS if delta <= tolerance else CheckStatus.FAIL
     message = (
         "conservation law satisfied" if status is CheckStatus.PASS else "conservation law violated"
@@ -288,7 +292,10 @@ def check_ood_ranges(
     for low, high in zip(lower, upper):
         scale = max(abs(low), abs(high), high - low, 1.0)
         margin = margin_fraction * scale
-        expanded.append((low - margin, high + margin))
+        expanded_low, expanded_high = low - margin, high + margin
+        if not (math.isfinite(expanded_low) and math.isfinite(expanded_high)):
+            raise ValueError("derived OOD margins must be finite")
+        expanded.append((expanded_low, expanded_high))
 
     outside = [
         row_index
@@ -341,16 +348,31 @@ def check_distribution_drift(
         variance = sum((value - mean) ** 2 for value in values) / (len(values) - 1)
         return mean, variance
 
-    ref_mean, ref_var = moments(reference)
-    cur_mean, cur_var = moments(current)
-    scale = max(math.sqrt(ref_var), 1e-12)
-    mean_shift = abs(cur_mean - ref_mean) / scale
-    if ref_var <= 1e-24 and cur_var <= 1e-24:
-        variance_ratio = 1.0
-    elif min(ref_var, cur_var) <= 1e-24:
-        variance_ratio = math.inf
-    else:
-        variance_ratio = max(ref_var, cur_var) / min(ref_var, cur_var)
+    try:
+        ref_mean, ref_var = moments(reference)
+        cur_mean, cur_var = moments(current)
+        if not all(math.isfinite(x) for x in (ref_mean, ref_var, cur_mean, cur_var)):
+            raise ArithmeticError("derived moments are not finite")
+        scale = max(math.sqrt(ref_var), 1e-12)
+        mean_shift = abs(cur_mean - ref_mean) / scale
+        if not math.isfinite(mean_shift):
+            raise ArithmeticError("standardized mean shift is not finite")
+        if ref_var <= 1e-24 and cur_var <= 1e-24:
+            variance_ratio = 1.0
+        elif min(ref_var, cur_var) <= 1e-24:
+            # A genuine zero-variance mismatch is a valid drift warning.
+            variance_ratio = math.inf
+        else:
+            variance_ratio = max(ref_var, cur_var) / min(ref_var, cur_var)
+            if not math.isfinite(variance_ratio):
+                raise ArithmeticError("variance ratio overflow")
+    except ArithmeticError:
+        return ValidationCheck(
+            name=name,
+            status=CheckStatus.FAIL,
+            message="distribution drift cannot be evaluated reliably: numerical overflow",
+            details={"reason": "non-finite derived moments or statistics"},
+        )
     drifted = mean_shift > max_standardized_mean_shift or variance_ratio > max_variance_ratio
     return ValidationCheck(
         name=name,
@@ -390,36 +412,51 @@ def check_residual_diagnostics(
     if finite.status is CheckStatus.FAIL:
         return finite
 
-    n = len(residuals)
-    mean = sum(residuals) / n
-    centered = [value - mean for value in residuals]
-    variance = sum(value * value for value in centered) / (n - 1)
-    standard_error = math.sqrt(variance / n) if variance > 0 else 0.0
-    bias_z = abs(mean) / standard_error if standard_error > 0 else (0.0 if mean == 0 else math.inf)
-
-    denominator = sum(value * value for value in centered)
-    lag1 = (
-        sum(centered[index] * centered[index - 1] for index in range(1, n)) / denominator
-        if denominator > 0
-        else 0.0
-    )
-
-    midpoint = n // 2
-    first = residuals[:midpoint]
-    second = residuals[midpoint:]
-
-    def sample_variance(values: Sequence[float]) -> float:
-        local_mean = sum(values) / len(values)
-        return sum((value - local_mean) ** 2 for value in values) / max(1, len(values) - 1)
+    try:
+        n = len(residuals)
+        mean = sum(residuals) / n
+        centered = [value - mean for value in residuals]
+        if not math.isfinite(mean) or any(not math.isfinite(x) for x in centered):
+            raise ArithmeticError("derived residual mean or centered values are not finite")
+        variance = sum(value * value for value in centered) / (n - 1)
+        standard_error = math.sqrt(variance / n) if variance > 0 else 0.0
+        bias_z = (
+            abs(mean) / standard_error if standard_error > 0 else (0.0 if mean == 0 else math.inf)
+        )
 
-    first_var = sample_variance(first)
-    second_var = sample_variance(second)
-    if first_var <= 1e-24 and second_var <= 1e-24:
-        variance_ratio = 1.0
-    elif min(first_var, second_var) <= 1e-24:
-        variance_ratio = math.inf
-    else:
-        variance_ratio = max(first_var, second_var) / min(first_var, second_var)
+        denominator = sum(value * value for value in centered)
+        lag1 = (
+            sum(centered[index] * centered[index - 1] for index in range(1, n)) / denominator
+            if denominator > 0
+            else 0.0
+        )
+        if not all(math.isfinite(x) for x in (variance, standard_error, denominator, lag1)):
+            raise ArithmeticError("derived residual variance or dependence is not finite")
+        midpoint = n // 2
+        first = residuals[:midpoint]
+        second = residuals[midpoint:]
+
+        def sample_variance(values: Sequence[float]) -> float:
+            local_mean = sum(values) / len(values)
+            return sum((value - local_mean) ** 2 for value in values) / max(1, len(values) - 1)
+
+        first_var = sample_variance(first)
+        second_var = sample_variance(second)
+        if first_var <= 1e-24 and second_var <= 1e-24:
+            variance_ratio = 1.0
+        elif min(first_var, second_var) <= 1e-24:
+            variance_ratio = math.inf
+        else:
+            variance_ratio = max(first_var, second_var) / min(first_var, second_var)
+            if not math.isfinite(variance_ratio):
+                raise ArithmeticError("segment variance ratio overflow")
+    except ArithmeticError:
+        return ValidationCheck(
+            name=name,
+            status=CheckStatus.FAIL,
+            message="residual diagnostics cannot be evaluated reliably: numerical overflow",
+            details={"reason": "non-finite derived residual statistics"},
+        )
 
     suspicious = (
         bias_z > max_bias_z or abs(lag1) > max_abs_lag1 or variance_ratio > max_variance_ratio

{scientific_computing_system-2.2.8 → scientific_computing_system-2.2.11}/src/cds/validation/drift.py

@@ -151,11 +151,25 @@ def screen_ood(
     if len(current[0]) != width:
         raise ValueError("reference and observations must have equal feature count")
 
-    means = tuple(sum(row[index] for row in baseline) / len(baseline) for index in range(width))
-    deviations = tuple(
-        math.sqrt(sum((row[index] - means[index]) ** 2 for row in baseline) / len(baseline))
-        for index in range(width)
+    # Accumulate divided terms instead of overflowing before division.
+    # Compute the population RMS using scaling, so finite 1e308 values
+    # do not produce spurious NaN means or OverflowError during squaring.
+    means = tuple(
+        math.fsum(row[index] / len(baseline) for row in baseline) for index in range(width)
     )
+    deviations_list: list[float] = []
+    for index, mean in enumerate(means):
+        offsets = [row[index] - mean for row in baseline]
+        if any(not math.isfinite(offset) for offset in offsets):
+            raise ValueError("reference deviations overflowed")
+        largest = max(abs(offset) for offset in offsets)
+        if largest == 0.0:
+            deviations_list.append(0.0)
+        else:
+            scaled = math.fsum((offset / largest) ** 2 for offset in offsets)
+            deviation = largest * math.sqrt(scaled / len(baseline))
+            deviations_list.append(deviation)
+    deviations = tuple(deviations_list)
 
     screened: list[OODObservation] = []
     for row_index, row in enumerate(current):

scientific_computing_system-2.2.11/tests/test_validation_derived_moments_overflow.py

@@ -0,0 +1,58 @@
+"""Validation must not certify overflowed scientific diagnostics as PASS."""
+
+from __future__ import annotations
+
+import math
+
+from cds.validation import CheckStatus, check_distribution_drift, check_residual_diagnostics
+
+
+def test_drift_rejects_overflowed_finite_means() -> None:
+    check = check_distribution_drift([1e308, 1e308], [-1e308, -1e308])
+    assert check.status is CheckStatus.FAIL
+    assert "numerical overflow" in check.message
+    assert "standardized_mean_shift" not in check.details
+
+
+def test_drift_rejects_overflowed_finite_variances() -> None:
+    check = check_distribution_drift([1e308, -1e308], [1e308, -1e308])
+    assert check.status is CheckStatus.FAIL
+    assert "numerical overflow" in check.message
+
+
+def test_drift_keeps_well_defined_zero_variance_mismatch_as_warning() -> None:
+    check = check_distribution_drift([1.0, 1.0], [1.0, 2.0])
+    assert check.status is CheckStatus.WARNING
+    assert check.details["variance_ratio"] == math.inf
+
+
+def test_drift_keeps_identical_finite_sample_as_pass() -> None:
+    check = check_distribution_drift([1.0, 2.0, 3.0], [1.0, 2.0, 3.0])
+    assert check.status is CheckStatus.PASS
+
+
+def test_residuals_reject_overflowed_finite_means() -> None:
+    check = check_residual_diagnostics([1e308] * 4)
+    assert check.status is CheckStatus.FAIL
+    assert "numerical overflow" in check.message
+
+
+def test_residuals_reject_overflowed_finite_squares_without_raising() -> None:
+    check = check_residual_diagnostics([1e308, -1e308, 1e308, -1e308])
+    assert check.status is CheckStatus.FAIL
+    assert "numerical overflow" in check.message
+
+
+def test_residuals_reject_overflowed_variances() -> None:
+    check = check_residual_diagnostics([1e154, -1e154, 1e154, -1e154])
+    assert check.status is CheckStatus.FAIL
+
+
+def test_residuals_keep_ordinary_centered_sample_as_pass() -> None:
+    check = check_residual_diagnostics([-1.0, 0.5, 1.0, -0.5, 0.5, -1.0, -0.5, 1.0])
+    assert check.status is CheckStatus.PASS
+
+
+def test_nonfinite_raw_samples_still_fail() -> None:
+    assert check_distribution_drift([0.0, float("inf")], [1.0, 2.0]).status is CheckStatus.FAIL
+    assert check_residual_diagnostics([0.0, float("nan"), 0.0, 0.0]).status is CheckStatus.FAIL

scientific_computing_system-2.2.11/tests/test_validation_derived_tolerance_overflow.py

@@ -0,0 +1,51 @@
+"""Never turn finite user tolerances into false-positive scientific passes."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable
+
+import pytest
+
+from cds.validation.checks import check_conservation, check_ood_ranges, cross_method_agreement
+from cds.validation.report import CheckStatus, ValidationCheck
+
+
+@pytest.mark.parametrize(
+    ("check", "message"),
+    [
+        (cross_method_agreement, "derived cross-method tolerance"),
+        (check_conservation, "derived conservation tolerance"),
+    ],
+)
+def test_finite_user_tolerance_must_not_overflow_to_false_pass(
+    check: Callable[..., ValidationCheck], message: str
+) -> None:
+    with pytest.raises(ValueError, match=message):
+        check(1e200, -1e200, rtol=1e308)
+
+
+@pytest.mark.parametrize("margin_fraction", [1e308, 9e307])
+def test_ood_finite_margin_overflow_never_masks_extreme_outliers(
+    margin_fraction: float,
+) -> None:
+    with pytest.raises(ValueError, match="derived OOD margins"):
+        check_ood_ranges([[0.0], [2.0]], [[1e300]], margin_fraction=margin_fraction)
+
+
+def test_regular_tolerances_still_have_expected_outcomes() -> None:
+    assert cross_method_agreement(1.0, 1.0 + 1e-10).status is CheckStatus.PASS
+    assert cross_method_agreement(1.0, 2.0).status is CheckStatus.FAIL
+    assert check_conservation(3.0, 3.0).status is CheckStatus.PASS
+    assert check_conservation(3.0, 4.0).status is CheckStatus.FAIL
+    assert check_ood_ranges([[0.0], [2.0]], [[100.0]]).status is CheckStatus.FAIL
+
+
+def test_extreme_finite_outlier_is_not_certified_by_a_normal_margin() -> None:
+    result = check_ood_ranges([[0.0], [2.0]], [[1e300]], margin_fraction=0.1)
+    assert result.status is CheckStatus.FAIL
+
+
+def test_positive_infinite_margin_is_already_rejected() -> None:
+    with pytest.raises(ValueError, match="margin_fraction"):
+        check_ood_ranges([[0.0], [2.0]], [[1e300]], margin_fraction=math.inf)

scientific_computing_system-2.2.11/tests/test_validation_ood_stable_and_coverage.py

@@ -0,0 +1,61 @@
+"""Reference tests for extreme finite inputs and scientific CI branches."""
+
+from __future__ import annotations
+
+import math
+
+import pytest
+
+from cds.validation import (
+    CheckStatus,
+    check_distribution_drift,
+    check_residual_diagnostics,
+    screen_ood,
+)
+
+
+def test_constant_extreme_reference_does_not_certify_different_observation() -> None:
+    report = screen_ood([[1e308], [1e308]], [[0.0], [1e308]])
+    assert report.observations[0].out_of_distribution
+    assert report.observations[0].max_abs_z == math.inf
+    assert report.observations[1].max_abs_z == 0.0
+    assert not report.observations[1].out_of_distribution
+
+
+def test_large_balanced_reference_has_finite_ood_standard_deviation() -> None:
+    report = screen_ood([[1e308], [-1e308]], [[1e308]], z_threshold=4.0)
+    assert report.observations[0].max_abs_z == pytest.approx(1.0)
+    assert not report.any_ood
+
+
+def test_extreme_mixed_reference_refuses_unrepresentable_centered_values() -> None:
+    reference = [[1e308]] * 9 + [[-1e308]]
+    with pytest.raises(ValueError, match="reference deviations overflowed"):
+        screen_ood(reference, [[0.0]])
+
+
+def test_ordinary_multifeature_ood_detects_shift() -> None:
+    report = screen_ood(
+        [[-1.0, 4.0], [1.0, 4.0], [0.0, 4.0]],
+        [[0.0, 4.0], [5.0, 4.0], [0.0, 5.0]],
+        z_threshold=3.0,
+    )
+    assert [row.out_of_distribution for row in report.observations] == [False, True, True]
+
+
+def test_drift_extreme_mean_shift_overflow_is_fail_not_pass() -> None:
+    report = check_distribution_drift([1e307] * 2, [-1e307] * 2)
+    assert report.status is CheckStatus.FAIL
+    assert "overflow" in report.message
+
+
+def test_drift_extreme_variance_ratio_overflow_is_fail_not_pass() -> None:
+    report = check_distribution_drift([-1e-11, 1e-11], [-1e153, 1e153])
+    assert report.status is CheckStatus.FAIL
+    assert "overflow" in report.message
+
+
+def test_residual_segment_variance_ratio_overflow_is_fail_not_pass() -> None:
+    report = check_residual_diagnostics([1e-10, -1e-10, 1e150, -1e150])
+    assert report.status is CheckStatus.FAIL
+    assert "overflow" in report.message