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.

The fsolve command is a sophisticated heuristic that chooses among many different algorithms depending on the input.  There are several more special purpose solving tools available in the RootFinding package.

Several symbolic solvers in Maple also have numeric modes. The dsolve and pdsolve commands both accept a numeric option, which indicates that a numerical answer should be computed using purely numeric methods. For extensive information on these numeric commands, refer to the dsolve/numeric and pdsolve/numeric help pages.

Like evalf, evalhf computes an numerical approximation of its input. However, evalhf uses hardware floats in all intermediate calculations before returning an sfloat.

The evalhf command is affected by the value of Digits, but since intermediate calculations are done with hfloats, at most 18 digits will be returned.

Notice that in this example the result is only correct to 16 digits. In general, the results from evalhf are guaranteed to 15 digits of accuracy.

To find the number of guaranteed digits for your version of Maple, use evalhf(Digits):

In fact, evalhf is, despite superficial similarities, very different from evalf.  The evalhf command uses a completely separate evaluation environment which uses only simple types rather that the Maple DAG types. This means that it can be very fast, but at the cost of being limited in the types of computations it can perform.

In particular evalhf only handles a specific list of functions. For the list of functions that evalhf recognizes, refer to the evalhf/fcnlist help page.

evalhf works with Arrays of hardware floats. It cannot handle symbols, lists, sets, and most other Maple data structures.

To create an Array of hardware floats, you can use the option datatype=float[8], which specifies that the elements in the Array are 8-byte hardware floats.

You can also create an Array that can be used by evalhf by using the constructor hfarray. Both constructors create an Array of hardware floats. The only difference is that hfarray defaults to C_order instead of Fortran_order.

User-defined Maple procedures can be evaluated in the evalhf environment as long as they comply with the restrictions outlined in the evalhf/procedure help page.

Maple has access to many libraries for fast numeric computation such as BLAS, CLAPACK, and the NAG® C Library. To take full advantage of the speed provided by these commands, you need to provide them with Matrices and Vectors with the appropriate datatype.

For example, floating-point Matrix times Matrix products can been computed very quickly in the BLAS libraries and quickest dispatch to the BLAS commands will happen if the Matrices are created with datatype=float[8].

Of course, many of the linear algebra commands will try to determine if you have a Matrix of low precision floats and will convert to the appropriate datatype automatically. In the next example, Af has datatype=anything, but the result of Af^2 has datatype=float[8] and requires only a small, but noticeable, copy and conversion overhead.

We recommend that you specify datatype=float[8] in your constructors explicitly if you intend to perform numeric computations.  This makes the numeric nature of the Matrix explicit, and it makes it impossible to accidentally add non-float entries to a Matrix and thus make subsequent computations slower.  An exception will be raised if non-numeric entries are assigned into the Matrix.

Other numeric types will be automatically converted to float[8].

If a Matrix contains only floats, but does not have a datatype=float[8] restriction, then addition of symbolic elements results in the more expensive symbolic commands to be used.

Another advantage of float[8] is that these Matrices are stored in the same way as an hfarray which is analogous to an array of floats in the C or Fortran programming languages and different from a Matrix of datatype=anything or datatype=sfloat which are arrays of Maple DAGs each of which will take more memory than a single 8-byte float. Note the difference in memory used in the following two examples.

It is also important to note that elements extracted from a float[8] rtable will be of type hfloat and so hfloat contagion will apply subject to the current setting of UseHardwareFloats.

There are also many optimized commands for Matrices of complex hfloats. These Matrices can be created using the option datatype=complex[8], and work similarly to those of datatype=float[8].

If you are constructing very large Matrices in your programs, use the ArrayTools package to construct and copy Matrices as efficiently as possible.

You can use the evalhf(Digits) construct to determine whether hardware floating-point arithmetic provides sufficient precision in a particular application.  If Digits is less than evalhf(Digits), then you can take advantage of the faster hardware floating-point calculations. Otherwise, you should use software floating-point arithmetic, with sufficient digits, to perform the calculation.

In the following example, the procedure myevalf takes an unevaluated parameter, expr. Without the uneval declaration, Maple would evaluate expr symbolically before invoking myevalf.

The evalhf command evaluates many Maple functions, but not all.  For example, you cannot evaluate an integral using hardware floating-point arithmetic.

You can improve the procedure myevalf so that it traps such errors and tries to evaluate the expression using software floating-point numbers instead.

This procedure provides a model of how to write procedures that use hardware floating-point arithmetic whenever possible.

The myevalf procedure returns sfloats.  A version that returns hfloats is easiest to write using the hfloat procedure option. This option will cause the procedure to use hfloat arithmetic as much as possible so long as digits less than 15. In particular it convert all floats in the procedure definition into hfloats, and causes evalhf to not convert its output to an sfloat.

The multiplication by $1.$ was added to the evalf return line to induce hfloat contagion causing the output to be an hfloat when possible.

For more information on the hfloat option, see The hfloat Option or refer to the option_hfloat help page.

This section illustrates how to take advantage of hardware floating-point arithmetic to calculate successive approximations using Newton's method. You can use Newton's method to find numerical solutions to equations.  As Example: Creating a Newton Iteration describes, if $x_n$ is an approximate solution to the equation $f\left(x\right)\=0$, then $x_{n\+1}$, given by the following formula, is typically a better approximation.

$x_{\left(n\+1\right)}\=x_n-\frac{f\left(x_n\right)}{f\'\left(x_n\right)}$

The procedure iterate takes a function, f, its derivative, df, and an initial approximate solution, x0, as input to the equation $f\left(x\right)\=0$. The procedure iterate calculates at most N successive Newton iterations until the difference between the new approximation and the previous one is small.  The procedure prints the sequence of approximations to show successive approximations.

The following procedure calculates the derivative of f and passes all the necessary information to iterate.

Use Newton to solve the equation $x^2-2\=0$.

This version of Newton uses sfloats unless the arguments passed in are hfloats.  If you add option hfloat to the procedure iterate, then hfloats are used automatically, provided the value of Digits is small enough.

Now the procedure Newton will return hfloats instead of sfloats when Digits is less than 15.

In this case, the procedure is simple enough that we can go beyond option hfloat and use the evalhf command to achieve best performance. This next version of Newton uses evalhf for floating-point arithmetic if possible and reverts to sfloats otherwise. Since iterate only tries to find a solution to an accuracy of 10^(1-Digits), Newton uses evalf to round the result of the hardware floating-point computation to an appropriate number of digits.

Newton uses hardware floating-point arithmetic for the iterations and rounds the result to software precision. Hardware floating-point numbers have more digits than the software floating-point numbers, given the present setting of Digits.

Newton must use software floating-point arithmetic to find a root of the following Bessel function.

Software arithmetic is used because evalhf does not recognize BesselJ and the symbolic code for BesselJ uses the type command and remember tables, which evalhf does not allow.

Using a try-catch block (as in the previous Newton procedure) allows the procedure to work when evalhf fails.

The previous Newton procedure prints many digits when it is trying to find a ten-digit approximation.  The reason is that the print command is located inside the iterate procedure, which is inside a call to evalhf, where all numbers are hardware floating-point numbers, and print as such.

Jacobi iteration is an iterative method for numerically solving systems of linear equations that are diagonally dominant (meaning that the diagonal elements of the matrix representing the system are larger than the sum of all other elements in any given row of the matrix). Given an initial guess of $\mathrm{x0}$ for the solution to $A\cdot x\=b$, the process is: if $x_k$ is an approximation for the solution, then the next approximation is $x_{k\+1}\=S^{\mathrm{-1}}\cdot \left(b-R\cdot x_k\right)$ where $S$ is the diagonal of $A$ and $A\=S\+R$.

The procedure Jacobi is a straightforward implementation of Jacobi iteration as it is usually presented in a numerical analysis course.

Here we construct a random Matrix that is strongly diagonally dominant to test the procedure. Note that, while in practice Jacobi iteration would not be used on dense Matrices, we use dense Matrices in these examples to illustrate some efficiency principles.

The code is written in such a way that it will automatically work for software floats at higher values of digits.

This implementation works well for small Matrices, but when the dimension becomes large, it becomes very slow.

Adding option hfloat to Jacobi is not likely to increase performance, since hfloat contagion from the float[8] Matrix elements means that hfloat arithmetic is likely being used everywhere possible already. However, it is possible to rewrite the internal loops as a procedure that can be evaluated with evalhf. (It might be possible to rewrite all of Jacobi to be evaluatable to evalhf, but it would be difficult and potential gains would be modest.)

And the rest of the procedure with option hfloat.

Using evalhf here achieves an impressive speed-up but you can achieve even better speed by taking advantage of the built-in Matrix and Vector operations. In general you code will be faster if you can replace nested loops with calls to external commands for Vectors or Matrices.  Those commands will be highly optimized for your platform taking advantage of multiple cores and cache hierarchy where possible.

This sort of speed-up is typical.  The built-in numerical linear algebra commands are easily an order of magnitude faster than loops run in Maple, and generally also faster than loops in evalhf.