b a c k

CalculatorApplet.java

Fraction.java

FractionTokenStream.java

StackFullException.java

CalculatorApplet.java

import java.io.*;
import java.applet.*;
import java.awt.*;
/**
* This is not a normal calculator. You can only enter fractions
*(fractions only) in a reversed polish notation. For example:
*
* 1/2 + 1/2 = 1/1 => normal notation
* 1/2 1/2 + = 1/1 => reverse polish notation
*
* [1][/][2][SPACE][1][/][2][SPACE][+][=]
* You should get 1/1 as an answer.
*
* Creation date: (4/5/00 11:28:46 PM)
* @author: William Martin
*/

public class CalculatorApplet extends Applet {

boolean setFlag = false;// flag to clear screen as a new expression
// is about to be entered.
boolean operatorFlag = false;// flag when the last key pressed was a
// operator button.
char lastOp; // the last operator entered

java.awt.Label display;
java.awt.Button button1;
java.awt.Button button2;
java.awt.Button button3;
java.awt.Button button4;
java.awt.Button button5;
java.awt.Button button6;
java.awt.Button button7;
java.awt.Button button8;
java.awt.Button button9;
java.awt.Button button0;
java.awt.Button buttonSPACE;
java.awt.Button minus;
java.awt.Button mult;
java.awt.Button plus;
java.awt.Button equals;
java.awt.Button div;
java.awt.Button buttonCLEAR;
java.awt.Button buttonFRAC;
java.awt.Button buttonNEGATE;
private String expression = "";

//Clears the screen////////////////////////////////////////

private void clearDisplay() {
expression = "";
updateDisplay();
operatorFlag = false;
}

// Clean up crew///////////////////////////////////////////

public void destroy() {
super.destroy();
}

//Evaluate the display as a string/////////////////////////

private void evaluateDisplay() throws IOException {
if (expression != "ERROR") {// prevent the ERROR message from
// being evaluated
Stack calcStack = new LinkedStack();
try {
expression = ReversePolishCalculator.evaluate //evaluate the
(calcStack, expression).toString();//string
} catch (Exception e) {// bad input handler
expression = "ERROR";
}
}
updateDisplay();
setFlag = true; // end of evaluation flag
operatorFlag = false; // clear the operator flag
}

//Event handlers///////////////////////////////////////////

public boolean handleEvent(Event evt) {
if (evt.target == button1 && evt.id == Event.ACTION_EVENT){
stringButtonClicked("1");
}
if (evt.target == button2 && evt.id == Event.ACTION_EVENT){
stringButtonClicked("2");
}
if (evt.target == button3 && evt.id == Event.ACTION_EVENT){
stringButtonClicked("3");
}
if (evt.target == button4 && evt.id == Event.ACTION_EVENT){
stringButtonClicked("4");
}
if (evt.target == button5 && evt.id == Event.ACTION_EVENT){
stringButtonClicked("5");
}
if (evt.target == button6 && evt.id == Event.ACTION_EVENT){
stringButtonClicked("6");
}
if (evt.target == button7 && evt.id == Event.ACTION_EVENT){
stringButtonClicked("7");
}
if (evt.target == button8 && evt.id == Event.ACTION_EVENT){
stringButtonClicked("8");
}
if (evt.target == button9 && evt.id == Event.ACTION_EVENT){
stringButtonClicked("9");
}
if (evt.target == button0 && evt.id == Event.ACTION_EVENT){
stringButtonClicked("0");
}
if (evt.target == buttonCLEAR && evt.id == Event.ACTION_EVENT){
clearDisplay();
}
if (evt.target == buttonFRAC && evt.id == Event.ACTION_EVENT){
stringButtonClicked("/");
}
if (evt.target == buttonNEGATE && evt.id == Event.ACTION_EVENT){
stringButtonClicked("-");
}
if (evt.target == buttonSPACE && evt.id == Event.ACTION_EVENT){
lastOp = ' ';
stringButtonClicked(" ");
}
if (evt.target == div && evt.id == Event.ACTION_EVENT){
stringButtonClicked("/");
}
if (evt.target == minus && evt.id == Event.ACTION_EVENT){
stringButtonClicked("-");
}
if (evt.target == mult && evt.id == Event.ACTION_EVENT){
stringButtonClicked("*");
}
if (evt.target == plus && evt.id == Event.ACTION_EVENT){
stringButtonClicked("+");
}
if (evt.target == equals && evt.id == Event.ACTION_EVENT){
try {
evaluateDisplay();
}
catch(Exception e) {
expression = "ERROR";
updateDisplay();
}
}
return super.handleEvent(evt);
}

//Initializes the applet///////////////////////////////////

public void init() {
super.init();
setBackground(Color.darkGray);
setLayout(null);
resize(422, 368);

display = new java.awt.Label("0", Label.RIGHT); //LED type
display.setBounds(63, 53, 294, 30);
display.setFont(new Font("Helvetica", Font.PLAIN, 20));
display.setForeground(new Color(65280));
display.setBackground(new Color(0));
add(display);

button1 = new java.awt.Button("1");
button1.setBounds(42, 105, 77, 26);
add(button1);

button2 = new java.awt.Button("2");
button2.setBounds(126, 105, 77, 26);
add(button2);

button3 = new java.awt.Button("3");
button3.setBounds(210, 105, 77, 26);
add(button3);

button4 = new java.awt.Button("4");
button4.setBounds(42, 143, 77, 26);
add(button4);

button5 = new java.awt.Button("5");
button5.setBounds(126, 143, 77, 26);
add(button5);

button6 = new java.awt.Button("6");
button6.setBounds(210, 143, 77, 26);
add(button6);

button7 = new java.awt.Button("7");
button7.setBounds(42, 180, 77, 26);
add(button7);

button8 = new java.awt.Button("8");
button8.setBounds(126, 180, 77, 26);
add(button8);

button9 = new java.awt.Button("9");
button9.setBounds(210, 180, 77, 26);
add(button9);

button0 = new java.awt.Button("0");
button0.setBounds(42, 218, 77, 26);
add(button0);

buttonSPACE = new java.awt.Button("SPACE");
buttonSPACE.setBounds(126, 218, 77, 26);
add(buttonSPACE);

buttonFRAC = new java.awt.Button("/");
buttonFRAC.setBounds(210, 218, 77, 26);
add(buttonFRAC);

minus = new java.awt.Button("SUB");
minus.setBounds(37, 270, 77, 26);
add(minus);

mult = new java.awt.Button("MUL");
mult.setBounds(212, 270, 81, 26);
add(mult);

plus = new java.awt.Button("ADD");
plus.setBounds(121, 270, 81, 26);
add(plus);

equals = new java.awt.Button("=");
equals.setBounds(35, 308, 350, 30);
add(equals);

div = new java.awt.Button("DIV");
div.setBounds(303, 270, 81, 26);
add(div);

buttonCLEAR = new java.awt.Button("CLEAR");
buttonCLEAR.setBounds(308, 105, 77, 26);
add(buttonCLEAR);

buttonNEGATE = new java.awt.Button("NEGATIVE");
buttonNEGATE.setBounds(308, 143, 77, 26);
add(buttonNEGATE);
}

//Called to start the applet///////////////////////////////

public void start() {
super.start();
}

// Called to stop the applet///////////////////////////////

public void stop() {
super.stop();
}

//Adds button pushed to string/////////////////////////////

private void stringButtonClicked(String s) {
if (setFlag == true){//if new expression - reset display.
//However, the expression cannot be started
//with an expression
if (s.charAt(0) != '/' && s.charAt(0) != '*' && //only operator
s.charAt(0) != '+' ){ //'-' permitted
expression = s;
setFlag = false;
if (s.charAt(0) == '-')
operatorFlag = true;
}
else {//No operator - set display with starting key value
expression = "ERROR";
updateDisplay();
setFlag = true;
operatorFlag = false;
}
}
else {//if not a new expression - make sure there is no double
//operator allowed & no operator in the wrong place
if((s.charAt(0) == '/' || s.charAt(0) == '-' ||
s.charAt(0) == '*' || s.charAt(0) == '+' )&&
(operatorFlag == true)){//is user trying to double
//click a operator?
expression = expression;
lastOp = s.charAt(0);
}
else if ((s.charAt(0) == '/' || s.charAt(0) == '-' ||
s.charAt(0) == '*' || s.charAt(0) == '+' )&&
(operatorFlag == false)){//operator not re-inserted
expression = expression + s;
operatorFlag = true;
lastOp = s.charAt(0);
}
else if ((operatorFlag == true) && (lastOp == '*' ||
lastOp == '+' )) {//no re-
//insert even before a
//number key
expression = "ERROR";
updateDisplay();
setFlag = true;
operatorFlag = false;
lastOp = s.charAt(0);
}
else {// all is well
expression = expression + s;
operatorFlag = false;;
}
}
updateDisplay(); //Finally update the display with new value
}

//Update the display after an event///////////////////////

private void updateDisplay() {
display.setText(expression);
}
}//THE END

[ top ]

//CSC 321 Homework2
//
//This class makes and performs operations on fractions!
//
//Creation date: (1/30/00 11:23:53 PM)
//
//Author:William Martin

public class Fraction {

public int den;
public int num;

public class ZeroDenominator extends Exception {
public ZeroDenominator () {}
public ZeroDenominator (String s) {
super(s);
}
}
public Fraction() {}
public Fraction(int n, int d) throws ZeroDenominator {
int g;
if (d == 0)
throw new ZeroDenominator ("Cannot divide by 0");
if (n == 0) {
num = 0;
den = 1;
return;
}
if (d < 0) {
n = -n;
d = -d;
}
if ((g = gcd(n, d)) != 1) {
n /= g;
d /= g;
}
num = n;
den = d;
}
public void div(Fraction x) {

num = num * x.den;
den = x.num * den;

}
private static int gcd(int a, int b) {
a = Math.abs(a);
b = Math.abs(b);
if (a == 0)
return (b);
if (b == 0)
return (a);
int t;
while (b > 0) {
t = a % b;
a = b;
b = t;
}
return (a);
}
public void minus(Fraction x) {

num = (x.den * num) - (x.num * den);
den = den * x.den;

}
public void plus(Fraction x) {

num = (x.den * num) + (x.num * den);
den = den * x.den;

}
public void times(Fraction x) {

num = num * x.num;
den = den * x.den;

}
public String toString() {
return (num + "/" + den);
}
}

[ top ]

import java.util.*;
import java.lang.*;
/**
* This class will tokenize the input stream and provide
* methods useful to the calculator class.
* Creation date: (2/7/00 6:26:15 PM)
* Creator: William Martin
*/
public class FractionsTokenStream extends StringTokenizer {
private String str;

public class TokenException extends Exception {
public TokenException() {
}
public TokenException(String s) {
super(s);
}
}
/**
* This method uses the string tokenizer class to
* accept on line of input coming in from system.in
* and will make the sequence of tokens
*/
public FractionsTokenStream(String str) {
super(str);
}
/**
* This method tests to see if there are more tokens available
* on the current line of input.
*
* Creation date: (2/7/00 7:05:59 PM)
* @return boolean
*/
public boolean moreTokens() {
return hasMoreTokens();
}
/**
* This method should only be used after the token has been tested
* and has qualified as a fraction. Will turn the token (a string after
* the test)into a fraction.
*
* Creation date: (2/7/00 10:14:31 PM)
* @return fraction.Fraction
*/
public Fraction nextFraction() {
try {
StringTokenizer tk = new StringTokenizer(str, "/");
String n = tk.nextToken();
int num = Integer.parseInt(n);
String d = tk.nextToken();
int den = Integer.parseInt(d);
return new Fraction(num, den);
}
catch (Exception e) {
System.err.print("Fraction Exception: ");
System.out.println(e.getMessage());
return null;
}
}
/**
* This method tests the next token in order for the client
* to determine whether the token should be treated as a fraction
* or a operator.
*
* Creation date: (2/7/00 7:41:38 PM)
* @return boolean
*/
public boolean nextIsFraction() {
str = nextToken();
if (str.length() <= 1)
return false;
else {
return true;
}

}
/**
* This method should only be used after the token has been tested
* and has not qualified as a fraction. Will turn the token (a string after
* the test)into a fraction.
*
* Creation date: (2/10/00 5:27:25 PM)
* @return java.lang.String
*/
public String nextOperator() {
return str;
}
}

[ top ]

/**
* This handles stack full exception for the array based stacks..
* Creation date: (2/14/00 10:53:45 PM)
* @author: William Martin
*/
public class StackFullException extends RuntimeException {
/**
* StackFullException constructor comment.
*/
public StackFullException() {
super();
}
/**
* StackFullException constructor comment.
* @param s java.lang.String
*/
public StackFullException(String err) {
super(err);
}
}

[ top ]