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