/* param: stack the stack being manipulated
pre: the stack contains at least two elements
post: the top two elements are popped and
their sum is pushed back onto the stack.
*/
void add (struct DynArr *stack)
{
//declare necessary doubles for operator use on stack
double operand_1, operand_2, add_result;
//make sure the stack is not empty
//assert(!isEmptyDynArr(stack));
//store and pop first number off
operand_1 = topDynArr(stack);
popDynArr(stack);
//make sure stack is not empty
//assert(!isEmptyDynArr(stack));
//store and pop second number off
operand_2 = topDynArr(stack);
popDynArr(stack);
//store in result
add_result = operand_2 + operand_1;
//push back onto stack
pushDynArr(stack, add_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 power(struct DynArr *stack){
assert(sizeDynArr(stack) >= 2);
double num2 = topDynArr(stack);
popDynArr(stack);
double num1 = topDynArr(stack);
popDynArr(stack);
pushDynArr(stack, pow(num1,num2));
}
/* 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 */
DynArr* work;
work = newDynArr(sizeof(s));
char testChar = 0;
do{
testChar = nextChar(s);
if (testChar == '(') {
pushDynArr(work, ')');
}
else if (testChar == ')') {
if (isEmptyDynArr(work)) {
return 0;
}
else if (testChar != topDynArr(work)) {
return 0;
}
else
popDynArr(work);
}
else if (testChar == '[') {
pushDynArr(work, ']');
}
else if (testChar == ']') {
if (isEmptyDynArr(work)) {
return 0;
}
else if (testChar != topDynArr(work)) {
return 0;
}
else
popDynArr(work);
}
else if (testChar == '{') {
pushDynArr(work, '}');
}
else if (testChar == '}') {
if (isEmptyDynArr(work)) {
return 0;
}
else if (testChar != topDynArr(work)) {
return 0;
}
else
popDynArr(work);
}
} while (testChar != '\0');
if (!isEmptyDynArr(work))
return 0;
return 1;
}
void power (struct DynArr *stack)
{
double power;
checkArrSize(stack);
power = pow( stack->data[stack->size-2], stack->data[stack->size-1]);
popDynArr(stack);
popDynArr(stack);
addDynArr(stack, power);
printf(" \n^\n");
}
void multiply (struct DynArr *stack)
{
double multiply;
checkArrSize(stack);
multiply = stack->data[stack->size-2] * stack->data[stack->size-1];
popDynArr(stack);
popDynArr(stack);
addDynArr(stack, multiply);
printf(" \n*\n");
}
/* 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 divide(struct DynArr *stack)
{
double divide;
checkArrSize(stack);
divide = stack->data[stack->size-2] / stack->data[stack->size-1];
popDynArr(stack);
popDynArr(stack);
addDynArr(stack, divide);
printf(" /\n");
}
/* param: stack the stack being manipulated
pre: the stack contains at least two elements
post: the top two elements are popped and
their sum is pushed back onto the stack.
*/
void add(struct DynArr *stack)
{
double sum;
checkArrSize(stack);
sum = stack->data[stack->size-2] + stack->data[stack->size-1];
popDynArr(stack);
popDynArr(stack);
addDynArr(stack, sum);
//printf("size of stack is %d and temp sum is %f and stack value at size is %f\n",stack->size, sum, stack->data[stack->size-1]);
printf(" +\n");
}
/* param: stack the stack being manipulated
pre: the stack contains at least two elements
post: the top two elements are popped and
their difference is pushed back onto the stack.
*/
void subtract(struct DynArr *stack)
{
/* FIXME: You will write this function */
double minus;
minus = stack->data[stack->size-2] - stack->data[stack->size-1];
popDynArr(stack);
popDynArr(stack);
addDynArr(stack, minus);
//printf("size of stack is %d and temp minus is %f and stack value at size is %f\n",stack->size, minus, stack->data[stack->size-1]);
printf(" -\n");
}
/* param: stack is the stack being manipulated
pre: the stack contains at least two elements
post: the top two elements are popped and their difference is pushed back onto the stack.
*/
void subtract(struct DynArr *stack) {
/* FIXME: You will write this function */
TYPE temp;
TYPE temp2;
TYPE temp3;
temp = peekDynArr(stack);
popDynArr(stack);
temp2=peekDynArr(stack);
popDynArr(stack);
temp3=temp2-temp;
pushDynArr(stack, temp3);
}
/* 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 */
struct DynArr *arr = newDynArr(7);
char a;
if (s != 0)
{
while (a = nextChar(s) != '\0')
{
if (&a == "(")
pushDynArr(arr, a);
else if (&a == "{")
pushDynArr(arr, a);
else if (&a == "[")
pushDynArr(arr, a);
else if (&a == ")")
{
if(topDynArr(arr) == '(')
popDynArr(arr);
else
return 0;
}
else if (&a == "}")
{
if(topDynArr(arr) == '{')
popDynArr(arr);
else
return 0;
}
else if (&a == "]")
{
if(topDynArr(arr) == '[')
popDynArr(arr);
else
return 0;
}
}
}
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 sum is pushed back onto the stack.
*/
void power(struct DynArr *stack)
{
assert(stack != 0);
TYPE secondNum = topDynArr(stack);
popDynArr(stack);
TYPE firstNum = topDynArr(stack);
popDynArr(stack);
TYPE sum = pow(firstNum, secondNum);
pushDynArr(stack, sum);
}
/* param: stack the stack being manipulated
pre: the stack contains at least two elements
post: the top two elements are popped and
their difference is pushed back onto the stack.
*/
void subtract(struct DynArr *stack)
{
assert(stack != 0);
TYPE secondNum = topDynArr(stack);
popDynArr(stack);
TYPE firstNum = topDynArr(stack);
popDynArr(stack);
TYPE sum = firstNum - secondNum;
pushDynArr(stack, sum);
}
/* 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 divide(struct DynArr *stack)
{
assert(stack != 0);
TYPE secondNum = topDynArr(stack);
popDynArr(stack);
TYPE firstNum = topDynArr(stack);
popDynArr(stack);
TYPE sum = firstNum / secondNum;
pushDynArr(stack, sum);
}
/* param: stack the stack being manipulated
pre: the stack contains at least two elements
post: the top two elements are popped and
their product is pushed back onto the stack.
*/
void multiply(struct DynArr *stack)
{
assert(stack != 0);
TYPE secondNum = topDynArr(stack);
popDynArr(stack);
TYPE firstNum = topDynArr(stack);
popDynArr(stack);
TYPE sum = firstNum * secondNum;
pushDynArr(stack, sum);
}
/* param: stack the stack being manipulated
pre: the stack contains at least two elements
post: the top two elements are popped and
their difference is pushed back onto the stack.
*/
void subtract(struct DynArr *stack){
if (sizeDynArr(stack) < 2){
printf( "\n ERROR \n");
printf("You need to have at least 2 numbers for subtraction \n");
printf("Please use: number1 number2 - format \n");
printf("number1 - number2 will not work \n");
}
assert(sizeDynArr(stack) >= 2);
double number = topDynArr(stack);
popDynArr(stack);
double subtract = topDynArr(stack) - number;
popDynArr(stack);
pushDynArr(stack, subtract);
}
/* 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 divide(struct DynArr *stack){
if (sizeDynArr(stack) < 2){
printf( "\n ERROR \n");
printf("You need to have at least 2 numbers for division\n");
printf("Please use: number1 number2 / format \n");
printf("number1 / number2 will not work \n");
}
assert(sizeDynArr(stack) >= 2);
double number = topDynArr(stack);
popDynArr(stack);
double divide = topDynArr(stack)/number;
popDynArr(stack);
pushDynArr(stack, divide);
}
/* param: stack the stack being manipulated
pre: the stack contains at least two elements
post: the top two elements are popped and
their sum is pushed back onto the stack.
*/
void add (struct DynArr *stack){
if (sizeDynArr(stack) < 2){
printf( "\n ERROR \n");
printf("You need to have at least 2 numbers for addition \n");
printf("Please use: number1 number2 + format \n");
printf("number1 + number2 will not work \n");
}
assert(sizeDynArr(stack) >= 2);
double first = topDynArr(stack);
popDynArr(stack);
double second = topDynArr(stack);
popDynArr(stack);
pushDynArr(stack, first + second);
}
/* 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 multiply(struct DynArr *stack){
if (sizeDynArr(stack) < 2){
printf( "\n ERROR \n");
printf("You need to have at least 2 numbers for multiplication \n");
printf("Please use: number1 number2 x format \n");
printf("number1 x number2 will not work \n");
}
assert(sizeDynArr(stack) >= 2);
double num2 = topDynArr(stack);
popDynArr(stack);
double num1 = topDynArr(stack);
popDynArr(stack);
pushDynArr(stack, num1 * num2);
}
void power(struct DynArr *stack) {
if (sizeDynArr(stack) >= 2) {
TYPE firstNum = topDynArr(stack);
popDynArr(stack);
TYPE secondNum = topDynArr(stack);
popDynArr(stack);
TYPE result = pow(secondNum, firstNum);
pushDynArr(stack, result);
flag = 1;
}
else
flag = 0;
}
void time(struct DynArr *stack) {
if (sizeDynArr(stack) >= 2) {
TYPE firstNum = topDynArr(stack);
popDynArr(stack);
TYPE secondNum = topDynArr(stack);
popDynArr(stack);
TYPE result = firstNum * secondNum;
pushDynArr(stack, result);
flag = 1;
}
else
flag = 0;
}
/* 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 check;
char cmp;
DynArr *stck;
stck = newDynArr(100);
do
{
check = nextChar(s);
if (check == '(' || check == '{' || check == '[')
{
pushDynArr(stck, check);
}
else if (check == ')' || check == '}' || check == ']')
{
if (isEmptyDynArr(stck))
{
return 0;
}
cmp = topDynArr(stck);
if ((check == ')' && cmp == '(') || (check == '}' && cmp == '{') || (check == ']' && cmp == '['))
{
popDynArr(stck);
}
}
} while (check != '\0');
if (isEmptyDynArr(stck))
{
return 1;
}
else
return 0;
}
/* 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;
DynArr *Parens;
Parens = newDynArr(5); // Arbitrary first length
//printf("DEBUG 40 s = %p\n", s);
while ( (c = nextChar(s)) != '\0' )
{
if (EQ(c, '(')) pushDynArr(Parens, ')');
else if (EQ(c, '{')) pushDynArr(Parens, '}');
else if (EQ(c, '[')) pushDynArr(Parens, ']');
else if (EQ(c, ')') || EQ(c,'}') || EQ(c, ']'))
{
if(isEmptyDynArr(Parens))
return 0; // We already know we're unbalanced
else
if ( EQ(topDynArr(Parens), c)) popDynArr(Parens);
}
}
if (isEmptyDynArr(Parens))
return 1; // True, is balanced
else
return 0; // False, is not balanced
}
void square (struct DynArr *stack)
{
double square;
square = pow(stack->data[stack->size-1], 2);
popDynArr(stack);
addDynArr(stack, square);
printf(" \nsquare\n");
}
void abso (struct DynArr *stack)
{
double abso;
abso = fabs(stack->data[stack->size-1]);
popDynArr(stack);
addDynArr(stack, abso);
printf(" \nabs\n");
}
void sqf (struct DynArr *stack)
{
double sqVar;
sqVar = sqrt(stack->data[stack->size-1]);
popDynArr(stack);
addDynArr(stack, sqVar);
printf(" \nsqrt\n");
}
void expo (struct DynArr *stack)
{
double ex;
ex = exp(stack->data[stack->size-1]);
popDynArr(stack);
addDynArr(stack, ex);
printf(" \nexp\n");
}
void logg (struct DynArr *stack)
{
double logger;
logger = log(stack->data[stack->size-1]);
popDynArr(stack);
addDynArr(stack, logger);
printf(" \nln\n");
}
void logg10(struct DynArr *stack)
{
double log;
log = log10(stack->data[stack->size-1]);
popDynArr(stack);
addDynArr(stack, log);
printf(" \nlog10\n");
}
void cube (struct DynArr *stack)
{
double cube;
cube = pow(stack->data[stack->size-1], 3);
popDynArr(stack);
addDynArr(stack, cube);
printf(" \ncube\n");
}
/* 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 divide (struct DynArr *stack)
{
/* FIXME: You will write this function */
if (sizeDynArr(stack) >= 2) {
TYPE firstNum = topDynArr(stack);
popDynArr(stack);
TYPE secondNum = topDynArr(stack);
popDynArr(stack);
TYPE result = secondNum / firstNum;
pushDynArr(stack, result);
flag = 1;
}
else
flag = 0;
}
