VGAMextra (version 0.0-6)

newtonRaphson.basic: Newton--Raphson algorithm

Description

Newton--Raphson algorithm to approximate the roots of univariate real--valued functions.

This function is vectorized.

Usage

newtonRaphson.basic(f, fprime, a, b, 
                    tol = 1e-8, n.Seq = 20,
                    nmax = 15, ...)

Value

The approximate roots in the intervals

\((a_j, b_j)\). When \(j = 1\), then a single estimated root is returned, if any.

Arguments

f

A univariate function whose root(s) are approximated. This is the target function. Must return a vector.

fprime

A function. The first derivative of f. Must return a vector.

a, b

Numeric vectors. Upper and lower real limits of the open interval \((a, b)\) where the root(s) of f will be searched. Notice, entries Inf, -Inf, NA and NaN are not handled.

These vectors are subject to be recycled if a and b lenghts differ.

tol

Numeric. A number close to zero to test whether the approximate roots from iterations \(k\) and \((k + 1)\) are close enough to stop the algorithm.

n.Seq

Numeric. The number of equally spaced initial points within the interval (a, b) to internally set up initial values for the algorithm.

nmax

Maximum number of iterations. Default is \(15\).

...

Any other argument passed down to functions f and fprime.

Author

V. Miranda.

Details

This is an implementation of the well--known Newton--Raphson algorithm to find a real root, \(r\), \(a < r < b\), of the function \(f\).

Initial values, \(r_0\) say, for the algorithm are internally computed by drawing `n.Seq' equally spaced points in \((a, b)\). Then, the function f is evaluated at this sequence. Finally, \(r_0\) results from the closest image to the horizontal axis.

At iteration \(k\), the \((k + 1)^{th}\) approximation given by $$r^{(k + 1)} = r^{(k)} - {\tt{f}}(r^{(k), ...)} / {\tt{fprime}}(r^{(k)}, ...)$$ is computed, unless the approximate root from step \(k\) is the desired one.

newtonRaphson.basic approximates this root up to a relative error less than tol. That is, at each iteration, the relative error between the estimated roots from iterations \(k\) and \(k + 1\) is calculated and then compared to tol. The algorithm stops when this condition is met.

Instead of being single real values, arguments a and b can be entered as vectors of length \(n\), say \({\tt{a}} = c(a_1, a_2, \ldots, a_n)\) and \({\tt{b}} = c(b_1, b_2,\ldots, b_n)\). In such cases, this function approaches the (supposed) root(s) at each interval \((a_j, b_j)\), \(j = 1, \ldots, n\). Here, initial values are searched for each interval \((a_j, b_j)\).

See Also

bisection.basic

Examples

# Find the roots in c(-0.5, 0.8), c(0.6, 1.2) and c(1.3, 4.1) for the
# f(x) = x * (x - 1) * (x - 2). Roots: r1 = 0, and r2 = 1, r3 = 2.

f <- function(x) x * (x - 1) * (x - 2)
fprime <- function(x) 3 * x^2 - 6 * x + 2

# Three roots.
newtonRaphson.basic(f = f, fprime  = fprime, 
                    a = c(-0.5, 0.6, 1.3), 
                    b = c(0.8, 1.2, 4.1))              ## 0.0, 1.0 and 2.0
                    
# Recycling rule. Intervals analysed are (-0.5, 1.2) and (0.6, 1.2)
newtonRaphson.basic(f = f, fprime  = fprime, 
                    a = c(-0.5, 0.6), b = c(1.2)) 

## Warning: There is more than one root in (-0.5, 1.2)!