Maple Numerics Overview - Maple Help

Numeric Computation in Maple

 This document describes the Maple numeric computation environment. It contains information regarding the following topics.
 • Goals of the Computation Environment
 • Number Formats
 • Special Values
 • Environment Variables
 • Arithmetic
 • Events, Exceptions, and Status Flags
 • Type-checking Facilities
 • Functions and Predicates
 • Input and Output Formatting
 • References

Goals of the Maple Numeric Computation Environment

 The Maple numeric computation environment is designed to achieve the following goals.
 1.   Consistency with IEEE standards.
 2.   Consistency across different types of numeric computations (hardware, software, and exact).
 3.   Provision of direct support for handling exceptional events.
 4.   Integration of routines from the Numerical Algorithms Group (NAG).
 5.   Ability to enable further refinements and extensions to the environment.
 IEEE Standards and Maple Numerics
 The IEEE/754 and IEEE/854 standards for floating-point arithmetic have natural generalizations to arbitrary precision computing environments, such as Maple. By adopting such natural generalizations, Maple provides a uniform and consistent view of numeric computation across each of the hardware (fixed precision), software (arbitrary precision), and exact computation environments. Furthermore, IEEE/754 has been widely adopted in the computer industry to the point where Maple is now supported only on machines that claim to be IEEE/754 compliant.
 Extensions to Industry Standards
 Maple floating-point computation environments differ from the IEEE/754 standard by including the following features.
 1.   Extensions to symbolic data.
 2.   The extension to complex numerics.
 3.   Square root is not considered a basic operation, and does not signal Invalid on negative arguments.
 4.   The RealToComplex event is included to handle operations that receive real input and return complex results.

Number Formats

 The Maple numeric computation environment supports the following number formats. Each format has an associated constructor and type-checking function. For more information, see the individual constructor and type-checking help pages.

 Format Constructor Type-checking Function integer fraction floating-point software floating-point Maple hardware floating-point complex

 A software floating-point number (type sfloat) and a general floating-point number (type float) are considered to be the same object.
 Maple hardware floating-point numbers can exist as elements of rtables, as elements extracted from rtables, within the evalhf evaluator, or more generally in ordinary computation. For the specific cases of Matrix and Vector rtables with hardware-float entries, linear algebra computations can usually be carried out via calls to NAG library routines, resulting in significant efficiency gains over similar computations performed in the symbolic computation domain. (See also UseHardwareFloats.)
 Numeric objects in any of the above formats are structural units in expressions; in particular, they are atomic with respect to map(). Standard functions are provided to extract the mathematical components of these objects (numerator, denominator, sign, mantissa, exponent, real part, and imaginary part). See the section on Functions and Predicates.

Special Values

 In each of the numeric formats listed in the previous section, there are the following special symbols.
 • infinity (both +infinity and -infinity)
 • undefined (representing the IEEE/754 NaN ("Not a Number"))
 Both types of infinities and at least one type of undefined are represented in each of the numeric formats (see the help pages for the respective constructors listed in the previous section). For specific information on these special symbols, see the infinity and undefined help pages.

Environment Variables

 There are four environment variables that control the operation of the numeric environment. For more information regarding their functionality, see the corresponding help page.

 controls the precision when performing floating-point operations controls the rounding of floating-point results contains the active numeric event handler procedures controls whether floating-point operations are performed in the hardware or software environment

Arithmetic

 Standard Arithmetic
 The standard operations of addition, subtraction, multiplication, division by a non-zero number, and exponentiation by an integer are provided.
 Complex Arithmetic
 Complex arithmetic is implemented according to standard formulas, and produces correctly rounded infinitely precise results whenever that result is representable in the current numeric environment. Furthermore, the result of an arithmetic operation when at least one operand is a complex numeric is a complex numeric, unless all complex numeric operands are purely imaginary and the mathematical result would be real, (in which case the Maple result is a real numeric (for example, Complex(1)^2 = Integer(-1))).
 Note: The complex conjugate of a real number is that real number, not a complex number with 0  imaginary part.
 Arithmetic Involving 0's, infinities, and undefineds
 A.  Real case
 The following rules specify the default results of the arithmetic operations other than exponentiation on real numeric operands when at least one of the operands is an infinity, 0, or undefined and no exception is signaled (see Events, Exceptions, and Status Flags). The rules are checked in order. The symbol x stands for any non-complex value not already included in a prior rule, and signum(x) means the sign of x.
 1.  Any basic operation for which either operand is an undefined returns an undefined (which will usually be one of the input undefineds).
 2.  $\mathrm{\infty }+x=\mathrm{\infty }$ ($x\ne -\mathrm{\infty }$)
 3. $x*\mathrm{infinity}=\mathrm{signum}\left(x\right)\mathrm{infinity}$ ($x\ne 0$)
 4.   $x*0=0$
 5. $x-x=-x+x=x+\left(-x\right)=+0$ unless the rounding mode is set to Round toward -infinity, in which case the result is -0; $-0-0=-0+\left(-0\right)=-0$, regardless of rounding mode.
 6. $\mathrm{iquo}\left(±\mathrm{infinity},x\right)=±\mathrm{signum}\left(x\right)\mathrm{infinity}$
 7. $\mathrm{irem}\left(x,±\mathrm{infinity}\right)=x$
 8. $\mathrm{iquo}\left(x,±\mathrm{infinity}\right)=0$
 9.  ${\mathrm{\infty }}^{x}=\mathrm{\infty }$ if $0 and is $0$ if $x<0$
 B.  Complex case
 The rules for complex arithmetic are inherited from the corresponding rules for real arithmetic, including the rules for operations involving infinities, undefineds, and 0's except if an operand to an operation is a 2-argument complex numeric in which exactly one component is 0 (hence, +0.0 or -0.0). In such cases, the correct interpretation of the 0 component is that it provides qualitative information rather than quantitative information. In particular, such a 0 component should not be understood to be an infinitesimal value. The operation in question produces qualitatively the same result as if the relevant operand were replaced by the mathematically equal real or purely imaginary value. Effectively, the product of a 0 component and an undefined or infinity is 0, with sign information being obtained according to the usual rules of arithmetic.
 Function evaluation also inherits this interpretation.
 For example, let $z=\mathrm{undefined}+0i$. Then:
 * $\frac{1}{z}=\mathrm{conj}\left(z\right)=\mathrm{undefined}-0i$
 * $\mathrm{sin}\left(z\right)=z$
 * $\mathrm{arcsin}\left(iz\right)=iz=-0+\mathrm{undefined}i$
 *  $z*\mathrm{undefined}=z$
 However,
 * $\mathrm{ln}\left(z\right)=\mathrm{undefined}+\mathrm{undefined}i$
 * $\mathrm{arcsin}\left(z\right)=\mathrm{undefined}+\mathrm{undefined}i$
 because z could be on a branch cut or not, with different imaginary parts for the result in each case.
 Arithmetic involving infinities is performed in the same manner.
 * $\left(1+0i\right)\mathrm{infinity}=\mathrm{infinity}+0i$
 * $\left(0-2i\right)\left(\mathrm{infinity}+0i\right)=0-\mathrm{infinity}i$
 * $\left(0+2i\right)\left(-\mathrm{infinity}+0i\right)=-0+\mathrm{infinity}i$
 * $\left(1+0i\right)\left(\mathrm{infinity}+\mathrm{undefined}i\right)=\mathrm{infinity}+\mathrm{undefined}i$
 The standard rules apply in the case of a product of any real or complex that is equal to 0 and any kind of infinity.
 * $\left(0+0i\right)\mathrm{infinity}=\mathrm{undefined}+\mathrm{undefined}i$
 * $\left(0+0i\right)\left(\mathrm{infinity}+\mathrm{undefined}i\right)=\mathrm{undefined}+\mathrm{undefined}i$
 * $\left(0+0i\right)\left(\mathrm{infinity}+\mathrm{infinity}i\right)=\mathrm{undefined}+\mathrm{undefined}i$
 If either component of a complex numeric is infinity, then the number is considered to be infinite for the purposes of computation.
 * $\frac{1}{\mathrm{\infty }+\mathrm{undefined}i}=0+0i$
 * $|\mathrm{infinity}+\mathrm{undefined}i|=\mathrm{infinity}$

Events, Exceptions, and Status Flags

 Maple provides direct support for handling exceptional events.  The NumericEventHandler environment variable holds the active numeric event handler procedures. For more information regarding events and status flags, see the following related help pages.

Type-checking Facilities

 Type-checking facilities are provided in the Maple computation environment.
 Note: While IEEE/754 uses predicates (for example, IsFinite(expr)), which are allowed to fail (signal Invalid), Maple generally uses types (for example, type(expr, finite)), which are required to return false if they are not able to return true.
 The various numeric types are listed in the numeric_types help page.

Functions and Predicates

 The following functions and predicates are provided in the Maple computation environment. They extend the functions and predicates of the IEEE/754 Standard. For more information regarding a particular function or predicate, see the associated help page.

 Functions

 Predicates

Input and Output Formatting

 Numeric formats supported in Maple can be formatted in a variety of representations. For more information on formatting input and output of numerics, see the printf and scanf help pages.

References

 For information regarding IEEE standards and other references used in the development of the Maple numeric computation environment, see the help page on numericrefs.