Complex number arithmetic
If the macro constant __STDC_NO_COMPLEX__ is defined by the implementation, the complex types, the header <complex.h> and all of the names listed here are not provided. |
(since C11) |
The C programming language, as of C99, supports complex number math with the three built-in types double _Complex, float _Complex, and long double _Complex (see _Complex). When the header <complex.h> is included, the three complex number types are also accessible as double complex, float complex, long double complex.
In addition to the complex types, the three imaginary types may be supported: double _Imaginary, float _Imaginary, and long double _Imaginary (see _Imaginary). When the header <complex.h> is included, the three imaginary types are also accessible as double imaginary, float imaginary, and long double imaginary.
Standard arithmetic operators +, -, *, / can be used with real, complex, and imaginary types in any combination.
|
A compiler that defines __STDC_IEC_559_COMPLEX__ is recommended, but not required to support imaginary numbers. POSIX recommends checking if the macro _Imaginary_I is defined to identify imaginary number support.
|
(since C99)
(until C11) |
|
Imaginary numbers are supported if __STDC_IEC_559_COMPLEX__ is defined.
|
(since C11) |
Types
|
|
|
imaginary type macro
(macro constant) |
|
|
complex type macro
(macro constant) |
The imaginary constant
|
|
|
the imaginary unit constant i
(macro constant) |
|
|
the complex unit constant i
(macro constant) |
|
|
the complex or imaginary unit constant i
(macro constant) |
Manipulation
|
|
|
constructs a complex number from real and imaginary parts
(function macro) |
|
|
computes the real part of a complex number
(function) |
|
|
computes the imaginary part a complex number
(function) |
|
|
computes the magnitude of a complex number
(function) |
|
|
computes the phase angle of a complex number
(function) |
|
|
computes the complex conjugate
(function) |
|
|
computes the projection on Riemann sphere
(function) |
Exponential functions
|
|
|
computes the complex base-e exponential
(function) |
|
|
computes the complex natural logarithm
(function) |
Power functions
|
|
|
computes the complex power function
(function) |
|
|
computes the complex square root
(function) |
Trigonometric functions
|
|
|
computes the complex sine
(function) |
|
|
computes the complex cosine
(function) |
|
|
computes the complex tangent
(function) |
|
|
computes the complex arc sine
(function) |
|
|
computes the complex arc cosine
(function) |
|
|
computes the complex arc tangent
(function) |
Hyperbolic functions
|
|
|
computes the complex hyperbolic sine
(function) |
|
|
computes the complex hyperbolic cosine
(function) |
|
|
computes the complex hyperbolic tangent
(function) |
|
|
computes the complex arc hyperbolic sine
(function) |
|
|
computes the complex arc hyperbolic cosine
(function) |
|
|
computes the complex arc hyperbolic tangent
(function) |
Notes
The following function names are reserved for future addition to complex.h and are not available for use in the programs that include that header: cerf, cerfc, cexp2, cexpm1, clog10, clog1p, clog2, clgamma, and ctgamma, along with their -f and -l suffixed variants.
Although the C standard names the inverse hyperbolics with "complex arc hyperbolic sine" etc., the inverse functions of the hyperbolic functions are the area functions. Their argument is the area of a hyperbolic sector, not an arc. The correct names are "complex inverse hyperbolic sine" etc. Some authors use "complex area hyperbolic sine" etc.
A complex or imaginary number is infinite if one of its components is infinite, even if the other component is NaN.
A complex or imaginary number is finite if both components are neither infinities nor NaNs.
A complex or imaginary number is a zero if both components are positive or negative zeroes.
Example
#include <stdio.h>
#include <complex.h>
#include <tgmath.h>
int main(void)
{
double complex z1 = I * I; // imaginary unit squared
printf("I * I = %.1f%+.1fi\n", creal(z1), cimag(z1));
double complex z2 = pow(I, 2); // imaginary unit squared
printf("pow(I, 2) = %.1f%+.1fi\n", creal(z2), cimag(z2));
double PI = acos(-1);
double complex z3 = exp(I * PI); // Euler's formula
printf("exp(I*PI) = %.1f%+.1fi\n", creal(z3), cimag(z3));
double complex z4 = 1+2*I, z5 = 1-2*I; // conjugates
printf("(1+2i)*(1-2i) = %.1f%+.1fi\n", creal(z4*z5), cimag(z4*z5));
}Output:
I * I = -1.0+0.0i
pow(I, 2) = -1.0+0.0i
exp(I*PI) = -1.0+0.0i
(1+2i)*(1-2i) = 5.0+0.0i
References
- C11 standard (ISO/IEC 9899:2011):
- 6.10.8.3/1/2 __STDC_NO_COMPLEX__ (p: 177)
- 6.10.8.3/1/2 __STDC_IEC_559_COMPLEX__ (p: 177)
- 7.3 Complex arithmetic <complex.h> (p: 188-199)
- 7.3.1/2 __STDC_NO_COMPLEX__ (p: 188)
- 7.25 Type-generic math <tgmath.h> (p: 373-375)
- 7.31.1 Complex arithmetic <complex.h> (p: 455)
- B.2 Complex <complex.h> (p: 475-477)
- Annex G (normative) IEC 60559-compatible complex arithmetic (p: 532-545)
- G.1/1 __STDC_IEC_559_COMPLEX__ (p: 532)
- C99 standard (ISO/IEC 9899:1999):
- 6.10.8/2 __STDC_IEC_559_COMPLEX__ (p: 161)
- 7.3 Complex arithmetic <complex.h> (p: 170-180)
- 7.22 Type-generic math <tgmath.h> (p: 335-337)
- 7.26.1 Complex arithmetic <complex.h> (p: 401)
- B.2 Complex <complex.h> (p: 419-420)
- Annex G (informative) IEC 60559-compatible complex arithmetic (p: 467-480)
- G.1/1 __STDC_IEC_559_COMPLEX__ (p: 467)
See also