qmlmathplot 0.4.2__tar.gz → 0.4.4__tar.gz

{qmlmathplot-0.4.2 → qmlmathplot-0.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qmlmathplot
-Version: 0.4.2
+Version: 0.4.4
 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>
@@ -281,8 +281,11 @@ corner is in the domain and no pole factor changes sign between them; the edge c
 interpolated and the cell's contour segment is stroked (the saddle case is paired using the cell
 centre's sign). The first-order/Newton path still supplies the sub-pixel width; the cell term
 adds the coverage of a thin or tangent branch whose centre projection fails. A **singular cell**
-(`|Fx| + |Fy| < 1e-3` in world units, plus `|F| < 0.05`) gets a small disc, so an isolated point
-such as `x**2 + y**2 = 0` is not left to the projection alone.
+(`|Fx| + |Fy| < 1e-3` in world units, `|F| < 0.05`, **and** `|F| < R·|grad F|` in pixels) gets
+a small disc, so an isolated point such as `x**2 + y**2 = 0` is not left to the projection alone.
+The last test is the scale-invariant one: it requires the point to be on the set to first order,
+so a scaled expression such as `(x+y)/(x·y)` — whose F and gradient are tiny far from its line —
+no longer fills whole quadrants with the disc.
 
 Still not ported: GGB's Bernstein subdivision (**polynomial-only**), its adaptive quad-tree
 refinement and the `ContourAssembler`/`ContourLinker` (they exist to produce a selectable vector

{qmlmathplot-0.4.2 → qmlmathplot-0.4.4}/README.md

@@ -268,8 +268,11 @@ corner is in the domain and no pole factor changes sign between them; the edge c
 interpolated and the cell's contour segment is stroked (the saddle case is paired using the cell
 centre's sign). The first-order/Newton path still supplies the sub-pixel width; the cell term
 adds the coverage of a thin or tangent branch whose centre projection fails. A **singular cell**
-(`|Fx| + |Fy| < 1e-3` in world units, plus `|F| < 0.05`) gets a small disc, so an isolated point
-such as `x**2 + y**2 = 0` is not left to the projection alone.
+(`|Fx| + |Fy| < 1e-3` in world units, `|F| < 0.05`, **and** `|F| < R·|grad F|` in pixels) gets
+a small disc, so an isolated point such as `x**2 + y**2 = 0` is not left to the projection alone.
+The last test is the scale-invariant one: it requires the point to be on the set to first order,
+so a scaled expression such as `(x+y)/(x·y)` — whose F and gradient are tiny far from its line —
+no longer fills whole quadrants with the disc.
 
 Still not ported: GGB's Bernstein subdivision (**polynomial-only**), its adaptive quad-tree
 refinement and the `ContourAssembler`/`ContourLinker` (they exist to produce a selectable vector

{qmlmathplot-0.4.2 → qmlmathplot-0.4.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "qmlmathplot"
-version = "0.4.2"
+version = "0.4.4"
 description = "Embeddable function plotter for Qt Quick / QtWidgets (implicit per-pixel drawing, MVVM)"
 readme = "README.md"
 requires-python = ">=3.11"

{qmlmathplot-0.4.2 → qmlmathplot-0.4.4}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "qmlmathplot"
-version = "0.4.2"
+version = "0.4.4"
 description = "Embeddable function plotter for Qt Quick / QtWidgets (implicit per-pixel drawing, MVVM)"
 readme = "README.md"
 authors = [

{qmlmathplot-0.4.2 → qmlmathplot-0.4.4}/src/qmlmathplot/model.py

@@ -358,6 +358,12 @@ float _seg_dist(vec2 p, vec2 a, vec2 b) {
     return length(p - (a + t * ab));
 }
 
+// A vertical interval [lo, hi] at this pixel's y, with a one-pixel feather at its edges.
+float _span_cov(float y, float lo, float hi, float sy) {
+    return clamp((y - lo) * sy + 1.0, 0.0, 1.0)
+         * clamp((hi - y) * sy + 1.0, 0.0, 1.0);
+}
+
 // GLSL pow() is undefined for a negative base; odd roots are real there (x**(1/3)).
 float _real_pow(float v, float p) {
     return v < 0.0 ? -pow(-v, p) : pow(v, p);
@@ -471,6 +477,11 @@ void main() {
         }
     }
 
+    // A pole inside this column is a jump, even when a monotone map such as exp()
+    // turns the two one-sided limits into a connected range (exp(tan(x)): 0 and +inf).
+    // The interval paths below would bridge that jump with a vertical connector.
+    bool pole_col = HAS_SIGN_POLE && POLE(x - 0.5 * dx) * POLE(x + 0.5 * dx) <= 0.0;
+
     // ---- fixed-x sub-pixel polyline (GeoGebra's sampled polyline, on the GPU) ----
     // 14 samples over ±2 columns (0.286-column spacing) cover the perpendicular foot even at
     // 89°: a ±1-column window lost 42 % of the width at 84°. Joining the samples gives a
@@ -488,9 +499,28 @@ void main() {
     bool prev_ok = false;
     float prev_d = 0.0;
     bool prev_d_ok = false;
+    int pole_crossings = 0;
+#if HAS_SIGN_POLE
+    if (abs(camera.z) > 1.0) {
+        float pp = POLE(x - 2.0 * dx);
+        for (int pi = 0; pi < 32; pi++) {
+            float tt = -2.0 + 4.0 * fract((float(pi) + 0.5) * 0.61803398875);
+            float px = x + tt * dx;
+            float pv = POLE(px);
+            if (pp * pv <= 0.0) pole_crossings += 1;
+            pp = pv;
+        }
+    }
+#endif
+    float prev_pole = 1.0;
     for (int i = 0; i < NS; i++) {
         float t = -2.0 + (float(i) + 0.5) * (4.0 / float(NS));
         float xi = x + t * dx;
+        float pv = POLE(xi);
+        if (i > 0 && prev_pole * pv <= 0.0) {
+            pole_crossings += 1;
+        }
+        prev_pole = pv;
         float v = 1e30;
         if (DOMS(xi)) {
             v = F(xi);
@@ -527,14 +557,61 @@ void main() {
         }
     }
 
+    // A single column path, as GeoGebra's IntervalPath: every resolvable connected column
+    // contributes one chord from its left-edge value to its right-edge value. The sampled
+    // polyline is only a fallback for columns where the interval cannot be oriented.
+    bool use_path = col.kind == IK_CONNECTED && col.lo > -IINF && col.hi < IINF
+                 && !pole_col && !HAS_DEPENDENT_QUOTIENT && sturns < 1.5;
+    bool inc = true;
+    if (use_path) {
+        int fi = -1;
+        int li = -1;
+        for (int i = 0; i < NS; i++) {
+            if (ok[i]) {
+                if (fi < 0) fi = i;
+                li = i;
+            }
+        }
+        if (fi >= 0 && li > fi && smp[li] < smp[fi]) {
+            inc = false;
+        }
+        float y0 = inc ? col.lo : col.hi;
+        float y1 = inc ? col.hi : col.lo;
+        pmin = min(pmin, _seg_dist(vec2(x * sx, y * sy),
+            vec2((x - 0.5 * dx) * sx, y0 * sy),
+            vec2((x + 0.5 * dx) * sx, y1 * sy)));
+    }
+
+    // Neighbour joins: the chord above ends at this column's edges; the previous/next
+    // columns' chords end at the same boundary but from their own interval. A short
+    // boundary join removes the 1-px gap/step at the hand-off.
+    if (use_path && (col.hi - col.lo) * sy > 2.0 * R) {
+        IVal prevc = FI(x - 1.5 * dx, x - 0.5 * dx);
+        IVal nextc = FI(x + 0.5 * dx, x + 1.5 * dx);
+        if (prevc.kind == IK_CONNECTED && prevc.lo > -IINF && prevc.hi < IINF) {
+            float left = inc ? prevc.hi : prevc.lo;
+            float here = inc ? col.lo : col.hi;
+            pmin = min(pmin, _seg_dist(vec2(x * sx, y * sy),
+                vec2((x - 0.5 * dx) * sx, left * sy),
+                vec2((x - 0.5 * dx) * sx, here * sy)));
+        }
+        if (nextc.kind == IK_CONNECTED && nextc.lo > -IINF && nextc.hi < IINF) {
+            float here = inc ? col.hi : col.lo;
+            float right = inc ? nextc.lo : nextc.hi;
+            pmin = min(pmin, _seg_dist(vec2(x * sx, y * sy),
+                vec2((x + 0.5 * dx) * sx, here * sy),
+                vec2((x + 0.5 * dx) * sx, right * sy)));
+        }
+    }
+
     // GeoGebra's unbounded-column rule (IntervalPath.drawNormalInfinity): only when the
     // finite bound itself is on screen. The segment uses the column's left edge and middle.
-    if (col.kind == IK_CONNECTED && col.lo <= -IINF
+    if (!pole_col && col.kind == IK_CONNECTED && col.lo <= -IINF
             && col.hi >= y_bot && col.hi <= y_top) {
         pmin = min(pmin, _seg_dist(vec2(x * sx, y * sy),
             vec2((x - 0.5 * dx) * sx, col.hi * sy), vec2(x * sx, y_bot * sy)));
     }
-    if (col.kind == IK_CONNECTED && col.hi >= IINF
+    if (!pole_col && col.kind == IK_CONNECTED && col.hi >= IINF
             && col.lo >= y_bot && col.lo <= y_top) {
         pmin = min(pmin, _seg_dist(vec2(x * sx, y * sy),
             vec2((x - 0.5 * dx) * sx, col.lo * sy), vec2(x * sx, y_top * sy)));
@@ -543,11 +620,11 @@ void main() {
     // covers it (the visible curve lies inside this x column). GeoGebra's normal-infinity
     // branch declines to draw here; the column is effectively whole (drawWhole), so a
     // vertical segment at the left edge is GGB's own rule for that topology.
-    if (col.kind == IK_CONNECTED && col.lo <= -IINF && col.hi > y_top) {
+    if (!pole_col && col.kind == IK_CONNECTED && col.lo <= -IINF && col.hi > y_top) {
         pmin = min(pmin, _seg_dist(vec2(x * sx, y * sy),
             vec2((x - 0.5 * dx) * sx, y_bot * sy), vec2((x - 0.5 * dx) * sx, y_top * sy)));
     }
-    if (col.kind == IK_CONNECTED && col.hi >= IINF && col.lo < y_bot) {
+    if (!pole_col && col.kind == IK_CONNECTED && col.hi >= IINF && col.lo < y_bot) {
         pmin = min(pmin, _seg_dist(vec2(x * sx, y * sy),
             vec2((x - 0.5 * dx) * sx, y_bot * sy), vec2((x - 0.5 * dx) * sx, y_top * sy)));
     }
@@ -561,11 +638,15 @@ void main() {
             pmin = min(pmin, _seg_dist(vec2(x * sx, y * sy),
                 vec2((x + 0.5 * dx) * sx, y_top * sy),
                 vec2((x + 0.5 * dx) * sx, col.hi * sy)));
+            pmin = min(pmin, _seg_dist(vec2(x * sx, y * sy),
+                vec2(x * sx, y_top * sy), vec2(x * sx, col.hi * sy)));
         }
         if (col.hi > y_bot) {
             pmin = min(pmin, _seg_dist(vec2(x * sx, y * sy),
                 vec2((x - 0.5 * dx) * sx, y_bot * sy),
                 vec2((x - 0.5 * dx) * sx, col.lo * sy)));
+            pmin = min(pmin, _seg_dist(vec2(x * sx, y * sy),
+                vec2(x * sx, y_bot * sy), vec2(x * sx, col.lo * sy)));
         }
     }
 
@@ -573,6 +654,8 @@ void main() {
     if (col.kind == IK_WHOLE && FILL_WHOLE) {
         pmin = min(pmin, _seg_dist(vec2(x * sx, y * sy),
             vec2((x - 0.5 * dx) * sx, y_bot * sy), vec2((x - 0.5 * dx) * sx, y_top * sy)));
+        pmin = min(pmin, _seg_dist(vec2(x * sx, y * sy),
+            vec2(x * sx, y_bot * sy), vec2(x * sx, y_top * sy)));
     }
 
     float band_cov = 0.0;
@@ -612,7 +695,22 @@ void main() {
     if (HAS_DEPENDENT_QUOTIENT && !FILL_WHOLE) {
         band_cov = 0.0;   // dependency overestimation: the polyline draws the real branches
     }
-    float cov = max(band_cov, clamp(R - pmin, 0.0, 1.0));
+    float dense = 0.0;
+    if (HAS_SIGN_POLE && pole_crossings >= 1 && abs(camera.z) > 1.0
+            && col.kind != IK_EMPTY) {
+        // Several poles inside the sampling window: the column is undersampled, so fill its
+        // *attained* y interval instead of drawing one branch per sample. Inverted means the
+        // gap [lo, hi] is not attained; filling it would paint the asymptote.
+        if (col.kind == IK_WHOLE) {
+            dense = 1.0;
+        } else if (col.kind == IK_INVERTED) {
+            dense = max(_span_cov(y, y_bot, col.lo, sy),
+                        _span_cov(y, col.hi, y_top, sy));
+        } else {
+            dense = _span_cov(y, max(col.lo, y_bot), min(col.hi, y_top), sy);
+        }
+    }
+    float cov = max(max(band_cov, dense), clamp(R - pmin, 0.0, 1.0));
     if (!DOM(x)) {
         float a = cov * color.a * qt_Opacity;
         fragColor = vec4(color.rgb * a, a);
@@ -1287,8 +1385,14 @@ void main() {
     // such as x² + y² = 0 is not left to the projection alone.
     // GGB measures the singular cell in *world* derivative units (|Fx| + |Fy| < 0.001);
     // the per-pixel gradient of an ordinary circle is ~0.01 and must not qualify.
+    // The distance gate is essential for a scaled expression: (x+y)/(x*y) has |F| < 0.05 and
+    // |Fx|+|Fy| < 0.001 over huge regions around ±50, although the level set is far away. A
+    // singular point must also be *on* the set to the first order: |F| ~ R*|grad F|. The
+    // ratio is scale-invariant, unlike the two absolute thresholds above.
     float gw_s = abs(FX(x, y)) + abs(FY(x, y));
-    if (dom && (f == f) && (abs(f) < 1e30) && gw_s < 1e-3 && abs(f) < 0.05) {
+    float gnorm_s = max(sqrt(gx * gx + gy * gy), 1e-9);
+    if (dom && (f == f) && (abs(f) < 1e30) && gw_s < 1e-3 && abs(f) < 0.05
+            && abs(f) < R * gnorm_s) {
         march_cov = 1.0;
     }