----------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
********************************************************
********************************************************
While the operator stack is not empty, pop the operator from the operator stack, create an
operand object from the popped operator, and push it to the operand stack. While the operand
stack has more than one operand, pop two operands from the operand stack and one operator
from the operator stack, and apply the operator to the operands. Push the result back to the
operand stack. The result of the expression is the single operand left on the operand stack. You
are required to implement the missing parts of this algorithm in the eval method of the Evaluator
class.
Please help, thank you

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

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

More Related Content

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

More from Adamq0DJonese (20)

Recently uploaded (20)

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