Hummingbird Publications © Dec.

HP Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2
Journal of Scientific Development Research
www.hummingbirdjournals.com
2023
Vol. 2 No. 2
JSDR2023

Exploring Python’s Computer Algebra System for Effective

training in Structural Analysis

Musa Abdul1 and Muhammed Tuga Bawa2

1
Department of Building, College of Environmental Studies, Kaduna Polytechnic,
Kaduna. 2Department of Building, Faculty of Environmental Sciences, Baze
University, Abuja.
[email protected]

Keywords: Python,
CAS, SymPy, Abstract
structural analysis, This paper explores the benefits of using Python’s
jupyter notebook. Computer Algebra System (CAS) to provide effective
training in structural analysis. The authors argue that by
introducing a comprehensive and flexible platform for
performing symbolic manipulation of equations and
equations systems, CAS will allow students to have greater
understanding of structural analysis principles. The paper
also discusses how this system can provide computer-
assisted teaching tools to facilitate learning in the
classroom. Structural analysis is a challenging area to teach,
as it requires intimate understanding of physical principles
and their application. The paper begins with an overview of
the fundamental concepts of structural analysis, as well as
the basics of Python and SymPy. This is followed by a
detailed description of sample problems adapted for SymPy
. The results of the exercises and experiments with SymPy
was discussed, focussing on the impact of the learning
process on the use of the library. Findings reveal that
SymPy is a powerful aid in teaching structural analysis,
especially when used with Jupyter Notebook.. Students can
use it to visualize and solve problems in a fraction of the
time required with traditional methods. It is believed that
SymPy’s intuitive approach together with Jupyter Notebook
will assist the students gain a deeper understanding of
theoretical and analytical concepts, which will be helpful on

Page 10 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219

 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

applying knowledge gained in practice. Overall, the use of

SymPy together with Jupyter Notebook in teaching
structural analysis appears to be an effective and beneficial
approach. Findings demonstrated that SymPy provides
students with an intuitive tool to easily explore and
understand difficult concepts, allowing them to gain
meaningful insights into the theory and practice of
structural analysis. Finally, the paper concludes with
recommendations on how schools and universities can
integrate CAS into their curriculum and cites potential
opportunities for further development in the field.

Introduction
Computer Algebra Systems (CAS) are software packages used in the manipulation of
mathematical formulae in order to automate tedious and sometimes difficult algebraic
tasks. The principal difference between a CAS and a traditional calculator is the ability
of the CAS to deal with equations symbolically rather than numerically. Baduge et al.
(2022) stated that, Building and construction industry is slowly but constantly evolving
and embracing new technologies such as Building Information Modelling (BIM),
Artificial Intelligence (AI), Internet of Things (IoTs) and Smart Vision (SV) to further
enhance the efficiency, productivity, accuracy, and safety of the built environments.
According to Quraishi & Dhapekar (2021), Python is an advanced open source
programming language which is widely utilized by software engineers across the
world for different applications. It is accessible for free and can work effectively on
PCs and can be setup with little or no configuration. Commercial software have been
utilized in the analysis and design of reinforced concrete and other Building and Civil
Engineering structures. The cost of the commercial software hinders their wider
applications, as most organisations acquire only a limited quantity for a few staff of
the organisation. Individuals with little or no programming background can easily
understand and immediately commence utilizing Python in their projects.
SymPy stands for Symbolic Python, that allows the symbolic manipulation of data.
Symbolic computation deals with the computation of mathematical objects
symbolically. This means that the mathematical objects are represented exactly, not
approximately, and mathematical expressions with unevaluated variables are left in
symbolic form. SymPy is a full featured computer algebra system (CAS) written in the
Python programming language. It is free and open source Python package. (Sympy
Development Team, 2022; Cywiak & Cywiak, 2021; Meurer et al., 2017; Stewart,
2017; Stewart & Mommert, 2023)

Page 11 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219

 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

Objectives and Research Questions

This paper is aimed at utilizing CAS ability provided by SymPy and Jupyter Notebook
in developing an alternative teaching and learning platform in structural analysis.
Specifically, the objectives of this paper are:
• To document structural analysis procedures for training in structural analysis
• To transform the document into CAS using SymPy
• To generate independent structural analysis module with study materials in
structural analysis
• To present the output of the module using Jupyter Notebook.

Research Questions
• Can training content delivery in structural analysis be documented for digital
transformation?
• Does the use of CAS accurately present the training content delivery in
structural analysis?
• Is it possible to generate independent training module with study materials ins
structural analysis?
• Does Jupyter Notebook accurately present the training module as CAS?

Python Programming Language

Block of code structure is created using indentation in Python. Indent one level, in, for
the beginning of a block and indent, out, to show end of the block. Python can be
downloaded for free at https://python.org/downloads/. Installing Python automatically
installs with it, IDLE (Integrated Development and Learning Environment) an IDE
(Integrated Development Environment) for executing Python programmes. The
following are the defined data types in Python: int (for integers), float (for numbers
with decimal points), str (for characters), list(for collection of values), tuple (for
unmodifiable collection of values), set(for non duplicate collection of values), dict (for
key:value pairs collection of values) and bool(for true or false values). Python is
object-oriented programming language. Method or functions are defined using the
“def” keyword and class definition is with the keyword, “class”. (Kaufmann & Held,
2023; Kuhlman, 2013; Mehare et al., 2023; Stewart & Mommert, 2023a; Wang &
Wang, 2023; Zemkoho, 2023; Kim & Duggirala, 2020)

SymPy
Katayama & Ohtsuka (2020) used SymPy for the symbolic computation and
automatic C++ code. According to Hua & Leu (2023) and Kopei et al. (2019)
variables must be declared as symbols in Sympy be usage. SymPy is very rich when

Page 12 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219

 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

it comes to computations symbolically. It has the ability to symbolically compute

derivatives, linear and non-linear algebra, limits, combination and permutation, sets,
matrices and much more. Meurer et al. (2017a) and Paffenroth & Kong (2015) stated
that, unlike many CASs, SymPy does not invent its own programming language.
Python itself is used both for the internal implementation and end user interaction. The
exclusive usage of a single programming language makes it easier for people already
familiar with that language to use or develop SymPy. At the same time, it gave
developers the ability to focus on their specific task, rather than language design.
SymPy is designed with a strong focus on usability as a library. Unlike many other
CASs, SymPy is designed to be used in an extensible way: both as an end-user
application and as a library.

Computer Algebra System (CAS)

A computer algebra system (CAS) is a program that can solve mathematical problems
by rearranging and manipulating variables, to suit the solution required, whose results
can be symbolic or numerical. CAS can serve as a calculator, provide analytical
expressions, and perform symbolic manipulations and offers a range of numerical
analysis methods for equations or systems of equations that otherwise cannot be solved
analytically, it also incorporates excellent graphical presentation of outputs. CAS are
used in the education process mainly as a means of solving tasks. The education
outcomes of the students taught with the CAS appeared significantly higher as
compared to the students who had not used these supplementary materials. (Castilla &
Peña, 2023; Galán–García et al., 2023; Kamalov et al., 2023; Karjanto & Husain,
2021; Mezhennaya & Pugachev, 2019; Pawlik et al., 2015)

Jupyter Notebook
Jupyter Notebook is recommended to be use as the IDE for the development. The
output from Jupyter Notebook is beautiful and natural. jupyter.org (2023) described
the Jupyter Notebook as the original web application for creating and sharing
computational documents. It offers a simple, streamlined, document-centric
experience. Emeritus (2023) mentioned that the ambition to make a computer-algebra
system the - tool of first recourse for teaching, learning, and doing mathematics - was
expressed in the 1987 National Science Foundation (NSF) grant that funded the first
step in bringing computers into the classroom. According to Jupyter Team (2015), a
notebook is a shareable document that combines computer code, plain language
descriptions, data, rich visualizations like 3D models, charts, graphs and figures, and
interactive controls. A notebook, along with an editor (like JupyterLab), provides a
fast interactive environment for prototyping and explaining code, exploring and
visualizing data, and sharing ideas with others.
Page 13 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219
 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

Real-world concepts and applications are associated in ways that encourage students
to apply them whenever possible to their learning processes. In this context, Jupyter
Notebooks and their highly innovative tools offer transparency for scientific research
and the reproductibility of new findings. These virtual notebooks can be used to
display text, video, and embedded interactive graphics. Jupyter installation is easy. It
can be installed using using this command – pip install notebook – Running the
notebook by this command – jupyter notebook – . Jupyter Notebook runs in a web
browser. (Bascuñana et al., 2023; Brown, 2018; Castilla & Peña, 2023; Colonnelli et
al., 2022; Hamrick, 2016; Ipython & Team, 2011; Ketcheson, 2014; Pérez & Granger,
2007; Seddighi et al., 2020; Suárez-García et al., 2021; Thomas & Cholia, 2021)

Structural Analysis
Structural analysis involves the assessment of structures under loads application. In
this paper, only force method of analysing statically indeterminate structures is
considered, i.e. structures where equilibrium equations are insufficient for their
complete analysis.

Force Method
This method involves releasing the redundants from an indeterminate structure and
ensuring conpatibity of the released structure with redundants acting separately as the
only loads on the structure. This will result in equations with the redundants as
unknowns. When the equations are solved and the rendundants determined, the
structure can be fully analysed using equilibrium equations. (Aslam Kassimali, 2012;
Connor & Faraji, 2016; Ghali et al., 2017; Hibbeler, 2017)

Utilization of CAS for Effective Teaching and Learning

The module chosen is Force Method of analysis and Jupyter Notebook is used as the
development IDE. This method of analysis consists of analysing second order
differential equation for calculating deflections at points of redundant, to be used in
ensuring compatibility of displacements, which in turn, will result in series of
simultaneous equations with the redundant loads as unknowns. This process used Rule
et al. (2019) 10 simple rules for writing and sharing computational analyses in Jupyter
Notebooks, as a guide. These rules are: Tell a story to an audience, Document the
process, not just the results, use cell divisions to clear the steps, Modularize the code,
Register the dependencies, Use version control, Build a pipe, Share and explain your
data, Design your Notebooks to read, run, and explore, and Advocates open research.

Description of Parts of the CAS Program.

• print(‘Contents’) – Displays “Contents” as an output to screen
• display(‘Contents’) – Profession display of “Contents” as an out to screen,
applicable if jupyterLab or IPython is used as IDE, otherwise, use
print(‘Contents’)
Page 14 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219
 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

• sympy.symbols(‘x y z’) – creates x, y and z as symbols to be used as symbols

in equations.
• sympy.Function(‘f’) – creates a function – f(x)
𝑑
• f(x).diff(x) – produces a first order differential equation (𝑑𝑥 𝑓(𝑥))
𝑑2
• f(x).diff(x, x) – produces a second order differential equation (𝑑𝑥 2 𝑓(𝑥))
• sympy.dsolve(ode, f(x), ics={f(1st):1st_value, f(2nd):2nd_value}) – solves
ordinary differential equation (ode) as f(x) with 1st initial condition = 1st_value
and 2nd initial condition = 2nd_value.
• sympy.Eq(‘equation’) – creates equation
• sympy.solve([eq1, eq2, eq3, eq4], (x1, x2, x3, x4)) – Solve for x1, x2, x3 and
x4 from equations (eq1, eq2, eq3 and eq4)
• def function_name(x, a): – creates function_name as a function with x and a as
parameters

The CAS Program

The problem to be solved in the module is given is figure 1. Using force method of
analysis, the structure is presented as a released structure (figure 2) and redundant
loads (figure 2).
42kN 30kN 48kN
15kN/m

A B C D E F

4m 2m 4m 3m 3m 2m 3m 5m

Figure 1

The Python program for the CAS is presented as follows:

Page 15 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219
 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

import sympy as sp
from IPython.display import Math
from sympy import latex
sp.init_printing()
display(Math(rf'\text{{FORCE METHOD}}'))
display(Math(rf'\text{{This is a method of analysing statically indeterminate structure.
The degree of redundancy is first determined.}}'))
display(Math(rf'\text{{Decision is taking on the forces or reactions to be considered
as redundants. The redundants are released, so the resultant released structure}}'))
display(Math(rf'\text{{is statically determinate. The redundants are considered
separately as the only loads on the structure. For example, figure 1 is a}}'))
display(Math(rf'\text{{statically indeterminate structure. The structure has 4 degrees
of redundancy. The four internal reactions are considered as the redundants and,}}'))
display(Math(rf'\text{{ therefore, released. Figure 2 is the released strucute and figure
3 the redundant loads.}}'))
display(Math(rf'\text{{To determine the values of the redundant forces, compatibility
of displacements are established at the released}}'))
display(Math(rf'\text{{redundant points. Displamenets are determined at the released
points from the released structure and the redundant loads,}}'))
display(Math(rf'\text{{ and compability are ensured with the original structure, before
releasing the redundants.}}'))
# Function for dealing with Macaulay brackets
def macaulay(x, a):
v=x-a
if v < 0:
return 0
return v
display(Math(rf'\text{{Calculating deflections at points of redundant}}'))
display(Math(rf'\text{{The released strucuture is a simply supply supported beam
suppoting both UDL and Point Loads}}'))
display(Math(rf'\text{{We need to generate deflection equations for simply supported
beam separately supporting uniformly distributed load and separately supporting point
loads}}'))
# We now define symbols
x, y, M, P, w, L, a, b, C1, C2, mac, eq, eq1, eq2, EI= sp.symbols('x y M P w L a b C1
C2 [x-a] eq eq1 eq2 EI')
yB1, yB2, yC1, yC2, yD1, yD2, yE1, yE2 = sp.symbols('yB1 yB2 yC1 yC2 yD1 yD2
yE1 yE2')

Page 16 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219

 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

yudl, yudlB1, yudlC1, yudlD1, yudlE1 = sp.symbols('yudl yudlB1 yudlC1 yudlD1

yudlE1')
ypl, yplB1, yplC1, yplD1, yplE1 = sp.symbols('ypl yplB1 yplC1 yplD1 yplE1')
yP1, yP1B, yP1C, yP1D, yP1E = sp.symbols('yP1, yP1B, yP1C, yP1D, yP1E')
yP2, yP2B, yP2C, yP2D, yP2E = sp.symbols('yP2, yP2B, yP2C, yP2D, yP2E')
yP3, yP3B, yP3C, yP3D, yP3E = sp.symbols('yP3, yP3B, yP3C, yP3D, yP3E')
yR1B, yR1C, yR1D, yR1E = sp.symbols('yR1B, yR1C, yR1D, yR1E')
yR2B, yR2C, yR2D, yR2E = sp.symbols('yR2B, yR2C, yR2D, yR2E')
yR3B, yR3C, yR3D, yR3E = sp.symbols('yR3B, yR3C, yR3D, yR3E')
yR4B, yR4C, yR4D, yR4E = sp.symbols('yR4B, yR4C, yR4D, yR4E')
R_B, R_C, R_D, R_E = sp.symbols('R_B, R_C, R_D, R_E')
# Define polynominal function, for example f(x) for f(3)
f = sp.Function('f')
display(Math(rf'\text{{Starting with simply supported beam supporting uniformly
distributed load}}'))
display(Math(rf'\text{{M = }}{latex(w*L*x/2 - w*x**2/2)}'))
#second_derivative = sp.symbols('second_derivative')
second_derivative = f(x).diff(x, x)
der = second_derivative.subs({f(x):y})
display(Math(rf'(EI{latex(der)}) \text{{ = -M}}'))
# define the equation
ode = second_derivative + M
eq = sp.Eq(ode, 0)
#display(eq)
ode = EI*second_derivative + sp.Rational(1,2)*w*L*x - sp.Rational(1,2)*w*x**2
eq = sp.Eq(ode, 0)
display(eq.subs({f(x):y}))
eq = sp.dsolve(ode, f(x), ics={f(0):0, f(L):0})
ydist, output = sp.symbols('ydist output')
ydist = sp.Rational(1,24)*L**3*w*x/EI - sp.Rational(1, 12)*L*w*x**3/EI +
sp.Rational(1, 24)*w*x**4/EI
display(Math(rf'\text{{Solving the differential we have:}}'))
display(Math(rf'\text{{yudl = }} {latex(ydist)}'))
display(Math(rf'\text{{substituting, w = 15, L = 26}}'))
yudl = ydist.subs({w:15, L:26})
display(Math(rf'\text{{yudl = }} {latex(yudl)}'))
display(Math(rf'\text{{Substitute, x = 4, for deflection at first redundant point}}'))
yudlB1 = yudl.subs({x:4})
display(Math(rf'\text{{yudlB1 = }} {latex(yudlB1)}'))
Page 17 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219
 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

display(Math(rf'\text{{Substitute, x = 10, for deflection at second redundant point}}'))

yudlC1 = yudl.subs({x:10})
display(Math(rf'\text{{yudlC1 = }} {latex(yudlC1)}'))
display(Math(rf'\text{{Substitute, x = 16, for deflection at third redundant point}}'))
yudlD1 = yudl.subs({x:16})
display(Math(f'yudlD1 = {latex(yudlD1)}'))
display(Math(rf'\text{{Substitute, x = 21, for deflection at fourth redundant point}}'))
yudlE1 = yudl.subs({x:21})
display(Math(rf'\text{{yudlE1 = }} {latex(yudlE1)}'))
ypl = sp.Rational(1,6)*(P/(EI*L)) * (-b * x**3 + L * mac**3 + a * b * x * (L + b))
display(Math(rf'\text{{Next is to calculate deflections due the Point loads}}'))
display(Math(rf'\text{{Deflections at redundant points due to point load of 42kN}}'))
display(Math(rf'\text{{At 42kN Point Load (P = 42, L = 26, a = 6, b = 20)}}'))
yP1 = ypl.subs({P:42, L:26, a:6, b: 20})
display(Math(rf'\text{{yP1 = }} {latex(yP1)}'))
yP1B = yP1.subs({x:4, mac:macaulay(4, 6)})
yP1C = yP1.subs({x:10, mac:macaulay(10, 6)})
yP1D = yP1.subs({x:16, mac:macaulay(16, 6)})
yP1E = yP1.subs({x:21, mac:macaulay(21, 6)})
display(Math(rf'\text{{yP1B = }} {latex(yP1B)}'))
display(Math(rf'\text{{yP1C = }} {latex(yP1C)}'))
display(Math(rf'\text{{yP1D = }} {latex(yP1D)}'))
display(Math(rf'\text{{yP1E = }} {latex(yP1E)}'))
display(Math(rf'\text{{At 30kN Point Load (P = 30, L = 26, a = 13, b = 13)}}'))
yP2 = ypl.subs({P:30, L:26, a:13, b: 13})
display(Math(rf'\text{{yP2 = }} {latex(yP2)}'))
yP2B = yP2.subs({x:4, mac:macaulay(4, 13)})
yP2C = yP2.subs({x:10, mac:macaulay(10, 13)})
yP2D = yP2.subs({x:16, mac:macaulay(16, 13)})
yP2E = yP2.subs({x:21, mac:macaulay(21, 13)})
display(Math(rf'\text{{yP2B = }} {latex(yP2B)}'))
display(Math(rf'\text{{yP2C = }} {latex(yP2C)}'))
display(Math(rf'\text{{yP2D = }} {latex(yP2D)}'))
display(Math(rf'\text{{yP2E = }} {latex(yP2E)}'))
display(Math(rf'\text{{At 48kN Point Load (P = 48, L = 26, a = 18, b = 8)}}'))
yP3 = ypl.subs({P:48, L:26, a:18, b: 8})
display(Math(rf'\text{{yP3 = }} {latex(yP3)}'))
yP3B = yP3.subs({x:4, mac:macaulay(4, 18)})
yP3C = yP3.subs({x:10, mac:macaulay(10, 18)})
Page 18 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219
 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

yP3D = yP3.subs({x:16, mac:macaulay(16, 18)})

yP3E = yP3.subs({x:21, mac:macaulay(21, 18)})
display(Math(rf'\text{{yP3B = }} {latex(yP3B)}'))
display(Math(rf'\text{{yP3C = }} {latex(yP3C)}'))
display(Math(rf'\text{{yP3D = }} {latex(yP3D)}'))
display(Math(rf'\text{{yP3E = }} {latex(yP3E)}'))
display(Math(rf'\text{{We now calculate the deflections at redundant points for the
released structure}}'))
yB1 = yudlB1 + yP1B + yP2B + yP3B
yC1 = yudlC1 + yP1C + yP2C + yP3C
yD1 = yudlD1 + yP1D + yP2D + yP3D
yE1 = yudlE1 + yP1E + yP2E + yP3E
display(Math(rf'\text{{yB1 = yudlB1 + yP1B + yP2B + yP3B}}'))
display(Math(rf'\text{{yB1 = }} {latex(yB1)}'))
display(Math(rf'\text{{yC1 = yudlC1 + yP1C + yP2C + yP3C}}'))
display(Math(rf'\text{{yC1 = }} {latex(yC1)}'))
display(Math(rf'\text{{yD1 = yudlD1 + yP1D + yP2D + yP3D}}'))
display(Math(rf'\text{{yD1 = }} {latex(yD1)}'))
display(Math(rf'\text{{yE1 = yudlE1 + yP1E + yP2E + yP3E}}'))
display(Math(rf'\text{{yE1 = }} {latex(yE1)}'))
display(Math(rf'\text{{Next is to calculate deflection at redundant point due to
redundant loads}}'))
display(Math(rf'\text{{Recal deflection equation for point load = }} {latex(ypl)}'))
display(Math(rf'\text{{Starting with }} R_B \text{{ as the redundant load}}'))
yR1B = ypl.subs({L:26, a:4, b:22, x:4, P:-R_B, mac:macaulay(4, 4)})
yR1C = ypl.subs({L:26, a:4, b:22, x:10, P:-R_B, mac:macaulay(10, 4)})
yR1D = ypl.subs({L:26, a:4, b:22, x:16, P:-R_B, mac:macaulay(16, 4)})
yR1E = ypl.subs({L:26, a:4, b:22, x:21, P:-R_B, mac:macaulay(21, 4)})
display(Math(rf'\text{{at x = 4m, yR1B = }} {latex(yR1B)} '))
display(Math(rf'\text{{at x = 10m, yR1C = }} {latex(yR1C)} '))
display(Math(rf'\text{{at x = 16m, yR1D = }} {latex(yR1D)} '))
display(Math(rf'\text{{at x = 21m, yR1E = }} {latex(yR1E)} '))
display(Math(rf'\text{{with }} R_C \text{{ as the redundant load}}'))
yR2B = ypl.subs({L:26, a:10, b:16, x:4, P:-R_C, mac:macaulay(4, 10)})
yR2C = ypl.subs({L:26, a:10, b:16, x:10, P:-R_C, mac:macaulay(10, 10)})
yR2D = ypl.subs({L:26, a:10, b:16, x:16, P:-R_C, mac:macaulay(16, 10)})
yR2E = ypl.subs({L:26, a:10, b:16, x:21, P:-R_C, mac:macaulay(21, 10)})
display(Math(rf'\text{{at x = 4m, yR2B = }} {latex(yR2B)}'))
display(Math(rf'\text{{at x = 10m, yR2C = }} {latex(yR2C)}'))
Page 19 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219
 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

display(Math(rf'\text{{at x = 16m, yR2D = }} {latex(yR2D)}'))

display(Math(rf'\text{{at x = 21m, yR2E = }} {latex(yR2E)}'))
display(Math(rf'\text{{with }} R_D \text{{ as the redundant load}}'))
yR3B = ypl.subs({L:26, a:16, b:10, x:4, P:-R_D, mac:macaulay(4, 16)})
yR3C = ypl.subs({L:26, a:16, b:10, x:10, P:-R_D, mac:macaulay(10, 16)})
yR3D = ypl.subs({L:26, a:16, b:10, x:16, P:-R_D, mac:macaulay(16, 16)})
yR3E = ypl.subs({L:26, a:16, b:10, x:21, P:-R_D, mac:macaulay(21, 16)})
display(Math(rf'\text{{at x = 4m, yR3B = }} {latex(yR3B)}'))
display(Math(rf'\text{{at x = 10m, yR3C = }} {latex(yR3C)}'))
display(Math(rf'\text{{at x = 16m, yR3D = }} {latex(yR3D)}'))
display(Math(rf'\text{{at x = 21m, yR3E = }} {latex(yR3E)}'))
display(Math(rf'\text{{with }} R_E \text{{ as the redundant load}}'))
yR4B = ypl.subs({L:26, a:21, b:5, x:4, P:-R_E, mac:macaulay(4, 21)})
yR4C = ypl.subs({L:26, a:21, b:5, x:10, P:-R_E, mac:macaulay(10, 21)})
yR4D = ypl.subs({L:26, a:21, b:5, x:16, P:-R_E, mac:macaulay(16, 21)})
yR4E = ypl.subs({L:26, a:21, b:5, x:21, P:-R_E, mac:macaulay(21, 21)})
display(Math(rf'\text{{at x = 4m, yR4B = }} {latex(yR4B)}'))
display(Math(rf'\text{{at x = 10m, yR4C = }} {latex(yR4C)}'))
display(Math(rf'\text{{at x = 16m, yR4D = }} {latex(yR4D)}'))
display(Math(rf'\text{{at x = 21m, yR4E = }} {latex(yR4E)}'))
display(Math(rf'\text{{Deflections at Redundant Points for the redundant loads is
obtained by adding the deflections at redundant points}}'))
yB2 = yR1B + yR2B + yR3B + yR4B
display(Math(rf'\text{{yB2 = yR1B + yR2B + yR3B + yR4B}}'))
display(Math(rf'\text{{yB2 = }} {latex(yB2)}'))
yC2 = yR1C + yR2C + yR3C + yR4C
display(Math(rf'\text{{yC2 = yR1C + yR2C + yR3C + yR4C}}'))
display(Math(rf'\text{{yC2 = }} {latex(yC2)}'))
yD2 = yR1D + yR2D + yR3D + yR4D
display(Math(rf'\text{{yD2 = yR1D + yR2D + yR3D + yR4D}}'))
display(Math(rf'\text{{yD2 = }} {latex(yD2)}'))
yE2 = yR1E + yR2E + yR3E + yR4E
display(Math(rf'\text{{yE2 = yR1E + yR2E + yR3E + yR4E}}'))
display(Math(rf'\text{{yE2 = }} {latex(yE2)}'))
display(Math(rf'\text{{Compatibility Equations}}'))
display(Math(rf'\text{{yB1 + yB2 = 0, yC1 + yC2 = 0, yD1 + yD2 = 0, yE1 + yE2 =
0}}'))
eq1 = sp.Eq((yB1.subs({EI:1}) + yB2.subs({EI:1})),0)
eq2 = sp.Eq((yC1.subs({EI:1}) + yC2.subs({EI:1})), 0)
Page 20 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219
 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

eq3 = sp.Eq((yD1.subs({EI:1}) + yD2.subs({EI:1})), 0)

eq4 = sp.Eq((yE1.subs({EI:1}) + yE2.subs({EI:1})), 0)
display(Math(f'Equation 1:{latex(eq1)}'))
display(Math(f'Equation 2: {latex(eq2)}'))
display(Math(f'Equation 3: {latex(eq3)}'))
display(Math(f'Equation 4: {latex(eq4)}'))
display(Math(rf'\text{{Solving the simultaneous equations}}'))
solution = sp.solve((eq1, eq2, eq3, eq4), (R_B, R_C, R_D, R_E))
display(solution)
display(Math(rf'\text{{The values for the redundants are as follows:}}'))
display(Math(rf'R_B\text{{ = }} {latex(solution[R_B])} kN =
{latex(solution[R_B].n())} kN'))
display(Math(rf'R_C\text{{ = }} {latex(solution[R_C])} kN =
{latex(solution[R_C].n())} kN'))
display(Math(rf'R_D\text{{ = }} {latex(solution[R_D])} kN =
{latex(solution[R_D].n())} kN'))
display(Math(rf'R_E\text{{ = }} {latex(solution[R_E])} kN =
{latex(solution[R_E].n())} kN'))

The CAS Package (Output of the Program)

FORCE METHOD
This is a method of analysing statically indeterminate structure. The degree of
redundancy is first determined. This is a method of analysing statically indeterminate
structure. The degree of redundancy is first determined. Decision is taking on the
forces or reactions to be considered as redundants. The redundants are released, so the
resultant released structure Decision is taking on the forces or reactions to be
considered as redundants. The redundants are released, so the resultant released
structure is statically determinate. The redundants are considered separately as the only
loads on the structure. For example, figure 1 is ais statically determinate. The
redundants are considered separately as the only loads on the structure. For example,
figure 1 is a statically indeterminate structure. The structure has 4 degrees of
redundancy. The four internal reactions are considered as the redundants and, statically
indeterminate structure. The structure has 4 degrees of redundancy. The four internal
reactions are considered as the redundants and, therefore, released. Figure 2 is the
released strucute and figure 3 the redundant loads. therefore, released. Figure 2 is the
released strucute and figure 3 the redundant loads.
To determine the values of the redundant forces, compatibility of displacements are
established at the releasedTo determine the values of the redundant forces,
compatibility of displacements are established at the released redundant points.
Page 21 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219
 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

Displamenets are determined at the released points from the released structure and the
redundant loads,redundant points. Displamenets are determined at the released points
from the released structure and the redundant loads, and compability are ensured with
the original structure, before releasing the redundants. and compability are ensured
with the original structure, before releasing the redundants. Calculating deflections at
points of redundant Calculating deflections at points of redundant The released
strucuture is a simply supply supported beam suppoting both UDL and Point LoadsThe
released strucuture is a simply supply supported beam suppoting both UDL and Point
Loads.
We need to generate deflection equations for simply supported beam separately
supporting uniformly distributed load and separately supporting point loadsWe need
to generate deflection equations for simply supported beam separately supporting
uniformly distributed load and separately supporting point loads.

Starting with simply supported beam supporting uniformly distributed load

𝑤𝐿𝑥 𝑤𝑥 2 𝑑2𝑦
𝑀= − , (𝐸𝐼 2 )
2 2 𝑑𝑥
𝑑2𝑦 𝑤𝐿𝑥 𝑤𝑥 2
= −𝑀, (𝐸𝐼 2 ) + − =0
𝑑𝑥 2 2
Solving the differential we have:
𝑤𝐿3 𝑥 𝑤𝐿𝑥 3 𝑤𝑥 3
𝑦𝑢𝑑𝑙 = − +
24𝐸𝐼 12𝐸𝐼 24𝐸𝐼
substituting, w = 15, L = 26
5𝑥 4 65𝑥 3 10986𝑥
𝑦𝑢𝑑𝑙 = − +
8𝐸𝐼 2𝐸𝐼 𝐸𝐼
Substitute, x = 4, for deflection at first redundant point
42020
𝑦𝑢𝑑𝑙𝐵1 =
𝐸𝐼
Substitute, x = 10, for deflection at first redundant point
836000
𝑦𝑢𝑑𝑙𝐶1 =
𝐸𝐼
Substitute, x = 16, for deflection at first redundant point
836000
𝑦𝑢𝑑𝑙𝐷1 =
𝐸𝐼
Substitute, x = 21, for deflection at first redundant point
410025
𝑦𝑢𝑑𝑙𝐸1 =
8𝐸𝐼
Next is to calculate deflections due the Point loads
Deflections at redundant points due to point load of 42kN

Page 22 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219

 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

At 42kN Point Load (P = 42, L = 26, a = 6, b = 20)

7. (26[𝑥 − 𝑎]3 − 20𝑥 3 + 5520𝑥)
𝑦𝑃1 =
26𝐸𝐼
5600 12904 113400 64575
𝑦𝑃1𝐵 = , 𝑦𝑃1𝐶 = , 𝑦𝑃1𝐷 = , 𝑦𝑃1𝐸 =
𝐸𝐼 13𝐸𝐼 13𝐸𝐼 13𝐸𝐼
At 30kN Point Load (P = 30, L = 26, a = 13, b = 13)
5. (26[𝑥 − 𝑎]3 − 13𝑥 3 + 6591𝑥)
𝑦𝑃2 =
26𝐸𝐼
4910 10175 10175
𝑦𝑃2𝐵 = , 𝑦𝑃2𝐶 = , 𝑦𝑃2𝐷 = , 𝑦𝑃2𝐸
𝐸𝐼 𝐸𝐼 𝐸𝐼
6025
=
𝐸𝐼
At 48kN Point Load (P = 48, L = 26, a = 18, b = 8)
4. (26[𝑥 − 𝑎]3 − 8𝑥 3 + 4896𝑥)
𝑦𝑃3 =
13𝐸𝐼
76288 163840 182272 117720
𝑦𝑃3𝐵 = , 𝑦𝑃3𝐶 = , 𝑦𝑃3𝐷 = , 𝑦𝑃3𝐸 =
13𝐸𝐼 13𝐸𝐼 13𝐸𝐼 13𝐸𝐼
We now calculate the deflections at redundant points for the released structure
759178
𝑦𝐵1 = 𝑦𝑢𝑑𝑙𝐵1 + 𝑦𝑃1𝐵 + 𝑦𝑃2𝐵 + 𝑦𝑃3𝐵, 𝑦𝐵1 =
13𝐸𝐼
116303
𝑦𝐶1 = 𝑦𝑢𝑑𝑙𝐶1 + 𝑦𝑃1𝐶 + 𝑦𝑃2𝐶 + 𝑦𝑃3𝐶, 𝑦𝐶1 =
𝐸𝐼
116519
𝑦𝐷1 = 𝑦𝑢𝑑𝑙𝐷1 + 𝑦𝑃1𝐷 + 𝑦𝑃2𝐷 + 𝑦𝑃3𝐷, 𝑦𝐷1 =
𝐸𝐼
7415285
𝑦𝐸1 = 𝑦𝑢𝑑𝑙𝐸1 + 𝑦𝑃1𝐸 + 𝑦𝑃2𝐸 + 𝑦𝑃3𝐸, 𝑦𝐸1 =
104𝐸𝐼
Next is to calculate deflection at redundant point due to redundant loads
𝑃.(𝐿[𝑥−𝑎]3 +𝑎𝑏𝑥(𝐿+𝑏)−𝑏𝑥 2 )
Recall deflection equation for point load = 6𝐸𝐼𝐿
Starting with 𝑅𝐵 as the redundant load
3872𝑅𝐵 6464𝑅𝐵
𝑎𝑡 𝑥 = 4𝑚, 𝑦𝑅1𝐵 = − , 𝑎𝑡 𝑥 = 10𝑚, 𝑦𝑅1𝐶 = −
39𝐸𝐼 39𝐸𝐼
5600𝑅𝐵 3175𝑅𝐵
𝑎𝑡 𝑥 = 16𝑚, 𝑦𝑅1𝐷 = − 𝑎𝑡 𝑥 = 21𝑚, 𝑦𝑅1𝐸 = −
39𝐸𝐼 39𝐸𝐼
with 𝑅C as the redundant load
6464𝑅𝐶 12800𝑅𝐶
𝑎𝑡 𝑥 = 4𝑚, 𝑦𝑅2𝐵 = − 𝑎𝑡 𝑥 = 10𝑚, 𝑦𝑅2𝐶 = −
39𝐸𝐼 39𝐸𝐼
11900𝑅𝐶 13775𝑅𝐶
𝑎𝑡 𝑥 = 16𝑚, 𝑦𝑅2𝐷 = − 𝑎𝑡 𝑥 = 21𝑚, 𝑦𝑅2𝐸 = −
39𝐸𝐼 78𝐸𝐼
with 𝑅D as the redundant load

Page 23 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219

 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

5600𝑅𝐷 11900𝑅𝐷
𝑎𝑡 𝑥 = 4𝑚, 𝑦𝑅3𝐵 = − , 𝑎𝑡 𝑥 = 10𝑚, 𝑦𝑅3𝐶 = −
39𝐸𝐼 39𝐸𝐼
12800𝑅𝐷 7900𝑅𝐷
𝑎𝑡 𝑥 = 16𝑚, 𝑦𝑅3𝐷 = − 𝑎𝑡 𝑥 = 21𝑚, 𝑦𝑅3𝐸 = −
39𝐸𝐼 39𝐸𝐼
with 𝑅E as the redundant load
3175𝑅𝐸 13775𝑅𝐸
𝑎𝑡 𝑥 = 4𝑚, 𝑦𝑅4𝐵 = − , 𝑎𝑡 𝑥 = 10𝑚, 𝑦𝑅4𝐶 = −
39𝐸𝐼 78𝐸𝐼
7900𝑅𝐸 3675𝑅𝐸
𝑎𝑡 𝑥 = 16𝑚, 𝑦𝑅4𝐷 = − , 𝑎𝑡 𝑥 = 21𝑚, 𝑦𝑅4𝐸 = −
39𝐸𝐼 26𝐸𝐼
Deflections at Redundant Points for the redundant loads is obtained by adding the
deflections at redundant points
𝑦𝐵2 = 𝑦𝑅1𝐵 + 𝑦𝑅2𝐵 + 𝑦𝑅3𝐵 + 𝑦𝑅4𝐵
3872𝑅𝐵 6464𝑅𝐶 5600𝑅𝐷 3175𝑅𝐸
𝑦𝐵2 = − − − −
39𝐸𝐼 39𝐸𝐼 39𝐸𝐼 39𝐸𝐼
𝑦𝐶2 = 𝑦𝑅1𝐶 + 𝑦𝑅2𝐶 + 𝑦𝑅3𝐶 + 𝑦𝑅4𝐶
6464𝑅𝐵 12800𝑅𝐶 11900𝑅𝐷 13775𝑅𝐸
𝑦𝐶2 = − − − −
39𝐸𝐼 39𝐸𝐼 39𝐸𝐼 78𝐸𝐼
𝑦𝐷2 = 𝑦𝑅1𝐷 + 𝑦𝑅2𝐷 + 𝑦𝑅3𝐷 + 𝑦𝑅4𝐷
5600𝑅𝐵 11900𝑅𝐶 12800𝑅𝐷 7900𝑅𝐸
𝑦𝐷2 = − − − −
39𝐸𝐼 39𝐸𝐼 39𝐸𝐼 39𝐸𝐼
𝑦𝐸2 = 𝑦𝑅1𝐸 + 𝑦𝑅2𝐸 + 𝑦𝑅3𝐸 + 𝑦𝑅4𝐸
3175𝑅𝐵 13775𝑅𝐶 7900𝑅𝐷 3675𝑅𝐸
𝑦𝐸2 = − − − −
39𝐸𝐼 78𝐸𝐼 39𝐸𝐼 26𝐸𝐼
Compatibility EquationsCompatibility Equations
𝑦𝐵1 + 𝑦𝐵2 = 0, 𝑦𝐶1 + 𝑦𝐶2 = 0, 𝑦𝐷1 + 𝑦𝐷2 = 0, 𝑦𝐸1 + 𝑦𝐸2 = 0
3872𝑅𝐵 6464𝑅𝐶 5600𝑅𝐷 3175𝑅𝐸 759178
𝐸𝑞𝑢𝑎𝑡𝑖𝑜𝑛 1: − − − − + =0
39𝐸𝐼 39𝐸𝐼 39𝐸𝐼 39𝐸𝐼 13𝐸𝐼
6464𝑅𝐵 12800𝑅𝐶 11900𝑅𝐷 13775𝑅𝐸 116303
𝐸𝑞𝑢𝑎𝑡𝑖𝑜𝑛 2: − − − − + =0
39𝐸𝐼 39𝐸𝐼 39𝐸𝐼 78𝐸𝐼 𝐸𝐼
5600𝑅𝐵 11900𝑅𝐶 12800𝑅𝐷 7900𝑅𝐸 116519
𝐸𝑞𝑢𝑎𝑡𝑖𝑜𝑛 3: − − − − + =0
39𝐸𝐼 39𝐸𝐼 39𝐸𝐼 39𝐸𝐼 𝐸𝐼
3175𝑅𝐵 13775𝑅𝐶 7900𝑅𝐷 3675𝑅𝐸 7415285
𝐸𝑞𝑢𝑎𝑡𝑖𝑜𝑛 4: − − − − + =0
39𝐸𝐼 78𝐸𝐼 39𝐸𝐼 26𝐸𝐼 104𝐸𝐼
Solving the simultaneous equations
11785243 12431641 819435343 35766798
{𝑅𝐵 : , 𝑅𝐶 : , 𝑅𝐷 : , 𝑅𝐸 : }
101916 101916 6369750 353875
The values for the redundants are as follows:
11785243
𝑅𝐵 = 𝑘𝑁 = 115.63682836846kN , 𝑅𝐶
101916
12431641
= 𝑘𝑁 =121.979286863692kN
101916
Page 24 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219
 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

819435343
𝑅𝐷 = 𝑘𝑁 = 128.644820126379kN, 𝑅𝐸
6369750
35766798
= 𝑘𝑁 = 101.071841752031kN
353875

Discussion of Results
The result has shown that training content delivery in structural analysis can be
documented for digital transformation. It has been digitally transformed. Not only was
the digital transformation possible, but the training content was accurately presented
by the CAS program and an independent training module has been produced with
study materials, which has been accurately presented by the Jupyter Notebool. SymPy
together with Jupyter Notebook provides a powerful tool and platform for training and
teaching delivery. The output from the use of the duo, is natural and elegant. SymPy
has proven to be powerful in terms of performing analysis symbolically. In this work,
SymPy produces accurate results in the treatment of differential equations as well as
solution to series of simultaneous equations. Sympy produces results of symbolic
analysis in fraction, rather than decimal, thereby, ensuring accuracy of results. Jupyter
Notebook has been used as a training platform and works well with SymPy, by
producing the output of symbolic results in their natural form. Combination of SymPy
and Jupyter Notebook, shows that, CAS can be utilized by all professionals.

Conclusion
A module in structural analysis, that depend not only on solution to simultaneous
equation, but differential equations as well, was implement using SymPy and Jupyter
Notebook. SymPy has proven itself as a powerful tool when it comes to computer
algebra system and a readily available platform for the development of teaching and
learning aid in structural analysis. SymPy libraries made provision for handling
problems associated with various aspects of structural analysis. It has successfully
symbolically solved differential equations associated with deflections and
simultaneous equations resulting from analysis. Its flexibility for allowing users to
define symbols make the process natural and the output from Jupyter Notebook, in
conformity with expectations. The use and application of SymPy is easy and
straightforward. SymPy is self-contained, the teaching-aid was implemented largely,
using SymPy. Jupyter Note provides the platform for the natural and well acceptable
output of the CAS.

Recommendations
The following are offered as recommendations:
• Structural trainers to invest in the use CAS for training content delivery.
Page 25 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219
 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

• Professional bodies of the building and engineering professions to organise

training workshops for their members on the use and application of CAS.
• Institutions of higher learning are encouraged to consider including CAS in
education and training curriculum.
• Further work be carried out on the use of SymPy and Jupyter Notebook CAS
ability for training in structural analysis.

References
Aslam Kassimali. (2012). Structural Analysis Fourth Edition. In Southern Illinois University—Carbondale (Vol. 53, Issue 9).
Baduge, S. K., Thilakarathna, S., Perera, J. S., Arashpour, M., Sharafi, P., Teodosio, B., Shringi, A., & Mendis, P. (2022).
Artificial intelligence and smart vision for building and construction 4.0: Machine and deep learning methods and
applications. In Automation in Construction (Vol. 141). https://doi.org/10.1016/j.autcon.2022.104440
Bascuñana, J., León, S., González-Miquel, M., González, E. J., & Ramírez, J. (2023). Impact of Jupyter Notebook as a tool to
enhance the learning process in chemical engineering modules. Education for Chemical Engineers, 44.
https://doi.org/10.1016/j.ece.2023.06.001
Brown, J. (2018). Using Jupyterhub in the Classroom : Setup and Lessons Learned. International Journal of Software Engineering
& Applications, 9(2). https://doi.org/10.5121/ijsea.2018.9201
Castilla, R., & Peña, M. (2023). Jupyter Notebooks for the study of advanced topics in Fluid Mechanics. Computer Applications
in Engineering Education, 31(4). https://doi.org/10.1002/cae.22619
Colonnelli, I., Aldinucci, M., Cantalupo, B., Padovani, L., Rabellino, S., Spampinato, C., Morelli, R., Di Carlo, R., Magini, N.,
& Cavazzoni, C. (2022). Distributed workflows with Jupyter. Future Generation Computer Systems, 128.
https://doi.org/10.1016/j.future.2021.10.007
Connor, J. J., & Faraji, S. (2016). Fundamentals of structural engineering: Second edition. In Fundamentals of Structural
Engineering: Second Edition. https://doi.org/10.1007/978-3-319-24331-3
Cywiak, M., & Cywiak, D. (2021). SymPy. In Multi-Platform Graphics Programming with Kivy. https://doi.org/10.1007/978-1-
4842-7113-1_11
Galán–García, J. L., Rodríguez–Cielos, P., Galán–García, M. Á., le Goff, M., Padilla–Domínguez, Y., Rodríguez-Padilla, P.,
Atencia, I., & Aguilera–Venegas, G. (2023). SODES: Solving ordinary differential equations step by step. Journal of
Computational and Applied Mathematics, 428. https://doi.org/10.1016/j.cam.2023.115127
Ghali, A., Neville, A. M., & Brown, T. G. (2017). Structural Analysis: A unified classical and matrix approach, Sixth edition. In
Structural Analysis: A Unified Classical and Matrix Approach, Sixth Edition. https://doi.org/10.1201/9781315273006
Hamrick, J. B. (2016). Creating and Grading IPython/Jupyter Notebook Assignments with NbGrader.
https://doi.org/10.1145/2839509.2850507
Hibbeler, R. (2017). Structural Analysis Tenth Edition. Pearson.
Ipython, T., & Team, D. (2011). IPython Documentation. Development, 3.
Kamalov, F., Santandreu, D., Leung, H. H., Johnson, J., & El Khatib, Z. (2023). Leveraging computer algebra systems in calculus:
A case study with SymPy. IEEE Global Engineering Education Conference, EDUCON, 2023-May.
https://doi.org/10.1109/EDUCON54358.2023.10125196
Karjanto, N., & Husain, H. S. (2021). Not another computer algebra system: Highlighting wxmaxima in calculus. Mathematics,
9(12). https://doi.org/10.3390/math9121317
Katayama, S., & Ohtsuka, T. (2020). Automatic code generation tool for nonlinear model predictive control with Jupyter. IFAC-
PapersOnLine, 53(2). https://doi.org/10.1016/j.ifacol.2020.12.447
Kaufmann, J., & Held, K. (2023). ana_cont: Python package for analytic continuation. Computer Physics Communications, 282.
https://doi.org/10.1016/j.cpc.2022.108519
Ketcheson, D. (2014). Teaching numerical methods with IPython notebooks and inquiry-based learning. Proceedings of the 13th
Python in Science Conference. https://doi.org/10.25080/majora-14bd3278-004
Kim, E., & Duggirala, P. S. (2020). Kaa: A python implementation of reachable set computation using bernstein polynomials.
EPiC Series in Computing, 74. https://doi.org/10.29007/rs5n
Kopei, V. B., Onysko, O. R., & Panchuk, V. G. (2019). Component-oriented acausal modeling of the dynamical systems in
Python language on the example of the model of the sucker rod string. PeerJ Computer Science, 2019(10).
https://doi.org/10.7717/peerj-cs.227
Kuhlman, D. (2013). A Python Book: Beginning Python, Advanced Python, and Python Exercises. A Python Book.
Mehare, H. Bin, Anilkumar, J. P., & Usmani, N. A. (2023). The Python Programming Language. In A Guide to Applied Machine
Learning for Biologists. https://doi.org/10.1007/978-3-031-22206-1_2
Meurer, A., Smith, C. P., Paprocki, M., Čertík, O., Kirpichev, S. B., Rocklin, M., Kumar, A., Ivanov, S., Moore, J. K., Singh, S.,
Rathnayake, T., Vig, S., Granger, B. E., Muller, R. P., Bonazzi, F., Gupta, H., Vats, S., Johansson, F., Pedregosa, F., …
Scopatz, A. (2017a). SymPy: Symbolic computing in python. PeerJ, 3. https://doi.org/10.7287/peerj.preprints.2083
Meurer, A., Smith, C. P., Paprocki, M., Čertík, O., Kirpichev, S. B., Rocklin, M., Kumar, Am. T., Ivanov, S., Moore, J. K., Singh,
S., Rathnayake, T., Vig, S., Granger, B. E., Muller, R. P., Bonazzi, F., Gupta, H., Vats, S., Johansson, F., Pedregosa, F., …
Scopatz, A. (2017b). SymPy: Symbolic computing in python. PeerJ Computer Science, 2017(1).
https://doi.org/10.7717/peerj-cs.103

Page 26 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219

 Journal of Scientific Development Research JSDR2023 [E-ISSN 3026-9989 P-ISSN 3027-0219] Vol. 2

Mezhennaya, N. M., & Pugachev, O. V. (2019). On perception of computer algebra systems and microsoft excel by engineering
students. Problems of Education in the 21st Century, 77(3). https://doi.org/10.33225/pec/19.77.379
Paffenroth, R., & Kong, X. (2015). Python in Data Science Research and Education. Proceedings of the 14th Python in Science
Conference. https://doi.org/10.25080/majora-7b98e3ed-019
Pawlik, A., Segal, J., Sharp, H., & Petre, M. (2015). Crowdsourcing scientific software documentation: A case study of the
NumPy documentation project. Computing in Science and Engineering, 17(1). https://doi.org/10.1109/MCSE.2014.93
Pérez, F., & Granger, B. E. (2007). IPython: A system for interactive scientific computing. Computing in Science and
Engineering, 9(3). https://doi.org/10.1109/MCSE.2007.53
Quraishi, M. A., & Dhapekar, M. N. K. (2021). Applicability of Python in Civil Engineering: Review. International Research
Journal of Engineering and Technology, 8(1).
Rule, A., Birmingham, A., Zuniga, C., Altintas, I., Huang, S. C., Knight, R., Moshiri, N., Nguyen, M. H., Rosenthal, S. B., Pérez,
F., & Rose, P. W. (2019). Ten simple rules for writing and sharing computational analyses in Jupyter Notebooks. In PLoS
Computational Biology (Vol. 15, Issue 7). https://doi.org/10.1371/journal.pcbi.1007007
Seddighi, M., Allanson, D., Rothwell, G., & Takrouri, K. (2020). Study on the use of a combination of IPython Notebook and an
industry-standard package in educating a CFD course. Computer Applications in Engineering Education, 28(4).
https://doi.org/10.1002/cae.22273
Stewart, J. M. (2017). SymPy: A Computer Algebra System. In Python for Scientists. https://doi.org/10.1017/9781108120241.009
Stewart, J. M., & Mommert, M. (2023a). About Python. In Python for Scientists. https://doi.org/10.1017/9781009029728.003
Stewart, J. M., & Mommert, M. (2023b). SymPy: Symbolic Math. In Python for Scientists.
https://doi.org/10.1017/9781009029728.008
Suárez-García, A., Arce-Fariña, E., Álvarez Hernández, M., & Fernández-Gavilanes, M. (2021). Teaching structural analysis
theory with Jupyter Notebooks. Computer Applications in Engineering Education, 29(5). https://doi.org/10.1002/cae.22383
Thomas, R., & Cholia, S. (2021). Interactive Supercomputing with Jupyter. Computing in Science and Engineering, 23(2).
https://doi.org/10.1109/MCSE.2021.3059037
Wang, J., & Wang, A. (2023). Python Tutorial. https://doi.org/10.1007/978-3-031-17646-3_2
Zemkoho, A. (2023). A Basic Time Series Forecasting Course with Python. Operations Research Forum, 4(1).
https://doi.org/10.1007/s43069-022-00179-z

Page 27 JSDR Vol. 2 (2) 2023 E-ISSN 3026-9989 P-ISSN 3027-0219