qmlmathplot 0.5.0__tar.gz → 0.6.0__tar.gz

{qmlmathplot-0.5.0 → qmlmathplot-0.6.0}/PKG-INFO

@@ -1,17 +1,21 @@
 Metadata-Version: 2.4
 Name: qmlmathplot
-Version: 0.5.0
+Version: 0.6.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>
 License-Expression: GPL-3.0-only
 License-File: LICENSE
 License-File: LICENSES/EUPL-1.2.txt
-Requires-Dist: sympy>=1.14
 Requires-Dist: pyside6>=6.12
+Requires-Dist: numpy>=1.26
+Requires-Dist: sympy>=1.14 ; extra == 'calc'
 Requires-Dist: matplotlib>=3.8 ; extra == 'matplotlib'
+Requires-Dist: matplotlib>=3.8 ; extra == 'mpl'
 Requires-Python: >=3.11
+Provides-Extra: calc
 Provides-Extra: matplotlib
+Provides-Extra: mpl
 Description-Content-Type: text/markdown
 
 # QMLMathPlot
@@ -28,6 +32,24 @@ The state is a **camera on an infinite canvas**: a `Plot` holds a `Camera` (wher
 and a list of `Curve`s (what is drawn), and the QML component `PlotView` binds to it. Several
 panels are several `Plot`s in a Qt layout — there is no figure, no axes box and no page.
 
+## Breaking changes in 0.6
+
+- **The model no longer parses expressions.** A calculator turns text into a `Program`
+  (`qmlmathplot.protocol`) and the model consumes it; the UI process does not import sympy.
+  The in-process default (`InlineCalculator`) needs the `calc` extra
+  (`pip install qmlmathplot[calc]`); a host that isolates the calculator injects
+  `ProcessCalculator` — see `examples/process_calculator.py`.
+- `Curve` and `add_curve` are **asynchronous**: shaders arrive with the program. Wait for
+  `shadersChanged`, and read `curve.error` for a failing edit (the previous drawing stays).
+  `Curve.expr` is a deprecated, lazily imported sympy view.
+- Routing is `Program.kind`: `intervals` (compute shader), `adaptive` (CPU `CurvePlotter`),
+  `implicit` (level set). `add_curve("a*x")` reports the parameter error on the curve
+  instead of raising.
+- **Removed:** `Figure`, `Axes`, `FigureCanvasQt`, `qmlmathplot.pyplot`. `MathPlotWidget`
+  stays.
+- **QML:** `import QmlMathPlot 2.0`; `cpuRenderer: true` became `renderMode: "cpu"`
+  (`"auto"` / `"gpu"` / `"cpu"`).
+
 ## Quick start
 
 One line in a QtWidgets layout (least effort):
@@ -49,16 +71,15 @@ 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:
+`add_curve()` (and `Curve.expression`) take the expression as text; a sympy object is also
+accepted and converted to its canonical string once. The model never parses it: a calculator
+turns the text into a `Program` (`kind`, shader sources, `math`/`numpy` programs), so the UI
+process can stay sympy-free. `Curve.expr` still exists as a deprecated, lazily imported sympy
+view for the compatibility layer, and the matplotlib hand-off uses it.
 
 ```python
 curve = plot.add_curve("sin(x)")
-plot.add_curve(sp.diff(sp.sympify(curve.expression, locals={"x": sp.Symbol("x")})), label="f'")
+plot.add_curve(sp.diff(sp.sympify(curve.expression)), label="f'")   # needs the [calc] extra
 ```
 
 `MathPlotWidget` keeps one curve's worth of convenience (`expression`, `error`,
@@ -77,14 +98,14 @@ Standalone window / command line:
 ```
 uv run qmlmathplot "sin(1/x)"                    # equivalent to python examples/minimal.py …
 uv run qmlmathplot --backend d3d11 "sin(1/x)"    # force a specific backend
-python examples/explorer_qtwidgets.py            # function input box + sibling widgets
+python examples/widget_minimal.py               # QtWidgets host
+python examples/process_calculator.py           # calculator in its own process
 ```
 
 The examples live in `examples/`: `minimal.py` is the smallest window;
-`explorer_qtwidgets.py` deliberately puts the plot widget into a "grabby"
-environment (input box, `QScrollArea`, `QSplitter`, overlay) to verify the widgets
-do not fight each other; `explorer_qtquick.py` (plus `explorer_qtquick.qml`) is
-the pure Qt Quick demo.
+`explorer_qtquick.py` (plus `explorer_qtquick.qml`) is the pure Qt Quick demo;
+`process_calculator.py` runs the calculator in its own process and can prove the isolation
+with `--check-isolation`; `widget_minimal.py` embeds `MathPlotWidget` in a QtWidgets layout.
 
 ## Embedding into an app
 
@@ -116,7 +137,7 @@ app.exec()
 ```
 
 ```qml
-import QmlMathPlot 1.0
+import QmlMathPlot 2.0
 
 PlotView {                       // inject a Plot, or let the component create its own
     anchors.fill: parent
@@ -171,74 +192,8 @@ Matplotlib *vocabulary* is kept where it is vocabulary (limits, grid, title, tic
 *mechanism* is refused — no `Figure`/`Axes`/`subplots` in the core (one view per widget, no
 bounded page), no redraw loop (the scene is live), no toolbar and no legend (host chrome), and
 an export is a canvas region at a pixel size rather than a re-rendered page (§9, implemented —
-see *Export* below). A **thin compatibility facade** (`Figure`, `Axes`, `FigureCanvasQt`,
-`qmlmathplot.pyplot`) provides the familiar names for porting scripts; it maps onto the same
-model and refuses the mechanisms that do not fit (see *Matplotlib-style facade* below).
-
-## Matplotlib-style facade
-
-For porting scripts and for code that expects Matplotlib's vocabulary, the package ships a
-**thin** compatibility layer. It maps onto the same `Plot`/`Camera` model and refuses the
-mechanisms that do not fit an infinite, live canvas.
-
-```python
-from qmlmathplot import Figure, FigureCanvasQt
-
-fig = Figure(figsize=(6.4, 4.8))       # stored for the window size only; no page is implied
-ax = fig.gca()                         # exactly one axes per figure
-ax.plot("sin(1/x)", label="sin(1/x)")
-ax.set_xlim(-1, 1)
-ax.set_ylim(-2, 2)
-ax.set_title("sin(1/x)")
-ax.set_xlabel("x")
-ax.set_ylabel("y")
-ax.grid(True)
-ax.set_aspect("equal")
-
-canvas = FigureCanvasQt(fig)           # a QWidget, like MathPlotWidget
-layout.addWidget(canvas)
-canvas.draw()                          # no-op: the Qt scene is already live
-```
-
-The same model through a pyplot-shaped module (global current figure, for scripts and
-notebooks; applications should keep the object API):
-
-```python
-import qmlmathplot.pyplot as plt
-
-plt.figure()
-plt.plot("sin(1/x)")
-plt.xlim(-1, 1)
-plt.title("sin(1/x)")
-plt.xlabel("x")
-plt.grid(True)
-plt.savefig("out.png")                 # Qt raster export
-plt.show()                             # blocks in a script; use block=False in a host
-```
-
-What maps: one figure/one axes (`subplots()` and `subplot(111)`), `plot(expression)`,
-`xlim`/`ylim`, `title`/`xlabel`/`ylabel`, `grid(axis=...)`, `aspect`, `savefig`/`to_image`,
-themes, `legend`, `annotate`/`text`, `axhline`/`axvline`, `set_xticks`/`set_yticks` and
-`tick_params`. `plt.gcf()`/`gca()`/`sca()`/`close()`/`show()` follow Matplotlib's
-current-figure shape.
-
-What is deliberately different:
-
-- **One view per figure.** `subplots(2, 1)`/`add_subplot(211)` raise `NotImplementedError`;
-  several panels are several `Figure` objects in a Qt layout, not a `GridSpec`.
-- **Expressions, not x/y arrays.** `ax.plot("sin(x)")` is native; `ax.plot(x, y)` is refused
-  because the Qt renderer evaluates an expression per pixel. For sampled data use
-  `Plot.to_matplotlib()` (the hand-off), or add a data-series artist.
-- **`draw()` / `draw_idle()` are no-ops.** The scene repaints from model signals; there is no
-  deferred renderer or blitting.
-- **`savefig` is a region at a pixel size**, not a page at a dpi. `width`/`height` are device
-  pixels and `dpi` is a multiplier; `backend="matplotlib"` is the vector route.
-- **Log axes and full annotation styling are not implemented.** `set_xscale()`/`set_yscale()`
-  raise with the reason; annotations support text + a straight arrow + pixel offset, not
-  Matplotlib's bbox/connectionstyle engine.
-- **Themes are per figure**, not `rcParams`; `plt` has no global style state beyond the current
-  figure.
-- **`mpl_connect`/`blit` are absent.** Qt signals are the event system.
+see *Export* below). 0.6 removed the Matplotlib-shaped facade entirely: the model is `Plot` /
+`Camera` / `Curve`, and the optional matplotlib hand-off is `Plot.to_matplotlib()`.
 
 ## Implicit curves
 
@@ -541,20 +496,17 @@ three import QtWidgets lazily, so a pure-QML host never loads it.
 
 | Layer | File | Responsibility |
 |---|---|---|
-| Model | `src/qmlmathplot/model.py` | expression → GLSL (no Qt dependency, unit-testable) |
+| Calculator | `src/qmlmathplot/calc/` | text → `Program` (GLSL, `math` and `numpy` sources); the only code that imports sympy. Qt-free, runs in-process or as `python -m qmlmathplot.calc` |
 | Shaders | `src/qmlmathplot/shaders/` + `shaderbuild.py` | GLSL resources, `@NAME@` substitution, shared `@INCLUDE` blocks, validation (no template strings in Python) |
 | Camera | `src/qmlmathplot/camera.py` | `Camera`: centre / zoom / aspect, the derived ranges, pan/zoom/reset, the nice-number tick algorithm |
 | Input | `src/qmlmathplot/input.py` | `ViewInput`: keyboard switch, pan step, rebindable shortcuts, key matching |
 | Animation | `src/qmlmathplot/animation.py` | `CameraAnimator`: the one eased interpolator behind wheel/keyboard moves |
-| Curves | `src/qmlmathplot/curve.py` | `Curve` (expression → baked `.qsb`, style, error; later edits bake on the thread pool) and `CurveListModel` |
+| Curves | `src/qmlmathplot/curve.py` | `Curve` (requests a `Program`, bakes its GLSL on the thread pool, keeps the last drawing on failure) and `CurveListModel` |
 | Render | `src/qmlmathplot/rhi.py` + `ggb_compute.py` | `CurveRhiItem`: one `QQuickRhiItem` draws every curve in one pass; interval-supported 1-D curves run the GGB path state machine in a compute shader |
 | Path spec | `src/qmlmathplot/ggb_path.py` | The GGB path state machine (topology in, segments out), shared by the CPU sampler and the tests; no interval arithmetic |
-| Reference | `src/qmlmathplot/ggb_reference.py` | CPU sampler (`mpmath.iv`) feeding the shared state machine; also used by the CPU fallback |
-| CPU fallback | `src/qmlmathplot/qml/CpuCurves.qml` + `pathcurve.py` | `view.cpuRenderer = true`: one QPainterPath per curve when RHI is unavailable |
+| Reference | `src/qmlmathplot/ggb_reference.py` | test oracle: CPU sampler (`mpmath.iv`) feeding the shared state machine |
+| CPU fallback | `src/qmlmathplot/qml/CpuCurves.qml` + `pathcurve.py` | `view.renderMode = "cpu"`: one QPainterPath per curve when RHI is unavailable |
 | Plot | `src/qmlmathplot/plot.py` | `Plot`: the camera, the curves and the styling the view binds to |
-| Facade | `src/qmlmathplot/figure.py` | `Figure` / `Axes`: Matplotlib-shaped names over one `Plot` (no Qt beyond the model) |
-| Facade host | `src/qmlmathplot/canvas.py` | `FigureCanvasQt`: a `MathPlotWidget` attached to a `Figure` (QtWidgets, lazy) |
-| Facade scripting | `src/qmlmathplot/pyplot.py` | `qmlmathplot.pyplot`: current figure, `plot`/`xlim`/`show`/`savefig` for scripts |
 | View | `src/qmlmathplot/qml/PlotView.qml` (+ `PlotCurves.qml`, `PlotFurniture.qml`, `PlotInput.qml`, `view.py`) | composition: model injection, camera mapping and keyboard focus; curves, furniture and pointer input live in the three child components (one `QQuickRhiItem` pass for all curves) |
 | Themes | `src/qmlmathplot/themes.py` + `themes/` | the vendored Matplotlib style sheets, resolved onto the `Plot`'s properties |
 | Export | `src/qmlmathplot/export.py` | `Plot.savefig()` / `to_image()`: the canvas region rendered offscreen at a pixel size (QtWidgets is imported lazily) |
@@ -562,7 +514,7 @@ three import QtWidgets lazily, so a pure-QML host never loads it.
 | Bake | `src/qmlmathplot/qsb.py` | GLSL → `.qsb` (PySide6 ships `qsb.exe`), cached by source hash |
 | Widget | `src/qmlmathplot/widget.py` | `MathPlotWidget`: QQuickWidget bridge, drops straight into QtWidgets layouts |
 | Entry | `src/qmlmathplot/app.py` | command line / standalone window (the `qmlmathplot` script, `examples/minimal.py`) |
-| Examples | `examples/` | `minimal.py` (minimal), `explorer_qtwidgets.py` (input box + widget coexistence), `explorer_qtquick.py` (Qt Quick) |
+| Examples | `examples/` | `minimal.py` (standalone window), `explorer_qtquick.py` (Qt Quick), `process_calculator.py` (the process split + `--check-isolation`), `widget_minimal.py` (QtWidgets) |
 
 ## Algorithm (GeoGebra's interval path on the GPU)
 
@@ -596,20 +548,15 @@ same state machine (topology in, screen-space segments out).
    the compute path from the expression). Expressions
    GGB's `IntervalFunctionSupport` rejects — `floor`, `sign`, `Min/Max`, `Piecewise`, and
    dependent quotients such as `x/sqrt(x**2)` (GGB's algebra simplifies it to `sgn`) — use
-   the sampled fragment: arc-length marching, the join invariant, the envelope band and the
-   boundary ray. Implicit curves always use their own level-set shader.
-
-Deliberate deviations: a wrapped pole (`exp(tan(x))`) becomes a connected `[0, +inf]`
-column. The rule is a Nyquist test against half the pole spacing (the distance between two
-poles, derived from the expression's period): below it the column is resolved, so the branch
-that approaches +∞ (the side with the larger neighbour high edge) is drawn and the other
-branch is left to the next column; at or above it the column width cannot guarantee one pole
-per column, and a non-negative, pole-only-domain expression fills the attained half-plane
-uniformly instead of leaving a moiré of spike tops. GGB's conservative connector would
-violate the "no line across a pole" invariant. The CPU sampler (`ggb_reference.py`,
-`mpmath.iv`) cannot express a gap, so its pole columns are path breaks; it feeds the same
-state machine. The deep-`log` view is handled by `drawNormalInfinity`'s on-screen test plus
-the whole-column rule, as before.
+   GGB's classic `CurvePlotter`, ported to `curveplotter.py`: adaptive sampling, continuity
+   checks and a world-space path, stroked by the RHI path pipeline (the CPU owns the path,
+   the GPU owns the stroke). Implicit curves always use their own level-set shader.
+
+Deliberate deviation: `exp(tan(x))` follows GGB's own wrapped-pole behaviour; no special
+fill compensates for it. The CPU sampler (`ggb_reference.py`, `mpmath.iv`) cannot express a
+gap, so its pole columns are path breaks; it feeds the same `ggb_path` state machine. The
+deep-`log` view is handled by `drawNormalInfinity`'s on-screen test plus the whole-column
+rule.
 
 
 ## Tests
@@ -622,11 +569,11 @@ uv run ruff check src tests examples   # bug-level lint (undefined names, unused
 ```
 
 - `test_model.py`: GLSL generation (small integer powers as repeated
-  multiplication, avoiding `pow(x, y)`'s undefined behaviour for x<0), shader
-  injection (including the camera uniform and the mapping), and the camera math
+  multiplication, avoiding `pow(x, y)`'s undefined behaviour for x<0), domain analysis,
+  and the camera math
   (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
+- `test_curve.py`: a failed expression keeps the last working expression, the style
   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
@@ -641,8 +588,8 @@ uv run ruff check src tests examples   # bug-level lint (undefined names, unused
   matplotlib's default style, the limits are forwarded to the camera, and a theme applies
   (and re-applies as a reset) while an unknown name is rejected.
 - `test_themes.py`: the vendored style sheets resolve to this library's properties.
-- `test_overlay.py`: annotations (`annotate`/`text`), horizontal/vertical guides, legend and
-  custom ticks, the `Axes`/`pyplot` forwarding, and the matplotlib hand-off mapping.
+- `test_overlay.py`: annotations, horizontal/vertical guides, legend and custom ticks, and
+  the matplotlib hand-off mapping.
 - `test_qsb_cache.py`: the cache location/info/clear API and the age + LRU prune; unrelated
   files in the temp directory are not touched.
 - `test_shader_bake.py`: the stage of a baked `.qsb` must match its purpose, and
@@ -670,10 +617,6 @@ uv run ruff check src tests examples   # bug-level lint (undefined names, unused
   extra.
 - `test_async_bake.py`: a later expression assignment bakes on the thread pool, a stale bake
   is discarded, and a failed bake keeps the drawn curve.
-- `test_compat.py`: the Matplotlib-shaped facade — expressions (and the refusal of x/y arrays),
-  limits/title/labels/grid/aspect, the single-axes rule, `pyplot` current-figure semantics,
-  `FigureCanvasQt` rendering and export, and that importing `qmlmathplot` does not load
-  QtWidgets.
 - `test_export.py`: `to_image()`/`savefig()` — the image is exactly the requested device size
   (`dpi` multiplies it), the no-argument form reproduces the live centre and scale, the three
   `adjustable` modes reconcile range and size as documented (a world 45-degree line stays at 45
@@ -750,7 +693,7 @@ Startup to the first frame is about **230 ms**, attributed as follows
 | Qt graphics device init (RHI/D3D11) | **~160 ms** | exactly what the first window's `show→expose` costs; a **bare window (no ShaderEffect) is the same**, so it is not the shader's fault |
 | Window creation + QML load + first frame | ~80 ms | from the second window on (device already created) this is the order of magnitude |
 | `qsb` bake | 0 / ~126 ms | cached by source hash: 0.15 ms on a hit; later `expression` assignments bake on Qt's thread pool, so only the first curve construction blocks (tests force the synchronous path) |
-| Expression analysis (sympy) | 0.6~3 ms | `unbounded_edges` only analyses **polynomial** boundaries (`tan(x)`'s `cos(x)=0` takes 94 ms via solve+limit, while tan diverges fast and sampling is naturally deep enough, so that ray is not needed) |
+| Expression analysis (sympy) | 0.6~3 ms | domain/pole analysis for the interval and implicit renderers; unsupported 1-D expressions go to the CPU CurvePlotter |
 
 Per-frame grab cycles (900×600, `grabToImage` — frame + readback, so an upper bound on
 the GPU cost), steady state on the same window: `sin(1/x)` default **13.6 ms**, `tan(x)`

{qmlmathplot-0.5.0 → qmlmathplot-0.6.0}/README.md

@@ -12,6 +12,24 @@ The state is a **camera on an infinite canvas**: a `Plot` holds a `Camera` (wher
 and a list of `Curve`s (what is drawn), and the QML component `PlotView` binds to it. Several
 panels are several `Plot`s in a Qt layout — there is no figure, no axes box and no page.
 
+## Breaking changes in 0.6
+
+- **The model no longer parses expressions.** A calculator turns text into a `Program`
+  (`qmlmathplot.protocol`) and the model consumes it; the UI process does not import sympy.
+  The in-process default (`InlineCalculator`) needs the `calc` extra
+  (`pip install qmlmathplot[calc]`); a host that isolates the calculator injects
+  `ProcessCalculator` — see `examples/process_calculator.py`.
+- `Curve` and `add_curve` are **asynchronous**: shaders arrive with the program. Wait for
+  `shadersChanged`, and read `curve.error` for a failing edit (the previous drawing stays).
+  `Curve.expr` is a deprecated, lazily imported sympy view.
+- Routing is `Program.kind`: `intervals` (compute shader), `adaptive` (CPU `CurvePlotter`),
+  `implicit` (level set). `add_curve("a*x")` reports the parameter error on the curve
+  instead of raising.
+- **Removed:** `Figure`, `Axes`, `FigureCanvasQt`, `qmlmathplot.pyplot`. `MathPlotWidget`
+  stays.
+- **QML:** `import QmlMathPlot 2.0`; `cpuRenderer: true` became `renderMode: "cpu"`
+  (`"auto"` / `"gpu"` / `"cpu"`).
+
 ## Quick start
 
 One line in a QtWidgets layout (least effort):
@@ -33,16 +51,15 @@ 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:
+`add_curve()` (and `Curve.expression`) take the expression as text; a sympy object is also
+accepted and converted to its canonical string once. The model never parses it: a calculator
+turns the text into a `Program` (`kind`, shader sources, `math`/`numpy` programs), so the UI
+process can stay sympy-free. `Curve.expr` still exists as a deprecated, lazily imported sympy
+view for the compatibility layer, and the matplotlib hand-off uses it.
 
 ```python
 curve = plot.add_curve("sin(x)")
-plot.add_curve(sp.diff(sp.sympify(curve.expression, locals={"x": sp.Symbol("x")})), label="f'")
+plot.add_curve(sp.diff(sp.sympify(curve.expression)), label="f'")   # needs the [calc] extra
 ```
 
 `MathPlotWidget` keeps one curve's worth of convenience (`expression`, `error`,
@@ -61,14 +78,14 @@ Standalone window / command line:
 ```
 uv run qmlmathplot "sin(1/x)"                    # equivalent to python examples/minimal.py …
 uv run qmlmathplot --backend d3d11 "sin(1/x)"    # force a specific backend
-python examples/explorer_qtwidgets.py            # function input box + sibling widgets
+python examples/widget_minimal.py               # QtWidgets host
+python examples/process_calculator.py           # calculator in its own process
 ```
 
 The examples live in `examples/`: `minimal.py` is the smallest window;
-`explorer_qtwidgets.py` deliberately puts the plot widget into a "grabby"
-environment (input box, `QScrollArea`, `QSplitter`, overlay) to verify the widgets
-do not fight each other; `explorer_qtquick.py` (plus `explorer_qtquick.qml`) is
-the pure Qt Quick demo.
+`explorer_qtquick.py` (plus `explorer_qtquick.qml`) is the pure Qt Quick demo;
+`process_calculator.py` runs the calculator in its own process and can prove the isolation
+with `--check-isolation`; `widget_minimal.py` embeds `MathPlotWidget` in a QtWidgets layout.
 
 ## Embedding into an app
 
@@ -100,7 +117,7 @@ app.exec()
 ```
 
 ```qml
-import QmlMathPlot 1.0
+import QmlMathPlot 2.0
 
 PlotView {                       // inject a Plot, or let the component create its own
     anchors.fill: parent
@@ -155,74 +172,8 @@ Matplotlib *vocabulary* is kept where it is vocabulary (limits, grid, title, tic
 *mechanism* is refused — no `Figure`/`Axes`/`subplots` in the core (one view per widget, no
 bounded page), no redraw loop (the scene is live), no toolbar and no legend (host chrome), and
 an export is a canvas region at a pixel size rather than a re-rendered page (§9, implemented —
-see *Export* below). A **thin compatibility facade** (`Figure`, `Axes`, `FigureCanvasQt`,
-`qmlmathplot.pyplot`) provides the familiar names for porting scripts; it maps onto the same
-model and refuses the mechanisms that do not fit (see *Matplotlib-style facade* below).
-
-## Matplotlib-style facade
-
-For porting scripts and for code that expects Matplotlib's vocabulary, the package ships a
-**thin** compatibility layer. It maps onto the same `Plot`/`Camera` model and refuses the
-mechanisms that do not fit an infinite, live canvas.
-
-```python
-from qmlmathplot import Figure, FigureCanvasQt
-
-fig = Figure(figsize=(6.4, 4.8))       # stored for the window size only; no page is implied
-ax = fig.gca()                         # exactly one axes per figure
-ax.plot("sin(1/x)", label="sin(1/x)")
-ax.set_xlim(-1, 1)
-ax.set_ylim(-2, 2)
-ax.set_title("sin(1/x)")
-ax.set_xlabel("x")
-ax.set_ylabel("y")
-ax.grid(True)
-ax.set_aspect("equal")
-
-canvas = FigureCanvasQt(fig)           # a QWidget, like MathPlotWidget
-layout.addWidget(canvas)
-canvas.draw()                          # no-op: the Qt scene is already live
-```
-
-The same model through a pyplot-shaped module (global current figure, for scripts and
-notebooks; applications should keep the object API):
-
-```python
-import qmlmathplot.pyplot as plt
-
-plt.figure()
-plt.plot("sin(1/x)")
-plt.xlim(-1, 1)
-plt.title("sin(1/x)")
-plt.xlabel("x")
-plt.grid(True)
-plt.savefig("out.png")                 # Qt raster export
-plt.show()                             # blocks in a script; use block=False in a host
-```
-
-What maps: one figure/one axes (`subplots()` and `subplot(111)`), `plot(expression)`,
-`xlim`/`ylim`, `title`/`xlabel`/`ylabel`, `grid(axis=...)`, `aspect`, `savefig`/`to_image`,
-themes, `legend`, `annotate`/`text`, `axhline`/`axvline`, `set_xticks`/`set_yticks` and
-`tick_params`. `plt.gcf()`/`gca()`/`sca()`/`close()`/`show()` follow Matplotlib's
-current-figure shape.
-
-What is deliberately different:
-
-- **One view per figure.** `subplots(2, 1)`/`add_subplot(211)` raise `NotImplementedError`;
-  several panels are several `Figure` objects in a Qt layout, not a `GridSpec`.
-- **Expressions, not x/y arrays.** `ax.plot("sin(x)")` is native; `ax.plot(x, y)` is refused
-  because the Qt renderer evaluates an expression per pixel. For sampled data use
-  `Plot.to_matplotlib()` (the hand-off), or add a data-series artist.
-- **`draw()` / `draw_idle()` are no-ops.** The scene repaints from model signals; there is no
-  deferred renderer or blitting.
-- **`savefig` is a region at a pixel size**, not a page at a dpi. `width`/`height` are device
-  pixels and `dpi` is a multiplier; `backend="matplotlib"` is the vector route.
-- **Log axes and full annotation styling are not implemented.** `set_xscale()`/`set_yscale()`
-  raise with the reason; annotations support text + a straight arrow + pixel offset, not
-  Matplotlib's bbox/connectionstyle engine.
-- **Themes are per figure**, not `rcParams`; `plt` has no global style state beyond the current
-  figure.
-- **`mpl_connect`/`blit` are absent.** Qt signals are the event system.
+see *Export* below). 0.6 removed the Matplotlib-shaped facade entirely: the model is `Plot` /
+`Camera` / `Curve`, and the optional matplotlib hand-off is `Plot.to_matplotlib()`.
 
 ## Implicit curves
 
@@ -525,20 +476,17 @@ three import QtWidgets lazily, so a pure-QML host never loads it.
 
 | Layer | File | Responsibility |
 |---|---|---|
-| Model | `src/qmlmathplot/model.py` | expression → GLSL (no Qt dependency, unit-testable) |
+| Calculator | `src/qmlmathplot/calc/` | text → `Program` (GLSL, `math` and `numpy` sources); the only code that imports sympy. Qt-free, runs in-process or as `python -m qmlmathplot.calc` |
 | Shaders | `src/qmlmathplot/shaders/` + `shaderbuild.py` | GLSL resources, `@NAME@` substitution, shared `@INCLUDE` blocks, validation (no template strings in Python) |
 | Camera | `src/qmlmathplot/camera.py` | `Camera`: centre / zoom / aspect, the derived ranges, pan/zoom/reset, the nice-number tick algorithm |
 | Input | `src/qmlmathplot/input.py` | `ViewInput`: keyboard switch, pan step, rebindable shortcuts, key matching |
 | Animation | `src/qmlmathplot/animation.py` | `CameraAnimator`: the one eased interpolator behind wheel/keyboard moves |
-| Curves | `src/qmlmathplot/curve.py` | `Curve` (expression → baked `.qsb`, style, error; later edits bake on the thread pool) and `CurveListModel` |
+| Curves | `src/qmlmathplot/curve.py` | `Curve` (requests a `Program`, bakes its GLSL on the thread pool, keeps the last drawing on failure) and `CurveListModel` |
 | Render | `src/qmlmathplot/rhi.py` + `ggb_compute.py` | `CurveRhiItem`: one `QQuickRhiItem` draws every curve in one pass; interval-supported 1-D curves run the GGB path state machine in a compute shader |
 | Path spec | `src/qmlmathplot/ggb_path.py` | The GGB path state machine (topology in, segments out), shared by the CPU sampler and the tests; no interval arithmetic |
-| Reference | `src/qmlmathplot/ggb_reference.py` | CPU sampler (`mpmath.iv`) feeding the shared state machine; also used by the CPU fallback |
-| CPU fallback | `src/qmlmathplot/qml/CpuCurves.qml` + `pathcurve.py` | `view.cpuRenderer = true`: one QPainterPath per curve when RHI is unavailable |
+| Reference | `src/qmlmathplot/ggb_reference.py` | test oracle: CPU sampler (`mpmath.iv`) feeding the shared state machine |
+| CPU fallback | `src/qmlmathplot/qml/CpuCurves.qml` + `pathcurve.py` | `view.renderMode = "cpu"`: one QPainterPath per curve when RHI is unavailable |
 | Plot | `src/qmlmathplot/plot.py` | `Plot`: the camera, the curves and the styling the view binds to |
-| Facade | `src/qmlmathplot/figure.py` | `Figure` / `Axes`: Matplotlib-shaped names over one `Plot` (no Qt beyond the model) |
-| Facade host | `src/qmlmathplot/canvas.py` | `FigureCanvasQt`: a `MathPlotWidget` attached to a `Figure` (QtWidgets, lazy) |
-| Facade scripting | `src/qmlmathplot/pyplot.py` | `qmlmathplot.pyplot`: current figure, `plot`/`xlim`/`show`/`savefig` for scripts |
 | View | `src/qmlmathplot/qml/PlotView.qml` (+ `PlotCurves.qml`, `PlotFurniture.qml`, `PlotInput.qml`, `view.py`) | composition: model injection, camera mapping and keyboard focus; curves, furniture and pointer input live in the three child components (one `QQuickRhiItem` pass for all curves) |
 | Themes | `src/qmlmathplot/themes.py` + `themes/` | the vendored Matplotlib style sheets, resolved onto the `Plot`'s properties |
 | Export | `src/qmlmathplot/export.py` | `Plot.savefig()` / `to_image()`: the canvas region rendered offscreen at a pixel size (QtWidgets is imported lazily) |
@@ -546,7 +494,7 @@ three import QtWidgets lazily, so a pure-QML host never loads it.
 | Bake | `src/qmlmathplot/qsb.py` | GLSL → `.qsb` (PySide6 ships `qsb.exe`), cached by source hash |
 | Widget | `src/qmlmathplot/widget.py` | `MathPlotWidget`: QQuickWidget bridge, drops straight into QtWidgets layouts |
 | Entry | `src/qmlmathplot/app.py` | command line / standalone window (the `qmlmathplot` script, `examples/minimal.py`) |
-| Examples | `examples/` | `minimal.py` (minimal), `explorer_qtwidgets.py` (input box + widget coexistence), `explorer_qtquick.py` (Qt Quick) |
+| Examples | `examples/` | `minimal.py` (standalone window), `explorer_qtquick.py` (Qt Quick), `process_calculator.py` (the process split + `--check-isolation`), `widget_minimal.py` (QtWidgets) |
 
 ## Algorithm (GeoGebra's interval path on the GPU)
 
@@ -580,20 +528,15 @@ same state machine (topology in, screen-space segments out).
    the compute path from the expression). Expressions
    GGB's `IntervalFunctionSupport` rejects — `floor`, `sign`, `Min/Max`, `Piecewise`, and
    dependent quotients such as `x/sqrt(x**2)` (GGB's algebra simplifies it to `sgn`) — use
-   the sampled fragment: arc-length marching, the join invariant, the envelope band and the
-   boundary ray. Implicit curves always use their own level-set shader.
-
-Deliberate deviations: a wrapped pole (`exp(tan(x))`) becomes a connected `[0, +inf]`
-column. The rule is a Nyquist test against half the pole spacing (the distance between two
-poles, derived from the expression's period): below it the column is resolved, so the branch
-that approaches +∞ (the side with the larger neighbour high edge) is drawn and the other
-branch is left to the next column; at or above it the column width cannot guarantee one pole
-per column, and a non-negative, pole-only-domain expression fills the attained half-plane
-uniformly instead of leaving a moiré of spike tops. GGB's conservative connector would
-violate the "no line across a pole" invariant. The CPU sampler (`ggb_reference.py`,
-`mpmath.iv`) cannot express a gap, so its pole columns are path breaks; it feeds the same
-state machine. The deep-`log` view is handled by `drawNormalInfinity`'s on-screen test plus
-the whole-column rule, as before.
+   GGB's classic `CurvePlotter`, ported to `curveplotter.py`: adaptive sampling, continuity
+   checks and a world-space path, stroked by the RHI path pipeline (the CPU owns the path,
+   the GPU owns the stroke). Implicit curves always use their own level-set shader.
+
+Deliberate deviation: `exp(tan(x))` follows GGB's own wrapped-pole behaviour; no special
+fill compensates for it. The CPU sampler (`ggb_reference.py`, `mpmath.iv`) cannot express a
+gap, so its pole columns are path breaks; it feeds the same `ggb_path` state machine. The
+deep-`log` view is handled by `drawNormalInfinity`'s on-screen test plus the whole-column
+rule.
 
 
 ## Tests
@@ -606,11 +549,11 @@ uv run ruff check src tests examples   # bug-level lint (undefined names, unused
 ```
 
 - `test_model.py`: GLSL generation (small integer powers as repeated
-  multiplication, avoiding `pow(x, y)`'s undefined behaviour for x<0), shader
-  injection (including the camera uniform and the mapping), and the camera math
+  multiplication, avoiding `pow(x, y)`'s undefined behaviour for x<0), domain analysis,
+  and the camera math
   (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
+- `test_curve.py`: a failed expression keeps the last working expression, the style
   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
@@ -625,8 +568,8 @@ uv run ruff check src tests examples   # bug-level lint (undefined names, unused
   matplotlib's default style, the limits are forwarded to the camera, and a theme applies
   (and re-applies as a reset) while an unknown name is rejected.
 - `test_themes.py`: the vendored style sheets resolve to this library's properties.
-- `test_overlay.py`: annotations (`annotate`/`text`), horizontal/vertical guides, legend and
-  custom ticks, the `Axes`/`pyplot` forwarding, and the matplotlib hand-off mapping.
+- `test_overlay.py`: annotations, horizontal/vertical guides, legend and custom ticks, and
+  the matplotlib hand-off mapping.
 - `test_qsb_cache.py`: the cache location/info/clear API and the age + LRU prune; unrelated
   files in the temp directory are not touched.
 - `test_shader_bake.py`: the stage of a baked `.qsb` must match its purpose, and
@@ -654,10 +597,6 @@ uv run ruff check src tests examples   # bug-level lint (undefined names, unused
   extra.
 - `test_async_bake.py`: a later expression assignment bakes on the thread pool, a stale bake
   is discarded, and a failed bake keeps the drawn curve.
-- `test_compat.py`: the Matplotlib-shaped facade — expressions (and the refusal of x/y arrays),
-  limits/title/labels/grid/aspect, the single-axes rule, `pyplot` current-figure semantics,
-  `FigureCanvasQt` rendering and export, and that importing `qmlmathplot` does not load
-  QtWidgets.
 - `test_export.py`: `to_image()`/`savefig()` — the image is exactly the requested device size
   (`dpi` multiplies it), the no-argument form reproduces the live centre and scale, the three
   `adjustable` modes reconcile range and size as documented (a world 45-degree line stays at 45
@@ -734,7 +673,7 @@ Startup to the first frame is about **230 ms**, attributed as follows
 | Qt graphics device init (RHI/D3D11) | **~160 ms** | exactly what the first window's `show→expose` costs; a **bare window (no ShaderEffect) is the same**, so it is not the shader's fault |
 | Window creation + QML load + first frame | ~80 ms | from the second window on (device already created) this is the order of magnitude |
 | `qsb` bake | 0 / ~126 ms | cached by source hash: 0.15 ms on a hit; later `expression` assignments bake on Qt's thread pool, so only the first curve construction blocks (tests force the synchronous path) |
-| Expression analysis (sympy) | 0.6~3 ms | `unbounded_edges` only analyses **polynomial** boundaries (`tan(x)`'s `cos(x)=0` takes 94 ms via solve+limit, while tan diverges fast and sampling is naturally deep enough, so that ray is not needed) |
+| Expression analysis (sympy) | 0.6~3 ms | domain/pole analysis for the interval and implicit renderers; unsupported 1-D expressions go to the CPU CurvePlotter |
 
 Per-frame grab cycles (900×600, `grabToImage` — frame + readback, so an upper bound on
 the GPU cost), steady state on the same window: `sin(1/x)` default **13.6 ms**, `tan(x)`

{qmlmathplot-0.5.0 → qmlmathplot-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qmlmathplot"
-version = "0.5.0"
+version = "0.6.0"
 description = "Embeddable function plotter for Qt Quick / QtWidgets (implicit per-pixel drawing, MVVM)"
 readme = "README.md"
 license = "GPL-3.0-only"
@@ -10,8 +10,8 @@ license-files = [
 ]
 requires-python = ">=3.11"
 dependencies = [
-    "sympy>=1.14",
     "PySide6>=6.12",
+    "numpy>=1.26",
 ]
 
 [[project.authors]]
@@ -19,7 +19,9 @@ name = "I-AM-A-NOOB"
 email = "suzc08@outlook.com"
 
 [project.optional-dependencies]
+calc = ["sympy>=1.14"]
 matplotlib = ["matplotlib>=3.8"]
+mpl = ["matplotlib>=3.8"]
 
 [project.scripts]
 qmlmathplot = "qmlmathplot.app:main"
@@ -32,6 +34,7 @@ build-backend = "uv_build"
 dev = [
     "pytest>=9.1.1",
     "matplotlib>=3.8",
+    "sympy>=1.14",
     "ruff>=0.9",
 ]
 

{qmlmathplot-0.5.0 → qmlmathplot-0.6.0}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "qmlmathplot"
-version = "0.5.0"
+version = "0.6.0"
 description = "Embeddable function plotter for Qt Quick / QtWidgets (implicit per-pixel drawing, MVVM)"
 readme = "README.md"
 license = "GPL-3.0-only"
@@ -10,14 +10,19 @@ authors = [
 ]
 requires-python = ">=3.11"
 dependencies = [
-    "sympy>=1.14",
     "PySide6>=6.12",
+    "numpy>=1.26",
 ]
 
 [project.optional-dependencies]
+# The calculator is the only part that needs sympy; install it for the in-process
+# calculator and the worker (`python -m qmlmathplot.calc`). A host that isolates the
+# calculator in another process does not need it in the UI environment.
+calc = ["sympy>=1.14"]
 # The matplotlib hand-off (Plot.to_matplotlib / savefig(backend="matplotlib")) is optional:
 # nothing in the package imports matplotlib until that path is used.
 matplotlib = ["matplotlib>=3.8"]
+mpl = ["matplotlib>=3.8"]
 
 [project.scripts]
 qmlmathplot = "qmlmathplot.app:main"
@@ -30,6 +35,7 @@ build-backend = "uv_build"
 dev = [
     "pytest>=9.1.1",
     "matplotlib>=3.8",      # the hand-off tests need it (the feature itself stays optional)
+    "sympy>=1.14",          # the calculator implementation and its oracles
     "ruff>=0.9",
 ]