Complex number arithmetic

The header <complex.h> defines macros and declares functions that support complex number arithmetic. Complex values are values of type double complex, float complex, long double complex,

If the macro constant __STDC_IEC_559_COMPLEX__(C99) is defined by the compiler, in addition to the complex types, the imaginary types are also supported: double imaginary, float imaginary, and long double imaginary. When a value of imaginary type is converted to a value of complex type, the resulting complex type has its real component set to zero. When a value of complex type is converted to a value of imaginary type, the real component is discarded.

Standard arithmetic operators +, -, *, / can be used with real, complex, and imaginary types in any combination.

If the macro constant __STDC_NO_COMPLEX__(C11) is defined by the compiler, the header <complex.h> and all of the names listed here are not provided.

If #pragma STDC CX_LIMITED_RANGE on is used, complex multiplication, division, and absolute value may use simplified mathematical formulas, despite the possibility of intermediate overflow.

Defined in header <complex.h>

#include <stdio.h>        /* printf                         */
#include <complex.h>      /* complex, float complex, I, ... */
 
int main () {
 
    #ifdef __STDC_IEC_559_COMPLEX__
           printf("_STDC_IEC_559_COMPLEX__ defined\n");
    #else
           printf("_STDC_IEC_559_COMPLEX__ not defined\n");
    #endif
    #ifdef __STDC_NO_COMPLEX__
           printf("__STDC_NO_COMPLEX__ defined\n");
    #else
           printf("__STDC_NO_COMPLEX__ not defined\n");
    #endif
    printf("\n");
 
    printf("%2zu\n", sizeof(float complex));           /*  8 */
    printf("%2zu\n", sizeof(double complex));          /* 16 */
    printf("%2zu\n", sizeof(long double complex));     /* implementation-defined */
 
    /* Two macros represent the imaginary unit “i”: */
    /*      _Complex_I                              */
    /*      I                                       */
    printf("%.1f%+.1fi\n", creal(_Complex_I),cimag(_Complex_I));
    printf("%.1f%+.1fi\n", creal(I),cimag(I));
 
    /* The central property of the imaginary unit:  i*i is -1. */
    printf("%.1f%+.1fi\n", creal(1.0*_Complex_I*1.0*_Complex_I),
                           cimag(1.0*_Complex_I*1.0*_Complex_I));
    printf("%.1f%+.1fi\n", creal(1.0*I*1.0*I),cimag(1.0*I*1.0*I));
 
    /* Use the macros to define complex constants. */
    double complex z1 = 1.0 + 2.0*I;
    double complex z2 = 2.0 + 4.0*_Complex_I;
 
    /* Sum and print. */
    double complex z3 = z1+z2;
    printf("%.1f%+.1fi\n", creal(z3),cimag(z3));
 
    /* When the macro named "I" conflicts in an application, */
    /* define a new macro named "J" or "j".                  */
    #undef I
    #define J _Complex_I
    z1 = 1.5 + 2.5*J;
 
    return 0;
}

Possible output:

_STDC_IEC_559_COMPLEX__ defined
__STDC_NO_COMPLEX__ not defined
 
 8
16
32
0.0+1.0i
0.0+1.0i
-1.0+0.0i
-1.0+0.0i
3.0+6.0i

Compiler support
Language
Headers
Type support
Program utilities
Variadic function support
Error handling
Dynamic memory management
Strings library
Algorithms
Numerics
Date and time utilities
Input/output support
Localization support
Concurrency support (C11)
Technical Specifications
Symbol index

Common mathematical functions
Floating-point environment (C99)
Pseudo-random number generation
Complex number arithmetic (C99)
Type-generic math (C99)

cppreference.com

Namespaces

Variants

Views

Actions

Complex number arithmetic

Contents

Types

The imaginary constant

Manipulation

Exponential functions

Power functions

Trigonometric functions

Hyperbolic functions

Example

Navigation

Toolbox