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)