Functions Plotter Applet Directions

Directions and Discussion for the Functions Plotter

Introduction

The Functions Plotter Applet is designed to quickly plot mathematical functions of one parameter. The screen snapshot below shows a typical example with 2 functions plotted in the Plot Pane tab.

You will notice that the 2 functions are specified by name exp and expsin in a comma-separated list. The function exp is built-in whereas the function expsin is user-defined in the Function Definition tab.

The definition of the function expsin is quite simple.

Type the name expsin in the Function Name text box.
Type the formal parameter x in the Function Parameters text box.
Type the expression that constitutes the body of the function in the Function Body text box.
Click the button Define Function.

You may test a function definition by typing expressions that use the function in the Expression Evaluation Pane.

You can go a long distance in using the Functions Plotter with just this much information. The rest of this page documents information needed for more sophisticated usage.

Plot Controls

The controls in the Plot Pane are straightforward.

The functions to be plotted are entered by name in a comma-separated list.
The range of x to be plotted must be specified.
The range of y to be plotted may be determined from the plot points or may be specified by the user.
The colors with which to plot successive functions are shown in the color panel and may be changed by the user.
The button Plot Functions will plot the functions using the choices made above.
The button Show Plot Data Table will show the data for the last plot executed provided that the plot is still visible in the graphics window.

The plotter is sophisticated and will simply ignore all data points that are generated during the evaluation process that are infinite or NaN, that is, “not a number”. If you show the plot data table, values that are infinite or NaN will be noted as such.

Looking Ahead

The plotter works by reading or parsing expressions including the expressions that define user functions. User functions can have zero or more parameters. The functions that will be plotted must have exactly one parameter but, for example, a function with two parameters might be used in the definition of another function with one parameter. Thus the generality is useful.

Before examining user functions and special forms, it is useful to tabulate all of the built-in definitions. We will then describe the special forms which make sophisticated definitions easy. Next we will comment on user functions. Finally we will provide access to the source code of FunctionsPlotter.

Built-in Definitions

The tables below list all of the built-in definitions.

Constant definitions:

Identifier	Type	Definition
`true`	`boolean`	`true`
`false`	`boolean`	`false`
`pi`	`double`	`Math.PI`
`e`	`double`	`Math.E`
`MaxInt`	`int`	`Integer.MAX_VALUE`
`maxint`	`int`	`Integer.MAX_VALUE`
`MinInt`	`int`	`Integer.MIN_VALUE`
`minint`	`int`	`Integer.MIN_VALUE`
`MaxLong`	`long`	`Long.MAX_VALUE`
`maxlong`	`long`	`Long.MAX_VALUE`
`MinLong`	`long`	`Long.MIN_VALUE`
`minlong`	`long`	`Long.MIN_VALUE`
`MaxDouble`	`double`	`Double.MAX_VALUE`
`maxdouble`	`double`	`Double.MAX_VALUE`
`MinDouble`	`double`	`Double.MIN_VALUE`
`mindouble`	`double`	`Double.MIN_VALUE`
`Infinity`	`double`	`Double.POSITIVE_INFINITY`
`infinity`	`double`	`Double.POSITIVE_INFINITY`
`NaN`	`double`	`Double.NaN`
`nan`	`double`	`Double.NaN`

Function definitions:

Function Name	Typical Usage
`abs`	`abs(x)`
`ceiling`	`ceiling(x)`
`floor`	`floor(x)`
`round`	`round(x)`
`max`	`max(x,y)`
`min`	`min(x,y)`
`sqrt`	`sqrt(x)`
`power`	`power(x,y)`
`root`	`root(x,y)`
`todegrees`	`todegrees(theta)`
`toradians`	`toradians(angle)`
`sin`	`sin(theta)`
`sindeg`	`sindeg(angle)`
`cos`	`cos(theta)`
`cosdeg`	`cosdeg(angle)`
`tan`	`tan(theta)`
`tandeg`	`tandeg(angle)`
`asin`	`asin(s)`
`asindeg`	`asindeg(s)`
`acos`	`acos(c)`
`acosdeg`	`acosdeg(c)`
`atan`	`atan(t)`
`atandeg(t)`	`atandeg(t)`
`atan2`	`atan2(y,x)`
`atan2deg`	`atan2deg(y,x)`
`exp`	`exp(x)`
`log`	`log(x)`
`ln`	`ln(x)`
`log2`	`log2(x)`
`log10`	`log10(x)`
`logtobase`	`logtobase(x,b)`

In the above table:
    x and y stand for generic variables;
    theta is an angle in radians;
    angle is an angle in degrees;
    s, c, t stand for possible values of sin, cos, tan;
    and b is the base for a logarithm.

The “function” random is implemented in a special fashion to take one of three forms with the following interpretations.

Function Name	Typical Usage	Interpretation
`random`	`random()`	Random number between 0 and 1
`random`	`random(x)`	Random number between 0 and x
`random`	`random(x,y)`	Random number between x and y

Operation definitions:

Precedence	Operations	Symbols
0	`IDENTITY`	`None`
1	`operationOR`	`\|\|`
2	`operationAND`	`&&`
3	`operationEQ operationNE`	`== !=`
4	`operationLT operationGT operationLE operationGE`	`< > <= >=`
5	`operationPlus operationMinus`	`+ -`
6	`operationTimes operationSlash operationPercent`	`* / %`
7	`operationCaret`	`^`
8	`operationNOT`	`!`

The caret operation ^ implements exponentiation. The operation x^y will be performed if the combination of arguments makes sense mathematically and the result can be represented in the range implemented in computer arithmetic.

Special Forms

The expression parser has the ability to define special forms and five such forms are built-in: set, let, if, eval, and random. Here is a brief synopsis of these special forms.

Special Form	Typical Usage
`set`	`set(identifier,expression)`
`let`	`let(identifier,expression)`
`if`	`if(test,expression-1,expression-2)`
`eval`	`eval(expression-1,...,expression-n)`
`random`	`random()` or `random(x)` or `random(x,y)`

The special forms are interpreted as follows.

set evaluates the expression and assigns it to the identifier in a persistant fashion that will be available across invocations of the parser.
set returns the evaluated expression as its value.
let evaluates the expression and assigns it to the identifier in a temporary fashion that will be available only in the current invocation of the parser.
let returns the evaluated expression as its value.
if evaluates the test expression as a boolean.
If the boolean result is true, expression-1 is evaluated and returned and expression-2 is skipped.
If the boolean result is false, expression-2 is evaluated and returned and expression-1 is skipped.
eval evaluates all expressions from left to right and returns the value of the last expression.
In particular, the initial expressions in an eval expression sequence may be let expressions whose temporary variables are then utilized in the final expression in the eval expression sequence.
random() returns a random double between 0 and 1.
random(x) returns a random double between 0 and x.
random(x,y) returns a random double between x and y.

random is introduced as a special form since in our simple parser ordinary functions cannot be overloaded to take different numbers of arguments.

Defining User Functions

The definition of user functions can be more sophisticated than it may appear at first because:

User functions may utilize other user functions in their definitions as well as utilizing the built-in functions.
The combination of eval and let enables the use of local variables.
The if form allows for the definition of piecewise functions, that is, functions whose formula is different on different intervals of x.
User functions may be recursive since the if form allows for testing for the base case.

Of course, the bread and butter of user-defined functions remains those defined by simple arithmetic expressions as in our example of expsin above.

Source Code

The standalone FunctionsPlotter applications requires 2 files in addition to the Java Power Tools.

FunctionsPlotter.java

This class contains the heart of the Functions Plotter code. The code makes liberal use of many tools built into Java Power Tools.

MultiColorView.java

This class defines a widget that shows a labeled list of ColorView objects so that multiple colors may be set at once. The application of this class is to define 8 colors for a sequence of up to 8 functions.

The FunctionsPlotter applet is built using a standard template that calls the application code.

FunctionsPlotterApplet.java

For pedagogical purposes, I took snapshots of the code during the development process. Each of the snapshots may be run as a standalone application. The MultiColorView class is needed for versions 7 and 8. Interestingly, no plotting is done until version 5. Earlier versions develop GUI structure only.

FunctionsPlotter1.java

Version 1 uses JPT to structure the GUI for the Plot Parameters area of the window and the Plot Functions button that is below that area. The button has no functionality at this stage.

FunctionsPlotter2.java

Version 2 changes the base class to BasePane to access definitions of “prettier” fonts that are then used for the labels, text fields, and buttons.

FunctionsPlotter3.java

Version 3 introduces a 500-by-500 graphics pane for plotting. The plot controls now occupy the left hand side of the window and the graphics pane is placed on the right hand side.

FunctionsPlotter4.java

Version 4 introduces a JTabbedPane in order to make available a pane in which the user may define simple mathematical functions that may later be plotted. This pane is prebuilt into JPT as the SimpleFunctionBuilder class. Underneath this class is a substantial infrastructure of both GUI and parser code. The graphics pane size was also changed to 600-by-600.

FunctionsPlotter5.java

Version 5 is the first version that plots functions. The JPT parser class BaseParser has built-in tools to take precisely the information in the Plot Parameters pane and compute the array of Point2D data needed for the plot. Plotting itself is then handled by the JPT class PlotTool which can plot multiple data sets in multiple colors. In this version, however, all functions are plotted in one color: red.

FunctionsPlotter6.java

Version 6 introduces mouse behavior in the graphics pane. Specifically, if a plot is visible, then as the mouse moves over the plot, the x,y coordinates will be displayed in 2 text fields below the graphics pane. The coordinates are “world” coordinates in the problem space not raw pixel positions.

FunctionsPlotter7.java

Version 7 introduces distinct colors for up to 8 functions plotted. This uses the widget MultiColorView which was developed for this purpose but which is also coded in a general fashion so that it may someday migrate into JPT. Access to the colors is via a button that opens a dialog box.

FunctionsPlotter8.java

Version 8 eliminates the dialog box for the MultiColorView widget since opening the dialog box turned out to be inconvenient. Instead the widget is placed directly below the Plot Parameters pane in the left side of the main GUI.

The final version (9) whose source code is given above adds the facility for displaying the actual plot data that was used to construct the function plots. This enables the user to examine the data carefully, look for interesting values such as maxima and minima, and even see if some values are infinite or NaN.

As an interesting example of plot data, plot exp,log on the range -2 to 2 and then look at the plot data.