A *compnum* is a general complex number whose real-part and imag-part are both flonums. The following procedures should be in a different library from the flonum procedures.

The R6RS-specific integer division procedures have been removed, as have the condition types.

This section uses *cx*, *cx _{1}*,

Returns `#t` if *obj* is a compnum, `#f` otherwise.

Returns the best compnum representation of
*x*.

The value returned is a compnum that is numerically closest to the argument.

Note:If compnums are represented in binary floating point, then implementations should break ties by preferring the floating-point representation whose least significant bit is zero.

The value returned is a compnum whose real part is the flonum *fl _{1}* and whose imaginary part is the flonum

The value returned is a compnum whose magnitude is the flonum *fl _{1}*
and whose angle is the flonum

This procedure returns `#t` if its arguments are equal.

These numerical predicates test a compnum for a particular property,
returning `#t` or `#f`.
The `cxzero?` procedure tests whether
it is `cx=?` to `0.0+0.0i,
cxfinite? tests whether both the real and the imaginary parts
are not an infinity and not a NaN,
cxinfinite? tests whether either the real or the imaginary parts or both is an infinity, and
cxnan? tests whether either the real part or the imaginary part or both is a NaN.`

These procedures return the compnum sum or product of their compnum arguments. In general, they should return the compnum that best approximates the mathematical sum or product. (For implementations that represent compnums using IEEE binary floating point, the meaning of “best” is defined by the IEEE standards.)

With two or more arguments, these procedures return the compnum difference or quotient of their compnum arguments, associating to the left. With one argument, however, they return the additive or multiplicative compnum inverse of their argument. In general, they should return the compnum that best approximates the mathematical difference or quotient. (For implementations that represent compnums using IEEE binary floating point, the meaning of “best” is reasonably well-defined by the IEEE standards.)

For undefined quotients, `cx/` behaves as specified by the
IEEE standards

This procedure returns the real part of *cx*.

This procedure returns the imaginary part of *cx*.

This procedure returns the angle of *cx*.

These procedures return the absolute value (magnitude) of *cx*.

See report section on “Transcendental functions” for the underlying mathematical operations. In the event that these operations do not yield a real result for the given arguments, the result may be a NaN, or may be some unspecified compnum.

Implementations that use IEEE binary floating-point arithmetic should follow the relevant standards for these procedures.

Returns the principal square root of *cx*. For negative arguments,
the result may be a NaN or some unspecified compnum.

Either *cx _{1}* should be non-negative, or, if

The following constants are defined in terms of the constants of the <math.h> header of ISO/IEC 9899:1999 (C language).

Scheme name |
C name |
Comments |

cx:i |
I |
0+1i as a compnum |

Scheme name |
C signature |
Comments |

cxconjugate |
double complex conj(double complex) |
complex conjugate |

cxexp |
double complex cexp(double complex) |
- |

||cxprojection||double complex cproj(double complex)||projects to Riemann sphere

The following are general complex number functions, not just for compnums.

(cis *z*)

Returns e^{iz}, a complex number whose real part is cos *z* and whose imaginary part is sin *z*.

(signum *z*)

Returns a complex number whose phase is the same as *z* but whose magnitude is 1, unless *z* is zero, in which case it returns *z*. As a consequence of this definition, negative real numbers return -1, positive real numbers return 1, and zero returns zero.