simulsi 0.2.0__py3-none-any.whl

simulsi/__init__.py

@@ -0,0 +1,70 @@
+"""SimulSI: Simulation Intelligence. Model the system. Simulate the future."""
+
+from simulsi._version import __version__
+from simulsi.analysis import Comparison, compare
+from simulsi.core import Clock, EventLog, LogRecord, Simulation, SimulationResult
+from simulsi.core.model import Model, Parameter, Params, model
+from simulsi.entities import Entity
+from simulsi.errors import (
+    CapacityError,
+    ConfigError,
+    EventStateError,
+    Interrupt,
+    ModelValidationError,
+    ResourceUsageError,
+    SchedulingError,
+    SimulsiError,
+)
+from simulsi.events import Event, EventStatus, Priority
+from simulsi.experiments import Experiment, ExperimentResult, MonteCarloResult, monte_carlo
+from simulsi.metrics import Metrics
+from simulsi.processes import AllOf, AnyOf, Process, Signal, Timeout, Waitable
+from simulsi.queues import Queue
+from simulsi.randomness import RandomStream
+from simulsi.resources import Preempted, Request, Resource
+from simulsi.scenarios import Scenario, grid
+
+__all__ = [
+    "AllOf",
+    "AnyOf",
+    "CapacityError",
+    "Clock",
+    "Comparison",
+    "ConfigError",
+    "Entity",
+    "Event",
+    "EventLog",
+    "EventStateError",
+    "EventStatus",
+    "Experiment",
+    "ExperimentResult",
+    "Interrupt",
+    "LogRecord",
+    "Metrics",
+    "Model",
+    "ModelValidationError",
+    "MonteCarloResult",
+    "Parameter",
+    "Params",
+    "Preempted",
+    "Priority",
+    "Process",
+    "Queue",
+    "RandomStream",
+    "Request",
+    "Resource",
+    "ResourceUsageError",
+    "Scenario",
+    "SchedulingError",
+    "Signal",
+    "Simulation",
+    "SimulationResult",
+    "SimulsiError",
+    "Timeout",
+    "Waitable",
+    "__version__",
+    "compare",
+    "grid",
+    "model",
+    "monte_carlo",
+]

simulsi/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from simulsi.cli.main import main
+
+sys.exit(main())

simulsi/_version.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

simulsi/analysis/__init__.py

@@ -0,0 +1,24 @@
+from simulsi.analysis.comparison import Comparison, ComparisonRow, compare, compare_samples
+from simulsi.analysis.report import format_table
+from simulsi.analysis.sensitivity import (
+    SensitivityResult,
+    SensitivityRow,
+    correlation_sensitivity,
+    finite_difference,
+    one_at_a_time,
+    sobol_indices,
+)
+
+__all__ = [
+    "Comparison",
+    "ComparisonRow",
+    "SensitivityResult",
+    "SensitivityRow",
+    "compare",
+    "compare_samples",
+    "correlation_sensitivity",
+    "finite_difference",
+    "format_table",
+    "one_at_a_time",
+    "sobol_indices",
+]

simulsi/analysis/comparison.py

@@ -0,0 +1,154 @@
+"""Scenario comparison against a baseline."""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Mapping, Sequence
+from dataclasses import asdict, dataclass
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+from simulsi.analysis.report import format_table
+from simulsi.statistics.core import Difference, paired_difference, welch_difference
+
+if TYPE_CHECKING:
+    from simulsi.experiments.experiment import ExperimentResult
+
+
+@dataclass(frozen=True)
+class ComparisonRow:
+    metric: str
+    baseline: str
+    scenario: str
+    baseline_mean: float
+    scenario_mean: float
+    absolute_difference: float
+    percentage_difference: float
+    ci_low: float
+    ci_high: float
+    p_value: float
+    method: str
+    n: int
+    significant: bool
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+class Comparison:
+    """Differences ``scenario - baseline`` for each metric, with confidence intervals.
+
+    The intervals quantify *simulation sampling error* only. A significant
+    difference means the model, as specified, responds to the change; it says
+    nothing about whether the real system would (that depends on model
+    validity). No multiple-comparison correction is applied.
+    """
+
+    def __init__(self, rows: Sequence[ComparisonRow], confidence: float) -> None:
+        self.rows = list(rows)
+        self.confidence = confidence
+
+    def to_dicts(self) -> list[dict[str, Any]]:
+        return [r.to_dict() for r in self.rows]
+
+    def get(self, metric: str, scenario: str) -> ComparisonRow:
+        for r in self.rows:
+            if r.metric == metric and r.scenario == scenario:
+                return r
+        raise KeyError((metric, scenario))
+
+    def format(self) -> str:
+        return format_table(
+            [
+                {
+                    "metric": r.metric,
+                    "scenario": r.scenario,
+                    "baseline": r.baseline_mean,
+                    "value": r.scenario_mean,
+                    "diff": r.absolute_difference,
+                    "diff%": r.percentage_difference,
+                    "ci_low": r.ci_low,
+                    "ci_high": r.ci_high,
+                    "sig": "*" if r.significant else "",
+                }
+                for r in self.rows
+            ]
+        )
+
+    def __repr__(self) -> str:
+        return f"Comparison({len(self.rows)} rows, confidence={self.confidence})"
+
+
+def _row(metric: str, base: str, sc: str, d: Difference) -> ComparisonRow:
+    pct = d.relative_difference * 100
+    return ComparisonRow(
+        metric,
+        base,
+        sc,
+        d.mean_a,
+        d.mean_b,
+        d.difference,
+        pct,
+        d.ci_low,
+        d.ci_high,
+        d.p_value,
+        d.method,
+        min(d.n_a, d.n_b),
+        d.significant,
+    )
+
+
+def compare(
+    result: ExperimentResult,
+    baseline: str = "baseline",
+    scenarios: Iterable[str] | None = None,
+    metrics: Iterable[str] | None = None,
+    *,
+    confidence: float = 0.95,
+) -> Comparison:
+    """Compare scenarios of one experiment with its ``baseline`` scenario.
+
+    When the experiment used common random numbers and both scenarios have the
+    same replication seeds, a paired-t interval is used (replication *i* of
+    each scenario saw the same random streams); otherwise Welch's t.
+    """
+    if baseline not in result.scenarios:
+        raise KeyError(f"baseline {baseline!r} not in experiment scenarios {result.scenarios}")
+    others = [
+        s for s in (scenarios if scenarios is not None else result.scenarios) if s != baseline
+    ]
+    names = list(metrics) if metrics is not None else result.metric_names
+    rows = []
+    for sc in others:
+        paired = result.metadata.common_random_numbers and result.seeds(sc) == result.seeds(
+            baseline
+        )
+        for m in names:
+            a, b = result.values(m, baseline), result.values(m, sc)
+            d = (
+                paired_difference(a, b, confidence)
+                if paired and len(a) == len(b)
+                else welch_difference(a, b, confidence)
+            )
+            rows.append(_row(m, baseline, sc, d))
+    return Comparison(rows, confidence)
+
+
+def compare_samples(
+    baseline: Mapping[str, Sequence[float]],
+    scenario: Mapping[str, Sequence[float]],
+    *,
+    paired: bool = False,
+    confidence: float = 0.95,
+    baseline_name: str = "baseline",
+    scenario_name: str = "scenario",
+) -> Comparison:
+    """Compare two ``{metric: values}`` samples (e.g. collected outside an Experiment)."""
+    rows = []
+    for m in baseline:
+        if m not in scenario:
+            continue
+        a, b = np.asarray(baseline[m], dtype=float), np.asarray(scenario[m], dtype=float)
+        d = paired_difference(a, b, confidence) if paired else welch_difference(a, b, confidence)
+        rows.append(_row(m, baseline_name, scenario_name, d))
+    return Comparison(rows, confidence)

simulsi/analysis/report.py

@@ -0,0 +1,46 @@
+"""Plain-text tables for terminal output."""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+
+def fmt_value(v: Any) -> str:
+    if isinstance(v, bool):
+        return str(v)
+    if isinstance(v, int):
+        return str(v)
+    if isinstance(v, float):
+        if math.isnan(v):
+            return "-"
+        if math.isinf(v):
+            return "inf" if v > 0 else "-inf"
+        a = abs(v)
+        if a != 0 and (a >= 1e6 or a < 1e-3):
+            return f"{v:.3e}"
+        return f"{v:.4g}" if a < 1000 else f"{v:,.1f}"
+    return str(v)
+
+
+def format_table(rows: Sequence[Mapping[str, Any]], columns: Sequence[str] | None = None) -> str:
+    if not rows:
+        return "(no rows)"
+    cols = list(columns) if columns is not None else list(rows[0].keys())
+    cells = [[fmt_value(r.get(c, "")) for c in cols] for r in rows]
+    widths = [max(len(c), *(len(row[i]) for row in cells)) for i, c in enumerate(cols)]
+    numeric = [
+        all(isinstance(r.get(c), int | float) and not isinstance(r.get(c), bool) for r in rows)
+        for c in cols
+    ]
+
+    def line(values: Sequence[str]) -> str:
+        return "  ".join(
+            v.rjust(w) if num else v.ljust(w)
+            for v, w, num in zip(values, widths, numeric, strict=True)
+        ).rstrip()
+
+    out = [line(cols), line(["-" * w for w in widths])]
+    out += [line(row) for row in cells]
+    return "\n".join(out)

simulsi/analysis/sensitivity.py

@@ -0,0 +1,387 @@
+"""Sensitivity analysis: which inputs move which outputs, and by how much.
+
+Methods implemented (all simple and well understood):
+
+* :func:`one_at_a_time` - change one parameter at a time around a base
+  point, with common random numbers, and report the change in each output
+  plus a paired confidence interval and an elasticity.
+* :func:`finite_difference` - local derivative ``d output / d parameter``
+  by central (or forward) differences with common random numbers.
+* :func:`correlation_sensitivity` - global screening from Monte Carlo
+  samples: Pearson, Spearman rank correlation and standardised regression
+  coefficients (SRC, with the regression R^2 so you can tell whether a
+  linear summary is adequate).
+
+* :func:`sobol_indices` - variance-based global sensitivity: first-order
+  and total-effect Sobol indices (Saltelli 2010 / Jansen estimators) with
+  bootstrap confidence intervals. Captures interactions and non-linear
+  effects at a cost of ``N * (d + 2)`` model evaluations.
+
+Correlation measures are cheap screening tools that miss interactions and
+non-monotonic effects; use Sobol indices when that matters.
+"""
+
+from __future__ import annotations
+
+import inspect
+import math
+from collections.abc import Callable, Mapping, Sequence
+from dataclasses import asdict, dataclass
+from typing import Any, Literal
+
+import numpy as np
+from scipy import stats as _st
+
+from simulsi.analysis.report import format_table
+from simulsi.core.model import Model
+from simulsi.experiments.montecarlo import MonteCarloResult, sample_inputs
+from simulsi.randomness.distributions import DistributionLike
+from simulsi.randomness.stream import RandomStream, derive_seed
+from simulsi.statistics.core import paired_difference, t_half_width
+
+
+@dataclass(frozen=True)
+class SensitivityRow:
+    parameter: str
+    output: str
+    method: str
+    value: float
+    ci_low: float = math.nan
+    ci_high: float = math.nan
+    setting: str = ""
+    detail: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+class SensitivityResult:
+    def __init__(
+        self, rows: Sequence[SensitivityRow], info: Mapping[str, Any] | None = None
+    ) -> None:
+        self.rows = list(rows)
+        self.info = dict(info or {})
+
+    def ranking(self, output: str | None = None, method: str | None = None) -> list[SensitivityRow]:
+        """Rows sorted by absolute effect size, largest first."""
+        rows = [
+            r
+            for r in self.rows
+            if (output is None or r.output == output) and (method is None or r.method == method)
+        ]
+        return sorted(rows, key=lambda r: -abs(r.value) if not math.isnan(r.value) else 0.0)
+
+    def to_dicts(self) -> list[dict[str, Any]]:
+        return [r.to_dict() for r in self.rows]
+
+    def format(self) -> str:
+        return format_table(
+            [
+                {
+                    "parameter": r.parameter,
+                    "setting": r.setting,
+                    "output": r.output,
+                    "method": r.method,
+                    "value": r.value,
+                    "ci_low": r.ci_low,
+                    "ci_high": r.ci_high,
+                }
+                for r in self.ranking()
+            ]
+        )
+
+    def __repr__(self) -> str:
+        return f"SensitivityResult({len(self.rows)} rows)"
+
+
+def _run_metrics(
+    model: Model, params: Mapping[str, Any], outputs: Sequence[str], reps: int, seed: int
+) -> dict[str, np.ndarray[Any, Any]]:
+    vals: dict[str, list[float]] = {o: [] for o in outputs}
+    for r in range(reps):
+        m = model.simulate(params, seed=derive_seed(seed, "replication", r)).metrics
+        for o in outputs:
+            if o not in m:
+                raise KeyError(f"model produced no metric {o!r}")
+            vals[o].append(m[o])
+    return {o: np.asarray(v, dtype=float) for o, v in vals.items()}
+
+
+def one_at_a_time(
+    model: Model,
+    changes: Mapping[str, Sequence[Any]],
+    outputs: Sequence[str],
+    *,
+    base: Mapping[str, Any] | None = None,
+    replications: int = 10,
+    seed: int = 0,
+    confidence: float = 0.95,
+) -> SensitivityResult:
+    """Vary each parameter in ``changes`` alone; report output change vs the base point.
+
+    ``value`` is the mean change in the output; ``detail`` includes the
+    elasticity ``(dy/y) / (dx/x)`` when both base values are non-zero numbers.
+    """
+    base_params = dict(model.resolve(base))
+    base_out = _run_metrics(model, base_params, outputs, replications, seed)
+    rows = []
+    for param, values in changes.items():
+        if param not in base_params:
+            raise KeyError(f"unknown parameter {param!r}")
+        x0 = base_params[param]
+        for v in values:
+            out = _run_metrics(model, {**(base or {}), param: v}, outputs, replications, seed)
+            for o in outputs:
+                d = paired_difference(base_out[o], out[o], confidence)
+                elasticity = math.nan
+                y0 = float(np.nanmean(base_out[o]))
+                if (
+                    isinstance(x0, int | float)
+                    and isinstance(v, int | float)
+                    and x0
+                    and y0
+                    and v != x0
+                ):
+                    elasticity = (d.difference / y0) / ((v - x0) / x0)
+                rows.append(
+                    SensitivityRow(
+                        param,
+                        o,
+                        "oat",
+                        d.difference,
+                        d.ci_low,
+                        d.ci_high,
+                        f"{param}={v}",
+                        f"base {param}={x0}; base output={y0:.4g}; elasticity={elasticity:.3g}",
+                    )
+                )
+    return SensitivityResult(
+        rows, {"base": base_params, "replications": replications, "seed": seed}
+    )
+
+
+def finite_difference(
+    model: Model,
+    parameters: Sequence[str],
+    outputs: Sequence[str],
+    *,
+    base: Mapping[str, Any] | None = None,
+    relative_step: float = 0.05,
+    replications: int = 10,
+    seed: int = 0,
+    scheme: Literal["central", "forward"] = "central",
+    confidence: float = 0.95,
+) -> SensitivityResult:
+    """Local derivatives by finite differences with common random numbers.
+
+    Integer parameters use a step of at least 1. The CI comes from the
+    per-replication paired differences, so it reflects simulation noise only;
+    a step that is too small amplifies noise, too large adds bias.
+    """
+    base_params = dict(model.resolve(base))
+    rows = []
+    base_out = (
+        _run_metrics(model, base_params, outputs, replications, seed)
+        if scheme == "forward"
+        else None
+    )
+    for p in parameters:
+        x0 = base_params[p]
+        if isinstance(x0, bool) or not isinstance(x0, int | float):
+            raise TypeError(f"parameter {p!r} is not numeric")
+        h: float = abs(x0) * relative_step or relative_step
+        if isinstance(x0, int):
+            h = max(1, round(h))
+        hi_params = {**(base or {}), p: x0 + h}
+        hi = _run_metrics(model, hi_params, outputs, replications, seed)
+        if scheme == "central":
+            lo = _run_metrics(model, {**(base or {}), p: x0 - h}, outputs, replications, seed)
+            span = 2 * h
+        else:
+            assert base_out is not None
+            lo, span = base_out, h
+        for o in outputs:
+            per_rep = (hi[o] - lo[o]) / span
+            mean = float(np.nanmean(per_rep))
+            hw = t_half_width(per_rep, confidence)
+            rows.append(
+                SensitivityRow(p, o, f"fd-{scheme}", mean, mean - hw, mean + hw, f"step={h:g}")
+            )
+    return SensitivityResult(rows, {"base": base_params, "relative_step": relative_step})
+
+
+def correlation_sensitivity(
+    mc: MonteCarloResult,
+    outputs: Sequence[str] | None = None,
+    *,
+    methods: Sequence[Literal["pearson", "spearman", "src"]] = ("pearson", "spearman", "src"),
+) -> SensitivityResult:
+    """Global screening from Monte Carlo samples of uncertain inputs."""
+    names = [k for k, v in mc.inputs.items() if np.issubdtype(np.asarray(v).dtype, np.number)]
+    if not names:
+        raise ValueError("no numeric sampled inputs to analyse")
+    X = np.column_stack([np.asarray(mc.inputs[k], dtype=float) for k in names])
+    rows = []
+    info: dict[str, Any] = {"r2": {}}
+    for o in outputs if outputs is not None else mc.output_names:
+        y = mc.outputs[o]
+        ok = ~np.isnan(y)
+        Xo, yo = X[ok], y[ok]
+        if len(yo) < 3 or np.std(yo) == 0:
+            continue
+        for j, name in enumerate(names):
+            x = Xo[:, j]
+            if np.std(x) == 0:
+                continue
+            if "pearson" in methods:
+                r, pv = _st.pearsonr(x, yo)
+                rows.append(
+                    SensitivityRow(name, o, "pearson", float(r), detail=f"p={float(pv):.3g}")
+                )
+            if "spearman" in methods:
+                rho, pv = _st.spearmanr(x, yo)
+                rows.append(
+                    SensitivityRow(name, o, "spearman", float(rho), detail=f"p={float(pv):.3g}")
+                )
+        if "src" in methods:
+            sd = Xo.std(axis=0)
+            keep = sd > 0
+            Z = (Xo[:, keep] - Xo[:, keep].mean(axis=0)) / sd[keep]
+            zy = (yo - yo.mean()) / yo.std()
+            A = np.column_stack([np.ones(len(zy)), Z])
+            coef, *_ = np.linalg.lstsq(A, zy, rcond=None)
+            pred = A @ coef
+            r2 = 1 - float(((zy - pred) ** 2).sum() / (zy**2).sum())
+            info["r2"][o] = r2
+            for name, c in zip(
+                [n for n, k in zip(names, keep, strict=True) if k], coef[1:], strict=True
+            ):
+                rows.append(SensitivityRow(name, o, "src", float(c), detail=f"R2={r2:.3f}"))
+    return SensitivityResult(rows, info)
+
+
+def _evaluate_rows(
+    model: Callable[..., Any] | Model,
+    inputs: Mapping[str, np.ndarray[Any, Any]],
+    rows: int,
+    *,
+    fixed: Mapping[str, Any],
+    vectorized: bool,
+    seed: int,
+    crn_period: int,
+) -> dict[str, np.ndarray[Any, Any]]:
+    """Evaluate ``model`` on every row of ``inputs``. Row ``j`` uses seed index ``j % crn_period``."""
+    if vectorized:
+        if isinstance(model, Model):
+            raise ValueError("vectorized=True is not available for simulation models")
+        res = model(**fixed, **inputs)
+        arrays = res if isinstance(res, Mapping) else {"value": res}
+        return {
+            k: np.broadcast_to(np.asarray(v, dtype=float), (rows,)).copy()
+            for k, v in arrays.items()
+        }
+    wants_rng = not isinstance(model, Model) and "rng" in inspect.signature(model).parameters
+    out: dict[str, list[float]] = {}
+    for j in range(rows):
+        params = {
+            **fixed,
+            **{k: v[j].item() if hasattr(v[j], "item") else v[j] for k, v in inputs.items()},
+        }
+        rep_seed = derive_seed(seed, "replication", j % crn_period)
+        if isinstance(model, Model):
+            values: Any = model.simulate(params, seed=rep_seed).metrics
+        elif wants_rng:
+            values = model(**params, rng=RandomStream(rep_seed))
+        else:
+            values = model(**params)
+        row = dict(values) if isinstance(values, Mapping) else {"value": float(values)}
+        for k, v in row.items():
+            out.setdefault(k, [math.nan] * j).append(float(v))
+        for k in out:
+            if len(out[k]) < j + 1:
+                out[k].append(math.nan)
+    return {k: np.asarray(v, dtype=float) for k, v in out.items()}
+
+
+def sobol_indices(
+    model: Callable[..., Any] | Model,
+    parameters: Mapping[str, DistributionLike | Mapping[str, Any]],
+    n: int = 1024,
+    *,
+    outputs: Sequence[str] | None = None,
+    seed: int = 0,
+    fixed: Mapping[str, Any] | None = None,
+    vectorized: bool = False,
+    confidence: float = 0.95,
+    n_bootstrap: int = 500,
+) -> SensitivityResult:
+    """First-order and total-effect Sobol indices with bootstrap confidence intervals.
+
+    Uses the Saltelli (2010) design: two independent sample matrices ``A`` and
+    ``B`` of ``n`` rows plus, for each of the ``d`` parameters, ``A`` with that
+    column taken from ``B``. First-order indices use the Saltelli (2010)
+    estimator, total effects the Jansen (1999) estimator. Inputs are assumed
+    independent. For simulation models every matrix row ``j`` uses the same
+    replication seed (common random numbers), which keeps simulation noise
+    from swamping the index estimates; noise still adds some bias, so use
+    enough replication length or average several runs per row if outputs are
+    very noisy.
+
+    ``value`` is the index estimate (``method`` = ``sobol-first`` or
+    ``sobol-total``). Estimates can fall slightly outside [0, 1] with small
+    ``n``; the bootstrap interval shows how precise they are.
+    """
+    if n < 2:
+        raise ValueError("n must be >= 2")
+    names = list(parameters)
+    d = len(names)
+    if d == 0:
+        raise ValueError("need at least one uncertain parameter")
+    a = sample_inputs(parameters, n, derive_seed(seed, "sobol-A"))
+    b = sample_inputs(parameters, n, derive_seed(seed, "sobol-B"))
+    blocks = [a, b] + [{k: (b[k] if k == name else a[k]) for k in names} for name in names]
+    design = {k: np.concatenate([blk[k] for blk in blocks]) for k in names}
+    total = n * (d + 2)
+    y_all = _evaluate_rows(
+        model,
+        design,
+        total,
+        fixed=dict(fixed or {}),
+        vectorized=vectorized,
+        seed=seed,
+        crn_period=n,
+    )
+    rng = np.random.default_rng(derive_seed(seed, "sobol-bootstrap"))
+    boot_idx = rng.integers(0, n, size=(n_bootstrap, n))
+    alpha = (1 - confidence) / 2
+    rows: list[SensitivityRow] = []
+    info: dict[str, Any] = {"n": n, "evaluations": total, "variance": {}}
+    for o in outputs if outputs is not None else list(y_all):
+        if o not in y_all:
+            raise KeyError(f"model produced no output {o!r}")
+        y = y_all[o].reshape(d + 2, n)
+        f_a, f_b, f_ab = y[0], y[1], y[2:]  # (n,), (n,), (d, n)
+        var = np.var(np.concatenate([f_a, f_b]), ddof=1)
+        s1 = np.mean(f_b * (f_ab - f_a), axis=1) / var
+        st = 0.5 * np.mean((f_a - f_ab) ** 2, axis=1) / var
+        # bootstrap over rows: shapes (B, n) and (d, B, n)
+        fa_b, fb_b, fab_b = f_a[boot_idx], f_b[boot_idx], f_ab[:, boot_idx]
+        var_b = np.var(np.concatenate([fa_b, fb_b], axis=1), axis=1, ddof=1)
+        with np.errstate(divide="ignore", invalid="ignore"):
+            b1 = np.mean(fb_b * (fab_b - fa_b), axis=2) / var_b
+            bt = 0.5 * np.mean((fa_b - fab_b) ** 2, axis=2) / var_b
+        info["variance"][o] = float(var)
+        for i, name in enumerate(names):
+            lo1, hi1 = np.nanquantile(b1[i], [alpha, 1 - alpha])
+            lot, hit = np.nanquantile(bt[i], [alpha, 1 - alpha])
+            rows.append(
+                SensitivityRow(
+                    name, o, "sobol-first", float(s1[i]), float(lo1), float(hi1), f"N={n}"
+                )
+            )
+            rows.append(
+                SensitivityRow(
+                    name, o, "sobol-total", float(st[i]), float(lot), float(hit), f"N={n}"
+                )
+            )
+    return SensitivityResult(rows, info)