def Partial_differential_equations(A = '0', B = '0', C = '0', D = '0', E = '0', F = '0', G = '0', kind = 1): A = parse_expr(functions.tipa_parse_str(A)) B = parse_expr(functions.tipa_parse_str(B)) C = parse_expr(functions.tipa_parse_str(C)) D = parse_expr(functions.tipa_parse_str(D)) E = parse_expr(functions.tipa_parse_str(E)) F = parse_expr(functions.tipa_parse_str(F)) G = parse_expr(functions.tipa_parse_str(G)) X, Y, u, f = map(sp.Function, 'XYuf') uxx = sp.integrals.diff(u(x, y), x, 2) uyy = sp.integrals.diff(u(x, y), y, 2) uxy = sp.integrals.diff(u(x, y), x, y) ux = sp.integrals.diff(u(x, y), x) uy = sp.integrals.diff(u(x, y), x) fx = sp.integrals.diff(f(x, y), x) fy = sp.integrals.diff(f(x, y), x) if kind == 1: eq = sp.Eq(D * fx + E * fy + F * f(x, y), G) return str(sp.pdsolve(eq)) elif kind == 2: eq = sp.Eq(D * fx + E * fy + F * f(x, y), G) return str(sp.pdsolve(eq)) elif kind == 3: eq = sp.Eq(D * fx + E * fy + F * f(x, y), G) return str(sp.pdsolve(eq)) elif kind == 4: eq = sp.Eq(A * uxx + B * uyy + C * uxy + D * ux + E * uy + F * u(x, y), G) return str(sp.pde_separate(eq, u(x, y), [X(x), Y(y)], strategy='mul')) elif kind == 5: eq = sp.Eq(A * uxx + B * uyy + C * uxy + D * ux + E * uy + F * u(x, y), G) return str(sp.pde_separate(eq, u(x, y), [X(x), Y(y)], strategy='add'))
def _parse_solution(self, deq): sol = None status = True try: ans = pdsolve(deq, u(x, y, t), real=True) if isinstance(ans, Eq): sol = ans.rhs sol = try_clear_expr(sol) # TODO handle later the multiple solution case elif isinstance(ans, list): ham_error('HAM_ERROR_CRITICAL', 'CRITICAL__NOT_IMPLEMENTED_YET') else: ham_error('HAM_ERROR_CRITICAL', 'CRITICAL__ASSERT_NOT_REACHED') except NotImplementedError: status = False sol = None # TODO temp treatment. FALL BACK to EQ_GEN_MODE ham_error('HAM_ERROR_CRITICAL', 'CRITICAL__ASSERT_NOT_REACHED') if status: status = self._check_if_solution_explicit(deq, sol) return sol, status
def apply(self, eqn, y, x, evaluation): 'DSolve[eqn_, y_, x_]' if eqn.has_form('List', None): # TODO: Try and solve BVPs using Solve or something analagous OR # add this functonality to sympy. evaluation.message('DSolve', 'symsys') return if eqn.get_head_name() != 'System`Equal': evaluation.message('DSolve', 'deqn', eqn) return if x.is_symbol(): syms = [x] elif x.has_form('List', 1, None): syms = sorted(x.get_leaves()) else: return evaluation.message('DSolve', 'dsvar', x) # Fixes pathalogical DSolve[y''[x] == y[x], y, x] try: y.leaves function_form = None func = y except AttributeError: func = Expression(y, *syms) function_form = Expression('List', *syms) if func.is_atom(): evaluation.message('DSolve', 'dsfun', y) return if set(func.leaves) != set(syms): evaluation.message('DSolve', 'deqx') return f_name = func.get_head_name() conversion_args = {'converted_functions': set([f_name])} sym_func = func.to_sympy(**conversion_args) sym_eq = eqn.to_sympy(**conversion_args) # XXX when sympy adds support for higher-order PDE we will have to # change this to a tuple of solvefuns kwargs = {'solvefun': sympy.Function(str('C1'))} try: if len(syms) > 1: sym_result = sympy.pdsolve(sym_eq, sym_func, **kwargs) else: sym_result = sympy.dsolve(sym_eq, sym_func) except ValueError: evaluation.message('DSolve', 'symimp') return except NotImplementedError: evaluation.message('DSolve', 'symimp') return except TypeError: # Sympy bug #9446 evaluation.message('DSolve', 'litarg', eqn) return except AttributeError: evaluation.message('DSolve', 'litarg', eqn) return except KeyError: evaluation.message('DSolve', 'litarg', eqn) return else: if not isinstance(sym_result, list): sym_result = [sym_result] if function_form is None: return Expression( 'List', *[ Expression('List', Expression('Rule', *from_sympy(soln).leaves)) for soln in sym_result ]) else: return Expression( 'List', *[ Expression( 'List', Expression( 'Rule', y, Expression('Function', function_form, *from_sympy(soln).leaves[1:]))) for soln in sym_result ])
def apply(self, eqn, y, x, evaluation): 'DSolve[eqn_, y_, x_]' if eqn.has_form('List', None): # TODO: Try and solve BVPs using Solve or something analagous OR # add this functonality to sympy. evaluation.message('DSolve', 'symsys') return if eqn.get_head_name() != 'System`Equal': evaluation.message('DSolve', 'deqn', eqn) return if x.is_symbol(): syms = [x] elif x.has_form('List', 1, None): syms = x.get_leaves() else: return evaluation.message('DSolve', 'dsvar', x) # Fixes pathalogical DSolve[y''[x] == y[x], y, x] try: y.leaves function_form = None func = y except AttributeError: func = Expression(y, *syms) function_form = Expression('List', *syms) if func.is_atom(): evaluation.message('DSolve', 'dsfun', y) return if set(func.leaves) != set(syms): evaluation.message('DSolve', 'deqx') return # Workaround sympy bug #11669. # https://github.com/sympy/sympy/issues/11669https://github.com/sympy/sympy/issues/11669 f_name = func.get_head_name() if six.PY2: try: f_name = str(f_name) except UnicodeEncodeError: return evaluation.message('DSolve', 'sym11669', func.get_head_name()) conversion_args = {'converted_functions': set([f_name])} sym_func = func.to_sympy(**conversion_args) sym_eq = eqn.to_sympy(**conversion_args) # XXX when sympy adds support for higher-order PDE we will have to # change this to a tuple of solvefuns kwargs = {'solvefun': sympy.Function(str('C1'))} try: if len(syms) > 1: sym_result = sympy.pdsolve(sym_eq, sym_func, **kwargs) else: sym_result = sympy.dsolve(sym_eq, sym_func) except ValueError: evaluation.message('DSolve', 'symimp') return except NotImplementedError: evaluation.message('DSolve', 'symimp') return except TypeError: # Sympy bug #9446 evaluation.message('DSolve', 'litarg', eqn) return except AttributeError: evaluation.message('DSolve', 'litarg', eqn) return except KeyError: evaluation.message('DSolve', 'litarg', eqn) return else: if not isinstance(sym_result, list): sym_result = [sym_result] if function_form is None: return Expression('List', *[ Expression( 'List', Expression('Rule', *from_sympy(soln).leaves)) for soln in sym_result]) else: return Expression('List', *[ Expression('List', Expression('Rule', y, Expression( 'Function', function_form, *from_sympy(soln).leaves[1:]))) for soln in sym_result])