jsxgraph 1.6.0 → 1.6.1

package/src/element/checkbox.js

@@ -131,36 +131,36 @@ var priv = {
  * }, checkbox);
  * })();
  * </script><pre>
- *
  * @example
- *         var i1 = board.create('input', [-3, 4, 'sin(x)', 'f(x)='], {cssStyle: 'width:4em', maxlength: 2});
- *         var c1 = board.create('checkbox', [-3, 2, 'label 1'], {});
- *         var b1 = board.create('button', [-3, -1, 'Change texts', function () {
- *                 i1.setText('g(x)');
+ *     var i1 = board.create('input', [1, 5, 'sin(x)', 'f(x)='], {cssStyle: 'width:4em', maxlength: 2});
+ *         var c1 = board.create('checkbox', [1, 3, 'label 1'], {});
+ *         var b1 = board.create('button', [1, 1, 'Change texts', function () {
+ *                 i1.setText('g(x)=');
  *                 i1.set('cos(x)');
  *                 c1.setText('label 2');
  *                 b1.setText('Texts are changed');
  *             }],
- *             {cssStyle: 'width:400px'});
- *
- * </pre><div id="JXG11cac8gg-2354-47e7-9da4-eb298e53de05" class="jxgbox" style="width: 300px; height: 300px;"></div>
+ *             {cssStyle: 'width:200px'});
+ * 
+ * </pre><div id="JXG31c6d070-354b-4f09-aab9-9aaa796f730c" class="jxgbox" style="width: 300px; height: 300px;"></div>
  * <script type="text/javascript">
  *     (function() {
- *         var board = JXG.JSXGraph.initBoard('JXG11cac8gg-2354-47e7-9da4-eb298e53de05',
- *             {boundingbox: [-8, 8, 8,-8], axis: true, showcopyright: false, shownavigation: false});
- *             var i1 = board.create('input', [-3, 4, 'sin(x)', 'f(x)='], {cssStyle: 'width:4em', maxlength: 2});
- *             var c1 = board.create('checkbox', [-3, 2, 'label 1'], {});
- *             var b1 = board.create('button', [-3, -1, 'Change texts', function () {
- *                     i1.setText('g(x)');
+ *         var board = JXG.JSXGraph.initBoard('JXG31c6d070-354b-4f09-aab9-9aaa796f730c',
+ *             {boundingbox: [-1, 7, 7, -1], axis: true, showcopyright: false, shownavigation: false});
+ *         var i1 = board.create('input', [1, 5, 'sin(x)', 'f(x)='], {cssStyle: 'width:4em', maxlength: 2});
+ *             var c1 = board.create('checkbox', [1, 3, 'label 1'], {});
+ *             var b1 = board.create('button', [1, 1, 'Change texts', function () {
+ *                     i1.setText('g(x)=');
  *                     i1.set('cos(x)');
  *                     c1.setText('label 2');
  *                     b1.setText('Texts are changed');
  *                 }],
- *                 {cssStyle: 'width:400px'});
- *
+ *                 {cssStyle: 'width:200px'});
+ * 
  *     })();
- *
+ * 
  * </script><pre>
+ * 
  */
 JXG.createCheckbox = function (board, parents, attributes) {
     var t,

package/src/element/slider.js

@@ -168,6 +168,7 @@ JXG.createSlider = function (board, parents, attributes) {
         ticks, ti, t,
         startx, starty,
         withText, withTicks,
+        snapValues, snapValueDistance,
         snapWidth, sw, s,
         attr;
 
@@ -175,6 +176,8 @@ JXG.createSlider = function (board, parents, attributes) {
     withTicks = attr.withticks;
     withText = attr.withlabel;
     snapWidth = attr.snapwidth;
+    snapValues = attr.snapvalues;
+    snapValueDistance = attr.snapvaluedistance;
 
     // start point
     attr = Type.copyAttributes(attributes, board.options, "slider", "point1");
@@ -211,7 +214,7 @@ JXG.createSlider = function (board, parents, attributes) {
     attr.withLabel = false;
     // gliders set snapwidth=-1 by default (i.e. deactivate them)
     p3 = board.create("glider", [startx, starty, l1], attr);
-    p3.setAttribute({ snapwidth: snapWidth });
+    p3.setAttribute({ snapwidth: snapWidth, snapvalues: snapValues, snapvaluedistance: snapValueDistance });
 
     // Segment from start point to glider point: highline
     attr = Type.copyAttributes(attributes, board.options, "slider", "highline");
@@ -226,7 +229,18 @@ JXG.createSlider = function (board, parents, attributes) {
      */
     p3.Value = function () {
         var sdiff = this._smax - this._smin,
-            ev_sw = Type.evaluate(this.visProp.snapwidth);
+            ev_sw = Type.evaluate(this.visProp.snapwidth),
+            snapValues, i, v;
+
+        snapValues = Type.evaluate(this.visProp.snapvalues);
+        if (Type.isArray(snapValues)) {
+            for (i=0; i < snapValues.length; i++) {
+                v = (snapValues[i] - this._smin) / (this._smax - this._smin);
+                if(this.position === v) {
+                    return snapValues[i];
+                }
+            }
+        }
 
         return ev_sw === -1
             ? this.position * sdiff + this._smin

package/src/math/heap.js

@@ -33,10 +33,17 @@
 /*jslint nomen: true, plusplus: true*/
 
 import Mat from "./math";
-import Type from "../utils/type";
 
 /**
- * Heap
+ * Instantiate a new heap.
+ * Elements of the heap are objects (node) with a property <tt>v</tt>.
+ * <p>
+ * The heap nodes are stored in a JavaScript array.
+ *
+ * @name JXG.Math.Heap
+ * @exports Mat.Heap as JXG.Math.Heap
+ *
+ * @constructor
  */
 Mat.Heap = function () {
     this.pq = [];
@@ -44,19 +51,28 @@ Mat.Heap = function () {
 };
 
 /**
- * public
+ * Clear the heap, i.e. remove all nodes.
  */
 Mat.Heap.prototype.empty = function () {
     this.pq = [];
     this.N = 0;
 };
 
+/**
+ * Insert element <tt>node</tt>into heap. An element is an object having at least the property <tt>v</tt>.
+ * @param {Object} node
+ */
 Mat.Heap.prototype.insert = function (node) {
     this.pq[this.N] = node;
     this.N++;
     this.fixUp(this.N);
 };
 
+/**
+ * Remove and return largest node in heap.
+ *
+ * @returns largest (in respect to property <tt>v</tt>) node
+ */
 Mat.Heap.prototype.delmax = function () {
     this.exchange(0, this.N - 1);
     this.fixDown(0, this.N - 1);
@@ -66,7 +82,9 @@ Mat.Heap.prototype.delmax = function () {
 };
 
 /**
- * private
+ * Restore heap properties from position k, i.e. positions < k.
+ * @param {Number} k
+ * @private
  */
 Mat.Heap.prototype.fixUp = function (k) {
     var i = k - 1;
@@ -77,9 +95,16 @@ Mat.Heap.prototype.fixUp = function (k) {
     }
 };
 
+/**
+ * Restore heap properties between positions k and N.
+ * @param {Number} k
+ * @param {Number} N
+ * @private
+ */
 Mat.Heap.prototype.fixDown = function (k, N) {
     var j,
         i = k;
+
     while (2 * i < N) {
         j = 2 * i;
 
@@ -96,6 +121,11 @@ Mat.Heap.prototype.fixDown = function (k, N) {
     }
 };
 
+/**
+ * Swap heap elements at position i and j
+ * @param {Number} i
+ * @param {Number} j
+ */
 Mat.Heap.prototype.exchange = function (i, j) {
     var t = this.pq[i];
     this.pq[i] = this.pq[j];

package/src/math/numerics.js

@@ -2960,12 +2960,18 @@ Mat.Numerics = {
     /**
      * Helper function to create curve which displays Riemann sums.
      * Compute coordinates for the rectangles showing the Riemann sum.
+     * <p>
+     * In case of type "simpson" and "trapezoidal", the horizontal line approximating the function value 
+     * is replaced by a parabola or a secant. IN case of "simpson", 
+     * the parabola is approximated visually by a polygonal chain of fixed step width. 
+     * 
      * @param {Function,Array} f Function or array of two functions.
      * If f is a function the integral of this function is approximated by the Riemann sum.
      * If f is an array consisting of two functions the area between the two functions is filled
      * by the Riemann sum bars.
      * @param {Number} n number of rectangles.
      * @param {String} type Type of approximation. Possible values are: 'left', 'right', 'middle', 'lower', 'upper', 'random', 'simpson', or 'trapezoidal'.
+     * "simpson" is Simpson's 1/3 rule.
      * @param {Number} start Left border of the approximation interval
      * @param {Number} end Right border of the approximation interval
      * @returns {Array} An array of two arrays containing the x and y coordinates for the rectangles showing the Riemann sum. This
@@ -2974,18 +2980,14 @@ Mat.Numerics = {
      * @memberof JXG.Math.Numerics
      */
     riemann: function (gf, n, type, start, end) {
-        var i,
-            delta,
+        var i, delta,
+            k, a, b, c, f0, f1, f2, xx, h,
+            steps = 30, // Fixed step width for Simpson's rule
             xarr = [],
             yarr = [],
-            j = 0,
             x = start,
-            y,
             sum = 0,
-            f,
-            g,
-            ylow,
-            yup;
+            y, f, g;
 
         if (Type.isArray(gf)) {
             g = gf[0];
@@ -3002,61 +3004,94 @@ Mat.Numerics = {
 
         delta = (end - start) / n;
 
-        // Upper bar ends
-        for (i = 0; i < n; i++) {
-            y = this._riemannValue(x, f, type, delta);
-            xarr[j] = x;
-            yarr[j] = y;
-
-            j += 1;
-            x += delta;
-            if (type === "trapezoidal") {
-                y = f(x);
-            }
-            xarr[j] = x;
-            yarr[j] = y;
-
-            j += 1;
-        }
-
-        // Lower bar ends
+        // "Upper" horizontal line defined by function
         for (i = 0; i < n; i++) {
-            if (g) {
-                y = this._riemannValue(x, g, type, -delta);
+            if (type === "simpson") {
+                sum += this._riemannValue(x, f, type, delta) * delta;
+
+                h = delta * 0.5;
+                f0 = f(x);
+                f1 = f(x + h);
+                f2 = f(x + 2 * h);
+
+                a = (f2 + f0 - 2 * f1) / (h * h) * 0.5;
+                b = (f2 - f0) / (2 * h);
+                c = f1;
+                for (k = 0; k < steps; k++) {
+                    xx = k * delta / steps - h;
+                    xarr.push(x + xx + h);
+                    yarr.push(a * xx * xx + b * xx + c);
+                }
+                x += delta;
+                y = f2;
             } else {
-                y = 0.0;
-            }
-            xarr[j] = x;
-            yarr[j] = y;
+                y = this._riemannValue(x, f, type, delta);
+                xarr.push(x);
+                yarr.push(y);
+
+                x += delta;
+                if (type === "trapezoidal") {
+                    f2 = f(x);
+                    sum += (y + f2) * 0.5 * delta;
+                    y = f2;
+                } else {
+                    sum += y * delta;
+                }
 
-            j += 1;
-            x -= delta;
-            if (type === "trapezoidal" && g) {
-                y = g(x);
+                xarr.push(x);
+                yarr.push(y);
             }
-            xarr[j] = x;
-            yarr[j] = y;
+            xarr.push(x);
+            yarr.push(y);
+        }
 
-            // Add the area of the bar to 'sum'
-            if (type !== "trapezoidal") {
-                ylow = y;
-                yup = yarr[2 * (n - 1) - 2 * i];
+        // "Lower" horizontal line
+        // Go backwards
+        for (i = 0; i < n; i++) {
+            if (type === "simpson" && g) {
+                sum -= this._riemannValue(x, g, type, -delta) * delta;
+
+                h = delta * 0.5;
+                f0 = g(x);
+                f1 = g(x - h);
+                f2 = g(x - 2 * h);
+
+                a = (f2 + f0 - 2 * f1) / (h * h) * 0.5;
+                b = (f2 - f0) / (2 * h);
+                c = f1;
+                for (k = 0; k < steps; k++) {
+                    xx = k * delta / steps - h;
+                    xarr.push(x - xx - h);
+                    yarr.push(a * xx * xx + b * xx + c);
+                }
+                x -= delta;
+                y = f2;
             } else {
-                yup = 0.5 * (f(x + delta) + f(x));
                 if (g) {
-                    ylow = 0.5 * (g(x + delta) + g(x));
+                    y = this._riemannValue(x, g, type, -delta);
                 } else {
-                    ylow = 0.0;
+                    y = 0.0;
+                }
+                xarr.push(x);
+                yarr.push(y);
+
+                x -= delta;
+                if (g) {
+                    if (type === "trapezoidal") {
+                        f2 = g(x);
+                        sum -= (y + f2) * 0.5 * delta;
+                        y = f2;
+                    } else {
+                        sum -= y * delta;
+                    }
                 }
             }
-            sum += (yup - ylow) * delta;
+            xarr.push(x);
+            yarr.push(y);
 
             // Draw the vertical lines
-            j += 1;
-            xarr[j] = x;
-            yarr[j] = yarr[2 * (n - 1) - 2 * i];
-
-            j += 1;
+            xarr.push(x);
+            yarr.push(f(x));
         }
 
         return [xarr, yarr, sum];
@@ -3082,12 +3117,12 @@ Mat.Numerics = {
      * @memberof JXG.Math.Numerics
      */
     riemannsum: function (f, n, type, start, end) {
-        JXG.deprecated("Numerics.riemannsum()", "Numerics.riemann()");
+        JXG.deprecated("Numerics.riemannsum()", "Numerics.riemann()[2]");
         return this.riemann(f, n, type, start, end)[2];
     },
 
     /**
-     * Solve initial value problems numerically using Runge-Kutta-methods.
+     * Solve initial value problems numerically using <i>explicit</i> Runge-Kutta methods.
      * See {@link https://en.wikipedia.org/wiki/Runge-Kutta_methods} for more information on the algorithm.
      * @param {object,String} butcher Butcher tableau describing the Runge-Kutta method to use. This can be either a string describing
      * a Runge-Kutta method with a Butcher tableau predefined in JSXGraph like 'euler', 'heun', 'rk4' or an object providing the structure
@@ -3099,18 +3134,20 @@ Mat.Numerics = {
      *     c: &lt;Array&gt;
      * }
      * </pre>
-     * which corresponds to the Butcher tableau structure shown here: https://en.wikipedia.org/w/index.php?title=List_of_Runge%E2%80%93Kutta_methods&oldid=357796696
-     * @param {Array} x0 Initial value vector. If the problem is of one-dimensional, the initial value also has to be given in an array.
+     * which corresponds to the Butcher tableau structure
+     * shown here: https://en.wikipedia.org/w/index.php?title=List_of_Runge%E2%80%93Kutta_methods&oldid=357796696 .
+     * <i>Default</i> is 'euler'.
+     * @param {Array} x0 Initial value vector. Even if the problem is one-dimensional, the initial value has to be given in an array.
      * @param {Array} I Interval on which to integrate.
-     * @param {Number} N Number of evaluation points.
+     * @param {Number} N Number of integration intervals, i.e. there are <i>N+1</i> evaluation points.
      * @param {function} f Function describing the right hand side of the first order ordinary differential equation, i.e. if the ode
-     * is given by the equation <pre>dx/dt = f(t, x(t)).</pre> So f has to take two parameters, a number <tt>t</tt> and a
-     * vector <tt>x</tt>, and has to return a vector of the same dimension as <tt>x</tt> has.
+     * is given by the equation <pre>dx/dt = f(t, x(t))</pre>. So, f has to take two parameters, a number <tt>t</tt> and a
+     * vector <tt>x</tt>, and has to return a vector of the same length as <tt>x</tt> has.
      * @returns {Array} An array of vectors describing the solution of the ode on the given interval I.
      * @example
      * // A very simple autonomous system dx(t)/dt = x(t);
-     * function f(t, x) {
-     *     return x;
+     * var f = function(t, x) {
+     *     return [x[0]];
      * }
      *
      * // Solve it with initial value x(0) = 1 on the interval [0, 2]
@@ -3121,7 +3158,8 @@ Mat.Numerics = {
      * var dataX = [];
      * var dataY = [];
      * var h = 0.1;        // (I[1] - I[0])/N  = (2-0)/20
-     * for(var i=0; i&lt;data.length; i++) {
+     * var i;
+     * for(i=0; i&lt;data.length; i++) {
      *     dataX[i] = i*h;
      *     dataY[i] = data[i][0];
      * }
@@ -3129,7 +3167,7 @@ Mat.Numerics = {
      * </pre><div class="jxgbox" id="JXGd2432d04-4ef7-4159-a90b-a2eb8d38c4f6" style="width: 300px; height: 300px;"></div>
      * <script type="text/javascript">
      * var board = JXG.JSXGraph.initBoard('JXGd2432d04-4ef7-4159-a90b-a2eb8d38c4f6', {boundingbox: [-1, 5, 5, -1], axis: true, showcopyright: false, shownavigation: false});
-     * function f(t, x) {
+     * var f = function(t, x) {
      *     // we have to copy the value.
      *     // return x; would just return the reference.
      *     return [x[0]];
@@ -3148,11 +3186,7 @@ Mat.Numerics = {
      */
     rungeKutta: function (butcher, x0, I, N, f) {
         var e,
-            i,
-            j,
-            k,
-            l,
-            s,
+            i, j, k, l, s,
             x = [],
             y = [],
             h = (I[1] - I[0]) / N,
@@ -3167,17 +3201,19 @@ Mat.Numerics = {
         s = butcher.s;
 
         // don't change x0, so copy it
-        for (e = 0; e < dim; e++) {
-            x[e] = x0[e];
-        }
+        // for (e = 0; e < dim; e++) {
+        //     x[e] = x0[e];
+        // }
+        x = x0.slice();
 
-        for (i = 0; i < N; i++) {
+        for (i = 0; i <= N; i++) {
             // Optimization doesn't work for ODEs plotted using time
             //        if((i % quotient == 0) || (i == N-1)) {
-            result[r] = [];
-            for (e = 0; e < dim; e++) {
-                result[r][e] = x[e];
-            }
+            // result[r] = [];
+            // for (e = 0; e < dim; e++) {
+            //     result[r][e] = x[e];
+            // }
+            result[r] = x.slice();
 
             r += 1;
             k = [];
@@ -3250,7 +3286,7 @@ Mat.Numerics = {
      * @param {Function} f Function, whose root is to be found
      * @param {Number} x0 Start value
      * @param {Object} object Parent object in case f is method of it
-     * @returns {Array} [x_0, f(x_0), x_1, f(x_1)] in case that x_0 <= x_1 
+     * @returns {Array} [x_0, f(x_0), x_1, f(x_1)] in case that x_0 <= x_1
      *   or [x_1, f(x_1), x_0, f(x_0)] in case that x_1 < x_0.
      *
      * @see JXG.Math.Numerics.fzero