See discussions, stats, and author profiles for this publication at: https://www.researchgate.

net/publication/360109804

Solving Differential Equations using Python

Presentation · April 2022

DOI: 10.13140/RG.2.2.26067.04641

CITATIONS READS

0 5,734

1 author:

Shardav Bhatt
Navrachana University Vadodara
29 PUBLICATIONS 26 CITATIONS

SEE PROFILE

All content following this page was uploaded by Shardav Bhatt on 22 April 2022.

The user has requested enhancement of the downloaded file.

 PPG College of Arts and Science
Department of Mathematics
Five Day International FDP on Mathematical Programming – 2022
20-25 April 2022
Day 3

Solving Differential
Equations using Python
22 April 2022
Shardav Bhatt
Navrachana University
Content 2

1. Downloading and Installing 7. System of ODEs

Python 8. Numerical solution of ODE
2. Python packages required 9. First order PDE
3. First order ODEs & IVPs

4. Plotting solutions of IVPs

5. Second order ODEs & IVPs

6. Higher order ODEs

Downloading and Installing Python 3

1. From official source: https://www.python.org/downloads/

2. From Anaconda Distribution: https://www.anaconda.com/products/distribution

3. Google Colab (No installation or Download): https://colab.research.google.com/

Python packages required 4

1. SymPy: https://www.sympy.org/en/index.html

For analytical solution of differential equations

2. SciPy: https://scipy.org/

For numerical solution of differential equations

• Anaconda distribution and Google colab both contains pre-installed

SymPy and SciPy.
Solving first order ODE 5

• Let’s start with a simple ODE

• Here is an independent variable

is a variable depending on

is derivative
Solving first order ODE 6

Mathematical
Type SymPy function Syntax
expression

𝑥 independent variable Symbol x = Symbol('x')

𝑦 variable depending on 𝑥 Function y = Function('y')(x)

𝑑𝑦
Derivative diff dydx = y.diff(x)
𝑑𝑥
𝑑𝑦
=𝑥 Differential equation Eq deq = Eq(dydx, x)
𝑑𝑥

General Solution of ODE dsovle dsolve(deq)

Solving first order ODE 7

• Step – 1: Import necessary SymPy functions

from sympy import Symbol, Function, Eq
• Step – 2: Define an equation
x = Symbol('x')
y = Function('y')(x)
dydx = y.diff(x)
deq = Eq(dydx, x)
• Step – 3: Solve ODE
from sympy import dsolve
solution = dsolve(deq)
Solving first order ODE 8

• Let’s solve another one

• Here we need to import a function exp from SymPy to represent .

• In python, can be written as y**2.

** is an operator in python to determine power.

Solving first order ODE 9

• Step – 1: Import necessary SymPy functions

from sympy import Symbol, Function, Eq, exp
• Step – 2: Define an equation
x = Symbol('x')
y = Function('y')(x)
dydx = y.diff(x)
deq = Eq(dydx, (x+1)*exp(-x)*y**2 )
• Step – 3: Solve ODE
from sympy import dsolve
solution = dsolve(deq)
Try Yourself! 10

Solve the following ODE

First order IVPs 11

• Initial value problems (IVPs) are ODE together with the initial condition.

• Consider an IVP,

• After finding a general solution, we use condition to

determine the arbitrary constant.

• For that we substitute and in the RHS of the general

solution and solve it.
 First order IVPs 12
• Step 1: Find the general solution s using dsolve as steps shown earlier
s = dsolve(deq)
• Step 2: Substitute the values and in the RHS of s using subs
eq = s.rhs.subs( , 𝟎 )- 𝟎
• Step 3: Import solve function and solve the expression using it
From sympy import solve

constant = solve([eq])
• Step 4: Substitute value of constant in the general equation using subs
solution = s.subs(constant)
Plotting the solution of IVP 13

• Suppose solution is the variable in which the particular solution of IVP

is stored.

• We can plot it using the function plot from sympy.

• Step 1: Import necessary modules

from sympy.plotting import plot

• Step 2: Plot the solution stored in the variable named solution

plot(solution.rhs)
Code to solve an IVP

14
from sympy import Symbol, Function, Eq, exp, dsolve, solve

x = Symbol('x')
y = Function('y')(x)
dydx = y.diff(x)
deq = Eq(dydx, -2*x*y )
s = dsolve(deq)

eq = s.rhs.subs(x,0)-1.8
constant = solve([eq])
solution = s.subs(constant)

from sympy.plotting import plot

plot(solution.rhs)
Try yourself! 15

• Consider an initial value problem

• Find the general solution, particular solution and plot it.

Solving second order ODE 16

• Consider a second order ODE

• It is convenient to use function Derivative of SymPy to write higher

order derivatives.

• Derivative(y,x) gives

• Derivative(y,x,x) gives
Solving second order ODE 17

• Code:

from sympy import Symbol, Function, Derivative, Eq, dsolve

x = Symbol('x')

y = Function('y')(x)

deq = Eq(Derivative(y,x,x) + Derivative(y,x) - 2*y, 0)

solution = dsolve(deq)
Solving second order IVP 18

• Consider a second order IVP

• For second order IVP, there are two initial conditions.

• We use these conditions in the general solution, which will given two
equations in two unknowns.

• Two arbitrary constants can be obtained by solving these two equations.

Solving second order IVP 19

• Code (after getting the general solution s)

s = dsolve(deq)

eqn1 = s.rhs.subs(x,0) - 1

eqn2 = s.rhs.diff(x).subs(x,0) + 1

constants = solve([eqn1, eqn2])

solution = s.subs(constants)

plot(solution.rhs)
Try yourself! 20

• Solve the following second order IVP:

Higher order ODEs 21

• Suppose we are solving a third order ODE

with conditions

, ,

• The syntax and steps of code for solving third order are similar to the
that of second order.
 Higher order ODEs 22

• Code to find General solution:

from sympy import Symbol, Function, Derivative, Eq, dsolve, exp

x = Symbol('x')

y = Function('y')(x)

deq = Eq(Derivative(y,x,x,x) + 3*Derivative(y,x,x) + 2*Derivative(y,x) + y, 30*exp(-x))

s = dsolve(deq)
 Higher order ODEs 23
• Code to find Particular solution:

s = dsolve(deq)

eq1 = s.rhs.subs(x,0) - 3

eq2 = s.rhs.diff(x).subs(x,0) + 3

eq3 = s.rhs.diff(x, x).subs(x,0) + 47

constants = solve([eq1, eq2, eq3])

solution = s.subs(constants)

from sympy.plotting import plot

plot(solution.rhs, (x,-1,1))
Try yourself! 24

• Solve the following fifth order ODEs

• Solve the following fifth order ODEs

System of ODEs 25

• Suppose we want to solve a system of ODE

• The syntax and steps of code for solving system of ODE are similar to
that of solving a single ODE.
 System of ODEs 26
• Code to find General solution:

from sympy import Symbol, Function, Derivative, Eq, dsolve, solve

x = Symbol('x')

y1 = Function('y1')(x)

y2 = Function('y2')(x)

deq1 = Eq(Derivative(y1), -0.02*y1 + 0.02*y2)

deq2 = Eq (Derivative(y2), 0.02*y1 - 0.02*y2)

system = (deq1, deq2)

s = dsolve(system)
 System of ODEs 27

• Code to find Particular solution:

s = dsolve(deq)

eq1 = s[0].rhs.subs(x,0) - 0

eq2 = s[1].rhs.subs(x,0) - 150

constants = solve([eq1, eq2])

y1 = s[0].subs(constants)

y2 = s[1].subs(constants)
System of ODEs 28

• Plotting a particular solution:

from sympy.plotting import plot

plot(y1.rhs, y2.rhs, (x, -10, 10))

Try yourself! 29

• Solve the following system of ODEs

Numerical solution of ODE 30

• The numerical solution of ODE can be obtained using the SciPy package.

• This can be done using the solve_ivp function of scipy.integrate.

• We can implement Runge-Kutta method of order 5, Runge-Kutta

method of order 3, Implicit Runge-Kutta method and Adams/BDF
to find numerical solution.
Numerical solution of ODE 31

• solve_ivp can solve IVP of the form

• We have to write

solution = solve_ivp(fun, t_span, y0, t_eval=None, method='RK45')

• Here fun is , t_span is an interval from to the desired point, y0 is 𝟎

• t_eval is the list of points at which solution is needed

• We can use other algorithms by providing different names of the method.

 Numerical solution of ODE 32

• Suppose we want to solve an IVP

• Code:
from scipy.integrate import solve_ivp
def fun(t, y):
return t + y + t*y
sol = solve_ivp(fun, t_span=[0, 1], y0=[1],
t_eval = [0, 0.2, 0.4, 0.6, 0.8, 1], method = 'RK45')
 Numerical solution of ODE 33

• sol.t gives all the points of provided by t_eval

• sol.y gives numerical solution at points given by sol.t

• We can plot them,

from matplotlib.pyplot import plot
plot(sol.t, sol.y[0], 'o-')
 Try yourself! 34

• Find the numerical solution of following IVP at points 1, 1.25, 1.5, 1.75, 2 & plot it.
First order PDE 35

• We can solve following type of PDEs using SymPy:

1. First order linear homogeneous partial differential equation

2. First order linear partial differential equation with constant coefficients

3. First order linear partial differential equation with variable coefficients

• PDE related functions are available in sympy.solvers.pde

 First order PDE 36

Function Use

classify_pde Returns a classifications for a PDE.

Solves any (supported) kind of partial differential

pdsolve
equation.
Checks if the given solution satisfies the partial
checkpdesol
differential equation
Solves a first order linear homogeneous partial
pde_1st_linear_constant_coeff_homogeneous
differential equation with constant coefficients.
Solves a first order linear partial differential equation with
pde_1st_linear_constant_coeff
constant coefficients.
Solves a first order linear partial differential equation with
pde_1st_linear_variable_coeff
variable coefficients.
First order PDE 37

• Consider a PDE:

• Here is a function of and . We can define PDE using following code:

from sympy import Symbol, u = f(x, y)
Function, Eq ux = u.diff(x)
x = Symbol('x')
uy = u.diff(y)
y = Symbol('y')
eq = Eq(2*ux + 3*uy, 1)
f = Function('f')
First order PDE 38

from sympy.solvers.pde import classify_pde, pdsolve, checkpdesol

classify_pde(eq)

solution = pdsolve(eq)

checkpdesol(eq, solution)
What next? 39

• We can solve many other mathematical problems using python like:

1. Finding limit, derivative, integration

2. Vector & Matrix operations

3. Laplace transforms, Fourier transform, Wavelet transforms

4. Statistical methods and probability distributions

5. Optimization and LPP

6. Numerical methods
View publication stats

Thank you
[email protected]

https://www.researchgate.net/profile/Shardav-Bhatt-2

(Refer the supported code file for the outputs and solutions)