CindyJS

Function Plotting

Cinderella provides several operators that allow one to plot information about mathematical functions. Besides simple function plotting, information on extrema, zeros, and inflection points can be shown.

Functions

The following functions allow to plot the graph of a function that maps a real number to a real number.

Plotting a Function: plot(‹expr›)

Description: The plot operator can be used to plot a function. The function must be given as an expression ‹expr›. This expression must contain the running variable # and calculate either a real value for a real input of # or a two-dimensional vector. In the first case, the plot operator will simply draw the function. In the latter case, it will draw a parametric plot of a function. The coordinate system is tied to the coordinate system of the geometric views. Instead of # also other running variables are detected automatically. If there is only one free variable then this variable is taken as running variable. If there are several free variables the plot(…) function searches for typical names in the order x, y, t, z.

Examples: In its simplest form the plot operator can be used directly to plot a function. The line plot(sin(#)) immediately plots the function sin(x). The same plot is generated by plot(sin(x)).

Similarly, one can first define a function whose graph is then displayed by the plot operator. The following lines of code produce the picture below:

f(x):=1/(x^2+1)*sin(4*x);
plot(f(x));

If invoked with an expression ‹expr› that produces a two-dimensional vector as output, the plot operator will automatically generate a parametric plot of a curve. Here the value range for the input variable is taken by default to be from 0 to 100. However, these defaults can easily be changed by modifiers. The line plot([sin(t),cos(t)]*t) produces the following output:

Modifiers: The plot operator supports many different modifiers. Some of them have to be explained in detail. They can be used to modify the appearance of the curve, to modify the plot range, to modify the position on the screen, and even to display maxima, minima, zeros, and inflection points of the function. An overview of available modifiers is given in the table below. Observe that some of the modifiers may even be invoked with different types of arguments, resulting in a slightly different effect.

Examples: Here are a few examples that demonstrate the use of the modifiers:

One can easily vary the plot range by setting the start and stop values. For instance, plot(f(#),start->A.x,stop->B.x) helps to control the plot using by the x-coordinates of two free construction points.

Plot Appearance

The resolution of the plot is controlled automatically and adaptively. The plot(…) function automatically increases its resolution close to singularities. The following plot shows the output of the call plot(sin(1/#)*#). Observe the quality of the plot close to the origin.

Usually jumps in functions are detected and by default they arenot connected. One can connect them on purpose by setting connect->true.

plot(x-floor(x))	plot(x-floor(x),connect->true)

Special Points

By using the modifiers for a curve's significant points one can display zeros, minima, maxima, and inflection points. The following three pictures demonstrate the use of these operators.

zeros->true

extrema->true

inflections->true

Dashing

The Dashing options for a plot statement are identical to those for lines and circles. They can be controlled by the modifiers dashing, dashtype and dashpattern.

• dashtype Can be an integer between 0 and 4 and selects one of four predefined dashing patterns. The value 0 creates a solid line.

• dashing is a real number specifying the unitsize of the dashes. Simply setting dashing->5 already creates a standard dashing.

• dashpattern Can be set to a list that specifies the length of the successive dashes and empty spaces.

The following picture has been created with plot(sin(x),dashpattern->[0,3,7,3],size->2,dashing->5)

Dynamic Color and Alpha

The color and the alpha can again be functions that depend on the running variable. By the the opacity and the color of the function plot can be varied along with the function. The following plot was generated with the statement

plot(sin(x),color->hue(x/(2*pi)),size->3)

Here the hue function was used that cyclically generates rainbow colors.

Plotting a Function: plot(‹expr›,‹var›)

Description: Identical to plot(‹expr›) but with a specified running variable.

Plotting integral-like effects: fillplot(‹expr›)

Not available in CindyJS yet!

Description: Often it is desirable to highlight the area between a function graph and the x-axis of the coordinate system (for instance if one generates an applet for explaining integrals). This can be done using the function fillplot. Similarly to plot, this operator takes a function as argument (the running variable is determined by the same process as in plot(…)). In its simplest form this operator just highlights the area traversed by the function. The function itself is not drawn. This could be done by explicitly calling also the plot(…) operator. The following code

f(x):=1/(x^2+1)*sin(4*x);
fillplot(f(x));
plot(f(x));

produces the following picture:

Warning: The singularity treatment of the fillplot(…) statement is by far less subtle than that of the plot(…) statement. So although the modifiers allow to draw functions also with fillplot one should use plot for function plotting.

Modifiers:

The color and the alpha modifier again support the use of functions that control color and opacity (similar to plot). The following sampler illustrates different usages of the fillplot statement:

fillplot(sin(x))
fillplot(sin(x),graph->true)
fillplot(sin(x),graph->true,pluscolor->(.5,1,.5),minuscolor->(1,.5,.5))
fillplot(sin(x),graph->true,color->(sin(x),-sin(x),0))

Plotting integral like effects: fillplot(‹expr1›,‹expr2›)

Not available in CindyJS yet!

Description: This function is very similar to the fillplot(…) statement. However, instead of highlighting the are between a function and the x-axis it highlights the area between two functions. The following picture

was created using the statement

fillplot(sin(x),cos(x),graph->true,pluscolor->(.5,1,.5),minuscolor->(1,.5,.5))

Modifiers: This statement supports exactly the same modifiers as fillplot(…).

Colorplots

Colorplots are useful to create visual information about functions defined in the entire plane. They can associate a color value to every point within a specified area.

In the Cinderella, colorplots will be computed on the CPU. In CindyJS, colorplots are compiled to WebGL at the first time when the command is called on a given expression. For consecutive calls of colorplot applied to the same expression, the compiled program is re-used as long as the occurring types have not changed. If the types have changed in the meantime, a recompilation is forced.

Due to the compilation to WebGL, there are some restrictions for the expressions that can be used for colorplot. For example, the while-operator and recursive functions must not be used.

For every variable that appears on the left side of an assignment within a colorplot-expression, it must be possible to determine its type in advance. Also, the type signature of a user defined functions must be determinable.

The only allowed types are boolean values, integers, real numbers, complex numbers, points, vectors, and lists of fixed length. All members of a list must be of the same type and this type must be one of the allowed types.

In CindyJS, there are limitations for the terms that can be used within colorplot:

• Every CindyJS operation is allowed if the term does not depend on the pixel coordinate and does not contain an internal assignment of a variable.
• For all other terms, only the following operations are allowed: ^, <, <=, =, ==, >, >=, _, -, ;, !=, /, &, %, +, abs, abs_infix, add, apply, arctan, arctan2, blue, ceil, complex, conjugate, cos, dist, dist_infix, div, exp, floor, forall, genList, green, grey, hue, if, im, imagergb, imagergba, join, log, max, meet, min, mod, mult, pow, random, re, red, regional, repeat, round, sin, sqrt, sub, sum, tan.

For technical reasons, both repeat (the number of iterations) and _ (the index of the accessed field) require a constant argument. A term is considered to be constant if it is either a number or a function of constant terms. If an expression within a loop (repeat, forall or apply) that depends on the running variable is required to be constant, CindyJS tries to unroll the corresponding loop.

Creating a colorplot on the entire drawing canvas colorplot(‹expr›)

Description: The colorplot operator makes it possible to give a visualization of a planar function. To each point of the entire drawing canvas a color value can be assigned by a function. In the function ‹expr› the running variable may be chosen as # (for more on running variables, see below). However, it is important to notice that this variable describes now a point in the plane (this is a variable in two-dimensional coordinates). The return value of ‹expr› should be either a real number (in which case a gray value is assigned) or a vector of three real numbers (in which case an RGB color value is assigned) or a vector of four real numbers (in which case an RGBA value is assigned -- The fourth component represents the alpha value). In any case, the values of the real numbers should lie between 0 and 1.

Running Variables: Usually # is a good choice for the running variable in the colorplot function. However, also other choices are possible. The possibilities for running variables are checked in the following order:

• If there is only one free variable in ‹expr› then this variable is taken as running variable and interpreted as a two-dimensional vector (as long as it is different from z).

• If ‹expr› contains # the # is taken as running variable (again as a two-dimensional vector)

• If ‹expr› contains both x and y as free variables the these two variables can be used as running variables the together represent the vector (x,y).

• If exactly one free variable is not assigned yet, then this variable is taken (as vector)

• if none of the above happens also p (for point) and z (for complex number) are checked as running variables.

• In any case, if z is the running variable, it will be interpreted as complex number (instead of a two-dimensional vector).

Modifiers:

Not available in CindyJS yet!

The colorplot operator supports three modifiers. The modifier pxlres can be set to an integer that determines the size in pixels of the elementary quadrangles of the color plot. The picture above was taken with pxlres->2 which is the default value. Setting the pxlres modifier either to 1 or to 2 produces stunning pictures. However, one should be aware that for each elementary quadrangle of the colorplot output the function has to be evaluated once. The computational effort grows quadratically as pxlres is linearly reduced. So sometimes it is also good practice to reduce the pxlres modifier in order to gain more preformace. The picture below has been rendered by setting pxlres->8.

One can also dynamically change the resolution. For this there is another modifier startres that can be used to have gradually improving plots, thus combining the best of two worlds. For example, using both startres->16 and pxlres->1 you will get a coarse plot during interactive movements, which will be re-calculated automatically with a finer resolution whenever there is enough time.

Furthermore, the colorplot operator supports a modifier alpha that is used to control the opacity. This modifier can even be set to values that depend parametrically on the running variable.

The picture below was generated by the following code, which is only a slight modification of the code of one of the previous examples:

f(A,B):=((1+sin(2*dist(A,B)))/2);
colorplot(
   (f(A,#),0,f(B,#)),
   C,D,
   pxlres->2,
   alpha->-abs(#)+5
)

Creating a colorplot on a rectangular area: colorplot(‹expr›,‹vec›,‹vec›)

To each point of a rectangle a color value can be assigned by a function. The second and third argument determine the lower left and the upper right corners of the drawing area.

Example: The following code and two points A and B produce the picture below. In the first line, a real-valued function is defined that assigns to two points the sine of the distance between them (shifted and scaled to fit into the interval [0, 1]). The first argument of the colorplot operator is now a vector of three numbers depending on the run variable # (the red part is a circular wave around A, the green part is zero, and the blue part is a circular wave around B). Finally, C and D mark the corners of the rectangle.

f(A,B):=((1+sin(2*dist(A,B)))/2);
colorplot(
   (f(A,#),0,f(B,#)),
   C,D
)

Running Variables:

For colorplot(‹expr›,‹vec›,‹vec›) the same rules for the running variable apply as to colorplot(‹expr›). For instance the following line

colorplot((sin(2x),sin(2y),0),A,B)

produces the following picture:

Creating a colorplot on a canvas with two reference points: colorplot(‹pos›,‹pos›,‹imagename›,‹expr›)

This operator uses ‹imagename› as a canvas and positions it with respect to two reference point identical to the rules of the drawimage(‹pos›,‹pos›,‹imagename›) operator. Then the two-dimensional function described by the expression in the last argument will be plotted to the canvas.

The rules for choosing the running variable within the expressions are the same as for colorplot(‹expr›).

Creating a colorplot on a canvas with no reference points: colorplot(‹imagename›,‹expr›)

This operator uses ‹imagename› as a canvas. Then the two-dimensional function described by the expression in the second will be plotted to the canvas. For the coordinates, CindyJS will assume that the two lower corners of the given canvas and the main drawing area coincide.

The rules for choosing the running variable within the expressions are the same as for colorplot(‹expr›).

Vector Fields

Vector fields can be used to visualize flows and forces. They have many applications in the visualization of systems of differential equations.

Drawing a vector field: drawfield(‹expr›)

Not available in CindyJS yet!

Description: The drawfield operator can be used to draw a vector field. The function must be given as an expression ‹expr›. This expression must contain a running variable (usually #), which should this time represent a two-dimensional vector (as in color plot). The result should also be a two-dimensional vector. Applying the operator drawfield to this expression will result in plotting the corresponding vector field. The field will be animated. This means that it will change slightly with every picture. Therefore, it is often useful to put the drawfield operator into the “timer tick” evaluation slot. This creates an animation control in the geometric view. Running the animation will automatically animate the vector field. The running variable policy is identical to the one in the colorplot(…) statement. In particular it is possible to use free variables x and y to represent the two dimensional location (x,y)

Examples: We consider a vector field defined by the function f(x,y)=(y,sin(x)). The corresponding code with the function definition and the call of the drawfield operator is as follows:

f(v):=[v.y,sin(v.x)];
drawfield(f(#));

Alternatively the same picture could be generated by

drawfield((y,sin(x)));

To generate the picture, a collection of needlelike objects is thrown onto the drawing surface. These needles will be oriented according to the vector field. During the animation, the needles move according to the vector field. It is also possible to replace the needles by small snakelike objects that give a more accurate impression of the vector field but take a longer time for calculation. This can be done with a suitable modifier.

f(v):=[v.y,sin(v.x)];
drawfield(f(#),stream->true,color->(0,0,0));

Modifiers: The drawfield operator supports many modifiers that control the generation process of the vector field. To help in understanding them we first describe in a bit more detail how the pictures are generated.

The pictures are generated by showing the movement of some test objects under the influence of the field. By default, the test objects are needlelike. They are initially positioned on a regular grid. Since this usually creates many visual artifacts, they are randomly distorted within a certain radius around the grid points. During an animation the needles are moved in the direction of the force field. The needles' lengths represent the strength of the field.

The following picture demonstrates the original grid. It has been rendered with move->0 and jitter->0. It shows clear artifacts resulting from unnatural alignment in the horizontal or vertical direction.

The following picture has been rendered with resolution->5 and stream->true.

Drawing a complex vector field: drawfieldcomplex(‹expr›)

Not available in CindyJS yet!

Description: This operator is very similar to the drawfield operator. However, it takes as input a one-dimensional complex function. The real and imaginary parts are treated as x and y components for the vector field. Otherwise, the operator is completely analogous to the previous one.

Example: The following example demonstrates the use of the operator with a complex polynomial whose zeros are determined by four points in the drawing:

f(x):=(x-complex(A))*(x-complex(B))*(x-complex(C))*(x-complex(D));
drawfieldcomplex(f(#),stream->true,resolution->5,color->(0,0,0))

The modifiers are analogous to those for the drawfield operators.

Drawing a force field: drawforces()

Not available in CindyJS yet!

Description: This operator is again very similar to the drawfield operator. However, this time it is related to a physics simulation in CindyLab. No arguments are required, and it shows the forces on a potential test charge that is placed at various locations on the screen. The test charge has mass = 1, charge = 1, and radius = 1. However, no other particle will interact with it. Sometimes it will be necessary to use the factor modifier to amplify the force field. The following example shows the interaction among four charged particles.

Drawing the force field of a point: drawforces(‹mass›)

Not available in CindyJS yet!

Description: There is another operator that draws the force field with respect to a fixed mass particle. The particle itself takes no part in the calculation of the forces. In this way, one can visualize the forces that act on a certain particle.

Grids

Grids can be used to visualize transformations that map the plane onto itself. With grids, the deformation induced by such a map can be visualized.

Mapping a rectangular grid: mapgrid(‹expr›)

Not available in CindyJS yet!

Description: This operator takes a rectangular grid and deforms it by a function given in ‹expr›. By default the range of the original grid is taken to be the unit rectangle in the plane. The bound of this rectangle may be altered using modifiers. It is also possible to visualize complex maps by using the complex->true modifier.

Modifiers: There are several modifiers controlling the behavior of this function.

Examples: The following piece of code exemplifies the usage of the mapgrid operator. Is also illustrates the effect of the xrange and yrange modifiers. It displays the effect of a two-dimensional function that squares the x and the y coordinate separately.

f(v):=(v_1^2,v_2^2);
linesize(1.5);
mapgrid(f(v),color->(0,0,0));
mapgrid(f(v),xrange->[1,2],color->(.6,0,0));
mapgrid(f(v),yrange->[1,2],color->(.6,0,0));
mapgrid(f(v),xrange->[1,2],yrange->[1,2],color->(0,.6,0));

In the following example we see that generally the grid lines do not have to stay straight or parallel.

f(v):=(v_1*sin(v_2),v_2*sin(v_1));
linesize(1.5);
mapgrid(f(v),xrange->[1,2],yrange->[1,2]);

The following simple example illustrates the usage of mapgrid for complex functions.

mapgrid(z^2,complex->true);

Using the resolution modifier, one can specify the number of mesh lines that are generated.

mapgrid(z^2,complex->true,resolution->4);

By default, the mapgrid command directly connects the mesh points. This may lead to pictures that do not really map the mathematical truth. Using the step modifier, one can introduce additional steps between the mesh points.

mapgrid(z^2,complex->true,resolution->4,step->5);

The results of the last three pieces of code are shown below.

Grids carry very characteristic information about complex functions. The following three pictures show grids for the functions z*z, sin(z), 1/z and tan(z) respectively.

Oscillographs

Oscillographs allow to visualize dynamic changes of values in physic simulations and animations.

Curve drawing of physics magnitudes: drawcurves(‹vec›,‹list›)

Not available in CindyJS yet!

Description: In real and simulated physical situations one is often interested in plotting curves that show how magnitudes evolve over time. For this, the drawcurves operator was created. Here ‹vec› is a two-dimensional vector that refers to the lower left corner of the drawing area, and ‹list› is a list of values that are to be observed. When the animation runs, the values are updated and the corresponding curves are drawn.

Example: The next picture shows a very simple application of the drawcurves operator. In CindyLab, a physical pendulum was constructed. The following code produces a curve plot of the x coordinate of the moving point and of its x velocity:

drawcurves([0,0],[D.x,D.vx])

Modifiers: The drawcurves operator supports many modifiers. Than can be used to change the appearance of the curves and to show additional information.

The following piece of code demonstrates the usage of the modifiers. It shows a weakly coupled pendulum and its energy behavior.

linecolor((1,1,1));
textcolor((0,0.8,0));
drawcurves((-7,-3),
  [A.x,B.x,A.ke,B.ke,a.pe+b.pe+c.pe],
  height->50,
  color->(1,1,1),
  back->(0,0,0),
  backalpha->1,
  range->"peek",width->400,
  colors->[
    [1,0.5,0.5],
    [0.5,1,0.5],
    [1,0.5,0.5],
    [0.5,1,0.5],
    [0.5,0.5,1]],
  texts->[
    "PosA = "+ A.x,
    "PosB = "+B.x,
    "EnergyA = "+A.ke,
    "EnergyB = "+B.ke,
    "PotentialEnergy = "+(a.pe+b.pe+c.pe)
]
);

The corresponding drawing looks as follows: