/* param: stack the stack being manipulated pre: the stack contains at least one element post: the top two elements are popped and their sum is pushed back onto the stack. */ void absolute(struct DynArr *stack) { assert(stack != 0); TYPE firstNum = topDynArr(stack); popDynArr(stack); TYPE sum = (abs(firstNum)); pushDynArr(stack, sum); }
/* param: stack the stack being manipulated pre: the stack contains at least one element post: the top two elements are popped and their sum is pushed back onto the stack. */ void exponential(struct DynArr *stack) { assert(stack != 0); TYPE firstNum = topDynArr(stack); popDynArr(stack); TYPE sum = exp(firstNum); pushDynArr(stack, sum); }
/* param: stack the stack being manipulated pre: the stack contains at least one element post: the top two elements are popped and their sum is pushed back onto the stack. */ void squareRoot(struct DynArr *stack) { assert(stack != 0); TYPE firstNum = topDynArr(stack); popDynArr(stack); TYPE sum = sqrt(firstNum); pushDynArr(stack, sum); }
/* param: stack the stack being manipulated pre: the stack contains at least one element post: the top two elements are popped and their sum is pushed back onto the stack. */ void naturalLog(struct DynArr *stack) { assert(stack != 0); TYPE firstNum = topDynArr(stack); popDynArr(stack); TYPE sum = log(firstNum); pushDynArr(stack, sum); }
/* Checks whether the parentheses are balanced or not param: s pointer to a string pre: s is not null post: */ int isBalanced(char* s) { struct DynArr *array = newDynArr(10); char c; while((c = nextChar(s)) != '0'){ switch(c){ case '{' : case '[' : case '(' : pushDynArr(array, c); break; case '}' : if(topDynArr(array) == '{'){ popDynArr(array); break; } return 0; case ']' : if(topDynArr(array) == '['){ popDynArr(array); break; } return 0; case ')' : if(topDynArr(array) == '('){ popDynArr(array); break; } return 0; } } if(array->size != 0){ return 0; } deleteDynArr(array); return 1; }
void squareRoot(struct DynArr *stack) { if (sizeDynArr(stack) >= 1) { TYPE result = sqrt(topDynArr(stack)); popDynArr(stack); pushDynArr(stack, result); flag = 1; } else flag = 0; }
void baseLog(struct DynArr *stack) { if (sizeDynArr(stack) >= 1) { TYPE result = log10(topDynArr(stack)); popDynArr(stack); pushDynArr(stack, result); flag = 1; } else flag = 0; }
void exponential(struct DynArr *stack) { if (sizeDynArr(stack) >= 1) { TYPE result = exp(topDynArr(stack)); popDynArr(stack); pushDynArr(stack, result); flag = 1; } else flag = 0; }
void cubing(struct DynArr *stack) { if (sizeDynArr(stack) >= 1) { TYPE result = pow(topDynArr(stack), 3); popDynArr(stack); pushDynArr(stack, result); flag = 1; } else flag = 0; }
/* param: stack the stack being manipulated pre: the stack contains at least one element post: the top two elements are popped and their sum is pushed back onto the stack. */ void cube(struct DynArr *stack) { assert(stack != 0); TYPE firstNum = topDynArr(stack); popDynArr(stack); TYPE secondNum = 3; TYPE sum = pow(firstNum, secondNum); pushDynArr(stack, sum); }
/* Checks whether the (), {}, and [] are balanced or not param: s pointer to a string pre: s is not null post: */ int isBalanced(char* s) { char c = ' '; int ret_val = 0; struct DynArr* stack = newDynArr(10); assert(stack != 0); assert(s != 0); while (c != '\0'){ ret_val = 1; c = nextChar(s); if (c == '(' || c == '[' || c == '{') pushDynArr(stack,c); if (c == ')' || c == ']' || c == '}') { if (c == ')' && topDynArr(stack) == '(') popDynArr(stack); else if (c == ']' && topDynArr(stack) == '[') popDynArr(stack); else if (c == '}' && topDynArr(stack) == '{') popDynArr(stack); else return 0; } } if (ret_val) ret_val = !(isEmptyDynArr(stack)); printf("return value %d\n", ret_val); deleteDynArr(stack); return ret_val; }
/* Checks whether the (), {}, and [] are balanced or not param: s pointer to a string pre: s is not null post: */ int isBalanced(char* s) { /* FIXME: You will write this function */ /* Check if s is null */ assert(s); /* Create stack to hold letters */ DynArr* stack = newDynArr(16); char c = nextChar(s); while(c) { if(c == '(' || c == '{' || c == '[') pushDynArr(stack, c); else if(c == ')' || c == '}' || c == ']') { int balanced = 0; if(!isEmptyDynArr(stack)) { char top = topDynArr(stack); if(top == '(' && c == ')') balanced = 1; else if(top == '{' && c == '}') balanced = 1; else if(top == '[' && c == ']') balanced = 1; } if(balanced) popDynArr(stack); else return 0; } c = nextChar(s); } return isEmptyDynArr(stack); }
/* param: stack the stack being manipulated pre: the stack contains at least 1 element post: the top element is popped, log10'd, and is pushed back onto the stack. */ void logTen(struct DynArr *stack) { //declare necessary doubles for operator use on stack double operand_1, logTen_result; //make sure the stack is not empty assert(!isEmptyDynArr(stack)); //store and pop first number off operand_1 = topDynArr(stack); popDynArr(stack); //store in result logTen_result = log10(operand_1); //push back onto stack pushDynArr(stack, logTen_result); }
/* param: stack the stack being manipulated pre: the stack contains at least 1 element post: the top element is popped, 'absolute valued', and is pushed back onto the stack. */ void absoluteValue(struct DynArr *stack) { //declare necessary doubles for operator use on stack double operand_1, abs_result; //make sure the stack is not empty assert(!isEmptyDynArr(stack)); //store and pop first number off operand_1 = topDynArr(stack); popDynArr(stack); //store in result abs_result = abs(operand_1); //push back onto stack pushDynArr(stack, abs_result); }
/* param: stack the stack being manipulated pre: the stack contains at least two elements post: the top two elements are popped and their quotient is pushed back onto the stack. */ void exponential(struct DynArr *stack){ assert(sizeDynArr(stack) >= 1); double num1 = topDynArr(stack); popDynArr(stack); pushDynArr(stack, exp(num1)); }
int main(int argc, char* argv[]){ DynArr *dyn; dyn = createDynArr(2); double a,b,c,d,e,f,g,h; a = 3; b = 4; c = 10; d = 6; e = 5; f = 20; printf("\n\nTesting addDynArr...\n"); addDynArr(dyn, a); addDynArr(dyn, b); addDynArr(dyn, c); addDynArr(dyn, d); addDynArr(dyn, e); printf("The array's content: [3,4,10,6,5]\n"); assertTrue(EQ(getDynArr(dyn, 0), a), "Test 1st element == 3"); assertTrue(EQ(getDynArr(dyn, 1), b), "Test 2nd element == 4"); assertTrue(EQ(getDynArr(dyn, 2), c), "Test 3rd element == 10"); assertTrue(EQ(getDynArr(dyn, 3), d), "Test 4th element == 5"); assertTrue(EQ(getDynArr(dyn, 4), e), "Test 5th element == 6"); assertTrue(sizeDynArr(dyn) == 5, "Test size = 5"); printf("\n\nTesting add...\nCalling addDynArr(dyn)\n"); add(dyn); printf("The array's content: [3,4,7,6,5]\n"); assertTrue(EQ(getDynArr(dyn, 3), (double)11), "Test 3rd element == 11"); assertTrue(sizeDynArr(dyn) == 4, "Test size = 4"); //removing result of add test and restoring array removeDynArr(dyn, 3); addDynArr(dyn, d); addDynArr(dyn, e); printf("\n\nTesting sub..."); subtract(dyn); printf("The array's content: [3,4,7,6,5]\n"); assertTrue(EQ(getDynArr(dyn, 3), (double)1), "Test 3rd element == 1"); assertTrue(sizeDynArr(dyn) == 4, "Test size = 4"); //printf("%d \n", sizeDynArr(dyn)); printf("Top: %f \n", topDynArr(dyn)); //removing result of add test and restoring array popDynArr(dyn); printf("Top: %f \n", topDynArr(dyn)); pushDynArr(dyn, f); pushDynArr(dyn, e); printf("Top: %f \n", topDynArr(dyn)); printf("\n\nTesting divide..."); divide(dyn); //printf("The array's content: [3,4,10,20,5]\n"); //assertTrue(EQ(getDynArr(dyn, 3),(double)4), "Test 3rd element == 4"); //assertTrue(sizeDynArr(dyn) == 4, "Test size = 4"); /* printf("At 4: %f \n", topDynArr(dyn)); removeDynArr(dyn,4); printf("At 3: %f \n", topDynArr(dyn)); removeDynArr(dyn,3); printf("At 2: %f \n", topDynArr(dyn)); removeDynArr(dyn,2); printf("At 1: %f \n", topDynArr(dyn)); printf("%d \n",sizeDynArr(dyn)); */ //removing result of add test and restoring array printf("\nTop: %f \n", topDynArr(dyn)); popDynArr(dyn); printf("Top: %f \n", topDynArr(dyn)); pushDynArr(dyn, f); pushDynArr(dyn, e); printf("Top: %f \n", topDynArr(dyn)); printf("\n\nTesting multiply...\nCalling addDynArr(dyn)\n"); multiply(dyn); //printf("The array's content: [3,4,10,6,5]\n"); //assertTrue(EQ(getDynArr(dyn, 3),(float)30), "Test 3rd element == 30"); //assertTrue(sizeDynArr(dyn) == (float)4, "Test size = 4"); printf("Before pop Top: %f \n", topDynArr(dyn)); //removing result of add test and restoring array popDynArr(dyn); printf("After pop Top: %f \n", topDynArr(dyn)); pushDynArr(dyn,(double) 2); pushDynArr(dyn,(double) 1); printf("After 2 push Top: %f \n", topDynArr(dyn)); printf("\n\nTesting power of...n"); powerOf(dyn); //printf("The array's content: [3,4,10,6,5]\n"); //assertTrue(EQ(getDynArr(dyn, 3),(float)2), "Test 3rd element == 2"); //assertTrue(sizeDynArr(dyn) == (float)4, "Test size = 4"); }
/* param: integer size of input and char pre: argc is not equal to 1 post: the final number is calculated without errors. */ double calculate(int numInputTokens, char **inputString) { int i; double result = 0.0; char *s; struct DynArr *stack; //set up the stack stack = createDynArr(20); // start at 1 to skip the name of the calculator calc for(i=1;i < numInputTokens;i++) { s = inputString[i]; if (strcmp(s, "+") == 0) // add { if (sizeDynArr(stack) >= 2) // make sure stack has two numbers to add together { add(stack); } else { printf("Not enough numbers. %s is causing an error. Exiting.\n", s); exit(0); } } else if (strcmp(s, "-") == 0) // subtract { if (sizeDynArr(stack) >= 2) // make sure stack has two numbers to subtract together { subtract(stack); } else { printf("Not enough numbers. %s is causing an error. Exiting.\n", s); exit(0); } } else if (strcmp(s, "/") == 0) // divide { if (sizeDynArr(stack) >= 2) // make sure stack has two numbers to divide together { divide(stack); } else { printf("Not enough numbers. %s is causing an error. Exiting.\n", s); exit(0); } } else if (strcmp(s, "x") == 0) // multiply { if (sizeDynArr(stack) >= 2) // make sure stack has two numbers to multiply together { multiply(stack); } else { printf("Not enough numbers. %s is causing an error. Exiting.\n", s); exit(0); } } else if (strcmp(s, "^") == 0) // calculate power { if (sizeDynArr(stack) >= 2) // make sure stack has two numbers to use for power { power(stack); } else { printf("Not enough numbers. %s is causing an error. Exiting.\n", s); exit(0); } } else if (strcmp(s, "^2") == 0) // calculate square { square(stack); } else if (strcmp(s, "^3") == 0) // calculate cube { cube(stack); } else if (strcmp(s, "abs") == 0) // calculate absolute { absolute(stack); } else if (strcmp(s, "sqrt") == 0) // calculate square root { squareRoot(stack); } else if (strcmp(s, "exp") == 0) // calculate exponetial { exponential(stack); } else if (strcmp(s, "ln") == 0) // calculate natural log { naturalLog(stack); } else if (strcmp(s, "log") == 0) // get log { baseTenLog(stack); } else { if (strcmp(s, "pi") == 0) // convert pi to a number { s = "3.14159265"; } else if (strcmp(s, "e") == 0) // convert e to a number { s = "2.7182818"; } if (isNumber(s, &result) != 0) // if a number see if you can push on stack { pushDynArr(stack, result); } else // exit if not a number { printf("Error. Following input causing an error: %s \n", s); exit (0); } } } assert(!isEmptyDynArr(stack)); // check to make sure stack isn't empty if (sizeDynArr(stack) > 1) { printf("Not enough operators. Too many numbers. "); for (int i = 1; i < numInputTokens; i++) { printf("%s ", inputString[i]); } printf(" \n"); exit(0); } result = topDynArr(stack); // get final number and make it it result return result; }
double calculate(int numInputTokens, char **inputString) { int i, limit=0; double result = 0.0; char *s; struct DynArr *stack; //set up the stack stack = createDynArr(20); printf("testing info! numInputTOkesn: %d\n", numInputTokens); // start at 1 to skip the name of the calculator calc for(i=1;i < numInputTokens;i++) { s = inputString[i]; // Hint: General algorithm: // (1) Check if the string s is in the list of operators. // (1a) If it is, perform corresponding operations. // (1b) Otherwise, check if s is a number. // (1b - I) If s is not a number, produce an error. // (1b - II) If s is a number, push it onto the stack if(strcmp(s, "+") == 0){ add(stack); limit = 0; } else if(strcmp(s,"-") == 0){ subtract(stack); limit = 0; } else if(strcmp(s, "/") == 0){ divide(stack); limit = 0; } else if(strcmp(s, "x") == 0){ multiply(stack); limit = 0; } else if(strcmp(s, "^") == 0){ power(stack); limit = 0; } else if(strcmp(s, "^2") == 0){ square(stack); limit = 0; } else if(strcmp(s, "^3") == 0 ){ cube(stack); limit = 0; } else if(strcmp(s, "abs") == 0){ abso(stack); limit = 0; } else if(strcmp(s, "sqrt") == 0){ sqf(stack); limit = 0; } else if(strcmp(s, "exp") == 0){ expo(stack); limit = 0; } else if(strcmp(s, "ln") == 0){ logg(stack); limit = 0; } else if(strcmp(s, "log") == 0){ logg10(stack); limit = 0; } else { if(limit >=2){ printf("\nLimit has been reached! You did something wrong!\n"); break; } //printf("%c is not an operator! converting to a a number!\n",*s); int isNum; double num = 0; isNum = isNumber(s, &num); if(isNum == 1){ //Is infact a number, push to stack pushDynArr(stack, num); limit++; //printf("value %f is now pushed to the statck\n", num); printf("\n%f", num); }else{ if(strcmp(s, "pi") == 0){ pushDynArr(stack, 3.144159265); printf("\n3.144159265"); limit++; }else if(strcmp(s, "e") == 0){ pushDynArr(stack, 2.7182818); limit++; printf("\n2.7182818"); }else{ //ignore because it is not a number printf("\nPosition %d is not a number, ignoring...\n", i+1); } } //limit is more than 2, this should not happen! // Remember to deal with special values ("pi" and "e") } } //end for /* FIXME: You will write this part of the function (2 steps below) * (1) Check if everything looks OK and produce an error if needed. * (2) Store the final value in result and print it out. */ if( stack->size > 1){ //something went wrong printf("\nError computing value, check your entry!\n"); }else{ result = topDynArr(stack); } return result; }
/* Checks whether the (), {}, and [] are balanced or not param: s pointer to a string pre: s is not null post: Returns 1 or 0 and displays corresponding response in main */ int isBalanced(char* s) { /* FIXME: You will write this function */ if (s == 0) return 0; char ch; struct DynArr *balArray = newDynArr(10); while((ch = nextChar(s)) != '\0') { //printf("%c\n",ch); //test statement //Push when ch = [,{,( if(ch == '[' || ch == '(' || ch == '{') pushDynArr(balArray, ch); //Pop when ],},) and when array is not empty if(ch == ']' || ch == ')' || ch == '}') { if (isEmptyDynArr(balArray)) return 0; //Check the individual situations and pop if matching if (ch == ']') { if (topDynArr(balArray) == '[') { popDynArr(balArray); } else return 0; } else if (ch == '}') { if (topDynArr(balArray) == '{') { popDynArr(balArray); } else return 0; } else if (ch == ')') { if (topDynArr(balArray) == '(') { popDynArr(balArray); } else return 0; } } //printf("%d", sizeDynArr(balArray));// test statement //printf("Top of Stack: %c\n", topDynArr(balArray));// test statement } if (!isEmptyDynArr(balArray)) { return 0; } else { deleteDynArr(balArray); return 1; } }
/* param: stack the stack being manipulated pre: the stack contains at least two elements post: the top two elements are popped and their quotient is pushed back onto the stack. */ void cubed(struct DynArr *stack){ assert(sizeDynArr(stack) >= 1); double num1 = topDynArr(stack); popDynArr(stack); pushDynArr(stack, pow(num1,3)); }
/* param: stack the stack being manipulated pre: the stack contains at least two elements post: the top two elements are popped and their quotient is pushed back onto the stack. */ void absoluteValue(struct DynArr *stack){ assert(sizeDynArr(stack) >= 1); double num1 = topDynArr(stack); popDynArr(stack); pushDynArr(stack, fabs(num1)); }
/* Checks whether the (), {}, and [] are balanced or not param: s pointer to a string pre: s is not null post: */ int isBalanced(char* s) { assert(s != NULL); int returnValue = 0; char testChar; struct DynArr *stringBalance = newDynArr((sizeof(s)/sizeof('a'))+1); do{ testChar = nextChar(s); if(testChar == '(' || testChar == '{' ||testChar == '[' ){ pushDynArr(stringBalance, testChar); returnValue = 0; }else if(testChar == ')' || testChar == '}' ||testChar == ']' ){ if(isEmptyDynArr(stringBalance)){ //if the first match is a close then the string is imbalanced returnValue = 0; break; } char top = topDynArr(stringBalance); switch(testChar){ case ')': if( top == '('){ popDynArr(stringBalance); returnValue = 1; }else { returnValue = 0; testChar = '\0'; } break; case '}': if( top == '{'){ popDynArr(stringBalance); returnValue = 1; }else { returnValue = 0; testChar = '\0'; } break; case ']': if( top == '['){ popDynArr(stringBalance); returnValue = 1; }else { returnValue = 0; testChar = '\0'; } break; } }else if(testChar == '\0'){ if(!isEmptyDynArr(stringBalance)){//if at the end of the string it is not empty then it is false returnValue = 0; } } }while(testChar != '\0'); return returnValue; }
/* param: stack the stack being manipulated pre: the stack contains at least two elements post: the top two elements are popped and their quotient is pushed back onto the stack. */ void squareRoot(struct DynArr *stack){ assert(sizeDynArr(stack) >= 1); double num1 = topDynArr(stack); popDynArr(stack); pushDynArr(stack, sqrt(num1)); }
/* Checks whether the (), {}, and [] are balanced or not param: s pointer to a string pre: s is not null post: */ int isBalanced(char* s) { int curlyCount = 0; int squareCount = 0; int perenCount = 0; int i; /* FIXME: You will write this function */ /*for(j = 0; s[j]; j++){ size++; }*/ DynArr stack = *newDynArr(strlen(s)+1); stack.size = strlen(s); for(i=0; i < strlen(s); i++){ stack.size--; } for(i=0; i < strlen(s); i++){ pushDynArr(&stack, s[i]); switch(topDynArr(&stack)){ case '{': curlyCount++; popDynArr(&stack); break; case '}': curlyCount--; popDynArr(&stack); break; case '[': squareCount++; popDynArr(&stack); break; case ']': squareCount--; popDynArr(&stack); break; case '(': perenCount++; popDynArr(&stack); break; case ')': perenCount--; popDynArr(&stack); break; default: popDynArr(&stack); break; } } if((curlyCount==0)&&(squareCount == 0)&&(perenCount==0)){ return 1; /*It is balanced*/ } return 0; /*Is not balanced*/ }
double calculate(int numInputTokens, char **inputString) { int i; double result = 0.0; char *s; struct DynArr *stack; //for keeping track of # of operands and operators int numOfOperands = 0; int numOfOperators = 0; int check = 0; //set up the stack stack = createDynArr(20); // start at 1 to skip the name of the calculator calc for(i=1;i < numInputTokens;i++) { s = inputString[i]; if(strcmp(s, "+") == 0) { numOfOperators++; //increase for binary operators add(stack); } else if(strcmp(s,"-") == 0) { numOfOperators++; subtract(stack); } else if(strcmp(s, "/") == 0) { numOfOperators++; divide(stack); } else if(strcmp(s, "x") == 0) { numOfOperators++; multiply(stack); } else if(strcmp(s, "^") == 0) { numOfOperators = numOfOperators; //for unary operators don't increase power(stack); } else if(strcmp(s, "^2") == 0) { numOfOperators = numOfOperators; square(stack); } else if(strcmp(s, "^3") == 0) { numOfOperators = numOfOperators; cube(stack); } else if(strcmp(s, "abs") == 0) { numOfOperators = numOfOperators; absoluteValue(stack); } else if(strcmp(s, "sqrt") == 0) { numOfOperators = numOfOperators; squareRoot(stack); } else if(strcmp(s, "exp") == 0) { numOfOperators = numOfOperators; exponential(stack); } else if(strcmp(s, "ln") == 0) { numOfOperators = numOfOperators; naturalLog(stack); } else if(strcmp(s, "log") == 0) { numOfOperators = numOfOperators; logTen(stack); } else { //check if its a number (or pi or e) if(isNumber(s, &result)) { numOfOperands++; //increase count of operands pushDynArr(stack, result); //if it is push onto stack } else { printf("You entered bad characters, exiting!\n"); //else print error message exit(0); } } } //end for //check for correct balance of operands and operators //must be one more operand than operators in sequence check = numOfOperands - numOfOperators; //this must be equal to 1 for valid input if (check > 1) { printf("Illegal Input, too many operands or too few operators, exiting\n"); exit(0); } else if (check < 1) { printf("Illegal Input, too few operands or too many operators, exiting\n"); exit(0); } //if passed check store final result and return result = topDynArr(stack); return result; }
/* param: stack the stack being manipulated pre: the stack contains at least two elements post: the top two elements are popped and their quotient is pushed back onto the stack. */ void naturalLog(struct DynArr *stack){ assert(sizeDynArr(stack) >= 1); double num1 = topDynArr(stack); popDynArr(stack); pushDynArr(stack, log(num1)); }
// this main function contains some int main(int argc, char* argv[]){ DynArr *dyn; dyn = newDynArr(2); int i; printf("\n\nTesting addDynArr...\n"); addDynArr(dyn, 3); addDynArr(dyn, 4); addDynArr(dyn, 10); addDynArr(dyn, 5); addDynArr(dyn, 6); printf("The array's content: [3,4,10,5,6]\n"); assertTrue(EQ(getDynArr(dyn, 0), 3), "Test 1st element == 3"); assertTrue(EQ(getDynArr(dyn, 1), 4), "Test 2nd element == 4"); assertTrue(EQ(getDynArr(dyn, 2), 10), "Test 3rd element == 10"); assertTrue(EQ(getDynArr(dyn, 3), 5), "Test 4th element == 5"); assertTrue(EQ(getDynArr(dyn, 4), 6), "Test 5th element == 6"); assertTrue(sizeDynArr(dyn) == 5, "Test size = 5"); printf("\n\nTesting putDynArr...\nCalling putDynArr(dyn, 2, 7)\n"); putDynArr(dyn, 2, 7); printf("The array's content: [3,4,7,5,6]\n"); assertTrue(EQ(getDynArr(dyn, 2), 7), "Test 3rd element == 7"); assertTrue(sizeDynArr(dyn) == 5, "Test size = 5"); printf("\n\nTesting swapDynArr...\nCalling swapDynArr(dyn, 2, 4)\n"); swapDynArr(dyn, 2, 4); printf("The array's content: [3,4,6,5,7]\n"); assertTrue(EQ(getDynArr(dyn, 2), 6), "Test 3rd element == 6"); assertTrue(EQ(getDynArr(dyn, 4), 7), "Test 5th element == 7"); printf("\n\nTesting removeAtDynArr...\nCalling removeAtDynArr(dyn, 1)\n"); removeAtDynArr(dyn, 1); printf("The array's content: [3,6,5,7]\n"); assertTrue(EQ(getDynArr(dyn, 0), 3), "Test 1st element == 3"); assertTrue(EQ(getDynArr(dyn, 3), 7), "Test 4th element == 7"); assertTrue(sizeDynArr(dyn) == 4, "Test size = 4"); printf("\n\nTesting stack interface...\n"); printf("The stack's content: [3,6,5,7] <- top\n"); assertTrue(!isEmptyDynArr(dyn), "Testing isEmptyDynArr"); assertTrue(EQ(topDynArr(dyn), 7), "Test topDynArr == 7"); popDynArr(dyn); printf("Poping...\nThe stack's content: [3,6,5] <- top\n"); assertTrue(EQ(topDynArr(dyn), 5), "Test topDynArr == 5"); pushDynArr(dyn, 9); printf("Pushing 9...\nThe stack's content: [3,6,5,9] <- top\n"); assertTrue(EQ(topDynArr(dyn), 9), "Test topDynArr == 9"); printf("\n\nTesting bag interface...\n"); printf("The bag's content: [3,6,5,9]\n"); assertTrue(containsDynArr(dyn, 3), "Test containing 3"); assertTrue(containsDynArr(dyn, 6), "Test containing 6"); assertTrue(containsDynArr(dyn, 5), "Test containing 5"); assertTrue(containsDynArr(dyn, 9), "Test containing 9"); assertTrue(!containsDynArr(dyn, 7), "Test not containing 7"); removeDynArr(dyn, 3); printf("Removing 3...\nThe stack's content: [6,5,9]\n"); assertTrue(!containsDynArr(dyn, 3), "Test not containing 3"); return 0; }
/* param: stack the stack being manipulated pre: the stack contains at least two elements post: the top two elements are popped and their quotient is pushed back onto the stack. */ void logBase10(struct DynArr *stack){ assert(sizeDynArr(stack) >= 1); double num1 = topDynArr(stack); popDynArr(stack); pushDynArr(stack, log10(num1)); }
// this main function contains some int main(int argc, char* argv[]){ DynArr *dyn; dyn = createDynArr(2); printf("\n\nTesting addDynArr...\n"); addDynArr(dyn, 3); addDynArr(dyn, 4); addDynArr(dyn, 10); addDynArr(dyn, 5); addDynArr(dyn, 6); printf("The array's content: [3,4,10,5,6]\n"); assertTrue(EQ(getDynArr(dyn, 0), 3), "Test 1st element == 3"); assertTrue(EQ(getDynArr(dyn, 1), 4), "Test 2nd element == 4"); assertTrue(EQ(getDynArr(dyn, 2), 10), "Test 3rd element == 10"); assertTrue(EQ(getDynArr(dyn, 3), 5), "Test 4th element == 5"); assertTrue(EQ(getDynArr(dyn, 4), 6), "Test 5th element == 6"); assertTrue(sizeDynArr(dyn) == 5, "Test size = 5"); printf("\n\nTesting putDynArr...\nCalling putDynArr(dyn, 2, 7)\n"); putDynArr(dyn, 2, 7); printf("The array's content: [3,4,7,5,6]\n"); assertTrue(EQ(getDynArr(dyn, 2), 7), "Test 3rd element == 7"); assertTrue(sizeDynArr(dyn) == 5, "Test size = 5"); printf("\n\nTesting swapDynArr...\nCalling swapDynArr(dyn, 2, 4)\n"); swapDynArr(dyn, 2, 4); printf("The array's content: [3,4,6,5,7]\n"); assertTrue(EQ(getDynArr(dyn, 2), 6), "Test 3rd element == 6"); assertTrue(EQ(getDynArr(dyn, 4), 7), "Test 5th element == 7"); printf("\n\nTesting removeAtDynArr...\nCalling removeAtDynArr(dyn, 1)\n"); removeAtDynArr(dyn, 1); printf("The array's content: [3,6,5,7]\n"); assertTrue(EQ(getDynArr(dyn, 0), 3), "Test 1st element == 3"); assertTrue(EQ(getDynArr(dyn, 3), 7), "Test 4th element == 7"); assertTrue(sizeDynArr(dyn) == 4, "Test size = 4"); printf("\n\nTesting stack interface...\n"); printf("The stack's content: [3,6,5,7] <- top\n"); assertTrue(!isEmptyDynArr(dyn), "Testing isEmptyDynArr"); assertTrue(EQ(topDynArr(dyn), 7), "Test topDynArr == 7"); popDynArr(dyn); printf("Poping...\nThe stack's content: [3,6,5] <- top\n"); assertTrue(EQ(topDynArr(dyn), 5), "Test topDynArr == 5"); pushDynArr(dyn, 9); printf("Pushing 9...\nThe stack's content: [3,6,5,9] <- top\n"); assertTrue(EQ(topDynArr(dyn), 9), "Test topDynArr == 9"); printf("\n\nTesting bag interface...\n"); printf("The bag's content: [3,6,5,9]\n"); assertTrue(containsDynArr(dyn, 3), "Test containing 3"); assertTrue(containsDynArr(dyn, 6), "Test containing 6"); assertTrue(containsDynArr(dyn, 5), "Test containing 5"); assertTrue(containsDynArr(dyn, 9), "Test containing 9"); assertTrue(!containsDynArr(dyn, 7), "Test not containing 7"); removeDynArr(dyn, 3); printf("Removing 3...\nThe stack's content: [6,5,9]\n"); assertTrue(!containsDynArr(dyn, 3), "Test not containing 3"); printf("Executing test functions...\n"); printf("\nTesting addDynArr()\n"); addDynArr_TEST(dyn); //Testing the add functionality under 3 conditions printf("\nTesting popDynArr()\n"); popDynArr_TEST(dyn); //Testing the pop function under 2 conditions printf("\nTesting topDynArr()\n"); topDynArr_TEST(dyn); //Testing the top function under 2 conditions printf("\nTesting pushDynArr()\n"); pushDynArr_TEST(dyn); //Testing the push function under 3 conditions printf("\nTesting containsDynArr()\n"); containsDynArr_TEST(dyn); //Testing the contains function under 2 conditions printf("\nTesting removeDynArr()\n"); removeDynArr_TEST(dyn); //Testing the remove function under 2 conditions return 0; }
double calculate(int numInputTokens, char **inputString){ int i; double result = 0.0; char *s; struct DynArr *stack; double num; //set up the stack stack = createDynArr(20); // start at 1 to skip the name of the calculator calc for(i=1;i < numInputTokens;i++) { s = inputString[i]; // Hint: General algorithm: // (1) Check if the string s is in the list of operators. // (1a) If it is, perform corresponding operations. // (1b) Otherwise, check if s is a number. // (1b - I) If s is not a number, produce an error. // (1b - II) If s is a number, push it onto the stack if(strcmp(s, "+") == 0){ add(stack); printf("Adding\n"); } else if(strcmp(s,"-") == 0){ subtract(stack); printf("Subtracting\n"); } else if(strcmp(s, "/") == 0){ divide(stack); printf("Dividing\n"); } else if(strcmp(s, "x") == 0){ multiply(stack); printf("Multiplying\n"); } else if(strcmp(s,"^") == 0){ power(stack); printf("Power\n"); } else if(strcmp(s, "^2") == 0){ squared(stack); printf("Squaring\n"); } else if(strcmp(s, "^3") == 0){ cubed(stack); printf("Cubing\n"); } else if(strcmp(s, "abs") == 0){ absoluteValue(stack); printf("Absolute value\n"); } else if(strcmp(s, "sqrt") == 0){ squareRoot(stack); printf("Square root\n"); } else if(strcmp(s, "exp") == 0){ exponential(stack); printf("Exponential\n"); } else if(strcmp(s, "ln") == 0){ naturalLog(stack); printf("Natural Log\n"); } else if(strcmp(s, "log") == 0){ logBase10(stack); printf("Log\n"); } else{ // FIXME: You need to develop the code here (when s is not an operator) // Remember to deal with special values ("pi" and "e") //check if not a number if (isNumber(s, &num) == 0){ if (strcmp(s, "pi") == 0){ num = 3.14159265; } else if (strcmp(s, "e") == 0){ num = 2.7182818; } else{ //wrong printf("%s is not valid (number or operator) \n", s); break; } } pushDynArr(stack, num); } } //end for /* FIXME: You will write this part of the function (2 steps below) * (1) Check if everything looks OK and produce an error if needed. * (2) Store the final value in result and print it out. */ if (sizeDynArr(stack) != 1) { printf("Incorrect count of numbers is detected! Calculations CANNOT be preformed. "); return 0; } else { result = topDynArr(stack); } return result; }