scientific-computing-system 2.0.1__tar.gz → 2.1.0__tar.gz

{scientific_computing_system-2.0.1 → scientific_computing_system-2.1.0}/CITATION.cff

@@ -2,28 +2,28 @@ cff-version: 1.2.0
 message: "If you use this software, please cite it using the metadata from this file."
 type: software
 title: "scientific-computing-system"
-version: 2.0.1
+version: 2.1.0
 authors:
   - name: "Furox-Art"
     email: "furkanarkn1451@gmail.com"
-abstract: "Pure Python computational science system — quantum simulation, signal processing, statistics, optimization, hypothesis generation, optional matplotlib plotting, and related numerical methods. All core modules are implemented without heavy external dependencies."
+abstract: "Pure Python computational science system with numerical methods, statistical validation, global sensitivity and identifiability analysis, conservative causal estimation, distribution-shift checks, memory-bounded scientific I/O, workflow orchestration, and optional scientific backends."
 license: MIT
 repository-code: "https://github.com/Furox-Art/scientific-computing-system"
 url: "https://github.com/Furox-Art/scientific-computing-system"
-date-released: "2026-09-29"
+date-released: "2026-09-30"
 keywords:
   - "pure python"
   - "scientific computing"
-  - "quantum simulation"
-  - "signal processing"
-  - "statistics"
-  - "hypothesis generation"
-  - "computational discovery"
+  - "model validation"
+  - "sensitivity analysis"
+  - "causal inference"
+  - "out-of-distribution detection"
+  - "scientific workflows"
 preferred-citation:
   type: software
   title: "scientific-computing-system"
   authors:
     - name: "Furox-Art"
   year: 2026
-  version: 2.0.1
+  version: 2.1.0
   url: "https://github.com/Furox-Art/scientific-computing-system"

{scientific_computing_system-2.0.1 → scientific_computing_system-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.5
+Metadata-Version: 2.4
 Name: scientific-computing-system
-Version: 2.0.1
+Version: 2.1.0
 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
@@ -128,6 +128,39 @@ This is a from-scratch rethinking of what scientific computing in Python could l
 - **Signal processing**: filters, wavelets, STFT
 - **ODE/PDE solvers**: stiff and non-stiff, symplectic integrators
 
+## Quick Start
+
+```bash
+pip install scientific-computing-system
+```
+
+```python
+from scs.linear_algebra import svd
+from scs.ode import solve_ivp
+from scs.stats import bayesian_posterior
+
+# every algorithm is readable pure Python — open the source, see the math
+U, S, Vt = svd(matrix, full_matrices=False)
+
+solution = solve_ivp(
+    lambda t, y: [y[1], -y[0] - 0.1 * y[1]],  # damped oscillator
+    t_span=(0, 50),
+    y0=[1.0, 0.0],
+    method="rk45",
+    rtol=1e-8,
+)
+```
+
+Also on npm: `npm i scientific-computing-system`. Full docs: [furox-art.github.io/scientific-computing-system](https://furox-art.github.io/scientific-computing-system/).
+
+## Common use cases
+
+- Learn and inspect **numerical methods in pure Python** without compiled extensions.
+- Prototype **scientific computing** workflows with transparent implementations.
+- Explore **ODE/PDE solvers**, numerical integration, optimization, Monte Carlo, signal processing, and linear algebra.
+- Run **statistics, uncertainty quantification, sensitivity analysis, dimensional analysis, and reproducible research** workflows.
+- Teach or audit algorithms where readable source code matters more than raw NumPy/SciPy performance.
+
 ## The catch
 
 It's slower than NumPy. Sometimes 10x slower, sometimes 100x. That's the price of pure Python. But it's also completely transparent-you can read every algorithm, understand every step, and modify anything without compiling C.

{scientific_computing_system-2.0.1 → scientific_computing_system-2.1.0}/README.md

@@ -32,6 +32,39 @@ This is a from-scratch rethinking of what scientific computing in Python could l
 - **Signal processing**: filters, wavelets, STFT
 - **ODE/PDE solvers**: stiff and non-stiff, symplectic integrators
 
+## Quick Start
+
+```bash
+pip install scientific-computing-system
+```
+
+```python
+from scs.linear_algebra import svd
+from scs.ode import solve_ivp
+from scs.stats import bayesian_posterior
+
+# every algorithm is readable pure Python — open the source, see the math
+U, S, Vt = svd(matrix, full_matrices=False)
+
+solution = solve_ivp(
+    lambda t, y: [y[1], -y[0] - 0.1 * y[1]],  # damped oscillator
+    t_span=(0, 50),
+    y0=[1.0, 0.0],
+    method="rk45",
+    rtol=1e-8,
+)
+```
+
+Also on npm: `npm i scientific-computing-system`. Full docs: [furox-art.github.io/scientific-computing-system](https://furox-art.github.io/scientific-computing-system/).
+
+## Common use cases
+
+- Learn and inspect **numerical methods in pure Python** without compiled extensions.
+- Prototype **scientific computing** workflows with transparent implementations.
+- Explore **ODE/PDE solvers**, numerical integration, optimization, Monte Carlo, signal processing, and linear algebra.
+- Run **statistics, uncertainty quantification, sensitivity analysis, dimensional analysis, and reproducible research** workflows.
+- Teach or audit algorithms where readable source code matters more than raw NumPy/SciPy performance.
+
 ## The catch
 
 It's slower than NumPy. Sometimes 10x slower, sometimes 100x. That's the price of pure Python. But it's also completely transparent-you can read every algorithm, understand every step, and modify anything without compiling C.

{scientific_computing_system-2.0.1 → scientific_computing_system-2.1.0}/docs/index.md

@@ -64,6 +64,14 @@ Module dependency graph and data flow, for contributors and auditors.
     [Statistics](tutorials/stats_demo.md),
     [Machine Learning](tutorials/ml_demo.md), then branch out.
 
+## What people use CDS for
+
+CDS is designed for searchable, practical scientific-Python tasks such as
+**numerical methods**, **ODE and PDE solving**, **Monte Carlo simulation**,
+**statistics and hypothesis testing**, **uncertainty quantification**,
+**sensitivity analysis**, **signal processing**, **linear algebra**,
+**symbolic mathematics**, and **reproducible computational research**.
+
 ## Key Features
 
 - **Pure Python:** Every module is implemented from scratch using the Python standard library. No heavy dependencies like NumPy or SciPy required.

{scientific_computing_system-2.0.1 → scientific_computing_system-2.1.0}/mkdocs.yml

@@ -1,9 +1,10 @@
 site_name: Scientific Computing System
 site_url: https://furox-art.github.io/scientific-computing-system/
 site_description: >-
-  Pure-Python computational science platform - quantum simulation, FFT,
-  linear algebra, statistics, ODEs, symbolic math and ML from scratch,
-  with zero runtime dependencies.
+  Pure-Python scientific computing and numerical methods platform for ODE/PDE
+  solvers, statistics, uncertainty quantification, sensitivity analysis,
+  signal processing, Monte Carlo, linear algebra, symbolic math and reproducible
+  computational research, with zero runtime dependencies.
 site_author: Furox-Art
 repo_url: https://github.com/Furox-Art/scientific-computing-system
 repo_name: Furox-Art/scientific-computing-system

{scientific_computing_system-2.0.1 → scientific_computing_system-2.1.0}/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.0.1"
+version = "2.1.0"
 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"
@@ -153,7 +153,7 @@ Issues = "https://github.com/Furox-Art/scientific-computing-system/issues"
 Changelog = "https://github.com/Furox-Art/scientific-computing-system/releases"
 
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling==1.31.0"]
 build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.wheel]
@@ -190,19 +190,20 @@ only-include = [
   "pyproject.toml",
   "requirements.lock",
   "requirements-dev.lock",
+  "requirements-build.lock",
   "mkdocs.yml",
 ]
 
-# Static versioning: `version` above and `src/cds/_version.py` are the package
-# version sources and must stay in lockstep. The release workflow additionally
-# rejects any `vX.Y.Z` tag whose X.Y.Z does not exactly match the built wheel
-# metadata, preventing GitHub and PyPI releases from drifting apart.
+# Static versioning: `version` above, `src/cds/_version.py`, and both version
+# fields in `CITATION.cff` are release metadata sources and must stay in
+# lockstep. scripts/check_version_discipline.py additionally requires a
+# monotonic version bump whenever package-affecting source changes occur.
 #
 # Release checklist:
-#   1. Bump `version` above AND `__version__` in `src/cds/_version.py`
+#   1. Bump all three version metadata sources together
 #   2. Commit, push, and wait for CI + Installed CLI Smoke to be green
 #   3. Merge the verified version bump to `main`; release.yml builds the wheel
-#      and creates the matching `vX.Y.Z` tag automatically
+#      from a hash-locked, non-isolated build toolchain
 #   4. Trusted Publishing uploads the verified build to PyPI; the GitHub Release
 #      contains release metadata only, never wheel/sdist distribution assets
 

scientific_computing_system-2.1.0/requirements-build.lock

@@ -0,0 +1,17 @@
+# Hash-locked Python 3.12 release-build environment.
+# Regenerate deliberately; release.yml installs this file with --require-hashes
+# and --only-binary=:all:, then runs `python -m build --no-isolation`.
+build==1.5.0 \
+    --hash=sha256:13f3eecb844759ab66efec90ca17639bbf14dc06cb2fdf37a9010322d9c50a6f
+hatchling==1.31.0 \
+    --hash=sha256:aac80bec8b6fe35e8480f1c335be8910fa210a0e6f735a139be205dadcacb544
+packaging==26.3 \
+    --hash=sha256:d7193f7c8e4e93f444fde0262bf90af30e16fa0ad0ad44cb553c87339b23cd1c
+pathspec==1.1.1 \
+    --hash=sha256:a00ce642f577bf7f473932318056212bc4f8bfdf53128c78bbd5af0b9b20b189
+pluggy==1.6.0 \
+    --hash=sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746
+pyproject-hooks==1.2.0 \
+    --hash=sha256:9e5c6bfa8dcc30091c74b0cf803c81fdd29d94f01992a7707bc97babb1141913
+trove-classifiers==2026.6.1.19 \
+    --hash=sha256:ab4c4ec93cc4a4e7815fa759906e05e6bb3f2fbd92ea0f897288c6a43efd15b3

{scientific_computing_system-2.0.1 → scientific_computing_system-2.1.0}/requirements-dev.lock

@@ -4,7 +4,7 @@
 #
 #    pip-compile --extra=dev --extra=docs --extra=test --output-file=requirements-dev.lock pyproject.toml
 #
-anyio==4.14.2
+anyio==4.15.1
     # via
     #   httpx
     #   jupyter-server
@@ -143,7 +143,7 @@ jupyter-events==0.12.1
     # via jupyter-server
 jupyter-lsp==2.3.1
     # via jupyterlab
-jupyter-server==2.21.0
+jupyter-server==2.21.1
     # via
     #   jupyter-lsp
     #   jupyterlab
@@ -314,7 +314,7 @@ python-dateutil==2.9.0.post0
     #   arrow
     #   ghp-import
     #   jupyter-client
-python-discovery==1.4.2
+python-discovery==1.6.1
     # via virtualenv
 python-json-logger==4.1.0
     # via jupyter-events
@@ -364,7 +364,7 @@ six==1.17.0
     # via
     #   python-dateutil
     #   rfc3339-validator
-soupsieve==2.9.0
+soupsieve==2.9.2
     # via beautifulsoup4
 stack-data==0.6.3
     # via ipython
@@ -395,7 +395,7 @@ traitlets==5.15.1
     #   nbclient
     #   nbconvert
     #   nbformat
-typing-extensions==4.15.0
+typing-extensions==4.16.0
     # via
     #   anyio
     #   beautifulsoup4
@@ -406,9 +406,9 @@ tzdata==2026.2
     # via arrow
 uri-template==1.3.0
     # via jsonschema
-urllib3==2.7.0
+urllib3==2.8.0
     # via requests
-virtualenv==21.5.1
+virtualenv==21.7.13
     # via pre-commit
 watchdog==6.0.0
     # via mkdocs

{scientific_computing_system-2.0.1 → scientific_computing_system-2.1.0}/src/cds/__init__.py

@@ -9,10 +9,12 @@ Key features:
 - Quantum simulation (single & multi-qubit with entanglement)
 - Signal processing (FFT, 2D FFT, convolution, filtering)
 - Optimization, statistics, probability, linear algebra
+- Multiple-testing/FDR corrections and conservative causal estimators
 - Hypothesis generation for structured research ideas
 - Workflow orchestration with approval gates and validation
-- Uncertainty propagation, sensitivity analysis, and reproducibility provenance
-- SI units, dimensional analysis, and scalable local data I/O
+- Uncertainty propagation, local/global sensitivity, and identifiability analysis
+- Distribution-drift and out-of-distribution validation
+- SI units, dimensional analysis, and memory-bounded scientific data I/O
 - Optional scientific-tool capability discovery and normalized adapters
 - CLI for quick calculations and discovery workflows
 
@@ -32,6 +34,7 @@ Usage:
 # Scientific computing modules
 from cds import (
     bayes,
+    causal,
     core,
     data_analysis,
     data_io,
@@ -98,6 +101,7 @@ __all__ = [
     "pendulum_period",
     "doppler_frequency",
     "bayes",
+    "causal",
     "core",
     "data_analysis",
     "data_io",

scientific_computing_system-2.1.0/src/cds/_version.py

@@ -0,0 +1,9 @@
+# Static version source. Kept in lockstep with `version` in pyproject.toml and
+# version metadata in CITATION.cff. Package-affecting changes require a
+# synchronized monotonic bump; scripts/check_version_discipline.py enforces it.
+from __future__ import annotations
+
+__all__ = ["__version__", "version", "__version_tuple__", "version_tuple"]
+
+__version__ = version = "2.1.0"
+__version_tuple__ = version_tuple = (2, 1, 0)

scientific_computing_system-2.1.0/src/cds/causal.py

@@ -0,0 +1,210 @@
+"""Conservative, assumption-gated causal effect estimators.
+
+This module does not infer causal structure from observational correlations.
+Callers must declare causal assumptions explicitly and, for observational
+back-door adjustment, provide the adjustment covariates themselves.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Sequence
+from dataclasses import dataclass
+
+from cds.validation import CheckStatus, ValidationCheck, ValidationReport
+
+
+@dataclass(frozen=True)
+class CausalAssumptions:
+    """Core identification assumptions that must be justified outside the estimator."""
+
+    temporal_order: bool | None
+    no_unmeasured_confounding: bool | None
+    positivity: bool | None
+    consistency: bool | None
+
+    @property
+    def identified(self) -> bool:
+        """Whether every required assumption is explicitly declared true."""
+        return all(
+            value is True
+            for value in (
+                self.temporal_order,
+                self.no_unmeasured_confounding,
+                self.positivity,
+                self.consistency,
+            )
+        )
+
+
+@dataclass(frozen=True)
+class CausalEffectEstimate:
+    """Point estimate from an explicitly identified causal design."""
+
+    effect: float
+    method: str
+    n_observations: int
+    adjustment_count: int
+    assumptions: CausalAssumptions | None
+
+
+def audit_causal_assumptions(assumptions: CausalAssumptions) -> ValidationReport:
+    """Convert explicit causal assumptions into PASS/WARNING/FAIL checks."""
+    report = ValidationReport()
+    for name, value in (
+        ("temporal_order", assumptions.temporal_order),
+        ("no_unmeasured_confounding", assumptions.no_unmeasured_confounding),
+        ("positivity", assumptions.positivity),
+        ("consistency", assumptions.consistency),
+    ):
+        if value is True:
+            report.add(ValidationCheck(name, CheckStatus.PASS, f"{name} explicitly supported"))
+        elif value is False:
+            report.add(ValidationCheck(name, CheckStatus.FAIL, f"{name} explicitly violated"))
+        else:
+            report.add(ValidationCheck(name, CheckStatus.WARNING, f"{name} not established"))
+    return report
+
+
+def _finite_vector(values: Sequence[float], *, name: str) -> tuple[float, ...]:
+    result = tuple(float(value) for value in values)
+    if any(not math.isfinite(value) for value in result):
+        raise ValueError(f"{name} must contain only finite values")
+    return result
+
+
+def _invert(matrix: Sequence[Sequence[float]], *, tolerance: float = 1e-12) -> list[list[float]]:
+    size = len(matrix)
+    augmented = [
+        [float(value) for value in row]
+        + [1.0 if row_index == column else 0.0 for column in range(size)]
+        for row_index, row in enumerate(matrix)
+    ]
+    for column in range(size):
+        pivot = max(range(column, size), key=lambda row: abs(augmented[row][column]))
+        if abs(augmented[pivot][column]) <= tolerance:
+            raise ValueError("causal adjustment design matrix is singular")
+        if pivot != column:
+            augmented[column], augmented[pivot] = augmented[pivot], augmented[column]
+        scale = augmented[column][column]
+        augmented[column] = [value / scale for value in augmented[column]]
+        for row in range(size):
+            if row == column:
+                continue
+            factor = augmented[row][column]
+            if factor == 0.0:
+                continue
+            augmented[row] = [
+                value - factor * pivot_value
+                for value, pivot_value in zip(augmented[row], augmented[column], strict=True)
+            ]
+    return [row[size:] for row in augmented]
+
+
+def _ols_coefficients(
+    design: Sequence[Sequence[float]], outcome: Sequence[float]
+) -> tuple[float, ...]:
+    if not design:
+        raise ValueError("causal estimator requires at least one observation")
+    columns = len(design[0])
+    if columns == 0 or any(len(row) != columns for row in design):
+        raise ValueError("causal design matrix must be rectangular and non-empty")
+    if len(design) < columns:
+        raise ValueError("causal design needs at least as many observations as coefficients")
+
+    gram = [[0.0] * columns for _ in range(columns)]
+    rhs = [0.0] * columns
+    for row, target in zip(design, outcome, strict=True):
+        for left in range(columns):
+            rhs[left] += row[left] * target
+            for right in range(columns):
+                gram[left][right] += row[left] * row[right]
+    inverse = _invert(gram)
+    return tuple(
+        sum(inverse[row][column] * rhs[column] for column in range(columns))
+        for row in range(columns)
+    )
+
+
+def linear_backdoor_effect(
+    outcome: Sequence[float],
+    treatment: Sequence[float],
+    covariates: Sequence[Sequence[float]],
+    *,
+    assumptions: CausalAssumptions,
+) -> CausalEffectEstimate:
+    """Estimate a linear back-door-adjusted treatment effect.
+
+    Identification is fail-closed: every assumption must be explicitly true.
+    The estimator fits ``outcome ~ 1 + treatment + covariates`` and returns the
+    treatment coefficient. The caller remains responsible for supplying a
+    causally valid adjustment set; this function never discovers one from data.
+    """
+    report = audit_causal_assumptions(assumptions)
+    if not assumptions.identified:
+        failures = [check.name for check in report.failures]
+        warnings = [check.name for check in report.warnings]
+        unresolved = failures + warnings
+        raise ValueError(
+            "causal effect is not identified; unresolved assumptions: " + ", ".join(unresolved)
+        )
+
+    y = _finite_vector(outcome, name="outcome")
+    treatment_values = _finite_vector(treatment, name="treatment")
+    if len(y) != len(treatment_values):
+        raise ValueError("outcome and treatment must have equal length")
+    if not y:
+        raise ValueError("causal estimator requires at least one observation")
+    if len(set(treatment_values)) < 2:
+        raise ValueError("treatment must vary across observations")
+    if len(covariates) != len(y):
+        raise ValueError("covariates must have one row per observation")
+
+    width = len(covariates[0]) if covariates else 0
+    rows: list[list[float]] = []
+    for index, raw_row in enumerate(covariates):
+        if len(raw_row) != width:
+            raise ValueError("covariate rows must have equal width")
+        row = _finite_vector(raw_row, name=f"covariates row {index}")
+        rows.append([1.0, treatment_values[index], *row])
+
+    coefficients = _ols_coefficients(rows, y)
+    return CausalEffectEstimate(
+        effect=coefficients[1],
+        method="linear-backdoor-adjustment",
+        n_observations=len(y),
+        adjustment_count=width,
+        assumptions=assumptions,
+    )
+
+
+def randomized_mean_effect(
+    treated_outcomes: Sequence[float],
+    control_outcomes: Sequence[float],
+    *,
+    randomized: bool,
+) -> CausalEffectEstimate:
+    """Estimate an average treatment effect from a declared randomized design."""
+    if not randomized:
+        raise ValueError("randomized_mean_effect requires an explicitly randomized design")
+    treated = _finite_vector(treated_outcomes, name="treated_outcomes")
+    control = _finite_vector(control_outcomes, name="control_outcomes")
+    if not treated or not control:
+        raise ValueError("treated and control groups must both be non-empty")
+    effect = sum(treated) / len(treated) - sum(control) / len(control)
+    return CausalEffectEstimate(
+        effect=effect,
+        method="randomized-difference-in-means",
+        n_observations=len(treated) + len(control),
+        adjustment_count=0,
+        assumptions=None,
+    )
+
+
+__all__ = [
+    "CausalAssumptions",
+    "CausalEffectEstimate",
+    "audit_causal_assumptions",
+    "linear_backdoor_effect",
+    "randomized_mean_effect",
+]

{scientific_computing_system-2.0.1 → scientific_computing_system-2.1.0}/src/cds/data_io/__init__.py

@@ -1,5 +1,14 @@
 """Streaming file I/O and lazy optional scientific data backends."""
 
+from cds.data_io.scientific import (
+    ArrayChunk,
+    ScientificArrayProfile,
+    iter_array_chunks,
+    iter_hdf5_chunks,
+    iter_netcdf_chunks,
+    profile_scientific_array,
+    reduce_chunks,
+)
 from cds.data_io.streaming import (
     FileProfile,
     OnlineMoments,
@@ -14,14 +23,21 @@ from cds.data_io.streaming import (
 )
 
 __all__ = [
+    "ArrayChunk",
     "FileProfile",
     "OnlineMoments",
+    "ScientificArrayProfile",
     "StreamingLinearAccumulator",
     "StreamingLinearFit",
     "fit_linear_csv_streaming",
+    "iter_array_chunks",
     "iter_csv_batches",
     "iter_file_blocks",
+    "iter_hdf5_chunks",
+    "iter_netcdf_chunks",
     "open_hdf5",
     "open_netcdf",
     "profile_file",
+    "profile_scientific_array",
+    "reduce_chunks",
 ]