plot3 0.6.8__tar.gz → 0.7.0__tar.gz

{plot3-0.6.8 → plot3-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plot3
-Version: 0.6.8
+Version: 0.7.0
 Summary: ggplot2 grammar of graphics for Python: interactive WebGL figures and journal-ready PNG, SVG, and PDF
 Author: Rigoberto Leyva Salmeron
 License-Expression: MIT

plot3-0.7.0/plot3/__version__.py

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

{plot3-0.6.8 → plot3-0.7.0}/plot3/build.py

@@ -10,6 +10,7 @@ import pandas as pd
 import copy
 import os
 
+from plot3.kde import EXACT_WORK, gaussian_1d
 from plot3.encode import encode_codes, encode_norm, pack_u16, pack_u32, pack_u8
 from plot3.mathtext import split_math
 from plot3.geoms import (
@@ -100,6 +101,11 @@ def _kde_1d(
     if hi <= lo:
         hi = lo + 1.0
     grid = np.linspace(lo, hi, n)
+    if x.size * n > EXACT_WORK:
+        # Large inputs: linear binning and an FFT, as R's density() does.
+        sums = gaussian_1d(x, lo, hi, n, bw)
+        if sums is not None:
+            return grid, sums / x.size
     # (n_grid, n_obs)
     u = (grid[:, None] - x[None, :]) / bw
     dens = np.exp(-0.5 * u * u).sum(axis=1) / (
@@ -1522,6 +1528,26 @@ def _rug_series(rug, g):
     return out
 
 
+def _remap_codes(codes, remap: dict, default) -> np.ndarray:
+    """``remap.get(int(c), default)`` for every code, as one table lookup."""
+    c = np.asarray(codes)
+    if c.dtype.kind not in "biuf" or (c.dtype.kind == "f" and not np.isfinite(c).all()):
+        # Same per-value rule, errors included (int() of NaN raises).
+        return np.array([remap.get(int(x), default) for x in c.ravel()]).reshape(c.shape)
+    ints = c.astype(np.int64)
+    out = np.full(ints.shape, default)
+    if remap and ints.size:
+        keys = np.fromiter(remap.keys(), dtype=np.int64, count=len(remap))
+        values = np.array(list(remap.values()))
+        order = np.argsort(keys)
+        keys, values = keys[order], values[order]
+        at = np.clip(np.searchsorted(keys, ints), 0, len(keys) - 1)
+        hit = keys[at] == ints
+        out = out.astype(np.result_type(out, values))
+        out[hit] = values[at[hit]]
+    return out
+
+
 def _rug_positions(scale, series) -> np.ndarray:
     """Values in the scale's own units; NaN where they have no place."""
     kind, pos, cats = col_values(series)
@@ -1531,6 +1557,13 @@ def _rug_positions(scale, series) -> np.ndarray:
             lookup = np.array([index.get(c, np.nan) for c in cats] + [np.nan], dtype=np.float64)
             codes = np.where(np.isfinite(pos), pos, len(cats)).astype(np.int64)
             return lookup[codes]
+        values = np.asarray(series)
+        # float32 prints differently as a NumPy scalar than as a float.
+        if values.dtype.kind in "biu" or values.dtype == np.float64:
+            # One text lookup per distinct value (NaN included), not per row.
+            codes, uniques = pd.factorize(values, use_na_sentinel=False)
+            lookup = np.array([index.get(str(u), np.nan) for u in uniques.tolist()], dtype=np.float64)
+            return lookup[codes] if len(codes) else np.array([], dtype=np.float64)
         return np.array([index.get(str(v), np.nan) for v in series], dtype=np.float64)
     if kind == "cat":
         return np.full(len(pos), np.nan)
@@ -2211,10 +2244,8 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
             }
             out = np.full(np.size(v), np.nan, dtype=np.float64)
             flat = np.asarray(v, dtype=np.float64).ravel()
-            for i, c in enumerate(flat):
-                if not math.isfinite(c):
-                    continue
-                out[i] = remap.get(int(c), -1)
+            finite = np.isfinite(flat)
+            out[finite] = _remap_codes(flat[finite], remap, -1)
             v = out.reshape(np.shape(v))
             sc.cats = merged
         else:
@@ -3089,9 +3120,7 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
                             i: color_scale[1].index(c)
                             for i, c in enumerate(local)
                         }
-                        codes = np.array(
-                            [remap.get(int(c), 0) for c in cv], dtype="<u2"
-                        )
+                        codes = _remap_codes(cv, remap, 0).astype("<u2")
                         payloads.append((pid, pack_u16(codes, g.compress)))
                         spec_l["ocolor"] = {
                             "id": pid, "dtype": "u16", "kind": "cat"
@@ -3121,8 +3150,7 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
                 # remap onto the global cat list
                 local = vals["color"][2]
                 remap = {i: color_scale[1].index(c) for i, c in enumerate(local)}
-                codes = np.array([remap.get(int(c), 0) for c in cv[order]],
-                                 dtype="<u2")
+                codes = _remap_codes(cv[order], remap, 0).astype("<u2")
                 payloads.append((pid, pack_u16(codes, g.compress)))
                 spec_l["color"] = {"id": pid, "dtype": "u16", "kind": "cat"}
             else:
@@ -3140,9 +3168,7 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
             if ckind == "cat":
                 local = vals["color"][2]
                 remap = {i: color_scale[1].index(c) for i, c in enumerate(local)}
-                codes = np.array(
-                    [remap.get(int(c), 0) for c in cv[order]], dtype="<u2"
-                )
+                codes = _remap_codes(cv[order], remap, 0).astype("<u2")
                 payloads.append((pid, pack_u16(codes, g.compress)))
                 spec_l["color"] = {"id": pid, "dtype": "u16", "kind": "cat"}
             else:
@@ -3322,10 +3348,7 @@ def build_spec(g: ggplot) -> tuple[dict, list[tuple[str, str]]]:
                     flat = np.full(raw.shape, 65535, dtype=np.uint16)
                     ok = np.isfinite(raw) & (raw >= 0)
                     if ok.any():
-                        mapped = np.array(
-                            [remap.get(int(c), 0) for c in raw[ok]],
-                            dtype=np.uint16,
-                        )
+                        mapped = _remap_codes(raw[ok], remap, 0).astype(np.uint16)
                         flat[np.flatnonzero(ok)] = mapped
                     enc = encode_codes(flat, g.compress)
                     pid = f"p{li}fc"

{plot3-0.6.8 → plot3-0.7.0}/plot3/encode.py

@@ -7,6 +7,10 @@ import gzip as _gzip
 
 import numpy as np
 
+# gzip is lossless at every level. Level 1 builds large payloads several
+# times faster than 6 for a few percent more bytes.
+_LEVEL = 1
+
 def delta_u16(a: np.ndarray) -> np.ndarray:
     """Column-wise delta mod 2^16 (lossless; tiny values on ordered data)."""
     d = a.astype(np.int32)
@@ -21,7 +25,7 @@ def pack_u16(q: np.ndarray, compress: bool) -> str:
         raw = _gzip.compress(
             np.ascontiguousarray(d[:, 0]).tobytes()
             + np.ascontiguousarray(d[:, 1]).tobytes(),
-            6,
+            compresslevel=_LEVEL, mtime=0,
         )
     else:
         raw = np.ascontiguousarray(q, dtype="<u2").tobytes()
@@ -31,7 +35,7 @@ def pack_u16(q: np.ndarray, compress: bool) -> str:
 def pack_f32(v: np.ndarray, compress: bool) -> str:
     raw = np.ascontiguousarray(v, dtype="<f4").tobytes()
     if compress:
-        raw = _gzip.compress(raw, 6)
+        raw = _gzip.compress(raw, _LEVEL, mtime=0)
     return base64.b64encode(raw).decode("ascii")
 
 
@@ -55,7 +59,7 @@ def pack_u8(values: np.ndarray, compress: bool) -> str:
     """uint8 array -> base64 (optional gzip; no delta)."""
     raw = np.ascontiguousarray(values, dtype=np.uint8).tobytes()
     if compress:
-        raw = _gzip.compress(raw, 6)
+        raw = _gzip.compress(raw, _LEVEL, mtime=0)
     return base64.b64encode(raw).decode("ascii")
 
 
@@ -63,6 +67,6 @@ def pack_u32(values: np.ndarray, compress: bool) -> str:
     """uint32 array -> base64 (optional gzip; no delta)."""
     raw = np.ascontiguousarray(values, dtype="<u4").tobytes()
     if compress:
-        raw = _gzip.compress(raw, 6)
+        raw = _gzip.compress(raw, _LEVEL, mtime=0)
     return base64.b64encode(raw).decode("ascii")
 

plot3-0.7.0/plot3/kde.py

@@ -0,0 +1,124 @@
+"""Binned Gaussian kernel density sums (linear binning + FFT convolution).
+
+R's ``density()`` bins too. Values are spread onto a fine grid (at least
+four points per output interval, at most 1/20 of a bandwidth apart in
+1D and 1/4 in 2D),
+convolved with the kernel by FFT, and read back at the output points. The
+relative error is far below what a plot shows. Values more than
+``_REACH`` bandwidths past the output range add nothing in float64 and are
+left out. The callers keep the exact sum for small inputs, and these
+helpers return None when the fine grid would be too large.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+# Below this many (observations x output points) the exact sum is cheap.
+EXACT_WORK = 2_000_000
+# The fine spacing is at most this fraction of the bandwidth (1D, 2D), and
+# the fine grid has at least four points per output interval. Linear
+# binning's error grows with the square of that fraction.
+_MAX_STEP_1D = 0.05
+_MAX_STEP_2D = 0.25
+_MIN_FINE = 4
+# Past this many bandwidths a kernel underflows to zero in float64.
+_REACH = 40.0
+# Largest fine grid (points, or cells in 2D) worth binning onto.
+_MAX_CELLS = 1 << 22
+
+
+def _fine_axis(values: np.ndarray, lo: float, hi: float, n: int, h: float, max_step: float):
+    """``(origin, step, size, first, fine)`` of a fine grid through the output points.
+
+    The output point ``k`` sits at fine index ``first + k * fine``. The grid
+    covers every value within ``_REACH`` bandwidths of the output range;
+    values farther out add nothing to the sums.
+    """
+    if n < 2 or not hi > lo or not h > 0 or not values.size:
+        return None
+    fine = max(_MIN_FINE, int(np.ceil((hi - lo) / ((n - 1) * max_step * h))))
+    step = (hi - lo) / ((n - 1) * fine)
+    low = max(float(values.min()), lo - _REACH * h)
+    high = min(float(values.max()), hi + _REACH * h)
+    below = max(0, int(np.ceil((lo - low) / step)))
+    above = max(0, int(np.ceil((high - hi) / step)))
+    size = (n - 1) * fine + 1 + below + above
+    if size > _MAX_CELLS:
+        return None
+    return lo - below * step, step, size, below, fine
+
+
+def _within(values: np.ndarray, origin: float, step: float, size: int) -> np.ndarray:
+    return (values >= origin) & (values <= origin + (size - 1) * step)
+
+
+def _linear_bins(values: np.ndarray, origin: float, step: float, size: int):
+    """Indices and weights of the two fine points around each value."""
+    pos = (values - origin) / step
+    left = np.clip(np.floor(pos).astype(np.int64), 0, size - 2)
+    frac = np.clip(pos - left, 0.0, 1.0)
+    return left, frac
+
+
+def _kernel_fft(step: float, size: int, h: float, length: int) -> np.ndarray:
+    offsets = np.arange(-(size - 1), size) * step
+    kernel = np.exp(-0.5 * (offsets / h) ** 2) / (h * np.sqrt(2.0 * np.pi))
+    return np.fft.rfft(kernel, length)
+
+
+def _fft_length(size: int) -> int:
+    return 1 << int(np.ceil(np.log2(3 * size - 2)))
+
+
+def _convolve(weights: np.ndarray, step: float, size: int, h: float, axis: int) -> np.ndarray:
+    """``sum_i w[i] K((j - i) step)`` for every fine index ``j`` along *axis*."""
+    length = _fft_length(size)
+    spectrum = np.fft.rfft(weights, length, axis=axis)
+    shape = [1] * weights.ndim
+    shape[axis] = -1
+    full = np.fft.irfft(spectrum * _kernel_fft(step, size, h, length).reshape(shape), length, axis=axis)
+    return np.take(full, np.arange(size - 1, 2 * size - 1), axis=axis)
+
+
+def gaussian_1d(x: np.ndarray, lo: float, hi: float, n: int, h: float) -> np.ndarray | None:
+    """``sum_i phi((g - x_i) / h) / h`` at ``linspace(lo, hi, n)``, or None."""
+    axis = _fine_axis(x, lo, hi, n, h, _MAX_STEP_1D)
+    if axis is None:
+        return None
+    origin, step, size, first, fine = axis
+    x = x[_within(x, origin, step, size)]
+    left, frac = _linear_bins(x, origin, step, size)
+    weights = np.bincount(left, 1.0 - frac, size) + np.bincount(left + 1, frac, size)
+    sums = _convolve(weights, step, size, h, axis=0)
+    return np.maximum(sums[first:first + (n - 1) * fine + 1:fine], 0.0)
+
+
+def gaussian_2d(
+    xs: np.ndarray, ys: np.ndarray, x_lims: tuple[float, float], y_lims: tuple[float, float],
+    n: int, hx: float, hy: float,
+) -> np.ndarray | None:
+    """``sum_i phi_x(gx - x_i) phi_y(gy - y_i)`` as an ``(n, n)`` (y, x) grid, or None."""
+    ax = _fine_axis(xs, x_lims[0], x_lims[1], n, hx, _MAX_STEP_2D)
+    ay = _fine_axis(ys, y_lims[0], y_lims[1], n, hy, _MAX_STEP_2D)
+    if ax is None or ay is None:
+        return None
+    (x_origin, x_step, x_size, x_first, x_fine), (y_origin, y_step, y_size, y_first, y_fine) = ax, ay
+    # Two FFT passes over the fine grid must beat n exponentials per value
+    # on each axis; a grid stretched over wide limits does not.
+    if x_size * y_size > _MAX_CELLS or x_size * y_size * 16 > xs.size * n:
+        return None
+    keep = _within(xs, x_origin, x_step, x_size) & _within(ys, y_origin, y_step, y_size)
+    xs, ys = xs[keep], ys[keep]
+    xl, xf = _linear_bins(xs, x_origin, x_step, x_size)
+    yl, yf = _linear_bins(ys, y_origin, y_step, y_size)
+    cells = y_size * x_size
+    weights = np.zeros(cells)
+    for dy, wy in ((0, 1.0 - yf), (1, yf)):
+        for dx, wx in ((0, 1.0 - xf), (1, xf)):
+            weights += np.bincount((yl + dy) * x_size + xl + dx, wy * wx, cells)
+    weights = weights.reshape(y_size, x_size)
+    sums = _convolve(_convolve(weights, x_step, x_size, hx, axis=1), y_step, y_size, hy, axis=0)
+    rows = slice(y_first, y_first + (n - 1) * y_fine + 1, y_fine)
+    cols = slice(x_first, x_first + (n - 1) * x_fine + 1, x_fine)
+    return np.maximum(sums[rows, cols], 0.0)

{plot3-0.6.8 → plot3-0.7.0}/plot3/scales.py

@@ -288,9 +288,19 @@ def ordered_levels(values, *, keep_order: bool = False) -> list:
     "10" before "4"); anything else sorts as text.
     """
     values = list(values)
-    present = [v for v in values if not _is_na(v)]
-    missing = len(present) != len(values)
-    distinct = list(dict.fromkeys(present))
+    try:
+        # Drop repeats first, then test the distinct values for missing:
+        # one isna() call per level instead of one per row.
+        keys = list(dict.fromkeys(values))
+    except TypeError:  # an NA whose comparison has no truth value
+        keys = None
+    if keys is None:
+        present = [v for v in values if not _is_na(v)]
+        missing = len(present) != len(values)
+        distinct = list(dict.fromkeys(present))
+    else:
+        distinct = [v for v in keys if not _is_na(v)]
+        missing = len(distinct) != len(keys)
     if not keep_order:
         if all(isinstance(v, (bool, np.bool_)) for v in distinct):
             distinct.sort(key=bool)

{plot3-0.6.8 → plot3-0.7.0}/plot3/stat2d.py

@@ -19,6 +19,7 @@ import numpy as np
 import pandas as pd
 
 from plot3.geoms import _Geom, aes
+from plot3.kde import EXACT_WORK, gaussian_2d
 from plot3.scales import col_values, ordered_levels, resolution
 from plot3.special import qt
 from plot3.table import has_column, materialize_columns
@@ -1334,6 +1335,11 @@ def _kde2d(xs, ys, n, lims=None, h=None):
     y0, y1 = (ys.min(), ys.max()) if lims is None else lims[2:]
     gx, gy = np.linspace(x0, x1, n), np.linspace(y0, y1, n)
     hx, hy = (_bandwidth(xs), _bandwidth(ys)) if h is None else (float(h[0]) / 4, float(h[1]) / 4)
+    if xs.size * n > EXACT_WORK:
+        # Large inputs: bilinear binning and FFT convolution.
+        sums = gaussian_2d(xs, ys, (float(x0), float(x1)), (float(y0), float(y1)), n, hx, hy)
+        if sums is not None:
+            return gx, gy, sums / xs.size
     kx = np.exp(-0.5 * ((gx[:, None] - xs[None, :]) / hx) ** 2) / (hx * math.sqrt(2 * math.pi))
     ky = np.exp(-0.5 * ((gy[:, None] - ys[None, :]) / hy) ** 2) / (hy * math.sqrt(2 * math.pi))
     z = (ky @ kx.T) / xs.size  # (ny, nx), the shape the contour code takes

{plot3-0.6.8 → plot3-0.7.0}/plot3.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plot3
-Version: 0.6.8
+Version: 0.7.0
 Summary: ggplot2 grammar of graphics for Python: interactive WebGL figures and journal-ready PNG, SVG, and PDF
 Author: Rigoberto Leyva Salmeron
 License-Expression: MIT

{plot3-0.6.8 → plot3-0.7.0}/plot3.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ plot3/geoms.py
 plot3/ggplot.py
 plot3/io.py
 plot3/jupyter.py
+plot3/kde.py
 plot3/latexin.py
 plot3/masking.py
 plot3/mathtext.py
@@ -48,6 +49,7 @@ tests/test_contour.py
 tests/test_everyday_ggplot2.py
 tests/test_expr.py
 tests/test_facets_compose.py
+tests/test_fast_paths.py
 tests/test_geom_function.py
 tests/test_geoms_ds.py
 tests/test_ggplot2_extras2.py

plot3-0.7.0/tests/test_fast_paths.py

@@ -0,0 +1,106 @@
+"""Vectorised level, code and density paths match the per-value rules."""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+import pandas as pd
+import pytest
+
+import plot3.build as build
+import plot3.stat2d as stat2d
+from plot3.build import _kde_1d, _remap_codes, _rug_positions
+from plot3.scales import Scale, _is_na, ordered_levels
+from plot3.stat2d import _kde2d
+
+
+def _levels_per_value(values, keep_order=False):
+    """ordered_levels as it was: test every row for missing, then dedupe."""
+    values = list(values)
+    present = [v for v in values if not _is_na(v)]
+    distinct = list(dict.fromkeys(present))
+    out = ordered_levels(distinct, keep_order=keep_order)
+    return out + ([None] if len(present) != len(values) else [])
+
+
+@pytest.mark.parametrize("values", [
+    ["Adelie", "Gentoo", None, "Adelie", "Chinstrap", float("nan"), "Gentoo"] * 500,
+    [4.0, 6.0, np.nan, 8.0, 10.0, 6.0] * 500,
+    [True, False, None, True] * 500,
+    [3, 1.0, 1, 2, np.int64(3)] * 500,
+    ["Biscoe", pd.NA, "Dream", pd.NA, pd.NaT, "Biscoe"] * 500,
+    [float("nan")] * 50 + ["Torgersen"],
+    [],
+])
+@pytest.mark.parametrize("keep_order", [False, True])
+def test_ordered_levels_matches_the_per_row_rule(values, keep_order):
+    assert ordered_levels(values, keep_order=keep_order) == _levels_per_value(values, keep_order)
+
+
+def test_remap_codes_matches_the_dict_rule():
+    rng = np.random.default_rng(0)
+    remap = {0: 2, 1: 0, 3: 1}
+    for codes in (rng.integers(-1, 5, 1000).astype(float), rng.integers(0, 4, 1000), np.array([], dtype=float)):
+        expected = np.array([remap.get(int(c), 7) for c in codes])
+        assert np.array_equal(_remap_codes(codes, remap, 7), expected)
+    assert np.array_equal(_remap_codes(np.array([1.9, -0.5]), remap, 7), [0, 2])
+    assert np.array_equal(_remap_codes(np.array([2.0]), {}, 0), [0])
+    with pytest.raises(ValueError):
+        _remap_codes(np.array([0.0, np.nan]), remap, 0)
+
+
+@pytest.mark.parametrize("series", [
+    pd.Series([4.0, 6.0, np.nan, 8.0, 4.0]),
+    pd.Series([4, 6, 8, 6]),
+    pd.Series([True, False, True]),
+    pd.Series(np.array([4.0, 6.5], dtype=np.float32)),
+])
+def test_rug_positions_on_a_discrete_scale_match_text_lookup(series):
+    scale = Scale("cat")
+    scale.cats = ["4", "6", "8", "True", "4.0", "6.0", "6.5", "nan"]
+    index = {c: i for i, c in enumerate(scale.cats)}
+    expected = np.array([index.get(str(v), np.nan) for v in series], dtype=np.float64)
+    np.testing.assert_array_equal(_rug_positions(scale, series), expected)
+
+
+def _exact(module, fn, *args, **kwargs):
+    saved = module.EXACT_WORK
+    module.EXACT_WORK = math.inf
+    try:
+        return fn(*args, **kwargs)
+    finally:
+        module.EXACT_WORK = saved
+
+
+@pytest.mark.parametrize("values, adjust", [
+    (np.random.default_rng(1).normal(4200, 800, 20_000), 1.0),
+    (np.random.default_rng(2).lognormal(0, 1.5, 20_000), 1.0),
+    (np.random.default_rng(3).normal(17, 2, 20_000), 0.2),
+    (np.r_[np.random.default_rng(4).normal(0, 1, 20_000), [1e6]], 1.0),
+    (np.random.default_rng(5).integers(2007, 2010, 20_000).astype(float), 1.0),
+])
+def test_binned_density_matches_the_exact_sum(values, adjust):
+    grid, dens = _kde_1d(values, adjust=adjust)
+    exact_grid, exact = _exact(build, _kde_1d, values, adjust=adjust)
+    np.testing.assert_array_equal(grid, exact_grid)
+    assert np.max(np.abs(dens - exact)) <= 2e-4 * exact.max()
+
+
+def test_small_densities_keep_the_exact_sum():
+    values = np.random.default_rng(6).normal(44, 5, 300)
+    np.testing.assert_array_equal(_kde_1d(values)[1], _exact(build, _kde_1d, values)[1])
+    xs, ys = np.random.default_rng(7).normal(0, 1, (2, 300))
+    np.testing.assert_array_equal(_kde2d(xs, ys, 50)[2], _exact(stat2d, _kde2d, xs, ys, 50)[2])
+
+
+@pytest.mark.parametrize("lims, h", [(None, None), (None, (2.0, 1.0)), ((-1, 1, -0.5, 0.5), None)])
+def test_binned_2d_density_matches_the_exact_sum(lims, h):
+    rng = np.random.default_rng(8)
+    xs, ys = rng.normal(44, 5, 60_000), rng.exponential(2, 60_000)
+    gx, gy, z = _kde2d(xs, ys, 100, lims, h)
+    ex, ey, exact = _exact(stat2d, _kde2d, xs, ys, 100, lims, h)
+    np.testing.assert_array_equal(gx, ex)
+    np.testing.assert_array_equal(gy, ey)
+    # A quarter-bandwidth grid: the error stays under 0.2% of the peak.
+    assert np.max(np.abs(z - exact)) <= 2e-3 * exact.max()

plot3-0.6.8/plot3/__version__.py

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