Documentation Center |
Finite lists of 2D points
This functionality does not run in MATLAB.
plot::PointList2d(pts, <a = a_{min} .. a_{max}>, options) plot::PointList2d(M_{2d}, <a = a_{min} .. a_{max}>, options)
plot::PointList2d holds lists of points in 2D.
These types are containers for a (large) finite number of points. They let you avoid constructing large numbers of objects of type plot::Point2d for two reasons. First, the point types have non-negligible overhead and constructing and plotting a large number of them (say, five thousand) takes more time than plotting the same number of points in a single container object. Second, and this may be even more important, having five thousand points in the object browser takes a significant amount of memory and is not as lucid as having a single point list displayed there.
The attribute Points2d is displayed in the inspector in the user interface only for short lists.
plot::PointList2d, PointList3d internally use lists for storing the points. It is therefore not advisable to add a large number of points one-by-one. See Example 2 for a better method of collecting data.
If you specify the color of one point, you must specify the colors of all other points in the list. See Example 3.
Attribute | Purpose | Default Value |
---|---|---|
AffectViewingBox | influence of objects on the ViewingBox of a scene | TRUE |
AntiAliased | antialiased lines and points? | TRUE |
Color | the main color | RGB::MidnightBlue |
Frames | the number of frames in an animation | 50 |
Legend | makes a legend entry | |
LegendText | short explanatory text for legend | |
LegendEntry | add this object to the legend? | FALSE |
Name | the name of a plot object (for browser and legend) | |
ParameterEnd | end value of the animation parameter | |
ParameterName | name of the animation parameter | |
ParameterBegin | initial value of the animation parameter | |
ParameterRange | range of the animation parameter | |
Points2d | list of 2D points | |
PointSize | the size of points | 1.5 |
PointColor | the color of points | RGB::MidnightBlue |
PointStyle | the presentation style of points | FilledCircles |
TimeEnd | end time of the animation | 10.0 |
TimeBegin | start time of the animation | 0.0 |
TimeRange | the real time span of an animation | 0.0 .. 10.0 |
Title | object title | |
TitleFont | font of object titles | [" sans-serif ", 11] |
TitlePosition | position of object titles | |
TitleAlignment | horizontal alignment of titles w.r.t. their coordinates | Center |
TitlePositionX | position of object titles, x component | |
TitlePositionY | position of object titles, y component | |
Visible | visibility | TRUE |
VisibleAfter | object visible after this time value | |
VisibleBefore | object visible until this time value | |
VisibleFromTo | object visible during this time range | |
VisibleAfterEnd | object visible after its animation time ended? | TRUE |
VisibleBeforeBegin | object visible before its animation time starts? | TRUE |
plot::PointList3d provides a basic form of scatter plot:
plot(plot::PointList3d([[1,1,1], [1,2,2], [1,3,2], [1,3,4], [2,1,1], [2,2,3], [2,3.5, 4]], PointSize=5))
We can use this, for example, to get a visual test of random number generators:
r := frandom(0): plot(plot::PointList3d([[r(), r(), r()] $ i=1..10000])):
r := random(10^10)*1e-10: plot(plot::PointList3d([[r(), r(), r()] $ i=1..10000])):
frandom and random fill the cube nicely, without noticeable patterns. The following generator, however, should probably not be used:
randseed := 12345: r := proc() begin randseed := (randseed * 17 + 8) mod 10^10: 1e-10 * randseed; end: plot(plot::PointList3d([[r(), r(), r()] $ i=1..10000])):
The following iteration leads to the so-called Hénon attractor (from chaos theory):
c1 := 1.4: c2 := 0.3: henon_iter := (x, y) -> [c1*x^2+y-1, c2*x]:
We start at (0, 0), let hundred iteration cycles pass by (to only plot the attractor) and then collect the next three thousand points:
[x, y] := [0, 0]: for i from 1 to 100 do [x, y] := henon_iter(x, y); end_for: data := {}: for i from 1 to 3000 do [x, y] := henon_iter(x, y); data := data union {[x, y]}; end_for:
Note that we collected the data in a set, because adding elements to a set is a fast operation, unlike changing the length of a list, and we don't care for the order in which points were reached. To plot the data, we must convert it to a list first:
data := coerce(data, DOM_LIST): plot(plot::PointList2d(data))
We'd like to invite you to experiment with different values of c1 and c2 and see how they change the resulting image.
plot::PointList2d and plot::PointList3d allow you to specify the colors of the points. For example, the following list contains two points. When you plot this list, the first point appears in red, and the second point appears in green:
Coords := [[3, 4, RGB::Red], [5, 5, RGB::Green]]; plotCoords := plot::PointList2d(Coords): plot(plotCoords, PointSize=5)
If you specify the color of one point, you must also specify the colors of all other points in the list:
Coords := [[3, 4, RGB::Red], [5, 5]]; plotCoords := plot::PointList2d(Coords)
Error: The attribute 'Points2d' in the 'PointList2d' object must be a list of lists of two expressions and an optional color value. [plot]
(Feigenbaum's period doubling route to chaos)
We consider the iteration x_{n + 1} = f_{p}(x_{n}) where is the "logistic map" with a parameter p. The iteration map f_{p} maps the interval [0, 1] to itself for 0 ≤ p ≤ 4. For small values of p, the sequence (x_{n}) has a finite number of accumulation points that are visited cyclically. Increasing p, the accumulation points split into 2 separate accumulation points for certain critical values of p ("period doubling"). For , there are infinitely many accumulation points and the sequence (x_{n}) behaves chaotically.
We wish to visualize the accumulation points as functions of p ("Feigenbaum diagram").
For P closely spaced values of p, we construct the sequence (x_{n}) starting with x_{0} = 0.5. We ignore the first N values, expecting that the next M values cycle over the accumulation points. These points are added to a list plotdata that is finally fed into a PointList2d for plotting:
f:= (p, x) -> p*x*(1-x): P:= 500: // number of steps in p direction N:= 200: // transitional steps before we are close to the cycle M:= 300: // maximal number of points on the cycle pmin:= 2.8: // Consider p between pmax:= 4.0: // pmin and pmax plotdata:= [ ]: for p in [pmin + i*(pmax - pmin)/P $ i = 0..P] do // First, do N iterations to drive the // point x towards the limit cycle x:= 0.5: for i from 1 to N do x:= f(p, x): end_for: // consider the next M iterates and use them as plot data: xSequence:= table(): xSequence[1]:= x; for i from 2 to M do x:= f(p, x): if abs(x - xSequence[1]) < 10^(-5) then // We are back at the beginning of the cycle; // the points will repeat. Go to the next p. break; else xSequence[i]:= x; end_if; end_for: plotdata:= plotdata . [[p, rhs(x)] $ x in xSequence]; end_for: plot(plot::PointList2d(plotdata, PointColor = RGB::Black, PointSize = 0.5*unit::mm)):
delete f, P, N, M, pmin, pmax, plotdata, x, xSequence, i;
Create the following number spiral by plotting only prime numbers. This plot shows that primes cluster along particular curves called prime-generating curves.
plot(plot::PointList2d([[sqrt(n)*cos(2*PI*sqrt(n)), sqrt(n)*sin(2*PI*sqrt(n))] $ n in [ithprime(j) $ j = 1..2345]], PointSize=1), Axes = None, Scaling = Constrained, Height = 100, Width = 100)
pts |
A list of points. A point must not be of type plot::Point2d or plot::Point3d, respectively. In 2D, each point must be a list of two real-valued expressions (the coordinates) and an optional RGB color. In 3D, each point mut be a list of three expressions (the coordinates) and an optional RGB or RGBa color. The lists specifying the points and the colors must all have the same length. |
M_{2d} |
An array or a matrix with 2 columns. Each row provides the coordinates of one point. M_{2d} is equivalent to the attribute Points2d. |
a |
Animation parameter, specified as a = a_{min}..a_{max}, where a_{min} is the initial parameter value, and a_{max} is the final parameter value. |