The `H V R` [`nest`

] command applies a function to a given
argument repeatedly. It takes two values, ‘`a`’ and ‘`n`’, from
the stack, where ‘`n`’ must be an integer. It then applies the
function nested ‘`n`’ times; if the function is ‘`f`’ and ‘`n`’
is 3, the result is ‘`f(f(f(a)))`’. The number ‘`n`’ may be
negative if Calc knows an inverse for the function ‘`f`’; for
example, ‘`nest(sin, a, -2)`’ returns ‘`arcsin(arcsin(a))`’.

The `H V U` [`anest`

] command is an accumulating version of
`nest`

: It returns a vector of ‘`n+1`’ values, e.g.,
‘`[a, f(a), f(f(a)), f(f(f(a)))]`’. If ‘`n`’ is negative and
‘`F`’ is the inverse of ‘`f`’, then the result is of the
form ‘`[a, F(a), F(F(a)), F(F(F(a)))]`’.

The `H I V R` [`fixp`

] command is like `H V R`, except
that it takes only an ‘`a`’ value from the stack; the function is
applied until it reaches a “fixed point,” i.e., until the result
no longer changes.

The `H I V U` [`afixp`

] command is an accumulating `fixp`

.
The first element of the return vector will be the initial value ‘`a`’;
the last element will be the final result that would have been returned
by `fixp`

.

For example, 0.739085 is a fixed point of the cosine function (in radians):
‘`cos(0.739085) = 0.739085`’. You can find this value by putting, say,
1.0 on the stack and typing `H I V U C`. (We use the accumulating
version so we can see the intermediate results: ‘`[1, 0.540302, 0.857553,
0.65329, ...]`’. With a precision of six, this command will take 36 steps
to converge to 0.739085.)

Newton’s method for finding roots is a classic example of iteration
to a fixed point. To find the square root of five starting with an
initial guess, Newton’s method would look for a fixed point of the
function ‘`(x + 5/x) / 2`’. Putting a guess of 1 on the stack
and typing `H I V R ' ($ + 5/$)/2 RET` quickly yields the result
2.23607. This is equivalent to using the

`calc-find-root`

)
command to find a root of the equation ‘These examples used numbers for ‘`a`’ values. Calc keeps applying
the function until two successive results are equal to within the
current precision. For complex numbers, both the real parts and the
imaginary parts must be equal to within the current precision. If
‘`a`’ is a formula (say, a variable name), then the function is
applied until two successive results are exactly the same formula.
It is up to you to ensure that the function will eventually converge;
if it doesn’t, you may have to press `C-g` to stop the Calculator.

The algebraic `fixp`

function takes two optional arguments, ‘`n`’
and ‘`tol`’. The first is the maximum number of steps to be allowed,
and must be either an integer or the symbol ‘`inf`’ (infinity, the
default). The second is a convergence tolerance. If a tolerance is
specified, all results during the calculation must be numbers, not
formulas, and the iteration stops when the magnitude of the difference
between two successive results is less than or equal to the tolerance.
(This implies that a tolerance of zero iterates until the results are
exactly equal.)

Putting it all together, ‘`fixp(<(# + A/#)/2>, B, 20, 1e-10)`’
computes the square root of ‘`A`’ given the initial guess ‘`B`’,
stopping when the result is correct within the specified tolerance, or
when 20 steps have been taken, whichever is sooner.