jsxgraph 1.9.1 → 1.9.2

package/src/math/geometry.js

@@ -1569,7 +1569,7 @@ JXG.extend(
             return func;
         },
 
-        otherIntersectionFunction: function(input, others, alwaysintersect, precision) {
+        otherIntersectionFunction: function (input, others, alwaysintersect, precision) {
             var func, board,
                 el1, el2,
                 that = this;
@@ -1577,22 +1577,22 @@ JXG.extend(
             el1 = input[0];
             el2 = input[1];
             board = el1.board;
-            func = function() {
+            func = function () {
                 var i, k, c, d,
                     isClose,
                     le = others.length,
                     eps = Type.evaluate(precision);
 
                 for (i = le; i >= 0; i--) {
-                    if (el1.elementClass ===  Const.OBJECT_CLASS_CIRCLE &&
+                    if (el1.elementClass === Const.OBJECT_CLASS_CIRCLE &&
                         [Const.OBJECT_CLASS_CIRCLE, Const.OBJECT_CLASS_LINE].indexOf(el2.elementClass) >= 0) {
                         // circle, circle|line
                         c = that.meet(el1.stdform, el2.stdform, i, board);
-                    } else if (el1.elementClass ===  Const.OBJECT_CLASS_CURVE &&
+                    } else if (el1.elementClass === Const.OBJECT_CLASS_CURVE &&
                         [Const.OBJECT_CLASS_CURVE, Const.OBJECT_CLASS_CIRCLE].indexOf(el2.elementClass) >= 0) {
                         // curve, circle|curve
                         c = that.meetCurveCurve(el1, el2, i, 0, board, 'segment');
-                    } else if (el1.elementClass ===  Const.OBJECT_CLASS_CURVE && el2.elementClass === Const.OBJECT_CLASS_LINE) {
+                    } else if (el1.elementClass === Const.OBJECT_CLASS_CURVE && el2.elementClass === Const.OBJECT_CLASS_LINE) {
                         // curve, line
                         if (Type.exists(el1.dataX)) {
                             c = JXG.Math.Geometry.meetCurveLine(el1, el2, i, el1.board, Type.evaluate(alwaysintersect));
@@ -1608,7 +1608,7 @@ JXG.extend(
                         d = c.distance(JXG.COORDS_BY_USER, others[k].coords);
                         if (d < eps) {
                             isClose = true;
-                       }
+                        }
                     }
                     if (!isClose) {
                         // We are done, the intersection is away from any other
@@ -2375,7 +2375,7 @@ JXG.extend(
         meetPlaneSphere: function (el1, el2) {
             var dis = function () {
                 return (
-                      el1.normal[0] * el2.center.X()
+                    el1.normal[0] * el2.center.X()
                     + el1.normal[1] * el2.center.Y()
                     + el1.normal[2] * el2.center.Z()
                     - el1.d
@@ -2385,13 +2385,13 @@ JXG.extend(
                 [
                     // Center
                     function () {
-                        return el2.center.X() - dis()*el1.normal[0];
+                        return el2.center.X() - dis() * el1.normal[0];
                     },
                     function () {
-                        return el2.center.Y() - dis()*el1.normal[1];
+                        return el2.center.Y() - dis() * el1.normal[1];
                     },
                     function () {
-                        return el2.center.Z() - dis()*el1.normal[2];
+                        return el2.center.Z() - dis() * el1.normal[2];
                     }
                 ],
                 [
@@ -2402,34 +2402,34 @@ JXG.extend(
                 ],
                 function () {
                     // Radius (returns NaN if spheres don't touch)
-                    let r = el2.Radius(),
+                    var r = el2.Radius(),
                         s = dis();
-                    return Math.sqrt(r*r - s*s);
+                    return Math.sqrt(r * r - s * s);
                 }
             ];
         },
 
         meetSphereSphere: function (el1, el2) {
             var skew = function () {
-                let dist = el1.center.distance(el2.center),
+                var dist = el1.center.distance(el2.center),
                     r1 = el1.Radius(),
                     r2 = el2.Radius();
-                return (r1 - r2)*(r1 + r2) / (dist*dist);
+                return (r1 - r2) * (r1 + r2) / (dist * dist);
             };
             return [
                 [
                     // Center
                     function () {
-                        let s = skew();
-                        return 0.5*((1-s)*el1.center.X() + (1+s)*el2.center.X());
+                        var s = skew();
+                        return 0.5 * ((1 - s) * el1.center.X() + (1 + s) * el2.center.X());
                     },
                     function () {
-                        let s = skew();
-                        return 0.5*((1-s)*el1.center.Y() + (1+s)*el2.center.Y());
+                        var s = skew();
+                        return 0.5 * ((1 - s) * el1.center.Y() + (1 + s) * el2.center.Y());
                     },
                     function () {
-                        let s = skew();
-                        return 0.5*((1-s)*el1.center.Z() + (1+s)*el2.center.Z());
+                        var s = skew();
+                        return 0.5 * ((1 - s) * el1.center.Z() + (1 + s) * el2.center.Z());
                     }
                 ],
                 [
@@ -2440,11 +2440,11 @@ JXG.extend(
                 ],
                 function () {
                     // Radius (returns NaN if spheres don't touch)
-                    let dist = el1.center.distance(el2.center),
+                    var dist = el1.center.distance(el2.center),
                         r1 = el1.Radius(),
                         r2 = el2.Radius(),
                         s = skew(),
-                        rIxnSq = 0.5*(r1*r1 + r2*r2 - 0.5*dist*dist*(1 + s*s));
+                        rIxnSq = 0.5 * (r1 * r1 + r2 * r2 - 0.5 * dist * dist * (1 + s * s));
                     return Math.sqrt(rIxnSq);
                 }
             ];
@@ -2854,28 +2854,19 @@ JXG.extend(
          * @param {Number} sgn Wither 1 or -1. Needed for minor and major arcs. In case of doubt, use 1.
          */
         bezierArc: function (A, B, C, withLegs, sgn) {
-            var p1,
-                p2,
-                p3,
-                p4,
+            var p1, p2, p3, p4,
                 r,
-                phi,
-                beta,
-                PI2 = Math.PI * 0.5,
+                phi, beta, delta,
+                // PI2 = Math.PI * 0.5,
                 x = B[1],
                 y = B[2],
                 z = B[0],
                 dataX = [],
                 dataY = [],
-                co,
-                si,
-                ax,
-                ay,
-                bx,
-                by,
-                k,
-                v,
-                d,
+                co, si,
+                ax, ay,
+                bx, by,
+                k, v, d,
                 matrix;
 
             r = this.distance(B, A);
@@ -2889,6 +2880,12 @@ JXG.extend(
                 phi = 2 * Math.PI - phi;
             }
 
+            // Always divide the arc into four Bezier arcs.
+            // Otherwise, the position of gliders on this arc
+            // will be wrong.
+            delta = phi / 4;
+
+
             p1 = A;
             p1[1] /= p1[0];
             p1[2] /= p1[0];
@@ -2905,9 +2902,16 @@ JXG.extend(
             }
 
             while (phi > Mat.eps) {
-                if (phi > PI2) {
-                    beta = PI2;
-                    phi -= PI2;
+                // if (phi > PI2) {
+                //     beta = PI2;
+                //     phi -= PI2;
+                // } else {
+                //     beta = phi;
+                //     phi = 0;
+                // }
+                if (phi > delta) {
+                    beta = delta;
+                    phi -= delta;
                 } else {
                     beta = phi;
                     phi = 0;
@@ -3112,8 +3116,13 @@ JXG.extend(
 
             var x = point.X(),
                 y = point.Y(),
-                t = point.position || 0.0,
-                result = this.projectCoordsToCurve(x, y, t, curve, board);
+                t = point.position,
+                result;
+
+            if (!Type.exists(t)) {
+                t = Type.evaluate(curve.visProp.curvetype) === 'functiongraph' ? x : 0.0;
+            }
+            result = this.projectCoordsToCurve(x, y, t, curve, board);
 
             // point.position = result[1];
 
@@ -3202,6 +3211,21 @@ JXG.extend(
                 newCoordsObj = new Coords(Const.COORDS_BY_USER, newCoords, board);
             } else {
                 // 'parameter', 'polar', 'functiongraph'
+
+                if (Type.evaluate(curve.visProp.curvetype) === 'functiongraph') {
+                    let dy = Math.abs(y - curve.Y(x));
+                    if (!isNaN(dy)) {
+                        minX = x - dy;
+                        maxX = x + dy;
+                    } else {
+                        minX = curve.minX();
+                        maxX = curve.maxX();
+                    }
+                } else {
+                    minX = curve.minX();
+                    maxX = curve.maxX();
+                }
+
                 /** @ignore */
                 minfunc = function (t) {
                     var dx, dy;
@@ -3215,8 +3239,6 @@ JXG.extend(
 
                 f_old = minfunc(t);
                 steps = 50;
-                minX = curve.minX();
-                maxX = curve.maxX();
 
                 delta = (maxX - minX) / steps;
                 t_new = minX;
@@ -3454,9 +3476,9 @@ JXG.extend(
 
             // adapt simplex size to parameter range
             if (dim === 1) {
-                rhobeg = 0.1*(target.range[1] - target.range[0]);
+                rhobeg = 0.1 * (target.range[1] - target.range[0]);
             } else if (dim === 2) {
-                rhobeg = 0.1*Math.min(
+                rhobeg = 0.1 * Math.min(
                     target.range_u[1] - target.range_u[0],
                     target.range_v[1] - target.range_v[0]
                 );
@@ -3473,17 +3495,17 @@ JXG.extend(
                     zDiff = p[2] - target.Z.apply(null, w);
 
                 if (n === 1) {
-                    con[0] =  w[0] - target.range[0];
+                    con[0] = w[0] - target.range[0];
                     con[1] = -w[0] + target.range[1];
                 } else if (n === 2) {
-                    con[0] =  w[0] - target.range_u[0];
+                    con[0] = w[0] - target.range_u[0];
                     con[1] = -w[0] + target.range_u[1];
-                    con[2] =  w[1] - target.range_v[0];
+                    con[2] = w[1] - target.range_v[0];
                     con[3] = -w[1] + target.range_v[1];
                 }
-                return xDiff*xDiff + yDiff*yDiff + zDiff*zDiff;
+                return xDiff * xDiff + yDiff * yDiff + zDiff * zDiff;
             };
-            Mat.Nlp.FindMinimum(_minFunc, dim, 2*dim, params, rhobeg, rhoend, iprint, maxfun);
+            Mat.Nlp.FindMinimum(_minFunc, dim, 2 * dim, params, rhobeg, rhoend, iprint, maxfun);
 
             // return [1, target.X(...params), target.Y(...params), target.Z(...params)];
             return [1, target.X.apply(null, params), target.Y.apply(null, params), target.Z.apply(null, params)];
@@ -3511,9 +3533,9 @@ JXG.extend(
 
             // adapt simplex size to parameter range
             if (dim === 1) {
-                rhobeg = 0.1*(target.range[1] - target.range[0]);
+                rhobeg = 0.1 * (target.range[1] - target.range[0]);
             } else if (dim === 2) {
-                rhobeg = 0.1*Math.min(
+                rhobeg = 0.1 * Math.min(
                     target.range_u[1] - target.range_u[0],
                     target.range_v[1] - target.range_v[0]
                 );
@@ -3529,27 +3551,27 @@ JXG.extend(
                 //         target.Z(...w)
                 //     ],
                 var c3d = [
-                        1,
-                        target.X.apply(null, w),
-                        target.Y.apply(null, w),
-                        target.Z.apply(null, w)
-                    ],
+                    1,
+                    target.X.apply(null, w),
+                    target.Y.apply(null, w),
+                    target.Z.apply(null, w)
+                ],
                     c2d = target.view.project3DTo2D(c3d),
                     xDiff = pScr[0] - c2d[1],
                     yDiff = pScr[1] - c2d[2];
 
                 if (n === 1) {
-                    con[0] =  w[0] - target.range[0];
+                    con[0] = w[0] - target.range[0];
                     con[1] = -w[0] + target.range[1];
                 } else if (n === 2) {
-                    con[0] =  w[0] - target.range_u[0];
+                    con[0] = w[0] - target.range_u[0];
                     con[1] = -w[0] + target.range_u[1];
-                    con[2] =  w[1] - target.range_v[0];
+                    con[2] = w[1] - target.range_v[0];
                     con[3] = -w[1] + target.range_v[1];
                 }
-                return xDiff*xDiff + yDiff*yDiff;
+                return xDiff * xDiff + yDiff * yDiff;
             };
-            Mat.Nlp.FindMinimum(_minFunc, dim, 2*dim, params, rhobeg, rhoend, iprint, maxfun);
+            Mat.Nlp.FindMinimum(_minFunc, dim, 2 * dim, params, rhobeg, rhoend, iprint, maxfun);
 
             // return [1, target.X(...params), target.Y(...params), target.Z(...params)];
             return [1, target.X.apply(null, params), target.Y.apply(null, params), target.Z.apply(null, params)];

package/src/math/math.js

@@ -109,6 +109,48 @@ JXG.Math = {
         return a - Math.floor(a / m) * m;
     },
 
+    /**
+     * Translate <code>x</code> into the interval <code>[a, b)</code> by adding
+     * a multiple of <code>b - a</code>.
+     * @param {Number} x
+     * @param {Number} a
+     * @param {Number} b
+     */
+    wrap: function (x, a, b) {
+        return a + this.mod(x - a, b - a);
+    },
+
+    /**
+     * Clamp <code>x</code> within the interval <code>[a, b]</code>. If
+     * <code>x</code> is below <code>a</code>, increase it to <code>a</code>. If
+     * it's above <code>b</code>, decrease it to <code>b</code>.
+     */
+    clamp: function (x, a, b) {
+        return Math.min(Math.max(x, a), b);
+    },
+
+    /**
+     * A way of clamping a periodic variable. If <code>x</code> is congruent mod
+     * <code>period</code> to a point in <code>[a, b]</code>, return that point.
+     * Otherwise, wrap it into <code>[mid - period/2, mid + period/2]</code>,
+     * where <code>mid</code> is the mean of <code>a</code> and <code>b</code>,
+     * and then clamp it to <code>[a, b]</code> from there.
+     */
+    wrapAndClamp: function (x, a, b, period) {
+        var mid = 0.5 * (a + b),
+            half_period = 0.5 * period;
+
+        return this.clamp(
+            this.wrap(
+                x,
+                mid - half_period,
+                mid + half_period
+            ),
+            a,
+            b
+        );
+    },
+
     /**
      * Initializes a vector of size <tt>n</tt> wih coefficients set to the init value (default 0)
      * @param {Number} n Length of the vector
@@ -882,7 +924,7 @@ JXG.Math = {
 
         minOr0 = min || 0;
 
-        if ( JXG.exists(step)) {
+        if (JXG.exists(step)) {
             tmp = (n - minOr0) / step;
             if (Number.isInteger(tmp)) {
                 return n;
@@ -968,7 +1010,7 @@ JXG.Math = {
      * @param {Number} a Variable number of arguments.
      * @returns Number
      */
-    hypot: function() {
+    hypot: function () {
         var i, le, a, sum;
 
         le = arguments.length;
@@ -985,7 +1027,7 @@ JXG.Math = {
      * @param {Number} x
      * @returns Number
      */
-    hstep: function(x) {
+    hstep: function (x) {
         return (x > 0.0) ? 1 :
             ((x < 0.0) ? 0.0 : 0.5);
     },
@@ -997,7 +1039,7 @@ JXG.Math = {
      * @param {Number} z
      * @returns Number
      */
-    gamma: function(z) {
+    gamma: function (z) {
         var x, y, t, i, le,
             g = 7,
             // n = 9,
@@ -1164,7 +1206,7 @@ JXG.Math = {
      * JXG.Math.decToFraction(-10.66666666666667);
      * // Result: [-1, 10, 2, 3 ]
     */
-    decToFraction: function(x, order) {
+    decToFraction: function (x, order) {
         var lead, sign, a,
             n, n1, n2,
             d, d1, d2,

package/src/options.js

@@ -2054,6 +2054,50 @@ JXG.Options = {
          */
         needsRegularUpdate: true,
 
+        /**
+         * If some size of an element is controlled by a function, like the circle radius
+         * or segments of fixed length, this attribute controls what happens if the value
+         * is negative. By default, the absolute value is taken. If true, the maximum
+         * of 0 and the value is used.
+         *
+         * @type Boolean
+         * @default false
+         * @name JXG.GeometryElement#nonnegativeOnly
+         * @example
+         * var slider = board.create('slider', [[4, -3], [4, 3], [-4, 1, 4]], { name: 'a'});
+         * var circle = board.create('circle', [[-1, 0], 1], {
+         *     nonnegativeOnly: true
+         * });
+         * circle.setRadius('a');         // Use JessieCode
+         * var seg = board.create('segment', [[-4, 3], [0, 3], () => slider.Value()], {
+         *     point1: {visible: true},
+         *     point2: {visible: true},
+         *     nonnegativeOnly: true
+         * });
+         *
+         * </pre><div id="JXG9cb76224-1f78-4488-b20f-800788768bc9" class="jxgbox" style="width: 300px; height: 300px;"></div>
+         * <script type="text/javascript">
+         *     (function() {
+         *         var board = JXG.JSXGraph.initBoard('JXG9cb76224-1f78-4488-b20f-800788768bc9',
+         *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
+         *     var slider = board.create('slider', [[4, -3], [4, 3], [-4, 1, 4]], { name: 'a'});
+         *     var circle = board.create('circle', [[-1, 0], 1], {
+         *         nonnegativeOnly: true
+         *     });
+         *     circle.setRadius('a');         // Use JessieCode
+         *     var seg = board.create('segment', [[-4, 3], [0, 3], () => slider.Value()], {
+         *         point1: {visible: true},
+         *         point2: {visible: true},
+         *         nonnegativeOnly: true
+         *     });
+         *
+         *     })();
+         *
+         * </script><pre>
+         *
+         */
+        nonnegativeOnly: false,
+
         /**
          * Precision options for JSXGraph elements.
          * This attributes takes either the value 'inherit' or an object of the form:
@@ -4410,6 +4454,7 @@ JXG.Options = {
         label: {
             position: 'urt'
         }
+
         /**#@-*/
     },
 

package/src/options3d.js

@@ -31,7 +31,7 @@ JXG.extend(Options, {
          * @type Line3D
          * @name View3D#xAxis
          */
-        xAxis: { visible: true, point2: { name: "x" } },
+        xAxis: { visible: true, point2: { name: "x" }, strokeColor: JXG.palette.red },
 
         /**
          * Attributes of the 3D y-axis.
@@ -39,7 +39,7 @@ JXG.extend(Options, {
          * @type Line3D
          * @name View3D#yAxis
          */
-        yAxis: { visible: true, point2: { name: "y" } },
+        yAxis: { visible: true, point2: { name: "y" }, strokeColor: JXG.palette.green },
 
         /**
          * Attributes of the 3D z-axis.
@@ -47,7 +47,7 @@ JXG.extend(Options, {
          * @type Line3D
          * @name View3D#zAxis
          */
-        zAxis: { visible: true, point2: { name: "z" } },
+        zAxis: { visible: true, point2: { name: "z" }, strokeColor: JXG.palette.blue },
 
         // Planes
         /**
@@ -492,7 +492,7 @@ JXG.extend(Options, {
             },
             continuous: true,
             slider: {
-                visible: true,
+                visible: 'inherit',
                 style: 6,
                 point1: { frozen: true },
                 point2: { frozen: true },
@@ -560,7 +560,7 @@ JXG.extend(Options, {
             },
             continuous: true,
             slider: {
-                visible: true,
+                visible: 'inherit',
                 style: 6,
                 point1: { frozen: true },
                 point2: { frozen: true },
@@ -570,6 +570,74 @@ JXG.extend(Options, {
             }
         },
 
+        /**
+         * Specify the user handling of the bank angle.
+         * <ul>
+         *  <li><tt>pointer</tt> sub-attributes:
+         *      <ul>
+         *          <li><tt>enabled</tt>: Boolean that specifies whether pointer navigation is allowed by elevation.
+         *          <li><tt>speed</tt>: Number indicating how many passes the range of the el_slider makes when the cursor crosses the entire board once in the horizontal direction.
+         *          <li><tt>outside</tt>: Boolean that specifies whether the pointer navigation is continued when the cursor leaves the board.
+         *          <li><tt>button</tt>: Which button of the pointer should be used? (<tt>'-1'</tt> (=no button), <tt>'0'</tt> or <tt>'2'</tt>)
+         *          <li><tt>key</tt>: Should an additional key be pressed? (<tt>'none'</tt>, <tt>'shift'</tt> or <tt>'ctrl'</tt>)
+         *      </ul>
+         *  <li><tt>keyboard</tt> sub-attributes:
+         *      <ul>
+         *          <li><tt>enabled</tt>: Boolean that specifies whether the keyboard (arrow keys) can be used to navigate the board.
+         *          <li><tt>step</tt>: Size of the step per keystroke.
+         *          <li><tt>key</tt>: Should an additional key be pressed? (<tt>'none'</tt>, <tt>'shift'</tt> or <tt>'ctrl'</tt>)
+         *      </ul>
+         *  <li><tt>continuous</tt>: Boolean that specifies whether the el_slider starts again from the beginning when its end is reached.
+         *  <li><tt>slider</tt> attributes of the el_slider ({@link Slider}) with additional
+         *      <ul>
+         *          <li><tt>min</tt>: Minimum value.
+         *          <li><tt>max</tt>: Maximum value.
+         *          <li><tt>start</tt>: Start value.
+         *      </ul>
+         * </ul>
+         *
+         * @name View3D#bank
+         * @type Object
+         * @default <pre>{
+         *      pointer: {enabled: true, speed: 1, outside: true, button: -1, key: 'none'},
+         *      keyboard: {enabled: true, step: 10, key: 'ctrl'},
+         *      continuous: true,
+         *      slider: {
+         *          visible: true,
+         *          style: 6,
+         *          point1: {frozen: true},
+         *          point2: {frozen: true},
+         *          min: 0,
+         *          max: 2 * Math.PI,
+         *          start: 0.3
+         *      },
+         * }<pre>
+         */
+        bank: {
+            pointer: {
+                enabled: true,
+                speed: 0.08,
+                outside: true,
+                button: -1,
+                key: 'none'
+            },
+            keyboard: {
+                enabled: true,
+                step: 10,
+                key: 'ctrl'
+            },
+            continuous: true,
+            slider: {
+                visible: 'inherit',
+                style: 6,
+                point1: { frozen: true },
+                point2: { frozen: true },
+                min: -Math.PI,
+                max:  Math.PI,
+                start: 0.0
+            }
+        },
+
         trackball: {
             enabled: false,
             outside: true,
@@ -594,6 +662,15 @@ JXG.extend(Options, {
          */
         fov: 1 / 5 * 2 * Math.PI,
 
+        /**
+         * When this option is enabled, points closer to the screen are drawn
+         * over points further from the screen within each layer.
+         *
+         * @name View3D#depthOrderPoints
+         * @default false
+         */
+        depthOrderPoints: false,
+
         /**
          * Fixed values for the view, which can be changed using keyboard keys `picture-up` and `picture-down`.
          * Array of the form: [[el0, az0, r0], [el1, az1, r1, ...[eln, azn, rn]]

package/src/parser/jessiecode.js

@@ -1110,7 +1110,8 @@ JXG.extend(JXG.JessieCode.prototype, /** @lends JXG.JessieCode.prototype */ {
 
         // The $()-function-calls are special because their parameter is given as a string, not as a node_var.
         if (node.type === 'node_op' && node.value === 'op_execfun' &&
-            node.children.length > 1 && node.children[0].value === '$' &&
+            node.children.length > 1 &&
+            (node.children[0].value === '$' || node.children[0].value === '$value') &&
             node.children[1].length > 0) {
 
             e = node.children[1][0].value;

package/src/parser/prefix.js

@@ -156,12 +156,19 @@ JXG.PrefixParser = {
                     throw new Error("PrefixParser.parse: " + fun + " is not allowed");
                 }
             } else {
-                // Allow shortcut 'V' for 'Value'
                 fun = term[0];
+
+                // Allow shortcut 'V' for 'Value'
                 if (fun === 'V') {
                     fun = 'Value';
                 }
 
+                // get coords always with z
+                // (its visibility is controlled by the attribute function formatCoords)
+                if (fun === 'Coords') {
+                    term[2] = 'true';
+                }
+
                 if (!Type.exists(term[1][fun])) {
                     throw new Error("PrefixParser.parse: " + fun + " is not a method of " + term[1]);
                 }