Integer type:** int32**** int64**** nag_int** show int32 show int32 show int64 show int64 show nag_int show nag_int

nag_roots_contfn_interval_rcomm (c05av) attempts to locate an interval containing a simple zero of a continuous function using a binary search. It uses reverse communication for evaluating the function.

Mark 23: fx no longer an output parameter

.You must supply an initial point x and a step h. nag_roots_contfn_interval_rcomm (c05av) attempts to locate a short interval
[x,y]
⊂
[boundl,boundu]
$[{\mathbf{x}},{\mathbf{y}}]\subset [{\mathbf{boundl}},{\mathbf{boundu}}]$ containing a simple zero of
f(x)
$f\left(x\right)$.

(On exit we may have
x > y
${\mathbf{x}}>{\mathbf{y}}$; x is determined as the first point encountered in a binary search where the sign of
f(x)
$f\left(x\right)$ differs from the sign of
f(x)
$f\left(x\right)$ at the initial input point x.) The function attempts to locate a zero of
f(x)
$f\left(x\right)$ using h,
0.1 × h
$0.1\times {\mathbf{h}}$,
0.01 × h
$0.01\times {\mathbf{h}}$ and
0.001 × h
$0.001\times {\mathbf{h}}$ in turn as its basic step before quitting with an error exit if unsuccessful.

nag_roots_contfn_interval_rcomm (c05av) returns to the calling program for each evaluation of
f(x)
$f\left(x\right)$. On each return you should set
fx = f(x)
${\mathbf{fx}}=f\left({\mathbf{x}}\right)$ and call nag_roots_contfn_interval_rcomm (c05av) again.

None.

- 1: x – double scalar
*On initial entry*: the best available approximation to the zero.- 2: fx – double scalar
- 3: h – double scalar
- 4: boundl – double scalar
- 5: boundu – double scalar
- 6: y – double scalar
*On initial entry*: need not be set.- 7: c(11$11$) – double array
*On initial entry*: need not be set.- 8: ind – int64int32nag_int scalar
*On initial entry*: must be set to 1$1$ or − 1 $-1$.

None.

None.

- 1: x – double scalar
*On intermediate exit*: contains the point at which f$f$ must be evaluated before re-entry to the function.- 2: h – double scalar
*On final exit*: is undefined.- 3: y – double scalar
*On final exit*: contains the closest point found to the final value of x, such that f(x) × f(y) ≤ 0.0 $f\left({\mathbf{x}}\right)\times f\left({\mathbf{y}}\right)\le 0.0$. If a value x is found such that f(x) = 0 $f\left({\mathbf{x}}\right)=0$, then y = x ${\mathbf{y}}={\mathbf{x}}$. On final exit with ifail = 4${\mathbf{ifail}}={\mathbf{4}}$, x and y are the end points of the largest interval searched.- 4: c(11$11$) – double array
- 5: ind – int64int32nag_int scalar
*On intermediate exit*: contains 2$2$ or 3$3$. The calling program must evaluate f$f$ at x, storing the result in fx, and re-enter nag_roots_contfn_interval_rcomm (c05av) with all other parameters unchanged.*On final exit*: contains 0$0$.- 6: ifail – int64int32nag_int scalar
- ifail = 0${\mathrm{ifail}}={\mathbf{0}}$ unless the function detects an error (see [Error Indicators and Warnings]).

Errors or warnings detected by the function:

On entry, boundu ≤ boundl ${\mathbf{boundu}}\le {\mathbf{boundl}}$, or x ∉ [boundl,boundu] ${\mathbf{x}}\notin [{\mathbf{boundl}},{\mathbf{boundu}}]$, or both x + h ${\mathbf{x}}+{\mathbf{h}}$ and x − h ∉ [boundl,boundu] ${\mathbf{x}}-{\mathbf{h}}\notin [{\mathbf{boundl}},{\mathbf{boundu}}]$.

- The parameter ind is incorrectly set on initial or intermediate entry.

- nag_roots_contfn_interval_rcomm (c05av) has been unable to determine an interval containing a simple zero starting from the initial value of x and using the step h. If you have prior knowledge that a simple zero lies in the interval [boundl,boundu] $[{\mathbf{boundl}},{\mathbf{boundu}}]$, you should vary x and h in an attempt to find it. (See also Section [Further Comments].)

nag_roots_contfn_interval_rcomm (c05av) is not intended to be used to obtain accurate approximations to the zero of
f(x)
$f\left(x\right)$ but rather to locate an interval containing a zero. This interval can then be used as input to an accurate rootfinder such as nag_roots_contfn_brent (c05ay) or nag_roots_contfn_brent_rcomm (c05az). The size of the interval determined depends somewhat unpredictably on the choice of x and h. The closer x is to the root and the **smaller** the initial value of h, then, in general, the smaller (more accurate) the interval determined; however, the accuracy of this statement depends to some extent on the behaviour of
f(x)
$f\left(x\right)$ near
x = x
$x={\mathbf{x}}$ and on the size of h.

For most problems, the time taken on each call to nag_roots_contfn_interval_rcomm (c05av) will be negligible compared with the time spent evaluating
f(x)
$f\left(x\right)$ between calls to nag_roots_contfn_interval_rcomm (c05av). However, the initial value of x and h will clearly affect the timing. The closer x is to the root, and the **larger** the initial value of h then the less time taken. (However taking a large h can affect the accuracy and reliability of the function, see below.)

You are expected to choose boundl and boundu as physically (or mathematically) realistic limits on the interval of search. For example, it may be known, from physical arguments, that no zero of
f(x)
$f\left(x\right)$ of interest will lie outside
[boundl,boundu]
$[{\mathbf{boundl}},{\mathbf{boundu}}]$. Alternatively,
f(x)
$f\left(x\right)$ may be more expensive to evaluate for some values of x than for others and such expensive evaluations can sometimes be avoided by careful choice of boundl and boundu.

The choice of boundl and boundu affects the search only in that these values provide physical limitations on the search values and that the search is terminated if it seems, from the available information about
f(x)
$f\left(x\right)$, that the zero lies outside
[boundl,boundu]
$[{\mathbf{boundl}},{\mathbf{boundu}}]$. In this case (ifail = 4${\mathbf{ifail}}={\mathbf{4}}$ on exit), only one of
f(boundl)
$f\left({\mathbf{boundl}}\right)$ and
f(boundu)
$f\left({\mathbf{boundu}}\right)$ may have been evaluated and a zero close to the other end of the interval could be missed. The actual interval searched is returned in the parameters x and y and you can call nag_roots_contfn_interval_rcomm (c05av) again to search the remainder of the original interval.

Though nag_roots_contfn_interval_rcomm (c05av) is intended primarily for determining an interval containing a zero of
f(x)
$f\left(x\right)$, it may be used to shorten a known interval. This could be useful if, for example, a large interval containing the zero is known and it is also known that the root lies close to one end of the interval; by setting x to this end of the interval and h small, a short interval will usually be determined. However, it is worth noting that once any interval containing a zero has been determined, a call to nag_roots_contfn_brent_rcomm (c05az) will usually be the most efficient way to calculate an interval of specified length containing the zero. To assist in this determination, the information in fx and in x, y and
c(1)
${\mathbf{c}}\left(1\right)$ on successful exit from nag_roots_contfn_interval_rcomm (c05av) is in the correct form for a call to function nag_roots_contfn_brent_rcomm (c05az) with
ind = − 1
${\mathbf{ind}}=-1$.

If the calculation terminates because
f(x) = 0.0
$f\left({\mathbf{x}}\right)=0.0$, then on return y is set to x. (In fact,
y = x
${\mathbf{y}}={\mathbf{x}}$ on return only in this case.) In this case, there is no guarantee that the value in x corresponds to a **simple** zero and you should check whether it does.

One way to check this is to compute the derivative of f$f$ at the point x, preferably analytically, or, if this is not possible, numerically, perhaps by using a central difference estimate. If
f^{′}(x) = 0.0
${f}^{\prime}\left({\mathbf{x}}\right)=0.0$, then x must correspond to a multiple zero of f$f$ rather than a simple zero.

Open in the MATLAB editor: nag_roots_contfn_interval_rcomm_example

function nag_roots_contfn_interval_rcomm_examplex = 3; fx = 0; h = 0.1; boundl = 0; boundu = 4; y = 0; c = zeros(11, 1); ind = int64(1); while (ind ~= int64(0)) [x, h, y, c, ind, ifail] = nag_roots_contfn_interval_rcomm(x, fx, h, boundl, boundu, y, c, ind); fx = x^2 -3*x + 2; end [x,y] [fx,c(1)]

ans = 1.7000 2.5000 ans = -0.2100 0.7500

Open in the MATLAB editor: c05av_example

function c05av_examplex = 3; fx = 0; h = 0.1; boundl = 0; boundu = 4; y = 0; c = zeros(11, 1); ind = int64(1); while (ind ~= int64(0)) [x, h, y, c, ind, ifail] = c05av(x, fx, h, boundl, boundu, y, c, ind); fx = x^2 -3*x + 2; end [x,y] [fx,c(1)]

ans = 1.7000 2.5000 ans = -0.2100 0.7500

© The Numerical Algorithms Group Ltd, Oxford, UK. 2009–2013