/*******************************************************
 *                     MP5.cpp                         *
 *******************************************************
 * The programm will convert the infix expression      *
 * into the postfix and than evaluate.                 *
 * The stack class will be used for conversion and     *
 * evaluation. The equations will be accepted only in  *
 * the infix form.                                     *
 * Quits when encounters # key.                        *       
 *******************************************************
 * Written by: Olesia Kovalenko                        *
 * For:	       CS 107                                  *
 * Date:       4/28/2003                               *
 *******************************************************/ 





#include<iostream>
#include<cctype>
using namespace std;



/////////////////////////////////////////////////////////
// definition of class provided  by the professor Troy //
/////////////////////////////////////////////////////////


class StackElem
{
// This class will store either a character or double data type.
// The names reflect the intended usage of this class with a program
// for infix to postfix equation translation and postfix equation
// evaluation.

// The class has two data members:
//  the first is an instance of an enumerated type to tell whether
//     the instance of the class is an operator/character or a
//     number/double.  THis value could be undefined in case the
//     instance of the class is created by the default constructor.
//
//  the second is an instance of a union that will hold either the
//     character value or the double value

 public:
   // create the enumerated type to determine the value stored in 
   //  the instance
   enum SEType {UNDEFINED, OPERATOR, NUMBER};

 private:
   // create the union to hold either the character or the double value
   union SEUnion
      {
       char oper;
       double numb;
      };

   // data member definition
   SEType et;           // the instance of the enumerated type
   SEUnion eu;          // the instance of the union

 public:
   // default constructor - type is unknown
   StackElem ()
     {
      et = UNDEFINED;
      eu.oper = '\0';
      eu.numb = 0.0;
     }

   // constructor to set up the instance to hold an operator
   StackElem (char op)
     {
      et = OPERATOR;
      eu.oper = op;
     }

   // constructor to set up the instance to hold a numeric value
   StackElem (double num)
     {
      et = NUMBER;
      eu.numb = num;
     }

   // a method to store an operator in the instance
   void setOperator(char op)
     {
      et = OPERATOR;
      eu.oper = op;
     }

   // a method to store a numeric value in the instance
   void setNumber(double num)
     {
      et = NUMBER;
      eu.numb = num;
     } 

   // a method to return the type of value stored in the instance
   SEType getType()
     {
      return et;
     }

   // a method to access an operator value
   // This method will return true if the instance does indeed
   //   store an operator and false otherwise
   // The method uses a pass-by-reference parameter to send the 
   //   operator value back to the calling code.  If the instance
   //   does not contain an operator the null character is sent 
   //   back to the calling code.
   bool getOperator (char &op)
     {
      if (et == OPERATOR)
         {
          op = eu.oper;
          return true;
         }
      else
         {
          op = '\0';
          return false;
         }
     }

   // a method to access an operator value
   // This method will return the operator value if the
   //   instance does indeed store an operator value.
   //   Otherwise the null character is returned.
   char getOperator ()
     {
      if (et == OPERATOR)
          return eu.oper;
      else
          return '\0';
     }

   // a method to access a numeric value
   // This method will return true if the instance does indeed
   //   store a numeric and false otherwise
   // The method uses a pass-by-reference parameter to send the 
   //   numeric value back to the calling code.  If the instance
   //   does not contain an numeric the value of 0.0 is sent 
   //   back to the calling code.
   bool getNumber (double &num)
     {
      if (et == NUMBER)
         {
          num = eu.numb;
          return true;
         }
      else
         {
          num = 0.0;
          return false;
         }
     }

   // a method to access a numeric value
   // This method will return the numeric value if the
   //   instance does indeed store a numeric value.
   //   Otherwise the value of 0.0 is returned.
   double getNumber ()
     {
      if (et == NUMBER)
          return eu.numb;
      else
          return 0.0;
     }

   // This method is meant for debugging purposes.
   // It outputs the type and value of the instance to cout.
   void output ()
     {
      if (et == UNDEFINED)
         cout << "UNDEFINED.";
      else if (et == OPERATOR)
         cout << "OPERATOR: " << eu.oper;
      else if (et == NUMBER)
         cout << "NUMBER: " << eu.numb;
     }
};





/////////////////////////////
//Definition of the class  //
/////////////////////////////

//1. Stack class.
//The class will serve the purpose of the stack
//used to convert from infix form into postfix and evaluate
class Stack
{
	private:
		
		int maxSize;
		StackElem* mystack;
		int numberUsed;
		
	public:
		//default constractor
		Stack()
		{
			maxSize	= 5;
			mystack = new StackElem[maxSize];
			numberUsed=0;
		}
		
		//copy constractor
		Stack (const Stack& somestack)
		{
			maxSize=2*somestack.maxSize;
			mystack = new StackElem[maxSize];
			for (int i=0; i<somestack.numberUsed; i++)
			{
				mystack[i]=somestack.mystack[i];
			}
			numberUsed=somestack.numberUsed;
		}
				
		//destructor
		~Stack()
		{
			delete [] mystack;
		}
		
		//push method to push the value on stack;
		void push(StackElem value);
			
		//pop method, pops the value of the stack
		StackElem pop();
		
		//top method returns the value on the top of the stack without changing contents of the stack 
		StackElem top();
		
		//The method checks if the stack is empty
		bool isEmpty();
		
		//The method will set the maximum size of the stack
		void setMax(int newMaxSize);
		
		//The method will get the number used in the stack
		int getNumberUsed();
		
		//The method will get the current maxSize of the stack
		int getMaxSize();
		
		//the method grows the stack in conjunction with function growS	
		void GrowStack(const Stack& temp);			
};

//////////////////////////
//function prototypes   //
//////////////////////////

// 1. The function to grow the array
void grow( StackElem* &arrayPtr, int& size);  

// 2. checks for white spaces, unknown characters and # 
bool checkError(char in_char);

// 3. will read in the equation from the input into the dynamic array
bool getEq( StackElem* &input, int& char_read, int& currentSizeInput );

// 4. displays the equation
void dispEq( StackElem* &input, int char_read);

// 5. the one that grows the stack
void growS(Stack& somestack);

// 6. converts the infix expression into the postfix expression.
bool getPostfix(StackElem* &input, StackElem* &postfix, int char_read,int& size_postfix, int currentSizeInput );

// 7. The function will determine the precedence of the operators
int precLevel(char op);

// 8. The function will determine based on precedence level 
//    which of the two operators has a higher precedence;
int precedence( char operator1, char operator2);

// 9. The function will evaluate the postfix expression
double getResult( StackElem* &postfix,int size_postfix);

//10. The function that will perform an operation
StackElem operation(StackElem firstNumber, StackElem secondNumber, StackElem operation);

int main()
{


	cout<<endl<<"*********************OLESIA KOVALENKO*********MP5*********************";
	cout<<endl<<"**The program will convert the infix eq. to postfix and evaluate it.**";
	cout<<endl<<"**********************************************************************"<<endl<<endl<<endl;
	
	//variables used
	int currentSizeInput=5;
	int currentSizePostfix=5;
	StackElem *input;
	StackElem *postfix;
	double result=0;
	int char_read=0;
	int size_postfix=0;
	bool successRead=false;
	bool successTranslated=false;	
	while(true)
	{
		//declare the input-infix array 
		input = new StackElem[currentSizeInput];
		
		//get next equation;
		successRead=getEq(input, char_read, currentSizeInput );
	
		//continue processing if successfull;
		if(successRead)
		{
			//display the equation;
			cout<<endl<<endl<<"The equation in INFIX form is: ";
			dispEq(input,char_read);
			
			//allocate the new postfix array
			postfix= new StackElem[currentSizeInput];
	
			//translate to the postfix
			successTranslated= getPostfix(input, postfix,char_read,size_postfix,currentSizeInput );	
			
			//print the postfix array
			cout<<endl<<endl<<"The processed equation in POSTFIX form is: ";
			dispEq(postfix,size_postfix);
			
			//evaluate only if translation to postfix is successful
			if( successTranslated)
			{
				//evaluate the postfix expression
				result= getResult(postfix,size_postfix); 
				//display the result
				cout<<endl<<"The postfix expression evaluates to: "<<result<<endl<<endl;
		
			}
		}
		//reset # of characters and arrays
		successRead=false;
		successTranslated=false;	
		char_read=0;
		size_postfix=0;
		delete []input;
		delete [] postfix;
		currentSizeInput=5;
		
	cout<<endl<<endl<<"**************************NEXT EQUATION*******************************"<<endl<<endl;
	}
	cout<<endl<<"**********************************************************************";
	cout<<endl<<"*******************************THE END********************************";
	cout<<endl<<"**********************************************************************"<<endl<<endl<<endl;

	return(0);
}


//////////////////////////////////////////
// Functions
//////////////////////////////////////////

//1.
// The function will increase the size of the array
// IN: ptr to the array, size of the array by refference
// OUT:  none, size increase by 2
void grow( StackElem* &arrayPtr, int& size)
{
	//temp array
	StackElem* tempArr;
	tempArr=new StackElem[2*size];
	
	//copy the elements
	for(int i = 0;i<size; i++)
	{
		tempArr[i]=arrayPtr[i];
	}
	
	//increase the size of the array
	delete [] arrayPtr;
	arrayPtr = tempArr;
	size=2*size;
}	
	

// 2.
//  The function checks for white spaces, unknown characters and # 
//  IN:  character
//  OUT: bool true if white space or unknown character, quits if #
bool checkError(char in_char)
{

	//check if pound key
	if(in_char=='#')
	{
		cout<<endl<<endl<<"The # is encountered. Quiting the program!"<<endl;
		cout<<endl<<"**********************************************************************";
		cout<<endl<<"*******************************THE END********************************";
		cout<<endl<<"**********************************************************************"<<endl<<endl<<endl;
		exit(1);
	}
	
	//check if unknown character print error and continue
	if((!isspace(in_char))&&(!isdigit(in_char))&&(in_char!='(')&&
	  (in_char!=')')&&(in_char!='*')&&(in_char!='/')&&
	  (in_char!='+')&&(in_char!='-')&&(in_char!='.')&&
	  (in_char!=';'))
	{
		cout<<endl<<"ERROR: Unknown character! The character encountered is \""<<in_char<<"\", skeeping!"<<endl; 		
		return(true); 
	}
		
	//check if white space character, skip if it is
	if(isspace(in_char))
	{
		return(true);
	}

	return(false);	

}	


// 3. 
// THe function will read in the equation from the input into the dynamic array
// IN: ptr to where the array will be stored, the current size of the array (by reff.)
//     the initial size of the array allocated.
// OUT: none, array filled in and the the size updated.
bool getEq( StackElem* &input, int& char_read, int& currentSizeInput )
{
	//variables used;
	char input_char;	 
	StackElem element;
	double num=0.0,place=0.0;
	bool digit= false, charErr=false, hasNeg=false;
	
			
	//Prompt for the input
	cout<<"Please enter the expression. To end expression use \";\", "<<endl;
	cout<<"To end program enter \"#\" : ";
	
	//get the character
	cin.get(input_char);
	
	
	while(input_char!=';')
	{
		
		
		
		
		//check for non-char and spaces inbetween the numbers
		charErr=checkError(input_char);
		if(charErr)
		{
			cin.get(input_char);
			continue;
		}
		
		//check if the previous element was numeric the parentecies itself were not present
		if((element.getType()==StackElem::NUMBER) && (input_char=='('))
		{
			
			while(input_char!=';')
			{
				cin.get(input_char);
				//check for non-char and spaces inbetween the numbers
				charErr=checkError(input_char);
			}
			cout<<endl<<endl<<"ERROR: Incorrect expression."<<endl;
			cout<<"ERROR: There has to be an operator between number and \"(\"."<<endl;
			cout<<"The expression is not in the infix form, skeeping!"<<endl<<endl;
			return(false);	 
		}
		

		//check if the previous element was operator the open parentecies itself cannot be present
		if((element.getType()==StackElem::OPERATOR) && (input_char==')') && 
		  (element.getOperator()!='.') && (element.getOperator()!=')') )
		{
			
			while(input_char!=';')
			{
				cin.get(input_char);
				//check for non-char and spaces inbetween the numbers
				charErr=checkError(input_char);
			}
			cout<<endl<<endl<<"ERROR: Incorrect expression. There cannot be \")\" after operator"<<endl;
			cout<<"The expression is not in the infix form, skeeping!"<<endl<<endl;			
			return(false);	 
		}
		
		//check if the first number has a negative sign
		if(((element.getType()==StackElem::UNDEFINED) && (input_char=='-')) ||
		  ((element.getType()==StackElem::OPERATOR) && (element.getOperator()=='(')) && (input_char=='-'))
		{
			cin.get(input_char);
			charErr=checkError(input_char);
			while(charErr)
			{
				cin.get(input_char);
				charErr=checkError(input_char);
			}		
			
			if(isdigit(input_char) || (input_char=='.'))
			{		
				hasNeg=true;
			}				
			else
			{
				while(input_char!=';')
				{
					cin.get(input_char);
					//check for non-char and spaces inbetween the numbers
					charErr=checkError(input_char);
				}
				cout<<endl<<"ERROR: The expression is not in the infix form."<<endl;
				cout<<"Skeeping that expression."<<endl<<endl;
				return(false);	
			}		
		
		
		}
		
		
		//check that if the previous was an operator next needs to be a number
		if((element.getType()==StackElem::OPERATOR) &&
		  (element.getOperator()!= '(') && (element.getOperator()!=')' ) )
		{
		
			// if negative possibly is a minus sign
			if (input_char=='-') 
			{
				cin.get(input_char);
				charErr=checkError(input_char);
				while(charErr)
				{
					cin.get(input_char);
					charErr=checkError(input_char);
				}		
				
				if(isdigit(input_char) || (input_char=='.'))
				{		
					hasNeg=true;
				}				
				else
				{
					while(input_char!=';')
					{
						cin.get(input_char);
						//check for non-char and spaces inbetween the numbers
						charErr=checkError(input_char);
					}
					cout<<endl<<"ERROR: The expression is not in the infix form."<<endl;
					cout<<"Skeeping that expression."<<endl<<endl;
					return(false);	
				}
			}			
			else if((!isdigit(input_char)) && (input_char!=';') && (input_char!='(') &&
			       (input_char !='.'))
			{

				while(input_char!=';')
				{
					cin.get(input_char);
					//check for non-char and spaces inbetween the numbers
					charErr=checkError(input_char);
				}
				cout<<endl<<"ERROR: The expression is not in the infix form."<<endl;
				cout<<" Skeeping that expression."<<endl<<endl;
				return(false);
			}   
			
		}
		
		//check that the ( is not followed by the operator other than ; or ( or . 
		if((element.getType()==StackElem::OPERATOR) && (element.getOperator()=='(') &&
		  ((input_char=='+') || (input_char=='-') || (input_char=='*') || (input_char=='/') ||
		      (input_char==')')) )
		{

				while(input_char!=';')
				{
					cin.get(input_char);
					//check for non-char and spaces inbetween the numbers
					charErr=checkError(input_char);
				}
				cout<<endl<<"ERROR: The expression is not in the infix form."<<endl;
				cout<<" Skeeping that expression."<<endl<<endl;
				return(false);
		}   
					
		
		//read if digit
		num=0.0;
		while(isdigit(input_char))
		{
			num=num * 10 +input_char - '0';
			cin.get(input_char);
			//here need to check if there is an error
			charErr=checkError(input_char);
			while(charErr)
			{
				cin.get(input_char);
				charErr=checkError(input_char);
			}		
			digit = true;
		}
		
		//check if float
		if (input_char=='.')
		{
			cin.get(input_char);
			place= 10.0;
			//skip the white space, nonchar, quit on # 
			charErr=checkError(input_char);
			while(charErr)
			{
				cin.get(input_char);
				charErr=checkError(input_char);
			}		
			//check for missplaced dots
			if((!isdigit(input_char)) && (element.getType()!=StackElem::NUMBER) && 
			   (input_char=='.') && (input_char!=')') )
			{	
				while(input_char!=';')
				{
					cin.get(input_char);
					//check for non-char and spaces inbetween the numbers
					charErr=checkError(input_char);
				}
				cout<<endl<<"ERROR: The expression is not in the infix form."<<endl;
				cout<<"Skeeping that expression."<<endl<<endl;
				return(false);			

			}
			
			
			while(isdigit(input_char))
			{
				num= num+ (input_char - '0')/place;
				place=place*10;
				cin.get(input_char);
				//here need to check if there is an error
				charErr=checkError(input_char);
				while(charErr)
				{
					cin.get(input_char);
					charErr=checkError(input_char);
				}		
					digit = true;	
			}
			

		}	
		
		//negate the number is negative sign found
		if(hasNeg)
		{
			num=-num;
			hasNeg=false;
		} 
				
		//set the variable element to operator or numeric if numeric the next char is already in
		// if not still have to get the next one.					
		if (digit == true)
		{
			element.setNumber(num);
			digit= false;
		}
		else
		{
			element.setOperator(input_char);
			cin.get(input_char);
		}
		 
		input[char_read] = element;
		char_read++;		
 
		//store the value into the input dinamic array
		//check if array is of sufficient size
		if (char_read>= currentSizeInput)
		{
			grow(input, currentSizeInput);		
		}

	}

	// close the expression with ';'
	element.setOperator(';');
	input[char_read]=element;
	char_read++;

	//return true is completed successfully
	return(true);
}




// 4.
//   The function will display the equation upon request
//   IN: Dinamic array, and number of elements in it  
//   OUT: None. the contents of the dynamic array are displayed.
void dispEq( StackElem* &input, int char_read)
{
	cout<<endl;
	for(int j=0; j<char_read; j++)
	{
		if(input[j].getType()==StackElem::OPERATOR)
		{
			cout<<input[j].getOperator()<<" ";
		}
		else if(input[j].getType()==StackElem::NUMBER)
		{
			cout<<input[j].getNumber()<<" ";
		}
		else
		{
			cout<<"ERROR:Problem with equation."<<endl;
			exit(1);	
		}
	}
	cout<<endl<<endl;
}

// 5.
// The function that will grow the size, here only for convinience, 
// used in conjunction with method GrowStack
// IN: the stack that needs to grow
// OUT none, the message stated the new size will be printed;
void growS(Stack& somestack)
{
	
	Stack tempStack(somestack);
	somestack.GrowStack(tempStack);	
	cout<<endl<<"A new array is bing allocated of size "<<somestack.getMaxSize()<<" for the stack."<<endl;
}

// 6.
// The function will convert the infix expression into the postfix expression.
// IN: dinamic array of the current infix eq; dyn. array to store postfix size infix,
//     size postfix and the current number of char in the equation.
// OUT: postfix array
bool getPostfix(StackElem* &input, StackElem* &postfix, int char_read,int& size_postfix, int currentSizeInput )
{ 

	//variables used
	Stack stack;
	StackElem temp;

	for(int pos=0; pos<char_read; pos++)
	{
		//if numeric send to postfix
		if(input[pos].getType()==StackElem::NUMBER)
		{
			postfix[size_postfix]=input[pos];
			size_postfix++;						
		}
		//if operator check if to store on stack or send to postfix
		else if(input[pos].getType()==StackElem::OPERATOR)
		{
			if((input[pos].getOperator()=='(') || (input[pos].getOperator()=='*') ||
			   (input[pos].getOperator()=='/') || (input[pos].getOperator()=='+') ||
			   (input[pos].getOperator()=='-') )
			{
				if(!(stack.isEmpty()))
				{
					temp=stack.top();
				}
					
				// pop the stack untill any of the following are true and store into postfix
				while(!(stack.isEmpty()) && (temp.getOperator()!='(') &&
				     ( precedence(temp.getOperator(),input[pos].getOperator())!=-1) )
				{
			   		postfix[size_postfix]=stack.pop();
					size_postfix++;
					
					//check next value on top
					if(!(stack.isEmpty()))
					{
						temp=stack.top();
					}					
				}	

				//grow the stack if more place is needed
				if (stack.getNumberUsed()>=stack.getMaxSize())
				{
					growS(stack);
				}
				//push the current operator on stack
				stack.push(input[pos]);

			}
			//if closing parenthesis encountered pop the stack into the postfix and ( is not found or empty
			else if(input[pos].getOperator()==')')
			{
				if(!(stack.isEmpty()))
				{
					temp=stack.top();
				}
				while(!(stack.isEmpty()) && (temp.getOperator()!='('))
				{
					//pop into postfix array
					postfix[size_postfix]=stack.pop();
					size_postfix++;
					//check what is new value on top
					if(!(stack.isEmpty()))
					{
						temp=stack.top();
					}	
				}
				//if stack is empty return to the main
				if(stack.isEmpty())
				{
					cout<<"ERROR: unmatched closing parenthesis."<<endl;
					cout<<"The needed parenthesis were not found!"<<endl;
					return(false);
				}
				
				//pop of the open parenthasis of the stack
				if(temp.getOperator()=='(')
				{
					//pop of the open parenthesis
					stack.pop();
				}
				
				
			}
			else if(input[pos].getOperator()==';')
			{
				if(!(stack.isEmpty()))
				{
					temp=stack.top();
				}
				while(!(stack.isEmpty()))
				{
					//check that there are no open parenthesis on the stack
					if(temp.getOperator()=='(')
					{
						cout<<"ERROR: unmatched open parenthesis."<<endl;
						cout<<"The needed parenthesis were not found!"<<endl;
						return(false);						
					}
					else
					{
						//pop into postfix array
						postfix[size_postfix]=stack.pop();
						size_postfix++;
					}
					//check what is new value on top
					if(!(stack.isEmpty()))
					{
						temp=stack.top();
					}	
				}
			//add closing parenthasis for refference
			postfix[size_postfix]=input[pos];
			size_postfix++;	
			
			}						
		}			 
	}
	return(true);	
}

// 7. 
// The function will determine the precedence of the operators
// IN: operator.
// OUT: 3=highest ( or )
//      2=middle  *,/
//      1=lowest  +,-
//	4=other ; #
int precLevel(char op)
{
	if( (op=='(') || (op==')'))
		return(3);
	else if( (op=='*') || (op=='/'))
		return(2);
	else if( (op=='+') || (op=='-'))
		return(1);		
	else
		return(4);

}

// 8.
// The function will determine based on precedence level 
//    which of the two operators has a higher precedence;
// IN: two operators
// OUT: 1 if op1>op2
//	-1 if op1<op2
//	0 if op1=op2
int precedence( char operator1, char operator2)
{
	if(precLevel(operator1)>precLevel(operator2))
		return(1);
	else if(precLevel(operator1)<precLevel(operator2))
		return(-1);
	else 
		return(0);
}


// 9.
// The function will evaluate the postfix expression
// IN: the pointer to the postfix array,the size of the array
// OUT: result in floating format
double getResult( StackElem* &postfix,int size_postfix)
{

	//variables used
	Stack stack;
	StackElem temp;
	int count=0;
	StackElem numf(0.0),numw(0.0),numr(0.0); 
	bool error=false;

	//process to the end of the expression that is ;
	while (postfix[count].getOperator()!=';')
	{

		// if the value in the postfix is a number send it to the stack
		if(postfix[count].getType()==StackElem::NUMBER)
		{	
			
			//grow the stack if more place is needed
			if (stack.getNumberUsed()>=stack.getMaxSize())
			{
				growS(stack);
			}
			stack.push(postfix[count]);

		}
		//if the operator is encountered pop the two values of the stack
		//note that the value poped second is the one from which is substracted 
		//and which is divided
		else if (postfix[count].getType()==StackElem::OPERATOR)
		{
			//if the stack is not empty perform operation 
			//if the stack becomes empty than the operands obtained
			//than expression is unbalanced 
			if(!(stack.isEmpty()))
				//pop the value of the stack
				numw=stack.pop();
			else 
				error=true;

			if(!(stack.isEmpty()))
				//pop the second value of the stack
				numf=stack.pop();
			else
				error=true;

			//if no error was encountered perform operation
			if(!error)
			{
				//grow the stack if needed
				if (stack.getNumberUsed()>=stack.getMaxSize())
				{
					growS(stack);
				}
				//push the result on the stack
				stack.push(operation(numf,numw,postfix[count]));

			}

		}
		//increment the count
		count++;
	}
	//the last operator has to be ; since it was put artificially into the postfix
	//if  not than there is a definite error
	if(postfix[count].getOperator()==';')
	{
		//if there is no error pop the result off the stack 
		if(!(stack.isEmpty()))
		{
			temp=stack.pop();
		}
		else
		{
			error=true;
		}

		//if the stack at that point is not empty or the value on the stack is not a number
		//than it is an error
		if( (!(stack.isEmpty())) || (temp.getType()!=StackElem::NUMBER) )
		{
			error=true;
		}

		//if the error was encountered print the error message and return
		if(error)
		{
			cout<<endl<<"ERROR:Unbalanced expression, no result will be returned"<<endl;
			error=false;
			return(0);
		}

	}
	//return the result
	return(temp.getNumber());		
}

//10.
//   The function that will perform an operation
//   IN: the two StackElem containing numbers, and StackElem containing an operator
//   OUT: the StackElem containing the result of the operation.
StackElem operation(StackElem firstNumber, StackElem secondNumber, StackElem operation)
{
	double result;
	StackElem SEresult;
	
	//perform an operation based on the operator get the double and return the 
	//stackElem type variable of the result
	if (operation.getOperator()=='+')
	{
		result=firstNumber.getNumber()+secondNumber.getNumber();
	}
	else if(operation.getOperator()=='-')
	{
		result=firstNumber.getNumber()-secondNumber.getNumber();
	}
	else if(operation.getOperator()=='*')
	{
		result=firstNumber.getNumber()*secondNumber.getNumber();
	}
	else if(operation.getOperator()=='/')
	{
		result=firstNumber.getNumber()/secondNumber.getNumber();
	}

	SEresult.setNumber(result);
	return(SEresult);
}

	
//////////////////////////////////////
// full definitions of class methods//
//////////////////////////////////////

//push method to push the value on stack;
//IN: the value (operator or number)
//OUT: none, the value is in the dynamic array
void Stack::push(StackElem value)
{
	mystack[numberUsed]= value;
	numberUsed++;
}

// pop method, pops the value of the stack
//IN: none
//OUT: the value that had been poped of the stack
StackElem Stack::pop()
{
	if(numberUsed<=0)
	{
		cout<<"ERROR IN POP: Attempt to access the space bellow alocated for stack,"<<endl;
		cout<<"the function isEmpty should of been used to check if the stack is empty."<<endl;
		cout<<"Such student does not deserve an A";
		exit(1);
	}
	numberUsed--;
	return(mystack[numberUsed]);
}
	
//top method returns the value on the top of the stack without changing contents of the stack
//IN: none
//OUT:the value on the top of the stack  
StackElem Stack::top()
{
	if(numberUsed<=0)
	{
		cout<<"ERROR IN TOP:Attempt to access the space bellow alocated for stack,"<<endl;
		cout<<"the function isEmpty should of been used to check if the stack is empty."<<endl;
		cout<<"Such student does not deserve an A";
		exit(1);
	}
	return(mystack[numberUsed-1]);
}
		
//The method checks if the stack is empty
//In: none
//OUT: bool, true if empty, false overwize
bool Stack::isEmpty()
{
	if(numberUsed<=0)
	{
		return true;
	}
	else
	{
		return false;
	}
}
		
//The method will set the maximum size of the stack
//IN: New size of the stack
//OUT: none
void Stack::setMax(int newMaxSize)
{
	maxSize=newMaxSize;
}
		
//The method will get the number used in the stack
//IN: none
//OUT: current number used in the stack
int Stack::getNumberUsed()
{
	return numberUsed;
}  			
		
//The method will get the current maxSize of the stack
//IN: none
//OUT: current maximum size of the stack
int Stack::getMaxSize()
{
	return maxSize;
}  

//The method will grow the stack used in conjunction with function grow stack		
//IN: the copy of the old Stack
//OUT: none 
void Stack::GrowStack(const Stack& temp)
{
	delete [] mystack;
	maxSize=2*maxSize;
	mystack = new StackElem[maxSize];
	for (int i=0;i<numberUsed;i++)
	{
		mystack[i]=temp.mystack[i];
	} 
}