//
// Parameter_Plane is part of the MAA/USMA Lite Applet Construction Kit Project
//
// Written by Frank Wattenberg
//
// Version 0.00
// 2 May, 2002
//
import java.awt.*;
import java.applet.*;
import java.util.*;
import java.io.*; // for Expr class
import java.util.Hashtable; // for Variable class
import java.util.Vector;
public class Parameter_Plane extends Applet
{
int check_out_sw = 1;
int margin;
int graph_width = 301;
int width, height;
int mark_x[] = new int[1000];
int mark_y[] = new int[1000];
int mark_index = 0;
int mark_sw = 0; // 0 = ready to mark, 1 = not ready to mark
int de_sw = 0; // 0 = algebraically defined functions, 1 = IVP defined functions
int parameter_space_curve_sw = 0; // 1 = draw a curve in the parameter space;
int mark_point_sw; // 0 = enable point marking, 1 = disable point marking
int time_mark = 0; // Time to mark point for if parameter_space_curve_sw = 1
double a_low, a_high, b_low, b_high, x_low, x_high, y_low, y_high;
double a_value, b_value;
String a_low_label, a_high_label, b_low_label, b_high_label;
String x_low_label, x_high_label, y_low_label, y_high_label;
String a_axis_label, b_axis_label, x_axis_label, y_axis_label;
String legend_1, legend_2, legend_3;
String a_label, b_label; // Used for variable names
Graphics bG;
Image bI;
Font textfont = new Font("Courier", Font.PLAIN, 14);
Color background_color;
Color parameter_graph_color;
Color function_graph_color;
Color grid_color;
Color cursor_color;
Color mark_color;
Color mark_button_color, mark_button_shadow_color, clear_button_color, clear_button_shadow_color;
Color legend_1_color, legend_2_color, legend_3_color;
Color parameter_space_curve_color;
Color time_mark_color;
LeftArrow FastLeftArrow, SlowLeftArrow;
RightArrow FastRightArrow, SlowRightArrow;
UpArrow FastUpArrow, SlowUpArrow;
DownArrow FastDownArrow, SlowDownArrow;
VCRButton mark_button, clear_button;
Expr y_of_x[] = new Expr[10];
Expr y_prime[] = new Expr[10];
Expr initial_value[] = new Expr[10];
Color y_of_x_color[] = new Color[10];
int y_of_x_thickness[] = new int[10];
int parameter_space_curve_thickness;
int number_of_curves;
String y_of_x_string;
Variable x;
Variable a;
Variable b;
Variable y[] = new Variable[10];
Variable Picon = Variable.make("Pi"); // define Pi, pi, E, and e
Variable PIcon = Variable.make("PI");
Variable picon = Variable.make("pi");
Variable Econ = Variable.make("E");
Variable econ = Variable.make("e");
DataDisplayFrame message_window; // Window for parser error messages.
String recovery_message_line_1; // Recovery message printed for syntax errors
String recovery_message_line_2;
public void init()
{
check_out_sw = getInteger("check_out_sw", 0, 1, 1);
if (check_out_sw == 1)
{
System.out.println("Starting Parameter_Plane Applet.");
System.out.println("Parameter messages to follow.");
}
else
{
System.out.println("Starting Parameter_Plane Applet.");
System.out.println("Parameter messages omitted.");
System.out.println("To turn parameter messages on add an");
System.out.println("applet parameter tag setting check_out_sw to 1.");
}
margin = getInteger("margin", 50, 100, 50);
width = 4 * margin + 2 * graph_width;
height = 4 * margin + graph_width;
bI = createImage(width, height); // Screen buffer
bG = bI.getGraphics();
bG.setFont(textfont);
FastLeftArrow = new LeftArrow(margin + graph_width/2 - 40, margin/2, 10);
SlowLeftArrow = new LeftArrow(margin + graph_width/2 - 20, margin/2, 5);
FastRightArrow = new RightArrow(margin + graph_width/2 + 40, margin/2, 10);
SlowRightArrow = new RightArrow(margin + graph_width/2 + 20, margin/2, 5);
FastUpArrow = new UpArrow(margin + graph_width + margin/2, margin + graph_width/2 - 40, 10);
SlowUpArrow = new UpArrow(margin + graph_width + margin/2, margin + graph_width/2 - 20, 5);
FastDownArrow = new DownArrow(margin + graph_width + margin/2, margin + graph_width/2 + 40, 10);
SlowDownArrow = new DownArrow(margin + graph_width + margin/2, margin + graph_width/2 + 20, 5);
de_sw = getInteger("de_sw", 0, 1, 0);
parameter_space_curve_sw = getInteger("parameter_space_curve_sw", 0, 1, 0);
mark_point_sw = getInteger("mark_point_sw", 0, 1, 0);
background_color = getColor("background_color", "255255255");
parameter_graph_color = getColor("parameter_graph_color", "192192255");
function_graph_color = getColor("function_graph_color", "192255192");
grid_color = getColor("grid_color", "000000000");
cursor_color = getColor("cursor_color", "255000000");
mark_color = getColor("mark_color", "000000255");
mark_button_color = getColor("mark_button_color", "128128255");
mark_button_shadow_color = getColor("mark_button_shadow_color", "000000000");
clear_button_color = getColor("clear_button_color", "128128255");
clear_button_shadow_color = getColor("clear_button_shadow_color", "000000000");
parameter_space_curve_color = getColor("parameter_space_curve_color", "000000000");
time_mark_color = getColor("time_mark_color", "000000000");
mark_button = new VCRButton(margin, 3 * margin + graph_width, 80, 20,
mark_button_color, background_color, mark_button_shadow_color, "Mark point");
clear_button = new VCRButton(margin + graph_width/2, 3 * margin + graph_width, 80, 20,
clear_button_color, background_color, clear_button_shadow_color, "Clear marked points");
a_low = getDouble("a_low", -9999, 9999, -1);
a_low_label = getString("a_low_label", "-1");
a_high = getDouble("a_high", -9999, 9999, 1);
a_high_label = getString("a_high_label", "1");
a_value = getDouble("a_initial", a_low, a_high, (a_low + a_high)/2);
a_axis_label = getString("a_axis_label", "a");
a_label = getString("a_label", a_axis_label);
b_low = getDouble("b_low", -9999, 9999, -1);
b_low_label = getString("b_low_label", "-1");
b_high = getDouble("b_high", -9999, 9999, 1);
b_high_label = getString("b_high_label", "1");
b_value = getDouble("b_initial", b_low, b_high, (b_low + b_high)/2);
b_axis_label = getString("b_axis_label", "b");
b_label = getString("b_label", b_axis_label);
x_low = getDouble("x_low", -9999, 9999, -1);
x_low_label = getString("x_low_label", "-1");
x_high = getDouble("x_high", -9999, 9999, 1);
x_high_label = getString("x_high_label", "1");
x_axis_label = getString("x_axis_label", "x");
y_low = getDouble("y_low", -9999, 9999, -1);
y_low_label = getString("y_low_label", "-1");
y_high = getDouble("y_high", -9999, 9999, 1);
y_high_label = getString("y_high_label", "1");
y_axis_label = getString("y_axis_label", "y");
legend_1 = getString("legend_1", "");
legend_2 = getString("legend_2", "");
legend_3 = getString("legend_3", "");
legend_1_color = getColor("legend_1_color", "000000000");
legend_2_color = getColor("legend_2_color", "000000000");
legend_3_color = getColor("legend_3_color", "000000000");
time_mark = getInteger("time_mark_initial", 0, 150, 0);
picon.set_value(Math.PI);
Picon.set_value(Math.PI);
PIcon.set_value(Math.PI);
econ.set_value(Math.E);
Econ.set_value(Math.E);
recovery_message_line_1 = getString("recovery_message_line_1", "Algebraic Expression Syntax Error.");
recovery_message_line_2 = getString("recovery_message_line_2", "");
number_of_curves = getInteger("number_of_curves", 1, 10, 10);
for (int i = 0; i < number_of_curves; i = i + 1)
{
y_of_x_string = getString("y_of_x_"+ java.lang.Integer.toString(i + 1), "x^4/4 + b * x^2/2 + a * x");
try
{
y_of_x[i] = Parser.parse(y_of_x_string);
}
catch (SyntaxException e)
{
tell_error("Syntax error: " + e + "\n" + e.explain());
return;
}
y_of_x_string = getString("y_"+ java.lang.Integer.toString(i + 1) + "_prime", "x^4/4 + b * x^2/2 + a * x");
try
{
y_prime[i] = Parser.parse(y_of_x_string);
}
catch (SyntaxException e)
{
tell_error("Syntax error: " + e + "\n" + e.explain());
return;
}
y_of_x_color[i] = getColor("y_of_x_color_" + java.lang.Integer.toString(i + 1), "000000000");
y_of_x_thickness[i] = getInteger("y_of_x_thickness_" + java.lang.Integer.toString(i + 1), 0, 2, 1);
if (de_sw == 1)
{
y_of_x_string = getString("initial_value_" + java.lang.Integer.toString(i + 1), "t");
try
{
initial_value[i] = Parser.parse(y_of_x_string);
}
catch (SyntaxException e)
{
tell_error("Syntax error: " + e + "\n" + e.explain());
return;
}
}
}
x = Variable.make(x_axis_label);
a = Variable.make(a_label);
b = Variable.make(b_label);
parameter_space_curve_thickness = getInteger("parameter_space_curve_thickness", 0, 2, 1);
for (int i = 0; i < number_of_curves; i = i + 1)
y[i] = Variable.make(getString("y_" + java.lang.Integer.toString(i + 1) + "_label",
"y" + java.lang.Integer.toString(i + 1)));
}
public int x_coord(double x)
{
double work;
work = 3 * margin + graph_width - 1 + (x - x_low) * graph_width / (x_high - x_low);
return (int) java.lang.Math.round(work);
}
public int y_coord(double y)
{
double work;
work = margin - 1 + graph_width - (y - y_low) * graph_width / (y_high - y_low);
return (int) java.lang.Math.round(work);
}
public int a_coord(double a)
{
double work;
work = margin - 1 + (a - a_low) * graph_width / (a_high - a_low);
return (int) java.lang.Math.round(work);
}
public int b_coord(double b)
{
double work;
work = margin - 1 + graph_width - (b - b_low) * graph_width / (b_high - b_low);
return (int) java.lang.Math.round(work);
}
public int getInteger(String param_name, int low, int high, int no_param)
{
int value;
if (check_out_sw == 1)
{
System.out.println("Parameter: " + param_name);
System.out.println(" Default value: " + java.lang.Integer.toString(no_param));
}
if (getParameter(param_name) != null)
{
value = Integer.parseInt(getParameter(param_name));
value = java.lang.Math.min(high, java.lang.Math.max(low, value));
}
else
{
value = no_param;
}
if (check_out_sw == 1)
{
System.out.println(" Actual value: " + java.lang.Integer.toString(value));
}
return value;
}
public void paint(Graphics g)
{
super.paint(g);
draw_screen();
g.drawImage(bI, 0, 0, this);
}
public void update(Graphics g)
{
paint(g);
}
public void draw_screen()
{
//
// Draw before background for clipping
//
int x_start, x_end;
int y_int_start[] = new int[10];
int y_int_end[] = new int[10];
double y_start[] = new double[10];
double y_end[] = new double[10];
double v1[] = new double[10];
double v2[] = new double[10];
double v3[] = new double[10];
double v4[] = new double[10];
double curve_a_start, curve_a_end, curve_b_start, curve_b_end;
int n = 150;
int save_a[] = new int[151];
int save_b[] = new int[151];
int thickness;
int work;
double dx = (x_high - x_low)/n;
bG.setColor(parameter_graph_color);
bG.fillRect(margin, margin, graph_width, graph_width);
bG.setColor(function_graph_color);
bG.fillRect(3 * margin + graph_width, margin, graph_width, graph_width);
bG.setColor(grid_color);
for (int i = 0; i <= graph_width; i = i + graph_width/20)
{
bG.drawLine(margin, margin + i, margin + graph_width - 1, margin + i);
bG.drawLine(3 * margin + graph_width, margin + i, 3 * margin + 2 * graph_width - 1, margin + i);
bG.drawLine(margin + i, margin, margin + i, margin + graph_width - 1);
bG.drawLine(3 * margin + graph_width + i, margin, 3 * margin + graph_width + i, margin + graph_width - 1);
}
if ((a_low < 0) & (0 < a_high))
{
work = a_coord(0.0);
bG.drawLine(work - 1, margin, work - 1, margin + graph_width);
bG.drawLine(work + 1, margin, work + 1, margin + graph_width);
}
if ((x_low < 0) & (0 < x_high))
{
work = x_coord(0.0);
bG.drawLine(work - 1, margin, work - 1, margin + graph_width);
bG.drawLine(work + 1, margin, work + 1, margin + graph_width);
}
if ((b_low < 0) & (0 < b_high))
{
work = b_coord(0.0);
bG.drawLine(margin, work - 1, margin + graph_width, work - 1);
bG.drawLine(margin, work + 1, margin + graph_width, work + 1);
}
if ((y_low < 0) & (0 < y_high))
{
work = y_coord(0.0);
bG.drawLine(3 * margin + graph_width, work - 1, 3 * margin + 2 * graph_width, work - 1);
bG.drawLine(3 * margin + graph_width, work + 1, 3 * margin + 2 * graph_width, work + 1);
}
a.set_value(a_value);
b.set_value(b_value);
if (de_sw == 0)
{
//
// The curves are described by functions
//
for (int p = 0; p < number_of_curves; p = p + 1)
{
thickness = y_of_x_thickness[p];
bG.setColor(y_of_x_color[p]);
x_start = x_coord(x_low);
x.set_value(x_low);
y_int_start[p] = y_coord(y_of_x[p].value());
for (int i = 1; i <= n; i = i + 1)
{
x_end = x_coord(x_low + i * dx);
x.set_value(x_low + i * dx);
y_int_end[p] = y_coord(y_of_x[p].value());
for (int j = -thickness; j <= thickness; j = j + 1)
{
for (int k = -thickness; k <= thickness; k = k + 1)
bG.drawLine(x_start + j, y_int_start[p] + k, x_end + j, y_int_end[p] + k);
}
x_start = x_end;
y_int_start[p] = y_int_end[p];
}
}
}
else
{
//
// The curves are described by differential equations
//
// The method used is the standard fourth order Runge-Kutta Method
//
x_start = x_coord(x_low); // starting coordinate
for (int p = 0; p < number_of_curves; p = p + 1)
{
y_start[p] = initial_value[p].value(); // double value at start
y_int_start[p] = y_coord(y_start[p]); // starting coordinate
}
if (parameter_space_curve_sw == 1)
{
save_a[0] = a_coord(initial_value[0].value());
save_b[0] = b_coord(initial_value[1].value());
}
for (int i = 1; i <= n; i = i + 1)
{
x_end = x_coord(x_low + i * dx); // ending coordinate
x.set_value(x_low + (i - 1) * dx); // set values of x, y1, ... yn for computation of v1
for (int p = 0; p < number_of_curves; p = p + 1)
y[p].set_value(y_start[p]);
for (int p = 0; p < number_of_curves; p = p + 1)
v1[p] = y_prime[p].value();
x.set_value(x_low + (i - 0.5) * dx); // set values of x, y1, ... yn for computation of v2
for (int p = 0; p < number_of_curves; p = p + 1)
y[p].set_value(y_start[p] + dx * v1[p]/2);
for (int p = 0; p < number_of_curves; p = p + 1)
v2[p] = y_prime[p].value();
for (int p = 0; p < number_of_curves; p = p + 1) // set values of y1, ... yn for computation of v3
y[p].set_value(y_start[p] + dx * v2[p]/2);
for (int p = 0; p < number_of_curves; p = p + 1)
v3[p] = y_prime[p].value();
x.set_value(x_low + i * dx); // set values of x, y1, ... yn for computation of v4
for (int p = 0; p < number_of_curves; p = p + 1)
y[p].set_value(y_start[p] + dx * v3[p]);
for (int p = 0; p < number_of_curves; p = p + 1)
v4[p] = y_prime[p].value();
for (int p = 0; p < number_of_curves; p = p + 1)
{
y_end[p] = y_start[p] + dx * (v1[p] + 2 * v2[p] + 2 * v3[p] + v4[p])/6;
y_int_end[p] = y_coord(y_end[p]);
}
for (int p = 0; p < number_of_curves; p = p + 1) // graph this segment of the solution
{
thickness = y_of_x_thickness[p];
bG.setColor(y_of_x_color[p]);
for (int j = -thickness; j <= thickness; j = j + 1)
{
for (int k = -thickness; k <= thickness; k = k + 1)
bG.drawLine(x_start + j, y_int_start[p] + k, x_end + j, y_int_end[p] + k);
}
}
if (parameter_space_curve_sw == 1)
{
save_a[i] = a_coord(y_end[0]);
save_b[i] = b_coord(y_end[1]);
bG.setColor(parameter_space_curve_color);
for (int j = -parameter_space_curve_thickness; j <= parameter_space_curve_thickness; j = j + 1)
{
for (int k = -parameter_space_curve_thickness; k <= parameter_space_curve_thickness; k = k + 1)
{
if ((a_coord(y_start[0]) < graph_width + 2 * margin) &&
(a_coord(y_end[0]) < graph_width + 2 * margin))
bG.drawLine(a_coord(y_start[0]) + j, b_coord(y_start[1]) + k,
a_coord(y_end[0]) + j, b_coord(y_end[1]) + k);
}
}
}
x_start = x_end;
for (int p = 0; p < number_of_curves; p = p + 1)
{
y_start[p] = y_end[p];
y_int_start[p] = y_int_end[p];
}
}
}
//
// Draw background to clip
//
bG.setColor(background_color);
bG.fillRect(0, 0, width, margin);
bG.fillRect(0, margin + graph_width, width, 3 * margin);
bG.fillRect(0, 0, margin, height);
bG.fillRect(margin + graph_width, 0, 2 * margin, height);
bG.fillRect(3 * margin + 2 * graph_width, 0, margin, height);
//
// Draw after background
//
bG.setColor(grid_color);
FastLeftArrow.draw(bG);
SlowLeftArrow.draw(bG);
FastRightArrow.draw(bG);
SlowRightArrow.draw(bG);
FastUpArrow.draw(bG);
SlowUpArrow.draw(bG);
FastDownArrow.draw(bG);
SlowDownArrow.draw(bG);
if (mark_point_sw == 0)
{
if (mark_sw == 0)
mark_button.draw_off(bG);
else
mark_button.draw_on(bG);
if (mark_index > 0)
clear_button.draw_off(bG);
else
clear_button.draw_on(bG);
}
bG.drawString(a_low_label, margin - bG.getFontMetrics().stringWidth(a_low_label)/2, (5 * margin)/4 + graph_width + 2);
bG.drawString(a_high_label, margin + graph_width - bG.getFontMetrics().stringWidth(a_high_label)/2,
(5 * margin)/4 + graph_width + 2);
bG.drawString(x_low_label, 3 * margin + graph_width - bG.getFontMetrics().stringWidth(x_low_label)/2,
(5 * margin)/4 + graph_width + 2);
bG.drawString(x_high_label, 3 * margin + 2 * graph_width - bG.getFontMetrics().stringWidth(x_high_label)/2,
(5 * margin)/4 + graph_width + 2);
bG.drawString(b_low_label, margin - bG.getFontMetrics().stringWidth(b_low_label) - 4,
margin + graph_width + 4);
bG.drawString(b_high_label, margin - bG.getFontMetrics().stringWidth(b_high_label) - 4,
margin + 4);
bG.drawString(y_low_label, 3 * margin + graph_width - bG.getFontMetrics().stringWidth(y_low_label) - 4,
margin + graph_width + 4);
bG.drawString(y_high_label, 3 * margin + graph_width - bG.getFontMetrics().stringWidth(y_high_label) - 4,
margin + 4);
bG.drawString(a_axis_label, margin + graph_width/2 - bG.getFontMetrics().stringWidth(a_axis_label)/2,
(3 * margin)/2 + graph_width);
bG.drawString(x_axis_label, 3 * margin + (3 * graph_width)/2 - bG.getFontMetrics().stringWidth(x_axis_label)/2,
(3 * margin)/2 + graph_width);
bG.drawString(b_axis_label, margin - 12 - bG.getFontMetrics().stringWidth(b_axis_label),
margin + graph_width/2 + 4);
bG.drawString(y_axis_label, 3 * margin + graph_width - 12 - bG.getFontMetrics().stringWidth(y_axis_label),
margin + graph_width/2 + 4);
bG.setColor(legend_1_color);
bG.drawString(legend_1, width/2 - bG.getFontMetrics().stringWidth(legend_1)/2, 2 * margin + graph_width);
bG.setColor(legend_2_color);
bG.drawString(legend_2, width/2 - bG.getFontMetrics().stringWidth(legend_2)/2, 2 * margin + graph_width + 18);
bG.setColor(legend_3_color);
bG.drawString(legend_3, width/2 - bG.getFontMetrics().stringWidth(legend_3)/2, 2 * margin + graph_width + 36);
bG.setColor(cursor_color);
bG.fillRect(a_coord(a_value) - 4, b_coord(b_value) - 4, 9, 9);
bG.setColor(mark_color);
for (int i = 0; i < mark_index; i = i + 1)
bG.fillRect(mark_x[i] - 2, mark_y[i] - 2, 5, 5);
if ((parameter_space_curve_sw == 1) && (time_mark > 0))
{
bG.setColor(time_mark_color);
bG.fillOval(save_a[time_mark] - 5, save_b[time_mark] - 5, 11, 11);
bG.drawLine(3 * margin + graph_width + 2 * time_mark, margin,
3 * margin + graph_width + 2 * time_mark, margin + graph_width - 2);
bG.drawLine(3 * margin + graph_width + 2 * time_mark - 1, margin,
3 * margin + graph_width + 2 * time_mark - 1, margin + graph_width - 2);
bG.drawLine(3 * margin + graph_width + 2 * time_mark + 1, margin,
3 * margin + graph_width + 2 * time_mark + 1, margin + graph_width - 2);
for (int i = 0; i <= 6; i = i + 1)
{
bG.drawLine(3 * margin + graph_width + 2 * time_mark - i, margin - 2 - i,
3 * margin + graph_width + 2 * time_mark + i, margin - 2 - i);
bG.drawLine(3 * margin + graph_width + 2 * time_mark - i, margin + graph_width + 2 + i,
3 * margin + graph_width + 2 * time_mark + i, margin + graph_width + 2 + i);
}
}
}
public boolean mouseDown(Event evt, int mx, int my)
{
if ((margin <= mx) & (mx <= margin + graph_width) & (margin <= my) & (my <= margin + graph_width))
{
a_value = a_low + (a_high - a_low) * (mx - margin)/graph_width;
b_value = b_low + (b_high - b_low) * (graph_width + margin - my)/graph_width;
mark_sw = 0;
time_mark = 0;
repaint();
return true;
}
if (SlowLeftArrow.test(mx, my))
{
a_value = a_value - (a_high - a_low)/graph_width;
a_value = java.lang.Math.max(a_value, a_low);
mark_sw = 0;
time_mark = 0;
repaint();
return true;
}
if (FastLeftArrow.test(mx, my))
{
a_value = a_value - 15 * (a_high - a_low)/graph_width;
a_value = java.lang.Math.max(a_value, a_low);
mark_sw = 0;
time_mark = 0;
repaint();
return true;
}
if (SlowRightArrow.test(mx, my))
{
a_value = a_value + (a_high - a_low)/graph_width;
a_value = java.lang.Math.min(a_value, a_high);
mark_sw = 0;
time_mark = 0;
repaint();
return true;
}
if (FastRightArrow.test(mx, my))
{
a_value = a_value + 15 * (a_high - a_low)/graph_width;
a_value = java.lang.Math.min(a_value, a_high);
mark_sw = 0;
time_mark = 0;
repaint();
return true;
}
if (SlowDownArrow.test(mx, my))
{
b_value = b_value - (b_high - b_low)/graph_width;
b_value = java.lang.Math.max(b_value, b_low);
mark_sw = 0;
time_mark = 0;
repaint();
return true;
}
if (FastDownArrow.test(mx, my))
{
b_value = b_value - 15 * (b_high - b_low)/graph_width;
b_value = java.lang.Math.max(b_value, b_low);
mark_sw = 0;
time_mark = 0;
repaint();
return true;
}
if (SlowUpArrow.test(mx, my))
{
b_value = b_value + (b_high - b_low)/graph_width;
b_value = java.lang.Math.min(b_value, b_high);
mark_sw = 0;
time_mark = 0;
repaint();
return true;
}
if (FastUpArrow.test(mx, my))
{
b_value = b_value + 15 * (b_high - b_low)/graph_width;
b_value = java.lang.Math.min(b_value, b_high);
mark_sw = 0;
time_mark = 0;
repaint();
return true;
}
if ((mark_point_sw == 0) && (mark_button.test(mx, my)))
{
mark_x[mark_index] = a_coord(a_value);
mark_y[mark_index] = b_coord(b_value);
mark_index = java.lang.Math.min(999, mark_index + 1);
mark_sw = 1;
repaint();
return true;
}
if ((mark_point_sw == 0) && (clear_button.test(mx, my)))
{
mark_index = 0;
mark_sw = 0;
repaint();
return true;
}
if ((3 * margin + graph_width < mx) && (mx <= 3 * margin + 2 * graph_width) &&
(margin - 10 < my) && (my < margin + graph_width + 10))
{
time_mark = (mx - (3 * margin + graph_width))/2;
repaint();
return true;
}
return true;
}
public Color getColor(String color_parameter, String default_color_parameter)
{
int red, green, blue;
Color color_variable;
String work;
work = getString(color_parameter, default_color_parameter);
red = Integer.parseInt(work.substring(0, 3));
green = Integer.parseInt(work.substring(3, 6));
blue = Integer.parseInt(work.substring(6, 9));
red = java.lang.Math.max(0, java.lang.Math.min(255, red));
green = java.lang.Math.max(0, java.lang.Math.min(255, green));
blue = java.lang.Math.max(0, java.lang.Math.min(255, blue));
color_variable = new Color(red, green, blue);
return color_variable;
}
public String getString(String param_name, String no_param)
{
String value;
if (check_out_sw == 1)
{
System.out.println("Parameter: " + param_name);
System.out.println(" Default value: " + no_param);
}
if (getParameter(param_name) != null)
{
value = getParameter(param_name);
}
else
{
value = no_param;
}
if (check_out_sw == 1)
{
System.out.println(" Actual value: " + value);
}
return value;
}
public double getDouble(String param_name, double low, double high, double no_param)
{
double value;
if (check_out_sw == 1)
{
System.out.println("Parameter: " + param_name);
System.out.println(" Default value: " + java.lang.Double.toString(no_param));
}
if (getParameter(param_name) != null)
{
value = java.lang.Double.valueOf(getParameter(param_name)).doubleValue();
value = java.lang.Math.min(high, java.lang.Math.max(low, value));
}
else
{
value = no_param;
}
if (check_out_sw == 1)
{
System.out.println(" Actual value: " + java.lang.Double.toString(value));
}
return value;
}
public void tell_error(String message)
{
message_window = new DataDisplayFrame("Expression Error");
message_window.hide();
message_window.clearText();
message_window.addText("An error has been detected in an algebraic expression.\n\n");
message_window.addText(message);
message_window.addText("\n\n");
message_window.addText(recovery_message_line_1);
message_window.addText("\n");
message_window.addText(recovery_message_line_2);
message_window.addText("\n");
message_window.pack();
message_window.show();
return;
}
}
class VCRButton
{
//
// On-off button
// Click to turn on
//
public int left;
public int top;
public int width;
public int height;
public String label;
public Color button_color, back_color, shadow_color;
public VCRButton(int left, int top, int width, int height,
Color button_color, Color back_color, Color shadow_color, String label)
{
this.left = left;
this.top = top;
this.width = width;
this.height = height;
this.button_color = button_color;
this.back_color = back_color;
this.shadow_color = shadow_color;
this.label = label;
}
public void draw_on(Graphics g)
{
g.setColor(back_color);
g.fillRect(left, top, width, height);
g.setColor(button_color);
g.fillRect(left + 3, top + 3, width - 3, height - 3);
g.setColor(shadow_color);
g.drawString(label, left + width/2 - g.getFontMetrics().stringWidth(label)/2, top + height + height/2 + 4);
}
public void draw_off(Graphics g)
{
g.setColor(back_color);
g.fillRect(left, top, width, height);
g.setColor(shadow_color);
g.fillRect(left + 3, top + 3, width - 3, height - 3);
g.setColor(button_color);
g.fillRect(left, top, width - 3, height - 3);
g.setColor(shadow_color);
g.drawString(label, left + width/2 - g.getFontMetrics().stringWidth(label)/2, top + height + height/2 + 4);
}
public boolean test(int mx, int my)
{
if ((mx >= left) & (mx <= left + width) &
(my >= top) & (my <= top + height))
return true;
else
return false;
}
}
class LeftArrow
{
public int point_x;
public int point_y;
public int width;
public LeftArrow(int point_x, int point_y, int width)
{
this.point_x = point_x;
this.point_y = point_y;
this.width = width;
}
public void draw(Graphics g)
{
for (int i = 0; i <= width; i = i + 1)
g.drawLine(point_x + i, point_y + i, point_x + i, point_y - i);
}
public boolean test(int mx, int my)
{
if ((point_x <= mx) & (mx <= point_x + width) & (point_y - width <= my) & (my <= point_y + width))
return true;
else
return false;
}
}
class RightArrow
{
public int point_x;
public int point_y;
public int width;
public RightArrow(int point_x, int point_y, int width)
{
this.point_x = point_x;
this.point_y = point_y;
this.width = width;
}
public void draw(Graphics g)
{
for (int i = 0; i <= width; i = i + 1)
g.drawLine(point_x - i, point_y + i, point_x - i, point_y - i);
}
public boolean test(int mx, int my)
{
if ((point_x - width <= mx) & (mx <= point_x) & (point_y - width <= my) & (my <= point_y + width))
return true;
else
return false;
}
}
class UpArrow
{
public int point_x;
public int point_y;
public int width;
public UpArrow(int point_x, int point_y, int width)
{
this.point_x = point_x;
this.point_y = point_y;
this.width = width;
}
public void draw(Graphics g)
{
for (int i = 0; i <= width; i = i + 1)
g.drawLine(point_x + i, point_y + i, point_x - i, point_y + i);
}
public boolean test(int mx, int my)
{
if ((point_x - width <= mx) & (mx <= point_x + width) & (point_y <= my) & (my <= point_y + width))
return true;
else
return false;
}
}
class DownArrow
{
public int point_x;
public int point_y;
public int width;
public DownArrow(int point_x, int point_y, int width)
{
this.point_x = point_x;
this.point_y = point_y;
this.width = width;
}
public void draw(Graphics g)
{
for (int i = 0; i <= width; i = i + 1)
g.drawLine(point_x + i, point_y - i, point_x - i, point_y - i);
}
public boolean test(int mx, int my)
{
if ((point_x - width <= mx) & (mx <= point_x + width) & (point_y - width <= my) & (my <= point_y))
return true;
else
return false;
}
}
//
// The following is used to display information in a form that
// can be imported into another program by cut-and-paste
//
class DataDisplayFrame extends Frame
{
final static Font textfont = new Font("Courier", Font.PLAIN, 12);
TextArea txt = new TextArea();
public DataDisplayFrame (String title)
{
super(title);
txt.setEditable(true);
txt.setFont(textfont);
add(txt);
}
public void addText(String text)
{
txt.setText(txt.getText() + text);
}
public void clearText()
{
txt.setText("");
}
public boolean handleEvent(Event evt)
{
if (evt.id == Event.WINDOW_DESTROY)
dispose();
return super.handleEvent(evt);
}
}
//
// The following was written by Darius Bacon
//
abstract class Expr {
/** @return the value given the current variable values */
public abstract double value();
/** Binary operator: addition */ public static final int ADD = 0;
/** Binary operator: subtraction */ public static final int SUB = 1;
/** Binary operator: multiplication */ public static final int MUL = 2;
/** Binary operator: division */ public static final int DIV = 3;
/** Binary operator: exponentiation */ public static final int POW = 4;
/** Binary operator: arctangent */ public static final int ATAN2 = 5;
/** Binary operator: maximum */ public static final int MAX = 6;
/** Binary operator: minimum */ public static final int MIN = 7;
/** Binary operator: less than */ public static final int LT = 8;
/** Binary operator: less or equal */ public static final int LE = 9;
/** Binary operator: equality */ public static final int EQ = 10;
/** Binary operator: inequality */ public static final int NE = 11;
/** Binary operator: greater or equal*/ public static final int GE = 12;
/** Binary operator: greater than */ public static final int GT = 13;
/** Binary operator: logical and */ public static final int AND = 14;
/** Binary operator: logical or */ public static final int OR = 15;
/** Unary operator: absolute value*/ public static final int ABS = 100;
/** Unary operator: arccosine */ public static final int ACOS = 101;
/** Unary operator: arcsine */ public static final int ASIN = 102;
/** Unary operator: arctangent*/ public static final int ATAN = 103;
/** Unary operator: ceiling */ public static final int CEIL = 104;
/** Unary operator: cosine */ public static final int COS = 105;
/** Unary operator: e to the x*/ public static final int EXP = 106;
/** Unary operator: floor */ public static final int FLOOR = 107;
/** Unary operator: natural log*/ public static final int LOG = 108;
/** Unary operator: negation */ public static final int NEG = 109;
/** Unary operator: rounding */ public static final int ROUND = 110;
/** Unary operator: sine */ public static final int SIN = 111;
/** Unary operator: square root */ public static final int SQRT = 112;
/** Unary operator: tangent */ public static final int TAN = 113;
/** Make a literal expression.
* @param v the constant value of the expression
* @return an expression whose value is always v */
public static Expr makeLiteral(double v) {
return new LiteralExpr(v);
}
/** Make an expression that applies a unary operator to an operand.
* @param rator a code for a unary operator
* @param rand operand
* @return an expression meaning rator(rand)
*/
public static Expr makeApp1(int rator, Expr rand) {
Expr app = new UnaryExpr(rator, rand);
return rand instanceof LiteralExpr
? new LiteralExpr(app.value())
: app;
}
/** Make an expression that applies a binary operator to two operands.
* @param rator a code for a binary operator
* @param rand0 left operand
* @param rand1 right operand
* @return an expression meaning rator(rand0, rand1)
*/
public static Expr makeApp2(int rator, Expr rand0, Expr rand1) {
Expr app = new BinaryExpr(rator, rand0, rand1);
return rand0 instanceof LiteralExpr && rand1 instanceof LiteralExpr
? new LiteralExpr(app.value())
: app;
}
/** Make a conditional expression.
* @param test `if' part
* @param consequent `then' part
* @param alternative `else' part
* @return an expression meaning `if test, then consequent, else
* alternative'
*/
public static Expr makeIfThenElse(Expr test,
Expr consequent,
Expr alternative) {
Expr cond = new ConditionalExpr(test, consequent, alternative);
if (test instanceof LiteralExpr &&
consequent instanceof LiteralExpr &&
alternative instanceof LiteralExpr)
return new LiteralExpr(cond.value());
else
return cond;
}
}
// These classes are all private to this module so that I can get rid
// of them later. For applets you want to use as few classes as
// possible to avoid http connections at load time; it'd be profitable
// to replace all these subtypes with bytecodes for a stack machine,
// or perhaps a type that's the union of all of them (see class Node
// in java/demo/SpreadSheet/SpreadSheet.java).
class LiteralExpr extends Expr {
double v;
LiteralExpr(double v) { this.v = v; }
public double value() { return v; }
}
class UnaryExpr extends Expr {
int rator;
Expr rand;
UnaryExpr(int rator, Expr rand) {
this.rator = rator;
this.rand = rand;
}
public double value() {
double arg = rand.value();
switch (rator) {
case ABS: return Math.abs(arg);
case ACOS: return Math.acos(arg);
case ASIN: return Math.asin(arg);
case ATAN: return Math.atan(arg);
case CEIL: return Math.ceil(arg);
case COS: return Math.cos(arg);
case EXP: return Math.exp(arg);
case FLOOR: return Math.floor(arg);
case LOG: return Math.log(arg);
case NEG: return -arg;
case ROUND: return Math.round(arg);
case SIN: return Math.sin(arg);
case SQRT: return Math.sqrt(arg);
case TAN: return Math.tan(arg);
default: throw new RuntimeException("BUG: bad rator");
}
}
}
class BinaryExpr extends Expr {
int rator;
Expr rand0, rand1;
BinaryExpr(int rator, Expr rand0, Expr rand1) {
this.rator = rator;
this.rand0 = rand0;
this.rand1 = rand1;
}
public double value() {
double arg0 = rand0.value();
double arg1 = rand1.value();
switch (rator) {
case ADD: return arg0 + arg1;
case SUB: return arg0 - arg1;
case MUL: return arg0 * arg1;
case DIV: return arg0 / arg1; // division by 0 has IEEE 754 behavior
case POW: return Math.pow(arg0, arg1);
case ATAN2: return Math.atan2(arg0, arg1);
case MAX: return arg0 < arg1 ? arg1 : arg0;
case MIN: return arg0 < arg1 ? arg0 : arg1;
case LT: return arg0 < arg1 ? 1.0 : 0.0;
case LE: return arg0 <= arg1 ? 1.0 : 0.0;
case EQ: return arg0 == arg1 ? 1.0 : 0.0;
case NE: return arg0 != arg1 ? 1.0 : 0.0;
case GE: return arg0 >= arg1 ? 1.0 : 0.0;
case GT: return arg0 > arg1 ? 1.0 : 0.0;
case AND: return arg0 != 0 && arg1 != 0 ? 1.0 : 0.0;
case OR: return arg0 != 0 || arg1 != 0 ? 1.0 : 0.0;
default: throw new RuntimeException("BUG: bad rator");
}
}
}
class ConditionalExpr extends Expr {
Expr test, consequent, alternative;
ConditionalExpr(Expr test, Expr consequent, Expr alternative) {
this.test = test;
this.consequent = consequent;
this.alternative = alternative;
}
public double value() {
return test.value() != 0 ? consequent.value() : alternative.value();
}
}
// Operator-precedence parser.
// Copyright 1996 by Darius Bacon; see the file COPYING.
/**
Parses strings representing mathematical formulas with variables.
The following operators, in descending order of precedence, are
defined:
- ^ (raise to a power)
- * /
- Unary minus (-x)
- + -
- < <= = <> >= >
- and
- or
^ associates right-to-left; other operators associate left-to-right.
These functions are defined:
abs, acos, asin, atan,
ceil, cos, exp, floor,
log, round, sin, sqrt,
tan. Each requires one argument enclosed in parentheses.
There are also binary functions: atan2, min, max; and a ternary
conditional function: if(test, then, else).
Whitespace outside identifiers is ignored.
Examples:
- 42
- 2-3
- cos(x^2) + sin(x^2)
*/
class Parser {
// Built-in constants
static private Variable pi = Variable.make("pi");
static {
pi.setValue(Math.PI);
}
/** Return the expression denoted by the input string.
*
* @param input the unparsed expression
* @exception SyntaxException if the input is unparsable */
static public Expr parse(String input) throws SyntaxException {
return new Parser().parseString(input);
}
/** Set of Variable's that are allowed to appear in input expressions.
* If null, any Variable is allowed. */
private Hashtable allowedVariables = null;
public void allow(Variable variable) {
if (null == allowedVariables) {
allowedVariables = new Hashtable();
allowedVariables.put(pi, pi);
}
allowedVariables.put(variable, variable);
}
Scanner tokens = null;
private Token token = null;
/** Return the expression denoted by the input string.
*
* @param input the unparsed expression
* @exception SyntaxException if the input is unparsable */
public Expr parseString(String input) throws SyntaxException {
String operatorChars = "+-*/^<>=,";
tokens = new Scanner(input, operatorChars);
return reparse();
}
private Expr reparse() throws SyntaxException {
tokens.index = -1;
nextToken();
Expr expr = parseExpr(0);
if (token.ttype != Token.TT_EOF)
throw error("Incomplete expression",
SyntaxException.INCOMPLETE, null);
return expr;
}
private void nextToken() {
token = tokens.nextToken();
}
private Expr parseExpr(int precedence) throws SyntaxException {
Expr expr = parseFactor();
loop:
for (;;) {
int l, r, rator;
// The operator precedence table.
// l = left precedence, r = right precedence, rator = operator.
// Higher precedence values mean tighter binding of arguments.
// To associate left-to-right, let r = l+1;
// to associate right-to-left, let r = l.
switch (token.ttype) {
case '<': l = 20; r = 21; rator = Expr.LT; break;
case Token.TT_LE: l = 20; r = 21; rator = Expr.LE; break;
case '=': l = 20; r = 21; rator = Expr.EQ; break;
case Token.TT_NE: l = 20; r = 21; rator = Expr.NE; break;
case Token.TT_GE: l = 20; r = 21; rator = Expr.GE; break;
case '>': l = 20; r = 21; rator = Expr.GT; break;
case '+': l = 30; r = 31; rator = Expr.ADD; break;
case '-': l = 30; r = 31; rator = Expr.SUB; break;
case '/': l = 40; r = 41; rator = Expr.DIV; break;
case '*': l = 40; r = 41; rator = Expr.MUL; break;
case '^': l = 50; r = 50; rator = Expr.POW; break;
default:
if (token.ttype == Token.TT_WORD && token.sval.equals("and")) {
l = 5; r = 6; rator = Expr.AND; break;
}
if (token.ttype == Token.TT_WORD && token.sval.equals("or")) {
l = 10; r = 11; rator = Expr.OR; break;
}
break loop;
}
if (l < precedence)
break loop;
nextToken();
expr = Expr.makeApp2(rator, expr, parseExpr(r));
}
return expr;
}
static private final String[] procs1 = {
"abs", "acos", "asin", "atan",
"ceil", "cos", "exp", "floor",
"log", "round", "sin", "sqrt",
"tan"
};
static private final int[] rators1 = {
Expr.ABS, Expr.ACOS, Expr.ASIN, Expr.ATAN,
Expr.CEIL, Expr.COS, Expr.EXP, Expr.FLOOR,
Expr.LOG, Expr.ROUND, Expr.SIN, Expr.SQRT,
Expr.TAN
};
static private final String[] procs2 = {
"atan2", "max", "min"
};
static private final int[] rators2 = {
Expr.ATAN2, Expr.MAX, Expr.MIN
};
private boolean atStartOfFactor() {
return token.ttype == Token.TT_NUMBER
|| token.ttype == Token.TT_WORD
|| token.ttype == '('
|| token.ttype == '-';
}
private Expr parseFactor() throws SyntaxException {
switch (token.ttype) {
case Token.TT_NUMBER: {
Expr lit = Expr.makeLiteral(token.nval);
nextToken();
return lit;
}
case Token.TT_WORD: {
for (int i = 0; i < procs1.length; ++i)
if (procs1[i].equals(token.sval)) {
nextToken();
expect('(');
Expr rand = parseExpr(0);
expect(')');
return Expr.makeApp1(rators1[i], rand);
}
for (int i = 0; i < procs2.length; ++i)
if (procs2[i].equals(token.sval)) {
nextToken();
expect('(');
Expr rand1 = parseExpr(0);
expect(',');
Expr rand2 = parseExpr(0);
expect(')');
return Expr.makeApp2(rators2[i], rand1, rand2);
}
if (token.sval.equals("if")) {
nextToken();
expect('(');
Expr test = parseExpr(0);
expect(',');
Expr consequent = parseExpr(0);
expect(',');
Expr alternative = parseExpr(0);
expect(')');
return Expr.makeIfThenElse(test, consequent, alternative);
}
Expr var = Variable.make(token.sval);
if (null != allowedVariables && null == allowedVariables.get(var))
throw error("Unknown variable",
SyntaxException.UNKNOWN_VARIABLE, null);
nextToken();
return var;
}
case '(': {
nextToken();
Expr enclosed = parseExpr(0);
expect(')');
return enclosed;
}
case '-':
nextToken();
return Expr.makeApp1(Expr.NEG, parseExpr(35));
case Token.TT_EOF:
throw error("Expected a factor",
SyntaxException.PREMATURE_EOF, null);
default:
throw error("Expected a factor",
SyntaxException.BAD_FACTOR, null);
}
}
private SyntaxException error(String complaint,
int reason,
String expected) {
return new SyntaxException(complaint, this, reason, expected);
}
private void expect(int ttype) throws SyntaxException {
if (token.ttype != ttype)
throw error("'" + (char)ttype + "' expected",
SyntaxException.EXPECTED, "" + (char)ttype);
nextToken();
}
// Error correction
boolean tryCorrections() {
return tryInsertions() || tryDeletions() || trySubstitutions();
}
private boolean tryInsertions() {
Vector v = tokens.tokens;
for (int i = tokens.index; 0 <= i; --i) {
Token t;
if (i < v.size()) {
t = (Token) v.elementAt(i);
} else {
String s = tokens.getInput();
t = new Token(Token.TT_EOF, 0, s, s.length(), s.length());
}
Token[] candidates = possibleInsertions(t);
for (int j = 0; j < candidates.length; ++j) {
v.insertElementAt(candidates[j], i);
try {
reparse();
return true;
} catch (SyntaxException se) {
v.removeElementAt(i);
}
}
}
return false;
}
private boolean tryDeletions() {
Vector v = tokens.tokens;
for (int i = tokens.index; 0 <= i; --i) {
if (v.size() <= i)
continue;
Object t = v.elementAt(i);
v.remove(i);
try {
reparse();
return true;
} catch (SyntaxException se) {
v.insertElementAt(t, i);
}
}
return false;
}
private boolean trySubstitutions() {
Vector v = tokens.tokens;
for (int i = tokens.index; 0 <= i; --i) {
if (v.size() <= i)
continue;
Token t = (Token) v.elementAt(i);
Token[] candidates = possibleSubstitutions(t);
for (int j = 0; j < candidates.length; ++j) {
v.setElementAt(candidates[j], i);
try {
reparse();
return true;
} catch (SyntaxException se) { }
}
v.setElementAt(t, i);
}
return false;
}
private Token[] possibleInsertions(Token t) {
String ops = tokens.getOperatorChars();
Token[] ts =
new Token[ops.length() + 6 + procs1.length + procs2.length];
int i = 0;
Token one = new Token(Token.TT_NUMBER, 1, "1", t);
ts[i++] = one;
for (int j = 0; j < ops.length(); ++j)
ts[i++] = new Token(ops.charAt(j), 0, "" + ops.charAt(j), t);
ts[i++] = new Token(Token.TT_WORD, 0, "x", t);
for (int k = 0; k < procs1.length; ++k)
ts[i++] = new Token(Token.TT_WORD, 0, procs1[k], t);
for (int m = 0; m < procs2.length; ++m)
ts[i++] = new Token(Token.TT_WORD, 0, procs2[m], t);
ts[i++] = new Token(Token.TT_LE, 0, "<=", t);
ts[i++] = new Token(Token.TT_NE, 0, "<>", t);
ts[i++] = new Token(Token.TT_GE, 0, ">=", t);
ts[i++] = new Token(Token.TT_WORD, 0, "if", t);
return ts;
}
private Token[] possibleSubstitutions(Token t) {
return possibleInsertions(t);
}
}
class Scanner {
private String s;
private String operatorChars;
Vector tokens = new Vector();
int index = -1;
public Scanner(String string, String operatorChars) {
this.s = string;
this.operatorChars = operatorChars + "()";
int i = 0;
do {
i = scanToken(i);
} while (i < s.length());
}
public String getInput() {
return s;
}
public String getOperatorChars() {
return operatorChars;
}
// The tokens may have been diddled, so this can be different from
// getInput().
public String toString() {
StringBuffer sb = new StringBuffer();
int whitespace = 0;
for (int i = 0; i < tokens.size(); ++i) {
Token t = (Token) tokens.elementAt(i);
int spaces = (whitespace != 0 ? whitespace : t.leadingWhitespace);
if (i == 0)
spaces = 0;
else if (spaces == 0 && !joinable((Token) tokens.elementAt(i-1), t))
spaces = 1;
for (int j = spaces; 0 < j; --j)
sb.append(" ");
sb.append(t.sval);
whitespace = t.trailingWhitespace;
}
return sb.toString();
}
private boolean joinable(Token s, Token t) {
return !(isAlphanumeric(s) && isAlphanumeric(t));
}
private boolean isAlphanumeric(Token t) {
return t.ttype == Token.TT_WORD || t.ttype == Token.TT_NUMBER;
}
public boolean isEmpty() {
return tokens.size() == 0;
}
public boolean atStart() {
return index <= 0;
}
public boolean atEnd() {
return tokens.size() <= index;
}
public Token nextToken() {
++index;
return getCurrentToken();
}
public Token getCurrentToken() {
if (atEnd())
return new Token(Token.TT_EOF, 0, s, s.length(), s.length());
return (Token) tokens.elementAt(index);
}
private int scanToken(int i) {
while (i < s.length() && Character.isWhitespace(s.charAt(i)))
++i;
if (i == s.length()) {
return i;
} else if (0 <= operatorChars.indexOf(s.charAt(i))) {
if (i+1 < s.length()) {
String pair = s.substring(i, i+2);
int ttype = 0;
if (pair.equals("<="))
ttype = Token.TT_LE;
else if (pair.equals(">="))
ttype = Token.TT_GE;
else if (pair.equals("<>"))
ttype = Token.TT_NE;
if (0 != ttype) {
tokens.addElement(new Token(ttype, 0, s, i, i+2));
return i+2;
}
}
tokens.addElement(new Token(s.charAt(i), 0, s, i, i+1));
return i+1;
} else if (Character.isLetter(s.charAt(i))) {
return scanSymbol(i);
} else if (Character.isDigit(s.charAt(i)) || '.' == s.charAt(i)) {
return scanNumber(i);
} else {
tokens.addElement(makeErrorToken("Unknown lexeme", i, i+1));
return i+1;
}
}
private int scanSymbol(int i) {
int from = i;
while (i < s.length()
&& (Character.isLetter(s.charAt(i))
|| Character.isDigit(s.charAt(i))))
++i;
tokens.addElement(new Token(Token.TT_WORD, 0, s, from, i));
return i;
}
private int scanNumber(int i) {
int from = i;
// We include letters in our purview because otherwise we'd
// accept a word following with no intervening space.
for (; i < s.length(); ++i)
if ('.' != s.charAt(i)
&& !Character.isDigit(s.charAt(i))
&& !Character.isLetter(s.charAt(i)))
break;
String text = s.substring(from, i);
double nval;
try {
nval = Double.valueOf(text).doubleValue();
} catch (NumberFormatException nfe) {
tokens.addElement(makeErrorToken("Not a number", from, i));
return i;
}
tokens.addElement(new Token(Token.TT_NUMBER, nval, s, from, i));
return i;
}
private Token makeErrorToken(String complaint, int from, int i) {
// TODO: incorporate the complaint somehow
return new Token(Token.TT_ERROR, 0, s, from, i);
}
}
/**
* An exception indicating a problem in parsing an expression. It can
* produce a short, cryptic error message (with getMessage()) or a
* long, hopefully helpful one (with explain()).
*/
/**
* An exception indicating a problem in parsing an expression. It can
* produce a short, cryptic error message (with getMessage()) or a
* long, hopefully helpful one (with explain()).
*/
class SyntaxException extends Exception {
/** An error code meaning the input string had stuff left over. */
public static final int INCOMPLETE = 0;
/** An error code meaning the parser ran into a non-value token
(like "/") at a point it was expecting a value (like "42" or
"x^2"). */
public static final int BAD_FACTOR = 1;
/** An error code meaning the parser hit the end of its input
before it had parsed a full expression. */
public static final int PREMATURE_EOF = 2;
/** An error code meaning the parser hit an unexpected token at a
point it expected to see some particular other token. */
public static final int EXPECTED = 3;
/** An error code meaning the expression includes a variable not
on the `approved' list. */
public static final int UNKNOWN_VARIABLE = 4;
/** Make a new instance.
* @param complaint short error message
* @param parser the parser that hit this snag
* @param reason one of the error codes defined in this class
* @param expected if nonnull, the token the parser expected to
* see (in place of the erroneous token it did see)
*/
public SyntaxException(String complaint,
Parser parser,
int reason,
String expected) {
super(complaint);
this.reason = reason;
this.parser = parser;
this.scanner = parser.tokens;
this.expected = expected;
}
/** Give a long, hopefully helpful error message.
* @returns the message */
public String explain() {
StringBuffer sb = new StringBuffer();
sb.append("I don't understand your formula ");
quotify(sb, scanner.getInput());
sb.append(".\n\n");
explainWhere(sb);
explainWhy(sb);
explainWhat(sb);
return sb.toString();
}
private Parser parser;
private Scanner scanner;
private int reason;
private String expected;
private String fixedInput = "";
private void explainWhere(StringBuffer sb) {
if (scanner.isEmpty()) {
sb.append("It's empty!\n");
} else if (scanner.atStart()) {
sb.append("It starts with ");
quotify(sb, theToken());
if (isLegalToken())
sb.append(", which can never be the start of a formula.\n");
else
sb.append(", which is a meaningless symbol to me.\n");
} else {
sb.append("I got as far as ");
quotify(sb, asFarAs());
sb.append(" and then ");
if (scanner.atEnd()) {
sb.append("reached the end unexpectedly.\n");
} else {
sb.append("saw ");
quotify(sb, theToken());
if (isLegalToken())
sb.append(".\n");
else
sb.append(", which is a meaningless symbol to me.\n");
}
}
}
private void explainWhy(StringBuffer sb) {
switch (reason) {
case INCOMPLETE:
if (isLegalToken())
sb.append("The first part makes sense, but I don't see " +
"how the rest connects to it.\n");
break;
case BAD_FACTOR:
case PREMATURE_EOF:
sb.append("I expected a value");
if (!scanner.atStart()) sb.append(" to follow");
sb.append(", instead.\n");
break;
case EXPECTED:
sb.append("I expected ");
quotify(sb, expected);
sb.append(" at that point, instead.\n");
break;
case UNKNOWN_VARIABLE:
sb.append("That variable has no value.\n");
break;
default:
throw new Error("Can't happen");
}
}
private void explainWhat(StringBuffer sb) {
fixedInput = tryToFix();
if (null != fixedInput) {
sb.append("An example of a formula I can parse is ");
quotify(sb, fixedInput);
sb.append(".\n");
}
}
private String tryToFix() {
return (parser.tryCorrections() ? scanner.toString() : null);
}
private void quotify(StringBuffer sb, String s) {
sb.append('"');
sb.append(s);
sb.append('"');
}
private String asFarAs() {
Token t = scanner.getCurrentToken();
int point = t.location - t.leadingWhitespace;
return scanner.getInput().substring(0, point);
}
private String theToken() {
return scanner.getCurrentToken().sval;
}
private boolean isLegalToken() {
Token t = scanner.getCurrentToken();
return t.ttype != Token.TT_EOF
&& t.ttype != Token.TT_ERROR;
}
}
class Token {
public static final int TT_ERROR = -1;
public static final int TT_EOF = -2;
public static final int TT_NUMBER = -3;
public static final int TT_WORD = -4;
public static final int TT_LE = -5;
public static final int TT_NE = -6;
public static final int TT_GE = -7;
public Token(int ttype, double nval, String input, int start, int end) {
this.ttype = ttype;
this.sval = input.substring(start, end);
this.nval = nval;
this.location = start;
int count = 0;
for (int i = start-1; 0 <= i; --i) {
if (!Character.isWhitespace(input.charAt(i)))
break;
++count;
}
this.leadingWhitespace = count;
count = 0;
for (int i = end; i < input.length(); ++i) {
if (!Character.isWhitespace(input.charAt(i)))
break;
++count;
}
this.trailingWhitespace = count;
}
Token(int ttype, double nval, String sval, Token token) {
this.ttype = ttype;
this.sval = sval;
this.nval = nval;
this.location = token.location;
this.leadingWhitespace = token.leadingWhitespace;
this.trailingWhitespace = token.trailingWhitespace;
}
public final int ttype;
public final String sval;
public final double nval;
public final int location;
public final int leadingWhitespace, trailingWhitespace;
}
/**
* A variable is a simple expression with a name (like "x") and a
* changeable value.
*/
/**
* A variable is a simple expression with a name (like "x") and a
* changeable value.
*/
class Variable extends Expr {
private static Hashtable variables = new Hashtable();
/**
* Return the variable named `name'. There can be only one
* variable with the same name returned by this method; that is,
* make(s1) == make(s2) if and only if s1.equals(s2).
* @param name the variable's name
* @return the variable; create it initialized to 0 if it doesn't
* yet exist */
static public synchronized Variable make(String name) {
Variable result = (Variable) variables.get(name);
if (result == null)
variables.put(name, result = new Variable(name));
return result;
}
private String name;
private double val;
/**
* Create a new variable.
* @param name the variable's name
*/
public Variable(String name) {
this.name = name; val = 0;
}
public String toString() { return name; }
/** Get the value.
* @return the current value */
public double value() {
return val;
}
/** Set the value.
* @param value the new value */
public void setValue(double value) {
val = value;
}
public void set_value(double value) {
val = value;
}
}