jsxgraph 1.14.0 → 1.14.1

package/src/element/sector.js

@@ -298,11 +298,11 @@ JXG.createSector = function (board, parents, attributes) {
                 s = el.line1.point1.coords;
             } else if (
                 el.line1.point2.Dist(el.line2.point1) < eps ||
-                el.line1.point2.Dist(el.line2.point1) < eps
+                el.line1.point2.Dist(el.line2.point2) < eps
             ) {
                 s = el.line1.point2.coords;
             } else {
-                console.log(
+                JXG.warn(
                     "JSXGraph warning: Can't create Sector from parallel lines with no common defining point."
                 );
             }
@@ -383,10 +383,13 @@ JXG.createSector = function (board, parents, attributes) {
                     B = l1.point1.coords.usrCoords;
                 } else if (
                     l1.point2.Dist(l2.point1) < eps ||
-                    l1.point2.Dist(l2.point1) < eps
+                    l1.point2.Dist(l2.point2) < eps
                 ) {
                     B = l1.point2.coords.usrCoords;
                 } else {
+                    JXG.warn(
+                        "JSXGraph warning: sector from parallel lines with no common defining point."
+                    );
                 }
             }
 

package/src/index.d.ts

@@ -5078,6 +5078,17 @@ declare namespace JXG {
             id: string | unknown | Function,
             onlyByIdOrName: boolean
         ): GeometryElement | Composition;
+        /**
+         * Sets an arbitrary number of attributes. Accepts an object (`{key1: value1, key2: value2, ...}`),
+         * a string (`'key:value'`), or an array (`['key', value]`). Some board attributes are immutable,
+         * like e.g. the renderer type.
+         * @param attr An object with attributes.
+         * @param force If true the attributes are set regardless of the previous setting was identical.
+         */
+        setAttribute(
+            attr: Partial<BoardAttributes> | string | [string, unknown],
+            force?: boolean
+        ): Board;
         /**
          *
          */

package/src/math/math.js

@@ -682,10 +682,10 @@ JXG.Math = {
     }),
 
     /**
-     * Calculates the cosine hyperbolicus of x.
+     * Calculates the hyperbolic cosine of \\(x\\).
      * @function
      * @param {Number} x The number the cosine hyperbolicus will be calculated of.
-     * @returns {Number} Cosine hyperbolicus of the given value.
+     * @returns {Number} Hyperbolic cosine of the given value.
      */
     cosh:
         Math.cosh ||
@@ -694,10 +694,10 @@ JXG.Math = {
         },
 
     /**
-     * Sine hyperbolicus of x.
+     * Hyperbolic sine of \\(x\\).
      * @function
-     * @param {Number} x The number the sine hyperbolicus will be calculated of.
-     * @returns {Number} Sine hyperbolicus of the given value.
+     * @param {Number} x The number the hyperbolic sine will be calculated of.
+     * @returns {Number} Hyperbolic sine of the given value.
      */
     sinh:
         Math.sinh ||
@@ -706,7 +706,7 @@ JXG.Math = {
         },
 
     /**
-     * Hyperbolic arc-cosine of a number.
+     * Inverse hyperbolic cosine of a number.
      * @function
      * @param {Number} x
      * @returns {Number}
@@ -718,7 +718,7 @@ JXG.Math = {
         },
 
     /**
-     * Hyperbolic arcsine of a number
+     * Inverse hyperbolic sine of a number
      * @function
      * @param {Number} x
      * @returns {Number}
@@ -795,7 +795,7 @@ JXG.Math = {
     },
 
     /**
-     * Computes cube root of real number
+     * Computes cube root of real number.
      * Polyfill for Math.cbrt().
      *
      * @function
@@ -915,7 +915,11 @@ JXG.Math = {
         },
 
     /**
-     * A square & multiply algorithm to compute base to the power of exponent.
+     * A square & multiply algorithm to compute `base` to the power of `exponent`.
+     * That is, for base \\(b\\) and integer exponent \\(e\\) it is a fast method to compute
+     * \\[ b^e .\\]
+     * For non-integer values of `exponent`, JavaScript's `Math.pow` is used.
+     *
      * Implementated by Wolfgang Riedl.
      *
      * @param {Number} base
@@ -950,16 +954,17 @@ JXG.Math = {
     },
 
     /**
-     * Greatest common divisor (gcd) of two numbers.
-     * See {@link <a href="https://rosettacode.org/wiki/Greatest_common_divisor#JavaScript">rosettacode.org</a>}.
+     * Greatest common divisor (gcd) of two finite, non-zero integer numbers.
+     * See {@link https://rosettacode.org/wiki/Greatest_common_divisor#JavaScript rosettacode.org}.
      *
-     * @param  {Number} a First number
-     * @param  {Number} b Second number
-     * @returns {Number}   gcd(a, b) if a and b are numbers, NaN else.
+     * @param  {Number} a First number, not zero, Infinity, or NaN
+     * @param  {Number} b Second number, not zero, Infinity, or NaN
+     * @returns {Number} gcd(a, b) if a and b are finite, non-zero numbers, NaN else.
+     * @see JXG.Math#lcm
      */
     gcd: function (a, b) {
         var tmp,
-            endless = true;
+            endless = 100000;
 
         a = Math.abs(a);
         b = Math.abs(b);
@@ -967,13 +972,24 @@ JXG.Math = {
         if (!(Type.isNumber(a) && Type.isNumber(b))) {
             return NaN;
         }
+        if (isNaN(a) || isNaN(b) || a === Infinity || b === Infinity) {
+            return NaN;
+        }
+        if (a === 0 || b === 0) {
+            return NaN;
+        }
+        if (!Number.isInteger(a) || !Number.isInteger(b)) {
+            JXG.warn('JSXGraph: JXG.Math.gcd requires integer parameters');
+            return NaN;
+        }
+
         if (b > a) {
             tmp = a;
             a = b;
             b = tmp;
         }
 
-        while (endless) {
+        while (endless > 0) {
             a %= b;
             if (a === 0) {
                 return b;
@@ -982,15 +998,18 @@ JXG.Math = {
             if (b === 0) {
                 return a;
             }
+            endless--;
         }
     },
 
     /**
-     * Least common multiple (lcm) of two numbers.
+     * Least common multiple (lcm) of two finite integer numbers.
+     * lcm(0, a) is defined as 0.
      *
      * @param  {Number} a First number
      * @param  {Number} b Second number
-     * @returns {Number}   lcm(a, b) if a and b are numbers, NaN else.
+     * @returns {Number} lcm(a, b) if a and b are finite integer numbers, NaN else.
+     * @see JXG.Math#gcd
      */
     lcm: function (a, b) {
         var ret;
@@ -998,6 +1017,16 @@ JXG.Math = {
         if (!(Type.isNumber(a) && Type.isNumber(b))) {
             return NaN;
         }
+        if (isNaN(a) || isNaN(b) || Math.abs(a) === Infinity || Math.abs(b) === Infinity) {
+            return NaN;
+        }
+        if (a === 0 || b === 0) {
+            return 0;
+        }
+        if (!Number.isInteger(a) || !Number.isInteger(b)) {
+            JXG.warn('JSXGraph: JXG.Math.gcd requires integer parameters');
+            return NaN;
+        }
 
         ret = a * b;
         if (ret !== 0) {
@@ -1183,7 +1212,7 @@ JXG.Math = {
     /* ********************  Comparisons and logical operators ************** */
 
     /**
-     * Logical test: a < b?
+     * Logical test: `a < b`?
      *
      * @param {Number} a
      * @param {Number} b
@@ -1194,7 +1223,7 @@ JXG.Math = {
     },
 
     /**
-     * Logical test: a <= b?
+     * Logical test: `a <= b`?
      *
      * @param {Number} a
      * @param {Number} b
@@ -1205,7 +1234,7 @@ JXG.Math = {
     },
 
     /**
-     * Logical test: a > b?
+     * Logical test: `a > b`?
      *
      * @param {Number} a
      * @param {Number} b
@@ -1216,7 +1245,7 @@ JXG.Math = {
     },
 
     /**
-     * Logical test: a >= b?
+     * Logical test: `a >= b`?
      *
      * @param {Number} a
      * @param {Number} b
@@ -1227,7 +1256,7 @@ JXG.Math = {
     },
 
     /**
-     * Logical test: a === b?
+     * Logical test: `a === b`?
      *
      * @param {Number} a
      * @param {Number} b
@@ -1238,7 +1267,7 @@ JXG.Math = {
     },
 
     /**
-     * Logical test: a !== b?
+     * Logical test: `a !== b`?
      *
      * @param {Number} a
      * @param {Number} b
@@ -1249,7 +1278,7 @@ JXG.Math = {
     },
 
     /**
-     * Logical operator: a && b?
+     * Logical operator: `a && b`?
      *
      * @param {Boolean} a
      * @param {Boolean} b
@@ -1260,7 +1289,7 @@ JXG.Math = {
     },
 
     /**
-     * Logical operator: !a?
+     * Logical operator: `!a`?
      *
      * @param {Boolean} a
      * @returns {Boolean}
@@ -1270,7 +1299,7 @@ JXG.Math = {
     },
 
     /**
-     * Logical operator: a || b?
+     * Logical operator: `a || b`?
      *
      * @param {Boolean} a
      * @param {Boolean} b
@@ -1281,7 +1310,7 @@ JXG.Math = {
     },
 
     /**
-     * Logical operator: either a or b?
+     * Logical operator: either `a` or `b`?
      *
      * @param {Boolean} a
      * @param {Boolean} b
@@ -1360,7 +1389,7 @@ JXG.Math = {
     /* *************************** Normalize *************************** */
 
     /**
-     * Normalize the standard form [c, b0, b1, a, k, r, q0, q1].
+     * Normalize the standard form `[c, b0, b1, a, k, r, q0, q1]`.
      * @private
      * @param {Array} stdform The standard form to be normalized.
      * @returns {Array} The normalized standard form.
@@ -1431,13 +1460,13 @@ JXG.Math = {
     },
 
     /**
-     * Theorem of Vieta: Given a set of simple zeroes x_0, ..., x_n
-     * of a polynomial f, compute the coefficients s_k, (k=0,...,n-1)
-     * of the polynomial of the form. See {@link https://de.wikipedia.org/wiki/Elementarsymmetrisches_Polynom}.
+     * Theorem of Vieta: Given a set of simple zeroes \\(x_0, \ldots, x_n\\)
+     * of a polynomial \\(f\\), compute the coefficients \\(s_k\\), \\(k=0, \ldots, n-1\\),
+     * of the polynomial of the form
+     * \\[ f(x) = (x-x_0)\cdots(x-x_n) = x^n + \sum_{k=1}^{n} (-1)^k s_{k-1} x^{n-k} \\]
+     *
+     * See {@link https://en.wikipedia.org/wiki/Vieta%27s_formulas}
      *
-     *  f(x) = (x-x_0)*...*(x-x_n) =
-     *  x^n + sum_{k=1}^{n} (-1)^(k) s_{k-1} x^(n-k)
-     * </p>
      * @param {Array} x Simple zeroes of the polynomial.
      * @returns {Array} Coefficients of the polynomial.
      *

package/src/math/numerics.js

@@ -509,22 +509,20 @@ Mat.Numerics = {
      * Calculates the integral of function f over interval using Romberg iteration.
      * @param {Array} interval The integration interval, e.g. [0, 3].
      * @param {function} f A function which takes one argument of type number and returns a number.
-     * @param {Object} [config] The algorithm setup. Accepted properties are max_iterations of type number and precision eps.
+     * @param {Object} [config] The algorithm setup. Accepted properties are `max_iterations` of type number and precision `eps`.
      * @param {Number} [config.max_iterations=20]
      * @param {Number} [config.eps=0.0000001]
      * @returns {Number} Integral value of f over interval
      * @example
-     * function f(x) {
-     *   return x*x;
-     * }
+     * var f = (x) => x * x;
      *
-     * // calculates integral of `f` from 0 to 2.
-     * var area1 = JXG.Math.Numerics.Romberg([0, 2], f);
+     * // Calculates integral of `f` from 0 to 3.
+     * var area1 = JXG.Math.Numerics.Romberg([0, 3], f);
      *
-     * // the same with an anonymous function
-     * var area2 = JXG.Math.Numerics.Romberg([0, 2], function (x) { return x*x; });
+     * // The same with an anonymous function
+     * var area2 = JXG.Math.Numerics.Romberg([0, 3], function (x) { return x * x; });
      *
-     * // use trapez rule with maximum of 16 iterations or stop if the precision 0.0001 has been reached.
+     * // Use trapez rule with maximum of 16 iterations or stop if the precision 0.0001 has been reached.
      * var area3 = JXG.Math.Numerics.Romberg([0, 2], f,
      *                                   {max_iterations: 16, eps: 0.0001});
      * @memberof JXG.Math.Numerics
@@ -541,8 +539,11 @@ Mat.Numerics = {
             p = [],
             integral = 0.0,
             last = Infinity,
-            m = config && Type.isNumber(config.max_iterations) ? config.max_iterations : 20,
-            eps = config && Type.isNumber(config.eps) ? config.eps : config.eps || 0.0000001;
+            m, eps;
+
+        config = Type.def(config, {});
+        m = config && Type.isNumber(config.max_iterations) ? config.max_iterations : 20;
+        eps = config && Type.isNumber(config.eps) ? config.eps : (config.eps || 0.0000001);
 
         a = interval[0];
         b = interval[1];
@@ -809,7 +810,7 @@ Mat.Numerics = {
         xm = 0.5 * (b - a);
         xp = 0.5 * (b + a);
 
-        if (n & (1 === 1)) {
+        if ((n & 1) === 1) {
             // n odd
             result = w[0] * f(xp);
             for (i = 1; i < m; ++i) {

package/src/math/statistics.js

@@ -619,12 +619,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.
@@ -632,10 +632,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))
@@ -689,7 +689,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
@@ -779,7 +779,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
@@ -791,7 +791,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.
      *
@@ -860,7 +860,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\\)
@@ -976,7 +976,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\\)
@@ -999,7 +999,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
@@ -1017,7 +1017,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
@@ -1039,7 +1039,7 @@ Mat.Statistics = {
 
     /**
      * Generate value of a random variable with Students-t-distribution with &nu; 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
@@ -1060,8 +1060,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)
@@ -1185,7 +1185,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