plot-io 0.12.0__py3-none-win_arm64.whl

plot_io/_native/kernels.py

@@ -0,0 +1,335 @@
+"""ctypes wrappers of the library's functions (stats.c, plot.c, colormap.c).
+Inputs are ``array('d')``; :mod:`plot_io.kernels` holds the functions the rest of plot_io
+calls."""
+
+import array
+import ctypes
+
+from vec_io import threads as _threads
+
+from . import _api, check, ctx, lib, ptr, take
+
+#: Function names of :func:`scaled` and :func:`extent` -> their codes (plio_api.h).
+FUNCTIONS = {None if k == "none" else k: v for k, v in _api.CODES["FN"].items()}
+#: Codes of colormap.c (plio_api.h).
+COLORMAP_MODES = _api.CODES["CMAP"]
+COLORMAP_SPACES = _api.CODES["SPACE"]
+
+
+def _zeros(n):
+    return array.array("d", bytes(8 * n))
+
+
+def _points(x, y, w=None):
+    return _api.Points(n=min(len(x), len(y)), x=ptr(x), y=ptr(y), w=ptr(w))
+
+
+def function_code(function):
+    try:
+        return FUNCTIONS[function]
+    except (KeyError, TypeError):
+        names = ", ".join(repr(k) for k in FUNCTIONS)
+        raise ValueError(f"unknown function {function!r} (use {names})") from None
+
+
+def scaled(values, scale, offset, function, low, high, under, over, nan, linthresh=1.0,
+           below=None, above=None):
+    n = len(values)
+    out = _zeros(n)
+    s = _api.Scale(function=function_code(function), has_nan=int(nan is not None),
+                   has_below=int(below is not None), has_above=int(above is not None),
+                   scale=scale, offset=offset, linthresh=linthresh, low=low, high=high,
+                   under=under, over=over, nan_value=0.0 if nan is None else nan,
+                   below=0.0 if below is None else below, above=0.0 if above is None else above)
+    check(lib().plio_scaled(ctx(), s, ptr(values), n, ptr(out)), "scaled")
+    return out
+
+
+def extent(values, function):
+    out = array.array("d", [0.0, 0.0])
+    count = lib().plio_extent(ctx(), ptr(values), len(values), function_code(function), ptr(out))
+    check(count, "extent")
+    return count, out[0], out[1]
+
+
+def quantiles(values, qs):
+    qs = array.array("d", qs)
+    out = _zeros(len(qs))
+    check(lib().plio_quantiles(ctx(), ptr(values), len(values), ptr(qs), len(qs), ptr(out)),
+          "quantiles")
+    return list(out)
+
+
+def box_stats(values, mode, a, b):
+    """``(count, [mean, q1, median, q3, low, high], outliers array('d'))``; ``mode`` a
+    ``_api.WHISKERS_*`` code."""
+    out = _zeros(6)
+    outliers_ptr = ctypes.c_void_p()
+    k = ctypes.c_int64()
+    rc = lib().plio_box_stats(ctx(), _api.Whiskers(mode=mode, a=a, b=b), ptr(values),
+                              len(values), ptr(out), ctypes.byref(outliers_ptr),
+                              ctypes.addressof(k))
+    check(rc, "box_stats")
+    outliers = array.array("d")
+    if k.value:
+        outliers.frombytes(take(outliers_ptr.value, 8 * k.value))
+    return rc, list(out), outliers
+
+
+def argsort(values, descending):
+    n = len(values)
+    out = array.array("q", bytes(8 * n))
+    check(lib().plio_argsort(ctx(), ptr(values), n, int(descending), ptr(out)), "argsort")
+    return out
+
+
+def take_rows(values, k, indices, base=None, n=None):
+    """Rows ``indices`` (``array('q')``) of ``values`` (``array('d')``, rows of ``k``), or of
+    ``n`` rows at address ``base`` when given. Large gathers are split over the worker
+    threads."""
+    m = len(indices)
+    out = array.array("d", [0.0]) * (m * k) if m * k else array.array("d")
+    if not m:
+        return out
+    if base is None:
+        base, n = ptr(values), len(values) // k
+    f = lib().plio_take
+    ip, op = ptr(indices), ptr(out)
+    step = max(65536, -(-m // (4 * _threads.count()))) if m * k >= 1 << 20 else m
+
+    def run(i0):
+        j = min(i0 + step, m) - i0
+        return check(f(ctx(), base, n, k, ip + 8 * i0, j, op + 8 * k * i0), "take", IndexError)
+
+    _threads.map_ordered(run, range(0, m, step))
+    return out
+
+
+def group_summary(values, rows, cols, groups, ngroups, threshold):
+    """``(sums, counts, counts above, sums above)`` of the finite values, each
+    ``array('d')`` of ``ngroups`` x ``cols``, of the ``rows`` x ``cols`` matrix ``values``;
+    ``groups`` (``array('q')``) holds each row's group, or -1 to leave it out."""
+    cells = ngroups * cols
+    out = _zeros(4 * cells)
+    s = _api.Summary(rows=rows, cols=cols, groups=ngroups, threshold=threshold,
+                     group=ptr(groups))
+    check(lib().plio_group_summary(ctx(), s, ptr(values), ptr(out)), "group_summary")
+    return out[:cells], out[cells:2 * cells], out[2 * cells:3 * cells], out[3 * cells:]
+
+
+def colors_at(values, table, steps, under, over, bad):
+    """RGBA (``array('d')``, 4 per value) of a color lookup: ``table`` holds 4 doubles per
+    entry, evenly sampled, or one per step starting at ``steps``; see stats.c."""
+    n = len(values)
+    out = _zeros(4 * n)
+    lut = _api.Lookup(m=len(table) // 4, table=ptr(table), steps=ptr(steps),
+                      flags=sum(bit for bit, c in zip((1, 2, 4), (under, over, bad))
+                                if c is not None))
+    for name, c in (("under", under), ("over", over), ("bad", bad)):
+        if c is not None:
+            getattr(lut, name)[:] = [float(v) for v in c[:4]]
+    check(lib().plio_colors_at(ctx(), lut, ptr(values), n, ptr(out)), "colors_at")
+    return out
+
+
+def cells(values, lo, hi, levels, split):
+    """``(out, bad count)``: color table indices (``levels`` > 0) or positions (``levels`` 0) of
+    ``values`` over [lo, hi], as ``array('d')``; see stats.c."""
+    n = len(values)
+    out = _zeros(n)
+    m = _api.CellMap(lo=lo, hi=hi, levels=levels, split=int(split))
+    bad = check(lib().plio_cells(ctx(), m, ptr(values), n, ptr(out)), "cells")
+    return out, bad
+
+
+def colormap_eval(stops, mode, space, ts):
+    """RGBA (``array('d')``, 4 per value) at positions ``ts`` (``array('d')``) of the map
+    with ``stops`` ``(position, rgba)``; see colormap.c."""
+    pos = array.array("d", [p for p, _ in stops])
+    rgba = array.array("d", [v for _, c in stops for v in c])
+    n = len(ts)
+    out = _zeros(4 * n)
+    s = _api.Stops(m=len(stops), mode=COLORMAP_MODES[mode], space=COLORMAP_SPACES[space],
+                   pos=ptr(pos), rgba=ptr(rgba))
+    check(lib().plio_colormap_eval(ctx(), s, ptr(ts), n, ptr(out)), "colormap_eval")
+    return out
+
+
+# --------------------------------------------------------------------------
+# plot.c
+
+
+def histogram(values, edges, weights):
+    out = _zeros(max(len(edges) - 1, 0))
+    check(lib().plio_histogram(ctx(), ptr(values), len(values), ptr(weights), ptr(edges),
+                               len(edges), ptr(out)),
+          "histogram")
+    return out
+
+
+def histogram2d(x, y, weights, x_edges, y_edges):
+    out = _zeros(max(len(x_edges) - 1, 0) * max(len(y_edges) - 1, 0))
+    check(lib().plio_histogram2d(ctx(), _api.Points(n=len(x), x=ptr(x), y=ptr(y), w=ptr(weights)),
+                                 ptr(x_edges), len(x_edges), ptr(y_edges), len(y_edges), ptr(out)),
+          "histogram2d")
+    return out
+
+
+def hexbin(x, y, weights, x0, y0, dx, dy, nx, ny):
+    out = _zeros(2 * nx * ny)
+    g = _api.Hexgrid(nx=nx, ny=ny, x0=x0, y0=y0, dx=dx, dy=dy)
+    check(lib().plio_hexbin(ctx(), _api.Points(n=len(x), x=ptr(x), y=ptr(y), w=ptr(weights)), g,
+                            ptr(out)), "hexbin")
+    return out
+
+
+def moments(values, weights):
+    """``(count, sum w, sum w^2, mean, sum w d^2, sum w d^3)``."""
+    out = _zeros(5)
+    rc = check(lib().plio_moments(ctx(), ptr(values), ptr(weights), len(values), ptr(out)),
+               "moments")
+    return (rc, *out)
+
+
+def moments2(x, y, weights):
+    """``(count, sum w, sum w^2, mean x, mean y, sum w dx^2, sum w dy^2, sum w dx dy)``."""
+    out = _zeros(7)
+    rc = check(lib().plio_moments2(ctx(), _points(x, y, weights), ptr(out)), "moments2")
+    return (rc, *out)
+
+
+def ecdf(values, weights):
+    n = len(values)
+    xs, cs = _zeros(n), _zeros(n)
+    m = check(lib().plio_ecdf(ctx(), ptr(values), ptr(weights), n, ptr(xs), ptr(cs)), "ecdf")
+    return xs[:m], cs[:m]
+
+
+def kde(values, weights, lo, hi, n, bandwidth, cumulative):
+    out = _zeros(n)
+    g = _api.KdeGrid(m=n, cumulative=int(cumulative), lo=lo, hi=hi, bw=bandwidth)
+    check(lib().plio_kde(ctx(), g, ptr(values), ptr(weights), len(values), ptr(out)), "kde")
+    return out
+
+
+def _take_doubles(p, n):
+    out = array.array("d")
+    if n:
+        out.frombytes(take(p, 8 * n))
+    elif p:
+        take(p, 0)
+    return out
+
+
+def _take_int64(p, n):
+    out = array.array("q")
+    if n:
+        out.frombytes(take(p, 8 * n))
+    return out
+
+
+def _grid(grid, w, h, xs, ys):
+    return _api.Grid(w=w, h=h, g=ptr(grid), xs=ptr(xs), ys=ptr(ys))
+
+
+def contour_lines(grid, w, h, xs, ys, level):
+    xy, starts, closed = ctypes.c_void_p(), ctypes.c_void_p(), ctypes.c_void_p()
+    k = lib().plio_contour_lines(ctx(), _grid(grid, w, h, xs, ys), level, ctypes.byref(xy),
+                                 ctypes.byref(starts), ctypes.byref(closed))
+    check(k, "contour_lines")
+    st = _take_int64(starts.value, k + 1) if k else array.array("q")
+    flags = take(closed.value, k) if k else b""
+    pts = _take_doubles(xy.value, 2 * st[-1] if k else 0)
+    if not k and starts.value:
+        take(starts.value, 0)
+    return pts, st, flags
+
+
+def contour_bands(grid, w, h, xs, ys, lo, hi):
+    xy, starts = ctypes.c_void_p(), ctypes.c_void_p()
+    k = lib().plio_contour_bands(ctx(), _grid(grid, w, h, xs, ys), lo, hi, ctypes.byref(xy),
+                                 ctypes.byref(starts))
+    check(k, "contour_bands")
+    st = _take_int64(starts.value, k + 1)
+    pts = _take_doubles(xy.value, 2 * st[-1] if len(st) else 0)
+    return pts, st
+
+
+def lowess(x, y, frac, iterations, delta):
+    out = _zeros(len(x))
+    args = _api.LowessArgs(frac=frac, iterations=iterations, delta=delta)
+    check(lib().plio_lowess(ctx(), args, ptr(x), ptr(y), len(x), ptr(out)),
+          "lowess")
+    return out
+
+
+def swarm(positions, sizes, uniform, slot_width):
+    out = _zeros(len(positions))
+    rc = check(lib().plio_swarm(ctx(), ptr(positions), ptr(sizes), 0 if uniform else 1,
+                                len(positions), slot_width, ptr(out)),
+               "swarm")
+    return out, rc
+
+
+def kde2d(x, y, weights, h, tx, ty, grid=None):
+    """Density at the targets ``(tx, ty)``: exact sums, or through a lattice of at least
+    ``grid`` points per side (see plot.c), with the blur and the sampling split over the
+    worker threads. Results do not depend on the split."""
+    f = lib()
+    m = min(len(tx), len(ty))
+    pts = _points(x, y, weights)
+    kern = _api.Kernel2d(h11=h[0], h12=h[1], h22=h[2])
+    what = "kde2d"
+    if grid is None:
+        out = _zeros(m)
+        check(f.plio_kde2d_exact(ctx(), pts, kern, ptr(tx), ptr(ty), m, ptr(out)), what)
+        return out
+    params = _zeros(12)
+    ns = check(f.plio_kde2d_setup(ctx(), pts, kern, grid, ptr(params)), what)
+    if not ns:
+        nan = float("nan")
+        return array.array("d", (0.0 if tx[i] - tx[i] == 0 and ty[i] - ty[i] == 0 else nan
+                                 for i in range(m)))
+    gu, gv, L = int(params[3]), int(params[4]), int(params[9])
+    delta, var = params[2], params[10]
+    lat, tmp = _zeros(gu * gv), _zeros(gu * gv)
+    check(f.plio_kde2d_bin(ctx(), pts, ptr(params), ptr(lat)), what)
+
+    def blur(src, dst, rows, cols):
+        b = _api.Blur(rows=rows, cols=cols, L=L, delta=delta, var=var)
+        step = max(8, -(-rows // (4 * _threads.count())))
+        _threads.map_ordered(
+            lambda r0: check(f.plio_kde2d_blur(ctx(), b, ptr(src), ptr(dst), r0,
+                                               min(r0 + step, rows)), what),
+            range(0, rows, step))
+
+    blur(lat, tmp, gv, gu)                      # along v
+    check(f.plio_transpose(ctx(), ptr(tmp), ptr(lat), gv, gu), what)
+    blur(lat, tmp, gu, gv)                      # along u: tmp holds gu rows of gv
+    out = _zeros(m)
+    base = out.buffer_info()[0]
+    step = 65536
+
+    def sample(i0):
+        k = min(i0 + step, m) - i0
+        check(f.plio_kde2d_sample(ctx(), ptr(params), ptr(tmp), ptr(tx) + 8 * i0,
+                                  ptr(ty) + 8 * i0, k, base + 8 * i0), what)
+
+    if m:
+        _threads.map_ordered(sample, range(0, m, step))
+    return out
+
+
+#: Codes of cluster.c (plio_api.h).
+LINKAGE_METHODS = _api.CODES["LINKAGE"]
+LINKAGE_METRICS = _api.CODES["METRIC"]
+
+
+def linkage(data, n, d, method, metric):
+    """The ``(n - 1) x 4`` merges (``array('d')``) of ``n`` rows of ``d`` values, or of a
+    condensed distance vector (``metric`` "precomputed"); see cluster.c."""
+    z = ctypes.c_void_p()
+    args = _api.LinkageArgs(n=n, d=d, method=LINKAGE_METHODS[method],
+                            metric=LINKAGE_METRICS[metric], data=ptr(data))
+    k = check(lib().plio_linkage(ctx(), args, ctypes.byref(z)), "linkage")
+    return _take_doubles(z.value, 4 * k)

plot_io/_native/manifest.json

@@ -0,0 +1,49 @@
+{
+  "abi": 5,
+  "cflags": [
+    "-ffreestanding",
+    "-nostdlib",
+    "-fno-builtin",
+    "-fno-stack-protector",
+    "-O2",
+    "-fPIC",
+    "-fvisibility=hidden",
+    "-g0",
+    "-std=c11",
+    "-Wall",
+    "-Wextra",
+    "-Werror",
+    "-Wframe-larger-than=4096",
+    "-ffp-contract=off",
+    "-fno-math-errno"
+  ],
+  "files": {
+    "linux-aarch64.so": {
+      "sha256": "55f6c8121722cf5fe95505cbbfaf3129bc99ee99dbed3a1917eadbaa84f4e72f",
+      "size": 72944,
+      "target": "aarch64-linux-musl"
+    },
+    "linux-x86_64.so": {
+      "sha256": "ad9da1225399d1a7bc4f05af9f346665967647c66c073176a3fb2514a4d7a65e",
+      "size": 88816,
+      "target": "x86_64-linux-musl"
+    },
+    "macos-arm64.dylib": {
+      "sha256": "cb1b3f7a43ea640fe1a22b53af14adcc8809816777a66bb2a6768d486126c18a",
+      "size": 117936,
+      "target": "aarch64-macos"
+    },
+    "windows-arm64.dll": {
+      "sha256": "6eff70aefdbcb0e289bfc10402aa20785640deef0ec8486131991776a54acbcc",
+      "size": 69632,
+      "target": "aarch64-windows-gnu"
+    },
+    "windows-x86_64.dll": {
+      "sha256": "4fc839a73a103cd0c78abb073b5fd19c083933434e9ecb48a084ce3033ade76c",
+      "size": 91136,
+      "target": "x86_64-windows-gnu"
+    }
+  },
+  "source_sha256": "1bd1a5c31bba3b2db0bbee55030e22e237544d79733df6cabd4c7fce0d26a7d3",
+  "zig": "0.15.1"
+}