Inital commitHEADmaster

1 files changed, 495 insertions, 0 deletions

diff --git a/projects/project2_LInfiniteInteger/InfiniteIntegerCalculatorFrame.java b/projects/project2_LInfiniteInteger/InfiniteIntegerCalculatorFrame.java
new file mode 100644
index 0000000..6e88ff8
--- /dev/null
+++ b/projects/project2_LInfiniteInteger/InfiniteIntegerCalculatorFrame.java
@@ -0,0 +1,495 @@
+import java.awt.BorderLayout;
+import java.awt.Font;
+import java.awt.GridLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.KeyListener;
+import java.util.ArrayList;
+
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+import javax.swing.JTextArea;
+
+@SuppressWarnings("serial")
+public class InfiniteIntegerCalculatorFrame extends JFrame
+{
+	private JButton[] numberButtons;	// number buttons (0 to 9)
+	private JButton plusButton;			// plus button (+)
+	private JButton minusButton;		// minus button (-)
+	private JButton multiplyButton;		// multiply button (*)
+	private JButton backButton;			// back button (<-)
+	private JButton equalButton;		// equal button (=)
+	private JButton clearButton;		//clear button (C)
+	private JTextArea textArea;			// Text area for expression and result
+	private JPanel buttonPanel;			// panel for all buttons
+	private ArrayList<String> ppString;	// Pretty printing string
+	private KeyListener kListener;
+	
+	public InfiniteIntegerCalculatorFrame()
+	{
+		textArea = new JTextArea();
+		textArea.setText("0");
+		textArea.setEditable(false);
+		textArea.setLineWrap(true);
+		
+		kListener = new KeyEvent();
+		textArea.addKeyListener(kListener);
+		
+		Font font = new Font(Font.SERIF, Font.BOLD, 20);
+		textArea.setFont(font);
+
+		setButtonsAndPanel();
+
+		add(buttonPanel, BorderLayout.EAST);
+		add(textArea, BorderLayout.CENTER);
+		
+		ppString = new ArrayList<String>();
+		ppString.add("0");
+	}
+	
+	public class KeyEvent implements KeyListener
+	{
+		public void keyPressed(java.awt.event.KeyEvent arg0)
+		{
+			int keyCode = arg0.getKeyCode();
+			char keyChar = arg0.getKeyChar();
+			
+			if(keyCode >= 48 && keyCode <=57 && keyChar != '*')
+			{
+				ButtonListener bl = new ButtonListener(keyCode - 48);
+				bl.actionPerformed(new ActionEvent(numberButtons[keyCode - 48], 1001, "" + (keyCode - 48)));
+			}
+			else if(keyCode >= 96 && keyCode <= 105)
+			{
+				ButtonListener bl = new ButtonListener(keyCode - 96);
+				bl.actionPerformed(new ActionEvent(numberButtons[keyCode - 96], 1001, "" + (keyCode - 96)));
+			}
+			else if(keyCode == 61 && keyChar == '+')
+			{
+				ButtonListener bl = new ButtonListener(10);
+				bl.actionPerformed(new ActionEvent(equalButton, 1001, "+"));
+			}
+			else if(keyCode == 107)
+			{
+				ButtonListener bl = new ButtonListener(10);
+				bl.actionPerformed(new ActionEvent(equalButton, 1001, "+"));
+			}
+			else if(keyCode == 45 && keyChar == '-')
+			{
+				ButtonListener bl = new ButtonListener(11);
+				bl.actionPerformed(new ActionEvent(minusButton, 1001, "-"));
+			}
+			else if(keyCode == 109)
+			{
+				ButtonListener bl = new ButtonListener(11);
+				bl.actionPerformed(new ActionEvent(minusButton, 1001, "-"));
+			}
+			else if(keyCode == 56 && keyChar == '*')
+			{
+				ButtonListener bl = new ButtonListener(12);
+				bl.actionPerformed(new ActionEvent(multiplyButton, 1001, "*"));
+			}
+			else if(keyCode == 106)
+			{
+				ButtonListener bl = new ButtonListener(12);
+				bl.actionPerformed(new ActionEvent(multiplyButton, 1001, "*"));
+			}
+			else if(keyCode == 8)
+			{
+				ButtonListener bl = new ButtonListener(13);
+				bl.actionPerformed(new ActionEvent(backButton, 1001, "<-"));
+			}
+			else if(keyCode == 61 && keyChar == '=')
+			{
+				ButtonListener bl = new ButtonListener(14);
+				bl.actionPerformed(new ActionEvent(equalButton, 1001, "="));
+			}
+			else if(keyCode == 10)
+			{
+				ButtonListener bl = new ButtonListener(14);
+				bl.actionPerformed(new ActionEvent(equalButton, 1001, "="));
+			}
+			else if(keyCode == 67)
+			{
+				ButtonListener bl = new ButtonListener(15);
+				bl.actionPerformed(new ActionEvent(clearButton, 1001, "C"));
+			}
+		}
+
+		public void keyReleased(java.awt.event.KeyEvent arg0)
+		{
+		}
+
+		public void keyTyped(java.awt.event.KeyEvent arg0)
+		{
+		}
+	}
+	
+	/**
+	 * setButtonsAndPanel
+	 * 
+	 * Initialize all buttons, initialize the button panel,
+	 * and add all buttons into button panel.
+	 */
+	private void setButtonsAndPanel()
+	{
+		numberButtons = new JButton[10];
+		ButtonListener[] nbls = new ButtonListener[16];
+		for(int i = 0; i <= 9; i++)
+		{
+			numberButtons[i] = new JButton("" + i);
+			nbls[i] = new ButtonListener(i);
+			numberButtons[i].addActionListener(nbls[i]);
+		}
+		
+		plusButton = new JButton("+");
+		nbls[10] = new ButtonListener(10);
+		plusButton.addActionListener(nbls[10]);
+		
+		minusButton = new JButton("-");
+		nbls[11] = new ButtonListener(11);
+		minusButton.addActionListener(nbls[11]);
+		
+		multiplyButton = new JButton("*");
+		nbls[12] = new ButtonListener(12);
+		multiplyButton.addActionListener(nbls[12]);
+		
+		backButton = new JButton("<-");
+		nbls[13] = new ButtonListener(13);
+		backButton.addActionListener(nbls[13]);
+		
+		equalButton = new JButton("=");
+		nbls[14] = new ButtonListener(14);
+		equalButton.addActionListener(nbls[14]);
+		
+		clearButton = new JButton("C");
+		nbls[15] = new ButtonListener(15);
+		clearButton.addActionListener(nbls[15]);
+
+		buttonPanel = new JPanel();
+		buttonPanel.setLayout(new GridLayout(4,4));
+		
+		buttonPanel.add(numberButtons[7]);
+		buttonPanel.add(numberButtons[8]);
+		buttonPanel.add(numberButtons[9]);
+		buttonPanel.add(plusButton);
+		buttonPanel.add(numberButtons[4]);
+		buttonPanel.add(numberButtons[5]);
+		buttonPanel.add(numberButtons[6]);
+		buttonPanel.add(minusButton);
+		buttonPanel.add(numberButtons[1]);
+		buttonPanel.add(numberButtons[2]);
+		buttonPanel.add(numberButtons[3]);
+		buttonPanel.add(multiplyButton);
+		buttonPanel.add(numberButtons[0]);
+		buttonPanel.add(equalButton);
+		buttonPanel.add(clearButton);
+		buttonPanel.add(backButton);
+	}
+
+	private class ButtonListener implements ActionListener
+	{
+		private int number;
+		
+		private ButtonListener(int aNumber)
+		{
+			/* Number associated with each button as follows:
+			 *   - 0 to 9 for number buttons
+			 *   - 10 for +
+			 *   - 11 for -
+			 *   - 12 for *
+			 *   - 13 for <-
+			 *   - 14 for =
+			 *   - 15 for C
+			 */
+			number = aNumber;
+		}
+		
+		public void actionPerformed(ActionEvent arg0)
+		{
+			int ppSize = ppString.size();
+			boolean error = false;
+			
+			if(number < 10)
+			{
+				if(ppSize == 1)
+				{
+					String temp = ppString.get(0);
+					
+					if(temp.equals("+") || temp.equals("*"))
+					{
+						ppString.add("" + number);
+					}
+					else if(temp.equals("0"))
+					{
+						ppString.set(0, "" + number);
+					}
+					else
+					{
+						ppString.set(0,temp + number);
+					}
+				}
+				else
+				{
+					String temp = ppString.get(ppSize - 1);
+					
+					if(temp.equals("+") || temp.equals("*"))
+					{
+						ppString.add("" + number);
+					}
+					else if(temp.equals("-"))
+					{
+						if(ppString.get(ppSize - 2).equals("+") || ppString.get(ppSize - 2).equals("*"))
+						{
+							ppString.set(ppSize - 1, temp + number);
+						}
+						else
+						{
+							ppString.add("" + number);
+						}
+					}
+					else
+					{
+						ppString.set(ppSize - 1, temp + number);
+					}
+				}
+			}
+			else if(number == 10)
+			{
+				ppString.add("+");
+			}
+			else if(number == 11)
+			{
+				ppString.add("-");
+			}
+			else if(number == 12)
+			{
+				ppString.add("*");
+			}
+			else if(number == 13)
+			{
+				if(ppSize > 0)
+				{
+					String temp = ppString.get(ppSize - 1);
+				
+					if(temp.length() > 1)
+					{
+						ppString.set(ppSize - 1, temp.substring(0, temp.length() - 1));
+					}
+					else
+					{
+						ppString.remove(ppSize - 1);
+					}
+				}
+			}
+			else if(number == 14)
+			{
+				InfiniteIntegerInterface result = calculateResult();
+				
+				if(result == null)
+				{
+					error = true;
+				}
+				else
+				{
+					ppString.clear();
+					ppString.add(result.toString());
+				}
+			}
+			else if(number == 15)
+			{
+				ppString.clear();
+				ppString.add("0");
+			}
+			
+			// Set textArea according to ppString
+			
+			ppSize = ppString.size();
+			String displayString = "";
+
+			if(ppSize > 0)
+			{
+				for(int i = 0; i < ppSize; i++)
+				{
+					displayString = displayString + ppString.get(i) + " ";
+				}
+			}
+			else
+			{
+				displayString = "0";
+			}
+			
+			if(error)
+			{
+				displayString = displayString + "\nInvalid Expression";
+			}
+			
+			textArea.setText(displayString);
+		}
+	}
+	
+	/**
+	 * calculateResult()
+	 * 
+	 * This method constructs a postfix expression base on the infix expression
+	 * stored in the array list of string ppString using stack as explained in
+	 * class. Then evaluate the postfix expression using stack.
+	 * 
+	 * @return an infinite integer as a result if the expression is valid.
+	 * Otherwise, return null to indicate invalid expression.
+	 */
+	private InfiniteIntegerInterface calculateResult()
+	{
+		ArrayList<String> postFix = new ArrayList<String>();		// Postfix expression
+		StackInterface<String> operators = new LStack<String>();	// Stack to store operators
+		
+		// Convert infix expression into postfix expression
+		
+		int expSize = ppString.size();
+		
+		for(int i = 0; i < expSize; i++)
+		{
+			String temp = ppString.get(i);
+			
+			if(temp.length() > 1)
+			{
+				postFix.add(temp);
+			}
+			else if(isOperator(temp.charAt(0)))
+			{
+				if(temp.equals("+") || temp.equals("-"))
+				{
+					while(!operators.isEmpty())
+					{
+						postFix.add(operators.pop());
+					}
+					operators.push(temp);
+				}
+				else
+				{
+					while(!operators.isEmpty() && operators.peek().equals("*"))
+					{
+						postFix.add(operators.pop());
+					}
+					operators.push(temp);
+				}
+			}
+			else
+			{
+				postFix.add(temp);
+			}
+		}
+		
+		while(!operators.isEmpty())
+		{
+			postFix.add(operators.pop());
+		}
+		
+		// Display postfix expression
+		
+		System.out.print("Postfix: ");
+		
+		for(int i = 0; i < postFix.size(); i++)
+		{
+			System.out.print(postFix.get(i) + " ");
+		}
+		System.out.println();
+		
+		// Evaluate postfix expression
+		
+		StackInterface<InfiniteIntegerInterface> resultStack = new LStack<InfiniteIntegerInterface>();
+		
+		int postFixSize = postFix.size();
+		
+		for(int i = 0; i < postFixSize; i++)
+		{
+			String temp = postFix.get(i);
+			
+			if(temp.length() == 1 && isOperator(temp.charAt(0)))
+			{
+				/* Encounter an operator, pop the top of the stack
+				 * twice to use those numbers as operand, calculate
+				 * the result, and push the result back onto the
+				 * stack.
+				 */
+				InfiniteIntegerInterface op1, op2;		// operand 1 and 2
+				
+				if(resultStack.isEmpty())
+				{
+					return null;				// if the stack is empty, invalid expression
+				}
+				else
+				{
+					op2 = resultStack.pop();	// Pop the second operand
+				}
+				
+				if(resultStack.isEmpty())
+				{
+					return null;				// if the stack is empty, invalid expression
+				}
+				else
+				{
+					op1 = resultStack.pop();	// Pop the first operand
+				}
+				
+				/* Calculating result of "op1 operator op2"
+				 * and push the result back onto the stack.
+				 */
+				if(temp.equals("+"))
+				{
+					resultStack.push(op1.plus(op2));
+				}
+				else if(temp.equals("-"))
+				{
+					resultStack.push(op1.minus(op2));
+				}
+				else
+				{
+					resultStack.push(op1.multiply(op2));
+				}
+			}
+			else
+			{
+				// Encounter a number, push the number onto the stack.
+				
+				resultStack.push(new LInfiniteInteger(temp));
+			}
+		}
+		
+		/* The expression is valid if the stack contain exactly
+		 * one item. That one single item is the result of evaluating
+		 * the arithmetic expression.
+		 */
+		
+		InfiniteIntegerInterface result = null;
+		
+		if(resultStack.isEmpty())
+		{
+			return null;				// The stack is empty, invalid expression
+		}
+		else
+		{
+			result = resultStack.pop();	// Pop the result out of the stack
+			
+			if(!resultStack.isEmpty())
+			{
+				result = null;			// The stack is NOT empty, invalid expression
+			}
+		}
+		
+		return result;
+	}
+	
+	/**
+	 * isOperator: Return true if the character c is an
+	 * operator, +, -, or *. Otherwise, return false.
+	 * @param c the character to be tested whether it is
+	 * an operator.
+	 * @return true if c is an operator. Otherwise, return false.
+	 */
+	private boolean isOperator(char c)
+	{
+		return c == '+' || c == '-' || c == '*';
+	}
+}