Reworking continuous functions' rendering to make it faster.

+ Diminishing pixel precision from 1 to 10.
+ The change is barely noticable by the human eye in most functions.
+ Reworked domain checking to keep the pixel perfect precision.

The only visual degradations are functions with very high y variations for very small x variations (like cos and sin on log scale).

LogarithmPlotter/qml/eu/ad5001/LogarithmPlotter/js/expr-eval.js

@@ -26,7 +26,8 @@ var ADDITIONAL_VARCHARS = [
   "ₕ","ₖ","ₗ","ₘ","ₙ","ₚ","ₛ",
   "ₜ","¹","²","³","⁴","⁵","⁶",
   "⁷","⁸","⁹","⁰","₁","₂","₃",
-  "₄","₅","₆","₇","₈","₉","₀"
+  "₄","₅","₆","₇","₈","₉","₀",
+  "∞"
 ]
 
 function Instruction(type, value) {
@@ -691,7 +692,7 @@ TokenStream.prototype.isConst = function () {
   var i = startPos;
   for (; i < this.expression.length; i++) {
     var c = this.expression.charAt(i);
-    if (c.toUpperCase() === c.toLowerCase()) {
+    if (c.toUpperCase() === c.toLowerCase() && !ADDITIONAL_VARCHARS.includes(c)) {
       if (i === this.pos || (c !== '_' && c !== '.' && (c < '0' || c > '9'))) {
         break;
       }

LogarithmPlotter/qml/eu/ad5001/LogarithmPlotter/js/math/domain.js

@@ -437,8 +437,8 @@ class UnionDomain extends Domain {
     static import(frm) {
         var domains = frm.trim().split("∪")
         if(domains.length == 1) domains = frm.trim().split("U") // Fallback
-        var dom1 = parseDomain(domains.pop())
+        var dom2 = parseDomain(domains.pop())
-        var dom2 = parseDomain(domains.join('∪'))
+        var dom1 = parseDomain(domains.join('∪'))
         return dom1.union(dom2)
     }
 }

LogarithmPlotter/qml/eu/ad5001/LogarithmPlotter/js/math/latex.js

@@ -114,7 +114,7 @@ function variable(vari, wrapIn$ = false) {
                         "ₜ","¹","²","³","⁴","⁵","⁶",
                         "⁷","⁸","⁹","⁰","₁","₂","₃",
                         "₄","₅","₆","₇","₈","₉","₀",
-                        "pi"]
+                        "pi", "∞"]
     let equivalchars = ["\\alpha","\\beta","\\gamma","\\delta","\\epsilon","\\zeta","\\eta",
                         "\\pi","\\theta","\\kappa","\\lambda","\\mu","\\xi","\\rho",
                         "\\sigma","\\sigma","\\tau","\\phi","\\chi","\\psi","\\omega",
@@ -124,7 +124,7 @@ function variable(vari, wrapIn$ = false) {
                         "{}_{t}","{}^{1}","{}^{2}","{}^{3}","{}^{4}","{}^{5}","{}^{6}",
                         "{}^{7}","{}^{8}","{}^{9}","{}^{0}","{}_{1}","{}_{2}","{}_{3}",
                         "{}_{4}","{}_{5}","{}_{6}","{}_{7}","{}_{8}","{}_{9}","{}_{0}",
-                        "\\pi"]
+                        "\\pi", "\\infty"]
     if(wrapIn$)
         for(let i = 0; i < unicodechars.length; i++) {
             if(vari.includes(unicodechars[i]))

LogarithmPlotter/qml/eu/ad5001/LogarithmPlotter/js/objs/function.js

@@ -115,9 +115,9 @@ class Function extends Common.ExecutableObject {
     static drawFunction(canvas, ctx, expr, definitionDomain, destinationDomain, drawPoints = true, drawDash = true) {
         // Reusable in other objects.
         // Drawing small traits every 0.2px
-        var pxprecision = 1
+        var pxprecision = 10
         var previousX = canvas.px2x(0)
-        var previousY;
+        var previousY = null;
         if(definitionDomain instanceof MathLib.SpecialDomain && definitionDomain.moveSupported) {
             // Point based functions.
             previousX = definitionDomain.next(previousX)
@@ -147,17 +147,42 @@ class Function extends Common.ExecutableObject {
                 ctx.fillRect(canvas.x2px(previousX)-1, canvas.y2px(previousY)-5, 2, 10)
             }
         } else {
-            previousY = expr.execute(previousX)
+            if(definitionDomain.includes(previousX))
-            for(var px = pxprecision; px < canvas.canvasSize.width; px += pxprecision) {
+                // PreviousY at the start of the canvas
-                var currentX = canvas.px2x(px)
+                previousY = expr.execute(previousX)
-                var currentY = expr.execute(currentX)
+            for(let px = pxprecision; px < canvas.canvasSize.width; px += pxprecision) {
-                if((definitionDomain.includes(currentX) || definitionDomain.includes(previousX)) &&
+                let currentX = canvas.px2x(px)
-                    (destinationDomain.includes(currentY) || destinationDomain.includes(previousY)) &&
+                if(!definitionDomain.includes(previousX) && definitionDomain.includes(currentX)) {
-                    Math.abs(previousY-currentY)<100) {
+                    // Should draw up to currentX, but NOT at previousX.
-                        canvas.drawLine(ctx, canvas.x2px(previousX), canvas.y2px(previousY), canvas.x2px(currentX), canvas.y2px(currentY))
+                    // Need to find the starting point.
+                    let tmpPx = px-pxprecision
+                    do {
+                        tmpPx++;
+                        previousX = canvas.px2x(tmpPx)
+                    } while(!definitionDomain.includes(previousX))
+                    // Recaclulate previousY
+                    previousY = expr.execute(previousX)
+                } else if(!definitionDomain.includes(currentX)) {
+                    // Next x is NOT in the definition domain.
+                    // Augmenting the pixel precision until this condition is fulfilled.
+                    let tmpPx = px
+                    do {
+                        tmpPx--;
+                        currentX = canvas.px2x(tmpPx)
+                    } while(!definitionDomain.includes(currentX) && currentX != previousX)
+                }
+                if(definitionDomain.includes(previousX) && definitionDomain.includes(currentX)) {
+                    let currentY = expr.execute(currentX)
+                    if(destinationDomain.includes(currentY)) {
+                        if(previousY != null && destinationDomain.includes(previousY)) {
+                            canvas.drawLine(ctx, canvas.x2px(previousX), canvas.y2px(previousY), canvas.x2px(currentX), canvas.y2px(currentY))
+                        }
                     }
-                previousX = currentX
+                    previousY = currentY
-                previousY = currentY
+                } else {
+                    previousY = null // Last y was invalid, so let's not draw anything from it.
+                }
+                previousX = canvas.px2x(px)
             }
         }
     }