A complex number x + 0*I, where x is a real number, is not the same as x itself. Strict adherence to this in the symbolic domain, however, would rapidly lead to large expressions cluttered with such 0s. As a compromise, therefore, Maple uses the following rules:

If x is of type extended_numeric, then x + 0.0*I, x - 0.0*I and x are all represented as distinct objects, as are 0.0 + x*I, -0.0 + x*I and x*I.

If x is not of type extended_numeric, then x + 0*I, x + 0.0*I and x - 0.0*I all evaluate to x, and 0 + x*I, 0.0 + x*I and -0.0 + x*I all evaluate to x*I.

The above rules are applied to expressions inside a procedure body at the time the procedure is executed, not when it is entered.

The complex constructor can be used to prevent the simplification of x + 0.0*I and x - 0.0*I to x (and 0.0 + x*I, -0.0 + x*I to x*I), where x is not of type extended_numeric. For example, Complex(CopySign(1, x), 0.0) remains unevaluated for such x.

There is no obvious way to represent the single point "complex infinity" (denoted here by cx-infinity) with the representation Maple uses for complex numbers (the canonical representation being the polar one, $\mathrm{\infty }{\ⅇ}^{\mathrm{undefined}\mathrm{I}}$ ). However, it is important to have such an object to represent, for example, the values of functions at poles such as GAMMA(-1). Therefore, Maple uses the following convention for this object:

Maple routines interpret any 2-argument complex number, where both arguments are some form of real infinity, as complex infinity.

There are several important consequences of this convention. Primarily, cx-infinity is located in no particular part of the complex plane, and hence we have:

csgn(cx-infinity), signum(cx-infinity), argument(cx-infinity) are all undefined.

1/cx-infinity = cx-0.

Note: Since the exact rational 0 + 0*I simplifies to the exact rational 0, it is not possible to preserve the mathematical properties of the symbolic cx-infinity under inversion transformations.

It does not make sense to ask for the real or imaginary parts of cx-infinity by using Re or Im (but Re and Im do not complain if you do so).

Computationally, 1.0 + 0.0*I, 1.0 - 0.0*I and 1.0 are distinct, but mathematically they are the same. Under ordinary circumstances (where branch cuts are not involved), results of computations using any of these forms of the number 1.0 return mathematically equivalent results. Therefore, Maple uses the following convention:

Computations which do not require the information contained in the sign of the real 0 or imaginary 0 part of a non-0 complex number (that is, computations which do not need to account for a relevant branch cut) return a value which is mathematically independent of the presence or absence of that 0 component and of its sign, if present.