View source for c/numeric/complex

{{title|Complex number arithmetic}}
{{c/numeric/complex/navbar}}
{{rrev|since=c11|
If the macro constant {{tt|__STDC_NO_COMPLEX__}} is defined by the implementation, the complex types, the header {{tt|<complex.h>}} and all of the names listed here are not provided.}}

The C programming language, as of C99, supports complex number math with the three built-in types {{c|double _Complex}}, {{c|float _Complex}}, and {{c|long double _Complex}} (see {{ltt|c/keyword/_Complex}}). When the header {{tt|<complex.h>}} is included, the three complex number types are also accessible as {{c|double complex}}, {{c|float complex}}, {{c|long double complex}}.

In addition to the complex types, the three imaginary types may be supported: {{c|double _Imaginary}}, {{c|float _Imaginary}}, and {{c|long double _Imaginary}} (see {{ltt|c/keyword/_Imaginary}}). When the header {{tt|<complex.h>}} is included, the three imaginary types are also accessible as {{c|double imaginary}}, {{c|float imaginary}}, and {{c|long double imaginary}}.

Standard arithmetic operators {{c|+}}, {{c|-}}, {{c|*}}, {{c|/}} can be used with real, complex, and imaginary types in any combination. <!--TODO: link to the arithmetic operators, don't forget cx limited range and the details from G.5.1 and G.5.2. in their description -->

{{rrev multi|since1=c99|rev1=
A compiler that defines {{tt|__STDC_IEC_559_COMPLEX__}} is recommended, but not required to support imaginary numbers. POSIX recommends checking if the macro {{lc|_Imaginary_I}} is defined to identify imaginary number support.
|since2=c11|rev2=
Imaginary numbers are supported if {{tt|__STDC_IEC_559_COMPLEX__}} {{rev inl|since=c23|or  {{tt|__STDC_IEC_60559_COMPLEX__}}}} is defined.
}}

{{dsc begin}}
{{dsc header|complex.h}}
{{dsc h2|Types}}
{{dsc inc|c/numeric/complex/dsc imaginary}}
{{dsc inc|c/numeric/complex/dsc complex}}

{{dsc h2|The imaginary constant}}
{{dsc inc|c/numeric/complex/dsc Imaginary_I}}
{{dsc inc|c/numeric/complex/dsc Complex_I}}
{{dsc inc|c/numeric/complex/dsc I}}

{{dsc h2|Manipulation}}
{{dsc inc|c/numeric/complex/dsc CMPLX}}
{{dsc inc|c/numeric/complex/dsc creal}}
{{dsc inc|c/numeric/complex/dsc cimag}}
{{dsc inc|c/numeric/complex/dsc cabs}}
{{dsc inc|c/numeric/complex/dsc carg}}
{{dsc inc|c/numeric/complex/dsc conj}}
{{dsc inc|c/numeric/complex/dsc cproj}}

{{dsc h2|Exponential functions}}
{{dsc inc|c/numeric/complex/dsc cexp}}
{{dsc inc|c/numeric/complex/dsc clog}}

{{dsc h2|Power functions}}
{{dsc inc|c/numeric/complex/dsc cpow}}
{{dsc inc|c/numeric/complex/dsc csqrt}}

{{dsc h2|Trigonometric functions}}
{{dsc inc|c/numeric/complex/dsc csin}}
{{dsc inc|c/numeric/complex/dsc ccos}}
{{dsc inc|c/numeric/complex/dsc ctan}}
{{dsc inc|c/numeric/complex/dsc casin}}
{{dsc inc|c/numeric/complex/dsc cacos}}
{{dsc inc|c/numeric/complex/dsc catan}}

{{dsc h2|Hyperbolic functions}}
{{dsc inc|c/numeric/complex/dsc csinh}}
{{dsc inc|c/numeric/complex/dsc ccosh}}
{{dsc inc|c/numeric/complex/dsc ctanh}}
{{dsc inc|c/numeric/complex/dsc casinh}}
{{dsc inc|c/numeric/complex/dsc cacosh}}
{{dsc inc|c/numeric/complex/dsc catanh}}
{{dsc end}}

===Notes===
The following function names are {{rev inl|since=c23|potentially}} reserved for future addition to {{tt|complex.h}} and are not available for use in the programs that include that header: {{lc|cerf}}, {{lc|cerfc}}, {{lc|cexp2}}, {{lc|cexpm1}}, {{lc|clog10}}, {{lc|clog1p}}, {{lc|clog2}}, {{lc|clgamma}}, {{lc|ctgamma}}{{rev inl|since=c23|, {{lc|csinpi}}, {{lc|ccospi}}, {{lc|ctanpi}}, {{lc|casinpi}}, {{lc|cacospi}}, {{lc|catanpi}}, {{lc|ccompoundn}}, {{lc|cpown}}, {{lc|cpowr}}, {{lc|crootn}}, {{lc|crsqrt}}, {{lc|cexp10m1}}, {{lc|cexp10}}, {{lc|cexp2m1}}, {{lc|clog10p1}}, {{lc|clog2p1}}, {{lc|clogp1}}}}, along with their -{{tt|f}} and -{{tt|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 parts is infinite, even if the other part is NaN.

A complex or imaginary number is finite if both parts are neither infinities nor NaNs.

A complex or imaginary number is a zero if both parts are positive or negative zeroes.

While MSVC does provide a [https://learn.microsoft.com/en-us/cpp/c-runtime-library/complex-math-support {{tt|<complex.h>}}] header, it does not implement complex numbers as native types, but as {{c|struct}}s, which are incompatible with standard C complex types and do not support the {{c|+}}, {{c|-}}, {{c|*}}, {{c|/}} operators.

===Example===
{{example
|code=
#include <complex.h>
#include <stdio.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===
{{ref std c23}}
{{ref std|section=6.10.8.3/1/2|title={{tt|__STDC_NO_COMPLEX__}}|p=TBD}}
{{ref std|section=6.10.8.3/1/2|title={{tt|__STDC_IEC_559_COMPLEX__}}|p=TBD}}
{{ref std|section=7.3|title=Complex arithmetic {{tt|<complex.h>}}|p=TBD}}
{{ref std|section=7.25|title=Type-generic math {{tt|<tgmath.h>}}|p=TBD}}
{{ref std|section=7.31.1|title=Complex arithmetic {{tt|<complex.h>}}|p=TBD}}
{{ref std|section=Annex G (normative)|title=IEC 60559-compatible complex arithmetic|p=TBD}}
{{ref std end}}
{{ref std c17}}
{{ref std|section=6.10.8.3/1/2|title={{tt|__STDC_NO_COMPLEX__}}|p=128}}
{{ref std|section=6.10.8.3/1/2|title={{tt|__STDC_IEC_559_COMPLEX__}}|p=128}}
{{ref std|section=7.3|title=Complex arithmetic {{tt|<complex.h>}}|p=136-144}}
{{ref std|section=7.25|title=Type-generic math {{tt|<tgmath.h>}}|p=272-273}}
{{ref std|section=7.31.1|title=Complex arithmetic {{tt|<complex.h>}}|p=391}}
{{ref std|section=Annex G (normative)|title=IEC 60559-compatible complex arithmetic|p=469-479}}
{{ref std end}}
{{ref std c11}}
{{ref std|section=6.10.8.3/1/2|title={{tt|__STDC_NO_COMPLEX__}}|p=177}}
{{ref std|section=6.10.8.3/1/2|title={{tt|__STDC_IEC_559_COMPLEX__}}|p=177}}
{{ref std|section=7.3|title=Complex arithmetic {{tt|<complex.h>}}|p=188-199}}
{{ref std|section=7.25|title=Type-generic math {{tt|<tgmath.h>}}|p=373-375}}
{{ref std|section=7.31.1|title=Complex arithmetic {{tt|<complex.h>}}|p=455}}
{{ref std|section=Annex G (normative)|title=IEC 60559-compatible complex arithmetic|p=532-545}}
{{ref std end}}
{{ref std c99}}
{{ref std|section=6.10.8/2|title={{tt|__STDC_IEC_559_COMPLEX__}}|p=161}}
{{ref std|section=7.3|title=Complex arithmetic {{tt|<complex.h>}}|p=170-180}}
{{ref std|section=7.22|title=Type-generic math {{tt|<tgmath.h>}}|p=335-337}}
{{ref std|section=7.26.1|title=Complex arithmetic {{tt|<complex.h>}}|p=401}}
{{ref std|section=Annex G (informative)|title=IEC 60559-compatible complex arithmetic|p=467-480}}
{{ref std end}}

===See also===
{{dsc begin}}
{{dsc see cpp|cpp/numeric/complex|Complex number arithmetic|nomono=true}}
{{dsc end}}

{{langlinks|ar|cs|de|es|fr|it|ja|ko|pl|pt|ru|tr|zh}}