def do_job(tasks_to_accomplish, tasks_that_are_done):
while not tasks_to_accomplish.empty():
try:
task = tasks_to_accomplish.get_nowait()
except queue.Empty:
return True
#print(task)
print(task['name'])
P = expression.Expression("P", "x2-x1**2")
Q = expression.Expression("Q", "x2**2-2*x2-2*x1-x1**2")
class Point(Structure):
_fields_ = [('x', c_double), ('y', c_double)]
def m_getVx(param, P, Q):
vx = None
try:
vx = P.execute_l(param) / math.sqrt(
math.pow(P.execute_l(param), 2) +
math.pow(Q.execute_l(param), 2))
except ZeroDivisionError:
vx = float('Inf')
return vx
def m_getVy(param, P, Q):
vy = None
try:
vy = Q.execute_l(param) / math.sqrt(
math.pow(P.execute_l(param), 2) +
math.pow(Q.execute_l(param), 2))
except ZeroDivisionError:
vy = float('Inf')
return vy
start = timer()
xk = task['point'].copy()
k = 1
while k < task['n']:
xk[0] += task['alpha'][0] * m_getVx(xk, P=P, Q=Q)
xk[1] += task['alpha'][1] * m_getVy(xk, P=P, Q=Q)
task['result'].append(xk.copy())
k += 1
dt = timer() - start
task['time'] = dt
tasks_that_are_done.put({
'name':
task['name'],
'point':
task['point'].copy(),
'n':
task['n'],
'alpha':
task['alpha'].copy(),
'result':
[task['result'][i].copy() for i in range(len(task['result']))],
'time':
task['time']
})
# tasks_that_are_done.close()
return True
def reduce(self, args, pool):
(arg0, arg1, arg2), args_tail = args[:3], args[3:]
#logger.debug(f'S x={arg0} y={arg1} z={arg2}')
return xp.Expression.concat(
xp.Expression(arg0, arg2,
xp.Expression(arg1, arg2).to_surface_normal_form()),
*args_tail), [arg2], []
def test_stack_pop(self):
grouping_operators = ['(', ')']
# test 1
operators = stack.LinkedListStack()
operands = stack.LinkedListStack()
parsed_expression = expression.Expression('(2+2)x(2+2)').parse()
expected_operators = ['+', 'x', '+']
expected_operands = ['2', '2', '2', '2']
results_operators = []
results_operands = []
for token in parsed_expression:
if token in expected_operators:
operators.push(token)
elif token != '' and token not in grouping_operators:
operands.push(token)
while (not operators.isEmpty()):
results_operators.append(operators.pop())
while (not operands.isEmpty()):
results_operands.append(operands.pop())
self.assertTrue(results_operators == expected_operators)
self.assertTrue(results_operands == expected_operands)
# print(results_operators)
# print(expected_operators)
# print(results_operands)
# print(expected_operands)
del operands, operators
# Test 2
operators = stack.LinkedListStack()
operands = stack.LinkedListStack()
parsed_expression = expression.Expression(
'(2.05+20x(100÷2))x((5-2)+2))').parse()
# In reverse order since Stacks are LIFO when popping
expected_operators = ['+', '-', 'x', '÷', 'x', '+']
expected_operands = ['2', '2', '5', '2', '100', '20', '2.05']
results_operators = []
results_operands = []
for token in parsed_expression:
if token in expected_operators:
operators.push(token)
elif token != '' and token not in grouping_operators:
operands.push(token)
while (not operators.isEmpty()):
results_operators.append(operators.pop())
while (not operands.isEmpty()):
results_operands.append(operands.pop())
self.assertTrue(results_operators == expected_operators)
self.assertTrue(results_operands == expected_operands)
def __init__(self, tasks_to_accomplish, tasks_that_are_done):
multiprocessing.Process.__init__(self)
self.task_queue = tasks_to_accomplish
self.result_queue = tasks_that_are_done
self.exit = multiprocessing.Event()
self.alpha = [0.01, 0.01]
self.P = expression.Expression("P", "x2-x1**2")
self.Q = expression.Expression("Q", "x2**2-2*x2-2*x1-x1**2")
self.n = 100
def main():
# 正常用例
print('2 + 3 =', exp.Expression(exp.Operator.add, 2, 3).eval())
# 除数为零的用例
try:
exp.Expression(exp.Operator.divide, 1, 0).eval()
except RuntimeError as re:
print(re)
# 乘方包含分数的用例
try:
exp.Expression(exp.Operator.power,
exp.Expression(exp.Operator.divide, 1, 4), 2).eval()
except RuntimeError as re:
print(re)
def gen_questions(n):
'''生成n个不重复的表达式，返回并保存到文件中'''
number_num = 200
numbers = init_numbers(number_num, -150, 150)
questions = [exp.Expression(number) for number in numbers]
for pos in range(len(questions)):
questions[pos].value = questions[pos]
questions[pos].no = pos
last = 0
while len(questions) - number_num < n:
temp = len(questions)
product_questions(
n + number_num, questions,
questions[random.randint(0, temp //
10)::random.randint(1, temp // 10)],
questions[last::random.randint(1, temp // 10)], 0.1)
if len(questions) != temp:
last = temp
else:
questions, last = questions[:number_num], 0
questions = questions[number_num:]
random.shuffle(questions)
questions_str = [
question.__str__() + '=' + question.eval().__str__() + '\n'
for question in questions
]
print(sys.path[0])
with open(sys.path[0] + '/../res/questions.txt', 'w') as save_file:
save_file.writelines(questions_str)
return questions
def p_exp1_exp1ops(p):
'exp1 : exp1 1L1R_OP_L1 exp2'
# if p[2].strrep == '/':
#
# else:
# expList = [p[1], p[3]]
expList = [p[1], p[3]]
p[0] = xp.Expression(p[2], expList)
def test_empty_init(self):
"Test the default Expression creation"
# 1. Create default Expression object
myobj = expression.Expression()
# 2. Make sure it has the default values
self.assertEqual(myobj.part2, False)
self.assertEqual(myobj.text, None)
self.assertEqual(len(myobj.tokens), 0)
def __init__(self, text=None, part2=False):
# 1. Set the initial values
self.part2 = part2
self.text = text
self.expressions = []
# 2. Process text (if any)
if text is not None and len(text) > 0:
for line in text:
self.expressions.append(
expression.Expression(text=line, part2=part2))
def test_part_two(self):
"Test examples from part two"
# 1. Loop for all of the examples
for exp in EXAMPLES:
# 2. Create the expression object
myobj = expression.Expression(text=exp['text'], part2=True)
self.assertEqual(len(myobj.tokens), exp['tokens'])
# 3. Check the value
self.assertEqual(myobj.evaluate(), exp['r2'])
def product_questions(n, questions, a, b, drop_out):
'''由已生成的表达式组合成更复杂的表达式'''
for left, right, op in product(a, b, exp.Operator):
if random.random() < drop_out:
continue
if not check_valid(op, left, right):
continue
question = exp.Expression(op, left, right)
question.value = op.value[1](left.value, right.value)
question.no = len(questions)
questions.append(question)
if len(questions) >= n:
return
def test_text_init(self):
"Test the Expression object creation from text"
# 1. Create Expression object from text
myobj = expression.Expression(text='123')
# 2. Make sure it has the expected values
self.assertEqual(myobj.part2, False)
self.assertEqual(len(myobj.text), 3)
self.assertEqual(len(myobj.tokens), 1)
# 3. Check methods
self.assertEqual(myobj.get_operand(myobj.tokens, '+'), (['123'], []))
self.assertEqual(myobj.evaluate(), 123)
def get_exp(inputStr):
if inputStr[1:] == 'loading':
return xp.Expression(op.Operator('loading...', lambda x: ''),
[xp.NoOpExpression("")])
global error
error = False
print('processing', inputStr.replace('\u2986', '$').replace('\u2985', '#'))
inputStr = preprocess(inputStr)
print('got', inputStr.replace('\u2986', '$').replace('\u2985', '#'))
resultingExpression = parser.parse(inputStr)
if error:
raise ValueError("Expression could not parse correctly.")
else:
return resultingExpression
def distribute(exp,rToL = True):
if(exp.op == "*"):
if rToL:
to_insert = exp.expList[1]
to_insert_to = exp.expList[0]
else:
to_insert = exp.expList[0]
to_insert_to = exp.expList[1]
all_insertion_sites = all_under_a_zero_prec_op(to_insert_to)
for site in all_insertion_sites:
multiplied_node = xp.Expression("*",[site,to_insert])
replace_child(site.parent,site,multiplied_node)
exp = to_insert_to
exp.assign_parents()
def p_exp3_parens(p):
'exp3 : LPAREN exp0 RPAREN'
p[0] = xp.Expression(FPRN_OP, [p[2]])
def p_exp1_exp2ops(p):
'exp2 : exp3 1L1R_OP_R2 exp2'
expList = [p[1], p[3]]
p[0] = xp.Expression(p[2], expList)
def p_exp0_exp0ops(p):
'exp0 : exp0 1L1R_OP_L0 exp1'
expList = [p[1], p[3]]
p[0] = xp.Expression(p[2], expList)
def p_exp3_clbracks(p):
'exp3 : LBRK_CURSOR LBRACK exp0 RBRACK'
p[0] = xp.Expression(SPRN_OP, [p[3]]).addCursor(0)
def p_exp3_crbracks(p):
'exp3 : LBRACK exp0 RBRACK RBRK_CURSOR'
p[0] = xp.Expression(SPRN_OP, [p[2]]).addCursor(1)
def p_exp3_cruparens(p):
'exp3 : LPAREN exp0 URPAREN URPRN_CURSOR'
p[0] = xp.Expression(LPRN_OP, [p[2]]).addCursor(1)
def p_exp3_bracks(p):
'exp3 : LBRACK exp0 RBRACK'
p[0] = xp.Expression(SPRN_OP, [p[2]])
def p_exp3_urparens(p):
'exp3 : ULPAREN exp0 RPAREN'
p[0] = xp.Expression(RPRN_OP, [p[2]])
def p_exp3_curparens(p):
'exp3 : ULPAREN exp0 RPAREN RPRN_CURSOR'
p[0] = xp.Expression(RPRN_OP, [p[2]]).addCursor(1)
def p_exp3_cluparens(p):
'exp3 : ULPRN_CURSOR ULPAREN exp0 RPAREN'
p[0] = xp.Expression(RPRN_OP, [p[3]]).addCursor(0)
def p_exp3_culparens(p):
'exp3 : LPRN_CURSOR LPAREN exp0 URPAREN'
p[0] = xp.Expression(LPRN_OP, [p[3]]).addCursor(0)
def do_job(tasks_to_accomplish, tasks_that_are_done):
while True:
try:
'''
try to get task from the queue. get_nowait() function will
raise queue.Empty exception if the queue is empty.
queue(False) function would do the same task also.
'''
task = tasks_to_accomplish.get_nowait()
#print(task)
print(task['name'])
P = expression.Expression("P", "x2-x1**2")
Q = expression.Expression("Q", "x2**2-2*x2-2*x1-x1**2")
class Point(Structure):
_fields_ = [('x', c_double), ('y', c_double)]
def m_getVx(param, P, Q):
vx = None
try:
vx = P.execute_l(param) / math.sqrt(
math.pow(P.execute_l(param), 2) +
math.pow(Q.execute_l(param), 2))
except ZeroDivisionError:
vx = float('Inf')
return vx
def m_getVy(param, P, Q):
vy = None
try:
vy = Q.execute_l(param) / math.sqrt(
math.pow(P.execute_l(param), 2) +
math.pow(Q.execute_l(param), 2))
except ZeroDivisionError:
vy = float('Inf')
return vy
start = timer()
xk = task['point'].copy()
k = 1
while k < task['n']:
xk[0] += task['alpha'][0] * m_getVx(xk, P=P, Q=Q)
xk[1] += task['alpha'][1] * m_getVy(xk, P=P, Q=Q)
task['result'].append(xk.copy())
k += 1
dt = timer() - start
task['time'] = dt
time.sleep(1)
except queue.Empty:
print("lol")
os.getpid()
break
else:
'''
if no exception has been raised, add the task completion
message to task_that_are_done queue
'''
# tasks_that_are_done.put(task['name'] + ' is done by ' + current_process().name)
tasks_to_accomplish.task_done()
tasks_that_are_done.put({
'name':
task['name'],
'point':
task['point'].copy(),
'n':
task['n'],
'alpha':
task['alpha'].copy(),
'result':
[task['result'][i].copy() for i in range(len(task['result']))],
'time':
task['time']
})
#tasks_that_are_done.task_done()
# time.sleep(100)
return
def test_stack_push(self):
grouping_operators = ['(', ')']
# Test 1
operators = stack.LinkedListStack()
operands = stack.LinkedListStack()
parsed_expression = expression.Expression('(2+2)x(2+2)').parse()
expected_operators = ['+', 'x', '+']
expected_operands = ['2', '2', '2', '2']
results_operators = []
results_operands = []
for token in parsed_expression:
if token in expected_operators:
operators.push(token)
elif token != '' and token not in grouping_operators:
operands.push(token)
node = operators.getTail()
while (node):
results_operators.append(node.value)
node = node.next
node = operands.getTail()
while (node):
results_operands.append(node.value)
node = node.next
self.assertTrue(results_operators == expected_operators)
self.assertTrue(results_operands == expected_operands)
del operands, operators
# Test 2
operators = stack.LinkedListStack()
operands = stack.LinkedListStack()
parsed_expression = expression.Expression(
'(2.05+20x(100÷2))x((5-2)+2))').parse()
expected_operators = ['+', 'x', '÷', 'x', '-', '+']
expected_operands = ['2.05', '20', '100', '2', '5', '2', '2']
results_operators = []
results_operands = []
for token in parsed_expression:
if token in expected_operators:
operators.push(token)
elif token != '' and token not in grouping_operators:
operands.push(token)
node = operators.getTail()
while (node):
results_operators.append(node.value)
node = node.next
node = operands.getTail()
while (node):
results_operands.append(node.value)
node = node.next
self.assertTrue(results_operators == expected_operators)
self.assertTrue(results_operands == expected_operands)
del operands, operators
def __init__(self):
self.commands = {
"commands": {
"none": 0,
"exit": 1,
"test": 2,
"clear": 3,
"help": 4,
"new": 5,
"show slist": 6,
"show scount": 7,
"acc": 8,
"mk": 9,
"start": 10,
"show result": 11,
"image 1": 12,
"start m": 13,
"image 2": 14,
"image 3": 15,
"int": 16,
"dist": 17,
"count": 18,
"npoint": 19,
"image 2 file": 20,
"int sq": 21,
"rule": 22,
},
"description": {
"none": "do nothing",
"exit": "exit from module",
"test": "do test stuff",
"clear": "clear something",
"help": "display helpfull information",
"new": "enter new raw data",
"show slist": "show raw data",
"show scount": "show raw data",
"show acc": "show accuracy",
"acc": "set accuracy",
"mk": "set default raw data",
"start": "start calculation process",
"start m": "start calculation process with multi p",
"show result": "show result",
"image 1": "show 2D visualization",
"image 2": "show 2D visualization in different colors",
"image 3":
"show 2D visualization in different colors by quiver",
"int":
"set interval witch will be a side of square for calculations",
"dist": "set dist. between points",
"count": "set count of iterations",
"npoint": "enter n points",
"image 2 file":
"show 2D visualization in different colors sava in file",
"int sq": "generate points in square between two points",
"rule": "set rule's number",
}
}
self.result = {"point": []}
self.expression_P = expression.Expression("P", "x2-x1**2")
self.expression_Q = expression.Expression("Q", "x2**2-2*x2-2*x1-x1**2")
self.condition = expression.Expression("No name", "x < 5")
self.start_point = [0.0, 0.0]
self.tasks_to_accomplish = multiprocessing.Manager().Queue()
self.tasks_that_are_done = multiprocessing.Manager().Queue()
self.processes = []
self.accuracy = 3
self.alpha = [10.0**(-self.accuracy), 10.0**(-self.accuracy)]
self.n = 10000
self.points_count = 10
self.start_point = [[x, y] for x in range(self.points_count + 1)
for y in range(self.points_count + 1)]
self.epsilon = [1, 1]
self.rule = 0
self.makedefault()
j += 1
if j >= len(args):
raise util.ParseException(
"Unable to parse group from '{}' due to missing '{}'"
.format(" ".join(args), right_sep))
if args[j] == right_sep:
depth -= 1
elif args[j] == left_sep:
depth += 1
self.append(Group(args[i + 1:j], self.depth + 1))
i = j
# check if it is an expression
elif expression.is_expression(arg):
self.append(expression.Expression(arg))
# check if it is a table
elif table.is_table(arg):
self.append(table.Table(arg))
# assume it is a normal roll
else:
self.append(Roll(arg))
# last line of code in the loop
i += 1
if not self.all_tags[tags.YIELD]:
self.__set_yield(firstStatFound or tags.TOTAL)
def p_exp3_ulparens(p):
'exp3 : LPAREN exp0 URPAREN'
p[0] = xp.Expression(LPRN_OP, [p[2]])
