qmlmathplot 0.4.3__py3-none-any.whl → 0.5.0__py3-none-any.whl

qmlmathplot/curve.py

@@ -3,8 +3,8 @@
 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``).
+Two artists share the class: ``Curve`` draws ``y = f(x)`` (see ``shaders/oned_sampled.frag``) and
+``ImplicitCurve`` draws the level set ``F(x, y) = 0`` (``shaders/implicit.frag``).
 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.
 """
@@ -27,6 +27,7 @@ from PySide6.QtCore import (
 )
 from PySide6.QtGui import QColor
 
+from .interval import compute_supported
 from .model import implicit_shader_sources, shader_sources
 from .qsb import bake
 
@@ -310,6 +311,8 @@ class Curve(QObject):
     def _get_fragment_shader(self) -> QUrl:
         return self._fragment
 
+    #: Empty when the compute renderer draws this expression: the RHI generates its path
+    #: from `expr`. Only the sampled fallback and implicit curves bake these shaders.
     vertexShader: QUrl = Property(QUrl, _get_vertex_shader, notify=shadersChanged)
     fragmentShader: QUrl = Property(QUrl, _get_fragment_shader, notify=shadersChanged)
 
@@ -340,8 +343,13 @@ class Curve(QObject):
                 "first"
             )
         implicit = self._force_implicit if force_implicit is None else force_implicit
-        return implicit_shader_sources(expr) if (implicit or "y" in names) \
-            else shader_sources(expr)
+        if implicit or "y" in names:
+            return implicit_shader_sources(expr)
+        if compute_supported(expr):
+            # The compute renderer generates its shader from `expr`; baking the sampled
+            # fallback here would be dead work (qsb + the edge analysis, ~130 ms/curve).
+            return "", ""
+        return shader_sources(expr)
 
     def _start_bake(
         self,
@@ -364,6 +372,11 @@ class Curve(QObject):
             self._error = f"{type(exc).__name__}: {exc}"
             self.errorChanged.emit()
             return
+        if not vertex_source and not fragment_source:
+            self._pending_expr = expr
+            self._pending_implicit = force_implicit
+            self._on_bake_done(generation, (None, None))
+            return
         self._pending_expr = expr
         self._pending_implicit = force_implicit
         if synchronous or not self.bake_async or QCoreApplication.instance() is None:
@@ -397,13 +410,16 @@ class Curve(QObject):
             return
         if expr is None:
             return
-        vertex, fragment = result           # type: ignore[misc]
+        if result == (None, None):
+            vertex = fragment = None
+        else:
+            vertex, fragment = result           # type: ignore[misc]
         self._expr = expr
         if implicit is not None:
             self._force_implicit = bool(implicit)
         self._error = ""
-        self._vertex = QUrl.fromLocalFile(str(vertex))
-        self._fragment = QUrl.fromLocalFile(str(fragment))
+        self._vertex = QUrl() if vertex is None else QUrl.fromLocalFile(str(vertex))
+        self._fragment = QUrl() if fragment is None else QUrl.fromLocalFile(str(fragment))
         self.exprChanged.emit()
         self.errorChanged.emit()
         self.shadersChanged.emit()
@@ -422,7 +438,7 @@ class ImplicitCurve(Curve):
 
 
 class CurveListModel(QAbstractListModel):
-    """The plot's curves, as a model so QML can put one ShaderEffect behind each of them."""
+    """The plot's curves, as a model the QRhi renderer and QML chrome read."""
 
     CurveRole = int(Qt.ItemDataRole.UserRole) + 1
     ExpressionRole = CurveRole + 1

qmlmathplot/ggb_compute.py

@@ -0,0 +1,55 @@
+# SPDX-FileCopyrightText: 2007-2026 GeoGebra GmbH
+# SPDX-License-Identifier: GPL-3.0-only
+# Portions derived from GeoGebra (EUPL-1.2); see THIRD_PARTY_NOTICES.md.
+"""GLSL generation for the sequential GPU port of GGB's interval path.
+
+One compute invocation walks the screen columns in order, evaluates ``FI`` (the interval of
+the function on the column), and runs the same state machine as
+:mod:`qmlmathplot.ggb_path`: ``IntervalPath`` (break/join), ``DrawInterval``
+(joined/independent/whole), ``DrawInvertedInterval`` (gap rays) and ``JoinLines``
+(neighbour-aware completion). The emitted segments are written into a storage buffer that a
+tiny vertex/fragment pair draws; no CPU sampling is involved.
+
+The neighbour state is taken from the previously evaluated column and a one-column prefetch,
+so the whole pass pays one ``FI`` per column plus one. No scalar ``F`` evaluations are used:
+the path is the interval's own endpoints, which is what GGB draws.
+"""
+
+from __future__ import annotations
+
+import sympy as sp
+
+from .shaderbuild import render, shader_source
+from .interval import has_sign_pole, interval_glsl, interval_lib_for
+from .model import _domain_is_pole_only, _non_negative, _pole_glsl, _pole_spacing
+
+__all__ = ["PATH_VERTEX", "PATH_FRAGMENT", "path_compute_source", "path_subsamples"]
+
+PATH_VERTEX = shader_source("path.vert")
+
+PATH_FRAGMENT = shader_source("path.frag")
+
+
+def path_subsamples(expression: str | sp.Basic) -> int:
+    # GGB FunctionSampler: one interval per screen column.
+    return 1
+
+
+
+
+def path_compute_source(expression: str | sp.Basic) -> str:
+    expr = expression if isinstance(expression, sp.Basic) else sp.sympify(expression)
+    pole = has_sign_pole(expr)
+    intervals = interval_glsl(expr)
+    return render(
+        "interval_path.comp",
+        SUBSAMPLES=path_subsamples(expression),
+        POLE=_pole_glsl(expr, "u") if pole else "1.0",
+        HAS_POLE="1" if pole else "0",
+        POLE_SPACING=f"{_pole_spacing(expr):.17g}",
+        UNIFORM_FILL="1" if (
+            pole and _non_negative(expr) and _domain_is_pole_only(expr)
+        ) else "0",
+        INTERVAL_LIB=interval_lib_for(intervals),
+        INTERVALS=intervals,
+    )

qmlmathplot/ggb_path.py

@@ -0,0 +1,354 @@
+# SPDX-FileCopyrightText: 2007-2026 GeoGebra GmbH
+# SPDX-License-Identifier: GPL-3.0-only
+# Portions derived from GeoGebra (EUPL-1.2); see THIRD_PARTY_NOTICES.md.
+"""GeoGebra's interval path as a state machine over column topologies.
+
+This is the semantic core of ``org.geogebra.common.euclidian.plot.interval``:
+``IntervalPath`` (break/join state), ``DrawInterval`` (joined/independent/whole),
+``DrawInvertedInterval`` (gap rays) and ``JoinLines`` (neighbour-aware completion of the
+inverted and infinite cases). It contains **no interval arithmetic and no sampling**: the
+input is one y-topology per screen column (empty / connected / inverted / whole), the output
+is screen-space segments.
+
+Keeping the decisions here rather than inline in the GLSL gives the GPU path a host-testable
+specification: synthetic topologies can exercise every branch without a GPU and without a
+second interval evaluator. ``ggb_reference`` feeds it from ``mpmath.iv``; ``ggb_compute``
+mirrors it in the compute shader, consuming the float32 ``INTERVAL_LIB`` topology.
+
+Coordinates are screen pixels (y down), matching GGB's path. The y interval is stored in
+world units; the conversions happen at the edges.
+
+Both ``JoinLines`` comparisons are ported literally, because GGB's own plotter output
+shows they matter: the top-edge equality is a **tolerance** (``MAX_PRECISION = 1e-12`` in
+double; a float-safe relative tolerance on the GPU), and ``toBottom`` compares differences
+**after** ``toScreenCoordYd``, which reverses their order. ``VERTICAL_MARGIN`` is not
+reproduced; the GPU clips the segment to the viewport anyway.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Literal
+
+__all__ = ["IVal", "Column", "PathPoint", "IntervalPath", "IINF"]
+
+Kind = Literal["empty", "connected", "inverted", "whole"]
+
+#: The GLSL library's infinity sentinel (``IINF``); real infinities are avoided on the GPU.
+IINF = 1e30
+
+
+@dataclass(frozen=True)
+class IVal:
+    """A conservative y value: a connected range, a gap, the whole line, or empty."""
+
+    lo: float
+    hi: float
+    kind: Kind = "connected"
+
+    @property
+    def empty(self) -> bool:
+        return self.kind == "empty"
+
+    @property
+    def whole(self) -> bool:
+        return self.kind == "whole"
+
+    @property
+    def inverted(self) -> bool:
+        return self.kind == "inverted"
+
+    def has_infinity(self) -> bool:
+        if self.kind == "empty":
+            return False
+        if self.kind == "whole":
+            return True
+        return self.lo <= -IINF or self.hi >= IINF
+
+    # Payload edges: an inverted value stores the excluded gap, a whole value is unbounded.
+    @property
+    def payload_lo(self) -> float:
+        if self.kind == "whole":
+            return -IINF
+        return self.lo
+
+    @property
+    def payload_hi(self) -> float:
+        if self.kind == "whole":
+            return IINF
+        return self.hi
+
+
+@dataclass(frozen=True)
+class Column:
+    x_lo: float
+    x_hi: float
+    y: IVal
+
+
+@dataclass
+class PathPoint:
+    x: float
+    y: float
+
+
+def _near(a: float, b: float, fraction: float = 1e-9) -> bool:
+    """``DoubleUtil.isEqual(0, |a-b|, MAX_PRECISION)`` with a scale-aware epsilon.
+
+    The double version uses 1e-12; the GPU needs a larger relative epsilon for float32.
+    """
+    return abs(a - b) <= fraction * max(1.0, abs(a), abs(b))
+
+
+class IntervalPath:
+    """Turns per-column topologies into a path, the way GGB's ``IntervalPath`` does.
+
+    ``columns`` must be in screen-column order. The x interval of a column is its world
+    span; ``width``/``height`` are the view's pixel size and the ``x_*``/``y_*`` arguments
+    are its world bounds.
+    """
+
+    def __init__(
+        self,
+        columns: list[Column],
+        width: float,
+        height: float,
+        x_lo: float,
+        x_hi: float,
+        y_lo: float,
+        y_hi: float,
+    ) -> None:
+        self.columns = columns
+        self.width = float(width)
+        self.height = float(height)
+        self.x_lo = float(x_lo)
+        self.x_hi = float(x_hi)
+        self.y_lo = float(y_lo)
+        self.y_hi = float(y_hi)
+        self.segments: list[tuple[PathPoint, PathPoint]] = []
+        self._point: PathPoint | None = None
+        self._last: IVal | None = None
+
+    # ------------------------------------------------------------------ driver
+    def update(self) -> list[tuple[PathPoint, PathPoint]]:
+        """Reset and rebuild the path; returns screen-space segments."""
+        del self.segments[:]
+        self._point = None
+        self._last = None
+        for index in range(len(self.columns)):
+            self._draw_at(index)
+        return list(self.segments)
+
+    def _draw_at(self, index: int) -> None:
+        column = self.columns[index]
+        y = column.y
+        if y.empty:
+            self._last = None
+            return
+        if self._last is None:
+            self._draw_independent(index)
+        elif y.whole:
+            self._draw_whole(column)
+        elif y.inverted:
+            self._draw_inverted(index)
+        elif y.has_infinity():
+            self._draw_normal_infinity(column)
+        else:
+            self._draw_joined(column)
+
+    # ------------------------------------------------------- DrawInterval
+    def _draw_joined(self, column: Column) -> None:
+        """``DrawInterval.drawUp``/``drawDown``: connect to the previous column edge."""
+        assert self._last is not None
+        y = column.y
+        # GGB compares the *screen* high edges; screen high is the world low edge.
+        up = y.lo < self._last.lo
+        if up:
+            first = (self._sx(column.x_lo), self._sy(y.hi))
+            second = (self._sx(column.x_hi), self._sy(y.lo))
+        else:
+            first = (self._sx(column.x_lo), self._sy(y.lo))
+            second = (self._sx(column.x_hi), self._sy(y.hi))
+        self._line_to(*first)
+        self._line_to(*second)
+        self._last = y
+
+    def _draw_independent(self, index: int) -> None:
+        """``IntervalPath.drawTupleIndependent``."""
+        column = self.columns[index]
+        y = column.y
+        if y.whole:
+            self._draw_whole(column)
+            return
+        if y.inverted:
+            self._draw_inverted(index)
+            return
+        # DrawInterval.drawIndependent -> line(x, y): a vertical at the right edge. Infinities
+        # are clamped by ``_sy``; the segment runs off screen and is clipped.
+        self._segment(
+            (self._sx(column.x_hi), self._sy(y.hi)),
+            (self._sx(column.x_hi), self._sy(y.lo)),
+        )
+        self._last = y
+
+    def _draw_whole(self, column: Column) -> None:
+        """``DrawInterval.drawWhole``: one vertical at x.low, then a path break."""
+        x = self._sx(column.x_lo)
+        self._segment((x, 0.0), (x, self.height))
+        self._last = None
+
+    # ------------------------------------------------ DrawNormalInfinity
+    def _draw_normal_infinity(self, column: Column) -> None:
+        """``IntervalPath.drawNormalInfinity`` / ``IntervalPathPlotter.leftToTop``."""
+        y = column.y
+        if y.lo <= -IINF and y.hi >= IINF:
+            self._last = None
+            return
+        if y.hi >= IINF:
+            if self.y_lo <= y.lo <= self.y_hi:
+                self._segment(
+                    (self._sx(column.x_lo), self._sy(y.lo)),
+                    (self._sx((column.x_lo + column.x_hi) * 0.5), 0.0),
+                )
+                # ``lastY = zero()`` in screen space: the path continues from the top edge.
+                self._last = IVal(self.y_hi, self.y_hi, "connected")
+            else:
+                self._last = None
+            return
+        if self.y_lo <= y.hi <= self.y_hi:
+            self._segment(
+                (self._sx(column.x_lo), self._sy(y.hi)),
+                (self._sx((column.x_lo + column.x_hi) * 0.5), self.height),
+            )
+            self._last = IVal(self.y_lo, self.y_lo, "connected")
+        else:
+            self._last = None
+
+    # ------------------------------------- DrawInvertedInterval / JoinLines
+    def _draw_inverted(self, index: int) -> None:
+        """``DrawInvertedInterval.draw`` for both the joined and independent cases.
+
+        ``drawJoined`` does not use ``lastY`` for the inverted branch; it only resets it
+        when the current topology is whole, so the two entry points coincide.
+        """
+        column = self.columns[index]
+        right = self.columns[index + 1] if index + 1 < len(self.columns) else None
+        if right is not None and right.y.inverted:
+            self._inverted_segments(column)
+        else:
+            self._inverted_joined(index)
+            # DrawInvertedInterval.draw() clears lastYSet when the next column is not
+            # inverted, so the following connected column restarts independently. Without
+            # this the stale lastY joins the two branches across the pole.
+            self._last = None
+
+    def _inverted_segments(self, column: Column) -> None:
+        """``DrawInvertedInterval.drawSegments``: the gap is excluded, so two rays."""
+        gap = column.y
+        if gap.hi > self.y_lo:
+            self._segment(
+                (self._sx(column.x_lo), self.height),      # world y_min
+                (self._sx(column.x_hi), self._sy(gap.lo)),
+            )
+        if gap.lo < self.y_hi:
+            self._segment(
+                (self._sx(column.x_hi), 0.0),              # world y_max
+                (self._sx(column.x_hi), self._sy(gap.hi)),
+            )
+
+    def _inverted_joined(self, index: int) -> None:
+        """``JoinLines.inverted`` with the current/left/right tuples."""
+        column = self.columns[index]
+        gap = column.y
+        left = self.columns[index - 1] if index > 0 else None
+        right = self.columns[index + 1] if index + 1 < len(self.columns) else None
+        left_y = left.y if left is not None else None
+        right_y = right.y if right is not None else None
+
+        if gap.hi < IINF:
+            if not self._infinite_boundary(left_y):
+                self._to_top(column, left, right)
+        if gap.lo > -IINF:
+            if self._infinite_boundary(right_y):
+                y1 = left_y.lo if left_y is not None and not left_y.empty else gap.lo
+                x = self._sx(column.x_lo)
+                self._segment((x, self._sy(y1)), (x, self.height))
+            else:
+                self._to_bottom(column, left, right)
+
+    @staticmethod
+    def _infinite_boundary(y: IVal | None) -> bool:
+        return y is not None and not y.empty and y.has_infinity()
+
+    def _to_top(self, column: Column, left: Column | None, right: Column | None) -> None:
+        current = column.y.payload_hi
+        left_diff = abs(current - left.y.payload_hi) if left is not None else float("inf")
+        right_diff = abs(current - right.y.payload_hi) if right is not None else float("inf")
+        # GGB reads ``left/rightXHigh`` without a null check; at a view edge one neighbour is
+        # missing, so fall back to this column's own edges (the segment is clipped anyway).
+        left_x = self._sx(left.x_hi) if left is not None else self._sx(column.x_lo)
+        right_x = self._sx(right.x_hi) if right is not None else self._sx(column.x_hi)
+        x_low = self._sx(column.x_lo)
+        x_high = self._sx(column.x_hi)
+        if left is not None and _near(left_diff, 0.0):
+            self._segment((x_low, self._sy(left.y.payload_hi)), (x_low, 0.0))
+        elif right is not None and _near(right_diff, 0.0):
+            self._segment((x_high, self._sy(right.y.payload_hi)), (x_high, 0.0))
+        elif left_diff < right_diff:
+            self._segment((right_x, 0.0), (left_x, self._sy(current)))
+        else:
+            self._segment((right_x, 0.0), (right_x, self._sy(current)))
+
+    def _screen_difference(self, value: float, neighbour: Column | None) -> float:
+        """``JoinLines.getLeftScreenDifference``: the difference in *screen* space.
+
+        ``toScreenCoordYd`` is decreasing, so this reverses the ordering of a world-space
+        comparison. GGB's own tan output depends on it; using raw world differences selected
+        the mirrored branch and drew the asymptote on the wrong side.
+        """
+        if neighbour is None or neighbour.y.empty:
+            return -1.0
+        if neighbour.y.whole:
+            return -math.inf
+        return self._sy(value)
+
+    def _to_bottom(self, column: Column, left: Column | None, right: Column | None) -> None:
+        current = column.y.payload_lo
+        left_diff = (self._screen_difference(abs(current - left.y.payload_lo), left)
+                     if left is not None else -1.0)
+        right_diff = (self._screen_difference(abs(current - right.y.payload_lo), right)
+                      if right is not None else -1.0)
+        right_x = self._sx(right.x_hi) if right is not None else self._sx(column.x_hi)
+        x_low = self._sx(column.x_lo)
+        x_high = self._sx(column.x_hi)
+        if left_diff == 0.0 and left is not None:
+            self._segment((x_low, self._sy(left.y.payload_lo)), (x_low, self.height))
+        elif right_diff == 0.0 and right is not None:
+            self._segment((x_high, self._sy(right.y.payload_lo)), (x_high, self.height))
+        elif left_diff < right_diff:
+            # JoinLines.toBottomLeft: to *currentXHigh*, not currentXLow.
+            self._segment((right_x, self._sy(current)), (x_high, self.height))
+        else:
+            self._segment((x_low, self._sy(current)), (x_high, self.height))
+
+    # ------------------------------------------------------------- primitives
+    def _line_to(self, x: float, y: float) -> None:
+        if self._point is None:
+            self._point = PathPoint(x, y)
+            return
+        self.segments.append((self._point, PathPoint(x, y)))
+        self._point = PathPoint(x, y)
+
+    def _segment(self, start: tuple[float, float], end: tuple[float, float]) -> None:
+        """``IntervalPathPlotter.segment``: starts a new subpath."""
+        self.segments.append((PathPoint(*start), PathPoint(*end)))
+        self._point = PathPoint(*end)
+
+    def _sx(self, x: float) -> float:
+        return (x - self.x_lo) / (self.x_hi - self.x_lo) * self.width
+
+    def _sy(self, y: float) -> float:
+        # Clamp before mapping: the sentinel infinities would otherwise produce inf/NaN.
+        y = max(-1e12, min(1e12, y))
+        return (self.y_hi - y) / (self.y_hi - self.y_lo) * self.height

qmlmathplot/ggb_reference.py

@@ -0,0 +1,77 @@
+# SPDX-FileCopyrightText: 2007-2026 GeoGebra GmbH
+# SPDX-License-Identifier: GPL-3.0-only
+# Portions derived from GeoGebra (EUPL-1.2); see THIRD_PARTY_NOTICES.md.
+"""CPU sampler for GeoGebra's interval path, using the shared state machine.
+
+``IntervalSampler`` produces one conservative y interval per screen column with
+``mpmath.iv`` (the CPU analogue of the GPU's ``INTERVAL_LIB``). The path decisions live in
+:mod:`qmlmathplot.ggb_path`, which is shared with the tests and mirrored by the compute
+shader; this module adds no geometry of its own.
+
+``mpmath.iv`` cannot express a gap: an interval through a pole (``tan``, ``1/x``) comes back
+as ``[-inf, +inf]``, which GGB's ``IntervalSet`` would call *inverted* with a finite gap.
+Such a column is reported as **empty** here — a path break — because drawing it as a whole
+column would bridge the pole. The GPU's ``FI`` does produce the inverted topology, and the
+state machine handles it; the synthetic tests in ``tests/test_ggb_path.py`` cover that
+branch.
+"""
+
+from __future__ import annotations
+
+import mpmath as mp
+import sympy as sp
+
+from .ggb_path import Column, IINF, IntervalPath, IVal, PathPoint
+
+__all__ = ["Column", "PathPoint", "IVal", "IntervalSampler", "IntervalPathReference"]
+
+
+class IntervalSampler:
+    """One conservative y interval per screen column (GGB FunctionSampler shape)."""
+
+    def __init__(self, expression: str | sp.Basic, x_lo: float, x_hi: float,
+                 width: int) -> None:
+        x = sp.Symbol("x")
+        self._expr = expression if isinstance(expression, sp.Basic) else sp.sympify(expression)
+        self._func = sp.lambdify(x, self._expr, modules=[_iv_module()])
+        self._x_lo = x_lo
+        self._x_hi = x_hi
+        self._width = max(1, int(width))
+
+    def columns(self) -> list[Column]:
+        dx = (self._x_hi - self._x_lo) / self._width
+        out: list[Column] = []
+        for i in range(self._width):
+            lo = self._x_lo + i * dx
+            hi = lo + dx
+            out.append(Column(lo, hi, self._y_interval(lo, hi)))
+        return out
+
+    def _y_interval(self, lo: float, hi: float) -> IVal:
+        try:
+            value = self._func(mp.iv.mpf([lo, hi]))
+            a, b = float(value.a), float(value.b)
+        except (ValueError, ZeroDivisionError, OverflowError):
+            return IVal(0.0, 0.0, "empty")
+        if not (a == a and b == b) or a > b:
+            return IVal(0.0, 0.0, "empty")
+        if a <= -IINF and b >= IINF:
+            # A pole: the true image is an inverted gap, which mpmath.iv cannot express.
+            return IVal(0.0, 0.0, "empty")
+        return IVal(max(a, -IINF), min(b, IINF), "connected")
+
+
+def _iv_module() -> dict[str, object]:
+    return {
+        "sin": mp.iv.sin,
+        "cos": mp.iv.cos,
+        "tan": mp.iv.tan,
+        "sqrt": mp.iv.sqrt,
+        "exp": mp.iv.exp,
+        "log": mp.iv.log,
+        "Abs": abs,
+    }
+
+
+#: Backwards-compatible name: the CPU backend and its tests import this.
+IntervalPathReference = IntervalPath