Numeric Computation in Maple - Maple Help

Online Help

All Products    Maple    MapleSim


Home : Support : Online Help : Mathematics : Numerical Computations : Maple Numerics : numerics

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

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.

  

For more information, see IEEEdiffs.

  

 

  

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

Integer

type[integer]

fraction

Fraction

type[fraction]

floating-point

Float

type[float]

software floating-point

SFloat

type[sfloat]

Maple hardware floating-point

HFloat

type[hfloat]

complex

Complex

type[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.

Digits

controls the precision when performing

 

floating-point operations

Rounding

controls the rounding of floating-point results

NumericEventHandler

contains the active numeric event handler procedures

UseHardwareFloats

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.  +x= (x)

  

3. x*infinity=signumxinfinity (x0)

  

4.   x*0=0 

  

5. xx=x+x=x+x=+0 unless the rounding mode is set to Round toward -infinity, in which case the result is -0; 00=0+0=0, regardless of rounding mode.

  

6. iquo±infinity,x=±signumxinfinity 

  

7. iremx,±infinity=x 

  

8. iquox,±infinity=0 

  

9.  x= if 0<x 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=undefined+0ⅈ. Then:

  

* 1z=conjz=undefined0ⅈ 

  

* sinz&equals;z

  

* arcsinz=z=0+undefined 

  

*  z*undefined=z 

  

However,

  

* lnz=undefined+undefined 

  

* arcsinz=undefined+undefined 

  

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.

  

* 1+0ⅈinfinity=infinity+0ⅈ 

  

* 02ⅈinfinity+0ⅈ=0infinity 

  

* 0+2ⅈinfinity+0ⅈ=0+infinity 

  

* 1+0ⅈinfinity+undefined=infinity+undefined 

  

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.

  

* 0+0ⅈinfinity=undefined+undefined 

  

* 0+0ⅈinfinity+undefined=undefined+undefined 

  

* 0+0ⅈinfinity+infinity=undefined+undefined 

  

If either component of a complex numeric is infinity, then the number is considered to be infinite for the purposes of computation.

  

* 1+undefined=0+0 

  

* |infinity+undefined|=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.

  

 

events

NumericEvent

NumericEventLocation

NumericEventHandler

NumericStatus

 

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

 

 

 

 

 

 

 

conjugate

CopySign

Default0

DefaultOverflow

DefaultUnderflow

denom

ilog10

Im

NextAfter

numer

NumericClass

NumericEventHandler

NumericStatus

NumericEvent

Re

Scale10

SFloatExponent

SFloatMantissa

sqrt

 

  

 

 

Predicates

 

 

 

 

 

relational operators

 

 

Unordered

 

 

OrderedNE

 

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.

See Also

IEEEdiffs

 


Download Help Document

Was this information helpful?



Please add your Comment (Optional)
E-mail Address (Optional)
What is ? This question helps us to combat spam