# Two Optimal Eighth-Order Derivative-Free Classes of Iterative Methods

Authors: F. Soleymani; S. Shateyi
Journal: Abstract and Applied Analysis
 (2012)

---

## Abstract

Optimization problems defined by (objective) functions for which derivatives are unavailable or available at an expensive cost are emerging in computational science. Due to this, the main aim of this paper is to attain as high as possible of local convergence order by using fixed number of (functional) evaluations to find efficient solvers for one-variable nonlinear equations, while the procedure to achieve this goal is totally free from derivative. To this end, we consider the fourth-order uniparametric family of Kung and Traub to suggest and demonstrate two classes of three-step derivative-free methods using only four pieces of information per full iteration to reach the optimal order eight and the optimal efficiency index 1.682. Moreover, a large number of numerical tests are considered to confirm the applicability and efficiency of the produced methods from the new classes.


---

## Body

## 1. Introduction

This paper focuses on finding approximate solutions to nonlinear scalar and sufficiently smooth equations by derivative-free methods. Techniques such as the false position method in the root-finding of a nonlinear equationf(x)=0, requires bracketing of the zero by two guesses. Such schemes are called bracketing methods. These methods are almost always convergent since they are based on reducing the interval between the two guesses so as to zero in on the root of the equation. In the Newton method, the zero is not bracketed. In fact, only one initial guess of the solution is needed to get the iterative process started in order to find the zero. The method hence falls in the category of open methods.Convergence in open methods is not guaranteed but if the method does converge, it does so much faster than the bracketing methods [1]. Although Newton’s iteration has widely been discussed and improved in the literature, see for example, [2, 3], one of the main drawback, which is the matter of first derivative evaluation, occasionally restricts the application of this method or its variants. On the other hand, when we discuss improving the iterative without memory methods for solving one variable nonlinear equations, the conjecture of Kung and Traub [4] is taken automatically into consideration. It should be remarked that according to the unproved conjecture of Kung and Traub [4], the index of efficiency will not pass the maximum level 2(n-1)/n, wherein n is the total number of (functional) evaluations.Apart from being involved in the first derivative, Newton’s iteration will use the second derivative of the function, when it is applied inoptimization problems to final the local minima. Therefore, its use will be limited especially when the cost of first and second derivatives of the functions is expensive. And subsequently, derivative-free algorithms come to attention.For the first time, Steffensen in [5] gave the following derivative-free form of Newton’s iteration
(1.1)xn+1=xn-f(xn)f[xn,wn],wn=xn+f(xn),n=0,1,2,…
which possesses the same rate of convergence and efficiency index as Newton’s.In this work, we suggest novel classes of three-step four-point iterative methods, which are without memory, derivative-free, optimal, and therefore consistent with hard problems. For this reason, the contents of the paper unfold as comes next. Section2 reveals our main contribution as some generalizations to the fourth-order uniparametric family of Kung and Traub [4]. Subsequently, Section 3 gives a very short discussion on the available derivative-free methods in the literature. Section 4 discusses the implementation of the new produced methods from our classes on large number of numerical examples. And finally, a short conclusion will be given in Section 5.


## 2. Main Outcome

In order to contribute and provide a class of methods, which are derivative-free with high efficiency index, we take into consideration the optimal two-step fourth-order uniparametric family of Kung and Traub [4] in the first two steps of a three-step cycle in which the Newton’s iteration has been performed in the last step as comes next
(2.1)yn=xn-f(xn)f[xn,wn],wn=xn+βf(xn),β∈ℝ∖{0},zn=yn-f(yn)f(wn)(f(wn)-f(yn))f[xn,yn],xn+1=zn-f(zn)f′(zn).This scheme includes four evaluations of the function and one of its first-order derivative to reach the order eight and 1.516 as its efficiency index. To improve the efficiency index, we first consider the same approximation as used in the second step of (2.1) to annihilate f′(zn) and then take advantage of weight function approach as follows:
(2.2)yn=xn-f(xn)f[xn,wn],wn=xn+βf(xn),zn=yn-f(yn)f(wn)(f(wn)-f(yn))f[xn,yn],xn+1=zn-f(zn)f(wn)(f(wn)-f(yn))f[xn,yn]{G(φ)×H(τ)×Q(σ)×L(ρ)},
where β∈ℝ∖{0}, φ=f(z)/f(y), τ=f(z)/f(w), σ=f(z)/f(x), ρ=f(y)/f(w), without the index n, and G(φ), H(τ), Q(σ), L(ρ) are four real-valued weight functions, which force the order to arrive at the maximum level eight by using the fixed number of evaluations per cycle. Theorem 2.1 shows that (2.2) will arrive at local eighth-order convergence by using only four function evaluations per full cycle. This reveals that any method from our proposed class possesses 1.682 as the efficiency index, which is optimal according to the Kung and Traub conjecture, while it is fully free from derivative evaluations.Theorem 2.1.
Letα∈D be a simple zero of a sufficiently differentiable function f:D⊆ℝ→ℝ and let that cj=f(j)(α)/j!, j≥1. If x0 is sufficiently close to α, then, (i) the local order of convergence of the solution by the class of methods without memory defined in (2.2) is eight, when
(2.3)G(0)=G′(0)=1,|G′′(0)|<∞,H(0)=H′(0)=1,Q(0)=1,Q′(0)=1,L(0)=1,L′(0)=L′′′(0)=0,L′′(0)=2+2βf[xn,wn],|L(4)(0)|<∞,
and (ii) this solution reads the error equation
(2.4)en+1=xn+1-α=-124c17((-2c22+c1c3)2c2(2c22-c1c3)(1+c1β)2×((-2c22+c1c3)212(1+c1β)2×(-2(7c24-8c1c22c3+c12c32+c12c2c4)+(-2c22+c1c3)2G′′(0))+c24L(4)(0)))en8+O(en9).Proof.
We expand any terms of (2.2) around the simple root α in the nth iterate by taking into account en=xn-α and f(α)=0. Thus, we write f(xn)=c1en+c2en2+c3en3+c4en4+⋯+O(en9). Accordingly, we attain
(2.5)yn-α=c2(1c1+β)en2+⋯+O(en9).
In the same vein, we obtain
(2.6)zn-α=(2c23-c1c2c3)(1+c1β)2c13en4-1c14(1+c1β)×(c12c32(1+c1β)(2+c1β)+c12c2c4(1+c1β)(2+c1β)+c24(10+c1β(11+5c1β))-c1c22c3(14+c1β(19+7c1β)))en5+⋯+O(en9).
We also have f(zn)=(1/c12)(2c23-c1c2c3)(1+c1β)2en4+⋯+O(en9). Now using symbolic computation in the last step of (2.2), we attain
(2.7)zn-f(zn)f(wn)(f(wn)-f(yn))f[xn,yn]-α=(6c25-5c1c23c3+c12c2c32)(1+c1β)3c15en6+⋯+O(en9).
Furthermore, by considering (2.7) and the real-valued weight functions as in (2.3), we will obtain the error equation (2.4). This shows that the proposed class of derivative-free methods (2.2)-(2.3) reaches the optimal eighth-order convergence by using only four function evaluations per full iteration. This ends the proof.Now, any optimal three-step four-point derivative-free without memory method can be produced by using (2.2)-(2.3). As an instance, we can have (β=0.01)
(2.8)yn=xn-f(xn)f[xn,wn],wn=xn+0.01f(xn),zn=yn-f(yn)f(wn)(f(wn)-f(yn))f[xn,yn],xn+1=zn-f(zn)f(wn)(f(wn)-f(yn))f[xn,yn]×{(f(yn)f(wn))2(1+f(zn)f(yn))(1+f(zn)f(wn))(1+f(zn)f(xn))×(1+(1+0.01f[xn,wn])(f(yn)f(wn))2)},
where its error equation reads
(2.9)en+1=(1+0.01c1)4c2(2c22-c1c3)(7c24-8c1c22c3+c12c32+c12c2c4)c17en8+O(en9).We should here recall that per computing step for any of the methods from the new class, the values off(wn)/((f(wn)-f(yn))f[xn,yn]) and f[xn,wn] should be computed only once, and then their values will be considered in the rest of the cycle wherever required.Many of the nonlinear functions are arising from solving complex environmental engineering problems, where the objective depends on the output of a numerical simulation of a physical process. These simulators are expensive to evaluate because they involve numerically solving systems of partial differential equations governing the underlying physical phenomena. However, function evaluation remains the dominant expense in optimization problems since the savings in time are often offset by increased accuracy of the simulation. For these reasons, algorithms like (2.2)-(2.3) in which there is no need of derivative evaluation, the order is optimal as well as the efficiency index is high are important in hard problems.Before going to the next sections, it is required to have a discussion on another similar class of derivative-free methods that is attainable by choosing a different approximation in the first step of (2.1) and also with a somehow different weight functions in the last step. Considering these in (2.1), we can have the following without memory derivative-free class
(2.10)yn=xn-f(xn)f[xn,wn],wn=xn-βf(xn),zn=yn-f(yn)f(wn)(f(wn)-f(yn))f[xn,yn],xn+1=zn-f(zn)f(wn)(f(wn)-f(yn))f[xn,yn]{G(φ)×H(τ)×Q(σ)×L(ρ)},
which its order is given in Theorem 2.2 to be eight by choosing appropriate weight functions. Noting that β∈ℝ∖{0}, φ=f(z)/f(y), τ=f(z)/f(w), σ=f(z)/f(x), ρ=f(y)/f(w), without the index n, G(φ),H(τ),Q(σ), and L(ρ) are four real-valued weight functions.Theorem 2.2.
Letα∈D be a simple zero of a sufficiently differentiable function f:D⊆ℝ→ℝ and let that cj=f(j)(α)/j!,j≥1. If x0 is sufficiently close to α, then, (i) the local order of convergence of the solution by the class of methods without memory defined in (2.10) is eight, when
(2.11)G(0)=G′(0)=1,|G′′(0)|<∞,H(0)=1,H′(0)=2-βf[xn,wn],Q(0)=1,Q′(0)=0,L(0)=1,L′(0)=L′′′(0)=0,L′′(0)=2-2βf[xn,wn],|L(4)(0)|<∞,
and (ii) this solution reads the error equation
(2.12)en+1=xn+1-α=-124c17((-2c22+c1c3)2c2(2c22-c1c3)(-1+c1β)2×((-2c22+c1c3)212(-1+c1β)2((-2c22+c1c3)2-2(7c24-8c1c22c3+c12c32+c12c2c4)+(-2c22+c1c3)2G′′(0))+c24L(4)(0)))en8+O(en9).Proof.
The proof of this theorem is similar to the proof of Theorem2.1. It is hence omitted.Now, by using (2.10)-(2.11), we can have some other efficient optimal eighth-order without memory derivative-free methods, such as
(2.13)yn=xn-f(xn)f[xn,wn],wn=xn-f(xn),zn=yn-f(yn)f(wn)(f(wn)-f(yn))f[xn,yn],xn+1=zn-f(zn)f(wn)(f(wn)-f(yn))f[xn,yn]×{(f(yn)f(wn))2(1+f(zn)f(yn))(1+(2-f[xn,wn])(f(zn)f(wn)))×(1+(f(zn)f(xn))2)(1+(1-f[xn,wn])(f(yn)f(wn))2)},
where its error equation is as follows:
(2.14)en+1=(-1+c1)4c2(2c22-c1c3)(7c24-8c1c22c3+c12c32+c12c2c4)c17en8+O(en9).
Another example from the new class of optimal iterations (2.10)-(2.11) can be
(2.15)yn=xn-f(xn)f[xn,wn],wn=xn-f(xn),zn=yn-f(yn)f(wn)(f(wn)-f(yn))f[xn,yn],xn+1=zn-f(zn)f(wn)(f(wn)-f(yn))f[xn,yn]{W1},
where
(2.16)W1=(1+f(zn)f(yn)+(f(zn)f(yn))2)×(1+(2-f[xn,wn])(f(zn)f(wn)))×(1+(f(zn)f(xn))2)(1+(1-f[xn,wn])(f(yn)f(wn))2),
by the following error equation
(2.17)en+1=(-1+c1)4c22(2c22-c1c3)(3c23-4c1c2c3+c12c4)c17en8+O(en9).


## 3. A Brief Look at the Literature

In this section, we shortly present some of the well-known high-order derivative-free techniques to find the simple zeros of nonlinear equations for the sake of comparison. Kung and Traub in [4] introduced the following without memory two-step iteration
(3.1)yn=xn-f(xn)f[xn,wn],wn=xn+βf(xn),xn+1=yn-f(yn)f(wn)(f(wn)-f(yn))f[xn,yn],
where β∈ℝ∖{0}, and it was in fact the first two steps of our novel class (2.2)-(2.3) in this paper. They moreover gave the following four-point eighth-order iterative scheme
(3.2)yn=xn+βf(xn),zn=yn-βf(xn)f(yn)f(yn)-f(xn),wn=zn-f(xn)f(yn)f(zn)-f(xn)[1f[yn,xn]-1f[zn,yn]],xn+1=wn-f(xn)f(yn)f(zn)f(wn)-f(xn)×[1f(wn)-f(yn){1f[wn,zn]-1f[zn,yn]}-1f(zn)-f(xn){1f[zn,yn]-1f[yn,xn]}],
wherein β∈ℝ∖{0}. Soleymani in [6] suggested the following three-step derivative-free seventh-order method
(3.3)yn=xn-f(xn)f[xn,wn],wn=xn+f(xn),zn=yn-f(yn)f[xn,wn]{1+2+f[xn,wn]1+f[xn,wn]f(yn)f(xn)},xn+1=zn-f(zn)f[yn,zn]{1+11+f[xn,wn](f(yn)f(xn))2}.
For further reading, one should consult the papers [7–10] and the references therein.Remark 3.1.
In terms of computational point of view, the efficiency index of our classes of derivative-free without memory methods (2.2)-(2.3) (and the class (2.10)-(2.11)) is greater than that of Newton’s and Steffensen’s, that is, 1.414, 1.565 of the sixth-order derivative-free technique given in [11], 1.587 of (3.1), 1.626 of (3.3), and is equal to 1.682 of the family (3.2).


## 4. Numerical Experiments

We now check the effectiveness of the novel derivative-free classes of iterative methods. In order to do this, we choose (2.8) as the representative from our class (2.2)-(2.3). Note that the derived methods from the class (2.10)-(2.11) can also be used.We have compared (2.8) with Steffensen’s method (1.1), the fourth-order family of Kung and Traub (3.1) with β=0.01, the seventh-order technique of Soleymani (3.3), and the optimal eighth-order family of Kung and Traub (3.2) with β=1, using the examples listed in Table 1. The results of comparisons are given in Table 2 in terms of the number significant digits for each test function after the specified number of iterations, that is, for example, 0.1e-207 shows that the absolute value of the given nonlinear function (f1) after nine iterations (corresponding to iteration (1.1)) is zero up to 207 decimal places.Table 1
The examples considered in this study.
Test functions
Zeros
f
1
(
x
)
=
(
sin
x
)
2
+
x
α
1
=
0
f
2
(
x
)
=
(
1
+
x
)
+
cos
(
π
x
2
)
-
1
-
x
2
α
2
≈
-
0.728584046444826
⋯
f
3
(
x
)
=
(
sin
x
)
2
-
x
2
+
1
α
3
≈
1.404491648215341
⋯
f
4
(
x
)
=
e
-
x
+
sin
(
x
)
-
2
α
4
≈
-
1.0541271240912128
⋯
f
5
(
x
)
=
x
e
-
x
-
0.1
α
5
≈
0.111832559158963
⋯
f
6
(
x
)
=
x
4
+
8
sin
(
π
x
2
+
2
)
+
x
3
x
4
+
1
-
6
+
8
17
α
6
=
-
2
f
7
(
x
)
=
x
2
+
2
x
+
5
-
2
sin
(
x
)
-
x
2
+
3
α
7
≈
2
.
331967655883964
⋯
f
8
(
x
)
=
sin
-
1
(
x
2
-
1
)
-
x
2
+
1
α
8
≈
0.594810968398369
⋯
f
9
(
x
)
=
(
sin
(
x
)
-
2
2
)
(
x
+
1
)
α
9
≈
0.785398163397448
⋯
f
10
(
x
)
=
x
5
+
x
4
+
4
x
2
-
15
α
10
≈
1.347428098968304
⋯
f
11
(
x
)
=
x
-
sin
(
cos
(
x
)
)
+
1
α
11
≈
-
0.1660390510510295
⋯
f
12
(
x
)
=
x
5
-
10
cos
(
tan
-
1
(
x
)
)
α
12
≈
1.419315939421532
⋯
f
13
(
x
)
=
x
5
-
10
cos
(
tan
-
1
(
x
4
)
)
+
17
x
α
13
≈
0.580593457809920
⋯
f
14
(
x
)
=
sin
(
cos
(
tan
-
1
(
2
x
sin
(
x
)
)
)
)
-
2
x
α
14
≈
0.273402731005321
⋯
f
15
(
x
)
=
x
3
-
x
2
-
2
x
-
cos
(
x
)
+
2
α
15
≈
0.498542523582153
⋯
f
16
(
x
)
=
x
3
+
sin
(
x
)
-
30
α
16
≈
9.716501993365200
⋯
f
17
(
x
)
=
tan
-
1
(
x
2
-
x
)
α
17
=
1
f
18
(
x
)
=
sin
-
1
(
x
2
)
-
2
x
α
18
=
0
f
19
(
x
)
=
sin
(
-
3
x
cos
(
x
)
)
α
19
≈
-
0.74886062246711
⋯
f
20
(
x
)
=
x
2
-
cos
(
x
)
α
20
≈
0.89055270972295
⋯Table 2
Results of convergence for different derivative-free methods.
f
Guess
(1.1)
(3.1)
(3.3)
(3.2)
(2.8)
f
1
IT
9
4
3
3
3
TNE
18
12
12
12
12
0.3
|
f
|
0.1
e
-
207
0.3
e
-
143
0.1
e
-
126
0.1
e
-
210
0.4
e
-
257
0.2
|
f
|
0.3
e
-
264
0.5
e
-
177
0.7
e
-
161
0.1
e
-
267
0.1
e
-
323
f
2
IT
9
4
3
3
3
TNE
18
12
12
12
12
−0.9
|
f
|
0.3
e
-
29
0.8
e
-
61
0.5
e
-
29
0.8
e
-
60
0.7
e
-
54
−0.4
|
f
|
0.6
e
-
156
0.1
e
-
216
0.6
e
-
107
0.1
e
-
178
0.1
e
-
341
f
3
IT
9
4
3
3
3
TNE
18
12
12
12
12
1.25
|
f
|
0.7
e
-
411
0.2
e
-
199
0.2
e
-
322
0.3
e
-
381
0.2
e
-
373
1.6
|
f
|
0.1
e
-
298
0.1
e
-
203
0.5
e
-
229
0.4
e
-
258
0.3
e
-
378
f
4
IT
9
4
3
3
3
TNE
18
12
12
12
12
−1.3
|
f
|
0.6
e
-
259
0.4
e
-
182
0.2
e
-
211
0.5
e
-
110
0.4
e
-
339
−1
|
f
|
0.9
e
-
640
0.2
e
-
330
0.6
e
-
483
0.4
e
-
618
0.1
e
-
636
f
5
IT
10
5
3
3
3
TNE
20
15
12
12
12
0
|
f
|
0.1
e
-
714
0.4
e
-
917
0.5
e
-
220
0.2
e
-
375
0.3
e
-
435
−0.7
|
f
|
0.1
e
-
64
0.4
e
-
220
0.7
e
-
20
0.4
e
-
53
0.1
e
-
95
f
6
IT
8
4
3
3
3
TNE
16
12
12
12
12
−2.2
|
f
|
0.9
e
-
362
0.2
e
-
327
0.4
e
-
348
0.8
e
-
518
0.3
e
-
449
−1.7
|
f
|
0.4
e
-
221
0.3
e
-
186
0.2
e
-
119
0.5
e
-
231
0.1
e
-
156
f
7
IT
9
4
3
3
3
TNE
18
12
12
12
12
3
|
f
|
0.2
e
-
528
0.2
e
-
232
0.3
e
-
294
0.8
e
-
429
0.3
e
-
411
0.6
|
f
|
0.1
e
-
259
0.1
e
-
232
0.2
e
-
154
0.3
e
-
232
0.5
e
-
362
f
8
IT
9
4
3
3
3
TNE
18
12
12
12
12
1.3
|
f
|
Div.
0.1
e
-
172
0.3
e
-
52
0.1
e
-
38
0.7
e
-
300
0.3
|
f
|
0.2
e
-
487
0.6
e
-
275
0.1
e
-
316
0.3
e
-
466
0.5
e
-
555
f
9
IT
9
4
3
3
3
TNE
18
12
12
12
12
0.6
|
f
|
0.1
e
-
682
0.4
e
-
277
0.1
e
-
236
0.9
e
-
396
0.4
e
-
483
0.4
|
f
|
0.1
e
-
169
0.5
e
-
168
Div.
0.1
e
-
144
0.2
e
-
271
f
10
IT
8
4
3
3
3
TNE
16
12
12
12
12
1.36
|
f
|
0.3
e
-
90
0.4
e
-
442
0.1
e
-
206
0.5
e
-
490
0.8
e
-
873
1.32
|
f
|
0.8
e
-
3
0.5
e
-
353
0.8
e
-
5
0.6
e
-
229
0.5
e
-
696
f
11
IT
9
4
3
3
3
TNE
18
12
12
12
12
−1
|
f
|
0.1
e
-
5
0.1
e
-
44
0.2
e
-
34
Div.
0.1
e
-
53
0.3
|
f
|
0.3
e
-
313
0.9
e
-
209
0.1
e
-
192
0.5
e
-
314
0.4
e
-
376
f
12
IT
9
4
3
5
3
TNE
18
12
12
20
12
1.4
|
f
|
0.2
e
-
122
0.2
e
-
388
0.3
e
-
133
0.1
e
-
378
0.2
e
-
766
1.3
|
f
|
Div.
0.4
e
-
181
Div.
0.2
e
-
221
0.1
e
-
357
f
13
IT
18
4
3
3
3
TNE
36
12
12
12
12
0.3
|
f
|
0.5
e
-
750
0.9
e
-
138
0.2
e
-
63
0.9
e
-
3
0.3
e
-
411
0.8
|
f
|
0.1
0.5
e
-
245
0.6
e
-
35
0.1
e
-
194
0.1
e
-
384
f
14
IT
8
4
3
3
3
TNE
16
12
12
12
12
0.2
|
f
|
0.2
e
-
42
0.9
e
-
334
0.1
e
-
519
0.1
e
-
214
0.3
e
-
604
0.5
|
f
|
0.2
e
-
283
0.5
e
-
263
0.1
e
-
306
0.8
e
-
364
0.3
e
-
468
f
15
IT
8
4
3
3
3
TNE
16
12
12
12
12
0.3
|
f
|
0.1
e
-
269
0.2
e
-
332
0.1
e
-
386
0.6
e
-
666
0.2
e
-
417
0.4
|
f
|
0.6
e
-
352
0.7
e
-
295
0.8
e
-
446
0.3
e
-
552
0.6
e
-
544
f
16
IT
9
4
3
3
3
TNE
18
12
12
12
12
9
|
f
|
0.9
e
-
391
0.1
e
-
310
0.1
e
-
246
0.4
e
-
346
0.6
e
-
528
9.2
|
f
|
0.1
e
-
474
0.3
e
-
314
0.5
e
-
281
0.2
e
-
448
0.6
e
-
573
f
17
IT
9
4
3
3
3
TNE
18
12
12
12
12
0.1
|
f
|
Div.
0.1
e
-
209
0.2
e
-
652
0.9
e
-
850
0.1
e
-
388
0.8
|
f
|
0.3
e
-
166
0.3
e
-
115
0.3
e
-
36
0.6
e
-
106
0.2
e
-
200
f
18
IT
9
4
3
3
3
TNE
18
12
12
12
12
0.3
|
f
|
0.2
e
-
457
0.1
e
-
162
0.6
e
-
406
0.3
e
-
377
0.2
e
-
294
0.2
|
f
|
0.1
e
-
534
0.4
e
-
216
0.7
e
-
490
0.2
e
-
458
0.4
e
-
401
f
19
IT
10
4
3
3
3
TNE
20
12
12
12
12
−0.7
|
f
|
0.4
e
-
294
0.2
e
-
282
0.2
e
-
56
0.1
e
-
202
0.1
e
-
504
−0.9
|
f
|
Div.
0.2
e
-
116
Div.
Div.
0.3
e
-
182
f
20
IT
8
4
3
3
3
TNE
16
12
12
12
12
0.9
|
f
|
0.5
e
-
445
0.5
e
-
552
0.1
e
-
588
0.2
e
-
937
0.4
e
-
1074
0.7
|
f
|
0.1
e
-
89
0.5
e
-
202
0.4
e
-
72
0.2
e
-
203
0.1
e
-
375It is important to review the proof of convergence for our proposed classes of methods (or the compared methods in Table2) before implementing them. Specifically, one should review the assumptions made in the proofs, when the result of the iterations become divergent. For situations, where the method fails to converge, it is because the assumptions made in the proofs are not met. For this reason in the long run, we give a Mathematica 8. code to extract initial approximations for all the zeros of a nonlinear function in an interval.It can be observed from Table2, that almost in most cases our contributed method from the class (2.2)-(2.3) is superior in solving nonlinear equations. Generally speaking, iterative methods of the same order and efficiency, and also with the same background, that is, Newton-type or Steffensen-type methods, have similar numerical outputs due to their similar characters. Note also that experimental results show that whatever the value of β≠0 is smaller, then the output results of solving nonlinear equations will be more accurate.We have completed Table2 for two different initial guesses. In Table 2, IT and TNE stand for number of iterations, and total number of (functional) evaluations. To have a fair comparison, we used high number of iterations for (1.1). The numerical results for the test functions support the theoretical discussions given in Section 2. We also point out that the procedure of applying the new iterative methods for nonsmooth functions is similar to those recently illustrated in [12]. And for multiple zeros, we must first take into account a transformation to convert the multiple zero into a simple one and then employ our iterative methods on the transformed equation. Moreover, for applying on functions with inexact coefficients, one remedy is to rationalize the coefficients first and then apply the desired scheme for obtaining the solutions with high accuracy.An important aspect of implementing high-order nonlinear solvers is in finding very robust initial guesses to start the process, when high precision computing is needed. As discussed in Section1, the convergence of our iterative methods is locally. To resolve this shortcoming, the best way is to rely on hybrid algorithms, in which the first item produces a robust initial point and the second item employs the new iterative methods when high precision is required. There are some ways in the literature to find robust starting points, mostly based on interval mathematics see for example, [13]. But herein we take into consideration the programming package Mathematica 8 [14] which could be efficiently applied on lists for high precision computing. In fact using [15], we could build a list of initial guesses enough close with good accuracy to start the procedure of our optimal derivative-free eighth-order methods. The procedure of finding such a robust list is based on the powerful command of NDSolve for the nonlinear function on the interval D=[a,b]. Such a way can be written in the following piece of Mathematica code by considering an oscillatory function as the input test function on the domain D=[-2.,12.], see Algorithm 1.Algorithm 1
f
[
x_
]
:=Sin[x]Cot
[
x
]
+Cos
[
x
∧
2
]
+0.5;
a=-2.; b=12.;
zeros=Reap
[
soln=y
[
x
]
/.First
[
NDSolve
[
{
y
′
[x]==Evaluate[D[f[x],x]],y[b]==
(
f
[
b
]
)},y[x],{x,a,b},
Method->{"EventLocator","Event"->y[x],
"EventAction":>Sow
[
{
x,y
[
x
]
}
]
}
]
]
]
[
[
2,1
]
]
;
initialPoints=Sort
[
Flatten
[
Take
[
zeros,Length
[
zeros
]
,1
]
]
]Thus now, we have an efficient list of initial approximations for the zeros of a nonlinear once differentiable function with finitely many zeros in an interval. The number of zeros and the graph of the function including the positions of the zeros can be given by the following commands (see Figure1), see Algorithm 2.Algorithm 2
L
ength[initialPoints]
P
lot[f[x],{x,a,b},Epilog->{PointSize[Medium], Red, Point[zeros]},
PlotRange->All, PerformanceGoal->"Quality", PlotStyle->{Thick, Brown}]Figure 1
The graph of the functionf with finitely many zeros in an interval.For this test, there are 33 zeros in the considered interval which can easily be used as the starting points for our proposed high-order derivative-free methods. Note that the output of the vector “initialPoints” contains the initial approximations. In this test problem, the list of zeros are {−1.48293, 1.48293, 2.18909, 2.72517, 3.38886, 3.71339, 4.15977, 4.55782, 4.7902, 7.67254, 7.78846, 8.04476, 8.20923, 8.40603, 8.60286, 8.75671, 8.9734, 9.09881, 9.32263, 9.43461, 9.65251, 9.76525, 9.9662, 10.0901, 10.2669, 10.4082, 10.557, 10.719, 10.8379, 11.023, 11.11, 11.3224, 11.3721}. Note that we end this section by mentioning that for very oscillatory functions, it is better to first divide the interval into some smaller subintervals and then obtain the solutions. The command NDSolve uses Maximum number of 10000 steps, if it is needed this could be changed. In cases when NDSolve fails, this algorithm might fail too.


## 5. Concluding Remarks and Future Works

The importance and application of nonlinear solvers made the construction of new methods by the beginning of the new century. On the other hand, when the cost of derivative evaluation is expensive or in some cases not available, the need for higher-order methods with high efficiency index, which do not require derivative evaluations per full cycle, are more and more felt in the scientific computing.Hence, this paper has recommended two wide classes of optimal eighth-order methods without memory to solve nonlinear scalar equations numerically. The merits of the produced methods from our classes were high efficiency index, being totally free from derivative, high accuracy in numerical examples and also consistency with the conjecture of Kung and Traub. The analytical proof of the main contribution was given in Section2 and its stability and efficiency were tested in Section 4. The numerical results attested the theoretical aspects as well as the high efficiency index by as small as possible of number of evaluations to achieve the highest possible order. We have also pointed out some notes regarding multiple zeros and how to extract initial approximations for the nonlinear functions with finitely many zeros in an interval.Providing with memory iterations using the classes (2.2)-(2.3) and (2.10)-(2.11) can be of researchers’ interests for future works.



---

*Source: 318165-2012-11-01.xml*