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]])