JSXGraph 1.10.1 Reference

JavaScript must be enabled in order for you to use JSXGraph and JSXGraph reference. However, it seems JavaScript is either disabled or not supported by your browser.

Namespace JXG.Math.Numerics

      ↳ JXG.Math.Numerics

Defined in: numerics.js.

Default Value:

500

Default Value:

80

Parameters:

{Array} interval

The integration interval, e.g. [0, 3].

{function} f

A function which takes one argument of type number and returns a number.

{Number} n

order

{Array} xgk

Kronrod quadrature abscissae

{Array} wg

Weights of the Gauss rule

{Array} wgk

Weights of the Kronrod rule

{Object} resultObj

Object returning resultObj.abserr, resultObj.resabs, resultObj.resasc. See the library QUADPACK for an explanation.

Returns:

{Number} Integral value of f over interval

Parameters:

{Number} x1

point 1

{Number} x2

point 2

{Number} t1

tangent slope 1

{Number} t2

tangent slope 2

Returns:

{Array} coefficents array c for the polynomial t maps to c[0] + c[1]*t + c[2]*t*t + c[3]*t*t*t

Parameters:

err

result_abs

result_asc

Parameters:

{Number} x

function argument

{function} f

JavaScript function returning a number

{String} type

Name of the Riemann sum type, e.g. 'lower', see {@see #riemann}.

{Number} delta

Width of the bars in user coordinates

Returns:

{Number} Upper (delta > 0) or lower (delta < 0) value of the bar containing x of the Riemann sum.

Parameters:

{Array} interval

The integration interval, e.g. [0, 3].

{Number} n

Max. limit

Returns:

{Object} Workspace object

Parameters:

{Array} R

Right triangular matrix represented by an array of rows. All entries a_(i,j) with i < j are ignored.

{Array} b

Right hand side of the linear equation system.

{Boolean} canModify Optional, Default: false

If true, the right hand side vector is allowed to be changed by this method.

Returns:

{Array} An array representing a vector that solves the system of linear equations.

Parameters:

{Array} points

Array consisting of 3*k+1 JXG.Points. The points at position k with k mod 3 = 0 are the data points, points at position k with k mod 3 = 1 or 2 are the control points.

Returns:

{Array} An array consisting of two functions of one parameter t which return the x resp. y coordinates of the Bezier curve in t, one zero value, and a third function accepting no parameters and returning one third of the length of the points.

Parameters:

{Array} points

Array consisting of JXG.Points.

{Number} order

Order of the B-spline curve.

Returns:

{Array} An Array consisting of four components: Two functions each of one parameter t which return the x resp. y coordinates of the B-spline curve in t, a zero value, and a function simply returning the length of the points array minus one.

Parameters:

{Array} points

Array consisting of JXG.Points.

{Number|Function} tau

The tension parameter, either a constant number or a function returning a number. This number is between 0 and 1. tau=1/2 give Catmull-Rom splines.

{String} type

(Optional) parameter which allows to choose between "uniform" (default) and "centripetal" parameterization. Thus the two possible values are "uniform" or "centripetal".

Returns:

{Array} An Array consisting of four components: Two functions each of one parameter t which return the x resp. y coordinates of the Catmull-Rom-spline curve in t, a zero value, and a function simply returning the length of the points array minus three.

Parameters:

{Array} points

Array consisting of JXG.Points.

{String} type

(Optional) parameter which allows to choose between "uniform" (default) and "centripetal" parameterization. Thus the two possible values are "uniform" or "centripetal".

Returns:

{Array} An Array consisting of four components: Two functions each of one parameter t which return the x resp. y coordinates of the Catmull-Rom-spline curve in t, a zero value, and a function simply returning the length of the points array minus three.

Parameters:

{function} f

Function, whose root is to be found

{Array|Number} x0

Start value or start interval enclosing the root

{Object} context Optional

Parent object in case f is method of it

Returns:

{Number} the approximation of the root Algorithm: Chandrupatla's method, see Tirupathi R. Chandrupatla, "A new hybrid quadratic/bisection algorithm for finding the zero of a nonlinear function without using derivatives", Advances in Engineering Software, Volume 28, Issue 3, April 1997, Pages 145-149. If x0 is an array containing lower and upper bound for the zero algorithm 748 is applied. Otherwise, if x0 is a number, the algorithm tries to bracket a zero of f starting from x0. If this fails, we fall back to Newton's method.

See:

JXG.Math.Numerics.root

JXG.Math.Numerics.fzero

Parameters:

{function} f

Function in one variable to be differentiated.

{object} obj Optional

Optional object that is treated as "this" in the function body. This is useful, if the function is a method of an object and contains a reference to its parent object via "this".

Returns:

{function} Derivative function of a given function f.

Parameters:

{Array} mat

Matrix.

Returns:

{Number} The determinant pf the matrix mat. The empty matrix returns 0.

Parameters:

{Function} f

Function, whose root is to be found

{Number} x0

Start value

{Object} context Optional

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 or [x_1, f(x_1), x_0, f(x_0)] in case that x_1 < x_0.

See:

JXG.Math.Numerics.fzero

JXG.Math.Numerics.chandrupatla

Parameters:

{function} f

{Array} x0

Start interval

{Object} context

Parent object in case f is method of it

Returns:

Array

Examples:

var f = (x) => Math.sqrt(x);
console.log(JXG.Math.Numerics.findDomain(f, [-5, 5]));

// Output: [ -0.00020428174445492973, 5 ]

Parameters:

{function} f

Function, whose minimum is to be found

{Array} x0

Start interval enclosing the minimum

{Object} context Optional

Parent object in case f is method of it

Returns:

{Number} the approximation of the minimum value position

Parameters:

{function} f

Function, whose root is to be found

{Array|Number} x0

Start value or start interval enclosing the root

{Object} context Optional

Parent object in case f is method of it

Returns:

{Number} the approximation of the root Algorithm: Brent's root finder from G.Forsythe, M.Malcolm, C.Moler, Computer methods for mathematical computations. M., Mir, 1980, p.180 of the Russian edition https://www.netlib.org/c/brent.shar If x0 is an array containing lower and upper bound for the zero algorithm 748 is applied. Otherwise, if x0 is a number, the algorithm tries to bracket a zero of f starting from x0. If this fails, we fall back to Newton's method.

See:

JXG.Math.Numerics.chandrupatla

JXG.Math.Numerics.root

Parameters:

{Array} A

Square matrix represented by an array of rows, containing the coefficients of the lineare equation system.

{Array} b

A vector containing the linear equation system's right hand side.

Throws:

{Error}

If a non-square-matrix is given or if b has not the right length or A's rank is not full.

Returns:

{Array} A vector that solves the linear equation system.

Parameters:

{Array} mat

Matrix

Returns:

Number

Parameters:

{Array} interval

The integration interval, e.g. [0, 3].

{function} f

A function which takes one argument of type number and returns a number.

{Object} resultObj

Object returning resultObj.abserr, resultObj.resabs, resultObj.resasc. See the library QUADPACK for an explanation.

Returns:

{Number} Integral value of f over interval

Parameters:

{Array} interval

The integration interval, e.g. [0, 3].

{function} f

A function which takes one argument of type number and returns a number.

{Object} resultObj

Object returning resultObj.abserr, resultObj.resabs, resultObj.resasc. See the library QUADPACK for an explanation.

Returns:

{Number} Integral value of f over interval

Parameters:

{Array} interval

The integration interval, e.g. [0, 3].

{function} f

A function which takes one argument of type number and returns a number.

{Object} resultObj

Object returning resultObj.abserr, resultObj.resabs, resultObj.resasc. See the library QUADPACK for an explanation.

Returns:

{Number} Integral value of f over interval

Parameters:

{Array} interval

The integration interval, e.g. [0, 3].

{function} f

A function which takes one argument of type number and returns a number.

{Object} config Optional

The algorithm setup. Accepted property is the order n of type number. n is allowed to take values between 2 and 18, default value is 12.

{Number} config.n Optional, Default: 16

Returns:

{Number} Integral value of f over interval

Examples:

function f(x) {
  return x*x;
}

// calculates integral of f from 0 to 2.
var area1 = JXG.Math.Numerics.GaussLegendre([0, 2], f);

// the same with an anonymous function
var area2 = JXG.Math.Numerics.GaussLegendre([0, 2], function (x) { return x*x; });

// use 16 point Gauss-Legendre rule.
var area3 = JXG.Math.Numerics.GaussLegendre([0, 2], f,
                                  {n: 16});

J = (a, b)
    (c, d)

 (d, -b)/ (ad-bc)
 (-c, a) / (ad-bc)

Parameters:

{JXG.Curve} c1

Curve, Line or Circle

{JXG.Curve} c2

Curve, Line or Circle

{Number} t1ini

start value for t1

{Number} t2ini

start value for t2

Returns:

{JXG.Coords} intersection point

Parameters:

{Array} coeffs

Coefficients of the polynomial. The position i belongs to x^i.

{Number} deg

Degree of the polynomial

{String} varname

Name of the variable (usually 'x')

{Number} prec

Precision

Returns:

{String} A string containg the function term of the polynomial.

Discussion:

This function assumes that F(X) is twice continuously differentiable over [A,B]
and that F''(X) <= M for all X in [A,B].

Licensing:
  This code is distributed under the GNU LGPL license.

Modified:

  17 April 2008

Author:

  Original FORTRAN77 version by Richard Brent.
  C version by John Burkardt.
  https://people.math.sc.edu/Burkardt/c_src/brent/brent.c

Reference:

  Richard Brent,
 Algorithms for Minimization Without Derivatives,
  Dover, 2002,
 ISBN: 0-486-41998-3,
  LC: QA402.5.B74.

Parameters:

  Input, double A, B, the endpoints of the interval.
 It must be the case that A < B.

  Input, double C, an initial guess for the global
 minimizer.  If no good guess is known, C = A or B is acceptable.

 Input, double M, the bound on the second derivative.

  Input, double MACHEP, an estimate for the relative machine
 precision.

  Input, double E, a positive tolerance, a bound for the
 absolute error in the evaluation of F(X) for any X in [A,B].

  Input, double T, a positive error tolerance.

   Input, double F (double x ), a user-supplied
 function whose global minimum is being sought.

  Output, double *X, the estimated value of the abscissa
 for which F attains its global minimum value in [A,B].

  Output, double GLOMIN, the value F(X).

Parameters:

f

x0

Parameters:

{Array} interval

The integration interval, e.g. [0, 3].

{function} f

A function which takes one argument of type number and returns a number.

Returns:

{Number} The value of the integral of f over interval

See:

JXG.Math.Numerics.NewtonCotes

JXG.Math.Numerics.Romberg

JXG.Math.Numerics.Qag

Parameters:

{Array} Ain

A symmetric 3x3 matrix.

Returns:

{Array} [A,V] the matrices A and V. The diagonal of A contains the Eigenvalues, V contains the Eigenvectors.

Parameters:

{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.

Examples:

var p = [];
p[0] = board.create('point', [-1,2], {size:4});
p[1] = board.create('point', [0,3], {size:4});
p[2] = board.create('point', [1,1], {size:4});
p[3] = board.create('point', [3,-1], {size:4});
var f = JXG.Math.Numerics.lagrangePolynomial(p);
var graph = board.create('functiongraph', [f,-10, 10], {strokeWidth:3});

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});
var txt2 = board.create('text', [-3, -6,  () => f.getCoefficients()], {fontSize: 12});

Parameters:

{Array} points

Array of JXG.Points

Returns:

{Function} returning the coefficients of the Lagrange polynomial through the supplied points.

Examples:

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_arr = JXG.Math.Numerics.lagrangePolynomialCoefficients(points);
var txt = board.create('text', [1, -4, f_arr], {fontSize: 10});

Parameters:

{Array} points

Array of JXG.Points

{Number} digits

Number of decimal digits of the coefficients

{String} param

Name of the parameter. Default: 'x'.

{String} dot

Multiplication symbol. Default: ' * '.

Returns:

{Function} returning the Lagrange polynomial term through the supplied points as string

Examples:

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});

Parameters:

{Array} p

Array of JXG.Points

Returns:

{Array} An array consisting of two functions x(t), y(t) which define a parametric curve f(t) = (x(t), y(t)), a number x1 (which equals 0) and a function x2 defining the curve's domain. That means the curve is defined between x1 and x2(). x2 returns the (length of array p minus one).

Examples:

var p = [];

p[0] = board.create('point', [0, -2], {size:2, name: 'C(a)'});
p[1] = board.create('point', [-1.5, 5], {size:2, name: ''});
p[2] = board.create('point', [1, 4], {size:2, name: ''});
p[3] = board.create('point', [3, 3], {size:2, name: 'C(b)'});

// Curve
var fg = JXG.Math.Numerics.Neville(p);
var graph = board.create('curve', fg, {strokeWidth:3, strokeOpacity:0.5});

Parameters:

{function} f

We search for a solution of f(x)=0.

{Number} x

initial guess for the root, i.e. start value.

{Object} context

optional object that is treated as "this" in the function body. This is useful if the function is a method of an object and contains a reference to its parent object via "this".

Returns:

{Number} A root of the function f.

Parameters:

{Array} interval

The integration interval, e.g. [0, 3].

{function} f

A function which takes one argument of type number and returns a number.

{Object} config Optional

The algorithm setup. Accepted properties are number_of_nodes of type number and integration_type with value being either 'trapez', 'simpson', or 'milne'.

{Number} config.number_of_nodes Optional, Default: 28

{String} config.integration_type Optional, Default: 'milne'

Possible values are 'milne', 'simpson', 'trapez'

Throws:

{Error}

If config.number_of_nodes doesn't match config.integration_type an exception is thrown. If you want to use simpson rule respectively milne rule config.number_of_nodes must be dividable by 2 respectively 4.

Returns:

{Number} Integral value of f over interval

Examples:

function f(x) {
  return x*x;
}

// calculates integral of f from 0 to 2.
var area1 = JXG.Math.Numerics.NewtonCotes([0, 2], f);

// the same with an anonymous function
var area2 = JXG.Math.Numerics.NewtonCotes([0, 2], function (x) { return x*x; });

// use trapez rule with 16 nodes
var area3 = JXG.Math.Numerics.NewtonCotes([0, 2], f,
                                  {number_of_nodes: 16, integration_type: 'trapez'});

Parameters:

{Array} a

Array of coefficients of the polynomial a[0] + a[1]*x+ a[2]*x**2... The coefficients are of type Number or JXG.Complex.

{Number} deg Optional

Optional degree of the polynomial. Otherwise all entries are taken, with leading zeros removed.

{Number} tol Optional, Default: Number.EPSILON

Approximation tolerance

{Number} max_it Optional, Default: 30

Maximum number of iterations

{Array} initial_values Optional, Default: null

Array of initial values for the roots. If not given, starting values are determined by the method of Ozawa.

Returns:

{Array} Array of complex numbers (of JXG.Complex) approximating the roots of the polynomial.

See:

JXG.Complex

JXG.C

Examples:

// Polynomial p(z) = -1 + 1z^2
var i, roots,
    p = [-1, 0, 1];

roots = JXG.Math.Numerics.polzeros(p);
for (i = 0; i < roots.length; i++) {
    console.log(i, roots[i].toString());
}
// Output:
  0 -1 + -3.308722450212111e-24i
  1 1 + 0i

// Polynomial p(z) = -1 + 3z - 9z^2 + z^3 - 8z^6 + 9z^7 - 9z^8 + z^9
var i, roots,
    p = [-1, 3, -9, 1, 0, 0, -8, 9, -9, 1];

roots = JXG.Math.Numerics.polzeros(p);
for (i = 0; i < roots.length; i++) {
    console.log(i, roots[i].toString());
}
// Output:
0 -0.7424155888401961 + 0.4950476539211721i
1 -0.7424155888401961 + -0.4950476539211721i
2 0.16674869833354108 + 0.2980502714610669i
3 0.16674869833354108 + -0.29805027146106694i
4 0.21429002063640837 + 1.0682775088132996i
5 0.21429002063640842 + -1.0682775088132999i
6 0.861375497926218 + -0.6259177003583295i
7 0.8613754979262181 + 0.6259177003583295i
8 8.000002743888055 + -1.8367099231598242e-40i

Parameters:

{Array} interval

The integration interval, e.g. [0, 3].

{function} f

A function which takes one argument of type number and returns a number.

{Object} config Optional

The algorithm setup. Accepted propert are max. recursion limit of type number, and epsrel and epsabs, the relative and absolute required precision of type number. Further, q the internal quadrature sub-algorithm of type function.

{Number} config.limit Optional, Default: 15

{Number} config.epsrel Optional, Default: 0.0000001

{Number} config.epsabs Optional, Default: 0.0000001

{Number} config.q Optional, Default: JXG.Math.Numerics.GaussKronrod15

Returns:

{Number} Integral value of f over interval

Examples:

function f(x) {
  return x*x;
}

// calculates integral of f from 0 to 2.
var area1 = JXG.Math.Numerics.Qag([0, 2], f);

// the same with an anonymous function
var area2 = JXG.Math.Numerics.Qag([0, 2], function (x) { return x*x; });

// use JXG.Math.Numerics.GaussKronrod31 rule as sub-algorithm.
var area3 = JXG.Math.Numerics.Quag([0, 2], f,
                                  {q: JXG.Math.Numerics.GaussKronrod31});

Parameters:

{Array} pts

Array of JXG.Coords

{Number} eps

If the absolute value of a given number x is smaller than eps it is considered to be equal 0.

Returns:

{Array} An array containing points which represent an apparently identical curve as the points of pts do, but contains fewer points.

Parameters:

pts

eps

Deprecated:

Use JXG.Math.Numerics.RamerDouglasPeucker

Parameters:

{Number|function|Slider} degree

number, function or slider. Either

{Array} dataX

Array containing either the x-coordinates of the data set or both coordinates in an array of JXG.Points or JXG.Coords. In the latter case, the dataY parameter will be ignored.

{Array} dataY

Array containing the y-coordinates of the data set,

Returns:

{function} A function of one parameter which returns the value of the regression polynomial of the given degree. It possesses the method getTerm() which returns the string containing the function term of the polynomial. The function returned will throw an exception, if the data set is malformed.

Parameters:

{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.

{Number} n

number of rectangles.

{String} type

Type of approximation. Possible values are: 'left', 'right', 'middle', 'lower', 'upper', 'random', 'simpson', or 'trapezoidal'. "simpson" is Simpson's 1/3 rule.

{Number} start

Left border of the approximation interval

{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 array may be used as parent array of a JXG.Curve. The third parameteris the riemann sum, i.e. the sum of the volumes of all rectangles.

Parameters:

{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 approximated by the Riemann sum.

{Number} n

number of rectangles.

{String} type

Type of approximation. Possible values are: 'left', 'right', 'middle', 'lower', 'upper', 'random', 'simpson' or 'trapezoidal'.

{Number} start

Left border of the approximation interval

{Number} end

Right border of the approximation interval

Returns:

{Number} The sum of the areas of the rectangles.

Parameters:

{Array} interval

The integration interval, e.g. [0, 3].

{function} f

A function which takes one argument of type number and returns a number.

{Object} config Optional

The algorithm setup. Accepted properties are max_iterations of type number and precision eps.

{Number} config.max_iterations Optional, Default: 20

{Number} config.eps Optional, Default: 0.0000001

Returns:

{Number} Integral value of f over interval

Examples:

function f(x) {
  return x*x;
}

// calculates integral of f from 0 to 2.
var area1 = JXG.Math.Numerics.Romberg([0, 2], f);

// the same with an anonymous function
var area2 = JXG.Math.Numerics.Romberg([0, 2], function (x) { return x*x; });

// 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});

Parameters:

{function} f

We search for a solution of f(x)=0.

{Number|Array} x

initial guess for the root, i.e. starting value, or start interval enclosing the root.

{Object} context

optional object that is treated as "this" in the function body. This is useful if the function is a method of an object and contains a reference to its parent object via "this".

Returns:

{Number} A root of the function f.

See:

JXG.Math.Numerics.chandrupatla

JXG.Math.Numerics.fzero

Parameters:

{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

{
    s: <Number>,
    A: <matrix>,
    b: <Array>,
    c: <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 . Default is 'euler'.

{Array} x0

Initial value vector. Even if the problem is one-dimensional, the initial value has to be given in an array.

{Array} I

Interval on which to integrate.

{Number} N

Number of integration intervals, i.e. there are N+1 evaluation points.

{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

dx/dt = f(t, x(t))

. So, f has to take two parameters, a number t and a vector x, and has to return a vector of the same length as x has.

Returns:

{Array} An array of vectors describing the solution of the ode on the given interval I.

Examples:

// A very simple autonomous system dx(t)/dt = x(t);
var f = function(t, x) {
    return [x[0]];
}

// Solve it with initial value x(0) = 1 on the interval [0, 2]
// with 20 evaluation points.
var data = JXG.Math.Numerics.rungeKutta('heun', [1], [0, 2], 20, f);

// Prepare data for plotting the solution of the ode using a curve.
var dataX = [];
var dataY = [];
var h = 0.1;        // (I[1] - I[0])/N  = (2-0)/20
var i;
for(i=0; i<data.length; i++) {
    dataX[i] = i*h;
    dataY[i] = data[i][0];
}
var g = board.create('curve', [dataX, dataY], {strokeWidth:'2px'});

Parameters:

{Array} x

x values of knots

{Array} y

y values of knots

Returns:

{Array} Second derivatives of the interpolated function at the knots.

See:

#splineEval

Parameters:

{Number|Array} x0

A single float value or an array of values to evaluate

{Array} x

x values of knots

{Array} y

y values of knots

{Array} F

Second derivatives at knots, calculated by JXG.Math.Numerics.splineDef

Returns:

{Number|Array} A single value or an array, depending on what is given as x0.

See:

#splineDef

Parameters:

{Array} pts

Array of JXG.Coords

{Number} numPoints

Number of remaining intermediate points. The first and the last point of the original points will be taken in any case.

Returns:

{Array} An array containing points which approximates the curve defined by pts.

Examples:

    var i, p = [];
    for (i = 0; i < 5; ++i) {
        p.push(board.create('point', [Math.random() * 12 - 6, Math.random() * 12 - 6]));
    }

    // Plot a cardinal spline curve
    var splineArr = JXG.Math.Numerics.CardinalSpline(p, 0.5);
    var cu1 = board.create('curve', splineArr, {strokeColor: 'green'});

    var c = board.create('curve', [[0],[0]], {strokeWidth: 2, strokeColor: 'black'});
    c.updateDataArray = function() {
        var i, len, points;

        // Reduce number of intermediate points with Visvakingam-Whyatt to 6
        points = JXG.Math.Numerics.Visvalingam(cu1.points, 6);
        // Plot the remaining points
        len = points.length;
        this.dataX = [];
        this.dataY = [];
        for (i = 0; i < len; i++) {
            this.dataX.push(points[i].usrCoords[1]);
            this.dataY.push(points[i].usrCoords[2]);
        }
    };
    board.update();