Next: Projections, Conjugates, and Decomposing of Complex Numbers, Previous: Arithmetic Functions, Up: Arithmetic Functions [Contents][Index]

ISO C99 introduces support for complex numbers in C. This is done
with a new type qualifier, `complex`

. It is a keyword if and only
if `complex.h` has been included. There are three complex types,
corresponding to the three real types: `float complex`

,
`double complex`

, and `long double complex`

.

Likewise, on machines that have support for `_Float`

or
`N``_Float`

enabled, the complex types `N`x`_Float`

and `N`
complex`_Float`

are also available if
`N`x complex`complex.h` has been included; see Mathematics.

To construct complex numbers you need a way to indicate the imaginary
part of a number. There is no standard notation for an imaginary
floating point constant. Instead, `complex.h` defines two macros
that can be used to create complex numbers.

- Macro:
*const float complex***_Complex_I**¶ -
This macro is a representation of the complex number “

*0+1i*”. Multiplying a real floating-point value by`_Complex_I`

gives a complex number whose value is purely imaginary. You can use this to construct complex constants:*3.0 + 4.0i*=`3.0 + 4.0 * _Complex_I`

Note that

`_Complex_I * _Complex_I`

has the value`-1`

, but the type of that value is`complex`

.

`_Complex_I`

is a bit of a mouthful. `complex.h` also defines
a shorter name for the same constant.

- Macro:
*const float complex***I**¶ -
This macro has exactly the same value as

`_Complex_I`

. Most of the time it is preferable. However, it causes problems if you want to use the identifier`I`

for something else. You can safely write#include <complex.h> #undef I

if you need

`I`

for your own purposes. (In that case we recommend you also define some other short name for`_Complex_I`

, such as`J`

.)