1 / 15

Mutual Recursion

Mutual Recursion. A set of methods calls each other cooperatively and repeatedly Expression is a term, or sum or difference of terms Term is a factor, or a product or quotient of factors Factor is a number, or an expression enclosed in parenthesis. Using Mutual Recursion.

colleen
Download Presentation

Mutual Recursion

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Mutual Recursion • A set of methods calls each other cooperatively and repeatedly • Expression is a term, or sum or difference of terms • Term is a factor, or a product or quotient of factors • Factor is a number, or an expression enclosed in parenthesis

  2. Using Mutual Recursion • Problem: to compute the value of arithmetic expressions such as 3 + 4 * 5 (3 + 4) * 5 1 - (2 - (3 - (4 - 5)))

  3. Syntax Diagram for Evaluating and Expression

  4. Syntax Tree for Two Expressions

  5. Evaluator • ExpressionTokenizer: breaks input string into tokens (numbers, operators, parenthesis) • nextToken returns string • peekToken: look at next token without consuming it • (3 * 4) + 6: See “+” without consuming it.

  6. Mutually Recursive Methods • Implement 3 methods that call each other recursively • getExpressionValue: calls getTermValue, is next token + or -, if so call get TermValue again and adds or subtracts • getTermValue: calls getFactorValue • getFactorValue: number or getExpressionValue

  7. File Evaluator.java 01: /** 02: A class that can compute the value of an arithmetic expression. 03: */ 04: public class Evaluator 05: { 06: /** 07: Constructs an evaluator. 08: @param anExpression a string containing the expression 09: to be evaluated. 10: */ 11: public Evaluator(String anExpression) 12: { 13: tokenizer = new ExpressionTokenizer(anExpression); 14: } 15: 16: /** 17: Evaluates the expression.

  8. 18: @return the value of the expression. 19: */ 20: public int getExpressionValue() 21: { 22: int value = getTermValue(); 23: boolean done = false; 24: while (!done) 25: { 26: String next = tokenizer.peekToken(); 27: if ("+".equals(next) || "-".equals(next)) 28: { 29: tokenizer.nextToken(); 30: int value2 = getTermValue(); 31: if ("+".equals(next)) value = value + value2; 32: else value = value - value2; 33: } 34: else done = true; 35: } 36: return value; 37: }

  9. 38: 39: /** 40: Evaluates the next term found in the expression. 41: @return the value of the term. 42: */ 43: public int getTermValue() 44: { 45: int value = getFactorValue(); 46: boolean done = false; 47: while (!done) 48: { 49: String next = tokenizer.peekToken(); 50: if ("*".equals(next) || "/".equals(next)) 51: { 52: tokenizer.nextToken(); 53: int value2 = getFactorValue(); 54: if ("*".equals(next)) value = value * value2; 55: else value = value / value2; 56: } 57: else done = true;

  10. 58: } 59: return value; 60: } 61: 62: /** 63: Evaluates the next factor found in the expression. 64: @return the value of the factor. 65: */ 66: public int getFactorValue() 67: { 68: int value; 69: String next = tokenizer.peekToken(); 70: if ("(".equals(next)) 71: { 72: tokenizer.nextToken(); 73: value = getExpressionValue(); 74: next = tokenizer.nextToken(); // read ")" 75: } 76: else 77: value = Integer.parseInt(tokenizer.nextToken());

  11. 78: return value; 79: } 80: 81: private ExpressionTokenizer tokenizer; 82: }

  12. File ExpressionTokenizer.java 01: /** 02: This class breaks up a string describing an expression 03: into tokens: numbers, parentheses, and operators 04: */ 05: public class ExpressionTokenizer 06: { 07: /** 08: Constructs a tokenizer. 09: @param anInput the string to tokenize 10: */ 11: public ExpressionTokenizer(String anInput) 12: { 13: input = anInput; 14: start = 0; 15: end = 0; 16: nextToken(); 17: }

  13. 18: 19: /** 20: Peeks at the next token without consuming it. 21: @return the next token or null if there are no more tokens 22: */ 23: public String peekToken() 24: { 25: if (start >= input.length()) return null; 26: else return input.substring(start, end); 27: } 28: 29: /** 30: Gets the next token and moves the tokenizer to the 31: following token. 32: @return the next token or null if there are no more tokens 33: */ 34: public String nextToken() 35: { 36: String r = peekToken(); 37: start = end;

  14. 38: if (start >= input.length()) return r; 39: if (Character.isDigit(input.charAt(start))) 40: { 41: end = start + 1; 42: while (end < input.length() && Character.isDigit(input.charAt(end))) 43: end++; 44: } 45: else 46: end = start + 1; 47: return r; 48: } 49: 50: private String input; 51: private int start; 52: private int end; 53: }

  15. File EvaluatorTest.java 01: import javax.swing.JOptionPane; 02: 03: /** 04: This program tests the expression evaluator. 05: */ 06: public class EvaluatorTest 07: { 08: public static void main(String[] args) 09: { 10: String input = JOptionPane.showInputDialog("Enter an expression:"); 11: Evaluator e = new Evaluator(input); 12: int value = e.getExpressionValue(); 13: System.out.println(input + "=" + value); 14: System.exit(0); 15: } 16: }

More Related