コード例 #1
0
def infix_to_postfix(infix_expr):
	#   converts infix expression to a postfix expression
    """ Method to convert infix expressions into postix
    Infix expression should have operations and operands seperated by spaces
    postfix expression will be formatted that way"""
    expression = infix_expr.split(" ")
    # operands = StackArray(len(expression)//2)
    operands = StackArray(30)
    to_process = []
    for part in expression:
        # part = expression[i]
        if not check_num(part):
            if (part == ')'):
                while (operands.peek() != '('):
                    to_process.append(str(operands.pop()))
                operands.pop()
                # print("Operand: " + part);
            else:
                while (not operandOnTop(part, operands)):
                    to_process.append(str(operands.pop()))
                operands.push(part);
                # print("Operand: " + part);
        else:
            if check_float(part):
                to_process.append(float(part))
            else:
                to_process.append(int(part))
    while (not operands.is_empty()):
        to_process.append(str(operands.pop()))
    postfix_expr = " ".join(str(thing) for thing in to_process)
    # print("Postfix Expression Ready: " + postfix_expr)
    return postfix_expr
コード例 #2
0
def infix_to_postfix(infixexpr):
    """Converts an infix expression to an equivalent postfix expression """
    prec = {'^':4, '*': 3, '/': 3, '+': 2, '-': 2, '(': 1}
    opstack = StackArray(30)
    postfixList = []
    tokenList = infixexpr.split(' ')#returns an array with elements split
    for tok in tokenList:
        if tok not in "^*()-/+": #if token is a number put in the list
            postfixList.append(tok)
        elif tok == '(': #if token is open parenthesis put it in list output
            opstack.push(tok)
        elif tok == ')': #if token is close parenthesis
            toptoken = opstack.pop() #take the top token of stack
            while toptoken != '(': #pop through the stack and append to output list until you get to the open parenthesis
                postfixList.append(toptoken)
                toptoken = opstack.pop()
        else:
            while (not opstack.is_empty()) and (prec[opstack.peek()] >= prec[tok]):#handle precedence
                if opstack.peek() == '^' and tok == "^":
                    break#dont append
                postfixList.append(opstack.pop())
            opstack.push(tok)

    while not opstack.is_empty():#if empty append everything else
        postfixList.append(opstack.pop())
    return " ".join(postfixList)
コード例 #3
0
def infix_to_postfix(infixexpr):
    """Converts an infix expression to an equivalent postfix expression """
    """Signature:  a string containing an infix expression where tokens are space separated is
       the single input parameter and returns a string containing a postfix expression
       where tokens are space separated"""
    operandStack = StackArray(30)
    postfixList = []
    tokenList = infixexpr.split()
    precedence = {"^": 4, "*": 3, "/": 3, "+": 2, "-": 2, "(": 1}
    for token in tokenList:
        if is_valid(token):
            postfixList.append(token)
        else:
            if token == '(':
                operandStack.push(token)
            elif token == ')':
                top = operandStack.pop()
                while top != '(':
                    postfixList.append(top)
                    top = operandStack.pop()
            else:
                while (operandStack.is_empty() == False) and (
                        precedence[operandStack.peek()] >= precedence[token]
                        and token != "^"):
                    postfixList.append(operandStack.pop())
                operandStack.push(token)
    while operandStack.is_empty() == False:
        postfixList.append(operandStack.pop())
    return " ".join(postfixList)
コード例 #4
0
ファイル: exp_eval.py プロジェクト: Alyssajan298/CPE-202
def postfix_eval(postfixExpr):
	""" Takes in a valid Postfix Expression and evaluates using the helper function doMath(op,op1,op2)"""
	newStack = StackArray(30)
	postfix = postfixExpr.split()
	for x in postfix:
		if x not in ('*','-','/','+','^'):
			newStack.push(x)
		elif x in ('*','-','/','+','^'):
			newStack.push(doMath(x,float(newStack.pop()),float(newStack.pop())))
	return newStack.pop()
コード例 #5
0
def postfix_eval(postfixExpr):
    """Evaluate the postfix expression using Stacks, and return final answer """
    opStack = StackArray(30)
    tList = postfixExpr.split()

    for t in tList:
        if t in "0123456789":
            opStack.push(int(t))
        else:
            op2 = opStack.pop()
            op1 = opStack.pop()
            result = doMath(t, op1, op2)
            opStack.push(result)
    return opStack.pop()
コード例 #6
0
def postfix_eval(postfix_expr):
	#   evaluates a postfix expression
    """ Evaluates a postfix expression and returns the answer """
    to_process = postfix_expr.split(" ")
    num_nums = postfix_valid(postfix_expr)
    if not num_nums:
        raise ValueError
    nums = StackArray(num_nums)
    while to_process:
        if (check_num(to_process[0])):
            nums.push(float(to_process[0]))
            del to_process[0]
            # print("Number: " + str(nums.peek()));
        else:
            # print("Operation: "+ to_process[0]);
            if to_process[0] in ["+", "-", "*", "/", "^"]:
                nums.push(do_math(nums.pop(), nums.pop(), to_process[0]))
                del to_process[0]
            else:
                del to_process[0]
            # print("Calculation complete: " + str(nums.peek()))
    return nums.pop()
コード例 #7
0
def postfix_eval(postfixExpr):
    """  Purpose """
    operandStack = StackArray(30)
    listexp = postfixExpr.split(' ')
    for token in listexp:
        if token not in "^*-+/":
            operandStack.push(float(token))
        else:
            op2 = operandStack.pop()
            op1 = operandStack.pop()
            if token == '^':
                operandStack.push(doMath(token, float(op2), float(op1)))
            else:
                operandStack.push(doMath(token, float(op1), float(op2)))
    return operandStack.pop()
コード例 #8
0
ファイル: exp_eval.py プロジェクト: Alyssajan298/CPE-202
def infix_to_postfix(infixexpr):
	"""Converts an infix expression to an equivalent postfix expression """

	"""Signature:  a string containing an infix expression where tokens are space separated is
	   the single input parameter and returns a string containing a postfix expression
	   where tokens are space separated"""
	
	newStack = StackArray(30)
	postfixList= []
	tokenList = infixexpr.split()
	x = 0
	par = 0 
	while x < len(tokenList): 
		if tokenList[x] is ('('): #When encountering paranthesis in the input
			newStack.push(tokenList[x])
			par = x+1
			while par < len(tokenList) and tokenList[par] not in (')'):
				if tokenList[par] not in ('*','-','/','+','^','('):
					postfixList.append(tokenList[par])
				elif tokenList[par] in ('('):
					newStack.push(tokenList[x])
				elif tokenList[par] in ('^'):
					if newStack.peek() in ('('):
						newStack.push(tokenList[par])
					elif newStack.peek() in '^':
						newStack.push(tokenList[par])
					elif newStack.peek() in ('*','/'):
						newStack.push(tokenList[par])
					elif newStack.peek() in ('+','-'):
						newStack.push(tokenList[par])
				elif tokenList[par] in ('*','/'):
					if newStack.peek() in ('('):
						newStack.push(tokenList[par])
					elif newStack.peek() in ('^'):
						postfixList.append(newStack.pop())
						newStack.push(tokenList[par])
					elif newStack.peek() in ('+','-'):
						newStack.push(tokenList[par])
					elif newStack.peek() in ('*','/'):
						postfixList.append(newStack.pop())
						newStack.push(tokenList[par])
				elif tokenList[par] in ('+','-'):
					if newStack.peek() in ('('):
						newStack.push(tokenList[par])
					elif newStack.peek() in ('^','*','/'):
						while newStack.peek() in ('^','*','/') and newStack.peek() not in ('(') :
							postfixList.append(newStack.pop())
						newStack.push(tokenList[par])
					elif newStack.peek() in ('+','-'):
						while newStack.peek() in ('+','-'):
							postfixList.append(newStack.pop())
						newStack.push(tokenList[par])
				par+=1
			condition = True
			while condition: #Popping and appending remaining symbols to list
				while newStack.peek() not in ('('):
					postfixList.append(newStack.pop())
				newStack.pop() #Removing the ( that was pushed onto the Stack
				iterate = 0
				if newStack.size() == 0:
						condition = False
						
				while iterate < newStack.size():
					if newStack.items[iterate] == None:
						iterate+=1
						continue
					elif newStack.items[iterate] in ('('):
						condition = True
						break
					else:
						iterate+=1	
					condition = False


				
			x = par

					 
		
		elif tokenList[x] not in ('*','-','/','+','^','(',')'): #Encountering a non paranthesis
			postfixList.append(tokenList[x])
		elif tokenList[x] in ('^'):
			if newStack.is_empty():
				newStack.push(tokenList[x])
			elif newStack.peek() in '^':
				newStack.push(tokenList[x])
			elif newStack.peek() in ('*','/'):
				newStack.push(tokenList[x])
			elif newStack.peek() in ('+','-'):
				newStack.push(tokenList[x])
		elif tokenList[x] in ('*','/'):
			if newStack.is_empty():
				newStack.push(tokenList[x])
			elif newStack.peek() in ('^'):
				postfixList.append(newStack.pop())
				newStack.push(tokenList[x])
			elif newStack.peek() in ('+','-'):
				newStack.push(tokenList[x])
			elif newStack.peek() in ('*','/'):
				postfixList.append(newStack.pop())
				newStack.push(tokenList[x])
		elif tokenList[x] in ('+','-'):
			if newStack.is_empty():
				newStack.push(tokenList[x])
			elif newStack.peek() in ('^','*','/'):
				while newStack.peek() in ('^','*','/') or not newStack.is_empty():
					postfixList.append(newStack.pop())
				newStack.push(tokenList[x])
			elif newStack.peek() in ('+','-'):
				while newStack.peek() in ('+','-'):
					postfixList.append(newStack.pop())
				newStack.push(tokenList[x])
		x+=1
	while not newStack.is_empty(): #Popping and appending remaining symbols to list
		postfixList.append(newStack.pop())
	return " ".join(postfixList) #Creates the Postfix Expression by joining the list