----------Evaluator-java---------------- package evaluator- import j.docx

**********Evaluator.java****************
package evaluator;
import java.util.*;
import operand.Operand;
import operator.Operator;
public class Evaluator {
private Stack<Operand> operandStack;
private Stack<Operator> operatorStack;
private StringTokenizer tokenizer;
private static final String DELIMITERS = "+-*^/() ";
public Evaluator() {
operandStack = new Stack<Operand>();
operatorStack = new Stack<Operator>();
}
public int eval(String expression) {
int result = 0;
String token;
Operator hashOpr = Operator.operators.get("#");
oprStack.push(hashOpr);
String delimiters = "+-*/#!";
// The 3rd argument is true to indicate that the delimiters should be used
// as tokens, too. But, we'll need to remember to filter out spaces.
this.tokenizer = new StringTokenizer(expression, DELIMITERS, true);

while (this.tokenizer.hasMoreTokens()) {
// filter out spaces
if (!(token = this.tokenizer.nextToken()).equals(" ")) {
// check if token is an operand
if (Operand.check(token)) {
operandStack.push(new Operand(token));
} else {
if (!Operator.check(token)) {
System.out.println("*****invalid token******");
System.exit(1);
}
// TODO Operator is abstract - this line will need to be fixed:
// ( The Operator class should contain an instance of a HashMap,
// and values will be instances of the Operators. See Operator class
// skeleton for an example. )
Operator newOperator = null; // new Operator( token );
while (operatorStack.peek().priority() >= newOperator.priority()) {
// note that when we eval the expression 1 - 2 we will
// push the 1 then the 2 and then do the subtraction operation
// This means that the first number to be popped is the
// second operand, not the first operand - see the following code
Operator oldOpr = operatorStack.pop();
Operand op2 = operandStack.pop();

Operand op1 = operandStack.pop();
operandStack.push(oldOpr.execute(op1, op2));
}
operatorStack.push(newOperator);
}
}
}
// Control gets here when we've picked up all of the tokens; you must add
// code to complete the evaluation - consider how the code given here
// will evaluate the expression 1+2*3
// When we have no more tokens to scan, the operand stack will contain 1 2
// and the operator stack will have + * with 2 and * on the top;
// In order to complete the evaluation we must empty the stacks (except
// the init operator on the operator stack); that is, we should keep
// evaluating the operator stack until empty
// Suggestion: create a method that takes an operator as argument and
// then executes the while loop; also, move the stacks out of the main
// method
return 0;
}
/**
* Class to help test your Evaluator:
* javac EvaluatorTester

* java EvaluatorTester "1+2" "3*5"
*/
public static void main(String[] args) {
Evaluator evaluator = new Evaluator();
for (String arg : args) {
System.out.format("%s = %dn", arg, evaluator.eval(arg));
}
}
}
************************************Operand.Java*******************************
*******************
package operand;
public class Operand {
public Operand( String token ) {
}
public Operand( int value ) {
}
public int getValue() {
return 0;
}
public static boolean check( String token ) {
return false;
}
}

*******************************************************EvaluatorTest.java*******
****************************************
package tests;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
import evaluator.Evaluator;
public class EvaluatorTest {
@Test
void testSimpleAddition() {
assertEquals(3, evaluator.eval("1 +2"));
}
@Test
void testSimpleDivision() {
assertEquals(0, evaluator.eval("1/2"));
}
@Test
void testSimpleExpression() {
assertEquals(7, evaluator.eval("1+2*3"));
}
@Test
void testSimpleParenthesizedExpression() {

assertEquals(9, evaluator.eval("(1+2)*3"));
}
@Test
void testComplexExpressionWithNegativeResult() {
assertEquals(7, evaluator.eval("2-(3/10)+2-5"));
}
@Test
void testAnotherComplexExpressionWithNegativeResult() {
assertEquals(-6, evaluator.eval("(6-12*2)/3"));
}
@Test
void testSimpleExponentiation() {
assertEquals(9, evaluator.eval("3^2"));
}
@Test
void testSlightlyMoreComplexExponentiation() {
assertEquals(4, evaluator.eval("3^2/2"));
}

@Test
void testHardMode() {
assertEquals(1176, evaluator.eval("2+3-5*((2-3)*2-5*2+3*(2-3-5-5*6)+4/2)*2-9"));
}
@Test
void testProperStackUsage() {
// Stacks should be emptied and in a valid state after the first evaluation occurs,
// so the second evaluation should run without exception and provide
assertEquals(6, evaluator.eval("1+2+3"));
assertEquals(1, evaluator.eval("10-8-1"));
}
}
******************************************************OperandTest.java*********
**********************************************************
package tests;
import static org.junit.Assert.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import java.util.Arrays;
import operand.Operand;

public class OperandTest {
@Test
void testCheck() {
ArrayList<String> validOperands =
new ArrayList<>(Arrays.asList( "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" ));
validOperands.forEach(operand -> assertTrue(Operand.check(operand)));
assertFalse(Operand.check("a"));
}
@Test
void testGetValueFromOriginalString() {
Operand operandOne = new Operand("3");
assertEquals(3, operandOne.getValue());
}
@Test
void testGetValueFromOriginalInt() {
Operand operandTwo = new Operand(7);
assertEquals(7, operandTwo.getValue());
}
}
*******************************************************OperatorTest.java********
*********************************************
package tests;
import static org.junit.Assert.assertTrue;

import static org.junit.jupiter.api.Assertions.assertFalse;
import java.util.ArrayList;
import java.util.Arrays;
import operator.Operator;
public class OperatorTest {
@Test
void testCheck() {
ArrayList<String> validOperators =
new ArrayList<>(Arrays.asList( "+", "-", "*", "/", "^" ));
validOperators.forEach(operator -> assertTrue(Operator.check(operator)));
assertFalse(Operator.check("1"));
}
}
******************************************************************************
****************
This is the readme
[![Open in Visual Studio Code](https://classroom.github.com/assets/open-in-vscode-
c66648af7eb3fe8bc4f294546bfd86ef473780cde1dea487d3c4ff354943c9ae.svg)](https://classroo
m.github.com/online_ide?assignment_repo_id=10049933&assignment_repo_type=AssignmentR
epo)
# Assignment 1 Documentation
Author: Eduardo Ruiz (please keep the Author: heading for my grading script)
## Overview of code skeleton
The folders `.devcontainer`, `.vscode`, and `lib` contain configuration information that must not
be deleted or modified. The remaining folders will be discussed in class.
## Scope of Work

| Requirement | Completed? | Comments from student |
| ------------------------- | ---------- | --------------------- |
| 1 - Implement algorithm | [] | |
| 2 - Tests | [] | |
| 3 - Class implementations | [] | |
## Class diagrams
REPLACE THIS TEXT: Include a diagram of all of the classes you worked with in this
assignment, indicating their relationships. For each class, include a one line description of its
responsibility. If you are looking for a tool to use to create the class diagram, check out
[Mermaid](https://mermaid.js.org/syntax/classDiagram.html) - this allows you to write
markdown in this file that will be rendered as class diagrams.
## Results and Conclusions
### What I Learned
REPLACE THIS TEXT: Describe what you learned by completing this assignment
### Challenged I Encountered
REPLACE THIS TEXT: Describe challenges you encountered completing this assignment, and
how you overcame those challenges
********************************************************
********************************************************
Please help, thank you
Computer Science Department San Francisco State University CSC 413 Assignment 1 -
Expression Evaluator Due Date: Sunday, February 19, at midnight. Note that the due date applies
to the last commit timestamp into the main branch of your repository. Note that no late
assignments will be accepted. Overview The purpose of this assignment is to practice object
oriented design to create an object that evaluates mathematical expressions. You are provided
with a project skeleton, which will be automatically cloned into your github repository when you
begin the assignment via this link: https:/I classroom.github.com/a/xpMT29ot. Submission Your
assignment will be submitted using github. Only the main branch of your repository will be
graded. Late submission is determined by the last commit time on the main branch. You are
required to answer the questions in the README . ad file in your repository. Your program will
be tested with a script, which will use some of the following commands. You are encouraged to

run these commands at a command prompt to ensure your project compiles without error! 1. git
clone your-repository-name 2. cd your-repository-name 3. find . -name "* .class" -type f -delete
4. find. -name "*.jar" -type f -delete 5. rm -rf tests 6. copy testing dependencies, current tests,
and some additional tests added to further exercise your code, then execute tests from the
command line The grading rubric is available in Canvas. Requirements You will be provided
with a code skeleton for the Evaluator class (Evaluator. java). You should program the utility
classes it uses - Operand and operator - and then follow the algorithm described below to
complete the implementation of the Evaluator class. The Evaluator implements a single public
method, eval, that takes a single string parameter that represents an infix mathematical
expression, parses and evaluates the expression, and returns the integer result. An example
expression is " 2 + 3 * 4 ", which would be evaluated to 14. The expressions are composed of
integer operands and operators drawn from the set + , , , / , , ( , and ). These operators have the
following precedence: The algorithm that is partially implemented in eval processes the tokens in
the expression string using two stacks; one for operators and one for operands (algorithm
reproduced here from http://csis.pace.edu/ murthy/ProgrammingProblems/ 16 Evaluation of infix
expressions): - If an operand token is scanned, an operand object is created from the token, and
pushed to the operand Stack - If an operator token is scanned, and the operator Stack is empty,
then an operator object is created from the token, and pushed to the operator Stack - If an
operator token is scanned, and the operator stack is not empty, and the operator's precedence is
greater than the precedence of the Operator at the top of the St a c k , then an operator object is
created from the token, and pushed to the operator stack - If the token is (, an operator object is
created from the token, and pushed to the operator Stack - If the token is ), then process
Operators until the corresponding ( is encountered. Pop the (Operator. - If none of the above
cases apply, process an Operator. The operand class allows for the generalization of operands in
our calculations. Note that two constructors are required: the constructor with the string
parameter will be used to create new operands as we retrieve tokens from the string expression,
and the constructor with the int parameter will be used to create new operands in the execute
method of operator subclasses. You must also consider how to maintain the state of the operand -
how should the token or vaiue be stored in the operand instance? Do we need both a string and
int. field in the class? In addition to the constructors, the following methods must be
implemented: - boolean check ( String token ) This method should return true if the token passed
as a parameter is a valid operand token - inl gelvalue() This method returns the integer value of
this operand

----------Evaluator-java---------------- package evaluator- import j.docx

More Related Content

Similar to ----------Evaluator-java---------------- package evaluator- import j.docx (20)

More from janettjz6sfehrle (20)

Recently uploaded (20)

----------Evaluator-java---------------- package evaluator- import j.docx