def set_equations(self, conf_equations=None, user=None, keep_solvers=False, make_virtual=False): """ Set equations of the problem using the `equations` problem description entry. Fields and Regions have to be already set. """ conf_equations = get_default(conf_equations, self.conf.get_default_attr('equations', None)) self.set_variables() variables = Variables.from_conf(self.conf_variables, self.fields) self.set_materials() materials = Materials.from_conf(self.conf_materials, self.functions) self.integrals = self.get_integrals() equations = Equations.from_conf(conf_equations, variables, self.domain.regions, materials, self.integrals, user=user, make_virtual=make_virtual) self.equations = equations if not keep_solvers: self.solvers = None
def set_equations(self, conf_equations=None, user=None, keep_solvers=False, make_virtual=False): """ Set equations of the problem using the `equations` problem description entry. Fields and Regions have to be already set. """ conf_equations = get_default(conf_equations, self.conf.get('equations', None)) self.set_variables() variables = Variables.from_conf(self.conf_variables, self.fields) self.set_materials() materials = Materials.from_conf(self.conf_materials, self.functions) self.integrals = self.get_integrals() equations = Equations.from_conf(conf_equations, variables, self.domain.regions, materials, self.integrals, user=user) self.equations = equations if not keep_solvers: self.solvers = None
def __init__(self): is_debug = self._debug_detect() if not is_debug: import RPi.GPIO as GPIO GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM) buttons = Buttons_HW(is_debug) buttons.listen_buttons(self._buttons_callback) self._game_select = GameSelect() self._game_select.set_callback(self._change_menu_mode) self._equations = Equations() self._equations.set_callback(self._change_menu_mode) self._display = Display_LCD(is_debug, self._draw) if is_debug: self._draw(self._display.debug_draw()) self._display.debug_show()
def assemble_by_blocks( conf_equations, problem, conf_ebc=None, conf_epbc=None, dw_mode="matrix", restore_variables=True ): """Instead of a global matrix, return its building blocks as defined in `conf_equations`. The name and row/column variables of each block have to be encoded in the equation's name, as in: conf_equations = { 'A,v,u' : "dw_lin_elastic_iso.i1.Y2( inclusion.lame, v, u )", } """ equations = Equations.from_conf(conf_equations) equations.setup_terms(problem.domain.regions, problem.variables, problem.materials) var_names = equations.get_variable_names() conf_variables = select_by_names(problem.conf.variables, var_names) problem.set_variables(conf_variables) dummy = problem.create_state_vector() indx = problem.variables.get_indx matrices = {} for key, mtx_term in conf_equations.iteritems(): ks = key.split(",") mtx_name, var_names = ks[0], ks[1:] output(mtx_name, var_names) problem.set_equations({"eq": mtx_term}) problem.time_update(conf_ebc=conf_ebc, conf_epbc=conf_epbc) ir = indx(var_names[0], stripped=True, allow_dual=True) ic = indx(var_names[1], stripped=True, allow_dual=True) mtx = eval_term_op(dummy, mtx_term, problem, dw_mode="matrix") matrices[mtx_name] = mtx[ir, ic] if restore_variables: problem.set_variables() return matrices
def set_equations(self, conf_equations, user=None, cache_override=None, keep_solvers=False): equations = Equations.from_conf(conf_equations) equations.setup_terms(self.domain.regions, self.variables, self.materials, user) i_names = equations.get_term_integral_names() self.integrals = Integrals.from_conf(self.conf.integrals, i_names) self.integrals.set_quadratures(fea.collect_quadratures()) self.geometries = {} equations.describe_geometry(self.geometries, self.variables, self.integrals) ## print self.geometries ## pause() # Call after describe_geometry(), as it sets ap.surface_data. self.variables.setup_dof_conns() if cache_override is None: cache_override = get_default_attr(self.conf.fe, "cache_override", True) equations.set_cache_mode(cache_override) self.equations = equations if not keep_solvers: self.solvers = None
def create_evaluable(expression, fields, materials, variables, integrals, update_materials=True, ebcs=None, epbcs=None, lcbcs=None, ts=None, functions=None, auto_init=False, mode='eval', extra_args=None, verbose=True, kwargs=None): """ Create evaluable object (equations and corresponding variables) from the `expression` string. Parameters ---------- expression : str The expression to evaluate. fields : dict The dictionary of fields used in `variables`. materials : Materials instance The materials used in the expression. variables : Variables instance The variables used in the expression. integrals : Integrals instance The integrals to be used. update_materials : bool Call time update function of the materials. Safe but can be slow. ebcs : Conditions instance, optional The essential (Dirichlet) boundary conditions for 'weak' mode. epbcs : Conditions instance, optional The periodic boundary conditions for 'weak' mode. lcbcs : Conditions instance, optional The linear combination boundary conditions for 'weak' mode. ts : TimeStepper instance, optional The time stepper. functions : Functions instance, optional The user functions for boundary conditions, materials etc. auto_init : bool Set values of all variables to all zeros. mode : one of 'eval', 'el_avg', 'qp', 'weak' The evaluation mode - 'weak' means the finite element assembling, 'qp' requests the values in quadrature points, 'el_avg' element averages and 'eval' means integration over each term region. extra_args : dict, optional Extra arguments to be passed to terms in the expression. verbose : bool If False, reduce verbosity. kwargs : dict, optional The variables (dictionary of (variable name) : (Variable instance)) to be used in the expression. Returns ------- equation : Equation instance The equation that is ready to be evaluated. variables : Variables instance The variables used in the equation. """ if kwargs is None: kwargs = {} domain = fields[fields.keys()[0]].domain caches = DataCaches() # Create temporary variables. aux_vars = Variables(variables) if extra_args is None: extra_args = kwargs else: extra_args = copy(extra_args) extra_args.update(kwargs) equations = Equations.from_conf({'tmp' : expression}, aux_vars, domain.regions, materials, integrals, setup=False, caches=caches, user=extra_args, verbose=verbose) equations.collect_conn_info() equations.assign_geometries() # The true variables used in the expression. variables = equations.variables if auto_init: for var in variables: var.init_data(step=0) if mode == 'weak': setup_dof_conns(equations.conn_info) if update_materials: materials.time_update(ts, domain, equations, verbose=False) equations.time_update(ts, ebcs, epbcs, lcbcs, functions) else: setup_extra_data(equations.conn_info) if update_materials: materials.time_update(ts, domain, equations, verbose=False) return equations, variables
from equations import Equations from random import randint import subprocess, os, platform, sys user_input = '' args = [] print("Loading ...") user_equation = Equations() def printOptions(): print("Please pass arguments a number/symbol at a time") print("Acceptable inputs are:") print("Any one digit number (0-9)") print("Addition, Subtraction, Multiplication and Division symbols (+, -, *, /)") print("If you would like to input numbers with multiple digits, place them one after another") print("Input 's' to have the program solve the inputted function") print("Input 'r' to reset the equation") print("Input 'd' to see a simple demo of the program") print("Input 'e' to solve a random equation") print("Input 'p' to print out your current list of arguments") print("Input 'u' to remove the last item added to the arguments") print("Input 'q' to quit the program") print("Input 'c' to clear the terminal and list options again") symbol_inputs = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '-', '*', '/',] printOptions() while True: user_input = input("Enter Symbol: ")
def evaluate_infix(expression): """ The highest level function for evaluation of expressions :param expression: string representing an infix expression :return: err_start, err_end, message, interpreted expression in case of any error, None, None, solution, interpreted_expression otherwise """ pat_unallowed = re.compile(r'([^A-Za-z0-9+\-*/=.,\s()])') if len(pat_unallowed.findall(expression)) > 0: pos = next(pat_unallowed.finditer(expression)).start() return pos, pos, "Unallowed symbol detected: %s" % expression[ pos], expression if "=" in expression: # Solve an equation if expression.count("=") > 1: pos = expression.index("=") + expression[expression.index("=") + 1:].index("=") + 1 return pos, pos, "More than one '=' symbols in expression can't be interpreted", expression result = Equations.solve(*expression.split("=")) if len(result) == 4: return result else: try: varname = result[0] polynomial = result[1] interpreted_expression = result[2] except (TypeError, IndexError): return -1, -1, "Something has gone terribly wrong", expression else: postfix_expression = PostfixExpression(expression) interpreted_expression = postfix_expression.interpreted_expression if postfix_expression.error_msg is not None: pos = postfix_expression.error_place return pos[0], pos[ 1], postfix_expression.error_msg, interpreted_expression else: varname = "" polynomial = postfix_expression.result.polynomial solver = PolynomialSolver() try: # Take the first (and the only) solution result = solver.solve(polynomial)[0] except NotImplementedError as e: return -1, -1, e.args[0], expression if result[1] == 0: if '=' in expression: return -1, -1, "The expression doesn't have a variable " + \ "(or the coefficient before it is 0), but " + \ "has a '=' sign. It cannot be interpreted.", expression # Formatting the result num_result = result[0] if math.floor( result[0]) != result[0] else math.floor(result[0]) return None, None, str(num_result), interpreted_expression else: if '=' not in expression: return -1, -1, "The expression has variables but doesn't have '=' sign." + \ "Should it be treated as equation?", expression # Formatting the result num_result = result[0] if math.floor( result[0]) != result[0] else math.floor(result[0]) return None, None, varname + ' = ' + str( num_result), interpreted_expression
class PiGame: _index = 0 _display = None _menu_mode = MenuMode.GAME_SELECT _game_select = None _equations = None def __init__(self): is_debug = self._debug_detect() if not is_debug: import RPi.GPIO as GPIO GPIO.setwarnings(False) GPIO.setmode(GPIO.BCM) buttons = Buttons_HW(is_debug) buttons.listen_buttons(self._buttons_callback) self._game_select = GameSelect() self._game_select.set_callback(self._change_menu_mode) self._equations = Equations() self._equations.set_callback(self._change_menu_mode) self._display = Display_LCD(is_debug, self._draw) if is_debug: self._draw(self._display.debug_draw()) self._display.debug_show() def _draw(self, draw): if self._menu_mode == MenuMode.GAME_SELECT: self._game_select.draw(draw) elif self._menu_mode == MenuMode.EQUATIONS: self._equations.draw(draw) elif self._menu_mode == MenuMode.MATH_SQUARE: draw.text((2, 2), "TODO", fill="white") def _buttons_callback(self, button): print(button) if self._menu_mode == MenuMode.GAME_SELECT: self._game_select.handle_button(button) elif self._menu_mode == MenuMode.EQUATIONS: self._equations.handle_button(button) elif self._menu_mode == MenuMode.MATH_SQUARE: pass if self._debug_detect(): self._display.debug_clear() self._draw(self._display.debug_draw()) self._display.debug_show() def _change_menu_mode(self, menu_mode): self._menu_mode = menu_mode def _debug_detect(self): try: # Check if user named `pi` exists # If exists then we known that code is running on Raspberry pwd.getpwnam('pi') return False except KeyError: return True
def main(): obj = Equations() while obj.runloop: obj.loop()