def main():
print 'Initial metric:'
pprint(gdd)
print '-'*40
print 'Christoffel symbols:'
for i in [0,1,2,3]:
for k in [0,1,2,3]:
for l in [0,1,2,3]:
if Gamma.udd(i,k,l) != 0 :
pprint_Gamma_udd(i,k,l)
print'-'*40
print'Ricci tensor:'
for i in [0,1,2,3]:
for j in [0,1,2,3]:
if Rmn.dd(i,j) !=0:
pprint_Rmn_dd(i,j)
print '-'*40
#Solving EFE for A and B
s = ( Rmn.dd(1,1)/ A(r) ) + ( Rmn.dd(0,0)/ B(r) )
pprint (s)
t = dsolve(s, A(r))
pprint(t)
metric = gdd.subs(A(r), t)
print "metric:"
pprint(metric)
r22 = Rmn.dd(3,3).subs( A(r), 1/B(r))
h = dsolve( r22, B(r) )
pprint(h)
def test_ode10():
f = Function("f")
#type:2nd order, constant coefficients (two real different roots)
eq = Eq(f(x).diff(x,x) - 3*diff(f(x),x) + 2*f(x), 0)
assert dsolve(eq, f(x)) in [
Symbol("C1")*exp(2*x) + Symbol("C2")*exp(x),
Symbol("C1")*exp(x) + Symbol("C2")*exp(2*x),
]
checksol(eq, f(x), dsolve(eq, f(x)))
def edo_main():
# const = [0]*6 #a0, a1, a2, a3, a4, a5 ; nessa ordem
print "Valores", const
##Criando uma variavel para guardar valores digitados anteriormente,este só vai calcular as coisas novamente se
# e somente se parâmetros de entrada diferentes forem colocados
constAnterior = const
# a5, a4, a3, a2, a1, a0, xT = input_coefs()
###Dif equation solver
##Sets if it is of homogenous or inhomogenous type and type of resolution method
if Respostas[7] == 0:
solvedEq = dsolve(sympify(Respostas[8]), y(t), hint="nth_linear_constant_coeff_homogeneous")
# elif (a3 != 0) or (a4 != 0) or (a5 != 0):
# solvedEq = dsolve(sympify(eq),y(t),hint='nth_linear_constant_coeff_variation_of_parameters')
else:
solvedEq = dsolve(sympify(Respostas[8]), y(t), hint="nth_linear_constant_coeff_undetermined_coefficients")
##Transformação do tipo sympy_unity para o sympy_mul (mais operações permitidas)
sepEq = solvedEq._args[1]
sepEq = sepEq.evalf(prec)
if const[5] != 0:
RespPart = sepEq.subs([(C1, 0), (C2, 0), (C3, 0), (C4, 0), (C5, 0)])
elif const[4] != 0:
RespPart = sepEq.subs([(C1, 0), (C2, 0), (C3, 0), (C4, 0)])
elif const[3] != 0:
RespPart = sepEq.subs([(C1, 0), (C2, 0), (C3, 0)])
elif const[2] != 0:
RespPart = sepEq.subs([(C1, 0), (C2, 0)])
elif const[1] != 0:
RespPart = sepEq.subs(C1, 0)
##Resposta transitória alocada em RespTran, natural em RespNat
Respostas[3] = RespPart.evalf(prec)
formaNatural = sepEq.subs(RespPart, 0)
Respostas[1] = formaNatural # Adicionando Forma natural de resposta na lista de respostas
## fN é a mesma coisa, mas usado por um bug bizarro do Sympy que exige uma variável sem alocações prévias quando diferenciando
##isso é válido no método conds_iniciais_aplicadas
fN = formaNatural
rP = RespPart.evalf(prec)
raizes()
conds_iniciais_aplicadas(fN, rP)
respForc = Respostas[4] + Respostas[3] # Yf = Yt + Yp
Respostas[5] = respForc.evalf(prec) # Adiciona Resposta Forcada a lista de respostas
respComp = Respostas[2] # Resposta completa p/ eqs. homogeneas
if Respostas[7] != 0: # Eqs. nao homogeneas
respComp = Respostas[2] + Respostas[5] # Respsota completa p/ eqs. nao-homogeneas
Respostas[6] = respComp.evalf(prec) # Adiciona Resposta Completa a lista de respostas
print "Respostas em ODE_main", Respostas
def main():
x = Symbol("x")
f = Function("f")
eq = Eq(f(x).diff(x), f(x))
print "Solution for ", eq, " : ", dsolve(eq, f(x))
eq = Eq(f(x).diff(x, 2), -f(x))
print "Solution for ", eq, " : ", dsolve(eq, f(x))
eq = Eq(x ** 2 * f(x).diff(x), -3 * x * f(x) + sin(x) / x)
print "Solution for ", eq, " : ", dsolve(eq, f(x))
def separable_equation(g, h, hf = None):
"""
dy/dx = g(x)*h(y)
dy/h(y) = g(x)*dx
"""
dy, dx = symbols('dy, dx')
print '\nODE to solve:'
pprint(Eq(dy/dx, g*h))
pprint(Eq(dy/h, g*dx))
print '\nintegrate both sides:'
LHS, RHS = symbols('LHS, RHS')
pprint(Eq(LHS, Integral(1/h,y)))
H = integrate(1/h,y)
pprint(Eq(LHS, H))
pprint(Eq(RHS,Integral(g,x)))
G = integrate(g, x)
pprint(Eq(RHS, G))
C = symbols('C')
print '\nsolving LHS = RHS + C...'
eq = Eq(H,G+C)
pprint(eq)
pprint(solve(eq, y))
if hf:
print '\nsolving ODE directly ...'
pprint(dsolve(f(x).diff(x)-g*hf, f(x)))
def symbolic_solve():
"""
Solves the problem symbolically using sympy
"""
f = Function('f')
sol = dsolve(2 * Derivative(f(x), x, x) - 1, f(x))
print sol
def __call__(self, equations, variables=None):
if variables is None:
variables = {}
if equations.is_stochastic:
raise ValueError('Cannot solve stochastic equations with this state updater')
diff_eqs = equations.substituted_expressions
t = Symbol('t', real=True, positive=True)
dt = Symbol('dt', real=True, positive=True)
t0 = Symbol('t0', real=True, positive=True)
f0 = Symbol('f0', real=True)
# TODO: Shortcut for simple linear equations? Is all this effort really
# worth it?
code = []
for name, expression in diff_eqs:
rhs = expression.sympy_expr
non_constant = _non_constant_symbols(rhs.atoms(),
variables) - set([name])
if len(non_constant):
raise ValueError(('Equation for %s referred to non-constant '
'variables %s') % (name, str(non_constant)))
# We have to be careful and use the real=True assumption as well,
# otherwise sympy doesn't consider the symbol a match to the content
# of the equation
var = Symbol(name, real=True)
f = sp.Function(name)
rhs = rhs.subs(var, f(t))
derivative = sp.Derivative(f(t), t)
diff_eq = sp.Eq(derivative, rhs)
general_solution = sp.dsolve(diff_eq, f(t))
# Check whether this is an explicit solution
if not getattr(general_solution, 'lhs', None) == f(t):
raise ValueError('Cannot explicitly solve: ' + str(diff_eq))
# Solve for C1 (assuming "var" as the initial value and "t0" as time)
if Symbol('C1') in general_solution:
if Symbol('C2') in general_solution:
raise ValueError('Too many constants in solution: %s' % str(general_solution))
constant_solution = sp.solve(general_solution, Symbol('C1'))
if len(constant_solution) != 1:
raise ValueError(("Couldn't solve for the constant "
"C1 in : %s ") % str(general_solution))
constant = constant_solution[0].subs(t, t0).subs(f(t0), var)
solution = general_solution.rhs.subs('C1', constant)
else:
solution = general_solution.rhs.subs(t, t0).subs(f(t0), var)
# Evaluate the expression for one timestep
solution = solution.subs(t, t + dt).subs(t0, t)
# only try symplifying it -- it sometimes raises an error
try:
solution = solution.simplify()
except ValueError:
pass
code.append(name + ' = ' + sympy_to_str(solution))
return '\n'.join(code)
def non_homo_linear(rhs, *cds):
char_func, eq, rs = homo_linear(*cds)
print('\nnon-homogeneous ODE:')
pprint(Eq(eq, rhs))
eq -= rhs
print('\nsolving non-homogeneous linear equation...\nresult:')
rs = dsolve(eq)
pprint(rs)
return char_func, eq, rs
def test_make_ode_01():
ode, params = _make_ode_01()
t, y, y0, k = params
result = dsolve(ode, y[1](t))
eq_assumption = sympy.Q.is_true(Eq(k[1], k[0]))
refined = result.refine(~eq_assumption)
ignore = k + y0 + (t,)
int_const = [fs for fs in refined.free_symbols if fs not in ignore][0]
ref = int_const*exp(-k[1]*t) - exp(-k[0]*t)*k[0]*y0[0]/(k[0] - k[1])
assert (refined.rhs - ref).simplify() == 0
def codegen(expr, lang, indent=' ', ics=None):
if lang == 'C':
code = ccode
elif lang == 'Fortran':
code = fcode
else:
raise ValueError("Lang must be 'C' or 'Fortran'")
try:
sol = dsolve(expr, ics=ics)
except ValueError:
# Not an ODE
return code(expr)
return ccode(sol.rhs, assign_to=sol.lhs.func.__name__)
def solve_model(self, ics, d_ics):
model_soln = [dsolve(eq) for eq in self.model]
def solve_constants(eq, ics, d_ics):
udiff = Eq(d_ics[0][1], eq.rhs.diff(t))
system = [eq.subs(ics), udiff.subs(t, 0)]
consts = solve(system, [C1, C2])
return eq.subs(consts)
model_soln_f = [solve_constants(eq[1], ics[eq[0]], d_ics[eq[0]])
for eq in enumerate(model_soln[:len(ics)])]
self.model_response = model_soln_f
self.x = lambdify(t, model_soln_f[0].rhs, 'numpy')
self.y = lambdify(t, model_soln_f[1].rhs, 'numpy')
def solveSystem(L,coordinates,initialConditions):
"""
This is currently not in use; I'm not sure it ever will be used.
L is a sympy expression for the Lagrangian.
coordinates is a list of tuples, like so:
[(x,xdot),(y,ydot)]
initialConditions are a list of the above form.
"""
(eulerLagrange,coordinates_t,t)=calcEL(L, coordinates)
for (i,(EL_i,coordinates_t_i)) in\
enumerate(zip(eulerLagrange,coordinates_t)):
eqn=sp.dsolve(EL_i,coordinates_t_i(t))
freeVars=filter(lambda x:x!=t,eqn.atoms())
newFreeVars=[sp.Symbol(str(freeVar)+"_%i"%i)
for freeVar in freeVars]
def homo_linear(*cds):
char_func = 0
eq = 0
for cd in cds:
try:
c, d = cd
except TypeError:
c, d = 1, cd
char_func += c * y**d
eq += c * f(x).diff(x, d)
print('\nhomogeneous ODE:')
pprint(Eq(eq, 0))
print('\nhomogeneous characteristic function:')
pprint(char_func)
print('\nsolving characteristic function...\nresult:')
pprint(solve(char_func))
print('\nsolving homogeneous linear equation...\nresult:')
rs = dsolve(eq)
pprint(rs)
return char_func, eq, rs
def main():
print("Initial metric:")
pprint(gdd)
print("-"*40)
print("Christoffel symbols:")
pprint_Gamma_udd(0, 1, 0)
pprint_Gamma_udd(0, 0, 1)
print()
pprint_Gamma_udd(1, 0, 0)
pprint_Gamma_udd(1, 1, 1)
pprint_Gamma_udd(1, 2, 2)
pprint_Gamma_udd(1, 3, 3)
print()
pprint_Gamma_udd(2, 2, 1)
pprint_Gamma_udd(2, 1, 2)
pprint_Gamma_udd(2, 3, 3)
print()
pprint_Gamma_udd(3, 2, 3)
pprint_Gamma_udd(3, 3, 2)
pprint_Gamma_udd(3, 1, 3)
pprint_Gamma_udd(3, 3, 1)
print("-"*40)
print("Ricci tensor:")
pprint_Rmn_dd(0, 0)
e = Rmn.dd(1, 1)
pprint_Rmn_dd(1, 1)
pprint_Rmn_dd(2, 2)
pprint_Rmn_dd(3, 3)
# print()
# print "scalar curvature:"
# print curvature(Rmn)
print("-"*40)
print("Solve Einstein's equations:")
e = e.subs(nu(r), -lam(r)).doit()
l = dsolve(e, lam(r))
pprint(l)
lamsol = solve(l, lam(r))[0]
metric = gdd.subs(lam(r), lamsol).subs(nu(r), -lamsol) # .combine()
print("metric:")
pprint(metric)
def process(self):
"""
Procesamos la ecuacion y obtenemos los resultados
"""
# Guardamos expresion
expr = ""
# Obtenemos los symbolos
x = sp.Symbol("x")
y = sp.Function("y")
# Obtenemos la expresion
ec = sp.sympify(self.ec)
# Valor inicial (PVI)
pvi = { y(self.x): self.y }
# preparamos la EDO
edo = sp.Eq(y(x).diff(x), ec)
expr += "EDO:\n\t"+str(edo)
# Despejamos Y
res = sp.dsolve(y(x).diff(x) - ec)
# Obtenemos y(x) = f(x)
expr += "\nEDO resuelta:\n\t"+str(res)
# reemplazamos PVI
c_eq = sp.Eq(res.lhs.subs(x, 0).subs(pvi), res.rhs.subs(x, 0))
expr += "\nRemplazamos PVI:\n\t"+str(c_eq)
# Obtenemos el valor de la constante
c = sp.solve(c_eq)
expr += "\nValor de C1:\n\t"+str(c[0])
# almacenamos los valores de interes
self.c = c[0] # valor de C1
self.res = res # ecuacion resuelta
# retornamos el resultado
return expr
def main():
print "Initial metric:"
pprint(gdd)
print "-"*40
print "Christoffel symbols:"
pprint_Gamma_udd(0,1,0)
pprint_Gamma_udd(0,0,1)
print
pprint_Gamma_udd(1,0,0)
pprint_Gamma_udd(1,1,1)
pprint_Gamma_udd(1,2,2)
pprint_Gamma_udd(1,3,3)
print
pprint_Gamma_udd(2,2,1)
pprint_Gamma_udd(2,1,2)
pprint_Gamma_udd(2,3,3)
print
pprint_Gamma_udd(3,2,3)
pprint_Gamma_udd(3,3,2)
pprint_Gamma_udd(3,1,3)
pprint_Gamma_udd(3,3,1)
print"-"*40
print"Ricci tensor:"
pprint_Rmn_dd(0,0)
e = Rmn.dd(1,1)
pprint_Rmn_dd(1,1)
pprint_Rmn_dd(2,2)
pprint_Rmn_dd(3,3)
#print
#print "scalar curvature:"
#print curvature(Rmn)
print "-"*40
print "solve the Einstein's equations:"
e = e.subs(nu(r), -lam(r))
l = dsolve(e, [lam(r)])
pprint( Eq(lam(r), l) )
metric = gdd.subs(lam(r), l).subs(nu(r),-l)#.combine()
print "metric:"
pprint( metric )
def main():
#print g
print "-"*40
print "Christoffel symbols:"
print Gamma.udd(0,1,0)
print Gamma.udd(0,0,1)
print
print Gamma.udd(1,0,0)
print Gamma.udd(1,1,1)
print Gamma.udd(1,2,2)
print Gamma.udd(1,3,3)
print
print Gamma.udd(2,2,1)
print Gamma.udd(2,1,2)
print Gamma.udd(2,3,3)
print
print Gamma.udd(3,2,3)
print Gamma.udd(3,3,2)
print Gamma.udd(3,1,3)
print Gamma.udd(3,3,1)
print "-"*40
print "Ricci tensor:"
print Rmn.dd(0,0)
e = Rmn.dd(1,1)
print e
print Rmn.dd(2,2)
print Rmn.dd(3,3)
#print
#print "scalar curvature:"
#print curvature(Rmn)
print "-"*40
print "solve the Einstein's equations:"
e = e.subs(nu(r), -lam(r))
l = dsolve(e, [lam(r)])
print lam(r)," = ",l
metric = gdd.subs(lam(r), l).subs(nu(r),-l)#.combine()
print "metric:"
print metric
def derive_true_solution():
import sympy as sym
u = sym.symbols('u', cls=sym.Function) # function u(t)
t, a, p, I = sym.symbols('t a p I', real=True)
def ode(u, t, a, p):
"""Define ODE: u' = (a + p*t)*u. Return residual."""
return sym.diff(u, t) + (a + p*t)*u
eq = ode(u(t), t, a, p)
s = sym.dsolve(eq)
# s is sym.Eq object u(t) == expression, we want u = expression,
# so grab the right-hand side of the equality (Eq obj.)
u = s.rhs
print u
# u contains C1, replace it with a symbol we can fit to
# the initial condition
C1 = sym.symbols('C1', real=True)
u = u.subs('C1', C1)
print u
# Initial condition equation
eq = u.subs(t, 0) - I
s = sym.solve(eq, C1) # solve eq wrt C1
print s
# s is a list s[0] = ...
# Replace C1 in u by the solution
u = u.subs(C1, s[0])
print 'u:', u
print sym.latex(u) # latex formula for reports
# Consistency check: u must fulfill ODE and initial condition
print 'ODE is fulfilled:', sym.simplify(ode(u, t, a, p))
print 'u(0)-I:', sym.simplify(u.subs(t, 0) - I)
# Convert u expression to Python numerical function
# (modules='numpy' allows numpy arrays as arguments,
# we want this for t)
u_func = sym.lambdify([t, I, a, p], u, modules='numpy')
return u_func
def __call__(self, equations, variables=None, method_options=None):
logger.warn("The 'independent' state updater is deprecated and might be "
"removed in future versions of Brian.",
'deprecated_independent', once=True)
method_options = extract_method_options(method_options, {})
if equations.is_stochastic:
raise UnsupportedEquationsException('Cannot solve stochastic '
'equations with this state '
'updater')
if variables is None:
variables = {}
diff_eqs = equations.get_substituted_expressions(variables)
t = Symbol('t', real=True, positive=True)
dt = Symbol('dt', real=True, positive=True)
t0 = Symbol('t0', real=True, positive=True)
code = []
for name, expression in diff_eqs:
rhs = str_to_sympy(expression.code, variables)
# We have to be careful and use the real=True assumption as well,
# otherwise sympy doesn't consider the symbol a match to the content
# of the equation
var = Symbol(name, real=True)
f = sp.Function(name)
rhs = rhs.subs(var, f(t))
derivative = sp.Derivative(f(t), t)
diff_eq = sp.Eq(derivative, rhs)
# TODO: simplify=True sometimes fails with 0.7.4, see:
# https://github.com/sympy/sympy/issues/2666
try:
general_solution = sp.dsolve(diff_eq, f(t), simplify=True)
except RuntimeError:
general_solution = sp.dsolve(diff_eq, f(t), simplify=False)
# Check whether this is an explicit solution
if not getattr(general_solution, 'lhs', None) == f(t):
raise UnsupportedEquationsException('Cannot explicitly solve: '
+ str(diff_eq))
# Solve for C1 (assuming "var" as the initial value and "t0" as time)
if general_solution.has(Symbol('C1')):
if general_solution.has(Symbol('C2')):
raise UnsupportedEquationsException('Too many constants in solution: %s' % str(general_solution))
constant_solution = sp.solve(general_solution, Symbol('C1'))
if len(constant_solution) != 1:
raise UnsupportedEquationsException(("Couldn't solve for the constant "
"C1 in : %s ") % str(general_solution))
constant = constant_solution[0].subs(t, t0).subs(f(t0), var)
solution = general_solution.rhs.subs('C1', constant)
else:
solution = general_solution.rhs.subs(t, t0).subs(f(t0), var)
# Evaluate the expression for one timestep
solution = solution.subs(t, t + dt).subs(t0, t)
# only try symplifying it -- it sometimes raises an error
try:
solution = solution.simplify()
except ValueError:
pass
code.append(name + ' = ' + sympy_to_str(solution))
return '\n'.join(code)
def eq2():
r = Symbol("r")
e = relativity.Rmn.dd(1,1)
C = Symbol("CC")
e = e.subs(relativity.nu(r), -relativity.lam(r))
print dsolve(e, [relativity.lam(r)])
def apply(self, eqn, y, x, evaluation):
"DSolve[eqn_, y_, x_]"
if eqn.has_form("List", eqn):
# 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() != "Equal":
evaluation.message("DSolve", "deqn", eqn)
return
if (
(x.is_atom() and not x.is_symbol())
or x.get_head_name() in ("Plus", "Times", "Power") # nopep8
or "Constant" in x.get_attributes(evaluation.definitions)
):
evaluation.message("DSolve", "dsvar")
return
# Fixes pathalogical DSolve[y''[x] == y[x], y, x]
try:
y.leaves
function_form = None
func = y
except AttributeError:
func = Expression(y, x)
function_form = Expression("List", x)
if func.is_atom():
evaluation.message("DSolve", "dsfun", y)
return
if len(func.leaves) != 1:
evaluation.message("DSolve", "symmua")
return
if x not in func.leaves:
evaluation.message("DSolve", "deqx")
return
left, right = eqn.leaves
eqn = Expression("Plus", left, Expression("Times", -1, right)).evaluate(evaluation)
sym_eq = eqn.to_sympy(converted_functions=set([func.get_head_name()]))
sym_x = sympy.symbols(str(sympy_symbol_prefix + x.name))
sym_func = sympy.Function(str(sympy_symbol_prefix + func.get_head_name()))(sym_x)
try:
sym_result = sympy.dsolve(sym_eq, sym_func)
if not isinstance(sym_result, list):
sym_result = [sym_result]
except ValueError:
evaluation.message("DSolve", "symimp")
return
except NotImplementedError:
evaluation.message("DSolve", "symimp")
return
except AttributeError:
evaluation.message("DSolve", "litarg", eqn)
return
except KeyError:
evaluation.message("DSolve", "litarg", eqn)
return
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 test_ode12():
f = Function("f")
#type:2nd order, constant coefficients (two complex roots)
eq = Eq(f(x).diff(x,x)+2*diff(f(x),x)+3*f(x), 0)
assert dsolve(eq, f(x)) == (Symbol("C1")*sin(x*sqrt(2))+Symbol("C2")*cos(x*sqrt(2)))*exp(-x)
checksol(eq, f(x), dsolve(eq, f(x)))
def apply(self, eqn, y, x, evaluation):
'DSolve[eqn_, y_, x_]'
if eqn.has_form('List', eqn):
# 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
# FIXME: This code is duplicated in calculus.py
if ((x.is_atom() and not x.is_symbol()) or # nopep8
x.get_head_name() in ('System`Plus', 'System`Times',
'System`Power') or
'System`Constant' in x.get_attributes(evaluation.definitions)):
evaluation.message('DSolve', 'dsvar')
return
# Fixes pathalogical DSolve[y''[x] == y[x], y, x]
try:
y.leaves
function_form = None
func = y
except AttributeError:
func = Expression(y, x)
function_form = Expression('List', x)
if func.is_atom():
evaluation.message('DSolve', 'dsfun', y)
return
if len(func.leaves) != 1:
evaluation.message('DSolve', 'symmua')
return
if x not in func.leaves:
evaluation.message('DSolve', 'deqx')
return
left, right = eqn.leaves
eqn = Expression('Plus', left, Expression(
'Times', -1, right)).evaluate(evaluation)
sym_eq = eqn.to_sympy(converted_functions=set([func.get_head_name()]))
sym_x = sympy.symbols(str(sympy_symbol_prefix + x.name))
sym_func = sympy.Function(str(
sympy_symbol_prefix + func.get_head_name()))(sym_x)
try:
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])
# existance theorem
import sympy
from sympy.abc import t
from sympy import Function, Derivative, dsolve, Eq, solve
y = Function('y')
formula = 1 + y(t)**2
solutions = dsolve(Eq(Derivative(y(t), t), formula))
print solutions
solution = solutions.args[1].subs(
'C1',
solve(Eq(solutions.args[1].subs(t, 0), 0))[0])
# uniqueness of solution
tdomain = np.linspace(-7, 7, 30)
formula = sympy.root(y(t), 3) * sympy.sin(2 * t)
solution1 = 0
solution2 = (8.0 / 27)**0.5 * (sympy.sin(t))**3
solution3 = -1 * (8.0 / 27)**0.5 * (sympy.sin(t))**3
plt.plot(tdomain, [0 for i in tdomain], 'blue', \
tdomain, np.array([solution2.subs(t, tval) for tval in tdomain]), 'black',\
tdomain, np.array([solution3.subs(t, tval) for tval in tdomain]), 'red')
from sympy import Symbol, Function, dsolve, diff, sqrt, pi
x = Symbol("x")
k = Symbol("k")
f = Function("f")
#print(f(x).diff(x,x)+f(x))
#print(dsolve(f(x).diff(x,x)+f(x),f(x)))
print(dsolve(f(x).diff(x) - 2 * sqrt(pi) * k * sqrt(f(x)), f(x)))
import sympy as sp
sp.init_printing()
x = sp.Function('x')
t = sp.Symbol('t')
w0 = sp.Symbol('w0', real=True, positive=True)
deq = sp.Eq(x(t).diff(t, t), -w0**2 * x(t))
solution = sp.dsolve(deq)
C0, C1, C2, C3 = sp.symbols('C0 C1 C2 C3')
print(sp.solve(solution, C1))
print(solution.subs(t, 0))
x = solution.rhs
print(x)
print(sp.solve(sp.Eq(x.diff(t).subs(t, 0), 1), C1))
import sympy as sp
import numpy as np
import matplotlib.pylab as plt
sp.init_printing()
x = sp.Function('x')
t = sp.Symbol('t')
w0 = sp.Symbol('w0', real=True, positive=True)
C0, C1, C2, C3 = sp.symbols('C0 C1 C2 C3')
x1 = sp.Function('x1')
x2 = sp.Function('x2')
eq1 = sp.Eq(x1(t).diff(t, t), -x1(t) + 2 * (x2(t) - x1(t)))
eq2 = sp.Eq(x2(t).diff(t, t), -x2(t) + 2 * (x1(t) - x2(t)))
s = sp.dsolve([eq1, eq2])
x1 = s[0].rhs
x2 = s[1].rhs
print(x1)
print(x2)
ic1 = sp.Eq(x1.subs(t, 0), 0)
ic2 = sp.Eq(x1.diff(t).subs(t, 0), 0)
ic3 = sp.Eq(x2.subs(t, 0), 1)
ic4 = sp.Eq(x2.diff(t).subs(t, 0), 0)
C = sp.Symbol('C')
C = sp.solve([ic1, ic2, ic3, ic4])
print(C)
x1c = x1.subs(C)
x1c = x1c.simplify()
import numpy as np
import matplotlib.pyplot as plt
from sympy.plotting import plot3d
from sympy.plotting import plot_parametric
from mpl_toolkits.mplot3d import Axes3D
import pickle
sy.init_printing(use_unicode=False)
sigma, t = sy.symbols('sigma t', real=True)
x, y = sy.symbols('x y', function=True)
M = sy.Matrix([[sigma + 1, 3], [-2, sigma - 1]])
eq = [
sy.Eq(sy.Derivative(x(t), t), (sigma + 1) * x(t) + 3 * y(t)),
sy.Eq(sy.Derivative(y(t), t), -2 * x(t) + (sigma - 1) * y(t))
]
solutions = sy.dsolve(eq)
C1, C2, omega = sy.symbols('C1 C2 omega')
initialConditions = [z.subs(t, 0) for z in solutions]
solutionsForC1C2 = sy.solve(initialConditions)
#For a)
newSolutions = [
z.subs([(C1, solutionsForC1C2[C1]), (C2, solutionsForC1C2[C2])])
for z in solutions
]
#b)
func = [sy.lambdify((t, sigma, x(0), y(0)), z.rhs) for z in newSolutions]
tspace = np.linspace(-2, 9, 1000)
# Example 4.4
# Linearization
from pylab import *
# Clean up
clf()
# Obtain true solution using sympy if available
try:
from sympy import dsolve, Derivative, symbols
y, t = symbols("y t", function=True)
y = dsolve(Derivative(y(t), t) + y(t) * (1 - y(t)), 0, ics={y(0): .5}).rhs
print("y(t) =", y)
true_solution = y.evalf(subs={t: 1.})
except ImportError:
# suppy the true soln
true_solution = 1. / (exp(1.) + 1.)
# Setup schemes
# Linearized Trapeziodal method
lin_trap = lambda y, h: y + h * y * (y - 1.) / (1. - h * (y - 1. / 2.))
full_trap = lambda y, h: (2. / h + 1. - sqrt((2. / h + 1.)**2 - 4. *
(2. / h * y + y * (y - 1.)))) / 2.
# Collect Data
H = logspace(0., 2.7, 10).round()
STEPS = zeros(len(H))
LIN_ERR = zeros(len(H))
FULL_ERR = zeros(len(H))
for i in range(len(H)):
N = H[i]
from IPython.display import display
import sympy
from sympy import Function, dsolve, Symbol
# symbols
t = Symbol('t', positive=True)
omegan = Symbol('\omega_n', positive=True)
zeta = Symbol('\zeta')
f0 = Symbol('f_0', positive=True)
wf = Symbol('\omega_f', positive=True)
u0 = Symbol('u_0', constant=True)
v0 = Symbol('v_0', constant=True)
# unknown function
u = Function('u')(t)
# solving ODE
f = f0*sympy.cos(wf*t)
ics = {u.subs(t, 0): u0,
u.diff(t).subs(t, 0): v0,
}
sol = dsolve(u.diff(t, t) + 2*zeta*omegan*u.diff(t) + omegan**2*u - f, ics=ics)
# sol.lhs ==> u(t)
# sol.rhs ==> solution
display(sol.rhs.simplify())
import sympy as sy
""" 例 1：f(x)' - x^2 = 0 """
def diff_eq(x, f):
return sy.diff(f(x), x, 1) - x**2
x = sy.symbols('x') # 约定变量
f = sy.Function('f') # 约定函数
sy.pprint(sy.dsolve(diff_eq(x, f), f(x))) # 输出 f(x)
""" 例 2：f(x)''+ f(x)=0 """
def diff_eq(x, f):
return sy.diff(f(x), x, 2) + f(x)
x = sy.symbols('x') # 约定变量
f = sy.Function('f') # 约定函数
sy.pprint(sy.dsolve(diff_eq(x, f), f(x))) # 输出 f(x)
""" 例 3：f(x)^(4) + 3*f(x)" - x^3 = 0 """
def diff_eq(x, f):
return sy.diff(f(x), x, 4) + 3 * sy.diff(f(x), x, 2) - x**3
x = sy.symbols('x') # 约定变量
f = sy.Function('f') # 约定函数
sy.pprint(sy.dsolve(diff_eq(x, f), f(x))) # 输出 f(x)
#TYPE 2
from sympy import Function, diff, solve, dsolve,pprint
from sympy.abc import x, y, u, p, q, a, b
z = Function("z")(u)
eqn=p*(1-q**2)-q*(1-z) #change for other questions
eqn1=eqn.subs(p,diff(z,u)).subs(q,a*diff(z,u))
print(eqn1)
h1=solve(eqn1,diff(z,u))
print(h1)
sol=dsolve(h1[0]-diff(z,u))
pprint(sol)
ans=sol.subs(u,x+a*y)
print("18MEC24006-DENNY JOHNSON P")
print("Required answer is")
print(ans)
# -*- coding:utf-8 -*-
import sympy as sm
t = sm.symbols('t')
x = sm.Function('x')
w = sm.Symbol('w', positive=True)
eq = sm.Eq(sm.diff(x(t), t, t) + w**2 * x(t), 0)
print("дифференциальное уравнение : ")
print(eq)
sol = sm.dsolve(eq)
print("решение дифференциальное уравниение ")
print sol
x = sol.rhs
print("решение дифференциальное уравниение (только направо) ")
print x
df_2 = sm.diff(x, t, t)
print df_2
# для проверка
print(sm.diff(x, t, t) + w**2 * x == 0)
y = Function("y")
if xT == 0:
temp_xT = t
##Adicionando os coefs a eq diferencial
eq = sympify(a2 * y(t).diff(t, 2) + a1 * y(t).diff(t) + a0 * y(t) - temp_xT)
else:
##Adicionando os coefs a eq diferencial
eq = sympify(a2 * y(t).diff(t, 2) + a1 * y(t).diff(t) + a0 * y(t) - xT)
# pprint(eq)
# print ""
###Dif equation solver
solvedEq = dsolve(sympify(eq), y(t), hint="nth_linear_constant_coeff_undetermined_coefficients")
##Transformação do tipo sympy_unity para o sympy_mul (mais operações permitidas)
sepEq = solvedEq._args[1]
# print "sepEq =", sepEq
##PRocesso de separação de resp natural e resposta transitória
elementosEq = sepEq.atoms(Symbol)
C1 = elementosEq.pop()
C2 = elementosEq.pop()
if C2 != t:
ordem_1 = False
# print "Tem c2"
RespPart = sepEq.subs([(C2, 0), (C1, 0)])
import sympy
from sympy import Function, dsolve, Symbol
# symbols
t = Symbol('t', positive=True)
m = Symbol('m', positive=True)
k = Symbol('k', positive=True)
# unknown function
u = Function('u')(t)
# solving ODE
sol = dsolve(m * u.diff(t, t) + k * u)
# sol.lhs ==> u(t)
# sol.rhs ==> solution
print(sol.rhs)
wn = sympy.Symbol('wn')
expr = sol.rhs.subs(sympy.sqrt(k / m), wn)
print(expr)
Created on Sun Jul 21 01:08:44 2019
@author: nina
"""
from IPython.display import display
import sympy
from sympy import Function, sqrt, dsolve, Eq, Derivative
from sympy import solve, Poly, Eq, Function, exp
from sympy import Indexed, IndexedBase, Tuple, sqrt
t = sympy.Symbol('t')
d = 0
o = 0.5
ro00 = Function('ro00')(t)
ro01 = Function('ro01')(t)
ro10 = Function('ro10')(t)
ro11 = Function('ro11')(t)
I = sympy.Symbol('I')
eq1 = Eq(Derivative(ro00, t), ro11 - I * (o * ro01 / 2 - o * ro10 / 2))
eq2 = Eq(Derivative(ro01, t),
-ro01 - I * (-d * ro01 + o * ro00 / 2 - o * ro11 / 2))
eq3 = Eq(Derivative(ro10, t),
-ro10 - I * (d * ro10 - o * ro00 / 2 + o * ro11 / 2))
eq4 = Eq(Derivative(ro11, t), -ro11 - I * (-o * ro01 / 2 + o * ro10 / 2))
"resenje je sa konstantama C1, C2 i C3"
soln = dsolve((eq1, eq2, eq3, eq4))
display(soln)
print(soln)
import sympy
from sympy import Function, dsolve, Symbol
# symbols
t = Symbol('t', positive=True)
wn = Symbol('\omega_n', positive=True)
zeta = Symbol('\zeta')
f0 = Symbol('f_0', positive=True)
wf = Symbol('\omega_f', positive=True)
u0 = Symbol('u_0', constant=True)
v0 = Symbol('v_0', constant=True)
# unknown function
u = Function('u')(t)
# solving ODE
f = f0 * sympy.cos(wf * t)
ics = {
u.subs(t, 0): u0,
u.diff(t).subs(t, 0): v0,
}
sol = dsolve(u.diff(t, t) + 2 * zeta * wn * u.diff(t) + wn**2 * u - f, ics=ics)
# sol.lhs ==> u(t)
# sol.rhs ==> solution
print(sol.rhs.simplify())
sympy.print_latex(sol.rhs.simplify())
from sympy.abc import t, g, k
from sympy import sqrt, Function, Derivative, dsolve
if __name__ == '__main__':
x, y = map(Function, 'xy')
dx = Derivative(x(t), t)
dy = Derivative(y(t), t)
eq1 = dx+k*x(t)/sqrt(x(t)+y(t))
eq2 = dy+k*y(t)/sqrt(x(t)+y(t))
s = dsolve((eq1, eq2))
print(s)
default=[0.0, 0.0, 0.0],
type="float",
nargs=3)
opt, argc = parser.parse_args(argvs)
print(opt, argc)
R, L, t, V = sym.symbols("R L t V")
i = sym.Function('i')
q = sym.Function('q')
eq1 = sym.Eq(R * i(t) + L * i(t).diff(t, 1), V)
R0 = 100
L0 = 100
V0 = 100000
C0 = 0.01
eq1 = sym.Eq(R0 * i(t) + L0 * i(t).diff(t, 1), V0)
eq2 = sym.Eq(R0 * i(t) + sym.integrate(1 / C0 * i(t), t), V0)
eq3 = sym.Eq(R0 * q(t).diff(t, 1) + 1 / C0 * q(t), V0)
an1 = sym.dsolve(eq1, ics={i(0): 0})
an3 = sym.dsolve(eq3, ics={q(0): 0})
an3_i = (1.0 - 1.0 * sym.exp(-1.0 * t)).diff(t, 1)
#an1_i = (1.0 - 1.0*exp(-1.0*t)).diff(t, 1)
print(t, i(0))
print(an1)
# print(an1.i(0))
#pt = np.linspace(0,10, 100)
#px = sym.lambdify(pt, an1)
sym.plot(an3_i, (t, 0, 10))
def test_ode11():
f = Function("f")
#type:2nd order, constant coefficients (two real equal roots)
eq = Eq(f(x).diff(x,x) - 4*diff(f(x),x) + 4*f(x), 0)
assert dsolve(eq, f(x)) == (Symbol("C1") + Symbol("C2")*x)*exp(2*x)
checksol(eq, f(x), dsolve(eq, f(x)))
from IPython.display import display
import sympy as syp
from sympy import init_printing
from sympy.physics.mechanics import dynamicsymbols
init_printing(use_unicode=True)
# %%
mux3 = dynamicsymbols('\mu_{x_3}')
t, mux1, h, munu = syp.symbols(r"t,\mu_{x_1} h a")
dynamics = munu * mux1 - h * mux3 - syp.diff(mux3, t)
display(dynamics)
# %%
mux3_dyn = syp.dsolve(dynamics, mux3)
display(mux3_dyn)
# %%
nu_diff = syp.diff(mux3_dyn.rhs, munu)
display(nu_diff)
import sympy as sy
def equation(t, i, u1, u2):
return -sy.diff(i(t), t, 1) + u1*i(t) + i(t)*(1 - i(t))*u2
u1 = sy.symbols('u1')
u2 = sy.symbols('u2')
t = sy.symbols('t')
i = sy.Function('i')
res = sy.dsolve(equation(t, i, u1, u2), i(t))
print(res)
print()
print('-'*50)
print()
sy.pprint(res)
def eq2():
r = Symbol("r")
e = Rmn.dd(1, 1)
C = Symbol("CC")
e = e.subs(nu(r), -lam(r))
pprint(dsolve(e, lam(r)))
def apply(self, eqn, y, x, evaluation):
'DSolve[eqn_, y_, x_]'
if eqn.has_form('List', eqn):
#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() != 'Equal':
evaluation.message('DSolve', 'deqn', eqn)
return
if (x.is_atom() and not x.is_symbol()) or \
x.get_head_name() in ('Plus', 'Times', 'Power') or \
'Constant' in x.get_attributes(evaluation.definitions):
evaluation.message('DSolve', 'dsvar')
return
# Fixes pathalogical DSolve[y''[x] == y[x], y, x]
try:
y.leaves
function_form = None
func = y
except AttributeError:
func = Expression(y, x)
function_form = Expression('List', x)
if func.is_atom():
evaluation.message('DSolve', 'dsfun', y)
return
if len(func.leaves) != 1:
evaluation.message('DSolve', 'symmua')
return
if x not in func.leaves:
evaluation.message('DSolve', 'deqx')
return
left, right = eqn.leaves
eqn = Expression('Plus', left, Expression('Times', -1, right)).evaluate(evaluation)
sym_eq = eqn.to_sympy(converted_functions = set([func.get_head_name()]))
sym_x = sympy.symbols(str(sympy_symbol_prefix + x.name))
sym_func = sympy.Function(str(sympy_symbol_prefix + func.get_head_name())) (sym_x)
try:
sym_result = sympy.dsolve(sym_eq, sym_func)
if not isinstance(sym_result, list):
sym_result = [sym_result]
except ValueError as e:
evaluation.message('DSolve', 'symimp')
return
except NotImplementedError as e:
evaluation.message('DSolve', 'symimp')
return
except AttributeError as e:
evaluation.message('DSolve', 'litarg', eqn)
return
except KeyError:
evaluation.message('DSolve', 'litarg', eqn)
return
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 eq4():
r = Symbol("r")
e = Rmn.dd(3, 3)
e = e.subs(nu(r), -lam(r))
pprint(dsolve(e, lam(r)))
pprint(dsolve(e, lam(r), 'best'))
def eq1():
r = Symbol("r")
e = relativity.Rmn.dd(0,0)
e = e.subs(relativity.nu(r), -relativity.lam(r))
print dsolve(e, [relativity.lam(r)])
def main():
plt.grid()
A = x * 3**-x
func = sp.lambdify(x, A)
a_S = 0
b_S = 1.5
eps = 0.0001
n = error_estimation(trapez, func, a_S, b_S, 3, eps)
print('шаг:', (b_S - a_S) / n)
print('метод трапеций:')
t = trapez(func, a_S, b_S, n)
print('n: ', t)
t2 = trapez(func, a_S, b_S, n // 2)
print('n/2:', t2)
print('метод Симпcон:')
n = error_estimation(simpson, func, a_S, b_S, 3, eps)
s = simpson(func, a_S, b_S, n)
print('n: ', s)
s2 = simpson(func, a_S, b_S, n // 2)
print('n/2:', s2)
f = newton_leibniz(A, a_S, b_S)
print('метод Ньютона:', f, '=', f.n(16))
sym = sp.integrate(A, (x, a_S, b_S))
print('точное решение:', sp.simplify(sym), '=', sym.n(16))
print()
diff_A = x*y**2 - y
#diff_A = x * y ** 2 + y
diff_func = sp.lambdify((x, y), diff_A)
diff_a = 0
diff_b = 2
x0 = 0
y0 = 1
nd = de_error(runge, diff_func, diff_a, diff_b, x0, y0, 0.25, 0.0001)
runge_x, runge_y = runge(diff_func, diff_a, diff_b, x0, y0, nd)
runge_x_2, runge_y_2 = runge(diff_func, diff_a, diff_b, x0, y0, nd // 2)
plt.plot(runge_x, runge_y, label='Рунге')
table1 = [['xᵢ', 'yᵢ', 'ỹᵢ', '∆ᵢ = |yᵢ - ỹᵢ|']]
for i in range(len(runge_x)):
if i % 2 == 0:
table1.append([runge_x[i], runge_y[i], runge_y_2[i // 2], abs(runge_y_2[i // 2] - runge_y[i])])
#else:
# table1.append([runge_x[i], runge_y[i], None, None])
print("Метод Рунге:")
#print(tabulate(table1, tablefmt='fancy_grid'))
nd = de_error(runge, diff_func, diff_a, diff_b, x0, y0, 0.5, 0.0001)
adams_x, adams_y = adams(diff_func, diff_a, diff_b, x0, y0, nd)
adams_x_2, adams_y_2 = adams(diff_func, diff_a, diff_b, x0, y0, nd // 2)
plt.plot(adams_x, adams_y, label='Адамс')
table2 = [['xᵢ', 'yᵢ', 'ỹᵢ', '∆ᵢ = |yᵢ - ỹᵢ|']]
for i in range(len(adams_x)):
if i % 2 == 0:
table2.append([adams_x[i], adams_y[i], adams_y_2[i // 2], abs(adams_y_2[i // 2] - adams_y[i])])
print("Метод Адамса:")
#print(tabulate(table2, tablefmt='fancy_grid'))
eiler_x, eiler_y = eiler(diff_func, diff_a, diff_b, x0, y0, nd)
eiler_x_2, eiler_y_2 = eiler(diff_func, diff_a, diff_b, x0, y0, nd // 2)
plt.plot(eiler_x, eiler_y, label='Эйлер')
table3 = [['xᵢ', 'yᵢ', 'ỹᵢ', '∆ᵢ = |yᵢ - ỹᵢ|']]
for i in range(len(eiler_x)):
if i % 2 == 0:
table3.append([eiler_x[i], eiler_y[i], eiler_y_2[i // 2], abs(eiler_y_2[i // 2] - eiler_y[i])])
print("Метод Эйлера:")
#print(tabulate(table3, tablefmt='fancy_grid'))
f = sp.Function('f')
C1 = sp.Symbol('C1')
solve = sp.simplify( sp.dsolve(sp.diff(f(x), x) + f(x) - x * f(x) ** 2, f(x)) )
print('решение:', solve)
CC = sp.solve(solve.subs({x:x0, f(x):y0}), C1)[0]
#print('C1 =', CC)
print('задача Коши:', solve.rhs.subs(C1, CC))
solution = sp.lambdify(x, solve.rhs.subs(C1, CC))
xL = np.linspace(diff_a, diff_b)
plt.plot(xL, solution(xL), 'r--', label='точное решение')
legend = plt.legend(loc='upper center', shadow=True, fontsize='x-large', frameon=True)
#legend.get_frame().set_facecolor('C0')
plt.show()
print()
#程序文件Pex8_7.py
import sympy as sp
sp.var('t, k') #定义符号变量t,k
u = sp.var('u', cls=sp.Function) #定义符号函数
eq = sp.diff(u(t), t) + k * (u(t) - 24) #定义方程
uu = sp.dsolve(eq, ics={u(0): 150}) #求微分方程的符号解
print(uu)
kk = sp.solve(uu, k) #kk返回值是列表，可能有多个解
k0 = kk[0].subs({t: 10.0, u(t): 100.0})
print(kk, '\t', k0)
u1 = uu.args[1] #提出符号表达式
u0 = u1.subs({t: 20, k: k0}) #代入具体值
print("20分钟后的温度为：", u0)
from sympy import Function, dsolve, Eq, Derivative, symbols
from sympy.abc import C, V, R, t
V = Function('V')
sol = dsolve(Derivative(V(t), t, 1) * C + V(t) / R, V(t))
print('dsolve(Derivative(V(t), t), V(t))=', sol.doit())
def eq3():
r = Symbol("r")
e = Rmn.dd(2, 2)
e = e.subs(nu(r), -lam(r))
pprint(dsolve(e, lam(r)))
import sympy
from sympy import Function, dsolve, Symbol
# symbols
t = Symbol('t', positive=True)
wf = Symbol('wf', positive=True)
# unknown function
u = Function('u')(t)
# solving ODE with initial conditions
u0 = 0.4
v0 = 2
k = 150
m = 2
F0 = 10
wn = sympy.sqrt(k/m)
#wf = 2*sympy.sqrt(k/m)
F = F0*sympy.sin(wf*t)
ics = {u.subs(t, 0): u0, u.diff(t).subs(t, 0): v0}
sol = dsolve(m*u.diff(t, t) + k*u - F, ics=ics)
import matplotlib
matplotlib.use('TkAgg')
from sympy.plotting import plot3d
p1 = plot3d(sol.rhs, (t, 0, 10), (wf, 0.8*wn, 0.99*wn),
xlabel='$t$', ylabel='$\omega_f$', zlabel='$u(t)$',
nb_of_points_x=250, nb_of_points_y=25)
import sympy
from sympy import Function, dsolve, Symbol
# symbols
t = Symbol('t', positive=True)
wn = Symbol('\omega_n', positive=True)
zeta = Symbol('\zeta')
# unknown function
u = Function('u')(t)
# solving ODE
sol = dsolve(u.diff(t, t) + 2 * zeta * wn * u.diff(t) + wn**2 * u)
# sol.lhs ==> u(t)
# sol.rhs ==> solution
print(sol.rhs.simplify())
print()
sympy.print_latex(sol.rhs.simplify())
"kod za resavanje sistema ODE sa razdvajanjem promenljivih"
import numpy as np
import sympy
from sympy import *
from sympy.abc import *
from sympy.plotting import plot
#from scipy import integrate
#import matplotlib.pyplot as plt
from sympy import init_printing
init_printing()
from sympy import Function, Indexed, Tuple, sqrt, dsolve, solve, Eq, Derivative, sin, cos, symbols
from sympy.abc import h, t, o, d, i
from sympy import solve, Poly, Eq, Function, exp
"zbog biblioteke sympy.abc rho00=x rho01=y rho10=z i rho11=w"
from sympy.abc import x, y, z, w
#f = Function('f')
from sympy import Indexed, IndexedBase, Tuple, sqrt
from IPython.display import display
init_printing()
h, t, o, d, i = symbols("h t o d i")
x, y, z, w = symbols("x y z w", cls=Function, Function=True)
eq1 = Eq(Derivative(x(t), t), x(t) - i * (o * y(t) / 2 - o * z(t) / 2))
eq2 = Eq(Derivative(y(t), t),
-y(t) - i * (-d * y(t) + o * x(t) / 2 - o * w(t) / 2))
eq3 = Eq(Derivative(z(t), t),
-z(t) - i * (d * z(t) - o * x(t) / 2 + o * w(t) / 2))
eq4 = Eq(Derivative(w(t), t), -w(t) - i * (-o * y(t) / 2 + o * z(t) / 2))
#constants = solve((soln[0].subs(t,0).subs(y(0),0), soln[0].subs(t,0).subs(z(0),0), soln[0].subs(t,0).subs(w(0),0)),{C1,C2,C3})
soln = dsolve((eq1, eq2, eq3, eq4), ics={x(0): 1, y(0): 0, z(0): 0, w(0): 0})
display(soln)
##Defining our function
y = Function('y')
##Adicionando os coefs a eq diferencial
eq =sympify(a2*y(t).diff(t,2) + a1*y(t).diff(t) +a0*y(t) -xT)
pprint(eq)
print ""
###Dif equation solver
##Sets if it is of homogenous or inhomogenous type
if xT == 0:
solvedEq = dsolve(sympify(eq),y(t),hint='nth_linear_constant_coeff_homogeneous')
else:
solvedEq = dsolve(sympify(eq),y(t),hint='nth_linear_constant_coeff_undetermined_coefficients')
##Transformação do tipo sympy_unity para o sympy_mul (mais operações permitidas)
sepEq = solvedEq._args[1]
##PRocesso de separação de resp natural e resposta transitória
#elementosEq = sepEq.atoms(Symbol)
#C1 = elementosEq.pop()
#C2 = elementosEq.pop()
C1,C2,C3,C4,C5 = symbols("C1 C2 C3 C4 C5")
print C1,C2
#程序文件Pex8_3_2.py
import sympy as sp
t = sp.symbols('t')
x1, x2, x3 = sp.symbols('x1:4', cls=sp.Function)
x = sp.Matrix([x1(t), x2(t), x3(t)])
A = sp.Matrix([[2, -3, 3], [4, -5, 3], [4, -4, 2]])
eq = x.diff(t) - A * x
s = sp.dsolve(eq, ics={x1(0): 1, x2(0): 2, x3(0): 3})
print(s)
