def test_all_equation_substitutions_simple(self): equation = Parser.parse_equation('y = (x)-(x)') substitution = ExpressionSubstitution(Parser.parse_expression('a - a'), Parser.parse_expression('0')) transformation = Transformation.apply_all_substitution_transformations( substitution) result = transformation.apply(equation) verify(str(result), self.reporter)
def test_all_equation_substitutions_addition_by_same(self): equation = Parser.parse_equation('3.0 = (x)+(x)') substitution = ExpressionSubstitution(Parser.parse_expression('a + a'), Parser.parse_expression('2*a')) transformation = Transformation.apply_all_substitution_transformations( substitution) result = transformation.apply(equation) verify(str(result), self.reporter)
def solve_equation(input): assert type(input) == str if Parser.is_equation(input): equation = Parser.parse_equation(input) variables = equation.get_variables() if len(variables) != 1: raise InputException( 'Equation should have exactly 1 variable but instead has {}: {}' .format(str(len(variables)), variables)) result = Solver.single_variable(equation, variables[0]) else: expression = Parser.parse_expression(input) variables = expression.get_variables() if len(variables) != 0: raise InputException( 'Expression should have no variables but instead has the following: {}' .format(variables)) result = expression.evaluate() print(result)
def test_left_associativity(self): result = Parser.parse_expression('1+2+3+4') self.assertEqual(str(result), '(((1)+(2))+(3))+(4)')
def test_parens_in_the_middle(self): result = Parser.parse_expression('1+(2+3+4)') verify(str(result), self.reporter)
def test_order_of_operations_prefix(self): result = Parser.parse_expression('---x++y-+y') verify(str(result), self.reporter)
def test_order_of_operations_complex(self): result = Parser.parse_expression('y*0.5 - 2*x') verify(str(result), self.reporter)
def single_variable(equation, variable, print_out=False, max_iterations=1000): assert isinstance(equation, Equation) if type(variable) == str: variable = Variable(variable) assert isinstance(variable, Variable) assert type(print_out) == bool assert type(max_iterations) == int assert variable.symbol in equation.get_variables() expected_result = Operation(variable) condition = lambda x: ( (Operation.areEqual(x.lhs, expected_result) and variable.symbol not in x.rhs.get_variables())\ or x is None ) distributions = [ ExpressionSubstitution(Parser.parse_expression('a * (b + c)'), Parser.parse_expression('a * b + a * c')), ExpressionSubstitution(Parser.parse_expression('(a + b) * c'), Parser.parse_expression('a * c + b * c')), ExpressionSubstitution(Parser.parse_expression('(a + b) / c'), Parser.parse_expression('a / c + b / c')), ExpressionSubstitution(Parser.parse_expression('a * (b - c)'), Parser.parse_expression('a * b - a * c')), ExpressionSubstitution(Parser.parse_expression('(a - b) * c'), Parser.parse_expression('a * c - b * c')), ExpressionSubstitution(Parser.parse_expression('(a - b) / c'), Parser.parse_expression('a / c - b / c')), ] distributions = [ Transformation.apply_all_substitution_transformations(x) for x in distributions ] distribute = SolverStep( Transformation.each_transformation(distributions, False)) pre_solve = SolverStep( Transformation.collect_like_terms_transformation()) equation = distribute.execute_step(equation) equation = pre_solve.execute_step(equation) branches = [equation] executed_branches = set() iterations = 0 no_regrets_transformations = [ Transformation.apply_all_substitution_transformations(x)\ for x in Solver.no_regrets_substitutions ] solve_step = SolverStep(Transformation.evaluation_transformation(), terminate_on_repeat=True) solve_step_2 = SolverStep( Transformation.each_transformation(no_regrets_transformations, False)) solve_step_3 = SolverStep(Transformation.flip_transformation(variable)) solve_step_4 = SolverStep.cancellations() solve_step.next_step = solve_step_2 solve_step_2.next_step = solve_step_3 solve_step_3.next_step = solve_step_4 solve_step_4.next_step = solve_step while iterations < max_iterations: if len(branches) == 0: raise SolverException('Exhausted possible transformations.') branch = branches[0] branches = branches[1:] if print_out: print('Executing branch: {}'.format(str(branch))) result = solve_step.execute_until(branch, condition, print_out=print_out) if condition(result): final_execute_step = SolverStep( Transformation.evaluation_transformation()) return final_execute_step.execute_step(result) else: executed_branches.add(str(branch)) executed_branches.add( str(result)) # Executed already since steps terminated new_branches = dict() # We don't care about the outputs of flips or cancellations new_branch_strings = solve_step_3.previous_inputs - executed_branches for string in new_branch_strings: new_branches[string] = Parser.parse_equation(string) solve_step.clear_history() solve_step_2.clear_history() solve_step_3.clear_history() solve_step_4.clear_history() for substitution in Solver.substitutions: left_substitution_result = [ x[1] for x in substitution.get_all_substitutions(branch.lhs) ] right_substitution_result = [ x[1] for x in substitution.get_all_substitutions(branch.rhs) ] equations = [ Equation(x, branch.rhs) for x in left_substitution_result ] equations += [ Equation(branch.lhs, x) for x in right_substitution_result ] pairs = [(str(x), x) for x in equations if str(x) not in executed_branches] for k, v in pairs: new_branches[k] = v if print_out: print("New branches from {}:\n{}\n".format( str(branch), '\n'.join(new_branches.keys()))) branches += new_branches.values() branches.sort(key=lambda x: len(str(x))) iterations += 1 raise SolverException( 'Could not solve equation for a single variable. Final result: {}' .format(str(equation)))
def test_collected_terms_as_expression(self): expression = Parser.parse_expression('2*x + y/4 - x*(3 + 5) - 2/y') terms = CollectedTerms.try_parse_expression(expression) expression_result = terms.as_expression verify(str(expression_result), self.reporter)
def test_parse_collected_terms_complex(self): expression = Parser.parse_expression('2*x + y/4 - x*(3 + 5) - 2/y') terms = CollectedTerms.try_parse_expression(expression) verify(str(terms), self.reporter)
def test_parse_collected_terms_simple(self): x = Parser.parse_expression('2*x') terms = CollectedTerms.try_parse_expression(x) verify(str(terms), self.reporter)