This tutorial builds on the Numerical Expression Solver tutorial, adding textual variables such as “e” or “pi”, and custom ones. Then you will create an applet that takes advantage of this new functionality by creating a graphical representation of an arbitrary expression at each point in space. This applet is shown below.
Starting with the Expression.java file you created last time, add the following variable:
/* * Used for getting variables */ Variable get;
This is an object of a type we haven’t defined yet, which will serve to return numerical values for variables.
Insert the following variable() function:
/* * Evaluates variable terms. */ double variable(){ double a; StringBuffer buf = new StringBuffer(); while( s.length() > 0 && Character.isLetter( s.charAt( 0 ) ) ){ buf.append( s.charAt( 0 ) ); s = s.substring( 1 ); } String v = buf.toString(); if( v.compareTo( "e" ) == 0 ){ a = Math.E; } else if( v.compareTo( "pi" ) == 0 ){ a = Math.PI; } else { a = get.variable( v ); } return a; }
For our purposes, a “variable” is defined as any contiguous sequence of alphabetic characters. This function firsts collects all the contiguous letters, and then checks to see if it recognizes them as one of its built-in constants, “e” or “pi”. If not, it makes a call to the get object, which hopefully will recognize the variable and return the appropriate value.
This function is not being called yet, so we need to modify the term() function as follows:
double term(){ double ans = 0; StringBuffer temp = new StringBuffer(); if( Character.isLetter( s.charAt( 0 ) ) ){ // new lines return variable(); // ... } // end new lines while( s.length() > 0 && Character.isDigit( s.charAt( 0 ) ) ){ temp.append(Integer.parseInt( "" + s.charAt( 0 ) )); s = s.substring( 1 ); } ... }
These newly inserted lines check to see whether the term is a number or a variable. If it starts with a letter, we assume it is a variable and deal with it by calling variable(). Otherwise, we continue as we did before, assuming it is a number.
Now we need to modify the constructor Expression() by changing the first couple lines:
public Expression( String s, Variable v ){ get = v; // remove white space, assume only spaces or tabs StringBuffer b = new StringBuffer(); ... }
We changed the declaration to accept a Variable object as an additional argument, and then assigned it to our variable get. If you know that your expression will contain know variables, you may pass null as the second argument.
Finally, in order to run this from the command-line, you will have to change the main() function to pass null as a second argument to the Expression() constructor:
public static void main( String[] args ){ Expression e = new Expression( args[0], null ); System.out.println( e + " = " + e.evaluate() ); }
These are all the changes that we need to make to Expression.java. However, you can’t compile it until we create the interface declaration Variable.java, given below in its entirety:
public interface Variable{ /* * Returns the value of given variable. */ public double variable( String s ); }
This interface allows any object to respond to the variable() function called by an Expression instance when it encounters an unknown variable.
You can now compile and run Expression.java as before. You can now enter “e” for the number 2.718… or “pi” for 3.141… These two “variables” function as numbers now.
Now let’s create the graphical plotter that uses this new functionality. Create the file ExpressionApplet.java as follows:
import java.awt.*; import java.awt.event.*; import java.awt.image.*; public class ExpressionApplet extends java.applet.Applet implements Variable{ Image img; // image buffer used to draw plot Expression exp; // the Expression we wish to draw TextField input; // the user input field for the Expression double x, y; // the currently evaluated variables double left = -Math.PI, right = Math.PI, top = Math.PI, bottom = - Math.PI; // our bounds /* * Set up the interface, create an initial Expression, * and draw it. */ public void init(){ input = new TextField("x^2+y^2",20); Button b = new Button( "Draw" ); final Variable v = this; input.addActionListener( new ActionListener(){ public void actionPerformed( ActionEvent e ){ exp = new Expression( input.getText(), v ); img = null; repaint(); } } ); b.addActionListener( new ActionListener(){ public void actionPerformed( ActionEvent e ){ exp = new Expression( input.getText(), v ); img = null; repaint(); } } ); add( input ); add( b ); exp = new Expression("x^2+y^2", this); repaint(); } }
As you can see, we have a good number of instance variables. The init() function takes care of setting things up for us, including creating an initial Expression, and calling repaint(), which draws the results of evaluating the Expression.
If you looked carefully at the above code, you would have noticed that the string passed to the Expression to evaluate includes “x” and “y”, which it can’t evaluate. This is where the Variable interface comes into play. Expression recognizes that “x” and “y” are variables, but doesn’t know what they are, so it calls its get.variable() function to evaluate them. As you might have guessed since the declaration of ExpressionApplet says that it implements the Variable interface, and in fact the applet is passed to the Expression constructor, we will implement that function here:
/* * Looks for variables we define, and returns them * appropriately. Otherwise, returns NaN. */ public double variable( String s ){ if( s.compareTo( "x" ) == 0 || s.compareTo( "X" ) == 0 ) return x; if( s.compareTo( "y" ) == 0 || s.compareTo( "Y" ) == 0 ) return y; return Math.log(-1); }
This function is what makes the graphical element possible. In the paint() function which follows, we will go through every pixel, setting the instance variables x and y appropriately, and then evaluating the Expression. If it contains “x” or “y”, our variable() function will be called.
Now add the paint() function, which does the actual evaluation and drawing of the Expression:
/* * Evaluate and draw the Expression at every pixel. */ public void paint( Graphics g ){ double min = 0, max = 0; if( img != null ){ g.drawImage( img, 0, 0, this ); return; } for( int y = 0; y < getSize().height; y++ ){ for( int x = 0; x < getSize().width; x++ ){ mapToVirtual( x, y ); double a = exp.evaluate(); if( a > max ) max = a; else if( a < min ) min = a; } } int pix[] = new int[ getSize().width * getSize().height ]; int index = 0; for( int y = 0; y < getSize().height; y++ ){ for( int x = 0; x < getSize().width; x++ ){ mapToVirtual( x, y ); pix[ index++ ] = Color.getHSBColor( (float)(exp.evaluate()/(max-min) - min/(max-min)), 1, 1 ).getRGB(); } } img = createImage( new MemoryImageSource( getSize().width, getSize().height, pix, 0, getSize().width ) ); g.drawImage( img, 0, 0, this ); }
The first thing to notice is that we check to see if the img variable is already defined before we do anything else. If it is defined, then paint() is being called simply because it was obscured, and now needs to be refreshed. If we didn't test for this case, we would have to re-evaluate the expression at every pixel every time something happened to require the applet to refresh. The reason this works is that when the user enters a new expression, we set the img variable to null.
Next we run through every pixel in our applet, calling mapToVirtual(), which sets the instance variables x and y to the appropriate values to be returned to the Expression, since most of the time the pixel index won't correspond to the coordinate we want it to. We then evaluate the expression and find the minimum and maximum values.
Once we have done this, we create an array of integers to hold our pixel color information, and reiterate through the pixels, this time setting them to colors. We have also scaled them to values between 0 and 1 because that is what the function Color.getHSBColor() needs. Once we have filled the pixel array, we create a MemoryImageSource with it, and draw the image. The instance variable img is now non-null, so if the applet needs to refresh, it won't have to go through all that calculation again.
Now we just need the function mapToVirtual():
/* * Map a pixel coordinate to a virtual coordinate. */ public void mapToVirtual( int x, int y ){ this.x = ( (right-left)/getSize().width )*x + left; this.y = ( (bottom-top)/getSize().height )*y + top; }
This function simply maps pixels linearly from their actual coordinates to assumed coordinates, according to the right, left, top, bottom variables declared at the beginning of the class. It sets the instance variables x, y to the virtual coordinates, as required for the variable() function.
You can now compile ExpressionApplet.java and include it in an HTML page as I have done here. If you wish, you may add text fields to set the virtual boundaries, so that you can move around and zoom in and out, instead of being always confined to one view, as here.
Here is the finished file Expression.java.
Here is the finished file Variable.java.
Here is the finished file ExpressionApplet.java.