std::complex

< cpp‎ | numeric

C++
 Language Standard library headers Concepts Utilities library Strings library Containers library Algorithms library Iterators library Numerics library Input/output library Localizations library Regular expressions library (C++11) Atomic operations library (C++11) Thread support library (C++11) Technical Specifications

Numerics library
 Common mathematical functions Floating-point environment Complex numbers Numeric arrays Pseudo-random number generation Compile-time rational arithmetic (C++11) Generic numeric operations iota (C++11) accumulate inner_product adjacent_difference partial_sum

std::complex
Member functions
Non-member functions
 real imag abs arg norm conj proj (C++11) polar operator""ioperator""ifoperator""il (C++14)(C++14)(C++14)
Exponential functions
Power functions
Trigonometric functions
 asin (C++11) acos (C++11) atan (C++11)
Hyperbolic functions
 asinh (C++11) acosh (C++11) atanh (C++11)

 Defined in header `` template< class T > class complex; (1) template<> class complex; (2) template<> class complex; (3) template<> class complex; (4)

The specializations std::complex<float>, std::complex<double>, and std::complex<long double> are `LiteralType`s for representing and manipulating complex numbers.

The effect of instantiating the template `complex` for any other type is unspecified.

Contents

Member types

 Member type Definition `value_type` `T`

Member functions

 (constructor) constructs a complex number (public member function) operator= assigns the contents (public member function) real accesses the real part of the complex number (public member function) imag accesses the imaginary part of the complex number (public member function) operator+=operator-=operator/=operator*= compound assignment of two complex numbers or a complex and a scalar (public member function)

Non-member functions

applies unary operators to complex numbers
(function template)
performs complex number arithmetics on two complex values or a complex and a scalar
(function template)
compares two complex numbers or a complex and a scalar
(function template)
serializes and deserializes a complex number
(function template)
returns the real component
(function template)
returns the imaginary component
(function template)
returns the magnitude of a complex number
(function template)
returns the phase angle
(function template)
returns the squared magnitude
(function template)
returns the complex conjugate
(function template)
(C++11)
returns the projection onto the Riemann sphere
(function template)
constructs a complex number from magnitude and phase angle
(function template)
Exponential functions
complex base e exponential
(function template)
complex natural logarithm with the branch cuts along the negative real axis
(function template)
complex common logarithm with the branch cuts along the negative real axis
(function template)
Power functions
complex power, one or both arguments may be a complex number
(function template)
complex square root in the range of the right half-plane
(function template)
Trigonometric functions
computes sine of a complex number (sin(z))
(function template)
computes cosine of a complex number (cos(z))
(function template)
computes tangent of a complex number (tan(z))
(function template)
computes arc sine of a complex number (arcsin(z))
(function template)
computes arc cosine of a complex number (arccos(z))
(function template)
computes arc tangent of a complex number (arctan(z))
(function template)
Hyperbolic functions
computes hyperbolic sine of a complex number (sh(z))
(function template)
computes hyperbolic cosine of a complex number (ch(z))
(function template)
computes hyperbolic tangent of a complex number
(function template)
computes area hyperbolic sine of a complex number
(function template)
computes area hyperbolic cosine of a complex number
(function template)
computes area hyperbolic tangent of a complex number
(function template)

Non-static data members

 For any object `z` of type `complex`, reinterpret_cast(z)[0] is the real part of z and reinterpret_cast(z)[1] is the imaginary part of z. For any pointer to an element of an array of `complex` named `p` and any valid array index i, reinterpret_cast(p)[2*i] is the real part of the complex number p[i], and reinterpret_cast(p)[2*i + 1] is the imaginary part of the complex number p[i] These requirements essentially limit implementation of each of the three specializations of std::complex to declaring two and only two non-static data members, of type `value_type`, with the same member access, which hold the real and the imaginary components, respectively. (since C++11)

Literals

 Defined in inline namespace `std::literals::complex_literals` A std::complex literal representing pure imaginary number (function)

Example

```#include <iostream>
#include <iomanip>
#include <complex>
#include <cmath>

int main()
{
using namespace std::literals;
std::cout << std::fixed << std::setprecision(1);

std::complex<double> z1 = 1i * 1i;     // imaginary unit squared
std::cout << "i * i = " << z1 << '\n';

std::complex<double> z2 = std::pow(1i, 2); // imaginary unit squared
std::cout << "pow(i, 2) = " << z2 << '\n';

double PI = std::acos(-1);
std::complex<double> z3 = std::exp(1i * PI); // Euler's formula
std::cout << "exp(i, pi) = " << z3 << '\n';

std::complex<double> z4 = 1. + 2i, z5 = 1. - 2i; // conjugates
std::cout << "(1+2i)*(1-2i) = " << z4*z5 << '\n';
}```

Output:

```i * i = (-1.0,0.0)
pow(i, 2) = (-1.0,0.0)
exp(i, pi) = (-1.0,0.0)
(1+2i)*(1-2i) = (5.0,0.0)```