jsxgraph 1.3.0 → 1.4.1

package/src/math/nlp.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Carsten Miller,
         Reinhard Oldenburg,
@@ -86,6 +86,12 @@ define(['jxg'], function (JXG) {
 
     "use strict";
 
+    /**
+     * The JXG.Math.Nlp namespace holds numerical algorithms for non-linear optimization.
+     * @name JXG.Math.Nlp
+     * @namespace
+     * 
+     */
     JXG.Math.Nlp =  {
 
         arr: function(n) {
@@ -124,6 +130,7 @@ define(['jxg'], function (JXG) {
         /**
          * Minimizes the objective function F with respect to a set of inequality constraints CON,
          * and returns the optimal variable array. F and CON may be non-linear, and should preferably be smooth.
+         * Calls {@link JXG.Math.Nlp#cobylb}.
          *
          * @param calcfc Interface implementation for calculating objective function and constraints.
          * @param n Number of variables.
@@ -135,10 +142,10 @@ define(['jxg'], function (JXG) {
          * @param iprint Print level, 0 <= iprint <= 3, where 0 provides no output and
          * 3 provides full output to the console.
          * @param maxfun Maximum number of function evaluations before terminating.
-         * @return Exit status of the COBYLA2 optimization.
+         * @returns {Number} Exit status of the COBYLA2 optimization.
          */
-	    // CobylaExitStatus FindMinimum(final Calcfc calcfc, int n, int m, double[] x, double rhobeg, double rhoend, int iprint, int maxfun)
         FindMinimum: function(calcfc, n,  m, x, rhobeg, rhoend,  iprint,  maxfun) {
+            // CobylaExitStatus FindMinimum(final Calcfc calcfc, int n, int m, double[] x, double rhobeg, double rhoend, int iprint, int maxfun)
             //     This subroutine minimizes an objective function F(X) subject to M
             //     inequality constraints on X, where X is a vector of variables that has
             //     N components.  The algorithm employs linear approximations to the
@@ -220,8 +227,21 @@ define(['jxg'], function (JXG) {
 
         //    private static CobylaExitStatus cobylb(Calcfc calcfc, int n, int m, int mpp, double[] x,
         //      double rhobeg, double rhoend, int iprint, int maxfun)
+        /**
+         * JavaScript implementation of the non-linear optimization method COBYLA.
+         * @param {Function} calcfc 
+         * @param {Number} n 
+         * @param {Number} m 
+         * @param {Number} mpp 
+         * @param {Number} x 
+         * @param {Number} rhobeg 
+         * @param {Number} rhoend 
+         * @param {Number} iprint 
+         * @param {Number} maxfun 
+         * @returns {Number} Exit status of the COBYLA2 optimization
+         */
         cobylb: function (calcfc, n,  m,  mpp,  x, rhobeg,  rhoend,  iprint,  maxfun) {
-    		// calcf ist funktion die aufgerufen wird wie calcfc(n, m, ix, ocon)
+            // calcf ist funktion die aufgerufen wird wie calcfc(n, m, ix, ocon)
             // N.B. Arguments CON, SIM, SIMI, DATMAT, A, VSIG, VETA, SIGBAR, DX, W & IACT
             //      have been removed.
 
@@ -294,7 +314,7 @@ define(['jxg'], function (JXG) {
             //     Make the next call of the user-supplied subroutine CALCFC. These
             //     instructions are also used for calling CALCFC during the iterations of
             //     the algorithm.
-		    //alert("Iteration "+nfvals+" x="+x);
+            //alert("Iteration "+nfvals+" x="+x);
             L_40:
             do {
                 if (nfvals >= maxfun && nfvals > 0) {

package/src/math/numerics.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,
@@ -31,6 +31,7 @@
 
 /*global JXG: true, define: true*/
 /*jslint nomen: true, plusplus: true*/
+/*eslint no-loss-of-precision: off */
 
 /* depends:
  utils/type
@@ -42,7 +43,7 @@
  * algorithms for solving linear equations etc.
  */
 
-define(['jxg', 'utils/type', 'math/math'], function (JXG, Type, Mat) {
+define(['jxg', 'utils/type', 'utils/env', 'math/math'], function (JXG, Type, Env, Mat) {
 
     "use strict";
 
@@ -1767,6 +1768,8 @@ define(['jxg', 'utils/type', 'math/math'], function (JXG, Type, Mat) {
          * Returns the Lagrange polynomials, see
          * Jean-Paul Berrut, Lloyd N. Trefethen: Barycentric Lagrange Interpolation,
          * SIAM Review, Vol 46, No 3, (2004) 501-517.
+         * <p>
+         * It possesses the method getTerm() which returns the string containing the function term of the polynomial.
          * @param {Array} p Array of JXG.Points
          * @returns {function} A function of one parameter which returns the value of the polynomial, whose graph runs through the given points.
          * @memberof JXG.Math.Numerics
@@ -1797,9 +1800,38 @@ define(['jxg', 'utils/type', 'math/math'], function (JXG, Type, Mat) {
          *
          * </script><pre>
          *
+         * @example
+         * var points = [];
+         * points[0] = board.create('point', [-1,2], {size:4});
+         * points[1] = board.create('point', [0, 0], {size:4});
+         * points[2] = board.create('point', [2, 1], {size:4});
+         *
+         * var f = JXG.Math.Numerics.lagrangePolynomial(points);
+         * var graph = board.create('functiongraph', [f,-10, 10], {strokeWidth:3});
+         * var txt = board.create('text', [-3, -4,  () => f.getTerm(2, 't', ' * ')], {fontSize: 16});
+         *
+         * </pre><div id="JXG73fdaf12-e257-4374-b488-ae063e4eecbb" class="jxgbox" style="width: 300px; height: 300px;"></div>
+         * <script type="text/javascript">
+         *     (function() {
+         *         var board = JXG.JSXGraph.initBoard('JXG73fdaf12-e257-4374-b488-ae063e4eecbb',
+         *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
+         *     var points = [];
+         *     points[0] = board.create('point', [-1,2], {size:4});
+         *     points[1] = board.create('point', [0, 0], {size:4});
+         *     points[2] = board.create('point', [2, 1], {size:4});
+         *
+         *     var f = JXG.Math.Numerics.lagrangePolynomial(points);
+         *     var graph = board.create('functiongraph', [f,-10, 10], {strokeWidth:3});
+         *     var txt = board.create('text', [-3, -4,  () => f.getTerm(2, 't', ' * ')], {fontSize: 16});
+         *
+         *     })();
+         *
+         * </script><pre>
+         *
          */
         lagrangePolynomial: function (p) {
             var w = [],
+                that = this,
                 /** @ignore */
                 fct = function (x, suspendedUpdate) {
                     var i, // j,
@@ -1843,12 +1875,159 @@ define(['jxg', 'utils/type', 'math/math'], function (JXG, Type, Mat) {
                     return num / denom;
                 };
 
-            fct.getTerm = function () {
-                return '';
+            /**
+             * Get the term of the Lagrange polynomial as string.
+             * Calls {@link JXG.Math.Numerics#lagrangePolynomialTerm}.
+             *
+             * @name JXG.Math.Numerics#lagrangePolynomial.getTerm
+             * @param {Number} digits Number of digits of the coefficients
+             * @param {String} param Variable name
+             * @param {String} dot Dot symbol
+             * @returns {String} containing the term of Lagrange polynomial as string.
+             * @see JXG.Math.Numerics#lagrangePolynomialTerm
+             * @example
+             * var points = [];
+             * points[0] = board.create('point', [-1,2], {size:4});
+             * points[1] = board.create('point', [0, 0], {size:4});
+             * points[2] = board.create('point', [2, 1], {size:4});
+             *
+             * var f = JXG.Math.Numerics.lagrangePolynomial(points);
+             * var graph = board.create('functiongraph', [f,-10, 10], {strokeWidth:3});
+             * var txt = board.create('text', [-3, -4,  () => f.getTerm(2, 't', ' * ')], {fontSize: 16});
+             *
+             * </pre><div id="JXG73fdaf12-e257-4374-b488-ae063e4eeccf" class="jxgbox" style="width: 300px; height: 300px;"></div>
+             * <script type="text/javascript">
+             *     (function() {
+             *         var board = JXG.JSXGraph.initBoard('JXG73fdaf12-e257-4374-b488-ae063e4eeccf',
+             *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
+             *     var points = [];
+             *     points[0] = board.create('point', [-1,2], {size:4});
+             *     points[1] = board.create('point', [0, 0], {size:4});
+             *     points[2] = board.create('point', [2, 1], {size:4});
+             *
+             *     var f = JXG.Math.Numerics.lagrangePolynomial(points);
+             *     var graph = board.create('functiongraph', [f,-10, 10], {strokeWidth:3});
+             *     var txt = board.create('text', [-3, -4,  () => f.getTerm(2, 't', ' * ')], {fontSize: 16});
+             *
+             *     })();
+             *
+             * </script><pre>
+             *
+             */
+            fct.getTerm = function(digits, param, dot) {
+                return that.lagrangePolynomialTerm(p, digits, param, dot)();
             };
 
             return fct;
         },
+        // fct.getTerm = that.lagrangePolynomialTerm(p, 2, 'x');
+
+        /**
+         * Determine the Lagrange polynomial through an array of points and
+         * return the term of the polynomial as string.
+         *
+         * @param {Array} points Array of JXG.Points
+         * @param {Number} digits Number of decimal digits of the coefficients
+         * @param {String} param Name of the parameter. Default: 'x'.
+         * @param {String} dot Multiplication symbol. Default: ' * '.
+         * @returns {String} containing the Lagrange polynomial through
+         *    the supplied points.
+         * @memberof JXG.Math.Numerics
+         *
+         * @example
+         * var points = [];
+         * points[0] = board.create('point', [-1,2], {size:4});
+         * points[1] = board.create('point', [0, 0], {size:4});
+         * points[2] = board.create('point', [2, 1], {size:4});
+         *
+         * var f = JXG.Math.Numerics.lagrangePolynomial(points);
+         * var graph = board.create('functiongraph', [f,-10, 10], {strokeWidth:3});
+         *
+         * var f_txt = JXG.Math.Numerics.lagrangePolynomialTerm(points, 2, 't', ' * ');
+         * var txt = board.create('text', [-3, -4, f_txt], {fontSize: 16});
+         *
+         * </pre><div id="JXGd45e9e96-7526-486d-aa43-e1178d5f2baa" class="jxgbox" style="width: 300px; height: 300px;"></div>
+         * <script type="text/javascript">
+         *     (function() {
+         *         var board = JXG.JSXGraph.initBoard('JXGd45e9e96-7526-486d-aa43-e1178d5f2baa',
+         *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
+         *     var points = [];
+         *     points[0] = board.create('point', [-1,2], {size:4});
+         *     points[1] = board.create('point', [0, 0], {size:4});
+         *     points[2] = board.create('point', [2, 1], {size:4});
+         *
+         *     var f = JXG.Math.Numerics.lagrangePolynomial(points);
+         *     var graph = board.create('functiongraph', [f,-10, 10], {strokeWidth:3});
+         *
+         *     var f_txt = JXG.Math.Numerics.lagrangePolynomialTerm(points, 2, 't', ' * ');
+         *     var txt = board.create('text', [-3, -4, f_txt], {fontSize: 16});
+         *
+         *     })();
+         *
+         * </script><pre>
+         *
+         */
+        lagrangePolynomialTerm: function(points, digits, param, dot) {
+            return function() {
+                var len = points.length,
+                    zeroes = [],
+                    coeffs = [],
+                    coeffs_sum = [],
+                    isLeading = true,
+                    n, t,
+                    i, j, c, p;
+
+                param = param || 'x';
+                if (dot === undefined) {
+                    dot = ' * ';
+                }
+
+                n = len - 1;  // (Max) degree of the polynomial
+                for (j = 0; j < len; j++) {
+                    coeffs_sum[j] = 0;
+                }
+
+                for (i = 0; i < len; i++) {
+                    c = points[i].Y();
+                    p = points[i].X();
+                    zeroes = [];
+                    for (j = 0; j < len; j++) {
+                        if (j !== i) {
+                            c /= p - points[j].X();
+                            zeroes.push(points[j].X());
+                        }
+                    }
+                    coeffs = [1].concat(Mat.Vieta(zeroes));
+                    for (j = 0; j < coeffs.length; j++) {
+                        coeffs_sum[j] += (j%2===1?(-1):1) * coeffs[j] * c;
+                    }
+                }
+
+                t = '';
+                for (j = 0; j < coeffs_sum.length; j++) {
+                    c = coeffs_sum[j];
+                    if (Math.abs(c) < Mat.eps) {
+                        continue;
+                    }
+                    if (JXG.exists(digits)) {
+                        c = Env._round10(c, -digits);
+                    }
+                    if (isLeading) {
+                        t += (c > 0) ? (c) : ('-' + (-c));
+                        isLeading = false;
+                    } else {
+                        t += (c > 0) ? (' + ' + c) : (' - ' + (-c));
+                    }
+
+                    if (n - j > 1) {
+                        t += dot + param + '^' + (n - j);
+                    } else if (n - j === 1) {
+                        t += dot + param;
+                    }
+                }
+                return t; // board.jc.manipulate('f = map(x) -> ' + t + ';');
+            };
+        },
 
         /**
          * Determine the coefficients of a cardinal spline polynom, See

package/src/math/plot.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,
@@ -457,7 +457,7 @@ define(['jxg', 'base/constants', 'base/coords', 'math/math', 'math/extrapolate',
                 vy = curve.Y(t_real, true) ;
                 vy2 = curve.Y(t_real2, true) ;
                 dy = (vy - vy2) / (t_real - t_real2);
-               
+
                 if (p_good !== null) {
                     this._insertPoint_v2(curve, new Coords(Const.COORDS_BY_USER, p_good, curve.board, false));
                     return true;
@@ -1016,7 +1016,7 @@ define(['jxg', 'base/constants', 'base/coords', 'math/math', 'math/extrapolate',
         },
 
         /**
-         * 
+         *
          * @param {JXG.Curve} curve JSXGraph curve element
          * @param {Number} ta
          * @param {Number} tb
@@ -1959,7 +1959,7 @@ console.log("Polynomial of degree", level);
                 dx, dy;
 
             //console.log("Level", level)
-            if (level == 0) {
+            if (level === 0) {
                 this._insertPoint_v4(curve, [1, NaN, NaN], t);
                 return;
             }

package/src/math/poly.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,

package/src/math/probfuncs.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Carsten Miller,
         Andreas Walter,
@@ -30,6 +30,7 @@
 
 /*global JXG: true, define: true*/
 /*jslint nomen: true, plusplus: true*/
+/*eslint no-loss-of-precision: off */
 
 /* depends:
  jxg

package/src/math/qdt.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,
@@ -10,20 +10,20 @@
     This file is part of JSXGraph.
 
     JSXGraph is free software dual licensed under the GNU LGPL or MIT License.
-    
+
     You can redistribute it and/or modify it under the terms of the
-    
+
       * GNU Lesser General Public License as published by
         the Free Software Foundation, either version 3 of the License, or
         (at your option) any later version
       OR
       * MIT License: https://github.com/jsxgraph/jsxgraph/blob/master/LICENSE.MIT
-    
+
     JSXGraph is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     GNU Lesser General Public License for more details.
-    
+
     You should have received a copy of the GNU Lesser General Public License and
     the MIT License along with JSXGraph. If not, see <http://www.gnu.org/licenses/>
     and <http://opensource.org/licenses/MIT/>.
@@ -42,58 +42,64 @@ define(['math/math', 'utils/type'], function (Mat, Type) {
 
     "use strict";
 
-    var
+    /**
+     * Instantiate a new quad tree.
+     *
+     * @name JXG.Math.Quadtree
+     * @exports Mat.Quadtree as JXG.Math.Quadtree
+     * @param {Array} bbox Bounding box of the new quad (sub)tree.
+     * @constructor
+     */
+    Mat.Quadtree = function (bbox) {
         /**
-         * Instantiate a new quad tree.
-         * @param {Array} bbox Bounding box of the new quad (sub)tree.
-         * @constructor
+         * The maximum number of points stored in a quad tree node
+         * before it is subdivided.
+         * @type Number
+         * @default 10
          */
-        Quadtree = function (bbox) {
-            /**
-             * The maximum number of points stored in a quad tree node
-             * before it is subdivided.
-             * @type {Number}
-             * @default 10
-             */
-            this.capacity = 10;
-
-            /**
-             * Point storage.
-             * @type {Array}
-             */
-            this.points = [];
-
-            this.xlb = bbox[0];
-            this.xub = bbox[2];
-            this.ylb = bbox[3];
-            this.yub = bbox[1];
-
-            /**
-             * In a subdivided quad tree this represents the top left subtree.
-             * @type {JXG.Quadtree}
-             */
-            this.northWest = null;
-
-            /**
-             * In a subdivided quad tree this represents the top right subtree.
-             * @type {JXG.Quadtree}
-             */
-            this.northEast = null;
-
-            /**
-             * In a subdivided quad tree this represents the bottom right subtree.
-             * @type {JXG.Quadtree}
-             */
-            this.southEast = null;
-
-            /**
-             * In a subdivided quad tree this represents the bottom left subtree.
-             * @type {JXG.Quadtree}
-             */
-            this.southWest = null;
-        };
-
-    Type.extend(Quadtree.prototype, /** @lends JXG.Quadtree.prototype */ {
+        this.capacity = 10;
+
+        /**
+         * Point storage.
+         * @name JXG.Math.Quadtree#points
+         * @type Array
+         */
+        this.points = [];
+        this.xlb = bbox[0];
+        this.xub = bbox[2];
+        this.ylb = bbox[3];
+        this.yub = bbox[1];
+
+        /**
+         * In a subdivided quad tree this represents the top left subtree.
+         * @name JXG.Math.Quadtree#northWest
+         * @type JXG.Math.Quadtree
+         */
+        this.northWest = null;
+
+        /**
+         * In a subdivided quad tree this represents the top right subtree.
+         * @name JXG.Math.Quadtree#northEast
+         * @type JXG.Math.Quadtree
+         */
+        this.northEast = null;
+
+        /**
+         * In a subdivided quad tree this represents the bottom right subtree.
+         * @name JXG.Math.Quadtree#southEast
+         * @type JXG.Math.Quadtree
+         */
+        this.southEast = null;
+
+        /**
+         * In a subdivided quad tree this represents the bottom left subtree.
+         * @name JXG.Math.Quadtree#southWest
+         * @type JXG.Math.Quadtree
+         */
+        this.southWest = null;
+    };
+
+    Type.extend(Mat.Quadtree.prototype, /** @lends JXG.Math.Quadtree.prototype */ {
         /**
          * Checks if the given coordinates are inside the quad tree.
          * @param {Number} x
@@ -149,10 +155,10 @@ define(['math/math', 'utils/type'], function (Mat, Type) {
                 mx = this.xlb + (this.xub - this.xlb) / 2,
                 my = this.ylb + (this.yub - this.ylb) / 2;
 
-            this.northWest = new Quadtree([this.xlb, this.yub, mx, my]);
-            this.northEast = new Quadtree([mx, this.yub, this.xub, my]);
-            this.southEast = new Quadtree([this.xlb, my, mx, this.ylb]);
-            this.southWest = new Quadtree([mx, my, this.xub, this.ylb]);
+            this.northWest = new Mat.Quadtree([this.xlb, this.yub, mx, my]);
+            this.northEast = new Mat.Quadtree([mx, this.yub, this.xub, my]);
+            this.southEast = new Mat.Quadtree([this.xlb, my, mx, this.ylb]);
+            this.southWest = new Mat.Quadtree([mx, my, this.xub, this.ylb]);
 
             for (i = 0; i < l; i += 1) {
                 this.northWest.insert(this.points[i]);
@@ -164,6 +170,7 @@ define(['math/math', 'utils/type'], function (Mat, Type) {
 
         /**
          * Internal _query method that lacks adjustment of the parameter.
+         * @name JXG.Math.Quadtree#_query
          * @param {Number} x
          * @param {Number} y
          * @returns {Boolean|JXG.Quadtree} The quad tree if the point is found, false
@@ -205,6 +212,7 @@ define(['math/math', 'utils/type'], function (Mat, Type) {
 
         /**
          * Retrieve the smallest quad tree that contains the given point.
+         * @name JXG.Math.Quadtree#_query
          * @param {JXG.Coords|Number} xp
          * @param {Number} y
          * @returns {Boolean|JXG.Quadtree} The quad tree if the point is found, false
@@ -227,7 +235,5 @@ define(['math/math', 'utils/type'], function (Mat, Type) {
         }
     });
 
-    Mat.Quadtree = Quadtree;
-
-    return Quadtree;
+    return Mat.Quadtree;
 });

package/src/math/statistics.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,
@@ -130,6 +130,57 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
             return 0.0;
         },
 
+        /**
+         * The P-th percentile ( 0 < P ≤ 100 ) of a list of N ordered values (sorted from least to greatest)
+         * is the smallest value in the list such that no more than P percent of the data is strictly less
+         * than the value and at least P percent of the data is less than or equal to that value. See {@link https://en.wikipedia.org/wiki/Percentile}.
+         *
+         * Here, the <i>linear interpolation between closest ranks</i> method is used.
+         * @param {Array} arr The set of values, need not be ordered.
+         * @param {Number|Array} percentile One or several percentiles
+         * @returns {Number|Array} Depending if a number or an array is the input for percentile, a number or an array containing the percentils
+         * is returned.
+         */
+        percentile: function(arr, percentile) {
+            var tmp, len, i, p, res = [], per;
+
+            if (arr.length > 0) {
+                if (ArrayBuffer.isView(arr)) {
+                    tmp = new Float64Array(arr);
+                    tmp.sort();
+                } else {
+                    tmp = arr.slice(0);
+                    tmp.sort(function (a, b) {
+                        return a - b;
+                    });
+                }
+                len = tmp.length;
+
+                if (Type.isArray(percentile)) {
+                    p = percentile;
+                } else {
+                    p = [percentile];
+                }
+
+                for (i = 0; i < p.length; i++) {
+                    per = len * p[i] * 0.01;
+                    if (parseInt(per, 10) === per) {
+                        res.push( (tmp[per - 1] + tmp[per]) * 0.5 );
+                    } else {
+                        res.push( tmp[parseInt(per, 10)] );
+                    }
+                }
+
+                if (Type.isArray(percentile)) {
+                    return res;
+                } else {
+                    return res[0];
+                }
+            }
+
+            return 0.0;
+        },
+
         /**
          * Bias-corrected sample variance. A variance is a measure of how far a
          * set of numbers are spread out from each other.
@@ -234,7 +285,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
                 } else {
                     len = arr.length;
                     res = [];
-    
+
                     for (i = 0; i < len; i++) {
                         res[i] = Math.abs(arr[i]);
                     }
@@ -489,7 +540,7 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
          *     () => JXG.Math.Statistics.TheilSenRegression(a.map(el => el.coords))
          *   ],
          *   {strokeWidth:1, strokeColor:'black'});
-         * 
+         *
          * </pre><div id="JXG0a28be85-91c5-44d3-aae6-114e81217cf0" class="jxgbox" style="width: 300px; height: 300px;"></div>
          * <script type="text/javascript">
          *     (function() {
@@ -500,16 +551,16 @@ define(['jxg', 'math/math', 'utils/type'], function (JXG, Mat, Type) {
          *     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))
          *       ],
          *       {strokeWidth:1, strokeColor:'black'});
-         * 
+         *
          *     })();
-         * 
+         *
          * </script><pre>
-         * 
+         *
          */
         TheilSenRegression: function (coords) {
             var i, j,

package/src/math/symbolic.js

@@ -1,5 +1,5 @@
 /*
-    Copyright 2008-2021
+    Copyright 2008-2022
         Matthias Ehmann,
         Michael Gerhaeuser,
         Carsten Miller,