Typically, however, all you really want is a few decimal places of the answer. For this purpose it is better to do the calculation in floating point. A numerical expression involving a number with a decimal point is evaluated in floating point (but see Forcing floating-point arithmetic ). Thus you could use

> (1+1./4321)^4321;

This is calculated very quickly, and the answer is in a much more convenient form.

The main disadvantage of floating point arithmetic is roundoff error. The calculation above is one in which the roundoff error is rather severe, due to the fact that we are adding a relatively small number ( 1./4321=.0002314279102 ) to a relatively large one ( 1 ), and losing significant digits in the process. This can be remedied by doing the calculation with a larger setting of the environment variable Digits , which controls the number of decimal digits used in the calculation.

> Digits:= 15:
r:= (1+1./4321)^4321:
Digits:= 10:
evalf(r);

There are some cases, however, in which even a very accurate floating-point approximation is no good, and exact arithmetic is necessary. Suppose, for example, we want to calculate where is some function and some number with as . Maple may be able to calculate it correctly if is given as an exact expression. But if instead you give Maple an inexact floating-point approximation of the correct , it will tell you that . This is in a sense perfectly correct (because approaches some finite number as ), but it is not what you wanted.

> f:= x -> 1/sin(x):
limit(f(x)*(x-Pi), x = Pi);

> b:= evalf(Pi,20);

> limit(f(x)*(x-b), x = b);

Similarly, suppose A is a matrix with eigenvalue a , and you want to find the corresponding eigenvectors. You can use kernel(A-a) if a is exact, but this will not work if it is only a floating-point approximation.

> with(linalg):

Warning, new definition for norm

Warning, new definition for trace

> A:= matrix([[1,2,3],[3,1,4],[1,5,9]]);

> evalf(Eigenvals(A));

> kernel(A-.818268536);

In this case you can express the exact eigenvalue as a root of the characteristic polynomial, using RootOf (with a third argument that identifies which root is meant):

> kernel(A-RootOf(charpoly(A,t),t,.818268536));

> evalf(");

However, a better method for large matrices might be to use the optional second argument to Eigenvals to obtain all the eigenvectors, and extract the one you want.

> evalf(Eigenvals(A,'vects'));

> col(vects,1);

See also: Automatic simplification and evalf , Digits , Eigenvals , evalf , Forcing floating-point arithmetic , RootOf , Roundoff error , The meaning of Digits