The Museum of HP Calculators

HP Forum Archive 15

 New root-seeking algorithmMessage #1 Posted by Namir on 25 Nov 2005, 11:21 p.m. I presented this new root-seeking algorithm (I call it the Quartile algorithm) at the HHC2005 conference It isa root-bracketing method that improves on the Bsection method: ```Given: Root bracketing guesses A and B Tolerance Tolr P-Code: Let alpha = 0.25 Let FA = F(A) Let FB= F(B) Do If ABS(FA) < ABS(B) Then Xm = A + alpha * (B - A) Else Xm = A + (1 - alpha)*(B - A) End Let Fm = F(Xm) If Fm * FA > 0 Then A = Xm FA = Fm Else B = Xm FB = Fm End Loop Until Abs(A - B) < Tolr Root = (A + B) / 2 ``` J. P. Moreau has implemeted the Quartile algorithm in BASIC, C++, and other languages. The BASIC code is found here

 Re: New root-seeking algorithmMessage #2 Posted by Marcus von Cube, Germany on 26 Nov 2005, 5:05 a.m.,in response to message #1 by Namir Namir, Quote:```Do If ABS(FA) < ABS(B) Then ``` I assume you mean: ```Do If ABS(FA) < ABS(FB) Then ``` Can you elaboreate a little about the heuristics behind the algorithm? Marcus

 Re: New root-seeking algorithmMessage #3 Posted by Namir on 26 Nov 2005, 7:22 a.m.,in response to message #2 by Marcus von Cube, Germany You are correct. Here is the correced p-code: P-Code: ```P-Code: Let alpha = 0.25 Let FA= F(A) Let FB= F(B) Do If ABS(FA) < ABS(FB) Then Xm = A + alpha * (B - A) Else Xm = A + (1 - alpha)*(B - A) End Let Fm = F(Xm) If Fm * FA > 0 Then A = Xm FA = Fm Else B = Xm FB = Fm End Loop Until Abs(A - B) < Tolr Root = (A + B) / 2 ```

 Re: New root-seeking algorithmMessage #4 Posted by Namir on 26 Nov 2005, 2:08 p.m.,in response to message #3 by Namir The most common two root-braketing methods are: 1. The Bisection method.This method compares the sign of function values. 2. he Reguli alse method uses the function values are weights to determine the new guess. The Quartile method compares the absolute funcion values to determine the next guess. Thus, its approach lies somewhere in between the above two methods. If you look at the p-code an change alpha to 0.5, you get the Bisection method. Thus, the Bisection method is a special case of the Quartile method, where the new guess is systematically taken as the middle of the root-bracketing interval. Edited: 26 Nov 2005, 2:09 p.m.

 Re: New root-seeking algorithmMessage #5 Posted by Patrick on 3 Dec 2005, 10:59 p.m.,in response to message #4 by Namir Sorry, Namir, I don't mean to be impolite, but so what? It is relatively simple to develop umpteen variations on a theme, the question is whether or not one of these variations is actually better in some way. Are there any analyses which motivates the choice of alpha = 0.25? In what categories of problems does this algorithm work better than others? How much better? Does it converge more frequently than others? Is it faster?

 Re: New root-seeking algorithmMessage #6 Posted by Namir on 10 Dec 2005, 9:24 a.m.,in response to message #5 by Patrick The Bisection method is a reliable method despite it's slowness. Often, complex root-seeking implementation use a combination of Newton (or similar/better methods) with he Bisection as a backup plan in case Newtons method yield guesses that stray away. The Quartile method is a root-bracketing method that is better than the Bisection. The value for alpha can be in the range of 0.25 and 0.3. Th Quartile algorithm uses a slightly different approach--compares the absolute values of the functions at interval [A. B]. The Quartile methd is not a variant of Bisection. Te Bisection is a special case of the Quartile method (setting alpha to 0.5). The method of False-Position is the next higherup root-bracketing method that uses the function values as weights. This algorithm does not systematically shrink the interval containing the root. To stop iterating, you compare the current new guess with the last new guess. If you are going to resort to the Bisection method as the main or backup method, then you can replace it with the Quartile method to have fewer iterations. The reduction in iterations depends on the function and the initial root-bracketing interval. Newtons method is popular in root solving. It uses calls to teh functio and it's first derivative. The Haily method is generally better than Newton's. It calls the function and its first two derivatives. The Householder method is even faster, but calls n he fucntion and it's first three derivatives! By using function calls to approximate the derivatives, I found that Haily's method is in general the optimum method (considering iterations and function calls). Parick, I welcome your suggstions for root-seeking algorithms (both variants of other methods or original algorithms). I think the subject is fascinating and I am interested in all sugegstions. Namir Edited: 10 Dec 2005, 9:28 a.m.

 Re: New root-seeking algorithmMessage #7 Posted by ECL on 10 Dec 2005, 10:26 p.m.,in response to message #6 by Namir Namir, I too am interested in root methods. I am not familiar w/ Householder method. I am dealing with simple methods (modified false position, newton-raphson..). I prefer non-symbolic derivative evaluation due to using primarily the 33s. Although this can be overcome with use of divided difference approach.

 Re: New root-seeking algorithmMessage #8 Posted by Namir on 10 Dec 2005, 10:39 p.m.,in response to message #7 by ECL ```Th Householder method is relatively new. Like Newton's and Haily's methods it is based on te Tayler's expansion. The Householder methods includes up to the third derivative. Atributes of method: + Very fast convergence rate + Requires first, second, and third function derivatives! + Using derivative approximation methods results in five function calls per iteration + Compared to other methods, this method has fewer iterations but a high number of function calls + Basic Householder iteration uses: X = X - f(X){[f’(X)^2 - f(X) f’’(X) / 2]/[f’(X)^3 - f(X) f’(X) f’’(X) - f'''(X) f(X)^2 / 6]} where f(x) is target function (f(x) = 0) f'(x) is the first derivative f''(x) is the second derivative f'''(x) is the third derivative Pseudo-code: Obtain initial guess x and Tolerance Obtain or set value to MaxIterations Clear Diverge flag Set IterCount = 0 Loop Increment IterCount If IterCount > MaxIterations Then Set Diverge flag and exit loop h = 0.01 * [1 + |x|] f0 = f(x) fp1 = f(x+h) fp2 = f(x+2h) fm1 = f(x-h) fm2 = f(x-2h) D1 = (fp - fm) / (2h) D2 = (fp - 2f0 + fm) / (h*h) D3 = (fp2 - 2 * fp1 + 2 * fm1 - fm2) / 2 / h ^ 3 diff = f0 * ((f0^2 - f0 * D1 / 2)/(f0^3 - f0 * D1 * D2 - D3 * f0^2 / 6]} x = x - diff Until |diff| < Tolerance Return root as x and Diverge flag ``` Edited: 11 Dec 2005, 8:38 a.m.

Go back to the main exhibit hall