Refactored some code to try and make it more inline with best pratices. Renamed parser as it conflicted with a standard Python library.
This commit is contained in:
+11
-13
@@ -1,6 +1,4 @@
|
||||
import ptoken as token
|
||||
import tokenizer
|
||||
import uuid
|
||||
from base_unit import Token, TokenType
|
||||
from collections import deque
|
||||
|
||||
class Op:
|
||||
@@ -10,7 +8,7 @@ class Op:
|
||||
self.right = right
|
||||
|
||||
def __str__(self):
|
||||
return "%s (%s) and (%s)" %(token.TokenType.get_operator_verb(self.op), self.left, self.right)
|
||||
return "%s (%s) and (%s)" %(TokenType.get_operator_verb(self.op), self.left, self.right)
|
||||
|
||||
class Num:
|
||||
def __init__(self, token):
|
||||
@@ -46,11 +44,11 @@ class Parser:
|
||||
new_list = []
|
||||
|
||||
for t in self.bak:
|
||||
if t.type == token.TokenType.variable:
|
||||
if t.type == TokenType.variable:
|
||||
if t.value in self.variables:
|
||||
new_list.append(token.Token(self.variables[t.value], token.TokenType.constant))
|
||||
new_list.append(Token(self.variables[t.value], TokenType.constant))
|
||||
else:
|
||||
new_list.append(token.Token(t.value, t.type))
|
||||
new_list.append(Token(t.value, t.type))
|
||||
return new_list
|
||||
|
||||
def advance_current_token(self):
|
||||
@@ -60,16 +58,16 @@ class Parser:
|
||||
self.current_token = self.tokens.popleft()
|
||||
|
||||
def factor(self):
|
||||
if self.current_token.type == token.TokenType.constant:
|
||||
if self.current_token.type == TokenType.constant:
|
||||
node = Num(self.current_token)
|
||||
self.advance_current_token()
|
||||
return node
|
||||
elif self.current_token.type == token.TokenType.variable:
|
||||
elif self.current_token.type == TokenType.variable:
|
||||
node = Variable(self.current_token)
|
||||
self.variables[self.current_token.value] = node
|
||||
self.advance_current_token()
|
||||
return node
|
||||
elif self.current_token.type == token.TokenType.exp_start:
|
||||
elif self.current_token.type == TokenType.exp_start:
|
||||
self.advance_current_token() # (
|
||||
node = self.topLevel()
|
||||
self.advance_current_token() # )
|
||||
@@ -78,7 +76,7 @@ class Parser:
|
||||
def lowLevel(self):
|
||||
node = self.factor()
|
||||
|
||||
while self.current_token.type == token.TokenType.power:
|
||||
while self.current_token.type == TokenType.power:
|
||||
tmp = self.current_token
|
||||
self.advance_current_token()
|
||||
node = Op(left=node, op=tmp.type, right=self.factor())
|
||||
@@ -88,7 +86,7 @@ class Parser:
|
||||
def midLevel(self):
|
||||
node = self.lowLevel()
|
||||
|
||||
while self.current_token.type in (token.TokenType.multiply, token.TokenType.divide):
|
||||
while self.current_token.type in (TokenType.multiply, TokenType.divide):
|
||||
tmp = self.current_token
|
||||
self.advance_current_token()
|
||||
node = Op(left=node, op=tmp.type, right=self.lowLevel())
|
||||
@@ -98,7 +96,7 @@ class Parser:
|
||||
def topLevel(self):
|
||||
node = self.midLevel()
|
||||
|
||||
while self.current_token.type in (token.TokenType.add, token.TokenType.subtract):
|
||||
while self.current_token.type in (TokenType.add, TokenType.subtract):
|
||||
tmp = self.current_token
|
||||
self.advance_current_token()
|
||||
node = Op(left=node, op=tmp.type, right=self.midLevel())
|
||||
+9
-9
@@ -1,13 +1,13 @@
|
||||
import ptoken
|
||||
import parser
|
||||
from base_unit import Token, TokenType
|
||||
from ast_gen import Variable, Num
|
||||
|
||||
debug = False
|
||||
|
||||
def calculate_results(node):
|
||||
|
||||
if type(node) is parser.Num:
|
||||
if type(node) is Num:
|
||||
return float(node.value)
|
||||
elif type(node) is parser.Variable:
|
||||
elif type(node) is Variable:
|
||||
return node.value
|
||||
|
||||
left = calculate_results(node.left)
|
||||
@@ -21,19 +21,19 @@ def operate(n1, n2, tokenType):
|
||||
n1 = float(n1)
|
||||
n2 = float(n2)
|
||||
|
||||
if tokenType == ptoken.TokenType.add:
|
||||
if tokenType == TokenType.add:
|
||||
if debug: print("Adding %f and %f to get %f." %(n1, n2, n1 + n2))
|
||||
return n1 + n2
|
||||
elif tokenType == ptoken.TokenType.subtract:
|
||||
elif tokenType == TokenType.subtract:
|
||||
if debug: print("Subtracting %f and %f to get %f." %(n1, n2, n1 - n2))
|
||||
return n1 - n2
|
||||
elif tokenType == ptoken.TokenType.multiply:
|
||||
elif tokenType == TokenType.multiply:
|
||||
if debug: print("Multiplying %f and %f to get %f" %(n1, n2, n1 * n2))
|
||||
return n1 * n2
|
||||
elif tokenType == ptoken.TokenType.divide:
|
||||
elif tokenType == TokenType.divide:
|
||||
if debug: print("Dividing %f and %f to get %f" %(n1, n2, n1 / n2))
|
||||
return n1 / n2
|
||||
elif tokenType == ptoken.TokenType.power:
|
||||
elif tokenType == TokenType.power:
|
||||
if debug: print("Raising %f to the power of %f to get %f" %(n1, n2, n1**n2))
|
||||
return n1 ** n2
|
||||
else:
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
import ptoken as token
|
||||
import tokenizer
|
||||
import expression
|
||||
import calc_engine
|
||||
from base_unit import Token, TokenType
|
||||
from calc_engine import calculate_results
|
||||
from expression import Expression, Variable
|
||||
from tokenizer import get_tokens_from_expression_string, stringify_token_list
|
||||
import factors
|
||||
import jsonpickle
|
||||
import itertools
|
||||
import copy
|
||||
import parser
|
||||
from ast_gen import Parser
|
||||
|
||||
base_list = [1, 2, 4, 6, 12]
|
||||
tolerance = .05
|
||||
@@ -151,8 +151,8 @@ json = jsonpickle.json.loads(open(fileLocation).read())
|
||||
with open("expression.json", "r") as f:
|
||||
#j = jsonpickle.json.load(f)
|
||||
exp = jsonpickle.decode(f.read())
|
||||
tokens = tokenizer.get_tokens_from_expression_string(exp.expression)
|
||||
tree = parser.Parser(tokens)
|
||||
tokens = get_tokens_from_expression_string(exp.expression)
|
||||
tree = Parser(tokens)
|
||||
#results = calc_engine.calculate_results(tokens.copy())
|
||||
#print(results)
|
||||
|
||||
@@ -187,7 +187,7 @@ for r in res:
|
||||
count +=1
|
||||
t = tree.update_variables(vs)#tokenizer.replace_variables(tokens, list(r))
|
||||
#tokenizer.print_token_list(t)
|
||||
result = calc_engine.calculate_results(tree.ast)
|
||||
result = calculate_results(tree.ast)
|
||||
if result <= int(exp.wrong_response * (1 + tolerance)) and result >= int(exp.wrong_response * (1 - tolerance)):
|
||||
if not result in answers:
|
||||
answers[result] = tree.get_tokens()
|
||||
@@ -201,6 +201,6 @@ with open("results.txt", "w") as f:
|
||||
print("Answers Found: %d" %(len(answers)))
|
||||
for k in answers:
|
||||
f.write("Result: %s for expression: " %(format(k, ".6f")))
|
||||
f.write(tokenizer.stringify_token_list(answers[k]))
|
||||
f.write(stringify_token_list(answers[k]))
|
||||
|
||||
|
||||
|
||||
+29
-29
@@ -1,4 +1,4 @@
|
||||
import ptoken as token
|
||||
from base_unit import Token, TokenType
|
||||
from collections import deque
|
||||
|
||||
def get_tokens_from_expression_string(expression_string):
|
||||
@@ -18,82 +18,82 @@ def get_tokens_from_expression_string(expression_string):
|
||||
raise SyntaxError("Invalid grammar, to many periods in number. Found at position " + str (i) + ".")
|
||||
if len(tokens) > 1:
|
||||
lookBehind = tokens[-1]
|
||||
if lookBehind.type == token.TokenType.exp_end:
|
||||
tokens.append(token.Token("^", token.TokenType.power))
|
||||
if lookBehind.type == TokenType.exp_end:
|
||||
tokens.append(token.Token("^", TokenType.power))
|
||||
if (i + 1) == len(expression_string):
|
||||
tokens.append(token.Token(tmp + c, token.TokenType.constant))
|
||||
tokens.append(token.Token(tmp + c, TokenType.constant))
|
||||
parsing_number = True
|
||||
tmp = tmp + c
|
||||
continue
|
||||
|
||||
elif c == '-' and not parsing_number:
|
||||
if expression_string[i + 1] == '.' or expression_string[i + 1].isdigit():
|
||||
if token.TokenType.get_operator(tokens[-1].value) != token.TokenType.unknown:#tokens[-1].type == token.TokenType
|
||||
if token.TokenType.get_operator(tokens[-1].value) != TokenType.unknown:#tokens[-1].type == token.TokenType
|
||||
#print(tokens[-1].value)
|
||||
#tokens.append(token.Token('+', token.TokenType.add))
|
||||
parsing_number = True
|
||||
tmp = "-"
|
||||
elif tokens[-1].type == token.TokenType.exp_start:
|
||||
elif tokens[-1].type == TokenType.exp_start:
|
||||
parsing_number = True
|
||||
tmp = "-"
|
||||
elif tokens[-1].type == token.TokenType.exp_end:
|
||||
tokens.append(token.Token(c, token.TokenType.get_operator(c)))
|
||||
elif tokens[-1].type == TokenType.exp_end:
|
||||
tokens.append(Token(c, TokenType.get_operator(c)))
|
||||
parsing_number = False
|
||||
tmp = ""
|
||||
elif expression_string[i + 1].isalpha():
|
||||
# Must be a variable.
|
||||
if tokens[-1].type == token.TokenType.exp_start:
|
||||
if tokens[-1].type == TokenType.exp_start:
|
||||
variable_is_negative = True
|
||||
elif token.TokenType.get_operator(tokens[-1].value) != token.TokenType.unknown:
|
||||
elif token.TokenType.get_operator(tokens[-1].value) != TokenType.unknown:
|
||||
variable_is_negative = True
|
||||
elif tokens[-1].type == token.TokenType.exp_end:
|
||||
tokens.append(token.Token(c, token.TokenType.get_operator(c)))
|
||||
elif tokens[-1].type == TokenType.exp_end:
|
||||
tokens.append(Token(c, TokenType.get_operator(c)))
|
||||
parsing_number = False
|
||||
tmp = ""
|
||||
else:
|
||||
tokens.append(token.Token(c, token.TokenType.get_operator(c)))
|
||||
tokens.append(Token(c, TokenType.get_operator(c)))
|
||||
parsing_number = False
|
||||
tmp = ""
|
||||
|
||||
elif c == '(':
|
||||
if parsing_number:
|
||||
tokens.append(token.Token(tmp, token.TokenType.constant))
|
||||
tokens.append(token.Token("*", token.TokenType.multiply))
|
||||
tokens.append(token.Token("(", token.TokenType.exp_start))
|
||||
tokens.append(token.Token(tmp, TokenType.constant))
|
||||
tokens.append(token.Token("*", TokenType.multiply))
|
||||
tokens.append(Token("(", TokenType.exp_start))
|
||||
parsing_number = False
|
||||
tmp = ""
|
||||
continue
|
||||
elif c == ')':
|
||||
if parsing_number:
|
||||
tokens.append(token.Token(tmp, token.TokenType.constant))
|
||||
tokens.append(token.Token(")", token.TokenType.exp_end))
|
||||
tokens.append(token.Token(tmp, TokenType.constant))
|
||||
tokens.append(Token(")", TokenType.exp_end))
|
||||
parsing_number = False
|
||||
tmp = ""
|
||||
continue
|
||||
elif token.TokenType.get_operator(c) != token.TokenType.unknown:
|
||||
elif TokenType.get_operator(c) != TokenType.unknown:
|
||||
if parsing_number:
|
||||
tokens.append(token.Token(tmp, token.TokenType.constant))
|
||||
tokens.append(token.Token(c, token.TokenType.get_operator(c)))
|
||||
tokens.append(Token(tmp, TokenType.constant))
|
||||
tokens.append(Token(c, TokenType.get_operator(c)))
|
||||
parsing_number = False
|
||||
tmp = ""
|
||||
continue
|
||||
elif c != ' ':
|
||||
if len(tokens) > 1:
|
||||
lookBehind = tokens[-1]
|
||||
if lookBehind.type == token.TokenType.exp_end:
|
||||
tokens.append(token.Token("^", token.TokenType.power))
|
||||
if lookBehind.type == TokenType.exp_end:
|
||||
tokens.append(Token("^", TokenType.power))
|
||||
|
||||
if (i + 1) < len(expression_string):
|
||||
lookAHead = expression_string[i + 1]
|
||||
if lookAHead == '(':
|
||||
tokens.append(token.Token(c, token.TokenType.variable))
|
||||
tokens.append(token.Token("*", token.TokenType.multiply))
|
||||
tokens.append(Token(c, TokenType.variable))
|
||||
tokens.append(Token("*", TokenType.multiply))
|
||||
tmp = ""
|
||||
parsing_number = False
|
||||
continue
|
||||
if parsing_number:
|
||||
tokens.append(token.Token(tmp, token.TokenType.constant))
|
||||
tokens.append(token.Token("*", token.TokenType.multiply))
|
||||
tokens.append(Token(tmp, TokenType.constant))
|
||||
tokens.append(Token("*", TokenType.multiply))
|
||||
# Check to see if the encountered variable, which is effectively a single character,
|
||||
# has been seen before. If it has been then simply increment the number that represents how many times it's been seen
|
||||
# else, add a new entry for it in the dictonary 'symbols_dic'.
|
||||
@@ -102,7 +102,7 @@ def get_tokens_from_expression_string(expression_string):
|
||||
else:
|
||||
symbols_dic[c] = 1
|
||||
# Afterwards, add the variable with the count of the times it's been seen as a token object to the list of tokens.
|
||||
tokens.append(token.Token(c + str(symbols_dic[c]), token.TokenType.variable, variable_is_negative))
|
||||
tokens.append(Token(c + str(symbols_dic[c]), TokenType.variable, variable_is_negative))
|
||||
variable_is_negative = False
|
||||
parsing_number = False
|
||||
tmp = ""
|
||||
@@ -119,7 +119,7 @@ def peek_list(tokens):
|
||||
def print_token_list(tokens):
|
||||
# Prints the list of Tokens to standard out.
|
||||
for tk in tokens:
|
||||
if tk.type == token.TokenType.variable:
|
||||
if tk.type == TokenType.variable:
|
||||
if tk.is_negative_variable:
|
||||
print("-%s " %(tk.value), end = "")
|
||||
else:
|
||||
|
||||
Reference in New Issue
Block a user