Solving

Linear and Nonlinear

Equations
An Insight for Engineers,
with Applications

Prepared by:
Dr. Gokhan Bingol ([email protected])
November 16, 2024
(Initial publication: February 10, 2022)
Document version: 4.0

Process Engineering Documents: https://www.pebytes.com/pubs

Follow on GitHub: https://github.com/gbingol
1. Introduction

Before the use of computers, there were several ways to solve algebraic and transcendental equations. In
some cases, the roots could be obtained by direct methods, however many other equations could not be
solved directly (Chapra & Canale 2013). The linear and nonlinear equations have arisen not only in many
aspects of process engineering analysis but also in many machine learning (ML) and artificial intelligence
(AI) methods. Therefore, mastering the methods to obtain the solutions of these equations is not only
essential to be able to understand, analyze and design engineering systems but also enables engineers to
tackle a range of ML/AI challenges, from predictive modeling to feature extraction.

Given the abundance of tools at our disposal, students generally question whether it is necessary to learn
the methods presented in this work. The answer is, it depends. If one only needs to solve a single equation
that can be conveniently plotted, then this approach would probably be the best. On the other hand, if the
equation is generated by say Process A and Process B needs the solution to continue its computation then
the need to numerically solve the equations arises. Even without the knowledge of any of the methods in
the following sections, it is still possible to “numerically” find the root of a given function by writing a
simple code. Let’s work on finding the root of f(x) = x2-5 = 0 in the interval of [0, 4].

Script 1.1
import numpy as np

n=1
while True:
x = np.linspace(start=0, stop=4, num=10**n)
y = np.fabs(x**2 - 5)

index = np.argwhere(y<1E-5)
if len(index)==0:
n += 1
continue
print(f"Generated {10**n} numbers and root={x[index]}")
break
Generated 1,000,000 numbers and root=[[2.23607]]

Note that somewhere between 100,000 to one million linearly spaced numbers has to be generated to be
able to find the root with a tolerance of 10 -5. Needless to say, this also means that the function has to be
evaluated over 100,000 times.
If all we were interested in was finding the solution of the equation, then the above approach should work
fairly well; however, it drastically suffers from the performance point of view. If the solution was needed
many times such approach could have been clearly the bottleneck. Of course, the above approach was a
rather naive way of solving the equation but clearly demonstrated the need for better approaches. Let’s try
a different way to solve the same problem:

Script 1.2
f = lambda x: x**2 - 5

x0 = 5 #initial guess
length, TOL = 1, 1E-5
iter = 0 #number of iterations

while True:
iter += 1

fx = f(x0)
if abs(fx)<TOL:
break

x0 = x0 - length if fx>0 else x0+length

length /= 1 if abs(fx)>1 else 2

print(x0, iter)
2.23607 24

This approach is significantly better than our first attempt (Script 1.1) since the number of iterations is
reduced from over 100,000 to only 24.

In the following sections, you'll find methods that, with the help of modern computers, make solving
complex equations efficient. The target audience of the current work is engineers and therefore this
document assumes the reader already has some background in calculus, numerical analysis and a basic to
intermediate knowledge of Python programming language. Throughout, you’ll encounter detailed, real-
world engineering examples designed to bring these methods to life and deepen your understanding.

3
2. Bracketing Methods

Intermediate value theorem: A continuous function whose domain contains the interval [a, b] takes any
value between f(a) and f(b) at some point in the interval (Wikipedia, 2023)1.

Bolzano's theorem: This is a corollary to intermediate value theorem and states that if a continuous
function has values of opposite sign inside an interval, say [a, b], then it has a root in that interval.

It is due to Bolzano’s theorem that the numeric methods using bracketing methods, which rely on the fact
that the signs of f(a) and f(b) are different, force that f(a) and f(b) must have different signs. Once a proper
choice of [a, b] is made, bracketing methods guarantee that a root will be found.

For example, if we attempt to solve f(x) = x2-5 = 0 using bracketing methods and if the interval is chosen
to be [3, 5], since f(3)f(5)>0 an error will be raised:

Script 2.1
from scisuit.roots import bisect

f = lambda x: x**2-5
result = bisect(f=f, a = 3, b = 5 )
RuntimeError: Func has same sign at both bounds.

One should note that the condition f(a)·f(b)>0 does not necessarily imply that there is no root, it only tells
us that we are not guaranteed to find a root. Instead of choosing a=3, if one chooses a=0:

Script 2.2
result = bisect(f=f, a = 0, b = 5 )
print(result)
Bisection using brute-force method
Root=2.23607, Error=9.54e-06 (18 iterations).

It is observed that a root has been found since f(a)·f(b)<0, and therefore according to Bolzano’s theorem
there lies at least one root in the interval. However, note that f(a)·f(b)<0 does not guarantee that there is
only a single root in the interval and according to Smith 2 (1998) when an equation has multiple roots, it is
the choice of the initial interval which determines which root is located.

1 https://en.wikipedia.org/wiki/Intermediate_value_theorem
2 Smith, MD (1998). https://web.mit.edu/10.001/Web/Course_Notes/NLAE/node2.html
2.1. Bisection method
Bisection method uses two different approaches to locate the root:

A) Brute force,
B) False position (Regula falsi).

2.1.1) Brute force

a+b a+ x 0
The initial interval [a, b] is halved x 0= , x 1= ,.. . until the requested tolerance is satisfied
2 2
assuming each xn is closer to the root as n increases.

Note that the numerator of the above-given equation for x1

could have b instead of a depending on the sign of f(x0). Since
f(x0)>0, b was replaced with x0.

Figure 2.1: Brute force method

Example 2.1: Find the root of f(x) = x2-5 = 0.

from scisuit.roots import bisect

result = bisect(lambda x: x**2-5, a = 0, b = 4)

print(result)
Bisection using brute-force method
Root=2.23606, Error=3.35e-06 (18 iterations).

It is seen that the brute-force approach required 18 iterations to reach the root (compare with Scripts 1.1 &
1.2). Oliveira & Takahashi (2020) remarks that typically bisection method produces an estimate with a
precision higher than needed. In line with that, although the tolerance level was set to 10 -5, the method
yielded an error in the order of 10 -6. It is insightful to take a look under the hood to see how the bisect
function actually found the root:

5
 Table 2.1: Working internals of bisection method
iter a b xn f(a) f(b) f(xn) Error
1 0 4 2 -5 11 -1
2 2 4 3 -1 11 4 1
...
6 2.125 2.25 2.1875 -0.484375 0.0625 -0.214844 0.0625
...
17 2.236053 2.236084 2.236069 -0.000065 0.000072 0.000003 0.000015
18 2.236053 2.236069 2.236061 -0.000065 0.000003 -0.000031 0.000008

In the 1st iteration the bounds were [0, 4], which were provided by the user, and therefore the midpoint
X1=2. Since in the 1st iteration f(X1) = -1 < 0 therefore in the 2nd iteration the lower bound, a, was replaced
with X1 and therefore [2, 4] became as the new brackets containing the root. Observe that the length of the
interval is always halved (1st = 4 -0 = 4, 2nd = 2).

We might assume that each and every iteration strictly brings us closer to the true root. Although, the
overall number of iterations indeed does that, while finding to the root, as seen from Fig. (2.2), the true
error might show some oscillations.

40
% True Relative Error

35
30 Note that while in the 1st iteration the true error
25 was around 10% (X1=2), in the 2nd iteration it
20
15 suddenly increased to approximately 35% (X2=3).
10
5
0
0 2 4 6 8 10 12 14 16 18 20
iterations

Figure 2.2: True error per iteration

Food for thought
This section can be skipped without loss of continuity. However, it provides a different perspective to the
definition of error and therefore is a recommended read. Consider the following plot which shows number
of iterations vs error from the data presented in Table (2.1).

0.8 Observe that fitting an exponential trendline

f(x) = 4.00281 exp( − 0.69324 x )
0.6 R² = 1.00000
gave a perfect R2 of 1.000
Error

0.4

0.2

0
0 2 4 6 8 10 12 14 16 18 20
iterations

Figure 2.3: Error |Xn+1-Xn| per iteration

The question we would like to pose here: Was the perfect fit of exponential trendline by chance? Was
there some rationale behind it?

Noting that in brute-force, the interval is halved, we can write a simple differential equation as follows:

dE
=kE
dn

which can be simply read as “the change of error per iteration is proportional to the existing error”,
which completely overlaps with the definition of brute-force. Using the data in Table 2.1, the value of k
can easily be computed as -0.69314. Note that the negative sign of k tells that the error decreases. Solving
the simple differential equation, it can be found that error at nth iteration:

E0
En=
2n

In a process engineering sense the differential equation approach to the error can be interpreted as that the
error in brute-force methodology follows a 1st order “reaction” kinetics.

7
2.1.2) Regula falsi

The brute force approach only halves the interval and does not use any information coming from the
values of f(a) and f(b). For example, if the value of f(a) is closer to zero than f(b), then it is very likely that
a is closer to the root than b.

Instead of halving the interval a line is defined between

[a, f(a)] and [b, f(b)] and the intersection of this line with
the x-axis (xr) replaces a or b depending on the sign of
f(xr).

Figure 2.4: Bisection method using regula falsi

The improved estimate of the true root, xr, can easily be found by two approaches:

1) Writing the equation of line between [a, f(a)] and [b, f(b)], which will yield Eq. (2.1):

f (b)⋅(a−b) (2.1)
x r=b−
f (a)−f (b)

2) Using the triangle similarity between [a, f(a), xr] and [b, f(b), xr] in Fig. (2.4) will give Eq.(2.2):

f (b)⋅a−f (a)⋅b (2.2)

x r=
f (b)−f (a)

Eq. (2.1) is recommended by Chapra & Canale (2013) and Press et al. (2007) whereas Eq. (2.2) is used
by more recent literature such as Gupta (2019) and Wikipedia (2022)3.

If the function is strictly monotone in the chosen interval, the regula falsi approach requires less iterations
than brute force. For example, in the interval [0, 4] f(x) = x2-5 = 0 is strictly monotone and therefore in

3 Wikipedia (2022). https://en.m.wikipedia.org/wiki/Regula_falsi

Example (2.2) it is observed that compared to brute-force approach (example 2.1), regula falsi approach
required 6 less iterations to find the root.

Example 2.2: Find the root of f(x) = x2-5 = 0 using regula-falsi.

result = bisect(lambda x: x**2-5, a = 0, b = 4, method = ("rf", False))
print(result)
Bisection using regula falsi method
Root=2.23607, Error=2.97e-06 (12 iterations).

Unlike Example (2.2), if the function’s value is nearly constant in the chosen interval, such as f(x)=x10-1 in
[0, 1.3], then the steps taken at each iteration will be very small and thus can lead to a very slow
convergence. In these cases, the brute force approach can yield considerably faster convergence than
regula-falsi.

Example 2.3: Finding the root of f(x) = x10-1 = 0.

#brute force
bf = bisect(lambda x: x**10-1, a = 0, b = 1.3)

#regula falsi
rf = bisect(lambda x: x**10-1, a = 0, b = 1.3, method=("rf", False))

print(bf)
print(rf)
Bisection using brute-force method
Root=1.00000, Error=9.92e-06 (17 iterations).

Bisection using regula falsi method

Root=1.00000, Error=2.66e-07 (61 iterations).

2.1.3) Modified regula falsi

Fig. (2.5) shows the change of bounds during each iteration for f(x) = x10-1 in the interval of [0, 1.3] when
regula falsi method was used. It is seen that only the lower bound (a) changed whereas the upper bound
(b) never changed. In other words, the upper bound was stagnant and this stagnation caused slow
convergence.

9
 When regula falsi without modification
was used, the upper bound’s value
remained same, whereas only the lower
bound’s value changed.

Figure 2.5: Change of bounds when using regula falsi

One way to alleviate the problem of slow convergence for functions with nearly constant values in the
interval is to modify the regula falsi method by detecting the stagnant bound (the bound which is
constantly replaced by xr) and dividing the value of f(xr) by 2 as recommended by Chapra and Canale
(2013).

Example 2.4: Finding the root of f(x) = x10-1 = 0 using modified regula falsi.
#modified regula falsi
rf_modified = bisect(lambda x: x**10-1, a = 0, b = 1.3, method=("rf", True))
print(rf_modified)
Bisection using regula falsi method
Using Modified regula-falsi
Root=1.00000, Error=4.17e-09 (13 iterations).

It is seen that compared with regula falsi (Example 2.3), modified regula falsi considerably improved the
convergence rate of f(x) = x10-1. We might wonder why?

Let’s take a look under the hood:

If number of iterations vs f(b) is plotted, the effect of the strategy recommended by Chapra and Canale
(2013) can be observed, as can be seen from Fig. (2.6-B).
Figure 2.6: The application of the strategy recommended by Chapra and Canale (2013) to alleviate
stagnation, A) value of b (upper bound) vs iterations, B) value of f(b) vs iterations

It is seen from Fig. (2.6-B) that in the 2nd, 4th ... iterations when the stagnation was detected the value of
f(b) was halved. On the other hand, from Fig. (2.6-A) it is observed that even if the value of f(b) was
halved, the value of b did not change since any attempt to halve the value of b might cause the root to be
missed.

11
2.2. Ridders method
It is a powerful variant of false position method. The root is assumed to be in the interval [x0, x2].

Note that the function is defined in [x0, x2].

d = x2-x1 = x1 - x0

Figure 2.7: Adapted from Ridders (1979)

Similar to brute force method, F(x) is first evaluated at the midpoint:

x0 + x2 (2.3)
x 1=
2
Then a non-linear function is defined:

H (x )= F (x )e
mx (2.4)

Imposing the condition:

H 2−2 H 1 + H 0 =0 (2.5)

where H n =H ( x n ) forces the function H(x) to become linear.

Putting Eq. (2.4) into Eq. (2.5) yields:

F 2⋅e
m⋅x 2
−2 F 1 e
m⋅x 1 X0
+ F 0 e =0 (2.6)

Dividing Eq. (2.6) by e m⋅x gives the following equation:

0

2m⋅d m⋅d
F 2⋅e −2 F 1 e + F 0 =0 (2.7)

Eq. (2.7) is a quadratic equation in terms of emd. If we define α= emd then Eq. (2.7) can be rewritten as
follows:

2
F 2 α −2 F 1 α + F 0 =0 (2.8)

2
Δ=4⋅( F 1− F 0⋅F 2 )>0 and noting that F2·F0<0 (ensuring real roots), the solution of Eq. (2.8):

F 1 −sign( F 0 ) √ Δ
α= >0 (2.9)
F2

Keeping in mind that H1<0, the final step is to apply regula falsi (Eq. 2.2) between (x1, H1) and (x2, H2) to
find the new point x3 :

H 2 x 1 −H 1 x2 (2.10)
x 3=
H 2 −H 1

After dividing Eq. (2.10) by H1 and adding and subtracting x 1 to the numerator and performing
straightforward algebraic manipulation:

d (2.11)
x 3= x 1−
H 2 / H 1−1

From Eq. (2.4), it is can be found that:

H 2 F ( x2 ) e2md F ( x 2 ) md (2.12)
= = e
H 1 F( x 1 )e md F ( x 1 )

13
Placing Eqs. (2.9) and (2.12) into Eq. (2.11) yields the following equation4,5:

sign[ F( x 0 )−F ( x2 )] F( x 1 )
x 3= x 1 +(x 1 −x 0 ) (2.13)
√ F( x 1 ) − F( x 0 ) F ( x 2)
2

Example 2.5: Finding the roots of f(x) = x2 – 5 = 0 and f(x) = x10-1 = 0

from scisuit.roots import ridder

res_x2 = ridder(lambda x: x**2-5, a = 0, b = 4)

res_x10 = ridder (lambda x: x**10-1, a = 0, b = 1.3)

print(res_x2)
print(res_x10)
Ridder's method
Root=2.23607, (3 iterations).

Ridder's method
Root=1.00000, (4 iterations).

Example (2.5) clearly illustrated that regardless of the function’s behavior after just a few iterations
Ridder’s method was able to find the root.

The convergence of Ridder’s method is quadratic, however, since it requires two function evaluations, the
actual order of the method is √2 (Press et al. 2007). Press et al. (2007) states that Ridder’s method is an
extraordinarily robust algorithm in both reliability and speed and therefore generally competitive with the
more highly developed and better established methods such as Van Wijngaarden, Dekker, and Brent.

4 The derivation is based on Ridders (1979) and in Eq. (2.13), Ridders (1979) uses sign[F(x0)] whereas Press et al.
(2007) uses sign[F(x0)-F(x2)].

5 To avoid the sign function in Eq. (2.13), Ridders (1979) recommends dividing the numerator and denominator by F(x 0).
However, for small F(x0) values, this can cause numerical instabilities, therefore scisuit uses the equation proposed by
Press et al. (2007).
2.3. Discussion
The above-mentioned bracketing methods were tested on 12 different functions at different intervals. The
tabulated data is presented in the format of number of iterations and in parenthesis the total running times.

Table 2.2: Number of iterations and running times (ms) required by different bracketing methods
f(x) Interval brute-force regula falsi modified rf Ridder
2
f1 = x ⋅(
x2
+√ 2⋅sin(x))−
√3 0, 1.2 17 (0.039) 43 (0.148) 10 (0.039) 3 (0.018)
3 18
f2 = 11⋅x 11−1 0.4, 1.6 17 (0.015) IE 23 (0.029) 4 (0.008)
35
f3 = 35⋅x −1 -0.5, 1.9 18 (0.014) IE 83 (0.098) 6 (0.010)
−9 −9 x
f4 = 2∗(x⋅e −e )+1 -0.5, 0.7 17 (0.023) 514 (0.806) 18 (0.036) 4 (0.012)
f5 = x 2−(1 – x )9 -1.4, 1 18 (0.021) IE 26 (0.047) 5 (0.015)
f6 = (x−1)⋅e−9 x + x 9 -0.8, 1.6 18 (0.024) IE 33 (0.062) 5 (0.014)
x 1
f7 = x 2+sin( )− -0.5, 1.9 18 (0.019) 28 (0.056) 11 (0.023) 4 (0.013)
9 4
1 1
f8 = ⋅(9− ) 0.001, 1.201 17 (0.012) IE 21 (0.017) 7 (0.007)
8 x
f9 = tan (x)−x – 0.046302 -0.9, 1.5 18 (0.013) 518 (0.388) 19 (0.022) 3 (0.007)
f10 = x + x⋅sin( √ 75 x) – 0.2
2
0.4, 1 16 (0.023) 7 (0.024) 9 (0.024) 3 (0.012)
10
f11 = x – 1 0, 1.3 17 (0.012) 61 (0.060) 13 (0.017) 4 (0.008)
2
f12 = x −5 0, 4 19 (0.015) 12 (0.017) 8 (0.014) 3 (0.007)
IE: Max iterations exceeded (max iteration = 1000)

It is seen that for all tested functions bisection and ridder methods converged to a root whereas regula
falsi and modified rf had problems converging to a root even when allowed to iterate up to 1000 iterations.
For example, for f2 and f5 regula falsi required 2789 and 13990 iterations, respectively.

In cases where the function’s value does not change considerably in the chosen interval, i.e. f 11 (see
appendix), in terms of number of iterations modified regula falsi performed better than brute-force which
performed considerably better than regula falsi. For a monotone function such as f12, as expected both
regula falsi and modified rf required less iterations than bisection method.

Regardless of the function’s behavior, in all cases Ridder’s method outperformed regula falsi, modified rf
and brute-force methods. However, one should note that in every iteration Ridder’s method has to

15
evaluate the function twice whereas for example brute-force only evaluates the function once per each
iteration.

Table 2.3: Runtime cost per iteration (μs / iteration)

f(x) Interval brute-force regula falsi modified rf Ridder
2
f1 = x ⋅(
x2
+√ 2⋅sin(x))−
√3 0, 1.2 2.28 3.45 3.89 5.83
3 18
f2 = 11⋅x 11−1 0.4, 1.6 0.85 NC 1.25 2.10
f3 = 35⋅x 35 −1 -0.5, 1.9 0.78 NC 1.18 1.73
−9 −9 x
f4 = 2∗(x⋅e −e )+1 -0.5, 0.7 1.34 1.57 1.98 2.95
2 9
f5 = x −(1 – x ) -1.4, 1 1.17 NC 1.82 2.90
−9 x 9
f6 = (x−1)⋅e +x -0.8, 1.6 1.31 NC 1.88 2.78
x 1
f7 = x 2+sin( )− -0.5, 1.9 1.04 2.00 2.05 3.20
9 4
1 1
f8 = ⋅(9− ) 0.001, 1.201 0.72 NC 0.79 1.06
8 x
f9 = tan (x)−x – 0.046302 -0.9, 1.5 0.70 0.75 1.15 2.27
f10 = x + x⋅sin( √ 75 x) – 0.2
2
0.4, 1 1.46 3.37 2.68 4.03
f11 = x 10 – 1 0, 1.3 0.72 0.99 1.28 1.93
2
f12 = x −5 0, 4 0.78 1.38 1.76 2.23
NC: Not converged (max iteration = 1000)

From Table (2.3), it is seen that regardless of the method applied, the runtime cost of different functions
are different. Of all tested functions, brute-force had the least runtime cost per iteration whereas Ridder’s
methods had the most, since it has to evaluate the function twice. Except one function, namely f 10,
modified regula falsi had higher runtime costs than regula falsi.

Although looking at the number of iterations it takes to find the root is a good strategy and employed in
the literature to select the applicability of a method to a certain problem, it does not suffice to win the
competition. For example, in all cases, Ridder’s method had the least number of iterations; however, in all
cases, the runtime cost per iteration of Ridder’s method was the highest, e.g. 2.5 to 3 times higher than
brute-force. Therefore, it is suggested that the overall runtime performance of a method should also be
taken into account when making a selection. Looking at Table (2.2), it is seen that of all the tested
functions Ridder’s method had the least overall runtime cost although it had the highest runtime cost per
iteration.
3. Open Methods

In the previous section we talked about bracketing methods where the root was always located within an
interval, [a, b]. It is due to this reason that the bracketing methods always converge.
converge

Unlike bracketing methods, open methods require initial value(s) that do not need to bracket the root. As
such, open methods can diverge; however, when they converge, they generally converge faster than
bracketing methods. Let’s investigate what we mean by “generally” by finding the root of f ( x)=x 10 −1
using both bracketing and open methods:

Script 3.1
from scisuit.roots import bisect, newton
f = lambda x: x**10-1

res_bisect = bisect(f=f, a = 0, b = 5 )
print(res_bisect)

res_newton = newton(f=f, x0 = 0.01, fprime=lambda x: 10*x**9)

print(res_newton)
Bisection using brute-force method
Root=0.99999, Error=9.54e-06 (19 iterations).

Newton method using (Newton-Raphson)

Could not converge to a root. Max iter exceeded.

It is seen that while bisection method located the root after 19 iterations, newton’s method exceeded
maximum iterations which was set to 100 by default (for scipy.optimize6 maxiter=50). Now if we set
maxiter to 500 and run newton’s method again:

Script 3.2
res_newton = newton(f=f, x0 = 0.01, fprime=lambda x: 10*x**9, maxiter=500)
print(res_newton)
Newton method using (Newton-Raphson)
Root=1.00000, Error=7.41e-09 (377 iterations).

377 iterations!!

6 https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.newton.html

17
Finally, let’s change our initial guess x0 to 1.3 and observe the effect:

Script 3.3
res_newton = newton(f=f, x0 = 1.3, fprime=lambda x: 10*x**9, maxiter=500)
print(res_newton)
Newton method using (Newton-Raphson)
Root=1.00000, Error=2.92e-09 (7 iterations).

7 iterations!! considerably faster than bisection method. It is clearly seen that when using open-methods
an intuition about the function can make a considerable difference not only on the performance but also on
the outcome of the method.
3.1. Newton-Raphson method
It is probably the most widely used root finding method (Chapra and Canale 2013; Press et al. 2007). As
seen from Fig. (3.1), the iteration process starts with an initial guess of the root, xi. Then using the
derivative of the function, a tangent line is drawn and its intersection with the x-axis is considered as an
improved estimate of the true root. Therefore,

f ( x i)
x i+1 =x i − (3.1)
f ' ( xi )

Eq. (3.1) tells that in order to find the root besides an initial guess, x0, the value of the function, f(x), and
the value of its derivative, f`(x), are needed at each iteration step.

The slope, m, at xi is equal to its derivative at that point. Therefore

from the figure:
f ( xi)
m=f ' ( x i )=
x i −x i+1
which is equal to Eq. (3.1).

Figure 3.1: Newton-Raphson method

Example 3.1: Find the root of f(x) = x2 – 5 = 0.

from scisuit.roots import newton

res = newton(lambda x: x**2-5, x0=1, fprime=lambda x: 2*x)

print(res)
Newton method (Newton-Raphson)
Root=2.23607, Error=9.18e-07 (5 iterations).

f(x) = x2 – 5 = 0 is monotonically increasing in the neighborhood of x0=1, therefore only 5 iterations were
required to find the root with an error of 9.18·10-7. It should also be noted that for f(x) = x2 – 5, the initial
estimate would have little effect on the performance of the method.

19
Example 3.2: Find the root of f(x) = x10 – 1 = 0.
res = newton(lambda x: x**10-1, x0=1.3, fprime=lambda x: 10*x**9)
print(res)
Newton method (Newton-Raphson)
Root=1.00000, Error=2.92e-09 (7 iterations).

However, unlike f(x) = x2 – 5 = 0, where the initial estimate of the root had minor effect on the
performance of Newton-Raphson method, for f ( x)=x 10 – 1=0 the initial estimate of the root could have
significant performance effect, especially when the initial estimate is in a location where the function’s
value is nearly constant.

Script 3.4
from scisuit.roots import newton

for x0 in [100, 10, 0.75, 0.1, 0.01]:

res = newton(lambda x: x**10-1, x0=x0, fprime=lambda x: 10*x**9, maxiter=1000)
print(f"({x0}, {res.iter})", end=", ")
(100, 48), (10, 26), (0.75, 12), (0.1, 180), (0.01, 377)

It is observed from the output that when the value of derivative is large (x 0=100), then the steps taken by
the method will be small and will yield a relatively slow convergence. However, on the other hand, when
the derivative is small (x0=0.01), then the initial step taken will be rather large and therefore will yield
such a large Xn that the convergence thereafter will be considerably slow as seen in the Fig. (3.2).

Figure 3.2: Effect of initial estimate for f(x) = x10 – 1 = 0 on performance A) x0=100, B) x0=0.01

If the initial estimate (or part of the iteration process) hits a local extremum Newton’s method can badly
diverge; however, when it converges, it converges quadratically therefore becomes the method of choice
for any function whose derivative can be evaluated efficiently, and whose derivative is continuous and
nonzero in the neighborhood of a root (Press et al. 2007) as seen in Example 3.1.
3.2. Secant Method
In the previous section, it was mentioned that Newton’s method was the choice “… any function whose
derivative can be evaluated efficiently”. This is not a problem for polynomials or many other functions,
but there are functions whose derivative maybe very difficult to find.

In such cases, the derivative can be approximated by a backward finite difference method:

f ( xi−1 )−f (x i )
f ' ( x i )= (3.2)
xi−1− x i

Placing Eq. (3.2) into Eq. (3.1) gives:

f ( x i )( x i−1−x i )
x i+1=x i − (3.3)
f ( x i−1 )−f ( x i )

Note that unlike Newton’s method, in secant method, two

starting points are required, xi-1 and xi.

Figure 3.3: Secant method

Example 3.3: Find the root of f(x) = x2 – 5 = 0.

from scisuit.roots import newton

#two starting points, x0 and x1

result = newton(lambda x: x**2-5, x0=0, x1=3)
print(result)
Newton method (Secant)
Root=2.23607, Error=9.18e-07 (7 iterations).

21
Remembering that regula falsi method requires two starting points and draws a line between them, then
you might be wondering what the difference between regula falsi and secant method is?

In both regula falsi and secant method, at the very first

step the location of xnew would be the same.

However, in the second iteration the path followed by

secant and regula falsi methods are different as shown
in Fig. (3.5).

Figure 3.4: Regula falsi vs secant (1st iteration)

In the 2nd iteration:

1) Secant method will draw the dark orange line
2) Regula falsi will draw the blue line

Figure 3.5: Regula falsi vs secant (2nd iteration)

Notice that in Fig. (3.5), for this particular figure, secant method would diverge from the root as of second
iteration whereas regula falsi would always converge, as long as enough iterations are allowed.
3.3. Halley’s Method
It is similar to Newton-Raphson's method, but converges more rapidly in the neighborhood of a root 7. The
derivation is straightforward and includes Taylor series expansion in the neighborhood of root, x.

2
f ( x)=f ( x n )+ f ' ( x n )( x−x n )+ f ' ' ( x n )( x−x n ) (3.4)

We know that when f(x)=0 then x=xn+1. Substituting these knowns into Eq. (3.4) and furthermore using
Eq. (3.1) and after some algebraic manipulation, the following equation is found [ a detailed derivation is
presented by Weisstein (2024)8]:

f ( xi)
x i+1=x i −

[
f ' ( x i )⋅ 1−
f ( xi) f ' ' ( xi)
2 f ' ( xi) 2
] (3.5)

It should be noted from Eq. (3.5) that Halley’s method not only requires the first derivative but also the
second derivative as well.

Example 3.4: Find the root of f(x) = x2 – 5 = 0.

from scisuit.roots import newton

result = newton(lambda x: x**2-5, x0=1, fprime=lambda x: 2*x, fprime2= lambda x: 2)

print(result)
Newton method (Halley)
Root=2.23607, Error=2.32e-11 (4 iterations).

It is seen that Halley’s method required less than both Newton-Raphson and secant methods.

Example 3.5: Find the root of f(x) = x10 – 1 = 0.

result = newton(f=lambda x: x**10-1, x0=1.3,
fprime=lambda x: 10*x**9,
fprime2=lambda x: 90*x**8)
print(result)
Newton method (Halley)
Root=1.00000, Error=1.29e-06 (4 iterations).

It is seen from the output that Halley’s method required less than Newton-Raphson (7 iterations).
7 https://blogs.sas.com/content/iml/2016/08/24/halleys-method-finding-roots.html
8 Weisstein, Eric W. "Halley's Method." From MathWorld--A Wolfram Web Resource.
https://mathworld.wolfram.com/HalleysMethod.html

23
3.4. Müller-Traub method
So far the methods discussed can only be used to find the real roots. Müller’s method can find both real
and complex roots. We have already seen that the secant method draws a straight line to obtain the new
point (xnew). Müller’s method takes a similar approach, but draws a parabola through three points.

The blue line shows the parabola drawn through the 3 points
on the f(x), the black line.

Figure 3.6: Müller-Traub method

Let’s see how we can find the new point, namely xnew (Chapra and Canale 2013 presents a detailed derivation ). We
can write the equation of the parabolic function as follows:

2
f (x )=a ( x−x 2 ) +b ( x−x 2 )+c (3.6)

If one replaces x with x0, x1 and x2, then 3 equations will be obtained. After a straightforward algebraic
manipulation the following set of equations will be obtained (two unknowns, a and b):

f (x 0 )−f ( x 2)=a( x 0− x 2 )2 +b( x 0 −x 2 )

(3.7)
2
f (x 1 )−f ( x2 )=a( x 1−x 2 ) +b( x1 −x 2 )

Defining the following equations will ease in finding the solution:

h0 =x 1 −x 0 h 1=x 2 −x 1
f ( x 1)−f ( x 0 ) f ( x 2 )−f ( x 1 ) (3.8)
δ 0= δ 1=
x1 −x 0 x 2− x 1

Therefore the unknowns in the parabolic equation (a, b and c) in terms of Eqs. (3.8):
 δ 1−δ 0
a= b=a h1 +δ 1 c=f ( x 2 ) (3.9)
h1 +h 0

Solving the quadratic equation (Eq. 3.6) using Eq. (3.9) will yield the new point:

−2 c (3.10)
x new = x2 +
b∓ √ b −4 ac
2

(the solution of the quadratic equation uses a modified form of the equation to take into account loss of significance ).

Example 3.6: Find the root of x2 + 1 = 0.

from scisuit.roots import muller

for x0 in (-1, 1):

result = muller(lambda x: x**2 + 1, x0 = x0)
print(result)
Muller method
Root=1j (2 iterations).

Muller method
Root=-1j (2 iterations).

It is easily seen that the solution of f(x) = x2 + 1 requires complex roots and therefore none of the
methods, except the Müller’s, could have locate the root. Please note the effect of the initial guess, x 0, on
the root (x0=-1 yielded 1j whereas for x0=1 the root was -1j).

Example 3.7: Find the root of f(x) = x2 – (1 – x)9 = 0.

for x0 in (-1.4, 1):
result = muller(lambda x: x**2 - (1 - x)**9, x0 = x0)
print(result, sep="\t")
Muller method
Root=(0.602886+0.945859j) (20 iterations).

Muller method
Root=(0.259205+0j) (7 iterations).

It should be noted that, when a function has both real and complex roots, even if the initial estimate of the
root is a real number, it is not guaranteed that Müller’s method will converge to a real root.

25
3.5. Discussion
Similar to bracketing methods, open methods were also tested on 12 different functions. The tabulated
data is presented in the format of number of iterations and the running times in parenthesis.

Table 3.1: Number of iterations and running times (ms) required by different open methods

f(x) X0, X1 Newton Secant Müller

2
f1 = x ⋅(
x2
+√ 2⋅sin(x))−
√3 0.1, 1.2 9 (0.038) 13 (0.045) 4 (0.035)
3 18
f2 = 11⋅x 11−1 0.4, 1.6 53 (0.062) NC 10 (0.026)
35
f3 = 35⋅x −1 -0.5, 1.9 576 (0.604) NC NC
f4 = 2∗(x⋅e−9−e−9 x )+1 -0.5, 0.7 9 (0.023) NC 15 (0.066)NR
2 9
f5 = x −(1 – x) -1.4, 1 13 (0.025) 9 (0.017) 20 (0.057)NR
−9 x 9
f6 = ( x−1)⋅e +x -0.8, 1.6 16 (0.042) 19 (0.034) 21 (0.076)NR
2 x 1
f7 = x +sin( )− -0.5, 1.9 4 (0.012) 8 (0.015) 2 (0.011)
9 4
1 1
f8 = ⋅(9− ) 0.001, 1.201 12 (0.014) NC 24 (0.048)
8 x
f9 = tan (x)−x – 0.046302 -0.5, 1.5 9 (0.017) 22 (0.022) 4 (0.017)NR
f10 = x 2+ x⋅sin( √ 75 x) – 0.2 0.4, 1 4 (0.016) 9 (0.023) 5 (0.029)
10
f11 = x – 1 0.1, 1.3* 180 (0.180) NC NC
2
f12 = x −5 0.1, 4* 9 (0.011) 8 (0.011) 2 (0.007)
NC: Not converged (either numerical bounds or the max number of iterations exceeded > 1000)
NR: Did not converge to a real root; however a complex root found.

It is seen that in all cases Newton’s method converged to a root, whereas out of 12 functions secant
method failed to converge 5 times and Müller’s method failed to converge twice (f3 and f11) and did not
converge to a real root 4 times (f4, f5, f6 and f9).

In terms of the overall runtime costs, Newton’s method outperformed Müller’s method in 5 functions (f4,
f5, f6, f8 and f10) whereas Müller’s method was the winner for 4 functions (f1, f2, f7 and f12).

The similarities and differences between secant and regula falsi methods have already been mentioned. If
one compares both method (Tables 2.2 & 3.1), it is seen that in general when converged, secant method
performed faster than regula falsi. For example, for f1, regula falsi required 43 iterations and 143 ms
whereas secant method located the root in 13 iterations and 45 ms.
It is seen from Table (3.1) that functions f3 and f11 posed problems to all methods, i.e. Newton-Raphson,
secant and Müller. Plot of f3 and f11 are presented below.

Figure 3.7: Plot of f 3 =35⋅x 35 −1 and f11 = x 10 – 1

It is seen from Fig. (3.7) that for both f3 and f11 the functions’ values did not change considerably in the
part of the selected interval or changed very quickly. When the function value stagnates, it yields a very
small derivative which can then cause the problem of exceeding numerical bounds during iterations (see
Fig. 3.2).

On the other hand, for a strictly monotonous function, i.e. f(x) = x2-5, not only all methods did converg to
a root but also required less than 10 iterations. Müller’s method, which uses a parabola to estimate the
new root, required only 2 iterations to locate the root of f12, which itself is a parabola.

27
 Table 3.2: Runtime cost per iteration (microseconds / iteration)

f(x) X0, X1 Newton Secant Müller

2
f1 = x ⋅(
x2
+√ 2⋅sin(x))−
√3 0.1, 1.2 4.24 3.48 8.73
3 18
f2 = 11⋅x 11−1 0.4, 1.6 1.17 NC 2.60
35
f3 = 35⋅x −1 -0.5, 1.9 1.05 NC NC
f4 = 2∗(x⋅e−9−e−9 x )+1 -0.5, 0.7 2.60 NC 4.39
2 9
f5 = x −(1 – x) -1.4, 1 1.92 1.88 2.86
−9 x 9
f6 = ( x−1)⋅e +x -0.8, 1.6 2.64 1.81 3.62
2 x 1
f7 = x +sin( )− -0.5, 1.9 2.88 1.93 5.55
9 4
1 1
f8 = ⋅(9− ) 0.001, 1.201 1.17 NC 1.99
8 x
f9 = tan (x)−x – 0.046302 -0.5, 1.5 1.84 0.98 4.20
f10 = x + x⋅sin( √ 75 x) – 0.2
2
0.4, 1 3.90 2.51 5.78
10
f11 = x – 1 0.1, 1.3* 1.00 NC NC
2
f12 = x −5 0.1, 4* 1.19 1.34 3.50

It is clearly seen from Table (3.2) that of all the functions tested the runtime cost per iteration of Müller’s
method was up to ~3 times higher than Newton-Raphson and secant methods. It has already been
mentioned that Müller’s method can be used for both real and complex numbers. In order to achieve this,
the code that powers Müller’s method uses a double precision complex number data structure 9 rather than
a double precision data type.

Besides, for trigonometric functions one has to use cmath rather than the math library of Python where for
the trigonometric functions required here performance of math is better than cmath. For example, if one
computes the square root of 25 using math and cmath libraries (for the purpose of benchmarking,
computation was run for 1 million times), it would be seen that math library will provide results ~1.5
times faster than cmath library.

All these could also be among the reasons why Müller’s method’s runtime cost per iteration was higher
than the other two methods, namely Newton-Raphson and secant.

9 https://en.cppreference.com/w/cpp/numeric/complex
 4. Hybrid Methods

4.1. van Wijngaarden-Dekker-Brent method

Brent’s method is a hybrid approach that combines the reliability of bracketing methods with the speed of
the open methods. It combines i) brute-force, ii) secant and iii) inverse quadratic interpolation methods
and applies the speedy open method (secant or inverse quadratic interpolation) whenever possible, but
reverts back to brute-force method if necessary (Chapra and Canale 2013 ). Press et al (2007)
recommends Brent’s method as the choice for one-dimensional root finding.

Brent's method is due to Richard Brent and builds on an earlier algorithm by Theodorus Dekker, therefore
is also known as the Brent–Dekker method (Wikipedia 2024 10). It is sometimes known as van
Wijngaarden-Dekker-Brent method (Wolfram MathWorld 202411).

Inverse Quadratic Interpolation: Similar to Müller’s method, when there are 3 points on f(x), it is
possible to define a quadratic function and find its intersection with the x-axis. However, it is possible that
the parabola, y=f(x), might not intersect with the x-axis, for example y=x2+1. However, x=f(y), will
always intersect with the x-axis as shown below:

The parabola passes through 3 points:

1) xi, f(xi),
2) xi-1, f(xi-1),
3) xi-2, f(xi-2)

Figure 4.1: Inverse quadratic interpolation

10 Wikipedia (2024). Brent's method. Available at: https://en.wikipedia.org/wiki/Brent%27s_method

11 Wolfram MathWorld (2024). Brent's method. Available at: https://mathworld.wolfram.com/BrentsMethod.html

29
Writing the Lagrange polynomial through the given 3 points:

( y− y i−1 )( y− y i ) ( y− y i−2 )( y− y i ) ( y− y i−2 )( y− y i−1 )

g( y)= x i−2 + x i−1 + x (4.1)
( y i−2 − y i−1 )( y i−2 − y i ) ( y i−1− y i−2 )( y i−1− y i ) ( y i − y i−2 )( y i − y i−1 ) i

Remembering that the root, xi+1, corresponds to y = 0, then Eq. (4.1) can be rewritten as:

y i−1 y i y i−2 y i y i−2 yi−1

x i+1 = x i−2 + x i−1 + x (4.2)
( y i−2 − yi−1 )( yi−2− y i ) ( y i−1 − yi−2 )( yi−1− y i ) ( y i− y i−2 )( y i − y i−1 ) i

From Eq. (4.2) one should note that that if yi-2, yi-1 and yi are not distinct then xi+1 does not exist.

Table 4.1: Number of iterations and running times (ms) of brute-force, secant and brentq methods
f(x) brute-force secant Brent

+ √ 2⋅sin( x))− √
2
2 x 3
f1 = x ⋅( 17 (0.039) 13 (0.045) 8 (0.020)
3 18
11
f2 = 11⋅x −1 17 (0.015) NC 11 (0.013)
35
f3 = 35⋅x −1 18 (0.014) NC 14 (0.013)
−9 −9 x
f4 = 2∗( x⋅e −e )+1 17 (0.023) NC 8 (0.012)
2 9
f5 = x −(1 – x) 18 (0.021) 9 (0.017) 8 (0.011)
−9 x 9
f6 = ( x−1)⋅e +x 18 (0.024) 19 (0.034) 13 (0.016)
2 x 1
f7 = x +sin( )− 18 (0.019) 8 (0.015) 9 (0.012)
9 4
1 1
f8 = ⋅(9− ) 17 (0.012) NC 11 (0.007)
8 x
f9 = tan( x)−x – 0.046302 18 (0.013) 22 (0.022) 8 (0.008)
f10 = x + x⋅sin( √ 75 x) – 0.2
2
16 (0.023) 9 (0.023) 8 (0.015)
10
f11 = x – 1 17 (0.012) NC 7 (0.007)
2
f12 = x −5 19 (0.015) 8 (0.011) 7 (0.007)

It is seen that in all cases brute-force method converged to a root with up to 19 iterations. On the other
hand, out of 12 functions, the secant method not converged to a root for 5 functions. As Brent’s method
has the sureness of a bracketing method in finding the root, therefore similar to brute-force method in all
cases Brent’s method converged to a root, but with fewer iterations, ranging from 7 to 14 iterations. In
terms of number of iterations, out of 12, except f7, Brent’s method outperformed the secant method. On the
other hand in terms of overall runtime cost, of all the functions tested, Brent’s method had the least
runtime cost. For example for the function namely f 1 the overall runtime performance is twice the secant
and brute-force methods. Since Brent’s method is a hybrid method, a question might arise, where does the
performance gain, in terms of number of iterations and overall runtime cost, come from? Let’s run brentq
function with the debug parameter set to True (feature discontinued) :

import math
from scisuit.roots import brentq

f1 = lambda x: x**2 * (x**2/3 + math.sqrt(2)*math.sin(x)) - math.sqrt(3)/18

debugTbl = brentq(f=f1, a=0, b=1.2, debug=True)

Table 4.2: Output of debugTbl variable showing the methods applied for finding the of f1

Iteration # Method
1 secant attempted, succeeded! It is seen that Brent’s method uses a
2 inv quad inter attempted, failed! using bisect mixture of brute-force, secant and
inverse quadratic interpolation (IQI).
3 secant attempted, succeeded!
4 inv quad inter attempted, failed! using bisect Out of 8 iterations to find the root of
5 secant attempted, succeeded! the function, namely f1, secant
method was used 4 times, brute-force
6 secant attempted, succeeded! was used twice (due to failed attempt
7 inv quad inter attempted, succeeded! to use IQI) and twice the IQI.

8 inv quad inter attempted, succeeded!

It is informative to compare the values Xn assumed during each iteration of brentq and secant methods.

Each and every iteration in Brent’s method

brings Xn closer to the root, whereas in secant
method, Xn assumed values further away from
the root. This is not possible in Brent’s method
as the root is always bracketed since the method
uses brute-force as a fail-safe (see 2nd and 4th
iterations). It is due to this reason that Brent’s
method not only performs better than the secant
method but also becomes more robust.

Figure 4.2: Value of Xn during iterations of Brent’s and

secant methods

31
4.2. ITP Method
Introduced by Oliveira and Takahashi (2020), it is short for Interpolate Truncate and Project and has the
optimal worst-case performance of the bisection method where the worst-case performance of bisection
method can be computed as follows:

⌈
n1/2= log 2
b−a
2ϵ ⌉ (4.3)

Similar to bisection method, ITP method initially requires the root to be bracketed in the interval of [a, b].
Unlike bisection method, ITP applies 3 distinct steps: a) Interpolation, b) Truncation, c) Projection:

A) Interpolation: To estimate the root, ITP uses linear interpolation:

b f (a)−af (b) (4.4)

xf =
f (a)−f (b)

where xf remains in the interval of [a, b].

B) Truncation: Interpolation alone may place xf too close to the bounds, which can slow down the
convergence. So the ITP method applies a truncation step:

i) A mid-point is computed:

a+b (4.5)
x 1/2=
2

ii) Parameters k1 and k2 are used to control the distance from the midpoint:

x t =x f +σ⋅δ (4.6)

k2
where δ=k 1⋅(b−a) and σ is the sign of x 1/2−x f to ensure xt is closer to the mid-point.
C) Projection: By defining a dynamic range projection step ensures the next point is neither too close nor
too far from the midpoint, therefore keeping the process stable and efficient. Without the projection step,
the interpolation or truncation points could occasionally jump too far from the root, especially if the
function behavior is irregular. By keeping the estimate close to the midpoint, the projection step ensures
that the ITP method retains a balance, avoiding oscillations and stabilizing the convergence. The dynamic
range is defined as:

nmax −k YY − XX (4.7)
r=TOL×2 −
2

where nmax =n0 +n1/2 is the estimated maximum number of iterations needed, k is the current iteration
count and YY-XX is the current interval width. Note that Eq. (4.7) ensures that the range gets smaller with
each iteration, making the steps more conservative as we get closer to the root.

Now we measure the distance of truncated point (xt) to the mid-point (x1/2). If xt lies within dynamic range
of x1/2, then xt is kept for next iteration, otherwise it is projected to be closer to the mid-point:

x opt =x 1/2−σ⋅r (4.8)

Note that the projection step acts as a "safety net" to prevent the guesses from overshooting or
undershooting due to aggressive steps.

D) Update: The final step is updating the values of bounds, namely a and b, so that the initial bracket gets
narrower by each iteration. The update logic is same as the bisection method, such that:

i) Compute the value of yopt: y opt =f ( x opt )

ii) If yopt>0 → b=xopt

iii) If yopt<0 → a=xopt

iv) If If yopt=0 → root is found.

33
Example 4.1: Find the root of f(x) = x2-5 = 0.
from scisuit.roots import bisect, brentq, itp

args = {"f":lambda x: x**2-5, "a":0, "b": 4}

for func in [bisect, brentq, itp]:

print(func(**args))
Bisection using brute-force method
Root=2.23607, Error=3.35e-06 (18 iterations).

Brent's method (inverse quadratic interpolation)

Root=2.23607, (7 iterations).

ITP method
Root=2.23607, Error=3.43e-07 (7 iterations).

It is seen that in terms of number of iterations hybrid methods, brentq and ITP, performed significantly
better than the brute-force method. Although employment of regula-falsi decreased the number of
iterations down to 12 [see Example (2.2)], the hybrid methods considerably outperforms both approaches.
Oliveira & Takahashi (2020) performed numerical experiments on 24 functions and found that the ITP
method required the least amount of function evaluations followed by Ridders, Matlab, Illinois, and
Regula Falsi.

The iteration count can be influenced by several factors related to parameter choices and function
behavior. The parameters k1 and k2 control the size of the truncation step, and small or misfit values can
lead to slower convergence, since the method takes smaller steps than necessary, which results in more
iterations. A common choice for these parameters is k1=0.1 and k2=2.0 (Oliveira & Takahashi, 2020).

result = itp(lambda x: x**2-5, a=0, b=4, k1=0.5, k2=1.5 )

print(result)
ITP method
Root=2.23607, Error=1.08e-06 (12 iterations).

Notice that under the same conditions, now it takes 12 iterations to locate the root. In selection of k 1 and
k2, scisuit package uses an approach similar to R’s ITP package12.

12 https://github.com/paulnorthrop/itp/blob/b51384f3c4514afa80797bb0b6d040f8ba38584a/src/itp_c.cpp#L61
5. Polynomials

Polynomials frequently arise in many applications in engineering and science. For example, when writing
energy balances involving radiation heat transfer or when calculating pressure-drop through a packed bed
of particles the roots of the polynomials must be found.

In general, a polynomial is defined as:

2
f n ( x)=a 0 +a1 x +...+a n x
n (5.1)

where n is the order of the polynomial and the a’s are constant coefficients. For n=1, finding the single
root is straightforward. For n<5 there are well-defined equations to find all the roots. However, although
there are equations13 to solve 4th degree polynomials, they are not as straightforward as the equations for
2nd or 3rd degree polynomials.

When n≥5, there are no equations to find the roots and the methodology to find the roots is as follows:

1. Turn polynomial into a monic polynomial, where an=1.

2. Prepare n by n companion matrix
3. The eigenvalues of the matrix are the roots of the polynomial.

Example 5.1:

Find the roots of 2x4 + x2 – 1 =0, using the above-mentioned steps.

Solution:

First let’s demonstrate how to solve it using Numpy’s polynomial class:

poly = np.polynomial.Polynomial([-1, 0, 1, 0, 2])
print(poly.roots().tolist())
[(-0.707+0j),
-0.99999j,
0.99999j,
(0.707+0j)]

13 https://en.wikipedia.org/wiki/Quartic_equation

35
Note that in its current form the polynomial is not monic (an=2). Therefore, divide by an.
1. x4 + 1/2·x2 – 1/2 =0 (monic polynomial)

2. Form 4 by 4 companion matrix.

( )
0 1 0 0
0 0 1 0
0 0 0 1
1/2 0 −1/2 0
3. Find the eigenvalues

import numpy as np
m = np.array( [
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1],
[0.5,0,-0.5,0]] )

#we don't need the eigenvectors

roots = np.linalg.eigvals(m)

#list gives a more detailed output

print(roots.tolist())
[(-0.707+0j),
(-1.1e-16+1.0j),
(-1.1e-16-1.0j),
(0.707+0j)]

Notice that the above output is exactly the same as calling np’s Polynomial.roots function. At this point, it
is instructive to see, how the companion matrix formed:

#degree of the polynomial

n=4

#create identity matrix

m = np.eye(n-1)

#Create n-1 length zero-vector

zeros = np.zeros(n-1)

#Insert zero-vector to the identity matrix as first column (we padded the matrix)
m = np.insert(m, 0, zeros, axis=1)

#monic polynomial coefficients (excludes leading coefficient)

coeffs = np.array([0, 1/2, 0, -1/2])
#reverse the order and multiply by -1
coeffs = -1*coeffs[::-1]

#append the coefficients to the matrix

m = np.vstack([m, coeffs])

print(m)
[[ 0 1 0 0]
[0 0 1 0]
[0 0 0 1]
[ 0.5 0 -0.5 0]]

which is equal to the companion matrix:

( )
0 1 0 0
0 0 1 0
0 0 0 1
1/ 2 0 −1/2 0

37
6. Set of Equations

6.1. Set of Nonlinear Equations

Assume that we have the following set of nonlinear equations:

f 1 (x 1 , x 2 ,..., x n )=0

f 2 ( x1 , x 2 ,..., xn )=0
(6.1)
...

f n ( x1 , x 2 ,..., x n)=0

and we are seeking x1, x2, …, xn satisfying all of the equations given in Eq. 6.1.

For simplicity, let’s focus on functions with two variables (derivation for functions with n variables
follows the same logic). Taylor’s theorem for a function of two variables, namely f(x, y), near (a, b):

∂f ∂f
f (x , y )≈ f (a ,b)+ (a , b)(x −a)+ (a , b)( y−b)+
∂x ∂y
(6.2)
2 2 2
1∂ f 1∂ f ∂ f
(a ,b)(x −a)2 + (a ,b)( y−b)2 +2 (a, b)( x−a)( y−b)
2 ∂ x2 2 ∂ y2 ∂x∂ y

If there are two functions: u(x, y)=0 and v(x, y)=0, then applying Taylor’s theorem:

∂ ui ∂u
ui+1=u i +( x i+1− xi ) +( y i+1− y i ) i
∂x ∂y
(6.3)
∂ vi ∂v
v i +1=v i +( x i+1 −x i ) +( y i+1− y i ) i
∂x ∂y
yields two equations & two unknowns.

∂ ui ∂u ∂u ∂u
x i+1 − i y i+1 =−ui + x i i + yi i
∂x ∂y ∂x ∂y
(6.4)
∂ vi ∂ vi ∂ vi ∂ vi
x i+1− y i+1=−v i + x i + yi
∂x ∂y ∂x ∂y
where unknowns are on the left hand-side.
Applying the Cramer’s rule:

∂ vi ∂u ∂ ui ∂v
ui −v i i vi −ui i
∂y ∂y ∂x ∂x (6.5)
x i+1 =x i − y i+1= y i −
∂ ui ∂ v i ∂ u i ∂ v i ∂ u i ∂ v i ∂ ui ∂ v i
− −
∂x ∂ y ∂ y ∂x ∂x ∂ y ∂ y ∂x
Notice that:

1. The denominator for equations xi+1 and yi+1 is the determinant of the Jacobian matrix.
2. The solution starts with an estimated solution vector, v=(x0, y0) corresponding to the function
vector f=(f1, f2)

Example 6.1: Solve the following set of non-linear equations.

2 2
x + y =5
2 2
x − y =1

Solution:
Define the equations as Python functions ( instead of variables x and y, we use a single notation t where x=t0 and
y=t1, which brings the flexibility to work with n variables easily):

from math import isclose

from scisuit.roots import fsolve

"""
Note that the Python functions are defined
in the form of f(x, y) = 0
"""
def f1(t):
return t[0]**2 + t[1]**2 -5
def f2(t):
return t[0]**2 - t[1]**2 -1

#initial solution vector (estimated)

v = [1, 1]

#function vector
f = [f1, f2]

result = fsolve( f, v )
print(result)

39
#check if the estimated roots satisfy (close enough to 0.0) equations
for func in f:
print(isclose(func(result.roots), 0.0, abs_tol=1E-5), end=", ")
Solving Set of Equations
Converged to roots after 4 iterations.
Root #0=1.7321
Root #1=1.4142

True, True

Finally, note that changing the initial solution vector could change the roots.

#different initial solution vector

v = [-1, -1]

result = fsolve( f, v )
print(result)
Solving Set of Equations
Converged to roots after 4 iterations.
Root #0=-1.7321
Root #1=-1.4142

Finally note that in math.isclose function the abs_tol parameter has been changed to 10 -5 as the default
absolute tolerance level is 10-9 whereas the default tolerance level for fsolve function is 10-5.
6.2. Set of linear equations
Assume we have the following set of linear equations:

a00 x 0 +a01 x 1+...+a0 n x n =b 0

a10 x 0 +a11 x 1+...+a 1n x n =b 1

(6.6)
⋮

a n0 x 0 +a n1 x 1+...+ann x n=bn

where a’s are the cofficients, x’s are unknowns and b’s are constants.

In order to solve the set of linear equations, it is more convenient to work with matrix notation, i.e. A as
the coefficient matrix, x as the unknown or solution vector and b as the constant vector. Therefore, the set
of equations will be compacted into:

Ax=b (6.7)

where

( ) () ()
a00 a01 ... a 0n b0 x0
A= a10 a11 ... a 1n , b= b 1 , x= x1
⋮ ⋮ ⋮ ⋮ ⋮ ⋮
an 0 a n1 ... ann bn xn

There are 3 scenarios that can happen in our search for the solution:

1. No solution
2. Exactly one solution
3. Infinitely many solutions.

41
Example 6.2: Given the following 3 pairs of points (1,3), (2, 7), (3, 15) find the equation for the trendline
(the “best” line).

Solution:

The equation for a line is: y= ax + b where there are two unknowns, namely a and b. However, 3 points
are given which yields 3 equations (more than unknowns):

( )( ) ( )
3=a+b 1 1 3
a
7=2 a +b , in matrix notation 2 1⋅ = 7
b
15=3 a +b 3 1 15

import scisuit.plot as plt

x = [1, 2, 3]
y = [3, 7, 15]

plt.scatter(x=x, y=y)
plt.show()

The points are not on a straight line and therefore there

can be infinitely many lines that can go in between the
given points.

Figure 6.1: Scatter plot of the 3 points

We can however obtain a solution that will represent the best line:

import numpy as np
import scisuit.plot as plt

A = np.array([ [1,1], [2,1], [3,1] ] )

b = np.array([3, 7, 15])

#least-square solution of Ax=b -> returns [slope, intercept]

sol = np.linalg.lstsq(A,b, rcond=None)[0]

#equation of the best line using the coefficients from the solution
f = lambda x: x*sol[0] + sol[1]
x = [1, 2, 3]
y = [3, 7, 15]

plt.scatter(x=x, y=y)

#compute lower and upper bounds of x and the corresponding y

x0 = [min(x), max(x)]
y0 = [f(v) for v in x0]

#draw a line
plt.plot(x=x0, y=y0, lw=3, ls="--")
plt.show()

Figure 6.2: Scatter chart with linear trendline (the best line)

43
Applications
 A. Energy Balance

Problem: In a manufacturing process, a spherical piece of metal is subjected to radiative heater operating
at 850K and to air flowing at 350K. The surface emissivity (ε) of the metal is 0.6 and the convective heat
transfer coefficient (h) is 40 W/(m2K). Find the temperature of the metal after a long enough time
(Adapted from Jaluria Y, 2020).

σ = 5.67·10-8 W/m2K4 (Stefan-Boltzmann constant)

Solution:

We assume that the Biot number (Bi) is smaller than 0.1 and therefore there is no temperature gradient
within the metal. After a long enough time steady state conditions will prevail, therefore heat losses will
be equal to heat gains.

Let’s write energy balance:

Radiative heating = Convective Cooling

ϵ⋅σ ⋅A s⋅[T 4surr −T 4 ]=h⋅A s⋅(T −T ∞ )

0.6⋅5.67⋅10−8⋅[ 8504 −T 4 ]=40⋅(T−350)

The equation resulting from energy balance can be written as follows:

f (T )=0.6⋅5.67⋅10−8⋅[850 4 −T 4 ]−40⋅(T −350)=0

Let’s define the equation as Python function:

f = lambda T : 0.6*5.67E-8*(850**4 – T**4) – 40*(T - 350)

1) We know that the temperature must be in between [350, 850] (already bracketed):

from scisuit.roots import bisect

result_bf = bisect(f, a=350, b=850)

print(result_bf)
Bisection using brute-force method
Root=645.92148, Error=7.45e-06 (26 iterations).

45
2) Application of secant method requires two starting points, x0 and x1. Choose x0=350 and x1=850.

from scisuit.roots import newton

result_newton = newton(f, x0=350, x1=850)

print(result_newton)
Newton method (Secant)
Root=645.92149, Error=3.17e-10 (8 iterations).

If you were to choose x 1 close to root such as 650 or 700 then the number of iterations would have been 6
and 7, respectively.

3) Similar to bisection method, Brent’s method requires that the root is bracketed initially. Therefore we
could also have used Brent’s method:

from scisuit.roots import brentq

result_bq = brentq(f, a=350, b=850)

print(result_bq)
Brent's method (inverse quadratic interpolation)
Root=645.92149, (6 iterations).

Notice that in terms of the number of iterations required, Brent’s method outperformed both bisection and
secant methods.

4) Another advanced method, that initially requires the root to be bracketed, is the ITP method:

from scisuit.roots import itp

result_itp = itp(f, a=350, b=850)

print(result_itp)
ITP method
Root=645.92149, Error=1.27e-11 (7 iterations).
5) Energy balance equation is a polynomial of 4th degree. Therefore, let’s go ahead convert the equation
into a polynomial of form:

a·T4 + b·T3 + c·T2 + d·T + e = 0

where

−8
a=0.6×5.67×10
b=c =0
d=40
−8 4
e=−40×350−0.6×5.67×10 ×850

import numpy as np

a = 0.6*5.67*1E-8
b=c=0
d = 40
e = -40*350 - a*850**4
poly = np.polynomial.Polynomial([e, d, c, b, a])

print(poly.roots().tolist())
[(-1244.20+0j), (299.14+1035.43j), (299.14-1035.43j), (645.92+0j)]

47
 B. Particle Technology

Particulate materials such as powders or bulk solids are widely used in process industries, for example in
the food processing, pharmaceutical, biotechnology, oil, chemical, mineral processing, metallurgical,
detergent, power generation, paint, plastics and cosmetics industries (Rhodes 2008).

1. Fluidization Velocity

Background: Fluidization is a process where a particulate material is converted from a static solid-like
state to a dynamic fluid-like state (Wikipedia 2022 14). Fluidization provides excellent heat and mass
transfer and therefore has several applications.

When a fluid is passed upwards through a bed of particles the pressure loss in the fluid due to frictional
resistance increases with increasing fluid flow. A point is reached when the upward drag force exerted by
the fluid on the particles is equal to the apparent weight of particles in the bed (Rhodes 2008). At this
point the bed of particles assumes the characteristics of a boiling liquid, hence the term fluidization. The
fluid responsible for fluidization may be a gas or a liquid (Shilton & Niranjan, 1993).

Weight of particles−Buoyancy force

Pressure drop=
Area

HA (1−ϵ )⋅ρ p⋅g− ρ f⋅HA (1−ϵ )⋅g

Δ P=
A

where H is the height of the particles before fluidization, A is the cross-sectional area of the container
(bed), ε is the voidage, ρp and ρf are the densities of particle and fluid, respectively.

Canceling cross-sectional area and rearranging terms yields:

ΔP
=(1−ϵ )⋅g⋅( ρ p− ρ f )
H
Pressure drop in the presence of multiple particles can be found using Ergun’s equation:

2 2
Δ P 150⋅(1−ϵ ) μ⋅U mf 1.75⋅ρ f U mf (1−ϵ )
= ⋅ 2 + ⋅ 3
H ϵ3 x sv x sv ϵ

14 https://en.wikipedia.org/wiki/Fluidization
where Umf is the minimum fluidization velocity, xsv is the Sauter-mean diameter and μ is the viscosity.

Equating last two equations gives the final form of the equation:

2
150⋅(1−ϵ )2 μ⋅U mf 1.75⋅ρ f U mf (1−ϵ ) (B.1)
(1−ϵ )⋅g⋅( ρ p − ρ f )= ⋅ 2 + ⋅ 3
ϵ3 x sv x sv ϵ

Problem: A packed bed of solids of density 1475 kg/m 3 occupies a depth of 0.5 m in a cylindrical vessel
of inside diameter 25 cm. The mass of solids in the bed is 15 kg and the surface-volume mean diameter of
the particles is 3 mm. What is the minimum flow rate of air at 60°C to fluidize the particles? At 60°C:
ρair=1.0585 kg/m3 and μair=1.998·10-5 Pa·s

Solution:

V bed =0.5× ( Π⋅0.252

4 )
=0.02454 m3 and V particles =
15 kg
1475 kg/ m
3
=0.01016 m
3

Therefore, voidage (ε):

0.01016
ϵ =1− =0.586
0.02454

Now, pressure drop per height of bed can be computed:

ΔP m kg Pa
=(1−0.586 )⋅9.81 2⋅(1475−1.0585) 3 =5991.12
H s m m

Observe that Eq. (B.1) is quadratic with respect to Umf and can be rewritten as follows:

2
A⋅U mf + B⋅U mf +C=0

where,

1.75⋅ρ f (1−ϵ ) 150⋅(1−ϵ )2 μ −Δ P

A= ⋅ 3 , B= 3 ⋅ 2 and C=
x sv ϵ ϵ x sv H

49
Noting that all the terms in A, B and C are known, the positive root ( we are interested in speed and not in the
velocity since the flow direction is known) gives the minimum fluidization velocity as Umf=2.06 m/s.

It is known that the temperature of the gas could affect Umf since increasing Tgas decreases density and
increases viscosity. A comparatively short script was written to investigate the effect of temperature on
Umf. For the investigation, the temperatures have been arbitrarily chosen as 20°, 40°, 60° and 80°C.

import math
import numpy as np
import scisuit.plot as plt
from scisuit.eng import Air

Rho_p, Dp = 1475, 3E-3 #kg/m3 and m

Xsv = Dp # particles are spherical

mp = 15 #kg
Vp = mp/Rho_p

Hbed, Dbed = 0.5, 0.25 #m

Vbed = (math.pi*Dbed**2/4)*Hbed

Voidage = 1 - Vp/Vbed

def umf(T):
air = Air(T=T+273.15)
Rho_f, Mu_f=air.rho(), air.mu()

dP_H=(1-Voidage)*9.81*(Rho_p - Rho_f) #Pa/m, g = 9.81 #m/s2

A = 1.75*Rho_f / Xsv * (1-Voidage)/Voidage**3

B = 150*(1-Voidage)**2 / Voidage**3 * (Mu_f/Xsv**2)
C = -dP_H

poly=np.polynomial.Polynomial([C, B, A])
return [x for x in poly.roots() if x>0][0]

T = [20, 40, 60, 80]

Umf = [umf(v) for v in T]

plt.scatter(x=T, y=Umf)
plt.xlabel("T(°C)")
plt.ylabel("Umf (m/s)")
plt.show()
 It is seen that increasing the gas
temperature increased Umf. Also one can
notice the perfect relationship between
Umf and temperature.

Figure B.1: Effect of air temperature on Umf

The strong relationship between air temperature and Umf could be due to the fact that the above-given
script did not take into account the following points:
1. Particle type [Geldart (1973) A, B, C or D]. For example, Botterill 15 et al. (1982) reported the
effect of temperature on Umf for some Group B and D particles. They observed a decrease of Umf
with increasing temperature for Group B particles whereas for Group D powders, an increase in
Umf was observed.

2. Change of bed voidage at incipient fluidization velocity.

3. Particle-particle or fluid-particle interactions.

15 Botterill JSM, Teoman Y, Yüregir KR (1982). The effect of operating temperature on the velocity of minimum
fluidization, bed voidage and general behaviour, Powder Technology, 31(1).

51
 2. Terminal Velocity
Background: A particle falling from rest in a fluid will initially experience a high acceleration as the
shear stress drag will be small. However, as the particle accelerates the drag force increases, causing the
acceleration to reduce. Eventually a force balance is achieved when the acceleration is zero and a
maximum or terminal relative velocity is reached by the single particle (Rhodes 2008). Stokes' law is key
to understanding a wide variety of physical processes such as swimming of microorganisms and
sedimentation of tiny particles in air and water (Dey et al. 2019).

Problem: Estimate the terminal velocity for 80-to-100-mesh particles of limestone (ρ= 2800 kg/m 3)
falling in water at 30°C.

Dp for 100 mesh=0.147 mm and 80 mesh= 0.175 mm, at 30°C : µ=0.801 cp, ρ=995.7 kg/m3

Solution:

D̄ p =0.161 mm (average diameter of the particles)

Let’s calculate Archimedes number, namely Ar.

D3p g ρ f ( ρ p− ρ f ) (0.161⋅10−3 )3⋅9.81⋅995.7⋅(2800−995.7)

Ar= = =114.79
μ2 (0.801⋅10−3)2

The drag coefficient (CD) and Reynolds number (Re) are related to Ar:
Ar

2 4
C D⋅Re = ⋅Ar=153.05
3

The CD for intermediate region can be calculated:

24 0.687
C D= (1+0.15⋅Re )
Re

Putting the last two equations together yields a non-linear equation:

24 0.687 2
(1+0.15⋅Re )⋅Re −153.05=0
Re
Expressing the last equation as Python function:

f = lambda Re : 24/Re*(1 + 0.15*Re**0.687)*Re**2 - 153.05

At this stage we need some intuition to be able to solve the equation with one of the root finding methods.
Recalling that Reynold’s number for different regions are: Stokes (~ <1), Intermediate (1<Re<1000) and
Newton’s (1000 < Re <2·105) gives the lower and upper bounds of Reynold’s number and therefore
bisection method seems a convenient choice to apply.

from scisuit.roots import bisect

result = bisect(f, a=1, b=1000)

print(result)
Bisection using brute-force method
Root=4.48838, Error=7.44e-06 (27 iterations).

The brute-force approach of bisection method yielded the Reynold’s after 27 iterations. Let’s see if regula
falsi approach would yield faster convergence:

result_rf = bisect(f, a=1, b=1000, method=("rf", False))

print(result_rf)
Bisection using regula falsi method
Could not converge to a root. Max iters exceeded.

Let’s take a look at the plot of f(Re) to get some insight:

import scisuit.plot as plt

x = np.linspace(0.1, 50, num=100)

y = [f(Re) for Re in x]

plt.scatter(x=x, y=y)
plt.show()

One can quickly realize that at the given interval, as the

Reynold’s number increase the value of the function
increases very quickly and moreover the root is close to
lower bound. Therefore, regula falsi did not converge.

Figure B.2: Plot of f(Re)

53
How about, modified regula falsi? Can it alleviate the problem of very slow convergence?

result_mrf = bisect(f, a=1, b=1000, method=("rf", True))

print(result_mrf)
Bisection using regula falsi method
Using Modified regula-falsi
Root=4.48837, Error=1.07e-07 (12 iterations).

Finally, since we have all the insight we need, let’s “cheat” and choose the interval as [1,10] and see the
results: Brute-force: 20 iterations and regula-falsi: 9 iterations.

This was expected as at the given interval the function is strictly monotonously increasing and therefore
was a good candidate for regula falsi method.
 C. Thermodynamics

Equation of state (EoS) establishes a relationship between pressure, temperature, and specific volume (P,
v, T) of a substance (Çengel et al. 2019). EoS is important in the modeling of a wide range of industrial
and natural processes and it is desired that EoS is accurate, consistent, easy to compute and robust
(Wilhelmsen et al. 201716).

The simplest and best-known EoS for substances in the gas phase is the ideal-gas equation. However, it is
rather simple and its range of applicability is limited in real gases. Therefore, it is desirable to have
equations that can represent the behavior of substances accurately over a larger region with no limitations.

Cubic equations of state compromise between generality and simplicity that is applicable in many process
engineering operations. As a matter of fact, cubic equations are the simplest equations capable of
representing both liquid and vapor behavior (Smith et al. 2017).

In this section 3 cubic equations of state were chosen to solve the problem proposed below:

1. Van der Waals

2. Redlich-Kwong
3. Peng-Robinson

Problem:

Given that the vapor pressure of water at 100°C is 101.3 kPa, find the molar volume of saturated-vapor
using the different equation of states (Question adapted from Smith et al. 2017).

Critical temperature (Tc) = 647.14 K

Critical pressure (Pc) = 22120 kPa
L⋅kPa
Universal gas constant (R): R = 8.314462
mol⋅K

16 Wilhelmsen Ø, Aasen A, Skaugen G, Aursand P, Austegard A, Aursand E, Gjennestad MA, Lund H, Linga G,
Hammer M (2017). Thermodynamic Modeling with Equations of State: Present Challenges with Established Methods.
Industrial & Engineering Chemistry Research, 56, 3503−3515.

55
 1. Van der Waals Equation
Background: The equation is based on the work of 19 th century Dutch physicist Johannes Diderik van der
Waals(Wikipedia 202217). It is given by the following equation:

( )
P+
a
v
2 ⋅( v−b)= RT

The equation improves the ideal-gas equation by including two effects: (I) the intermolecular attraction
forces (a / v2) and (II) the volume occupied (b) by the molecules themselves (Çengel et al. 2019).

Solution of the proposed problem:

2
L ⋅kPa L
For water vapor: a = 553.6 and b=0.03049
mol 2
mol

To compute molar volume it must be in the following form:

(
f (v )= P+
a
v )
2 ⋅(v−b)−RT
(C.1)

Let’s translate Eq. (C.1) to a Python function:

a, b= 553.6, 0.03049
P = 101.3 #kPa
R = 8.314462
T=100 + 273.15 #K

f = lambda v: (P + a/v**2)*(v - b) - R*T

The bracketing, open or hybrid methods require at least one starting point. At this point all we know is
that at standard temperature and pressure 1 mol of ideal gas occupies 22.4 L. Although water vapor is not
an ideal gas (see Çengel et al. (2019) for exceptions to this claim), 22.4 L seems a reasonable initial guess. At
this point, we can employ Newton’s method to solve Eq. (C.1):

a 2 ab
f ' ( v)=P− 2
+ 3
v v

derF = lambda v: P - a/v**2 + (2*a*b)/v**3 #derivative

17 https://en.wikipedia.org/wiki/Van_der_Waals_equation
Now that we have Eq. (C.1) and its derivate an initial starting point (x0), we can proceed with the solution:

from scisuit.roots import newton

#22.4 L was rounded to 22 L just for convenience

result = newton(f=f, x0=22, fprime=derF)
print(result)
Newton method (Newton-Raphson)
Root=30.47863, Error=1.39e-07 (3 iterations).

After 3 iterations, molar volume: v=30.478 L/mol = 1.69325 m3/kg

Is the result acceptable?:

true value−approximation 1.67290−1.69325

% Relative Error= ×100= ×100=−1.21 %
true value 1.67290

In conclusion, we found out that Van der Waals equation estimated (overestimated) the true value with
approximately 1% error.

57
 2. Redlich / Kwong Equation
Background: Redlich/Kwong was was formulated by Otto Redlich and Joseph Neng Shun Kwong in
1949. The equation is generally more accurate than the Van der Waals and the ideal gas equations at
temperatures above the critical temperature. (Wikipedia 2022 18). The equation is as follows (Smith et al.
2017)

( Z− β )
Z=1+ β −q β
Z( Z+ β )

where β and q are dimensionless parameters and are defined as follows:

P
q= Ψ ⋅T −3/2 β =Ω⋅ r
Ω r
Tr

where Ω and Ψ are pure numbers, independent of substance but specific to a particular equation of state.
For RK equation Ω=0.08664 and Ψ=0.42748.

Solution:
Using the critical temperature (Tc) and critical pressure (Pc), we first calculate the reduced temperature (Tr)
and reduced pressure (Pr):

T 100+273.15 P 101.3
T r= = =0.576614 and P r= = =0.004579
Tc 647.14 P c 22120

Calculating the dimensionless parameters:

0.42748
q= Ψ ⋅T r
−3/2 (−3/ 2)
= ⋅(0.576614 ) =11.268589
Ω 0.08664

Pr 0.004579
β =Ω⋅ =0.08664⋅ =0.00068810952
Tr 0.576614

Putting the values for β and q into Redlich/Kwong equation yields:

18 Wikipedia (2024). Redlich–Kwong equation of state. Available at: https://en.wikipedia.org/wiki/Redlich%E2%80%93Kwong_equation_of_state

 (Z−0.00068810952)
Z=1+0.00068810952−11.268589⋅0.00068810952
Z (Z+0.00068810952)

Let’s compact the equation and express it in the form of f(Z) =0 :

(Z−0.00068810952)
f (Z )=Z−1.00068810952+0.00775402362 =0 (C.2)
Z (Z +0.00068810952)

Solution of Eq. (C.2) will yield the compressibility factor. Translating it to a Python function:

beta = 0.00068810952
f = lambda z: (z - 1) - beta + 0.00775402362 * ( (z-beta) / ( z*(z+beta) ) )

Since we are trying to find compressibility factor, which is roughly in the range of (0, 1) for water vapor,
the upper and lower bounds of the solution is pretty much known. However, before delving into choosing
a method for solution, let’s remember that all methods will evaluate the function first at the given initial
points. Therefore, looking at Eq. (C.2), it is clear that when Z=0 then f(Z)=∞. Therefore, we must avoid a
starting value of Z=0; however, it is possible to choose in the neighborhood of 0.0.

result = bisect(f, a = 0.0001, b = 1)

print(result)
Bisection using brute-force method
Root=0.99289, Error=7.37e-07 (15 iterations).

Since we know the lower and upper bounds, it is possible to employ Brent’s method:

result = brentq(f, a = 0.0001, b = 1)

print(result)
Brent's method (inverse quadratic interpolation)
Root=0.99289, (3 iterations).

Let’s also try the ITP method since we know the bracket that the root lies in:

result = itp(f, a = 0.0001, b = 1)

print(result)
ITP method
Root=0.99290, Error=6.48e-06 (4 iterations).

Notice the considerable differences between the hybrid methods (Brent and ITP) and bisection methods!!

59
Does it make any sense that Z=0.9928, which is rather close to 1.0 ?

According to Çengel et al. (2019) “At very low pressures (PR << 1), gases behave as ideal gases
regardless of temperature”. Since we have already calculated PR as 0.004579, it makes sense that Z is
close to 1.

Let’s calculate the specific volume and compare with the experimental value of 1.67290 m 3/kg.

m3 Pa
0.9928×8.314462 ×373.15 K
ZRT mol⋅K m3 m3
V= = =0.030399242 =1.68885
P 101325 Pa mol kg

Is it acceptable?:

true value−approximation 1.67290−1.68885

% Relative Error= ×100= ×100=−0.95 %
true value 1.67290

In conclusion, we find out that RK equation estimated (overestimated) the true value with less than 1%
error. Notice that RK equation gave a slightly better estimate than Van der Waals equation.
 3. Peng-Robinson Equation
Background: It was developed in 1976 at The University of Alberta by Ding-Yu Peng and Donald
Robinson (Wikipedia 202219). It is used widely used in commercial process simulators, such as Aspen
Plus™. The equation is:

RT αa
P= −
v−b v 2 +2 bv−b 2

where constants a and b are:

2 2
R TC RT C
a=0.45723553 b=0.07779607
PC PC

α in PR equation can be computed using the following equation:

α =[ 1+Κ ( 1−√ T r )]
2

where K is computed as follows:

2
Κ=0.37464+1.5422 ω −0.26993 ω

The acentric factor, ω, is defined as:

ω =−1.0−log (P rsat )T =0.7

r

Since Tr is dimensionless, observe that ω, κ, α are also dimensionless.

Solution of the proposed problem:

First, we need to find a way to calculate the acentric factor (ω):

T T =0.7 =647.14 K ×0.7=452.998 K=179.848 ° C

r

Using the steam tables at 179.85°C saturated vapor pressur is Pws(179.85 °C) = 998.753 kPa. Now that
pressure and the critical pressure are both known, reduced pressure can easily be computed:

19 https://en.wikipedia.org/wiki/Cubic_equations_of_state

61
 P ws 998.75296 kPa
P r= = =0.045151580
Pc 22120 kPa

Now acentric factor can be calculated:

ω =−1.0−log (0.045151580)=0.345327

Knowing the value of acentric factor allows the computation of K=0.875014. Once K and reduced
temperature (Tr=0.576614) are known, α can be computed as 1.465482.

At this point all we need is to express PR equation in the form of f(x)=0. Simply rewriting:

RT αa (C.3)
f (v )= P− + 2 =0
v−b v +2 bv −b 2

Translating Eq. (C.3) as Python function:

#Givens
T, P = 373.15, 101.3 #K and kPa

#Knowns
Tc, Pc= 647.14, 22120 #K and kPa
R= 8.314462

a = 0.45723553*(R**2*Tc**2) / Pc
b = 0.07779607*(R*Tc) / Pc
alpha = 1.465482

f = lambda v: P - (R*T) / (v - b) + (alpha*a) / (v**2 + 2*b*v - b**2)

One of the root finding methods need to be selected to find the root of f(v). The derivative of Eq. (C.3) can
be conveniently taken if we would like to use Newton-Raphson method; however, now that we have
“experience” from the previous sections (C1 & C2), we will employ a bracketing method.

Let’s arbitrarily choose brute-force variant of bisection:

from scisuit.roots import bisect

result = bisect(f, a = 20, b = 50)

print(result)
Bisection using brute-force method
Root=30.36157, Error=8.36e-06 (22 iterations).
We mentioned that it was due to the “experience” that we chose a good interval (a=20, b=50). What
happens if we don’t have the experience, which is not uncommon not to have?

We could approach with the same intuition we did in Section C1: “... at standard temperature and
pressure 1 mol of ideal gas occupies 22.4 L.”. This gives us a starting point but also left us with the choice
of an open method that takes only a single parameter, i.e. the Newton-Raphson method.

RT (α a)⋅(2 v +2 b)
f ' ( v)= − 2 =0
( v−b) (v +2bv −b 2)2
2

Writing it as Python function and employing Newton’s method:

derf = lambda v: (R*T) / (v-b)**2 - (alpha*a)*(2*v+2*b) / (v**2+2*b*v-b**2)**2

from scisuit.roots import newton

result_newton = newton(f, x0=20, fprime=derf)

print(result_newton)
Newton method (Newton-Raphson)
Root=30.36157, Error=9.00e-07 (5 iterations).

The molar volume is 30.36157 L/mol and has exactly the same value that we found using bisection
method; however, with only 5 iterations.

Still, is there a better way?

Luckily, the answer is yes! If we define two variables A and B as follows (for reference, please see footnote at
page 61):

α aP bP
A= B=
2
R T
2
RT

Placing A and B into Eq. (C.3) yields a polynomial:

3 2 2 2 3
Z −(1−B)Z +( A−2 B−3 B )Z−( AB−B −B )=0

where Z is the compressibility factor.

Now all we need to do is to find the roots of a 3rd degree polynomial using a short script:

63
import numpy as np

A = alpha*a*P / (R**2*T**2)
B = b*P / (R*T)

coeffs = [1, -(1 - B), (A - 2*B - 3*B**2), -(A*B - B**2 – B**3)]

poly = np.polynomial.Polynomial(coeffs[::-1])
print(poly.roots())
[7.3e-04 7.3e-03 9.9132e-01]

As expected, the 3rd degree polynomial returned 3 roots, 2 of which are close to zero. Remembering that
the roots represent the compressibility factor, the 2 roots did not make any sense. Therefore, we chose
Z=0.99132.

Continuing with the script:

Z = max(poly.roots())
V = Z*R*T / P
print(V)
30.36157

All our approaches yielded the same value, v=30.36157 L/mol. After a straightforward unit conversion
one can find v=1.68675 m3 / kg.

Is the result acceptable?:

true value−approximation 1.67290−1.68675

% Relative Error= ×100= ×100=−0.828 %
true value 1.67290

Similar to Van der Waals and Redlich-Kwong equations, we conclude that Peng-Robinson equation
estimated (overestimated) the true value with less than 1% error.
 D. Fluid Dynamics

Background: In 1939, Cyril F. Colebrook (1910–1997) combined the available data (experimental results
from the measurements of the flow rate and the pressure drop) for transition and turbulent flow in smooth
as well as rough pipes into the implicit relation known as the Colebrook equation.

The equation establishes a relationship between the friction factor (f) and the Reynolds number (Re), pipe
roughness (ε), and inside diameter (D) of pipe.

1
√f
=−2.0 log (
ϵ / D 2.51
+
3.7 Re √ f )
Problem: Water at 16°C (σ=998.922 kg/m3 and μ=0.0011 Pa·s) is flowing steadily in a 5 cm diameter
horizontal pipe made of stainless steel at a rate of 0.006 m 3/s. Determine the pressure drop for flow over a
60 m-long section of the pipe (Adapted from Çengel and Cimbala 2006).

Solution:

Given the volumetric flow rate ( V̇ ) and the diameter of the pipe (D), it is possible to calculate the
average velocity (V) of the fluid:

V̇ 0.006 m3 / s
V= = =0.191m/ s
A c Π(5⋅10−2 )2 / 4

Since density and viscosity of the fluid, average velocity and diameter of the pipe are known, Reynolds
number (Re) can be calculated:

ρ v D 998.2×0.191×5⋅10−2
Re= μ = =8666 >4000
0.0011

Roughness for stainless steel is (ε=0.002 mm), therefore

−3
ϵ = 0.002⋅10 m =4⋅10−5
−2
D 5⋅10 m

65
Putting these values into Colebrook’s equation and rearranging, we seek the root of:

g( f )=
1
√f (
+2.0 log 1.081⋅10−5 +
2.51
)
8666 √ f
=0 (D.1)

Expressing Eq. (D.1) as Python function:

from math import sqrt, log10

def g(f):
_temp = 1.081E-5 + 2.51/(8666*sqrt(f)) #inside log
return 1/sqrt(f) + 2.0* log10(_temp)

In order to use one of the root finding methods (bracket, open or hybrid), we need at least 1 initial guess.
We already know that friction factor must be greater than 0. Therefore we can be tempted to choose 0;
however, looking at the denominator of Eq. (D.1) it tells us that this is not possible. Therefore we can
choose a number slightly greater than zero and apply Newton’s method.

However, Eq. (D.1) is not very calculus friendly! Even if we take the derivative, we know that open
methods can diverge…

Is there a better way to approach the problem?

The answer is yes! Let’s first plot the Moody chart to get some insights:

import scisuit.plot as plt

plt.moody()
plt.show()
If one inspects Moody chart (Fig. D.1), it can be seen that the friction factor ranges from 0.01 to 0.1.
Therefore knowing this range allows us to use bracketing methods and be sure to find a root!

from scisuit.roots import brentq

result = brentq(g, a=0.01, b=0.1)

print(result)
Brent's method (inverse quadratic interpolation)
Root=0.03214, (7 iterations).

We find f=0.03214. It is seen that knowledge gained from Moody chart proved to be very useful.
However, it includes a wider range than needed.
Figure D.1: Moody chart (generated by scisuit Python package).

Can we narrow down the initial estimate and therefore obtain higher performance in finding the root?

Luckily, the answer is still yes! The paper published by Chen (1984) gives an explicit simple equation for
estimating the friction factor. Chen’s equation is as follows:

0.3
1 ϵ )b ]
f =c [ + K (
Re a D

For the constants a, b and K, Chen (1984) states that for turbulent regions c =0.3164, a=0.83 and when
b=1.0 then K=0.11. Writing Chen’s equation as Python function:

def Chen_f(Re, Eps, D):

temp1 = 1 / Re**0.83
temp2 = 0.11*(Eps / D)
return 0.3164*(temp1 + temp2)**0.3

Calculating the friction factor with the defined Python function:

Re, Eps, D = 8666, 0.002E-3, 5E-2

f_est = Chen_f(Re, Eps, D)
print(f_est)
0.033173

67
The estimate of the friction factor with Chen’s equation is indeed very close to the actual root which we
calculated as 0.03214. However, noting that we obtained only a single starting point our choice so far
becomes limited to Newton’s method.

For the Reynold’s numbers of 4000 and 10000, Chen (1984) gives the estimated percentage deviations
from Colebrook equation for different relative roughness. Let’s choose the maximum percentage
deviations for over- and under-estimates, which is [-13.2%, +4.5%], and expand the estimated value using
the percentage deviations (we believe true root will be in between):

a = f_est*(1 - 0.132)
b = f_est*(1 + 0.045)

Now that we have two starting points, a and b, and therefore can use Brent’s or ITP methods.

from scisuit.roots import brentq, itp

result_bq = brentq(g, a = a, b = b)
print(result_bq)

result_itp = itp(g, a = a, b = b)
print(result_itp)
Brent's method (inverse quadratic interpolation)
Root=0.03214, (4 iterations).

ITP method
Root=0.03214, Error=5.16e-05 (4 iterations).

This is equal to our first attempt but with roughly 43% less iterations needed as our estimate using Chen’s
equation was very close to the root.

Using the friction factor to calculate pressure-drop:

2
L ρV
Δ P=f
D 2
2
60 m 998.2×0.191
Δ P=0.03214 ⋅ =702.23 Pa
5⋅10−2 m 2
 E. Heat Transfer

1. Heat Exchanger Design – LMTD

Background: Consider the following temperature profile in a counter-flow heat exchanger where hot
fluid enters from one end and the cold fluid enters from the opposite end.

The temperature difference at point #1 is

Δ T 1 =T h1−T c 1 whereas at point #2
Δ T 2 =T h2−T c 2 . One can quickly realize that
ΔT1 ≠ ΔT2.

Figure E.1: Temperature profile in a counter flow heat

exchanger (Adapted from Holman 2008)

In order to quantify the heat transfer, a suitable mean temperature difference (MTD) across the heat
exchanger needs to be known. The suitable MTD in this case is called the logarithmic mean temperature
difference (LMTD) and is mathematically expressed as follows:

(T h 2−T c 2 )−(T h1−T c 1 ) Δ T 2−Δ T 1

Δ T m= =
ln
[ (T h2 −T c 2 )
(T h1 −T c 1 ) ] ln
[ ]
ΔT2
ΔT1

Problem: A hot process stream of heat capacity flow rate 100 kW/°C has inlet temperature T 1 = 125°C
and outlet temperature T2 = 50°C. It is known that the overall heat transfer coefficient is virtually
independent of the cooling water flow rate, and at the relevant process stream flow rate has a value
corresponding to UA = 175 kW/°C. If cooling water enters at 30°C, what is the exit temperature of the
cooling water stream and what is its flow rate? (Adapted from Paterson 1984)

69
Solution:

Had we known the flow rate of the water, the problem would have been a trivial one. However, note that
both the flow rate of the water and its exit temperature are unknown.

Since we know the heat capacity flow rate of the hot stream and its inlet and exit temperatures, the heat
transfer rate can be calculated:

kW
Q= ṁ⋅c p⋅Δ T =100 ×(125−50 )°C=7500 kW
°C

kW
Q=UA Δ T m →7500 kW =175 ×ΔT m → Δ T m=42.857 ° C
°C

In the equation for LMTD ΔT2 =50-30=20°C and ΔTm=42.857°C, and therefore to find the outlet
temperature of water ΔT1 should be computed. Placing the knowns (ΔT2 and ΔTm) the LMTD equation can
be rewritten as follows:

20− X
f ( X )=42.857− =0
ln[ ]
20
X

The exit temperature of water is the root of the above equation and therefore it needs to be written as
Python function:

from math import log

f = lambda x: 7500 / 175 - (20-x) / log(20/x)

Since we will be using a bracketing method two estimates of the temperature are needed. By looking at
Fig. (E.1), it can be seen that Tc1 can not be greater than T h1 and cannot be smaller or equal to Tc2, therefore
Tc2<Tc2<Th1. Thus the interval is [Tc2 + δ, Th1 – δ]. Here δ has been arbitrarily chosen as 1.0. Now that a
range has been established bracketing methods can be employed:

from scisuit.roots import brentq

result = brentq(f, a=31, b=124)

print(result)
Brent's method (inverse quadratic interpolation)
Root=78.72298, (5 iterations).
After 5 iterations, the root has been found as 78.7229. In other words ΔT1=78.7229°C. Since ΔT1 is
known, the rest of the straightforward computations are left as an exercise to the reader.

Paterson (1984) proposed the following non-iterative solution in his paper:

(
Δ T 1 = 7 Δ T 2 +6
Q
UA ) (
−4 √ 3 Δ T 22 +2 Δ T 2
Q
UA )
Note that in Paterson’s equation Q/UA is equal to LMTD, ΔTm=42.86°C. Placing the knowns (ΔT2 and
ΔTm) gives ΔT1=78.57°C. A simpler approach to the non-iterative solution has been proposed by Chen
(1987). Chen’s equation is as follows:

( )
2 2 1/3
Δ T 1 Δ T 2 +Δ T 1 Δ T 2
Δ T m=
2

Note that Chen’s equation can also be expressed as a polynomial of AX2 + BX + C = 0, where A=ΔT2, B=
ΔT22 and C=- 2ΔTm3. Therefore the root of the polynomial yields ΔT1.

import numpy as np

A, B, C = 20, 400, -2*7500 / 175**3

poly = np.polynomial.Polynomial([C, B, A])

print(poly.roots())
[-99.2844 79.284]

Chen (1987) also proposed the following direct solution, where finding the roots of the polynomial can be
avoided:

√[ ( )]
2
−Δ T 2 ΔT2 2 Q 3
Δ T 1= + +
2 4 Δ T 2 UA

Placing the knowns in the equation gives ΔT1=79.2844°C.

71
 2. Transient Heat Conduction - A pathological case
Background: Many heat transfer problems are time dependent and such transient problems arise when
there is a change in the boundary conditions. When such conditions occur, in order to obtain the exact
spatial solution, the following equation needs also to be solved for different Biot (Bi) numbers and
positive roots should be obtained:

f (x )=x⋅tan (x )− Bi (E.1)

Problem:

Find the solution of f (x )=x⋅tan (x )− Bi for different Bi numbers.

Solution:

To narrow down the solution, let’s arbitrarily choose a Bi number and focus on it by assuming different Bi
numbers will follow the similar rationale. Let’s choose Bi as 100.

Let’s take a look at the plot of the function:

It is clearly seen that, the function has several roots and

we wish to obtain the first 4 roots as it is mostly
sufficient enough transient heat transfer problems.

Figure E.2: Plot of x⋅tan( x )−100

Let’s define the equation as a Python function:

from math import tan, cos

f = lambda x: x*tan(x) - 100

Unlike the previous problems, here we have no intuition about possible values of x. However, looking at
the solution table from a heat transfer book (Incropera and DeWitt, 1996), it is seen that possible values
for the first four roots range between 1.55 to 10.88.

Bracketing the root here is not an easy task (see Fig. E.2). Taking the derivative of the function is
straightforward so our intuition tells us to use Newton’s method as it requires only a single initial estimate.

df = lambda x: tan(x) + x*(1/cos(x))**2

Let’s try with different starting points (x0):

from scisuit.roots import newton

x0 = [0.1, 1, 2]
roots = [newton(f=f, x0=v, fprime=df) for v in x0]

#Do roots satisfy the equation?

f_v = [f(elem.root) for elem in roots]

print(*roots, sep="\n")
print(*f_v, sep="\n")
Newton method (Newton-Raphson)
Root=496.57036, Error=9.16e-06 (4 iterations).

Newton method (Newton-Raphson)

Root=51.36180, Error=9.49e-08 (26 iterations).

Newton method (Newton-Raphson)

Root=45.12917, Error=2.91e-06 (28 iterations).

8.829331932247442e-09
5.002220859751105e-12
5.070631914350088e-09

It is seen that although the starting points were fairly close to each other, they yielded completely different
roots. Furthermore, it can be seen from Fig. (E.2) that there is actually a root between 1 and 2 and none of
the starting points yielded a root between 1 and 2.

Since we “know” the lower and upper bounds, let’s try Brent’s method:

result = brentq(f, a=1, b=2)

print(result)
RuntimeError: Root is not bracketed.

73
As already mentioned, bracketing the root is a challenge for this problem. Let’s arbitrarily choose a=1.57
and b=1.575, then we have negative and positive values of the function. Let’s use the powerful and
reliable methods to search for the root:

from scisuit.roots import brentq, ridder, itp

roots = [func(f, a=1.57, b=1.575) for func in (brentq, ridder, itp)]

print(*roots, sep="\n")
Brent's method (inverse quadratic interpolation)
Root=1.57080, (13 iterations).

Ridder's method
Root=1.57079, (6 iterations).

ITP method
Root=1.57080, Error=4.28e+05 (10 iterations).

All of the chosen methods returned the root as ~1.5708, which is completely incorrect! [f(x) =
-427737.433]. Before explaining why this happened, let’s zoom in the function in the chosen interval:

We see that at the chosen interval the function is

discontinuous which defeats the very pillar of
intermediate value theorem, which begins with “if f is a
continuous function …”.

The termination criteria for most bracketing methods is

based on relative error, which is defined as:
|x(i+i)-x(i)|<ε
Therefore, we see that after some iterations the error will
Figure E.3: Plot of xtan( x)−100 be less than tolerance and the function will return once
this condition is satisfied.

Although this was an extreme case it should be noted that if there are suspected discontinuities in the
chosen interval it is always best to check the end-result before accepting it as root.
Let’s have another attempt and choose a=1 and b=1.57.

result = ridder(f, a=1, b=1.57)

print(result.root)
1.555246953

Verifying the result, f(1.555246953) = 0.0118. Although we have found the correct root, we were “lucky”
with our choice of the interval. Therefore, for such pathological cases, it is a good idea to create look-up
tables for further uses.

75
 F. Evaporation (Unit Operations)

Background: Evaporation is employed to remove water from dilute liquid foods to obtain a concentrated
liquid product. Removal of water from foods provides microbiological and chemical stability. In order to
remove the water, heat is supplied via steam.

Problem: We are required to find the steam requirements of a double-effect forward-feed evaporator to
concentrate a liquid food material from 11 to 50% total solids concentrate. The feed rate is 10000 kg/h at
20°C. Inside the second effect the boiling of liquid takes place under vacuum at 70 °C. The saturated
steam is supplied to the first effect at 198.5 kPa. The condensate from the first effect exits at 120 °C and
from the second effect at 95 °C.

The overall heat-transfer coefficient in the first and second effect are 1000 and 800 W/(m2 °C),
respectively. The specific heats of the liquid food are C pF=3.8, CpI=3.0, and CpP=2.5 kJ/(kg °C) at initial,
intermediate, and final concentrations. Assume the heat exchanger areas and temperature gradients are
equal in each effect. (Adapted from Singh and Heldman 2008).

Solution:

Figure F.1: Adapted from Singh and Heldman (2008).

Overall Mass Balance:

mF⋅x F =m P⋅x P
2.78⋅0.11=mP⋅0.5→ m p=0.61kg

mF =mv 1 +mv 2 +m P
2.78=mv 1 +mv 2 +0.61

mv 1 +mv 2 =2.168 kg

Energy Balance on 1st Effect

mF⋅C p F⋅T F +mS⋅H S =m I⋅C PI⋅T I +mv 1⋅H v 1 +mC⋅H C

2.78×3.8×20+mS ×2706.3=mI ×3×95+mv 1⋅2668.1+mS⋅503.71

211.28+mS⋅2202.59=m I⋅285 +mv 1⋅2668.1

Energy Balance on 2nd Effect

mI⋅C pI⋅T I +mv 1⋅H g@ 95°C =mv 1⋅H f @95 °C +mv 2⋅H g @70° C +m P⋅C pP⋅T P

mI⋅3×95+mv 1⋅2668.1=mv 1⋅397.96 +mv 2⋅2626.8+0.61×2.5×70

mI⋅285+mv 1⋅2270.5=mv 2⋅2626.8+106.75

Energy Balance Using Overall Heat Transfer Coefficient

Q=UA Δ T

mS⋅H fg =1000×25× A → mS×2202.59 = 10

mv 1⋅H fg =800×25× A mv 1×2270.14 8

mS
=1.288
mv 1

77
Putting All Equations Together

mv 1 +mv 2 =2.168 kg

mI⋅285+mv 1⋅2668.1−mS⋅2202.59=211.28

mI⋅285+mv 1⋅2270.5−mv 2⋅2626.8=106.75

mS −1.288⋅mv 1 =0

4 equations and 4 unknowns (mv1, mv2, ms, mI).

( ) () ( )
1 1 0 0 mv 1 2.168
m
−2202.59 285 , x= v 2 , b= 211.28
A= 2668.1 0
2270.5 −2626.8 0 285 mS 106.75
−1.28 0 1 0 mI 0

import numpy as np

A = np.array([
[1, 1, 0, 0],
[2668.1, 0, -2202.59, 285],
[2270.5, -2626.8, 0, 285],
[-1.28, 0, 1, 0] ])

b = np.array([2.168, 211.28, 106.75, 0])

x = np.linalg.solve(A, b)
print(x)
[1.10733 1.06067 1.41738 1.32886]

Therefore mv1=1.10733 kg/s, mv2=1.06067 kg/s, mS=1.41738 kg/s and mI=1.32886 kg/s
References

Chapra SC, Canale RP (2013). Numerical methods for engineers, seventh edition. McGraw Hill
Education.

Chen JJJ (1984). A simple explicit formula for the estimation of pipe friction factor. Proceedings of the
Institution of Civil Engineers, 77, 49-55

Chen JJJ (1987). Comments on improvements on a replacement for the logarithmic mean. Chemical
Engineering Science, 42(10), 2488-2489.

Çengel YA, Boles MA, Kanaoglu M (2019). Thermodynamics: an engineering approach, 9 th edition,
McGraw-Hill Education.

Çengel YA, Cimbala JM (2006). Fluid mechanics: fundamentals and applications. McGraw-Hill
Education.

Dey S, Zeeshan Ali SK, Padhi E (2019). Terminal fall velocity: the legacy of Stokes from the perspective
of fluvial hydraulics. Available at: https://royalsocietypublishing.org/doi/10.1098/rspa.2019.0277

Geldart D (1973). Types of gas fluidization. Powder Technology, 7(5), 285-292.

Gupta RK (2019). Numerical Methods Fundamentals and Applications. Cambridge University Press.

Holman JP (2008). Heat Transfer 10th Edition, McGraw-Hill series in mechanical engineering.

Incropera FP, DeWitt DP (1996). Fundamentals of Heat and Mass Transfer, Fourth Edition. John Wiley
& Sons Ltd.

Jaluria Y (2020). Design and optimization of thermal systems, 3rd Edition, CRC Press/Taylor & Francis
Group.

Oliveira IFD, Takahashi RHC (2020).An Enhancement of the Bisection Method Average Performance
Preserving Minmax Optimality. ACM Transactions on Mathematical Software, 47(1), Article 5.

Paterson WR (1984). A replacement for the logarithmic mean. Chemical Engineering Science, 39 (11),
1635-1636

Press WH, Teukolsky SA, Vetterling WT, Flannery BP (2007). Numerical Recipes The Art of Scientific
Computing. Cambridge University Press.

Rhodes M. (2008). Introduction to Particle Technology, 2nd edition. John Wiley & Sons Ltd.

79
Ridders CJF (1979). A New Algorithm for Computing a Single Root of a Real Continuous Function.
IEEE Transactions on Circuits and Systems, 26 (11).

Shilton NC, Niranjan K (1993). Fluidization and Its Applications to Food Processing. Food Structure,
12, 199-215.

Singh RP, Heldman D. (2008). Introduction to Food Engineering 4th Edition. Academic Press.

Smith JM, Van Ness HC, Abbott MM, Swihart MT (2017). Introduction to chemical engineering
thermodynamics, 8th edition. McGraw-Hill Education.
Appendix
Test Functions
To test and compare the above-mentioned methods following functions were used. The derivative of the
functions are presented in the second column.

Table 1. Test functions used for comparisons

f(x) f`(x) Root Func Source

+ √ 2⋅sin( x))− √
2 3 Anon (2021a)
x 3 4x 0.39942
2
f1 = x ⋅( + √ 2 x 2 cos ( x)+2 √ 2 x sin ( x)
3 18 3
11 10 Anon (2021a)
f2 = 11⋅x −1 121 x 0.80413
35 34 Anon (2021a)
f3 = 35⋅x −1 1225 x 0.90341
−9 −9 x −9 −9 x Anon (2021a)
f4 = 2∗( x⋅e −e )+1 2 e +18e 0.07701
2 9 8 Anon (2021a)
f5 = x −(1 – x) 2 x +9(1− x) 0.25921
−9 x 9 −9 x 9x 8 Anon (2021a)
f6 = ( x−1)⋅e +x e ⋅(10−9 x+9 e x ) 0.53674
2 x 1 1 x 0.44754 Anon (2021a)
f7 = x +sin( )− 2 x + cos ( )
9 4 9 9
1 1 1 0.11111 Anon (2021a)
f8 = ⋅(9− )
8 x 8x
2

f9 = tan( x)−x – 0.046302 −1+sec ( x )

2
0.50000 Anon (2021a)

f10 = x + x⋅sin( √ 75 x) – 0.2

2
2 x + √ 75 x cos( √ 75 x)+sin ( √75 x) 0.67980 Anon (2021a)

10 9 Chapra & Canale (2013)

f11 = x – 1 10 x 1.0
2
f12 = x −5 2x 2.23607 -

Anon (2021a). https://www.rdocumentation.org/packages/pracma/versions/1.0.5/topics/ridder

It is insightful to plot some of the functions to be able to understand the presented methods better and
therefore 4 functions were selected for this purpose. All plots were generated using Wolfram Alpha.

81
 11
f =11⋅x −1 f =( x−1)⋅e
−9 x
+x
9

10 2
f =x – 1 f =x −5