Numeric Computation in Maple

This document describes the Maple numeric computation environment. It contains information regarding the following topics.

•

Goals of the Computation Environment

•

Events, Exceptions, and Status Flags

•

Typechecking Facilities

•

Functions and Predicates

•

Input and Output Formatting


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 floatingpoint 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 floatingpoint 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 typechecking function. For more information, see the individual constructor and typechecking help pages.


A software floatingpoint number (type sfloat) and a general floatingpoint number (type float) are considered to be the same object.


Maple hardware floatingpoint 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 hardwarefloat 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.

Digits

controls the precision when performing


floatingpoint operations

Rounding

controls the rounding of floatingpoint results

NumericEventHandler

contains the active numeric event handler procedures

UseHardwareFloats

controls whether floatingpoint operations


are performed in the hardware or software environment





Arithmetic



The standard operations of addition, subtraction, multiplication, division by a nonzero number, and exponentiation by an integer are provided.


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


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 noncomplex 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$)


5. $xx=x+x=x+\left(x\right)=+0$ unless the rounding mode is set to Round toward infinity, in which case the result is 0; $00=0+\left(0\right)=0$, regardless of rounding mode.


6. $\mathrm{iquo}\left(\pm \mathrm{infinity},x\right)=\pm \mathrm{signum}\left(x\right)\mathrm{infinity}$


7. $\mathrm{irem}\left(x,\pm \mathrm{infinity}\right)=x$


8. $\mathrm{iquo}\left(x,\pm \mathrm{infinity}\right)=0$


9. ${\mathrm{\infty}}^{x}=\mathrm{\infty}$ if $0<x$ and is $0$ if $x<0$


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 2argument 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}+\mathrm{0i}$. Then:


* $\frac{1}{z}=\mathrm{conj}\left(z\right)=\mathrm{undefined}\mathrm{0i}$


* $\mathrm{sin}\left(z\right)=z$


* $\mathrm{arcsin}\left(\mathrm{i}z\right)=\mathrm{i}z=0+\mathrm{undefined}\mathrm{i}$


* $z*\mathrm{undefined}=z$


* $\mathrm{ln}\left(z\right)=\mathrm{undefined}+\mathrm{undefined}\mathrm{i}$


* $\mathrm{arcsin}\left(z\right)=\mathrm{undefined}+\mathrm{undefined}\mathrm{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+\mathrm{0i}\right)\mathrm{infinity}=\mathrm{infinity}+\mathrm{0i}$


* $\left(0\mathrm{2i}\right)\left(\mathrm{infinity}+\mathrm{0i}\right)=0\mathrm{infinity}\mathrm{i}$


* $\left(0+\mathrm{2i}\right)\left(\mathrm{infinity}+\mathrm{0i}\right)=0+\mathrm{infinity}\mathrm{i}$


* $\left(1+\mathrm{0i}\right)\left(\mathrm{infinity}+\mathrm{undefined}\mathrm{i}\right)=\mathrm{infinity}+\mathrm{undefined}\mathrm{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+\mathrm{0i}\right)\mathrm{infinity}=\mathrm{undefined}+\mathrm{undefined}\mathrm{i}$


* $\left(0+\mathrm{0i}\right)\left(\mathrm{infinity}+\mathrm{undefined}\mathrm{i}\right)=\mathrm{undefined}+\mathrm{undefined}\mathrm{i}$


* $\left(0+\mathrm{0i}\right)\left(\mathrm{infinity}+\mathrm{infinity}\mathrm{i}\right)=\mathrm{undefined}+\mathrm{undefined}\mathrm{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}\mathrm{i}}=0+0\mathrm{i}$


* $\mathrm{infinity}+\mathrm{undefined}\mathrm{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.



Typechecking Facilities



Typechecking 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.



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.






