jarvisplot 2.1.5__tar.gz → 2.1.6__tar.gz

{jarvisplot-2.1.5 → jarvisplot-2.1.6}/JarvisPLOT.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 2.1.5
+Version: 2.1.6
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -161,11 +161,20 @@ The loop `jplot man` prints is:
 5. `jplot <file>` — render, only when the figure itself is needed.
 
 `jplot man --json` is the machine-readable manual: 15 topics, plus a
-live page for every one of the 28 layer methods and 11 transform steps
-(`jplot man scatter`, `jplot man transform.profile`). Method contracts come from
+live pages for every registered layer method and transform step
+(`jplot man scatter`, `jplot man transform.profile`, `jplot man PDF1D`). Method contracts come from
 the same registry `jplot cap methods` reads, so a man page cannot drift from the
 code.
 
+For continuous one-dimensional distributions from raw samples, use `PDF1D`
+(CDF plus PDF) or `CDF1D` in a data transform. `coordinates.x` owns `expr`,
+`lim`, and `grid`; optional `repeat` computes independent batch means and
+standard deviations. See [the contract](docs/specs/PDF_CDF_1D.md) and the
+[runnable example](Example/pdf_cdf_1d.yaml).
+Reconstruction defaults to adaptive true CDF anchors and `monotone_c2`
+interpolation (C2 CDF / C1 PDF). Set `anchors: all` and `interpolation: pchip`
+to reproduce the original all-node reconstruction.
+
 Two things worth knowing before trusting a config:
 
 - `jplot validate` checks shape and contracts and never touches the data;

{jarvisplot-2.1.5 → jarvisplot-2.1.6}/JarvisPLOT.egg-info/SOURCES.txt

@@ -30,6 +30,7 @@ jarvisplot/data_loader_summary.py
 jarvisplot/dataset_types.py
 jarvisplot/diagnostic_guidance.py
 jarvisplot/diagnostics.py
+jarvisplot/distribution_1d_config.py
 jarvisplot/dryrun_runtime.py
 jarvisplot/expr_names.py
 jarvisplot/fix_apply.py
@@ -53,6 +54,7 @@ jarvisplot/yaml_io.py
 jarvisplot/Figure/__init__.py
 jarvisplot/Figure/adapters_rect.py
 jarvisplot/Figure/adapters_ternary.py
+jarvisplot/Figure/adaptive_cdf_runtime.py
 jarvisplot/Figure/bin_stat_runtime.py
 jarvisplot/Figure/colorbar_runtime.py
 jarvisplot/Figure/config_runtime.py
@@ -65,6 +67,7 @@ jarvisplot/Figure/data_pipelines.py
 jarvisplot/Figure/debug_config.py
 jarvisplot/Figure/density_cell_runtime.py
 jarvisplot/Figure/design_runtime.py
+jarvisplot/Figure/distribution_1d_runtime.py
 jarvisplot/Figure/dynesty_runtime.py
 jarvisplot/Figure/figure.py
 jarvisplot/Figure/figure_types.py
@@ -139,6 +142,7 @@ jarvisplot/schema/manifest.json
 jarvisplot/schema/plot-config.json
 jarvisplot/schema/core/common.json
 jarvisplot/schema/core/dataset.json
+jarvisplot/schema/core/distribution-1d.json
 jarvisplot/schema/core/figure.json
 jarvisplot/schema/core/generated-data.json
 jarvisplot/schema/core/layer.json
@@ -190,6 +194,7 @@ jarvisplot/verbs/man.py
 jarvisplot/verbs/suggest.py
 jarvisplot/verbs/template.py
 jarvisplot/verbs/validate.py
+tests/test_adaptive_cdf.py
 tests/test_agent_digest.py
 tests/test_agent_envelope.py
 tests/test_axis_title.py
@@ -215,6 +220,7 @@ tests/test_debug_yaml_override.py
 tests/test_density_cell_transform.py
 tests/test_design_runtime.py
 tests/test_diagnostic_guidance.py
+tests/test_distribution_1d_transform.py
 tests/test_docs_status_labels.py
 tests/test_doctor_partial.py
 tests/test_explain.py

{jarvisplot-2.1.5 → jarvisplot-2.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: JarvisPLOT
-Version: 2.1.5
+Version: 2.1.6
 Summary: Jarvis-PLOT: YAML-driven plotting engine
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -161,11 +161,20 @@ The loop `jplot man` prints is:
 5. `jplot <file>` — render, only when the figure itself is needed.
 
 `jplot man --json` is the machine-readable manual: 15 topics, plus a
-live page for every one of the 28 layer methods and 11 transform steps
-(`jplot man scatter`, `jplot man transform.profile`). Method contracts come from
+live pages for every registered layer method and transform step
+(`jplot man scatter`, `jplot man transform.profile`, `jplot man PDF1D`). Method contracts come from
 the same registry `jplot cap methods` reads, so a man page cannot drift from the
 code.
 
+For continuous one-dimensional distributions from raw samples, use `PDF1D`
+(CDF plus PDF) or `CDF1D` in a data transform. `coordinates.x` owns `expr`,
+`lim`, and `grid`; optional `repeat` computes independent batch means and
+standard deviations. See [the contract](docs/specs/PDF_CDF_1D.md) and the
+[runnable example](Example/pdf_cdf_1d.yaml).
+Reconstruction defaults to adaptive true CDF anchors and `monotone_c2`
+interpolation (C2 CDF / C1 PDF). Set `anchors: all` and `interpolation: pchip`
+to reproduce the original all-node reconstruction.
+
 Two things worth knowing before trusting a config:
 
 - `jplot validate` checks shape and contracts and never touches the data;

{jarvisplot-2.1.5 → jarvisplot-2.1.6}/README.md

@@ -139,11 +139,20 @@ The loop `jplot man` prints is:
 5. `jplot <file>` — render, only when the figure itself is needed.
 
 `jplot man --json` is the machine-readable manual: 15 topics, plus a
-live page for every one of the 28 layer methods and 11 transform steps
-(`jplot man scatter`, `jplot man transform.profile`). Method contracts come from
+live pages for every registered layer method and transform step
+(`jplot man scatter`, `jplot man transform.profile`, `jplot man PDF1D`). Method contracts come from
 the same registry `jplot cap methods` reads, so a man page cannot drift from the
 code.
 
+For continuous one-dimensional distributions from raw samples, use `PDF1D`
+(CDF plus PDF) or `CDF1D` in a data transform. `coordinates.x` owns `expr`,
+`lim`, and `grid`; optional `repeat` computes independent batch means and
+standard deviations. See [the contract](docs/specs/PDF_CDF_1D.md) and the
+[runnable example](Example/pdf_cdf_1d.yaml).
+Reconstruction defaults to adaptive true CDF anchors and `monotone_c2`
+interpolation (C2 CDF / C1 PDF). Set `anchors: all` and `interpolation: pchip`
+to reproduce the original all-node reconstruction.
+
 Two things worth knowing before trusting a config:
 
 - `jplot validate` checks shape and contracts and never touches the data;

jarvisplot-2.1.6/jarvisplot/Figure/adaptive_cdf_runtime.py

@@ -0,0 +1,131 @@
+"""Adaptive empirical-CDF anchors and a local, monotone C2 quintic interpolant.
+
+No bins, kernels, or nonlinear solver. The quartic PDF is represented in the
+Bernstein basis; nonnegative coefficients certify nonnegativity on each whole
+interval, rather than only at sampled output points.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from heapq import heappop, heappush
+
+import numpy as np
+from scipy.interpolate import BPoly, CubicSpline, PchipInterpolator
+
+from ..distribution_1d_config import AnchorSettings
+
+
+def monotone_c2(x: np.ndarray, y: np.ndarray) -> BPoly:
+    """Exact C2 Hermite quintics with locally limited slopes and curvatures.
+
+    On an interval of width h and secant m, the quartic derivative's Bernstein
+    coefficients are [d0, d0+h*a0/4, 5*m-2*(d0+d1)+h*(a1-a0)/4,
+    d1-h*a1/4, d1]. Limit curvatures first, then shrink each node's (d,a)
+    together so all five coefficients are nonnegative. Each shared node has
+    one value, slope, and curvature: the assembled CDF is C2 and PDF is C1.
+    The support endpoints have zero slope/curvature, allowing constant CDF
+    extension and zero PDF extension without a boundary derivative jump.
+    """
+    x, y = np.asarray(x, dtype=float), np.asarray(y, dtype=float)
+    if x.ndim != 1 or len(x) < 2 or y.shape != x.shape or not np.all(np.isfinite(x)) or not np.all(np.isfinite(y)):
+        raise ValueError("monotone_c2 needs matching finite 1D anchor arrays")
+    h, mass = np.diff(x), np.diff(y)
+    if np.any(h <= 0) or np.any(mass < 0):
+        raise ValueError("monotone_c2 requires strictly increasing x and nondecreasing CDF anchors")
+    # A clamped cubic estimates smooth slopes/curvatures in linear time. Its
+    # unconstrained interpolant is never returned: the quintic limiter below
+    # certifies monotonicity even where the cubic estimate would overshoot.
+    seed = CubicSpline(x, y, bc_type=((1, 0.0), (1, 0.0)))
+    slopes = np.maximum(seed(x, 1), 0.0)
+    slopes[[0, -1]] = 0.0
+    curvature = seed(x, 2)
+    # Adjacent interval constraints for the first/last PDF control coefficients.
+    lower, upper = np.full(len(x), -np.inf), np.full(len(x), np.inf)
+    lower[:-1] = -4 * slopes[:-1] / h
+    upper[1:] = 4 * slopes[1:] / h
+    curvature = np.clip(curvature, lower, upper)
+    curvature[[0, -1]] = 0.0
+    # Both contributions are nonnegative after clipping. Reducing either node
+    # cannot violate another interval's constraint, so one local pass suffices.
+    left = 2 * slopes[:-1] + h * curvature[:-1] / 4
+    right = 2 * slopes[1:] - h * curvature[1:] / 4
+    available = 5 * mass / h
+    total = left + right
+    factors = np.ones(len(h))
+    active = total > available
+    factors[active] = (available[active] / total[active]) * (1 - 32 * np.finfo(float).eps)
+    node_factors = np.ones(len(x))
+    node_factors[:-1] = np.minimum(node_factors[:-1], factors)
+    node_factors[1:] = np.minimum(node_factors[1:], factors)
+    slopes *= node_factors
+    curvature *= node_factors
+    if not np.all(np.isfinite(slopes)) or not np.all(np.isfinite(curvature)):
+        raise ValueError("monotone_c2 cannot resolve this anchor spacing; inspect support and score precision")
+    return BPoly.from_derivatives(x, np.column_stack((y, slopes, curvature)), extrapolate=False)
+
+
+def interpolate_cdf(x: np.ndarray, y: np.ndarray, method: str):
+    if method == "monotone_c2":
+        return monotone_c2(x, y)
+    if method == "pchip":
+        return PchipInterpolator(x, y, extrapolate=False)
+    raise ValueError(f"unknown CDF interpolation {method!r}")
+
+
+@dataclass(frozen=True)
+class AnchorFit:
+    curve: BPoly | PchipInterpolator
+    indices: np.ndarray
+    max_error: float
+    stop_reason: str
+
+
+def fit_anchors(x: np.ndarray, y: np.ndarray, config: AnchorSettings, interpolation: str) -> AnchorFit:
+    """Select only real empirical nodes plus the supplied support endpoints.
+
+    A bounded set of probability seeds starts the fit. Each pass evaluates
+    residuals against all empirical knots once, then scans disjoint intervals
+    and refines up to eight worst intervals. min_mass is the required observed
+    cumulative mass on EACH side of a proposed new node; it stops the selector
+    from chasing individual sample jumps. No output grid participates.
+    """
+    if config.method == "all":
+        curve = interpolate_cdf(x, y, interpolation)
+        return AnchorFit(curve, np.arange(len(x)), 0.0, "all")
+    # Retain the first empirical value and the first empirical value reaching
+    # probability one, so the fit preserves the observed onset and upper tail.
+    last = min(int(np.searchsorted(y, 1.0)), len(x) - 1)
+    selected = {0, min(1, len(x) - 1), last, len(x) - 1}
+    seed_count = min(9, config.max_points - len(selected) + 1)
+    for target in np.linspace(0, 1, seed_count)[1:-1]:
+        index = min(int(np.searchsorted(y, target)), len(x) - 1)
+        ordered = sorted(selected)
+        slot = int(np.searchsorted(ordered, index))
+        if index in selected or slot == 0 or slot == len(ordered):
+            continue
+        if min(y[index] - y[ordered[slot - 1]], y[ordered[slot]] - y[index]) >= config.min_mass:
+            selected.add(index)
+    while True:
+        indices = np.array(sorted(selected), dtype=int)
+        curve = interpolate_cdf(x[indices], y[indices], interpolation)
+        residual = np.abs(curve(x) - y)
+        error = float(np.max(residual))
+        if error <= config.tolerance:
+            return AnchorFit(curve, indices, error, "tolerance")
+        if len(selected) >= config.max_points:
+            return AnchorFit(curve, indices, error, "max_points")
+        queue = []
+        for lo, hi in zip(indices[:-1], indices[1:]):
+            # Search only nodes with enough probability mass on both sides.
+            start = max(lo + 1, int(np.searchsorted(y, y[lo] + config.min_mass, side="left")))
+            end = min(hi, int(np.searchsorted(y, y[hi] - config.min_mass, side="right")))
+            if start >= end:
+                continue
+            index = start + int(np.argmax(residual[start:end]))
+            if residual[index] > config.tolerance:
+                heappush(queue, (-float(residual[index]), index))
+        if not queue:
+            return AnchorFit(curve, indices, error, "min_mass")
+        for _ in range(min(8, config.max_points - len(selected), len(queue))):
+            _, index = heappop(queue)
+            selected.add(index)

jarvisplot-2.1.6/jarvisplot/Figure/distribution_1d_runtime.py

@@ -0,0 +1,165 @@
+"""Raw weighted samples -> continuous CDF, optionally its analytic derivative.
+
+PDF1D and CDF1D share the reconstruction. No histogram or sample-grid
+renormalisation participates in fitting: the grid only evaluates the interpolant.
+"""
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+import numpy as np
+import pandas as pd
+from scipy.interpolate import PchipInterpolator
+
+from ..distribution_1d_config import KINDS, settings
+from ..memtrace import memtrace_checkpoint, memtrace_object_inventory
+from ..utils.expression import eval_dataframe_expression
+from .adaptive_cdf_runtime import fit_anchors
+
+ALGORITHM_REVISION = "weighted-ecdf-adaptive-bernstein-c2-v3"
+
+
+def _values(df: pd.DataFrame, expr: Any, logger=None) -> np.ndarray:
+    values = np.asarray(eval_dataframe_expression(df, expr, logger=logger), dtype=float)
+    if values.ndim == 0:
+        return np.full(len(df), float(values))
+    if values.shape != (len(df),):
+        raise ValueError(f"expression {expr!r} must return one value per input row, got {values.shape}")
+    return values
+
+
+def _infer_limits(x: np.ndarray, scale: str) -> tuple[float, float]:
+    unique = np.unique(x)
+    if len(unique) < 2:
+        raise ValueError("one unique sample cannot define a continuous support; set coordinates.x.lim")
+    lo = unique[0] - 0.5 * (unique[1] - unique[0])
+    hi = unique[-1] + 0.5 * (unique[-1] - unique[-2])
+    if scale == "log":
+        if unique[0] <= 0:
+            raise ValueError("coordinates.x.scale: log requires positive samples")
+        lo = max(lo, unique[0] * 0.5)
+    if not np.isfinite(lo) or not np.isfinite(hi) or not lo < hi:
+        raise ValueError("cannot infer finite support; set coordinates.x.lim")
+    return float(lo), float(hi)
+
+
+def empirical_knots(x: np.ndarray, weights: np.ndarray, limits: tuple[float, float]):
+    """Inclusive empirical nodes plus support endpoints; return largest atom too."""
+    lo, hi = limits
+    order = np.argsort(x, kind="stable")
+    x, weights = x[order], weights[order]
+    unique, first = np.unique(x, return_index=True)
+    # Rescaling before summation avoids overflow without changing probability.
+    scaled = weights / weights.max()
+    mass = np.add.reduceat(scaled, first)
+    mass /= mass.sum()
+    cumulative = np.minimum(np.cumsum(mass), 1.0)
+    cumulative[-1] = 1.0
+    interior = (unique > lo) & (unique < hi)
+    knots = np.r_[lo, unique[interior], hi]
+    probabilities = np.r_[0.0, cumulative[interior], 1.0]
+    return knots, probabilities, float(mass.max())
+
+
+def build_cdf(x: np.ndarray, weights: np.ndarray, limits: tuple[float, float]) -> PchipInterpolator:
+    """Original all-anchor PCHIP path, useful for exact empirical-node comparisons.
+
+    A sample exactly at lo cannot retain its jump with F(lo)=0; its mass is
+    carried into the first interval. Other empirical nodes retain their CDF.
+    Production reconstruction uses fit_anchors with the selected settings.
+    """
+    knots, probabilities, _ = empirical_knots(x, weights, limits)
+    return PchipInterpolator(knots, probabilities, extrapolate=False)
+
+
+def distribution_1d(df: pd.DataFrame, cfg: Mapping[str, Any], kind: str, logger=None) -> pd.DataFrame:
+    if kind not in KINDS:
+        raise ValueError(f"unknown distribution transform {kind!r}")
+    if not isinstance(df, pd.DataFrame) or df.empty:
+        raise ValueError(f"{kind} needs a nonempty pandas sample table")
+    opts = settings(cfg)
+    memtrace_checkpoint(logger, f"pipeline.{kind}.before", df)
+    x = _values(df, opts.x["expr"], logger)
+    weights = _values(df, opts.weight["expr"], logger) if opts.weight else np.ones(len(df))
+    if not np.all(np.isfinite(x)) or not np.all(np.isfinite(weights)):
+        raise ValueError(f"{kind} needs finite samples and weights; filter invalid rows first")
+    if np.any(weights < 0):
+        raise ValueError(f"{kind} needs nonnegative probability weights; signed event weights are not a CDF")
+    work = pd.DataFrame({"x": x, "weight": weights})
+    if opts.repeat is not None:
+        if opts.repeat not in df.columns:
+            raise KeyError(f"{kind} missing repeat column {opts.repeat!r}")
+        if df[opts.repeat].isna().any():
+            raise ValueError(f"{kind} repeat identifiers must not be missing")
+        work["repeat"] = df[opts.repeat].to_numpy()
+    positive = weights > 0
+    if not positive.any():
+        raise ValueError(f"{kind} weights sum to zero")
+    limits = opts.limits or _infer_limits(x[positive], opts.scale)
+    lo, hi = limits
+    if np.any((x[positive] < lo) | (x[positive] > hi)):
+        raise ValueError(f"{kind} coordinates.x.lim must contain all positive-weight samples; filter first to truncate")
+    grid = np.geomspace(lo, hi, opts.grid) if opts.scale == "log" else np.linspace(lo, hi, opts.grid)
+    memtrace_object_inventory(logger, f"pipeline.{kind}.samples", {"samples": work})
+    curves = ("cdf", "pdf") if kind == "PDF1D" else ("cdf",)
+    mean = {key: np.zeros(opts.grid) for key in curves}
+    m2 = {key: np.zeros(opts.grid) for key in curves}
+    groups = work.groupby("repeat", sort=False, observed=True) if opts.repeat else [(None, work)]
+    n = 0
+    boundary_mass = False
+    diagnostics = []
+    for label, block in groups:
+        block = block.loc[block.weight > 0]
+        if block.empty:
+            raise ValueError(f"{kind} repeat {label!r} weights sum to zero")
+        bx, bw = block.x.to_numpy(), block.weight.to_numpy()
+        boundary_mass |= bool(np.any(bx == lo))
+        knots, probabilities, largest_jump = empirical_knots(bx, bw, limits)
+        fit = fit_anchors(knots, probabilities, opts.anchors, opts.interpolation)
+        cdf = fit.curve
+        diagnostics.append({
+            "repeat": label.item() if isinstance(label, np.generic) else label,
+            "n_anchors": len(fit.indices), "n_candidates": len(knots),
+            "max_cdf_error": fit.max_error, "stop_reason": fit.stop_reason,
+            "largest_empirical_jump": largest_jump,
+        })
+        if logger is not None:
+            logger.debug(f"{kind} repeat={label!r}: anchors={len(fit.indices)}/{len(knots)}, "
+                         f"max CDF node error={fit.max_error:.6g}, stopped={fit.stop_reason}")
+            if opts.anchors.method == "adaptive" and fit.max_error > opts.anchors.tolerance:
+                logger.warning(f"{kind} repeat={label!r}: CDF error {fit.max_error:.6g} exceeds "
+                               f"tolerance {opts.anchors.tolerance:g}; stopped at {fit.stop_reason}. "
+                               "Adjust anchors settings if finer CDF reconstruction is needed.")
+            if opts.anchors.method == "adaptive" and largest_jump > max(2 * opts.anchors.tolerance, opts.anchors.min_mass):
+                logger.warning(f"{kind} repeat={label!r}: empirical probability jump {largest_jump:.6g}; "
+                               "a continuous density spreads this discrete mass over an interval")
+        values = {"cdf": cdf(grid)}
+        if kind == "PDF1D":
+            pdf = cdf.derivative()(grid)
+            tolerance = 128 * np.finfo(float).eps * max(1.0, float(np.max(np.abs(pdf))))
+            if np.min(pdf) < -tolerance:
+                raise ValueError(f"{kind} produced a negative density beyond floating-point tolerance")
+            values["pdf"] = np.maximum(pdf, 0.0)
+        n += 1
+        for key in curves:
+            if not np.all(np.isfinite(values[key])):
+                raise ValueError(f"{kind} produced nonfinite {key}; inspect sample spacing/support")
+            delta = values[key] - mean[key]
+            mean[key] += delta / n
+            m2[key] += delta * (values[key] - mean[key])
+    out = {opts.name: grid}
+    for key in curves:
+        out[key] = mean[key]
+        out[f"{key}_std"] = np.sqrt(np.maximum(m2[key], 0.0) / (n - 1)) if n > 1 else np.full(opts.grid, np.nan)
+    out["n_repeats"] = n
+    table = pd.DataFrame(out)
+    table.attrs["distribution_1d"] = {
+        "algorithm": ALGORITHM_REVISION, "interpolation": opts.interpolation,
+        "anchor_method": opts.anchors.method, "support": limits, "repeats": diagnostics,
+    }
+    if logger is not None:
+        if boundary_mass:
+            logger.warning(f"{kind}: mass at the lower support boundary is spread over the first CDF interval")
+        logger.debug(f"{kind}: {len(df)} samples -> {opts.grid} points, {n} repeats, support={limits}, std ddof=1")
+    memtrace_checkpoint(logger, f"pipeline.{kind}.after", table)
+    return table

{jarvisplot-2.1.5 → jarvisplot-2.1.6}/jarvisplot/Figure/preprocessor.py

@@ -327,12 +327,16 @@ class DataPreprocessor:
         )
 
     def _transform_input_columns(self, transform: Any) -> List[str]:
+        from ..distribution_1d_config import distribution_config, distribution_input_columns, distribution_kind
+
         out: set[str] = set()
         if not isinstance(transform, list):
             return []
         for step in transform:
             if not isinstance(step, Mapping):
                 continue
+            if distribution_kind(step) is not None:
+                out.update(distribution_input_columns(distribution_config(step)))
             if "filter" in step:
                 out.update(self._expr_symbols(step.get("filter")))
             if "sortby" in step:
@@ -357,12 +361,17 @@ class DataPreprocessor:
         return sorted(out)
 
     def _transform_output_columns(self, transform: Any) -> List[str]:
+        from ..distribution_1d_config import distribution_config, distribution_kind, distribution_output_columns
+
         out: set[str] = set()
         if not isinstance(transform, list):
             return []
         for step in transform:
             if not isinstance(step, Mapping):
                 continue
+            kind = distribution_kind(step)
+            if kind is not None:
+                out.update(distribution_output_columns(kind, distribution_config(step)))
             if "add_column" in step:
                 add_cfg = step.get("add_column", {})
                 if isinstance(add_cfg, Mapping):
@@ -937,12 +946,18 @@ class DataPreprocessor:
         return self._stable_hash(payload)
 
     def _runtime_profile_tokens(self, transform: Any) -> List[Dict[str, Any]]:
+        from ..distribution_1d_config import distribution_kind
+        from .distribution_1d_runtime import ALGORITHM_REVISION
+
         tokens: List[Dict[str, Any]] = []
         if not isinstance(transform, list):
             return tokens
         for step in transform:
             if not isinstance(step, Mapping):
                 continue
+            kind = distribution_kind(step)
+            if kind is not None:
+                tokens.append({"kind": kind, "algo": ALGORITHM_REVISION, "cfg": deepcopy(step)})
             if "profile" in step:
                 cfg = step.get("profile", {})
                 if isinstance(cfg, Mapping):

{jarvisplot-2.1.5 → jarvisplot-2.1.6}/jarvisplot/Figure/preprocessor_runtime.py

@@ -16,6 +16,8 @@ from ..memtrace import memtrace_checkpoint, memtrace_object_inventory
 from ..utils.expression import eval_dataframe_expression
 from ..utils.pathing import resolve_project_path
 from .bin_stat_runtime import bin_stat, bin_stat_config, is_bin_stat_transform
+from ..distribution_1d_config import distribution_config, distribution_kind
+from .distribution_1d_runtime import distribution_1d
 from .correlation_runtime import correlation, correlation_config, is_correlation_transform
 from .significance_runtime import (
     is_significance_transform,
@@ -74,6 +76,8 @@ HEAVY_TRANSFORM_KEYS = frozenset(
         "make_density_core",
         "posterior_density",
         "make_interp_2d",
+        "PDF1D",
+        "CDF1D",
         "type",
         # Not heavy to compute, but cross-block: what a ``to_df`` name resolves
         # to, and the fact that a producing block hands the layer nothing, only
@@ -599,6 +603,8 @@ def apply_transforms_impl(
                     preprocessor._safe_nrows(df),
                 )
             )
+        elif distribution_kind(trans) is not None:
+            df = distribution_1d(df, distribution_config(trans), distribution_kind(trans), preprocessor.logger)
         elif is_bin_stat_transform(trans):
             before_rows = preprocessor._safe_nrows(df)
             df = bin_stat(df, bin_stat_config(trans), preprocessor.logger)

{jarvisplot-2.1.5 → jarvisplot-2.1.6}/jarvisplot/column_demand.py

@@ -270,6 +270,11 @@ def _collect_expr_columns(obj: Any, out: Set[str]) -> None:
             if key == "make_interp_2d":
                 out.update(_interp_2d_cfg_input_columns(v))
                 continue
+            if key in {"pdf1d", "cdf1d"}:
+                from .distribution_1d_config import distribution_input_columns
+
+                out.update(distribution_input_columns(v))
+                continue
             if key == "bin_stat":
                 out.update(_bin_stat_cfg_columns(v, "input"))
                 continue
@@ -381,12 +386,17 @@ def _transform_needs_all_columns(transform: Any) -> bool:
 
 def _transform_output_columns(transform: Any) -> Set[str]:
     """Return column names produced as outputs by a transform list."""
+    from .distribution_1d_config import distribution_kind, distribution_output_columns
+
     out: Set[str] = set()
     if not isinstance(transform, list):
         return out
     for step in transform:
         if not isinstance(step, Mapping):
             continue
+        kind = distribution_kind(step)
+        if kind is not None:
+            out.update(distribution_output_columns(kind, step.get(kind)))
         if "bin_stat" in step:
             out.update(_bin_stat_cfg_columns(step.get("bin_stat"), "output"))
         ccfg = _correlation_transform_config(step)

{jarvisplot-2.1.5 → jarvisplot-2.1.6}/jarvisplot/data_loader.py

@@ -154,6 +154,12 @@ class DataSet():
             "columns": self.columns,
             "full_load": bool(getattr(self, "full_load", False)),
         }
+        from .distribution_1d_config import distribution_kind
+
+        if isinstance(self.transform, list) and any(distribution_kind(step) for step in self.transform):
+            from .Figure.distribution_1d_runtime import ALGORITHM_REVISION
+
+            extra["distribution_1d_algorithm"] = ALGORITHM_REVISION
         if self.type in IN_MEMORY_DATASET_TYPES:
             # Nothing on disk to fingerprint; identity is the declaration alone.
             return {"path": None, "size": None, "mtime_ns": None, "md5": None, **extra}

{jarvisplot-2.1.5 → jarvisplot-2.1.6}/jarvisplot/data_loader_runtime.py

@@ -31,6 +31,8 @@ from .utils.dataframes import polars_to_pandas
 from .utils.pathing import resolve_project_path
 from .Figure.preprocessor_runtime import add_column, drop_columns, filter_df, keep_columns, sort_by
 from .Figure.profile_runtime import profiling
+from .distribution_1d_config import distribution_config, distribution_kind
+from .Figure.distribution_1d_runtime import distribution_1d
 
 JP_ROW_IDX = "__jp_row_idx__"
 
@@ -204,6 +206,8 @@ def apply_dataset_transform(dataset, stage: str = "dataset") -> None:
             cfg = dict(posterior_density_config(trans))
             cfg.setdefault("_base_dir", getattr(dataset, "rootpath", None))
             df = posterior_density(df, cfg, dataset.logger)
+        elif distribution_kind(trans) is not None:
+            df = distribution_1d(df, distribution_config(trans), distribution_kind(trans), dataset.logger)
         elif is_interp_2d_transform(trans):
             df = make_interp_2d(df, interp_2d_config(trans), dataset.logger)
         elif "sortby" in trans:
@@ -411,7 +415,8 @@ def _apply_dataset_transform_polars(
             elif "drop_columns" in trans:
                 lf = drop_columns(lf, trans.get("drop_columns"), dataset.logger)
             elif (
-                "profile" in trans
+                distribution_kind(trans) is not None
+                or "profile" in trans
                 or "make_density_core" in trans
                 or "posterior_density" in trans
                 or "make_interp_2d" in trans