A new family of adaptive methods with memory for solving nonlinear equations

In this work, an adaptive method with memory is developed such that all previous information are applied. The importance of the proposed method can be seen because of the optimization in important effecting factors, i.e., least number of iterations steps, least number of functional evaluations, least value of absolute error, and maximum efficiency index in final as well as in individual step as compared with the other methods. Indeed, it is proved that this adaptive method with memory has efficiency index 2 and competes all the existing methods without and with memory in the literature. The order of convergence is obtained by using two self-accelerating parameters, which is increased from 2 to 4 without any new function evaluation. It means that, the order of convergence can be improved until 100%. Numerical examples and the comparison with existing methods are included to demonstrate exceptional convergence speed of the proposed method and confirm theoretical results.


Introduction and preliminaries
Many of the complex problems in science and engineering contain the function of nonlinear and transcendental nature in the equation of the form f (x) = 0. Numerical iterative schemes like Newton's method [42] are often used to obtain the approximate solution of such problems because it is not always possible to obtain its exact solution by usual algebraic process. However, the condition f � (x) ≠ 0 in a neighborhood of the required root is severe indeed for convergence of Newton's method, which restricts its applications in practice. To overcome on this difficulty, Steffensen replaced the first derivative of the function in the Newton's iterate by forward finite difference approximation [58]. Traub in his book classified iterative methods for solving such equations as one point or multipoints [61]. We classify the iterative formulas by information they need as follows [61]: 1. One-point iterative method without memory In this type of methods, x k+1 can be determined by only new data at x k . No previous information is reused.
The most commonly known example is Newton's I.F. (iterative formula) [42]: and free derivative Steffensen's [58] : 2. One-point iterative method with memory In this category x k+1 can be determined by new information at x k and reused information at x k−1 , … , x k−n . Thus, x k+1 = (x k ;x k−1 , … , x k−n ). Then will be called a one- point I.F. with memory. The best-known examples of a one-point I.F. with memory are the secant I.F. [47] and Traub's method [61] 3.
Efficiency Index (EI) We recall the so-called efficiency index defined by Ostrowski [43], as EI = p 1∕n , where p is the order of convergence and n is the total number function evaluations per iteration. Lotfi [33] and Soleymani [62] have checked iterative methods with high efficiency index.
Note 1 We use the symbols →, O, and ∼ according to the following conventions [61]. If lim x n →∞ g(x n ) = C, we write Traub investigated that it is possible to increase the order of convergence of without memory methods by reusing the obtained information of the previous iteration. If one can increase the order of convergence in a without memory method by reusing the old information, then he/she can develop it with a memory method. To our surprise, there is not any method with memory that reuses the information from the all previous information. This motivated us to focus on this problem. Therefore, in this work, we will develop an adaptive memory method that uses the information not only from the last two steps, but also from all the previous iterations. This technique enables us to achieve the highest efficiency both theoretically and practically. Indeed, we will prove that this adaptive memory method has efficiency index 2 and hence competes all the existing methods without and with memory in the literature. Also, we later compare both numerical performances and efficiency index of our proposed method with some significant methods to show our claims. We approximate and update the introduced accelerator parameters in each iteration by suitable kind and optimal of Newton's interpolation. We conclude that even with this one-step method, we need not to pay attention to higher kinds of steps in multipoint methods since this adaptive with memory method can achieve the efficiency index near 2 after three iterations, so from the theoretical and numerical aspects, it is enough to consider and utilize it practically. This paper is organized as follows: In "A family of two-parameter iterative methods" section deals with modifying the optimal one-point method without memory introduced by family Khaksar [28], constructed by introducing two iterative parameters which are calculated with helped of Newton's interpolatory polynomial of different degrees. In "Recursive adaptive method with memory" section, the aim of this work is presented by contributing an iterative method adaptive with memory for solving nonlinear equations, improved order of convergence from 3.56 to 4 without adding more evaluations is presented, and achieve in maximum performance index. It means that, without any new function calculations, we can improve convergence order by 100%. The comparisons of absolute errors and computational efficiencies are given in "Numerical examples" section to illustrate convergence behavior. In "Conclusion" section, we give the concluding remarks.

A family of two-parameter iterative methods
In this section, we deal with modifying one-point without memory methods by Khaksar [28]. So that their error equation has two accelerator elements. Khaksar's method has the iterative expression: Denoted by KM, where ∈ ℜ − {0}, its error equation is given by To transform Eq. (8) in a method with memory, with two accelerators, we consider the following modification of (8) [28]: where and are nonzero arbitrary parameters. In what follows, we present the error of Eq. (10).

Remark 1
It is worth noting that to the best of our knowledge although there are many methods with memory, however, developing adaptive methods with memory has not been considered in the literature.
The next theorem states of the error equation of Eq. (10).
Theorem 1 Let I ⊆ be an open interval, f ∶ I → be a scalar function which has a simple root in the open interval I, and also the initial approximation x 0 is sufficiently close the simple zero, and then, the one-step iteration method (10) has two orders, which satisfies the following error equation: Proof Let be a simple zero of equation f (x) = 0 and x k = + e k . By Taylor expansion, we have : Expanding f (w k ) about , we get : x−y is a divided difference, then the expression f [x k , w k ] can be written in terms of e k as: . .

Remark 2
The family of one-point methods mentioned in Eq. (10) requires two function evaluations and has order of convergence two. Therefore, this family is optimal in the sense of the Kung-Traub conjecture and possesses the computational efficiency EI = 2 1∕2 ≈ 1.4142. (17) .
the best approximations. Hence, the following approximates are applied are Newton's interpolating polynomials of two and third degrees, set through three and four best available approximations (nodes) (x k , x k−1 , w k−1 ) and (w k , x k , x k−1 , w k−1 ), respectively. It should be noted that if one uses lower Newton's interpolation, lower accelerators are obtained. Replacing the fixed parameters and in the iterative formula (10) by the varying k and k calculated by (20), we propose the following new methods with memory, x 0 , 0 , 0 are given then

Recursive adaptive method with memory
This section concerns with extracting the novel with memory method from (10) by using two self-accelerating parameters. Theorem (1) states that modified method (10) has order of convergence 2 if ≠ 1 f � ( ) and ≠ c 2 . Now, we pose a main question: Is it possible to increase the order of convergence ? If so, how can it be done and what is the new convergence order? For answering these questions, we note the error equation (11). It can be seen that if we set = 1 2f � ( ) , then at least the coefficient of e 2 k disappears. However, we do not know and consequently, f � ( ) and f �� ( ) cannot be computed. On the other hand, we can approximate using available data and therefore improve order of convergence. Following the same idea in the methods with memory, this issue can be resaved. However, we are going to do it in a more efficient way, say recursive adaptively. Let us describe it a little more. If we use information from the current and only the last iteration, we come up with the method introduced in [34,36]. Also, we have considered are Newton's interpolating polynomials of 2k and 2k + 1 degrees, set through 2k + 1 and 2k + 2 best available approxima- Here, we concern the second question regarding order of convergence of the method with memory (10). In what follows, we discuss the general convergence analysis of the recursive adaptive method with memory (10). It should be noted that the convergence order varies as the iteration go ahead. First, we need the following lemma: The proof is similar to Lemma 1 mentioned in [64].
The following result determines the order of convergence through the one-point iterative method with memory (21). □

Theorem 2 If an initial estimation
equating the powers of e k+1 on the right-hand sides of Eqs.

Remark 3
It should be kept in mind that the system of equations (23) includes the previous iterations for k = 0, 1, 2, … . In this case, we have the regular methods with memory in which the information from the current and the previous steps are used.

Remark 4
For k = 1 , we use the information from the current and the one previous step. In this case, the order of convergence of the method with memory can be computed from the following of system of equations This system of equations has t he solution This special case gives the given result by khaksar haghani [28]. This is a new kind of adaptive approach with memory method .
Remark 7 Also, if k = 4, we conclude by the system of equations (29): (shown by TLAM) Solving these equations, we get : p ≃ 1.99705 and r ≃ 3.9941.

Remark 8
As can be easily seen that the improvement in the order of convergence from 2 to 4 (100% of an improvement) is attained without any additional functional evaluations, which points to very high computational efficiency of the proposed method. Therefore, the efficiency index of the proposed method (23)

Numerical examples
In this section, the proposed derivative-free adaptive methods are applied to solve smooth as well as nonsmooth nonlinear equations and compared with the existing without memory and with memory methods. The iterative methods without memory and with memory are listed in Tables 1 and 2, respectively. Table 3 lists the exact roots and initial approximations x 0 , which are computed using the Find-Root command of Mathematica [23]. Table 4 compares evaluation function and efficiency index of the proposed method by with and without memory schemes. Table 5 compares improvement percent with memory and homogeneous without memory. Constructed iteration adaptive method, with the given function f having a simple zero is mentioned in Table 6. Tables 7, 8 and 9 compare our proposed method forty one with and without memory. In recent years, since in practice high-precision computations are applied, the higher-efficiency index schemes have become (34) important. Due to this reason all the computations reported have been performed in the programming package Mathematica 10 using 2000 digits floating-point arithmetic using "SetAccuraccy"command. The errors |x k − | of approximations to the sought zeros, produced by the different methods at the first three iterations, are given in Table 6 where m(−n) stands for m × 10 −n . These tables also include, for each test function, the initial estimation values and the last value of the computational order of convergence COC [44] computed by the expression (if it is stable) where p is the order of convergence. At least 40 iterative methods with and without memory, for comparing with our      Figure 13 compares of methods without memory, with memory (25%, 50% and 75% of improvements) and recursive adaptive (100% of improvements) in terms of highest possible efficiency index. Complex test function f 10 used to show that the proposed method is applicable to the complex domain too. In these tables symbols In, div have demonstrator infinity and divergence, respectively. It can be observed our proposed method has minimum evaluation function and maximum efficiency index. Tables 4  and 5 show that the method (23) competes the previous methods. In additional its efficiency index is better than all the previous works. In other words, it has efficiency index 4 1∕2 = 2. The same results can be observed in the second and third columns of Table 5 and at least has evaluation function inter iterative methods existent methods with-and without memory. Some of iterative methods in the some examples are divergent. We also incorporated and applied the developed adaptive method with memory (34) for different test examples and obtained results with the same behavior as above. We can see that the self-accelerating parameters and the consequently adapting method play a key role in increasing the order of convergence of the iterative method.
Algorithms to find an initial approximation 1 An important aspect in implementing the iterative methods for the solution of nonlinear equations and systems relies on the choice of the initial approximation. There are a few known ways in the literature [24] to extract a starting point for the solutions of nonlinear functions. In practice, users need to find out robust approximations for all the zeros in an interval. Thus, to remedy this and to respond on this need, we provide a way to extract all the real zeros of nonlinear function in the interval D = [a, b]. We use the command Reduce in Mathematica 10 [23]. Hence, we give a hybrid algorithm including two main steps, a predictor and a corrector. In the predictor step, we extract initial approximations for all the zeros in an interval up to 8 decimal places. Then the corrector step will be used to boost up the accuracy of the starting points up to any tolerance. We also give some significant cautions for applying on different test   Let us define the function and the domain for imposing the Reduce[ ] command as in Algorithm 1.
One may note that Reduce[ ] works with function of exact arithmetic. Hence, if a nonlinear function is the floatingpoint arithmetic, that is, has inexact coefficients, thus we should write it in the exact arithmetic when we enter it into the above piece of code. Now we store the list of initial approximations in initialValues, by the following piece of code, which also sort the initial points. The tol will specify that the accuracy of each member of the provided sequence to be correct up to utmost tol, decimal places (Algorithm 2).
It is obvious that f is so oscillatory, and by the above predictor piece of Mathematica code, we attain that it has 59 real solutions. Note that the graph of the function f has been drawn in Fig. 14.
Note that if a user needs much more accuracy, thus higher number of steps should be taken. It should be remarked that in order to work with such a high accuracy, we must then choose more than 2000 decimal places arithmetic in our calculations.
However, running the above algorithm could capture all the real zeros of the nonlinear functions. One is that for many oscillatory function or for nonsmooth functions, the best way is to first divide the whole interval into some subintervals and then find all the zeros of the function on the subintervals. And second, in case of having a root cluster, that is, when the zeros are concentrated on a very small area, then it would be better to increase the first tolerance of our algorithm in the predictor step, to find reliable starting points and then start the process.
And last, if the nonlinear function has an exact solution, that is to say, an integer be the solution of a nonlinear function, then the first step of our algorithm finds this exact solution, and an error-like message would be generated by applying our second step. For instance, the function g(x) = (x 2 − 4) sin(100x) on the interval D = [0, 10] has 319 real solutions in which one of them (its plot is given in Fig. 15), that is. 2, is an exact one. Thus, the first step of the mentioned Algorithm 1 finds the following very efficient list of starting points in which 2, is the exact solution: {0     2 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 "Introduction and preliminaries" section, the convergence of our iterative methods is local. 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, [3]. But herein we take into consideration the programming package Mathematica 10 [23] which could be efficiently applied on lists for high-precision computing. In fact using [24], we could build a list of initial guesses close enough with good accuracy to start the procedure of our optimal derivative-free fourth-order methods. The procedure of finding such a robust list is based on the powerful command of NDSolve for the nonlinear function f (x) = 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 Fig. 14); see Algorithm 4. For this test, there are 59 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. 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 10,000 steps, if it is needed this could be changed. In cases when NDSolve fails, this algorithm might fail too. The output of Algorithm 4 is as follows: {1.1103225, 2.5611445, 2.9496729, 3 . 4 5 3 7 6 9 7 , 3 . 9 9 9 3 4 5 3 , 4 .  3 Although the choice of good initial approximations is of great importance in the application of iterative methods, including multipoint methods, this task is very seldom considered in the literature. Recall that Steffensen-like methods of the second order have been most frequently used as predictors in the first step of multipoint methods. These methods are of tangent type, and therefore, they are locally convergent, which means that a reasonably close initial approximation to the sought zero should be found. Otherwise, if the chosen initial approximation is too far from the sought zero (say, if it is chosen randomly), then the applied methods, either the ones proposed in this paper or some others with local convergence developed during the last two centuries, will probably find some other (often unwanted) zero or they will diverge. Therefore, the determination of a reasonably good approximation x 0 that guarantees the convergence of the sequence of approximations {x k } k∈N to the zero of f is a significant task. It is interesting to note that initial approximations, chosen randomly in a suitable way, give acceptable results when simultaneous methods for finding all roots of polynomial equations are applied, e.g., employing Aberth's approach [2].
There are many methods (mainly of non-iterative nature) and strategies for finding sufficiently good initial approximations. The well-known bisection method and its modifications belong to the simplest but not always sufficiently efficient techniques. There is a vast literature on this subject so that we omit details here. We only note that complete rootfinding algorithms often consist of two parts: (1) slowly convergent search algorithm to isolate distinct real or complex Fig. 16 The graph of the function h with finitely many zeros in an interval Fig. 17 The graph of the function f 20 (x) = sin(5x)e x , f 21 (x) = 2 with finitely many zeros in an interval Table 1 Considered methods without memory One-step Two-step Three-step Four-step   Table 4 Numerical results for the test functions f i (x), i = 1, 2, 3, … , 20 the proposed method (34) Function interval containing single root and (2) rapidly convergent iterative method for finding sufficiently close approximation of the isolated root to the required accuracy. In this paper we are concentrating on the part (2). Applying computer algebra systems, a typical statement for solving nonlinear equations reads FindRoot[equation, {x, x 0 }] ; see, e.g., Wolfram's computational software package Mathematica, that is, an initial approximation x 0 is required. In finding good initial approximations, a great advance was recently achieved by developing an efficient non-iterative method of significant practical importance, originally proposed by Yun [65]. Yun's method is based on numerical integration briefly referred to as NIM, where tanh, arctan and signum functions are involved. The NIM requires neither any knowledge of the derivative f(x) nor any iterative process. Handling non-pathological cases it is not necessary to have a close approximation to the zero; instead, a real interval (not necessarily tight) that contains the root (so-called inclusion interval) is sufficient. For illustration, to find an initial approximation x 0 of the zeros = −1.4044916, 1.4044916 of the function h(x) = sin(x) 2 − x 2 + 1 isolated in the interval [−5, 5], we employed Yun's algorithm with the statement taking m = 250, a = −1, b = 2, and found very good approximation x 0 = 1.40449. The graph of function h is plotted in Fig. 16.  show that proposed method is very useful to find an acceptable approximation of the exact solution of nonlinear equations, specially when the function is non-differentiable. In fact, we have contributed further to the development of the theory of iteration processes and propose a new accurate and efficient higher-order derivative-free method for solving nonlinear equations numerically. In other words, the efficiency index of the proposed family with memory is EI = 4 1∕2 = 2, which is much better than optimal one until six-point optimal methods without memory having efficiency indexes EI = 2 1∕2 ≃ 1.414, EI = 4 1∕3 ≃ 1.587, EI = 8 1∕4 ≃ 1.681,   Using the command FindRoot and assigning the function to the two functions, then draw both functions in a concatenated graph.
The command WorkingPrecision specifies the accuracy of the operation. For example, if we want to find the root of equation f 2 (x) = sin(5x)e x − 2, we rewrite it like this f 20 (x) = sin(5x)e x , f 21 (x) = 2. Then, first, by plotting the function in interval [−2, 2] and then using the code given below, in the package Mathematica, the approximate value of the root can be determined.
Below is the program output and its graph in Fig. 17.