/*************************************************************************
* *
* This source code file, and compiled classes derived from it, can *
* be used and distributed without restriction, including for commercial *
* use. (Attribution is not required but is appreciated.) *
* *
* David J. Eck *
* Department of Mathematics and Computer Science *
* Hobart and William Smith Colleges *
* Geneva, New York 14456, USA *
* Email: eck@hws.edu WWW: http://math.hws.edu/eck/ *
* *
*************************************************************************/
import java.awt.*;
import java.applet.Applet;
import java.util.*;
import edu.hws.jcm.draw.*;
import edu.hws.jcm.data.*;
import edu.hws.jcm.functions.*;
import edu.hws.jcm.awt.*;
// The MultiApplet can display the graphs of several functions, in different colors.
// By default, there is only one function, but you can configure the applet to
// use more than one function with applet params.
// The definitions of these functions can, optionally, use parameters whose
// values are controled by sliders at the bottom of the applet.
public class MultiGraph extends GenericGraphApplet {
private Vector sliders
; // Elements of this vector are the VariableSlider // objects that represent the parameter values.
// The sliders are created in the setUpParser() method.
private ExprIn[] inputs; // The function input boxes (or null if inputs aren't used)
private Graph1D[] graphs; // The graphs of the functions, in the case function input boxes are NOT used
private int functionCt; // Number of functions -- size of inputs or graphs array
private static class ColorPatch
extends Canvas { // a canvas with a preferred size
setBackground(c);
}
}
g.drawRect(0,0,getSize().width-1,getSize().height-1);
}
}
private static class ExprIn extends ExpressionInput {
// Doesn't throw an error if empty, just sets function in graph to null
Graph1D graph; // Graph associated with this function input.
Function func; // The function of x defined by this graph.
ExprIn
(String definition,
Parser p, Graph1D g, Variable v
) { super(definition,p);
graph = g;
func = getFunction(v);
if (definition.trim().length() > 0)
graph.setFunction(func);
}
public void checkInput() { // (will be called during constructor -- hence the funny bit with checking if graphe is null)
if (!hasChanged)
return;
String text = getText
().
trim(); if (text.length() == 0) { // set graph's function to null so it doesn't have to do any computations.
if (graph != null)
graph.setFunction(null);
hasChanged = false;
}
else {
super.checkInput();
if (graph != null)
graph.setFunction(func);
}
}
}
protected void setUpParser() { // Override this to add VariableSliders to parser.
// Get the data for any sliders from applet params named "Parameter", "Parameter1", ...
// The sliders are created and the variables are added to the parser by the
// addParameter() method, which is defined below.
int ct = 0;
String param = getParameter
("Parameter"); if (param == null) {
ct++;
param = getParameter("Parameter" + ct);
}
while (true) {
if (param == null)
break;
addParameter(param);
ct++;
param = getParameter("Parameter" + ct);
}
super.setUpParser(); // Call this last so function definitions
// in applet params can use the parameter names
} // end setUpParser()
private void addParameter
(String data
) { // Create a VariableSlider from the information in name and add it to the
// Vector of sliders. The data must contain the name of the variable
// associated with the slider. The name can be followed by a ";" and up to
// three numbers. (If there is no ";", a space after the name will do.)
// The numbers can be separated by commas, spaces, or tabs. The first
// number gives the minimum value on the slider, the second gives the maximum,
// and the third gives the initial value of the slider variable.
double min = -5, max = 5, val = 0; // min, max, and value for slider
data = data.trim();
int pos = data.indexOf(';');
if (pos < 0)
pos = data.indexOf(' ');
String name
; // The name of the parameter
if (pos < 0) {
// If there is no space or ";", the data is just the name of the variable.
name = data;
}
else {
// Get the name from the front of the data, then look for min, max, and val.
String nums = data.
substring(pos+
1); name = data.substring(0,pos).trim();
try {
if (toks.hasMoreElements())
min =
(new Double(toks.
nextToken())).
doubleValue(); if (toks.hasMoreElements())
max =
(new Double(toks.
nextToken())).
doubleValue(); if (toks.hasMoreElements())
val =
(new Double(toks.
nextToken())).
doubleValue(); }
min = -5;
max = 5;
val = 0;
}
}
// Create the slider, adding the associated variable to the parser, and set its value.
VariableSlider slide = new VariableSlider(name, new Constant(min), new Constant(max), parser);
slide.setVal(val);
sliders.addElement(slide); // Save the slider in the array of sliders for later use.
} // end setUpParser();
private void getColors() { // get graph colors from color parameters, if any.
int ct = 0;
Color c = getColorParam
("GraphColor"); if (c == null) {
ct++;
c = getColorParam("GraphColor" + ct);
}
while (true) {
if (c == null)
break;
vec.addElement(c);
ct++;
c = getColorParam("GraphColor" + ct);
}
if (vec.size() > 0) {
graphColors =
new Color[vec.
size()]; for (int i = 0; i < vec.size(); i++)
graphColors
[i
] =
(Color)vec.
elementAt(i
); }
}
private Vector getFunctions
() { // Read applet parms "Function", "Funcion1", ... // Return a vector containing the function definition strings
int ct = 0;
String c = getParameter
("Function"); if (c == null) {
ct++;
c = getParameter("Function" + ct);
}
while (true) {
if (c == null)
break;
functions.addElement(c);
ct++;
c = getParameter("Function" + ct);
}
if (functions.size() == 0)
functions.addElement( " abs( " + xVar.getName() + ") ^ " + xVar.getName() );
double[] d = getNumericParam("FunctionCount");
if (d == null || d.length == 0 || d[0] <= 0.5)
functionCt = functions.size();
else {
functionCt =
(int)Math.
round(d
[0]); if (functionCt < functions.size()) { // use number of functions specified as functionCt
functionCt = functions.size();
}
else { // make extra empty functions to bring total up to functionCt
int extra = functionCt - functions.size();
for (int i = 0; i < extra; i++)
functions.addElement("");
}
}
return functions;
}
private Panel makeFunctionInput
(Vector functions,
int funcNum
) { // make input box for specified function
// also adds the input box to the inputs[] array
Graph1D graph = new Graph1D();
graph.setColor(graphColors[funcNum % graphColors.length]);
ExprIn in =
new ExprIn
((String)functions.
elementAt(funcNum
),parser,graph,xVar
); in.setOnUserAction(mainController);
JCMPanel p = new JCMPanel();
if (functions.size() > 1)
name = " " + getParameter("FunctionName","f") + (funcNum+1) + "(" + xVar.getName() + ") = ";
else
name = " " + getParameter("FunctionName","f") + "(" + xVar.getName() + ") = ";
if (graphColors.length > 1 && functions.size() > 1)
p.
add(new ColorPatch
( graphColors
[funcNum
% graphColors.
length] ),
BorderLayout.
EAST); inputs[funcNum] = in;
return p;
}
protected void setUpBottomPanel() {
// Overridden to create an appropriate input panel
// Create a panel holding all the function inputs and
// sliders, with a display label for each slider to show its value.
boolean funcInput = "yes".equalsIgnoreCase(getParameter("UseFunctionInput","yes"));
if ( funcInput && "yes".equalsIgnoreCase(getParameter("UseComputeButton", "yes")) ) { // make the compute button
String cname = getParameter
("ComputeButtonName",
"New Functions"); computeButton =
new Button(cname
); computeButton.addActionListener(this);
}
Panel firstPanel =
null; // To help find a place for the compute button
getColors();
Vector functions = getFunctions
();
if (!funcInput && sliders.size() == 0) // nothing to put in the input panel
return;
JCMPanel panel = new JCMPanel();
if (! "no".equalsIgnoreCase(getParameter("TwoInputColumns","no")))
else
panel.
setBackground(getColorParam
("PanelBackground",
Color.
lightGray));
if (funcInput) { // make an input box for each function and add it to the panel
inputs = new ExprIn[functions.size()];
for (int i = 0; i < functions.size(); i++) {
Panel p = makeFunctionInput
(functions,i
); if (firstPanel == null)
firstPanel = p;
panel.add(p);
}
}
else { // just make graphs from the function definition strings.
graphs = new Graph1D[functions.size()];
for (int i = 0; i < functions.size(); i++) {
graphs[i] = new Graph1D();
graphs[i].setColor(graphColors[ i % graphColors.length ]);
if (def.length() > 0) { // if the definition string is empty, leave graph's function undefined
Function f = new SimpleFunction( parser.parse(def), xVar );
graphs[i].setFunction(f);
}
}
}
for (int i = 0; i < sliders.size(); i++) { // add sliders to the input panel
JCMPanel p = new JCMPanel();
VariableSlider slide = (VariableSlider)sliders.elementAt(i);
p.add(new DisplayLabel(" " + slide.getName() + " = # ", new Value[] { slide.getVariable() } ),
panel.add(p);
slide.setOnUserAction(mainController);
}
if (computeButton != null) { // find a place for the compute button!
if (functions.size() == 1)
else if (limitsPanel == null) {
p.add(computeButton);
panel.add(p);
}
// otherwise, add it at the end of setUpLimitPanel();
}
} // end setUpBottomPanel()
protected void setUpLimitsPanel() { // add compute button if it hasn't been put somewhere else
super.setUpLimitsPanel();
if (limitsPanel != null && computeButton != null && functionCt != 1)
limitsPanel.addComponent(computeButton);
}
protected void setUpCanvas() { // Overridden to add the graph to the canvas.
super.setUpCanvas(); // Do the default setup.
// set up bottom panel has already been defined
// add the graphs to the canvas
if (graphs != null) {
for (int i = 0; i < graphs.length; i++)
canvas.add(graphs[i]);
}
else {
for (int i = 0; i < inputs.length; i++)
canvas.add(inputs[i].graph);
}
} // end setUpCanvas
protected void doLoadExample
(String example
) { // This method is called when the user loads an example from the
// example menu (if there is one). It overrides an empty method
// in GenericGraphApplet.
// For the FamiliesOfGraphs applet, the example string should contain
// an expression that defines the function to be graphed. This must
// be followed by a semicolon and list of zero or more numbers.
// Then there is another semicolon and one or more function definitions,
// separated by semicolons. You can have as many function
// definitions as you have functions in your applet setup.
// (Note that having the numbers before the
// functions is different from the format of examples in all the
// other configurable applets. This is to allow more than one function.) Note that even if you leave
// out the numbers, you still need two semicolons. The list of numbers has the following meaning:
// The first four numbers give the x- and y-limits to be used for the
// example. If they are not present, then -5,5,-5,5 is used. The
// remaining numbers occur in groups of three. Each group give the maximum, minimum, and value of a parameters that was defined
// with the "Parameter", "Parameter1", ... applet params.
int pos = example.indexOf(";");
double[] limits = { -5,5,-5,5 }; // x- and y-limits to use
if (pos > 0) {
// Get limits from example text.
String nums = example.
substring(0,pos
); example = example.substring(pos+1);
if (toks.countTokens() >= 4) {
for (int i = 0; i < 4; i++) {
try {
limits[i] = d.doubleValue();
}
}
}
}
int i = 0;
while (i < sliders.size() && toks.hasMoreElements()) {
// Look for a value for the i-th slider.
try {
double min =
(new Double(toks.
nextToken())).
doubleValue(); double max =
(new Double(toks.
nextToken())).
doubleValue(); double d =
(new Double(toks.
nextToken())).
doubleValue(); VariableSlider slider = ((VariableSlider)sliders.elementAt(i));
slider.setMin(new Constant(min));
slider.setMax(new Constant(max));
slider.setVal(d);
}
}
i++;
}
}
// Set up the example data and recompute everything.
int funcNum = 0;
while (funcNum < functionCt) {
if (toks.hasMoreElements()) { // define the function using definition from example text
String def = toks.
nextToken(); if (graphs != null) {
try {
graphs[funcNum].setFunction(new SimpleFunction( parser.parse(def), xVar ));
}
catch (ParseError e) {
graphs[funcNum].setFunction(null);
}
}
else
inputs[funcNum].setText(def);
}
else { // function is undefined
if (graphs != null)
graphs[funcNum].setFunction(null);
else
inputs[funcNum].setText("");
}
funcNum++;
}
CoordinateRect coords = canvas.getCoordinateRect(0);
coords.setLimits(limits);
coords.setRestoreBuffer();
mainController.compute();
} // end doLoadExample()
} // end class MultiGraph