# JSXGraph 1.11.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.

Class Index | File Index

Elements

- Angle
- Arc
- Arrow
- Arrowparallel
- Axes3D
- Axis
- Axis3D
- Bisector
- Bisectorlines
- Boxplot
- Button
- Cardinalspline
- Chart
- Checkbox
- Circle
- Circle3D
- Circumcenter
- Circumcircle
- CircumcircleArc
- CircumcircleSector
- Comb
- Conic
- Curve
- Curve3D
- CurveDifference
- CurveIntersection
- CurveUnion
- Derivative
- Ellipse
- Face3D
- ForeignObject
- Functiongraph
- Functiongraph3D
- Glider
- Grid
- Group
- Hatch
- Hyperbola
- Image
- ImplicitCurve
- Incenter
- Incircle
- Inequality
- Input
- Integral
- Intersection
- IntersectionCircle3D
- IntersectionLine3D
- Label
- Legend
- Line
- Line3D
- MajorArc
- MajorSector
- Measurement
- Mesh3D
- Metapostspline
- Midpoint
- MinorArc
- MinorSector
- MirrorElement
- MirrorPoint
- NonReflexAngle
- Normal
- Orthogonalprojection
- OtherIntersection
- Parabola
- Parallel
- Parallelogram
- Parallelpoint
- ParametricSurface3D
- Perpendicular
- PerpendicularPoint
- PerpendicularSegment
- Plane3D
- Point
- Point3D
- PolarLine
- PolePoint
- Polygon
- Polygon3D
- PolygonalChain
- Polyhedron3D
- RadicalAxis
- Reflection
- ReflexAngle
- RegularPolygon
- Riemannsum
- Sector
- Segment
- Semicircle
- Slider
- Slopefield
- Slopetriangle
- Smartlabel
- Sphere3D
- Spline
- Stepfunction
- Tangent
- TangentTo
- Tapemeasure
- Text
- Text3D
- Ticks
- Ticks3D
- Tracecurve
- Transformation
- Transformation3D
- Turtle
- Vectorfield
- Vectorfield3D
- View3D

Classes

- _global_
- JXG
- JXG.AbstractRenderer
- JXG.Board
- JXG.Board.infobox
- JXG.C
- JXG.CA
- JXG.CanvasRenderer
- JXG.Chart
- JXG.Circle
- JXG.Circle3D
- JXG.Complex
- JXG.Composition
- JXG.Coords
- JXG.CoordsElement
- JXG.Curve
- JXG.Curve3D
- JXG.Dump
- JXG.EventEmitter
- JXG.Expect
- JXG.Face3D
- JXG.ForeignObject
- JXG.GeometryElement
- JXG.GeometryElement3D
- JXG.GeonextParser
- JXG.Group
- JXG.Image
- JXG.JessieCode
- JXG.JSXGraph
- JXG.Legend
- JXG.Line
- JXG.Line3D
- JXG.Math
- JXG.Math.BoxQuadtree
- JXG.Math.Clip
- JXG.Math.Extrapolate
- JXG.Math.Geometry
- JXG.Math.ImplicitPlot
- JXG.Math.IntervalArithmetic
- JXG.Math.Metapost
- JXG.Math.Nlp
- JXG.Math.Numerics
- JXG.Math.Plot
- JXG.Math.Poly
- JXG.Math.Poly.Monomial
- JXG.Math.Poly.Polynomial
- JXG.Math.Poly.Ring
- JXG.Math.ProbFuncs
- JXG.Math.Quadtree
- JXG.Math.Statistics
- JXG.NoRenderer
- JXG.Options
- JXG.Plane3D
- JXG.Point
- JXG.Point3D
- JXG.Polygon
- JXG.Polygon3D
- JXG.PrefixParser
- JXG.Sphere3D
- JXG.Surface3D
- JXG.SVGRenderer
- JXG.Text
- JXG.Text3D
- JXG.Ticks
- JXG.Transformation
- JXG.Turtle
- JXG.Util
- JXG.Util.Base64
- JXG.Util.Unzip
- JXG.Util.UTF8
- JXG.View3D
- JXG.VMLRenderer
- JXG.XML

# Namespace JXG.Math.Plot

↳ JXG.Math.Plot

Defined in: plot.js.

Namespace Summary
Constructor Attributes | Constructor Name and Description
--- | ---
| JXG.Math.Plot 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._criticalInterval(vec, le, level) TODO
<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.neighborhood_isNaN_v2(curve, t0) Check if there is a single NaN function value at t0.
<static> | JXG.Math.Plot.updateParametricCurve(curve, mi, ma) Updates the data points of a parametric curve, alias for JXG.Curve#updateParametricCurve_v2.
<static> | JXG.Math.Plot.updateParametricCurve_v2(curve, mi, ma) Updates the data points of a parametric curve.
<static> | JXG.Math.Plot.updateParametricCurve_v3(curve, mi, ma) Updates the data points of a parametric curve.
<static> | JXG.Math.Plot.updateParametricCurve_v4(curve, mi, ma) Updates the data points of a parametric curve, plotVersion 4.
<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 between 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._criticalInterval(vec, le, level)
TODO

Parameters:
{Array} vec
{Number} le
{Number} level

Returns:
  Object

<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> {Boolean} JXG.Math.Plot.neighborhood_isNaN_v2(curve, t0)
Check if there is a single NaN function value at t0.

Parameters:
{*} curve
{*} t0

Returns:
  {Boolean} true if there is a second NaN point close by, false otherwise

<static> {JXG.Curve} JXG.Math.Plot.updateParametricCurve(curve, mi, ma)
Updates the data points of a parametric curve, alias for JXG.Curve#updateParametricCurve_v2. This is needed for backwards compatibility, if this method has been used directly in an application.

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.

See:
  JXG.Curve#updateParametricCurve_v2

<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#plotVersion is `3`.

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_v3(curve, mi, ma)
Updates the data points of a parametric curve. This version is used if JXG.Curve#plotVersion is `3`. This is an experimental plot version, not recommended to be used.

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_v4(curve, mi, ma)
Updates the data points of a parametric curve, plotVersion 4. This version is used if JXG.Curve#plotVersion is `4`.

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 Fri Apr 04 2025 09:22:41 GMT+0200 (Mitteleuropäische Sommerzeit)