differential-equations

Can anybody give me some advice how to solve an ODE in Python that has a time-delay implemented in it? I can't seem to figure out how to do it using scipy.integrate.odeint. What I am looking for should look like: # the constants in the equation b = 1/50 d = 1/75 a = 0.8 G = 10 ** (-2) tau = 0.5 u = [b, d, tau, a, G] # enter initial conditions N0 = 0.1 No0 = 10 w = [N0, No0] def logistic(w, t, u): N, No = w b, d, tau, a, G = u dNdt = b * (No(t) - N(t) ) * (N(t) / No(t) ) - d * N(t - tau) dNodt = G * (a * No(t) - N(t) ) * (N(t) / No(t) ) return [dNdt, dNodt] # create timescale # create timescale

How can I setup the three body problem in python? How to I define the function to solve the ODEs? The three equations are x'' = -mu / np.sqrt(x ** 2 + y ** 2 + z ** 2) * x , y'' = -mu / np.sqrt(x ** 2 + y ** 2 + z ** 2) * y , and z'' = -mu / np.sqrt(x ** 2 + y ** 2 + z ** 2) * z . Written as 6 first order we have x' = x2 , y' = y2 , z' = z2 , x2' = -mu / np.sqrt(x ** 2 + y ** 2 + z ** 2) * x , y2' = -mu / np.sqrt(x ** 2 + y ** 2 + z ** 2) * y , and z2' = -mu / np.sqrt(x ** 2 + y ** 2 + z ** 2) * z I also want to add in the path Plot o Earth's orbit and Mars which we can assume to be circular.

How do I numerically solve an ODE in Python? Consider \ddot{u}(\phi) = -u + \sqrt{u} with the following conditions u(0) = 1.49907 and \dot{u}(0) = 0 with the constraint 0 <= \phi <= 7\pi. Then finally, I want to produce a parametric plot where the x and y coordinates are generated as a function of u. The problem is, I need to run odeint twice since this is a second order differential equation. I tried having it run again after the first time but it comes back with a Jacobian error. There must be a way to run it twice all at once. Here is the error: odepack.error: The function and its Jacobian

I wish to solve the Lorentz model in Python without the help of a package and my codes seems not to work to my expectation. I do not know why I am not getting the expected results and Lorentz attractor. The main problem I guess is related to how to store the various values for the solution of x,y and z respectively.Below are my codes for the Runge-Kutta 45 for the Lorentz model with 3D plot of solutions: import numpy as np import matplotlib.pyplot as plt #from scipy.integrate import odeint #a) Defining the Runge-Kutta45 method def fx(x,y,z,t): dxdt=sigma*(y-z) return dxdt def fy(x,y,z,t): dydt

How can I evaluate the constants C1 and C2 from a solution of a differential equation SymPy gives me? There are the initial condition f(0)=0 and f(pi/2)=3. >>> from sympy import * >>> f = Function('f') >>> x = Symbol('x') >>> dsolve(f(x).diff(x,2)+f(x),f(x)) f(x) == C1*sin(x) + C2*cos(x) I tried some ics stuff but it's not working. Example: >>> dsolve(f(x).diff(x,2)+f(x),f(x), ics={f(0):0, f(pi/2):3}) f(x) == C1*sin(x) + C2*cos(x) By the way: C2 = 0 and C1 = 3. There's a pull request implementing initial/boundary conditions, which was merged and should be released in SymPy 1.2. Meanwhile, one

I don't really know where to start with this problem, as I haven't had much experience with this but it is required to solve this part of the project using a computer. I have a 2nd order ODE which is: m = 1220 k = 35600 g = 17.5 a = 450000 and b is between 1000 and 10000 with increments of 500. x(0)= 0 x'(0)= 5 m*x''(t) + b*x'(t) + k*x(t)+a*(x(t))^3 = -m*g I need to find the smallest b such that the solution is never positive. I know what the graph should look like, but I just don't know how to use odeint to get a solution to the differential equation. This is the code I have so far: from

I'm working with a DE system, and I wanted to know which is the most commonly used python library to solve Differential Equations if any. My Equations are non Linear First Order equations. If you need to solve large nonlinear systems (especially stiff ones), the scipy tools will be slow and awkward. The PyDSTool package is now quite commonly used in this situation. It lets your equations be automatically converted into C code and integrates them with good solvers. It's especially good if you want to define state-defined events such as threshold crossings, add external input signals from arrays