qmlmathplot 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

qmlmathplot/__init__.py

@@ -51,7 +51,7 @@ Demos: ``examples/minimal.py``, ``examples/explorer_qtwidgets.py``,
 from typing import TYPE_CHECKING
 
 from .camera import HOME_SIZE, HOME_VIEW, Camera, nice_ticks
-from .curve import Curve, CurveListModel
+from .curve import Curve, CurveListModel, ImplicitCurve
 from .plot import Plot
 from .view import QML_MAJOR, QML_MINOR, QML_URI, qml_component_path, register_qml_types
 
@@ -64,6 +64,7 @@ __all__ = [
     "CurveListModel",
     "HOME_SIZE",
     "HOME_VIEW",
+    "ImplicitCurve",
     "MathPlotWidget",
     "nice_ticks",
     "Plot",

qmlmathplot/__main__.py

@@ -0,0 +1,13 @@
+"""``python -m qmlmathplot`` — the same entry point as the installed ``qmlmathplot`` script.
+
+Keeping it here means the command works even when the console script is not on ``PATH`` (a
+``pip install --user``, a virtualenv used through ``python -m``, or a checkout run with
+``uv run``).
+"""
+
+import sys
+
+from .app import main
+
+if __name__ == "__main__":
+    sys.exit(main())

qmlmathplot/app.py

@@ -1,7 +1,10 @@
-"""MVP entry point: wraps the component into a minimal verifiable window (called by `main.py` /
-`uv run qmlmathplot`).
+"""MVP entry point: wraps the component into a minimal verifiable window.
 
-    python main.py --backend d3d11 "sin(1/x)"
+Reachable as the installed ``qmlmathplot`` console script, as ``python -m qmlmathplot``, and as
+``examples/minimal.py``:
+
+    python -m qmlmathplot --backend d3d11 "sin(1/x)"
+    uv run qmlmathplot "tan(x)"
 
 The RHI backend comes from the launch argument; without it, Qt's default backend is used. When
 specified it must be written to ``QSG_RHI_BACKEND`` *before* ``QGuiApplication`` — Qt reads it

qmlmathplot/curve.py

@@ -1,8 +1,12 @@
 """Curve layer: one expression -> GLSL -> .qsb plus its style, and the list model QML repeats.
 
-A curve knows nothing about the view: the camera decides where we look, the curve decides
-what is drawn. One curve = one fragment shader pass (see ``model.FRAGMENT_TEMPLATE``), so
-``visible`` is the lever that costs nothing.
+A curve knows nothing about the view: the camera decides where we look, the curve decides what is
+drawn. One curve = one fragment shader pass, so ``visible`` is the lever that costs nothing.
+
+Two artists share the class: ``Curve`` draws ``y = f(x)`` (see ``model.FRAGMENT_TEMPLATE``) and
+``ImplicitCurve`` draws the level set ``F(x, y) = 0`` (``model.IMPLICIT_FRAGMENT_TEMPLATE``).
+They differ only in the shader *sources* — the uniform block, the model roles and the QML side
+are the same — so ``curve_for()`` can pick one from the expression's free symbols.
 """
 
 from __future__ import annotations
@@ -20,10 +24,10 @@ from PySide6.QtCore import (
 )
 from PySide6.QtGui import QColor
 
-from .model import shader_sources
+from .model import implicit_shader_sources, shader_sources
 from .qsb import bake
 
-__all__ = ["Curve", "CurveListModel"]
+__all__ = ["Curve", "CurveListModel", "ImplicitCurve", "curve_for", "parsed"]
 
 #: First colour of the default cycle (matplotlib's "tab10" blue, as in its default style).
 DEFAULT_COLOR = "#1f77b4"
@@ -33,12 +37,63 @@ DEFAULT_COLOR_CYCLE = ("#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd",
 
 
 def _color(value: object) -> QColor:
-    """A QColor from a QColor or anything QColor() understands ("#rrggbb", a name, …)."""
+    """A QColor from a QColor, anything QColor() understands ("#rrggbb", a name, …), or None
+    for the default curve colour."""
+    if value is None:
+        return QColor(DEFAULT_COLOR)
     return QColor(value) if not isinstance(value, QColor) else QColor(value)
 
 
+def parsed(value: str | sp.Expr) -> tuple[str, sp.Expr]:
+    """The canonical string and the parsed expression of a curve input.
+
+    A string is parsed here, once; a sympy expression is used as it is (no ``Expr -> str ->
+    Expr`` round trip). The canonical string is what identifies the expression.
+    """
+    if isinstance(value, sp.Basic):
+        return str(value), value
+    return str(value), sp.sympify(value, locals={"x": sp.Symbol("x"), "y": sp.Symbol("y")})
+
+
+def curve_for(
+    expression: str | sp.Expr,
+    *,
+    implicit: bool | None = None,
+    color: object = None,
+    line_width: object = None,
+    label: str = "",
+    parent: QObject | None = None,
+) -> Curve:
+    """Create the artist an expression needs.
+
+    Auto-routed by the free symbols: ``x`` (or none) is a 1-D curve ``y = f(x)``, ``x`` and ``y``
+    is an implicit curve (the level set ``F(x, y) = 0``), and anything else raises — a parameter
+    must be substituted before it is plotted, and silently evaluating it as a pixel coordinate is
+    exactly the trap this avoids. ``implicit=True`` picks the level-set artist regardless of the
+    symbols (``add_implicit``).
+    """
+    text, expr = parsed(expression)
+    names = {symbol.name for symbol in expr.free_symbols}
+    if names - {"x", "y"}:
+        raise ValueError(
+            f"{sorted(names - {'x', 'y'})} must be substituted first: only x (or x and y) may "
+            f"be free, got {text!r}"
+        )
+    cls: type[Curve] = ImplicitCurve if (implicit or "y" in names) else Curve
+    return cls(expr, color=color, line_width=line_width, label=label, parent=parent)
+
+
 class Curve(QObject):
-    """One curve: an expression, its baked shaders, its style and its error text."""
+    """One curve: an expression, its baked shaders, its style and its error text.
+
+    The fragment shader follows the expression: ``y = f(x)`` while only ``x`` (or nothing) is
+    free, the level set ``F(x, y) = 0`` as soon as ``y`` appears — so ``add_curve`` and assigning
+    to ``expression`` both route themselves, and a text field can turn a function into a level
+    set. ``ImplicitCurve`` forces the level-set template regardless of the symbols.
+    """
+
+    #: Forced to the level-set template (see ``ImplicitCurve``).
+    _force_implicit = False
 
     expressionChanged = Signal()
     styleChanged = Signal()
@@ -49,7 +104,7 @@ class Curve(QObject):
 
     def __init__(
         self,
-        expression: str = "sin(x)",
+        expression: str | sp.Expr = "sin(x)",
         color: str | QColor = DEFAULT_COLOR,
         line_width: float = 1.5,
         label: str = "",
@@ -57,7 +112,8 @@ class Curve(QObject):
     ) -> None:
         super().__init__(parent)
         self._symbol = sp.Symbol("x")
-        self._expression = str(expression)
+        self._expression = ""
+        self._expr: sp.Expr = sp.Integer(0)      # replaced by the first assignment below
         self._color = _color(color)
         self._line_width = float(line_width)
         self._label = str(label)
@@ -65,23 +121,62 @@ class Curve(QObject):
         self._error = ""
         self._vertex = QUrl()
         self._fragment = QUrl()
-        self._compile(self._expression)
+        self._set_expression(expression)
 
     # ---------------------------------------------------------------- Expression
     def _get_expression(self) -> str:
         return self._expression
 
-    def _set_expression(self, source: str) -> None:
-        source = str(source)
-        if source == self._expression:
+    def _set_expression(self, source: str | sp.Expr) -> None:
+        """Set the expression from a string (parsed here, once) or from a sympy expression.
+
+        The canonical **string** is what identifies the expression — ``sp.sin(x)`` and
+        ``"sin(x)"`` are the same, and re-setting either is free — while the parsed
+        ``sp.Expr`` is cached for the bake and for the matplotlib hand-off, so neither ever
+        stringifies and re-parses again.
+        """
+        if isinstance(source, str):
+            canonical = source
+        else:
+            canonical = str(source)
+        if canonical == self._expression:
             return
-        self._expression = source
+        if isinstance(source, sp.Basic):          # already an expression: use it as it is
+            expr: sp.Expr = source
+        else:
+            try:
+                expr = sp.sympify(source, locals={"x": self._symbol, "y": sp.Symbol("y")})
+            except Exception as exc:
+                # Keep the last parsed expression: the shaders stay, `expression` is what was
+                # typed and `error` says why.
+                self._expression = str(canonical)
+                self._error = f"{type(exc).__name__}: {exc}"
+                self.expressionChanged.emit()
+                self.errorChanged.emit()
+                return
+        previous = self._expr
+        self._expression = str(canonical)
+        self._expr = expr
         self.expressionChanged.emit()
-        self._compile(source)
+        if not self._compile(expr):
+            # `expression` stays what was set (the text field shows it), `expr` stays what is
+            # drawn — the same rule as the unparsable string above.
+            self._expr = previous
 
     # Annotate the value type (PySide6 idiom): Property is a descriptor, so without the
     # annotation a type checker only sees the Property object and flags every read and write.
-    expression: str = Property(str, _get_expression, _set_expression, notify=expressionChanged)
+    # Declared "QVariant" so an ``sp.Expr`` reaches the setter unconverted; the getter is always
+    # the canonical string (QML, a project file and the text field all want one).
+    expression: str | sp.Expr = Property("QVariant", _get_expression, _set_expression,
+                                         notify=expressionChanged)
+
+    def _get_expr(self) -> sp.Expr:
+        return self._expr
+
+    #: The parsed expression being drawn (read-only): the object form the setter accepts, and
+    #: the one the bake and the matplotlib hand-off use. It follows the last expression that
+    #: compiled, so `expression` can show a failing edit while `expr` keeps the drawn curve.
+    expr: sp.Expr = Property("QVariant", _get_expr, notify=expressionChanged)
 
     # ------------------------------------------------------------------ Style
     def _get_color(self) -> QColor:
@@ -147,23 +242,57 @@ class Curve(QObject):
 
     error: str = Property(str, _get_error, notify=errorChanged)
 
-    def _compile(self, source: str) -> None:
-        """expression -> GLSL -> .qsb; on failure keep the last working shaders and write the
-        reason into ``error``."""
+    @property
+    def implicit(self) -> bool:
+        """Whether this curve is currently drawn as a level set ``F(x, y) = 0``.
+
+        Read-only, and it follows the expression: assigning ``"x**2 + y**2 - 1"`` switches this
+        curve's shader to the implicit one. The matplotlib hand-off uses it to skip level sets,
+        which cannot be sampled into a polyline.
+        """
+        return self._force_implicit or "y" in {symbol.name for symbol in self._expr.free_symbols}
+
+    def _sources(self, expr: sp.Expr) -> tuple[str, str]:
+        """The shader sources for this expression; anything unrenderable raises ``ValueError``
+        (which ``_compile`` turns into ``error``, keeping the last working shaders)."""
+        names = {symbol.name for symbol in expr.free_symbols}
+        if names - {"x", "y"}:
+            raise ValueError(
+                f"only x (or x and y) may be free, got {sorted(names)}: substitute parameters "
+                "first"
+            )
+        return implicit_shader_sources(expr) if (self._force_implicit or "y" in names) \
+            else shader_sources(expr)
+
+    def _compile(self, expr: sp.Expr) -> bool:
+        """expr -> GLSL -> .qsb; on failure keep the last working shaders, write the reason into
+        ``error`` and return False. The expression is parsed by the setter, never here."""
         try:
-            expr = sp.sympify(source, locals={"x": self._symbol})
-            vert_src, frag_src = shader_sources(expr)
+            vert_src, frag_src = self._sources(expr)
             vertex = bake(vert_src, "vert")
             fragment = bake(frag_src, "frag")
         except Exception as exc:  # noqa: BLE001 — expression or bake can fail; both reach the UI
             self._error = f"{type(exc).__name__}: {exc}"
             self.errorChanged.emit()
-            return
+            return False
         self._error = ""
         self._vertex = QUrl.fromLocalFile(str(vertex))
         self._fragment = QUrl.fromLocalFile(str(fragment))
         self.errorChanged.emit()
         self.shadersChanged.emit()
+        return True
+
+
+class ImplicitCurve(Curve):
+    """A curve drawn from the level set ``F(x, y) = 0``, whatever the free symbols.
+
+    No sampling and no envelope band: one evaluation of ``F`` and its two partials per pixel give
+    the distance to the level set (``docs/api-design.md`` §6b). Thin features and several
+    branches through one pixel are not handled yet, and a domain/pole curve is not special-cased
+    either — pixels where ``F`` is undefined come out NaN and are dropped.
+    """
+
+    _force_implicit = True
 
 
 class CurveListModel(QAbstractListModel):
@@ -245,21 +374,16 @@ class CurveListModel(QAbstractListModel):
         curve.visibleChanged.connect(lambda c=curve: self._notify(c, (self.VisibleRole,)))
 
     # ---------------------------------------------------------------- public
-    @Slot(str, "QVariant", "QVariant", str, result=QObject)
-    @Slot(str, result=QObject)
-    def add_curve(
-        self,
-        expression: str,
-        color: object = None,
-        line_width: object = None,
-        label: str = "",
-    ) -> Curve:
-        """Append a curve. Colour and line width default to the plot's cycle and width."""
+    # "QVariant" so a sympy expression is not stringified on the way in (see Plot.add_curve).
+    @Slot("QVariant", "QVariant", "QVariant", str, result=QObject)
+    @Slot("QVariant", result=QObject)
+    def _defaults(self, color: object, line_width: object) -> tuple[QColor, float]:
         if color is None:
             color = self._cycle[len(self._curves) % len(self._cycle)]
-        if line_width is None:
-            line_width = self._default_line_width
-        curve = Curve(expression, color, float(line_width), label, parent=self)  # type: ignore[arg-type]
+        return _color(color), (self._default_line_width if line_width is None
+                               else float(line_width))  # type: ignore[arg-type]
+
+    def _append(self, curve: Curve) -> Curve:
         row = len(self._curves)
         self.beginInsertRows(QModelIndex(), row, row)
         self._curves.append(curve)
@@ -267,6 +391,37 @@ class CurveListModel(QAbstractListModel):
         self._watch(curve)
         return curve
 
+    @Slot("QVariant", "QVariant", "QVariant", str, result=QObject)
+    @Slot("QVariant", result=QObject)
+    def add_curve(
+        self,
+        expression: str | sp.Expr,
+        color: object = None,
+        line_width: object = None,
+        label: str = "",
+    ) -> Curve:
+        """Append the artist the expression needs: ``y = f(x)``, or the level set
+        ``F(x, y) = 0`` when both symbols are free (see ``curve_for``). Colour and line width
+        default to the plot's cycle and width."""
+        default_color, default_width = self._defaults(color, line_width)
+        return self._append(curve_for(expression, color=default_color, line_width=default_width,
+                                      label=label, parent=self))
+
+    @Slot("QVariant", "QVariant", "QVariant", str, result=QObject)
+    @Slot("QVariant", result=QObject)
+    def add_implicit(
+        self,
+        expression: str | sp.Expr,
+        color: object = None,
+        line_width: object = None,
+        label: str = "",
+    ) -> Curve:
+        """Append an implicit curve (the level set ``F(x, y) = 0``) explicitly, whatever the free
+        symbols: ``x`` alone is a valid level set (vertical lines)."""
+        default_color, default_width = self._defaults(color, line_width)
+        return self._append(curve_for(expression, implicit=True, color=default_color,
+                                      line_width=default_width, label=label, parent=self))
+
     @Slot(QObject)
     def remove_curve(self, curve: Curve) -> None:
         row = self.index_of(curve)

qmlmathplot/export.py

@@ -70,9 +70,11 @@ def render(
 ) -> QImage:
     """Render ``plot`` offscreen and return the grabbed image, in device pixels.
 
-    ``xlim`` / ``ylim`` default to the camera (the live centre and scale, extended to the export
-    size), ``width`` / ``height`` default to the live view's device size (``dpi`` multiplies
-    both), and ``adjustable`` reconciles the two parameter sets.
+    ``xlim`` / ``ylim`` default to the camera's own view (its centre and scales applied to the
+    size it was told it has — that is exactly ``camera.xlim`` / ``ylim``), ``width`` /
+    ``height`` default to the live view's device size (``dpi`` multiplies both), and
+    ``adjustable`` reconciles the two parameter sets. The pixel size changes the resolution,
+    never the region: the region cannot depend on the screen's ``devicePixelRatio``.
     """
     dpi = float(dpi)
     if not dpi > 0:
@@ -122,11 +124,19 @@ def render(
         widget.resize(round(logical[0]), round(logical[1]))
         widget.show()                       # offscreen: WA_DontShowOnScreen, never exposed
 
-        # The range: the camera, extended to the export size, unless the caller asked for one
+        # The range: the camera's own view — its centre and scales applied to the size it was
+        # told it has, which is exactly ``camera.xlim``/``ylim`` — unless the caller asked for
+        # one. Not ``logical`` (the export's size): the scale is world units per logical pixel
+        # *of the live view*, so deriving the range from the offscreen widget's logical size
+        # made the region depend on the screen's devicePixelRatio and silently cropped it by
+        # that factor (at DPR 1.5 a ±2.5 view came out as ±1.67 at 400×400 device pixels, and a
+        # level set whose visible arc sat at |x| > 1.67 was not drawn at all). ``width``,
+        # ``height`` and ``dpi`` change the number of pixels, never the region; a caller that
+        # wants a different region passes ``xlim``/``ylim``.
         range_x = _pair(xlim, "xlim") if xlim is not None else (
-            live[0] - 0.5 * logical[0] * live[2], live[0] + 0.5 * logical[0] * live[2])
+            live[0] - 0.5 * live_size[0] * live[2], live[0] + 0.5 * live_size[0] * live[2])
         range_y = _pair(ylim, "ylim") if ylim is not None else (
-            live[1] - 0.5 * logical[1] * live[3], live[1] + 0.5 * logical[1] * live[3])
+            live[1] - 0.5 * live_size[1] * live[3], live[1] + 0.5 * live_size[1] * live[3])
         span_x, span_y = range_x[1] - range_x[0], range_y[1] - range_y[0]
         centre = (0.5 * (range_x[0] + range_x[1]), 0.5 * (range_y[0] + range_y[1]))
 

qmlmathplot/model.py

@@ -21,9 +21,11 @@ from sympy.printing.precedence import PRECEDENCE
 
 __all__ = [
     "FRAGMENT_TEMPLATE",
+    "IMPLICIT_FRAGMENT_TEMPLATE",
     "VERTEX_SHADER",
     "dfunc_glsl",
     "func_glsl",
+    "implicit_shader_sources",
     "shader_sources",
 ]
 
@@ -152,6 +154,7 @@ def unbounded_edges(expr: sp.Expr, name: str = "x") -> list[tuple[float, bool, b
     either).
     """
     sym = sp.Symbol(name)
+    poles = _pole_factors(expr)
     out: list[tuple[float, bool, bool]] = []
     for cond in _domain_conditions(expr):
         lhs = cond.lhs if isinstance(cond, (sp.Gt, sp.Ge, sp.Ne)) else None
@@ -169,6 +172,14 @@ def unbounded_edges(expr: sp.Expr, name: str = "x") -> list[tuple[float, bool, b
         for point in points:
             if not point.is_number:
                 continue
+            # A boundary that is also a *pole* (a sign-changing denominator vanishes there)
+            # needs no ray: its samples already exceed any viewport, and a ray would draw the
+            # very connector the pole rules remove. This is the difference the module docstring
+            # always claimed ("1/x and tan diverge fast") — it held for tan only because its
+            # boundary is non-polynomial, while `1/x`'s x=0 boundary is polynomial and got a
+            # ray, which drew a pale line across the viewport (measured at x = ±0.014).
+            if any(sp.simplify(f.subs(sym, point)) == 0 for f in poles):
+                continue
             down = up = False
             for side in ("+", "-"):
                 try:
@@ -312,6 +323,28 @@ vec2 _edge_du(float ex) {
     return vec2(0.0, 0.0);
 }
 
+// Distance (logical px) from a pixel to the boundary ray: the polyline's infinite extension
+// along a slowly diverging domain boundary (log(x) as x→0+), which a fixed-width sampling
+// window can never reach. nl/nh are the column's extremes — its own valid samples, or the
+// probe taken just inside the domain when the column has none (see main). The ray is drawn
+// only when those samples have *not* already reached that viewport edge: if the polyline
+// already leaves the viewport it covers the visible part on its own, and extending it would
+// be a connector.
+float _ray_dist(vec2 p, float ex, vec2 du, float nl, float nh,
+                float y_top, float y_bot, float sx, float sy) {
+    float d = 1e30;
+    if (ex >= 1e29 || nl >= 1e29) {
+        return d;
+    }
+    if (du.x != 0.0 && nl > y_bot) {
+        d = min(d, _seg_dist(p, vec2(ex * sx, nl * sy), vec2(ex * sx, -1e12)));
+    }
+    if (du.y != 0.0 && nh > -1e29 && nh < y_top) {
+        d = min(d, _seg_dist(p, vec2(ex * sx, nh * sy), vec2(ex * sx, 1e12)));
+    }
+    return d;
+}
+
 #define F(u) (@FUNC@)
 #define DF @DFUNC@
 // Domain predicate (pixels outside the domain are not drawn) and "pole denominators"
@@ -328,17 +361,56 @@ void main() {
     float x = camera.x + (vUV.x - 0.5) * size.x * camera.z;
     float y = camera.y + (0.5 - vUV.y) * size.y * camera.w;
 
-    // Domain: pixels outside are not drawn (x<0 for log(x), x<0 for sqrt(x), |x|>1 for
-    // asin, …)
-    if (!DOM(x)) {
-        fragColor = vec4(0.0);
-        return;
-    }
-
+    // Domain: pixels outside are not drawn (x<0 for log(x), x<0 for sqrt(x), |x|>1 for asin, …)
+    // — with one exception, the unbounded-boundary ray. The stroke is a *band* centred on the
+    // boundary, and for a slowly diverging edge (log(x) as x→0+) that band hugs x = 0, so the
+    // half of it lying outside the domain must still be painted. Discarding those pixels
+    // outright left the descent with its right half only (measured: 1.5 of the nominal 3.0
+    // device px, and the missing side was exactly the x < 0 half).
     float spany = size.y * camera.w;   // visible y span (world units)
     float dx = camera.z;               // world x per pixel
     float sx = 1.0 / camera.z;         // pixels per world x
     float sy = 1.0 / camera.w;         // pixels per world y
+    float y_top = camera.y + 0.5 * spany;
+    float y_bot = camera.y - 0.5 * spany;
+    // The boundary query is the sampled interval **widened by the stroke radius**
+    // (lineWidth/2 + 0.5): the coverage ramp reaches that far, so a narrower window clips the
+    // ray's own stroke (measured: the ray was evaluated only by the ±1-column band of pixels
+    // and the descent's neighbours got distance to an endpoint — 1.00 device px instead of
+    // 3.00). The constants are the sample offsets of the loop below (-1 + 0.25/4, -1 + 7.25/4).
+    float edge_r = (lineWidth * 0.5 + 0.5) * dx;   // stroke radius, world units
+    float ex_ = _edge_hit(x - 0.9375 * dx - edge_r, x + 0.8125 * dx + edge_r);
+    vec2 du_ = (ex_ < 1e29) ? _edge_du(ex_) : vec2(0.0, 0.0);
+    // A column with no valid sample (a pixel just outside the domain) still lies inside the
+    // stroke's band around the boundary, so the band must be evaluated there too — but its
+    // extent has to come from the function itself, probed just inside the domain, since every
+    // sample of such a column is out of domain. Judging it by the sentinel alone drew a
+    // full-height line at `log(x-1)`'s boundary in a shallow view (where the visible curve is
+    // nowhere near the boundary), while ignoring those pixels altogether cost the descent its
+    // whole outer half (1.00-1.67 of the nominal 3.00 device px) in a deep one.
+    float edge_nl = 1e30;
+    float edge_nh = -1e30;
+    if (ex_ < 1e29) {
+        float probe_r = F(ex_ + 0.25 * dx);
+        float probe_l = F(ex_ - 0.25 * dx);
+        if (probe_r == probe_r && abs(probe_r) < 1e30) {
+            edge_nl = min(edge_nl, probe_r);
+            edge_nh = max(edge_nh, probe_r);
+        }
+        if (probe_l == probe_l && abs(probe_l) < 1e30) {
+            edge_nl = min(edge_nl, probe_l);
+            edge_nh = max(edge_nh, probe_l);
+        }
+    }
+
+    if (!DOM(x)) {
+        float cov = clamp(lineWidth * 0.5 + 0.5
+                          - _ray_dist(vec2(x * sx, y * sy), ex_, du_, edge_nl, edge_nh,
+                                      y_top, y_bot, sx, sy),
+                          0.0, 1.0);
+        fragColor = vec4(color.rgb * cov * color.a * qt_Opacity, cov * color.a * qt_Opacity);
+        return;
+    }
 
     float f0 = F(x);
     float d1 = DF;
@@ -404,24 +476,38 @@ void main() {
                 bool have = false;
                 float ps = 0.0;
                 float pd = 0.0;
+                float px = 0.0;
                 for (int k = 0; k < 16; k++) {
+                    float xk;
                     float s;
                     bool ok;
                     if (k - (k / 2) * 2 == 0) {         // even slot: reuse a narrow-window sample
+                        xk = smp_x[k / 2];
                         s = smp[k / 2];
                         ok = smp_ok[k / 2];
                     } else {                             // odd slot: sample additionally
-                        float xi = x + (-1.0 + (float(k) + 0.5) / 8.0) * h;
-                        s = F(xi);
-                        ok = DOMS(xi) && (s == s) && (abs(s) < 1e30);
+                        xk = x + (-1.0 + (float(k) + 0.5) / 8.0) * h;
+                        s = F(xk);
+                        ok = DOMS(xk) && (s == s) && (abs(s) < 1e30);
                     }
                     if (ok) {
                         if (have) {
-                            float d = s - ps;
-                            if (pd * d < 0.0) { turns16 += 1.0; }
-                            pd = d;
+                            // A pair that straddles a pole is a jump, not a turn — and it must
+                            // not seed the next comparison either: its huge difference has the
+                            // opposite sign to the following pair's, which then reads as a
+                            // second, fake turn. Measured at tan(x)'s pole: turns16 = 2 and
+                            // w = 1 (the band filled the column solid, the connector); with the
+                            // jump excluded turns16 = 0 and the column draws nothing.
+                            if (POLE(px) * POLE(xk) <= 0.0) {
+                                pd = 0.0;
+                            } else {
+                                float d = s - ps;
+                                if (pd * d < 0.0) { turns16 += 1.0; }
+                                pd = d;
+                            }
                         }
                         ps = s;
+                        px = xk;
                         have = true;
                     }
                 }
@@ -456,7 +542,14 @@ void main() {
             bool prev_oki = false;
             for (int i = 0; i < 8; i++) {
                 if (smp_ok[i]) {
-                    if (prev_oki) {
+                    // A segment that crosses a pole is not part of the curve: the two
+                    // branches diverge to ±∞ there, and joining them draws the vertical
+                    // connector. Decided by the denominator's sign change (world units, so
+                    // it does not drift with zoom) rather than by the "gap" test below,
+                    // which needs the sampled values to exceed the viewport by 32× — the
+                    // pole column of a shallow view only reaches ~15×, and tan(x) then drew
+                    // its connector (measured: a full-height column at x=±π/2).
+                    if (prev_oki && POLE(prev_xi) * POLE(smp_x[i]) > 0.0) {
                         dmin = min(dmin, _seg_dist(p, vec2(prev_xi * sx, prev_si * sy),
                                                       vec2(smp_x[i] * sx, smp[i] * sy)));
                     }
@@ -465,21 +558,12 @@ void main() {
                 }
                 prev_oki = smp_ok[i];
             }
-            // Infinite extension at unbounded boundaries: when the window crosses a domain
-            // boundary where the function tends to ±∞, pull a vertical ray from the nearest
-            // valid sample along the boundary to ±1e12, so a slowly diverging branch
-            // (log(x) as x→0+) is drawn to any depth. The ray lies on the boundary x, so the
-            // width stays constant and the columns align.
-            float ex_ = _edge_hit(x - h, x + h);
-            if (ex_ < 1e29 && nl < 1e29) {
-                vec2 du_ = _edge_du(ex_);
-                if (du_.x != 0.0) {
-                    dmin = min(dmin, _seg_dist(p, vec2(ex_ * sx, nl * sy), vec2(ex_ * sx, -1e12)));
-                }
-                if (du_.y != 0.0) {
-                    dmin = min(dmin, _seg_dist(p, vec2(ex_ * sx, nh * sy), vec2(ex_ * sx, 1e12)));
-                }
-            }
+            // Infinite extension along a slowly diverging boundary (log(x) as x→0+): the ray
+            // lies on the boundary x, so the width stays constant and the columns align. See
+            // _ray_dist for when it is drawn. A column whose own samples are all out of domain
+            // borrows the probe taken above, so the band keeps its width there too.
+            dmin = min(dmin, _ray_dist(p, ex_, du_, nl < 1e29 ? nl : edge_nl,
+                                       nh > -1e29 ? nh : edge_nh, y_top, y_bot, sx, sy));
             cov = clamp(lineWidth * 0.5 + 0.5 - dmin, 0.0, 1.0);
         }
         if (w > 0.0) {
@@ -514,6 +598,78 @@ void main() {
 """
 
 
+# Implicit curves: the level set F(x, y) = 0, stroked by the same first-order idea as the 1-D
+# stroke, one dimension up. One evaluation of F and its two partials give the distance to the
+# level set in pixels:
+#
+#     d = |F| / |grad F in pixels|,  cov = clamp(lineWidth/2 + 0.5 - d, 0, 1)
+#
+# No sampling loop and no envelope band: this is the single-sheet, smooth case (thin features and
+# several branches of F through one pixel, e.g. sin(1/(x*x + y*y)), are a separate problem —
+# docs/api-design.md §6b). Out-of-domain pixels (log(x), sqrt, …) come out NaN and are dropped,
+# so there is no DOM/POLE machinery here either.
+IMPLICIT_FRAGMENT_TEMPLATE = """#version 440
+layout(location = 0) in vec2 vUV;
+layout(location = 0) out vec4 fragColor;
+layout(std140, binding = 0) uniform buf {
+    mat4 qt_Matrix;
+    float qt_Opacity;
+    vec4 camera;      // centre.x, centre.y, world units per logical pixel (x, y)
+    vec2 size;        // viewport size (logical pixels)
+    float lineWidth;  // line width (logical pixels)
+    vec4 color;       // non-premultiplied rgba
+};
+
+// Argument reduction: the GPU's built-in sin/cos are unreliable for large arguments;
+// fold into [0,2π) before calling
+#define TAU 6.283185307179586
+float _wrap(float t) { return t - TAU * floor(t * (1.0 / TAU)); }
+#define SIN(t) sin(_wrap(t))
+#define COS(t) cos(_wrap(t))
+
+// F is a macro with two parameters (text substitution; the call always passes the plain pixel
+// coordinates, so no extra parentheses are needed on the arguments — see the note in the 1-D
+// template). FX/FY are *object-like* macros, i.e. the definition is spliced into a product
+// (`gx = FX * camera.z`), so the definition itself must be parenthesized: a partial that is not
+// a single term, e.g. d/dx (x-1)^2 = 2*x - 2, otherwise expands to `2*x - 2 * camera.z` and the
+// gradient (hence the coverage) comes out wrong.
+#define F(x, y) (@FUNC@)
+#define FX (@DFUNCX@)
+#define FY (@DFUNCY@)
+
+void main() {
+    float x = camera.x + (vUV.x - 0.5) * size.x * camera.z;
+    float y = camera.y + (0.5 - vUV.y) * size.y * camera.w;
+
+    float f = F(x, y);
+    // |grad F| in pixels: the partial derivative per world unit times the world units per pixel
+    float gx = FX * camera.z;
+    float gy = FY * camera.w;
+    // Distance from this pixel to the level set, in pixels. The floor keeps a critical point of
+    // F (grad F = 0, e.g. the apex of a degenerate level set) from dividing by zero.
+    float d = abs(f) / max(sqrt(gx * gx + gy * gy), 1e-9);
+
+    float cov = clamp(lineWidth * 0.5 + 0.5 - d, 0.0, 1.0);
+    float a = cov * color.a * qt_Opacity;
+    if (isnan(f) || isinf(f)) {
+        a = 0.0;                       // pixels where F itself is undefined
+    }
+    fragColor = vec4(color.rgb * a, a);   // premultiplied alpha
+}
+"""
+
+
+def implicit_shader_sources(expr: sp.Expr) -> tuple[str, str]:
+    """Vertex/fragment shader sources for an implicit curve (the level set ``F(x, y) = 0``).
+
+    Same uniform block as the 1-D shader, so the QML side and the curve model need no special
+    case: only the expressions differ.
+    """
+    return (VERTEX_SHADER, IMPLICIT_FRAGMENT_TEMPLATE
+            .replace("@FUNC@", func_glsl(expr, "x"))
+            .replace("@DFUNCX@", func_glsl(sp.diff(expr, sp.Symbol("x")), "x"))
+            .replace("@DFUNCY@", func_glsl(sp.diff(expr, sp.Symbol("y")), "x")))
+
 def shader_sources(expr: sp.Expr) -> tuple[str, str]:
     """Vertex/fragment shader sources for the QML front end (implicit model)."""
     frag = (

qmlmathplot/mpl.py

@@ -27,6 +27,8 @@ if TYPE_CHECKING:  # pragma: no cover - typing only; the real imports stay lazy
 
 __all__ = ["figure_for", "save_via_matplotlib", "sympy_plot_for"]
 
+#: The free symbol every curve is written in (see ``Curve``).
+_SYMBOL = sp.Symbol("x")
 #: Logical pixels to points (96 px/inch, 72 pt/inch): our sizes are in px, matplotlib's in pt.
 PX_TO_PT = 72.0 / 96.0
 #: The DPI the hand-off assumes for sizes that only exist in pixels (the live viewport).
@@ -57,31 +59,38 @@ def _pair(value: Sequence[float], name: str) -> tuple[float, float]:
 
 
 def _visible_curves(plot: Plot) -> list[Curve]:
-    """The curves the Qt view would draw (a hidden curve is not handed over)."""
+    """The curves the Qt view would draw (a hidden curve is not handed over).
+
+    Implicit curves (the level set ``F(x, y) = 0``) are **skipped**: a sampled polyline cannot
+    come from an implicit expression (the faithful route would be a ``contour`` on a grid, i.e. a
+    different renderer with a grid resolution), and this hand-off refuses to pretend. A plot made
+    of implicit curves only is therefore empty here — use the Qt export for it.
+    """
     return [plot.curves.at(index) for index in range(len(plot.curves))
-            if plot.curves.at(index).visible]
+            if plot.curves.at(index).visible and not plot.curves.at(index).implicit]
 
 
-def _sample(expression: str, x0: float, x1: float, samples: int) -> tuple[object, object]:
+def _sample(curve: Curve, x0: float, x1: float, samples: int) -> tuple[object, object]:
     """Uniform samples of one curve; NaN where the function is outside its domain.
 
     matplotlib breaks the line at NaN, which is how the hand-off keeps ``log(x)`` from being
     drawn for x < 0. Infinities (poles, ``1/x`` at 0) are turned into NaN as well, so a pole
     breaks the line instead of drawing a connector across it.
+
+    The expression comes from ``Curve.expr``: the curve parsed it once, so no string is parsed
+    again here.
     """
     import numpy
 
-    symbol = sp.Symbol("x")
     try:
-        function = sp.lambdify(symbol, sp.sympify(expression, locals={"x": symbol}),
-                               modules=["numpy"])
+        function = sp.lambdify(_SYMBOL, curve.expr, modules=["numpy"])
         with numpy.errstate(all="ignore"):        # log(x<0) etc.: NaN, not a warning storm
             xs = numpy.linspace(x0, x1, samples)
             ys = numpy.asarray(function(xs), dtype=float)
     except Exception as exc:
-        # Broad on purpose: sympify, lambdify and the evaluation itself all report by raising,
-        # and the caller wants one clear message naming the expression.
-        raise ValueError(f"cannot sample {expression!r}: {exc}") from exc
+        # Broad on purpose: lambdify and the evaluation itself report by raising, and the
+        # caller wants one clear message naming the expression.
+        raise ValueError(f"cannot sample {curve.expression!r}: {exc}") from exc
     if ys.ndim == 0:                              # a constant expression evaluates to a scalar
         ys = numpy.full(xs.shape, float(ys))
     ys[~numpy.isfinite(ys)] = numpy.nan
@@ -162,7 +171,7 @@ def figure_for(
                        fontweight="bold" if plot.title_bold else "normal")
 
     for curve in _visible_curves(plot):
-        xs, ys = _sample(curve.expression, x_range[0], x_range[1], samples)
+        xs, ys = _sample(curve, x_range[0], x_range[1], samples)
         axes.plot(xs, ys, color=curve.color.name(), linewidth=curve.lineWidth * PX_TO_PT,
                   label=curve.label or curve.expression)
     return figure
@@ -207,20 +216,14 @@ def sympy_plot_for(
     is the same one the matplotlib hand-off would show, and every curve keeps its colour.
     """
     _require()                                    # sympy's plotting backend is matplotlib too
-    symbol = sp.Symbol("x")
     curves = _visible_curves(plot)
     if not curves:
         raise ValueError("nothing to hand to sympy: the plot has no visible curve")
     x_range = _pair(xlim, "xlim") if xlim is not None else (plot.xlim.x(), plot.xlim.y())
     y_range = _pair(ylim, "ylim") if ylim is not None else (plot.ylim.x(), plot.ylim.y())
-    expressions = []
-    for curve in curves:
-        try:
-            expressions.append(sp.sympify(curve.expression, locals={"x": symbol}))
-        except Exception as exc:
-            raise ValueError(f"cannot parse {curve.expression!r}: {exc}") from exc
     handle = sp.plotting.plot(
-        *expressions, (symbol, x_range[0], x_range[1]), show=False,
+        *(curve.expr for curve in curves),        # parsed once, by the curve
+        (_SYMBOL, x_range[0], x_range[1]), show=False,
         adaptive=adaptive,                        # see Plot.to_sympy for why False is the default
         nb_of_points=samples,
         label=[curve.label or curve.expression for curve in curves],

qmlmathplot/plot.py

@@ -11,6 +11,8 @@ from __future__ import annotations
 from PySide6.QtCore import Property, QObject, Signal, Slot
 from PySide6.QtGui import QColor, QImage, QVector2D
 
+import sympy as sp
+
 from .camera import Camera
 from .curve import DEFAULT_COLOR_CYCLE, Curve, CurveListModel
 from .themes import names, resolve
@@ -141,18 +143,45 @@ class Plot(QObject):
         "QVariant", _get_aspect, _set_aspect, notify=aspectChanged
     )
 
-    @Slot(str, "QVariant", "QVariant", str, result=QObject)
-    @Slot(str, result=QObject)
+    # "QVariant" for the expression so a sympy expression arrives *unconverted*: a `str` slot
+    # would have PySide stringify it first, i.e. the very Expr -> str -> Expr round trip this
+    # signature exists to avoid (QML passes a string, which is unchanged).
+    @Slot("QVariant", "QVariant", "QVariant", str, result=QObject)
+    @Slot("QVariant", result=QObject)
     def add_curve(
         self,
-        expression: str,
+        expression: "str | sp.Expr",
         color: object = None,
         line_width: object = None,
         label: str = "",
     ) -> Curve:
-        """Add a curve (colour and width default to the plot's cycle and ``lineWidth``)."""
+        """Add a curve (colour and width default to the plot's cycle and ``lineWidth``).
+
+        The artist follows the expression's free symbols: ``x`` (or none) is a 1-D curve
+        ``y = f(x)``, ``x`` **and** ``y`` is an implicit curve — the level set ``F(x, y) = 0``,
+        so ``add_curve("x**2 + y**2 - 1")`` is a circle — and any other free symbol raises
+        ``ValueError`` (substitute parameters first).
+        """
         return self._curves.add_curve(expression, color, line_width, label)
 
+    @Slot("QVariant", "QVariant", "QVariant", str, result=QObject)
+    @Slot("QVariant", result=QObject)
+    def add_implicit(
+        self,
+        expression: str | sp.Expr,
+        color: object = None,
+        line_width: object = None,
+        label: str = "",
+    ) -> Curve:
+        """Add an implicit curve — the level set ``F(x, y) = 0`` — explicitly, whatever the
+        expression's free symbols (``x`` alone gives vertical lines).
+
+        Drawn per pixel like the other artists, with no sampling: ``|F|`` divided by ``|grad F|``
+        in pixels is the distance to the level set. Smooth, single-sheet level sets only for now
+        — thin features and several branches through one pixel are not handled yet.
+        """
+        return self._curves.add_implicit(expression, color, line_width, label)
+
     @Slot(QObject)
     def remove_curve(self, curve: Curve) -> None:
         self._curves.remove_curve(curve)

{qmlmathplot-0.2.0.dist-info → qmlmathplot-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qmlmathplot
-Version: 0.2.0
+Version: 0.3.0
 Summary: Embeddable function plotter for Qt Quick / QtWidgets (implicit per-pixel drawing, MVVM)
 Author: I-AM-A-NOOB
 Author-email: I-AM-A-NOOB <suzc08@outlook.com>
@@ -44,6 +44,18 @@ An un-themed plot looks like matplotlib (white background, tab10 colours, grey g
 axes through the origin with the tick labels riding them) — the default style sheet is applied
 at construction, so `plot.theme = "default"` is the reset.
 
+`add_curve()` (and `Curve.expression`) accept the expression **either as a string or as a sympy
+expression**: `plot.add_curve(sp.sin(1 / sp.Symbol("x")))` is the same curve as
+`plot.add_curve("sin(1/x)")`. The stored and reported form is always the canonical string — QML,
+a project file and the text field want one — while the parsed expression is cached and exposed as
+`Curve.expr`, which is what re-baking and the matplotlib hand-off use. The object form exists so a
+curve can be composed without string interpolation:
+
+```python
+curve = plot.add_curve("sin(x)")
+plot.add_curve(sp.diff(sp.sympify(curve.expression, locals={"x": sp.Symbol("x")})), label="f'")
+```
+
 `MathPlotWidget` keeps one curve's worth of convenience (`expression`, `error`,
 `line_width`, `curve_color`, `background_color`, `aspect`, `view_bounds()`,
 `reset_view()`, `zoom()`, `pan_pixels()`); everything else lives on the model behind it:
@@ -122,9 +134,9 @@ The model:
 
 | Object | Members |
 |---|---|
-| `Plot` | `camera`, `curves`, `xlim`/`ylim`/`aspect` (forwarded), `add_curve()` / `remove_curve()`, `available_themes`, and the style properties: `background`, `grid`, `grid_color`, `grid_width`, `grid_alpha`, `grid_style`, `axis_color`, `axis_width`, `axes_position`, `color_cycle`, `line_width`, `text_color`, `tick_color`, `tick_length`, `font_size`, `tick_font_size`, `title`, `title_color`, `title_font_size`, `title_bold`, `ticks_visible`, `theme` |
+| `Plot` | `camera`, `curves`, `xlim`/`ylim`/`aspect` (forwarded), `add_curve()` / `add_implicit()` / `remove_curve()`, `available_themes`, and the style properties: `background`, `grid`, `grid_color`, `grid_width`, `grid_alpha`, `grid_style`, `axis_color`, `axis_width`, `axes_position`, `color_cycle`, `line_width`, `text_color`, `tick_color`, `tick_length`, `font_size`, `tick_font_size`, `title`, `title_color`, `title_font_size`, `title_bold`, `ticks_visible`, `theme` |
 | `Camera` | `centre`, `zoom` (world units per logical pixel), `aspect`, `xlim`/`ylim` (derived), `ticks_x`/`ticks_y`, `zoomStep` / `panEnabled` / `zoomEnabled`, slots `setViewport(w, h)` / `zoom_by(delta, u, v, w, h)` / `pan_pixels(dx, dy)` / `reset()` |
-| `Curve` | `expression`, `color`, `lineWidth`, `visible`, `label`, `error` (read-only), the baked `vertexShader` / `fragmentShader` |
+| `Curve` | `expression` (string or sympy expression), `expr` (the parsed expression, read-only), `implicit`, `color`, `lineWidth`, `visible`, `label`, `error` (read-only), the baked `vertexShader` / `fragmentShader` |
 | `CurveListModel` | the curves as a model (`curve`, `expression`, `color`, `lineWidth`, `visible`, `vertexShader`, `fragmentShader` roles) so QML puts one `ShaderEffect` behind each |
 
 Every setter is a Qt `Property` with a notify signal, so the same calls work from QML, from a
@@ -144,6 +156,35 @@ bounded page), no `FigureCanvas`/`draw()` (the scene is live), no toolbar and no
 chrome), and an export is a canvas region at a pixel size rather than a re-rendered page
 (§9, implemented — see *Export* below).
 
+## Implicit curves
+
+An expression whose free symbols are `x` **and** `y` is drawn as the level set `F(x, y) = 0`.
+The artist follows the expression, whoever sets it: `add_curve` routes it by itself, assigning to
+`curve.expression` re-routes the same curve (so a text field can turn `sin(x)` into a circle),
+and `add_implicit` asks for the level-set artist explicitly — also for a function of `x` alone,
+which is a pair of vertical lines. Only a *third* free symbol is refused: substitute parameters
+first.
+
+```python
+plot.add_curve("x**2 + y**2 - 1")        # a circle: {x, y} routes to the level-set artist
+plot.add_implicit("x*y - 1")             # the same artist, asked for by name
+plot.curves.at(0).expression = "x**2 + y**2 - 4"   # re-routes the curve that is already there
+plot.add_curve("a*sin(x)")               # ValueError: substitute `a` first
+```
+
+The renderer is the same idea as the 1-D stroke, one dimension up: one evaluation of `F` and its
+two partials per pixel give the distance to the level set in *pixels*,
+`d = |F| / sqrt((Fx·dx)² + (Fy·dy)²)`, and the coverage is `clamp(lineWidth/2 + 0.5 - d, 0, 1)` —
+analytic antialiasing and a stroke width that does not depend on the angle, with no sampling grid
+(the unit circle measures the same 3 device pixels at 0°, 45°, 90° and 135° for `lineWidth=2` at
+DPR 1.5).
+
+Known limit: **smooth, single-sheet level sets**. Thin features and several branches through one
+pixel (`sin(1/(x*x + y*y))`), and 2-D domains/poles, are not handled yet — the assessment is
+`docs/api-design.md` §6b; pixels where `F` is undefined are dropped. The matplotlib hand-off
+skips implicit curves (a level set has no polyline to sample), while the Qt export renders them
+like anything else.
+
 ## The camera (centre, zoom, aspect)
 
 `Camera` stores three numbers that do not depend on the widget: `centre` (world coordinates in
@@ -279,6 +320,14 @@ backend is used**. The implementation sets `QSG_RHI_BACKEND` before
 
 ## Structure (model / view)
 
+The layers are strict about Qt. **`model.py` (expression → GLSL), `themes.py` (style-sheet
+conversion) and `mpl.py` (the sampled hand-off) import no Qt at all** — they are unit-testable
+without a `QApplication`. `Camera`, `Curve` and `Plot` are the **ViewModel**: `QObject`s whose
+`Property`es carry notify signals, which is precisely what the QML component binds to — and why
+a Python-side assignment updates the view with no call in between. `view.py`, `PlotView.qml`,
+`export.py` and `widget.py` are the View/embedding layer and do need Qt; `export.py` and
+`widget.py` import QtWidgets lazily, so a pure-QML host never loads it.
+
 | Layer | File | Responsibility |
 |---|---|---|
 | Model | `src/qmlmathplot/model.py` | expression → GLSL, shader source template (no Qt dependency, unit-testable) |
@@ -327,7 +376,12 @@ QSG_RHI_BACKEND=opengl uv run pytest -m gui
   (the home view at the first size, resize keeping the scale, an anchored zoom that
   is exactly reversible, the aspect expanding but never cropping, ticks).
 - `test_curve.py`: a failed expression keeps the last working shaders, the style
-  setters are idempotent, and the list model reports the right roles.
+  setters are idempotent, and the list model reports the right roles — plus the
+  `Expr`/string round-trip accounting (a string is parsed once, an expression never).
+- `test_implicit.py`: the routing by free symbols (and the `ValueError` for a third symbol), the
+  level-set shader text (same uniform block as the 1-D one, no sampling loop), and the rendered
+  geometry of a unit circle: crossings a quarter of the height from each edge, a blank middle,
+  radius 1 on both axes, and a stroke of the same width at 0°/45°/90°/135°.
 - `test_plot.py`: the plot's properties convert, notify exactly once and are wired
   (a PySide property with an unresolved notify name silently loses it), the defaults are
   matplotlib's default style, the limits are forwarded to the camera, and a theme applies
@@ -391,15 +445,21 @@ extrema/zeros by bisection. The same approach is used here:
   perpendicular foot lands on a segment (on a sloped line it is displaced along x
   by `m·d/√(1+m²)`); with a narrower window the distance degraded to "distance to
   the nearest endpoint" and steep parts looked thin and ragged.
-- **Break on jumps**: via the **analytic pole gap** (denominator sign change, world
-  units) — no vertical connector is drawn at the asymptotes of `1/x`, `tan(x)`.
-  (An earlier "adjacent samples differ by more than 4 viewport heights" criterion
-  was pixel-/viewport-relative, so under magnification it also cut legitimate steep
-  segments; it was removed.)
+- **Break on jumps**: a denominator sign change (world units) decides, in three places,
+  that nothing joins the branches — the polyline segment that straddles the pole is not
+  stroked, a straddling pair does not count as a turn in the band's turn count (it used to
+  fill the pole column solid), and the unbounded-boundary ray is not drawn there. No vertical
+  connector at the asymptotes of `1/x`, `tan(x)`. (An earlier "adjacent samples differ by
+  more than 4 viewport heights" criterion was pixel-/viewport-relative, so under magnification
+  it also cut legitimate steep segments; it was removed. The remaining "spread beyond 32
+  viewport heights" gap is a second line of defence only — at `tan`'s pole column the spread
+  is ~15 viewports, so it never fires there.)
 - **Domain** (derived by sympy, injected as `DOM`): denominator ≠ 0, `log` argument
   > 0, `sqrt` argument ≥ 0, `asin/acos` argument ∈ [−1,1]; pixels outside the domain
-  are discarded outright. NaN/inf samples take part in neither the envelope nor
-  segment joining.
+  are discarded outright — except for the **boundary ray** of a slowly diverging edge
+  (`log(x)` as x→0+), which is a band centred *on* the boundary and therefore paints the few
+  pixels outside the domain that it covers (the whole outer half of that band, otherwise).
+  NaN/inf samples take part in neither the envelope nor segment joining.
 - **Undersampled columns** (several oscillations inside one column) are replaced
   wholesale by the envelope band: a polyline is random sawtooth in such columns.
   There are two criteria, both **scale-independent**: (a) ≥ 2 direction reversals

{qmlmathplot-0.2.0.dist-info → qmlmathplot-0.3.0.dist-info}/RECORD

@@ -1,11 +1,12 @@
-qmlmathplot/__init__.py,sha256=C_fYVkO8WQPVW1K_wvjdH8OniRbUpdCkIPB-ULvP6Kk,2832
-qmlmathplot/app.py,sha256=9ojtrU9_wIcgUq7Ib449KRkuLSsr7FLzSBNguI-T8l4,3124
+qmlmathplot/__init__.py,sha256=fJu6acfPJfV-5AhhCmSdGhf9eBzVWuLHuSr-UpfRLeU,2869
+qmlmathplot/__main__.py,sha256=vQOzajfwfvukcwvhZSg29HtGocqQnQGBBbc-Rc2AUT4,389
+qmlmathplot/app.py,sha256=P2RBLyUIfjn8_JGpnkJa7exKs6LcQTYY8tSZQtxyQ3I,3243
 qmlmathplot/camera.py,sha256=YSLtGODs_efGwmtKbjT9osss-jmyV7MaLEYOu_zcxg0,16894
-qmlmathplot/curve.py,sha256=Q-3S8WhsHWanWnZXkHH_nak8q7CXDHSioqyUyblKQJ0,10723
-qmlmathplot/export.py,sha256=QfoE4TKnKt-xdaUAkB8IsyupyfwFKu8hn0ikKp8mzrI,8065
-qmlmathplot/model.py,sha256=WAY2VyoMKR5vGkPxrr2GOfUnl0xXW01ntfQ_qW8i2Wg,24961
-qmlmathplot/mpl.py,sha256=Liaqq1NWBjuSe95uxBsx2YbUULU4F5kvcvWDQErnE-Y,10684
-qmlmathplot/plot.py,sha256=XDp_Jg2FQLQLDmUhUy5tuzAFCerihwitaBICp4i_xuA,15306
+qmlmathplot/curve.py,sha256=_LCoZraLBCQxVUFWh2kmi4kjBNgg3zbfZFwg_i9J-YU,18688
+qmlmathplot/export.py,sha256=BEZh5mDHlxGH0ernsGPOCfAjZGi_qwuecANYkRnKFEk,8999
+qmlmathplot/model.py,sha256=mbWj9Tmf3k8T17EmkGUNZGe1xdtZ6TVQvaYdGYEMVxs,34128
+qmlmathplot/mpl.py,sha256=Q6yuVeuXlejYM5n_odCFIwLq2-w2MP8hfD9po-ZiCog,10970
+qmlmathplot/plot.py,sha256=A_mJOSCtSeW0mPd4KvKcwITRC1h4hw1ToGwFUIX7X9c,16810
 qmlmathplot/qml/PlotView.qml,sha256=4XfSGcmlsD6LNua_qhB5DtVuL-PTFO3gG4LhJzzQC7M,11519
 qmlmathplot/qsb.py,sha256=kTaC3hKAZYSNU5M2ySRFcWUdwTZT8DAHUdsUgKRCanc,3964
 qmlmathplot/themes/LICENSE.matplotlib,sha256=ojr3trhyymyw7GeYxkhO2JYoAxUVscbgMFz9b1qrcVM,4928
@@ -40,7 +41,7 @@ qmlmathplot/themes/tableau-colorblind10.mplstyle,sha256=PzUMoOtw0V6l0bPk8ApRAKvc
 qmlmathplot/themes.py,sha256=QocZLOgPYXCJW9fYc6i5q6nHEE_S4mQVZXySZ4ISCPw,9225
 qmlmathplot/view.py,sha256=G6W0WfI4yT0eX4rHswqwu3y48MQTXjcA0BnWpIS1vD0,1746
 qmlmathplot/widget.py,sha256=HXSQko0YwixG0bx--BP6k_Fd_fn-58P-ywT2-HZw0E0,7899
-qmlmathplot-0.2.0.dist-info/WHEEL,sha256=xTCBFIZIIyRSxyowOv5Wqg_jFU6KsdIffuulBB09Ph8,80
-qmlmathplot-0.2.0.dist-info/entry_points.txt,sha256=4z36D_RpPSYLiJDRM8iXnrSe1T4c2alfQJPcJTss3qY,54
-qmlmathplot-0.2.0.dist-info/METADATA,sha256=qlC49LZEVjSKctg5FELNUSiMnUkisgwwAd5VtKONzqU,30542
-qmlmathplot-0.2.0.dist-info/RECORD,,
+qmlmathplot-0.3.0.dist-info/WHEEL,sha256=xTCBFIZIIyRSxyowOv5Wqg_jFU6KsdIffuulBB09Ph8,80
+qmlmathplot-0.3.0.dist-info/entry_points.txt,sha256=4z36D_RpPSYLiJDRM8iXnrSe1T4c2alfQJPcJTss3qY,54
+qmlmathplot-0.3.0.dist-info/METADATA,sha256=2dRCAwsWnPUtJsGG-ZYnbULVypGg5K7Lj_EKoD0z_Mk,34895
+qmlmathplot-0.3.0.dist-info/RECORD,,