jsxgraph 1.14.0 → 1.14.1

package/distrib/docs/math_statistics.js.html

@@ -704,12 +704,12 @@ Mat.Statistics = {
      * The Theil-Sen estimator can be used to determine a more robust linear regression of a set of sample
      * points than least squares regression in {@link JXG.Math.Numerics.regressionPolynomial}.
      *
-     * If the function should be applied to an array a of points, a the coords array can be generated with
-     * JavaScript array.map:
+     * If the function should be applied to an array `a` of *points*, a coords array can be generated with
+     * JavaScript `array.map`:
      *
-     * <pre>
+     * ```
      * JXG.Math.Statistics.TheilSenRegression(a.map(el => el.coords));
-     * </pre>
+     * ```
      *
      * @param {Array} coords Array of {@link JXG.Coords}.
      * @returns {Array} A stdform array of the regression line.
@@ -717,10 +717,10 @@ Mat.Statistics = {
      *
      * @example
      * var board = JXG.JSXGraph.initBoard('jxgbox', { boundingbox: [-6,6,6,-6], axis : true });
-     * var a=[];
-     * a[0]=board.create('point', [0,0]);
-     * a[1]=board.create('point', [3,0]);
-     * a[2]=board.create('point', [0,3]);
+     * var a = [];
+     * a[0] = board.create('point', [0, 0]);
+     * a[1] = board.create('point', [3, 0]);
+     * a[2] = board.create('point', [0, 3]);
      *
      * board.create('line', [
      *     () => JXG.Math.Statistics.TheilSenRegression(a.map(el => el.coords))
@@ -774,7 +774,7 @@ Mat.Statistics = {
 
     /**
      * Generate values of a standard normal random variable with the Marsaglia polar method, see
-     * <a href="https://en.wikipedia.org/wiki/Marsaglia_polar_method">https://en.wikipedia.org/wiki/Marsaglia_polar_method</a>.
+     * {@link https://en.wikipedia.org/wiki/Marsaglia_polar_method}..
      * See also D. E. Knuth, The art of computer programming, vol 2, p. 117.
      *
      * @param {Number} mean mean value of the normal distribution
@@ -864,7 +864,7 @@ Mat.Statistics = {
     },
 
     /**
-     * Generate value of a uniform distributed random variable in the interval [a, b].
+     * Generate value of a uniform distributed random variable in the interval `[a, b]`.
      * @param {Number} a
      * @param {Number} b
      * @returns Number
@@ -876,7 +876,7 @@ Mat.Statistics = {
 
     /**
      * Generate value of a random variable with exponential distribution, i.e.
-     * \\(f(x; \lambda) = \lambda * e^(-\lambda x)\\) if \\(x \geq 0\\) and \\(f(x; \lambda) = 0\\) if \\(x < 0\\).
+     * \\(f(x; \lambda) = \lambda \cdot e^{-\lambda x}\\) if \\(x \geq 0\\) and \\(f(x; \lambda) = 0\\) if \\(x < 0\\).
      * See <a href="https://en.wikipedia.org/wiki/Exponential_distribution">https://en.wikipedia.org/wiki/Exponential_distribution</a>.
      * Algorithm: D.E. Knuth, TAOCP 2, p. 128.
      *
@@ -945,7 +945,7 @@ Mat.Statistics = {
 
     /**
      * Generate value of a random variable with gamma distribution of order alpha.
-     * See <a href="https://en.wikipedia.org/wiki/Gamma_distribution">https://en.wikipedia.org/wiki/Gamma_distribution</a>.
+     * See {@link https://en.wikipedia.org/wiki/Gamma_distribution}.
      * Algorithm: D.E. Knuth, TAOCP 2, p. 129.
 
      * @param {Number} a shape, \\( > 0\\)
@@ -1061,7 +1061,7 @@ Mat.Statistics = {
 
     /**
      * Generate value of a random variable with beta distribution with shape parameters alpha and beta.
-     * See <a href="https://en.wikipedia.org/wiki/Beta_distribution">https://en.wikipedia.org/wiki/Beta_distribution</a>.
+     * See {@link https://en.wikipedia.org/wiki/Beta_distribution}.
      *
      * @param {Number} alpha \\(< 0\\)
      * @param {Number} beta \\(< 0\\)
@@ -1084,7 +1084,7 @@ Mat.Statistics = {
 
     /**
      * Generate value of a random variable with chi-square distribution with k degrees of freedom.
-     * See <a href="https://en.wikipedia.org/wiki/Chi-squared_distribution">https://en.wikipedia.org/wiki/Chi-squared_distribution</a>.
+     * See {@link https://en.wikipedia.org/wiki/Chi-squared_distribution}.
      *
      * @param {Number} k \\(>0\\)
      * @returns Number
@@ -1102,7 +1102,7 @@ Mat.Statistics = {
 
     /**
      * Generate value of a random variable with F-distribution with d<sub>1</sub> and d<sub>2</sub> degrees of freedom.
-     * See <a href="https://en.wikipedia.org/wiki/F-distribution">https://en.wikipedia.org/wiki/F-distribution</a>.
+     * See {@link https://en.wikipedia.org/wiki/F-distribution}.
      * @param {Number} d1 \\(>0\\)
      * @param {Number} d2 \\(>0\\)
      * @returns Number
@@ -1124,7 +1124,7 @@ Mat.Statistics = {
 
     /**
      * Generate value of a random variable with Students-t-distribution with ν degrees of freedom.
-     * See <a href="https://en.wikipedia.org/wiki/Student%27s_t-distribution">https://en.wikipedia.org/wiki/Student%27s_t-distribution</a>.
+     * See {@link https://en.wikipedia.org/wiki/Student%27s_t-distribution}.
      * @param {Number} nu \\(>0\\)
      * @returns Number
      * @memberof JXG.Math.Statistics
@@ -1145,8 +1145,8 @@ Mat.Statistics = {
 
     /**
      * Generate values for a random variable in binomial distribution with parameters \\(n\\) and \\(p\\).
-     * See <a href="https://en.wikipedia.org/wiki/Binomial_distribution">https://en.wikipedia.org/wiki/Binomial_distribution</a>.
-     * It uses algorithm BG from <a href="https://dl.acm.org/doi/pdf/10.1145/42372.42381">https://dl.acm.org/doi/pdf/10.1145/42372.42381</a>.
+     * See {@link https://en.wikipedia.org/wiki/Binomial_distribution}.
+     * It uses algorithm BG from {@link https://dl.acm.org/doi/pdf/10.1145/42372.42381}.
      *
      * @param {Number} n Number of trials (n >= 0)
      * @param {Number} p Probability (0 <= p <= 1)
@@ -1270,7 +1270,7 @@ Mat.Statistics = {
 
     /**
      * Generate values for a random variable in geometric distribution with probability \\(p\\).
-     * See <a href="https://en.wikipedia.org/wiki/Geometric_distribution">https://en.wikipedia.org/wiki/Geometric_distribution</a>.
+     * See {@link https://en.wikipedia.org/wiki/Geometric_distribution}.
      *
      * @param {Number} p (0 <= p <= 1)
      * @returns Number

package/distrib/docs/math_tiling.js.html

@@ -131,11 +131,11 @@ import Mat from "./math.js";
 Mat.Tiling = {
     /**
      * Triangulate (partition it into triangles) a given two dimensional domain.
-     * The number of triangles the original rectangle is divided into depends on the parameters stepsU and stepsV.
-     * Input are the ranges of u and v, as well as stepsU and stepsV which are static.
-     * If the optional parameter stepsV is not given or is equal to 0, the rectangle is partitioned into
+     * The number of triangles the original rectangle is divided into depends on the parameters` `stepsU` and `stepsV`.
+     * Input are the ranges of \\(u\\) and \\(v\\), as well as `stepsU` and `stepsV` which are static.
+     * If the optional parameter `stepsV` is not given or is equal to 0, the rectangle is partitioned into
      * nearly equilateral triangles.
-     * Otherwise, the shape of the triangles depends on the ratio of stepsU / stepsV.
+     * Otherwise, the shape of the triangles depends on the ratio of `stepsU / stepsV`.
      *
      * @param {JXG.ParametricSurface3D|JXG.Plane3D} el element which is displayed using a polyhedron3d.
      * From this element its function F is used.
@@ -291,8 +291,8 @@ Mat.Tiling = {
 
     /**
      * Rectangulate (partition it into rectangles) a given two dimensional domain.
-     * The number of rectangles the original rectangle is divided into depends on the parameters stepsU and stepsV.
-     * Input are the ranges of u and v, as well as stepsU and stepsV which are static.
+     * The number of rectangles the original rectangle is divided into depends on the parameters `stepsU` and `stepsV`.
+     * Input are the ranges of \\(u\\) and \\(v\\), as well as `stepsU` and `stepsV` which are static.
      *
      * @param {JXG.ParametricSurface3D|JXG.Plane3D} el element which is displayed using a polyhedron3d.
      * From this element its function F is used.
@@ -416,288 +416,6 @@ Mat.Tiling = {
         }
         return [vertices, faces];
     }
-
-    // triangulation_old: function (p1, p2, p3, p4, stepsU, stepsV) {
-    //     // Vectors used for checking if the given coordinates create a rectangle
-    //     var vec1 = [p2[0] - p1[0], p2[1] - p1[1]],
-    //         vec2 = [p3[0] - p2[0], p3[1] - p2[1]],
-    //         vec3 = [p4[0] - p3[0], p4[1] - p3[1]],
-    //         vec4 = [p1[0] - p4[0], p1[1] - p4[1]],
-
-    //         coords = [],
-    //         faces = [],
-    //         width, height,
-    //         wSide, hSide,
-    //         triangleWidth, triangleHeight,
-    //         s1, s2,
-    //         i, j,
-    //         numRows,
-    //         widthX, widthY, heightX, heightY,
-    //         oddPoints,
-    //         evenPoints;
-
-    //     // Check if the given coordinates create a rectangle, otherwise an exception is thrown
-    //     if (
-    //         vec1[0] * vec4[0] + vec1[1] * vec4[1] !== 0 ||
-    //         vec2[0] * vec1[0] + vec2[1] * vec1[1] !== 0 ||
-    //         vec3[0] * vec2[0] + vec3[1] * vec2[1] !== 0 ||
-    //         vec4[0] * vec3[0] + vec4[1] * vec3[1] !== 0
-    //     ) {
-    //         throw new Error(" the board created is not rectangle  ");
-    //     }
-
-    //     // Set initial values for wSide, hSide
-    //     wSide = [0, 0];
-    //     hSide = [0, 0];
-
-    //     // Check for longer side of rectangle:
-    //     // longer side is appointed height, shorter side is appointed width
-    //     s1 = Math.sqrt((p2[0] - p1[0]) * (p2[0] - p1[0]) + (p2[1] - p1[1]) * (p2[1] - p1[1]));
-    //     s2 = Math.sqrt((p3[0] - p2[0]) * (p3[0] - p2[0]) + (p3[1] - p2[1]) * (p3[1] - p2[1]));
-    //     if (s1 <= s2) {
-    //         width = s1;
-    //         height = s2;
-    //         // Determine start and end points of the width-side and height-side
-    //         wSide = [p1, p2];
-    //         hSide = [p2, p3];
-    //     } else {
-    //         width = s2;
-    //         height = s1;
-    //         // Determine start and end points of the width-side and height-side
-    //         wSide = [p2, p3];
-    //         hSide = [p1, p2];
-    //     }
-    //     // Calculate height and width of the triangles and number of rows
-    //     triangleWidth = width / stepsU;
-
-    //     if (stepsV === undefined || stepsV === 0) {
-    //         // Equilateral triangles, depending on parameter "stepsU"
-    //         triangleHeight = (triangleWidth * Math.sqrt(3)) / 2;
-    //         numRows = Math.round(height / triangleHeight);
-    //     } else {
-    //         // Two parameters stepsU, stepsV
-    //         numRows = stepsV;
-    //         triangleHeight = height / numRows;
-    //     }
-
-    //     // Calculate values of "shifting vectors"
-    //     widthX = (wSide[1][0] - wSide[0][0]) / stepsU;
-    //     widthY = (wSide[1][1] - wSide[0][1]) / stepsU;
-    //     heightX = (hSide[1][0] - hSide[0][0]) / numRows;
-    //     heightY = (hSide[1][1] - hSide[0][1]) / numRows;
-
-    //     oddPoints = [];
-    //     evenPoints = [];
-
-    //     // Push coordinates of the base point (p1)
-    //     coords.push([p1[0], p1[1]]);
-    //     evenPoints.push(coords.length - 1);
-
-    //     // Calculate point coordinates of layer 0 and store indices in evenPoints
-    //     for (i = 1; i <= stepsU; i++) {
-    //         coords.push([p1[0] + i * widthX, p1[1] + i * widthY]); // Points first line
-    //         evenPoints.push(coords.length - 1);
-    //     }
-
-    //     for (i = 1; i <= numRows; i++) {
-    //         if (i % 2 === 0) {
-    //             // Points and faces of layers with an even index
-
-    //             evenPoints = [];
-    //             // Calculate first point coordinates within the layer
-    //             coords.push([
-    //                 p1[0] + i * heightX,
-    //                 p1[1] + i * heightY
-    //             ]);
-    //             // evenPoints stores index of the first point of the layer
-    //             evenPoints.push(coords.length - 1);
-    //             // Calculate all other point coordinates within the layer
-    //             for (j = 1; j <= stepsU; j++) {
-    //                 coords.push([
-    //                     coords[evenPoints[0]][0] + j * widthX,
-    //                     coords[evenPoints[0]][1] + j * widthY
-    //                 ]);
-    //                 //evenPoints stores index of the most recently calculated point of the layer
-    //                 evenPoints.push(coords.length - 1);
-    //             }
-    //             // Connect the faces of the row by grouping indices of points
-    //             faces.push([evenPoints[0], oddPoints[0], oddPoints[1]]);
-    //             for (j = 1; j <= stepsU; j++) {
-    //                 faces.push([evenPoints[j - 1], oddPoints[j], evenPoints[j]]);
-    //                 faces.push([evenPoints[j], oddPoints[j], oddPoints[j + 1]]);
-    //             }
-    //         } else {
-    //             // Points and faces of layers with an odd index
-
-    //             oddPoints = [];
-    //             // Calculate first point coordinates within the layer
-    //             coords.push([
-    //                 p1[0] + i * heightX,
-    //                 p1[1] + i * heightY
-    //             ]);
-    //             // oddPoints stores index of the first point of the layer
-    //             oddPoints.push(coords.length - 1);
-    //             // Calculate all other point coordinates within the layer except for the last point
-    //             for (j = 1; j <= stepsU; j++) {
-    //                 coords.push([
-    //                     coords[oddPoints[0]][0] + j * widthX - widthX / 2,
-    //                     coords[oddPoints[0]][1] + j * widthY - widthY / 2
-    //                 ]);
-    //                 // oddPoints stores index of the most recently calculated point of the layer
-    //                 oddPoints.push(coords.length - 1);
-    //             }
-    //             // Calculate last point coordinates within the layer
-    //             coords.push([
-    //                 coords[oddPoints[0]][0] + stepsU * widthX,
-    //                 coords[oddPoints[0]][1] + stepsU * widthY
-    //             ]);
-    //             // oddPoints stores index of last point within the layer
-    //             oddPoints.push(coords.length - 1);
-    //             // Connect the faces of the row by grouping indices of points
-    //             faces.push([oddPoints[0], evenPoints[0], oddPoints[1]]);
-    //             for (j = 1; j <= stepsU; j++) {
-    //                 faces.push([oddPoints[j], evenPoints[j - 1], evenPoints[j]]);
-    //                 faces.push([oddPoints[j], evenPoints[j], oddPoints[j + 1]]);
-    //             }
-    //         }
-    //     }
-
-    //     return [coords, faces];
-    // },
-
-    // rectangulation_old: function (p1, p2, p3, p4, stepsU, stepsV) {
-    //     // Vectors used for checking if the given coordinates create a rectangle
-    //     var vec1 = [p2[0] - p1[0], p2[1] - p1[1]],
-    //         vec2 = [p3[0] - p2[0], p3[1] - p2[1]],
-    //         vec3 = [p4[0] - p3[0], p4[1] - p3[1]],
-    //         vec4 = [p1[0] - p4[0], p1[1] - p4[1]],
-
-    //         coords = [],
-    //         faces = [],
-    //         wSide, hSide,
-    //         s1, s2,
-    //         i, j,
-    //         widthX, widthY,
-    //         heightX, heightY,
-    //         startPointLayer;
-
-    //     // Check if the given coordinates create a rectangle, otherwise an exception is thrown
-    //     if (
-    //         vec1[0] * vec4[0] + vec1[1] * vec4[1] !== 0 ||
-    //         vec2[0] * vec1[0] + vec2[1] * vec1[1] !== 0 ||
-    //         vec3[0] * vec2[0] + vec3[1] * vec2[1] !== 0 ||
-    //         vec4[0] * vec3[0] + vec4[1] * vec3[1] !== 0
-    //     ) {
-    //         throw new Error("rectangulation_old: area is not rectangle  ");
-    //         // console.log("rectangulation_old: area is not rectangle  ");
-    //     }
-
-    //     // Set initial values for wSide, hSide
-    //     wSide = [0, 0];
-    //     hSide = [0, 0];
-
-    //     // Check for longer side of rectangle:
-    //     // longer side is appointed height, shorter side is appointed width
-    //     // s1 = Math.sqrt((p2[0] - p1[0]) * (p2[0] - p1[0]) + (p2[1] - p1[1]) * (p2[1] - p1[1]));
-    //     // s2 = Math.sqrt((p3[0] - p2[0]) * (p3[0] - p2[0]) + (p3[1] - p2[1]) * (p3[1] - p2[1]));
-    //     s1 = Mat.hypot(vec1[0], vec1[1]);
-    //     s2 = Mat.hypot(vec2[0], vec2[1]);
-
-    //     if (s1 <= s2) {
-    //         // Determine start and end points of the width-side and height-side
-    //         wSide = [p1, p2];
-    //         hSide = [p2, p3];
-    //     } else {
-    //         // Determine start and end points of the width-side and height-side
-    //         wSide = [p2, p3];
-    //         hSide = [p1, p2];
-    //     }
-
-    //     // Calculate values of "shifting vectors"
-    //     widthX = (wSide[1][0] - wSide[0][0]) / stepsV;
-    //     widthY = (wSide[1][1] - wSide[0][1]) / stepsV;
-    //     heightX = (hSide[1][0] - hSide[0][0]) / stepsU;
-    //     heightY = (hSide[1][1] - hSide[0][1]) / stepsU;
-
-    //     // Initialize startPointLayer that stores coordinates of the first point of the current layer
-    //     startPointLayer = [];
-
-    //     // Push coordinates of base point (p1)
-    //     coords.push([p1[0], p1[1]]);
-    //     startPointLayer = coords[0];
-
-    //     // Calculate point coordinates of layer 0
-    //     for (j = 1; j <= stepsV; j++) {
-    //         coords.push([startPointLayer[0] + j * widthX, startPointLayer[1] + j * widthY]);
-    //     }
-
-    //     for (i = 1; i <= stepsU; i++) {
-    //         startPointLayer = [];
-
-    //         // Calculate point coordinates of first point of layer
-    //         coords.push([
-    //             p1[0] + i * heightX,
-    //             p1[1] + i * heightY
-    //         ]);
-    //         startPointLayer = coords[coords.length - 1];
-
-    //         // Calculating remaining point coordinates of layer
-    //         for (j = 1; j <= stepsV; j++) {
-    //             coords.push([
-    //                 startPointLayer[0] + j * widthX,
-    //                 startPointLayer[1] + j * widthY
-    //             ]);
-    //         }
-
-    //         // Connect rectangles by grouping indices of points
-    //         for (
-    //             j = coords.length - stepsV - 1;
-    //             j < coords.length - 1;
-    //             j++
-    //         ) {
-    //             faces.push([j, j - stepsV - 1, j - stepsV, j + 1]);
-    //         }
-    //     }
-
-    //     return [coords, faces];
-    // },
-
-    // /**
-    //  * This function creates an array of dynamic 3-dimensional points
-    //  * based on an array of pairs of two coordinates.
-    //  * It uses a mathematical function to assign a third coordinate (the z-coordinate)
-    //  * to each pair of two coordinates.
-    //  * The 3-dimensional points are not stored directly.
-    //  * Instead the array stores JavaScript functions that utilize the mentioned mathematical function
-    //  * to return an array of three coordinates.
-    //  * This allows the recognition and proper visualization of changes to the underlying
-    //  * mathematical function.
-    //  * @name mapMeshTo3D
-    //  * @param {Array} surface
-    //  * @param {Parametricsurface3d} el
-    //  * @returns {Array} dynamicPoints array of [x, y, z] coordinates
-    //  *
-    //  * @private
-    //  * @memberof JXG.Math.Tiling
-    //  */
-    // mapMeshTo3D: function (surface, el) {
-    //     var dynamicPoints = [], i;
-
-    //     for (i = 0; i < surface[0].length; i++) {
-    //         dynamicPoints.push(
-    //             (function (u, v) {
-    //                 return function(x, y) { return el.F(u, v); };
-    //             })(surface[0][i][0], surface[0][i][1])
-    //         ); // Capture values explicitly
-    //         // dynamicPoints.push(
-    //         //     (function (u, v) {
-    //         //         return function(x, y) { return el.F(Type.evaluate(u), Type.evaluate(v)); };
-    //         //     })(surface[0][i][0], surface[0][i][1])
-    //         // ); // Capture values explicitly
-    //     }
-
-    //     return dynamicPoints;
-    // }
 };
 
 export default Mat.Tiling;

package/distrib/docs/parser_jessiecode.js.html

@@ -3558,7 +3558,7 @@ upcomingInput:function () {
 showPosition:function () {
         var pre = this.pastInput();
         var c = new Array(pre.length + 1).join("-");
-        return pre + this.upcomingInput() + "\n" + c+"^";
+        return JXG.escapeHTML(pre + this.upcomingInput() + "\n" + c+"^");
     },
 next:function () {
         if (this.done) {

package/distrib/docs/renderer_canvas.js.html

@@ -291,7 +291,7 @@ JXG.extend(
          * Set the gradient angle for linear color gradients.
          *
          * @private
-         * @param {JXG.GeometryElement} node An arbitrary JSXGraph element, preferably one with an area.
+         * @param {JXG.GeometryElement} el An arbitrary JSXGraph element, preferably one with an area.
          * @param {Number} radians angle value in radians. 0 is horizontal from left to right, Pi/4 is vertical from top to bottom.
          */
         updateGradientAngle: function (el, radians) {
@@ -347,7 +347,7 @@ JXG.extend(
          * Set circles for radial color gradients.
          *
          * @private
-         * @param {SVGnode} node SVG gradient node
+         * @param {JXG.GeometryElement} el An arbitrary JSXGraph element, preferably one with an area.
          * @param {Number} cx Canvas value x1 (but value between 0 and 1)
          * @param {Number} cy  Canvas value y1 (but value between 0 and 1)
          * @param {Number} r  Canvas value r1 (but value between 0 and 1)
@@ -360,19 +360,20 @@ JXG.extend(
                 c1, c2,
                 cxs, cys, rs,
                 fxs, fys, frs,
-                dx, dy;
+                dx, dy, d;
 
             c1 = new Coords(Const.COORDS_BY_USER, [bb[0], bb[1]], el.board);
             c2 = new Coords(Const.COORDS_BY_USER, [bb[2], bb[3]], el.board);
             dx = c2.scrCoords[1] - c1.scrCoords[1];
             dy = c1.scrCoords[2] - c2.scrCoords[2];
-
             cxs = c1.scrCoords[1] + dx * cx;
             cys = c2.scrCoords[2] + dy * cy;
             fxs = c1.scrCoords[1] + dx * fx;
             fys = c2.scrCoords[2] + dy * fy;
-            rs = r * (dx + dy) * 0.5;
-            frs = fr * (dx + dy) * 0.5;
+
+            d = Math.abs(dx) + Math.abs(dy);
+            rs = Math.max(r * d * 0.5, 0);
+            frs = Math.max(fr * d * 0.5, 0);
 
             return this.context.createRadialGradient(fxs, fys, frs, cxs, cys, rs);
         },

package/distrib/docs/renderer_svg.js.html

@@ -338,7 +338,7 @@ JXG.SVGRenderer = function (container, dim) {
         var id = this.uniqName('ClipFull'),
             node1 = this.container.ownerDocument.createElementNS(this.svgNamespace, 'clipPath'),
             node2 = this.container.ownerDocument.createElementNS(this.svgNamespace, 'rect'),
-            style, rx, ry;
+            style, r;
         node1.setAttributeNS(null, 'id', id);
 
         node2.setAttributeNS(null, 'x', 0);
@@ -348,10 +348,9 @@ JXG.SVGRenderer = function (container, dim) {
 
         // Inherit border-radius
         style = getComputedStyle(this.container);
-        rx = Type.exists(style['border-radius']) ? parseFloat(style['border-radius']) : 0;
-        ry = rx;
-        node2.setAttributeNS(null, 'rx', rx);
-        node2.setAttributeNS(null, 'ry', ry);
+        r = (Type.exists(style['border-radius']) && style['border-radius'] !== '') ? parseFloat(style['border-radius']) : 0;
+        node2.setAttributeNS(null, 'rx', r);
+        node2.setAttributeNS(null, 'ry', r);
 
         node1.appendChild(node2);
         return node1;
@@ -1039,7 +1038,7 @@ JXG.extend(
 
         // Already documented in JXG.AbstractRenderer
         setLayer: function (el, level) {
-            var node;
+            var node, elNode;
             if (!Type.exists(level)) {
                 level = 0;
             } else if (level >= Options.layer.numlayers) {
@@ -1047,8 +1046,16 @@ JXG.extend(
             }
 
             node = this.layer[level];
+            // if ('moveBefore' in Element.prototype) {
             if (Type.exists(node.moveBefore)) {
-                node.moveBefore(el.rendNode, null);
+                // node.moveBefore(el.rendNode, null);
+                elNode = el.rendNode;
+                if (elNode.isConnected && node.isConnected &&
+                    (elNode.ownerDocument === node.ownerDocument)) {
+                    node.moveBefore(elNode, null);
+                } else {
+                    node.insertBefore(elNode, null);
+                }
             } else {
                 node.appendChild(el.rendNode);
             }
@@ -1335,6 +1342,7 @@ JXG.extend(
                 i = 0;
                 while (i < len) {
                     if (el.points[i] === undefined) {
+                        i++;
                         continue;
                     }
                     scr = el.points[i].scrCoords;