The most basic numeric type in Maple is the integer. Small integers are represented directly as hardware integers (similar to the int type in C or integer type in Fortran), which allows for maximum efficiency of both CPU time used for arithmetic and memory used for storage. That is, the number can be stored in one machine word and arithmetic operations can be performed with one CPU operation. On 32-bit architectures, integers in the range $-2^{30}-1$ to $2^{30}-1$ are stored in this way, while on 64-bit architectures, integers in the range $-2^{62}-1$ to $2^{62}-1$. Integers stored in this way are referred to as immediate integers.

Larger integers are stored in DAGs of type INTPOS or INTNEG, which contain pointers to arrays of digits that can store integers up to magnitude ${\mathrm{10}}^{2^{28}-218}$ on 32-bit architectures and ${\mathrm{10}}^{2^{35}\+2^{32}-18}$ on 64-bit architectures.

The arithmetic for these large integers is computed using the GNU Multiple Precision Arithmetic (GMP) library. This library is quite efficient, but still several orders of magnitude slower than arithmetic on immediate integers since each arithmetic operation will require more than one CPU operation and the larger the integer, the more operations and memory will be needed for arithmetic.

Any transitions between GMP integers and immediate integers will be completely transparent and it is not possible to tell them apart in general without use low-level tools such as addressof. However, you can check if an integer is small enough to fit into a single machine word with types integer[4] and integer[8] for 4-byte and 8-byte words respectively.

Integers of all types pass a type,integer type check.

The Integer constructor is guaranteed to return an integer, an extended numeric symbol such as infinity or undefined, a complex number with integer parts, or return unevaluated.

The system dependent value for the largest immediate integer can be found with kernelopts(maximmediate), the maximum number of decimal digits in an integer can be found with kernelopts(maxdigits), and the version of the GMP library being used can be found with kernelopts(gmpversion).

Exact rational numbers are stored in DAGs of type RATIONAL, which consist of a pair of integers.  The first integer is the numerator and can be a POSINT or NEGINT.  The second integer is the denominator and is a POSINT. Most low-level programming languages such as C or Fortran do not have an equivalent rational number type.

Rational numbers can be constructed by using the division operator or the Fraction constructor.  In either case, automatic simplification will occur to ensure that the denominator is positive and that the fraction is in lowest terms (the numerator and denominator do not have factors in common). This means that the Fraction constructor may return integers in some cases.

Rational number arithmetic is performed in the natural way using integer arithmetic and the igcd and ilcm operations to reduce to lowest terms.

Rational numbers of all types will pass a type,rational type check. Only rational numbers that are not also integers will pass a type,fraction type check.  Additionally, type,extended_rational includes all rationals as well as the extended numeric symbols infinity, -infinity, and undefined.

Like the Integer constructor, the Fraction constructor will return unevaluated if it cannot return a value of type extended_rational.

Floating-point numbers are stored in DAGs of type FLOAT.

In Maple, as in nearly every programming language, floating-point numbers can be constructed using and visually distinguished from integers with a decimal point symbol, '.'. The floating-point number $1.$ is often treated as equal to the exact integer $1$.

Maple floating-point numbers can also be constructed with the SFloat constructor (or the equivalent Float constructor) and can be checked with the nearly equivalent type,sfloat and type,float types. We will generally refer to these numbers as sfloats to when we need to distinguish them from hardware floating-point numbers (hfloats), introduced below.

A floating-point number represents a rational number with a fixed precision. That rational number can be recovered with convert/rational.

However, not every rational number can be represented exactly by a floating-point number. For example, the closest floating-point number to $\frac{1}{3}$ is $0.3333333333$.

Also, unlike numeric types integer and rational, integer and float do not have compatible arithmetic.  Floating-point arithmetic has a fixed finite precision, and does round off if the result of arithmetic does not fit into that precision.

Unlike many other programming languages the precision of sfloat arithmetic can be changed. For this reason, sfloats are known as arbitrary precision floating-point numbers.

More information on sfloats and how they differ from the floating-point types in languages such as C and Fortran will be discussed in greater detail in More about Floating-Point Numbers in Maple.

Floating-point numbers of the type used in languages such as C and Fortran can also be constructed in Maple; they are known as hardware floating-point numbers or hfloats. These types are stored as 8-byte double precision IEEE floating-point numbers contained in DAGs of type HFLOAT.  Since the . notation is used to construct Maple sfloats, hfloats must be constructed with the HFloat constructor.  Maple will display sfloats and hfloats the same way, using decimal notation.

The advantage of hfloats over sfloats is that their arithmetic is computed directly using a single CPU operation for each arithmetic operation. Maple sfloats, however, offer much more flexibility and precision.  In many ways the difference is analogous to the difference between immediate integers and GMP integers.

Hardware floats can be distinguished from sfloats with the type,hfloat type.

For more information on hardware floats and how they differ from sfloats, see More about Floating-Point Numbers in Maple.

The special built-in symbols infinity ($\mathrm{\infty }$), and undefined can be used in numeric arithmetic in Maple.  In general, operations involving $\mathrm{\infty }$ simplify automatically to a signed infinity or a complex infinity. For details, refer to the type,infinity help page.

The undefined symbol is usually produced as the result of attempting to carry out an operation that cannot result in a number for the given operands. Almost every arithmetic operation involving undefined returns undefined. For details, refer to the type,undefined help page.

Integer and rational numbers share exact undefined and infinite symbols while sfloat and hfloat numbers have their own versions of these, which are displayed differently but treated similarly.

A complex number in Maple is a DAG of type COMPLEX, which consists of a pair of any of the two numeric types.  They can be constructed in the natural way using the symbol $\mathrm{I}$ for the imaginary unit, or using the Complex constructor.

Automatic simplification will ensure that if one of the parts of a complex number is a float (or hfloat), then other will be made into a float (hfloat).

Complex numbers are not of type type,numeric but can be checked with type type,complex which can also be structured to check for the numeric subtypes of its two components.

Many Maple expressions represent constants, but are not considered to be of type numeric. This means that arithmetic performed on these constants will be more generic symbolic operations on DAGs of type SUM, PROD, NAME, or FUNCTION. Some examples of non-numeric constants are Pi ($\mathrm{\pi }$), $\mathrm{Catalan}$, $\sin \left(1\right)$, $\sqrt{5}$, and $\mathrm{\pi }\+{\ⅇ}^2-\sqrt{1\+5\mathrm{Catalan}}$.

The dismantle command shows that the two numbers $1$ and $1.$  have different internal representations.  $1$ is simply stored as an integer while $1.$ is stored as a pair of integers.

Similarly, the numbers $\frac{1}{2}$ and $0.5$ are also different even though they are both stored as pairs of integers.

In Maple, the FLOAT DAG-type represents a floating-point number in the form S * 10^E where both S and E are integers. For $1.$, the significand (or mantissa) is $S\=1$ and the exponent is $E\=0$. In addition to being specified in decimal notation, floats of this form can be constructed by using scientific notation, or the Float constructor.

The advantage of using this significand-exponent representation is that fixed precision approximations of large and small numbers can be stored compactly and their arithmetic can be done efficiently. Storing the integer 10^50 needs at least 167 bits or 3 words on a 64-bit machine. The floating-point number 1e50 can be stored in less than 8 bits but in in practice uses 2 words (one for each integer).

Using two immediate integers, a float can store a much larger range of numbers than a rational number with two immediate integers. The range a rational can represent is about $1.{10}^{-9}..1.{10}^9$ while a float can represent a range of about $1.{10}^{-1073741823}..9.{10}^{1073741823}$. This is a much larger range for the same storage cost.  Of course, that larger range means that floats of a fixed size can represent fewer numbers in that range. And since floating-point numbers are always of a fixed size, this means that arithmetic will always be of limited precision.  That is, each operation will have to round the result to a number that can be represented as another floating-point number.

In Maple, the significand is limited to 10 decimal digits of precision by default but can be changed while the exponent is restricted to being a word-sized integer.

More information on the restrictions on the size of software floats in Maple can be found by using the Maple_floats command.

By contrast, hfloats, are represented in base 2, rather than base 10. So they represent numbers using the form S * 2^E, where the significand, S, is a 52-bit integer and the exponent, E, is a 10-bit integer. Thus, the range of numbers representable as hardware floats is $2.225073859{10}^{-308}..1.797693135{10}^{308}$. Because the largest possible significand of a hardware float has about $\mathrm{floor}\left({\log }_{10}\left(2^{52}\right)\right)\=15$ base-10 digits of precision, hardware floats can be converted to software floats without meaningful loss of precision when Digits is 15.  Conversely, so long as their exponent is smaller than 307 and their significand had fewer than 15 digits sfloats can be converted to hfloats without loss of precision.

By default, 10-digit precision is used for floating-point arithmetic, which means that the arithmetic will be rounded to 10 digits.  This means any single floating-point operation will be accurate to 10 digits.

For example, storing 10^50+1 requires 50 decimal digits so it will be rounded in floating-point arithmetic. By contrast, 10^50+10^41 can be stored with 10 digits so it will still be computed accurately.

 The Digits environment variable can be used to change the working precision used by Maple. Larger values of Digits will allow more accurate computation, but at the cost of slower arithmetic.

The maximum value for Digits is system dependent and can be found with the Maple_floats command.

For the default value of Digits, the significand is an immediate integer and so arithmetic will be fast in general.  It also means that some numerical function evaluations (such as sin in the following example) will be able to use the CPU's native hardware floating-point arithmetic to achieve the needed precision.  However, raising Digits about the default value will lead to slower arithmetic and slower function evaluation.

Reducing Digits below its default value does not usually lead to large improvements in performance.

It is also important to note that changing Digits does not necessarily change the accuracy of sequences of multiple floating-point computations; it changes only the precision of the individual operations performed. The following example computes two additions using 10 digits of precision, but catastrophic cancellation leads to a mere one digit of accuracy in the final answer.

Ensuring accuracy requires careful study of the problem at hand. In this example, you need 19 digits of precision to get 10 digits of accuracy.

An important property of floating-point numbers in Maple, and nearly every other computing environment, is contagion.  When numerical expressions are created involving both floating-point numbers and exact numbers, the floating property is contagious and causes the answer to become a floating-point number.

As you can see, this contagion property can be used as a quick method to convert exact values to floating-point numbers.  However, while floating-point contagion extends to all Maple structures of type numeric (except, in some cases, hfloats), it does not apply to non-numeric constants.

The hfloat type is also contagious, but the precise behavior of the contagion is determined by the UseHardwareFloats environment variable. By default, hfloats are contagious for small values of Digits:

For large values of Digits, hfloats in computations will be converted to sfloats so that the results are sfloats.

If UseHardwareFloats=true then hfloats are completely contagious.

If UseHardwareFloats=false then hfloats will always be converted to sfloats in computations, regardless of the setting of Digits.  The HFloat constructor will still create hfloats, however.

Table 7.1 summarizes the floating-point contagion rules.

The software floating-point system is designed as a natural extension of the industry standard for hardware floating-point computation, known as IEEE 754. Thus, there are representations for infinity and undefined (what IEEE 754 calls a NaN, meaning Not a Number) as discussed in Extended Numeric Types.

The IEEE 754 standard defines five rounding algorithms. Two methods called nearest and simple round to nearest values, and the other three are directed roundings that round up or down (as needed) towards $-\mathrm{\infty }$, $\mathrm{\infty }$, or 0. Maple implements all of these rounding modes and the desired mode can be selected by setting the Rounding environment variable.

Another important feature of this system is that the floating-point representation of zero, 0., retains its arithmetic sign in computations.  That is, Maple distinguishes between +0. and -0. when necessary.  In most situations, this difference is irrelevant, but when dealing with functions that have a discontinuity across the negative real axis, such as $\ln \left(x\right)$, preserving the sign of the imaginary part of a number on the negative real axis is important.

For more intricate applications, Maple implements extensions of the IEEE 754 notion of a numeric event, and provides facilities for monitoring events and their associated status flags. For more information about this system, refer to the numerics help page.

The evalf command is the primary tool in Maple for performing floating-point calculations in software floating-point mode. You can use evalf to compute approximations of non-numeric constants.

You can alter the number of digits of the approximation by changing the value of the environment variable Digits, or by specifying the number as an index to evalf (which leaves the value of Digits unchanged).

Remember that the Digits command specifies the precision in decimal digits, unlike hardware floating-point numbers which specify precision in binary digits.

All floating-point computations are performed in finite precision, with intermediate results generally being rounded to Digits precision. As such, it is possible for round-off errors to accumulate in long computations.  Maple ensures that the result of any single floating-point arithmetic operation (+, -, *, /, or sqrt) is fully accurate.  Further, many of the basic functions in Maple, such as the trigonometric functions and their inverses, the exponential and logarithmic functions, and some of the other standard special functions for mathematics, are accurate to within .6 units in the last place (ulps), meaning that if the Digits + 1st digit of the true result is a 4, Maple may round it up, or if it is a 6, Maple may round it down.  Most mathematical functions in Maple, including numerical integration, achieve this accuracy on nearly all inputs.

It is possible to create software floats with different precisions. Changing the value of Digits will not change these numbers; it affects only the precision of subsequent operations on those numbers.

From this example, you can see that evalf can be used to create a lower precision float from one of higher precision. This can be used to round a result to a desired number of digits. However, evalf will not increase the precision of a low precision float.

The evalf command also provides an interface to purely numerical computations of integrals, limits, and sums.

Some definite integrals have no closed-form solution in terms of standard mathematical functions.  You can use evalf to obtain a numerical answer directly using numerical techniques.

In other cases, Maple can find an exact solution, but the form of the exact solution is almost incomprehensible. The function $\mathrm{Beta}$ in the following example is a special function that appears in mathematical literature.

The two previous examples use the Int command rather than int for the integration.  If you use int, Maple first tries to integrate the expression symbolically.  Thus, when evaluating the following commands, Maple determines a symbolic answer and then converts it to a floating-point approximation, rather than performing direct numerical integration.  In general, the symbolic computation is more difficult, and thus slower than the numerical computation.

Similarly, evalf can be used on the inert forms Limit and Sum to compute using numerical algorithms for computing numeric limits and sums.

When Not to Use evalf

In general the symbolic commands in Maple are able to handle floating-point numbers in their input, but, by their nature floats are not as precise as rationals or symbolic constants.  So, even if you want a numerical answer from a command, you should avoid calling evalf on the input. The following command does not compute the expected answer of $0.1111111111$. >  limit(n*(evalf(1/3) - 1/(3+1/n)), n=infinity); $Float\left(-\mathrm{\infty }\right)$ (98) It would have been computed correctly with non-float values in the input. >  evalf( limit(n*(1/3 - 1/(3+1/n)), n=infinity) ); $0.1111111111$ (99)

There are also a number of numerical algorithms available in Maple in commands other than evalf.  One of the most important is fsolve which is short for floating-point solve. This command computes numerical solutions to equations or systems of equations.  In general, it is much more efficient than calling evalf on the result of solve, especially if you are interested in only a single solution.