Next: Introduction to numerical solution of differential equations, Previous: Functions and Variables for FFTPACK5, Up: Numerical [Contents][Index]
Returns a rearranged representation of expr as in Horner’s rule, using
x as the main variable if it is specified.  x may be omitted in
which case the main variable of the canonical rational expression form of
expr is used.
horner sometimes improves stability if expr is
to be numerically evaluated.  It is also useful if Maxima is used to
generate programs to be run in Fortran.  See also stringout.
(%i1) expr: 1e-155*x^2 - 5.5*x + 5.2e155;
                           2
(%o1)             1.e-155 x  - 5.5 x + 5.2e+155
(%i2) expr2: horner (%, x), keepfloat: true;
(%o2)         1.0 ((1.e-155 x - 5.5) x + 5.2e+155)
(%i3) ev (expr, x=1e155);
Maxima encountered a Lisp error:
 arithmetic error FLOATING-POINT-OVERFLOW signalled
Automatically continuing.
To enable the Lisp debugger set *debugger-hook* to nil.
(%i4) ev (expr2, x=1e155);
(%o4)                 7.00000000000001e+154
Finds a root of the expression expr or the function f over the
closed interval [a, b].  The expression expr may be an
equation, in which case find_root seeks a root of
lhs(expr) - rhs(expr).
Given that Maxima can evaluate expr or f over
[a, b] and that expr or f is continuous,
find_root is guaranteed to find the root,
or one of the roots if there is more than one.
find_root initially applies binary search.
If the function in question appears to be smooth enough,
find_root applies linear interpolation instead.
bf_find_root is a bigfloat version of find_root.  The
function is computed using bigfloat arithmetic and a bigfloat result
is returned.  Otherwise, bf_find_root is identical to
find_root, and the following description is equally applicable
to bf_find_root.
The accuracy of find_root is governed by abserr and
relerr, which are optional keyword arguments to
find_root.  These keyword arguments take the form
key=val.  The keyword arguments are
abserrDesired absolute error of function value at root.  Default is
find_root_abs.
relerrDesired relative error of root.  Default is find_root_rel.
find_root stops when the function in question evaluates to
something less than or equal to abserr, or if successive
approximants x_0, x_1 differ by no more than relerr
* max(abs(x_0), abs(x_1)).  The default values of
find_root_abs and find_root_rel are both zero.
find_root expects the function in question to have a different sign at
the endpoints of the search interval.
When the function evaluates to a number at both endpoints
and these numbers have the same sign,
the behavior of find_root is governed by find_root_error.
When find_root_error is true,
find_root prints an error message.
Otherwise find_root returns the value of find_root_error.
The default value of find_root_error is true.
If f evaluates to something other than a number at any step in the search
algorithm, find_root returns a partially-evaluated find_root
expression.
The order of a and b is ignored; the region in which a root is sought is [min(a, b), max(a, b)].
Examples:
(%i1) f(x) := sin(x) - x/2;
                                        x
(%o1)                  f(x) := sin(x) - -
                                        2
(%i2) find_root (sin(x) - x/2, x, 0.1, %pi);
(%o2)                   1.895494267033981
(%i3) find_root (sin(x) = x/2, x, 0.1, %pi);
(%o3)                   1.895494267033981
(%i4) find_root (f(x), x, 0.1, %pi);
(%o4)                   1.895494267033981
(%i5) find_root (f, 0.1, %pi);
(%o5)                   1.895494267033981
(%i6) find_root (exp(x) = y, x, 0, 100);
                            x
(%o6)           find_root(%e  = y, x, 0.0, 100.0)
(%i7) find_root (exp(x) = y, x, 0, 100), y = 10;
(%o7)                   2.302585092994046
(%i8) log (10.0);
(%o8)                   2.302585092994046
(%i9) fpprec:32;
(%o9)                           32
(%i10) bf_find_root (exp(x) = y, x, 0, 100), y = 10;
(%o10)                  2.3025850929940456840179914546844b0
(%i11) log(10b0);
(%o11)                  2.3025850929940456840179914546844b0
Returns an approximate solution of expr = 0 by Newton’s method,
considering expr to be a function of one variable, x.
The search begins with x = x_0
and proceeds until abs(expr) < eps
(with expr evaluated at the current value of x).
newton allows undefined variables to appear in expr,
so long as the termination test abs(expr) < eps evaluates
to true or false.
Thus it is not necessary that expr evaluate to a number.
load("newton1") loads this function.
See also realroots, allroots, find_root and
mnewton.
Examples:
(%i1) load ("newton1");
(%o1)  /maxima/share/numeric/newton1.mac
(%i2) newton (cos (u), u, 1, 1/100);
(%o2)                   1.570675277161251
(%i3) ev (cos (u), u = %);
(%o3)                 1.2104963335033529e-4
(%i4) assume (a > 0);
(%o4)                        [a > 0]
(%i5) newton (x^2 - a^2, x, a/2, a^2/100);
(%o5)                  1.00030487804878 a
(%i6) ev (x^2 - a^2, x = %);
                                           2
(%o6)                6.098490481853958e-4 a