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.

Class Index | File Index

Elements

Classes


Namespace JXG.Math.Plot


      ↳ JXG.Math.Plot



Defined in: plot.js.

Namespace Summary
Constructor Attributes Constructor Name and Description
 
Functions for plotting of curves.
Field Summary
Field Attributes Field Name and Description
<static>  
JXG.Math.Plot.criticalThreshold
If the absolute maximum of the set of differences is larger than criticalThreshold * median of these values, it is regarded as critical point.
<static>  
JXG.Math.Plot.steps
Number of equidistant points where the function is evaluated
Method Summary
Method Attributes Method Name and Description
<private> <static>  
JXG.Math.Plot._borderCase(curve, a, b, c, ta, tb, tc, depth)
Investigate a function term at the bounds of intervals where the function is not defined, e.g.
<private> <static>  
JXG.Math.Plot._findStartPoint(curve, ta, b, tb, tb)
For a curve c(t) defined on the interval [ta, tb] find the first point which is in the visible area of the board (plus some outside margin).
<private> <static>  
JXG.Math.Plot._getBorderPos(curve, a, b, c, ta, tb, tc, depth)
Investigate a function term at the bounds of intervals where the function is not defined, e.g.
<private> <static>  
JXG.Math.Plot._getCuspPos(curve, ta, tb)
<private> <static>  
JXG.Math.Plot._getJumpPos(curve, ta, tb)
<private> <static>  
JXG.Math.Plot._getLimes(curve, a, tc, c, tb, b, may_be_special, depth, depth)
<private> <static>  
JXG.Math.Plot._getLimits(curve, t)
<private> <static>  
JXG.Math.Plot._insertLimesPoint(curve, pnt, t, depth, limes)
<private> <static>  
JXG.Math.Plot._insertPoint(curve, pnt, t, depth, limes)
Add a point to the curve plot.
<private> <static>  
JXG.Math.Plot._insertPoint_v2(pnt, pnt, t)
Add a point to the curve plot.
<private> <static>  
JXG.Math.Plot._isOutside(a, ta, b, tb, board)
Decide if a path segment is too far from the canvas that we do not need to draw it.
<private> <static>  
JXG.Math.Plot._isOutsidePoint(a, board)
Decide if a point of a curve is too far from the canvas that we do not need to draw it.
<private> <static>  
JXG.Math.Plot._isUndefined(curve, a, ta, b, tb)
Test if the function is undefined on an interval: If the interval borders a and b are undefined, 20 random values are tested if they are undefined, too.
<private> <static>  
JXG.Math.Plot._plotNonRecursive(curve, a, ta, b, tb, depth, delta)
Recursive interval bisection algorithm for curve plotting.
<private> <static>  
JXG.Math.Plot._plotRecursive_v2(curve, a, ta, b, tb, depth, delta)
Recursive interval bisection algorithm for curve plotting.
<private> <static>  
JXG.Math.Plot._triangleDists(a, b, c)
Compute distances in screen coordinates between the points ab, ac, cb, and cd, where d = (a + b)/2.
<static>  
JXG.Math.Plot.checkReal(points)
Check if at least one point on the curve is finite and real.
<private> <static>  
JXG.Math.Plot.isDistOK(dx, dy, MAXX, MAXY)
Compares the absolute value of dx with MAXX and the absolute value of dy with MAXY.
<private> <static>  
JXG.Math.Plot.isSegmentDefined(x0, y0, x1, y1)
<private> <static>  
JXG.Math.Plot.isSegmentOutside(x0, y0, x1, y1, board)
Crude and cheap test if the segment defined by the two points (x0, y0) and (x1, y1) is outside the viewport of the board.
<static>  
JXG.Math.Plot.updateParametricCurve(curve, mi, ma)
Updates the data points of a parametric curve.
<static>  
JXG.Math.Plot.updateParametricCurve_v2(curve, mi, ma)
Updates the data points of a parametric curve.
<static>  
JXG.Math.Plot.updateParametricCurveNaive(curve, mi, ma, len)
Updates the data points of a parametric curve.
<static>  
JXG.Math.Plot.updateParametricCurveOld(curve, mi, ma)
Updates the data points of a parametric curve.
Namespace Detail
JXG.Math.Plot
Functions for plotting of curves.
Field Detail
<static> JXG.Math.Plot.criticalThreshold
If the absolute maximum of the set of differences is larger than criticalThreshold * median of these values, it is regarded as critical point.
See:
JXG.Math.Plot#_criticalInterval

<static> JXG.Math.Plot.steps
Number of equidistant points where the function is evaluated
Method Detail
<private> <static> {JXG.Boolean} JXG.Math.Plot._borderCase(curve, a, b, c, ta, tb, tc, depth)
Investigate a function term at the bounds of intervals where the function is not defined, e.g. log(x) at x = 0. c is inbetween a and b
Parameters:
{JXG.Curve} curve
JSXGraph curve element
{Array} a
Screen coordinates of the left interval bound
{Array} b
Screen coordinates of the right interval bound
{Array} c
Screen coordinates of the bisection point at (ta + tb) / 2
{Number} ta
Parameter which evaluates to a, i.e. [1, X(ta), Y(ta)] = a in screen coordinates
{Number} tb
Parameter which evaluates to b, i.e. [1, X(tb), Y(tb)] = b in screen coordinates
{Number} tc
(ta + tb) / 2 = tc. Parameter which evaluates to b, i.e. [1, X(tc), Y(tc)] = c in screen coordinates
{Number} depth
Actual recursion depth. The recursion stops if depth is equal to 0.
Returns:
{JXG.Boolean} true if the point is inserted and the recursion should stop, false otherwise.

<private> <static> {Array} JXG.Math.Plot._findStartPoint(curve, ta, b, tb, tb)
For a curve c(t) defined on the interval [ta, tb] find the first point which is in the visible area of the board (plus some outside margin).

This method is necessary to restrict the recursive plotting algorithm JXG.Curve._plotRecursive to the visible area and not waste recursion to areas far outside of the visible area.

This method can also be used to find the last visible point by reversing the input parameters.

Parameters:
{JXG.Curve} curve
JSXGraph curve element
{Array} ta
Curve parameter of a.
{Array} b
Screen coordinates of the end point of the segment (unused)
{Array} tb
Curve parameter of b
tb
Returns:
{Array} Array of length two containing the screen ccordinates of the starting point and the curve parameter at this point.

<private> <static> {JXG.Boolean} JXG.Math.Plot._getBorderPos(curve, a, b, c, ta, tb, tc, depth)
Investigate a function term at the bounds of intervals where the function is not defined, e.g. log(x) at x = 0. c is inbetween a and b
Parameters:
{JXG.Curve} curve
JSXGraph curve element
{Array} a
Screen coordinates of the left interval bound
{Array} b
Screen coordinates of the right interval bound
{Array} c
Screen coordinates of the bisection point at (ta + tb) / 2
{Number} ta
Parameter which evaluates to a, i.e. [1, X(ta), Y(ta)] = a in screen coordinates
{Number} tb
Parameter which evaluates to b, i.e. [1, X(tb), Y(tb)] = b in screen coordinates
{Number} tc
(ta + tb) / 2 = tc. Parameter which evaluates to b, i.e. [1, X(tc), Y(tc)] = c in screen coordinates
{Number} depth
Actual recursion depth. The recursion stops if depth is equal to 0.
Returns:
{JXG.Boolean} true if the point is inserted and the recursion should stop, false otherwise.

<private> <static> JXG.Math.Plot._getCuspPos(curve, ta, tb)
Parameters:
{JXG.Curve} curve
JSXGraph curve element
{Number} ta
{Number} tb

<private> <static> JXG.Math.Plot._getJumpPos(curve, ta, tb)
Parameters:
{JXG.Curve} curve
JSXGraph curve element
{Number} ta
{Number} tb

<private> <static> JXG.Math.Plot._getLimes(curve, a, tc, c, tb, b, may_be_special, depth, depth)
Parameters:
{JXG.Curve} curve
JSXGraph curve element
{Array} a
{Number} tc
{Array} c
{Number} tb
{Array} b
{String} may_be_special
{Number} depth
depth

<private> <static> JXG.Math.Plot._getLimits(curve, t)
Parameters:
{JXG.Curve} curve
JSXGraph curve element
{Number} t

<private> <static> JXG.Math.Plot._insertLimesPoint(curve, pnt, t, depth, limes)
Parameters:
{JXG.Curve} curve
JSXGraph curve element
{*} pnt
{*} t
{*} depth
{*} limes

<private> <static> JXG.Math.Plot._insertPoint(curve, pnt, t, depth, limes)
Add a point to the curve plot. If the new point is too close to the previously inserted point, it is skipped. Used in JXG.Curve._plotRecursive.
Parameters:
{JXG.Curve} curve
JSXGraph curve element
{JXG.Coords} pnt
Coords to add to the list of points
t
depth
limes

<private> <static> JXG.Math.Plot._insertPoint_v2(pnt, pnt, t)
Add a point to the curve plot. If the new point is too close to the previously inserted point, it is skipped. Used in JXG.Curve._plotRecursive.
Parameters:
{JXG.Coords} pnt
Coords to add to the list of points
pnt
t

<private> <static> {Boolean} JXG.Math.Plot._isOutside(a, ta, b, tb, board)
Decide if a path segment is too far from the canvas that we do not need to draw it.
Parameters:
{Array} a
Screen coordinates of the start point of the segment
{Array} ta
Curve parameter of a (unused).
{Array} b
Screen coordinates of the end point of the segment
{Array} tb
Curve parameter of b (unused).
{JXG.Board} board
Returns:
{Boolean} True if the segment is too far away from the canvas, false otherwise.

<private> <static> {Boolean} JXG.Math.Plot._isOutsidePoint(a, board)
Decide if a point of a curve is too far from the canvas that we do not need to draw it.
Parameters:
{Array} a
Screen coordinates of the point
{JXG.Board} board
Returns:
{Boolean} True if the point is too far away from the canvas, false otherwise.

<private> <static> JXG.Math.Plot._isUndefined(curve, a, ta, b, tb)
Test if the function is undefined on an interval: If the interval borders a and b are undefined, 20 random values are tested if they are undefined, too. Only if all values are undefined, we declare the function to be undefined in this interval.
Parameters:
{JXG.Curve} curve
JSXGraph curve element
{Array} a
Screen coordinates of the left interval bound
{Number} ta
Parameter which evaluates to a, i.e. [1, X(ta), Y(ta)] = a in screen coordinates
{Array} b
Screen coordinates of the right interval bound
{Number} tb
Parameter which evaluates to b, i.e. [1, X(tb), Y(tb)] = b in screen coordinates

<private> <static> {JXG.Curve} JXG.Math.Plot._plotNonRecursive(curve, a, ta, b, tb, depth, delta)
Recursive interval bisection algorithm for curve plotting. Used in JXG.Curve.updateParametricCurve.
Parameters:
{JXG.Curve} curve
JSXGraph curve element
{Array} a
Screen coordinates of the left interval bound
{Number} ta
Parameter which evaluates to a, i.e. [1, X(ta), Y(ta)] = a in screen coordinates
{Array} b
Screen coordinates of the right interval bound
{Number} tb
Parameter which evaluates to b, i.e. [1, X(tb), Y(tb)] = b in screen coordinates
{Number} depth
Actual recursion depth. The recursion stops if depth is equal to 0.
{Number} delta
If the distance of the bisection point at (ta + tb) / 2 from the point (a + b) / 2 is less then delta, the segment [a,b] is regarded as straight line.
Returns:
{JXG.Curve} Reference to the curve object.

<private> <static> {JXG.Curve} JXG.Math.Plot._plotRecursive_v2(curve, a, ta, b, tb, depth, delta)
Recursive interval bisection algorithm for curve plotting. Used in JXG.Curve.updateParametricCurve.
Parameters:
{JXG.Curve} curve
JSXGraph curve element
{Array} a
Screen coordinates of the left interval bound
{Number} ta
Parameter which evaluates to a, i.e. [1, X(ta), Y(ta)] = a in screen coordinates
{Array} b
Screen coordinates of the right interval bound
{Number} tb
Parameter which evaluates to b, i.e. [1, X(tb), Y(tb)] = b in screen coordinates
{Number} depth
Actual recursion depth. The recursion stops if depth is equal to 0.
{Number} delta
If the distance of the bisection point at (ta + tb) / 2 from the point (a + b) / 2 is less then delta, the segment [a,b] is regarded as straight line.
Returns:
{JXG.Curve} Reference to the curve object.

<private> <static> {Array} JXG.Math.Plot._triangleDists(a, b, c)
Compute distances in screen coordinates between the points ab, ac, cb, and cd, where d = (a + b)/2. cd is used for the smoothness test, ab, ac, cb are used to detect jumps, cusps and poles.
Parameters:
{Array} a
Screen coordinates of the left interval bound
{Array} b
Screen coordinates of the right interval bound
{Array} c
Screen coordinates of the bisection point at (ta + tb) / 2
Returns:
{Array} array of distances in screen coordinates between: ab, ac, cb, and cd.

<static> JXG.Math.Plot.checkReal(points)
Check if at least one point on the curve is finite and real.
Parameters:
points

<private> <static> {Boolean} JXG.Math.Plot.isDistOK(dx, dy, MAXX, MAXY)
Compares the absolute value of dx with MAXX and the absolute value of dy with MAXY.
Parameters:
{Number} dx
{Number} dy
{Number} MAXX
{Number} MAXY
Returns:
{Boolean} true, if |dx| < MAXX and |dy| < MAXY.

<private> <static> JXG.Math.Plot.isSegmentDefined(x0, y0, x1, y1)
Parameters:
x0
y0
x1
y1

<private> <static> {Boolean} JXG.Math.Plot.isSegmentOutside(x0, y0, x1, y1, board)
Crude and cheap test if the segment defined by the two points (x0, y0) and (x1, y1) is outside the viewport of the board. All parameters have to be given in screen coordinates.
Parameters:
{Number} x0
{Number} y0
{Number} x1
{Number} y1
{JXG.Board} board
Returns:
{Boolean} true if the given segment is outside the visible area.

<static> {JXG.Curve} JXG.Math.Plot.updateParametricCurve(curve, mi, ma)
Updates the data points of a parametric curve. This version is used if JXG.Curve#doadvancedplot is true.
Parameters:
{JXG.Curve} curve
JSXGraph curve element
{Number} mi
Left bound of curve
{Number} ma
Right bound of curve
Returns:
{JXG.Curve} Reference to the curve object.

<static> {JXG.Curve} JXG.Math.Plot.updateParametricCurve_v2(curve, mi, ma)
Updates the data points of a parametric curve. This version is used if JXG.Curve#doadvancedplot is true.
Parameters:
{JXG.Curve} curve
JSXGraph curve element
{Number} mi
Left bound of curve
{Number} ma
Right bound of curve
Returns:
{JXG.Curve} Reference to the curve object.

<static> {JXG.Curve} JXG.Math.Plot.updateParametricCurveNaive(curve, mi, ma, len)
Updates the data points of a parametric curve. This version is used if JXG.Curve#doadvancedplot is false.
Parameters:
{JXG.Curve} curve
JSXGraph curve element
{Number} mi
Left bound of curve
{Number} ma
Right bound of curve
{Number} len
Number of data points
Returns:
{JXG.Curve} Reference to the curve object.

<static> {JXG.Curve} JXG.Math.Plot.updateParametricCurveOld(curve, mi, ma)
Updates the data points of a parametric curve. This version is used if JXG.Curve#doadvancedplot is true. Since 0.99 this algorithm is deprecated. It still can be used if JXG.Curve#doadvancedplotold is true.
Parameters:
{JXG.Curve} curve
JSXGraph curve element
{Number} mi
Left bound of curve
{Number} ma
Right bound of curve
Returns:
{JXG.Curve} Reference to the curve object.

Documentation generated by JsDoc Toolkit 2.4.0 on Wed Jan 20 2021 12:20:36 GMT+0100 (Mitteleuropäische Normalzeit)